There seems to be an immediate problem with starting to develop in Common Lisp: choosing an implementation. What should one take into account, and how much weight should it bear when considering a CL implementation?

Should it conform to the ANSI standard? Should it be supported by SLIME? Do certain implementations lack good libraries, documentation, etc?

  • Interesting question: I am reading "Practical Common Lisp" right now and I try out my examples in CLISP, but I guess any implementation conforms with the standard: Common Lisp seems a very mature and stable language to me.
    – Giorgio
    Commented Jan 19, 2013 at 10:30

2 Answers 2


It depends on your specific needs, and the strenghts and weaknesses of the particular implementations. That said, here is what first comes to my mind when thinking about different implementations:

SBCL is pretty fast, and good at number crunching. So, if you depend on heavy numerical computation, that might be the right implementation for you. Also, it has decent type inference (for a Lisp implementation).

CLISP is a relatively small, byte-compiling implementation that might be interesting for scripting.

A few years ago, I tried CCL and stuck with it, because I preferred its error messages and stack traces to the ones of other implementations, as well as its relatively low compilation times. For me, ease of interactive use is something of very high priority. If its speed is needed, I might still switch to SBCL for the deployed program. (Never needed to, though.) Also, there is the option of commercial support.

If you want to deploy on the JVM, there's ABCL.

For embedded use, ECL.

Allegro has AllegroGraph, AllegroStore, a simple to use visual GUI builder, and much more, but not everybody likes their licensing terms.

LispWorks, seems to lend itself pretty well for end-user application programming with a nice cross-platform GUI toolkit and licensing terms that might fit small teams and single programmers better than Allegro's. (At least it's what I'd prefer.)

Of course, these are just broad categories and impressions. I'd suggest taking a closer look at SBCL, CCL, and CLISP, since those are IMHO the most used and best supported open source implementations, then choosing one of those. That is, unless your needs match with what ABCL or ECL have to offer.

Should it conform to the ASNI standard?

It wouldn't be a CL implementation, if it didn't. (There might, of course, be a few deviations in practice, but conformance should at least be the goal.)

Should it be supported by SLIME?

Sure – if you use SLIME. (In my opinion, it's the best Lisp environment available at the moment, but to each his own.)

Do certain implementations lack good libraries, documentation, etc?

At least SBCL, CCL, Allegro, and LispWorks should be well supported by most of the libraries commonly used. CLISP comes with a pretty nice library collection itself, and should also be supported mostly.


Dan Weinreb (unfortunately he passed away last year) wrote an overview:

Lisp Survey

There are many differences between the CL implementations. It is not possible to cover all different needs (speed, size, license, price, compatibility, operating system support, ...) of users for a Lisp system in one implementation. One has to find a local optimum by using one or more of the available implementations, which follow a certain philosophy:

  • free, no-cost, C-based (thus widely ported): ECL, CLISP

  • free, no-cost, JVM-based: ABCL

  • free, no-cost, extensive native implementation: SBCL, CCL, CMUCL

  • proprietary, commercial, very extensive native implementation, excellent support for GUI-based apps: Allegro CL, LispWorks

by OS/Platform:

Not the answer you're looking for? Browse other questions tagged or ask your own question.