Personal tools
You are here: Home Projects LISP Common Lisp family
Document Actions

Common Lisp family

by Paul McJones last modified 2019-06-25 08:58


Previous: UtiLisp - Up: LISP - Next: EuLisp




  • Guy L. Steele Jr. Common Lisp Reference Manual.
    • Swiss Cheese Edition. August 1981.
    • Flat Iron Edition. February 1982. (See Orlikowski and Yates 1994.)
    • Colander Edition. July 29, 1982. Computer History Museum, Herbert Stoyan collection on LISP programming, Accession number 102719215.
    • Laser Edition. November 16, 1982. Computer History Museum, Herbert Stoyan collection on LISP programming, Accession number 102719216.
    • Excelsior Edition. July 15, 1983.
    • Mary Poppins Edition. November 29, 1983. Computer History Museum, Herbert Stoyan collection on LISP programming, Accession number 102719258
  • Guy L. Steele Jr. Common LISP: the Language. Digital Press, 1984, 465 pages.
  • Daniel G. Bobrow, Linda G. DeMichiel, Richard P. Gabriel, Sonya E. Keene, Gregor Kiczales, and David A. Moon. Common Lisp Object System Specification. Technical Document 88-002R of X3J13. Lisp and Symbolic Computation, Volume 1, Number 3-4, February, 1989.
  • Guy L. Steele, Jr. Common Lisp: the Language, Second Edition. Digital Press, 1990, 1029 pages. Online at
  • Kent M. Pitman et al. Information Technology - Programming Language - Common Lisp (formerly ANSI X3.226-1994 (R1999)).
  • Kent Pitman. Common Lisp HyperSpec, version 7.0. LispWorks Ltd., 2005. Online at



  • Archive of email to COMMON-LISP@SU-AI.ARPA, December 1981 to November 1984.
  • Larry Masinter and Bill vanMelle. Report on Common Lisp to the Interlisp Community. Email message, circa December 1981, 8 pages.
    • Computer History Museum: gift of Larry Masinter, Lot X6058.2011. PDF
    • Text file from SUMEX-AIM INTERLISP, <lisp> Text file

    "In a fit of optimism that usually does not characterize him, Gabriel approached the Xerox Interlisp group, and received a warmer welcome than he did in Berkeley, but he left with only an indication that someone, probably Bill VanMelle, would attend the meetings, mostly as an observer." [Steele and Gabriel 1993]

  • Arun Welch. CL History. Posting to comp.lang.lisp, October 20, 1994, Message-ID <>. Online at Online at CMU AI Repository

    A collection of email from key Common Lisp contributors spanning 1981 to 1984; also mentions ELISP.

  • Guy L. Steele, Jr. An overview of COMMON LISP. Proceedings of the 1982 ACM symposium on LISP and functional programming, Pittsburgh, Pennsylvaniam, August, 1982, pages 98-107. ACM DL
  • Herbert Stoyan. Common LISP - a Survey and a Critique. Rundbrief der Fachgruppe Kűnstliche Intelligenz in der Gesellschaft fűr Informatik. Number 28, November 1982, pages 11-20. PDF at
  • Richard P. Gabriel and Larry M. Masinter. Performance of Lisp systems. Proceedings of the 1982 ACM symposium on LISP and functional programming, Pittsburgh, Pennsylvania, pages 123-142. ACM DL
  • Rodney A. Brooks and Richard P. Gabriel. A critique of Common LISP. Proceedings of the 1984 ACM Symposium on LISP and functional programming, Austin, Texas, pages 1-8. ACM DL
  • Richard P. Gabriel. Performance and Evaluation of Lisp Systems. The MIT Press, Cambridge, Massachusetts, 1985. PDF at The MIT Press
  • Archive of email to quinquevirate@SU-AI.ARPA, December 1985 to May 1990.
  • For archives of cl-iteration@SU-AI.ARPA, cl-object-oriented-programming@SU-AI.ARPA, cl-subsets@SU-AI.ARPA, cl-windows@SAIL.STANFORD.EDU, and see
  • Jon L White. Reconfigurable, retargetable bignums: a case study in efficient, portable Lisp system building. Proceedings of the 1986 ACM conference on LISP and functional programming, Cambridge, Massachusetts, pages 174-191. ACM DL
  • S.E. Fahlman. Common Lisp. Annual Review of Computer Science, Volume 2, June 1987, pages 1-19. Online at
  • Linda G. DeMichiel and Richard P. Gabriel. The Common Lisp Object System: An Overview. Proceedings ECOOP 1987, June 1987, Lecture Notes in Computer Science, Volume 276, Springer, pages 151-170. SpringerLink Online at via Internet Archive Online at
  • C. Queinnec and J. Chailloux, editors. Proceedings of the First International Workshop on Lisp Evolution and Standardization. February 22-23, 1988, Paris, France. Published by IOS, Amsterdam, 1988.
  • Takayasu Ito and Taiichi Yuasa. Some Non-standard Issues on Lisp Standardization. Proceedings of the First International Workshop on LISP Evolution and Standardization, February 22-23, 1988, Paris France, Published by IOS, Amsterdam, 1988, pages 11-20. PDF
  • Larry Masinter. Common LISP Cleanup. Proceedings of the First International Workshop on LISP Evolution and Standardization, February 22-23, 1988, Paris France, Published by IOS, Amsterdam, 1988, pages 21-24. Computer History Museum: gift of Larry Masinter, Lot X6058.2011. PDF of preprint
  • Kent M. Pitman. Interactions in Lisp. Proceedings of the First International Workshop on Lisp Evolution and Standardization, February 22-23, 1988, pages 45-49. Online at
  • Linda G. DeMichiel. Overview: The Common Lisp Object System. Lisp and Symbolic Computation, Volume 1, Number 3-4, February, 1989, pages 227-244. DOI Online at
  • Richard P. Gabriel, Jon L. White, and Daniel G. Bobrow. CLOS: Integrating Object-Oriented and Functional Programming. Commun. ACM, Volume 34, Number 9, 1991, pages 28-38. ACM DL Online at
  • Henry G. Baker. Critique of DIN Kernel Lisp Definition Version. Lisp & Symbolic Computation, Volume 4, Number 4, March 1992, pages 371-398. Online at

    "The last ten years have seen both a boom and and bust for the Lisp language. From its inception in 1958 until its commercialization in 1980, Lisp was content to live a life of academic obscurity, servicing the needs of Artificial Intelligence, theorem proving and symbolic algebra researchers. In this role, Lisp could explore many new ideas and quickly absorb new ideas from the programming language 'mainstream'. However, when AI became a business, Lisp was drawn to the money like a moth to the flame. Lisp quickly sought to become 'industrial strength', and ANSI Common Lisp was the result. Unfortunately, 'industrial' quickly became 'rust belt', as the newly standardized Common Lisp could not quickly grow and adapt to the new, more "open" environment.

    In Lisp's quest for industrial respect, it abandoned its traditional customers. Symbolic algebra developers (e.g., Maple, Mathematica) forsook Lisp for the more portable and efficient C. Logicians gave up Lisp for Prolog and ML. Vision researchers, seeking the highest performance from parallel computers, dropped Lisp in favor of C, Fortran (!) and various fringe parallel languages. AI companies were forced to move their expert systems into C, C++, Ada and Cobol (!) because of the large size, poor performance and poor integration of Common Lisp systems. Academicians teaching undergraduates chose Scheme and ML for their small size, portability and clean semantics."

  • JoAnne Yates and Wanda J. Orlikowski. Knee-jerk Anti-LOOPism and other E-mail Phenomena: Oral, Written, and Electronic Patterns in Computer-Mediated Communication. MIT Sloan School Working Paper #3578-93 Center for Coordination Science Techincal Report #150, July 1993. Online at
  • Wanda J. Orlikowski and JoAnne Yates. Genre Repertoire: Norms and Forms for Work and Interaction. MIT Sloan School Working Paper #3671-94, Center for Coordination Science Technical Report #166, March 1994. Online at

    "Most of the work [designing Common Lisp] was carried out by E-mail discussion. These discussions were captured in file archives. One research at the Sloan School at MIT has used these archives to study computer-mail-based decision-making and interaction. [Steele and Gabriel 1993]

  • John C. Mallery, Howard E. Shrobe, Robert Laddaga, Thomas F. Knight, Kalman Reti, Paul Robertson, Andrew J. Blumberg, Susan Felshin, and Patrick H. Winston. Modernizing Common Lisp: Recommended Extensions. Email to Artificial Intelligence Laboratory, Massachusetts Institute of Technology, July 7, 1999. Online at
  • Masayuki Ida. The History of Lisp Standardization during 1984 – 1990. Proceedings of the 2002 International Lisp Conference, San Francisco, California, October 2002. PDF

    "CLtL1 was the output of a hastily united group of MacLisp successors, who felt InterLisp group was stronger than they were. They did not dream of international matters or even of commercial interests. Most of them thought it is just a US academic research matter: most of them did not know how to make international standards, or even American national standards."

  • Kent M. Pitman. Common Lisp: the untold story. Talk at Lisp50@OOPSLA, the 50th Anniversary of Lisp workshop, Monday, October 20, 2008.
  • Daniel Weinreb. Common Lisp Implementations: A Survey. Version 8, February 14, 2010. Online at via

    "There has been a new wave of interest in Common Lisp over the last few years. This paper is a November, 2007 (updated February, 2010) survey of Common Lisp implementations that are currently being actively maintained. It also provides references to writings about why Lisp is interesting and important, Lisp textbooks, and useful Lisp resources including repositories of available libraries."



  • David S. Touretzky. COMMON LISP: A Gentle Introduction to Symbolic Computation.The Benjamin/Cummings Publishing Company, Inc., 1990. Online at


Implementations - open source

See also:

CMU Common Lisp (CMUCL)

"CMUCL was developed at the Computer Science Department of Carnegie Mellon University. The work was a small autonomous part within the Mach microkernel-based operating system project, and started more as a tool development effort than a research project. The project started out as Spice Lisp, which provided a modern Lisp implementation for use in the CMU community. CMUCL has been under continual development since the early 1980's (concurrent with the Common Lisp standardization effort). Most of the CMU Common Lisp implementors went on to work on the Gwydion environment for Dylan. The CMU team was lead by Scott E. Fahlman, the Python compiler was written by Robert MacLachlan." [CMUCL credits]


Steel Bank Common Lisp (SBCL)

"Steel Bank CL (SBCL) forked from CMU CL in December, 1999. The fork was initiated by William Newman. The system is named after the industries where Andrew Carnegie and Andrew Mellon, respectively, made fortunes.

The original goal of the fork was to produce a version of CMU CL that was easier to build and to maintain. After the fork, SBCL diverged from CMU CL, and as can be seen in this survey there are significant differences between their feature sets these days. While SBCL and CMU CL still share a lot of common code, few changes to one system are ported over to the other. Due to this and the different development philosophies, it can be expected that the implementations will continue to diverge.

The CLOS implementation is based on PCL, but has been substantially modified. The compiler generates reasonably good machine code: good for low-level number crunching as well." [Weinreb 2010]


