A register

8-bit Breadboard Computer

A working 8-bit computer built from scratch, no microcontroller, no CPU chip. Just 74LS logic, three EEPROMs, and a clock, wired one gate at a time until it could run a program. Literally a charge in motion: electrons walking the bus, one pulse at a time.

The whole machine on breadboards, every module wired and labelled by hand.

A faithful recreation of Ben Eater's 8-bit computer, the SAP-1 ("Simple As Possible") architecture from Malvino's Digital Computer Electronics, built as our final-year college project, first on breadboards and then as a soldered PCB. The goal was to understand, at the wire level, how a CPU actually works: how a clock drives a shared bus, how registers latch and release, how an ALU adds, and how a few EEPROMs become a control unit.

Credit where it's due. The design, schematics, and the superb video series are entirely Ben Eater's work (eater.net/8bit, YouTube). This repo documents our build of it. No design changes, we followed the reference faithfully and learned every module by reproducing it.

The Team

Built by three of us, final year, always & forever, the people you build your first computer with.

• Sarosh (KJ), github.com/ChargeInMotion
• HighCarlSagan, github.com/HighCarlSagan
• Shivam Singh

"You have my sword." "And my bow." "And my axe.", three of us, one bus, one fellowship that saw it through to the PCB.

Why We Built This

Our aim was simple to say and hard to do: build and understand the working of an actual 8-bit computer on a breadboard, putting four years of ECE, every analog and digital fundamental we'd been taught, to work on one bench. A CPU had always been a black box that just "executes instructions"; the only way to truly open it is to build one by hand, place every gate, route every bus line, and watch a program move through it one clock pulse at a time. Where our own coursework left gaps, Ben Eater's series filled them.

We followed it end to end, breadboard first, then PCB. You don't skip steps: you earn each module by getting the one before it to actually work.

"It is not our abilities that show what we truly are. It is our choices.", and we chose to do it the hard way, with discrete logic.

What It Does

• An 8-bit computer with a shared 8-bit bus that every module reads from and writes to.
• Runs small programs from 16 bytes of RAM, entered via DIP switches.
• A microcoded control unit (built from EEPROMs) sequences each instruction into up to 5 micro-steps.
• Classic demo: LDA 14, ADD 15, OUT, load a value, add another, show the sum on the 7-segment display.

Architecture (SAP-1)

Every module hangs off one common 8-bit bus. The control logic decides, each clock step, which module drives the bus and which latches from it.

                          ┌──────────────── 8-BIT BUS ────────────────┐
                          │     │      │       │      │      │        │
                    ┌─────┴─┐ ┌─┴───┐ ┌┴─────┐ ┌┴───┐ ┌┴────┐ ┌──────┴─┐
        Clock ────▶ │ Prog. │ │ MAR │ │ RAM  │ │ IR │ │  A  │ │ Output │
        module      │ Count │ │     │ │16×8  │ │    │ │ reg │ │ reg +  │
          │         └───────┘ └─────┘ └──────┘ └─┬──┘ └──┬──┘ │ 7-seg  │
          │                                      │       │    └────────┘
          │                              ┌───────┘   ┌───┴───┐
          ▼                              ▼           ▼       ▼
   ┌──────────────┐                 ┌─────────┐   ┌──────┐ ┌──────┐
   │ Control Unit │◀── opcode ──────│ Instr.  │   │  B   │ │ ALU  │
   │ (3× EEPROM   │── control sigs ─│ decoder │   │ reg  │▶│ Σ /  │
   │  microcode)  │   to all modules└─────────┘   └──────┘ │ A−B  │
   └──────────────┘                                        └──────┘

Modules: clock · program counter · memory address register (MAR) · RAM · instruction register · A & B registers · ALU (adder/subtractor) · output register (7-segment) · CPU control logic.

Control logic. The instruction register's upper nibble is the opcode; the lower nibble is the operand. 28C16 EEPROMs hold the microcode lookup tables, for each opcode, a sequence of up to 5 micro-steps asserting control signals like CO (counter out), MI (MAR in), RO (RAM out), AI (A in), EO (ALU out), SU (subtract), OI (output in), J (jump), HLT (halt).

How We Built It, Module by Module

We built and verified each unit on its own before wiring it to the bus, you don't get to the Mines of Moria without first learning to read the map.

