(More screenshots and videos)

The Intensity Engine

The Intensity Engine is the open source project that forms the basis of Syntensity, and consists of a client, server, and master (metadata) server - everything you need to run your own games or even your own virtual world. More specifically, it includes:

3D rendering (from Cube 2)
High-level scripting API for game creation, in JavaScript (running on Google V8), which can run scripts on both client and server and transparently synchronize them
A large library of useful scripting code - weapons, movement options, items, events, etc.
Physics (from Cube 2, currently working on adding Bullet physics as an option), both clientside and serverside (customizable)
In-world editing, also in multiplayer (from Cube 2, with some additions)
A plugin system, using Python, for extending the engine with additional components (plugins exist for saving highscore data locally using SQLite, etc., and experimental plugins exist for VLC, WebKit, Skype, etc.)
An experimental browser plugin (for running the client in a web browser)

Status

The Intensity Engine is basically feature complete and stable. We have working example games of various kinds (co-op FPS, CTF FPS, racing, drawing, platformer), and we have been running Intensity Engine servers in production since October 2009, very successfully.

While feature complete for our initial goals, there is a lot more we intend to do with this project. For one thing, we are trying to work together with related open source projects, to have less duplication of effort. Also, we are right now focused on including optional support for Bullet physics, web browser integration, and we are considering doing some major work on the 3D rendering system as well. Help is welcome!

Links

Bugs, feature requests, etc.
Getting and running the code:
- Download Git, the version control system used for the Intensity Engine
- In an appropriate directory, run git clone git://github.com/kripken/intensityengine.git (or use a GUI, several exist for Git)
- See COMPILE.txt for compilation instructions
- See README.txt for general information and how to run the code (TROUBLESHOOTING.txt may also be useful)
IRC: #syntensity on FreeNode
The Syntensity blog has updates regarding Intensity Engine development

Technical Overview

Architecture overview
Written mostly in C++, with Python for high-level code and JavaScript for game logic
Cross-platform: Windows and Linux are supported for both client and server (OS X support should arrive as soon as we find a maintainer)
The following open source components are utilized:
- Cube 2 / Sauerbraten (zlib)
- Google V8 (BSD)
- SDL (LGPL)
- Python (PSFL)
- MochiKit (MIT)
- Django (BSD)
- Boost C++ Libraries (BSL)
- zlib (zlib)

Licensing

The Intensity Engine's open source license is the GNU Affero GPL 3.0 (AGPL). For details, read the license text, but in a brief and informal overview, if you use the Intensity Engine code then you need to keep your own changes to it open as well, and under the same license (even if you are just running a remote server - so long as it isn't completely private).

Some important aspects of our licensing:

We do not consider your games/activities/content to be 'derivative works' of the engine, that is, your scripts, maps, etc., do not need to be licensed under the AGPL - much like Blender, or how the Linux kernel doesn't consider userspace apps derivative works of itself. This is very different from, say, how the Quake engine forces your games to be GPL licensed. Basically, your Intensity Engine content is yours and yours alone, and you can license it however you want - for example, you can sell your games. Only the engine itself is relevant for the AGPL (note that the Python code in the engine is part of the engine; 'scripts' above refers to scripts defining games/activities, written in JavaScript, not to Python code).
When using the Intensity Engine, the only licensing relevant for you is the engine's AGPL license, whereas Syntensity's terms of use apply only if you use Syntensity. In other words, Syntensity is just one particular project using the Intensity Engine, and you are more than welcome to use the Intensity Engine for purposes entirely unrelated to Syntensity (and not under Syntensity's terms of use).
We will release particular components of ours under the Apache 2.0 license, if other projects want to reuse them (e.g., the asset system, networking code) - we do not want licensing to be a barrier to open source collaboration.
We do not require copyright assignment from contributors. Contributors have the option, instead, to submit their code under the Apache 2.0 license - we will still accept it into the Intensity Engine, and they will remain the sole copyright holders of their code. This has drawbacks for us, but we feel it's a fair compromise.
Unrestricted licenses are possible if you do not want to comply with the AGPL. Contact us for details.