Introducing Simulant

Merry Christmas! The festive season seems like a good time for an announcement, so here we go!

I'm pleased to announce the Alpha release of the Simulant Game Engine - a new open-source project to bring modern game development flows to older platforms.

Simulant is a portable general-purpose game engine, written in C++. It's aim is to allow writing games for older 3D consoles like the SEGA Dreamcast, as well as modern platforms such as Windows, Linux and Android.

Simulant is built to let you get a game up and running fast! The API is designed to be easy-to-use and to read so that even novice C++ developers can build games and experiment. The simulant command line tool lets you set up a scaffold project, and build, package and test for multiple platforms with a few simple commands.

Simulant requires using Linux as a development OS, but uses cross-compilers and Docker to build your game for other platforms.

The development of Simulant as led to the development of GLdc, a brand new OpenGL implementation for the SEGA Dreamcast, and the fledgling ALdc which hopes to bring OpenAL compatibility to the same platform.

Simulant comes with a bunch of features:

  • Multiple renderers (OpenGL 1.1 and OpenGL 2.1)
  • High-level Scene management
  • Powerful material system, supporting GLSL on GL 2.x
  • Hierarchical scene building
  • Scriptable particle system (custom JSON format)
  • Support for loading .obj and .md2 meshes, as well as Tiled .tmx files
  • Complex configurable rendering pipeline
  • Easy-to-use API
  • Automatic memory management of game assets
  • Automatic level-of-detail mesh selection
  • Combination Spatial hash and Octree based culling systems
  • Built-in realistic Newtonian physics engine
  • Entity behaviour component system
  • UI widget rendering system
  • Built-in helpers for scrollable backgrounds, skyboxes and animated sprites
  • OpenAL powered audio
  • There's probably more I've forgotten...

And if that isn't enough, the whole thing is controllable from a simple command-line management command, which allows you to bootstrap projects, build them for multiple platforms, run unit tests, and package your game for Linux (flatpak) and Dreamcast (.CDI). Windows installer support is coming soon!

You don't even have to compile the game engine yourself, just install the management command and it will download pre-compiled game engine libraries which are generated automatically via a complex build system!

Simulant is built to support multiple OpenGL renderers. Currently there are OpenGL 1.1 and OpenGL 2.1 renderers and a GLES 2 renderer will happen soon. As for platforms:

  • Linux: Packaging needs work. Working Flatpak packages are built with the "package" command though.
  • Windows: Executables are buildable using the built-in cross-compiling, there is no installer generation (packaging) yet, although when it lands it will use NSIS. If you want to compile manually + natively on Windows, then building on VC++ should work, it may require some minor patches.
  • Android: An Android build has worked in the past, a long time ago, but it bitrotted away. It's about 80% restored, but doesn't work yet
  • OSX: TravisCI is building for OSX on the GitHub mirror, although it's not being used for anything except checking that nothing broke. You'll have to build OSX projects manually on OSX itself for now.
  • Dreamcast: Builds and generates a bootable .cdi image. Romdisk support is high priority, as is VMU file loading/saving.

Getting Started

Providing you have a Linux installation available (preferably Fedora 28 or 29), getting up and running should be easy. Head on over to the tutorial!


Simulant is currently at Alpha stage. This means the codebase is unstable, and the API is subject to change. If you're using Simulant to build a game, make sure you update frequently, and file bugs and submit patches to help improve things.

Keep an eye on the Simulant Discord chat, and issue tracker.

Get Involved!

Simulant has so far been pretty much a one-man project, for it to reach its potential it needs other contributors. If you want to help out, hit the Discord group and come join the community! Here are some useful links for getting started!

And if you don't have the time to contribute, but want to support my work then my patreon is here


Simulant is very much under development, so pay attention to the following caveats:

  • Nothing is stable. APIs will change!
  • The Dreamcast support is currently missing audio, this is work in progress
  • The Dreamcast port is missing built-in support for VMU storage, rom disks and CD audio. You can use native KallistiOS SDK for some of this functionality
  • Work is ongoing to support texconv's texture format for Dreamcast native textures
  • Baseline memory usage is still higher than I'd like
  • The material system is due to change soon to be switched for a more readable JSON based system.
  • The current default OpenGL 2.x shader has a bug which overbrightens some models
  • Thread-safety is a bit hit and miss
  • Some of the APIs are a first-pass and have bugs or inconsistencies
  • On the GL 2.x renderer, render batching (performance) needs improving


Simulant is released under the LGPL (with patches accepted under dual LGPL+MIT licensing), there are a number of reasons for this, but it does mean that:

  • If you make and distribute changes to Simulant, you must make those changes available under the LGPL.
  • If your game statically links to Simulant, you must release your app's source code under an LGPL compatible license, or buy a commercial license for Simulant.

For more information, take a look at the licensing page