DonateOpen the app

Product

One engine, every way in.

The same Rust core runs in your browser, behind your agent, in your terminal and in CI. It places, routes, checks, simulates, runs the firmware and exports what a factory needs and it gives the same answer everywhere.

The app

Open app.pcbkit.io. That’s the install.

Start a board, open one of 8,500+ open boards, drop a KiCad project or open one from GitHub. No sign-up. Everything runs in the tab, on your computer’s cores.

The PCBKit app's front page: New board, New device, Import KiCad, Open from GitHub and Parts on the left; the board library with the Doom handhelds, a retro computer and devices, 8,638 open boards.
The front page: start a board or a device, import one, or pick from the library.

  • Proven circuits

    Regulators, USB-C power, LEDs, buttons, crystals, sensor ports. Each block works out its own part values from the numbers you give it and warns you when they don’t add up.

  • Real parts you can buy

    Say what a part must meet (10 kΩ, 1 %, 0402) and PCBKit picks one in stock and tells you why that one.

  • Any chip, from its datasheet

    Your agent reads a datasheet into a part sheet; PCBKit checks the pins against the package and the land pattern against the standard before it goes on the board.

  • See what you’ll get

    The board in 3D as the factory will make it: mask, finish and parts on their pads, its layers lifted apart.

  • Undo anything

    Every change, yours or your agent’s, is one step in the history. Try things. Nothing is lost.

  • Share it with a link

    One link anyone can open, no account needed: your board read-only, its AI tour first, following your changes.

Agents

Add PCBKit to your agent.
Then ask for a board.

One plugin for Claude Code, Codex, Claude and ChatGPT. It gives your agent PCBKit’s tools and teaches it how to use them, so it designs boards instead of guessing. Every call says why it runs and you watch it on your board.

  • Claude Code

    Add the marketplace and install the plugin.

    claude plugin marketplace add pcbkit-io/plugins
claude plugin install pcbkit@pcbkit

  • Codex

    The same repository is a Codex marketplace.

    codex plugin marketplace add pcbkit-io/plugins
codex plugin add pcbkit@pcbkit

  • Claude and ChatGPT

    Add a custom connector in the settings with this address.

    https://mcp.pcbkit.io/mcp

Then ask: Make a board with an LED that blinks every 2 seconds.

An agent's live page in PCBKit: the CAN node board it just built and verified, in 3D, with a strip of small ticks under the Build button, one per agent call, coloured by the board's state after it.
The live page of an agent’s session: the board follows every call. The ticks under Build are the agent’s calls, coloured by the board’s state after each (red where its first write did not compile); hover one for its reason.
  • The work is on your disk. With Claude Code and Codex the project is the repository: changed files are written back, git keeps the history, routing runs on your computer.
  • The build decides. One build places, routes, picks parts, checks, runs the firmware and ends with a verdict and ranked options, so the agent does not have to orchestrate a dozen tools.
  • The board in the chat. In Claude and ChatGPT the board opens inside the conversation, drawn by PCBKit’s own renderer in 2D and 3D.
  • Open to read. The plugin is a public repository, pcbkit-io/plugins.

Lab and firmware

It runs Doom.

Design the board, write its firmware, press Run. PCBKit compiles the code in the browser tab and runs the image on models of the board’s own chips, screen and buttons included: the same image you flash onto the board when it arrives. We built eleven Doom handhelds to prove it.

  • 11

    Doom handhelds, every one routed, checked and ready to order

  • 7

    processors: RP2040, RP2350, ESP32-S3, ESP32-C3, STM32F411, i.MX RT1062, CH32V003

  • 3

    instruction sets in the page: Arm, RISC-V and Xtensa

  • 0

    things to install: the compilers run in your browser tab

The PCBKit app with the Doom handheld open in the Lab tab: the board in 3D, Doom playing on its screen, the board's buttons as controls on the left.
The Lab tab: the firmware built in the page and running on the board’s own simulated chip.
Change the weather: the firmware reads the sensors over I²C and drives the display.

Real Arduino, in a tab.

Real sketches with the libraries everyone uses, built exactly as the Arduino IDE builds them and running on a whole simulated ATmega328P beside the board in 3D. Then order the board and flash the same sketch onto it.

Sensors are timed digital models, not analog physics. Anything a model does not cover stops with a message instead of a guess.

All Arduino boards in the app

  • AVR and Arduino

    avr-gcc 15.2.0 with ArduinoCore-avr 1.8.8, fourteen libraries and Arduino’s preprocessing, built to WebAssembly from pinned sources; a rebuild reproduces the tools byte for byte.

    ATmega328P, ATmega168P

  • Clang and LLD 19

    RISC-V and Arm Cortex-M from one compiler, with a kit per chip: start-up code, link layout and register headers.

    RP2040, RP2350, STM32F103, F401, F411, G030, G431, CH32V003, ESP32-C3, i.MX RT1062

  • Espressif Clang

    Espressif’s LLVM for the Xtensa cores, compiled to WebAssembly, with ESP-IDF’s register headers and low-level drivers.

    ESP32, ESP32-S3

