[6-3] Publicly Redistributable Lisp Software

AI Algorithms and Tools:

   PAIL (Portable AI Lab) is a computing environment containing a
   collection of state-of-the-art AI tools, examples, and documentation.
   It is aimed at those involved in teaching AI courses at university
   level or equivalent. The system has enough built-in functionality to
   enable its users to get practical experience with a broad range of AI
   problems without having to build all the supporting tools from
   scratch. It is implemented in Common Lisp and uses CLOS and Allegro
   Common Windows (i.e., in Allegro CL 4.1). It is available by anonymous
   ftp from 
      pobox.cscs.ch:/pub/ai/ []
   Written by Mike Rosner and Dean Allemang {dean,mike}@idsia.ch.

   AI_ATTIC is an anonymous ftp collection of classic AI programs and
   other information maintained by the University of Texas at Austin.  It
   includes Parry, Adventure, Shrdlu, Doctor, Eliza, Animals, Trek, Zork,
   Babbler, Jive, and some AI-related programming languages.  This
   archive is available by anonymous ftp from 
      ftp.cc.utexas.edu:/pub/AI_ATTIC/  []
   (AKA bongo.cc.utexas.edu). For more information, contact

Analogical Reasoning:

   SME is the Structure-Mapping Engine, as described in Falkenhainer,
   Forbus, and Gentner's 1987 AIJ article.  Available from
   multivac.ils.nwu.edu:/pub/SME For further information, contact Brian
   Falkenhainer <falkenhainer@parc.xerox.com> or Ken Forbus


   Gabriel Lisp Benchmarks are available by anonymous ftp as
   The benchmarks are described in the book "Performance Evaluation of
   Lisp Systems", by Richard Gabriel. 

   Lucid CL contains a set of benchmarks in its goodies/ directory,
   including Bob Boyer's logic programming benchmark, a benchmark to
   create and browse through an AI-like database of units, a CLOS speed
   test, a compilation speed test, TAKR (the 100 function version of TAK
   that tries to defeat cache memory effects), CTAK (A version of the
   TAKeuchi function that uses the CATCH/THROW facility), STAK (A version
   of the TAKeuchi function with special variables instead of parameter
   passing), DERIV and DDERIV (Symbolic derivative benchmarks written by
   Vaughn Pratt), DESTRU (a destructive operation benchmark), DIV2 (a
   benchmark which divides by 2 using lists of n ()'s), the FFT benchmark
   written by Harry Barrow, FPRINT (a benchmark to print to a file),
   FRPOLY (a Franz Lisp benchmark by Fateman based on polynomial
   arithmentic), Forest Baskett's PUZZLE benchmark (originally written in
   Pascal), the TPRINT benchmark to read and print to the terminal, a
   benchmark that creates and traverses a tree structure, and TRIANG
   (board game benchmark). Some of the benchmarks may work only in Lucid.

Blackboard Architectures:

   The UMass GBB system (V1.2) is available by anonymous ftp from
   ftp.cs.umass.edu:/gbb. The commercial GBB product is not.
   Work on the UMass GBB project (and funding) ended over 2 years ago.
   Many researchers using it have opted for the commercial
   release.  The UMass research system remains available, but the
   two should not be confused as the commercial system is
   substantially improved and extended. The commercial system is
   available from Blackboard Technology Group, 401 Main Street, Amherst,
   Massachusetts 01002, telephone 800-KSS-8990 or 413-256-8990, fax

   For a tutorial on how to build a blackboard system, see the paper
      P. R. Kersten and Avi C. Kak, "A Tutorial on LISP Object-Oriented
      Programming for Blackboard Computation (Solving the Radar Tracking
      Problem)", International Journal of Intelligent Systems 8:617-669, 1993
   Although samples of the code are given in the paper, the full source
   code is available in a separate technical report from the School of
   Electrical Engineering at Purdue University.  If you are interested in
   getting a copy of the technical report, send mail to Avi Kak
   <kak@ecn.purdue.edu>. (The circumstances under which the software was
   developed prevent them from making the source code available by
   anonymous FTP. However, the full source code is printed in the
   technical report.)

Case-based Reasoning:

   CL-Protos is a Common Lisp implementation of the case-based
   reasoning system developed by E. Ray Bareiss and Bruce W.
   Porter of the University of Texas/Austin AI Lab. It runs
   on Sun3, TI Explorer, HP 9000, and Symbolics, and gobbles a
   huge amount of memory. Common Lisp implementation by
   Rita Duran, Dan Dvorak, Jim Kroger, Hilel Swerdlin, and Ben Tso.
   For more information, bug reports, or comments, contact
   either Dan Dvorak <dvorak@cs.utexas.edu> or Ray Bareiss
   <bareiss@ils.nwu.edu> or Erik Eilerts <eilerts@cs.utexas.edu>
   Available by anonymous ftp from cs.utexas.edu:/pub/porter

   The complete code for "Inside Case-Based Reasoning" by Riesbeck and
   Schank, 1989, is available by anonymous ftp from 
   This includes code for an instructional version of CHEF by Kristian
   Hammond and MICRO-xxx. Contact Bill Andersen <waander@cs.umd.edu>
   for more information.  

CLOS Software:
   See question [5-6].

