Matt Regan, known for his channel DrMattRegan, has kicked off a new series that’s catching attention in retro computing circles: a scratch-built Commodore 64. But there’s a twist — no 6510 CPU, no VIC-II, no SID, and no programmable logic chips. Instead, Matt’s toolkit is a mix of EPROMs, SRAM, and TTL logic. It’s a Commodore 64 reimagined through pure, old-school digital circuitry.
Matt, who hails from Australia and holds a PhD in Computer Science, isn’t exactly new to deep technical projects. He once built a low-latency VR display controller at Paul Allen’s Interval Research and later contributed to NVIDIA’s Tesla and Fermi architectures. So, when he says he’s going to recreate a C64 without using the original silicon, you know he means business.
How This Project Works
Matt is structuring the build as a “trilogy of trilogies” — a concept that suggests the man has watched Star Wars at least once.
- Epoch 1 focuses on building the CPU, adding text-based video output, and bringing up BASIC.
- Epoch 2 will dive into sprite graphics and handling interrupts.
- Epoch 3 will tackle sound, evolving into a full SID-level experience.
The end goal? A completely homemade system that runs real Commodore 64 software — all without relying on the classic custom chips.
Understanding the CPU Blueprint
Before the soldering starts, Matt walks viewers through the 6502 architecture. The essentials — accumulator, program counter, instruction register, ALU, and sequencer — mirror designs dating back to the earliest digital computers, like the Manchester Mark I. Unlike the rudimentary setups of the 1940s, though, this modern build can lean on fast static RAM and programmable EPROMs.
Matt compares the 6502’s architecture to a physical notepad and rulebook setup — think longhand math on a pad, just sped up thousands of times. This perspective helps explain the Turing machine foundations behind CPUs, and why a straightforward Turing machine wouldn’t cut it for real-time computing back when vacuum tubes ruled the Earth.
EPROMs: The New “Brain”
Rather than using a traditional CPU, Matt’s design programs behavior directly into two 2-megabit EPROMs, building a custom finite state machine. These EPROMs output 32 bits of information, latched through a set of octal D-type flip-flops. A portion of the output loops back into the EPROMs, defining the machine’s next state, while the rest manages data operations.
This configuration essentially makes the EPROMs act as a custom processor — one that isn’t running “software” in the usual sense, but instead jumps through hardware-defined lookup tables.
Building the Notepad: Static RAM
For temporary storage — the “notepad” in the analogy — Matt uses static RAM (SRAM). SRAM allows reading and writing without the volatility and complexity of DRAM, making it a good fit for a project that needs fast and reliable access.
To manage memory addresses correctly, additional flip-flops capture address lines and synchronize reads and writes to the SRAM. Without this, the system would have read/write timing problems, which would be… bad.
Adding Random Access and Main Memory
A second RAM chip holds what would normally live in a C64’s main memory: the BASIC ROM, the KERNAL, and any loaded programs. To reach these memory locations, a pair of octal flip-flops act as the system’s memory address registers.
This setup enables indirect addressing, meaning the system doesn’t need to know the absolute position of everything in memory. It behaves more like a real computer, capable of executing a running program without relying on manual memory management at every step.
Building a “Real” 6502 Emulator
Matt outlines three levels of understanding for this system:
- Basic Level: Recognizing that the Turing machine model — rulebook and notepad — can emulate a CPU.
- Intermediate Level: Understanding how the rulebook is actually programmed to emulate real instructions like those of the 6502.
- Advanced Level: Introducing modules like a basic ALU and program counter to improve efficiency, reducing the size and complexity of the rulebook.
To create the 6502 emulator inside the hardware, Matt uses precomputed rules stored in the EPROMs, not a traditional ALU that does addition on the fly. Every instruction’s behavior, from addition to branching, is prebuilt into lookup tables.
Printed Circuit Board Design
Matt designed custom PCBs to house all the EPROMs, SRAM, and flip-flops. He used ZIF (Zero Insertion Force) sockets for the EPROMs, allowing him to swap chips during development without risking damage.
The boards feature a free-routing layout that keeps traces clean and troubleshooting manageable. After building the first prototype, Matt clocked the system at a fraction of real-time using an Arduino as the clock source — enough to run his go-to benchmark: Apple II Pac-Man.
Yes, it’s slow, but that’s beside the point — the core logic worked.
What’s Next?
The next step will be getting a video display running — again, built purely from EPROMs, SRAM, and TTL logic. No VIC-II in sight. The series promises to explore the barest bones of what made the Commodore 64 tick, peeling back the abstraction layers that modern computing usually hides.
