
                        Linux & AI/Alife mini-HOWTO

                                Version 1.1

             This document is maintained by John A. Eikenberry
                    The master page for this document is
                 http://www.ai.uga.edu/students/jae/ai.html
                   Last modified: Fri Jan 24 00:30:58 EST


Table of Contents

   * What's New
   * Introduction
        o Purpose
        o Where to find this software
        o Updates and comments
   * Basics of AI & Alife
        o AI vs Alife
   * Programming languages
   * AI class/code libraries
   * AI software kits, applications, etc.
   * Alife class/code libraries
   * Alife software kits, applications, etc.
   * Autonomous Agents
   * AI & Alife related newsgroups
   * AI & Alife resource links


What's New

(1.24.97) A couple of more agent kits. Including another perl module and the
Tocoma project. CMU lisp, a new neural net simulator, a parallel genetic
algorithm library, and a few links. Plus I've redone the links to show their
destinations (for the benefit of those seeing this as a plain text
document).

(11.14.96) I've added a new neural net simulator and a new perl agent
system.

(I forget) I got some good tips on some new stuff. Three interesting new
programming languages, plus a few applications. Thanks to Holger Schauer for
the tips.

If you know of any AI/Alife applications, class libraries, etc. Please email
me about them. Include your name, ftp and/or http sites where they can be
found, plus a brief overview/commentary on the software (this info would
make things a lot easier on me... but don't feel obligated ;).

Introduction

Purpose

The Linux OS has evolved from its origins in hackerdom to a full blown UNIX,
capable of rivaling any commercial UNIX. It now provides an inexpensive base
to build a great workstation. It currently is shedding its hardware
dependencies, being ported to DEC Alphas, Sparcs, mk86 (PowerPC/Amiga/etc.),
and many others. This potential speed boost along with its networking
support will make it great for workstation clusters. As a workstation it
allows for all sorts of research and development, including artifical
intelligence and artificial life.

The purpose of this Mini-Howto is to provide a source to find out about
various software packages, code libraries, and anything else that will help
someone get started working with (and find resources for) artifical
intelligence and artificial life. All done with Linux specifically in mind.

Where to find this software

All this software should be available via the net (ftp || http). The links
to where to find it will be provided in the description of each package.
There will also be plenty of software not covered on these pages (which is
usually platform independent) located on one of the locations listed in the
resource links section.

Updates and comments

If you find any mistakes, know of updates to one of the items below, or have
problems compiling and of the applications, please mail me at:
jae@ai.uga.edu and I'll see what I can do.

I know that keeping this list up to date, not to mention developing it in
the first place will take a lot of work. So please be patient. I hope you
will find this document helpful.


Basics of AI & Alife

AI vs Alife

This could also be known as the rational model vs the biological model.

There is some contention about how these two paradigms and how they relate
to one another. Please consider this distiction and the following
explanation as my opinion only.

AI
     The rational model (AI) is based around the ideas of logic,
     linguistics, and the concept of rationality. It is centered around the
     idea of logical rule construction. At its roots are programming
     languages such as lisp and prolog. Expert systems are the largest
     success of this paradigm. An expert system being a detailed knowledge
     base and a complex rule system to utilize it. Such systems have been
     used for such things as medical diagnosis support and credit checking
     systems.
Alife
     The biological model (Alife) has taken a different approach in
     conceiving of intelligence and the way of getting to it. This model
     stresses the use of nature for inspiration. Two major ideas have arisen
     from this basic model; neural networks and evolutionary computing.
     Neural networks are programs designed to simulate the workings of the
     brain. They consist of a network of small mathematical-based nodes,
     which work together to form patterns of information. They have
     tremendous potential and currently seem to be having a great deal of
     success with image processing and robot control. Evolutionary computing
     is really a broad term for a vast array of programming techniques
     (genetic algorithms, complex adaptive systems, evolutionary
     programming, etc.). The main thrust of all these techniques is the idea
     of evolution. The idea that a program can be written that will evolve
     toward a certain goal. This goal can be anything from solving some
     engineering problem to winning a game.

Programming languages

While any programming language can be used for artificial intelligence/life
research, these are programming languages which are used extensively for, if
not specifically made for, artificial intelligence programming.

Gdel [New]
Web page: www.cs.bris.ac.uk/~bowers/goedel.html
     Gdel is a declarative, general-purpose programming language in the
     family of logic programming languages. It is a strongly typed language,
     the type system being based on many-sorted logic with parametric
     polymorphism. It has a module system. Gdel supports infinite precision
     integers, infinite precision rationals, and also floating-point
     numbers. It can solve constraints over finite domains of integers and
     also linear rational constraints. It supports processing of finite
     sets. It also has a flexible computation rule and a pruning operator
     which generalises the commit of the concurrent logic programming
     languages. Considerable emphasis is placed on Gdel's meta- logical
     facilities which provide significant support for meta-programs that do
     analysis, transformation, compilation, verification, debugging, and so
     on.

LIFE [New]
Web page: www.isg.sfu.ca/life
     LIFE (Logic, Inheritance, Functions, and Equations) is an experimental
     programming language proposing to integrate three orthogonal
     programming paradigms proven useful for symbolic computation. From the
     programmer's standpoint, it may be perceived as a language taking after
     logic programming, functional programming, and object-oriented
     programming. From a formal perspective, it may be seen as an instance
     (or rather, a composition of three instances) of a Constraint Logic
     Programming scheme due to Hoehfeld and Smolka refining that of Jaffar
     and Lassez.

CLisp (Lisp)
FTP site: sunsite.unc.edu/pub/Linux/devel/lang/lisp/
     CLISP is a Common Lisp implementation by Bruno Haible and Michael
     Stoll. It mostly supports the Lisp described by 'Common LISP:
     TheLanguage (2nd edition)' and the ANSI Common Lisp standard. CLISP
     includes an interpreter, a byte-compiler, a large subset of CLOS
     (Object-Oriented Lisp) , a foreign language interface and, for some
     machines, a screen editor.

     The user interface language (English, German, French) is chooseable at
     run time. Major packages that run in CLISP include CLX & Garnet. CLISP
     needs only 2 MB of memory.

CMU Common Lisp [New]
Web page: www.mv.com/users/pw/lisp/index.html
FTP site: sunsite.unc.edu/pub/Linux/devel/lang/lisp/
     CMU Common Lisp is a public domain "industrial strength" Common Lisp
     programming environment. Many of the X3j13 changes have been
     incorporated into CMU CL. Whereever possible, this has been done so as
     to transparently allow the use of either CLtL1 or proposed ANSI CL.
     Probably the new features most interesting to users are SETF functions,
     LOOP and the WITH-COMPILATION-UNIT macro.

GCL (Lisp)
FTP site: sunsite.unc.edu/pub/Linux/devel/lang/lisp/
     GNU Common Lisp (GCL) has a compiler and interpreter for Common Lisp.
     It used to be known as Kyoto Common Lisp. It is very portable and
     extremely efficient on a wide class of applications. It compares
     favorably in performance with commercial Lisps on several large
     theorem-prover and symbolic algebra systems. It supports the CLtL1
     specification but is moving towards the proposed ANSI definition. GCL
     compiles to C and then uses the native optimizing C compilers (e.g.,
     GCC). A function with a fixed number of args and one value turns into a
     C function of the same number of args, returning one value, so GCL is
     maximally efficient on such calls. It has a conservative garbage
     collector which allows great freedom for the C compiler to put Lisp
     values in arbitrary registers.

     It has a source level Lisp debugger for interpreted code, with display
     of source code in an Emacs window. Its profiling tools (based on the C
     profiling tools) count function calls and the time spent in each
     function.

Mercury [New]
Web page: www.cs.mu.oz.au/~zs/mercury.html
     Mercury is a new, purely declarative logic programming language. Like
     Prolog and other existing logic programming languages, it is a very
     high-level language that allows programmers to concentrate on the
     problem rather than the low-level details such as memory management.
     Unlike Prolog, which is oriented towards exploratory programming,
     Mercury is designed for the construction of large, reliable, efficient
     software systems by teams of programmers. As a consequence, programming
     in Mercury has a different flavor than programming in Prolog.

DFKI OZ
Web page: www.ps.uni-sb.de/oz/
FTP site: ps-ftp.dfki.uni-sb.de/pub/oz/system/
     Oz is a high-level programming language designed for concurrent
     symbolic computation. It is based on a new computation model providing
     a uniform and simple foundation for several programming paradigms,
     including higher-order functional, constraint logic, and concurrent
     object-oriented programming. Oz is designed as a successor to languages
     such as Lisp, Prolog and Smalltalk, which fail to support applications
     that require concurrency, reactivity, and real-time control.

     DFKI Oz is an interactive implementation of Oz featuring a programming
     interface based on GNU Emacs, a concurrent browser, an object-oriented
     interface to Tcl/Tk, powerful interoperability features (sockets, C,
     C++), an incremental compiler, a garbage collector, and support for
     stand-alone applications. Performance is competitive with commercial
     Prolog and Lisp systems.

SWI Prolog
Web page: swi.psy.uva.nl/projects/xpce/SWI-Prolog.html
FTP site: swi.psy.uva.nl/pub/SWI-Prolog/
     The new SWI/XPCE package is out (SWI-2.7.8/XPCE-4.8.18). SWI is a free
     version of prolog in the Edinburgh Prolog family (thus making it very
     similar to Quintus and many other versions). With: a large library of
     built in predicates, a module system, garbage collectionm, a two-way
     interface with the C language, plus many other features. It is meant as
     a educational language, so it's compiled code isn't the fastest.
     Although it similarity to Quintus allows for easy porting.

     XPCE is freely available in binary form for the linux version of
     SWI-prolog. XPCE is an object oriented X-windows GUI development
     package/environment.

BIGLOO Scheme
FTP site: ftp.inria.fr:/INRIA/Projects/icsla/Implementations/
     BIGLOO is a Scheme interpreter and compiler. It conforms to the
     IEEE-Scheme standard (IEEE P1178) with some extensions, such as regular
     expression parsing (RGC), a lexical analyzer generator, a full foreign
     function interface, and a pattern matching compiler. Bigloo can also
     compile modules written in Caml (an ML dialect), letting you mix
     Scheme, ML, and C. Object-oriented programming is provided by Meroon
     v3. The main goal of Bigloo is to deliver small and fast stand alone
     applications. Bigloo produces ANSI C and hence should be easy to port.

ELK Scheme
Web site: www.informatik.uni-bremen.de/~net/elk
US FTP site: ftp.x.org/contrib/devel_tools/
EU FTP site: ftp.uni-bremen.de/pub/programming/languages/scheme/elk/
     Elk (Extension Language Kit) has been designed specifically as an
     embeddable, reusable extension language subsystem for applications
     written in C or C++. Elk is also useful as a stand-alone Scheme
     implementation, in particular as a platform for rapid prototyping of
     X11-based Scheme programs. Elk was first published in 1989; the current
     version is Elk 3.0. The Elk distribution includes a Scheme interpreter
     (embeddable and stand-alone versions), several dynamically loadable
     extensions, run-time support (including a top-level implemented in
     Scheme and a debugger), and 230+ pages of documentation (troff and
     PostScript format).

     Major features of Elk are incremental, dynamic loading of compiled
     extensions (supported on many platforms); freezing of the interpreter
     or application into a new executable file; a C/C++ programmer's
     interface for language interoperability; Scheme bindings for X11 Xlib,
     Xt, Athena and Motif Widgets; a UNIX interface (not restricted to
     POSIX); bitstrings, records, and regular expressions; a stop-and-copy
     and an incremental, generational garbage collector.

MIT Scheme
FTP site: swiss-ftp.ai.mit.edu:/archive/sheme-7.4/
     MIT Scheme includes Edwin (Scheme's Emacs-like editor) and Liar (the
     Scheme compiler). Does not have a convenient foreign function interface
     yet. FTP distribution includes MIT C-Scheme Reference and User manuals,
     as well as the Revised^4 Report on Scheme.

Scheme->C
FTP site: gatekeeper.dec.com:/pub/DEC/Scheme-to-C/
     Scheme->C is an R4RS compliant Scheme system that is centered around a
     compiler that compiles Scheme to C. Besides the base language, the
     system includes "expansion passing style" macros, a foreign function
     call capability, records, weak pointers, 3 X11 interfaces, call/cc, and
     a generational, conservative, copying garbage collector. The result is
     a system that is portable, efficient, and able to build applications
     that contain a mix of compiled and interpreted Scheme, and compiled
     code from C, C++ and other languages.

Scheme 48
FTP site: swiss-ftp.ai.mit.edu:/archive/s48/
     Scheme 48 is a Scheme implementation based on a virtual machine
     architecture. Scheme 48 is designed to be straightforward, flexible,
     reliable, and fast. It should be easily portable to 32-bit
     byte-addressed machines that have POSIX and ANSI C support. In addition
     to the usual Scheme built-in procedures and a development environment,
     library software includes support for hygienic macros (as described in
     the Revised^4 Scheme report), multitasking, records, exception
     handling, hash tables, arrays, weak pointers, and FORMAT. Scheme 48
     implements and exploits an experimental module system loosely derived
     from Standard ML and Scheme Xerox. The development environment supports
     interactive changes to modules and interfaces.

SCM (Scheme)
FTP site: swiss-ftp.ai.mit.edu:/archive/scm/
     SCM conforms to the Revised^4 Report on the Algorithmic Language Scheme
     and the IEEE P1178 specification. Scm is written in C. It uses the
     following utilities (all available at the ftp site).
     SLIB (Standard Scheme Library) is a portable Scheme library which is
     intended to provide compatability and utility functions for all
     standard Scheme implementations, including SCM, Chez, Elk, Gambit,
     MacScheme, MITScheme, scheme->C, Scheme48, T3.1, and VSCM, and is
     available as the file slib2a0.tar.gz. Written by Aubrey Jaffer.
     JACAL is a symbolic math system written in Scheme, and is available as
     the file jacal1a4.tar.gz.
     SCMCONFIG contains additional files for the SCM distribution to build
     SCM on Unix machines using GNU autoconf.
     SLIB-PSD is a portable debugger for Scheme (requires emacs editor).
     TURTLSCM is a turtle graphics package which works with SCM on MSDOS or
     X11 machines. Written by Mkinen Sami and Jarkko Leppanen , it is
     available as the file turtlegr.tar.Z.
     XSCM is an X Windows interface to Xlib and the Motif and OpenLook
     toolkits for the SCM interpreter. It requires scm4a10 or later. It
     should be available as xscm1.05.tar.Z. Contact campbell@redsox.bsw.com
     for more information. WB is a disk based, sorted associative array C
     library (database). These associative arrays consist of variable length
     (less that 256 bytes) keys and values.
     WB comes with an interface to SCM. Basic operations are creation,
     destruction, opening and closing of diskfiles and arrays, insertion,
     deletion, retrieval, successor, and predecessor (with respect to
     dictionary order of keys). Functional application of find-next,
     deletion, and modification over a range of consecutive key values is
     supported. Multiple associative arrays can be stored in one disk file.
     Simultaneous access to multiple disk files is supported. A structure
     checker, garbage collector are included. A repair program and ram-disk
     type file (for temporary structures) are in developement. The current
     WB implementation has a file size limit of 2^32 * block size (default
     2048) = 2^43 bytes (8796 Gbytes). WB does its own memory and disk
     management. WB is available as wb1a1.tar.z.

AI class/code libraries

These are libraries of code or classes for use in programming within the
artificial intelligence field. They are not meant as stand alone
applications, but rather as tools for building your own applications.

AI Search
FTP site: ftp.icce.rug.nl/pub/peter/
Submitted by: Peter M. Bouthoorn
     Basically, the library offers the programmer a set of search algorithms
     that may be used to solve all kind of different problems. The idea is
     that when developing problem solving software the programmer should be
     able to concentrate on the representation of the problem to be solved
     and should not need to bother with the implementation of the search
     algorithm that will be used to actually conduct the search. This idea
     has been realized by the implementation of a set of search classes that
     may be incorporated in other software through C++'s features of
     derivation and inheritance. The following search algorithms have been
     implemented:

     - depth-first tree and graph search.
     - breadth-first tree and graph search.
     - uniform-cost tree and graph search.
     - best-first search.
     - bidirectional depth-first tree and graph search.
     - bidirectional breadth-first tree and graph search.
     - AND/OR depth tree search.
     - AND/OR breadth tree search.

     Peter plans to release a new verision of the library soon, which will
     also be featured in a book about C++ and AI to appear this year.

AI software kits, applications, etc.

These are various applications, software kits, etc. meant for research in
the field of artificial intelligence. Their ease of use will vary, as they
were designed to meet some particular research interest more than as an easy
to use commercial package.

ASA - Adaptive Simulated Annealing
Web site: www.ingber.com/
FTP site: ftp.ingber.com/
     ASA (Adaptive Simulated Annealing) is a powerful global optimization
     C-code algorithm especially useful for nonlinear and/or stochastic
     systems.

     ASA is developed to statistically find the best global fit of a
     nonlinear non-convex cost-function over a D-dimensional space. This
     algorithm permits an annealing schedule for 'temperature' T decreasing
     exponentially in annealing-time k, T = T_0 exp(-c k^1/D). The
     introduction of re-annealing also permits adaptation to changing
     sensitivities in the multi-dimensional parameter-space. This annealing
     schedule is faster than fast Cauchy annealing, where T = T_0/k, and
     much faster than Boltzmann annealing, where T = T_0/ln k.

Babylon
FTP site: ftp.gmd.de/gmd/ai-research/Software/Babylon/
     BABYLON is a modular, configurable, hybrid environment for developing
     expert systems. Its features include objects, rules with forward and
     backward chaining, logic (Prolog) and constraints. BABYLON is
     implemented and embedded in Common Lisp.

CLEARS [New]
Web site: www.coli.uni-sb.de/~clears/
     The CLEARS system is an interactive graphical environment for
     computational semantics. The tool allows exploration and comparison of
     different semantic formalisms, and their interaction with syntax. This
     enables the user to get an i dea of the range of possibilities of
     semantic construction, and also where there is real convergence between
     theories.

CLIPS
Web site: www.jsc.nasa.gov/~clips/CLIPS.html
FTP site:
cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/areas/expert/systems/clips
Submitted by: Oori Hasson
     CLIPS is a productive development and delivery expert system tool which
     provides a complete environment for the construction of rule and/or
     object based expert systems.

     CLIPS provides a cohesive tool for handling a wide variety of knowledge
     with support for three different programming paradigms: rule-based,
     object-oriented and procedural. Rule-based programming allows knowledge
     to be represented as heuristics, or "rules of thumb," which specify a
     set of actions to be performed for a given situation. Object-oriented
     programming allows complex systems to be modeled as modular components
     (which can be easily reused to model other systems or to create new
     components). The procedural programming capabilities provided by CLIPS
     are similar to capabilities found in languages such as C, Pascal, Ada,
     and LISP.

EMA-XPS - A Hybrid Graphic Expert System Shell [New]
Web site: wmwap1.math.uni-wuppertal.de:80/EMA-XPS/
     EMA-XPS is a hybrid graphic expert system shell based on the
     ASCII-oriented shell Babylon 2.3 of the German National Research Center
     for Computer Sciences (GMD). In addition to Babylon's AI-power (object
     oriented data representation, forward and backward chained rules -
     collectable into sets, horn clauses, and constraint networks) a graphic
     interface based on the X11 Window System and the OSF/Motif Widget
     Library has been provided.

