PCBKit: from idea to circuit board in minutes

The renderer

Watch a board come alive.

Not a mock-up: every frame is PCBKit’s own renderer drawing real open boards, the same one that runs in the app on your screen.

Rendered frame by frame by PCBKit’s own renderer; the radio board routed by PCBKit from bare pads. Open boards by their authors: MIST.1010 by Eugene Lozovoy (MIT), HBR MK2 RX/TX by Aleksander Alekseev (MIT), Cynthion by Great Scott Gadgets (CERN-OHL-P-2.0), moco RD501 by ZiTe (CERN-OHL-P-2.0), ESP32-WROOM-32 USB Development Board by Habib Ur Rehman (CERN-OHL-S-2.0), pslab hardware by FOSSASIA (Apache-2.0).

The lab

It runs Doom.

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

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

Play in your browser

Doom handheld

A real Doom handheld: an RP2350 (Pico Plus 2) under a 2.8″ ILI9341 screen with ten buttons, on a routed red keycard.

Ready to order42 parts2 layersGPL-2.0

Open and press Run Sources on GitHub

The PCBKit app with the Doom handheld open in the Lab tab: the red board in 3D, Doom playing on its screen, the board's buttons as controls on the left, its fabrication settings on the right. — The Lab tab: the firmware built in the page and running on the RP2350 handheld. Play with a gamepad or the keyboard.

Not just games

Change the weather. Watch the code react.

Write C for an ATmega328P and watch it run on the board in 3D: real instructions, simulated sensors, and a display that lights up because your code drove it. Make the room warmer, breathe some CO₂ into it, and see what your program does about it.

Temperature, humidity and CO₂ rise; the firmware reads the SHT31 and the SCD40 over I²C and drives the display over SPI.

Change the weather
Drag temperature, humidity and CO₂. The SHT31 and the SCD40 sample them on their own clocks; the display changes only when your firmware writes it.
Every instruction runs
An ATmega328P executes your program instruction by instruction, with I²C and SPI timed from its clock. Anything not modelled stops with a message instead of a guess.
Battery included
Charge, average draw, peak current and hours left, from each part’s current profile and what your code switches on.

weather.cATmega328P · 16 MHz · C

#define CO2_ORANGE_PPM 800
#define CO2_RED_PPM 1200

static void co2_indicators(void) {
    uint8_t bytes[9];
    if (!scd_command(0xec, 0x05) || !scd_read(bytes, 9)) { PORTD = 0; return; }
    for (uint8_t i = 0; i < 9; i += 3)
        if (crc(bytes + i) != bytes[i + 2]) { PORTD = 0; return; }
    uint16_t ppm = ((uint16_t)bytes[0] << 8) | bytes[1];
    PORTD = ppm < CO2_ORANGE_PPM ? 1 << PD5
          : ppm < CO2_RED_PPM    ? 1 << PD6
          :                        1 << PD7;
}

Edit it, build it, run it.

The firmware is a plain C file in the project, next to the board. Change the thresholds, build, and the simulated chip restarts with your program, keeping the room and the battery as they were. A compiler error leaves the last image paused and points at the line.

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

More boards to play with

From the blog

Arduino

Real Arduino. In a tab.

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

Adafruit SSD1306
Adafruit GFX
Adafruit SHT31
Sensirion SCD4x
LiquidCrystal
Servo
Wire
EEPROM

The PCBKit app with the weather station open in the Lab tab: an Arduino Nano and an OLED showing 23.0 °C and 45 % in 3D, sliders for the temperature and humidity on the left, and the build's memory report under the program. — The weather station in the Lab: drag the temperature and humidity, and the sketch redraws the OLED. The build reports memory as the Arduino IDE does: 20,890 bytes of flash, 565 bytes of globals.

co2-monitor.inoArduino Nano · ATmega328P

#include <Wire.h>
#include <SensirionI2cScd4x.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

Adafruit_SSD1306 display(128, 64, &Wire, -1);
SensirionI2cScd4x scd40;

