Booley

The open-source agentic RTL IDE

Booley turns Claude Code or Codex into a capable RTL assistant. It runs the agent in a sandbox, hands it real EDA tools, and checks its work against your acceptance criteria: passing tests, area and timing budgets, cycle counts, coverage, and more. You design; it does the grunt work.

Integrated Development Environment

RTL development is fragmented across editors, tool-specific commands, build environments, logs, and waveform viewers. Booley brings that workflow together in one reproducible VS Code workspace.

• One Window: RTL, the agent, terminals, EDA runs, results, and waveform viewing live in a single VS Code window. You can move from editing to simulation to waveform debugging to synthesis without switching between separate applications.
• Reproducible team environment: configure the project once, and its Docker environment supplies the same pinned EDA stack, agent tooling, and system dependencies to every team member. Nobody has to rebuild the toolchain independently or debug "works on my machine" differences (why Docker).
• A typed interface for each Booley Flow: a Flow is one command (sim, lint, synth, or fpga) that runs an EDA job end to end and returns a structured result: pass/fail plus metrics such as area, timing, or cycle counts, instead of a raw log to grep. Each Flow's interface stays the same across EDA tools and across projects: sim stays sim whether it runs Verilator today or Xcelium^* tomorrow, and on every project you work on. Flows are built on FuseSoC, so there's no per-repo EDA glue to learn or maintain.

_{* Xcelium support is a work in progress.}

Built for agentic workflows

The mental model behind Booley is simple: treat an LLM agent like a talented junior engineer. It can write RTL and testbenches, but it is inexperienced with EDA tools, prone to questionable design decisions, and too risky to give unrestricted host access—it could, for example, force-push to your Git repository and rewrite its history. Booley gives it a constrained workspace, explicit specifications, automated checks, and human review.

• Sandboxed for autonomous execution: the agent and every command it launches run inside a Docker container with restricted mounts and network access. You can delegate long-running tasks to agents without approving every bash tool call and without worrying about your files and git history (details, security model).
• Strict guardrails and acceptance criteria: in Ticket Mode, Booley checks explicit acceptance criteria you define during ticket creation. Area and cycle-count criteria help the agent stay within the project's PPA budget, while coverage and mutation-testing criteria help it write stronger testbenches. At review time, one briefing shows scope deviations and the results of configured checks, so you can see at a glance what passed and what needs attention (details).
• Waveform-aware debugging: bwave lets the agent query real traces instead of guessing from RTL. Ask "How many i_ready/o_valid handshakes occurred between 1,000 and 2,000 ns?" or "When did data_o equal 0xDEADBEEF?" The agent answers from actual simulation data instead of spending minutes reasoning from code (and getting it wrong) (details).

There are two ways you can cooperate with LLM agents in Booley:

• Interactive Mode: unlike a plain Claude Code or Codex chat, the agent starts with immediate access to the project's available Booley Flows and Specialists (focused sub-agents for code review, mutation testing, and coverage analysis, each started with fresh context) and already knows what the project can build, run, and test. From your first prompt, it is ready to inspect or edit RTL, run a simulation, lint, or synthesis Flow, and call a Specialist. You remain in the loop, guiding the work and making decisions as they come up.
• Ticket Mode: the autonomous path. You write a ticket, specifying what needs doing, which files are in scope, which tests must pass, and any other completion criteria. Booley creates an isolated worktree, where the agent runs any Booley Flows and Specialist reviews required by the ticket's acceptance criteria; Booley tracks completion and hands you a review-ready result.

A ticket is a Markdown file with YAML frontmatter. Booley won't hand the work back for review until every mandatory criterion is green:

---
summary: Add a registered bypass path to the FIFO read port
type: feature
branch: main
scope:
  - rtl/fifo.sv
  - tb/test_fifo.py
on_success: [triage_report, review]
CRITERIA_MANDATORY:
  LINT:     {lint_fifo: clean}
  SIM:      {sim_fifo: {all: pass}}
  COVERAGE: {sim_fifo: {tests: all, metrics: {line: {min_pct: 90}}}}
  REVIEW:   {rtl: {bugs: clean}}
CRITERIA_OPTIONAL:
  SYNTH:    {synth_fifo: {area_increase_at_most: 10%}}
---

## Description

Current state, required changes, affected interfaces…

See FEATURES.md for the full list of capabilities.

Quick Start

Three ways in, ordered by how much you want to invest:

1. Level 1: Watch. See an engineer drive Booley on a demo project, start to finish. Zero setup.
2. Level 2: Try the demo yourself. Clone the configured demo, create a Ticket with the bundled ticket-creation skill, and run your own change.
3. Level 3: Use it on your own project. Full integration on your own RTL.

Level 1: Watch

Four videos show an engineer driving Booley on a demo project end to end, so viewers can see the workflow before touching anything:

1. Design Optimization (12:43)
2. Finding and Fixing Bugs (9:40)
3. Feature Ticket Creation (10:36)
4. Ticket Results Review (11:21)

I recorded all four videos, then replaced my narration with text-to-speech to stay anonymous for now.

Level 2: Try the demo yourself

Follow the demo repository's README to try the demo, after you install Booley.

Level 3: Use it on your own project

Follow SETUP.md to integrate Booley with your own RTL project, after you install Booley.

Installation

Booley supports Windows and Linux (Ubuntu 26.04 tested); macOS is not supported. You need:

