This Custom, Hand-Built Computer Is Made Almost Entirely From Basic Logic Gate ICs

The goal

The invention of the CPU and GPU meant that engineers could now design large, capable computers which required far less external circuitry and lower component counts, thus ushering in the modern era. But when trying to learn how math and programming can be performed by logic gates, it can be useful to create a simple computer out of only basic chips, so that is exactly what the YouTuber known as jdh decided to do. His breadboard PC, called the JDH-8, has 8-bit registers, a 16-bit address bus, 256 I/O ports, and a very simple 208x240px graphics processor. Perhaps best of all, it was assembled entirely on 20 breadboards and with a massive number of jumper wires.

Coming up with a plan

Before jdh could even attempt to begin laying out his minicomputer's circuitry, he first had to come up with a detailed plan, schematic, and select the best parts for the build. The CPU is based on a load-store architecture, meaning that it must load a value from memory into a register before an operation can be performed. It also supports a hardware stack with push and pop instructions, as well as a plethora of ALU operations.

For storing operation data, the JDH-8's CPU contains eight total registers, with up to 7 being available for general use and the last one for storing status flags that the ALU generates after an operation. In terms of memory, 16KB of ROM hold the program, 16KB of general purpose RAM, a stack space, and three words that hold the stack pointer, program counter, and current memory bank.

You can view jdh's process of designing and emulating his CPU design here in far more detail.

The Schematic

With the theoretical design now working on an emulator, jdh could move onto the next step: converting it into hardware. Rather than making one gigantic schematic with every component, the design was split into modules that could interact with each other without being overly convoluted. And instead of laying down individual transistors for each part, logic gates, banks of latches, multiplexers, and other parts are represented by a single symbol each for easier use.

Once everything had been designed virtually, simulated, and confirmed to work, the schematic was converted into a series of actual chips with wires that carry signals between them.

Construction

Each module was laid out onto several breadboards independently so that it could be tested. This consisted of placing the ICs down the middle and running jumper wires between the correct pins. In all, jdh had to build an ALU, register file, address module, I/O, instruction counter, control signals, and finally the video generator which was the most involved by far.

Testing

After spending countless hours wiring ICs together and testing modules, jdh connected them together and applied power for the first time. Luckily for him, most of the instructions worked properly, but trying to show graphics on a screen turned out to not function correctly. Eight hours, 20 more attempts, and several fixes later, it finally worked and displayed the letters 'HI' onscreen along with a tiny smiling face.

As seen below, jdh could now show images on a screen, do some math, and interact with other devices over its I/O bus.

A postmortem of the project

Even though this project was quite impressive and worked correctly, jdh did have some things that he wished were different. Namely, the hardware stack was unnecessary, his ALU design was over-engineered, and the load-store architecture proved to be unwieldy. But even with this reflection, the minicomputer worked correctly, and it will be exciting to see what else can be done with it.

To see more information about how it works, you can view jdh's explanation video below or look at his code and design files here on GitHub.