void setup() {
  pinMode(GREEN, OUTPUT);
  Wire.begin();
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  scd40.begin(Wire, SCD40_I2C_ADDR_62);
  scd40.wakeUp();
  sensorFound = scd40.startPeriodicMeasurement() == 0;
}

Built as the IDE builds it. The sketch is preprocessed by arduino-cli’s rules, prototypes from ctags included, and compiled by avr-gcc 15.2.0 with ArduinoCore-avr 1.8.8, in your browser tab, in one to two seconds.
A whole ATmega328P. Three timers in every mode, USART, SPI, I²C, ADC, comparator, EEPROM, watchdog and sleep. Run out of RAM and it crashes, as a real Nano does.
Ready for the bench. Every board is routed and ready to order. The same sketch builds in the Arduino IDE and flashes onto the board that arrives, as it is.

All Arduino boards in the app The boards and sketches on GitHub

Toolchains and chips

Compilers and chips, in the page.

No installer, no SDK download, no USB cable. The compilers are open-source toolchains built to WebAssembly from their published sources, and the chips are models that run the image instruction by instruction. Anything a model does not cover stops with a message instead of a guess.

AVR and Arduino
avr-gcc 15.2.0, binutils 2.45, avr-libc 2.2.1, ArduinoCore-avr 1.8.8, fourteen libraries and Arduino’s ctags, 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, STM32F411, CH32V003, i.MX RT1062
Espressif Clang 22
Espressif’s LLVM for the Xtensa cores, compiled to WebAssembly and checked against the real boot ROMs.
ESP32-S3, ESP32-C3

Simulated chips

ATmega328P
ATmega168P
RP2040
RP2350
ESP32-S3
ESP32-C3
STM32F411
CH32V003
i.MX RT1062
RISC-V computer

And the parts around them

SSD1306 / SSD1309 OLED
HD44780 LCD
ST7735
ST7789
ILI9341
PCD8544
MAX7219
SHT31
SCD40
MCP23017
Servos
Buttons
Knobs
LEDs in six colours
SPI flash
PSRAM
Serial terminal

The ATmega328P model against simavr 1.8, the data sheet as the judge
Test sketch	Against simavr
serial	53 bytes on the USART, equal
interrupts	equal intervals, but 4 cycles to enter each interrupt (the data sheet’s 4; simavr counts none)
pwm	Timer0 periods equal; simavr drives no Timer1 or Timer2 compare output
eeprom	30 bytes equal; each EEPROM write takes 3.4 ms here, none in simavr
servo	20 ms frames and pulse widths equal; writing TCNT1 blocks the next match, as the data sheet says

The ATmega328P checked against simavr, an independent simulator, with the data sheet deciding where the two differ.

The toolchains on GitHub

How it works

You say what it should do. PCBKit does the copper.

A circuit board is the green card inside every gadget: chips sit on it and thin copper tracks connect them. Drawing those tracks by hand takes days. With PCBKit you describe the device, your agent writes the design, and PCBKit lays out the copper so it follows every rule. Say “move the connector to the left edge”, and the board follows.

Say what you want
“A USB-C sensor node, 50 × 30 mm, two layers, a port for an I2C sensor.” Plain words are enough.
Your agent draws it up
It picks proven circuits and real parts and writes them into one small file. PCBKit checks every line as it lands.
PCBKit wires it
It places the parts, routes every connection in copper and fills the ground plane, while you watch in 3D.
Files for the factory
Gerber and drill files, the parts list and the placement file, zipped the way board factories ask for them.
Order in one clicksoon
Colour, finish and quantity, checked against what the factory can make, ordered from the app.

The router

A router that finishes the board.

We put PCBKit’s router against another open-source autorouter, on that router’s own benchmarks: the same boards stripped to bare pads, the same machine, 120 seconds and 8 threads each, one run. KiCad’s own design-rule checker judged every result.

A four-layer robot controller, 70 parts: 204 of 204 connections routed in 14.0 seconds, in a browser tab on a laptop.

1,026/1,157
human-designed PCBench boards routed clean from bare pads, judged by KiCad’s own DRC (the other router: 958)
16×
faster on the median board of tier A: 0.4 s against 6.6 s, with the same 120 s and 8 threads each
½
about half the vias on the boards both routers finish, with slightly shorter copper, in a quarter of the memory