FOOL & FOX
FTP site: ntia.its.bldrdoc.gov/pub/fuzzy/prog/
     FOOL stands for the Fuzzy Organizer OLdenburg. It is a result from a
     project at the University of Oldenburg. FOOL is a graphical user
     interface to develop fuzzy rulebases. FOOL will help you to invent and
     maintain a database that specifies the behaviour of a fuzzy-controller
     or something like that.

     FOX is a small but powerful fuzzy engine which reads this database,
     reads some input values and calculates the new control value.

Otter: An Automated Deduction System [New]
Web site: www.mcs.anl.gov/home/mccune/ar/otter
     Our current automated deduction system Otter is designed to prove
     theorems stated in first-order logic with equality. Otter's inference
     rules are based on resolution and paramodulation, and it includes
     facilities for term rewriting, term orderings, Knuth-Bendix completion,
     weighting, and strategies for directing and restricting searches for
     proofs. Otter can also be used as a symbolic calculator and has an
     embedded equational programming system.

Scsh
FTP site: swiss-ftp.ai.mit.edu/pub/su/scsh/
     Scsh is a Unix shell/systems programming environment implemented on top
     of Scheme 48 (a portable, byte-code compiled R4RS Scheme
     implementation). Scsh provides:

     - A high-level macro notation for writing typical shell-script
     computations: running programs, pipelines, I/O redirection, and so
     forth.

     - A complete system-call interface to Unix: fork, exec, I/O, file
     system, time, env vars, and so forth. The I/O interface includes a
     *complete* interface to BSD sockets, both Unix and TCP/IP domains. I/O
     is completely integrated with Scheme ports. System calls return useful
     values, not error codes; errors are reported by raising exceptions
     which can be caught by handlers. -Other useful shell-programming
     utilities: filename globbing/pattern matching, regexp matching, macros
     for writing AWK-like programs, field and record parsers, and so forth.

     -The ability to write executable shell scripts using the Unix #!
     interpreter feature, with access to command-line argv values.

     These features are completely integrated into Scheme 48's R4RS Scheme
     implementation; the programming language is Scheme. The scsh release is
     self-contained -- it comes with its own complete Scheme 48
     implementation.

