Overview

MUPS/16 is an ongoing project to build a 16-bit CPU from scratch, using mostly basic 74-series logic ICs, a few ROM and RAM chips, and some almost-period-appropriate PLDs. It is, like most homebrew CPU projects, a work in progress, but the core of the Mk1 implementation is complete, with a basic LCD output providing the only IO so far.

I built most of the PCBs in what I intended to be their final form, but when I came to the control unit I switched to a plug-in card design on a backplane, so that I could iterate more rapidly (not having to worry about space constraints). The 1.0 build as it stands still uses the plugin cards.

The 1.0 build as it stood on its first successful run. The only real changes since then are the LCD output, and the clock converted to a PCB.

The Mk1.1 Revision

The Mk 1.1 boards, laid out as they will sit in the machine

The Mk 1.1 layout, with KiCad renders of the boards that exist so far, and grey for the ones still to be laid out. Click a board for details.

As of August 2026, I've run into enough issues with the first version that I'm building a Mk1.1 that tries to include lessons learned. I've tried to be very careful about feature creep and version 2.0-itis, and so I've resisted the temptation to throw in features like pipelining that I would desperately like to try. This version is purely a revision of the first. The instruction set is changing slightly to reflect removal of instructions I never used, and ones I should have added, but the core functionality will remain identical.

Note that the board writeups currently all still reference the 1.0 design. I'll update them as I build out the new boards.

History

This build was originally inspired by watching Ben Eater's 8-bit CPU video series, but I decided to try to take it a bit further and build a CPU that included a few more features of modern CPUs. Principally, this meant a more full-featured ALU, more registers and an MMU.

Originally, my intention was to build everything on breadboards, and so I restricted myself to a 16-bit design, as wiring anything more than that on breadboards is just no fun. The breadboard-only idea went out the window pretty early on, partly because I found it painful debugging problems caused by bad connections on the cheap boards I started with, but also because I realised just how cheap PCB manufacture is these days.

As I've designed and built out pieces of the CPU I've more or less settled on the following properties:

  • 16-bit design end-to-end, with no segment or offset registers. This limits the usable address space per process to 64KB, but I'm OK with that;
  • multi-cycle design, with no pipelining. Each instruction takes between 3 and 5 cycles (though they can have up to 8);
  • microcoded architecture, because I couldn't think of a good way to avoid that with only 16 bits per instruction (it's just not possible to encode opcodes, register info and control signals directly in 16 bits, for anything other than a toy CPU);
  • MIPS-like instruction set, despite using microcode. This was mainly because I hoped that by sticking to a RISC instruction set I would avoid the temptation to load up on special-purpose instructions, which would complicate any future version 2 with pipelining;
  • at least 8 registers, since programming in assembly with fewer isn't much fun;
  • some sort of useful I/O, including at least a PS/2 keyboard interface and a serial port, so that I could display output without having to build a VGA adaptor;
  • interrupts. Again, this was partly because I had no idea how these would actually work, and partly because they would be needed for I/O;
  • no microcontrollers anywhere (except for the unavoidable one built into the LCD display).
Overview