Boards routed clean by KiCad’s DRC, and the median seconds per board
Set	Boards	PCBKit clean	Other router clean	Median s, PCBKit	Median s, other router
PCBench A	453	449	447	0.4	6.6
PCBench B	560	491	436	3.4	30.0
PCBench C	122	77	66	9.4	101.7
PCBench D	22	9	9	102.3	103.2
KiCad demos	20	12	7	17.2	102.1

PCBench tiers A–D are 1,157 boards people designed and routed by hand, by difficulty. One AWS Graviton machine (192 cores), 16 boards at a time. The other router is still ahead on the very largest boards, with 10 and 12 layers; that is where we are working now.

Six ideas, all on by default.

Routing is a hard search: thousands of connections competing for the same few millimetres. Here is how PCBKit solves it in seconds, on a laptop, inside a browser tab.

Negotiate
All nets are routed at once, overlapping at first. Each pass makes contested space more expensive, until no two nets share it. The search grid has eight directions and spans every layer.
Exact where it counts
The grid guides the search, but every clearance is checked against exact geometry, to a fraction of a micron. Fine-pitch escapes with zero slack still fit.
Search the neighbourhood
Next it rips up a window around whatever is still unrouted, routes it again and keeps the result if it is better. Eight candidate states are searched side by side.
Pours, live
Copper pours are modelled while routing: the fill, the clearance around other nets, islands and thermal spokes. The router knows which pads a pour actually connects.
Pad access as a set
A pad on a dense part gets up to eight exact, full-width exits. Neighbouring pads negotiate for them instead of each getting a fixed stub.
Respects the mask
It knows where the solder mask opens, which vias are untented and where thin mask webs sit between pads, and routes so the fab can keep them.

Analysis and simulation

Know what the board will do before you order it.

Where does the power go, which track runs hot, how many millivolts reach the far connector? Ask the board. PCBKit solves the physics of the copper you actually routed, in your browser, and says plainly what it could not know.

The robot controller's bottom copper in PCBKit 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. — The robot controller’s 5 V rail feeding two servo headers: 3.1 A through the copper, 215 mV lost on the way, 437 mW of heat in the tracks.

Four lenses, one click
Voltage domains and where the power flows, the temperature rise of every power track, the board’s heat as a field, and a checklist for the factory, drawn over the board in 2D and 3D.
Voltage drop in the real copper
Every track, via and pour of a net meshed and solved: current divides the way it really does, and you see where millivolts and milliwatts go.
Circuits, DC to transient
Operating points, AC sweeps and adaptive transients, with SPICE netlists imported: subcircuits, behavioural sources, switches.
Heat and current, coupled
Joule heat from the copper feeds the board’s temperature, which changes the copper’s resistance, until both agree.
Fields and lines
2D electric fields for capacitance and impedance, and reflection, phase and loss along a transmission line.
Checked, not guessed
Solvers agree with ngspice to eight digits on a 40,000-node network, the browser’s answers match native ones bit for bit, and a model PCBKit lacks is reported as missing, never filled in.

Plugins

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

One plugin for Claude, Claude Code, ChatGPT and Codex. It gives your agent PCBKit’s tools and teaches it how to use them, so it designs boards instead of guessing. No new assistant to learn, nothing to run on your computer, no account to start.

Claude Code

Add the marketplace and install the plugin.

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

Codex

The same repository is a Codex marketplace.

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

Claude and ChatGPT
Add a custom connector in the settings with this address. Listings in both directories are in review.
```
https://mcp.pcbkit.io/mcp
```

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

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: select and move parts, route it, play its tour, share it by link or go fullscreen.
More than a hundred tools. Write and check the design, pick proven circuit blocks and real parts, place, route, fill, simulate, and export Gerber files or a KiCad board. Every answer carries the numbers that matter and the next step.
Skills included. The plugin brings two skills: one that starts your first board, and one that knows how to design, change, check, route and export with the tools.
Open to read. The plugin is a public repository: seralexeev/pcbkit-plugins on GitHub. It connects to mcp.pcbkit.io/mcp, which any assistant that takes MCP servers can use too.

