What is Nihil

Nihil is a hardware-in-the-loop IDE that your own agent drives.

Nihil is a desktop app for Windows, macOS and Linux. The coding agent you already run (Claude Code, Codex, Gemini, Antigravity, OpenRouter or a local model) designs the PCB and its enclosure, runs your real firmware against a circuit simulation and a digital twin, and hands you fab-ready files once four gates agree. It is built for firmware and hardware engineers, small teams and makers who ship boards with microcontrollers. It is in invite-only alpha.

14steps every board runs, in the same order

4gates: circuit stress, ERC, final DRC with parity, live part check

19chip models today: Arduino AVR, ESP32, RP2040, RP2350, STM32, SAMD, Teensy 4

34tools your agent gets through one MCP server

What category is it?

Nihil is an integrated development environment for electronics, the way an IDE is for software. The nearest names are hardware-in-the-loop (HIL) tooling and firmware simulation, but it covers more of the job: the PCB, the CAD, the firmware, the simulation, the proof and the record all live in one project.

Nihil at a glance
QuestionAnswer
What it isAn agentic hardware-in-the-loop IDE: PCB and CAD generation, circuit simulation, a digital twin, firmware in the loop, gates, and a record of every run.
Who it is forFirmware and hardware engineers, small teams and makers building boards around microcontrollers.
Runs onWindows, macOS and Linux, on your machine. Simulation is local and deterministic.
The agentYours. Claude Code, Codex, Gemini, Antigravity, OpenRouter or a local model, in your own terminal inside the app. Nihil hosts no model and resells no tokens.
Chips simulatedNineteen microcontrollers (Arduino AVR, ESP32, RP2040, RP2350, STM32, SAMD, Teensy 4): the ESP32-P4 and STM32G030F6 with the firmware hosted on the chip model, seventeen at register level. More can be added from a register file.
Your filesPlain files in plain git, readable without Nihil.
StatusInvite-only alpha. The demo project runs read-only in a browser tab.

What it does

  • Designs the board. PCBs come from Python generators, and every board runs the same 14 steps. Four are gates, and no fab file exists until all four are clean.
  • Runs your firmware before the board exists. The control core compiles for the microcontroller and for your PC, and runs against models of the board. How that works, and where it stops.
  • Proves it against physics. A native digital twin runs the same firmware at a fixed 1 ms step against a model of the product: tyres, motor, pack, walls.
  • Imports what you already have. KiCad projects come in directly. Anything else, your agent writes the port. How an agent works on a board here, and how to build hardware with AI, start to finish.
  • Keeps the record. Every run keeps its decisions, questions, results and versions, so the proof outlives the chat that produced it.
Nihil's Sandbox on the demo RC car in its Twin view: the one_pass scenario at seed 1 has finished 10.000 s of simulated time, the car is drawn in 3-D with its front time-of-flight reading, and the acceptance list on the right shows six checks passed with the verdict nihil obstat.
The demo project's RC car after one recorded run: scenario one_pass, seed 1, trace f9f254b22ef79b11. The six acceptance checks on the right passed.

What it is not

  • Not a model provider. You pay your agent's provider directly.
  • Not a replacement for the bench. A twin proves your control logic against modelled physics. It does not prove the physics model is right, so constants only a bench can settle get a BENCH row, and the twin's result says which ones it leaned on.
  • Not instruction-set emulation. The firmware runs as C against a chip model; emulating the CPU running your compiled binary is documented in the method and not built.
  • Not a promise of every chip. Nineteen microcontrollers are modelled today, and Arduino sketches and vendor SDK programs do not run in the loop yet.

Questions people ask

What is Nihil?

Nihil is an agentic hardware-in-the-loop IDE for Windows, macOS and Linux. Your own coding agent designs the PCB and CAD, runs your real firmware against a circuit simulation and a digital twin, and delivers fab-ready files only after four gates pass.

Does Nihil include an AI model?

No. Nihil hosts no model and resells no tokens. You bring Claude Code, Codex, Gemini, Antigravity, OpenRouter or a local model, on your own plan, and Nihil hands that agent a hardware-in-the-loop lab through one MCP server with 34 tools.

Which chips can it simulate?

Nineteen microcontrollers are modelled today. Seventeen run at register level, generated from their vendors' register files: the ATmega328P, ATmega2560, ATmega32U4 and ATtiny85 behind the Arduino Uno, Nano, Mega and Leonardo; the ESP32, ESP32-S3, ESP32-S2, ESP32-C6, ESP32-C5 and ESP32-C3; the RP2040 and RP2350 of the Raspberry Pi Pico and Pico 2; the STM32F411 and STM32F401 of the Black Pill; the SAMD21 and SAMD51; and the i.MX RT1062 of the Teensy 4. The ESP32-P4 and the STM32G030F6 run from hand-made tables. Their register-level firmware runs in the loop; Arduino sketches and vendor SDK programs do not yet. The NVIDIA Jetson Orin Nano is a Linux computer: its program runs as it is, with real CUDA, against simulated devices; the Orin NX, the AGX Orin and the Raspberry Pi 5, 4 and Zero 2 W have board profiles on the same path. A microcontroller's firmware runs on its chip model inside the circuit simulator, and the same control code runs in the digital twin. Extensions let an agent add other chips.

Is it an emulator of my compiled firmware?

No. The control core, written in C with no vendor headers, is compiled for your PC and linked to the chip model and the twin. Instruction-set emulation of the microcontroller is documented and not built.

Can I bring a board I already designed?

Yes. A KiCad project is imported directly. For Altium, Eagle, a PDF schematic or a photo of a drawing, your agent writes the port. Until the board's models, limits and scenarios are declared, the circuit gate skips and says so.

Does it replace testing on real hardware?

No. It moves most of the finding earlier. Anything only a bench can settle gets a BENCH row, and a scenario that passes in the twin is meant to run on the real board unchanged. When the prototype is on your desk, Nihil talks to it over a serial port: who it is and which build it runs, its self-test, its field log, and on a bench build, sensor values held where you put them.

Where do my project files live?

On your machine, as plain files in plain git, readable without Nihil. Teams work through branches and worktrees, and the app shows who is on which board, CAD or firmware.

How do I try it?

The demo project (an RC car and its two boards) runs read-only in your browser at nihil.sh/demo/. The desktop app is in invite-only alpha; an invite code gets you the download and a licence file, and everyone else can join the waitlist.

Read next

See it run on a real board.

The demo project is an RC car, its two boards, its twin and every gate’s record, in the real app, read-only, in a tab. The desktop app is in invite-only alpha for Windows, macOS and Linux.