Rutgers Common Lisp for TOPS-20 on DECSYSTEM-20

Charles L. Hedrick and J. Storrs (Josh) Hall developed a Common Lisp for the DECSYSTEM-20 running TOPS-20 at Rutgers University during 1983-1985. This system was based on Carnegie-Mellon's Spice Lisp, but used an assembly language kernel whose "interior design is sort of a cross between the Spice machine and Elisp, the Rutgers extended-addressing version of UCI Lisp" [Hedrick 1985]. The Spice system code, which is the portion of the runtime written in Lisp, was used with only minor modifications to deal with representation dependencies. The Spice compiler was modified to generate code for the DECSYSTEM-20.

The version of the kernel and Lisp code exhibited here contains bug fixes and improvements by Björn Victor, Per-Erik Martin and others at Uppsala University, Sweden, and also by Peter Samson at Systems Concepts, San Francisco, California.

The Flavors code was adapted for Common Lisp from Spice Lisp Flavors by Torbjörn Åhs and Björn Victor at Uppsala University. Spice Lisp Flavors was adapted by Steven Handerson from Symbolics Flavors. Symbolics Flavors was designed by Howard Cannon and David Moon. [Cannon 1979] [Weinreb and Moon 1980] [Moon and Weinreb 1985] [Moon 1986]

Source code
  • Charles L. Hedrick and J. Storrs (Josh) Hall. Common Lisp for TOPS-20 on DECSYSTEMS-20. Rutgers University, 1983-1985. Modifications and additions by Björn Victor and others at Uppsala University, Sweden, 1985-1997. Distributed by permission of Charles L. Hedrick, July 28, 2005.
  • Charles L. Hedrick. Tops-20 Common Lisp Red Pages. Rutgers University
    • Swiss Cheese Edition (very drafty), 1983, 23 pages. PDF
    • 1985, 26 pages. PDF
  • Daniel Weinreb and David Moon. Flavors: Message Passing in the Lisp Machine. A.I. Memo No. 602, Artificial Intelligence Laboratory, Massachusetts Institute of Technology, November 1980. PDF at MIT
  • David Moon and Daniel Weinreb. Introduction to Flavors. 1985. PDF

    "This document is adapted from text written primarily by David Moon and Daniel Weinreb which appeared in the Lisp Machine Manual, fourth edition, chapter 20, copyrighted by the Massachusetts Institute of Technology."

  • Steven Handerson and Jim Muller. Spice Lisp Flavors. Spice Lisp Project, 1985. PDF
  • Skef Wholey, Scott E. Fahlman and Joseph Ginder. Revised Internal Design of Spice Lisp. DRAFT, Spice Document S026 [Revised], undated. PDF

    Stoyan includes a document with these authors and title as Spice Document S226, 1983.

  • Howard I. Cannon. Flavors - A Non-Hierarchical Approach to Object-Oriented Programming. Unpublished draft, Artificial Intelligence Laboratory, 1979 (revised 2007). Posted by permission of the author. PDF
  • David Moon. Object-oriented programming with flavors. Conference proceedings on Object-oriented programming systems, languages and applications, Portland, Oregon, 1986, pages 1-8. ACM DL


