MCL8080+ Crams an Intel 8080 Emulator Into an ATTiny85

Yes — an Atmel ATTiny85, a chip with 8 KB of flash and 512 bytes of SRAM, can emulate an Intel 8080 well enough to run period-correct CP/M binaries at reduced clock speed. The MCL8080+ project, published this week on Hackaday, is the most-complete public implementation. It will not run a full BBS or a modern game, but as a proof-of-concept it lands cleanly, and the bill of materials is cheaper than a single Raspberry Pi Zero W.

What MCL8080+ actually does

The MCL8080+ project, documented in a Hackaday post and the author's GitHub repository, implements an Intel 8080 instruction decoder in hand-tuned AVR assembly running on an ATTiny85. The interpreter handles the complete 8080 instruction set, exposes a small simulated memory map through external SPI SRAM (because 512 bytes of internal SRAM is not enough for any real 8080 program), and emulates a serial-terminal I/O path so the user can type into a host PC and watch the 8080 program respond.

The reported clock-rate equivalence is in the kilohertz range — well under the 2 MHz of an original 8080 — but enough to run small CP/M binaries and toy BASIC interpreters. The result is more art project than usable retro-computing platform, which is exactly why it caught the maker community's attention.

Why this is interesting

The ATTiny85 is one of the smallest, cheapest microcontrollers still in production. It is an 8-pin DIP chip, runs on a coin cell, and sells in single quantities for under $2. Per Microchip's product page, the ATTiny85 has 8 KB of program flash, 512 bytes of SRAM, and a 20 MHz maximum clock speed. Fitting a full 8080 emulator in 8 KB of program memory required hand-tuning the AVR assembly so tightly that the author published the implementation as much for its tutorial value as for its runtime utility.

This is the kind of constraint-driven engineering that retro-computing makers find satisfying. It is also a useful exercise for builders who want to understand how interpreted-instruction emulation actually works at the cycle-counting level.

Per-platform comparison: what runs an 8080 emulator

The interesting cell in that table is the first row: the ATTiny85 is the smallest chip that can realistically run an 8080 emulator, and the project's value is in proving that it is possible at all. For a maker who wants a useful retro-computing platform, a Raspberry Pi Zero W or Raspberry Pi 4 8GB is the practical answer.

Why an 8080 specifically?

The Intel 8080, released in 1974, is the spiritual ancestor of CP/M and a sizable chunk of early personal-computer software. Per the Intel 8080 Wikipedia entry, the chip was an 8-bit microprocessor with a 16-bit address bus, 8-bit data bus, and an instruction set of 78 distinct opcodes. The instruction set is small enough to fit an emulator into kilobytes of host program memory, and it has the historical pull of being the chip behind the Altair 8800, the IMSAI 8080, and the early CP/M software ecosystem.

For makers, the 8080 is the lowest-effort entry point into vintage emulation: smaller than the Z80, smaller than the 6502, and small enough that you can hand-code the interpreter rather than generate it.

What you would build with this

A maker who wants to actually use the project would pair the ATTiny85 with an external SPI SRAM chip (the MCL8080+ recommendation is a 23LC1024 — 128 KB of SRAM, $1-$2), a USB-to-serial bridge for the terminal, and a host PC running a serial terminal. The 8080 binary lives in flash on the ATTiny or in external storage; the emulator interprets the 8080 instructions and routes memory accesses through the SPI SRAM. CP/M's own minimal disk-image format can be served from a microSD card via SPI on a slightly larger build.

Boards like the 8BitDo SN30 Pro controller sit in the same maker-shelf neighborhood — small, cheap, USB-based, and built around constrained microcontrollers — though the controller is a finished product and the MCL8080+ is a kit.

Common pitfalls

• Underestimating the SRAM constraint. The ATTiny85's 512 bytes of internal SRAM cannot hold any real 8080 program; external SPI SRAM is mandatory.
• Skipping the cycle-counting work. The 8080 has documented timing behavior; sloppy emulators that ignore cycle counts run faster but break programs that expect realistic timing.
• Treating it as a usable computer. This is a demo, not a daily driver. For actual CP/M, a Pi Zero W with a more mature emulator is far more practical.
• Wiring the SPI bus loosely. The ATTiny85 has limited pins; sharing the SPI bus between SRAM and an SD card needs care.

When to use the MCL8080+ approach

This is an educational platform first. Build it if you want to understand how single-instruction-decoder emulators work at the assembly level, or if you specifically want a "smallest possible computer that runs 8080 code" demo. It is not a replacement for a Pi Zero running a more mainstream emulator when you want to actually use CP/M for anything.

What it teaches that a Pi-based emulator does not

The Pi-based emulator hides the interpreter loop inside a Linux process and a couple thousand lines of C. The ATTiny implementation lays the entire interpreter open in a few hundred lines of AVR assembly. Walking through that source code — and modifying it — is the closest most makers will come to understanding instruction-level emulation as a craft. That educational value is the project's real product, even more than the working CP/M binary.

Bottom line

MCL8080+ proves that an 8 KB ATTiny85 plus a small external SPI SRAM is enough to host an Intel 8080 emulator. Per the project's documentation and the Hackaday writeup, it runs at sub-megahertz effective speed, executes small CP/M binaries, and is built as a teaching tool. Most makers will build it to learn from it, not to use it daily. For actual retro-computing on cheap hardware, a Raspberry Pi Zero W plus an established emulator is the working answer; for a Linux-class homelab, a Raspberry Pi 4 8GB takes the same role for any vintage CPU.

Related guides

• Raspberry Pi 4 8GB vs Pi 5 vs Pi Zero W for a 2026 homelab
• Sound Blaster vs Aureal Vortex 2: the positional-audio war Creative won

Why the ATTiny family still ships

Microchip continues to manufacture the ATTiny85 in 2026, twenty-plus years after the family's introduction. The reason is industrial: tens of millions of low-cost embedded products use the chip for the kind of small-job microcontroller work it has always been good at. That production volume keeps the chip available, documented, and cheap, which is exactly what hobby projects like MCL8080+ rely on.

How long this kind of project takes

Per the author's blog notes, the MCL8080+ took several months of evenings to bring up. The bulk of the work was the cycle-accurate instruction decoder; the SPI memory layer and serial I/O were comparatively quick. A maker copying the project from the published source can be running CP/M's command prompt in an afternoon.

What is missing from the demo

The MCL8080+ does not implement floppy-emulation timing, does not handle interrupts in a fully period-correct way, and does not run the original 8080 at native speed. None of those omissions are surprising for an 8 KB project; all of them are reasons the demo is a demo rather than a replacement for, say, Altair clone hardware.

Citations and sources

• Microchip — ATtiny85 product page
• Wikipedia — Intel 8080
• Hackaday — maker-project coverage

This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.