Lisp
Last reviewed
Apr 28, 2026
Sources
37 citations
Review status
Source-backed
Revision
v1 ยท 4,273 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
Apr 28, 2026
Sources
37 citations
Review status
Source-backed
Revision
v1 ยท 4,273 words
Add missing citations, update stale details, or suggest a clearer explanation.
Lisp (historically LISP, an acronym for "LISt Processor") is a family of programming languages with a distinctive parenthesized prefix-notation syntax based on s-expressions. Lisp was specified in 1958 by John McCarthy at the Massachusetts Institute of Technology, making it the second-oldest high-level programming language still in widespread use, after Fortran, which preceded it by about a year.[1][2]
Lisp pioneered or popularized many ideas that later became standard: conditional expressions, recursion as a primary control structure, dynamic typing, automatic garbage collection, higher-order functions, tree data structures, and the read-eval-print loop. The language was the dominant tool of artificial intelligence research from the early 1960s through the late 1980s, when symbolic AI projects from natural language understanding to expert systems were almost universally written in some Lisp dialect.[3][4]
Lisp is a family. The two most influential modern dialects are Common Lisp, the large multi-paradigm dialect codified by ANSI in 1994, and Scheme, the minimalist lexically-scoped dialect designed at MIT in 1975. The most widely used 21st century descendant is Clojure, a JVM-targeting dialect first released in 2007. Other living dialects include Emacs Lisp, AutoLISP, Racket, and ClojureScript.[5]
Lisp's roots reach into 1950s work on symbolic computation and the lambda calculus of Alonzo Church. John McCarthy, then an assistant professor of mathematics at MIT, attended the 1956 Dartmouth Conference at which the phrase "artificial intelligence" was coined. He came away convinced that AI research would need a programming language for non-numerical, list-structured data, rather than the numeric arrays of Fortran.[1][6]
McCarthy's memo "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I," in the April 1960 Communications of the ACM, gave the language its theoretical core. The paper described eval, a universal evaluator, in terms of a tiny set of primitive operators: atom, eq, car, cdr, cons, cond, quote, and lambda.[2]
McCarthy intended eval only as mathematics. The breakthrough came from his student Steve Russell, who realized in late 1958 that eval could itself be hand-translated into machine code for the IBM 704 and used as an interpreter. Russell's hand-compiled eval was the first Lisp implementation.[1][6]
The IBM 704 left a permanent mark on Lisp vocabulary. The 704's address word was divided into halves called the address part and the decrement part, and two machine instructions extracted these fields: "Contents of Address Register" and "Contents of Decrement Register." Lisp's primitive operators for taking the head and tail of a pair were named after these instructions, giving programmers car and cdr for the next sixty years.[1]
Lisp 1.5, the first widely distributed Lisp, was released in 1962 along with the Lisp 1.5 Programmer's Manual by McCarthy, Abrahams, Edwards, Hart, and Levin. The manual contained the first published description of a complete Lisp implementation, including a metacircular evaluator.[7]
Lisp 1.5 was followed by a proliferation of dialects. The two early lines that mattered most were MacLisp, developed at the MIT AI Laboratory starting in 1966 for the Project MAC PDP-6 and PDP-10 systems, and Interlisp, which emerged from BBN-Lisp around 1967 and was later developed at Xerox PARC into Interlisp-D.[3][5]
Through the 1970s the dialect tree branched further. Stanford and Carnegie Mellon used variants of MacLisp. Lisp Machine Lisp, and its successor Zetalisp, grew up around the dedicated Lisp computers built at MIT and at the spinoff companies Symbolics and Lisp Machines, Inc. Scheme, invented in 1975 by Gerald Sussman and Guy Steele at MIT, took a different path: a small, lexically-scoped dialect.[8][9]
Beginning in 1981 a working group led by Steele began the multi-year effort that produced Common Lisp, a union dialect that absorbed features of MacLisp, Lisp Machine Lisp, and the academic dialects. Common Lisp the Language (CLtL1) appeared in 1984, the second edition (CLtL2) in 1990, and the ANSI standard X3.226-1994 in 1994.[5][10][11]
A parallel cultural fork happened around editors. Richard Stallman, at the MIT AI Lab in the 1970s, ported the original TECO-based Emacs to Lisp Machine Lisp and then, in 1985, released GNU Emacs, embedding Emacs Lisp as the editor's extension language.[12]
Many features that programmers now take for granted appeared first in Lisp. Lisp 1.5 in 1962 already had most of them.[2][7]
S-expressions and homoiconicity. Lisp programs and Lisp data are represented by the same recursive tree structure, the s-expression. A list like (+ 1 2) is simultaneously code that adds two numbers and a three-element list whose first element is the symbol +. This property, called homoiconicity, is the foundation of Lisp's macro system.[1][13]
Conditional expressions. McCarthy introduced cond in his 1960 paper. Earlier languages such as Fortran had only IF statements that jumped to a label. Lisp's cond was an expression whose value was the value of the first branch whose test succeeded. The modern if expression descends from this construct.[2]
Recursion. Lisp was the first widely used language to treat recursion as the natural way to express computation.[2]
Garbage collection. McCarthy's group implemented automatic garbage collection in Lisp 1.5 to manage the cons cells that proliferate during list processing, the first widely-used automatic memory management in a programming language.[1][14]
First-class and higher-order functions. Functions can be passed as arguments, returned from other functions, and stored in data structures. The lambda expression, borrowed from Church's lambda calculus, gave programmers anonymous functions. Higher-order functions such as mapcar were standard idioms by the early 1960s.[1][2]
Macros. Because programs are data, programs can be written that take programs as input and return new programs. Lisp macros are run at compile time and produce code, an unusually powerful form of metaprogramming.[5][13]
Read-eval-print loop. The interactive REPL, in which the user types an expression and the system reads, evaluates, and prints it, was a defining feature of Lisp from Lisp 1.5 onward.[1][6]
Dynamic typing. Lisp values carry their type at runtime, so the same variable can hold a number, a string, or a function. Dynamic typing was unusual in compiled languages of the 1960s and is now standard in scripting languages.[1]
Symbolic computing. Numbers, strings, and lists in Lisp share the runtime with first-class symbols, atomic objects identified by name. Symbols make it natural to write programs that reason about formulas and rules, which is why Lisp was attractive for early symbolic AI work.[2][7]
Lisp's syntax is austere. Every program is built from atoms (symbols and literals) and lists, written as a sequence of elements between parentheses. A function call is a list whose first element is the operator and whose remaining elements are the arguments. There are no infix operators, no precedence rules, and no statement separators.[1][2]
A recursive factorial in Common Lisp:
(defun factorial (n)
(if (= n 0)
1
(* n (factorial (- n 1)))))
The defun form binds the symbol factorial to a function of one parameter n. The body is a single if expression: when n is zero the value is 1, otherwise the function multiplies n by (factorial (- n 1)). The same program in Scheme replaces defun with define.[10][8]
"Hello, World" in Common Lisp:
(format t "Hello, World!~%")
The sea of parentheses is the most-commented feature of the syntax. Critics joked that LISP stood for "Lots of Irritating Spurious Parentheses." Practitioners argue the uniform structure pays back the visual cost: editors can manipulate code at the level of expressions, and the same parser that reads data also reads programs, which is what makes macros practical.[13]
| Dialect | Released | Origin | Notes |
|---|---|---|---|
| Lisp 1.5 | 1962 | MIT (McCarthy et al.) | First widely distributed Lisp; IBM 704/7090. |
| MacLisp | 1966 | MIT AI Lab | Dominant academic Lisp on PDP-10 in the 1970s. |
| Interlisp | 1967 | BBN, later Xerox PARC | Interlisp-D on Xerox Lisp Machines. |
| Scheme | 1975 | MIT (Sussman, Steele) | Minimalist, lexically scoped, tail-call optimized. |
| Lisp Machine Lisp | 1976 | MIT AI Lab | Lisp for the MIT CADR Lisp machine. |
| Zetalisp | late 1970s | Symbolics, LMI | Successor to Lisp Machine Lisp; basis for CLOS. |
| Franz Lisp | 1978 | UC Berkeley | MacLisp-style Lisp for Unix on VAX. |
| Common Lisp | 1984 | Steele et al. | ANSI X3.226-1994 in 1994. |
| Emacs Lisp | 1985 | GNU (Stallman) | Extension language for GNU Emacs. |
| AutoLISP | 1986 | Autodesk | Scripting language for AutoCAD. |
| Picolisp | 1988 | Software Lab Burger | Tiny Lisp for application programming. |
| Newlisp | 1991 | Lutz Mueller | Scripting Lisp with shallow dynamic scope. |
| Racket (PLT Scheme) | 1995 | PLT, Northeastern University | Renamed Racket in 2010. |
| Scheme R5RS | 1998 | Scheme community | Long-standing reference standard. |
| Clojure | 2007 | Rich Hickey | JVM-hosted; immutable persistent data structures. |
| ClojureScript | 2011 | Hickey, David Nolen | Clojure compiled to JavaScript. |
| Hy | 2013 | Paul Tagliamonte | Compiled to Python AST. |
| Fennel | 2016 | Phil Hagelberg | Compiles to Lua. |
| Janet | 2017 | Calvin Rose | Embeddable functional and imperative Lisp. |
The table lists only landmarks. The combined Lisp family includes hundreds of named dialects, especially before the Common Lisp consolidation.[5][11]
Common Lisp is the largest member of the Lisp family among professional programmers outside Clojure and Scheme. It was designed by a committee in the early 1980s to unify the MacLisp-descended dialects of MIT, Carnegie Mellon, and the Lisp machine vendors. Common Lisp the Language (CLtL1) by Guy Steele was published in 1984, the second edition (CLtL2) in 1990, and the ANSI standard X3.226-1994 (now INCITS 226-1994) in 1994.[10][11][15]
Common Lisp is multi-paradigm, with first-class support for functional, imperative, and object-oriented styles. It includes a full numeric tower of integers, ratios, floats, and complex numbers, with arbitrary-precision integer arithmetic in the standard. It defines a condition system more flexible than ordinary exception handling, letting the handler choose among several restarts that the signaling code provides.[10]
The object system CLOS (Common Lisp Object System) supports multiple inheritance, multimethods that dispatch on the runtime type of every argument, before-after-around method combination, and a metaobject protocol. CLOS was incorporated into the standard during the CLtL2 work and influenced object systems in Dylan and Julia.[10][11]
Major implementations include:
| Implementation | Type | Notes |
|---|---|---|
| SBCL (Steel Bank Common Lisp) | Free | Native code compiler; descended from CMU CL. |
| CCL (Clozure CL) | Free | Native compiler for x86-64 and Apple Silicon. |
| CLISP | Free | Bytecode interpreter; once the standard GNU implementation. |
| ECL (Embeddable Common Lisp) | Free | Compiles via C; designed for embedding. |
| ABCL (Armed Bear Common Lisp) | Free | Common Lisp on the JVM. |
| Allegro CL | Commercial | Franz Inc.; long history in industrial AI deployments. |
| LispWorks | Commercial | LispWorks Ltd.; cross-platform IDE. |
SBCL is the de facto reference implementation in 2020s open-source work, producing native machine code with performance on numeric kernels competitive with C compiled by GCC.[15]
Scheme was created in 1975 by Gerald Sussman and Guy Steele at MIT, originally as part of an exploration of actor model ideas. The first description appeared in MIT AI Memo 349, Scheme: An Interpreter for Extended Lambda Calculus. The lasting innovation was lexical scope. Earlier Lisps were dynamically scoped; Scheme used the static, lexical binding rules familiar from Algol, which made closures and higher-order functions much easier to reason about.[8][16]
Scheme is small. The language standard for many years could be printed in fewer than fifty pages, in deliberate contrast to the thousand-plus pages of Common Lisp the Language. The standard mandates tail-call optimization: a tail call must not consume additional stack, which lets programmers express loops as recursion without losing efficiency.[8][17]
The Scheme community has standardized the language through a series of "Reports on the Algorithmic Language Scheme." R3RS (1986) defined the basic language; R4RS (1991) refined macros and numeric tower; R5RS (1998) became the long-running de facto standard at about 50 pages; R6RS (2007) was larger and more prescriptive but was partially rejected by the community; R7RS-small (2013) returned to minimalism and is widely supported.
Major implementations include MIT/GNU Scheme, Chez Scheme (now open source), Chicken, Gambit, Guile, and Racket, which began as PLT Scheme in 1995 and is the most mature Scheme-influenced platform with its own language tower and module system.[18]
Scheme's most visible cultural artifact is the textbook Structure and Interpretation of Computer Programs by Hal Abelson and Gerald Sussman with Julie Sussman, published in 1985. SICP was the introductory programming textbook used in MIT's 6.001 course for two decades.[19]
Clojure is a Lisp dialect created by Rich Hickey and first released in October 2007. Hickey's goal was to bring Lisp to the Java Virtual Machine and the broader ecosystem of mainstream programmers, while updating the language for concurrent, multi-core hardware.[20]
The central design decision is the embrace of immutable, persistent data structures. Clojure's lists, vectors, maps, and sets are implemented as variants of Bagwell's hash array mapped tries (HAMTs). Updating one of these structures returns a new structure that shares almost all of its memory with the old one. Identity is modeled separately from value through reference types (atoms, refs, agents, and vars), each with its own concurrency semantics. Refs participate in software transactional memory.[20]
Clojure runs primarily on the JVM. A CLR port exists as ClojureCLR, and the most successful sibling project is ClojureScript, which compiles Clojure to JavaScript using Google's Closure compiler. ClojureScript has been visible in front-end web work using libraries such as Reagent and Re-frame.[21]
Clojure has seen meaningful industrial adoption. Public users include Walmart Labs (Clojure powers their order management system), Nubank (one of the largest banks in Brazil migrated its core banking platform to Clojure), CircleCI, Funding Circle, and Cisco.[22][23] The language also provides core.async, a library implementing Communicating Sequential Processes (CSP) style channels on top of macros, similar in spirit to Go's concurrency primitives.[20]
Lisp's identification with artificial intelligence is no accident. McCarthy invented the language for AI research and the major AI laboratories at MIT, Stanford, and Carnegie Mellon adopted it. From roughly 1962 through the late 1980s, if a graduate student was writing a thesis on natural language understanding, theorem proving, or expert systems, the code was almost certainly Lisp.[3][4]
A partial roll call of classic AI systems written in Lisp:
| System | Years | Author / Lab | Subject |
|---|---|---|---|
| DENDRAL | 1965 onward | Stanford (Lederberg, Feigenbaum, Buchanan) | Inferring molecular structure from mass spectrometry. |
| MACSYMA | 1968 onward | MIT Project MAC | Symbolic algebra; ancestor of Maxima. |
| SHRDLU | 1968 to 1970 | MIT (Terry Winograd) | Natural language understanding in a blocks world. |
| MYCIN | early 1970s | Stanford (Shortliffe et al.) | Expert system for diagnosing bacterial infections. |
| INTERNIST-1 | 1974 onward | University of Pittsburgh | Internal medicine diagnostic system. |
| R1 / XCON | 1980 onward | CMU and DEC (John McDermott) | Expert system for configuring VAX computers. |
| EURISKO | 1976 to 1984 | Stanford (Doug Lenat) | Heuristic learning; precursor to Cyc. |
| Cyc | 1984 onward | MCC, Cycorp (Doug Lenat) | Comprehensive common-sense knowledge base. |
| KEE, ART, S.1 | mid-1980s | IntelliCorp, Inference, Teknowledge | Commercial expert system shells. |
SHRDLU by Terry Winograd was an early demonstration that a program could understand English commands operating on a simulated world of blocks. It was written in MacLisp and MicroPlanner, and remains a milestone in natural language processing despite being limited to its closed domain.[24]
MYCIN, developed at Stanford in the early 1970s by Edward Shortliffe, diagnosed bacterial infections and recommended antibiotics. It was never used clinically because of liability concerns, but it established the rule-base / inference-engine / explanation-facility architecture that defined a decade of expert system work. MYCIN was implemented in Interlisp.[25]
XCON (originally R1) was an expert system written in OPS5 that configured VAX systems for Digital Equipment Corporation. By the mid-1980s DEC reported XCON was saving on the order of $25 million a year, the most-cited example of expert systems paying for themselves in industry.[26]
Cyc, launched by Doug Lenat in 1984 at MCC, set out to encode hand-curated common-sense knowledge in formal logic. Cyc continues at Cycorp; its core inference language SubL is a Lisp dialect.[27]
Prolog, the other major symbolic AI language, competed with Lisp through the 1970s and 1980s, especially in Europe and Japan, where the Fifth Generation Computer project bet on Prolog. In North America, Lisp stayed dominant.[4]
The end of Lisp's reign came suddenly. By the late 1980s commercial expert systems were failing to live up to their hype, and the specialized Lisp machine industry collapsed when general-purpose RISC workstations running C-based code overtook them on price and performance. The AI Winter and the cost advantage of Unix workstations pushed AI work in the 1990s toward C, C++, and MATLAB. By the time deep learning emerged in the 2010s, the dominant AI language had become Python.[28][29]
A Lisp machine was a workstation whose hardware was designed to execute Lisp efficiently. The architecture typically included tagged words for runtime type checking, microcoded instructions for fast cons, car, and cdr, and incremental garbage collection. The editor, compiler, debugger, window system, and operating system were all written in Lisp and could be inspected and modified at any time.[30]
The MIT Lisp Machine Project began in 1973, led by Tom Knight. It produced the CADR machine in 1977, which became the basis for the commercial machines of the 1980s. The MIT lab spun off two competing companies:
The Lisp machine industry was small (perhaps a few thousand units shipped per year at peak) and depended on AI research funding. By 1987 to 1990 the AI Winter and the rise of cheaper Unix workstations from Sun, MIPS, and DEC made dedicated Lisp hardware uncompetitive. Symbolics filed for Chapter 11 bankruptcy in 1993; LMI had collapsed earlier. Emulators of Symbolics Open Genera continued to run on Alpha and later x86 machines for niche customers.[30][31]
John McCarthy (1927 to 2011) invented Lisp and shared the 1971 Turing Award for his contributions to AI.[1]
Marvin Minsky co-founded the MIT AI Laboratory with McCarthy in 1959 and used Lisp for work on knowledge representation, frames, and the Society of Mind theory.[3]
Gerald Sussman and Guy Steele created Scheme and co-authored, with Hal Abelson, the SICP textbook that defined how computer science was taught at MIT for two decades.[19]
Richard Stallman implemented Emacs Lisp and made it the extension language of GNU Emacs, ensuring that millions of programmers since 1985 have encountered Lisp through their text editor.[12]
Paul Graham co-founded Viaweb in 1995, implemented in Common Lisp and sold to Yahoo in 1998 for about $49 million in stock, becoming Yahoo Store. Graham's essays "Beating the Averages" (2003) and "Roots of Lisp" (2002) became canonical arguments for the productivity of Lisp in startups.[13][32]
Rich Hickey created Clojure and ClojureScript and gave conference talks ("Simple Made Easy," "The Value of Values") that influenced software design beyond Lisp.[20]
Peter Norvig wrote Paradigms of AI Programming: Case Studies in Common Lisp (1991), which presented Lisp implementations of unification, pattern matching, planners, and logic programming. He later directed research at Google and co-authored Artificial Intelligence: A Modern Approach with Stuart Russell.[33]
Doug Lenat led Cyc from 1984 until his death in 2023; Cyc remained Lisp-based throughout.[27]
Lisp is no longer the dominant AI language and has not been since the early 1990s. It is still in active use in several niches.
Emacs and the Emacs Lisp ecosystem may be the largest single Lisp deployment in the world. Every Emacs user runs a Lisp interpreter that loads, byte-compiles, and executes Lisp packages as part of normal editor operation. The MELPA archive holds several thousand packages.[12]
Clojure is the most commercially significant living Lisp. Stack Overflow developer surveys through the 2010s and 2020s have shown Clojure among the highest-paid programming languages, reflecting industrial use at Walmart, Nubank, Apple, Cisco, and many smaller fintech and analytics shops.[22][23]
Common Lisp survives in computer algebra (Maxima, the open-source descendant of MACSYMA, is written in Common Lisp), in robotics, in commercial scheduling and constraint software (ITA Software's QPX airline fare search engine, acquired by Google in 2011, was a famously large Common Lisp system), and in the SBCL community.[15][34]
AutoLISP, Autodesk's embedded dialect, has shipped in AutoCAD since 1986 and is used by tens of thousands of CAD users.[5]
Newer dialects keep arriving: Hy (Lisp on the Python AST), Fennel (Lisp transpiling to Lua), and Janet (a small embeddable Lisp written in C). In machine learning, Lisp is largely absent from production code, which is dominated by Python wrapping C++ kernels.[29]
Greenspun's tenth rule. Articulated by Philip Greenspun: "Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp." The rule is a joke about feature creep, but Lisp programmers cite it earnestly when defending the size of Common Lisp.[35]
The parentheses jokes. The backronym "Lots of Irritating Spurious Parentheses" predates the Common Lisp era. The number of opening parens at the start of a line, sometimes ten or more in deeply nested code, has been a target for critics. Lisp users tend to point out that proper editor support makes the parentheses invisible in practice.[13]
Reputation as elite or academic. Lisp's association with MIT and the lambda calculus gave it a reputation as a difficult, ivory-tower language. Paul Graham's contrarian framing was that this reputation came from the unfamiliarity of metaprogramming to programmers raised on lower-level languages.[13]
Influence on later languages. Python's decorators, list comprehensions, and first-class functions descend from Lisp's higher-order programming. JavaScript's closures and dynamic typing were borrowed from Scheme by Brendan Eich, who said publicly that Netscape originally hired him to embed Scheme in the browser before he was redirected to design a new language with a more familiar syntax. Ruby, Julia, and lambda expressions in C++11 also trace back to Lisp.[36][37]