Void.Engine 2.0.1

There is a newer version of this package available.
See the version list below for details.

dotnet add package Void.Engine --version 2.0.1

NuGet\Install-Package Void.Engine -Version 2.0.1

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.0.1" />

For projects that support PackageReference, copy this XML node into the project file to reference the package.

<PackageVersion Include="Void.Engine" Version="2.0.1" />
                    

                            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.0.1

The NuGet Team does not provide support for this client. Please contact its maintainers for support.

#r "nuget: Void.Engine, 2.0.1"

#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.0.1

#: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.0.1
                    

                            Install as a Cake Addin

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

                            Install as a Cake Tool

The NuGet Team does not provide support for this client. Please contact its maintainers for support.

VOID Engine

A lightweight, modular, extensible 2D game framework for .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.

net10.0
- NAudio.SoundFile (>= 3.0.1)
- SDL3-CS (>= 3.4.16)
- SDL3-CS.Linux (>= 3.4.16)
- SDL3-CS.MacOS (>= 3.4.16)
- SDL3-CS.Windows (>= 3.4.16)
- Silk.NET.OpenAL (>= 2.23.0)
- Silk.NET.OpenAL.Soft.Native (>= 1.23.1)
- Silk.NET.OpenGL (>= 2.23.0)
- StbImageSharp (>= 2.30.16)
- Void.Packer (>= 1.0.1)

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.1.0	39	9/14/2026
2.0.1	53	9/13/2026
1.2.1	93	9/8/2026

[2.0.1] 2026.9.13 - VOID Engine 2.0 represents a major architectural milestone.

   VOID is no longer built around SFML. The engine now owns its platform,
   rendering, input, audio, camera, and graphics abstractions, providing a
   cleaner foundation for VOID itself and a significantly stronger extension
   surface for developers building custom rendering backends.

   Major architecture update:
   * Completely removed the SFML.Net dependency from VOID Engine
   * Added SDL3-CS as the platform layer for windows, displays, events, keyboard, mouse, gamepads, fullscreen, and graphics-context creation
   * Added the built-in OpenGL renderer using Silk.NET.OpenGL
   * Added renderer-neutral public APIs for Vulkan, Direct3D, Metal, OpenGL, and custom third-party renderer implementations
   * Added native platform handle access through IRendererContext for renderer plugins
   * Added native handle support for Windows, X11/XWayland, Wayland, and Cocoa where supported
   * Reworked textures, shaders, GPU buffers, render targets, pipelines, samplers, command submission, and graphics resources around renderer-neutral contracts
   * Replaced SFML audio with Silk.NET.OpenAL and NAudio.SoundFile decoding
   * Added multi-monitor display management and runtime display selection
   * Added Linux backend selection for Auto, X11, Wayland, and X11ThenWayland
   * Preserved VOID's high-level game, asset, batching, font, sound, and rendering workflows while replacing the underlying platform architecture

   Pluggable rendering:
   * Added IRendererBackend, IGraphicsDevice, IRendererContext, and renderer-neutral graphics resource contracts
   * Added public renderer capabilities and native-window integration for external renderer plugins
   * Made IRenderTarget usable by third-party renderer implementations
   * Removed internal renderer dependencies from public render-target and batching paths
   * Added renderer-neutral shader lifecycle and extension contracts
   * Added validation for vertex layouts, render commands, graphics-device ownership, and custom renderer resources
   * Added an external renderer smoke test covering the complete GameSettings.SetRenderer(...) plugin path

   Renderer and batching improvements:
   * Converted SpriteBatcher to indexed rendering using four vertices per sprite
   * Added reusable UInt32 index buffers
   * Reduced redundant OpenGL state changes through shared state caching
   * Cached shaders, textures, VAOs, buffers, viewport state, render targets, blend state, clear state, and uniform values
   * Improved streaming and full-buffer GPU uploads
   * Removed redundant CPU-side vertex copies
   * Reduced repeated camera and atlas work inside rendering hot paths
   * Corrected CPU batch timing statistics and reserved GPUTime for future real GPU timing support
   * Fixed transformed sprite scaling, rotated-sprite camera culling, triangle statistics, and primitive strip/fan batching
   * Corrected half-texel handling for pixel-space texture coordinates

   Texture atlas improvements:
   * Fixed Skyline free-space reuse that could produce overlapping atlas regions
   * Hardened Skyline and Guillotine packing and defragmentation
   * Made atlas defragmentation transactional
   * Added validation for invalid, overlapping, fractional, and out-of-bounds packer results
   * Improved support and validation for custom IAtlasPacker implementations
   * Kept CPU atlas data, metadata, and GPU uploads synchronized during defragmentation
   * Improved LRU eviction and recovery behavior
   * Added accurate pixel-area atlas metrics
   * Reduced unnecessary atlas LRU updates for frequently reused regions

   Shader and graphics improvements:
   * Reserved texture unit zero for the primary draw texture
   * Prevented custom shader samplers from colliding with the primary texture
   * Switched texture handling to renderer-reported hardware limits
   * Added stable OpenGL sampler-unit management
   * Cleared stale texture bindings when shader uniforms or resources change
   * Corrected untextured draw handling
   * Expanded renderer-neutral shader and graphics documentation

   Camera system:
   * Added the extensible BaseCamera abstraction
   * Added VOID's own 4x4 Matrix implementation for renderer and camera transforms
   * Removed System.Numerics.Matrix4x4 from the camera/rendering path
   * Added camera rotation
   * Added matrix-based WorldToScreen and ScreenToWorld conversion
   * Added rotated-camera bounds and conservative view culling
   * Updated batching, render targets, post-processing, and shaders to work with BaseCamera
   * Preserved the existing zero-rotation camera behavior
   * Preserved independent cameras for world and UI rendering
   * Added support for developer-defined custom camera implementations

   Text and font rendering:
   * Fixed wrapped-text horizontal and vertical alignment
   * Restored wrapped-text vertical overflow limits
   * Made tab measurement and rendering use matching spacing
   * Ignored carriage returns consistently
   * Fixed positioned-text camera-edge culling
   * Fixed direct-font rendering when half-texel offset is enabled
   * Refreshed font and text rendering internals for the new renderer architecture

   Input improvements:
   * Migrated keyboard, mouse, and gamepad input to SDL3
   * Restored InputAction updates in the main game loop
   * Improved InputAction default-state and invalid-name handling
   * Added TryGetAction overloads
   * Made KeyboardState and MouseState immutable snapshots
   * Fixed mouse focus and scroll-wheel snapshot behavior
   * Added IEquatable support to MouseState
   * Renamed XButton1/XButton2 to Extra1/Extra2

   Pathfinding improvements:
   * Fixed directed connection cleanup
   * Fixed flow-field traversal across directed connections
   * Reused available point IDs after removals
   * Corrected one-way segment handling
   * Guarded against zero-length pathfinding edges
   * Added validation for invalid point-weight scales
   * Made pathfinding disposal idempotent
   * Ensured failed path queries consistently return empty lists

   Core correctness improvements:
   * Hardened FastRandom range and bounds handling
   * Fixed Vect2 scalar-left operators and equality/hash consistency
   * Corrected FrameTime total-time accumulation in fixed timestep mode
   * Aligned DisplayMode equality and hashing with Vect2 precision behavior
   * Improved Matrix inversion and equality behavior
   * Removed unused SoundInstance playback-state fields
   * Preserved SoundInstance stop-state reporting without redundant state tracking
   * Reworked LDtk setting TryGet helpers to use non-throwing lookup and type-check paths instead of exception-driven control flow
   * Preserved strict Get setting validation and detailed missing-field, invalid-type, and enum parsing errors
   * Made LDtk setting existence checks safely return false for empty field names

   Logging improvements:
   * Hardened fatal and critical logging behavior
   * Added Critical and CriticalWithCategory crash APIs
   * Fixed duplicate exception output
   * Fixed FileSink daily rotation, size rollover, retention, and UTF-8 size tracking
   * Improved logger flushing and shutdown ordering
   * Prevented disabled log messages from being unnecessarily formatted
   * Integrated logger flushing and disposal into engine shutdown

   Documentation and tooling:
   * Extensively refreshed XML documentation across the public engine API
   * Documented renderer backend lifecycle, resource ownership, capabilities, and extension contracts
   * Documented custom renderer and custom atlas-packer requirements
   * Refreshed camera, math, window, graphics, input, logging, shader, and rendering documentation
   * Updated runnable examples for the VOID 2.0 architecture
   * Updated package metadata and README documentation for VOID Engine, Packer, CLI, and Templates
   * Removed stale SFML references throughout the project

   Breaking changes:
   * SFML.Net and SFML-specific public types are no longer part of VOID Engine
   * Rendering integrations written against the previous SFML architecture must migrate to the new renderer-neutral contracts
   * Custom renderer plugins should use IRendererBackend, IGraphicsDevice, and IRendererContext
   * Platform-specific renderer integrations should request native handles through IRendererContext instead of depending directly on VOID's SDL implementation
   * Graphics resources, shaders, textures, render targets, and GPU integrations may require migration to the new public graphics APIs
   * Camera extensions should now target BaseCamera and VOID's Matrix type
   * MouseButton.XButton1 and MouseButton.XButton2 have been renamed to Extra1 and Extra2

   VOID 2.0 establishes the new foundation for the engine:
   renderer-neutral, platform-independent, extensible, and fully owned by VOID.