Quake / QuakeWorld · PC · 1996 · Impact: Industry-Changing
A fundamental synchronisation problem between client-side prediction and server authority in early QuakeWorld network code produced visible "warping" of other players' positions, prompting innovations in client-side interpolation and lag compensation that became the architectural foundation of all subsequent online first-person shooters.
Quake's original netcode transmitted full player position data to each client, relying on the server as the sole authoritative source of game state. At late-1990s connection speeds — typically 28.8 or 33.6 kbps modem connections — this approach produced playable but noticeably delayed results on the local player's movement and made other players' positions visibly inconsistent, "warping" between locations as packets arrived. John Carmack's QuakeWorld client, released as a free update in late 1996, introduced client-side prediction: the local client would simulate the effects of the player's own inputs immediately rather than waiting for server confirmation, then reconcile with the server's authoritative state when confirmations arrived. This produced smooth local movement at the cost of introducing a new class of bugs: prediction errors, where the client's simulated state diverged from the server's actual state, producing brief corrections that appeared as position snaps or movement reversals. Other players' positions, which could not be predicted client-side (since the client had no knowledge of other players' inputs), were interpolated between received positions — smoothly extrapolating movement paths between packet arrivals. The interaction between prediction for the local player and interpolation for remote players introduced a subtle but fundamental challenge: the local player was operating in a slightly different temporal frame than remote players, meaning that shooting at where an opponent appeared on screen was not the same as shooting at where the server believed that opponent to be. This desync problem — now called the "peeker's advantage" or the lag compensation problem — was the central technical challenge of online multiplayer design for the following decade, and every solution that subsequent games implemented traced its lineage to the approaches first attempted in QuakeWorld.
Client-side prediction runs a local simulation of the physics and movement that the server will also run, allowing the client to display results immediately without waiting for the network round trip. When the server's authoritative state arrives, the client compares it to the locally predicted state and, if they differ, corrects the discrepancy — ideally smoothly enough that the player does not notice. This correction process is where prediction desync bugs appear: if the prediction diverges significantly from the server's state (because of packet loss, timing differences, or unaccounted-for interactions with other game objects), the correction manifests as a visible snap or teleport.
Interpolation of remote players' positions addresses a different problem: since the client cannot predict where other players will move (it does not know their inputs), it displays each remote player's position as a smooth path between the last two received position updates. This smoothing introduces a display delay equal to approximately one packet interval — typically 50 to 100 milliseconds at competitive connection speeds. The result is that shooting at a remote player's displayed position requires aiming at where they were slightly in the past, not where they are on the server now.
QuakeWorld's architecture — client-side prediction for local player movement, server authority for all game state, interpolation for remote entities — became the template that the industry built on for the following twenty years. Valve's Half-Life extended the model with more sophisticated lag compensation: rather than requiring the client to aim ahead of remote players to account for interpolation delay, the server would rewind its game state by the client's measured latency when processing hit detection, checking whether a shot would have connected at the moment the client fired rather than at the moment the server received the shot data.
This approach — server-side lag compensation combined with client-side prediction — became the dominant architecture for online first-person shooters and persists in modified form in Counter-Strike 2, Valorant, and Apex Legends. The specific bugs that QuakeWorld's prediction introduced, and the solutions Carmack and Valve developed to address them, constitute the foundational technical vocabulary of online multiplayer design. The desync problem was not solved so much as managed through an evolving set of trade-offs between fairness, playability, and anti-cheat requirements that the industry is still negotiating today.