Common Lisp Implementations: A Survey

by Daniel Weinreb (dlw@alum.mit.edu)

Version 8 (February 14, 2010)

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. I hope it will help you find the right implementation for your project or product.

This paper also contains pointers to useful Web pages related to Lisp (including many dialects, not just Common Lisp). The organization is:

  • Survey of Implementations of Common Lisp
  • Support by Some Major Libraries and Tools
  • Other Lists of Implementations
  • Glossary
  • Tutorials
  • Papers
  • Success Stories: successful products and projects written in Lisp
  • Common Lisp Textbooks Available On-Line
  • Resources: Repositories of free software libraries, communities, job postings, etc.
  • User Groups
  • Blogs
  • The Beauty of Lisp

Implementations

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.

I have not attempted to determine how closely each implementation adheres to the X3J13 specification. Sadly, there is no comprehensive language compatibility test suite. Such suites are extremely difficult, not to mention boring, to create.

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, Windows
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 CL

http://www.franz.com

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

Update, December 2008: Franz continues to produce technology. They have released support for the Amazon Elastic Computing Cloud (EC2) (available to supported Enterprise Edition customers; for Express or Professional Edition, talk to Franz). They are also continuing to develop and enhanced their Integrated Development Environment (IDE).

Armed Bear CL

Armed Bear Common Lisp development is run by Erik Huelsmann, along with a group of four principal committers and a growing group of incidental contributors. The current version is 0.18.1 (releases are bi-monthly so the number changes frequently); recent work has focused on correctness issues and CLOS performance improvement.

Erik Huelsmann ehuels@gmail.com

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 CL

CMU Common Lisp is an open-source project. The current release is 19e, which arrived in May 2008 (There were new features and many, many bug fixes, including many for double-double-float). 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.

The latest version, as of May 2008, is CMUCL 19e.

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 CL (OpenMCL)

Clozure CL (formerly OpenMCL)

