Building a CPU from Scratch

Every computer ever built — from the Apollo Guidance Computer to the M4 chip in your MacBook — can be constructed from a single type of logic gate: NAND.

A NAND gate outputs 0 only when both its inputs are 1. That’s it. From this one building block, we can create every other logic gate, and from those gates, an entire computer.

Let’s start by building the basic gates. Click the switches to toggle inputs and watch the output LED respond.

Now for the magic trick of digital design: composition. We take the gates we just built and wire them together into bigger circuits. Those bigger circuits become building blocks for even bigger ones.

Let’s build an adder — the circuit that lets a CPU do math.

Everything so far has been combinational — the outputs depend only on the current inputs. But a computer needs to remember things. To store a bit, we need feedback: a circuit whose output connects back to its own input.

This is where the clock enters the picture. Sequential circuits use a clock signal to synchronize state changes. Click the Tick button to advance the clock by one cycle.

Now we combine everything. A counter uses flip-flops, NOT gates, XOR gates, and AND gates working together. Bit 0 always toggles. Bit 1 toggles when bit 0 is 1. Bit 2 toggles when bits 0 and 1 are both 1. The AND gates form a carry chain — the same idea as addition.

Click Tick repeatedly or hit Auto to watch it count. The four LEDs show the binary value: 0000, 0001, 0010, 0011, ... up to 1111 (15), then it wraps around.

A program counter in a CPU works just like this — it counts through memory addresses, fetching one instruction at a time. The only difference is width (16 bits for the 6502) and the ability to load a new value (for jumps and branches).

We built a full adder that adds three single bits. But a CPU needs to add numbers. The trick is chaining: connect the carry-out of each full adder to the carry-in of the next. Four full adders in a row give you a 4-bit adder that can add numbers 0–15.

This is called a ripple-carry adder because the carry “ripples” from the least significant bit to the most significant. The 6502 uses exactly this pattern, just wider — 8 bits for its ALU, 16 bits for address arithmetic.

Try it: set the A switches (a3–a0) to 0011 (3) and the B switches to 0101 (5). You should see the sum LEDs show 1000 (8).

An adder can only add. A real CPU needs to do logic too — AND, OR, XOR. The Arithmetic Logic Unit (ALU) computes all of these in parallel and uses a multiplexer to pick the result based on a control signal.

Below is a 1-bit ALU slice. It has an adder, AND, OR, and XOR gate all wired to the same inputs. The two op switches select which result passes through: 00 = ADD, 01 = AND, 10 = OR, 11 = XOR.

Chain 8 of these slices (with carry linking the adders) and you have the complete ALU of the 6502. The CPU’s control unit just sets the op bits based on which instruction it decoded. Same circuit, different operation — that’s what makes it programmable.

Registers store a few values. A CPU needs thousands of addressable bytes. That’s RAM — an array of memory cells, each with an address. You put an address on the bus and the data at that address appears on the output.

The key insight: reads are instant (combinational) but writes need a clock tick. Change the addr input and data_out updates immediately. To write: set addr, set data_in, turn we (write-enable) ON, then Tick. Turn we OFF and change the address to read it back.

Try it: write the value 42 to address 1, then write 7 to address 2. Switch between addresses to see both values are remembered. The 6502 has 2 KB of RAM wired to its address bus — same idea, just 2,048 locations instead of 256.

Everything we’ve built — gates, adders, registers, counters, and an ALU — are the building blocks of a real processor. The MOS 6502 (1975) powered the Apple II, Commodore 64, and NES. It has just 3,510 transistors and an elegant instruction set. Its ALU is wider (8 bits), its program counter longer (16 bits), and it has a control unit that decodes 56 instructions — but the pieces are the same.

Below is a complete 6502 system simulated at the gate level — over 5,500 lines of TypeScript, compiled and running in your browser. It has a CPU, RAM, ROM, and a memory-mapped console output at address $F000.

The ROM is pre-loaded with C programs compiled with cc65, a C compiler targeting the 6502. Click Run to watch the CPU execute real compiled C code, one cycle at a time.