A project about MIT’s CADR Lisp Machine, with three aims.
Simulate the CADR accurately: in software (muir-sim’s cadr) and in hardware (muir-fpga’s CADR), from MIT’s schematics and sources, running MIT’s system and muir-sys’s 1xxx releases for the CADR.
Evolve it into QUUX, a modern design, again in software (muir-sim’s quux) and in hardware (muir-fpga’s QUUX), running the updated system (muir-sys’s 2xxx releases for QUUX).
Build it with AI: the Rust, the SystemVerilog, the Lisp changes and the FPGA work are written by Claude, through Claude Code; MIT’s own sources stay MIT’s.
01 / THE TWO MACHINES
Two purposes, on one base.
QUUX is where the changes are made.
The original, down to its chips.
MIT’s machine as it was built. Its simulation follows the original board schematics and runs the historical microcode and Lisp software. QUUX starts from it.
The CADR’s design, taken further.
QUUX starts from the CADR and its way of running Lisp, and changes the processor, its memory and its devices wherever a change pays for itself.
| Feature | CADR | QUUX |
|---|---|---|
| The word | 32 bits | 40 bits |
| Execution | 145 ns microcycles, delay lines | A four-stage pipeline |
| Main memory | Memory boards on the Xbus | The memory bus, on the processor’s own port |
| Memory cache | None | 4K to 64K words, by board |
| Address translation | A two-level map, 31 regions mapped at once | A page table behind a TLB |
| PDL buffer | 1K words | 16K words |
| Multiply and divide | 32 steps each | One instruction each |
| Clocks and interval timers | Microsecond clock and one interval timer on the I/O board | Microsecond clock in the processor, three interval timers |
| Real-time clock | None | Unix seconds in one word |
| Display | TV board, 768 by 963 | Video controller, up to 1920 by 1080 |
| Disk | Disk controller, by cylinder, head and sector | Block-disk, by block number |
| Disk file | MIT’s pack and label | A raw image or a VHD, with a GPT |
| Buses | Xbus and Unibus, with a bus interface and an I/O board | None: the register page |
| File access | Over the Chaosnet, from a file server | The file device |
| Network | Chaosnet | Ethernet, with ARP, IPv4, ICMP and TCP |
| Debugging | Console registers on the Unibus, and a debug cable between machines | The host’s port alone |
| Microcode | MIT’s 323 | muir-sys’s 2xxx |
| Lisp system | MIT’s System 100 | muir-sys’s Systems 2xxx |
| Garbage collector | MIT’s incremental copying collector | A generational collector |
02 / ONE REPOSITORY EACH
CADR and QUUX, simulated.
MIT’s CADR simulated from MIT’s own schematics of its boards, at three levels of detail down to every chip, booting MIT’s released system; and QUUX beside it. Two machines: cadr and quux.
The CADR finds its files on ozd.
The simulatorThe machines in the fabric of FPGA boards.
muir-sim’s RTL model of the CADR and of QUUX in the fabric of small FPGA boards, held to muir-sim tick for tick.
A CADR board finds its files on ozd.
The boardsThe Lisp Machine system.
The system that runs on both machines, continuing where MIT’s released system left off, with releases for both: the updated system for QUUX, and the CADR’s own.
The system03 / MIT, AROUND 1978
A workstation for one person, written in Lisp.
The CADR, MIT’s Lisp Machine, became the foundation for the first Lisp Machines sold by LMI and Symbolics. LMI’s Lambda ran the CADR’s software, its microcode assembled from the same sources, and Texas Instruments’ Explorer was made from the Lambda’s design. muir-sim simulates the CADR, running MIT’s last release of its system, restored from recovered tapes; muir-fpga puts it in the fabric of an FPGA.
Inside the CADR04 / LMI, 1979 TO 1986
Lisp Machine, Inc. was founded in 1979 by Richard Greenblatt of MIT’s AI Lab, with Stephen Wyle, to build Lisp Machines on its customers’ money: they paid for their machines in advance.
MIT’s machine, built as MIT built it.
LMI’s first machines were the CADR itself, the same logical and physical design as MIT’s; Greenblatt recalls about thirty-five of them.
The CADR’s successor, on the NuBus.
The Lambda, described in 1982, put its processor on four boards on the NuBus, a bus also from MIT, and ran the CADR’s software; its microcode was assembled from the CADR’s own sources. Two processors could share one box. Its word is 32 bits, as the CADR’s; a 40-bit version was planned.
A new design, never sold.
Not descended from MIT’s machines: 32-bit objects, a 6-bit tag over a 26-bit pointer, 64-bit instructions and a four-stage pipeline. It ran its first instructions on 31 December 1986; LMI’s money ran out before it reached the market.
05 / SYMBOLICS, 1983 AND 1987
Symbolics was founded by staff of MIT’s AI Lab to make Lisp Machines. Its first machine, the LM-2 (1981), was the CADR’s design repackaged.
Symbolics’ own design.
The 3600 was a new design, inspired by the CADR but sharing few of its implementation details. Its word is 36 bits.
The processor on one chip.
The Ivory, described in 1987, put the processor on a single chip. Its word is 40 bits: a 2-bit cdr code, a 6-bit type and a 32-bit field.
06 / ABOUT
The CADR, its schematics, wire lists, microcode and system are MIT’s, recovered by other people’s work over decades; muir-sim’s manual lists every source and what each contributed. This project made muir-sim, the simulator of the CADR and its three engines; muir-fpga, which puts the CADR and QUUX in the fabric of FPGA boards; QUUX, the CADR evolved, and muir-sys’s updated system for it; and ozd, the CADR’s associated machine.
The projects are written with Claude Code, on Anthropic’s models; each project’s own page says how it was made. The site is written using OpenAI’s and Anthropic’s models.
Muir is named for Nathan Muir, the character Robert Redford plays in Spy Game (2001). In memory of Robert Redford.
© 2026 Mete Balci. Every project, and this site, is AGPL-3.0-or-later; the site’s fonts, IBM Plex Mono and Gelasio, are under the SIL Open Font License 1.1: IBM Plex Mono’s and Gelasio’s licence texts.