Free simulation software for linux

The Noble Ape Simulation has been developed (as the Nervana Simulation) since 1996 and is a biological simulation software. The aim of the simulation is to create a detailed biological environment and a cognitive simulation.
The Simulation is intended as a palette for open source cross-platform development. It provides a stable means of simulating large-scale environments and cognitive processes on Windows, Mac and Linux.
The Simulation includes a detailed scripting language for user-implemented movement and cognitive-process development.
Enhancements:
- This release fixes a bug in displaying only the seen Noble Apes, and has code simplification towards OpenGL implementation.

Mars Simulation Project is a free software Java project to create a simulation of future human settlement of Mars.
The simulation is a multi-agent artificial society set in a detailed virtual world.
XML configuration files allow the user to modify the simulation properties.
The Mars Simulation Projects main window contains the following components:
- Menu Bar
- Search Tool
- Time Tool
- Mars Navigator
- Monitor Tool
- Rover Info Window
- Settlement Info Window
- Person Info Window
- Unit Bar
The Mars Simulation Project can be configured with a number of XML configuration files located in the "conf/" directory. It is recommended that you save a backup copy of a configuration file before modifying it in case there is an error and the simulation cannot read the modified configuration file.
Here are the configuration files you can modify for the simulation. You will need to start a new simulation for any changes to be loaded in.
- buildings.xml
- crops.xml
- landmarks.xml
- malfunctions.xml
- medical.xml
- people.xml
- settlements.xml
- simulation.xml
- vehicles.xml
Enhancements:
- This release includes the new mission tool for viewing, creating, and editing missions as well as plenty of bugfixes.

Multi-Simulator Interface, in shrot MSI, is a simulation interconnection engine. In other words it is a program that connects simulations together by synchronizing their clocks and data. Multi-Simulation Interface serves the same purpose as HLA and supports most of HLAs functionality (and more).
The MSI is an HLA alternative. The major motivating factors in the design of the MSI are speed, interoperability, and ease of use.
The MSI was written as a cutting edge distributed simulation component to connect multiple instances of ATLs premiere simulation software, CSIM, and it can be used to interface any compatible simulations.
How does the MSI compare to HLA?
The MSI was originally created to be just a light weight HLA RTI. However, as it was written, limitations in HLA were discovered. The MSI is an improvement on both the design and implementation of HLA. Some highlights include:
A 1,536 to 1 reduction in size over the publicly available (until late 2002) HLA RTI.
At least one order of magnitude of bandwidth consumption less than the publicly available (until late 2002) HLA RTI.
The ability to subscribe to an object name in addition to a type.
Time synchronization that allows for proper causality when used with discrete event simulators.
Support for systems-of-systems (SoS) and hierarchically organized simulations.
Availability for many platforms.
MSI Concept - A Synchronized Data Broker
The concept behind MSI is the synchronized data broker. There are many connected software systems that posses state data that changes over the life of that system. In the case where these systems need to exchange this changing data with other systems and the other systems will exhibit the effects of this data on their own state, the synchronization of this data may need to be managed.
Historically the management of this data has been as simple as tagging it with the time of its release. If there is any conflict in the data the most recent version of the data is used. If the data is late an extrapolation can potentially be used. In SQL relational databases transactions and locking are used to ensure data integrity. Most data brokering services offer little or no sychronization, only delivery.
MSI Setup and Use
The MSI uses a XML stream through a direct socket connection for communications. This enables the MSI to be used from any programming language that can use sockets (C, C++, Java, Ada, Lisp, Perl, etc.). Also, the MSI was written with cross-platform libraries that make it portable to all the major OS platforms (Linux, Solaris, Mac OS X, Microsoft Windows, IRIX, HPUX, etc.).
The MSI is a single executable file and is distributed with example code for the simulator/federate side interface.
MSI Time Synchronization
The MSI time synchronizer can mix unconstrained with time constrained simulations. Each constrained simulation reports the time of the next event that will occur in that simulation/federate. This time may be artificially inflated to cause loose synchronization (less overhead but less guarantee of accuracy). The simulations/federates will advance to the announced time.
MSI Data Synchronization
The MSI implements a publish/subscribe data broker. The MSI is presently not validating, therefore it does not require a separate data format specification (like the HLA FOM). When data format validation is implemented, it will be an optional feature and not written in Lisp. This greatly reduces MSIs setup time. Also, not being locked to a predetermined data format allows for dynamic data types.
There are five commands associated with the MSI data broker: publish, subscribe, update, unsubscribe, destroy (destroy is not implemented yet). Simulations/federates may subscribe to object names in addition to object types. This allows simulations to subscribe to specific objects of a type without needing to receive updates of all objects of that type. The update command is both an incoming and outgoing command. When a simulation/federate receives an update command, it is expected to reflect the new values of that object.
The MSI has a very flexible publish and subscribe system. A federate may subscribe to an object type or an object name. In addition a federate may specify particular attributes of an object or object type. For example, if an object has attributes name, x, y, and z, a federate that only considers two dimensions may choose to subscribe only to name, x, and y.
The MSI also supports systems of systems and object hierarchy in simulations. A publishing federate may designate a parent object. Subscribers may then subscribe to the objects children.
MSI Messaging
The MSI allows simulations/federates to send messages (interactions in HLA) to each other. These messages can contain multiple attributes and be multicast to a specific group of simulations.
Recently Added Features
Removed external library dependencies to improve the portability and fragility of the MSI.
Added a better client library.
Improved documentation.
Enhancements:
- An XML parsing bug in the utilities library was fixed.
- The socket library was enhanced with more protocols, Win32 tricks, and the ability to key off of addresses as well as names.
- The --wait-for command line argument was added.
- Several internal bugs were fixed.
- More of the client library and the CSIM interface were flushed out.
- All standard functionality was tested.

