A networking method that runs on every single frame, rollback keeps your local fighting game moving without pausing to wait for your opponent’s controller input. The moment your rival’s data finally arrives, the game rewinds a few frames, applies the correct input, and resimulates forward in a single tick. That short rewind is hidden behind prediction and frame interpolation, so you almost never see the correction.
Here’s a quick look at how modern fighting games stay smooth across the internet, and what every competitor should understand about prediction, resimulation, and the tradeoffs that come with the technology.
The Core Idea Behind Rollback Netcode
Two players sit on opposite sides of the country, each holding a controller, and both expect every button press to land the instant they tap it. Older networking methods failed at exactly that task, which is why rollback now sets the baseline for any serious online fighter.
Your console runs a complete, self-contained simulation of the match on your side. When your opponent’s next input fails to arrive before your next frame is ready to draw, the game picks its best guess, renders the frame, and keeps moving. The instant the real input shows up over the wire, the engine compares it to the guess, rewinds to the frame where the input should have been, and resimulates everything from that point forward. Any visual difference between the guess and the corrected state is masked for a few frames, so a single misprediction rarely registers as more than a faint twitch on screen.
What Actually Gets Resimulated
Every object in play, from your fighter’s health bar to a fireball halfway across the screen, gets recalculated from the rewound frame forward. That sounds expensive, but a well-built rollback engine only resimulates a handful of frames (usually 3 to 8) so the work stays light. Modern CPUs handle this resimulation in under a millisecond, which is why the technique scales well even on older hardware.
Why Responsiveness Wins Over Pixel Perfection
Fighting games live and die by the gap between pressing a button and seeing the result. Delay-based systems accept input lag as the price of perfect sync, which drags every interaction toward sluggish. Rollback accepts a brief visual hiccup as the price of zero added input lag. For a genre built on 1-frame combos and frame-perfect parries, that trade has never really been a contest.
How Rollback Actually Works Under the Hood
The whole technique rests on a single demand: both players must run a fully deterministic game. Same inputs on the same frame must always produce the same result, down to the last pixel. No floating-point drift, no unsynced random seeds, no hidden timers reading your local clock. When that rule holds, the rewound simulation on each machine arrives at the same game state, and the match stays in lockstep.
The Role of Input Prediction
The local machine predicts the opponent’s next input the instant a frame is ready to render. Most engines default to “repeat the last known input,” a surprisingly accurate guess because players often hold a direction or mash the same button. The prediction is cheap, often correct, and means the rendered frame never has to wait on the network.
When Predictions Miss
When the real input finally arrives and disagrees with the prediction, the engine rewinds to that frame, applies the correct input, and resimulates the next several frames in one tight tick. Mispredictions are the only thing that produces visible artifacts, and good netcode keeps the resimulation window short. The shorter the window, the less the engine has to fix, and the rarer the glitches you actually see.
Tip: A rollback implementation that resimulates only 3 to 4 frames feels almost identical to local play on a decent connection. Past 7 or 8 frames, artifacts start to pile up and the experience degrades fast.
Rollback Versus Delay-Based Netcode
Two philosophies compete for every online fighting game released, and the difference between them shapes how every match feels at the controller level.
| Factor | Rollback Netcode | Delay-Based Netcode |
|---|---|---|
| Input lag added | Near zero | Fixed buffer (often 3 to 8 frames) |
| Visual smoothness | Brief corrections on mispredictions | Always smooth, never corrects |
| Behavior on clean connections | Feels like local play | Feels one step behind |
| Behavior on poor connections | Responsive with occasional visible glitches | Sluggish but visually clean |
| Implementation cost | High (requires deterministic engine) | Low (just buffer the inputs) |
| Competitive preference | Strongly preferred by the FGC | Mostly retired for fighters |
Delay-based netcode holds every player’s input for a fixed number of frames so both sides see the same game state. The buffer is sized for the worst expected ping, which guarantees sync but taxes every interaction with a flat tax of lag. Rollback adds almost no delay at all, accepting rare visual corrections as the cost of immediate response.
Neither approach is perfect, and the choice reflects a developer’s tolerance for lag versus visual noise. For fighting games specifically, the math has spoken: responsiveness beats visual purity every time.
That math, however, only became practical once a working implementation made rollback cheap enough for smaller studios to adopt.
GGPO and the Rollback Revival of the 2020s
Most of the rollback implementations shipping today trace their DNA back to a single open-source library. GGPO, created by Tony Cannon in the mid-2000s, became the foundation for an entire generation of fighting game netcode, and its influence only grew once the pandemic forced the FGC indoors.
The Pre-Rollback Dark Ages
For years, GGPO lived mostly in indie titles and community mods. Major publishers treated online play as a console feature, not a competitive one, so flagship fighters shipped with delay-based code that punished anyone with above-average ping. Skullgirls and Them’s Fightin’ Herds used GGPO directly, but the rest of the genre lagged behind.
The 2020s Shift
COVID-era online tournaments and growing player demand pushed studios like Arc System Works, NetherRealm, and Capcom to adopt rollback in flagship releases. Guilty Gear Strive, Mortal Kombat 11, and The King of Fighters XV all leaned on GGPO-derived or GGPO-inspired middleware. Capcom went further, patching rollback into Street Fighter V years after launch and building it into Street Fighter 6 from day one.
The revival turned rollback from a niche technical term into a baseline expectation. A new fighting game shipping without it now draws immediate community criticism, and the bar for any online experience has permanently shifted.
The Honest Tradeoffs Players Actually Feel
Rollback feels like magic until it doesn’t, and the moments it stumbles are worth understanding before you blame your router.
Visual Artifacts Scale With Connection Quality
Brief teleports, projectiles vanishing for a frame, characters popping back a few pixels: those are the classic rollback symptoms, and they show up more often as your connection worsens. A misprediction forces a resimulation, and the more frames the engine has to fix, the more visible the correction. On a clean wired connection, you might see a glitch once every few matches. On a Wi-Fi connection with a spotty router, you might see one every few seconds.
CPU Spikes During Heavy Resimulation
Older hardware or unoptimized builds can suffer frame drops when the engine has to resimulate many frames at once, especially in games with dense particle effects or many on-screen objects. Modern implementations use prediction and short rollback windows to keep this rare, but it still shows up in fighters with elaborate super animations.
Desyncs Are Rare but Real
A desync happens when two simulations drift out of alignment and the match is no longer playing the same game. Determinism bugs, mods, or extreme network corruption can trigger them, and the standard fix is a match restart. Modern rollback code includes integrity checks to catch drift early, but the failure mode still exists.
Heads up: Rollback is not magic, and packet loss above roughly 5 to 10 percent will degrade almost any implementation. No amount of netcode can fully compensate for a connection that drops data on the regular.
Why Competitive Communities Still Choose Rollback
Competitive players tolerate brief visual hiccups because consistent responsiveness outweighs the occasional glitch every time. A 4-frame input delay ruins neutral, makes combos inconsistent, and turns every match into a coin flip on the worst connection in the lobby. A brief teleport mid-round is a small price for inputs that land when you press them.
Getting the Most Out of Rollback in Practice
You can tune your setup to give any rollback implementation its best shot at staying invisible. Most of the wins come from cutting jitter, the small unpredictable delays that force the engine to mispredict and resimulate.
Connection Setup Checklist
- Use wired ethernet: Wi-Fi introduces jitter that rollback has to constantly correct, even when your measured ping looks fine.
- Open the required ports: Each fighting game lists specific UDP ports in its docs; forwarding them cuts routing hops and reduces packet delay.
- Favor a moderate NAT type: Strict NAT often blocks direct connections, forcing traffic through relay servers that add latency and packet loss.
- Match the rollback frame setting to your hardware: Higher values tolerate more lag but burn more CPU and memory; tune it to your rig.
- Read rollback corrections as feedback: A brief teleport on your opponent’s character means the engine just hid a misprediction, useful information rather than a bug.
Choosing New Games With Rollback in Mind
Treat rollback as the new baseline when evaluating any new fighting game, and weight the online experience heavily in your buying decision. Check community netcode reviews, look for GGPO or GGPO-derived middleware, and ask whether the developer has a track record of patching online play post-launch. A beautiful roster means nothing if you cannot find clean matches at your skill level.
Even with the best netcode in place, a few practical habits separate smooth sessions from rage-quit nights.
Bottom Line
It solves the one problem fighting games cannot tolerate: input lag, which is exactly why rollback has earned its strong reputation. By running a local simulation, predicting opponent inputs, and resimulating only when predictions miss, it delivers near-instant response at the cost of a rare visible correction. The technique demands deterministic engines, but libraries like GGPO have made it accessible enough that modern flagship fighters ship with it as a default. Your setup and your game choice decide how invisible the corrections stay.
FAQ
What is rollback netcode in fighting games?
It is a networking method that runs each player’s simulation locally and only corrects when opponent inputs arrive late. It favors input responsiveness over pixel-perfect sync, which is why competitive fighting games have adopted it almost universally.
How does rollback netcode work?
The local machine predicts the opponent’s next input, renders the frame, and keeps playing. When the real input arrives, the engine rewinds to the correct frame, reapplies the input, and resimulates forward. Mispredictions are hidden behind a few frames of visual smoothing.
What is the difference between rollback and delay-based netcode?
Delay-based netcode buffers every input by a fixed number of frames to guarantee sync, which adds flat input lag. Rollback adds almost no input delay but accepts brief visual corrections when predictions fail.
Which fighting games use rollback netcode?
Modern flagships like Guilty Gear Strive, Mortal Kombat 11, The King of Fighters XV, and Street Fighter 6 all use rollback. Older titles including Street Fighter V and Skullgirls have received rollback patches or community updates in recent years.
Why is rollback netcode better for fighting games?
Fighting games depend on frame-perfect inputs and reactive defense, both of which collapse under even small input lag. Rollback keeps the response tight, which is why competitive communities strongly prefer it.
What is GGPO?
GGPO is an open-source rollback middleware created by Tony Cannon in the mid-2000s. Most modern rollback implementations, including those in flagship fighting games, trace their lineage to GGPO or build directly on top of it.
