[Linux & AI/Alife mini-HOWTO]

                                Version 1.2

             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: Mon May 19 00:26:49 EDT 1997

[Image]

Table of Contents

   * What's New
   * Introduction
        o Purpose
        o Where to find this software
        o Updates and comments
        o Basics of AI & Alife
   * Programming languages
   * AI
        o AI class/code libraries
        o AI software kits, applications, etc.
   * Connectionism (neural nets)
        o Connectionist Class/Code Libraries
        o Connectionist Applications
   * Evolutionary Computing (EC) (genetic algorithms/programming)
        o EC Class/Code Libraries
        o EC Applications
   * Alife
        o Alife class/code libraries
        o Alife software kits, applications, etc.
   * Autonomous Agents
   * AI & Alife related newsgroups
   * AI & Alife resource links

[border]

What's New

(5.18.97)I've done a bit of cleaning in the links section. I've also added a
genetic programming library (GP kernel), the ADATE system, the Sugal (GA)
system, Geco (GA), Grammer Work Bench (NLP), Screamer (lisp library), SNePS,
Ara, JATlite, Fuf and SURGE, and finally TIN (alife). I've also begun a
reorganization of this page. This will end up with two versions of this
page. One, like this one, containing the whole howto, the second will be
broken up into parts to allow for troublesome connections.

(5.8.97)I've updated some dead or outdated links. I've collected a ton of
material to add over the last couple months, but have been incredibly busy.
I'm going to try to find the time to update this page soon.

(3.4.97)I removed Scsh and put it on my linux page. The more I thought about
it, the less Scsh seemed an AI application. I also added Soar, a general
coginitive architecture development system. It looks pretty cool and should
work on linux (any info to the contrary would be appreciated, I don't have
time right now t o mess with it). Last but not least, I've added a couple
more Scheme implementations to the list (can you tell I really like scheme).

(2.16.97) A new robot simulator, another neural net simulator, a cellular
automata simulation system, and a new (optimizable) version of prolog.

