Truly handcrafted CPU: A hardcore developer spent three months on manual soldering and typed 1,800 lines of assembly code, and surprisingly, the self-made chip was able to connect to a screen and play *The Matrix*.

They say there's only a fine line between genius and madness, and that's absolutely true. Because it's really hard to tell which side the project you're about to see falls on.

This is the self - introduction of a YouTuber named Majsterkowanie i nie tylko (abbreviated as MINT, meaning “DIY and more”), who is also the developer of this project.

Recently, he showcased an astonishing project on YouTube called EPROMINT: With just a soldering iron, a bunch of old memory chips, and 8 - bit logic devices, he built an entire processor from scratch. Yes, it's not a development board, nor a microcontroller, but a complete CPU capable of instruction execution and memory addressing.

Moreover, this self - made CPU was successfully connected to a VFD screen, running the code he wrote himself, and could even play a low - resolution version of The Matrix...

In addition, MINT open - sourced the entire project's code on GitHub: https://github.com/majsterkowanieinietylko/EPROMINT. He said, “It took me a full three months, countless days and nights. I held the soldering iron and typed on the keyboard for hundreds of hours, just to pave a new way for myself and for you — a way that can lead far.”

The Birth of a Crazy Idea Stemmed from a Bunch of Old Chips He Didn't Want to Throw Away

There was no large - scale team or multi - million - dollar budget behind the development of this chip. It was all done by MINT alone.

According to what MINT revealed in the video, the idea of making a self - made processor all started with a bunch of old memory chips.

“I collected a lot and then started experimenting. Soon I realized that these seemingly outdated parts could actually be assembled into something really cool. After adding some peripheral circuits, I made a development board based on a single memory chip, which could perform any relatively simple operations. For example, controlling a motor to run faster or slower — this uses so - called PWM, which adjusts the actual output of the motor by quickly switching the power supply on and off; or displaying a message on the screen,” MINT said.

In one experimental project, MINT also developed a programmable module based on a single memory chip and designed a simple programming environment for it. Based on this, MINT could change programs, generate firmware, and write to the chip more easily, and the whole process was almost like modern development.

It was this experience that gave him a bold idea: If multiple such modules were combined, could an entire set of arithmetic logic be built? Could a complete processor even be created?

As an enthusiast of retro electronics, MINT decided to build a processor that pays tribute to the “era of the origin of computers” — it was that generation of processors that promoted the popularization of computer technology. He once assembled a computer with the classic Z80 processor by himself, so he had a relatively in - depth understanding of processor architecture.

In this project, he chose a “minimalist” but extremely challenging path: completely abandoning modern integrated circuits and only using old - style memory chips and logic elements popular in the golden age of 8 - bit computing, trying to build a CPU in the most primitive way.

Three Months Later, from ALU to a Complete Module System

When designing, MINT started with the most basic component — the Arithmetic Logic Unit (ALU).

At first, the first - version prototype ALU he developed only supported simple addition operations, and its functions were not very stable and a bit crude. MINT said, “I'm not making a toy; I'm making a complete processor. So I redesigned a more powerful ALU.” So, he abandoned this version and started the development all over again.

Subsequently, MINT redesigned the ALU with a slot - type structure.

The following work was repetitive physical labor: designing the circuit layout, soldering sockets, wiring, installing capacitors, power supplies, and wires, and debugging again and again. “Each module took me several days, but it was worth it — I could modify it at any time to avoid rework later,” he said.

The new version was not only more powerful but also laid the foundation for subsequent function expansion.

Based on the ALU, MINT then successively implemented three core modules:

Memory control module: Used for data storage and address addressing. By manually writing the ALU output to a specific address and designing the address control logic, the data read - write process was realized.

IO interface and program storage module: Provides the processor with the ability to interact with the outside world, and program instructions are also stored in this area. The processor can execute instructions such as “read the values at addresses A and B, add them, and store the result in C”.

Control module (instruction scheduling center): Responsible for reading instructions from the program memory and coordinating the operation of the ALU, memory, and IO.

After assembly, the total weight of this processor exceeded 500 grams.

However, having just the hardware is not enough; there also needs to be an instruction set that defines what operations the processor can perform.

MINT pointed out that these instructions seem simple, such as “read the value at memory address X into register A”, but implementing them involves multiple steps such as memory control, address decoding, and register writing.

So, he assigned an opcode to each instruction, and the control module determines how the circuit should work based on this code. The whole process is complex but clear.

