Documentation

Start here

The fastest way in is an example that already works. Each of these opens wired up, with its sketch, ready to run:

• Blink — one LED, one resistor, pin 13. Start here.
• Current Limiting — what the resistor is actually for.
• Voltage Divider — two resistors, one ratio.
• Breadboard — how the rows and rails connect.
• Piezo Buzzer, Servo, Mic, OLED, Clap Rhythm — parts in context.

Opening an example gives you a temporary workspace. You can change anything in it; press ⌘S / Ctrl S to keep it. In the browser, work does not survive a reload unless you export it — see Browser vs desktop.

Starting from nothing

New Blank Project on the welcome screen gives you an empty canvas. Add an Arduino Uno first — almost everything else is defined relative to it — then a breadboard if you need more than a couple of parts.

The canvas

Parts are drawn at their real physical size. An Uno is 68.6 × 53.4 mm, and breadboard holes sit on a true 0.1″ pitch, so a part's legs land in holes the same way they would on your desk.

• Add a part — from the parts panel on the left rail.
• Move — drag it. Legs snap onto the hole lattice as you go.
• Select — click. Selection follows the part's drawn shape, so empty space beside a narrow part doesn't grab it.
• Rotate — ⌘R, in 45° steps. Rotation re-snaps the ports to the grid, not the bounding box, so a rotated part still plugs in.
• Flip — ⌘F horizontally, ⇧⌘F vertically.
• Duplicate — ⌘D.
• Delete — Backspace or Delete.
• Stacking — ⌘] and ⌘[ move a part above or below its neighbours.

Pan with the arrow keys or by dragging empty canvas; zoom with + and −; ⌘0 resets the view when you have lost the circuit off-screen.

Editing values

Select a part to edit its properties — resistance, capacitance, LED colour, servo angle. Values are not decoration: the analog solver uses them, so a 10 Ω current-limiting resistor and a 10 kΩ one produce visibly different brightness.

Wiring

Click a pin or a breadboard hole to start a wire, then click the destination to finish it. Click intermediate points to route it by hand; wires are multi-point and orthogonal. Escape cancels a wire in progress.

• While a wire is in flight, it sees through parts and snaps to the nearest port — so you can land on a pin underneath something.
• Drag the end of an existing selected wire to move that end somewhere else, rather than deleting and redrawing it.
• Wire Color in the canvas toolbar sets the colour of new wires; Auto picks by role, so power and ground stay conventional.

How a breadboard connects

• Each half-row of five holes is one node — a to e are joined, f to j are joined.
• The centre channel separates the two halves, and is 0.3″ wide so a DIP chip or a push button straddles it correctly.
• The long rails down the edges run the length of the board — one for power, one for ground.

Writing the sketch

The .ino tab is an Arduino-style editor with syntax highlighting, autocomplete and multiple tabs. It is the same sketch you would paste into the Arduino IDE — setup(), loop(), pinMode, Serial.

void setup() { pinMode(13, OUTPUT); }

void loop() {
  Serial.println("Hello World");
  digitalWrite(13, HIGH);
  delay(500);
  digitalWrite(13, LOW);
  delay(500);
}

A dot on a tab means unsaved changes. Save with ⌘S / Ctrl S.

If a project has several sketches, the one that gets compiled is the configured main file — set it from the Run menu.

Running a simulation

Press the green play button on the canvas, or F5. F8 pauses. Pressing play compiles the sketch first, so there is a short delay before anything moves — the serial monitor narrates it.

What runs is a real ATmega328P emulation at 16 MHz driving an analog solver. Timers, interrupts and Serial behave as they do on hardware, and component values affect the result. An LED's brightness follows the actual duty cycle on its pin, so a sketch that fights itself — one loop driving a pin high while another drives it low — shows up as a dim LED rather than a silent logic error.

Give it a few seconds on first run. Compilation plus emulator startup is not instant, and an empty serial monitor for two or three seconds is normal rather than a failure.

Serial monitor & plotter

The panel under the canvas has several tabs:

• Serial Monitor — everything Serial.print and Serial.println emit. Once the simulation is running you can type into the input box and press Enter to send serial input back to the sketch.
• Serial Plotter — the same stream, graphed. Print a number per line and watch it as a curve; useful for a potentiometer or microphone.
• Problems — compile errors and circuit warnings.
• SPICE Logs — what the analog solver did, when you want to know why a voltage is what it is.
• Terminal — a real shell. Desktop only.

Toggle the panel with ⌘J / Ctrl J.

Keyboard shortcuts

Application

These work anywhere, with either ⌘ or Ctrl.

Canvas

These apply while the canvas has focus.

Canvas shortcuts currently bind ⌘ only, so on Windows and Linux the Ctrl equivalents do not fire yet. The menus and toolbar do the same jobs. Application shortcuts above are unaffected.

Circuit files (.cdl)

A circuit is saved as .cdl — plain text you can read, diff and commit. This is blink, complete:

Circuit {
    uno := ArduinoUno {
        position: (-208, -176);
    }
    led_red := LED {
        position: (-80, -240);
        color: red;
    }
    Wire {
        from: led_red.anode;
        to: uno.13;
        color: red;
    }
    Wire {
        from: led_red.cathode;
        to: uno.GND_1;
        color: black;
    }
}

Parts get a document-local name (uno, led_red) and wires reference parts by it. Editing the file and editing the canvas are the same act — both update together, and ⌘\ shows the code beside the circuit.

Because it is text, a circuit belongs in version control next to the sketch that drives it, and a diff shows what actually changed.

Browser vs desktop

The browser version runs the real simulator, not a recording. It is not the whole app, though:

The browser cannot run arduino-cli. The bundled examples therefore ship precompiled, and an edited sketch is compiled by a small hosted service. If that service is unreachable, the examples still run — the Run button says so rather than failing quietly.

The desktop build compiles locally and works with no network at all.

Self-hosting

Everything the hosted version does, you can run yourself, and it costs nothing.

• The compile service is a small Node service wrapping arduino-cli, with a Dockerfile and a hardening guide. Point the app at yours with COMPILE_API_URL.
• Cloud sync runs against your own Appwrite project, cloud or self-hosted.
• The whole app is a normal Flutter build. No licence check, no key.

git clone --recursive https://github.com/PinBench/pinbench.git
cd pinbench
flutter pub get
dart run build_runner build --delete-conflicting-outputs
flutter run

To compile your own sketches on desktop you also need arduino-cli with the AVR core installed: arduino-cli core install arduino:avr.

Troubleshooting

The LED doesn't light

Check the LED's polarity — anode to the pin, cathode toward ground — and that a resistor is in series. Then check both legs are really in holes: a leg in the air is treated as grounded, not as disconnected, which can look like a circuit that should work.

The LED is lit but very dim

Brightness follows the duty cycle on the pin. Either the current-limiting resistor is far too large, or two parts of the sketch are driving the same pin in opposite directions and the pin is only high for a sliver of each cycle.

"Compilation failed" in the browser

Editing a bundled sketch means it can no longer use the precompiled result, so it needs the compile service. Either revert your edit, use the desktop app, or point the build at a compile service of your own.

Nothing in the serial monitor

Confirm the simulation is actually running — the input box is disabled until it is — and give it a few seconds. Compilation and emulator startup happen before the first Serial.println arrives.

My work vanished after a reload

In the browser it is not persisted. Export the circuit (⌘E) or use the desktop app, which saves to real files.