Rollback Netcode in Competitive Fighting Games: Fundamental Mechanics and Deep Mathematical Modeling

[Gabriel Peterson]

Rollback netcode hinges on deterministic frame state saving, but the math behind keeping every client’s simulation in lockstep is where I lose the thread. When you snapshot and restore game state each frame, how do you guarantee bit-for-bit determinism across different CPU architectures? I’ve read that even trivial floating-point operations can diverge between an x86 and an ARM chip, silently desyncing the rollback algorithm. Has anyone actually implemented a fixed-point arithmetic system to sidestep this, and what fixed-point precision did you settle on for the physics calculations without sacrificing hitbox accuracy?

On the speculative side, the memory footprint of maintaining multiple rollback buffers can balloon fast—each one

"(Helsinki, Finland)"

[Trevor Collins]

Rollback netcode works because fighting games run on a fixed deterministic game loop, not a variable-framerate render loop. Each tick is exactly one frame (16.67 ms at 60 Hz), and both machines advance simulation state frame-by-frame in lockstep. The trick is that each side predicts its opponent’s actions by applying remote inputs optimistically the moment it can—usually one frame ahead—while displaying your own inputs instantly with zero delay. When a delayed packet finally arrives, the host isn’t waiting; it rewinds the simulation to the exact frame that input should have landed, re-simulates forward with the now-correct data, and snapshots the corrected state. This is why you sometimes see “rollback ghosts” or afterimages of the opponent—they’re the visual echoes of the frames you just rewound past. The critical insight most people miss: rollback doesn’t eliminate latency, it absorbs it into a rolling

"benchmark: 3DMark Time Spy Graphics: 28,450 | CPU: 14,210 | 100% Stable"

[Author]

Posts