In addition, MINT said, “The ALU not only supports addition and subtraction but can even perform multiplication, division, logarithms, trigonometric functions, etc. This is a function I deliberately expanded — after all, the Z80 doesn't have these. I tested and optimized it while working, and sometimes I would delete the original design and add better ideas.”

Finally, after design, MINT hand - wrote more than 1800 lines of assembly code for the processor, totaling about 120KB, covering a wide range of functions from mathematical functions to logical bit operations.

Of course, there were also many bugs in this process. The way to solve some bugs was even a bit like “digital modern art”. To debug these programs, MINT also printed a whole set of paper documents. The advantage of paper is that it can be flipped through at any time, is easy to mark, and doesn't depend on equipment, which is very suitable for use in debugging complex systems.

Interrupt System, Function Calls, and Stack Support: Getting Closer to a “Real CPU” Step by Step

At this point, the CPU was basically taking shape. Next, MINT started writing the first official program for testing — making the processor blink an LED continuously and light up another LED when an interrupt was received.

This leads to another key topic — the interrupt mechanism.

Processors usually execute instructions sequentially one by one, but sometimes we want them to respond immediately to certain external events (such as a button press). This requires interrupts.

In terms of architecture design, EPROMINT implemented a complete interrupt handling logic. When an external event triggers an interrupt, the processor pushes the current Program Counter (PC) onto the stack, jumps to the interrupt service program; after execution, it restores the PC from the stack and continues the original program flow. This mechanism enables it to respond immediately to external inputs such as buttons, giving it the basic interaction ability of a modern processor.

In addition to basic instructions, MINT also wrote a series of complex programs for the processor. For example, displaying numerical results on an LCD screen, or converting numbers into ASCII strings and then outputting them to a high - resolution VFD display. This process involved manually implementing division operations, stack operations, and character encoding conversion, all done in assembly language.

In one test, he even challenged to process a 256 - bit large integer. In the experiment, he made the processor try to perform a division calculation on a 100 - digit decimal number generated by a Chat tool, and the system crashed. To find out the problem, he used a RAM that doesn't lose data when powered off to save the memory content, traced and troubleshooted the logic line by line, and finally found the root cause of the fault.

What's even more amazing is that the EPROMINT project can not only run code but also play videos.

MINT manually implemented a division loop for precise frame - rate control, enabling it to output a stable 24 - frame - per - second video signal. After connecting to a high - resolution VFD display, he even played a clip from The Matrix — although it was in a minimalist pixel style, the effect was complete and shocking.

Open - Source and Future Plans: Developing a C Compiler for It

EPROMINT is now completely open - source. All circuit diagrams, firmware, design documents, and instruction set descriptions can be obtained on GitHub (https://github.com/majsterkowanieinietylko/EPROMINT) and Google Drive (https://drive.google.com/drive/folders/11 - RFmGcRUevfkHXVt - ET09YOgsZoN3Ui).

MINT said that the next - stage plan is to develop a C language compiler for it, so that more people can write programs for this self - made processor in a high - level language.

He hopes that through this project, people can re - understand the essence of processors. The mobile phones, computers, and smart devices we use every day are actually running similar underlying logic. It's just that in the context of the high integration of contemporary technology, this complexity is perfectly hidden.

“This project made me re - respect the power of these basic components, and I also hope more people can see that without modern ICs or ready - made platforms, as long as you understand and work hard, a computer can still be 'assembled' from scratch.”

After the release of EPROMINT, it immediately sparked heated discussions in the community. Many netizens commented:

“Great! Finally, we don't have to use Arduino or Raspberry Pi. It's all based on old - style chips.”

“This is the ultimate manifestation of the DIY spirit.”

Some people also joked, “We need this person to be in charge of Intel's 18A process.”

It's undeniable that EPROMINT doesn't win in terms of practicality. Its running speed, integration level, and even power consumption performance can't be compared with modern chips. But this “retro processor” made up of old parts and driven by assembly language demonstrates the essence of the concept of “computing” in a highly personalized way.

And the initiator of this experiment is just an ordinary creator who loves hands - on work and holds a soldering iron. It has to be said that masters are often among the people.

References:

https://www.youtube.com/watch?v=xBB1nAUvuqU

https://www.tomshardware.com/pc - components/cpus/passionate - enthusiast - builds - a - fully - functional - processor - out - of - old - memory - chips - hand - solders - every - wire - writes - 1800 - lines - of - assembler - code - and - makes - it - play - the - matrix - on - a - vfd - display#xenforo - comments - 3883038

This article is from the WeChat public account “CSDN”, compiled by Tu Min, and published by 36Kr with permission.