April 10, 2026

Let's Build an Amstrad CPC 6128!

Inspired by Ben Eater's series to build a 6502 computer, I have decided to build my own 8-bit computer on a bunch of breadboards. More specifically, I'm building an Amstrad CPC 6128, a Z80 based computer, clocked at 4 MHz with 128 KB of RAM, which was very popular in Europe in the late 80s.

Rebuilding my childhood computer is going to be an exciting journey that I will document here, failures and successes alike. We should be learning a lot and hopefully not burn too many components while we're at it!

Let's not fool ourselves though. Building a computer is not that simple and we will cut corners. Probably a lot! But others have done it before, some a while ago, others more recently. There is also a very active community around the CPC who has made a ton of resources available to us. We will need them!

The Destination

They say "it's not about the destination, it's about the journey". When my wife was struggling to finish school, a friend encouraged her to keep going by saying, "it's not about the journey, it's about the destination!" We thought the mistake was really funny until we realized she was also right - both things are true! While I am looking forward to the journey, I also need a destination: to run an original CPC game! I haven't decided which game yet, but maybe Bruce Lee, which is, to me, a quintessential game of the CPC.

Here are our main milestones to get there:

1. Display the screen buffer, in all 3 official video modes
2. Take the Z80 for a test run, i.e. tick it with a clock and "watch" it execute NOP instructions
3. Boot the ROM and get to the Ready screen
4. Handle keyboard inputs and run BASIC commands
5. Load and save things on a "floppy drive"
6. Play sounds
7. Wrap it all together and run an original CPC game!

I have the bad feeling that I am missing important steps here, but "oh well". I guess we will find out what they are soon enough!

The Map

We can't tackle a project like this without knowing what components lie in a CPC and how they work together, at least to some extent. So what's under the hood?

This is the circuit diagram of the CPC 464, same-ish computer with only 64 KB of RAM. It is a bit simpler than its 6128 counterpart and the colors make it easier to read. So what do we have here?

• 🟩 Z80A CPU, reads and writes 8-bit data at 16-bit addresses.
• 🟧 M5L0255AP PIO, uses 3 8-bit ports to interact with peripherals (keyboard, joysticks, cassettes, floppy drives, printer) and the sound chip.
• 🟨 AY-3-8912 sound chip, generates 3-voice sounds, was widely used in arcade games and a bunch of 8-bit computers.
• 🟦 HD6845SP video controller, generates the raster data to be displayed, was also very popular in 8-bit computers and is the ancestor of the EGA and VGA PC cards.
• 🟪 HM4864U-2 DRAM, stores 64 Kb of data. Each chip handles 1 bit at a time. The CPC combines 8 of these to handle 8-bit words. And the 6128 has 16 to get its 128 KB.
• 🟪 74LS153 multiplexers (above the RAM), act as traffic lights to alternate memory access between the CPU and the video controller. They also split the 16-bit addresses into two 8-bit words to access the memory in a row-column multiplexing fashion required by the DRAM.
• 🟪 74LS244 and 74LS373 (below the RAM), transfer data between the DRAM and the data bus.
• 🟪 the ROM stores the OS and a BASIC interpreter. I cannot make out what the chip is. It holds 32 KB with a 200 ns access time.
• 🟫 the Gate Array acts as the chief conductor of this microchip orchestra:
  • Clocked at 16 MHz itself, it provides the other clock signals: 4 MHz for the CPU and 1 MHz for the sound chip.
  • Selects the active current memory chip (ROM or RAM, and RAM banking on the 6128).
  • Manages the multiplexers to alternate RAM access between the CPU and the video controller.
  • Outputs the RGB or Lum signal for the screen.
  • Synchronizes interrupt and V-sync signals.
• 🔴 the Clock Signals and Sync Signals are the heartbeats that bring the whole machine to life.
• 🔵 Address Bus tells the machine where to access the data.
• 🟣 Data Bus tells the machine what the data is.

This diagram is going to be very important. It is the map that will guide us to our destination. Every connection between any two components of the machine is represented somewhere in this map.

Before We Embark

Some of these chips are widely available while others are going to be more difficult to find. Some of these chips, despite being available, have more convenient alternatives. Let's see what parts of the design we can modify to make our life simpler and to make our goal reachable.

Gate Array

This is a bespoke chip made for the CPC. Each CPC model has a different one, specifically programmed for its hardware. There is no way we can get our hands on one of these and we need a replacement. These are the two options I can think of:

