Free scum of the universe software for linux

Universe project is a Open Source Master Of Orion-like game.

Universe is an Open-Source game which resembles Master Of Orion. It is written in Java.

The goal is to have as few arbitrary limits as possible, allowing games as large as you wish. It also supports a concept called "Schemes" which allows programmers to develop distinct rule sets and extensions.

Universe Crimson is a red theme with some hubble images as the wallpaper, but i like it.

This theme is great, works with every thing, w00t a dark theme that works!

Thousand Parsec is a 4 Xs game (eXplore, eXpand, eXterminate, eXploit) but it is different in the sense that it is designed for long games supporting universes as large as your computer can handle. (Have a quad Xeon with 4 gig of ram? Well have a couple of million systems in your universe!.

Thousand Parsec also supports long term play with players joining and leaving throughout the game. As well the tech tree is easily expandable and can be extended during the game without effecting anybody already playing (ie introduction of new technology as the game progresses).

You can choose to have highly exotic universes where the laws of physics are totally different or universes that are very similar to our own.

The game is TURN BASED, this means that clicking quickly isnt vital but strategy is.

The game should also be highly extend-able. Allowing player customisation not found in the commercial games.

Anyway we have high hopes for what TP will become. We have currently stolen a lot of ideas from Stars!, VGA Planets an XPace.

Way of The Warrior: Sons of Twilight is a Web-based boardgame of fantasy battle. Like a boardgame, it is turn based and at least 2 players are neeed, but there is no upper limit on the number of players.
Way Of The Warrior: Sons of twilight is fully and easily customizable, from the unit to the board tile.
Enhancements:
- board visualization is now good
- sincronization algoritm for the save process

Xholon runtime framework executes applications that are event-driven or that have highly dynamic structure or behavior. Specify your models using XML and Java, or using third-party UML2 tools and MDA transformations.
To get started, read or actively work through the basic HelloWorld tutorial. Its a very simple application, but it demonstrates many of the main concepts.
For more detail on the concepts behind Xholon, you might want to read one of the papers thats been published. These describe how to model cells and other complex biological entities using tools designed for developing real-time and embedded systems.
This earlier work used Rational Rose RealTime and C++, rather than the current Java. Xholon is intended to be a runtime framework that can execute the same types of systems described in those papers, plus many more traditional non-biological event-driven systems.
The goal of the Cellontro sister project is to develop complex biological simulations using the Xholon framework. Most of the features described in the published papers have been re-implemented as Cellontro applications using Xholon.
Also have a look at the sample applications that are included with the Xholon software. These give an idea of the range of applications that can be supported by the Xholon runtime framework.
These have been employed as use cases to determine what functionality is most important in Xholon. The digital watch simulation is a good example of a Xholon application with a hierarchical state machine, developed using a UML modeling tool.
A Xholon is essentially a holon. A holon is an entity that lives within a hierarchical structure, and is both a whole and a part at the same time.
In mainstream computer science terms, a Xholon is a node in a tree. The node has a single parent, possibly one or more children, and possibly one or more siblings. A Xholon may also be an active agent able to interact in real-time with other Xholons in the tree.
In UML2 terminology, a Xholon is a structured classifier that may exist as a part within other structured classifiers, and that may in turn contain other structured classifiers as parts of itself. The result is a hierarchical containment structure, nested to an arbitrary number of levels.
As a part, a Xholon plays a specific role within another structured classifier. Xholons are UML classes that are subsequently refined using UML2 composite structure diagrams. Structured classifiers interact with each other through ports, by passing messages or by making function calls.
Using the more philosophical terminology used to describe holons, a Xholon is something that is simultaneously both a whole and a part. Since everything in the universe is a holon, then everything running within a computer application should be a Xholon. The term holon was invented by Arthur Koestler in 1967.
The Xholon Project is inspired by biological concepts. A major incentive behind the project is to build a run-time environment that is equally adapted to running simulations of biological systems, and to running more traditional real-time, embedded and other event-driven reactive systems.
Xholon applications may contain structures that are highly mutable. A Xholon is an active agent that can modify the tree structure in which it lives. It can navigate the tree to interact with any other node, it can add, delete or modify other nodes, it can exchange messages with other nodes, and it can move itself to another position within the tree.
The Xholon Project incorporates many concepts of the Real-time Object-Oriented Modeling (ROOM) methodology, much of which has been incorporated into UML2. At the same time, Xholon removes some of the limitations of ROOM to allow for greater flexibility, mutability and mobility of active objects.
The Xholon run-time can serve as a target for a Model Driven Architecture (MDA) transformation pipeline. MDA stresses the importance of models, and the ability to transform those models, through a series of steps, into an executing target system.
You can create your model using a UML tool such as Gentlewares Poseidon or NoMagics MagicDraw, save the model as an XMI file, transform it using XSLT (or by some other MDA means) into a Xholon model and application, and then execute the model.
Enhancements:
- UML state machine simulation capabilities have been extended, including animation, and fork, join, junction.
- Additional Agent-Based Modeling functionality is available.
- The NetLogo-like syntax has been enhanced.
- The architecture is more flexible and is ready to more fully support integration of multiple domains.
- Histograms and probability distributions are now available. Line charts update in real-time.
- Numerous other modeling, simulation, transformation, and execution features have been added.

IGE - Outer Space is an on-line strategy game with SciFi theme.

IGE - Outer Space is an on-line strategy game which takes place in the dangerous universe. You must become the commander of many stars, planets, and great fleets and you will struggle for survival with other commanders.

Outer Space communicates with the server in the same way as your browser, but you will need a special client to play it. Using this client you can create an account on the server and you can start to explore the world of the Outer Space.

The JEROME Project or the Java-based Engine for Real-time Online Multiuser Environments, is designed as a heterogeneous parallel virtual machine, or grid, specifically for real-time applications.
Main features:
- Cross-platform - To allow for a completely heterogenous node network
- Standard - To use industry-standard technologies to connect and administer the nodes
- Simplicity - To maintain the simplicity of the codebase
- Independence - To be as implementation-independent as possible
- Fault-tolerance - To handle faults and load in realtime, without failure
- Reliability - To minimize or eliminate downtime for configuration or implementation changes
- Scalability - To be scalable, and meet the needs of all applications
- Speed - To be as transparent to message processing and communication latency as possible.
The JEROME architecture is a framework for creating realtime applications that benefit from a dynamic grid model. Each node is given one of four major tasks. These tasks are the four main aspects of the realtime processing enviroment: the interface or gateway, the event processor or context, the database, and the background or ambient processor.
Any number of these nodes are dynamically connected to eachother to form a realtime processing unit that dynamically distributes the processing load over nodes of the same type, and communicates via standard networks.