Clozure Common Lisp

"In 1984, Coral Software began the development of a Common Lisp for the Macintosh, called Coral Common Lisp (CCL). Three years later, CCL 1.0 was released. It ran on a 1 MB Macintosh Plus.

Subsequently, Coral entered into a marketing relationship with Franz, under which CCL was renamed to Macintosh Allegro Common Lisp (MACL). That didn't last long, and in late 1988, Coral was acquired by Apple, who released the Lisp under the name Macintosh Common Lisp (MCL).

In 1994, in the midst of switching from the 68K to the PowerPC CPU for its Macintosh line, Apple transferred MCL to Digitool. Digitool completed the PowerPC port and released a PowerPC version of MCL around 1995.

Erann Gat (now known as Ron Garret) of JPL wanted to develop a small-footprint Lisp for use on PowerPC-based robots and flight systems. A source license for MCL was acquired from Digitool, and in 1998, Gary Byers ported a version of the MCL compiler and runtime to VxWorks and LinuxPPC. In 2001, Digitool agreed to open source the work that had been done at JPL, and OpenMCL was born.

In 2007, Alice Hartley of Digitool announced that the code for the original MCL would be released under an open source license. Largely in order to avoid confusion with this newly open sourced version of MCL, OpenMCL was renamed to Clozure CL. As a bonus, this makes the name of the primary implementation package and the default installation directory name ("ccl") meaningful again.” [Clozure CL History]


MCL (Macintosh Common Lisp)

"Open source version of the Macintosh Common Lisp development environment. Works on Intel and PPC computers with MacOSX 10.4 and up, including MacOSX 10.6 'Snow Leopard'.


Thanks to Digitool for releasing MCL as open source and to Clozure for updating it to work on Intel and Snow Leopard." [Project home page]

See history of Clozure Common Lisp above.


Kyoto Common Lisp (KCL)

"A new player from Japan – Kyoto Common Lisp (KCL) – provided a bit of a spoiler: KCL has a compiler that compiles to C, which is compiled by the C compiler. This Lisp was licensed essentially for free, and the Common Lisp companies suddenly had a surprising competitor." [Steele and Gabriel 1993]

"Kyoto Common Lisp (KCL) is a highly portable and implementation of Common Lisp originally developed at Kyoto University in Japan. KCL conforms to CLtL1."

  • Sources: free but requires a license. Online at CMU Artificial Intelligence Repository
  • Taiichi Yuasa and Masami Hagiya. Kyoto Common Lisp Report. Research Institute for Mathematics Sciences, Kyoto University, August 1985, 87 pages. PDF PostScript
  • T. Yuasa. Design and Implementation of Kyoto Common Lisp. Journal of Information Processing, Volume 13, Number 3, 1990, pages 284-295. PDF PostScript


Austin Kyoto Common Lisp (AKCL)

"Austin Kyoto Common Lisp (AKCL) is a collection of ports, bug fixes and improvements to KCL written by Bill Schelter. {A}KCL generates C code which it compiles with the local C compiler."

"To build AKCL, one must also have in place the sources for KCL. At the time one builds AKCL, one automatically merges AKCL changes with the KCL sources, which are left unmodified, in accordance with the KCL license."


ECoLisp / ECL / ECL-Spain / ECL / Embeddable Common Lisp (Università di Pisa)

"ECL (Embeddable Common-Lisp) is an interpreter of the Common-Lisp language as described in the X3J13 Ansi specification, featuring CLOS (Common-Lisp Object System), conditions, loops, etc, plus a translator to C, which can produce standalone executables.” []

"Embeddable Common Lisp, a member of the KCL Family, is a Common Lisp implementation initially developed by Giuseppe Attardi, maintained for many years by Juan Jose Garcia-Ripoll and currently maintained by Daniel Kochmański. ECL is the successor to EcoLisp.” []

The long and complex history of ECL is described in this section of the manual.
Source code
Papers about ECL


ManKai Common Lisp (MKCL)

"ManKai Common Lisp is a member of the KCL Family through its ECL branch. MKCL is a quite complete ANSI Common Lisp implementation, mainly developed by Jean-Claude Beaudoin at the moment.

MKCL features, in its permanent configuration, a number of significant extensions like multi-threading, FFI and Unicode support, along with a good set of prepackaged libraries: CFFI, Babel, alexandria, FiveAM, Bordeaux-Threads, ASDF, SLIME and more." [MKCL at CLiki]