(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.

[border]

Basics of AI & Alife

AI and Alife can be broken down into many subfields. I try to give a *very*
brief introduction to these here. Though it would better serve you (if you
are interested) to look at some of the sites linked to below for more info
on these facinating subjects.

Artifical Intelligence [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.
Evolutionary Computing [EC]
     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.
Connectionism
     Connectionism is a techinical term for a group of related techniques.
     These include areas such as Artificial Neural Networks, Symantic
     Networks and a few other similar ideas. My present focus is on nerual
     networks (though I am looking for stuff using the other techniques).
     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.
Alife
     Alife takes yet another approach to the misteries of intelligence. It
     has many aspects similar to EC and connectionism, but takes these ideas
     and gives them a metalevel twist. Alife stresses the development of
     intelligence through emergent behaviour of complex adaptive systems.
     Alife stresses the social or group based aspects of intelligence. It
     seeks to understand life and survival. By studying the behaviours of
     groups of 'beings' it seeks to discover the way intelligence or higher
     order activity emerges from seemingly simple individuals. Cellular
     Automata and Conway's Game of Life are probably the most commonly known
     applications of this field.
Autonomous Agents
     Also known as intelligent software agents or just agents, this area of
     AI research deals with simple applications of small programs that aid
     the user in his/her work. They can be mobile (able to stop their
     execution on one machine and resume it on another) or static (live in
     one machine). They are usually specific to the task (and therefore
     fairly simple) and meant to help the user much as an assistant would.
     The most popular (ie. widely known) use of this type of application to
     date are the web robots that many of the indexing engines (eg.
     webcrawler) use.

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.

G�del [New]
Web page: www.cs.bris.ac.uk/~bowers/goedel.html
     G�del 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. G�del 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 G�del'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/research/mercury/
     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/oz2/
     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.

BinProlog [New]
Web site(documentation):
clement.info.umoncton.ca/BinProlog/UNCOMPRESSED/doc/html/art.html
FTP site(source): clement.info.umoncton.ca/BinProlog
FTP site(binary): clement.info.umoncton.ca/BinProlog/UNCOMPRESSED/bin
     BinProlog is a fast and compact Prolog compiler, based on the
     transformation of Prolog to binary clauses. The compilation technique
     is similar to the Continuation Passing Style transformation used in
     some ML implementations. BinProlog 5.00 is also probably the first
     Prolog system featuring dynamic recompilation of asserted predicates (a
     technique similar to the one used in some object oriented languages
     like SELF 4.0), and a very efficient segment preserving copying heap
     garbage collector.

     Although it (used to) incorporate some last minute research
     experiments, which might look adventurous at the first sight, BinProlog
     is a fairly robust and complete Prolog implementation featuring both
     C-emulated execution and generation of standalone applications by
     compilation to C.

SWI Prolog
Web page: swi.psy.uva.nl/projects/xpce/SWI-Prolog.html
FTP site: swi.psy.uva.nl/pub/SWI-Prolog/
     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.tzi.uni-bremen.de/tzi/dmn/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.

Gambit-C Scheme [New]
Web site: www.iro.umontreal.ca/~gambit/
FTP site: ftp.iro.umontreal.ca/pub/parallele/gambit
     In this variant of Gambit, the compiler generates highly portable C
     code that is reasonably efficient. The primary goals of Gambit-C are
     portability and correctness (in particular it correctly implements
     tail-recursion across modules and uses a precise garbage-collector).
     Gambit-C runs on a wide range of Unix workstations, on Macintosh, and
     DOS/Windows. It also supports these features: dynamic-loading of
     compiled files, C-interface (FFI), and a memory management system that
     expands and contracts the heap based on the program's needs.

MIT Scheme
Web site: www-swiss.ai.mit.edu/scheme-home.html
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.

MzScheme [New]
Web site: www.cs.rice.edu/CS/PLT/packages/mzscheme
FTP site: cs.rice.edu/public/mflatt/mzscheme
     MzScheme is fully R4RS-compilant (including the full numerical tower),
     and also provides:
        o Pre-emptive threads for all platforms
        o Generative structures (a.k.a. record datatypes)
        o A system for exceptions, where all primitive errors raise a
          specific exception
        o First-class compilation units for organizing program components
        o A class-based object system reminiscent of C++
        o Built-in regular expression matching tools
        o Simple TCP communication support on all platforms
        o Portable filesystem access and process control commands

RScheme [New]
Web site:www.rosette.com/~donovan/rs/rscheme.html
FTP site: ftp.rosette.com/pub/rscheme
     RScheme is an object-oriented, extended version of the Scheme dialect
     of Lisp. RScheme is freely redistributable, and offers reasonable
     performance despite being extraordinarily portable. RScheme can be
     compiled to C, and the C can then compiled with a normal C compiler to
     generate machine code. By default, however, RScheme compiles to
     bytecodes which are interpreted by a (runtime) virtual machine. This
     ensures that compilation is fast and keeps code size down. In general,
     we recommend using the (default) bytecode code generation system, and
     only compiling your time-critical code to machine code. This allows a
     nice adjustment of space/time tradeoffs. (see web site for details)

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
Web site: www-swiss.ai.mit.edu/~jar/s48.html (download from ftp site)
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).
        o 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.
        o JACAL is a symbolic math system written in Scheme, and is
          available as the file jacal1a4.tar.gz.
        o SCMCONFIG contains additional files for the SCM distribution to
          build SCM on Unix machines using GNU autoconf.
        o SLIB-PSD is a portable debugger for Scheme (requires emacs
          editor).
        o 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.
        o 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.

AI

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.
Screamer [New]
Web site: www.cis.upenn.edu/~screamer-tools/home.html
     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.

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/#ASA-CODE
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
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
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.

FUF and SURGE [New]
Web site: www.dfki.de/lt/registry/generation/fuf.html
FTP site: ftp.cs.columbia.edu/pub/fuf/
     FUF is an extended implementation of the formalism of functional
     unification grammars (FUGs) introduced by Martin Kay specialized to the
     task of natural language generation. It adds the following features to
     the base formalism:
        o Types and inheritance.
        o Extended control facilities (goal freezing, intelligent
          backtracking).
        o Modular syntax.
     These extensions allow the development of large grammars which can be
     processed efficiently and can be maintained and understood more easily.
     SURGE is a large syntactic realization grammar of English written in
     FUF. SURGE is developed to serve as a black box syntactic generation
     component in a larger generation system that encapsulates a rich
     knowledge of English syntax. SURGE can also be used as a platform for
     exploration of grammar writing with a generation perspective.

The Grammar Workbench [New]
Web site: www.cs.kun.nl/agfl/GWB.html
     The Grammar Workbench, or GWB for short, is an environment for the
     comfortable development of Affix Grammars in the AGFL-formalism. Its
     purposes are:
        o to allow the user to input, inspect and modify a grammar;
        o to perform consistency checks on the grammar;
        o to compute grammar properties;
        o to generate example sentences;
        o to assist in performing grammar transformations.

Otter: An Automated Deduction System
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.

SNePS [New]
Web site: www.cs.buffalo.edu/pub/sneps/WWW/
FTP site: ftp.cs.buffalo.edu/pub/sneps/
     The long-term goal of The SNePS Research Group is the design and
     construction of a natural-language-using computerized cognitive agent,
     and carrying out the research in artificial intelligence, computational
     linguistics, and cognitive science necessary for that endeavor. The
     three-part focus of the group is on knowledge representation,
     reasoning, and natural-language understanding and generation. The group
     is widely known for its development of the SNePS knowledge
     representation/reasoning system, and Cassie, its computerized cognitive
     agent.

Soar [New]
Web site: www.isi.edu/soar/soar.html
FTP site: cs.cmu.edu/afs/cs/project/soar/public/Soar6/
     Soar has been developed to be a general cognitive architecture. We
     intend ultimately to enable the Soar architecture to:
        o work on the full range of tasks expected of an intelligent agent,
          from highly routine to extremely difficult, open-ended problems
        o represent and use appropriate forms of knowledge, such as
          procedural, declarative, episodic, and possibly iconic
        o employ the full range of problem solving methods
        o interact with the outside world and
        o learn about all aspects of the tasks and its performance on them.
     In other words, our intention is for Soar to support all the
     capabilities required of a general intelligent agent.

Connectionism

Connectionist class/code libraries

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

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

Connectionish software kits/applications

These are various applications, software kits, etc. meant for research in
the field of connectionism. 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 (am6.tar.Z on ftp site) [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.

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): cnbc.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.

Evolutionary Computing

EC class/code libraries

These are libraries of code or classes for use in programming within the
evolutionary computation 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....

GECO [New]
FTP site: ftp://ftp.aic.nrl.navy.mil/pub/galist/src/
     GECO (Genetic Evolution through Combination of Objects), an extendible
     object-oriented toolbox for constructing genetic algorithms (in Lisp).
     It provides a set of extensible classes and methods designed for
     generality. Some simple examples are also provided to illustrate the
     intended use.

GP Kernel [New]
Web site: www.emk.e-technik.th-darmstadt.de/~thomasw/gp.html
     The GP kernel is a C++ class library that can be used to apply genetic
     programming techniques to all kinds of problems. The library defines a
     class hierarchy. An integral component is the ability to produce
     automatically defined functions as found in Koza's "Genetic Programming
     II".

     Functionality includes; Automatically defined functions (ADFs),
     tournament and fitness proportionate selection, demetic grouping,
     optional steady state genetic programming kernel, subtree crossover,
     swap and shrink mutation, a way of changing every parameter of the
     system without recompilation, capacity for multiple populations,
     loading and saving of populations and genetic programs, standard random
     number generator, internal parameter checks.

lil-gp
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.

Sugal [New]
Web site: www.trajan-software.demon.co.uk/sugal.htm
     Sugal [soo-gall] is the SUnderland Genetic ALgorithm system. The aim of
     Sugal is to support research and implementation in Genetic Algorithms
     on a common software platform. As such, Sugal supports a large number
     of variants of Genetic Algorithms, and has extensive features to
     support customisation and extension.

EC software kits/applications

These are various applications, software kits, etc. meant for research in
the field of evolutionary computing. 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.

ADATE(Automatic Design of Algorithms Through Evolution) [New]
Web site: www-ia.hiof.no/~rolando/adate_intro.html
     ADATE is a system for automatic programming i.e., inductive inference
     of algorithms, which may be the best way to develop artificial and
     general intelligence.

     The ADATE system can automatically generate non-trivial and novel
     algorithms. Algorithms are generated through large scale combinatorial
     search that employs sophisticated program transformations and
     heuristics. The ADATE system is particularly good at synthesizing
     symbolic, functional programs and has several unique qualities.

Alife

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.

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.

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.

     Swarm 1.0 is out. It requires libtclobjc and BLT 2.1 (both available at
     the swarm site).

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.

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.

The Cellular Automata Simulation System [New]
Web site: www.cs.runet.edu/~dana/ca/cellular.html
     The system consists of a compiler for the Cellang cellular automata
     programming language, along with the corresponding documentation,
     viewer, and various tools. Cellang has been undergoing refinement for
     the last several years (1991-1995), with corresponding upgrades to the
     compiler. Postscript versions of the tutorial and language reference
     manual are available for those wanting more detailed information. The
     most important distinguishing features of Cellang, include support for:
        o any number of dimensions;
        o compile time specification of each dimension's size; cell
          neighborhoods of any size (though bounded at compile time) and
          shape;
        o positional and time dependent neighborhoods;
        o associating multiple values (fields), including arrays, with each
          cell;
        o associating a potentially unbounded number of mobile agents [
          Agents are mobile entities based on a mechanism of the same name
          in the Creatures system, developed by Ian Stephenson
          (ian@ohm.york.ac.uk).] with each cell; and
        o local interactions only, since it is impossible to construct
          automata that contain any global control or references to global
          variables.

dblife & dblifelib
FTP site: ftp.cc.gatech.edu/ac121/linux/games/amusements/life/
     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: cs.ucsd.edu/pub/LEE/
     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
Web site:www.geocities.com/SiliconValley/Heights/1051**
FTP site: ftp.coe.uga.edu/users/jae/alife/
*(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.

Tierra
Web site: www.hip.atr.co.jp/~ray/tierra/tierra.html
FTP site:alife.santafe.edu/pub/SOFTWARE/Tierra/
Alternate FTP site: ftp.cc.gatech.edu/ac121/linux/science/biology/
     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.

TIN [New]
FTP site: ftp.coe.uga.edu/users/jae/alife/
     This program simulates primitive life-forms, equipped with some basic
     instincts and abilities, in a 2D environment consisting of cells. By
     mutation new generations can prove their success, and thus passing on
     "good family values".

     The brain of a TIN can be seen as a collection of processes, each
     representing drives or impulses to behave a certain way, depending on
     the state/perception of the environment ( e.g. presence of food, walls,
     neighbours, scent traces) These behaviour process currently are :
     eating, moving, mating, relaxing, tracing others, gathering food and
     killing. The process with the highest impulse value takes control, or
     in other words: the tin will act according to its most urgent need.

XLIFE
FTP site: ftp.cc.gatech.edu/ac121/linux/games/amusements/life/
     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 of various sorts. I have given them their own section sense they
didn't seem to quite make sense in any of the above.

AgentK
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]
FTP site: ftp.hawk.igs.net/pub/users/jduncan/modules/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: ftp.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.

Aglets Workbench [New]
Web site: www.trl.ibm.co.jp/aglets/
     An aglet is a Java object that can move from one host on the Internet
     to another. That is, an aglet that executes on one host can suddenly
     halt execution, dispatch to a remote host, and resume execution there.
     When the aglet moves, it takes along its program code as well as its
     state (data). A built-in security mechanism makes it safe for a
     computer to host untrusted aglets. The Java Aglet API (J-AAPI) is a
     proposed public standard for interfacing aglets and their environment.
     J-AAPI contains methods for initializing an aglet, message handling,
     and dispatching, retracting, deactivating/activating, cloning, and
     disposing of the aglet. J-AAPI is simple, flexible, and stable.
     Application developers can write platform-independent aglets and expect
     them to run on any host that supports J-AAPI.

Ara [New]
Web site: www.uni-kl.de/AG-Nehmer/Ara/
     Ara is a platform for the portable and secure execution of mobile
     agents in heterogeneous networks. Mobile agents in this sense are
     programs with the ability to change their host machine during execution
     while preserving their internal state. This enables them to handle
     interactions locally which otherwise had to be performed remotely.
     Ara's specific aim in comparison to similar platforms is to provide
     full mobile agent functionality while retaining as much as possible of
     established programming models and languages.

JATLite [New]
Web site: java.stanford.edu/java_agent/html/
     ATLite is providing a set of java packages which makes easy to build
     multi-agent systems using Java. JATLite provides only light-weight,
     small set of packages so that the developers can handle all the
     packages with little efforts. For flexibility JATLite provides four
     different layers from abstract to Router implementation. A user can
     access any layer we are providing. Each layer has a different set of
     assumptions. The user can choose an appropriate layer according to the
     assumptions on the layer and user's application. The introduction page
     contains JATLite features and the set of assumptions for each layer.

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.

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.

Penguin!

FTP site:
www.perl.org/CPAN/modules/by-category/23_Miscellaneous_Modules/Penguin/FSG/
     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.

SimRobot [New]
Web site: www.informatik.uni-bremen.de/~simrobot/
FTP site: ftp.uni-bremen.de/pub/ZKW/INFORM/simrobot/
     SimRobot is a program for simulation of sensor based robots in a 3D
     environment. It is written in C++, runs under UNIX and X11 and needs
     the graphics toolkit XView.
        o Simulation of robot kinematics
        o Hierarchically built scene definition via a simple definition
          language
        o Various sensors built in: camera, facette eye, distance
          measurement, light sensor, etc.
        o Objects defined as polyeders
        o Emitter abstractly defined; can be interpreted e.g. as light or
          sound
        o Camera images computed according to the raytracing or Z-buffer
          algorithms known from computer graphics
        o Specific sensor/motor software interface for communicating with
          the simulation
        o Texture mapping onto the object surfaces: bitmaps in various
          formats
        o Comprehensive visualization of the scene: wire frame w/o hidden
          lines, sensor and actor values
        o Interactive as well as batch driven control of the agents and
          operation in the environment
        o Collision detection
        o Extendability with user defined object types
        o Possible socket communication to e.g. the Khoros image processing
          software

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.

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.html-NEuroNet -
     ANN software
   * www.cs.cmu.edu/Web/Groups/AI/html/repository.html-CMU Artificial
     Intelligence Repository
   * ftp.io.com/pub/genetic-programming/-John Koza's Genetic Programming
     archive.

AI/Alife Research, Bibliographies, Books, etc.

   * www.mcs.net/~jorn/html/ai.html-Outsider's Guide to AI [New]
   * www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/clm/clm.html-Common
     Lisp Book
   * www.elwoodcorp.com/alu/table/contents.htm-The Association of Lisp Users
     [New]
   * 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.html-WASTE (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.cs.umbc.edu/agents/agentnews/-AgentNews Webletter
   * www.agent.org-Agent Society Home Page [New]
   * drogo.cselt.stet.it/fipa/-FIPA Foundation for Intelligent Physical
     Agents [New]
   * www.robotmag.com/-Robot Magazine [New]
   * alife.santafe.edu/~joke/encore/-ENCORE-The Hitch-Hikers Guide to
     Evolutionary Computation
   * 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.html-ALife
     Bibliography
   * complex.csu.edu.au/complex/-Complex Systems Information Network
   * www.geneticprogramming.com/-The Genetic Programming Notebook [New]
   * gracco.irmkant.rm.cnr.it/luigi/lupa_algames.html-The Artificial Life
     Games Homepage
   * www.krl.caltech.edu/~charles/alife-game/-Project: Von Neumann
   * gal4.ge.uiuc.edu/illigal.home.html-IlliGAL Home Page (GA's)
   * isl.msu.edu/GA/-MSU GARAGe Home Page (GA's)
   * www.aracnet.com/~wwir/NovaGenetica/-Nova Genetica (GA's)