Simulated chips

  • ATmega328P
  • ATmega168P
  • RP2040
  • RP2350
  • ESP32
  • ESP32-S3
  • ESP32-C3
  • ESP32-P4
  • STM32F103
  • STM32F401
  • STM32F411
  • STM32G030
  • STM32G431
  • CH32V003
  • i.MX RT1062
  • Z80 computer

The toolchains on GitHub

Analysis and simulation

Know what the board will do before you order it.

Ask the board in plain words. Your agent writes the analysis, PCBKit solves the physics of the copper you actually routed, draws the answer on the board and says plainly what it could not know.

  • The robot controller’s bottom copper with a voltage-drop simulation of its 5 V net: the track from the regulator to the servo headers coloured from purple to orange, and a table of the voltage and current at each pin.

    Voltage drop

    Will the servos get their 5 volts?

    Every track, via and pour of the robot controller’s 5 V rail meshed and solved: 3.1 A to two servo headers, 215 mV lost on the way, 437 mW of heat in the copper.

  • The robot controller in 3D with its temperature as a glow over the copper, and the heat lens beside it: hottest part 71 °C, board peak 50 °C, 717 mW of heat.

    Heat

    Will anything cook?

    The board’s temperature in still air from what each part sheds. On the robot controller R9 runs at about 71 °C against its 155 °C limit; the board peaks at 50 °C.

  • The robot controller’s copper coloured by voltage: 12 V violet, 5 V coral, 3.3 V amber, ground slate, and the power lens with its supplies and the heat lost in the regulator.

    Power

    Where does each voltage go?

    Every rail coloured on the copper, from the inputs through the regulators to the loads: 717 mW comes in, 99 mW of it leaves as heat in the regulator.

  • The robot controller’s copper coloured by temperature rise under each net’s current, and the current lens with the hottest copper of each power net.

    Current

    Are the power tracks wide enough?

    Each power track coloured by how much its current warms it. On the robot controller the hottest, +3.3V, rises 0.3 °C, well within the 10 °C designers aim for.

  • The USB audio DAC with each net labelled with its impedance on the board, the USB pair at 154 Ω, and the trace impedance script’s findings and inputs.

    Signal integrity

    Are my lines on target?

    Every net and pair field-solved on the board’s own stack. The USB DAC’s data pair reads 154 Ω where USB wants 90 Ω, and the finding says what to change.

  • The USB audio DAC with its signals coloured by how much of each runs without a return path, the stretches labelled on the board, and the script’s findings.

    Return paths

    Does every signal have a way home?

    Copper with no plane under it, marked where it runs: on the USB DAC twelve short stretches, the longest 2.1 mm, and every change of layer stitched.

  • An ESP32-C6 board beside the load-step template: the 3.3 V rail at the load, the first edge close up and the load current.

    Power integrity

    Will the rail dip when the radio transmits?

    A load step through the board’s own regulator, capacitors and copper: 390 mA bursts on an ESP32-C6 board’s 3.3 V rail dip it by 4.1 mV.

  • A buck converter board beside the converter template: loop gain crossing 0 dB at 30 kHz, loop phase, a load step and efficiency over load.

    Converters

    Is the buck converter stable?

    Loop gain and phase, a load step and the efficiency over load, from the converter’s own parts on the board, with the compensation it asked for.

  • An ESP32-C6 board beside the eye template: the statistical eye, the bathtub curve, the pulse response with its DFE taps and a PRBS7 eye.

    High speed

    Does the link open at 5 Gb/s?

    The channel from the copper as routed, equalized as a SerDes would train it: the statistical eye, the bathtub, the pulse response and a PRBS eye.

  • Your agent writes the analysis

    A short script in a sandbox reads the board, calls PCBKit’s solvers and draws the answer on it: findings in place, curves, heat maps and colour over the copper in 2D and 3D.

  • Circuits and signals

    Operating points, sweeps, AC, noise and transients with SPICE netlists and IBIS buffers. Lossy lines with skin effect, eyes with equalization.

  • Checked, not guessed

    Circuits within 1 µV of ngspice, impedance within 0.7 % of Hammerstad–Jensen, lossy lines within 0.2 dB of the exact solution to 5 GHz. A model PCBKit lacks is reported as missing, never filled in.

Pre-compliance, not sign-off: there is no 3D full-wave solver, emission from cables is not modelled and IBIS-AMI models are not run. Every script says what it assumed.

The eye template in PCBKit on an ESP32-C6 board's USB pair at 5 Gb/s: the answer in plain words with the equalization it chose and the inputs below as sliders and menus.
A USB pair at 5 Gb/s: the answer first, the inputs below it.

The language

A board you can read like code, checked like code.

A board is one short text file, design.pcbkit, beside the KiCad files: what is on the board, how it is connected and what it is for, with real units. Your agent writes it, you can read it, git keeps every version and PCBKit works out where the copper goes.

design.pcbkit2 layers · 14 parts · routes complete, 0 errors
pcbkit 2

