These are some free Lisp implementations.

I haven't included Scheme implementations written in Java because I've never found a decent free Java.

What's all this, then?

Originally, I was looking for a Lisp that would do fast bignum operations -- either natively, or by linking to some library such as GNU gmp or OpenSSL via some extension mechanism. Why I wanted to do this is too complicated to get into. Another requirement was that it work on Windows as well as *nix. Anyway, I investigated lots of implementations, and of course went overboard doing so. I've accumulated my research here, and still occasionally update it when I learn something interesting. Of course, I still obsessively update my shopping-for-wristwatches page despite having settled on a nice watch years ago, so what does that tell you ...

Executive summary

As of Jan 2004, the only systems that do everything that I originally wanted, and are tolerably fast, are

  • guile 1.6 with OpenSSL, although 1.8 probably works too

    • This first table shows those implementations that might have all my favorite criteria -- indicated by the tildes in the column headers. (Those are there merely to get the columns to sort the way I want.) They're ordered with the fastest ones first.

    Note: the version numbers you see below aren't meant to indicate the latest version available; they're just the version that I tried.

    Note: when the column about bignums refers to speed, it's talking about the speed of the native implementation, not the speed of some math library like GNU gmp or OpenSSL that I might link in.

    _implementationgui-friendlyhas-profilernotesthreadsunicode~bignums~windoze-ffi~xml-parsing
    guile 1.8 (from CVS)NopeyesUses GNU gmp, hence very fast: about twice as fast as Clisp.Didn't build cleanly on Cygwin as of May 2004 (missing declaration for siginterrupt, and the built binary immediately dies with a Windows popup).SSAX
    Perl 5.8.2Easy access to lots of toolkitsNot a Lisp at all, of courseDon't think soYou betchaGNU gmpNot that I know of, but not needed. One problem, however: Math::Bignum::GMP doesn't currently build on CygwinApproximately one million options
    recent PythonEasy access to lots of toolkitsNot a Lisp at all, of coursebuilt-inProbably not needed. Presumably
    ClispDon't think so

    Dan Barlow says it has "very fast bignum support"; my tests confirm this

    This site might have some FFI tips

    		Don't think soUCS-4yes; about twice as fast as mzschemeBoth Cygwin and Win32, but I haven't figured it outxmls looks promising
    mzschemeMrEd -- slickWell, DrScheme does; I don't know if it's accessible from mzscheme
    • Built-in GUI tester
    • Supposedly mzscheme can be made into an operating system kernel. I swear I'm not making this up.
    • Bignums as fast as any Scheme I've tried. Perhaps this is because the source includes a copy of GNU gmp
    • The documentation is a little thin, but the developers have published a number of academic papers which motivate many of the features. Here is a good place to start looking.
    		yesYes, starting with version 300yes; about twice as fast as guile 1.6 without GNU gmp or OpenSSL, and half as fast as clisp

    yes, but I haven't yet figured out how to load extensions on Windows.

    version 300 has a remarkably sophisticated system, which promises to be very easy to use

    both SSAX and a built-in library. It generated this page, for what that's worth.

    guile 1.6has some GTK
    • Frustratingly sparse FFI documentation
    		yes, although I dimly recall them being unreliableyes; about twice as fast as gambit, and half as fast as mzschemeOK with Cygwin. In fact, this is the only Lisp with which I haven't had the usual I-can't-dlopen-a-DLL-on-Windows trouble.I suspect SSAX will work
    gambit 4.0Guillaume Germain's 'statprof'yesyesHaven't yet tried
    Petit LarcenyWorked only on Sparc and Mac OS X for a long time; the x86 support is new as of January 2006, and I haven't yet tried it.yes
    Jazz SchemeI know nothing about it other than what I gleaned from a quick glance at its home page

    The following table includes implementations that seem to lack at least one of the qualities I most want. They're not in any particular order.

    _implementationgui-friendlyhas-profilernotesthreadsunicode~bignums~ffi~windoze~xml-parsing
    lushAppears to have frighteningly-sophisticated graphics bindingsBy an amazing coincidence, this software has the same name as my wife's all-time favorite storesurprisingly, noCygwin
    MaximaA computer algebra system implemented in Common Lisp. Unfortunately there's no way to directly access Lisp from it, never mind that the manual says that you can.GNU gmp, so they say
    scheme48/scshapparently not Apparently they're pre-emptive, even on POSIX systems that don't themselves provide threads. Presumably the magic happens inside the VM, between virtual instructions.Here's a paper describing how it all worksyes, but too slowalmost OK with Cygwin, except my call to 
    (dynamic-load "./bignums.so")
    hangs    		yes, although scsh-0.6.6 didn't build on Cygwin (May 2006)straightforward via SSAX
    Tiny SchemeSure is tiny.no
    CMU Common LispHas some rather ancient bindings, I think; "CLX" comes to mindprobablydon't think soyesYes, but I haven't figured out how to use it :(no; x86 unix only
    Steel Bank Common LispHas some rather ancient bindings, I think; "CLX" comes to mind

    Dan Barlow seems to be working hard on it, and there seems to be a genuine community using it

    		in recent versions; may not be stabledoubt ityesHaven't figured it out either, but I'm encouraged to read here: sb-grovel : Tool for extracting constants and structures from C headers, for use in ~FFI codedoubt it

    GNU Common Lisp

    		Sparse-to-nonexistent documentationprobablyyes
    MIT 7.7.1"a simple two-dimensional line-graphics interface"
    • I've never heard of anybody using it for anything useful
    • Edwin is much more Emacs-like than I remembered. It seems comfortable, modulo a few surprising keybindings.

    (apropos 'thread) yields a lot of interesting-looking hits

    		Apparently notyes
    bigloo 2.5cbiglooksupposedlycoop yesnoyes yes

    chickenVersion 2, Build 206

    		`There's a Gtk binding somewhere for it, I think.', says RiastradhYes, according to Riastradh
    • easy to use
    • both the csi interpreter, and the compiled code, seems ungodly slow
    • Seems quite active, as of December 2005
    • "Chicken is mostly a one-man, hobbyist project" -- so says felix, the implementor
    		SRFI-18, says Riastradhyes, with this standalone gmp binding

    Yes: "straightforward" and "easy", according to the home page

    A remarkably simple-looking alternate FFI is available from here

    gauche 0.6.8Has GTK and OpenGL bindings, for what that's worthsupposedlySupports lots o' SRFIs.yes -- SRFI-18 on pthreadsyesApparently notyes
    scm 5d6probably not Apparently notmoribund (1996) port
    Rscheme v0.7.3.3-b20u, 2004-04-02no, even though it uses GNU gmp for something or other.
    stklos 0.57yes -- gtk apparently not yes; probably fast since the code appears to incorporate GNU gmpno (fails to build), even though the file PORTING-NOTES implies that it can be made to build on Cygwin
    Stkmoribund: September 1999; presumably StkLos is its successor
    stalin 0.9hard to figure out how to use it
    Goo 0.153ApparentlyA new language inspired by scheme. Unlike Arc, goo is "particularly object-oriented"."experimental"Apparently, in versions 155 and laterApparently notApparently; a kludge to get it to talk to GTK is here
    oaklispmoribund: Jan 2000
    petit chezyesnot obviously free
    Pico Lisp
    • I know very little about it, but it's ... intriguing
    • This is the (somewhat notorious) system that has only dynamic binding

    And these don't even exist yet.

    _implementationgui-friendlynotesthreadsunicode~bignums~ffi~windoze
    Minor Schemegtk 2.0
    • Designed by Jim Blandy, who strikes me as a Smart Person
    • It's a native-code compiler
    		yes indeedyesyesyes indeedno -- IA-32 Linux only
    arcDoesn't yet exist, at least not for public consumptionpresumablyone would hopepresumablyI'd be surprised, although perhaps on Cygwin

    Other lists

    So what we have now is a zillion Schemes, about three of which [MIT, Chez, & Scheme48] are good bases left over from the eighties (excluding the Yale dialect), and most of the rest of which are kludges piled on top of kludges to try to make toy interpreters useful. There are a few other decent ones, too, like Gambit, Chicken, & Stalin.
    -- Riastradh

    In finest nerdly tradition, this page was generated by mzscheme from $Id: lisps.scm 3623 2007-05-24 21:13:05Z erich $.