This is GNU CLISP, an ANSI Common Lisp implementation.

CLISP is mostly ANSI CL compliant, including a CLOS implementation.


Availability
============

GNU CLISP is available via anonymous ftp (sources and selected binaries) from
  <ftp://cvs2.cons.org/pub/lisp/clisp/>,
  <ftp://ftp.gnu.org/pub/gnu/clisp/>
and their mirrors.
More information at
  <http://clisp.cons.org/>,
  <http://www.clisp.org/>,
  <http://www.gnu.org/software/clisp/> and
  <http://clisp.sourceforge.net/>.

See file <resources.html> on these sites, e.g.
  <http://clisp.cons.org/resources.html>,
where you will find links to general Common Lisp information
and documentation, as well as CLISP-specific links.

Mailing lists
=============

There are three mailing lists for users of CLISP.  You will find
subscription information and archives on the homepage mentioned above.


-------------------------------------------------------------------------------
                        Common Lisp CLISP

Common Lisp is
  * a general-purpose programming language and an AI language
  * interactive
  * a Lisp for professional use

Common Lisp programs are
  * easy to test (interactive)
  * easy to maintain (depending on programming style)
  * portable across hardware/OS platforms and implementations
    (there is a standard for the language and the library functions)

Our Common Lisp CLISP
  * needs only 2 MB of memory
  * implements most of the ANSI standard, as well as some extensions
  * can call your preferred editor
  * is freely distributable

Common Lisp provides
  * clear syntax, carefully designed semantics
  * several data types: numbers, strings, arrays, lists, characters, symbols,
    structures, streams etc.
  * runtime typing: the programmer need not bother about type declarations,
    but he gets notified on type violations.
  * many generic functions:
    88 arithmetic functions for all kinds of numbers (integers, ratios,
    floating point numbers, complex numbers),
    44 search/filter/sort functions for lists, arrays and strings
  * automatic memory management (garbage collection)
  * packaging of programs into modules
  * an object system, generic functions with powerful method combination
  * macros: every programmer can make his own language extensions

Our Common Lisp CLISP provides
  * an interpreter
  * a compiler which makes execution of programs 5 times faster
  * all data types with unlimited size (the size need never be declared,
    the size of lists and arrays may be changed dynamically)
  * integers of arbitrary length, unlimited floating point number precision
  * 800+ library functions and macros, 600+ of them written in C

CLISP compares well with other ANSI CL implementations wrt performance
in most areas, such as CLOS, I/O, lists, integer arithmetics (CLISP's
bignum performance is better than that of some other CL implementations).
The worst performance CLISP exhibits in the area of floating point
arithmetics.  While showing nothing spectacularly bad and easily
outperforming Java, Perl, TCL and any Scheme interpreter, CLISP is slower
than another open-source CL implementation, CMU CL (http://www.cons.org/cmucl),
which outperforms C and FORTRAN.  If your code is heavily numeric, you
might prefer CMUCL, otherwise CLISP is a wise choice.

-------------------------------------------------------------------------------

