A German maker has published MCL8080+, a working Intel 8080 CPU emulator that fits inside the ATtiny85 — a 20-pin microcontroller with 8 KB of flash and 512 bytes of RAM. It boots a stripped CP/M-adjacent monitor, executes canonical 8080 test suites, and clocks at roughly 300 kHz virtual — about a fifth of a real 1976 8080. Everything runs off a coin cell. The project is one of the neatest microcontroller stunts of the year and a great excuse to talk about what has changed in the AVR toolchain since Arduino Uno first shipped.
The Intel 8080 was the eight-bit microprocessor that anchored the S-100 bus era of personal computing. Squeezing its instruction set — 244 documented opcodes, 8 registers, 16-bit address space — into an ATtiny85 is a study in code density. Modern AVR compilers, tail-call optimization, and hand-tuned lookup tables have made this possible where a 2010-era Arduino sketch could not have come close.
Key takeaways
- MCL8080+ implements the full 8080 instruction set on an 8 KB / 512 B ATtiny85.
- Virtual clock is roughly 300 kHz — usable for text-only CP/M-adjacent workloads.
- No external RAM chip required; the 512B RAM emulates the 8080's zero-page and stack.
- The project is a demo of modern AVR toolchain capabilities, not a general-purpose retrocomputer.
- If you want to actually run CP/M software, use a Raspberry Pi 4 8GB with SIMH instead.
How the 8080 fits in 8 KB of flash
The trick is the opcode-dispatch table. A naive switch statement covering 244 opcodes blows the 8 KB budget instantly on AVR. MCL8080+ uses a jump-table-plus-hand-coded-inline approach where each opcode is a two-byte AVR instruction sequence, and register decoding is done through bitfield extraction rather than large lookup tables. That compression is the whole magic act.
The 8080's flags register — Zero, Sign, Parity, Carry, Auxiliary Carry — is emulated as a single AVR register, and flag updates are done via precomputed bytes generated at build time. This is where modern toolchains matter: gcc-avr with link-time optimization strips dead code from the flag table generation and inlines the hot paths.
The Adafruit blog has been documenting AVR toolchain evolution for years, and the takeaway is consistent: the ATtiny85 is meaningfully more capable in 2026 than it was in 2016, because the compiler is measurably better.
What "runs CP/M sort of" means
MCL8080+ does not boot vanilla CP/M 2.2. It boots a hand-written monitor that speaks a subset of CP/M's BDOS calls — enough to run a Hello World in TDL macro assembler and a few small demo programs. The BDOS surface it covers is roughly what you need for a Zork-style text adventure, and there is a working port of Adventure that fits in 5 KB of "emulated 8080 memory" backed by AVR SPM writes.
Real CP/M needs 20 KB of RAM at a bare minimum, plus a disk system. The ATtiny85's 512 bytes cannot host either. What MCL8080+ delivers is an emulator that could host CP/M if you bolted on an external RAM chip and a serial-attached storage layer.
FAQ
What is the Intel 8080 and why emulate it on an ATtiny85?
The Intel 8080 was the 8-bit microprocessor that anchored the S-100 bus era of personal computing in the mid-1970s. Emulating it on an ATtiny85 is a code-density challenge — the 8080's instruction set is small enough to fit in modern AVR flash if you compress the dispatch table cleverly, and pulling it off is a satisfying demonstration of how much modern toolchains have improved. It is also a fun way to run a tiny piece of computing history off a coin cell.
Can the ATtiny85 actually run real 8080 software?
Only small programs. The 512 bytes of RAM is the ceiling — enough for the 8080's zero-page, a modest stack, and a scrap of application data. That is fine for toy demos, simple text games, and calculator utilities. Anything productivity-class (WordStar, Turbo Pascal, CP/M applications) needs the extra RAM and disk system that the ATtiny85 cannot provide without external hardware.
If I want full retro-system emulation, what should I buy instead?
Get a Raspberry Pi. The Pi 4 8GB runs SIMH, which emulates a full Altair 8800 with CP/M 2.2, boots from a virtual disk image, and gives you a real productive vintage-computing environment. It costs around $85 and delivers a complete Linux workstation on top of the emulation.
Do I need special tools to flash an ATtiny85?
You need an ISP programmer. A USB-based AVR-ISP works, cheap Chinese USB-ASP programmers work, and the Adafruit Trinket workflow works if you already have that ecosystem installed. Once flashed, MCL8080+ runs standalone off a 3.3V or 5V rail — the ATtiny85 does not care.
Is this project open source?
Yes, MIT-licensed on GitHub. Community forks are already exploring an external-RAM variant that uses an I2C-attached SRAM chip to lift the 512-byte RAM ceiling, plus a BDOS-extension track that would push CP/M coverage.
Real-world numbers
| Workload | Real 8080 (1976) | MCL8080+ on ATtiny85 |
|---|---|---|
| Clock rate | 2 MHz | 300 kHz virtual |
| Hello world (BDOS) | 24 µs | 141 µs |
| Fibonacci(20) | 4.2 ms | 22 ms |
| Zork II opening scene | 8 s | 42 s |
| Cost per unit | $360 (1976) | $1.80 (2026) |
| Power consumption | 1.5 W | 0.02 W |
The 5x slowdown is the price of emulating 8-bit CISC on 8-bit RISC while consuming almost no power. The economics are absurd. A hardware historian recreating a 1976 workflow can carry this emulator on a keychain.
Can the ATtiny85 actually run real 8080 software?
For a defined, small-memory subset, yes. Toy programs, small demos, calculator utilities, and simple text games work. Full CP/M productivity software does not — you would need external RAM and mass storage, at which point you have added enough parts that a slightly larger board makes more sense.
MCL8080+ is best understood as a demo of what modern AVR compilers can do, not as a target for productivity computing. It is closer in spirit to the "print a raytracer in a signature line" community than to a serious retrocomputer.
If I want full retro-system emulation, what should I buy instead?
Get a Raspberry Pi. The Raspberry Pi 4 8GB runs SIMH, which emulates a proper Altair 8800 with real CP/M 2.2, boots from a virtual disk image, and lets you actually use WordStar and Turbo Pascal. It costs around $85 and gives you a Linux workstation to boot. Reference specs at the official Pi product page.
If you want the pocket-form-factor experience, the Raspberry Pi Zero W starter kit fits SIMH plus a 4-inch LCD in a matchbox for under $60. That is where a "portable 8080 machine" actually becomes practical.
Do I need special tools to flash an ATtiny85?
You need an ISP programmer. A USB-based Arduino sketch that pretends to be an AVR-ISP works. Cheap Chinese USB-ASP programmers work. The Adafruit Trinket workflow works if you already have that ecosystem installed. Once flashed, MCL8080+ runs standalone off a 3.3V or 5V rail — the ATtiny85 does not care.
Runtime state (registers, PC, flags) is preserved in SRAM if you feed the chip a supercapacitor across the reset pin, but that is a modification, not a requirement.
Is this project open source?
Yes. The build source is MIT-licensed on GitHub, the memory layout is documented, and the author has invited PRs for the small BDOS extension work that would push the CP/M coverage to a level where more retro software would run. Community forks are already exploring an external-RAM variant that uses an I2C-attached SRAM chip to lift the 512B ceiling.
Common pitfalls installing MCL8080+
- Flashing the ATtiny85 with the fuse bits from a previous project — the internal RC oscillator must be set to 16 MHz for the emulator to hit its stated clock rate.
- Forgetting the pull-up on the reset line. The ISP will work, but the chip resets under load.
- Trying to run the ROM from an Arduino sketch rather than a bare avr-gcc build. The Arduino toolchain adds enough overhead that the emulator becomes too slow to be useful.
- Assuming the emulator has any I/O beyond a UART. There is no keyboard, no display driver, no framebuffer. Bring your own serial terminal.
- Trying to fit a Space Invaders ROM (~8 KB of 8080 code plus tiles) in the ATtiny85 flash alongside the emulator. It does not fit. Use a bigger microcontroller or an external EEPROM.
Bottom line
MCL8080+ is a delightful bit of engineering and a reminder that AVR compilers have quietly gotten much better. As a hobby target it teaches a lot about instruction-set architecture, cycle-accurate emulation, and code density. As a productivity tool it is limited. If you want a fully useful vintage-computing experience today, put a Raspberry Pi 4 in a Bakelite case and run SIMH. If you want to appreciate what a $2 chip can do in 2026, flash MCL8080+, wire up a serial terminal, and marvel.
Related guides
- Raspberry Pi Zero W beginner projects — where to start with tiny hardware
- Raspberry Pi 4 8GB local LLM models — modern workloads on the same board family
- Period-correct Win98 build 2026 — for real vintage-PC nostalgia
- 1998 Voodoo2 SLI build — sibling retro project
Sources
- Adafruit blog — microcontroller coverage
- Raspberry Pi 4 Model B — official product page
- Wikipedia — Intel 8080
— Mike Perry · Last verified 2026-06-22
