Common Lisp Implementations

up
prev next

search
site map
navigate
about

<*lisp*>
<*learning*>
<*applications*>
<*tools*>
<*community*>
<*references*>
<*SYSTEMS*>
<*related*>

 This is a central listing of suppliers of Lisp and Lisp products. It includes commercial and free Common Lisp implementations and suppliers of language applications intended to work in conjunction with one or more of these implementations. The implementations listed here purport to be at least "close" to early Common Lisp as defined in CLtL1. Some implementations for other dialects of Lisp are listed on the related languages page.

Commercial vendors

Commercial PC (non-UNIX) Lisp Implementations

Commercial Macintosh Lisp Implementations

Commercial UNIX Lisp Implementations

Other Commercial Lisp Implementations

  • Butterfly (BBN)
  • Genera Lisp machines (Symbolics)
  • Explorer Lisp machines (Texas Instruments)
  • L embedded systems (IS Robotics)
  • *Lisp (Thinking Machines)

Free Implementations

Free PC (non-UNIX) Lisp Implementations

Free Unix Lisp Implementations

    Other Free Lisp Implementations

    • cl.el Embedded in Elisp (GNU)
    • ALSP Embedded in ADA (Software Architecture and Engineering)
    • AWK Lisp Embedded in AWK (Roger Corman)
    • StarSim Embedded in CL (Thinking Machines)

    Brief Descriptions

    Giuseppe Attardi (ECoLisp)

    ECoLisp (ECL, Eco Common Lisp) is a Common Lisp implementation which 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. ECL also includes MTCL, a multithread facility, and CLOS.

    This is an alpha release.

    BBN, Inc.

    BBN has a special purpose machine called the Butterfly, which runs both Common Lisp and Scheme. The source code for both has been made publicly by BBN.

    Bill Birch (RefLisp)

    RefLisp is a small Lisp interpreter. Versions exist for MS-DOS and UNIX (AIX). The MS-DOS version supports CGA/EGA/VGA graphics and the Microsoft Mouse. The interpreter is a shallow-binding (i.e., everything has dynamic scope), reference counting design making it suitable for experimenting with real-time and graphic user interface programming. Common Lisp compatibility macros are provided, and most of the examples in "Lisp" by Winston & Horn have been run on RefLisp. RefLisp makes no distinction between symbol-values and function-values, so a symbol can be either but not both. RefLisp comes with an ASCII manual and many demonstration programs, including an analog clock which never stops for garbage collection. There is also a program profiler.

    CMU Common Lisp (CMUCL)

    CMU Common Lisp (or CMUCL for short) is an implementation of the Common Lisp programming language. Though it originated at CMU, a group of individuals now maintains and enhances it.

    CMUCL's focus is on a portable compiler which, mostly through a deeper-than-usual understanding of Common Lisp source, generates high-quality native code. It is particularly strong on number-crunching programs.

    Other features include an efficient and elegant interface to foreign code, and pre-defined access methods for most Unix system calls.

    CMUCL comes with a variety of tools, among them:

    • Hemlock, an emacs-style editor which is entirely implemented in and extensible through Common Lisp. It lives in the same world as the Lisp image you are working with. This means that all code you wrote in CL can be used to customize your editor and the editor has full access to the status of the running Lisp without the need for a hidden interface to "interview" it.
    • Various debugging and profiling utilities.
    • Interfaces to X11 (CLX) and Motif.
    • CLOS based on PCL.
    • Generational garbage collection on some platforms.
    • The compiler not only generates good code, but also gives a lot of feedback to the programmer, providing extensive hints on how to optimize the code by using declarations.

    CMUCL is available on

    • Intel x86/FreeBSD
    • Intel x86/Linux (libc5 and glibc2)
    • SPARC/SunOS4 (aka Solaris 1)
    • SPARC/SunOS5 (aka Solaris 2)
    • PA-RISC/HPUX (problems on some HPUX versions, check the mailing list archives)
    • DEC Alpha/OSF1 (aka Digital Unix aka Compaq Tru64 Unix)
    • SGI/Irix6

    CMUCL is public domain software; users may do anything with CMUCL and its sources, including linking it to other object files, and basing proprietary systems on it. CMUCL benefits greatly from the large number of individuals having access to the system and its sources. Without their feedback, many annoying bits couldn't have been eliminated.

    Although CMUCL has not yet been revised to be compliant with the ANSI Common Lisp standard, it runs practically all free Common Lisp packages (except those that are written just for one CL implementation), such as CL-HTTP, Garnet, MK:DEFSYSTEM, Screamer, and CLIO/CLOE.

    SBCL

    Steel Bank Common Lisp (SBCL) is a derivative of CMUCL, with a focus on easier maintainability. See the SBCL web site for details.

    Conscious Computing (LinkLisp)

    LinkLisp is a Lisp implementation for Windows that supports a large subset of Common Lisp. It is DLL and VBX callable from C/C++ and Visual Basic. It costs $249.

    For more information, write to Conscious Computing, 3100 Connecticut Avenue NW, Suite 202, Washington, DC 20008, call 202-483-6350, or fax 202-462-9110.

    Roger Corman (CormanLisp, PowerLisp)

    Corman Lisp is a Common Lisp compiler and development environment for Windows 95, 98 and NT platforms. It consists of a Common Lisp native code compiler and an editor/development environment. Corman Lisp was designed for high performance, with a generational garbage collector, foreign function interface, optimizing compiler, built in x86 assembler, and the ability to create Win32 applications. A C header parser makes it simple to link to new OS modules. Multiple threads are supported, with the IDE running in a separate thread and each Lisp thread running in a separate OS thread.

    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.

    PowerLisp is a Common Lisp development environment for the Macintosh. It consists of a Common Lisp interpreter, native-code 680x0 compiler, 680x0 macro assembler, disassembler, incremental linker and multi-window text editor.

    PowerLisp has the ability to run in the background. While executing a Common Lisp program, the user may switch to another application as it continues to run. You can also edit programs while a Common Lisp program is running.

    PowerLisp is targeted to be compatible with CTLTL2 without CLOS (for now) but some Common Lisp functions are not yet implemented. Upcoming versions should include the remaining language features.

    Documentation in Word and MacWrite format and sample programs/source included.

    See the PowerLisp web site for details.

    Digitool, Inc. (MCL)

    Macintosh Common Lisp is a commercial Common Lisp implementation for the Apple Macintosh. It includes a native CLOS, Macintosh Toolbox/interface toolkit, ephemeral garbage collection, incremental compiler, window-based debugger, source-code stepper, object inspector, emacs-style editor, and a foreign function interface. Compilers are included for both 68K and PowerPC targets. CLIM 2.0 is available as an extra-cost option.

    MCL requires Macintosh System Software 7.5 or later, or Mac OS 8.0 or later.

    Elwood Corp. (Eclipse)

    Eclipse is a complete ANSI Common Lisp, made available to programmers in two ways:
    • A traditional top-level Lisp listener.
    • A C library containing all ANSI functions and data types. The functions use normal C naming and argument passing conventions.
    In addition, the Eclipse compiler can be used to generate human-readable C code which uses the library. The generated functions and variables use normal C naming and argument passing conventions.

    Complete applications can be written in C or translated from Lisp to C using the Eclipse compiler. Object files are then produced using any C compiler and linked to the Eclipse library to produce stand-alone executables which can be run without the top-level Lisp listener.

    Franz, Inc. (Allegro)

    The Allegro CL 3.0 Web Version for Windows is a full functional free version of Franz's Dynamic Object Oriented Programming Development System for ANSI standard CLOS, with some limitations:
    limited heap size, no foreign function support, missing compile-file, missing disassembler and missing save-image. The documentation fully explains these capabilities.
    This version includes an in-core native 32-bit compiler, a drag & drop Interface Builder, full debugging and development tools and an editor. Franz sells a supported version of this software, Allegro CL for Windows, without these limitations.

    Allegro Common Lisp 4.2 runs on a variety of platforms, including Sparcs, RS6000, HP700, Silicon Graphics, DecStation (prices start at $4,500) and NeXT ($2,000). It requires 12mb RAM for the 680x0 and 16mb for RISC. It includes native CLOS, X-windows support, Unix interface, incremental compilation, generational garbage collection, and a foreign function interface. Options include Allegro Composer (development environment, including debugger, inspector, object browser, time/space code profiler, and a graphical user interface, $1,500), Common LISP Interface Manager (CLIM 2.0 is a portable high-level user interface management system. CLIM 2.0 for Allegro CL supports both Motif and Openlook and Windows, ($1,000). Franz also markets Allegro CL 3.0 for Windows 3.1, Windows NT and Windows95 for $595 (discount prices of $449 are sometimes advertised in various AI magazines). A Professional version with royalty free runtime distribution and source code is available for $2495. Allegro CL for Windows provides 32-bit compilation, complete CLOS, an integrated development environment, visual drag & drop Interface Builder, interface to the Windows API, DLL support, and free runtime delivery.

    Note that Franz Lisp is an earlier (not Common) Lisp dialect that is closer to Maclisp than to the Allegor Common Lisp that Franz, Inc. now produces.

    Free Software Foundation (GNU, Elisp, GCL)

    The Free Software Foundation (FSF) was founded by Richard Stallman to produce good quality, free software. They produce:
    • A text editor widely used by programmers: EMACS.
    • One of the most popular C/C++ compilers: GCC.
    • Three kinds of Lisp:
      • Elisp is what the Emacs text-editor is programmed in.
      • GCL is a Common Lisp.
      • GUILE is a Scheme-based scripting language.
    • Lots of other stuff. The goal of the GNU project (Gnu's Not Unix) is to replace all of Unix with free software, one piece at a time.

    GNU Common Lisp (GCL) is a highly portable implementation of Common Lisp originally based on Austin Kyoto Common Lisp (AKCL), a Common Lisp (CLtL1) implementation developed at Kyoto University in Japan and extended by Bill Schelter of UT/Austin. GCL is intended to eventually support the ANSI Standard for Common Lisp. GCL generates C code which it compiles with the local optimizing C compiler (e.g., GCC).

    GCL has a source level debugger for interpreted code, profiling tools based on the C profiling tools, and supports CLX, and PCL.

    Gold Hill (Golden CL)

    Golden Common Lisp (GCLisp 4.4) runs on IBM PCs under DOS, Windows, OS/2, and Windows NT, costing $2,000 ($250 extra for Gold Hill Windows), and includes an incremental compiler, foreign function interface, interactive debugger, SQL interface, and emacs-like editor. It supports DDE and other Windows stuff, and is CLtL1 compatible. Supports PCL/CLOS. It requires 4mb RAM, and 12mb disk. See a review in PC-WEEK 4/1/91 comparing GCLisp with an older version of MCL.

    Xanalys (LispWorks, Liquid, Lucid, FreeLisp)

    Xanalys's LispWorks (R) for the Windows (R) operating system ("LWW") runs on Windows NT, 95 and 98. On Unix platforms LispWorks runs on Sun Sparc and clones (SunOS and Solaris), IBM RS/6000 (AIX), DEC Alpha (OSF/1), HP PA (HP-UX), and SGI (IRIX). Liquid CL (formerly Lucid CL) runs on the same range of unix platforms with the exception of DEC Alpha.

    All editions implement the ANSI Common Lisp standard and come with native CLOS/MOP, incremental compiler, interpreter, dynamic loader, and tools for inspection, profiling, disassembly, stepping and tracing. Language extensions include: full multithreading, foreign language interface, defsystem, support for internationalization through Unicode, programmer-extensible streams, TCP socket streams, object finalization, weak vectors and hash-tables, LALR parser generator, CAPI portable GUI toolkit.

    All editions support the Common LispWorks IDE, which provides a smooth and comfortable workflow, allowing you to incrementally write, test, and extend your software while it is running. Features include: interactive listener; debugger; object inspector; browsers for classes, generic functions, compilation conditions; profiler; integrated extensible editor; build system manager; source code location and cross-referencing tool; complete online documentation.

    The Professional Edition of LWW includes everything you need for commercial Common Lisp software development and application delivery. CLIM 2.0 is included to further increase program portability. Applications developed with the Professional edition can be distributed free of charge.

    The Enterprise Edition of LWW extends the Professional Edition, providing portable distributed computing through CORBA, database access through object-oriented SQL/ODBC libraries, expert system programming through KnowledgeWorks and an embedded Prolog compiler. On Unix the SQL interface is part of the LispWorks product and libraries supporting product delivery, CORBA, CLIM and KnowledgeWorks may be purchased separately.

    On the other hand the Personal Edition of LWW is intended for personal and educational Lisp programming. As a contribution to the Common Lisp community, Xanalys is making the Personal Edition of LispWorks for Windows available free of charge from its Web site. While the Personal Edition includes the full Common Lisp compiler and development environment, it does limit program size and duration and it does not support application delivery.

    Wade Hennessey (WCL)

    WCL is an implementation of Common Lisp for Sparc based workstations. WCL provides a large subset of Common Lisp as a Unix shared library that can be linked with Lisp and C code to produce efficient and small applications. For example, the executable for a Lisp version of the canonical ``Hello World!'' program requires only 40k bytes under SunOS 4.1 for SPARC. WCL provides CLX R5 as a shared library, and comes with PCL and a few other utilities.

    IS Robotics (L)

    "L" is a Common Lisp subset for real-time embedded systems. This is the stuff that makes those "bug" robots work.

    U. Karlsruhe & Munich U. (CLISP)

    CLISP is a Common Lisp implementation by Bruno Haible of Karlsruhe University and Michael Stoll of Munich University, both in Germany. It mostly supports the Lisp described in "Common LISP: The Language (2nd edition)" and the ANSI Common Lisp standard. It runs on microcomputers (DOS, OS/2, Windows NT, Windows 95, Amiga 500-4000, Acorn RISC PC) as well as on Unix workstations (Linux, SVR4, Sun4, DEC Alpha OSF, HP-UX, NeXTstep, SGI, AIX, Sun3 and others) and needs only 2 MB of RAM. It is free software and may be distributed under the terms of GNU GPL. The user interface comes in German, English, French and Spanish. CLISP includes an interpreter, a compiler, a large subset of CLOS, a foreign language interface and a socket interface. Packages running in CLISP include PCL and, on Unix machines, CLX and Garnet.

    U. Kiel (CLiCC)

    CLiCC (Common Lisp to C Compiler) generates C-executables from Common Lisp application programs. CLiCC is not a Common Lisp system, and hence does not include any program development or debugging support. CLiCC is intended to be used as an add-on to existing Common Lisp systems for generating portable applications. CLiCC (version 0.6.2) can now compile itself to get a standalone compiler that may be used without a Lisp system. CLiCC supports CL_0, a subset of Common Lisp + CLOS, which excludes EVAL and related functions. At present CL_0 is based on CLtL1, but is headed towards CLtL2 and ANSI-CL. The generated C code (ANSI-C or K&R-C compatible) may be compiled using a conventional C compiler on the target machine, and must be linked with the CLiCC runtime library in order to generate executables. CLiCC has a foreign function interface.

    The generated C code is not readable in the sense of hand written C code. It results from a direct translation of abstract machine code to corresponding C constructs.

    Written by Wolfgang Goerigk, Ulrich Hoffman, and Heinz Knutzen

    Kyoto U., Austin Code Works, Ibuki Inc

    Kyoto Common Lisp (KCL) is a highly portable and implementation of Common Lisp originally developed at Kyoto University in Japan. KCL conforms to CLtL1. Austin Kyoto Common Lisp (AKCL) is a collection of ports, bug fixes and improvements to KCL written by Bill Schelter. {A}KCL generates C code which it compiles with the local C compiler.

    It is recommended that you use AKCL and not try to compile KCL, since KCL is unlikely to work with current operating systems.

    Commercial versions of {A}KCL are available from Austin Code Works, 11100 Leafwood Lane, Austin, TX 78750-3409, Tel. 512-258-0785, Fax 512-258-1342, E-mail guthery@acw.com, including a CLOS for AKCL.

    Ibuki Common Lisp is a commercialized and improved version of Kyoto Common Lisp. It runs on over 30 platforms, including Sun3, Sparc, Dec (Ultrix), Apollo, HP 9000, IBM RS/6000, Silicon Graphics and IBM PCs. It includes an incremental compiler, interpreter, foreign function interface. It generates C code from the Lisp and compiles it using the local C compiler. Image size is about 3mb. Cost is $2800 (workstations), $3500 (servers), $700 (IBM PCs). Supports CLOS and CLX ($200 extra). Source code is available at twice the cost. Ibuki now also has a product called CONS which compiles Lisp functions into linkable Unix libraries. Write to: Ibuki Inc., PO Box 1627, Los Altos, CA 94022, or call 415-961-4996, fax 415-961-8016, or send email to Richard Weyhrauch, rww@ibuki.com or support@ibuki.com.

    A port of AKCL to DOS is in beta test.

    GCL is based on AKCL.

    Microcomputer Systems Consultants (NanoLISP)

    NanoLISP 2.0 is a Lisp interpreter for DOS systems that supports a large subset of the Common Lisp (CLtL2) standard, including lexical and dynamic scoping, four lambda-list keywords, closures, local functions, macros, output formatting, generic sequence functions, transcendental functions, 2-d arrays, bit-arrays, sequences, streams, characters double-floats, hash-tables and structures. Runs in DOS 2.1 or higher, requiring only 384k of RAM. Cost is $100. Write to: Microcomputer Systems Consultants, PO Box 6646, Santa Barbara, CA 93160 or call 805-967-2270.

    Poplog

    Poplog is a programming environment implementing several languages, including Common Lisp, ML and Prolog. The environment includes a customizable multi-font editor (VED) support for X, and hypertext help and tutorials.

    Poplog is now available for free, with sources.

    Roger Rohrbach (AWK Lisp)

    AWK Lisp is a Lisp interpreter implemented in Awk.

    It provides intrinsic versions of the basic functions on s-expressions, and many others written in LISP.

    The interpreter has thirteen built-in functions: car, cdr, cons, eq, atom, set, eval, error, quote, cond, and, or, list. These include the five elementary functions on s-expressions defined by McCarthy; some conditional expression operators; an assignment operator, and some functions to control the evaluation process.

    Sapiens Software (Star Sapphire)

    Star Sapphire Common LISP 3.4 provides a subset of Common Lisp and includes an emacs-like editor, compiler, debugger, DOS graphics and CLOS. It runs on IBM PCs (MSDOS or Windows), requires 640k RAM, a hard disk, and costs $100. Write to: Sapiens Software Corporation, PO Box 3365, Santa Cruz, CA 95063-3365, call 408-458-1990, fax 408-425-0905/9220. Copies may also be ordered from the Programmers' Shop at 800-421-8006. Sapiens Software also has a Lisp-to-C translator in beta-test.

    Roger Sheldon (LILY)

    Lily (LIsp LibrarY) is a C++ class library that lets C++ programmers write LISP-style code. Includes some example programs from Winston's Lisp book recoded in Lily. Most or all of chapters 17 (Symbolic Pattern Matching), 18 (Expert Problem Solving), and 23 (Lisp in Lisp) are implemented in the examples.

    This package is mainly useful in academia for instructors who wish to teach AI techniques in C++. The garbage collection mechanism is rather slow, making it unattractive for industrial use.

    Requires: GNU G++ (2.4.5 or later) or Turbo C++ for Windows.

    Soft Warehouse, Inc (muLISP-90)

    muLISP-90 v7.1 is a small Lisp which runs on IBM PCs (or the HP 95LX palmtop), MS-DOS version 2.1 or later. It isn't Common Lisp, although there is a Common Lisp compatibility package which augments muLISP-90 with over 450 Common Lisp special forms, macros, functions and control variables. Includes a screen-oriented editor and debugger, a window manager, an interpreter and a compiler. Among the example programs is DOCTOR, an Eliza-like program. The runtime system allows one to create small EXE or COM executables. Uses a compact internal representation of code to minimize space requirements and speed up execution. The kernel takes up only 50k of space. Costs $150. muLISP-XM is a version of muLISP-90 that can take advantage of up to 4 gigabytes of extended memory and costs $300. Write to Soft Warehouse, Inc., 3660 Waialae Avenue, Suite 304, Honolulu, HI 96816-3236, call 808-734-5801, or fax 808-735-1105.

    Software Architecture and Engineering, Inc

    ALSP is a package of types, objects, and functions that emulate the important capabilities of Lisp which are not directly available in Ada. These capabilities are represented in Ada in a relatively straightforward manner without changing the Ada language definition.

    Requires an ADA implementation.

    Written by Andrew Ferrentino and Michael Jaskowiak.

    Symbolics (Genera, Zetalisp)

    Symbolics was formed to commercialize the MIT Lisp Machine (also called the CADR), a machine with special hardware for running Lisp that was one of the first workstations, and among the first computers to use a mouse, have a windowing system and have built in networking. (LMI was another company formed to commercialize the MIT Lisp Machine.)

    The machine was very successful, and so many were sold to government and other high value installations that the company did not produce a low price machine until the workstation market had changed dramaticaly.

    Most installations had the complete source to the operating system, which was in Zetalisp (a close precursor to Common Lisp).

    Although no new machines are being made, existing hardware is being serviced (and sold?).

    Just before going bankrupt, the company ported the operating system, Genera, to 64 bit DEC workstations. Symbolics Open Genera runs on DEC 3000 Workstations (models 600 and 800 APX with the OSF/1 operating system), at a price of $18,500.

    CLOE (Common Lisp Operating Environment) is a cross-development environment for IBM PCs (MSDOS) and Symbolics Genera. It includes CLOS, condition error system, generational garbage collection, incremental compilation, code time/space profiling, and a stack-frame debugger. It costs from $625 to $4000 and requires 4-8mn RAM and a 386 processor.

    Texas Intruments (Explorer)

    The TI Explorer was a competitor to the Symbolics Lisp Machine

    Thinking Machines (*Lisp, StarSim)

    The Connection Machine is a massively parallel supercomputer programmed in *Lisp. A copy of Getting STartined in *Lisp, the *Lisp Reference Manual and the *Lisp Dictionary are available from Thinking Machines for $100.

    A simulator for *Lisp, StarSim, runs inside a number of different commercial Common Lisp implementations and is available by FTP.

    Top Level

    Top Level Common Lisp includes futures, a debugger, tracer, stepper, foreign function interface and object inspector. It runs on Unix platforms, requiring 8mb RAM, and costs $687. Write to: Top Level, 100 University Drive, Amherst, MA 01002, call (413) 549-4455, or fax (413) 549-4910.

    Venue (Medley, Xerox Interlisp)

    Xerox made a series of special hardware machines that were called D machines, since their names all started with the letter D (e.g., Dandelion, Dorado, Dandetiger). The Lisp that ran on these machines was Interlisp -- a precursor to Common Lisp. Later Lisp hardware was called Envos(?).

    The Lisp system used on these machines was ported to other hardware. The system is called Medley, and is currently sold by Venue.

    Medley is a Common Lisp development environment that includes a native CLOS w/MOP, window toolkit, window-based debugger, incremental compiler, structure editor, inspectors, stepper, cross-referencer (Masterscope), code analysis tools, and browsers. It is the successor to InterLisp-D.

    Medley is available for most Unix platforms, as well as for IBM compatible PCs. Pricing information is available.

    Jeff Weisberg (jlisp)

    jlisp is a lisp interpreter designed to be used as an embedded interpreter and is easily interfaced with C/C++. jlisp is easily extended. Written at U. Rochester.

    http://www.lisp.org
    Copyright 1999 by the Association of Lisp Users.
    Don Naumann, Systems Editor.
    last update: $Date: 2001/08/21 20:13:24 $