Clozure Common Lisp is maintained by Clozure Associates, a software development consulting company (http://www.clozure.com/). There are two full-time maintainers, three part-time maintainers, and several other contributors (some at Clozure, some not). The current version is 1.4.

Clozure CL has a long history. It began at Coral Software as Coral Common Lisp, which was initially released in 1987, and 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 1989 Coral was acquired by Apple, who released the Lisp under the name Macintosh Common Lisp (MCL). In 1994, amidst a switch 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 PPC embedded systems in 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. Since then, a lot of development has taken place, funded both by clients and directly by Clozure, including ports to several platforms, MOP enhancements, native threads, Unicode, and a brand new Cocoa-based IDE for Mac OS X (totally unrelated to MCL's IDE).

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 (or CCL for short).

Clozure CL 1.4 runs on the following platforms:

The 32-bit x86 ports require a processor that supports the SSE2 instructions.

It is distributed in both binary and source form. The command-line versions require manual installation (some script editing, setting a PATH variable, etc). There is a version for Mac OS X 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 software. It is distributed under the terms of the LLGPL. Fee-based support for Clozure CL is available from Clozure Associates on a per-incident or contract basis.

All the Emacs-based development packages (slime, ilisp, etc.) work with Clozure CL. Also, the Mac OS X version has a GUI-based IDE written in Lisp using the Mac OS X Cocoa framework.

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 CL.

Corman CL

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 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.

It runs on the following platforms:

It will run on 64-bit Vista, in console mode. However, it does not yet compile code to take advantage of 64-bits.

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.

For someone's code (this is not from Corman Technologies) to make Corman CL work better with Emacs:

And Chris Double's libraries and utilities for Corman CL including Gray Streams:

Embedded CL

Embedded CL is community-supported software. The current version is 10.2.1. 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 current maintainer is Juan Jose Garcia Ripoll. 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.

It is a full Common Lisp implementation. You can use it just fine without doing any embedding at all. See

Gnu CL (GCL)

(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:

GNU CLISP

(Note: GNU CLISP should not be confused with GCL.)

GNU CLISP is a free software project. The current release is 2.48, released July 28, 2009. 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 features a source-level debugger which allows stepping through interpreted code, form by form.

The pre-history of CLISP started when Michael Stoll of Munich University 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 of Karlsruhe University, 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. Sam Steingold is the current maintainer (or at least he's one of them).

The most recent release, which arrived in May 2008, is 2.45. It is described as "It mostly supports the Lisp described in the ANSI Common Lisp standard." (Please remember my statement at the beginning: I do not know how closely each implementation adheres to the X3J13 standard.)

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 GNU/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 only needs 4MB of RAM. It has particularly good, high-speed support for bignums and arbitrary-precision floating point, ideal for scientific computation. It has regular expressions, a socket interface, and an X11 Window System interface (through CLX, Garnet, and CLUE (CL User Interface Environment) and CLIO (CL Interactive Objects)). There is a "module" facility allows for easy interfacing to external libraries.

It has a native JIT compiler, based on GNU Lightning.

The user interface comes in English, German, French, Spanish, Dutch, Russian and Danish, and can be changed at run time. It includes a foreign language interface, a socket interface, I18N (internationalization) support. It runs Maxima, ACL2, and many other Common Lisp packages.

More information at

Sources and selected binaries are available by anonymous FTP from

and its mirrors.

LispWorks

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).

The current version is 6.0.

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$1500 / 1200 Euro at the time of writing. A single LispWorks Enterprise (64-bit) Edition development license for commercial use costs US$4500 / 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, Solaris) 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:

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

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)

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.35.

It runs on these platforms:

There is a Windows port, but it is not quite ready for prime time. It can be used for development work. However, it has some limitations. (a) SBCL expects to be able to map various important constants (NIL, T, a few other things) into hard-coded addresses, and this isn't always possible on Windows, so SBCL sometimes won't start on some people's hosts. Rebooting the host or recompiling SBCL with a few changed magic numbers often does the trick. (b) SBCL doesn't yet have threading on Windows (it's being worked on, though). (c) There are some bugs and missing bits having to do with I/O. (d) 64-bit SBCL for 64-bit Windows is not yet ready.

Binaries are available for all supported 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.

For commercial SBCL support and custom development, see Nikodemus Siivola's company:

Support by Some Major Libraries and Tools

This table shows which implementations are supported, and/or have been tested, 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/tested, it may be quite easy to add support, or it might even just work, so don't assume that a "No" is necessarily a big problem.

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, or just because their documentation was explicit and complete regarding implementations.

Name Slime McCLIM Bordeaux Araneida Hunchentoot UnCommon Web clocc GBBopen LTK FSet
Allegro CL Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes
Armed Bear CL Yes No Yes Yes No No No No No No
CMU CL Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes
Clozure CL Yes Yes Yes Yes Yes Yes Some Yes Yes Yes
Corman CL Yes No Yes No No No Some No No No
Embedded CL Yes No Yes No No No No Yes Yes No
GNU CL (GCL) No No No No No No No No No No
GNU clisp Yes Yes No Yes No Yes Yes Yes Yes Yes
LispWorks Yes Yes Yes Yes Yes No Yes Yes Yes Yes
Scieneer CL Yes No No No No No No Yes Yes Yes
Steel Bank CL Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes

Other Lists of Implementations

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:

Glossary

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). All Common Lisp implementations are required to support bignums, but implementing them very efficiently is difficult. Some implmenentations have put more effort into this area than others.

"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" means any programming language other than Lisp (when used in "foreign function call"), or any natural language other than English, depending on context.

"FTP" stands for File Transfer Protocol. This is one of the earliest standard Internet protocols (actually predating the Internet itself!), used for transferring files from one computer to another. Ordinary browsers let you perform FTP transfers by using a URL whose scheme is "ftp", e.g. "ftp://ftp.gnu.org/pub/gnu/clisp/".

"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:

"I18N" means "internationalization", which usually means libraries and other facilities designed to help you write programs that adhere to conventions that differ between countries. The most important is support for alternative character encodings, and usually UNICODE. It can also include support for different formats of printing dates, currency units, and so on.

"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.

"Scheme" is a programming language closely related to Lisp, sometimes called the second main dialect of Lisp. It was originally designed by Guy Steele and Gerald Sussman, at the MIT Artificial Intelligence Lab, in the late 1970's. The most widely-used version is called R5RS; the emerging new version is R5RS. Scheme is clean and minimalist, and provides first-class continuations. It is widely used in college curricula.

"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.

Tutorials

"Common Lisp: First Contact", an easy-to-read, short tutorial for Common Lisp, by Sven Van Caekenberghe.

"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:

A video talk on CLOS by Daniel G. Bobrow, one of the creators of CLOS, about 50 minutes, discussing the history, design criteria (why CLOS was designed the way it was), principal language features, and metaobjects:

"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:

"Lisp Primer" by Colin Allen and Maneesh Dhagat:

A tutorial on the LOOP macro:

"Tutorial on Good Lisp Programming Style", by Peter Norvig (Sun Labs) and Kent Pitman (Harlequin, Inc.), presented at the Lisp Users and Vendors Conference, August 10, 1993. This is half-way between a book and a set of overhead slides, 116 pages in all. It's in PostScript and can be viwed with tools such as GSView from Ghostgum Software:

A list of common pitfalls in Common Lisp:

How to use Lisp to store data on Amazon S3, using Sven Van Caekenberghe's CL-S3 library

There are many more tutorials linked to at:

Papers

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 (Ron Garret) 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:

"Beating C in Scientific Computing Applications" by Didier Verna is an excellent C vs. Lisp benchmark paper.

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.

"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.

McCLIM is an open source implementation of CLIM (Common Lisp Interface Manager), a powerful toolkit for writing GUI's in Common Lisp.

"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.

"Lisp: A Language for Stratified Design", by Harold Abelson and Gerald Jay Sussman, MIT AI Memo 986, August 1987, is a short paper illustrating the power of Lisp as language for expressing the design and organization of computational systems. The paper actually uses Scheme, but it's easy to see how to do the same thing very analogously in Common Lisp.

A setup guide for CLISP, Emacs, and Slime.

And a version for SBCL:

A setup guide for SBCL, Emacs, and Slime under Windows Vista:

A history of macro systems in Lisp and Scheme, particularly about "hygenic" macros.

Documentation for the LispWorks CAPI system. Although this library is implementation-specific, it is of great interest, because of its large role in letting you write applications that look native. The CAPI currently runs under X Window System with GTK+ and Motif, Microsoft Windows and Mac OS X. It creates real native items such as buttons.

Information and bibliography about memory management in general:

Henry Baker has written many interesting papers about Lisp, and Lisp-related issues:

Prof. Shriram Krishnamurthi, a language expert from Brown University, has a nice, understanable example that shows the power of Scheme to make systems easier to write and understand:

Papers on the history of Lisp and Common Lisp, in increasing order of detail:

Information about the European Lisp Workshop since 2004, including the papers themselves, is available at:

Success Stories: successful products and projects written in Lisp

Many successful products and projects were/are written in Lisp. These sites tell about many of them.

[TODO: Put in descriptions!]

SPIKE is the planning and scheduling software used in support of the Hubble Space Telescope. SPIKE is written in Allegro CL and has been made available as a general toolkit for planning and scheduling under Contract NAS5-26555 with the National Aeronautics and Space Administration.

"Little b" is a biology-specific language for producing computer models of biological systems. It's a classic example of how Lisp can be used to create domain-specific languages, in part by using Lisp macros:

"Lisp as a Base for a Statistical Computing System", by Ross Ihaka (U. Aukland, N.Z) and Duncan Temple Lang (U.C. Davis, USA), from the COMPSTAT 2000 Proceedings in Computational Statistics:

AgentSheets AgentSheets is a revolutionary tool that lets you create your own agent-based games and simulations and publish them on the Web through a user-friendly drag-and-drop interface. It was created by Alexander Repenning. It is the only Lisp-based tool that has ever become required technology in public schools.

Our Doings by Bruce Lewis is a nice photo sharing service, built using BRL (Kawa Scheme) (as well as Linux, Jetty, and PostgreSQL). There's a nice explanation of it at:

and you can find it at:

Common Lisp Textbooks Available On-Line

"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:

The "Common Lisp Quick Reference", a pamphlet with quick reminders of how to use Lisp facilities. It comes in various physical configurations.

The differences between the language as described in "Common Lisp: The Language, Second Edition" and the ANSI Common Lisp standard:

A work-in-progress Lisp textbook. It's a Wiki, so you can not only read it but write it, too:

Several good papers about the Common Lisp Object System:

"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:

The author describes this as "one of the most hardcore computer programming books out there. Starting with the fundamentals, it describes the most advanced features of the most advanced language: Common Lisp. Only the top percentile of programmers use Lisp and if you can understand this book you are in the top percentile of Lisp programmers." It focuses on Lisp macros.

"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:

"The Common Lisp Object System MetaObject Protocol" is reference documentation on the CLOS MOP:

"How to Design Programs: An Introduction to Computing and Programming" by Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, and Shriram Krishnamurthi is actually in Scheme rather than Common Lisp, but it's such an excellent book on programming that it's well worth reading:

Resources: Repositories of free software libraries, communities, job postings, etc.

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. There are also URL's for Lisp communities, job posting sites, etc.

The Common Lisp Directory, everything about Common Lisp: software, people, FAQ's, conferences, etc.

Common Lisp Wiki, mainly links to free Common Lisp software:

Starter package (Common Lisp with batteries included). This is a way to get a whole Common Lisp environment, on Windows, based on LispWorks Personal Edition and its interactive development environment (rather than SLIME).

A collection of free Lisp libraries, maintained by Franz Inc. but for everybody:

The Common Lisp Open Code Collection, a collection of free libraries, intended to be portable between implementations:

Common-Lisp.net, administered by Hans Huebner, Drew Crampsie, and Gary [?], links to lots of free Common Lisp software, project hosting for open/free software Common Lisp projects, a list of Lisp-related mailing lists, and more:

Open source (LLGPL) libraries from Franz, Inc., including the AllegroServe web server, URI support, an FTP server, an NFS server for Windows, an XML/HTML parser, and more:

Another repository of code:

Lispbox: A distribution containing a Common Lisp implementation, GNU Emacs, SLIME, ASDF, the code from Practical Common Lisp ready to be loaded using ASDF, and some glue code to make it all easier to use. By Peter Seibel.

Pascal Bourguignon's Lisp libraries

Sven Van Caekenberghe's libraries, movies, a tutorial, etc.

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.

A wiki run by the Association of Lisp Users:

The comp.lang.lisp FAQ (answers to frequently-asked questions). Some of the questions are specifically about the comp.lang.lisp newsgroup, but most are about Lisp itself:

A general explanation of what Lisp is about, with useful links helping you get started:

Links to lots of textbooks and tutorials:

Links to books and papers about learning Lisp:

Lots more links to Common Lisp resources:

A discussion board about Lisp (Common Lisp, Scheme, and other dialects, and tools):

The Carnegie-Mellon Artificial Intelligence Repository:

This newsgroup is a general discussion of Lisp, primarily about Common Lisp. Many people monitor the newsgroup. It's a good place to get questions answered. However, please do not use it to cheat on your school homework by getting someone else to do it for you:

You can access the comp.lang.lisp newsgroup via HTTP, too:

The Common Lisp Document Repository: a repository of printable text documents that contain material that are of interest to the Common Lisp community.

A WWW gateway to newsgroups about Lisp, including newsgroups that discuss particular implementations:

Job posting for Lisp programmers. This is also useful for finding out some of the companies that are using Lisp:

All kinds of information about Lisp, featuring videos, from Rainer Joswig:

Summer of Lisp (Google "Summer of Code" projects):

Slava Akhmechet's articles, many of which are about Lisp, and his Weblocks Common Lisp web framework and cl-cont implementation of continuations in Common Lisp:

New web site for Weblocks:

Lisppaste, a web site for sharing pieces of code, Lisp and otherwise. It is intended for passing code conveniently and readably between users of Internet Relay Chat (IRC).

Videos from Eric W. Normand, that show you step by step how to build a Reddit-like web application in Common Lisp. It uses Edi Weitz's Hunchentoot library, a sophisticated HTTP server, and the cl-who library to generate HTML.

Aquamacs Emacs, by David Reitter and Kevin Walzer, is an Aqua-native build of GNU Emacs, very natural to use on MacOS X. It comes with SLIME.

Cusp is a Lisp plugin for Eclipse, an interactive development environment that uses the back end part of Slime (called Swank). It currently works only with SBCL.

Dandelion is a Lisp plugin for Eclipse, compatible with CLISP and SBCL. At this time, the documentation appears to be available only in German, and is dated July 24, 2007, written by Michael Bohn.

ABLE is a Common Lisp environment for Linux, Windows and MacOS X featuring tabbed editing, a Lisp listener with command history, symbol completion, syntax highlighting, parenthesis matching, automatic indentation, call-tips and Hyperspec lookup. It is written entirely in Common Lisp, using LTK (which interfaces to the Tk toolkit). It supports CLISP, SBCL, and CCL (Clozure Common Lisp, formerly known as OpenMCL). By Phil Armitage.

LispIDE is a basic graphical shell for several Lisp and Scheme implementations available for Windows.

Ready Lisp is a binding together of several popular Common Lisp packages especially for Mac OS X, including: Aquamacs, SBCL and SLIME. Once downloaded, you'll have a single application bundle which you can double-click -- and find yourself in a fully configured Common Lisp REPL. By John Wiegley.

Music software developed at the Stanford University Center for Computer Research in Music and Acoustics (CCRMA, pronounced like "karma"), much of it by noted composer and software expert Bill Schottstaedt:

Another library to generate HTML (and XHTML), by Kevin Rosenberg:

A library to let Common Lisp programs use .Net facilities:

A Common Lisp "FAQ" by Peter Seibel:

CL Gardeners, a project to build a community of Common Lisp users working to make Common Lisp more attractive.

An open-source implementation of PHP in Scheme (!):

A Wiki about Scheme (using Wiki software called WiLiKi, written in the Gauche implementation of Scheme R5RS:

Essays, code, hints, myths, hacks, etc:

Zachary ("Xach") Beane's Lisp libraries:

Zachary ("Xach") Beane's ZS3 library for using Amazon S3:

Lars Rune Nostdal's SymbolicWeb: Common Lisp Web Framework using AJAX and Comet, based on Hunchentoot, and jQuery on the client side. SymbolicWeb allows for two way real-time communication between server and client. Updates or changes can propagate from the server to the client at any time (Comet), while AJAX is used to send messages or events the other way around.

WebActions, from Franz. Inc, is another web framework. It is distributed under the LLGPL.

Pico Lisp, from Software Lab, is a small Lisp dialect focusing on XHTML and CSS for web applications:

A "pastebin" for Lisp code. This is a useful way to share snippets of code with others while you're communicating via IRC (Internet Relay Chat). It displays code with Lisp syntax highlighting.

Alexander Repenning's "Open Agent Engine", a Common Lisp interface to the OpenGL 2D/3D graphics library. OpenGL is an extremely powerful and popular standard graphics specification, for which there are implementations all all major operating systems. It is licensed under LGPL. It runs on Clozure CL and Allegro CL (and the no-longer-maintained Macintosh CL). See:

BKNR is a set of Common Lisp libraries which together form an environment suitable for serving HTTP clients from a persistent Lisp system. BKNR is a pragmatic environment used to create systems for real world users. The major code components of BKNR are:

  • Persistence mechanism based on transaction logging, supporting immutable binary large objects and CLOS persistence.
  • XML processing facilities
  • HTTP application environment with session handling and template engine

It is open-source, under a BSD-style license. It runs on Clozure CL (FreeBSD and MacOS) and SBCL (FreeBSD and Linux). Hans Hubner is the principal developer/maintainer.

Climacs is an Emacs-like editor built on CLIM, that has good integration with other CLIM-based applications. Specialized editors, such as for editing music (see "Some Lisp tools for musicology" by Lewis and Rhodes, 2006). Troels "Athas" Henriksen is the principal developer/maintainer.

Symbolic Composer, from Tonality Systems, is a very extensive system that helps you compose music, using Lisp for algorithmic computing. It currently costs about $400 and runs on MacOS X or Windows.

Robert Tolksdorf keeps a list list of programming languges that are implemented to run on the JVM (Java Virtual Machine). Here, he lists languages in the Lisp/Scheme family:

User Groups

List of Lisp regional user groups:

Montreal Scheme/Lisp User Group:

Chicago Lisp. There are over 20 members.

New York City Lisp Users Group. I am told that this is a very active and large (> 235 members) group.

Scheme Boston

Boston Lispers

Vancouver Lisp Users Group

Bay Area Lispniks

New York Lisp & Scheme Programmers meetup group:

New York Functional Programmers Meetup Group (focuses on Ocaml, Haskell, et. al, but Lisp and Scheme programmers are welcome):

Find a Lisp & Scheme Meetup Group near you:

Mailing lists for Common Lisp topics, including lists for local user groups:

Blogs

(I intended to add more descriptive text about the individual blogs.)

A meta-blog (aggregation of blogs) about Common Lisp, by Zach Beane:

"Finding Lisp", a blog by Dave Roberts. It seems to have stopped around December, 2008, presumably succeeded by Dave Roberts's LispForum web site (www.lispforum.com):

"Lemonodor", a blog by John Wiseman, mainly about Lisp. It seems to have stopped publishing around September 2008, but the archives go back to November 2001 and have some very interesting material:

"Lispmeister", a blog run by Markus Fix, mainly about Lisp (tried it on 5/23/2009, timed out):

"Exploring Lisp: Writings on Lisp and the process of programming", a blog by Geoff Wozniak (active):

"Wingolog", by Andy Wingo (active):

"Programming Musings", by Jose Antonio Ortega Ruiz (active):

"Smug Lisp Weenie", a blog by Kenny Tilton:

Dan Weinreb's blog, which has Lisp articles from time to time:

Another Lisp-related blog, by Lukas Macedo

"Informal Methods", a blog with interesting Lisp-related postings:

Another blog, by Mikael Jansson:

A very interesting blog, by Eric W. Normand

"unClog: opening it up with Common Lisp", by Gary King of (among other things) Franz Inc.

Joseph Gutierrez's blog about Lisp style:

Nicky Peeters's blog about Common Lisp and other subjects:

Someone's (who works at stix.to?) blog about Lisp:

Hans Huebner's blog:

Common Lisp Weekly News:

Another good blog with a lot about Lisp:

"Rondam Ramblings", by Ron Garret:

"Send More Paramedics", by Fogus:

(within parens...) by Marco Antoniotti

"Tamas K. Papp's Blog":

"random-state.net", by Nikodemus Siivola (one of the SBCL maintainers):

See also:

The Beauty of Lisp

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.