This project connects software to real hardware: a from-scratch 8-bit CPU on a custom PCB, plus Python tools that turn a tiny assembly language into EEPROM contents.
The point is not just to simulate a CPU. The point is to write instructions, generate ROM images, burn them into real chips, move the EEPROM to the board, and watch the hardware execute.
This is a custom educational CPU project. The design starts from the classic Ben Eater-style 8-bit computer, then moves toward a single-PCB build with Python-generated ROM images and an Arduino-based EEPROM programmer.
The CPU is only half the project. The other half is the software pipeline that lets me write simple assembly, encode it into bytes, generate a ROM image, and program an EEPROM that the hardware can actually run.
Assembly source
↓
Python assembler
↓
ROM image / byte array
↓
Arduino Nano programmer
↓
AT28C64 EEPROM
↓
8-bit CPU board
↓
LEDs / output register
This project sits between computer science, electrical engineering, and embedded systems.
Registers, buses, ALU behavior, flags, instruction fetch, program counter movement, and how control signals make the datapath do work.
Glue logic, tri-state buses, latches, edge-triggered registers, clock sequencing, control lines, decoupling, and electrical debugging.
A small Python toolchain parses assembly, encodes instructions, creates a byte listing, and outputs data suitable for EEPROM programming.
The workflow is intentionally practical. I want to change code, regenerate bytes, burn the ROM, and test it on the board.
Edit a tiny source file like program.asm.
Run the Python assembler to turn mnemonics and operands into bytes.
Send the generated ROM image over serial to the Arduino Nano.
The Nano drives shift registers, address lines, data lines, and write control.
Move the EEPROM to the CPU board and observe the output register or LEDs.
The ISA is intentionally small. The goal is to make each instruction easy to understand and easy to trace through the hardware.
| Mnemonic | Meaning |
|---|---|
LDA |
Load accumulator from memory. |
ADD |
Add memory value to accumulator. |
SUB |
Subtract memory value from accumulator. |
STA |
Store accumulator to memory. |
LDI |
Load an immediate value into the accumulator. |
JMP |
Jump to another address. |
JC |
Jump if the carry flag is set. |
JZ |
Jump if the zero flag is set. |
OUT |
Copy the accumulator to the output register. |
HLT |
Halt the CPU. |
This is the kind of tiny assembly program the Python tooling is meant to parse and encode.
; Example: load a value, store it, read it back, and output
LDI 0x0
STA 0xF
LDA 0xF
OUT
HLTThe control unit is microcoded. Each instruction runs as a sequence of smaller control steps.
The control word is a bitfield. Each bit drives something on the CPU: register load lines, output enable lines, ALU operation selection, memory read/write, program counter increment/load, and the output register.
Long term, the same Python tooling can generate not only instruction ROM images, but also the microcode ROM image.
(opcode, microstep, flags)
↓
control_word
↓
Register load / enable
ALU operation select
Memory read / write
Program counter control
Output register enable
To avoid manually entering bytes, I built a simple ROM loader around an Arduino Nano.
The programmer writes bytes to specific EEPROM addresses and can read them back for verification.
The Nano does not have enough GPIO for everything, so shift registers fan out address, data, and control signals.
Once the programmer works, I can change the assembler or microcode and burn new EEPROM contents quickly.
This project is still active. The point of the page is to show the build honestly: completed work, testing work, and next steps.
This is exactly the kind of project LaunchShell is meant to document: a real build that connects theory, tools, mistakes, debugging, and practical systems thinking.
Design the CPU, route the PCB, source parts, assemble the board, and build the ROM loader.
Keep KiCad files, assembler code, ROM images, notes, and test programs in version control.
Expect wiring issues, timing problems, bad assumptions, incorrect control bits, and failed test programs.
Use the failure points to understand how real machines execute instructions at the signal level.
These are useful starting points for readers who want to understand the background.
The original educational breadboard computer series that inspired the starting architecture.
A practical reference for building an Arduino-based EEPROM programmer.
A related single-board 8-bit computer project that influenced the PCB direction.
This project is a bridge between code and hardware. Python generates the bytes, an Arduino writes them to ROM, and the CPU board turns those bytes into visible behavior. That makes every layer observable: source code, opcodes, memory addresses, control signals, and physical output.