Constraint Programming and Non-determinism:


   Screamer is an extension of Common Lisp that adds support for
   nondeterministic programming.  Screamer consists of two levels.  The
   basic nondeterministic level adds support for backtracking and
   undoable side effects.  On top of this nondeterministic substrate,
   Screamer provides a comprehensive constraint programming language in
   which one can formulate and solve mixed systems of numeric and
   symbolic constraints.  Together, these two levels augment Common Lisp
   with practically all of the functionality of both Prolog and
   constraint logic programming languages such as CHiP and CLP(R).
   Furthermore, Screamer is fully integrated with Common Lisp. Screamer
   programs can coexist and interoperate with other extensions to Common
   Lisp such as CLOS, CLIM and Iterate.

   In several ways Screamer is more efficient than other implementations
   of backtracking languages.  First, Screamer code is transformed into
   Common Lisp which can be compiled by the underlying Common Lisp
   system.  Many competing implementations of nondeterministic Lisp are
   interpreters and thus are far less efficient than Screamer.  Second,
   the backtracking primitives require fairly low overhead in Screamer.
   Finally, this overhead to support backtracking is only paid for those
   portions of the program which use the backtracking primitives.
   Deterministic portions of user programs pass through the Screamer to
   Common Lisp transformation unchanged.  Since in practise, only small
   portions of typical programs utilize the backtracking primitives,
   Screamer can produce more efficient code than compilers for languages
   in which backtracking is more pervasive.

   Screamer is fairly portable across most Common Lisp implementations.
   It currently runs under Genera 8.1.1 and 8.3 on both Symbolics 36xx
   and Ivory machines, under Lucid 4.0.2 and 4.1 on Sun SPARC machines,
   under MCL 2.0 and 2.0p2 on Apple Macintosh machines, and under Poplog
   Common Lisp on Sun SPARC machines.  It should run under any
   implementation of Common Lisp which is compliant with CLtL2 and with
   minor revision could be made to run under implementations compliant
   with CLtL1 or dpANS.

   Screamer is available by anonymous FTP from 
   Contact Jeffrey Mark Siskind <qobi@ai.mit.edu> for further
   information. Screamer is also available from the Common Lisp Repository.

   The Screamer Tool Repository, a collection of user-contributed
   Screamer code, is available by anonymous ftp from
   or by WWW from
   Please direct all inquires about the repository to

Defeasible Reasoning:

   An implementation of J. Paris and A. Vencovska's model of belief is
   available by anonymous ftp from
   Paris and Vencovska's paper (Artificial Intelligence, 64(2), December
   1993) provides a mathematical model of an agent's belief in an event
   by identifying it with his ability to imagine the event within the
   context of his previous experience.  This approach leads to beliefs
   having properties different from those normally ascribed to it. The
   implementation was written by Ian Pratt <ipratt@cs.man.ac.uk> and Jens
   Doerpmund <dorpmunj@cs.man.ac.uk> and runs in Common Lisp.

Eliza and Similar Programs:

   See Peter Norvig's book and AI_ATTIC (question [6-1] above).

   The doctor.el is an implementation of Eliza for
   GNU-Emacs emacs-lisp. Invoke it with "Meta-X doctor"

   muLISP-87 (a MSDOS Lisp sold by Soft Warehouse) includes
   a Lisp implementation of Eliza.

   Implementations of ELIZA for other languages are mentioned in the AI FAQ.

   The original Parry (in MLISP for a PDP-10) is available in

   Other programs, such as RACTER, are listed in part 4 of the AI FAQ.

Expert Systems:

   FOCL is an expert system shell and machine learning program written in
   Common Lisp. The machine learning program extends Quinlan's FOIL
   program by containing a compatible explanation-based learning
   component.  FOCL learns Horn Clause programs from examples and
   (optionally) background knowledge. The expert system includes a
   backward-chaining rule interpreter and a graphical interface to the
   rule and fact base. For details on FOCL, see: Pazzani, M. and Kibler,
   D., "The role of prior knowledge in inductive learning", Machine
   Learning 9:54-97, 1992. It is available by anonymous ftp from
   as the files README.FOCL-1-2-3, FOCL-1-2-3.cpt.hqx (a binhexed,
   compacted Macintosh application), FOCL-1-2-3.tar.Z (Common Lisp
   source code), and FOCL-1-2-3-manual.hqx (binhexed manual).  If you
   use a copy of FOCL, or have any comments or questions, send mail to

   BABYLON is a development environment for expert systems. It
   includes frames, constraints, a prolog-like logic formalism, and a
   description language for diagnostic applications. It is implemented in
   Common Lisp and has been ported to a wide range of hardware platforms.
   Available by anonymous ftp from 
      ftp.gmd.de:/gmd/ai-research/Software/Babylon/ []
   as a BinHexed stuffit archive, on the Web via the URL
   on the Apple CD-ROM, or with the book "The AI Workbench BABYLON",
   which contains *full source code* of BABYLON and the stand-alone
   version for the Mac. The book describes the use of BABYLON in detail.

   OPS5 is a public domain Common Lisp implementation of the OPS5
   production system interpreter written by Charles Forgy. It is
   available from the CMU AI Repository in
   and includes the original port by George Wood and Jim Kowalski
   (ops5orig.tar.gz), and a later port by Mark Kantrowitz (ops5.tar.gz).
   The latter has been tested under Allegro, Lucid, CMU CL, Ibuki CL and

Frame Languages:

   FrameWork is a portable generic frame system available from the CMU
   AI Repository, in 

   THEO (learning frame system) is available free from CMU, after
   signing a license agreement. Send mail to Tom.Mitchell@cs.cmu.edu.

   FrameKit is available free from CMU, after signing a
   license agreement. Send mail to Eric.Nyberg@cs.cmu.edu

   KR. Send mail to Brad.Myers@cs.cmu.edu for more info.

   PARKA. Frames for the CM. Contact spector@cs.umd.edu.
   PARMENIDES (Frulekit) is available free, after signing
   a license agreement. Send mail to peter.shell@cs.cmu.edu 

   FROBS is available free by anonymous ftp from
   Contact Robert Kessler <kessler@cs.utah.edu> for more info.

   PFC is a simple frame system written by Tim Finin
   available free by anonymous ftp from linc.cis.upenn.edu.

   YAK is a hybrid knowledge-representation system of the
   KL-ONE family. Includes an optional graphical interface
   depending on the Lisp. Available free after signing a license 
   agreement. Contact Enrico Franconi <franconi@irst.it>.

