README-lisps.md

   1 Notes on Lisp implementations for Maxima:
   2 =========================================
   3
   4 Clisp, CMUCL, Scieneer Common Lisp (SCL), GCL (ANSI-enabled only),
   5 ECL, ABCL and SBCL can compile and execute Maxima.
   6 Allegro Common Lisp (ACL) and CCL might also work, but have not
   7 been fully tested.
   8
   9 Ports to other ANSI Common Lisps should be straightforward
  10 and are welcome; please post a message on the Maxima mailing list
  11 if you are interested in working on a port.
  12
  13 When Maxima is recompiled, the Lisp implementation is selected by
  14 an argument of the form `--enable-foolisp` for the configure script.
  15 `./configure --help` shows a list of the Lisp types recognized by
  16 configure (among other options). It is possible to specify several
  17 Lisp type(s) you want Maxima to be built with at the same time.
  18 configure tries to autodetect the Lisp type if it is not specified,
  19 but it has been reported that autodetection can fail.
  20
  21
  22 Comparison of execution times (in seconds)
  23 ------------------------------------------
  24
  25 This is the result of the `run_testsuite()` function for
  26 Maxima 5.36.0 as reported on the Maxima mailing list:
  27
  28 ### 64 Bit (Gentoo Linux):
  29
  30     gcl-2.6.12    152
  31     sbcl-1.2.10   155
  32     ccl-1.10      313
  33     ecl-15.3.7    559
  34     clisp-2.49   1060
  35
  36 ### 32 Bit (Gentoo Linux)
  37
  38     sbcl-1.2.10  170
  39     gcl-2.6.12   177
  40     cmucl-20e    253
  41     ccl-1.10     293
  42     ecl-15.3.7   556
  43     clisp-2.49   844
  44
  45
  46 Clisp <http://clisp.org>
  47 ------------------------
  48
  49 Clisp can be built with readline support, so Maxima has
  50 advanced command-line editing facilities when built with it.
  51
  52 Clisp is compiled to bytecodes, so Maxima running on Clisp is
  53 substantially slower than on Lisps compiled to machine instructions.
  54 On the other hand, Clisp contains code from CLN <https://www.ginac.de/CLN/>,
  55 a library for efficient computations with all kinds of numbers in
  56 arbitrary precision. Another advantage of Clisp is that byte code
  57 resulting in compiling a program on one computer might work on a
  58 computer running a different Clisp version. Also Clisp uses an
  59 extremely efficient memory handling which means it might not run
  60 out of memory where ECL, SBCL and GCL do.
  61
  62 CLISP version 2.49 has a bug that causes it to output garbled data
  63 if the front-end is fast enough to acknowledge a data packet while
  64 the next data packet is still being prepared.
  65
  66 There are Clisp implementations for many platforms including
  67 MS Windows and Unix-like systems.
  68
  69 Maxima compiled with a typical linux install of clisp 2.49.92
  70 typically depends on the following libraries:
  71
  72  * libc
  73  * libffcall
  74  * libreadline
  75  * libsigsegv
  76  * libtinfo
  77  * libunistring
  78
  79
  80 CMUCL <https://cmucl.org/>
  81 ----------------------------------
  82
  83 CMUCL is a fast option for Maxima on platforms where it is
  84 available. The rmaxima front-end provides advanced line-editing
  85 facilities for Maxima when compiled with CMUCL. rlwrap is available
  86 from: <https://github.com/hanslub42/rlwrap>
  87
  88 CMUCL versions: 18e and 19a and later are known to work.
  89
  90 There are CMUCL implementations only for Unix-like systems
  91 (not MS Windows).
  92
  93 Scieneer Common Lisp (SCL) <https://web.archive.org/web/20171014210404/http://www.scieneer.com/scl/>
  94 ----------------------------------------------------------------------------------------------------
  95
  96 Scieneer Common Lisp (SCL) is a fast option for Maxima for a
  97 range of Linux and Unix platforms.  The SCL 1.2.8 release and later
  98 are supported.  SCL offers a lower case, case sensitive, version which
  99 avoids the Maxima case inversion issues with symbol names.  Tested
 100 front end options are: Maxima emacs mode available in the
 101 interfaces/emacs/ directory, the Emacs imaxima mode available from
 102 <https://sites.google.com/site/imaximaimath/>, and TeXmacs available from
 103 <https://www.texmacs.org>
 104
 105 GCL <https://www.gnu.org/software/gcl/>
 106 ---------------------------------------
 107
 108 GCL versions starting with 2.4.3 can be built with readline
 109 support, so Maxima has advanced command-line editing facilities
 110 when built with it. GCL produces a fast Maxima executable that
 111 profit from GCL's fast bignum algorithms.
 112
 113 Only the ANSI-enabled version of GCL works with Maxima, i.e.,
 114 when GCL is built, it must be configured with the `--enable-ansi` flag,
 115 i.e., execute `./configure --enable-ansi` in the build directory
 116 before executing make.
 117
 118 Whether GCL is ANSI-enabled or not can be determined by
 119 inspecting the banner which is printed when GCL is executed;
 120 if ANSI-enabled, the banner should say `ANSI`.
 121 Also, the special variable `*FEATURES*` should include the keyword `:ANSI-CL`.
 122
 123 There are GCL implementations for many platforms
 124 including MS Windows and Unix-like systems.
 125
 126 Maxima compiled using a typical linux install using gcl 2.6.12
 127 typically depends on:
 128
 129  * libc
 130  * libgmp
 131  * libreadline
 132  * libx11
 133  * gcc
 134
 135
 136 SBCL <https://www.sbcl.org>
 137 --------------------------
 138
 139 SBCL is a fork of CMUCL which differs in some minor details,
 140 but most notably, it is simpler to rebuild SBCL than CMUCL.
 141 For many tasks a Maxima compiled with SBCL is considerably faster than
 142 GCL. For other tasks GCL is faster than SBCL.
 143
 144 As SBCL doesn't use readline it is recommended to use rmaxima for using
 145 a command-line Maxima with SBCL. For common details of SBCL and CMUCL
 146 See CMUCL above.
 147
 148 Maxima compiled using a typical Linux install using SBCL 1.4.10
 149 typically depends on:
 150
 151  * libc
 152  * zlib
 153
 154
 155 Allegro Common Lisp <https://franz.com/products/allegro-common-lisp/>
 156 ---------------------------------------------------------------------
 157
 158 Maxima should work with Allegro Common Lisp, but
 159 only limited testing has been done with these Lisp
 160 implementations. User feedback would be welcome.
 161
 162
 163 CCL <https://ccl.clozure.com/>
 164 ------------------------------
 165
 166 CCL, formerly known as OpenMCL, is known to work with Maxima on
 167 all platforms where ccl runs including Linux, Mac OSX, and Windows.
 168 There are appear to be some bugs in the 32-bit version of CCL, but
 169 the 64-bit version passes all tests.
 170
 171
 172 ECL <https://common-lisp.net/project/ecl/>
 173 ------------------------------------------
 174
 175 ECL is known to work with Maxima and passes the testsuite. ECL
 176 runs on many platforms and OSes and is the lisp compiler used for
 177 Maxima on Android. It is faster than CLISP, but seems to tend more
 178 towards fragmenting the available memory. ECL tends to be slower
 179 than GCL or SBCL but faster than CLISP.
 180
 181 ECL must be configured to use the C compiler, building Maxima with the
 182 ECL bytecode compiler is (currently) not possible.  So do **not** use the
 183 option `--with-cmp=no` when building ECL.
 184
 185 Maxima compiled using a typical linux install using ecl 16.1.2
 186 typically only depends on:
 187
 188  * libc
 189
 190
 191 Armed Bear Common Lisp (ABCL) <https://www.abcl.org>
 192 ----------------------------------------------------
 193
 194 ABCL's main feature is that is tightly integrated into Java.
 195 That also means that it is an interpreter running in a virtual machine
 196 which makes it even slower than Clisp. Also Java doesn't automatically
 197 convert tail-recursive function calls to loops which means that in a
 198 few functions might run out of stack space faster than other Lisps.
 199
 200