# Lisp machine
A Lisp machine is a general-purpose computer whose processor, instruction set, and operating system were designed specifically to run the [Lisp](https://www.edgepedia.org/lisp-programming-language) [programming language](https://www.edgepedia.org/programming-language) efficiently, typically as a single-user workstation with a tagged architecture, hardware-supported garbage collection, and a graphical user interface. Two largely independent lines of such machines emerged in the 1970s: one at MIT that led to the commercial [Symbolics](https://www.edgepedia.org/symbolics) and Lisp Machines, Inc. (LMI) systems, and one at Xerox PARC, where the Interlisp-D environment ran on the D-machines.[1](https://dspace.mit.edu/entities/publication/90b5d708-79c5-470c-b42e-596f7ae32485) • [2](https://interlisp.org/history/)
| Key fact | Detail |
|---|---|
| First "Lisp machine" | AltoLisp (Peter Deutsch, 1973) introduced a specialized, microcoded instruction set modeling Lisp's basic operations more closely than a general-purpose instruction set could[3](https://xeroxparcarchive.computerhistory.org/erinyes/lispmanual/.ChapAck.im%214.html) |
| MIT CADR | A general-purpose, 32-bit microprogrammable processor, revised from the CONS machine; described in MIT AI Memo AIM-528, issued May 1, 1979 by Thomas F. Knight Jr., David A. Moon, Jack Holloway, and Guy L. Steele Jr.[1](https://dspace.mit.edu/entities/publication/90b5d708-79c5-470c-b42e-596f7ae32485) |
| Tagged architecture | In the original 32-bit Symbolics design, 4 bits of every data chunk indicated the type of the data in the other 28 bits, giving run-time type checking without declarations[4](https://ocw.mit.edu/courses/6-933j-the-structure-of-engineering-revolutions-fall-2001/30eb0d06f5903c7a4256d397a92f6628_Symbolics.pdf) |
| Xerox D-machines | Dorado, Dolphin, Dandelion, and Daybreak workstations ran Interlisp-D, which supplied the GUI and the entire operating system over a common byte-code virtual machine[2](https://interlisp.org/history/) |
| Commercial hardware | The LMI Lambda (introduced 1986) was based on the CADR design of Richard Greenblatt and Thomas Knight[5](https://www.computerhistory.org/revolution/artificial-intelligence-robotics/13/290/1252) |
| Measured speedup | Message passing took about 3.5 microseconds on a Symbolics 3600 versus 1000 microseconds on a traditional architecture, according to Russell Noftsker[4](https://ocw.mit.edu/courses/6-933j-the-structure-of-engineering-revolutions-fall-2001/30eb0d06f5903c7a4256d397a92f6628_Symbolics.pdf) |
| Recognition | The 1992 ACM Software System Award went to the Interlisp team for pioneering work in programming environments[6](https://interlisp.org/history/timeline/) |
## Why dedicated Lisp hardware
Lisp was the preferred language for artificial intelligence research, but it ran slowly on the expensive conventional computers of the era, and time-shared machines such as the [PDP-10](https://www.edgepedia.org/pdp-10) offered little support for garbage collection or object-oriented procedure calls. The machines were also bulky and noisy, which made a PDP-10, in the words attributed to Knight and Greenblatt, "an unwelcome office mate."[4](https://ocw.mit.edu/courses/6-933j-the-structure-of-engineering-revolutions-fall-2001/30eb0d06f5903c7a4256d397a92f6628_Symbolics.pdf)
The design response, documented in the Symbolics Technical Overview, combined fast Lisp execution, a dedicated personal computer and console, a tagged architecture with run-time data-type checking and generic instructions, virtual memory, an integrated local area network, and interactive high-resolution bit-mapped graphics. Conspicuously absent was time-sharing: Knight and Greenblatt did not believe in building one.[4](https://ocw.mit.edu/courses/6-933j-the-structure-of-engineering-revolutions-fall-2001/30eb0d06f5903c7a4256d397a92f6628_Symbolics.pdf)
## The MIT line: CONS, CADR, Symbolics, and LMI
**CADR.** The CADR machine, a revised version of the earlier CONS machine, is described in AIM-528 as a general-purpose, 32-bit microprogrammable processor and the basis of the Lisp-machine system developed at MIT as a high-performance, economical implementation of Lisp.[1](https://dspace.mit.edu/entities/publication/90b5d708-79c5-470c-b42e-596f7ae32485) Richard Greenblatt and Thomas Knight are shown with the CADR at MIT in the [Computer History Museum](https://www.edgepedia.org/computer-history-museum)'s record of the project.[7](https://www.computerhistory.org/chess/stl-431614f64ea3e/)
LMI, the other spin-off, introduced the Lambda in 1986, a specialized Lisp computer described as both faster and cheaper than conventional machines and based on the CADR design.[5](https://www.computerhistory.org/revolution/artificial-intelligence-robotics/13/290/1252)
**Hardware techniques.** The Lisp processor's core instruction set was augmented by a microcoding capability that let macros for commonly used Lisp functions run from a cache-like structure on the processor, so that the core instructions and microcoded functions together effectively implemented Lisp in hardware. David A. Moon's ephemeral-object garbage collector exploited instruction-set support written specifically for a garbage collector; according to Russell Noftsker, it ran so efficiently that the system ran faster with garbage collection than without.[4](https://ocw.mit.edu/courses/6-933j-the-structure-of-engineering-revolutions-fall-2001/30eb0d06f5903c7a4256d397a92f6628_Symbolics.pdf)
The tagged architecture was the defining feature. Because Lisp does not have strong typecasting in the manner of C, Fortran, or COBOL, a pointer can point to data of any type, so the machines dedicated bits of each word to the data type. In the original 32-bit architecture, 4 bits of every data chunk indicated the type of the other 28 bits, eliminating type declarations and catching bugs at run time. Error-correcting codes on memory and disks, costing 4 or 8 extra bits per 32, 36, or 40 bit word depending on the machine generation, detected and fixed corruption at run time.[4](https://ocw.mit.edu/courses/6-933j-the-structure-of-engineering-revolutions-fall-2001/30eb0d06f5903c7a4256d397a92f6628_Symbolics.pdf)
On the software side, the entire operating system was written in Lisp, the garbage collector was built into the system, and the Symbolics dialect offered the Flavor system for object-oriented programming with message passing, incremental debugging, and multiple namespaces.
## The Xerox line: Interlisp and the D-machines
The Xerox lineage grew out of Interlisp, a software development environment that began with an implementation of Lisp for the PDP-1 at Bolt, Beranek and Newman in 1966, gained the DWIM ("Do What I Mean") error-correction facility in 1968 from Warren Teitelman, and was renamed Interlisp in 1972 when its development became a joint effort of Xerox PARC and BBN after Danny Bobrow and Teitelman moved to PARC.[3](https://xeroxparcarchive.computerhistory.org/erinyes/lispmanual/.ChapAck.im%214.html) • [6](https://interlisp.org/history/timeline/)
Microcode was the path to personal Lisp. AltoLisp, Peter Deutsch's 1973 implementation for the [Xerox Alto](https://www.edgepedia.org/xerox-alto), introduced a specialized, microcoded instruction set that modeled Lisp's basic operations more closely than a general-purpose instruction set could, and is described in the Interlisp-D manual as the first true "Lisp machine." AltoLisp in turn served as the departure point for Interlisp-D, the implementation for the Xerox 1100 Series of personal computers begun in 1979.[3](https://xeroxparcarchive.computerhistory.org/erinyes/lispmanual/.ChapAck.im%214.html) A 1976 specification of the Interlisp virtual machine defined a small kernel of primitive operations whose implementation would suffice to port the whole system, which the manual calls a watershed in enabling subsequent implementations.[3](https://xeroxparcarchive.computerhistory.org/erinyes/lispmanual/.ChapAck.im%214.html)
Interlisp-D provided the GUI and the entire operating system for the Xerox Lisp machines, called D-machines after their names Dorado, Dolphin, Dandelion, and Daybreak, all sharing a common byte-code virtual machine. The machines were not primarily designed for Lisp, and each software environment at PARC, including [Smalltalk](https://www.edgepedia.org/smalltalk) and Cedar/Mesa, had its own microcode implementing its instruction set; once loaded, the software took over the machine with no separate operating system underneath.[2](https://interlisp.org/history/) Sold through the Xerox Office Systems Division, the Dandelion became the Xerox 1108 (also marketed as the Xerox 8010) and the Daybreak the Xerox 1186 (also the Xerox 6085).[2](https://interlisp.org/history/)
Named releases followed through the 1980s: Chorus and Fugue in 1983, Harmony and Intermezzo in 1985, Koto in 1985 for the Xerox 1186 with some [Common Lisp](https://www.edgepedia.org/common-lisp) features, Lyric in 1987, and Medley 1.0 in 1988, which ran on Suns under SunOS as well as [IRIX](https://www.edgepedia.org/irix), AIX, HPUX, and Ultrix. Development moved from Xerox PARC to the Xerox AI Systems division, to the spin-out company Envos (formed in 1989 and closed that April), and then to a smaller company called Venue.[6](https://interlisp.org/history/timeline/) • [2](https://interlisp.org/history/) In time, the virtual machine was rewritten in C to run under Sun Unix as well as numerous other Unix platforms, and Common Lisp support was added to the system.[2](https://interlisp.org/history/)
## Programming environment
The Lisp machines' lasting contribution to software practice was the integrated environment. The Interlisp system combined structure editing, source code management, code analysis, and cross-referencing to support rapid incremental development; its Masterscope tool analyzed a large program and built a queryable database of relationships among components, answerable through a natural-language front end.[2](https://interlisp.org/history/) • [6](https://interlisp.org/history/timeline/) The 1992 ACM Software System Award citation credited the Interlisp team with pioneering programming environments that integrated source-language debuggers, a fully compatible integrated interpreter and compiler, automatic change management, structure-based editing, logging facilities, interactive graphics, and analysis and profiling tools.[6](https://interlisp.org/history/timeline/)
The Medley system, the final form of this environment, includes a debugger, a list structure editor, a file package, a compiler, and text-editing facilities, with three executives: Common Lisp, Xerox Common Lisp, and Interlisp. Its interactive window-based debugger appears automatically on an error, and the break window is a full executive window in which the user can inspect state, change data structures, evaluate expressions, and redefine functions.[6](https://interlisp.org/history/timeline/)
## Decline and afterlife
Lisp machines were built for a market of AI researchers on time-shared or expensive conventional hardware, and their fortunes followed AI funding. The Medley Interlisp project notes that Interlisp-D was distributed commercially by Xerox until its development tapered off in the 1990s.[2](https://interlisp.org/history/) For non-Lisp programs such as Fortran, a Symbolics machine offered no significant performance advantage, which limited the machines to their niche even at their peak.[4](https://ocw.mit.edu/courses/6-933j-the-structure-of-engineering-revolutions-fall-2001/30eb0d06f5903c7a4256d397a92f6628_Symbolics.pdf)
The hardware survives as museum material and restoration projects. The Medley Interlisp project continues to restore and distribute the software environment, whose ideas, such as the ADVISE/advice construct, carried into later [aspect-oriented programming](https://www.edgepedia.org/aspect-oriented-programming) frameworks including Aspect/J and Spring.[6](https://interlisp.org/history/timeline/)
## References
1. [The CADR machine, AIM-528, MIT DSpace (Knight, Moon, Holloway, Steele, May 1, 1979)](https://dspace.mit.edu/entities/publication/90b5d708-79c5-470c-b42e-596f7ae32485)
2. [History, The Medley Interlisp Project](https://interlisp.org/history/)
3. [A Brief History of Interlisp, Interlisp-D manual chapter, Xerox PARC archive](https://xeroxparcarchive.computerhistory.org/erinyes/lispmanual/.ChapAck.im%214.html)
4. [Symbolics case study, MIT 6.933J The Structure of Engineering Revolutions (Fall 2001)](https://ocw.mit.edu/courses/6-933j-the-structure-of-engineering-revolutions-fall-2001/30eb0d06f5903c7a4256d397a92f6628_Symbolics.pdf)
5. [LMI Lambda, Computer History Museum Revolution exhibition](https://www.computerhistory.org/revolution/artificial-intelligence-robotics/13/290/1252)
6. [Interlisp Timeline, The Medley Interlisp Project](https://interlisp.org/history/timeline/)
7. [Richard Greenblatt and Thomas Knight with the CADR LISP Machine at MIT, Computer History Museum](https://www.computerhistory.org/chess/stl-431614f64ea3e/)
8. [You can now view the Computer History Museum's collection from home, PC Gamer](https://www.pcgamer.com/hardware/you-can-now-view-the-computer-history-museums-collection-from-the-comfort-of-your-own-home-and-its-full-of-retro-blasts-from-the-past/)
---
*Topic: Encyclopedia › Technology and the built world › Computing and digital systems › Computer hardware › Personal computers & laptops*
*Initially written Sep 17, 2026 · Reviewed: Oct 15, 2026 · Edited: Oct 15, 2026; Oct 25, 2026 · Last review: Oct 15, 2026*
*Copyright 2026 EdgeChat AI, a subsidiary of Biostate AI.*
License: Edgepedia Community License 1.0, https://www.edgepedia.org/edgepedia/license