How to Build an 8-bit Computer from C Header Files

Imagine you've decided to write an emulator for the Commodore 64 or ZX Spectrum. Usually this turns into a long dive into the Z80 or MOS 6502 processor manuals, implementing timings, and trying to get everything to work with graphics output. But there's a project that offers a different approach — treating it like assembling a kit on a breadboard.

We're talking about the chips repository by developer floooh. It's a collection of 8-bit chip emulators and complete systems written in pure C. The main highlight is that everything is packed into header files (header-only), and the interaction between components mimics real physical pins.

What's the Core of This Project

When we write code, we're used to objects, methods, and callbacks. In chips, everything works differently. The author introduced the concept of pin bit masks. Each chip has a function tick that takes a 64-bit number. Each bit in this number represents the state of a specific chip "leg": address bus, data bus, read/write signals, or interrupts.

You feed a mask as input, the function calculates one clock cycle of the chip and returns an updated mask. To build a computer, you literally "run wires" in code, copying bits from one chip's output mask to another chip's input mask. This feels incredibly logical if you've ever held a soldering iron or dug into old hardware schematics.

What's Inside the Box

The repository contains a decent collection of hardware from the golden era of home computers.

To start with — processors. There's the classics: Z80, 6502, and 8080. Along with them come peripheral chips without which a computer won't boot. For example, the i8259 interrupt controller, i8253 timer, or MC6845 video controller.

Besides individual components, the author included ready-made assemblies in the project. You can run emulation of:

• Amstrad CPC 464/6128
• Commodore 64
• ZX Spectrum 48/128
• Acorn Atom
• And even the Soviet RK-86 (or rather, its close relative based on the 8080)

All of this is written in a C99 subset that GCC, Clang, and even MSVC handle without issues. No external dependencies — just include the appropriate .h file and you're good to go.

How It Works Technically

Despite the pursuit of "purity" in pin simulation, the author made sensible compromises for performance. If we honestly simulated every logic gate, the emulator would crawl even on top-tier hardware. That's why address decoding in the system emulators is often simplified.

It's interesting how testing is handled. There are no tests in the main repository — they're in a separate project chips-test. The usage examples are there too. And if you want to see what it's capable of in a browser, the author has demos compiled to WebAssembly. They run very fast, which confirms the viability of the header-only approach.

Practical Benefits

Why does a modern developer need this when there are dozens of ready-made emulators?

First, it's an ideal foundation for creating your own specialized tools. If you need to debug code for an old processor or write a custom debugger, chips provides a ready, tested, and very compact foundation.

Second, it's an excellent textbook on computer architecture. Instead of reading dry theory, you can see exactly how data flows from the processor to memory through the bus, just by placing breakpoints in the code.

Third, the project is useful for embedded systems enthusiasts. Thanks to no dependencies and low resource requirements, these emulators can run on a microcontroller, creating a "computer within a computer."

Is It Worth Trying

If you're a retro computing fan or just love beautiful, concise C code, it's definitely worth checking out the repository. The bit mask architecture is a fresh take on the old problem of emulation.

The project is alive, actively updated, and maintained. Of course, the documentation in the README itself is fairly brief, but the code is written so cleanly that it's easy to figure out on your own. For those who want to dig even deeper, the author even compiled a collection of schematics and manuals in an accompanying repository emu-info.

One caveat — this isn't a "plug and play" library for the average user. To get an image on screen, you'll need to attach some graphics backend (like Sokol or SDL) and figure out how to convert data from emulated video memory into pixels. But for those who like to dig into the "guts" of system software, this is more of a plus than a minus.