GENESIS (short for GEneral NEural SImulation System) is a general purpose simulation platform that was developed to support the simulation of neural systems ranging from subcellular components and biochemical reactions to complex models of single neurons, simulations of large networks, and systems-level models.

GENESIS has provided the basis for laboratory courses in neural simulation at Caltech, the Marine Biological Laboratory, the Crete, Trieste, Bangalore, and Obidos short courses in Computational Neuroscience, and at least 49 universities of which we are aware.

Most current GENESIS applications involve realistic simulations of biological neural systems. Although the software can also model more abstract networks, other simulators are more suitable for backpropagation and similar connectionist modeling.

Installation

1. Pick the place where you want to install the "genesis" directory tree. If you are making a system-wide installation as "root" user, /usr/local is a good choice. For a personal installation, without root privileges, you can use your home directory ("~"). Change to this directory and extract the genesis directory from the archive file genesis2.2.1-linux-bin.tar.gz. For example,

cd /usr/local
tar xvzf /mnt/cdrom/genesis2.2.1-linux-bin.tar.gz

or from wherever you have it (e.g.~/downloads/genesis2.2.1-linux-bin.tar.gz).

2. Change to the "genesis" directory and run the setup script that creates the ".simrc" GENESIS initialization file". Then copy .simrc to your home directory.

cd genesis
./binsetup
cp .simrc ~

3. Finallly, add the genesis directory to your search path, so that "genesis" can be found from any directory that you are in. If your login shell is bash, you can do this by editing the .bashrc file in your home directory to add the line

PATH=$PATH:/usr/local/genesis

at the end of the file. If you are using tcsh or csh as your command shell, add

set path=($path /usr/local/genesis)

to your .tcsh or .csh file.

At this point, you are ready to try running GENESIS. Change into the directory genesis/Scripts and try some of the tutorials suggested in the README file.

Cell Electrophysiology Simulation Environment (CESE) is a comprehensive framework specifically designed to perform computational electrophysiological simulations, for example, simulations of cardiac myocyte electrical activity.
Cell Electrophysiology Simulation Environment is useful for simulations of action potentials, individual ionic currents, and changes in ionic concentrations.
CESE is a cross-platform program, it runs on any system that has Java runtime environment (JRE) version 1.4 or above. It was tested on Windows, Linux, Solaris, MacOS X, and AIX.
CESE users
CESE is an integrated environment for performing computational simulations using a variety of electrophysiological models.
At this stage CESE allows creation and execution of the single-cell models (containing both Hodgkin-Huxley (HH) and Markovian current formulations). Models of electrical activity of cardiac myocytes with source code are included in the CESE distribution. We hope to extend the number of available models, and add certain neuronal models in the future.
The main strength of CESE is in its uniformity ? a program interface remains the same for different types of models. You can easily switch between models and compare simulation outputs. Model parameters can be modified, selected for output and/or clamped in the same, standard way.
CESE extends the conventional electrophysiological meaning of the "voltage clamp". You can clamp virtually any model variable, including voltage (membrane potential), total or individual ionic currents, ionic concentrations, temperature, gating variables, etc. The clamping commands can be complex piece-wise functions, individually set for the model variable of interest. This opens endless possibilities for the exploration of complex model behavior.
CESE provides simple, but efficient data visualizations. Simulation results can be presented in the graphic and tabulated forms. Plots can be customized, and regions of interest zoomed.
Even though CESE was not designed to be a data analysis tool, you can generate current-voltage relationships (I-Vs) and calculate statistical parameters for a given signal within the program. You can export your data to ASCII, Axon Text File (ATF), and NetCDF formats to continue analysis in your favorite package.
CESE developers
CESE was created from the ground up to incorporate the best programming practices available to Java developers, both in terms of user interface consistency and code clarity and reuse. Wherever possible, CESE rely on available Java APIs (for example Java2D, JavaBeans, JAXP) to simplify the code.
Model creation requires a number of house-keeping functions to be coded ? these include ODE integrators, routines for handling model parameters, saving/restoring model state, visualizing simulation results, etc. CESE provides you with implementation for these routines, hence, you can concentrate on writing the code for concrete ionic current(s), and CESE will handle the rest.
CESE is not trying to create complicated programming frameworks on its own ? rather, it utilizes core Java APIs. For example, models are Java components conforming to the JavaBeans specification. We use XML to specify clamping commands, and Java object serialization to save/restore model parameters.
Enhancements:
- This release improves results printing, adds export to the scalable vector graphics (SVG) format, improves support for continuous simulations, and fixes many bugs in plot rendering and model switching.

Fungus Agent Simulator project consists of a distributed multi-agent-based simulator.
Fungus Agent Simulator is a distributed multi-agent-based simulator that lets users easily create artificial life simulations. It uses a modular and a extensible architecture. A tiny scripting language (named Mycelium) is provided.
With Mycelium, users can easily build a simulation. Users can access the information traveling between the agents. Multiple scheduling models and multiple view are provided.
Main features:
- Agent
- Agent Based Simulation
- Agent could be a object or a threaded object
- Hierarchical agent
- Communication
- Messages passing communication model
- Discrete Event
- Communications canals are accessible
- Kernel
- Manage Scheduling Techniques
- distributed simulation
- Graphical user interface
- Simulator is written in Java

Transit Executive project is a real-time strategy simulation game of building transit systems, make profits, and attempt to take over your competition.