Servers pull a player-position archive from roughly 100–200 ms ago, replay the hit-detection math against that older snapshot, and confirm the kill on the world you actually saw on your screen. By trusting the shooter’s view of the timeline, the server turns what would be a missed round into a confirmed kill, and every modern online shooter from Counter-Strike to Valorant relies on some variant of that trade-off.
This technical breakdown unpacks the server-side rewinding trick that keeps online gunfights feeling fair, walking competitive FPS players through the timing problem, tick rate trade-offs, and the peeker’s advantage behind every registered headshot.
The Core Problem: When Two Timelines Collide
Every bullet you fire begins as input on your local machine, crosses the internet, lands on a remote server, and only then produces a result. That round trip typically falls between 30 and 120 milliseconds on a wired connection, and it stretches past 200 milliseconds on a congested Wi-Fi evening. The server cannot assume your screen reflects reality, so it acts as the single source of truth for every player connected to the match.
Once your round-trip time climbs past 60 milliseconds, the gap between your local view and the server’s view becomes visible during firefights. A target who looks exposed on your monitor may already be behind cover on the server, because your position update took 80 milliseconds to arrive. Shooters compress hundreds of milliseconds of input into split-second exchanges, leaving almost no margin for that drift, and a clean headshot can fail simply because the server is still working from a snapshot taken a few frames ago.
Why a Single Authoritative World Matters
If the server let every client decide hits locally, two players firing at each other on the same tick would both “win,” and desyncs would compound until the match became unplayable. Centralizing hit detection keeps the world consistent, but it also means the server is always reacting to events that already happened on someone’s machine. That delay is exactly what lag compensation tries to undo, and you feel the result every time a shot lands where your instincts said it should.
Rewinding the Server Clock to Match the Shooter
When you fire, the game attaches a timestamp to the shot based on the moment it actually left your client. The server then looks at that timestamp, rewinds every player’s stored position back to that exact instant, and runs hit detection against the rewinded world. The technique is called server-side rewind, and it underpins how lag compensation works in shooters like Counter-Strike 2 and Call of Duty.
Most implementations cap this rewind at around 200 milliseconds to prevent abuse and keep behavior predictable, because past that threshold a high-ping attacker could theoretically land hits on targets who were never visible at the same time. Valve popularized the approach when it integrated server-side rewind into the Source engine for Counter-Strike 1.6 around 2002, and the technique has been the industry default ever since.
What a Rewind Actually Looks Like in Code
Think of the server keeping a short ring buffer of player positions, one snapshot every server tick. When a shot arrives, the server searches the buffer for each player’s position at your claimed time, then performs a line trace through the world as it existed at that moment. If the line hits a player capsule, the server registers the kill and snaps the victim’s animation back to the bullet’s impact frame. To you, it feels like the shot landed instantly, while to the victim it can look like they died through a wall.
Why Tick Rate Shapes How Fair the Rewind Feels
Tick rate sets how many times per second the server refreshes world state, commonly 64 Hz in casual servers and 128 Hz in competitive titles. Between snapshots the server has to interpolate positions, and the wider that gap, the more guesswork is involved when a rewind lands between two stored frames.
Lower tick rates create larger interpolation windows, forcing the server to estimate where a player was and occasionally misjudge hit geometry. Higher tick rates shorten the worst-case rewind window and produce tighter, more consistent hit registration, which is why tournaments and ranked ladders in Counter-Strike 2 and Valorant insist on 128-tick servers. Choosing 128-tick infrastructure is a deliberate trade-off between bandwidth cost and competitive integrity, because each player sends about twice as many position updates and the server processes them at a steeper CPU cost per match.
Higher tick rates smooth those victim-side rewind hits, but they also force clients to predict more aggressively between updates.
| Tick Rate | Snapshot Interval | Worst-Case Rewind Error | Typical Use |
|---|---|---|---|
| 32 Hz | 31.25 ms | ~30 ms | Console casual matchmaking |
| 64 Hz | 15.6 ms | ~15 ms | Standard PC matchmaking |
| 128 Hz | 7.8 ms | ~7 ms | Competitive and ranked play |
| 240 Hz | 4.2 ms | ~4 ms | Niche arena shooters and training servers |
Client-Side Prediction and Server Reconciliation
Predicted movement lets you dodge and turn instantly without waiting for server confirmation each frame. Your client runs a local copy of the movement rules, shows you the result immediately, and sends the input upstream. The server processes the same input, then compares its authoritative state to what your client predicted. When the two drift, the server quietly corrects your view through a process called server reconciliation.
Reconciliation is blended smoothly so the correction feels like natural motion rather than a teleport. Your client may resimulate the last few frames from the server’s snapshot and replay them at a slightly adjusted speed, hiding a position error of 10 to 20 centimeters behind a subtle stutter. Prediction smooths control feel, lag compensation smooths shooting feel, and good netcode balances both so neither dominates your experience.
Why Movement and Shooting Need Different Tricks
Movement is forgiving because the human eye barely notices a 5 cm correction over a tenth of a second. Shooting is unforgiving because a one-frame difference decides whether a tracer passes through a head or a shoulder. That asymmetry is why prediction and rewind live in different parts of the stack, even though they cooperate on the same client.
The Shooter Versus the Target: Peeker’s Advantage and the Cost of Fairness
Rewinding time favors whoever pulled the trigger, often penalizing the defender who has already returned to cover. The victim sees themselves as safe, their model tucked behind a wall on their own screen, while the server still considers them exposed during the rewind interval. That mismatch is the everyday version of peeker’s advantage, and it scales directly with ping.
High-ping players can extend their effective presence by abusing the rewind window against lower-ping opponents. A 150 ms player peeking a corner effectively gives themselves an extra 150 ms of “existence” on the server before the player on the other end sees them disappear. Studios respond by capping rewind length and analyzing anomaly patterns with systems like FairFight and BattlEye, which flag accounts whose kills disproportionately rely on extreme rewind values.
Watch for the corner trick. If an enemy consistently kills you the instant you see them swing out, then dies a half-second later on your screen, their ping is almost certainly forcing a rewind you cannot physically counter with positioning alone.
How Different Engines Handle the Same Problem
Valve’s Source engine pioneered server-side rewind that became the baseline for most modern shooters. Unreal Engine offers configurable lag compensation that studios tune per title rather than shipping a single default, which is why a Call of Duty title on the IW engine can feel different from an Unreal Tournament match running on the same conceptual approach. Riot’s Valorant and Blizzard’s Overwatch lean on deterministic rollback techniques borrowed from fighting-game netcode, where the server and clients simulate the same inputs in lockstep and roll back to a consistent state on disagreement.
The shared goal is a consistent feel, but each engine makes a different bet on where the fairness trade-off should land. Source-style rewind is cheap to implement and easy to reason about, while rollback is more expensive computationally but produces spectacular hit registration in twitchy 5v5 formats, which is exactly the design space Valorant and Overwatch 2 occupy.
| Engine or Game | Compensation Style | Rewind Cap | Tick Rate |
|---|---|---|---|
| Source (Counter-Strike 2) | Server-side rewind | ~200 ms | 64 / 128 Hz |
| IW engine (Call of Duty) | Server-side rewind with prediction | ~250 ms | Variable |
| Valorant | Deterministic rollback | Implicit, frame-based | 128 Hz |
| Overwatch 2 | Deterministic rollback | Implicit, frame-based | 128 Hz |
Practical Signals That Reveal Lag Compensation at Work
Recognizing the mechanic in your own matches is the fastest way to debug frustration during a session. A kill confirmed on the killcam even though the target was already behind cover indicates a rewind registered the shot from an earlier snapshot. Enemies who appear to stand still for a fraction of a second may be experiencing a reconciliation correction after the server overruled their predicted motion. Frequent “I shot first” deaths, where you clearly fired first and still lost, suggest your ping is stretching the server’s rewind cap to its limit.
Run through this short checklist the next time a match feels off:
- Check the killcam geometry. If the bullet path passes through a wall on your replay, the rewind pulled a hit that physics would have denied.
- Watch for micro-freezes on opponents. A visible snap or stutter on an enemy is reconciliation in action, not lag on your end.
- Compare your ping to the kill feed. Deaths where you fired 100 ms before a 200 ms opponent landed on you point at the rewind cap working against you.
- Test alternate servers. Switching to a closer region often reduces the gap between your local clock and the server’s clock enough to make the same gunfights feel tighter.
Bottom Line
Lag compensation is the quiet agreement between your client and the server that the shot you saw is the shot that counts, even if the trip took 80 milliseconds. The server rewinds stored positions, runs hit detection on the world as it existed when you pulled the trigger, then broadcasts the result to everyone. The price of that convenience is a small but real advantage for the aggressor, which is why rewind caps, tick rate, and anti-cheat heuristics all sit on top of the system. Once you can read the signals, the mechanic stops feeling like the game cheating you and starts looking like the trade-off it actually is.
FAQ
What is lag compensation in online shooters?
That the server’s method of rewinding stored player positions to the moment you fired, so hit detection runs against the world you saw rather than the server’s delayed view. It exists to keep hit registration honest across ping differences of 30 to 200 milliseconds.
How does lag compensation actually work on the server?
The server tags your shot with a client-side timestamp, pulls each player’s position from a short history buffer for that exact moment, and performs a line trace through that older snapshot. If the trace hits a hitbox, the server confirms the kill and broadcasts the result to every client in the match.
What is rewind time and how is it calculated?
Rewind time is the gap between the current server tick and the timestamp stamped on your shot packet, and most Source-engine titles clamp that figure to a hard ceiling of 200 ms. The cap exists to prevent high-ping attackers from landing hits on players who were never visible to them at the same instant.
Why does tick rate matter for lag compensation?
Tick rate controls how fresh the server’s stored positions are, with 128 Hz producing snapshots every 7.8 ms and 64 Hz producing them every 15.6 ms. Higher tick rates shrink the worst-case rewind error and make hit registration more consistent, which is why competitive shooters run 128-tick servers.
What is peeker’s advantage and how does it relate to lag compensation?
Peeker’s advantage is the bonus a high-ping player gains because the server rewinds the target’s position to a moment when they were still exposed. A 150 ms player effectively exists for an extra 150 ms on the server before the opponent sees them disappear around a corner.
How do Valve, Riot, and other devs implement lag compensation differently?
Valve’s Source engine uses a fixed rewind cap of roughly 200 ms, Riot’s Valorant and Blizzard’s Overwatch 2 use deterministic rollback borrowed from fighting-game netcode, and the IW engine behind Call of Duty blends rewind with heavier client-side prediction. Each approach trades CPU cost against consistency in a different place.
