Shmellyorc/Void

A modular, extensible 2D game framework for .NET.

VOID Engine is a lightweight, modular 2D game framework for .NET.

It provides the systems most games need without trying to become a giant all-in-one engine.

VOID is built around a simple idea:

Give developers solid defaults without assuming those defaults are right for every game.

Use the built-in systems as they are, extend them, replace them, or ignore the ones you do not need.

VOID deliberately stays focused on framework-level systems. Features such as full physics and UI frameworks are left to your game or the libraries you choose.

Package	Version	NuGet
Void.Engine	2.2.1
Void.Packer	1.0.1
Void.Packer.CLI	1.0.1
Void.Templates	1.0.1

Install the project template:

dotnet new install Void.Templates

Create and run a game:

dotnet new voidgame -n MyGame
cd MyGame
dotnet run

Or install the engine directly:

dotnet add package Void.Engine

Large engines often try to solve every possible problem.

That can be useful, but it can also leave developers working around systems that do not fit their game.

At the other extreme, very low-level frameworks provide freedom but leave you rebuilding common infrastructure yourself.

VOID sits in the middle.

It provides useful defaults while exposing the places where different games may reasonably need different solutions.

The built-in implementation is not assumed to be the only implementation.

No engine fork required. No fighting hidden internals. No one-size-fits-all workflow.

VOID also aims to keep the normal path simple. Advanced systems should exist underneath the framework without making basic tasks complicated.

Performance-sensitive code is written with allocation behavior, thread safety, and hot-path cost in mind.

VOID 2.0 no longer depends on SFML.

The built-in renderer uses Silk.NET.OpenGL, while SDL3-CS handles the platform layer and Silk.NET.OpenAL handles audio.

The OpenGL renderer is a default implementation, not the definition of VOID's rendering system.

Custom backends can be selected through GameSettings:

var settings = GameSettings.Instance
    .SetRenderer(() => new MyRenderer())
    .Build();

Renderer plugins can implement VOID's public graphics contracts for APIs such as:

• Vulkan
• Direct3D
• Metal
• OpenGL
• custom renderers

VOID also exposes platform-native window handles through IRendererContext when a backend requires them.

Game code and higher-level engine systems remain renderer-neutral.

Read the Custom Renderer documentation

VOID provides extension points where alternate implementations make sense.

Examples include:

For example:

GameSettings.Instance.SetAtlasPacker(typeof(MyAtlasPacker));

AssetManager.Instance.AddMountToStart(new CloudMount());

AssetManager.Instance.RegisterAssetType<MyAsset>(
    new[] { ".myext" },
    (id, data, tag) => new MyAsset(id, data, tag)
);

Logger.Instance.AddSink(new DatabaseSink());

The defaults are there when you want them.

The extension points are there when you do not.

VOID includes an API and command-line tool for packaging assets into authenticated, encrypted archives.

Features include:

• AES-GCM authenticated encryption
• adaptive compression
• per-file integrity verification
• configurable chunked encryption
• streaming reads
• incremental updates
• concurrent asset loading support

Install the CLI:

dotnet tool install --global Void.Packer.CLI

Build a pack:

void-packer build -c Content/ -o Packs/

Verify it:

void-packer verify --pack GameAssets.pack

The pack system is intended to make casual extraction and unauthorized reuse more difficult while maintaining practical runtime access.

No client-side asset format can make shipped assets impossible for a determined attacker to recover.

See the VOID Wiki and Void.Packer documentation for the full packing API and CLI reference.

A small Flappy Bird-style example demonstrating the basic VOID workflow.

A larger rogue-lite zombie survival example demonstrating more of the framework working together.

VOID uses SDL3 for its platform layer. The built-in graphics backend uses OpenGL.

• .NET 10

Runtime graphics, platform, input, and audio dependencies are provided through the engine package.

• VOID Wiki
• Getting Started
• Migrating to VOID 2.0
• Custom Renderers
• Full VOID spec sheet and technical details

MIT.

Use VOID for personal, commercial, open-source, or closed-source projects.

No royalties. No engine fees.

VOID Engine: the foundation is yours. Build the rest your way.