Free models software for linux

Model Builder is a graphical tool for designing, simulating, and analyzing mathematical models consisting of a system of ordinary differential equations (ODEs).
Main features:
- Equation-based model definition. No need to learn to program to define and run your models. Just type-in you differential equations
- Graphic output of simulation. You can save the graphics in the most common formats: png, svg, pdf, etc.
- Spreadsheet view of the results. From the spreadsheet you can make customized plots from your variables. You can also export your data to a .csv text file
- Latex rendering of your system of equations.
- Intuitive graphical interface.
- Uncertainty analysis module (coming soon!)

Config::Model provides a framework to help in validating the semantic content of configuration data. The project can also be used to provide a semantic check of options of a complex program like mplayer or transcode.
For most complex software, configuration upgrade is a difficult task for most people. By using Config::Model, a software can provide a smooth upgrade path for their users.
How does this work ?
Using this project, a typical configuration validation tool will be made of 3 parts :
The user interface
The validation engine which is in charge of validating all the configuration information provided by the user.
The storage facility that store the configuration information
Dont we already have some configuration validation tools ?
Youre probably thinking of tools like webmin. Yes, these tools exist and work fine, but they have their set of drawbacks.
Usually, the validation of configuration data is done with a script which performs semantic validation and often ends up being quite complex (e.g. 2500 lines for Debians xserver-xorg.config script which handles xorg.conf file).
In most cases, the configuration model is expressed in instructions (whatever programming language is used) and interspersed with a lot of processing to handle the actual configuration data.
Whats the advantage of this project ?
The Config::Model projects provide a way to get a validation engine where the configuration model is completely separated from the actual processing instruction.
The configuration model is expressed in a declarative form (i.e. a Perl data structure) which is always easier to maintain than a lot of code.
The declaration specifies:
the structure of the configuration data (which can be queried by generic user interfaces)
the properties of each element (boundaries, check, integer or string, enum like type ...)
the default values of parameters (if any)
mandatory parameters
the targeted audience (intermediate, advance, master)
on-line help (for ach parameter or value of parameter)
the level of expertise of each parameter (to hide expert parameters from newbie eyes)
So, in the end:
maintenance and evolution of the configuration content is easier
user will see a *common* interface for *all* programs using this project.
user will not see advanced parameters
upgrade of configuration data is easier and sanity check is performed
audit of configuration is possible to check what was modified by the user compated to default values
What about the user interface ?
Config::Model will also come with a Curses::UI interface that queries the users model and generate the relevant user screens.
What about data storage ?
Since the syntax of configuration files vary wildly form one program to another, most people who want to use this framework will have to provide a dedicated parser/writer.
Nevertheless, this project can also provide a writer/parser for most common format: like ini style file, or provide an interface to the Elektra or debconf projects. This point is open for discussion.
It is entirely possible for a single configuration model to use several parsers and writers so one model will ensure the consistency of several configuration files together.
Enhancements:
- The Xorg model was updated to Config::model version 0.609.
- Some bugs were fixed.

Molle is a cross-platform prover for modal logic. It exploits the modal semantic tableaux method.

Molle project features a very usable graphical interface, with an interactive representation of generated models.

DodeboLMS (previously "Spaghettilearning") is an e-learning platform for distance learning. DoceboLMS project supports SCORM 1.2, the e-learning international standard.
You can manage different learning models, from collaborative learning to self learning.
Enhancements:
- This version fix several bugs.
- Now the 3.0.x family is really stable and works with PHP 4, PHP 5, and MySQL 3.2.x, 4, and 5.

DEMOS is a modeling tool for the EP model. The EP model proposes a declarative executable model for engineering object-based systems which achieves executability through a hybrid approach that annotates model elements with Java code snippets.
DEMOS project is implemented as an Eclipse plugin and provides graphical editing of applications using the EP model, background code generation, and immediate feedback on syntactical validity of models and user-supplied code.
Enhancements:
- Changes in this release are the addition of a visual inspector for running EP systems, significant performance improvements, improved consistency between models and generated code, and minor feature enhancements and bugfixes.

Installation: The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system.
2. Running `configure might take a while. While running, it prints some messages telling which features it is checking for.
3. Type `make to compile the package.
4. Optionally, type `make check to run any self-tests that come with the package.
5. Type `make install to install the programs and any data files and
6. documentation.
7. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make disclean. There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.

XML Tree Object Model Parser is an easy to use XML parser designed to provide an easy and simple to use library for parsing XML configuration files. It is split into two components.

The first one is the Parser itself, which uses J2SE 1.4 XML Parsing API, and the second one is what I call XML Tree Object Model, which is a XMLTree containing all of the XML Nodes or Elements in that tree.

The basic idea behind XTOM is to parse the XML file into an XMLTree and then navigate the elements of that tree by refering to them by the path, such as one/two/three.

The idead behind the navigation system came from Jakartas Digester. XTOM just simplifies it to increase the developement of XML based applications.

powerPlant is a geometry generator and editor. powerPlant is specially suitable to generate terrain and plant models. The geometry generation is based on custom implementations of L-Systems, Turtle-Interpretation and the Diamond-and-Square algorithm.

powerPlant is composed of a Java application supplying the application logic and external Haskell programs for geometry generation.

The application is intended to create complex, realistic models by supplying a minimum ammount of parameters instead of explicit modelling. Created models can be combined recursively to make up complete scenes. This scene creation is presented in a WYSIWYG tree view. The integrated terrain tool can also be used to generate various coloured, tileable textures.

Every work result (models, scenes) can be loaded and saved in a xml file. User interaction takes place in a convenient Java Swing GUI that brings together all the aspects of the application.

The chosen approach should significantly shorten the process of creating adequate 3D-models and entire virtual landscapes with realtime visualization. Visualization is based on OpenGL/GLU API and includes adjustable speed optimizations.