↑Top ◇Content5 ✦Fair play4 ▸Game feel7 ⧉Your project5 ⬢Scale5 ⬡Bandwidth7 ◈Bad connections5 ⟳Communication3

Feature highlights

The ones that matter most,
in plain language.

Nucleus is a multiplayer networking engine with hundreds of shipped features. Below are the ones picked for what they change about your game, grouped by the problem they solve: bandwidth, feel, bad connections, scale, content, communication, fair play, and fitting whatever you are building. The rest is the detail underneath these.

Hundreds

Of Shipped Features

Up to 85%

Less Bandwidth

4 or 4,000

Players Per World

Security Suite

Auth, Anti-Cheat, Packet Layer

◇

Content and worlds

Worlds you can load, move and keep.

Scenes are networked objects in their own right: load them per player or for everyone, run several copies at once, and stream the content they need on demand. Objects move between them, reparent to one another while the game runs, and the whole world can be put away and brought back.

Multiplayer scene manager

Load scenes for one player or everyone, run many copies of a scene at once, and move players between them in one call.

02Pro

Addressables and asset bundles

Ship small and stream the rest. Players are prompted to load what they need automatically, and never hear about content they cannot build.

Move objects between scenes

Move a spawned object and everything under it into another scene, and let a player carry what they are steering across with them.

Runtime reparenting

Parent one networked object to another while the game runs and every player follows, parents placed before their children.

05Pro

World save and load

Save a running world and load it back later. What only made sense inside the session it came from is dropped rather than restored.

✦

Fair play

Authoritative by default. Suspicious by design.

Control of an object is something you grant and take back. Everything a client claims is checked, and misbehaviour is reported to you with detail rather than swallowed.

Cheat detection

Fifteen kinds of misbehaviour are caught for you, each reported with details and a sensible default punishment.

07Pro

Multi-writer objects

Several players can change one object safely, with the winner decided for you and the change attributed.

Check every value a client writes

Judge the value itself, not just who sent it: an index that has to be inside the bank, a health total that only ever falls, a seat nobody else has claimed. Decline one and the member keeps what it had, nobody else is told, and the player is not punished for asking.

09Pro

Your authentication, your packet layer

Use your own account system, and players see nothing until you approve them. Wrap every packet the engine sends for encryption, compression or an integrity check, in one place.

▸

How it feels to play

Instant on the input. Honest on the server.

Prediction, reconciliation and smoothing are built in, so your character answers the controller immediately while the server stays the authority on what really happened.

Easy interpolation

Read the interpolated value instead of the raw one and any replicated type animates between ticks, vectors, rotations, floats and your own types included, in one line.

11 In development

Subtick input

Input is collected every frame, carrying where inside the tick it happened, while the server keeps simulating on its fixed step. Players on high frame rates act on what they actually pressed instead of what survived rounding to a tick boundary.

Prediction with reconciliation and replay

Your character responds instantly, and still cannot cheat.

Projected physics

Physics objects stay in sync whether the server or a client owns them, and they get there without rewinding and resimulating the world every time a correction lands.

14Pro

Instant client-side spawning

Spawn or despawn something and use it straight away, without waiting on the server to approve it. A predicted spawn catches up the time it spent in flight.

15Pro

Lag-compensated hit detection

Shots count against what the shooter saw on screen. Rewound hitboxes work with walls too, so a shot can penetrate cover or deflect off it.

State aligned to the tick

State, input, spawns, despawns and physics all resolve on tick boundaries rather than whenever a frame happens to land. Both machines are talking about the same instant, so comparisons are exact and a bug reproduces.

⧉

Fitting your project

Your engine. Your deploy.

Nucleus is a C# library with no engine dependency, configured the way hosting providers expect.

Engine agnostic

A plain C# library with no engine dependency, so it runs wherever .NET does, headless servers included. The official Unity plugin ships with it, and more than thirty runnable demos.

Unity components, already written

