PartForge

Every wire on the board carries one bit: on or off, 1 or 0. On the board an on wire is drawn green and an off wire grey. For the robot, a bit is a simple yes-or-no fact. lineL is on when the left sensor is over the black line. motorL is on when the left wheel should spin forward.

A gate is a tiny box with a fixed rule. It looks at the wires coming in on its left and sets the wire going out on its right. That's all a gate does. The rule is usually written as a truth table, which lists every combination of inputs and the output each one gives. Here are the gates in the Parts list:

Why the example robot follows a line

The Line Follower is just two NOTs (each built from a NAND, which is what the Inverter part is). The left sensor feeds the left motor through one, and the right sensor feeds the right motor through the other. The robot starts straddling the line, so normally neither sensor sees it. Here are the four cases:

No step in this needs a program. Two flipped wires, applied about sixty times a second, are enough to steer.

Where the Lego idea comes in

Gates snap together the way bricks do. Wire a few gates together, press Save as…, and the circuit becomes a new block in Your parts. It has its own pins and can go inside the next circuit. The Inverter is one NAND, the Line Follower is two Inverters, and a part you build next could use the Line Follower as one of its pieces. In PartForge the bricks are pieces of logic, not motors and wheels. The robot's body is fixed, and what you build is its brain.

Open PartForge in a second tab and keep this page beside it. There are three panels: Parts on the left (the bricks), the board in the middle (where you wire them), and Test drive on the right (the robot). A mouse is easiest. On a phone, tap instead of click and use the Edit and Delete buttons instead of double-click and right-click.

The sections below are for when you want to know how the page itself works: how nested parts are flattened, why every gate waits one tick, and how the robot reads its brain.

There are only two kinds of part. A primitive (NAND, AND, OR, NOR, XOR, NOT, HIGH) has a function from input bits to output bits. A composite has a circuit inside it: nodes, each of which is another part, and wires from output pins to input pins. Saving a circuit is all it takes to make a new part, and the new part can go inside the next one.

The Inverter that ships with the page is the smallest example: one NAND with both inputs tied together, because NAND(a, a) = NOT a. Circuits are plain data, so the examples are written with a one-line-per-wire shorthand.

A composite part's pins aren't declared anywhere. They're read off its Input and Output nodes, so renaming a node renames the pin, and moving it up or down reorders the pins.

The one thing a part may not do is contain itself, even indirectly (A inside B inside A), because flattening it would never end. Saving runs a depth-first search over what the circuit uses.

The library also refuses unlabelled or duplicate pins, and won't delete a part that another part uses. Saved parts are written to the browser in dependency order (Inverter before Line Follower), so they can be loaded back one at a time.

Simulating parts inside parts directly would mean passing signals across every boundary on every tick. Instead, compile() expands the whole design once into a netlist: a flat list of primitive gates, where each signal is just a number (a net). The simulator never sees a composite part.

Every output pin gets its own net before any wiring happens, so a wire can point at a gate that hasn't been visited yet. That is what lets circuits loop back on themselves.

Then each node is handled by kind. Gates are copied straight into the netlist. A composite part is expanded recursively, with its input pins bound to the nets outside it.

“Declare these two nets equal” is exactly what union-find is for. Each net points at a parent; following parents leads to the net that represents the whole group. After expansion, every group is renumbered to one compact net, so the Line Follower, three levels deep in the editor, becomes just 2 NAND gates on 5 nets.

The simulator keeps two arrays of bits: the signals now and the signals next. On each tick every gate reads now and writes next, then the arrays swap. Every gate therefore has exactly one tick of delay, like a real gate's propagation delay.

That one rule is what makes feedback meaningful. Without a delay, a NOT gate wired to its own input has no consistent value. With one, it flips every tick: a clock. Two cross-coupled NOR gates hold whichever state they were last pushed into: the SR Latch in the parts list, one bit of memory.

settle() steps until a tick changes nothing, and reports when that never happens. The tests use it to check that adders settle and that a self-wired NOT doesn't. A real quirk shows up here too: the SR Latch, powered up with both inputs off, flickers forever until you pulse set or reset, which is how an idealised latch with identical gates behaves. The page's Signal speed menu sets how many ticks run per frame (1, 4 or 64), so you can slow it down and watch signals travel.

The robot is a two-wheeled, differential-drive car on a table with an oval line. Any part whose pins are named after its sensors (lineL, lineR, bump) and motors (motorL, motorR, optionally revL, revR) can be its brain. Each physics step reads the sensors, runs the brain's circuit for 32 ticks so the signals settle, and turns the motor pins into wheel speeds.

That turning rule is all the example brain needs. The Line Follower connects each sensor to the motor on the same side through an Inverter: while the left sensor sees the line, the left wheel stops and the car turns left, back onto it. Both sensors start off the line (it runs between them), so both wheels drive. In the simulator it laps the track in 17.7 seconds without its centre ever straying more than 3.4 px from the line, and a test checks a full lap on every run.

“This circuit (live)” in the Brain menu recompiles the board after every edit, so you can rewire the brain while the robot is driving.

• Signals are single bits, and wheels are only full forward, stopped or full reverse. There are no buses, no analog values and no motor speed control yet.
• There's no clock part and no timer, so a brain can't yet do “back up for one second”. You can build a clock from a self-wired NOT, but its speed depends on the tick rate, not on real time.
• Every gate has the same one-tick delay. Real gates differ, and races that depend on those differences don't appear here.
• The robot is kinematic: no mass, friction or wheel slip, and the table edge simply stops it. It is meant to make the logic visible, not to model a real car.
• The editor has no undo, multi-select or copy and paste. Wiring on a phone works, but a mouse is easier.

The tests cover every gate's truth table, the Inverter, the half adder, a full adder built from two half adders (all eight input combinations), the SR latch remembering a bit, a self-wired NOT that never settles, the library's rules, saving and loading, and the robot: driving straight, turning, feeling a bump, lapping the track with the Line Follower, and roaming the table with a wall-bouncing brain.