Documentation

Nexeda docs

Everything you need to run the agentic RTL loop — concepts, the API, and how to self-host.

Overview

Nexeda turns a specification into verified, synthesizable RTL by running a closed loop: interpret → design → verify → simulate → repair → sign-off. A deterministic tool runner wraps Icarus Verilog, Verilator and yosys; five LLM agents coordinate the work. The backend is a FastAPI service; the frontend is this site plus the live Playground.

Quickstart

The fastest path is the hosted Playground — no install required:

• Open the Playground.
• Pick a target (Xilinx FPGA), describe a standard block, and press Run the loop.
• Watch each stage stream: design → lint → testbench → simulate → repair → PPA.

To run the backend locally with the full open toolchain:

git clone github.com/vlsiwebofficial-max/nexeda
cd nexeda
export ANTHROPIC_API_KEY=sk-ant-...
docker compose up --build
# run-view: http://localhost:8080  ·  API: http://localhost:8001

Core concepts

Project

A design effort: a spec, a target (xilinx_fpga, generic_fpga, asic), and an end application that drives PPA bias.

Run

One execution of the loop. A run carries the current RTL and testbench, an ordered list of iterations, all artifacts, and a streamed event log.

Artifacts

Every iteration saves its RTL, testbench, simulation log, waveform and PPA report — inspectable by kind.

Self-checking protocol

Generated and golden testbenches follow one convention so a parser — not a human — can score them:

$display("PASS: %0s", name);
$display("FAIL: %0s exp=%0d got=%0d", name, exp, got);
// final summary line, parsed by the tool runner
$display("NEXEDA_SUMMARY passed=%0d total=%0d", pass_cnt, total_cnt);

HTTP API

All application routes are under /api; the health check is at the root. Base URL (hosted): https://nexeda-production.up.railway.app

Method	Path	Purpose
GET	/health	Liveness check (no dependencies)
GET	/api/tools	EDA tool + LLM availability
POST	/api/projects	Create a project from a spec
POST	/api/runs	Start the agentic loop (async)
GET	/api/runs/{id}/stream	SSE live progress
GET	/api/runs/{id}	Full run incl. iterations & PPA
GET	/api/runs/{id}/artifacts/{kind}	rtl · testbench · sim_log · ppa
POST	/api/review	Lint + AI review of pasted RTL
POST	/api/verify	Generate a testbench, simulate, score

Example — start a run:

POST /api/projects   { "name", "spec", "target", "application" }  → { project_id }
POST /api/runs       { "project_id" }                            → { run_id }
GET  /api/runs/{run_id}/stream    # server-sent events

Benchmarks

The eval harness ships with golden references and self-checking testbenches. The first benchmark is a synchronous FIFO; the suite grows toward ~20 standard FPGA blocks (arbiter, AXI-Lite slave, FSM, CDC). Convergence rate and time-saved versus a baseline are the headline metrics.

Self-hosting

Nexeda is built to run inside your network so RTL never leaves it. The backend is a single FastAPI service in a Docker image that bundles the open EDA toolchain. Heavy, licensed flows (Vivado place-and-route) run on a separate worker on the roadmap. See the repository README for the full deployment guide.