Project page:

comp.lang.lisp thread on its announcement.


GNU Common Lisp (GCL)

"GCL is the product of many hands over many years. The original effort was known as the Kyoto Common Lisp system, written by Taiichi Yuasa and Masami Hagiya in 1984. In 1987 new work was begun by William Schelter, and that version of the system was called AKCL (Austin Kyoto Common Lisp). In 1994 AKCL was released as GCL (GNU Common Lisp) under the GNU public library license. The primary purpose of GCL during that phase of its existence was to support the Maxima computer algebra system, also maintained by Dr. Schelter. It existed largely as a subproject of Maxima.

After the passing of Dr. Schelter in 2001, it was decided that GCL should be actively maintained and improved. GCL is currently maintained by a team of 12 developers across the world coordinated via the gcl-devel mailing list." [GCL History]



"CLISP is a Common Lisp implementation by Bruno Haible, then of Karlsruhe University, and Michael Stoll, then of Munich University, both in Germany. It supports the Lisp described in the ANSI Common Lisp standard plus many extensions.

CMUCL's CLOS implementation is derived from the PCL reference implementation written at Xerox PARC. Its implementation of the LOOP macro was derived from code from Symbolics, which was derived from code written at MIT. The CLX code is copyrighted by Texas Instruments Incorporated. " [CLISP Common Lisp Summary]


BBN Butterfly Common Lisp



See SPUR Lisp, which was a Common Lisp derived from Spice Lisp and extended with features to support concurrency on the SPUR multiprocessor workstation at the University of California at Berkeley.


Corman Common Lisp.

Corman Common Lisp was originally a commercial product, but Roger Corman stopped developing it and released under an open source MIT license in 2015. He had previously released the source for his Macintosh product, PowerLisp.

"Corman Lisp is particularly focused on Windows on the Intel archicture. It features a native code compiler for Intel processors, 80x86 assembler and disassembler, incremental linker and multi-window text editor. It is fully integrated with the Win32 API, and all the Windows API functions are readily available from Lisp.

Corman CL was designed and implemented by Corman Technologies, since 1995. Previously they developed PowerLisp for the Mac, but Corman CL was a complete rewrite for Windows. (PowerLisp is no longer developed or supported). They have developed and maintained Corman CL continuously, with new major releases approximately every 18 months (and minor updates more often). The CLOS implementation was originally from Art of the Metaobject Protocol Closette, and then extensively rewritten to add missing Common Lisp features and to improve performance." [Weinreb 2010]

  • PowerLisp for Macintosh (includes source): via
    "PowerLisp 2.02 is being released with complete source code (the entire product, including editor, can be built from scratch). This product is free for personal use. For commercial use, please contact us at A more complete license is being developed and will be posted here when available."
  • Corman Lisp


Poplog Common Lisp

"Poplog is an integrated toolkit providing a highly extendable collection of languages and tools for teaching, research and development. It is described on Wikipedia here. By default it includes incremental compilers for three powerful AI programming languages which can be used interactively both when learning to program and when developing software:

  • Pop-11--the core language -- used to implement itself and the others;
  • Common Lisp; and
  • Prolog;

as well as

  • Standard ML, a widely used functional language."
[What is Poplog?]

Source code
Papers and implementation documentation
  • Aaron Sloman. The Evolution of POPLOG and Pop-11 at Sussex University. In: POP-11 Comes of Age: The Advancement of an AI Programming Language, Ed. J. A.D.W.Anderson, Ellis Horwood, pp 30-54, 1989. PDF and HTML at
  • R. Smith, A. Sloman and J. Gibson. POPLOG's two-level virtual machine support for interactive languages, In: D. Sleeman and N. Bernsen, editors. Research Directions in Cognitive Science Volume 5: Artificial Intelligence, Lawrence Erlbaum Associates, 1992, pages 203-231. Online at


CLiCC (The Common Lisp to C Compiler)

From the APPLY project, which also participated in EuLisp.

"CLiCC is a Common Lisp to C Compiler. It generates C-executables or modules from Common Lisp application programs. CLiCC is intended to be used as an addon to existing Common Lisp systems for generating portable applications. CLiCC supports a strict and very large subset CL0 (Common Lisp0) of Common Lisp + CLOS.

CLiCC is not a Common Lisp system. The generated C code, although human readable, is not primarily intended to be maintainable in C, hence, CLiCC is not a translator. The target language is a subset of C. CLiCC is adaptable to generate ANSI- or K&R-C. A standard C compiler, e.g. the GNU gcc, can be used on the target machine to generate stand alone executables or linkable modules.