Alife class/code libraries

These are libraries of code or classes for use in programming within the
artificial life field. They are not meant as stand alone applications, but
rather as tools for building your own applications.

GAGS
Web site: kal-el.ugr.es/gags.html
FTP site: kal-el.ugr.es/GAGS/
     Genetic Algorithm application generator and class library written
     mainly in C++.
     As a class library, and among other thing, GAGS includes:
        o A chromosome hierarchy with variable length chromosomes. Genetic
          operators: 2-point crossover, uniform crossover, bit-flip
          mutation, transposition (gene interchange between 2 parts of the
          chromosome), and variable-length operators: duplication,
          elimination, and random addition.
        o Population level operators include steady state, roulette wheel
          and tournament selection.
        o Gnuplot wrapper: turns gnuplot into a iostreams-like class.
        o Easy sample file loading and configuration file parsing.
     As an application generator (written in PERL), you only need to supply
     it with an ANSI-C or C++ fitness function, and it creates a C++ program
     that uses the above library to 90% capacity, compiles it, and runs it,
     saving results and presenting fitness thru gnuplot.

     Last version released has been 0.92; 0.94e is in beta stage, but seems
     to be stable. This version includes a TCL/TK GUI (soon, or at least
     some day, to be changed to tkPERL), as well as many improvements on the
     code.