• A & B registers. Built from D flip-flops. To verify them in isolation we ran the clock in bistable / single-step mode (one clean pulse at a time) so we could literally watch the bits shift on the LEDs before trusting the register. To be, or not to be, which is, after all, all a flip-flop ever has to decide.
• Instruction register. Built it, then sat with it until the why clicked: how the opcode it holds is what tells the control unit which microcode sequence to run. Understanding its role was the moment the "computer" stopped being a pile of chips.
• ALU. Wired to operate on the A & B registers, addition first, then subtraction, reading its result back onto the bus.
• Programming the EEPROMs. We used an ESP32 as the programmer to flash the microcode (and program bytes) onto the EEPROM ICs.
• Output unit. Decoded the bus value to the 7-segment display.
• Bringing it together. The real lesson wasn't any single module, it was the integration: timing, bus arbitration, and the new class of bugs that only appear when everything shares one set of wires. When the output register finally lit up with the result of a program we'd toggled into RAM, all three of us just stared at it going amaze, amaze, amaze.

The Clock That Wouldn't Behave

Every good build has a boss fight. Ours was the 555-timer clock, right at the start, and nothing else in the machine works until the clock does. Every great scheme needs the clock to strike on time.

• Symptom: the clock wasn't producing clean square waves on the breadboard, edges were ragged and the whole machine was unreliable.
• Diagnosis: we were seeing IR drops across the power rails, current spikes were sagging the supply voltage along the breadboard's long, resistive rails, so the 555 never saw a stable Vcc.
• Fix: added a decoupling capacitor across the power rails to act as a local charge reservoir, smoothing the supply. The clock snapped into clean, stable square waves and stayed there.

No 1.21 gigawatts needed, just one capacitor in the right place. Great Scott, the clock was clean. A small fix that teaches why every real board is littered with decoupling caps.

Bill of Materials

The full parts list from Eater's reference build (~$250–300, 14 breadboards), which we followed:

Sourcing. Every IC, breadboard, jumper, wire, and tool was bought in person from the Chandni Chowk electronics market in Delhi, half the adventure was hunting down each 74LS part across the lanes.

What We Learned

• A "CPU" is just timing. Every instruction is a fixed sequence of "this module drives the bus, that module latches it," paced by the clock. At 1 Hz with LEDs, the fetch-decode-execute cycle becomes something you can watch.
• Microcode is a lookup table. The control unit isn't clever logic; it's EEPROMs mapping (opcode, step) → control signals. That one idea connects this breadboard to real microcoded processors.
• The power rail is a circuit too. Our clock bug wasn't the 555, it was the rails. Decoupling capacitors went from "that thing in schematics" to a reflex.
• Bus contention is real. Two modules driving the bus at once = garbage. The control signals exist precisely to guarantee exactly one driver per step.
• Integration is its own skill. Each module worked alone; making them cooperate on shared wires, with correct timing, was the actual project.
• Hardware debugging is a discipline. No printf, you debug with a meter, a logic probe, and the clock single-stepped by hand.

What's in this repo

Beyond the write-up above, this repo holds the actual artifacts from our build:

• design/kicad-8bit-computer/: our KiCad capture of the full computer (clock, program counter, MAR, RAM, instruction register, A and B registers, ALU, output, control logic) plus the custom footprints we drew.
• design/pcb-modules/: the per-module boards we laid out in KiCad, A register, B register, ALU, control logic, instruction register, program counter.
• simulation/A_register.pdsprj: a Proteus simulation of the register before we committed it to copper.
• images/scope/: oscilloscope captures from the running machine.
• docs/8bit-alu-thesis-redacted.pdf: our project report. Personal contact details and roll numbers are removed.

Open the .sch and .kicad_pcb files in KiCad to view or edit the design.

Build photos

The breadboard build, the bus running down the middle with each module hung off it:

The output stage: a 7-segment display decoded off the bus, next to the MAR and RAM.

PCB

After the breadboard worked end to end, we laid it out as a PCB. KiCad 3D views:

Clock on the scope

The 555 clock running at about 961 Hz on a Siglent scope, after the decoupling fix described above. Clean square edges, stable supply.

Roadmap

A faithful recreation today; ideas for later, roughly increasing in difficulty:

• Add build photos (breadboard + PCB)
• Short clip of it running
• Scope captures of the running clock
• Document our own programs beyond the LDA/ADD/OUT demo
• Flags register (Zero / Carry) + conditional jumps
• Extend the ALU (subtract done; add logic ops / shifts)
• Publish the PCB design files

References & Credit

• Ben Eater, 8-bit computer: eater.net/8bit · parts list · schematics
• Video series: Building an 8-bit breadboard computer (YouTube)
• Architecture: SAP-1, Albert Malvino & Jerald Brown, Digital Computer Electronics

All design credit belongs to Ben Eater. This repository is our hands-on build and notes, shared in the same spirit of learning his series is taught in.

Author

Sarosh (KJ) · github.com/ChargeInMotion · sarosh@chargeinmotion.dev "I'm a charge in motion."