CLiCC itself is a Lisp application. It has been developed using Franz Allegro Common Lisp 4.1. However, it does not require Allegro to run. Other Lisp systems including CLISP, GCL (AKCL) or CMU Common Lisp will do. The forthcoming release 0.6.5 will run under Allegro 4.3 as well. Moreover, CLiCC should compile itself to C. Unfortunately, this is impossible at present. As this bug is not yet fixed, release 0.6.2 has to be used in order to produce a stand alone compiler. " [Project page]

  • Project page:
  • O. Burkart, Wolfgang Goerigk, and H. Knutzen. CLICC: A New Approach to the Compilation of Common Lisp to C. In: Workshop Alternative Konzepte für Sprachen und Rechner, Bericht Nr. 8/91-I des Instituts für angewandte Mathematik und Informatik der Univ. Münster, 1991. Online at CiteSeerX
  • Wolfgang Goerigk, Ulrich Hoffmann, and Heinz Knutzen. COMMONLISP0 and CLOS0: The Language Definition. APPLY-Arbeitspapier APPLY/CAU/II.2/2, Christian-Albrechts-Universität, Kiel, September 1993. .ps.Z at
  • Source codeup to version 0.6.4: CMU AI Repository
  • Source code 0.6.5:



By Jim Allard at Gensym, later released as open source.

"ThinLisp is an open source Lisp to C translator for delivering commercial quality, Lisp-based applications. It implements a subset of Common Lisp with extensions. ThinLisp itself is written in Common Lisp, and so must run on top of an underlying Common Lisp implementation such as Allegro, MCL, or CMU Lisp. The C code resulting from a translation can then be independently compiled to produce a small, efficient executable image."

ThinLisp is not a typical Lisp implementation in that it does not implement a garbage collector or many of the other run-time development features of other Lisps. ThinLisp is designed for producing high quality deliverable C libraries and executables from Lisp sources. Originally designed for real-time control applications, ThinLisp stresses run-time performance at the expense of some development time conveniences. This is exactly the opposite design philosophy from many Lisps, but that's what makes this one thin!

ThinLisp is the current generation (4th) of a series of Lisp to C translators used to deploy a large Lisp system (1 million lines) built starting around 1990." [README]


Armed Bear Common Lisp (ABCL)

"Originally started to be a scripting language for the J editor, it now supports JSR-223 (Java scripting API): it can be a scripting engine in any Java application. Additionally, it can be used to implement (parts of) the application using Java to Lisp integration APIs.” [Project home page]

"ABCL was originally the extension language for the J editor, which was started in 1998 by Peter Graves. Sometime in 2003, a whole lot of code that had previously not been released publically was suddenly committed that enabled ABCL to be plausibly termed an emergent ANSI CommonLisp implementation candidate.

From 2006 to 2008, Peter manned the development lists, incorporating patches as made sense. After a suitable search, Peter nominated Erik Hülsmann to take over the project.

In 2008, the implementation was transferred to the current maintainers, who have strived toimprove its usability as a contemporary Common Lisp implementation." [User Manual]

Project home page:



Peter Graves.

"XCL is a new native-code implementation of Common Lisp. It features a kernel written in C++ and an optimizing compiler written in Lisp with backends for x86 and x86-64.

XCL runs on Linux, FreeBSD (tested only on x86, but it might work on x86-64 too), and 32-bit Windows." [Armed Bear]


Implementations - commercial


Allegro CL. Franz Inc.

"Allegro Common Lisp was originally called Extended Common Lisp, first released in 1985. It is written in itself, and we used Franz Lisp (another dialect of Lisp that Franz used to sell in the 80's) to bootstrap the new implementation.

The compiler and runtime system were written from scratch, but some of the interpreter came from CMU's Spice Lisp. Our CLOS implementation was originally based on Xerox PCL. The interpreter and CLOS implementations were rewritten over the first few years of the product's life. An extensive history of Franz, Inc. can be found at The principal founders of Franz were Fritz Kunze, John Foderero, and Richard Fateman. John Foderero, the original primary architect at Franz, is still there as Chief Scientist." [Weinreb 2010]


Control Data Corporation Common Lisp

"Following CDC ALISP lineage for a moment, ALISP [at University of Massachusetts Amherst] was eventually replaced with work on a native Common Lisp that was headed by Richard Hudson." [Dan Corkill, personal communication, September 4, 2010]

"The Lisp/VE team was led by Richard L. Hudson and consisted of David M. Hart, Susan E. Lander, Andy Podgurski, Mali Anand, and Joanne Pommers. the compiler and runtime was written by the Lisp/VE team primarily in Lisp and a language called Cybil (Cyber Implementation Language). It leveraged a lot of the CMU Spice Lisp code to implement many of the Common Lisp functions and libraries. It faithfully implements the Common Lisp dialect and was available commercially as part of CDC's Cyber 180, the last machine CDC built." [Richard L. Hudson, personal communication, September 10, 2012]

