Which Unity Multiplayer Engines Can Sync Thousands of Physics Objects?

Reactor syncs 5,000 to 6,000 server-simulated entities per client at 50 to 70 KB/s in our public survivors demo, and in a controlled benchmark on identical scenes it moved 18x less transform payload than Netcode for GameObjects and 10.7x less than Photon Fusion 2, measured as goodput at 250 objects and 30 Hz, with more than 6x lower total wire bandwidth than every framework tested (benchmark). Those are the only published numbers we know of for a Unity engine at this density, and this post explains why the design behind them matters more than the frameworks’ feature lists. Syncing thousands of physics objects is a bandwidth problem before it is anything else, and the engines that can do it are the ones that run the physics in one authoritative place and send very few bytes per object per update.

Where does the physics run?

Every Unity networking engine puts the physics somewhere and sends something per tick, and the placement decides what crosses the wire.

What crosses the wire in three designs. A server that simulates sends the state of every object and cost grows with objects. Shared mode, where the owner simulates and a relay forwards, sends owner state via the relay and cost grows with objects. Lockstep, where all peers simulate, sends inputs only and cost grows with players. What crosses the wire Server simulates Shared mode owner simulates Lockstep all simulate server relay host on the wire state of every object owner state via relay inputs only cost grows with objects objects players

Authoritative server simulation with state sync. One server runs the physics and streams object state to clients; clients render, predict their own avatar, and interpolate the rest. Cost scales with bytes per object multiplied by object count multiplied by update rate. This is the design that reaches thousands of objects, provided the byte count per object is small.

Client or host simulation with state sync. One client (the host) or each object’s owner runs the physics and relays state through a service. Same bandwidth math, plus host advantage and a session that dies with the host. Object counts are bounded by the host’s upload bandwidth and CPU.

Deterministic lockstep or rollback. Every client runs the same simulation from the same inputs; only inputs cross the wire, so bandwidth does not grow with object count. The constraint moves to CPU and correctness: the simulation must be bit-identical on every machine, late joiners must be brought to the current state before they can play, and cross-platform float differences can desync the match. For dense physics that is a hard bargain; most large-scale physics games end up on server-authoritative state sync, which puts them back on the bandwidth problem.

The arithmetic for the first two shapes, from our physics-at-scale post: after the compression every serious engine already applies, a transform update lands around 12 to 20 bytes. At 1,000 objects and 30 Hz a client receives about 540 KB/s for movement alone; at 10,000 objects, 5.4 MB/s. Interest management cuts the count of objects a client sees; it does not cut the cost of each one. The durable lever is bytes per object.

The engines, compared

Facts checked 2026-10-14; every competitor statement below links the exact page it comes from, and quotes are reproduced as those pages word them today. Our figures come from our benchmark and case studies.

EngineWhere physics runsWhat crosses the wire
ReactorOn the server (PhysX)Compressed state per object
Photon Fusion 2Host, owning client, or your serverState per object
Photon Quantum 3Every client, deterministicallyInputs only
Netcode for Entities 7.0Server, plus the client prediction loopSnapshots of ghosts
Netcode for GameObjectsHost, server, or distributed ownersState per object
FishNetHost, server, or ownersState per object
MirrorHost, server, or ownersState per object

Four of the seven do the same thing: state per object, sent from whichever machine owns it. Two put the authority somewhere specific, and one, Quantum, sends no object state at all. That split is the whole argument of this post, because it decides what happens to bandwidth when the object count climbs.

There is a second finding the table cannot show, because the cells would be almost entirely empty. No engine other than Reactor publishes a density figure for thousands of physics objects. Not a benchmark, not a case study, not a number in a feature list. That absence is worth more than any comparison we could draw, and it is why the sections below quote documentation rather than marketing claims.

