Breadbox
Desktop Arduino workbench — real AVR emulation, SPICE transient solver, 3D breadboard, AI circuit agent, MCP-native.
A complete Arduino workbench, simulated for real.
Most Arduino simulators fake one half of the problem: they either string-match your code instead of executing it, or they animate the circuit instead of solving it. Breadbox does neither. arduino-cli produces a real .hex from your sketch, avr8js runs it instruction-by-instruction, a SPICE solver handles the volts and amps, and an agent can design the surrounding circuit for you. The same tools ship as a CLI binary, a desktop app, and an MCP server.
Breadboard in 2D and 3D
A 30-row breadboard with power rails, targeting Uno, Nano, Mega 2560, and RPi Pico. Around 30 built-in parts snap to the grid and connect through the internal bus strips. The same board renders as a flat schematic-style canvas or as a 3D scene built from real GLB part models — and you can author entirely new parts in a declarative DSL.
Real Bytecode, Real Circuit
arduino-cli compiles your sketch into the exact .hex an Uno would run, and avr8js executes it cycle-by-cycle — every #include, interrupt, and library just works. Underneath, a patched SPICE engine solves the surrounding circuit as a transient system, with capacitors, inductors, BJTs and MOSFETs integrated over time rather than approximated.
Agent-Driven Workbench
A Claude-powered agent designs circuits as a typed DSL — validate_design dry-runs the diagram before apply_design commits it — and a separate fix agent diagnoses a board that misbehaves. Reachable from the chat panel, the breadbox CLI, or any MCP client.
Prompt to circuit, circuit to silicon.
Say what you want
An agent turns the sentence into a typed circuit diagram, validates it, then commits it to the board — placing parts, routing wires, and writing the sketch in one pass.
Or build it yourself
Around 30 parts snap to the grid and connect through the breadboard's real bus strips. Every edit re-derives the schematic beside it — the same board, drawn two ways.
Real toolchain, real bytecode
arduino-cli compiles the sketch against avr-gcc and avr8js executes the resulting .hex cycle-by-cycle. The compiler's transcript streams in line by line — this is the same binary a physical Uno would run.
Sensors that answer
An emulated HC-SR04 echoes back a real pulse width, pulseIn() times it, and the distance lands in the serial monitor — while a SPICE solver works out the volts and amps behind every net.
The same board, in space
Flip the workspace and the circuit rebuilds as a three.js scene from real GLB part models, with jumper wires routed around the parts they pass over.
Driven by the running sketch
The 3D scene is not a still life. Stepper shafts and servo horns turn on the pulses the sketch emits, and LCD, OLED, and seven-segment screens are painted from the display buffer the emulated MCU is actually writing to.
What powers Breadbox
Six systems under the surface.
arduino-cli → avr8js
The real avr-gcc toolchain compiles the sketch; avr8js runs the .hex cycle-by-cycle. Interrupts, timers, USART, I2C, SPI, EEPROM — emulated, not shimmed. Pico sketches run on rp2040js.
Transient circuit solver
The board compiles to a SPICE netlist and is solved over time by a patched spicey: trapezoidal integration, real C and L, Ebers-Moll BJTs, level-1 MOSFETs. Runs in a Web Worker, cross-checked against ngspice in CI.
Three.js breadboard
GLB part models, wires routed around the parts they cross, a transform gizmo, and an assembly editor for mounting your own models onto a servo horn or stepper shaft. Rapier physics sits behind an experimental flag.
DSL-first circuit agent
Circuits are written as a typed diagram: validate_design dry-runs it, apply_design commits it atomically. A fix agent diagnoses a misbehaving board, and a policy engine can block a design that would over-draw a rail.
MCP server
20 tools over stdio, so Claude Desktop or Cursor can build circuits without opening the app. Edits hit disk, the app file-watches, and the open canvas redraws about half a second later — no reload.
Part registry + custom DSL
One schema per type drives the footprint, both renderers, the pin resolver, the agent's tool schema, and the power model. ~30 built-ins — and a declarative DSL whose behavior signals make a part you invent drivable from sketch code.
A real Arduino workbench,
with an AI agent at every layer.
Breadbox started as a transpiler-based toy and grew up twice. First the execution got real: arduino-cli compiles your sketch and avr8js runs the resulting .hex cycle-by-cycle — interrupts, timers, USART, I2C, PWM, EEPROM. Then the circuit got real: the board is compiled to a SPICE netlist and solved as a transient system, so capacitors charge, inductors ring, and a transistor is a transistor rather than an if-statement.
The architecture centres on a single diagram DSL and a component registry. The same schema drives the agent's tool inputs, the CLI's headless diagram commands, the MCP server's tool surface, the 2D and 3D renderers, and the persistence layer — so the agent, a human in Claude Desktop, and a scripted pipeline all speak the same dialect. A custom-part DSL extends that to parts nobody has built yet: describe the electrics, bind an SVG to a few behavior signals, and it simulates and animates like a built-in.
It ships as a single-file binary and a Tauri desktop app for macOS and Windows, with the whole web UI embedded in the executable and a signed auto-updater. There is no cloud to sign into: the board, the sketch, and the parts you author are files on your disk — which is also what lets an MCP client edit them and have the open canvas redraw a half-second later.