GAlib: Matthew's Genetic Algorithms Library
Web Site: lancet.mit.edu/ga/
FTP site: lancet.mit.edu/pub/ga/
Register GAlib at: http://lancet.mit.edu/ga/Register.html
     GAlib contains a set of C++ genetic algorithm objects. The library
     includes tools for using genetic algorithms to do optimization in any
     C++ program using any representation and genetic operators. The
     documentation includes an extensive overview of how to implement a
     genetic algorithm as well as examples illustrating customizations to
     the GAlib classes.

GALOPPS
Web site: isl.msu.edu/GA/software/galopps/index.html
FTP site: isl.cps.msu.edu/pub/GA/galopps/
     GALOPPS is a flexible, generic GA, in 'C'. It was based upon Goldberg's
     Simple Genetic Algorithm (SGA) architecture, in order to make it easier
     for users to learn to use and extend.

     GALOPPS extends the SGA capabilities several fold:
        o (optional) A new Graphical User Interface, based on TCL/TK, for
          Unix users, allowing easy running of GALOPPS 3.2 (single or
          multiple subpopulations) on one or more processors. GUI
          writes/reads "standard" GALOPPS input and master files, and
          displays graphical output (during or after run) of user-selected
          variables.
        o 5 selection methods: roulette wheel, stochastic remainder
          sampling, tournament selection, stochastic universal sampling,
          linear-ranking-then-SUS.
        o Random or superuniform initialization of "ordinary"
          (non-permutation) binary or non-binary chromosomes; random
          initialization of permutation-based chromosomes; or user-supplied
          initialization of arbitrary types of chromosomes.
        o Binary or non-binary alphabetic fields on value-based chromosomes,
          including different user-definable field sizes.
        o 3 crossovers for value-based representations: 1-pt, 2-pt, and
          uniform, all of which operate at field boundaries if a non-binary
          alphabet is used.
        o 4 crossovers for order-based reps: PMX, order-based, uniform
          order-based, and cycle.
        o 4 mutations: fast bitwise, multiple-field, swap and random sublist
          scramble.
        o Fitness scaling: linear scaling, Boltzmann scaling, sigma
          truncation, window scaling, ranking.
        o Plus a whole lot more....

