The kit

If you're into computers and you haven't seen Ben Eater's 6502 breadboard computer series, go watch it right now. I'll wait.

The premise is simple: build a working computer from a WDC 65C02 processor, some RAM, some ROM, and a bunch of discrete logic — all on breadboards. No PCB, no microcontroller abstractions, no hiding behind an Arduino. Just you, the chips, and a lot of jumper wires.

I ordered the kit. It arrived in a bag of ICs, a handful of breadboards, and a clock module. Three weeks later, I had a working computer that could run 6502 assembly and output to an LCD display.

And that's when the real fun started.

Going off-script

Ben's kit is brilliant as a learning tool, but once you understand how everything connects, you start seeing places where you can push it further. The architecture is so transparent — every signal is right there on the breadboard, probe-able, hackable — that it's almost impossible not to start modifying things.

First thing I did was increase the clock speed. The kit runs at a conservative frequency to keep things stable on breadboards, but the 65C02 can handle more. Swapped the clock crystal for a faster one, added some decoupling caps to keep the power rails clean, and suddenly everything ran noticeably quicker. Had to chase down a few timing issues with the RAM — the address setup time was getting tight — but that's the kind of debugging that teaches you more than any textbook.

Then I expanded the address decoding. The basic kit uses simple logic for chip select, which works but wastes address space. I replaced it with a proper decoder that maps the full 64K space more efficiently — dedicated regions for RAM, ROM, and I/O. This opened up room for peripherals.

The USB-to-serial interface

This was my favorite addition. I wanted the 6502 to talk to my Mac — send and receive data over a terminal, like a real serial computer from the era.

I wired up a WDC 65C51 ACIA (Asynchronous Communications Interface Adapter) to the bus. The 65C51 handles all the serial protocol stuff in hardware — start bits, stop bits, baud rate generation — so the 6502 just reads and writes to a couple of I/O addresses. On the other end, a cheap FTDI USB-to-serial adapter connects to my laptop.

Getting the baud rates to match was a journey. The 65C51's internal baud rate generator divides from the input clock, and the math doesn't always work out to standard rates depending on your crystal frequency. I ended up running the ACIA off its own 1.8432 MHz crystal (the magic frequency that divides cleanly into standard baud rates) rather than sharing the system clock.

Once it clicked — once I typed a character in my terminal and watched it appear on the LCD, then typed a response on the 6502's input and watched it show up in the terminal — that was pure magic. Two computers from completely different eras, talking to each other over serial, exactly the way it was done in 1980.

The debugging

Breadboard computers are chaos. Everything works until it doesn't, and when it doesn't, the failure mode is usually "nothing happens." No error messages. No stack traces. Just silence and blinking LEDs.

My best friend through this was a logic analyzer. Hook it up to the address bus, data bus, and control signals, trigger on a specific address, and you can see exactly what the CPU is doing cycle by cycle. It's like having a debugger, except the debugger is showing you actual electrical signals on actual wires.

The most satisfying bug I found: intermittent crashes that only happened when the LCD was updating. Turns out the LCD's enable signal was creating noise on the data bus that the RAM was interpreting as a write. A single pull-down resistor fixed it. One resistor. Three days of debugging.

Why this matters

In an era of M4 chips and cloud computing, there's something deeply grounding about building a computer that runs at kilohertz instead of gigahertz. You can see it think. You can probe every wire and understand every signal. There's no abstraction hiding the truth from you.

The 6502 powered the Apple II, the Commodore 64, the NES. This little chip shaped the entire personal computer revolution. Building one from scratch on a breadboard — understanding exactly how it fetches an instruction, decodes it, executes it — gives you a perspective on computing that no amount of high-level programming can provide.

I've been having more fun with this project than anything else I've done recently. Every session at the bench ends with either a breakthrough or a new mystery to solve, and both of those feel like winning.

The breadboard is getting crowded. I might need to start thinking about a PCB.