Brigse
Provides FPGA development support for AMD/Xilinx parts: the Spartan-3/3A/3E add-on builds designs with Xilinx ISE 14.7 and returns utilization and timing reports; a planned AMD 7-series add-on will use yosys + nextpnr-xilinx.
Planned add-on for Intel Cyclone V FPGAs using yosys + nextpnr-mistral, intended to expose the same build, report, and programming workflow as other FPGA families.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Brigse build the blinky example for my Tang Nano 9K and tell me if timing passes"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A modular MCP server that lets an AI agent build, inspect,
simulate and program FPGA designs through one set of tools. Each FPGA family is an add-on behind
a common interface, so the agent calls build the same way for every board.
Early stage (v0.1). Brigse works on its author's machine, an Apple Silicon Mac on macOS 27, and has gone from Verilog to a running board on one board so far. It has not been tried on other machines or operating systems. Expect rough edges and breaking changes. Systematic testing is planned and listed below; until then, treat it as a working prototype.
Three add-ons are implemented: Xilinx ISE 14.7 for Spartan-3/3A/3E, and two for Gowin (the vendor's
Gowin EDA if you have it, and the open-source flow). When several add-ons cover a part, the usable
vendor tool is preferred; pass backend to build to choose.
Open-source add-ons are installed on request: the agent calls request_install, the plan (what,
from where, how big, licence) appears in the dashboard at http://brigse.localhost:8765, and only
the user can approve it there. Vendor tools and licences are never downloaded by the server.
What has been checked so far
Area | Checked | Not checked yet |
Spartan-3A (ISE) | Builds of a small example and of the Next186 SoC; the SoC bitstream matched a reference build | Loading onto the board from macOS (not supported yet) |
Gowin, vendor tool | Build, then a temporary load onto a Tang Nano 9K; LEDs seen blinking | Other Gowin boards and parts |
Gowin, open-source | Install after approval, build, uninstall (on a test folder) | Its bitstream on a real board |
Error explainer | 18 real failures from the three toolchains, plus 2 good builds that must stay quiet ( | Errors outside this list are reported unexplained |
Chip view from a bitstream | Against a known placement: 408 of 408 logic tiles and 4 of 4 block RAM, no false ones; empty designs show nothing; on a real Gowin EDA build the block RAM count (19 of 26) equals the IDE's own report | Multipliers, input pins, other chips |
Waveforms and chip view | Recording, text view, dashboard endpoint ( | Large recordings (capped at 60 000 changes), other Gowin chips for the chip view (only the 9K was checked) |
Dashboard and approvals | Board choice, approve/reject, buttons refused while something runs | Browsers other than the one used in development |
Platforms | macOS 27 on Apple Silicon | Linux, Windows, Intel Macs |
The scripts in tests/ drive the server over MCP the way an agent would; they need the real tools
installed and are run by hand.
Planned
Testing on Linux and on more boards
Programming the Spartan-3A from macOS
Add-ons for AMD 7-series and Cyclone V
Parsed reports and clearer errors for larger designs
How the idea came about
Brigse came out of NanoLink86, a project that runs FreeDOS on the open-source Next186 x86 system-on-chip (by Nicolae Dumitrache) on two FPGA boards: a Sipeed Tang Nano 9K (Gowin) and a Xilinx Spartan-3A Starter Kit. Two boards meant two vendor toolchains, and the Spartan-3A was the problem: that chip can only be built with Xilinx ISE 14.7, a tool from 2013 with no macOS version. Every build meant booting a 49 GB Ubuntu desktop VM, typing the same six commands and reading thousand-line logs to find out whether timing had passed.
Two questions came out of that. Could the heavy part shrink, and could an AI agent do the routine part? The first answer was a slimmed ISE (about 1.7 GB of the 17.8 GB install) in a small headless VM. Along the way it turned out that ISE cannot run under user-mode x86 translators on Apple Silicon at all, which is why the VM stays. The second answer was an MCP server, so that "build this and tell me if timing passes" becomes one request instead of a ritual.
Having both boards in one project made it clear that each family should be a separate add-on: you install only what your boards need, vendor tool or open-source flow, behind the same tools. The local window and the approval step came from a simple rule: an agent may ask to download or delete something, but a person decides.
The name is short for Bridge to Semiconductor, and it sounds like βρύση, the Greek word for a tap.
Related MCP server: fpga-mcp
Tools
Tool | What it does |
| Installed and planned add-ons, the parts each covers, and their state |
| Starts synthesis-to-bitstream as a background job, returns a |
| Progress per step; when finished, fetches outputs and returns the report |
| Explains a failed build in plain words (where, why, how to fix) and catches mistakes the tools let through |
| Draws where a Gowin design sits on the chip, from its bitstream (Gowin EDA builds too), as SVG and a PNG for slides |
| Utilisation, timing (slack, and per clock its Fmax against the required frequency), failing constraints and bitstream from an output folder |
| Checks Verilog in about a second with Verilator (syntax, undeclared names, widths, latches), each issue with file, line and source; run before a build that takes minutes. Falls back to Icarus Verilog's parser |
| Compiles and runs a Verilog testbench with Icarus Verilog and records every signal, with no change to the testbench |
| Which module of a design uses how much logic, flip-flops, block RAM and multipliers, from a quick separate synthesis that keeps the hierarchy (the build flattens it); biggest first. An estimate for the Gowin architecture |
| Tests Verilog with a Python testbench (cocotb) on Icarus Verilog: one row per test, with the assertion message of each failure. Needs |
| Reads a recording as text for an agent: what changed and when, or one row per clock edge |
| USB probes and the JTAG chain (openFPGALoader) |
| Loads a bitstream; a dry run unless |
| Start/stop an add-on's runtime (the ISE VM) |
| What is running right now and who started it (agent or user) |
| Known boards and the one selected |
| Ask the user to approve installing or removing an add-on |
| Address of the local window |
Error explainer
When a build fails, build_status and diagnose return the cause instead of thousands of log lines:
where it is, why it happens, how to fix it. The rules were written from output the real tools printed
when a design was broken on purpose; a message with no rule is passed on unexplained, never guessed at.
It also catches mistakes the tools let through. The open-source Gowin flow builds a design whose signal name was mistyped (only a warning) and ignores a constraint for a name that is not in the design; Gowin EDA silently puts a port with no pin constraint on a pin of its own. A failing timing constraint is traced to its slowest path (ISE).
Seeing what the tools did
Waveforms.
simulaterecords every signal. The dashboard draws them (zoom, drag, a cursor that shows each value, hex/binary/decimal); thewavestool gives an agent the same data as text, for example one row per rising clock edge.Live log. While a build runs, the Builds tab shows its log as it is written (Server-Sent Events, no polling): every step of the open-source Gowin flow and Gowin EDA, line by line. The ISE virtual machine keeps its logs inside the VM, so there the last lines of the current step are shown as they change.
Chip view. For builds made with the open-source Gowin flow, the dashboard draws the chip as a grid of tiles and colours the ones that hold your design: logic, pins, block RAM, multipliers. It is drawn from the placement nextpnr wrote and the chip database that ships with the tools. Gowin EDA's own placement cannot be read outside its GUI, so for those builds (and any other Gowin bitstream) the
chip_viewtool reads the bitstream itself withgowin_unpackand counts the tiles that hold a configured LUT, a block RAM, a PLL or an output buffer. It never changes the file. Limits, also written on the picture: multipliers cannot be read, input pins cannot be told from unused ones, and only the GW1N-9C chip (Tang Nano 9K) has been checked. For a PNG that can go on a slide:uv sync --extra png.examples/tangnano9k_demois a design that uses logic, block RAM and a multiplier, to show what a fuller chip looks like.
The window
brigse dashboard opens http://brigse.localhost:8765, a page served on this machine only. It shows
what is running, the selected board, builds with their reports, and the add-ons. The user can pick
the board, approve or reject the agent's requests, repeat a build, load a build into the board's
SRAM (never flash), start or stop the ISE VM, and install or uninstall the open-source tools.
Only what Brigse downloaded can be uninstalled; vendor tools you installed are never touched.
The window answers only to this computer's own names and only to its own page: a request with a foreign
Host (DNS rebinding) or Origin (another site's page) is refused, every action needs a token that only the
loaded page has, the page cannot be put in a frame, and a decision on an agent's request cannot be changed
once made. tests/test_dashboard_security.py tries each of these attacks.
The agent and the user share the same rules: one build at a time per add-on and one use of the programmer at a time. While anything runs, the page greys its buttons out and the server refuses them, and the agent's tools get a clear "already running" answer.
Install
brew install uv icarus-verilog openfpgaloader verilator # verilator is optional: it makes `lint` stronger
git clone https://github.com/Tslrs/Brigse.git ~/brigse && cd ~/brigse && uv syncConnect it to your AI app with one command. It adds only its own entry, keeps your other servers,
saves the old file as .bak, and then starts Brigse the way the app will, to check that it answers:
uv run brigse install-agent antigravity # or: claude-desktop, claude-code, --all
uv run brigse install-agent --all --dry-run # show what would change, write nothingThen restart the app. Builds can be long (an ISE build takes about 25-30 minutes), so every
build and build_status answer carries a next field that tells the agent what to do: ask
again in 50 seconds, or, when it is finished, read the report and the diagnosis before saying it worked.
In the terminal
No browser needed. These work in any terminal (Ghostty, iTerm, over ssh):
uv run brigse status # board, builds with time and timing, simulations, add-ons, pending requests
uv run brigse status --watch # the same, refreshing every 3 seconds
uv run brigse approvals # answer the agent's requests: approve, reject or skip
uv run brigse dashboard # open the full window in the browser
uv run brigse install-cocotb # once, to use Python testbenches: a small separate environment, about 40 MBapprovals only works in a real terminal and needs the whole word typed. When it is run from
a script or an agent's pipe, it refuses and leaves the request pending.
Add-ons
Add-on | Parts | Toolchain | State |
|
| Xilinx ISE 14.7 in a headless x86 VM | implemented |
|
| your own Gowin EDA install ( | implemented |
|
| yosys + nextpnr-himbaechel + apicula (OSS CAD Suite) | implemented |
|
| yosys + nextpnr-xilinx | planned |
|
| yosys + nextpnr-mistral | planned |
An add-on is one module in src/brigse/backends/ that subclasses Backend
(status, build_start, build_status, report, control) and is listed in registry.py.
Spartan-3A add-on (ISE 14.7)
ISE has no macOS build, and on Apple Silicon it does not run under user-mode x86 translators (box64, qemu-user and FEX-Emu were all tried). It therefore runs in a small headless x86-64 Debian VM under Lima/QEMU: about 3 GB instead of a full desktop VM.
You need your own licensed ISE 14.7 install (WebPACK is free). ISE binaries and licence files are not part of this repository and must not be committed. Only the command-line tools and the Spartan-3 device data are needed, about 1.7 GB of the 17.8 GB install:
ISE_DS/ISE/{bin,lib}/lin64,ISE_DS/common/{bin,lib}/lin64ISE_DS/ISE/{data,xilinx,xilinxun,fpga,fpgacore,cse,msg,verilog,vhdl,xcf,xcfp}(withoutdata/cse/cseflash)ISE_DS/ISE/{spartan3,spartan3a,spartan3e,spartan3adsp,virtex,virtex2,virtex2p}
Create the VM and unpack that tree to /opt/Xilinx/14.7/ISE_DS, with the licence in ~/.Xilinx/:
brew install lima lima-additional-guestagents qemu
LIMA_HOME="$PWD/vm" limactl start --name=ise --tty=false --arch=x86_64 --vm-type=qemu --cpus=4 --memory=4 --disk=8 --containerd=none template:debian-12build copies the project into the VM, runs xst, ngdbuild, map, par, trce and bitgen,
and copies the results to <project>/build_out/<job_id>/. If <top>.xst exists the project's
own synthesis script is used; otherwise a .prj/.xst pair is generated from the sources.
Everything runs under full emulation, so it is slow: the Next186 SoC (55% of an XC3S700A) takes about 27 minutes.
Known limits:
Programming a Spartan-3A from macOS is untested. openFPGALoader does not list the XC3S700A or the Xilinx Platform Cable USB, so
programrefuses that part instead of guessing.One VM, one build at a time is the tested case.
Where things live
Everything Brigse needs can sit in one folder, next to the code:
Brigse/
├── src/ tests/ examples/ ... the code (this repository)
├── ise-lite/ your own slimmed ISE archives (never committed)
├── data/ state and the open-source tools Brigse downloaded (never committed)
└── vm/ Lima's home, with the small ISE virtual machine (never committed)If data/ exists next to the code it is used; otherwise ~/.brigse. Set BRIGSE_HOME to choose another
place. The same goes for vm/ and BRIGSE_VM_HOME (otherwise Lima's default, ~/.lima). To run limactl
by hand against that VM: export LIMA_HOME=<this folder>/vm.
Test
The checks that need no vendor tools run with uv sync --group dev && uv run pytest (needs iverilog for the
waveform test; the MCP protocol is tested against a fake add-on, tests/mock_server.py) and on every push through GitHub Actions (Linux and macOS). The rest drive the real tools:
uv run python tests/smoke_client.py # protocol, simulate, report
uv run python tests/smoke_client.py --build # also builds examples/blinky in the ISE VMRelated work
fpgaZeroMCP (open-source flow), fpga-mcp by wmm246 (Vivado/Quartus/Anlogic) and several Vivado-only servers cover current devices. This project's focus is the add-on structure and legacy ISE-only parts.
Contributors
Who | Part |
Idea and direction, design decisions, the boards and licences, testing on real hardware | |
Claude (Anthropic) | Implementation, the dashboard, tests and this documentation, written as a coding agent in Claude Code under Tslrs's direction |
Every commit records both, with Claude as co-author.
Licence
Brigse is released under the MIT licence. It covers only the code in this repository. The FPGA vendor tools that the add-ons drive (Xilinx ISE, Gowin EDA) have their own licences and are not distributed here.
Available Tools
15 toolsactivityA
What is in progress right now (builds, installs, programmer use) and who started it.
The user can also start actions from the dashboard, so check this before starting work that needs the same add-on or the programmer.
Inputs: no named parameters.
backend_controlA
Start, stop or check an add-on's runtime (for ise_spartan3: its VM).
action: 'start', 'stop' or 'status'. Stopping frees RAM; it is refused while a build runs.
Inputs: action (required), backend (required).
buildA
Start a full build (synthesis to bitstream) as a background job.
project_dir: folder with the HDL sources (copied to the build machine; old outputs are skipped). top: top module name. If .xst exists in the folder, the project's own synthesis script is used. part: device-package-speed, e.g. xc3s700a-fg484-4. Defaults to the selected board's part. The part selects the add-on. sources: paths relative to project_dir; default is every .v/.vhd in the folder except testbenches. constraints: constraints file relative to project_dir; default is the only .ucf (ISE) or .cst (Gowin) in the folder. backend: force a specific add-on. By default the usable add-on with the highest priority is used (the vendor tool when the user has it, otherwise the open-source flow).
Inputs: top (required), project_dir (required), part, backend, +2 more.
build_statusA
Report a build job's progress; when it has finished, fetch the outputs and return the report.
wait_seconds: wait up to this long (max 50) for the job to finish before answering.
Inputs: job_id (required), wait_seconds.
dashboard_infoA
Return the address of the local status window and whether it is running.
Inputs: no named parameters.
detect_boardsC
List connected USB programming probes and, for a given cable, the FPGAs on its JTAG chain.
Inputs: cable.
install_statusB
Check an install or uninstall request. If the user approved it, start the work (when automatic).
wait_seconds: wait up to this long (max 50) for the user's decision.
Inputs: request_id (required), wait_seconds.
list_backendsA
List the installed and planned FPGA add-ons, the part families each covers, and its state.
Inputs: no named parameters.
list_boardsA
List known boards (part, add-on, programmer support) and the one currently selected.
Inputs: no named parameters.
programA
Load a bitstream onto a board with openFPGALoader.
Prefer the temporary SRAM load (write_flash=false): it leaves the design stored on the board untouched. Use write_flash=true only when the user explicitly asks for a permanent write.
Without confirm=true this is a dry run that only shows the command. write_flash=true makes the design persistent. Pass part to check first that the loader supports the device.
Inputs: bitstream (required), part, board, cable, +2 more.
reportC
Summarise the reports in a build output folder: utilisation, timing, failing constraints, bitstream.
backend: the add-on that produced the folder; detected automatically when omitted.
Inputs: outputs_dir (required), backend.
request_installA
Ask the user to approve installing an add-on. Nothing is downloaded by this call.
The request appears in the dashboard with what would be installed, from where, the disk cost and the licence situation. Only the user can approve or reject it there. reason: one sentence for the user on why you need it.
Inputs: backend (required), reason.
request_uninstallB
Ask the user to approve removing an add-on that Brigse installed. Nothing is deleted by this call.
Only add-ons installed by Brigse can be removed (the downloaded open-source tools); vendor tools the user installed are never touched. Poll install_status with the returned request_id.
Inputs: backend (required), reason.
select_boardB
Select the board to work with. build then uses its part when no part is given.
The user can also pick the board in the dashboard; check list_boards for the current choice.
Inputs: board_id (required).
simulateB
Compile and run a Verilog testbench with Icarus Verilog.
sources: files relative to cwd, testbench included. top: testbench module, if ambiguous. The run passes when the simulator exits 0 and prints no FAIL/ERROR text.
Inputs: sources (required), cwd, top, timeout_s.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 15 tools
Most tools map to a distinct resource+action: listing backends vs. boards vs. probes, installing vs. running a backend, building vs. simulating vs. programming. The closest overlaps are list_boards vs. detect_boards (known boards vs. connected JTAG hardware) and backend_control/install_status, but the descriptions make those boundaries clear.
The dominant pattern is verb_noun or noun_noun with underscores (list_backends, select_board, request_install, build_status, detect_boards). A few bare names (build, report, simulate, activity, dashboard_info) deviate slightly but remain unambiguous and readable.
15 tools sit at the top of the well-scoped range and each covers a real step in the FPGA workflow: discovery, install approval, backend lifecycle, build, status/report, simulation, and programming. No tool looks redundant or tacked on.
The surface covers the full lifecycle from hardware discovery through install, build, report, simulation, and bitstream loading, with no obvious dead ends. Minor gaps exist: no cancel/abort for a running build, no listing or cleaning of build outputs, and no tool to inspect source/constraint files before building.
Maintenance
Related MCP Connectors
Design circuits, simulate and verify embedded firmware, and lay out PCBs with AI agents.
AI-native programming language and toolchain for accountable, verifiable agent-driven development.
Run, build, and validate firmware on virtual hardware from your AI agent. Hardware knowledge corpus.
A public board where AI agents design pieces of an open AI inference accelerator on sky130. Submit Verilog and it is linted, synthesised, simulated against hidden vectors, mapped to real standard cells for area, timed for critical path and power, and proven equivalent to a reference. No key, no account, one call. The best verified design gets fabricated.
Related MCP Servers
- AlicenseAqualityDmaintenanceProvides AI assistants with a complete FPGA toolchain for HDL linting, simulation, synthesis, and place-and-route across various hardware targets. It features a GitHub-backed IP core registry that enables users to search for and import MIT-licensed cores directly through their chat interface.151MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI assistants to drive Xilinx Vivado, Intel Quartus, and Anlogic TangDynasty for FPGA development, including project creation, synthesis, implementation, timing closure, and hardware programming through natural language.42 PyPI6MIT
- AlicenseAqualityCmaintenanceEnables AI coding agents and IDEs to run a complete open-source FPGA flow, including synthesis, place-and-route, bitstream generation, and safe hardware programming for iCE40/ECP5 boards.616 npmApache 2.0
- FlicenseNot gradedqualityAmaintenanceEnables AI coding agents such as Claude Code, Cursor, and Codex to drive a locally installed Xilinx Vivado across the full FPGA flow, from GUI, headless Tcl, or attached sessions through synthesis, implementation, timing and CDC analysis, waveform queries, and device programming. It exposes 32 curated tools plus evidence-driven workflow prompts that return structured timing/IO reports, Chinese-language CRITICAL WARNING diagnostics, and guarded bitstream generation.-