John von Neumann Universal Constructor
Web site: alife.santafe.edu/alife/software/jvn.html
FTP site: alife.santafe.edu/pub/SOFTWARE/jvn/
     The universal constructor of John von Neumann is an extension of the
     logical concept of universal computing machine. In the cellular
     environment proposed by von Neumann both computing and constructive
     universality can be achieved. Von Neumann proved that in his cellular
     lattice both a Turing machine and a machine capable of producing any
     other cell assembly, when fed with a suitable program, can be embedded.
     He called the latter machine a "universal constructor" and showed that,
     when provided with a program containing its own description, this is
     capable of self-reproducing.

lil-ga
Web site: isl.msu.edu/GA/software/lil-gp/index.html
FTP site: isl.cps.msu.edu/pub/GA/lilgp/
     lil-gp is a generic 'C' genetic programming tool. It was written with a
     number of goals in mind: speed, ease of use and support for a number of
     options including:
        o Generic 'C' program that runs on UNIX workstations
        o Support for multiple population experiments, using arbitrary and
          user settable topologies for exchange, for a single processor
          (i.e., you can do multiple population gp experiments on your PC).
        o lil-gp manipulates trees of function pointers which are allocated
          in single, large memory blocks for speed and to avoid swapping.

PGAPack Parallel Genetic Algorithm Library [New]
Web site: www.mcs.anl.gov/home/levine/PGAPACK/index.html
FTP site: ftp.mcs.anl.gov/pub/pgapack/
     PGAPack is a general-purpose, data-structure-neutral, parallel genetic
     algorithm library. It is intended to provide most capabilities desired
     in a genetic algorithm library, in an integrated, seamless, and
     portable manner. Key features are in PGAPack V1.0 include:
        o Callable from Fortran or C.
        o Runs on uniprocessors, parallel computers, and workstation
          networks.
        o Binary-, integer-, real-, and character-valued native data types.
        o Full extensibility to support custom operators and new data types.
        o Easy-to-use interface for novice and application users.
        o Multiple levels of access for expert users.
        o Parameterized population replacement.
        o Multiple crossover, mutation, and selection operators.
        o Easy integration of hill-climbing heuristics.
        o Extensive debugging facilities.
        o Large set of example problems.
        o Detailed users guide.

Swarm
Web site: www.santafe.edu/projects/swarm
FTP site: ftp.santafe.edu/pub/swarm
     The swarm alife simulation kit. Swarm is a simulation environment which
     facilitates development and experimentation with simulations involving
     a large number of agents behaving and interacting within a dynamic
     environment. It consists of a collection of classes and libraries
     written in Objective-C and allows great flexibility in creating
     simulations and analyzing their results. It comes with three (3) demos
     and good documentation.

     It requires Tcl7.4/Tk4.0, libtclobjc and BLT 2.1 (both available at the
     swarm site). BLT2.1 requires one small fix to compile on linux. Modify
     the top level Makefile to make sure it points at the right tcl/tk
     files:
     STD_LIBS = -ltk -ltcl -L/usr/X11R6/lib -lX11
     This is with RedHat 3.0.3 (should be the same for slackware or just
     about any other distribution).

Alife software kits, applications, etc.

These are various applications, software kits, etc. meant for research in
the field of artificial life. Their ease of use will vary, as they were
designed to meet some particular research interest more than as an easy to
use commercial package.

Aspirin/MIGRAINES [New]
FTP site:
sunsite.unc.edu/pub/academic/computer-science/neural-networks/programs/Aspirin/
     The software that we are releasing now is for creating, and evaluating,
     feed-forward networks such as those used with the backpropagation
     learning algorithm. The software is aimed both at the expert
     programmer/neural network researcher who may wish to tailor significant
     portions of the system to his/her precise needs, as well as at casual
     users who will wish to use the system with an absolute minimum of
     effort.

BugsX
FTP site: ftp.Germany.EU.net/pub/research/softcomp/Alife/packages/bugsx/
     Display and evolve biomorphs. It is a program which draws the biomorphs
     based on parametric plots of Fourier sine and cosine series and let's
     you play with them using the genetic algorithm.

