Lockstep Networking Technology
Our games are powered by an in-house deterministic lockstep networking system built for highly interactive, physics-based multiplayer experiences. It combines a custom networking layer, cross-platform deterministic physics, standard Unity C# development, and standalone authoritative servers into one reusable technology foundation.
One of the system’s main advantages is its ability to support up to 64 players alongside large numbers of active physics bodies interacting within the same shared world. Players can push, carry, throw, collide with, destroy, and trigger objects while those objects continue interacting with other players and the surrounding environment. This enables us to design multiplayer games in which physics is not merely a visual effect, but a central part of the gameplay.
How Deterministic Lockstep Works
Traditional multiplayer netcode commonly relies on state replication. The server repeatedly sends positions, rotations, velocities, animation states, and other updates for networked players and objects. As the number of players and physics bodies increases, the amount of state that must be transmitted can grow significantly.
Clients must then interpolate between updates and may use prediction to hide latency. When the predicted state differs from the server’s authoritative state, the client must apply corrections. In physics-heavy games, these corrections can appear as objects snapping, vehicles shifting position, collisions being reversed, or players seeing different outcomes.
Our lockstep system takes a different approach. Instead of continuously transmitting the state of every simulated object, each client and server runs the same simulation locally at a fixed tick rate. The network primarily exchanges compact player inputs and simulation commands. These commands are processed in the same order and on the same simulation tick by every connected machine.
When the simulation begins from the same state and receives the same ordered inputs, it produces the same result everywhere.
For example, when a player launches a physics object into a group of other objects, the network does not need to continuously transmit the position and velocity of every object involved in the resulting chain reaction. It synchronizes the command that initiated the action, and each machine independently calculates the collisions, forces, movement, and final outcome.
Enabling Highly Interactive Multiplayer Worlds
This approach allows bandwidth usage to remain tied more closely to the number of player inputs than to the total number of physics objects in the world.
That distinction is important for the types of games we are building. A single multiplayer match may contain:
-
•
Up to 64 players
-
•
Player-controlled characters and vehicles
-
•
Projectiles and physics-based weapons
-
•
Movable and throwable objects
-
•
Interactive environmental obstacles
-
•
Destructible or reactive objects
-
•
Large collision chains and cascading physics events
With traditional state replication, many of these objects may require frequent transform, velocity, and state updates. With deterministic lockstep, their behavior can be calculated locally after the initiating inputs have been synchronized.
This makes it practical to build highly interactive multiplayer games where dozens of players can manipulate the same physical environment at once. Instead of limiting physics interactions to reduce network traffic, we can make them a defining part of the experience.
Cross-Platform Deterministic Physics
Standard floating-point physics can produce slightly different results across processors, operating systems, compilers, and hardware platforms. Even a very small numerical difference can accumulate over thousands of simulation ticks and eventually cause two machines to disagree about the state of the game.
To prevent this, we are developing a cross-platform deterministic physics system designed to produce consistent results across supported platforms. Physics calculations, collision resolution, movement, gameplay logic, and simulation order are carefully controlled so that the same starting state and inputs produce the same outcome.
The system can also generate state hashes at selected simulation intervals. These hashes allow the server and clients to verify that they remain synchronized. If a machine diverges from the authoritative simulation, the difference can be detected and corrected before it develops into a larger gameplay problem.
Standalone Authoritative Servers
Our standalone servers participate in the same deterministic simulation as the players while remaining independent of the graphical Unity game client.
The server controls the official simulation timeline, validates player commands, maintains the authoritative game state, and ensures that all participants process inputs on the correct simulation ticks. This prevents any individual player from becoming the sole authority over a match.
Running the server as a standalone application also removes unnecessary rendering, audio, and client-side overhead. This produces a smaller and more efficient server process that is easier to deploy and scale across multiplayer sessions.
Minimal Bandwidth Usage
Traditional state replication may need to continually synchronize:
- •Player and vehicle transforms
- •Linear and angular velocities
- •Projectiles and pickup items
- •Movable environmental objects
- •Collision outcomes
- •Enemy and gameplay states
- •Destructible objects and chain reactions
Our lockstep system can reproduce many of these results locally. The network primarily carries player inputs, simulation commands, timing information, acknowledgements, and occasional synchronization or validation data.
This enables multiplayer worlds with many players and physics bodies without requiring every object’s complete state to be repeatedly transmitted. The result is a networking model designed for dense, physics-driven interaction while maintaining minimal bandwidth usage.
Built Directly for Unity and C#
Many deterministic networking solutions require developers to use a specialized simulation framework, restricted programming model, custom scripting language, or separate gameplay workflow.
Our technology is built around standard Unity and C#. This allows us to develop gameplay using familiar Unity projects, components, tools, and programming practices while still benefiting from deterministic simulation.
By keeping the technology integrated with our normal Unity workflow, we can prototype faster, reuse existing development knowledge, and improve the shared networking foundation with every game we build.
Designed for Physics-Based Multiplayer Games
Lockstep is not automatically the best networking model for every multiplayer game. Traditional snapshot replication remains effective for experiences that do not require large numbers of precisely synchronized interactions.
For the games we are building—including fast-paced arcade, racing, sports, fighting, RTS, MOBA, and large-scale party games—deterministic lockstep provides a strong technical advantage.
It allows us to build shared worlds where up to 64 players and many physics bodies can interact simultaneously. Players can collide, race, launch objects, trigger chain reactions, manipulate the environment, and directly influence one another through physics, all while remaining synchronized and using minimal bandwidth.