1. Use an FPGA, a programmable gate array. This is the natural solution, except that I don't have one laying around. Oh, and also, I have never used one before. We are going to have to learn how they work if we ever go down that route. According to the interwebs, the learning curve is steep!
2. Use a microcontroller instead. An ESP32 is what I have in mind, just because I happend to have one laying around. I am not too sure whether it can do the job like a gate array would, but we'll give it a try. Easy to program, easy to stick on a breadboard, it has a couple of interesting features: USB port, serial interfaces, Bluetooth, Wi-Fi, a decent amount of RAM, and a bunch of GPIO pins. It can generate clock signals for us, we can use it to interface with a keyboard, and it can act as an external memory to emulate a floppy drive.

So let's start with the ESP32. But there is a risk, it might not be fast enough. In which case we'll switch to an FPGA and still keep it for its many interfaces that we'll use to emulate floppy drives and to get inputs for a keyboard.

DRAM

Instead of parallelizing 8 chips of 64 Kb of DRAM, we can instead use one single chip of 64 KB of SRAM. Note the difference here: b stands for bit, B stands for byte. For the 6128 version, it's actually 2 chips instead of 16. While we're at it, let's go straight for a single chip of 128 KB SRAM if we can. And we're done! This design change is going to save us a lot of wiring and precious breadboard space. Also, SRAM doesn't need to periodically refreshed to keep its data alive like DRAM does.

Since we are changing this piece of hardware, we don't need multiplexers anymore. We are going to plug all 16 address lines directly into the SRAM. But we still need line drivers to switch between the address bus and the video controller. We'll use octal data buffers: they have 8 input lines, split into two sets of 4 bits that can be activated independently. With 4 of these, we will be able to select where we are getting the addresses from.

ROM

There are a couple of options we have to emulate the ROM. They all imply using a programmable ROM so that we can easily write to it, and even modify it if needed. It doesn't really matter if we use an EPROM, EEPROM or a Flash Memory. What matters is having enough of it (we need 32 KB) with a maximum access time of 200 ns. An important criteria is also what my local electronics store has in stock. The one chip that meets all these needs is a 512 KB Flash memory with a 90 ns access time. 512 KB is plenty, we'll only use a fraction of that. In theory, we could access more, maybe do some bank switching and use more than 32 KB, swap ROMs, store more games maybe? We'll see!

TTL vs CMOS

The original CPC runs on TTL technology. But today we have CMOS technology, which is faster, uses less power, but is also more vulnerable to static damage. Both technology have different logic voltage levels but are somewhat compatible. Mixing them is usually okay, but we must be careful about timing and voltages. Since I'm far from being an expert in such things though, I'd rather not mix them.

Another contender is CMOS with TTL compatibility technology. Just like CMOS, but with signals that play nicely with TTL chips. We'll go for that, because some of our chips will be TTL (like the Z80 itself).

In the original design, all chips belong to the 74LSx series, which is TTL. They all have a CMOS counterpart in the 74HCx series, and also a TTL compatible CMOS version in the 74HCTx series. Any of our integrated circuits will be from the HCT family.

The Shopping List

So this is what we'll need for our journey:

• Z80A CPU
• 8255-5 PIO
• AY-3-8912 Sound Chip
• 6845 Video Controller
• Memory chips
  • Flash Memory, 32 KB, 200 ns
  • SRAM, 128 KB, 200 ns
  • Data Buffer 74HCT244 (5)
  • Data Buffer/Latch 74HCT373
• ESP32 (there are many, the one I have is a ESP32-S3-DEV-KIT-N16R8)
• Voltage converters: the Z80 ecosystem operates on 5V while the ESP32 operates on 3.3V. We need converters so that we don't fry our little chips!
• A couple of breadboards, How many, you ask? Let's see:
  • CPU, PIO and AY-3-8912 can probably fit on one board.
  • The RAM and the few data buffers around it will need two 2 boards.
  • The ESP32 and the video controller should be fine on one board.
  • My voltage converters are quite large (I think it's because they can convert both ways) and will use up 2 boards. There is probably a better setup to optimize the space they take, but we can worry about later.
  • ... And I almost forgot the EEPROM! We'll try to stick it with its RAM friends.
• And of course the usual electronic suspects: 22-AWG wires, LEDs, resistors, capacitors, buttons, a couple of NAND gates and also OR gates.

Is It Even a CPC Anymore?

Many parts of the original machine will be replaced with something else. We are going to end up with a bunch of disparate components, some of which not even at the same voltage levels, all slapped on a couple of breadboards and crudely wired together. Will that be a Amstrad CPC? Just like the Ship of Theseus, what gives a computer its identity? Its hardware? The software it runs? How it looks and how it sounds?

It will display the same pictures, play the same sounds, and run the same games, but in the inside, it will be nothing like the original. Clearly, it won't be a CPC, but what the world will come to call the Frankenstrad CPC 6128.