Deterministic Lockstep Saves Multiplayer Bandwidth by Transmitting Keystrokes Instead of Coordinates

The survival of a multiplayer simulation is decided the moment the engine chooses what data to push through the network socket. Instead of transmitting the result of an action—the exact coordinates of a moving archer—the system transmits only the catalyst. By sending the mouse click and trusting the receiving machine to calculate the rest, the architecture decouples bandwidth from the scale of the virtual world.[1][4]

This approach is known as deterministic lockstep. It is the invisible mechanism that allows real-time strategy games to render thousands of colliding units without choking the connection. If a server attempted to broadcast the position, velocity, and health of every single soldier, the data payload would instantly overwhelm a standard residential router.[1]

Instead, the network acts as a simple courier for human intent. When a player orders a battalion to march, the game does not send a thousand trajectory updates. It sends a single command: "Player One pressed right-click at this map coordinate on frame 400."[2][4]

The Illusion of a Shared Reality

Every player in a lockstep match is actually playing a completely isolated, local copy of the game. There is no central server dictating where the trees are or how fast a cavalry unit is moving. The machines simply agree to start at the exact same initial state and process the exact same list of keystrokes in the exact same order.[1][2]

Because the underlying math is identical, the isolated simulations arrive at the exact same conclusions. If the inputs match, the outputs must match. This is the "deterministic" half of the equation: a guarantee that a specific catalyst will always produce a specific, bit-for-bit identical result across every computer in the lobby.[2]

"Determinism means that given the same initial condition and the same set of inputs your simulation gives exactly the same result," writes network engineer Glenn Fiedler. "Not close. Not near enough. Exactly the same down to the bit-level."[2]

The "lockstep" half dictates the flow of time. A machine cannot simulate frame 401 until it has received the inputs from every other player for frame 400. The simulation steps forward together, pausing if a packet from a lagging player is delayed in transit.[2][4]

Beating the Dial-Up Bottleneck

This architecture was forged under the severe hardware constraints of the late 1990s. When developers were building the original Age of Empires, they wanted eight players to command sprawling armies over 28.8-kilobit modems. That bandwidth was barely enough to transmit plain text, let alone a dynamic battlefield.[1]

If the engine had continuously transmitted every unit's position, status, and direction, the network would have capped the game at roughly 250 moving objects. That limitation would have fundamentally changed the genre, reducing massive historical sieges to minor skirmishes.[1]

By switching to deterministic lockstep, the developers bypassed the entity limit entirely. Because bandwidth consumption was tied only to the player's physical keystrokes, the network cost of moving one unit was identical to the cost of moving 1,500 units. The simulation simply ran the local math.[1][4]

"Instead of synchronizing the world, the game synchronized the decisions that changed it," notes a retrospective on the engine's architecture. The trade-off was processing power: every client had to compute the entire world's logic, rather than just rendering the graphics.[1]

The Butterfly Effect of Floating Points

While lockstep solves the bandwidth problem, it introduces a brutal engineering constraint. The simulation must be perfectly sealed against any outside variance. If one machine calculates an archer's position to be a fraction of a millimeter further left than another machine, the entire match is doomed.[1][2]

That tiny discrepancy will compound. The archer might bump into a villager on one screen but miss them on another. The villager's delayed path alters resource collection, which delays a building's construction, which changes the timing of an attack. Minutes later, the two simulations will completely desynchronize, and the game will crash.[1]

Achieving this perfect consistency is notoriously difficult because modern processors handle floating-point decimal math differently. A calculation like a sine wave might yield a slightly different rounding error on an Intel chip compared to an AMD processor.[2][4]

To survive, lockstep engines often abandon standard floating-point math entirely. Developers build custom fixed-point math libraries and implement shared pseudo-random number generators. If a villager chops a tree, the "random" sound effect that plays must be pulled from the exact same seed on every machine.[2][4]

The Evolution Into Rollback Netcode

The fatal flaw of pure lockstep is its reliance on the slowest connection. Because the engine must wait for every player's input before advancing the frame, a single lagging connection forces everyone else's game to stutter and freeze. The simulation is held hostage by the weakest link.[2][3]

In genres that require split-second reactions, like fighting games, this stutter is unacceptable. To solve it, developers evolved lockstep into "rollback" netcode. The underlying determinism remains, but the engine no longer waits for delayed packets to arrive.[3]

Instead, the game predicts what the lagging opponent is going to do—usually assuming they will just keep doing whatever they were doing a frame ago. The local simulation advances instantly, keeping the gameplay perfectly smooth for the local player.[3]

If the delayed packet finally arrives and contradicts the prediction, the engine performs a violent correction. It rewinds the simulation state to the moment of the error, applies the correct input, and fast-forwards back to the present. This all happens in a fraction of a 16-millisecond frame, completely invisible to the human eye.[3][4]

Why Modern Shooters Reject the Model

Despite its elegance, deterministic lockstep is rarely used in modern first-person shooters or massive open-world games. Those environments are simply too complex to keep perfectly deterministic. A physics engine calculating the chaotic bounce of a grenade across uneven terrain will inevitably produce micro-variations.[2][4]

Instead, shooters rely on an authoritative server model. The server runs the true simulation and constantly broadcasts absolute coordinates to the clients. If a client disagrees with the server about where a player is standing, the server forcefully snaps the player back into place.[4]

This state-synchronization approach requires vastly more bandwidth, which is why modern shooters demand broadband connections. But it allows developers to use standard physics engines and prevents players from hacking the game by modifying their local simulation.[2][4]

Lockstep remains the gold standard only where entity counts are massive and inputs are sparse. By trusting the math rather than the network, strategy games continue to render thousands of colliding variables across the globe, bound together by nothing more than a synchronized list of clicks.[1][4]