"I think it was also the first full implementation of Pitman's condition system (I recall Susan exchanging a lot of question/clarification emails with Kent during that time.)" [Dan Corkill, personal communication, September 10, 2012]

  • Anonymous [Richard L. Hudson]. LISP for NOS/VE Language Definition: Usage Supplement. Publication Number 60486213, Control Data Corporation, Preliminary version, March 1985. Computer History Museum, Herbert Stoyan Collection on LISP Programming, Accession number 102720188. PDF
  • Anonymous [Richard L. Hudson]. LISP for NOS/VE Language Definition: Usage Supplement. Publication Number 60486213, Control Data Corporation, Revision B, December 1989. Gift of Richard L. Hudson. PDF


Digital Equipment Corporation VAX LISP

The manuals in this section are a gift of Beryl Nelson to CHM.

"The VAX LISP language is an extended implementation of the COMMON LISP language defined in COMMON LISP: The Language. In addition to the features supported by COMMON LISP, VAX LISP provides the following extensions:

  • DCL (DIGITAL Command Language) LISP command
  • Extensible editor
  • Error handler
  • Debugging facilities
  • Extensible pretty printer
  • Facility for calling out to external routines
  • Facility for defining non-LISP data structures (alien structures)
  • Facility for defining interrupt functions (that is, functions that execute asynchronously)
  • Window and graphics support for the VAXstation II workstation" [User's Guide, Chapter 1]
  • VAX LISP/VMS, Software Version 2.0, May 1986.
    • Anonymous. User's Guide. PDF
    • Anonymous. System Access Programming Guide. PDF
    • Anonymous. Installation Guide. PDF
    • Anonymous. Editor Programming Guide. PDF
    • Anonymous. Graphics Programming Guide. PDF
  • VAX LISP/ULTRIX, Software Version 2.0, May 1986.
    • Anonymous. User's Guide. PDF
    • Anonymous. System Access Programming Guide. PDF
    • Anonymous. Installation Guide. PDF
  • VAX LISP instructional materials, 1984.
    • Anonymous. VAX LISP Student Workbook. Volumes I, II, and III.
    • Anonymous. VAX LISP Tests/Exercises.



"LispWorks is produced by LispWorks Ltd.

Development began in Cambridge, England in 1987 and continues there today. The various owners have been: 1987-2000 Harlequin, 2000-2004 Xanalys, and 2005-present LispWorks Ltd.

The CLOS implementation started out as a branch of PCL (Portable Common Loops)." [Weinreb 2010]


Lucid Common Lisp (now Liquid Common Lisp)


GCLISP. Gold Hill.


Texas Instruments Explorer Lisp

  • Anonymous. Lisp Reference. TI Part Number 2243201-0001, Texas Instruments Explorer. PDF at


Chestnut Lisp

"I founded Chestnut and produced the first version of the Lisp-to-C translator, which covered a small subset of Common Lisp, for in-house use in 1989. Chestnut was working on A.I.-flavored applications, particularly a natural-language engine, that we wanted to code in Lisp -- but had to deliver in C, mostly for memory compactness. Since the C code would at some point be maintained, and there were Lisp-agnostic C programmers on the project, we wanted the code to be as clean and clear as possible. Soon after, we discovered that there was a significant demand for the translator itself. The company's encounter with the market, beginning in 1990, was quite a shock: We assumed that customers would adapt their Lisp code to use our Common Lisp subset, to explicitly garbage-collect, etc. We wound up implementing all of CLtL2, including CLOS, and created several translation modes, one of which was fully automatic; local variables were saved on a stack so that they could be recognized as roots for garbage collection. A good number of large Lisp projects were coming to fruition at about the same time, and had to deliver in C for various reasons: portability; to work with multilingual teams; performance and memory footprint; and general fears about Lisp as a language. Many of them became Chestnut customers.

The project benefited greatly from the work of a small group of Lisp internals experts, including several members of the ANSI Lisp (X3J13) standards committee, which had codified Common Lisp only recently. Kim Barrett wrote all of the CLOS translator; Sandra Loosemore designed the translation engine and optimization framework; Jonathan Rees wrote much of the runtime library; he and James O'Toole, both MIT grad students, wrote several very fast garbage collectors, did a good deal of optimizing, and worked on portability; Andy Latto, Dmitry Nizhegorodov, Jeff Brodie, and Rick Harris made major contributions. Jim Allard, then with Gensym Corp., had built a translator for Gensym's use that Chestnut eventually replaced, and already had a lot of good engineering ideas that were incorporated into the product.

