Void.Engine 2.2.0

.NET 10.0 This package targets .NET 10.0. The package is compatible with this framework or higher. 
dotnet add package Void.Engine --version 2.2.0
                    


                    

                
NuGet\Install-Package Void.Engine -Version 2.2.0
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package. 
<PackageReference Include="Void.Engine" Version="2.2.0" />
For projects that support PackageReference, copy this XML node into the project file to reference the package. 
<PackageVersion Include="Void.Engine" Version="2.2.0" />
                    


                            Directory.Packages.props
                        

                    

                
<PackageReference Include="Void.Engine" />
                    


                            Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package. 
paket add Void.Engine --version 2.2.0
                    


                    

                
#r "nuget: Void.Engine, 2.2.0"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package. 
#:package Void.Engine@2.2.0
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package. 
#addin nuget:?package=Void.Engine&version=2.2.0
                    


                            Install as a Cake Addin
                        

                    

                
#tool nuget:?package=Void.Engine&version=2.2.0
                    


                            Install as a Cake Tool

VOID Engine

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

License: MIT NuGet .NET

What is VOID?

VOID Engine provides the systems most 2D 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 full UI frameworks are left to your game or the libraries you choose.

Install

dotnet add package Void.Engine

Or install the project template:

dotnet new install Void.Templates

Then create and run a game:

dotnet new voidgame -n MyGame
cd MyGame
dotnet run

Features

System What It Does
Rendering Batched sprite and primitive rendering, texture atlasing, shaders, render targets, post-processing
Renderer API Public renderer-neutral contracts with a pluggable backend architecture
Platform SDL3 windowing, displays, fullscreen modes, events, keyboard, mouse, and gamepads
Assets Mount-based virtual file system, custom asset types, pack loading, LRU eviction
Audio OpenAL playback, sound pooling, priority-based voice stealing, category volumes
Saving AES-GCM encrypted saves with manifest verification
Pathfinding A*, Dijkstra, BFS, and flow fields
Coroutines Tweens, sequencing, delays, waits, and easing
Logging Async logging with console and file sinks
Math Vectors, matrices, rectangles, colors, easing, and random helpers
Tooling Project templates and authenticated encrypted asset packing tools
LDtk LDtk level and asset integration

Philosophy

Extend, don't modify.

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 Rendering Architecture

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 renderer 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 exposes native window handles through IRendererContext when a backend requires them.

Higher-level game and engine code remains renderer-neutral.

Read the Custom Renderer documentation

Extensibility

VOID provides extension points where alternate implementations make sense.

Extension Point Purpose
IAsset Define custom asset types
IMount Add custom asset sources
IAtlasPacker Replace the texture packing algorithm
ILogSink Add custom logging destinations
IRendererBackend Provide another graphics backend
IGraphicsDevice Implement renderer-specific GPU behavior
IBatcher Add custom batching strategies
IRenderTarget Provide custom render surfaces
BaseCamera Build specialized camera behavior
ContentTypeWriterReader<T> Support custom save-data types

Examples:

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.

Asset Packer

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.

Quick Start Without the Template

Create a normal console project and add VOID:

dotnet new console -n MyGame
cd MyGame
dotnet add package Void.Engine

Create a game class:

using Void.Engine;

public class MyGame : Game
{
    public MyGame(GameSettings settings) : base(settings) { }

    protected override void OnEnter() { }
    protected override void OnUpdate(FrameTime frameTime) { }
    protected override void OnDraw(FrameTime frameTime) { }
    protected override void OnExit() { }
}

Configure and run it:

using Void.Engine;

var settings = GameSettings.Instance
    .SetAppCompany("MyStudio")
    .SetAppName("MyGame")
    .SetWindow(1280, 720)
    .Build();

using var game = new MyGame(settings);
game.Run();

Demos

FlappyBirb

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

Scavengers

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

Supported Platforms

Platform Status
Windows Supported
macOS Supported
Linux Supported

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

Requirements

  • .NET 10

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

Documentation

License

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.

Product Compatible and additional computed target framework versions.
.NET net10.0 is compatible.  net10.0-android was computed.  net10.0-browser was computed.  net10.0-ios was computed.  net10.0-maccatalyst was computed.  net10.0-macos was computed.  net10.0-tvos was computed.  net10.0-windows was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last Updated
2.2.0 79 9/23/2026
2.1.1 132 9/18/2026
2.1.0 125 9/14/2026
2.0.1 104 9/13/2026
1.2.1 111 9/8/2026

VOID Engine 2.2.0

   Beacons
   - Added timed Beacon subscriptions using float lifetimes in seconds.
   - Added TimeSpan subscription overloads through BeaconManager extensions.
   - Added SubscribeOnce support for string and enum topics.
   - Added timed SubscribeOnce overloads using float and TimeSpan lifetimes.
   - Timed subscriptions expire lazily when their topic is published, subscribed to, or unsubscribed from.
   - Timed subscription expiration uses Game.Instance.FrameTime.TotalTime.
   - Preserved the existing multicast delegate publish path for normal Beacon dispatch.
   - Timed Beacon subscriptions do not require a per-frame BeaconManager update.
   - Timed subscriptions can still be manually removed using their original callback.

   Input Actions
   - Changed InputAction internal action and state dictionaries to cached 64-bit identifiers.
   - InputAction names now use HashHelper.Cache64 for internal lookup.
   - Changed InputActionState snapshots to use ulong action identifiers instead of string dictionary keys.
   - Reduced repeated string-key lookup and comparison work for action state queries.
   - Preserved the existing public string and enum InputAction APIs.
   - Preserved retained InputActionState snapshot behavior and action transition semantics.
   - Input action string identifiers are now case-sensitive and follow HashHelper caching behavior.

   Hashing
   - Optimized HashHelper cached lookups to avoid creating unused Lazy hash values on cache hits.
   - Cache32 and Cache64 now create Lazy values only when a key is missing.
   - Preserved existing FNV-1a hashing, cached results, and thread-safe initialization behavior.
   - Reduced unnecessary allocations during repeated cached hash lookups.

   Spritesheets
   - Fixed Aseprite nine-patch slice center data being interpreted as border sizes.
   - Nine-patch borders are now calculated correctly from the Aseprite center rectangle.
   - Fixed incorrect nine-patch corner sizing when using smaller source patches such as 16x16 sprites.

   LDtk
   - Fixed IntGrid instance world positions using layer grid dimensions instead of the layer tile size.
   - IntGrid positions are now calculated from grid location and tile size.

   Collision
   - Fixed MoveAndSlideCircle corner jitter and touching behavior.
   - Circle-vs-rectangle and circle-vs-circle resolution now use penetration-only collision checks.
   - Improved circle collision resolution using radial push-out behavior.
   - Limited circle collision resolution to four passes to prevent unstable corner behavior.