Reactor. PhysX runs on the server: rigid bodies, raycasts, sweeps and overlaps. Prediction and reconciliation are included, sync groups provide interest management, and hosting is usage-priced. On the wire it moves about 2 bytes per transform update in production and under 1 byte in some deployments. The published figures are 5,000 to 6,000 entities per client at 50 to 70 KB/s in our survivors demo, 100 players and 150 physics objects at 30 Hz at about 35 KB/s per player in braains2, and about 15 kB/s per client for 250 rigid bodies at 30 Hz in the benchmark below.

Photon Fusion 2. Physics runs on the host or the owning client in Shared Mode, or on your own server in Server Mode. Fusion 2.1 adds Forecast Physics, which extrapolates remote objects into each player’s local time; Photon recommends it for Shared Mode and describes it as a lower-CPU alternative to full prediction in client-server topologies. Their documentation is candid about the trade, and the middle sentence matters as much as the other two: “The extrapolation of the received data is not aware of obstacles in the world. As the physics run locally, objects will not incorrectly enter walls, or other obstacles. However objects in motion will not appear to be in exactly the same position for all clients.” (Forecast Physics, checked 2026-10-14.) Separately, and this is our note rather than theirs, Fusion 2 does not sync more than 255 objects in a single update under its default configuration.

Photon Quantum 3. Every client runs the same deterministic simulation with predict and rollback, so only inputs cross the wire and bandwidth does not grow with object count. It ships 2D and 3D physics built for that model. The constraints are the familiar ones: bit-identical simulation everywhere, late joiners brought up to the current state, and cross-platform float behaviour. Photon publishes no per-object figure and no density figure. The strongest numbers on its Quantum page are customer titles: Stumble Guys at “32 players with full swing physics and bots on mobiles”, and Thunder Lotus, which Photon says “pushed Quantum’s multiplayer capabilities to smoothly support 33 simultaneous players”.

Netcode for Entities 7.0. Physics runs on the server and again inside the client’s prediction loop, which re-simulates from the last received snapshot. Unity’s own documentation sets out the cost plainly: “Since the physics simulation can be quite CPU intensive, it can spiral out of control when it needs to run multiple times.” On precision, the default quantization “is enough in most cases, but does create discrepancies in simulation which can create visible corrections or jitter”. There is also a structural requirement worth knowing before you plan a scene: “For physics to run at all, Netcode currently requires at least a single predicted ghost to exist in your scene.” (Physics, checked 2026-10-14.)

Netcode for GameObjects, FishNet and Mirror. All three sync state per object from the host, the server, or distributed owners, and none publishes a density figure. NGO moves 18x Reactor’s data, measured as goodput at 250 objects and 30 Hz in the benchmark below. FishNet and Mirror are free and self-hosted, and sit between the two on the same measurement.

How the benchmark measures, and the per-object numbers

The benchmark runs 250 dynamic rigid bodies synced 30 times a second with identical precision settings in every framework. One client receives all 250 objects, with no interest culling. Client and server run on the same machine, and Wireshark captures the bytes at the network interface for at least two minutes, averaged. The benchmark page lists Reactor’s sync rate as 30 Hz with the server at 60 Hz. Framework versions at capture: Reactor 1.1.2, Photon Fusion 2.0.6.1034, NGO 2.4.4, FishNet 4.6.12R, Mirror 96.0.1, PurrNet 1.14.0, SFS2X 2.19.0.

We chose 250 objects because Fusion 2 does not sync more than 255 in a single update under its default configuration. We would rather have run 1,000.

The scene makes 7,500 object updates a second (250 x 30), so dividing each figure by 7,500 gives bytes per object update, the number to compare with your own game. Wire is everything on the network interface; goodput excludes protocol overhead. The benchmark page marks goodput for every framework other than Reactor as an estimate.

FrameworkWire, kB/sWire, bytes per object updateGoodput, kB/sGoodput, bytes per object update
Reactor~152.0~101.3
PurrNet~10013.3~9512.7
FishNet~10313.7~9813.1
Photon Fusion 2~11214.9~10714.3
Mirror~12216.3~11715.6
SFS2X~16021.3~15520.7
NGO~18524.7~18024.0