// A USB-C sensor board: 3.3 V from USB, a serial bridge and the console header a 3.3 V FTDI
// cable plugs into, an I2C humidity sensor with its decoupling and pull-ups, a power LED.
net VBUS {
  voltage = 5V
  current = 500mA
}
net V3V3 { voltage = 3.3V }
net GND, DP, DN, TX, RX, SDA, SCL

board = Board { name = "usb-sensor" }

usb = UsbC2 {
  vbus -- VBUS
  gnd -- GND
  dp -- DP
  dn -- DN
}
ldo = Ldo {
  vin -- VBUS
  vout -- V3V3
  gnd -- GND
  current = 100mA
}
bridge = UsbUart {
  dp -- DP
  dn -- DN
  vcc -- V3V3
  gnd -- GND
  tx -- TX
  rx -- RX
}
console = UartHeader {
  tx -- TX
  rx -- RX
  vcc -- V3V3
  gnd -- GND
}

/// A humidity sensor in SOIC-8, its pins typed: a supply above 3.6 V does not compile.
part Sensor: Part {
  footprint = soic(8)
  pinout = {
    VDD = "8"
    GND = "4"
    SDA = "5"
    SCL = "6"
    ADDR = "1"
    NC1 = "2"
    NC2 = "3"
    INT = "7"
  }
  pinTypes = {
    VDD = io.powerIn(min = 1.7V, max = 3.6V)
    GND = .ground
    SDA = io.openDrain(max = 3.6V)
    SCL = io.input(max = 3.6V)
    ADDR = io.input(max = 3.6V)
    NC1 = .nc
    NC2 = .nc
    INT = .openDrain
  }
}
U2 = Sensor {
  VDD -- V3V3
  GND -- GND
  SDA -- SDA
  SCL -- SCL
  ADDR -- GND
  INT -- .nc
}
C1 = cap(100nF) { decouples = U2.VDD }
i2c = I2cPullups {
  sda -- SDA
  scl -- SCL
  vcc -- V3V3
  speed = 400kHz
  capacitance = 50pF
}
power = LedIndicator {
  signal -- V3V3
  gnd -- GND
  color = .green
  current = 1mA
}
  • Typed nets and pins. A pin says what it takes: a 3.6 V supply on a 5 V net, two outputs fighting, a missing pull-up do not compile and the error points at the line.
  • Intent the design states. A connector says what it mates with, a capacitor which pin it decouples, a filter the cutoff it is for, a fuse the short it must break. Each becomes a check at the line that wrote it.
  • Values PCBKit chooses. Write `?` where a value follows from the rest: a capacitor’s rating, a fuse’s hold current, the board’s size. PCBKit chooses it and says why.
  • Proofs, not guesses. Where a finding rests only on stated facts with the arithmetic re-derived, it is an error at once; everything else is measured blind before it speaks.
The PCBKit app with the Doom handheld: Doom running in the Lab on the left, the board in 3D in the middle and its design file on the right, the line that declares the selected processor highlighted.
The code and the board side by side: click a part, the editor shows where it is declared.

The language referenceThe board format

Ordering

From the board to the factory.

Gerber and drill files, the parts list and the placement file, zipped the way factories ask for them. Pick PCBWay, OSH Park, AISLER, NextPCB or JLCPCB and the board lands on the fab’s own order page, its colour and finish checked against what that fab makes. You choose the options and pay there.

The archive is frozen by its digest with what it orders and read back before it goes: the order record.

The Order tab of the PCBKit app: the board's size and layers, an assembled toggle and the fabs PCBWay, OSH Park, AISLER, NextPCB and JLCPCB with what each makes and a note where a fab does not offer the chosen mask colour.

The library

Start from a board people love.

8,500+ open boards by the people who made them: keyboards, radios, synths, sound cards, watches. Each opens with its AI tour, keeps its author and its licence and can be changed and routed again.

Browse the librarySources and licences

Embed

Put your board on any web page.

One line of HTML shows any GitHub repository’s board live on your site, or a picture of it for a README. Free, no account.

Embed a board

HackRF One, a software-defined radio board, drawn in 3D by PCBKit
HackRF One by Great Scott Gadgets (GPL-2.0), straight from its GitHub repository. A picture until you press the button, then the real app in a frame: turn it, lift its layers apart, play its tour.

CLI and CI

In your terminal and your CI.

  • The command line

    Route, check, render and export your KiCad project where it is (Altium, Eagle and EasyEDA boards import), offline, answering in JSON for scripts and agents and serving the same commands over MCP to any local agent. macOS, Linux and Windows; release 2026.10.31.

    curl -fsSL https://pcbkit.io/install.sh | sh

    github.com/pcbkit-io/cli

  • The CI gate

    PCBKit’s check on every push and before every order, on any KiCad repository: a verdict in levels, a report anyone can re-run digest for digest and waivers kept with their reasons. GitHub Actions and GitLab CI.

    uses: pcbkit-io/verify@v0

    How the gate works · github.com/pcbkit-io/verify