by Daniel Weinreb (dlw@alum.mit.edu)
Version 3
There has been a new wave of interest in Common Lisp over the last few years. This paper is a November, 2007 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. I hope it will help you find the right implementation for your project or product.
How did I pick the implementations to include in the survey? Research on the Internet showed that of all the implementations, some were full-fledged in their time, but have been abandoned for one reason or another, and some don't really count as being the Common Lisp dialect.
There are eleven real currently-maintained implementations. I judged this by seeing which implementations were currently being supported by prominent libraries and tools, by seeing whether there was active mail/news/etc. traffic about the implementation, by searching the web and asking around. Obviously this was something of a judgement call on my part. If I omitted any, it was certainly not on purpose. Please let me know if there are others.
I did not run the implementations. I did not do any benchmark (performance) comparisons of runtime or compiler speed, and you'll find little in this paper about performance. I did not attempt to independently verify the answers to the survey. No organization endorses this paper. In particular, the web site on which you found this paper does not endorse it and bears no resposibility for its contents. I feel very confident that everybody who responded to the survey did so in good faith. Any errors are entirely my fault. Please send corrections to me.
This survey only covers implementations of the Common Lisp dialect (ANSI Standard X3J13), not any other Lisp dialects, nor Scheme. The primary design work for the initial Common Lisp was mainly 1982. Guy L. Steele Jr. was the editor of the initial specification. He, Dave Moon, Richard Gabriel, Scott Fahlman, and I were the primary designers, although of course the design drew very heavily on preceeding dialects. The ANSI X3J13 standard (formally, X3.226-1994) was completed mainly in 1993, and published in 1994. It is about 1150 pages long. Papers about the history of Common Lisp are referenced below (see "Resources").
In my opinion, having multiple supported implementations of a language, rather than merely one canonical implementation, is a sign of a robust and vibrant language. There are many Java implementations (e.g. JRockit), many Python implementations (JPython, IronPython), and so on. These Common Lisp implementations do a very good job of meeting the official X3J13 language standard, and it's very easy, often no work at all, to make an application developed in one run in another if you stay within the defined language.
If you're maintaining a large body of Common Lisp software, it can be helpful to regularly build it using two or more implementations of Common Lisp, even if you only ship the code with one version. This is because different compilers, and different runtimes, will sometimes find (or provide clearer reports of) program errors than another implementation. It's a little bit of extra work, but in the long run it saves you time.
These are the implementations, in alphabetical order:
| Name | a.k.a. | License | Platforms |
| Allegro CL | Commercial | Linux, Unix, Mac, Windows | |
| Armed Bear CL | ABCL | GPL | Linux, Unix, Mac, Windows |
| CMU CL | CMUCL | Open | Linux, Unix, Mac |
| Clozure CL | OpenMCL | LLGPL | Linux, Unix, Mac |
| Corman CL | Commercial | Windows | |
| Embedded CL | ECL | LGPL | Linux, Unix, Mac, Windows |
| GNU CL | GCL | LGCP, GPL | Linux, Unix, Mac |
| GNU clisp | CLISP | GPL | Linux, Unix, Mac, Windows |
| LispWorks | Commercial | Linux, Unix, Mac, Windows | |
| Scieneer CL | SCL | Commercial | Linux, Unix |
| Steel Bank CL | SBCL | BSD/Public | Linux, Unix, Mac |
My deepest thanks to everyone who responded to the survey:
Thanks to Bruce Tate for permission to quote his paper. Special thanks to Pascal Costanza of Vrije Universiteit Brussel, Brussels, Belgium, for all his wise advice and other invaluable help.
To the survey results, I have sometimes added small amounts of material from the implementations' web site.
Note: I did not include in the survey Digitool, Inc.'s MCL. It is still widely-used, but the level of maintenance disqualified it for this survey. Alice Hartley recently announced that it will be open-sourced shortly. The Lucid technology is now available from LispWorks under the name Liquid Common Lisp, but as it is not supported by the major portable libraries and tools, I chose to omit it. (Also, Symbolics's Genera may re-appear, probably as open source, someday, but is currently unavailable for all intents and purposes.)
No-cost (free/open) software is very popular these days, for obvious reasons. However, I urge the reader not to make quick judgments. Speaking of the period 1984-1992, Common Lisp co-designers Guy L. Steele Jr. and Richard Gabriel said: "Though one might think a free, good-quality product would easily beat an expensive better-quality product, this proved false, and Common Lisp companies thrived despite their no-cost competitor [they refer here to Kyoto CL]. It turned out that better performance, better quality, commitment by developers to moving ahead with the standard, and better service were more important than no price tag." That was many years ago. Kyoto CL was amazing -- it took us all by surprise, being developed far away by two young Japanese researchers who had no contact with the CL community at all -- although it left much to be desired. The current no-cost implementations are far better than Kyoto CL was then, both in terms of software quality and maintenance. My only point here is that you should not draw premature conclusions.
Also, don't compare version numbers across implementations. Some version numbering systems are modest. If the implementation says that it's version 1.0.23, that should not be taken to mean anything at all about the age or maturity of the implementation.
Allegro Lisp is a product of Franz Inc. The current release is 8.1. There is a large group of maintainers (more than 10). There is a highly optimizing native compiler on all platforms.
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 http://franz.com/about/company.history.lhtml. 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.
It runs on the following platforms:
32-Bit:
64-Bit:
It is distributed in binary form, in the native format for each operating system.
Allegro CL is not open-source, but much of the source code is available to customers, who must sign a license agreement. Some of our source is open (e.g., AllegroServe). Open-source products from Franz use the LLGPL. Pricing for Allegro CL starts at $599. There is a runtime fee. There are three editions:
Allegro CL has an extensive, modern IDE on Windows and Linux (on GTK) [http://www.franz.com/doc/cgide.htm]. On X11-based systems, Composer is also available [http://www.franz.com/doc/composer.htm]. For those that prefer Emacs, there are two choices: SLIME or our own Emacs-Lisp interface (ELI) [http://www.franz.com/doc/eli.htm].
There are many Common Lisp extensions, including:
There are also the following associated products:
AllegroGraph [http://agraph.franz.com/] -- capable of processing billions of RDF triples, AllegroGraph is a modern, high-performance, persistent, disk-based 64-bit RDF graph database with support for SPARQL, RDFS++, and Prolog reasoning from both Java and Lisp applications. The persistent and scalable 64-bit RDF graph database provides the solid storage layer for powerful reasoning and ontology modeling capabilities.
AllegroCache [http://www.franz.com/products/allegrocache/] -- a high-performance, dynamic object caching database system. It allows programmers to work directly with objects as if they were in memory while in fact the object data is always stored persistently. It supports a full transaction model with long and short transactions, and meets the classic ACID requirements for a reliable and robust database. It automatically maintains referential integrity of complex data objects. AllegroCache provides 64-bit real-time data caching on the application memory to achieve very high data access throughput by applications over as large a data set as necessary. Some of the other features include: bulk loading, transaction logging, expression cursors, range queries, dynamic schema evolution, standalone & client/server operation, native Lisp btrees (comparable in speed with BerkeleyDB, with more control) that supports billions of objects (and terabytes of data), maps, sets, XML export/restore, and user controlled caching.
SOAP API [http://www.franz.com/doc/soap.htm] -- an implementation of the SOAP client and server API, and given a web service WSDL definition we can generate the Lisp functions and definitions needed to send messages to the service and to receive and decode the replies.
jLinker [http://www.franz.com/doc/jlinker.htm] -- interface to Java.
Allegro Btrees [http://www.franz.com/products/allegrocl/acl_btrees.lhtml] -- a high performance btree implementation: * Written completely in Lisp in order to get the best performance possible and the best integration into a Lisp program. * Keys and values are simple vectors of type (unsigned-byte 8). If you wish to store other types of data you have to write encoder/decoders to/from (unsigned-byte 8) vectors. * Extensive support for caching disk blocks to avoid disk I/O.
AllegroServe [http://www.franz.com/doc/aserve/aserve.html] -- a dynamic, high-performance Lisp-based web server that interoperates with other web/application servers.
Allegro Webactions [http://www.franz.com/doc/webactions.html] -- a Web Application Framework for building dynamic web pages that can be easily maintained and updated.
SAX/DOM XML Parser [http://www.franz.com/doc/sax.htm] -- fast, validating XML parser, successfully tested against all major test suites.
An HTML parser [http://www.franz.com/doc/phtml.htm].
XML RPC [http://www.franz.com/doc/xml-rpc.htm] -- allows Lisp applications to communicate via XML.
Lisp RPC [http://www.franz.com/doc/rpc.htm] -- allows Lisp applications to easily communicate.
Allegro Prolog [http://www.franz.com/products/prolog/] -- a classic AI programming language in Allegro CL for Logic Programming, with an execution speed in excess of 1 Mlips and running essentially cons free. It can also be used as a query language for AllegroCache and AllegroGraph.
Regular expressions [http://www.franz.com/doc/regexp.htm#regexp-new-1] A fast, Perl-compatible regular expression matcher.
SWIG interface to C++ -- generate Allegro CL foreign function interfaces to C libraries automatically, using the open source tool SWIG (see http://www.swig.org for more information).
ODBC interface [http://www.franz.com/doc/aodbc.htm].
Allegro Oracle Direct Connect [http://www.franz.com/doc/oracle-interface.htm] -- high-performance direct access to Oracle databases.
Allegro MySQL Direct Connect [http://www.franz.com/doc/mysql.htm] -- high-performance direct access to MySQL databases.
Windows service module [http://www.franz.com/doc/delivery.htm#ntservice-functions-2] -- allows applications to run as a Windows service (like a daemon on UNIX).
Allegro ORBLink [http://www.franz.com/support/documentation/current/orblink/doc/index.htm] CORBA-compliant ORB.
An extensive foreign function interface [http://www.franz.com/doc/foreign-functions.htm], including User-defined foreign types [http://www.franz.com/doc/ftype.htm].
DNS API [http://www.franz.com/doc/dns.htm].
Full Document Object Model (DOM) Level 1 Core API [http://www.franz.com/doc/dom.htm].
Environments [http://www.franz.com/doc/environments.htm], for which our implementation is freely available.
Extensive, time-tested multiprocessing API [http://www.franz.com/doc/multiprocessing.htm].
Common Lisp implementation details are discuss here: * http://www.franz.com/doc/implementation.htm * http://www.franz.com/doc/loading.htm * http://www.franz.com/doc/packages.htm * http://www.franz.com/doc/pathnames.htm
Armed Bear Common Lisp is maintained by Peter Graves. Although it is not his primary project, he still does maintenance releases, most recently in March 2007. The current version is 0.0.10.10.
It is unique in that it runs under the Java Virtual Machine. This means it can take advantage of the highly-optimized Just-In-Time code generators and garbage collectors in each Java implementation. It also allows easy interoperability with Java, giving it access to a very large library.
ABCL was originally intended to be an extension language for the j editor (http://armedbear.org/j.html), but gradually developed into a full Common Lisp implementation, in part so that Paul Dietz's ANSI Common Lisp test could be used. ABCL is not a fork of any other implementation, but it uses code adapted from several of the other free CL's, most notably SBCL and CMUCL. The CLOS implementation started out from Closette, but has changed very much since. From their web site: "ABCL's CLOS is intolerably slow and does not handle on-the-fly redefinition of classes correctly. There is no support for the long form of DEFINE-METHOD-COMBINATION, and certain other required CLOS features are also missing. Enough CLOS is there to run ASDF and CL-PPCRE, if you're in no hurry."
It runs on any platform that supports Java 1.4 or later (which basically means it runs everywhere).
It is distributed in source form.
ABCL is distributed under the terms of the GNU General Public License, with a special linking exception. If you link ABCL with your own program, then you do not need to release the source code for that program. However, any changes that you make to ABCL itself must be released in accordance with the terms of the GPL.
ABCL is still used in the j editor project, and j has a slime-like facility for running Lisp shells. ABCL also works with emacs/slime.
CMU Common Lisp is an open-source project. The current release is 19d (19e is coming soon). There are three primary maintainers, and at least six very active contributors, and volunteers from the open source community. It has an optimized native code generator. It is widely used.
CMUCL was originally 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 was funded by DARPA under CMU's "Research on Parallel Computing" contract. CMUCL has been under continual development since the early 1980's (concurrent with the Common Lisp standardization effort). Most of the CMU Common Lisp implementers went on to work on the Gwydion environment for Dylan. The CMU team was lead by Scott E. Fahlman. The compiler was written by Robert MacLachlan. In 1994, the project funding stopped, and so CMUCL continues as a group of users and developers collaborating over the Internet. Some of the active contributors have included Martin Cracauer, Pierre Mai, Eric Marsden, Gerd Moellmann, Timothy Moore, Raymond Toy, Peter van Eynde, and Paul Werkowski.
CMUCL features a sophisticated native-code compiler which is capable of powerful type inferences, and generates code competitive in speed with C compilers, a graphical source-level debugger using a Motif interface, an interface to the X11 Window System (CLX), and a sophisticated graphical widget library (Garnet), and an Emacs-like editor implemented in Common Lisp.
The CLOS implementation is Xerox's PCL (Portable Common Loops), with many modifications done by Gerd Moellmann.
It runs on the following platforms:
32-bit:
There is no 64-bit version.
There is an ongoing effort to port CMUCL to win32, but no public source code or binaries are available at present.
It is distributed as pre-compiled binaries, and as source. It is available as a .deb package for Debian GNU/Linux, in RPM format for Red Hat/x86, and as a package for the Gentoo Linux distribution.
There are no fees or runtime licenses. It is in the public domain.
CMUCL works well with SLIME and Ilisp with emacs/xemacs.
Clozure Common Lisp (previously and still widely known as OpenMCL).
Clozure CL is maintained by Clozure Associates. There are two full-time maintainers, three half-time maintainers, and several other people (some at Clozure, some not) who contribute. The current version is 1.1.
Its history is an interesting path from commercial, to important government research, and finally to an open source project. In the beginning there was Coral Common Lisp, developed by Coral Software, with CCL 1.0 released in 1987, targeting 1MB MacPlus. Subsequently Coral entered a marketing relationship with Franz under which CCL was renamed to Macintosh Allegro Common Lisp (MACL). This didn't last long, and in 1989 Coral was acquired by Apple. Apple released the Lisp under the name Macintosh Common Lisp (MCL). In 1994, amidst a switch from the 68K to PowerPC CPU for its Macintosh line, Apple transferred MCL to Digitool. Digitool did the port and released a PowerPC version of MCL around 1995.
In 1998, Gary Byers forked a version of the MCL compiler and runtime and ported it to VxWorks and LinuxPPC, at the behest of JPL and Erann Gat (since renamed to Ron Garret) under a source license arrangement with Digitool. In 2001, Digitool agreed to open-source the work that had been done at JPL, and OpenMCL was born. At the time, Gary Byers was involved in Clozure Associates, so Clozure took on hosting and support of OpenMCL. Since then, a lot of development has taken place on OpenMCL, both for clients and work funded directly by Clozure, including ports to several platforms, MOP, native threads, Unicode, and a brand new Cocoa-based IDE for Mac OS (totally unrelated to MCL's IDE).
Many of the original implementors (from Coral) are among the current maintainers.
Originally, MCL supported a pre-CLOS object system, called ObjectLisp, and had an entire IDE, editor, and a bunch of tools written using it. Thus, unlike most other Lisps at the time, we already had a significant body of real code depending on an object system. When it became clear that CLOS would be the object standard for Common Lisp, we were ready to convert the IDE to CLOS. We did not base our implementation on PCL because that would have doubled our memory usage. Therefore our CLOS implementation was written from scratch by Gail Zacharias and Bill St. Clair. This was during MCL's Apple days, so the CLOS implementation was funded by Apple.
In 2007, Alice Hartley of Digitool announced that the original MCL will be open-sourced. In order to avoid confusion with this newly open sourced version of MCL, as well as for a number of other reasons, OpenMCL is being renamed to Clozure CL, or CCL.
It runs on the following platforms:
A port to the Intel-32 architecture is currently underway.
It is distributed in already-compiled form. The command-line versions require manual installation (some script editing, setting a PATH variable, etc). There is a version of for Mac OS that can just be dragged to the Applications folder. In the future, there may be separate "IDE" and "command-line" editions, but not yet.
Clozure CL is Free Open Source Software, with no fees for the development or runtime licenses. All source code is released under the LLGPL. Custom development, and commercial support, are available for a fee from Clozure Associates, which is a software development consulting firm. (This custom development can include changes to Clozure CL as well as applications written in Clozure CL).
All the Emacs-based development packages (slime, ilisp, etc) work with Clozure CL. Also, the MacOS version has a GUI-based IDE written in Lisp using the OS X Cocoa framework.
It is small, fast, and mature. It compiles to native code. The compiler has some lifetime analysis. The Macintosh version supports Cocoa programming through a full-featured Objective C bridge, and has an IDE and tools with real Macintosh sensibility. Even though it's an open-source implementation, its commercial pedigree means it was implemented by professionals, not by students and researchers.
One particularly notable application that uses Clozure CL is ACL2 (A Computational Logic for Applicative Common Lisp), a side-effect free variant of CL with the Boyer-Moore theorem prover, from the University of Texas. It particularly takes advantage of parallelization offered by native threads. Also, Clozure CL's IDE, using the Objective C Bridge, is written in Clozure XL.
Corman Common Lisp is from Corman Technologies, Inc. The current version is 3.01. There is one primary developer and one other developer.
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 we 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.
It runs on the following platforms:
It is distributed in ready-to-install (includes a standard Windows installer) and all pre-compiled. It includes project files that allow users to rebuild it (rebuilding the kernel requires the Microsoft C++ compiler).
All source code is included in the release distribution.
The Corman Lisp compiler is free for personal use, and comes with full source code (in Common Lisp, C++ and assembler). If you wish to use Corman Lisp to create and distribute applications, or in an educational setting, you must purchase a registered copy. If you wish to use the IDE (editor and development environment) for more than 30 days you must purchase a registered copy. See the CormanLisp web site, for details and to download the program:
Licenses are $249, educational discount licenses are $125. There are no runtime license fees of any kind. Once a developer has purchased a license, he or she may create applications and redistribute them or sell them without paying any additional fees. There is only one edition, but it is available either as free, regular license fee, or educational license fee. Only users who have paid the license fee are permitted to distribute Lisp applications. There are other license issues and restrictions included in the installation package. In all cases the distribution is complete and the same--but if the user has not paid the license fee there are some times they will see "nagware" dialogs suggesting they purchase a license.
A multi-windowed text editor for editing, compiling and executing Corman Lisp programs is included. The IDE runs in a different thread than Corman Lisp programs, always allowing full control even while Corman Lisp is running. Note that the sources for this application are not included in this package.
For Windows development, it has very good performance and very tight integration with the operating system. Intel assembly code can be easily embedded in lisp code, lisp code can call native, code, native code can call lisp code, etc. The garbage collector is also very efficient and multiple simultaneous threads are supported.
Embedded CL is community-supported software. The current version is 0.9i. There is one primary developer, plus contributions from the open source community.
It compiles Lisp functions into C functions that use the C stack and standard procedure call conventions. This lets Lisp and C code be easily mixed. It is designed to be used as a C library from any C application. It is embeddable: prominent examples are plugins for Mozilla (e.g. Firefox) and XChat. The code is rather clean and maintainable. It is described as "quite fast". It produces standalone executables for all environments, as well as shared libraries. It can merge C and C++ code. It is described as "rather ANSI compliant".
ECL is based on the Kyoto Common Lisp. The history line is KCL -> AKCL -> EcoLisp -> ECL -> ECL-Spain -> ECL It was originally supported by Giuseppe Attardi. The CLOS implementation is based on PCL. There is a paper at:
It uses a byte code compiler and interpreter, and a translator to C. It can build standalone executables and dynamically-linked libraries that can be incorporated into other C-based programs. It uses the gnu multiprecision library for fast bignum operations.
It runs on the following platforms:
Both 32-bit and 64-bit:
It is distributed in source form (you need a C compiler), but sometimes people make the Windows port available in binary form.
It is free, licensed with LGPL. There are no fees.
(Note: GCL should not be confused with GNU clisp.)
http://www.gnu.org/software/gcl/
GCL has a very long history. It comes from Kyoto Common Lisp, which was written in Japan by T. Yuasa and M. Hagiya, working alone (which greatly impressed the Common Lisp community!). KCL used a compiler that produced C code, which was then compiled into the appropriate machine language. Later, William Schelter at University of Texas at Austin did extensive modifications, the result of which was called AKCL. It was officially adopted by the GNU Project, and is the basis for many open-source Lisp projects, including acl2, axiom, hol88, and nqthm. GCL is also one of the most common Maxima platforms. The CLOS implementation comes from PCL.
The current version is 2.6.7. cvs tag "Version_2_6_8pre" is the next stable release candidate.
The primary maintainer is Camm Maguire, and there are many free-software volunteers. GCL development, like many open source projects, proceeds in bursts. At such times, contributors number from 5 to 10.
It runs on the following platforms:
The source code is freely available, and is licensed partly under LGPL and partly under GPL. Binary distributions are available for major platforms. There are no license fees.
Rather then using threads, GCL provides fork-based parallelism, with p-let, p-and and p-or. It's based on the Unix/Linux "fork" operation, which provides copy-on-write memory pages. This means the child process instantly inherits the parent's memory image, and the operating system only copies pages as they are modified (written) after the fork. GCL allocates on the C stack in the child to avoid GC calls there, which would write to many pages. The result is then printed in the child and read in the parent across a socket. It's quite fast, with a latency around 2ms. The huge advantage in avoiding threads lies in preserving a natural Lisp syntax and keeping all the internals under the hood. The user need not explicitly worry about locks, mutexes, memory corruption, reentrancy/thread safety, spaghetti stacks, etc. Any Lisp function which results in a printable result can be parallelized without modification in this way.
To make parallel programming easier, GCL supports MPI (Message Passing Interface), a standard library API used by mpich, lam, openmpim, et. al. It is used to synchronize data structures across many nodes in a parallel (e.g. "Beowulf" )computing cluster. This can also be used on a single machine to pass data via extremely fast SysV shared memory between processes.
GCL also features:
The following features are in the "head" branch and will be available in version 2.7.0:
(Note: GNU clisp should not be confused with GCL.)
GNU clisp is a free software project. The current release is 2.43. There are two or three (or five, depending on how you count) primary maintainers, plus a community of volunteers.
It is particularly known for running Maxima (the free software derivative of DOE Macsyma), using GNU clisp's SCREEN package. It is also famous for being used in the Viaweb (Yahoo! Stores) application; it also runs Maxima. It features a source-level debugger which allows stepping through interpreted code, form by form.
The pre-history of CLISP started when Michael Stoll read a couple of articles by Martin Gardner (I think) on LISP in "Spektrum der Wissenschaft", the German sibling of the Scientific American. He wrote a Lisp implementation for the Sinclair ZX81. Later, he teamed up with Bruno Haible, and they implemented Common Lisp (based on the original "Common Lisp: The Language") for the Atari/68000, first in assembly language but later (1991/1992) in C. To fit in memory, they wrote a byte-code compiler; much faster than the interpreter but not as good as native code. Bruno put a lot of effort into very efficient arithmetic.
It runs on the following platforms:
It is distributed in binary form for the most important platforms, and in source form. It also comes with most Linux distributions. It's available from the "BSD ports" sites.
The available development environments are: simple command line (supported through the GNU readline library), Emacs SLIME, Emacs inferior-mode, Jabberwocky.
It features a small start-up time, and particularly good support for bignums and arbitrary-precision long-floats, ideal for scientific computation. It has regular expressions, a socket interface, and an X Window System interface. It also features extremely fast bignums. There is a "module" facility allows for easy interfacing to external libraries.
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 * 2005- LispWorks Ltd
The CLOS implementation started out as a branch of PCL (Portable Common Loops).
The current version is 5.0.2.
It runs on the following platforms:
The source code is generally not available. However, most of the editor source is distributed with commercial editions of LispWorks to allow customers to write extensions and customizations in the same way that Emacs users do. Distributions are all already-compiled.
LispWorks is available in three editions:
For a detailed summary of the features in each edition, see:
Development Licensing: A single LispWorks Professional (32-bit) Edition development license for commercial use costs US$1300 / 1200 Euro at the time of writing. A single LispWorks Enterprise (64-bit) Edition development license for commercial use costs US$3900 / 3600 Euro at the time of writing. LispWorks Enterprise (32-bit) Edition is also available, separately licensed at the same price.
Maintenance and support contracts are available as optional extras. Discounted license fees are offered to academic institutions. Quantity discounts and site licenses are available. Current prices are shown at:
On the popular platforms (Windows, Macintosh, Linux, FreeBSD) there are no runtime license fees.
LispWorks comes with its own interactive development environment. LispWorks can also be used with SLIME.
There is a growing list of successsful applications built on LispWorks at: * http://www.lispworks.com/success-stories/
An especially interesting one is InspireData, data visualization software written by Clozure Associates, under contract with TERC, in LispWorks. Originally funded by the National Science Foundation, InspireData lets students in grades 4-12 tools visualize, investigate and understand data in science, mathematics, and the social sciences. In its first six months of release, InspireData sold over 20,000 copies, establishing it the most widely distributed Common Lisp application.
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.
SCL 1.1 was publicly released in September 2002. The SCL 1.2 version was released in September 2003, adding support for 64-bit platforms, and integrating high performance HTTP support. The SCL 1.3 version was released in April 2006 consolidating many improvements and adding support for the Solaris x86 and 64 bit AMD64 platforms.
It also features integrated, high performance, and scalable HTTP support; stream input and output functions are designed for high speed buffered character or octet operation; SSL support (built on OpenSSL)
It runs on the following platforms:
32-bit:
64-bit:
It is distributed in binary form; sources are not available. It is sold as a customized package of licensing and support, generally with per-processor core licensing. There is no distinction between development and runtime. Value-added and embedded licenses can be negotiated. Scieneer says "there are a wide range of licensing and support options that we will consider, so please contact us to discuss licensing and support options." Some prices are presented at:
For development, it supports SLIME and ELI.
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.
SBCL is a volunteer driven project, with no formal controlling organization. During the last year code from approximately 40 persons were merged into SBCL. Of course the level of activity of the individual contributors varies greatly, with the top five accounting for around 75% of the changes. William Harold Newman, Christophe Rhodes, Nikodemus Siivola, and Juho Snellman have been major contributors in the last few years. See:
For an extensive list of people who have worked on SBCL, and on CMU CL before it, see:
The current version is 1.0.11.
It runs on these platforms:
There is work going on to port to Windows x86, but it is still in alpha-testing and considered experimental.
Binaries are available for all platforms, but are generally not made for all platform/release combinations. Thus to get a reasonably new version for some of the rarer platforms will require compiling one.
It is distributed in both binary and source form. The licensing is BSD-style for a few subsystems, and public domain for the rest. There are no fees.
The default SBCL distribution does not include an IDE. Slime is most often used. Due to the overlap between SBCL and Slime contributors, new SBCL features are often integrated to Slime immediately. The Eclipse Lisp IDE Cusp is based on SBCL and the socket protocol of Slime. It provides a read-eval-print loop, a project manager, an outline of your code for simple navigation, a code editor, syntax highlighting, auto-indentation, parenthesis matching, auto-completion, library management, and more.
Steel Bank Studio Ltd exists to provide support and development.
It is notably use in ITA Software's "QPX" airline low-fare search engine, a very large application that is used by Orbix and many airlines.
Some of the terms used above may be unfamiliar to some readers.
"ASDF", which stands for "Another System Definition Tool", is a very widely-used Common Lisp package for compiling and loading programs. Basically, it's Common Lisp's answer to the Unix "make" facility. Nearly all Common Lisp packages are defined using ASDF.
"Bignum" means an arbitrary-precision integer. A bignum can represent any integer, with no limit (until all of virtual memory runs out).
"CLIM" is powerful Lisp-based programming interface that provides a layered set of portable facilities for constructing user interfaces. These include basic windowing, input, output, and graphics services; stream-oriented input and output extended with facilities such as output recording, presentations, and context sensitive input; high level "formatted output" facilities; application building facilities; command processing; and a compositional toolkit similar to those found in the X world that supports look and feel independence.
"CLOS" is the Common Lisp Object System. This is the part of Common Lisp that provides object-oriented programming. It is based on two predecessors: New Flavors, mainly by David A. Moon, which was in turn based on the original Flavors, mainly by Howard Cannon; and CommonLOOPS from Xerox PARC, mainly by Gregor Kiczales and Danny Bobrow. The most comprehensive explanation of CLOS is the textbook by Sonya Keene mentioned below. Sonya Keene was one of the original committee that designed CLOS, and is one of the best technical writers in the world.
"CMU" is Carnegie-Mellon University, the original source CMU CL, Steel Bank CL, and Scieneer CL.
A "conservative" garbage collector does not always know which memory locations might contain pointers to objects, and is sometimes required to preserve storage that it not really made of Lisp objects. A "precise" garbage collector always knows.
"ELI" stands for Emacs-Lisp Interface.
"FFI" means foreign function-call interface, a facility for calling foreign functions, most commonly in C or C++.
"Foreign", in this context, means any language other than Lisp.
"GC" means garbage collector, the subsystem that frees up memory that is no longer in use.
A "generational" garbage collector keeps track of recently-created objects, which are the most likely to be garbage. Almost all new GC's are written using this technology.
"GPL" means the Gnu Public License.
"Gray Streams" (see also "Simple Streams") is an interface that allows a programmer to define a new kind of I/O stream, that can be used with all of Common Lisp's I/O functions such as readline and format. "Gray Streams" was proposed to X3J13 for inclusion in the Common Lisp standard by David N. Gray, then of Texas Instruments. It is supported by Allegro CL, CMUCL, Clozure CL, Embedded CL, GNU clisp, LispWorks, and SBCL. The official definition can be found at:
"LGPL" means the "Lesser" Gnu Public License. The LGPL permits you to link the libraries to "non-free" software without forcing that software to be released under the GPL. See:
"LLGPL" means the "Lisp Lesser" Gnu Public License, like the LGPL with a prequel which defines the effect in terms more typically used in Lisp programs. The obligation to allow for relinking doesn't apply (this was really targeted at the C paradigm).
"MOP" is the meta-object protocol for CLOS. It is not a part of the Common Lisp standard, and there some some small ambiguities in the specification itself, but it is so useful that many CL implementations provide some or all of it. The ultimate reference explanation of the MOP is "The Art of the Metaobject Protocol" by Gregor Kiczales et. al., from MIT Press. But this is heavy reading and you can find simpler introductions (see Papers, below).
"PCL" refers to the Portable Common Loops implementation of CLOS, originally written primarily by Gregor Kiczales at Xerox Palo Alto Research Center (PARC). Many Lisp implementations based their CLOS implementation on this code base. In addition to the implementations described in this paper, PCL was also used in AKCL, Ibuki, Lucid CL, Medley, Symbolics Genera, and Symbolics CLOE.
"Simple Streams" is like "Gray Streams" (q.v.), but it's a different interface, intended to avoid some problems with Gray streams. It was originally designed by Franz, Inc. It is supported by Allegro CL, CMUCL, and SBCL. Documentation can be found at:
"Threads" run concurrently. "Native threads" mean threads provided by the operating system. "Non-native threads" (sometimes called "green" threads) are provided by a library that runs above the level of the operating system. The main advantages of native threads are that other threads can continue to operate when one thread is waiting at the operating system level (e.g. doing I/O); on multi-processor systems, threads can run truly-concurrently utilizing up to as many processors as the hardware provides; interoperability with foreign code work better. The main advantage of non-native threads is that thread-switching overhead is lower. Native threads are also called "preemptive threads", and non-native are also called "cooperative threads", which are better terms insofar as they focus on what behavior you see rather than how the behavior is implemented.
"Unicode" is a representation of characters and strings that allows international character sets, rather than simply the "Latin" set. It is supported by Allegro CL, Clozure CL, partly in Corman CL, GNU clisp, LispWorks, Scieneer CL, and SBCL.
This table shows which implementations are supported by some of the prominent Common Lisp libraries and tools. This table should be seen as information about the libraries and tools, rather than on the implementations. If an implementation is not supported, it may be quite easy to add support.
Most Common Lisp libraries work on all Common Lisp implementations. This is why I omitted such important facilities as ASDF. The ones mentioned here are special because they depend on facilities that are not (yet) standardized in Common Lisp, mainly access to features of the underlying operating systems.
| Name | Slime | McCLIM | Bordeaux | Araneida | Hunchentoot | UnCommon Web | clocc | GBBopen | LTK |
| Allegro CL | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
| Armed Bear CL | Yes | No | Yes | Yes | No | No | No | No | No |
| CMU CL | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
| Clozure CL | Yes | Yes | Yes | Yes | Yes | Yes | Some | Yes | Yes |
| Corman CL | Yes | No | Yes | No | No | No | Some | No | No |
| Embedded CL | Yes | No | Yes | No | No | No | No | Yes | Yes |
| GNU CL (GCL) | No | No | No | No | No | No | No | No | No |
| GNU clisp | Yes | Yes | No | Yes | No | Yes | Yes | Yes | Yes |
| LispWorks | Yes | Yes | Yes | Yes | Yes | No | Yes | Yes | Yes |
| Scieneer CL | Yes | No | No | No | No | No | No | Yes | Yes |
| Steel Bank CL | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
These are some papers about Lisp, many explaining the virtues of Lisp as a language and debunking detractors.
"Common Lisp - Myths and Legends", by Nick Levine and Kent Pitman. A great paper on what Lisp is good for, and answering common misconceptions.
"Lisp and elements of style", by Nick Levine, are notes for a lecture course, with exercises. It has a lot of conceptual background, explaining the motivations and principles of basic features of Common Lisp.
Mainly about why Lisp is good to teach but also a general explanation of Common Lisp's good points, by Stuart Watt:
"Beating the Averages", a famous and influential essay about the benefits of Lisp in general, and how using Lisp was important in the success of Viaweb (later Yahoo! Stores), by Paul Graham:
"Revenge of the Nerds", despite the name, is really about the importance of choosing a programming language, and of course the benefits of choosing Lisp, by Paul Graham:
Paul Graham has written many useful and important essays about Lisp, including a FAQ, famous quotes about Lisp, the history of Lisp, and so on. You can find links to these at:
Pascal Costanza's "Highly Opinionated Guide to Lisp" explains about the nature of Lisp, and is full of useful resources:
"Accelerating Hindsight: Lisp as a Vehicle for Rapid Prototyping", by Kent Pitman, explains what rapid prototyping is about and why Lisp supports it well:
David Lamkins responds to the usual mythical objections to Lisp, and provides some success stories:
"Lisp as an Alternative to Java", Erann Gat of NASA's Jet Propulsion Lab. A short study showing Lisp programs were shorter, took less time to develop, and actually ran faster than the same programming tasks in C++, let alone Java:
How Common Lisp combines object-oriented, functional, and procedural programming within a single, unified system:
"Computational Resources and Efficiency in Lisp" discusses general issues of the performance of Lisp implementations, qualitatively:
A survey of how various people came to be using Lisp, and their experiences:
"Lisp: Good News, Bad News, How to Win Big", by Richard Gabriel, one of the co-designers of Common Lisp. This paper was published in 1991 and so its particulars are out of date. It is a somewhat philosophical examination of good and bad points of Lisp, with suggestions for future directions:
"The Art of Lisp & Writing", by Richard Gabriel, originally written as a foreword for Lamkins's "Successful Lisp" (see above) compares programming with mapmaking and even poetry. It then talks about the use of Lisp as a prototyping language. "Lisp, viewed this way, is a good vehicle for understanding how programming and software development really take place. Because programming Lisp is more like writing than like describing algorithms, it fits with how people work better than the alternatives."
"The Common Lisp Object System: An Overview" by Linda G. DeMichiel and Richard Gabriel, is a good introduction to CLOS written by two of the committee that designed CLOS.
"Warp Speed Introduction to CLOS" by Joe Marshall is a very short introduction.
"Fundamentals of CLOS" by Nick Levine is a much more extensive guide. It describes itself as "an introduction to the 10% of CLOS which you need to get through 90% of use cases."
"A Brief Guide to CLOS" by Jeff Dalton:
"CFFI: The Common Foreign Function Interface" is very complete. CFFI is supported by most of the Common Lisp implementations described in this paper; the site goes into complete detail about implementation support.
"UFFI: Lisp Universal Foreign Function Interface" is very complete. UFFI is supported by most of the Common Lisp implementations described in this paper; the site goes into complete detail about implementation support.
Many successful products and projects were/are written in Lisp. These sites tell about many of them.
"Practical Common Lisp" by Peter Seibel, full text (a very widely used textbook):
"Common Lisp: The Language, 2nd Edition" by Guy L. Steele Jr., full text. This was the basis of the Common Lisp specification, but further changes were made in the X3J13 ANSI standardization process, so it's not quite the last word:
"Common Lisp: A Gentle Introduction to Symbolic Computing" by David Touretzky, full text:
"Common Lisp: An Interactive Approach" by Stuart Shapiro, full text:
"Successful Lisp: How to Understand and Use Common Lisp", by David B. Lamkins, full text:
"On Lisp: Advanced Techniques for Common Lisp" by Paul Graham, full text (more advanced than the others):
"ANSI Common Lisp" by Paul Graham, with sample text (this one is a book that you have to buy, although some of the essays in it can be found on Paul Graham's web site):
"Loving Lisp: The Savvy Programmer's Secret Weapon", by Mark Watson, 2002:
The ANSI Common Lisp specification, as hypertext:
Several good papers about the Common Lisp Object System:
"The Common Lisp Cookbook" is a collection of tutorials, with many helpful hints, including how to set up Emacs. However, it seems to predate SLIME:
"Open Implementations and Metaobject Protocols", by Gregor Kiczales and Andreas Paepcke, about what metaobject protocols are all about:
A facility for searching through documentation on Lisp, mainly the spec and several books:
"Lisp Primer" by Colin Allen and Maneesh Dhagat:
"Object-Oriented Programming in Common Lisp: A Programmer's Guide to CLOS" by Sonya E. Keene, is the best book on CLOS. Unfortunately, it's not available on-line.
A list of books about Lisp:
These web sites are repositories of information about Common Lisp. From them, you can find a huge number of free software libraries and links to other useful sites.
The Common Lisp Directory, everything about Common Lisp: software, people, FAQ's, conferences, etc.
Common Lisp Wiki, mainly links to free Common Lisp software:
The Common Lisp Open Code Collection:
Common-Lisp.net, links to free Common Lisp software and more:
The Association of Lisp Users, an international organization whose mission is: to support the Lisp community by hosting an annual conference and providing administrative support for Lisp-related projects and local user groups:
"The ALU Website Map" contains links to many high-quality articles discussing Lisp language issues such as "compiled/interpreted", "strong/weak typing", "memory management", "macros", "language comparisons", etc., as well as links to tutorials and books and so on.
Links to lots of textbooks and tutorials:
Lots more links to Common Lisp resources:
A meta-blog about Common Lisp:
The Carnegie-Mellon Artificial Intelligence Repository:
This newsgroup is a general discussion of Lisp, primarily about Common Lisp:
A WWW gateway to newsgroups about Lisp, including newsgroups that discuss particular implementations:
Job posting for Lisp programmers:
Papers on the history of Lisp and Common Lisp, in increasing order of detail:
"Finding Lisp", a blog by Dave Roberts:
"Lemonodor", a blog by John Wiseman, mainly about Lisp:
"Lispmeister", a blog run by Markus Fix, mainly about Lisp:
"Exploring Lisp: Writings on Lisp and the process of programming", a blog by Feoff Wozniak:
All kinds of information about Lisp, featuring videos, from Rainer Joswig:
You can find other lists of Lisp implementations at various web sites. However, it is not always clear whether the information is up-to-date, and, of course, you have to trust the authors' opinions.
A very extensive list, including many implementations that are long gone, with brief descriptions, many of which explain the history of the implementation:
A list and comparison of Common Lisp implementations. This is not very thorough and may be out of date.
Another list of implementations, including all of the implementations described above as well as others, can be found under "Implementations" in:
And another comparison, also out of date (April 2006):
A comparison of implementations focusing on their MacOS abilities:
Another:
Also, Rainer Joswig did a survey, similar to this one, specifically directed to MacOS. He wrote it in October 2003 for the International Lisp Conference of 2003, and last updated it in November of 2007. A slightly earlier version can be found at:
And finally, a lovely mini-essay about Lisp, by Bruce Tate, from his paper, "Crossing Borders: The Beauty of Lisp, the El Dorado of Programming Languages":
Lisp has long been recognized as one of the great programming languages. The fanatical following it has inspired throughout its long history -- nearly 50 years -- tells you it's something special. At MIT, Lisp plays a foundational role in the curriculum for all programmers. Entrepreneurs like Paul Graham used Lisp's incredible productivity as the jet fuel for successful startups. But to the chagrin of its followers, Lisp never made it into the mainstream. As a Java programmer, if you spend some time with Lisp -- this lost city of gold -- you'll discover many techniques that will change the way you code, for the better.
I recently finished my first marathon and found running much more rewarding than I ever could have expected. I turned an act as simple as taking a step into something extraordinary for the human body, running 26.2 miles. Some languages, like Smalltalk and Lisp, give me a similar feeling. For Smalltalk, the step is the object; everything in Smalltalk deals with objects and message passing. With Lisp, the foundational step is even simpler. This language is composed entirely of lists. But don't let the simplicity fool you. This 48-year-old language comes with incredible power and flexibility that the Java language can't begin to match.