agent · in the appwindow.pcbkit

pcbkit.hello("my-agent")
await pcbkit.commands("route")          // what it does, its schema
await pcbkit.call("route", {})          // runs as a job
await pcbkit.wait("job")
await pcbkit.call("view.state", {})     // what the person sees
await pcbkit.call("journal.since", {})  // what changed since my turn

Next to you in the app
Claude Code, Codex, Cursor, Gemini CLI or OpenCode drive the open page through a small API. You both work on the same board, and every change can be undone. A journal tells the agent what changed since its turn, and it sees what you see. Browsers with WebMCP get every command as a tool.
window.pcbkit
In your terminal
The pcbkit command line runs the same commands on a board repository and serves them over MCP to any local agent. Every command says what it does, what it takes and what it changes, with a JSON Schema; /agents.md and /llms.txt are generated from them.
pcbkit mcp

The language

A board you can read like a recipe.

Under the hood, a board is one short text file, design.pcbkit. It says what’s on the board and how it’s connected, with real units, and PCBKit works out where the copper goes. Your agent writes it, you can read it, and git keeps every version.

design.pcbkit2 layers · 14 parts · routes to complete

use "blocks/support.pcbkit" as support
⋯
net GND, VBUS
net V3 named "+3V3"
net USB_DP, USB_DN
net STATUS
bus I2C[2]
pair USB = (USB_DP, USB_DN)
⋯
board = Board {
  name = "sensor-node"
  outline = rect(50mm, 30mm)
  cutouts = [circle((3.5mm, 26.5mm), 1.6mm), circle((46.5mm, 26.5mm), 1.6mm)]
  layers = [signal(Cu.top), signal(Cu.bottom)]
}
⋯
usb = NetClass {
  trackWidth = 0.2mm
  diffPairGap = 0.2mm
  nets = [USB]
}
⋯
ldo = support.Ldo(VBUS, V3, GND, bulk = 4.7uF) { at = (14mm, 24mm) }

U1 = Mcu {
  at = (25mm, 14mm)
  pins { VDD: V3, DP: USB.p, DN: USB.n, SDA: I2C[0], SCL: I2C[1], LED: STATUS, GND: GND }
}
⋯
status = support.StatusLed(STATUS, GND) { at = (34mm, 6mm) }
sensor = support.SensorPort(V3, I2C[0], I2C[1], GND) { at = (46mm, 15mm) }

gnd = pour(net = GND, layers = [Cu.bottom]) { outline = board.outline }
⋯
rule UsbPair {
  select = copper(pair = USB)
  limits { trackWidth: limit(min = 0.2mm), diffPairGap: limit(min = 0.15mm, max = 0.25mm) }
}

Show the whole file (78 lines)

use "blocks/support.pcbkit" as support

// USB-powered sensor node: 3.3 V regulator, QFN-32 MCU, I2C sensor port and SWD port.
net GND, VBUS
net V3 named "+3V3"
net USB_DP, USB_DN
net STATUS
bus I2C[2]
pair USB = (USB_DP, USB_DN)

board = Board {
  name = "sensor-node"
  outline = rect(50mm, 30mm)
  cutouts = [circle((3.5mm, 26.5mm), 1.6mm), circle((46.5mm, 26.5mm), 1.6mm)]
  layers = [signal(Cu.top), signal(Cu.bottom)]
}

supply = NetClass {
  trackWidth = 0.5mm
  nets = [VBUS, V3, GND]
}
usb = NetClass {
  trackWidth = 0.2mm
  diffPairGap = 0.2mm
  nets = [USB]
}

part Mcu = device(footprint = qfn(32, size = (5mm, 5mm), ep = (3.1mm, 3.1mm)), pinout = {
  VDD: ["1", "17"],
  DN: "3",
  DP: "4",
  NRST: "8",
  SDA: "21",
  SCL: "22",
  LED: "24",
  SWDIO: "29",
  SWCLK: "30",
  GND: "33",
})
part C100n = cap(100nF, package = "0402") // one per supply pin