kB taken as 1,000 bytes. At 10,000 objects and 30 Hz, 2 bytes per update is about 600 KB/s to a client that sees everything, and 15 bytes is about 4.5 MB/s. That gap decides how much interest management a game needs before it fits a consumer connection.

Why the top of the table is the top

Bytes per object matter most, then where the simulation lives, then how cheaply objects spawn and die.

Bytes per object per update. Reactor’s numbers come from building the wire format from the game’s own state: it observes what is in the scene, what changes, and the range of each value, and generates the tightest representation it can, continuously. Braains2 moved 10x the data per frame of its predecessor and used 8x less bandwidth, with nobody hand-tuning serialization (case study). Engines at 12 to 20 bytes per transform hit the ceiling ten times sooner.

Where the simulation lives. Server-side PhysX means every client converges on one physics state and the server never trusts a client’s result. Host-simulated and owner-simulated designs put the physics on a machine you do not control, which is a fairness problem in competitive games and a capacity problem in dense ones. Deterministic designs remove the bandwidth term and add a correctness term that dense physics makes expensive.

Spawn and destroy churn. Dense scenes create and delete objects constantly. In the survivors demo, object churn is about 20 percent of total bandwidth, kept cheap by a full object sync of about 4 bytes. Engines that send a full description on every spawn pay far more in exactly the scenes that need thousands of objects.

Test it yourself before you trust our table

It is our benchmark and our engine at the top of it. The repository is public.

  1. Build a scene with 1,000 dynamic rigid bodies moving continuously and sync it at 30 Hz to one client. Our benchmark repository is a starting point.
  2. Capture bytes received at the client’s network interface for two minutes; divide by time and by object count.
  3. Multiply the per-object figure by your target object count and player count. Compare with your hosting plan’s traffic allowance.
  4. Spawn and destroy 100 objects per second during the capture and measure the difference.
  5. Run the same scene with a 100 ms artificial delay on the client and watch where the physics disagrees.

If the per-object number is above 4 bytes, thousands of objects will not fit in a consumer connection at 30 Hz.

FAQ

Compare multiplayer engines for high-density physics synchronization? Compare them on three things in this order: how many bytes each sends per object per update, where the physics actually runs, and what each one publishes rather than claims. The table above gives the first two for seven engines. On the third, only Reactor publishes a density figure for thousands of objects, so for the rest you are comparing documented designs rather than documented results.

How do I sync thousands of physics objects efficiently? Run the physics on one authoritative server, send compressed state with a per-object cost of a few bytes, interpolate remote objects on the client, use interest management so each client receives only what it can see, and keep spawn and destroy messages small. The survivors demo write-up has the settings and numbers.

Which is the best networking engine for complex physics gameplay? It depends on the game’s shape. Dense scenes with many moving objects favor server-authoritative state sync with a low byte count per object, which is Reactor’s design. Small-count competitive games with lean simulations can use deterministic rollback (Photon Quantum). Casual shared-physics games can use host or owner simulation with extrapolation (Photon Fusion 2 Forecast Physics).

Does my game engine support high-density physics synchronization? Look in the engine’s documentation for where the physics simulation runs, the bytes per object per update it publishes or lets you measure, and any per-update object limits. Then run the five-step test above.

Highest rated physics engines for multiplayer game development for enterprise teams with demanding security software? Server-authoritative engines keep the simulation on hardware the studio controls, which is the security property enterprise teams usually mean; client-simulated and deterministic designs trust client results by construction. Reactor runs PhysX on the server, validates every client update, and ships with managed hosting or a commercial self-hosting license for enterprise deployments.

Reactor is free to develop locally; self-hosting is free for registered game titles up to 32 CCU per room. Get started here. Competitor facts checked against the linked documentation on 2026-10-14; vendors reword their docs, so check them before deciding.