Delta Engine: The Open-Source C# Multiplatform Engine Behind SoulCraft, and Its Status in 2026

Delta Engine is an open-source game engine written in C#, created by developer Benjamin Nitschke and his Hannover-based team. Its promise was to let developers build a game once in .NET with Visual Studio, then deploy it to Windows, mobile phones and other platforms. It powered the mobile action RPG SoulCraft, and in 2014 its source code was released on GitHub under the Apache 2.0 licence. The company behind it, Delta Engine GmbH, still exists, but it has moved into AI and robotics, and the public engine hasn’t been developed since 2014.

This profile covers where Delta Engine came from, how its entity system works, the games made with it, how it differs from the similarly named Delta3D, and what’s left of it in 2026. It includes an entity example we compiled and ran against the engine’s own source. Facts were checked against the Delta Engine website, its GitHub repositories and contemporary coverage in November 2026.

What Is Delta Engine?

Delta Engine is an open-source multiplatform game engine written in C# (.NET) by Benjamin Nitschke and Delta Engine GmbH of Hannover, Germany. It targeted Windows, iOS, Android and Windows Phone from Visual Studio, with an entity-and-behaviour design and its own editor. Its last public release, v1.1 (March 2014), is on GitHub under the Apache 2.0 licence and is no longer actively developed.

A Short History of Delta Engine

Benjamin Nitschke had been writing .NET games since the early 2000s, almost a decade before Delta Engine. His studio’s real-time strategy game Arena Wars (2004) is described on the Delta Engine website as the first commercial .NET game, and his later projects Rocket Commander (2005) and an XNA racing game (2006) accompanied books on Managed DirectX and XNA game programming.

Delta Engine itself appeared at MobileBits, a German mobile studio where Nitschke was CTO. In August 2011, PocketGamer.biz reported that MobileBits was beta-testing Delta Engine, a C# and .NET engine for Windows Phone, iOS and Android, and offering its source code to developers. Nitschke said Unity was good for prototyping, but that Delta Engine gave more flexibility and control to developers who preferred working in code (PocketGamer.biz on Delta Engine).

In August 2012, Nitschke founded Delta Engine GmbH in Hannover to develop the engine (Delta Engine’s About page). The public releases followed in milestones:

How Delta Engine Works

Delta Engine was designed for C# developers who wanted to stay in Visual Studio. Its readme describes it as free to use on Windows, open source and written in C#, needing only the .NET Framework 4 Client Profile, with dependencies installed through NuGet (Delta Engine on GitHub). Its main ideas were:

• Entities with components and behaviours. Almost everything in the engine is an entity. An entity holds components (plain data, such as a position or a colour) and starts behaviours (logic). An UpdateBehavior runs once per update tick for every entity that uses it, which keeps game logic in small, reusable pieces.
• A fixed update rate. Game logic runs at a fixed time step, 20 updates per second by default, while drawing runs as fast as possible.
• Interchangeable frameworks. The same game code could run on GLFW, OpenTK, SharpDX, SlimDX, XNA or MonoGame underneath, which is how one codebase reached different platforms.
• An editor and AppBuilder. The editor includes particle, material, level and UI editors, a sample browser and a project creator. Its AppBuilder builds and deploys an app to a chosen device with one button, and a Continuous Updater shows code changes in the running game.
• Test-driven development. The codebase was written test-first, following Clean Code principles, and the website still publishes its C# coding guidelines.

The test-first style shows in the numbers. Of the 178,324 lines of C# in the 2014 release, more than 52,000 are unit tests:

Hello, Delta Engine: An Entity and a Behaviour

This program creates a Planet entity with a Rotation component and starts a Spin behaviour on it. Spin turns every entity that uses it by 90 degrees per second. It runs without a window, using the engine’s own MockEntitiesRunner, the class its unit tests use:

// SpinTest.cs - a Delta Engine entity with a component and an update behavior,
// run headless with the engine's own MockEntitiesRunner
using System;
using System.Collections.Generic;
using DeltaEngine.Entities;
using DeltaEngine.Mocks;

// Components are plain data attached to an entity
public struct Rotation
{
	public Rotation(float degrees)
	{
		Degrees = degrees;
	}

	public float Degrees;
}

// Entities hold components and start behaviors
public class Planet : Entity
{
	public Planet()
	{
		Add(new Rotation(0));
		Start<Spin>();
	}
}