The translator was a pricey product: the company provided customers a good deal of support, and for customers who wanted readable C code that was also fast, compact, and portable, didn't really have any competitors. Our customers' best alternative was usually to spend several million dollars, and a year or two, reimplementing their applications in C. So Chestnut was able to find a niche, which grew as the company expanded its marketing efforts and as the amount of pre-sale engineering work it needed to perform for each customer drastically fell.

The company went out of business in 1995, several years after I left. ...

Its technology was sold to Oracle for use on a single development project. It's possible that an approach by the Lisp community would persuade Oracle to release the software as open source. Or Gensym, now based in Texas, might consent to its release. It would take some legwork and luck. In its favor are the passage of time and the re-emergence of Lisp as a platform.

The closest heir to Chestnut's technology seems to be Thinlisp, about which more above. Led by Jim Allard and Ben Hyde, it starts with some of the same design philosophy as Chestnut and focuses on the engineering virtues that, in the developers' experience, were most critical to a successful "develop in Lisp, deploy in C" engine." [Bill Brodie, comp.lang.lisp, 28 January 2009]


Scieneer Common Lisp (SCL)

"Scieneer CL is produced by Scieneer Pty Ltd of Australia. The current version is 1.3.7. There is one primary developer.

It is a fork from CMU CL, with improvements focusing primary on high-performance scientific computing.

Scieneer Pty Ltd was formed in March 2000 to develop and support a professional Common Lisp implementation for Symmetrical Multi-Processor (SMP) systems which is a key requirement for many high performance computing and enterprise applications.

The company was founded by Douglas Crosher, who was a developer of CMU Common Lisp. He was responsible for the x86 port, the generational garbage collector, the multi-processing support, and other enhancements." [Weinreb 2010]

The Scieneer web site became unresponsive sometime after September 2017.


See also:




Computer algebra

  • Axiom. Online at

    "Axiom has been in development since 1971. At that time, it was called Scratchpad. Scratchpad was a large, general purpose computer algebra system that was originally developed by IBM under the direction of Richard Jenks. The project started in 1971 and evolved slowly. Barry Trager was key to the technical direction of the project. Scratchpad developed over a 20 year stretch and was basically considered as a research platform for developing new ideas in computational mathematics. In the 1990s, as IBM's fortunes slid, the Scratchpad project was renamed to Axiom, sold to the Numerical Algorithms Group (NAG) in England and became a commercial system. As part of the Scratchpad project at IBM in Yorktown Tim Daly worked on all aspects of the system and eventually helped transfer the product to NAG. For a variety of reasons it never became a financial success and NAG withdrew it from the market in October, 2001.

    NAG agreed to release Axiom as free software. The basic motivation was that Axiom represents something different from other programs in a lot of ways. Primarily because of its foundation in mathematics the Axiom system will potentially be useful 30 years from now. In its current state it represents about 30 years and 300 man-years of research work. To strive to keep such a large collection of knowledge alive seems a worthwhile goal."

  • Maxima. Online at

    "Maxima is a descendant of DOE Macsyma, which had its origins in the late 1960s at MIT. It is the only system based on that effort still publicly available and with an active user community, thanks to its open source nature. Macsyma was the first of a new breed of computer algebra systems, leading the way for programs such as Maple and Mathematica. This particular variant of Macsyma was maintained by William Schelter from 1982 until he passed away in 2001. In 1998 he obtained permission to release the source code under GPL. It was his efforts and skill which have made the survival of Maxima possible, and we are very grateful to him for volunteering his time and skill to keep the original Macsyma code alive and well. Since his passing a group of users and developers has formed to keep Maxima alive and kicking. Maxima itself is reasonably feature complete at this stage, with abilities such as symbolic integration, 3D plotting, and an ODE solver, but there is a lot of work yet to be done in terms of bug fixing, cleanup, and documentation. This is not to say there will be no new features, but there is much work to be done before that stage will be reached, and for now new features are not likely to be our focus." [About Maxima]


Theorem provers

The Boyer-Moore theorem prover pioneered the approach (also used by ACL2) of using "home-grown dialect of Pure Lisp" as a logic language, and also uses a regular Lisp as an implementation language.

  • R. S. Boyer and J Moore. Nqthm (the Boyer-Moore theorem prover).
  • Matt Kaufmann and J Strother Moore. ACL2 (Applicative Common Lisp - A Computational Logic).


Previous: UtiLisp - Up: LISP - Next: EuLisp
« June 2019 »
Su Mo Tu We Th Fr Sa
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29

Powered by Plone CMS, the Open Source Content Management System

This site conforms to the following standards: