Interlisp is a family of programming languages and integrated development environments originally developed in the late 1960s at Bolt, Beranek and Newman (BBN) and later at Xerox PARC. It was one of the first languages to incorporate a fully interactive development system, featuring a powerful editor, debugging tools, and a unique “Do-What-I-Mean” (DWIM) error‑correction facility. Interlisp evolved from BBN Lisp and the later Interlisp‑D version ran on Xerox Lisp machines, influencing later environments such as Common Lisp and Smalltalk. Its design emphasized programmer productivity through a sophisticated, integrated toolset, making it a landmark in early interactive computing.

1 History

1.1 Origins at BBN (BBN Lisp, 1966–1972)

Interlisp’s roots lie in BBN Lisp, an implementation of Lisp 1.5 developed at Bolt, Beranek and Newman starting in 1966. BBN Lisp introduced an interactive interpreter and an early debugging system. By 1972, the language had been extended with a resident editor and a rudimentary error‑handling mechanism, laying the groundwork for the full Interlisp environment.

1.2 Interlisp-10 on PDP-10 (1972–1979)

In 1972, the system was ported to the DEC PDP‑10 running the TOPS‑10 operating system and renamed Interlisp‑10. This version added the first integrated structure editor (the “Tedit” editor) and a more advanced debugger. Interlisp‑10 became widely used in the ARPANET community, especially for artificial intelligence research.

1.3 Interlisp-D at Xerox PARC (1979–1985)

Xerox PARC adapted Interlisp to run on its own line of Xerox Lisp machines, calling the result Interlisp‑D. This version introduced a full graphical window system, bitmapped displays, and a mouse‑driven interface. Interlisp‑D was one of the first programming environments to offer a truly integrated graphical user interface.

1.3.1 The Lisp Machine version

Interlisp‑D was the primary operating environment for the Xerox 1100 series Lisp machines (the “D‑Machine”). It included a high‑resolution display, a dedicated mouse, and a microcoded Lisp interpreter that made interactive development very fast.

1.3.2 Integration with the Xerox Star workstation

Although the Xerox Star was primarily a business workstation, a version of Interlisp‑D could run as a guest on it. This integration allowed Lisp developers to access Star’s office applications and network services while using Interlisp’s unique development tools.

1.4 Later implementations and influence (1985–1990s)

After the commercial decline of the Xerox Lisp machines, Interlisp influenced the design of Common Lisp and several Lisp Machine environments. A portable implementation, known as “Portable Interlisp,” was created in the late 1980s. Throughout the 1990s, the system was maintained primarily by a small community of enthusiasts and used in legacy AI applications.

2 Core Features

2.1 Interactive development environment

Interlisp’s environment was designed to support a conversational style of programming. The programmer could evaluate expressions, edit functions, and debug code without leaving the main Lisp listener.

2.1.1 The Structure Editor (Masterscope)

Instead of editing raw text, Interlisp’s structure editor (called Masterscope) allowed users to browse and edit the internal representation of Lisp functions. Masterscope could display function definitions as trees and perform cross‑referencing, making large‑scale program maintenance easier.

2.1.2 The Debugger and breakpoints

The debugger provided breakpoints, single‑step execution, and a stack‑backtrace viewer. When an error occurred, the programmer could examine variable bindings and even edit the running code on the fly, then resume execution.

2.1.3 The Exec (command interpreter)

The Exec was a command‑line interface that accepted both Lisp expressions and special system commands. It featured command history, abbreviations, and the ability to invoke the editor or debugger via simple keystrokes.

2.2 DWIM (Do-What-I-Mean) system

DWIM was Interlisp’s most famous innovation. It attempted to correct common syntactic and typographical errors automatically, allowing the programmer to continue working with minimal interruption.

2.2.1 Automatic error correction

When the interpreter encountered an undefined function or variable, DWIM would search the current environment for a symbol with a similar name. If a unique match was found, the correction was applied transparently, and a note was printed.

2.2.2 Spelling correction and type inference

DWIM also corrected misspelled function names and variable names, and could infer the intended meaning of certain ambiguous expressions (e.g., treating a missing quotation mark as a string‑type hint). The system learned from user corrections over a session.

2.3 The Interlisp virtual machine and bytecode

Interlisp code was compiled into an intermediate bytecode for a virtual machine. This bytecode was then interpreted or further compiled to native code. The virtual machine provided a consistent interface across different hardware platforms, and the bytecode format allowed for incremental compilation and fast loading.

2.4 Object-oriented extensions (Lisp Object Oriented Programming System, LOOPS)

In the early 1980s, Xerox PARC developed LOOPS (Lisp Object Oriented Programming System) as an extension to Interlisp. LOOPS added classes, objects, methods, and inheritance, predating the widespread adoption of object‑oriented programming in Lisp. It influenced later systems like Common Lisp Object System (CLOS).

2.5 Graphics and window system (on Interlisp-D)

Interlisp‑D included a native window system based on the Xerox bitmapped display. Programmers could create windows, draw graphics, and handle mouse and keyboard events using a library of Lisp functions. The window system was fully integrated with the debugger, editor, and Exec, enabling graphical debugging tools.

3 Programming Language Syntax and Semantics

3.1 Data types (atoms, lists, numbers, strings)

Interlisp supported the standard Lisp data types: atoms (symbols), lists (represented as cons cells), integers, floating‑point numbers, and strings. It also had arrays and records. Special markers, such as “atomic symbols” with property lists, were used extensively for variable and function storage.

3.2 Function definition and lambda expressions

Functions were defined using the DEFINE special form, which accepted a lambda expression or a simplified function descriptor. Lambda expressions followed the traditional Lisp syntax: (LAMBDA (parameters) body). Functions could be compiled or interpreted.

3.3 Control structures (prog, cond, selectq)

Interlisp provided PROG for sequential execution with labels and go‑to statements, COND for conditional branching, and SELECTQ for multi‑way branching based on a key. It also supported DO‑style iteration and MAP‑type functions for list processing.

3.4 Input/output and file handling

I/O functions included PRIN1, PRINT, READ, and TERPRI. The file system was accessed through primitives like OPEN, CLOSE, INFILE, and OUTFILE. A “file package” managed multiple open streams and provided automatic file‑name resolution.

3.5 Interlisp’s unique macros (FEXPRs and NLAMBDA)

Unlike most Lisp dialects, Interlisp allowed the definition of special forms called FEXPRs (function expressions) that received their arguments unevaluated. NLAMBDA was a similar mechanism for macros with delayed evaluation. These features gave Interlisp a powerful, flexible macro system that could emulate control‑structure syntax.

4 Tools and Libraries

4.1 File package and version control

The Interlisp file package managed source files and their dependencies. It included a simple version‑control system that kept a history of changes per file. The package could automatically recompile dependencies when a file was changed.

4.2 Spell program and documentation tools

The Spell program was a spelling checker for comments and documentation strings. Interlisp also included tools to generate formatted documentation from specially marked comments, similar to modern doc‑string systems.

4.3 Notecards (hypertext system)

Notecards was a hypertext system built on top of Interlisp‑D. It allowed users to create, link, and browse notecards containing text, graphics, or Lisp code. Notecards was one of the first hypermedia systems and influenced later products like HyperCard.

4.4 Interlisp for Common Lisp (Portable Interlisp Project, “Medley”)

In the late 1980s, the Portable Interlisp Project (later called “Medley”) re‑implemented the Interlisp environment on top of Common Lisp. Medley preserved most of the original tools, including DWIM, Masterscope, and the window system, and could run on modern hardware through emulation.

5 Legacy and Impact

5.1 Influence on Common Lisp and Lisp Machine environments

Many features of Interlisp, such as the integrated environment, incremental compilation, and the DWIM concept, were adopted (often in simplified form) by later Common Lisp implementations and Lisp Machine operating systems. The structure editor concept also influenced Emacs’s paredit mode.

5.2 Contributions to integrated development environments (IDEs)

Interlisp pioneered the notion of a language‑centered IDE, where editing, debugging, and execution are seamlessly combined. This model directly influenced later IDEs such as Smalltalk‑80’s environment and Interlisp‑D’s graphical shell was a forerunner of modern visual programming tools.

5.3 Modern reimplementations (e.g., Medley Interlisp)

5.3.1 The Medley project (2018–present)

Since 2018, the Medley Interlisp project has revived the old Interlisp‑D environment, making it available on current operating systems via a virtual machine. The project has released open‑source versions that preserve the original bitmapped interface and toolset, allowing historical research and retro‑computing enthusiasts to experience the system.

5.3.2 Emulation and preservation efforts

Several archives, including the Computer History Museum and university libraries, have preserved Interlisp source code and documentation. Emulators for the Xerox Lisp machines (such as the “NedoPC” emulator) run the original Interlisp‑D binaries, ensuring the system remains accessible for study.

6.1 Lisp family tree

Interlisp belongs to the broad Lisp family, descending from BBN Lisp and contemporary with Maclisp and early Scheme. It later influenced the development of Common Lisp and the Lisp Machine dialects (ZetaLisp, Symbolics Lisp). Its branch is sometimes called the “Interlisp dialect.”

6.2 Comparison with Maclisp and Scheme

Compared to Maclisp, Interlisp placed stronger emphasis on programmer‑aiding tools and a uniform namespace (no separate function‑value cell). Unlike Scheme, Interlisp used dynamic scoping (until the late versions added lexical scope options) and lacked first‑class continuations. Interlisp’s DWIM system was unique among major Lisp dialects.

6.3 Notable users and applications

Interlisp was used at Xerox PARC for experiments in office automation, hypertext (Notecards), and early expert systems. Other users included MIT’s Artificial Intelligence Laboratory, Stanford’s AI Lab, and several ARPANET research sites. Well‑known applications include the “Amber” common‑sense reasoning system and the “PARRY” chatbot simulation.