dblife & dblifelib
FTP site: sunsite.unc.edu/pub/linux/X11/games/other/
     dblife: Sources for a fancy Game of Life program for X11 (and curses).
     It is not meant to be incredibly fast (use xlife for that:-). But it IS
     meant to allow the easy editing and viewing of Life objects and has
     some powerful features. The related dblifelib package is a library of
     Life objects to use with the program.

     dblifelib: This is a library of interesting Life objects, including
     oscillators, spaceships, puffers, and other weird things. The related
     dblife package contains a Life program which can read the objects in
     the Library.

Drone
Web site: pscs.physics.lsa.umich.edu/Software/Drone/
     Drone is a tool for automatically running batch jobs of a simulation
     program. It allows sweeps over arbitrary sets of parameters, as well as
     multiple runs for each parameter set, with a separate random seed for
     each run. The runs may be executed either on a single computer or over
     the Internet on a set of remote hosts. Drone is written in Expect (an
     extension to the Tcl scripting language) and runs under Unix. It was
     originally designed for use with the Swarm agent-based simulation
     framework, but Drone can be used with any simulation program that reads
     parameters from the command line or from an input file.

LEE
Web site: www-cse.ucsd.edu/users/fil/lee/lee.html
FTP site: www-cse.ucsd.edu/users/fil/lee/lee.html
     LEE (Latent Energy Environments) is both an Alife model and a software
     tool to be used for simulations within the framework of that model. We
     hope that LEE will help understand a broad range of issues in
     theoretical, behavioral, and evolutionary biology. The LEE tool
     described here consists of approximately 7,000 lines of C code and runs
     in both Unix and Macintosh platforms.

Net-Life & ZooLife
Net-Life Web site: www.d.umn.edu/~cbusch/dist/net-life-htmls/netlife.html
ZooLife Web site: www.d.umn.edu/~cbusch/dist/net-life-htmls/zoolife.html
FTP site: www.d.umn.edu/~cbusch/dist/
*(netlife-2.0.tar.gz contains both Net-Life and ZooLife)
     Net-Life is a simulation of artificial-life, with neural "brains"
     generated via slightly random techniques. Net-Life uses artificial
     neural nets and evolutionary algorithms to breed artificial organisms
     that are similar to single cell organisms. Net-life uses asexual
     reproduction of its fittest individuals with a chance of mutation after
     each round to eventually evolve successful life-forms.

     ZooLife is a simulation of artificial-life. ZooLife uses probablistic
     methods and evolutionary algorithms to breed artificial organisms that
     are similar to plant/animal zoo organisms. ZooLife uses asexual
     reproduction with a chance of mutation.