J1 = header(4) {
  at = (4mm, 15mm)
  pins = [VBUS, USB.n, USB.p, GND]
}
ldo = support.Ldo(VBUS, V3, GND, bulk = 4.7uF) { at = (14mm, 24mm) }

U1 = Mcu {
  at = (25mm, 14mm)
  pins { VDD: V3, DP: USB.p, DN: USB.n, SDA: I2C[0], SCL: I2C[1], LED: STATUS, GND: GND }
}

decoupling = {
  for ((i, p) in enumerate([(21mm, 17mm), (29mm, 11mm)])) {
    [i]: C100n { at = p; rotation = 90deg; pins { a: V3, b: GND } },
  }
}

J3 = header(5, pitch = 1.27mm) {
  // debug port, joined to the MCU's pins directly
  at = (25mm, 3mm)
  rotation = 90deg
  pins = [V3, U1.pin.SWDIO, U1.pin.SWCLK, U1.pin.NRST, GND]
}
R1 = res(10kohm, package = "0402") {
  at = (20mm, 8mm)
  pins { a: V3, b: U1.pin.NRST }
}

status = support.StatusLed(STATUS, GND) { at = (34mm, 6mm) }
sensor = support.SensorPort(V3, I2C[0], I2C[1], GND) { at = (46mm, 15mm) }

gnd = pour(net = GND, layers = [Cu.bottom]) { outline = board.outline }

rule UsbPair {
  select = copper(pair = USB)
  limits { trackWidth: limit(min = 0.2mm), diffPairGap: limit(min = 0.15mm, max = 0.25mm) }
}

The PCBKit app with the design file open beside the board in 3D: nets declared in code on the right, the routed robot controller on the left. — The code and the board side by side: click a part, the editor shows where it’s declared.

The library

Start from a board people love.

8,500+ open boards by the people who made them, converted to PCBKit: keyboards, radios, synths, sound cards, watches. Each opens with its AI tour: the camera flies from part to part while a guide explains what each one does. Then turn it in 3D, change it and route it again. Each keeps its author and its licence.

Browse the library Sources and licences

New · Embed

Put your board on any web page.

One line of HTML shows any GitHub repository’s board live on your site: in 3D, its layers apart, its AI tour. Or take a picture of it for a README. Free, no account. Here is one, for real.

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.

For beginners

Never made a board? You’ll be fine.

You don’t need to know how a voltage regulator works to use one. PCBKit knows, and it watches your back while you learn.

Proven circuits
Voltage 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.
Mistakes caught early
Two outputs fighting, a chip with no power, a forgotten pull-up, millimetres added to nanofarads. PCBKit points at the line and says what’s wrong.
Footprints done for you
314 standard footprints, computed from package dimensions by the industry standard (IPC-7351B), each with a 3D body.
Undo anything
Every change, yours or your agent’s, is one step in the history. Try things. Nothing is lost.
Real parts you can buy
Say what a part must meet (10 kΩ, 1 %, 0402) and PCBKit picks an orderable one for it, 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.
Share it with a link
One link anyone can open, no account needed: your board read-only, its AI tour first, following your changes.
Room to grow
Everything is plain text in git, and boards go to and from KiCad files. When you outgrow the basics, nothing is locked in.
See what you’ll get
The board in 3D as the factory will make it: mask, finish and parts on their pads. Turn it in your hand before you spend a cent.

Under the hood

One Rust core, everywhere.

The language, the checks, the router, the simulation and the renderer are one Rust codebase. It compiles natively for the command line and our servers, and to WebAssembly for the browser, and gives the same answer in both.

Threads in the browser. The WebAssembly core is built with atomics, bulk memory and SIMD128 on shared memory: Web Workers become real threads, a work-stealing pool on all cores but one.
Same answer everywhere. The router counts work, not seconds. Give it the same budget and it lays the same copper byte for byte, on any machine, with any thread count, natively or in WebAssembly. A test checks this on every fixture board.
Exact geometry, fast. Clearance maps are rasterised row by row in explicit SIMD, and every result is checked against exact shapes to a fraction of a micron.
Our own renderer. 2D, 3D as fabricated and the layers apart, drawn by our own passes on WebGPU or WebGL2, one submission per frame.
A result first. When a person is waiting, the router keeps to a deadline and hands back a routed board first, then polishes it in the background.

