We're Open-Sourcing boardsmith

boardsmith is a CLI tool that turns a text prompt into a KiCad schematic, bill of materials, and firmware -- and it works offline, without an API key, in about 10 seconds.

Today we're releasing it under AGPL-3.0. github.com/ForestHubAI/boardsmith

The Problem We Kept Running Into

We're a four-person team. Before ForestHub, all of us spent years building embedded systems. And we kept doing the same thing over and over: wire an ESP32 to a BME280 over I2C. Add pull-ups. Add decoupling caps. Look up the I2C address. Open KiCad. Draw the nets. Write the init code. Double-check the datasheet for the fifteenth time that year.

None of this is hard. But it's tedious, error-prone, and eats hours that should go into the actual product logic. The gap between "I know what circuit I want" and "I have a schematic, BOM, and firmware skeleton" is surprisingly wide -- and nothing in the existing toolchain closes it.

There are AI tools that generate code. There are AI tools that generate images. There is nothing that generates electrically valid schematics with matching firmware. So we built one.

What It Actually Does

Here's the real thing, not a mockup:

$ pip install boardsmith
$ boardsmith build -p "ESP32 with BME280 temperature sensor over I2C" --no-llm

Ten seconds later, you get:

Output:
├── schematic.kicad_sch     KiCad 8, open directly
├── firmware/main.cpp       Arduino/ESP-IDF ready
├── firmware/hardware.h     Pin definitions
├── bom.json                JLCPCB part numbers + cost
└── gerber/                 JLCPCB-ready (optional)

That schematic is not a template with blanks filled in. It's a computed circuit: correct I2C pull-up resistor values for the bus speed, decoupling caps on the right rails, proper power nets, pin assignments that don't conflict. The firmware includes initialization sequences, pin definitions, and peripheral setup that match the schematic exactly. The BOM has real manufacturer part numbers with LCSC mappings for direct JLCPCB SMT assembly.

Open the .kicad_sch file in KiCad. It just works.

How It Works

Under the hood, boardsmith runs a 9-stage synthesis pipeline:

• Intent parsing -- figure out what you're asking for
• Requirements normalization -- resolve ambiguities, set defaults
• Component selection -- pick parts from the verified knowledge base (212 components, each with electrical ratings, timing constraints, I2C addresses)
• Topology synthesis -- determine bus connections, pull-ups, power routing
• HIR composition -- build the Hardware Intermediate Representation
• Constraint refinement -- run 11 checks: voltage compatibility, I2C address conflicts, pin assignment, power budget, timing, decoupling, pull-up values, bus width, clock domains, current limits, ERC validation
• BOM generation -- line items with MPN, LCSC part number, and estimated cost
• KiCad export -- native .kicad_sch output
• Confidence scoring -- how much does the pipeline trust this design?

The core data structure is HIR -- Hardware Intermediate Representation. It's a typed Pydantic v2 schema that flows through every stage: components, connections, voltages, provenance tracking, constraints. HIR is the contract between the synthesis pipeline (prompt to schematic) and the firmware compiler (schematic to code). Every stage reads HIR, transforms it, and writes HIR back. This means stages are independently testable and replaceable.

Agentic EDA

boardsmith also closes the loop. Three capabilities turn it from a one-shot generator into an iterative design tool:

ERCAgent

After schematic generation, boardsmith build automatically invokes the ERCAgent if LLM credentials are available. It reads real KiCad ERC output, asks the LLM to reason about each violation, and applies surgical patches (ADD/MODIFY only -- no destructive deletes). Up to 5 iterations with stall detection. Most ERC violations get fixed automatically.

boardsmith modify

Patch an existing KiCad schematic without touching the synthesis pipeline. Tell it "add battery management with TP4056" and the LLM generates a modification plan, you confirm, patches are applied, and the ERCAgent validates post-patch. A timestamped .bak backup is created before any write.

boardsmith verify

Check a design against its intent using 6 semantic verification tools: connectivity, bootability, power, components, BOM, and PCB. Rule-based checks run free; the LLM-guided fix loop handles what rules can't catch.

The --no-llm Philosophy

This is the part we care about most: boardsmith build --no-llm runs the full pipeline deterministically. No network. No API key. Same input, same output, every time.

We designed it this way because we don't think hardware synthesis should depend on a probabilistic model for correctness. The knowledge base contains exact electrical specs from datasheets. The constraint checker uses arithmetic, not vibes. Pull-up values are calculated from bus capacitance and speed, not hallucinated.

When you do enable LLM mode, the system uses the model for two things: interpreting ambiguous prompts more flexibly, and iterating on designs that fail constraint checks. The LLM proposes changes; the deterministic pipeline validates them. The model never gets the final say on electrical correctness.

This is not a wrapper around GPT that outputs a schematic-shaped string. The pipeline existed before we added LLM support, and it works fine without it.

What It Can't Do (Yet)

• No analog design. Op-amp circuits, filters, analog signal conditioning -- not yet. The topology synthesizer handles digital buses (I2C, SPI, UART) and power distribution.
• No high-speed design. Impedance matching, differential pairs, length-matched traces -- none of that. If your design needs controlled impedance, boardsmith can give you a starting schematic, but you'll need to handle the layout yourself.
• 212 components. That covers sensors, displays, comms modules, MCUs, memory, actuators, and power regulators. Enough for many embedded projects, but not everything.
• STM32 is beta. ESP32 and RP2040 are stable with good coverage. STM32 HAL support works but covers a smaller subset of peripherals.
• No multi-board designs. One prompt, one board.

Why Open Source, Why AGPL

We chose AGPL-3.0 for a specific reason: if you improve boardsmith, those improvements come back to everyone. Use it in your projects, modify it for your workflow, build products with it -- but if you distribute a modified version, share the source.

For companies that need to integrate boardsmith into proprietary toolchains without the AGPL obligations, we offer a commercial license. That's how we sustain development as a four-person seed-stage team.

But the real reason for open-sourcing is simpler: the knowledge base is the bottleneck. 212 components is a decent start, but the embedded ecosystem has thousands of parts. We can't write every ComponentEntry ourselves. Every contributor who adds a sensor, display, or comms module makes boardsmith more useful for every other user. That's a flywheel we can't spin alone.

How to Try It

pip install boardsmith
boardsmith build -p "ESP32 with BME280 temperature sensor" --no-llm

Python 3.10+. No API key. No Docker. No signup. Output lands in ./boardsmith-output/. Open the schematic in KiCad, flash the firmware, check the BOM.

What's Next

We're focused on three things in the near term: More components (this is where community contributions have the highest leverage), better STM32 support (moving from beta to stable), and OpenAI tool-use support (currently ships with Anthropic tool-use for ERCAgent and verify).

Longer term, we're thinking about analog circuit synthesis, multi-board systems, and simulation integration. But we'd rather ship what works today than promise what might work next year.

boardsmith is at github.com/ForestHubAI/boardsmith. Star it, try it, break it, tell us what component you wish it had.

At ForestHub, we believe the best tools make hardware as accessible as software.