01 — MICROTHE FAST ONE
60 M/s
about 9x the machine
What each microcycle does, and nothing about when. The quickest way to boot the system and use it.
--microMUIR-SIM · QUUX AND CADR, SIMULATED IN SOFTWARE
QUUX and CADR,
simulated.
QUUX is the CADR evolved; the CADR is MIT’s Lisp Machine of 1978, simulated from its schematics.
muir-sim simulates both on your own computer, as two machines: quux for QUUX, and cadr for MIT’s machine as built, from MIT’s schematics of its boards.
RUST / NO CRATE DEPENDENCIES / AGPL-3.0-OR-LATER
FIG. 01 — SYSTEM 100, BOOTEDMIT / CADR
MIT · ARTIFICIAL INTELLIGENCE LABORATORY
cadr / 1978
The machine’s screen, keyboard and mouse reach you over RFB, so any VNC viewer is its terminal.
An artistic impression, not the CADR itself.↗
3ENGINES: MICRO, RTL, CHIP
2MACHINES: CADR AND QUUX
0CRATE DEPENDENCIES
01 / WHAT IT IS
The machines,
in software.
muir-sim runs the CADR’s software by simulating its hardware, not by reimplementing Lisp, and boots the last release of the Lisp Machine software MIT made, restored from tapes the MIT Tapes of Tech Square project recovered. QUUX, beside it, runs muir-sys’s updated system. muir-sim is written in Rust and has no crate dependencies.
What the two machines are, their processors, buses and boards, is on their own pages: the CADR and QUUX. How muir-sim runs each, and what it does for one machine alone, is on CADR in muir-sim and QUUX in muir-sim.
02 / WHAT MUIR-SIM DOES
Three engines.
One machine, three depths.
muir-sim has no Lisp of its own. It simulates the CADR from MIT’s own schematics of its boards, and MIT’s software runs on it unchanged: the microcode, the Lisp system, and MIT’s debugger for the machine. QUUX runs muir-sys’s microcode and system.
The CADR’s processor carries out each instruction as a series of small steps, written in microcode; one step is a microcycle, and the real machine did about 6.9 million of them a second. muir-sim simulates it at three levels of detail, and all three agree at the end of every microcycle, so the fast ones can be checked against the slow one. QUUX runs on micro and rtl; chip is the CADR’s alone.
02 — RTLTHE EVERYDAY ONE
16 M/s
about 2x the machine, flat out
What each microcycle does and when: waits on the buses, timeouts, the debug cable. It could run twice the machine’s speed, but by default it is held to the machine’s own, so the machine’s clock keeps the day’s time; --no-pace lets it run flat out.
--rtl03 — CHIPEVERY CHIP
1,400/s
about 1/5,000 of the machine
MIT’s schematics of every board, simulated part by part and wire by wire. Far too slow to use, and the reference the other two are checked against.
--chipThe worst case, with everything fitted: the color TV on every engine, and on chip MIT’s disk controller with its multiplexor as well, every board a netlist. Rates are flat out, with no pacing, from cargo run --release --example benchmark -- --everything on one core of an Apple M4, rounded down; without the second display board chip runs about 2,000/s and the other two the same.
03 / BUILD AND BOOT
Build it,
then boot a machine.
No binaries are distributed; you build it yourself. A fresh clone needs nothing else — there are no crate dependencies.
Install rustup first and open a new shell so cargo is on the path; the compiler version is pinned in the repository.
01
The Rust toolchain.
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | shInstall rustup, then open a new shell so cargo is on the path.
02
Clone and build.
git clone https://github.com/metebalci/muir-sim
cd muir-sim
cargo build --releaseThat builds quux, cadr and the pack tool diskpack. cargo test beside it is optional, and a fresh clone passes with nothing fetched.
03
Boot a machine.
Each machine fetches its own system and runs from its own page: the CADR, on MIT’s System 100 or muir-sys’s Systems 1xxx, and QUUX, on muir-sys’s Systems 2xxx.
04 / ABOUT
MIT’s machine, and
what muir-sim adds.
The CADR, the schematics, the wire lists, the microcode and the diagnostics are MIT’s, recovered by other people’s work over decades; the manual lists every source and what each contributed. muir-sim is this project’s: the simulator of the CADR at three levels of detail, and QUUX, the CADR evolved, beside it.
muir-sim is written with Claude Code, using Anthropic’s Claude Opus and Claude Fable. It is written in Rust and has no crate dependencies.
© 2026 Mete Balci. muir-sim is AGPL-3.0-or-later. MIT’s own schematics and wire lists are committed unmodified in mit/.