The robot controller in 3D with its four copper layers lifted apart like panes of glass, the vias running between them. — The four layers of the robot controller, lifted apart.

Routing in a browser tab: 1 thread vs 12.

Seconds, headless Chrome, AMD EPYC 9554. Same work budget, so the copper is identical in every run. One WebAssembly thread is within 10% of one native thread.

Board	1 thread	12 threads
USB boardcomplete, 4 vias	6.2 s	2.0 s
MCU board, 20 netscomplete, 23 vias	13.8 s	4.4 s
Motor controller, 63 parts, 4 layerssame copper either way	86.0 s	28.5 s

Measured

Measured, not promised.

Every change to the router, the checks and file import is measured on public boards that people designed. An independent checker judges the result, and a board only counts if it comes out clean.

96.1%
of 482 curated public boards import and export with every pad and every connection confirmed by an independent checker
KiCad files, both ways
232/235
human-designed boards where, after a refill, pour connectivity matches the independent checker
copper pours
4–26ms
from an edit to the board on screen, on boards up to 6 MB, in the browser
headless browser
10µm
every one of 2,821 silkscreen texts on 46 boards lands within 10 µm of KiCad’s own plot
text as KiCad prints it

What will you build?

Free. In your browser or in your agent. No sign-up.

Start a board Play Doom first

About

Who makes it

Hi, I’m Sergey Alekseev. I’m building Rabbit, an autonomous rover, and I write about it at rabbit0.dev. Rabbit runs on a Jetson Orin Nano with a stereo camera and maps the house in 3D. Its electronics are still a nest of wires, and every tool I tried for its boards made me feel slow. PCBKit is the tool I wanted: one my agent and I can work in together, from an idea to a board on my desk.

I started PCBKit to solve that problem for myself: to get Rabbit’s boards made without fighting the tools. I share how it goes in the open, what works and what the router can’t do yet. The engineering notes, with their numbers, are on the blog.

If you build something with it, or it gets in your way, write to support@pcbkit.io. We read every message.

PCBKit is free. If it saves you time, you can help keep it that way: donate once or every month.

Hardware is having its vibe coding moment.

Doom handheld

Doom on a 4.3″ RGB panel

Doom on a Teensy 4.1

Doom on a CH32V003

Doom on a Pico and an OLED

Doom on an ESP32-C3

Doom on an STM32F411

Doom on a bare RP2040

Doom on an ESP32-S3

Doom on a bare RP2350

Doom on a Pico Plus 2 carrier

Change the weather

Every instruction runs

Battery included

Edit it, build it, run it.

More boards to play with

Simulated chips

And the parts around them

Say what you want

Your agent draws it up

PCBKit wires it

Files for the factory

Order in one clicksoon

Six ideas, all on by default.

ANegotiate

BExact where it counts

CSearch the neighbourhood

DPours, live

EPad access as a set

FRespects the mask

Four lenses, one click

Voltage drop in the real copper

Circuits, DC to transient

Heat and current, coupled

Fields and lines

Checked, not guessed

Claude Code

Codex

Claude and ChatGPT

Next to you in the app

In your terminal

Slab Keyboard: left PCB

YUIOP: yuiop29re

Real Time Chess board

ColdFire and FPGA development kit

Saiboard (11x3)

Bitaxe Ultra

Multi-Channel DAQ: analog front end

pslab hardware

Put your board on any web page.

Proven circuits

Mistakes caught early

Footprints done for you

Undo anything

Real parts you can buy

Any chip, from its datasheet

Share it with a link

Room to grow

See what you’ll get

Routing in a browser tab: 1 thread vs 12.

What will you build?

Negotiate

Exact where it counts

Search the neighbourhood

Pours, live

Pad access as a set

Respects the mask