Genetic Algorithms:

   GECO (Genetic Evolution through Combination of Objects) is a
   genetic algorithm shell written by George Williams,
   <george@hsvaic.boeing.com>. It is available by anonymous ftp 
   from cambridge.apple.com:/pub/mcl2/contrib/ as the following
      GECO-v1.0.cpt.hqx       binhex'd Compact Pro archive
      GECO-v1.0.tar.Z         compressed tar file for Unix machines (no MCL
      GECO.abstract           a brief description
   It runs in MCL 2.0, but should be portable among CLtL2 compliant
   Common Lisps.

   GAL is a genetic algorithm suite written by Bill Spears of NRL. The
   MCL2.0 port was done by Howard Oakley <howard@quercus.demon.co.uk> and
   is available from cambridge.apple.com:/pub/MCL2/contrib as
   GAL.sea.hqx.  Improvements and adaptations should be sent to Bill
   Spears, but questions on the MCL port should be directed to Howard Oakley.

   Other genetic algorithms code is available  
   including Genesis (source-code/ga-source/genesis.tar.Z) and the archives
   of the GA-List mailing list. A survey of free and commercial
   genetic algorithms implementations is available in

Knowledge Representation:

   KNOWBEL is an implementation of Telos (a sorted/temporal logic
   system) by Bryan M. Kramer, <kramer@ai.toronto.edu>. It is
   available by anonymous ftp from ai.toronto.edu:/pub/kr/ as the
   files knowbel.tar.Z and manual.txt.tar.Z 
   Runs in Allegro CL on Sparcstations and Silicon Graphics 4d
   and in MCL on Apple Macintoshes. 
   SNePS (Semantic Network Processing System) is the implementation of a
   fully intensional theory of propositional knowledge representation and
   reasoning. SNePS includes a module for creating and accessing
   propositional semantic networks, path-based inference, node-based
   inference based on SWM (a relevance logic with quantification) that
   uses natural deduction and can deal with recursive rules, forward,
   backward and bi-directional inference, nonstandard logical connectives
   and quantifiers, an assumption based TMS for belief revision, a
   morphological analyzer and a generalized ATN (GATN) parser for parsing
   and generating natural language, SNePSLOG, a predicate-logic-style
   interface to SNePS, XGinseng, an X-based graphics interface for
   displaying, creating and editing SNePS networks, SNACTor, a
   preliminary version of the SNePS Acting component, and SNIP 2.2, a new
   implementation of the SNePS Inference Package that uses rule shadowing
   and knowledge migration to speed up inference.  SNeRE (the SNePS
   Rational Engine), which is part of Deepak Kumar's dissertation about
   the integration of inference and acting, will replace the current
   implementation of SNACTor.  SNePS is written in Common Lisp, and has
   been tested in Allegro CL 4.1, Lucid CL 4.0, TI Common Lisp, CLISP
   May-93, and CMU CL 17b. It should also run in Symbolics CL, AKCL 1.600
   and higher, VAX Common Lisp, and MCL. The XGinseng interface is built
   on top of Garnet.  SNePS 2.1 is free according to the GNU General
   Public License version 2. The SNePS distribution is available by
   anonymous ftp from 
      ftp.cs.buffalo.edu:/pub/sneps/  [] 
   as the file rel-x-yyy.tar.Z, where 'x-yyy' is the version. The other
   files in the directory are included in the distribution; they are
   duplicated to let you get them without unpacking the full distribution
   if you just want the bibliography or manual. If you use SNePS, please
   send a short message to shapiro@cs.buffalo.edu and
   snwiz@cs.buffalo.edu. Please also let them know whether you'd like to
   be added to the SNUG (SNePS Users Group) mailing list. 

   COLAB (COmpilation LABoratory) is a hybrid knowledge representation
   system emphasizing the horizontal and vertical compilation of
   knowledge bases. It is comprised of cooperating subsystems -- CONTAX,
   FORWARD, RELFUN and TAXON -- which deal with different knowledge
   representation and reasoning formalisms. Each subsystem can also be
   used as stand-alone system. CONTAX deals with constraint nets and
   constraint-propagation techniques. Relational knowledge in the form of
   Horn rules is processed by forward (FORWARD) and backward (RELFUN)
   chaining. Taxonomic knowledge is represented by intensional concept
   definitions which are automatically arranged in a subsumption
   hierarchy (TAXON).  The COLAB software was developed at DFKI and the
   University of Kaiserslautern and runs in Common Lisp. (The subsystems
   have been tested in AKCL and Lucid CL, and possibly also Allegro CL
   and Symbolics CL.) All the subsystems are available free of charge for
   research purposes.
   o  RELFUN is a logic-programming language with call-by-value (eager),
      non-deterministic, non-ground functions, and higher-order operations.
      It accepts freely interchangeable LISP-style and PROLOG-style syntaxes.
      For sources to RELFUN and copies of relevant papers, contact
      Dr. Harold Boley, DFKI, Postfach 2080, W-6750 Kaiserslautern, Germany,
      call +49-631-205-3459, fax +49-631-205-3210, or send email to
   o  TAXON is a terminological knowledge representation system extended by
      concrete domains.  For sources to TAXON and copies of relevant papers,
      contact Philipp Hanschke, DFKI, Postfach 2080, W-6750 Kaiserslautern,
      Germany, call +49-631-205-3460, fax +49-631-205-3210, or send email to
   o  CONTAX is a constraint system for weighted constraints over
      hierarchically structured finite domains. CONTAX uses CLOS in addition
      to Common Lisp.  For sources to CONTAX and copies of relevant papers,
      contact Manfred Meyer, DFKI, Postfach 2080, W-6750 Kaiserslautern,
      Germany, call +49-631-205-3468, fax +49-631-205-3210, or send email to
   o  FORWARD is a logic programming language with bottom-up and top-down
      evaluation of Horn clauses. For sources to FORWARD and copies of
      relevant papers, contact Knut Hinkelmann, DFKI, Postfach 2080, W-6750
      Kaiserslautern, Germany, call +49-631-205-3467, fax +49-631-205-3210,
      or send email to hinkelma@dfki.uni-kl.de.

   URANUS is a logic-based knowledge representation language. Uranus is
   an extension of Prolog written in Common Lisp and using the syntax of
   Lisp. Uranus extends Prolog with a multiple world mechanism for
   knowledge representation and term descriptions to provide
   functional programming within the framework of logic programming.
   It is available free by anonymous ftp from 
      etlport.etl.go.jp:/pub/uranus/ftp/ []
   for research purposes only.  For more information contact the author, 
   Hideyuki Nakashima <nakashim@etl.go.jp>.

Languages and Alternate Syntaxes:

   Generalized Lisp (or Glisp for short) is a coordinated set of high
   level syntaxes for Common Lisp.  Initially GLisp consists of three
   dialects: Mlisp, Plisp and ordinary Lisp, together with an extensible
   framework for adding others.  Mlisp (Meta-Lisp) is an Algol-like
   syntax for people who don't like writing parentheses. For example,
   one can write print("abc", stream) instead of (print "abc" stream).
   Plisp (Pattern Lisp) is a pattern matching rewrite-rule language.
   Plisp is a compiler-compiler; its rules are optimized for writing
   language translators.  All dialects may be freely intermixed in a
   file. The translators for all dialects are written in Plisp, as is
   the Glisp translator framework itself. Support routines for the
   translators are written in Mlisp and/or Lisp. All dialects are
   translated to Common Lisp and execute in the standard Common Lisp
   environment. Glisp is available by anonymous ftp from apple.com or 
   GLISP runs in MCL and has to be modified for other Common Lisp

   CGOL is algol-like language that is translated into Lisp before
   execution. It was developed originally by Vaughn Pratt. A Common Lisp
   implementation of CGOL is available by anonymous ftp from
      peoplesparc.berkeley.edu:/pub/cgol.1.tar.Z  []
   (The number "1" may increase if newer versions are posted.)  It was 
   written by a UC Berkeley graduate student, Tom Phelps, as a term
   project, so there may still be some rough edges. There is a lot of
   documentation in the distribution, including the "original" CGOL memo
   (pratt.memo). For more information, contact Richard Fateman

   StarLisp Simulator. The StarLisp Simulator simulates *Lisp, one of
   the programming langauges used to program the Connection Machine.
   StarLisp runs under Symbolics, Lucid, Allegro, and Franz, and is
   available by anonymous ftp from
   The "CM5 *Lisp Tutorial" is available by anonymous ftp from
      arp.anu.edu.au:/ARP/papers/starlisp/  []
   in Andrew "ez" and postscript formats.  Write to Zdzislaw Meglicki
   <Zdzislaw.Meglicki@cisr.anu.edu.au> for more information about the tutorial.

   InterLisp->Common-Lisp Translator -- ftp.ai.sri.com:/pub/pkarp/lisp/ilisp/
   Other InterLisp to Common Lisp translators may be found in the LispUsers
   archive listed above.

   The Yale Haskell system runs in CMU Common Lisp, Lucid CL, and AKCL.
   It is available by anonymous ftp from 
        Chalmers animal.cs.chalmers.se:/pub/haskell/yale/ []
        Glasgow  ftp.dcs.glasgow.ac.uk:/pub/haskell/yale/ []
        Yale     nebula.cs.yale.edu:/pub/haskell/yale/    []
   as the files
        haskell-beta-2-source.tar.Z   -- full sources
        haskell-beta-2-sparc.tar.Z    -- sparc executable

Lisp Tools:

   See the Common Lisp Repository in [6-2].

   The Automatic Memoization Facility adds a practical memoization
   facility to Common Lisp. Automatic memoization is a technique by which
   an existing function can be transformed into one that "remembers"
   previous arguments and their associated results, yielding large
   performance gains for certain types of applications.  This facility
   extends the ideas from Norvig's book into what is needed for a
   practical tool for us in large programs. It adds facilities for
   bookkeeping and timing, and lets you evaluate of the timing advantages
   of memoization, and save hash tables to disk for automatic reuse in
   later sessions. The code is available by anonymous ftp from
   archive.cs.umbc.edu:/pub/Memoization []. Contact Marty Hall
   <hall@aplcenmp.apl.jhu.edu> for more information. The code includes an
   overview of memoization and its applications.

   PLisp - A Common Lisp front end to Postscript. This translates many
   Common Lisp functions to postscript as well as manage the environment
   and many lispisms (&optional and &rest arguments, multiple values,
   macros, ...).  Available via anonymous ftp
         nebula.cs.yale.edu:/pub/plisp/plisp.tar.Z []
   Written by John Peterson <peterson-john@cs.yale.edu>.

   RegExp is an extension to Allegro Common Lisp which adds
   regular expression string matching, using the foreign
   function interface. Available by anonymous ftp from
   ftp.ai.sri.com:/pub/pkarp/regexp/. Contact pkarp@ai.sri.com
   for more information.

   ifi.informatik.uni-stuttgart.de:/pub/xit/cl-utilities/ contains
   three small utilities:
        completion.lisp         A simple filename completion program.
        cl-utilities.lisp       Some macros for dealing with points,
                                regions, and some miscellaneous macros.
        copy-objects.lisp       Code for copying instances.

   think.com:/think/lisp contains some useful lisp code (most of it
   Symbolics dependent) including:
        lisp-lint.lisp          A set of compiler style checkers that
                                warn when a function call does not
                                conform to Common Lisp. 

   MEASURES is a system to handle engineering numbers and measures in
   Common Lisp. It runs in Allegro CL, LispWorks, MCL, and Symbolics CL.
   Written by Roman Cunis.  Some documentation can be found in the file
   measures.doc and examples in measures-example.lisp.  It is available
   from the Common Lisp Repository
   in the file measures-2.0.tar.gz.  For further information, contact Ralf
   Moeller, University of Hamburg, Bodenstedtstr 16, 2000 Hamburg 50,
   Germany, call 40-4123-6134, fax 40-4123-6530, or send email to

   DEFTABLE provides a macro that unifies the interface to Common
   Lisp's table-like data structures (e.g., association lists, property
   lists, and hash tables). Written by Peter Norvig
   <norvig@harlequin.com>.  It is available by anonymous ftp from
   ftp.ai.mit.edu:/pub/lptrs/deftable.lisp [] and also the
   Lisp Utilities Repository. An article describing deftable was
   published in ACM Lisp Pointers 5(4):32-38, December 1992.

   SEQUEL (SEQUEnt processing Language) is designed both as a general
   purpose AI language for generating type-secure and efficient Lisp
   programs and as a very high level specification language for
   implementing logics on the computer. Designed at the University of
   Leeds, SEQUEL compiles sequent-calculus specifications of arbitrary
   logics to working proof assistants.  The sequent calculus
   specifications are compiled into Horn clauses and from Horn clauses
   into virtual machine instructions of an abstract machine SLAM (SequeL
   Abstract Machine) which then translates these instructions into
   efficient Lisp code using WAM-style compilation techniques.  Although
   a functional programming language, SEQUEL includes facilities for
   backtracking usually associated with logic programming, and supports a
   pattern-matching method of building functions based on Prolog
   notation.  The Lisp code generated from SEQUEL functions is completely
   portable and runs in most Common Lisp implementations. It is
   comparable in efficiency with hand-written code.  SEQUEL also supports
   optional static type-checking in the manner of SML and similar
   languages.  With type-checking enabled, all inputs and loaded files
   are type-checked and the resulting Lisp programs are type-secure.  The
   SEQUEL compiler uses the information gleaned from type-checking to add
   compiler directives within the generated Lisp functions to produce
   optimized Lisp programs.  SEQUEL includes a UNIX-style top level with
   its own trace package and type-checking debugger. SEQUEL is also of
   interest to automated reasoning researchers. It provides a very
   powerful means of generating proof assistants and theorem provers that
   have a very fast performance using WAM-derived compilation techniques.
   The theorem provers are automatically verified. It includes a facility
   for Datalog and an efficient occurs-check Horn-clause-to-Lisp
   compiler, a mouse driven graphical interface for all proof assistants
   and theorem provers built under SEQUEL (currently available only under
   Lucid).  Several demonstration theorem provers for different logics,
   including FOL, Clarke's logic of space, partial evaluation, set
   theory, and constructive type theory are available.  SEQUEL runs under
   Kyoto CL, Lucid CL, and CMU Common Lisp.  SEQUEL is available free for
   non-commercial purposes by anonymous ftp from
      agora.leeds.ac.uk:/scs/logic/  []
   and includes LaTeX documentation in the distribution. For more
   information, contact Mark Tarver <mark@scs.leeds.ac.uk> or 

   ILU (Xerox PARC Inter-Language Unification) is a system for promoting
   language interoperability via interfaces between units of program
   structure called "modules". ILU currently supports Common Lisp, ANSI
   C, C++, and Modula-3. The Common Lisp support provides CLOS `network
   objects' that communicate via RPC between Lisp processes, as well
   between Lisp and other languages.  ILU is available by anonymous ftp
   Write to Bill Janssen <janssen@parc.xerox.com> for more information.

Machine Learning:

   ID3: A Lisp implementation of ID3 and other machine learning
   algorithms are available by anonymous ftp from the machine learning
   group at the University of Texas as cs.utexas.edu:/pub/mooney

   COBWEB/3 is a concept formation system available free after
   signing a license agreement. Contact cobweb@ptolemy.arc.nasa.gov
   for more information.

   RWM (Refinement With Macros) is a Common Lisp program for learning
   problem solving strategies. RWM takes a high level description of a
   problem as input and successively refines it into a sequence of
   "easier" subproblems, which collectively constitute a strategy for
   solving the given problem. RWM also learns macro moves which are
   useful for efficiently solving the problem. A short documentation and
   some example problems/strategies are included. To get a copy of this
   description, send mail to the Bilkent University Archieve Server
   bilserv@trbilun.bitnet with "send RWM.tar.Z" in the body of the
   message. For further information, contact H. Altay Guvenir

   MockMma -- peoplesparc.berkeley.edu:/pub/mma.tar.Z       []
   A Mathematica-style parser written in Common Lisp. Written by Richard
   Fateman; fateman@renoir.Berkeley.EDU. Runs in any valid Common Lisp.
   Tested in Allegro, KCL and Lucid.

      Maxima for Common Lisp (License required from National
      Energy Software Center at Argonne.) Ported by Bill Schelter.

   QUAIL (Quantitative Analysis in Lisp) extends Common Lisp to better
   support quantitative analysis. It includes an object-oriented
   quantitative analysis programming environment based on CLOS.  Quail
   was developed by the Statistical Computing Laboratory of the
   Department of Statistics and Actuarial Science of the University of
   Waterloo.  It includes a variety of mathematical and statistical
   capabilities, such as symbolic and numerical differentiation,
   numerical integration, probability calculations (e.g., pseudo-random
   number generation), and statistical response models.  The
   object-oriented graphics display facilities include building blocks
   for arbitrary graphics, a collection of stock statistical graphics,
   function plotting, 3d-rotating function and surface plots, and
   graphical browsers. Quail currently runs in MCL, but a Franz and CLX
   based version is forthcoming. It is available by anonymous ftp from
      setosa.uwaterloo.ca:/pub/Quail/ []
   You must read the file README-I-MEAN-IT and return a signed copy of
   the license agreement ($10 annual license fee) before using the
   software. For further information, contact Dr. R. W. Oldford,
   <rwoldford@watstat.waterloo.edu> or <rwoldford@watstat.uwaterloo.ca>.

Medical Reasoning:

   TMYCIN -- sumex-aim.stanford.edu:/tmycin  The TMYCIN rule based system.


   Common Music is a music composition language written in Common Lisp
   and CLOS that outputs music (directly or through scorefiles) to a
   variety of synthesis packages, such as the Music Kit, Common Lisp
   Music, MIDI, and CSound.  Common Music runs under MCL 2.0, Allegro CL
   3.1.2 (NeXT), AKCL 1.615 (NeXT), Allegro CL 4.1 beta (SGI Iris), and
   AKCL 6.15 (Sun4). It is available by anonymous ftp from
      ccrma-ftp.stanford.edu:/pub/Lisp/cm.tar.Z []
      ftp.zkm.de:/pub/cm.tar.Z             [] 
   To be added to the mailing list, send mail to
   cmdist-request@ccrma.stanford.edu. For further information, contact
   Rick Taube, <hkt@zkm.de> or <hkt@ccrma.stanford.edu>.
   [Note: In the Common Music sources, there is a generic portable Lisp
   Listener style interpreter that supports command dispatching in
   addition to Lisp evaluation. It is the file ./utils/tl.lisp.] 

   Common Lisp Music (CLM) is a software synthesis and signal
   processing package (CL-MUSIC) and a package that makes it relatively
   easy to take advantage of the Motorola DSP 56000 (CL-MUSIC-56).  It is
   available by anonymous ftp from 
      ccrma-ftp.stanford.edu:/pub/Lisp/clm.tar.Z [] 
   Basic documentation is in clm.wn (or clm.rtf) and
   ins.lisp.  CLM runs on NeXT under Allegro CL or KCL and on SGI Indigo
   under Allegro CL. The non-56000 version should run on any machine with
   C and Common Lisp. Send bug reports or suggestions to
   Bil Schottstaedt <bil@ccrma.stanford.edu>.

   Common Music Notation (CMN) is a western music notation package based on
   Common Lisp, CLOS (pcl), PostScript, and the Adobe Sonata font. It is
   available by anonymous ftp from 
      ccrma-ftp.stanford.edu:/pub/Lisp/cmn.tar.Z [] 
   To be added to the mailing list (same list as for Common Music), 
   send mail to cmdist-request@ccrma.stanford.edu.  Please send bug
   reports and suggestions to Bil Schottstaedt <bil@ccrma.stanford.edu>. 

Natural Language Processing:

   The Xerox part-of-speech tagger is available by anonymous ftp from
   parcftp.xerox.com:/pub/tagger/tagger-1-0.tar.Z. It is implemented in
   Common Lisp and has been tested in Allegro CL 4.1, CMU CL 17e, and
   Macintosh CL 2.0p2. For more information, contact the authors, Jan Pedersen
   <pedersen@parc.xerox.com> and Doug Cutting <cutting@apple.com>. 

Natural Language Generation:

   FUF is a natural language generation system based on Functional
   Unification Grammars implemented in Common Lisp. It includes a
   unifier, a large grammar of English (surge), a user manual and many
   examples. FUF is available by anonymous ftp from
   as the files fuf5.2.tar.Z and surge.tar.Z. For further information,
   contact the author, Michael Elhadad <elhadad@bengus.bgu.ac.il>.
   [A WAM-based C compiler for FUF is in the works.]

Neural Networks:

   ANSIL  -- nervous.cis.ohio-state.edu:/pub/lispusers/ansil/ 
             "Advanced Network Simulator in Lisp"
             email: ansil@cis.ohio-state.edu

Object-Oriented Programming:

   PCL -- parcftp.xerox.com:/pcl/ []
   Portable Common Loops (PCL) is a portable implementation of
   the Common Lisp Object System (CLOS). A miniature CLOS
   implementation called Closette is available pcl/mop/closette.lisp.

   CLOS-on-KEE -- zaphod.lanl.gov:/pub/
   A subset of CLOS that is implemented on top of KEE. Contact
   egdorf%zaphod@LANL.GOV (Skip Egdorf) for more info.

   MCS (Meta Class System) -- ftp.gmd.de:/lang/lisp/mcs/ []
   Portable object-oriented extension to Common Lisp. Integrates the
   functionality of CLOS (the Common Lisp Object System), and TELOS, (the
   object system of LeLisp Version 16 and EuLisp).  MCS provides a metaobject
   protocol which the user can specialize. Runs in any valid Common Lisp.
   Contact: Harry Bretthauer and Juergen Kopp, German National Research
   Center for Computer Science (GMD), AI Research Division,
   P.O. Box 1316, D-5205 Sankt Augustin 1, FRG, email: juergen.kopp@gmd.de

   CommonORBIT (also called CORBIT) is an object-oriented extension of
   Common Lisp.  It uses a prototype (classless) model of OOP, is easy to
   use and yet has many sophisticated features found also in KL-ONE type
   languages.  CommonORBIT is a Common Lisp reimplementation of ORBIT,
   which was originally conceived by Luc Steels around 1981-1983.
   Because of its delegation-based rather than class-based inheritance,
   CommonORBIT offers extreme flexibility to define and change
   practically anything at run-time.  Because of the generic functions,
   it fits well into regular Lisp code.  It can co-exist with CLOS but
   remains completely separate. The source code of CommonORBIT is in the
   public domain and available by anonymous ftp from the Lisp
   Utilities Repository,
   in the oop/non-clos/corbit/ subdirectory as the file corbit.tar.gz. 
   Documentation is available as the files corbit.msword.hqx, corbit.ps
   or corbit.text. A stripped-down version of CORBIT, known as BOOPS
   (Beginner's Object-Oriented Programming System), is also available
   from the repository as boops.tar.Z. For further information,
   contact the author, Koenraad de Smedt <desmedt@ruls40.LeidenUniv.nl>.

Parser Generators:

   Mark Johnson <mj@cs.brown.edu> has written a LALR parser generator
   for Common Lisp. It is fairly small (about 500 lines of code) and
   can be found in the Common Lisp Repository above.

   IPG (Incremental Parser Generator) is available by email from 
   Jan Rekers <rekers@cwi.nl>.  It is an appendix to his thesis. It is
   written in LeLisp, but should be portable to other Lisp dialects.

   Zebu 2.8.5 is a parser generator for Common Lisp by Joachim H. Laubsch
   <laubsch@hplabs.hpl.hp.com>.  It is an extention written in Common
   Lisp of the Scheme version.  It generates a LALR(1) parsing table.  To
   parse a string with a grammar, only this table and a driver need to be
   loaded. The present version of Zebu contains the ability to define
   several grammars and parsers simultaneously, a declarative framework
   for specifying the semantics, as well as efficiency related
   improvements.  The current version compiles a grammar with 300
   productions (including dumping of the tables to disk) in approx 2
   minutes and 30 seconds on a HP 9000/370.  This implimentation has been
   tested in Lucid CL, Allegro CL, and MCL 2.0b. The current version
   can also produce a generator in addition to a parser. A copy may be
   found on cambridge.apple.com:/pub/mcl2/contrib/zebu-2.2.tar.Z.

Probabilistic Reasoning and Statistics:

   BELIEF is a Common Lisp implementation of the Dempster and Kong fusion
   and propagation algorithm for Graphical Belief Function Models and the
   Lauritzen and Spiegelhalter algorithm for Graphical Probabilistic
   Models. It includes code for manipulating graphical belief models such
   as Bayes Nets and Relevance Diagrams (a subset of Influence Diagrams)
   using both belief functions and probabilities as basic representations
   of uncertainty. It is available by anonymous ftp from
      ftp.stat.washington.edu []
   and by email from the author, Russell Almond <almond@stat.washington.edu>.
   Contact the author at almond@statsci.com for information about a
   commercial version GRAPHICAL-BELIEF currently in the prototype stages.

   XLISP-STAT is an extensible statistics package which runs in XLISP.
   It has recently been ported to Common Lisp, and is available as
      umnstat.stat.umn.edu:/pub/xlispstat/CL/CLS1.0A1.tar.Z []
   The CL port does not yet include the lisp-stat dynamic graphics 
   package, only the numerics. The XLisp version is available from
   the above site and several mirror sites, such as mac.archive.umich.edu, 
   and runs on the Apple Macintosh, Unix systems running X11
   (Vax, PMAX, Sun3, Encore Multimax, and Cray XMP), Sun workstations
   running SunView, and the Commodore Amiga. An experimental version
   for DOS computers running Microsoft Windows 3.0 is also available.
   Documentation is available online, in the tutorial introduction
   pub/xlispstat/xlispstat.doc.tar.Z and also in the book
      Luke Tierney, "Lisp-Stat: An Object Oriented Environment for Statistical
      Computing and Dynamic Graphics", Wiley, 1990, 397 pages.
      ISBN 0-471-50916-7. 
   For more information, write to Lisp-Stat Information, School of
   Statistics, 270 Vincent Hall, University of Minnesota, Minneapolis, MN
   55455, or send e-mail to lispstat-info@umnstat.stat.umn.edu.

   CLASP (Common Lisp Analytical Statistics Package) provides the basic
   functionality of a statistics package. It is implemented on top of
   CLOS and CLIM on a variety of platforms, and uses BBN's SciGraph
   package for plotting. The CLIM interface includes a "notebook" that is
   both a "desktop" for icons and a Lisp interactor pane.  The Common
   Lisp Instrumentation Package (CLIP) is available along with CLASP.
   CLIP is designed to allow AI system developers andevaluators a
   portable way to define and manage "alligator clips" for instrumenting
   their programs.  CLIP produces data about program behavior in CLASP
   format, as well as other commonly used data formats.  It currently has
   facilities to support experiment design, such as scenario scripting
   and factorial combination of independent variables, and can collect
   data in summary form (at the end of each trial) or based upon the
   occurrence of specific events (both periodic and non-periodic).  CLASP
   is available by anonymous ftp from
   and CLIP is in the directory 
   A tutorial on CLASP can be found in 
   Bugs should be reported to clasp-support@cs.umass.edu. For more
   information, contact Dave Hart <dhart@cs.umass.edu>.

   IDEAL is a LISP system developed for building and evaluating influence
   diagrams and Bayesian networks.  It is accompanied with a graphical
   user interface (CLIM-based) for constructing, editing, and solving
   belief networks and influence diagrams. For more information, write
   to srinivas@rpal.rockwell.com.


   NONLIN -- cs.umd.edu:/pub/nonlin (
   Common Lisp implementation of the NONLIN planning system originally
   designed and implemented by Austin Tate. Bugs can be reported to
   nonlin-bugs@cs.umd.edu. User's group is nonlin-users@cs.umd.edu.
   The authors request that anybody ftping the code send a message to
   nonlin-users-request@cs.umd.edu, letting them know you have a copy
   and also letting them know if you wish to subscribe to the users group.
   More information can also be obtained from Jim Hendler, hendler@cs.umd.edu.

   ABTWEAK is a complete hierarchical, non-linear planner that extends
   David Chapman's (MIT 1986) TWEAK planner as described by 
   Yang (Waterloo) and Tenenberg (Rochester) in 1989.  This implementation
   includes a complete search strategy suited to abstraction hierarchies
   known as LEFT-WEDGE (Woods 1991). This planner and related work 
   predates that of SNLP. ABTWEAK is available by anonymous ftp from
   For more information, send mail to Qiang Yang <qyang@logos.uwaterloo.ca>.
   Also, source, all related papers, and manuals are available via WWW
   at the home page of Steve Woods <sgwoods@logos.uwaterloo.ca>,
   on URL http://logos.uwaterloo.ca/students/sgwoods/sgwoods.html, or via the
   Logic Programming and Artificial Intelligence Group (LPAIG) page
   on URL http://logos.uwaterloo.ca/.

   RHETORICAL is a planning and knowledge tool available by
   anonymous ftp from ftp.cs.rochester.edu:/pub/packages/knowledge-tools
   in the files rhet-19-40.tar.Z and cl-lib-3-11.tar.Z. The files
   tempos-3-6.tar.Z and timelogic-5-0.tar.Z add James Allen's
   interval logic to Rhet. It runs on Symbolics Genera and
   Allegro Common Lisp. Written by Brad Miller <miller@cs.rochester.edu>.

   PRODIGY is an integrated planning and learning system,
   available free after signing a license agreement. Contact
   prodigy@cs.cmu.edu for more information.

   SOAR is an integrated intelligent agent architecture currently
   being developed at Carnegie Mellon University, the University of
   Michigan, and the Information Sciences Institute of the University of
   Southern California. SOAR, and its companion systems, CParaOPS5 and
   TAQL, have been placed in the public domain. The system may be
   retrieved by anonymous ftp to ftp.cs.cmu.edu (or any other CMU CS
   machine) in the directory /afs/cs.cmu.edu/project/soar/5.2/2/public/.
   [Note: You must cd to this directory in one atomic operation, as
   superior directories may be protected during an anonymous ftp.]  For
   more information, send email to soar-request@cs.cmu.edu or write to
   The Soar Group, School of Computer Science, Carnegie Mellon
   University, Pittsburgh, PA 15213.  Finally, though the software is in
   the public domain, the manual remains under copyright. To obtain one
   (at no charge) send a request (including your physical mail address)
   to soar-doc@cs.cmu.edu or to the physical address above. 

   A simple route planning agent implemented in Soar6 is available by
   anonymous ftp from 
   This is the complete code for the agent described in the IEEE Expert
   article: Smith, J. W. and Johnson, T. R., "A stratified approach to
   specifying, designing, and building knowledge systems", IEEE Expert,
   8(3):15-25, 1993.

   SNLP is a domain independent systematic nonlinear planner,
   available by anonymous ftp from cs.washington.edu:/pub/snlp.tar.Z
   Contact weld@cs.washington.edu for more information. 

   IDM is a Common Lisp implementation of both a classical and extended
   version of the STRIPS planner. It is available by anonymous ftp from 
   sauquoit.gsfc.nasa.gov ( Questions, comments and bug
   reports may be sent to idm-users@chelmsford.gsfc.nasa.gov.             

Planning Testbeds:

   TILEWORLD is a planning testbed/simulator developed at SRI
   International by Martha Pollack, Michael Frank and Marc
   Ringuette. TILEWORLD originally ran under Lucid CL, but was
   later extended and ported to Allegro CL by Badr H. Al-Badr
   and Steve Hanks. The new tileworld is available by anonymous
   ftp from cs.washington.edu as the file new-tileworld.tar.Z
   It includes an X interface. Contact pollack@cs.pitt.edu for more

   TRUCKWORLD is a simulated world intended to provide a 
   testbed for AI planning programs, where the planning agent
   is a truck with arms that roams around the simulated world. It is
   available by anonymous ftp from 
   It includes an X interface. Contact Steve Hanks <hanks@cs.washington.edu>
   for more information. Send mail to
   to be added to the mailing list.

   ARS MAGNA is a simulated world intended for use as a testbed for
   planning and mapping programs.  The simulated agent is a robot in an
   indoors environment.  High-level sensing and action are provided,
   realistically modelled on current vision and robotics research.  It is
   written in Nisp, a macro package running on top of Common Lisp.  It is
   available by anonymous ftp from 
   as file ars-magna.tar.Z.  It includes an X display.  Contact Sean Engelson
   <engelson@cs.yale.edu> for more information.

Qualitative Reasoning:

   QSIM is a qualitative reasoning system implemented in Common
   Lisp. It is available by anonymous ftp from cs.utexas.edu:/pub/qsim
   Contact Ben Kuipers <kuipers@cs.utexas.edu> for more information.

   QPE is the Qualitative Process Engine, an envisioner for QP theory.
   QPE is publically available from multivac.ils.nwu.edu:/pub/QPE
   Maintained by Ken Forbus <forbus@ils.nwu.edu>.

Theorem Proving:

   MVL (Multi-Valued Logic) is a theorem proving system written in Common
   Lisp. MVL is a bilattice-based reasoning system.  By changing the
   bilattice, you can use MVL to do truth maintenance, nonmonotonic
   reasoning, first-order reasoning, and a variety of other reasoning
   strategies.  MVL is available by anonymous ftp from 
      t.uoregon.edu:/mvl/mvl.tar.Z []
   as mvl.tar.Z. A user's manual may be found in the file manual.tex. For
   more information, contact Matthew L. Ginsberg, <ginsberg@t.stanford.edu>
   or <ginsberg@cs.stanford.edu>. Matthew asks that you send him an email
   message if you retrieve the system by anonymous ftp.

   ftp.cli.com:/pub/nqthm/nqthm.tar.Z   Contact: kaufman@cli.com
      nqthm/               Boyer and Moore's theorem prover.
                           Also available from ftp.cli.com:/pub/nqthm.
      proof-checker/       Matt Kaufmann's proof checking
                           enhancements to nqthm.
   The mailing list nqthm-users-request@cli.com is for users of the
   Boyer-Moore theorem-prover, NQTHM.

   DTP is a general first-order theorem prover incorporating intelligent
   backtracking and subgoal caching, as well as a trace facility that can
   display proof spaces graphically.  Implemented in CLtL2 Common Lisp, it runs
   in Franz Allegro, Lucid, and Macintosh (MCL) Common Lisp.  DTP is available
   on the Web at
   or by anonymous ftp from
      meta.stanford.edu:/pub/dtp/ []
   Contact Don Geddis <Geddis@CS.Stanford.EDU> for more information.

   RRL (Rewrite Rule Laboratory) -- herky.cs.uiowa.edu:/public/rrl

   FRAPPS (Framework for Resolution-based Automated Proof Procedures) is
   a portable resolution theorem-prover written in Common Lisp. It is
   available via anonymous ftp from a.cs.uiuc.edu:/pub/frapps [].
   If you take a copy of FRAPPS, please send a short note to Prof.
   Alan M. Frisch <frisch@cs.uiuc.edu>.

Truth Maintenance:

   The truth maintenance system and problem solver implementations
   described in the book "Building Problem Solvers" by Ken Forbus and
   Johan de Kleer are available by anonymous ftp from
   parcftp.xerox.com:/pub/bps/. Includes a constraint propagation
   system similar to Steele's Constraints system, among other things.
   For more information send mail to Johan de Kleer <deKleer@parc.xerox.com>.

Virtual Reality:

   VEOS (Virtual Environment Operating Shell) is an extendible environment
   for prototyping distributed applications for Unix. The programmer's
   interface uses XLISP 2.1. Although intended for distributed
   Virtual Reality applications at The Human Interface Technology Lab
   in Seattle, it should be appropriate for other applications.  VEOS
   uses heavyweight sequential processes, corresponding roughly to
   unix processes. VEOS runs on DEC/5000, Sun4, and Silicon Graphics
   VGX and Indigo. VEOS is available by anonymous ftp from
      milton.u.washington.edu:/public/veos/ []
   as veos.tar.Z. If you use the software, the authors ask that you send
   them mail to veos-support@hitl.washington.edu.


   OBVIUS -- white.stanford.edu:/obvius/ []
             whitechapel.media.mit.edu:/obvius/ []
   Object-Based Vision and Image Understanding System (OBVIUS), is a Common
   Lisp image processing package. Provides a library of image processing
   routines (e.g., convolutions, fourier transforms, statistical
   computations, etc.) on gray or binary images and image-sequences (no
   color support yet), an X windows display interface, postscript printer
   output, etc.  It uses a homebrew interface to X11 (i.e., it does not use
   clx or clue). However, they eventually hope to port Obvius to a clx/clue
   platform. Written by David Heeger <heeger@white.stanford.edu> and Eero
   Simoncelli <eero@central.cis.upenn.edu>. Runs in Lucid-4.0. Includes
   LaTeX documentation and User's Guide.


   ftp.csrl.aoyama.ac.jp:/YY/       YY window toolkit sources
   ftp.csrl.aoyama.ac.jp:/lispsrc/  Common Lisp programs, including MIT's FRL.
Go Back Up

Go To Previous

Go To Next