// One UpdateBehavior instance updates every entity that started it
public class Spin : UpdateBehavior
{
	public override void Update(IEnumerable<Entity> entities)
	{
		foreach (var entity in entities)
		{
			var rotation = entity.Get<Rotation>();
			entity.Set(new Rotation(rotation.Degrees + 90 * Time.Delta));
		}
	}
}

public static class Program
{
	public static void Main()
	{
		var runner = new MockEntitiesRunner(typeof(Spin));
		var planet = new Planet();
		for (int tick = 0; tick < 20; tick++)
			runner.RunEntities();
		Console.WriteLine("Update step: " + Time.Delta + " s");
		Console.WriteLine("After 20 updates: " + planet.Get<Rotation>().Degrees + " degrees");
		planet.Stop<Spin>();
		for (int tick = 0; tick < 20; tick++)
			runner.RunEntities();
		Console.WriteLine("After Stop<Spin>() and 20 more: " + planet.Get<Rotation>().Degrees + " degrees");
	}
}

The program printed:

Update step: 0.05 s
After 20 updates: 90 degrees
After Stop<Spin>() and 20 more: 90 degrees

Twenty updates at the default 0.05-second step make one second, so the planet turned exactly 90 degrees. After Stop<Spin>(), the behaviour no longer touched it.

Tested: we compiled the engine’s core library from the 2014 GitHub release with the .NET 8 SDK on Ubuntu 24.04. 106 of its 107 source files compiled unchanged. The exception is an editor helper that uses .NET Framework-only features, and we also added one alias to resolve a name clash with newer .NET. The engine’s own mock classes compiled as they are, and the program printed the output above. We didn’t test graphics, input or the editor, which need Windows and the 2014-era frameworks.

Games Made with Delta Engine

The 2014 release also includes sample games such as Asteroids, Breakout, Snake, a side-scroller and Creepy Towers, a tower-defence prototype.

Delta Engine vs Delta3D: Not the Same Engine

Delta Engine and Delta3D are different engines with similar names. Delta3D is an open-source C++ simulation engine, licensed under the LGPL and developed at the US Naval Postgraduate School for training and defence simulation. It has features such as HLA networking, large-scale terrain and a Physics Abstraction Layer. Delta Engine is a C# game engine from Germany, licensed under Apache 2.0 and aimed at mobile and PC games. If you’ve read that “Delta Engine” supports HLA or is LGPL-licensed, that description belongs to Delta3D.

Delta Engine in 2026

• The public engine is frozen. The GitHub repositories have had no changes since October 2015, and the 2014 release targets Visual Studio 2012/2013 and .NET Framework 4.
• The company has moved on. Delta Engine GmbH says it shifted to contract work, teaching, and then AI and robotics research from 2019. It now builds robot arms and a programming language called Strict, and its blog was still posting about Strict in October 2026.
• The website keeps the old material. It still hosts the engine documentation and tutorials, labelled as “more or less from 2012/2013” and not actively maintained. It also says the team “will return to engine and programming language development in the future”.

For a new C# game in 2026, Delta Engine isn’t a practical choice. Its code is still a clear, well-tested example of an entity-based engine design.

Delta Engine Alternatives

• MonoGame: the open-source continuation of Microsoft’s XNA, one of the frameworks Delta Engine itself could run on, still maintained (MonoGame).
• Godot: a free, open-source engine with full C# support through .NET. See our Godot engine profile.
• Unity: the leading commercial engine scripted in C#. See our Unity engine profile.

For more open-source engines, see our directory of open-source C++ game engines.

Key Takeaways

• Delta Engine is an open-source game engine written in C#, not C++, created by Benjamin Nitschke.
• It began at MobileBits in 2011, and Delta Engine GmbH was founded in Hannover in August 2012.
• Its last public release, v1.1, came in March 2014 under the Apache 2.0 licence, and it hasn’t been actively developed since.
• Its design centres on entities, components and update behaviours, with interchangeable frameworks such as OpenTK, SharpDX and MonoGame.
• Its best-known game is SoulCraft, a mobile action RPG from 2012.
• It isn’t Delta3D, the LGPL C++ simulation engine it’s sometimes confused with.

Conclusion

Delta Engine was an early, ambitious bet on C# for multiplatform mobile games, years before that became mainstream. It shipped SoulCraft, opened its source and showed a disciplined, test-driven way of building an engine. Its team has since moved on to robotics and language design, so the engine survives as a 2014 snapshot. That snapshot still compiles on modern .NET and is still worth reading for its design.

For more engines across every genre, browse our game development hub.