Over 1 km of wire, 1.800 lines of assembly, and zero shortcuts: the EPROMINT project revives 8-bit computing with a modern DIY twist—and you can explore every detail on GitHub.
In an era defined by nanometer-scale silicon and automated chip fabrication, one Polish electronics enthusiast has proven that raw ingenuity still has a place in modern computing. Known online by the name Majsterkowanie i nie tylko (“DIY and more”), this creator has hand-built an entire 8-bit CPU from scratch using only obsolete EPROM memory chips and logic components. The result, dubbed EPROMINT, is nothing short of extraordinary—and it doesn’t just work; it plays scenes from The Matrix on a vacuum fluorescent display (VFD).
More than just a retro tribute, the EPROMINT is a fully programmable processor with a real instruction set, interrupt handling, and custom architecture. Every connection was hand-soldered. Every instruction was hand-coded. And every module—ALU, memory interface, control unit—was designed and built from the ground up.
A CPU Built from Memory Chips
The project began with a simple experiment: using EPROMs (Erasable Programmable Read-Only Memory) to simulate basic logic for tasks like LED dimming and message display. But what started as tinkering quickly evolved. The creator realized that if memory could mimic simple logic gates, then in theory, an entire processor could be built using only programmable memory and control logic.
Inspired by the legendary Zilog Z80 and the principles of 8-bit computing, the design took shape. Unlike modern CPUs with billions of transistors, the EPROMINT uses EPROM chips to store lookup tables representing the truth tables of logic operations. Inputs are sent to the EPROM, and the chip returns the output just like a logic gate—except it’s programmable.
Engineering the Impossible
The EPROMINT is physically distributed across four full-sized perfboards, weighs over 500 grams, and contains more than 1.000 meters of hand-wired connections. Each component is socketed for easy debugging. It draws around 250 mA in idle mode and is capable of operating at clock speeds up to 9 MHz.
The CPU is divided into modular units:
- Main ALU (Arithmetic Logic Unit): Capable of addition, subtraction, multiplication, division, trigonometric functions, bit manipulation and more.
- Address Bus Controller: A secondary ALU incrementing memory addresses and managing stack operations.
- Control Unit: Decodes instructions and directs data flow—crafted with 256 unique instructions.
- Memory Interface: Manages RAM and ROM for code and data, and connects to external displays and I/O devices.
Each module communicates via standard buses and is orchestrated by a precisely coded instruction set written in custom assembler.
Over 1.800 Lines of Custom Assembly Code
Creating hardware is only half the battle—what made this CPU truly functional is the software written for it. The creator hand-coded over 1.800 lines of assembler, defining not just low-level instructions, but complete routines for arithmetic, logic, control flow, and even multimedia.
The instruction set includes advanced features rarely seen in vintage 8-bit designs:
- Bit-string manipulation
- Conditional branching
- Stack-based interrupts
- Function call and return support
- Floating-point approximations (logarithmic, trigonometric)
Despite the complexity, every line of code was manually written and converted into machine instructions, without the aid of a traditional assembler. Instead, opcode tables were built and referenced by hand.
Interrupts, VFD Displays, and… The Matrix
EPROMINT isn’t just capable of blinking LEDs—it can handle interrupts, manage memory stacks, and execute full multi-step programs with conditionals. One of the key demo programs featured in the YouTube presentation includes video playback of The Matrix on a VFD (Vacuum Fluorescent Display).
Achieving 24 frames per second, the system syncs video playback by precisely calculating the clock cycles needed to delay between frame updates. The interrupt system is used to pause current operations, handle external triggers, and resume tasks—a level of complexity that rivals early microcomputers.
Debugging in Pure Machine Code
With no compiler or IDE, debugging meant reading RAM manually after crashes and visualizing execution with LEDs and thermal cameras. One of the highlights of the build was using a special battery-backed SRAM chip to “spy” on stack memory after a failed movie playback attempt.
By analyzing the raw bytes, the creator identified bugs in the division routine, fixed comparison logic, and reloaded the modified machine code to achieve a near-perfect 24 FPS playback.
EPROMINT: A Love Letter to Computing
This project is more than just a technical achievement—it’s a tribute to the fundamentals of digital logic, the early days of microprocessors, and the human spirit of invention. It reminds us that behind every elegant piece of modern technology lies a deep, almost magical complexity built by decades of iteration and passion.
The EPROMINT isn’t a commercial product, and it won’t replace your Intel or ARM chip anytime soon. But it’s open-source, educational, and inspiring to any hacker, maker, or engineer curious about how the heart of a computer really ticks.
What’s Next?
According to the project’s author, the journey isn’t over. The next stage? Building a C compiler targeting the EPROMINT instruction set—an even more ambitious leap that would allow higher-level programming on a hand-built CPU.
And for those wondering—yes, this processor is entirely visible and traceable. Every clock tick. Every instruction. Every bit.
Welcome to open-hardware punk computing.