• Python 3.11+
• Git 2.37.2+
• Docker, with about 4 GB free for the image (6 GB with the RISC-V toolchain) plus room for build artifacts
• VS Code
• A host agent CLI on PATH for Project Setup: Claude Code (claude, the default) or Codex (codex)
• Credentials for the installed agent CLI

Use pipx to install the CLI in a persistent, isolated environment. On Ubuntu/Debian, first prepare pipx:

sudo apt-get update
sudo apt-get install -y pipx
pipx ensurepath

Reopen your terminal before running the install block so the pipx launcher is on PATH. On Windows, install pipx with py -m pip install --user pipx, run py -m pipx ensurepath, and reopen the terminal first.

Install your host agent CLI using the instructions linked above, then install Booley and prepare the host:

pipx install booley-rtl
booley bootstrap

To upgrade an existing install:

pipx upgrade booley-rtl
booley bootstrap --update

If you already have uv, uv tool install booley-rtl and uv tool upgrade booley-rtl are equivalent; follow them with booley bootstrap and booley bootstrap --update, respectively.

Alternative: pip user install, only for interpreters that permit user installs (including Windows). Ensure the user scripts directory is on PATH:

python3 -m pip install --user booley-rtl
booley bootstrap

On Windows use py -m pip in place of python3 -m pip. To upgrade this alternative, run python3 -m pip install --user --upgrade booley-rtl, then booley bootstrap --update.

Seeing externally-managed-environment, PATH, or other install errors? See Troubleshooting.

Next: try the demo or set up your own project.

Supported EDA Tools

Current integrations:

• Simulate / elaborate — Verilator, Icarus Verilog; cocotb testbenches supported
• Lint — Verilator, Verible
• ASIC synthesis (PPA estimate, not tape-out) — logical Yosys or physical Yosys + OpenROAD
• Waveform debug — bwave (+ VaporView GUI in VS Code)
• FPGA implementation — AMD Vivado
• Coming soon — Synopsys VCS, Cadence Xcelium

For exact versions, provisioning, trace support, and platform constraints, see SUPPORTED-EDA-TOOLS.md. Support for additional commercial EDA tools is coming soon; see the roadmap.

Limitations

• The IDE shell is stock VS Code today. Booley brings its agent chat, reproducible environment, EDA Flows, and waveform tooling together inside VS Code; it does not yet ship custom editor chrome or a standalone IDE. Native VS Code UI and, longer term, a VS Code fork are planned (roadmap).
• Booley will not design hardware for you. You design the architecture and write the specs; Booley handles the grunt work. Force multiplier, not replacement.
• You need prior digital design experience. Even the most advanced LLM is useless without electronic engineering fundamentals; Booley assumes you can read RTL, judge a waveform, and know what a sane result looks like.
• Source languages are SystemVerilog and Verilog only. VHDL is not supported.
• UVM is not supported.
• Setup can take effort. I've tried to make the setup process as streamlined as possible, but every build system is different; complex flows or heavy licensed EDA tools may still need project-specific work. It's a price you pay once, though. After that, every ticket and every session builds on it, and development speeds up significantly.
• Work in progress. Expect occasional bugs and rough edges in the UI. I'm actively on it, and things keep getting better.

How Booley is built

Booley was designed and is maintained by a hardware engineer, not a career software engineer. Its first-party code was written by Claude and Codex, but this is not vibe-coding: I define the architecture and specifications, weigh design tradeoffs, review implementation plans and code, direct revisions, and make the final engineering decisions. Every change also goes through separate agent and human reviews, including QA passes aimed specifically at finding bugs.

Development follows Booley's coding principles, with isolated branches, pull-request review, type checking, linting, automated tests, coverage requirements, and CI. The project is still young and hasn't yet had extensive review or long-term maintenance from experienced software engineers; those contributions are especially welcome.

Documentation

• Features
• Architecture
• Setup
• Usage
• Flow reference
• Supported EDA tools

Contributing

Booley is still early, so the most useful contribution is trying it and reporting what works, what doesn't, and what you want next. Tell /booley-feedback in your agent chat; it gathers and redacts any needed evidence. Opinions need no reproduction, and nothing leaves your machine until you approve the exact text (feedback guide, configuration).

Code and documentation contributions are welcome; see CONTRIBUTING.md. Please keep feedback technical and specific; broader debates about AI's effects on society or employment are outside the project's scope.

For suspected vulnerabilities, follow the private reporting process in SECURITY.md instead of opening a public issue.

Acknowledgments

Booley stands on a lot of other people's work. Thank you to:

• The authors of Edalize and FuseSoC, and especially their lead maintainer, Olof Kindgren, for the framework that makes Booley's whole idea of a simple, unified CLI-over-EDA interface possible.
• The author of vcdvcd, Ciro Santilli, for the VCD-parsing work that seeded the bwave idea.
• The author of wavepeek, another neat waveform-to-CLI EDA tool, for the clean top-level CLI interface that inspired bwave's top-level CLI (the internals started well before wavepeek and are quite different).
• The author of VaporView, Lloyd Ramseyer, for the excellent VS Code waveform viewer that bwave gui drives for scoped waveform inspection right in the IDE.
• The authors of Yosys, Verilator, Icarus Verilog, Verible, and sv2v, for the excellent open-source EDA tools that make Booley possible at all.
• Matt Pocock, for his great agentic software engineering techniques, which shaped how Booley's agents are built and driven.

License

Apache 2.0. See LICENSE for details.