Neureka ANS (nn/xnn) [New]
Web site: www.bgif.no/neureka/ FTP site: ftp.ii.uib.no/pub/neureka/linux/
     nn is a high-level neural network specification language. The current
     version is best suited for feed-forward nets, but recurrent models can
     and have been implemented, e.g. Hopfield nets, Jordan/Elman nets, etc.
     In nn, it is easy to change network dynamics. The nn compiler can
     generate C code or executable programs (so there must be a C compiler
     available), with a powerful command line interface (but everything may
     also be controlled via the graphical interface, xnn). It is possible
     for the user to write C routines that can be called from inside the nn
     specification, and to use the nn specification as a function that is
     called from a C program. Please note that no programming is necessary
     in order to use the network models that come with the system
     (`netpack').

     xnn is a graphical front end to networks generated by the nn compiler,
     and to the compiler itself. The xnn graphical interface is intuitive
     and easy to use for beginners, yet powerful, with many possibilities
     for visualizing network data.

     NOTE: You have to run the install program that comes with this to get
     the licence key installed. It gets put (by default) in /usr/lib. If you
     (like myself) want to install the package somewhere other than in the
     /usr directory structure (the install program gives you this option)
     you will have to set up some environmental variables (NNLIBDIR &
     NNINCLUDEDIR are required). You can read about these (and a few other
     optional variables) in appendix A of the documentation (pg 113).

PDP++
Web site: www.cnbc.cmu.edu/PDP++/
FTP site (US): hydra.psy.cmu.edu/pub/pdp++/
FTP site (Europe): unix.hensa.ac.uk/mirrors/pdp++/
     As the field of connectionist modeling has grown, so has the need for a
     comprehensive simulation environment for the development and testing of
     connectionist models. Our goal in developing PDP++ has been to
     integrate several powerful software development and user interface
     tools into a general purpose simulation environment that is both user
     friendly and user extensible. The simulator is built in the C++
     programming language, and incorporates a state of the art script
     interpreter with the full expressive power of C++. The graphical user
     interface is built with the Interviews toolkit, and allows full access
     to the data structures and processing modules out of which the
     simulator is built. We have constructed several useful graphical
     modules for easy interaction with the structure and the contents of
     neural networks, and we've made it possible to change and adapt many
     things. At the programming level, we have set things up in such a way
     as to make user extensions as painless as possible. The programmer
     creates new C++ objects, which might be new kinds of units or new kinds
     of processes; once compiled and linked into the simulator, these new
     objects can then be accessed and used like any other.

SNNS
Web site: www.informatik.uni-stuttgart.de/ipvr/bv/projekte/snns/snns.html
FTP site: ftp.informatik.uni-stuttgart.de/pub/SNNS/
     Stuttgart Neural Net Simulator (version 4.1). An awsome neural net
     simulator. Better than any commercial simulator I've seen. The
     simulator kernel is written in C (it's fast!). It supports over 20
     different network architectures, has 2D and 3D X-based graphical
     representations, the 2D GUI has an integrated network editor, and can
     generate a separate NN program in C.
     SNNS is very powerful, though a bit difficult to learn at first. To
     help with this it comes with example networks and tutorials for many of
     the architectures.
     ENZO, a supplimentary system allows you to evolve your networks with
     genetic algorithms.

     The Readme.linux file that comes with this package must be old. It's
     instructions for building the package are wrong. I've edited it to
     reflect what I had to do to get the package to compile. Please download
     SNNS.Readme.linux and use it instead of the Readme.linux file that
     comes with the distribution.

Tierra
Web site: www.hip.atr.co.jp/~ray/tierra/tierra.html
FTP site: tierra.slhs.udel.edu/tierra/
Alternate FTP site: sunsite.unc.edu/pub/Linux/apps/
     Tierra's written in the C programming language. This source code
     creates a virtual computer and its operating system, whose architecture
     has been designed in such a way that the executable machine codes are
     evolvable. This means that the machine code can be mutated (by flipping
     bits at random) or recombined (by swapping segments of code between
     algorithms), and the resulting code remains functional enough of the
     time for natural (or presumably artificial) selection to be able to
     improve the code over time.

Various Neural Networks
Web site: www.mcs.com/~drt/svbp.html
Submitted by: Don Tveter
     Example neural net codes from the book, The Basis of Artificial
     Intelligence. These are simple example codes of these various neural
     nets. They work well as a good starting point for simple
     experimentation and for learning what the code is like behind the
     simulators. The types of networks available on this site are:
     (implemented in C++)

        o The Backprop Package
        o The Nearest Neighbor Algorithms
        o The Interactive Activation Algorithm
        o The Hopfield and Boltzman machine Algorithms
        o The Linear Pattern Classifier
        o ART I
        o Bi-Directional Associative Memory
        o The Feedforward Counter-Propagation Network

XLIFE
FTP site: sunsite.unc.edu/pub/linux/X11/games/other/
     This program will evolve patterns for John Horton Conway's game of
     Life. It will also handle general cellular automata with the orthogonal
     neighborhood and up to 8 states (it's possible to recompile for more
     states, but very expensive in memory). Transition rules and sample
     patterns are provided for the 8-state automaton of E. F. Codd, the
     Wireworld automaton, and a whole class of `Prisoner's Dilemma' games.

Autonomous Agents

This is a collection of software meant for the developement of software
agents and bots of various sorts (irc bots, chatterbots, etc.). I have given
them their own section sense they didn't seem to quite make sense in any of
the above.

AgentK
Web site: www.csd.abdn.ac.uk/~pedwards/publs/agentk.html
FTP site: ftp.csd.abdn.ac.uk/pub/wdavies/agentk
     This package synthesizes two well-known agent paradigms: Agent-Oriented
     Programming, Shoham (1990), and the Knowledge Query & Manipulation
     Language, Finin (1993). The initial implementation of AOP, Agent-0, is
     a simple language for specifying agent behaviour. KQML provides a
     standard language for inter-agent communication. Our integration (which
     we have called Agent-K) demonstrates that Agent-0 and KQML are highly
     compatible. Agent-K provides the possibility of inter-operable (or
     open) software agents, that can communicate via KQML and which are
     programmed using the AOP approach.

Agent, the Perl5 Module [New]
Web site: www.hawk.igs.net/~jduncan/agent/
     The Agent is a prototype for an Information Agent system. It is both
     platform and language independent, as it stores contained information
     in simple packed strings. It can be packed and shipped across any
     network with any format, as it freezes itself in its current state.

AGENT TCL
Web site: www.cs.dartmouth.edu/~agent/
FTP site: cs.dartmouth.edu/pub/agents/
     A transportable agent is a program that can migrate from machine to
     machine in a heterogeneous network. The program chooses when and where
     to migrate. It can suspend its execution at an arbitary point,
     transport to another machine and resume execution on the new machine.
     For example, an agent carrying a mail message migrates first to a
     router and then to the recipient's mailbox. The agent can perform
     arbitrarily complex processing at each machine in order to ensure that
     the message reaches the intended recipient.

Java(tm) Agent Template
Web site: cdr.stanford.edu/ABE/JavaAgent.html
     The JAT provides a fully functional template, written entirely in the
     Java language, for constructing software agents which communicate
     peer-to-peer with a community of other agents distributed over the
     Internet. Although portions of the code which define each agent are
     portable, JAT agents are not migratory but rather have a static
     existance on a single host. This behavior is in contrast to many other
     "agent" technologies. (However, using the Java RMI, JAT agents could
     dynamically migrate to a foriegn host via an agent resident on that
     host). Currently, all agent messages use KQML as a top-level protocol
     or message wrapper. The JAT includes functionality for dynamically
     exchanging "Resources", which can include Java classes (e.g. new
     languages and interpreters, remote services, etc.), data files and
     information inlined into the KQML messages.

Penguin! [New]
Web site: www.eden.com/~fsg/penguin.html
     Penguin is a Perl 5 module. It provides you with a set of functions
     which allow you to:
        o send encrypted, digitally signed perl code to a remote machine to
          be executed.
        o receive code and, depending on who signed it, execute it in an
          arbitrarily secure, limited compartment.
     The combination of these functions enable direct perl coding of
     algorithms to handle safe internet commerce, mobile
     information-gathering agents, "live content" web browser helper apps,
     distributed load-balanced computation, remote software update, distance
     machine administration, content-based information propagation,
     Internet-wide shared-data applications, network application builders,
     and so on.

TclRobots
FTP site: ftp.neosoft.com/pub/tcl/alcatel/code/
     TclRobots is a programming game, similar to 'Core War'. To play
     TclRobots, you must write a Tcl program that con- trols a robot. The
     robot's mission is to survive a battle with other robots. Two, three,
     or four robots compete during a battle, each running different programs
     (or pos- sibly the same program in different robots.) Each robot is
     equipped with a scanner, cannon, drive mechanism. A single match
     continues until one robot is left running. Robots may compete
     individually, or combine in a team ori- ented battle. A tournament can
     be run with any number of robot programs, each robot playing every
     other in a round- robin fashion, one-on-one. A battle simulator is
     avail- able to help debug robot programs.

     The TclRobots program provides a physical environment, imposing certain
     game parameters to which all robots must adhere. TclRobots also
     provides a view on a battle, and a controlling user interface.
     TclRobots requirements: a wish interpreter built from Tcl 7.4 and Tk
     4.0.

The Tocoma Project [New]
Web site: www.cs.uit.no/DOS/Tacoma/index.html
     An agent is a process that may migrate through a computer network in
     order to satisfy requests made by clients. Agents are an attractive way
     to describe network-wide computations.

     The TACOMA project focuses on operating system support for agents and
     how agents can be used to solve problems traditionally addressed by
     operating systems. We have implemented a series of prototype systems to
     support agents.

     TACOMA Version 1.2 is based on UNIX and TCP. The system supports agents
     written in C, Tcl/Tk, Perl, Python, and Scheme (Elk). It is implemented
     in C. This TACOMA version has been in public domain since April 1996.

     We are currently focusing on heterogeneity, fault-tolerance, security
     and management issues. Also, several TACOMA applications are under
     construction. We implemented StormCast 4.0, a wide-area network weather
     monitoring system accessible over the internet, using TACOMA and Java.
     We are now in the process of evaluating this application, and plan to
     build a new StormCast version to be completed by June 1997.

Khepera Simulator
Web site: wwwi3s.unice.fr/~om/khep-sim.html
     Khepera Simulator is a public domain software package written by
     Olivier MICHEL during the preparation of his Ph.D. thesis, at the
     Laboratoire I3S, URA 1376 of CNRS and University of Nice-Sophia
     Antipolis, France. It allows to write your own controller for the
     mobile robot Khepera using C or C++ languages, to test them in a
     simulated environment and features a nice colorful X11 graphical
     interface. Moreover, if you own a Khepera robot, it can drive the real
     robot using the same control algorithm. It is mainly destinated to
     researchers studying autonomous agents.

VWORLD
Web site: www.ai.uga.edu/students/jae/projects.html#vworld
     Vworld is a simulated environment for research with autonomous agents
     written in prolog. It is currently in something of an beta stage. It
     works well with SWI-prolog, but should work with Quitnus-prolog with
     only a few changes. It is being designed to serve as an educational
     tool for class projects dealing with prolog and autonomous agents. It
     comes with three demo worlds or environements, along with sample agents
     for them.
     There are two versions now. One written for SWI-prolog and one written
     for LPR-prolog. Documentation is roughly done (with a student/professor
     framework in mind), and a graphical interface is planned.

AI & Alife related newsgroups

These newgroups are not Linux specific. But they are good resources for
anyone working in artificial intelligence or artficial life. If you can't
access these newsgroups, many of their FAQs are available at:
http://www.cis.ohio-state.edu/hypertext/faq/bngusenet/comp/ai/top.html

   * comp.ai
   * comp.ai.edu
   * comp.ai.genetic
   * comp.ai.neural-nets
   * comp.ai.vision
   * comp.ai.fuzzy
   * comp.ai.games
   * comp.ai.jair.announce
   * comp.ai.jair.papers
   * comp.ai.nat-lang
   * comp.ai.nlang-know-rep
   * comp.ai.philosophy
   * comp.ai.shells
   * comp.ai.alife
   * comp.ai.doc-analysis.misc
   * comp.ai.doc-analysis.ocr
   * comp.lang.prolog
   * comp.lang.lisp
   * alt.irc.bots

AI & Alife resource links

These are a few of the many AI and Alife sites out there. These sites are
good places to start hunting for more information or for finding software.
I'll be adding more links to this list soon, as well as organizing it
better. These links are not Linux specific, but I wanted to include them to
provide a jump off point to the huge amount of info related to these topics
located on the web.

AI & Alife archives, software resources, etc.

   * alife.santafe.edu/~joke/zooland/ZooLand Artificial Life Resources
   * www.neuronet.ph.kcl.ac.uk/neuronet/software/software.htmlNEuroNet - ANN
     software
   * www.cs.cmu.edu/Web/Groups/AI/html/repository.html-CMU Artificial
     Intelligence Repository

AI Research, Bibliographies, Books, etc.

   * www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/clm/clm.html-Common
     Lisp Book
   * www.cs.indiana.edu/scheme-repository/home.html-Scheme repository
   * agents.www.media.mit.edu/groups/agents/-MIT Media Lab, Autonomous
     Agents Group
   * www.aic.nrl.navy.mil/Navy Center for Applied Research in Artificial
     Intelligence
   * intranet.ca/~sshah/waste/waste.htmlWASTE (AI Contest)
   * www.cs.washington.edu/research/jair/home.html-Journal of Artificial
     Intelligence Research
   * www.cs.ucl.ac.uk/misc/ai/-University of London's AI Resource Page
   * www.cris.com/~swoodcoc/ai.html -Artificial Intelligence in Games
   * www.st.rim.or.jp/~kanada/research-database.html-Yasusi Kanada's
     Resource Page
   * www.cs.umbc.edu/agents/agentnews/-AgentNews Webletter
   * arti.vub.ac.be/www/steels/-Luc Steels homepage

Alife Research, Bibliographies, Books, etc.

   * alife.santafe.edu-Santafe's Alife page
   * www.krl.caltech.edu/~brown/alife/-Alife FAQ
   * www.cogs.susx.ac.uk/users/ezequiel/alife-page/alife.htmlALife
     Bibliography
   * www.fusebox.com/cb/alife.htmlThe Live Alife Page
   * complex.csu.edu.au/complex/-Complex Systems Information Network
   * www.serve.com/~ale/html/cplxsys.html-Complex (Adaptive) Systems
     Information
   * www.ezone.com/sos/-Self Organizing Systems
   * gracco.irmkant.rm.cnr.it/luigi/lupa_algames.html-The Artificial Life
     Games Homepage
   * www.krl.caltech.edu/~charles/alife-game/-Project: Von Neumann
   * alife.santafe.edu/~joke/encore/-ENCORE-The Hitch-Hikers Guide to
     Evolutionary Computation
   * gal4.ge.uiuc.edu/illigal.home.html-IlliGAL Home Page (GA's)
   * isl.msu.edu/GA/ -MSU GARAGe Home Page (GA's)
   * www.owlnet.rice.edu/~jjf/gp/-The Genetic Programming Notebook
   * www.aracnet.com/~wwir/NovaGenetica/-Nova Genetica (GA's)