In the Unity plugin, add a component and it replicates: transforms, animators, rigidbodies, NavMesh agents, scene loading and player spawning, each with an inspector and no networking code from you.

19Pro

Host migration

The session survives the host leaving. A relay transport, a pluggable session host and reclaim tokens hand the world to a successor with its objects and their owners intact.

Bring your own transport

Two ship with the engine: UDP for real play, and an offline one that runs a host without touching the network. Everything above them is written against one small class, so your own transport or a platform SDK drops in and nothing else in your game notices.

Command-line configuration

Set port and address with launch flags, the way hosting providers and automated deploys expect.

⬢

Scale

Four players. Or four thousand.

Area of interest decides who hears about what, which is the single biggest lever on how far a server goes. The same group covers the small end: objects several players can write to.

22Pro

Area of interest

Players receive only what matters to them, which is the main lever on how many players and objects you can support. Distance is measured from what each player controls, and the rules are yours to stack.

23Pro

Spawn pacing

A player walking into a crowded area is fed the objects over several ticks rather than all at once, so arriving somewhere busy never costs a stall.

Networked collections

Lists, arrays, sets, dictionaries and queues replicate themselves, sending the operation that changed them rather than the whole collection.

References to objects and players

Point a replicated field at another networked object or at a player and every machine resolves it to its own copy. A reference to something a player cannot see yet fills itself in when it arrives, and empties again if it goes away.

26Pro In development

Change the tick rate while running

Raise or lower the simulation rate on a live session, so a busy server can trade precision for headroom instead of being restarted.

⬡

Bandwidth

Less on the wire, every tick.

Nucleus sends changes, packed to the bit, batched into as few packets as it can. You write ordinary fields and the engine decides what actually goes out.

27Pro

Divine object updates

Position and rotation replicate for as low as 0.4 bytes an update, every tick they change. That is the real-time cost, not a number an interval bought.

28Pro

Custom delta encoding

A delta encoder built for the job, coming out 20 to 40% ahead of the deltas other frameworks send.

Packet batching

Far less packet overhead, without you managing when anything sends.

Changes only, full picture for new arrivals

Players who join late or come back into range get the whole world; everyone else pays only for what changed.

Automatic pooling

Near-zero garbage while your game runs, covering every framework and data type including your own.

Roslyn code generation

Mark a field and it replicates. No hand-written networking code, and no runtime cost for it.

33Pro

Send interval, hand set

Pace any value yourself, from every tick it changes down to once every two seconds.

◈

Bad connections

Built for the players who are not on fibre.

Delivery is unreliable and acknowledged rather than reliable and stalling. Losses are repaired, and you can reproduce a bad line on your own machine before a player finds it.

Unreliable by default, with acknowledgment

Fast delivery as standard, a reliable channel when you need one, and nothing stalls behind a lost packet.

Packet loss recovery

Missing updates, spawns and despawns are repaired, so a rough connection catches up instead of desyncing. Repairs are capped per player, so a bad or misbehaving connection can't flood the server.

Per-player connection stats

Bandwidth, ping, jitter and packet loss, ready to show players or act on.

Network condition simulation

Reproduce lag, jitter and packet loss on your own machine.

38Pro

Reconnect into the world you left

A player who drops and comes back relinks to the world they had, with the objects they controlled held for them rather than freed to whoever asks first. What a dropped client clears is your call.

⟳

Communication

Say it to exactly who needs to hear it.

Object-scoped calls for gameplay, and your own message types for everything that is not about an object in the world.

Flexible remote calls

Call a method on an object and choose who runs it: the server, everyone watching it, one player, or everyone but one. Client to client included.

Messages that belong to no object

Send your own message types between server and player. They are not bound to a networked object, so anything can listen: a UI screen, a manager, a script with nothing to do with networking.

Reliable or unreliable, per message

Pick the channel on the send itself, and anything too big for a single packet moves to the reliable one on its own rather than failing.

Theme:

Features — Nucleus

The ones that matter most,in plain language.