Downloads
C# · netstandard2.1 · Any Game Engine

NUCLEUS

State-Synchronized Multiplayer Networking

A tick-based, bit-level networking engine built for multiplayer games. Authoritative server architecture, transport-agnostic, with delta state replication that plugs into any C# runtime.

Bit
Level Precision
Δ Delta
State Updates
7
Core Modules
0 GC
Hot-Path Allocs
Why Nucleus

Precision networking,
without the overhead.

Every byte counts in multiplayer. Nucleus is engineered to give you surgical control over what gets sent, when, and to whom — with zero compromise on performance.

Bit-Level Serialization
Write single bits, not bytes. The Writer/Reader system operates at the bit level with pooled buffers — giving you surgical control over every packet.
Delta State Replication
Send only what changed. New observers get a full snapshot, then are promoted to delta updates — slashing bandwidth with every tick.
Deterministic Tick Loop
A named, multi-priority step system: EarlyTick, EarlyVariable, LateState, LateVariable, LateTick. Everything happens in a precise, reproducible order.
Transport Agnostic
Swap entire socket layers without touching your game logic. Ships with Tugboat (LiteNetLib) and Yak (offline loopback) out of the box.
Source-Generated Serializers
Mark types with [NetworkedType] and get auto-generated, compile-time bit serializers. Full and Delta modes, no runtime reflection required.
Zero-Allocation Pools
Writers, Readers, Connections, packets, lists, sets — everything on the hot path is pooled with IPoolResettable. GC stays quiet during play.
Architecture

Seven modules.
One CoreManager.

Instantiate one CoreManager and the engine bootstraps itself. Every sub-manager wires up, cross-subscribes, and the tick loop stands ready.

CoreManager
Singleton orchestrator — bootstraps all managers
NetworkLoop
Multi-priority tick engine with named loop steps
Transport
Pluggable socket layer & connection lifecycle
Packets
Message RPCs + tick-aligned state packets
Serializers
Bit-level Writer/Reader, pooled, three modes
Components
NetworkComponent, NetworkedMember<T> primitives
Systems
Observer sets, full→delta promotion pipeline
CoreManager
Singleton Orchestrator
NetworkLoop
Transport
Packets
Serializers
States
Systems
// Tick Loop Steps (per frame)
1.EarlyTickUpdate← tick++
2.EarlyVariableUpdate
3.LateStateUpdate
4.LateVariableUpdate
5.LateTickUpdate
Integration

Clean API.
Minimal boilerplate.

Get a networked game running in minutes. Nucleus handles the complexity so you can focus on building your game.

QuickStart.cs
// Bootstrap the entire engine with one line
CoreManager core = new();

// Add a real UDP transport (LiteNetLib)
Transport transport = await core.TransportManager
    .AddTransportAsync<Tugboat>();

// Start listening as an authoritative server
await core.TransportManager.ConnectAsync(Invoker.Server);

// React to clients joining
core.ServerManager.ClientAuthenticated += (Connection client) =>
{
    Console.WriteLine($"Player {client.Id} connected");
};

// Drive it from your game loop
core.NetworkLoopManager.Start();
Performance

Engineered for
competitive play.

Every design decision in Nucleus prioritises performance. Bit packing, delta replication, and object pooling combine so your game uses less bandwidth, less CPU, and less memory — every tick.

1bit
Minimum Packet Unit
True bit-level writes. No byte-alignment waste on your state data.
Δonly
Delta Replication
Unchanged fields cost zero bandwidth. Send only what changed.
0
GC Allocations
All hot-path objects rented from pools. GC stays quiet during play.
3
Priority Levels
High, Normal, Low per loop step. Deterministic execution, always.
Bandwidth — Delta vs Full
Full serialization (baseline)100%
Delta — 10% field change rate~12%
Delta — 30% field change rate~35%
Serialization Modes
Full — every fieldInitial sync
Delta — changed fields onlyPer-tick
Uncompressed — raw outputDebug / tools
Compatibility

Your engine.
Your rules.

Nucleus targets netstandard2.1 with no runtime dependencies. Plug your game loop in, swap the transport, and it works — in Unity, Godot, Flax, or a bare-metal server process.

Bring Your Own Loop
Implement INetworkLoopStepProvider to feed Nucleus ticks from Unity's Update, Godot's _Process, or any custom game loop.
Pluggable Transports
Ship with Tugboat (LiteNetLib UDP) or Yak (offline loopback). Extend Transport to support Steam Sockets, EOS, or anything else.
Authoritative by Default
Server-authoritative design is baked in. Clients authenticate, receive state deltas, and send inputs. No client trust, no reconciliation headaches.
Offline Testing with Yak
The Yak transport runs both server and client in-process with zero network overhead. Write and test your game logic locally before going online.
🎮
Unity
Recommended
🐦
Godot
Mono / .NET
Flax
.NET Runtime
🖥️
Standalone
.NET 6 / 8
🔧
Custom
Any Engine
🧪
Yak
Offline Test
// One-line transport swap
// Production — real UDP over the internet
await core.TransportManager.AddTransportAsync<Tugboat>();

// Testing — offline in-process loopback
await core.TransportManager.AddTransportAsync<Yak>();
Get Started

Ready to build your
multiplayer game?

Nucleus is available now. Add the package, create a CoreManager, and you're networked — in minutes, not weeks.

NuGet Package Manager
$ dotnet add package Nucleus.Networking
01 / INSTALL
Add the Package
Install Nucleus via NuGet or reference the DLL. Targets netstandard2.1 — works in any compatible project.
02 / BOOTSTRAP
Create CoreManager
Instantiate one CoreManager. All 7 sub-managers wire up automatically. Add a transport and start the loop.
03 / SHIP
Build Your Game
Define your states, write your messages, hook your systems. Nucleus takes care of the network layer from there.
Theme: