The History of Rollback Netcode, aka GGPO, bka Client-Side Prediction
You don't need data centers to predict the future when you have rollback!
If it took your hand a second to move every time your brain told it to, you’d probably be freaked out. Imagine how hard it’d be to eat soup like this. You’d lift the spoon without feedback on your speed or force—maybe it’d go up an inch? Maybe it’d fling into your face? Hope it was a cold soup like gazpacho! Imagine how dangerous driving a car like this would be.
In the world of online gaming, this has unfortunately been the norm for quite some time. Here in the US, I have about 20ms before my machine is talking to faster infrastructure. That means if I’m playing a game online with my next door neighbor, we’ve got 40ms of lag between us plus whatever the server generates. Not every game uses delay-based netcode—but for the action-heavy ones where things need to feel instantaneous, I’d rather just carry my setup down the street!
Smart minds have been knowing about this issue—one of the earliest developers to crack the code and simulate lagless interaction was John Carmack, the lead programmer at id Software (and one of the Masters of Doom.)
Server Authority and Prediction
For PC gamers in 1996, Quake was the most important title to release. Designed around fully 3D environments and fast-paced rocket fire, it’s campaign was considered a masterpiece. When taking the game online however, it was nearly unplayable over a standard dial-up connection. Recognizing that that world’s internet infrastructure would not improve fast enough, John Carmack re-engineered Quake’s multiplayer by introducing QuakeWorld—a host of dedicated servers running his latest invention—Client-Side Prediction and Server Reconciliation.
Instead of using delay to get two networked copies of a game running in sync, each game assumes it always in sync, showing the player their own actions the moment they input them and having the server guess at what their opponent is doing next.
This predictive model is a lot more basic than you might imagine. Here’s how it works:
If you guessed Still holding forward, you’d be thinking like Carmack’s predictive model. The game has no reason to believe you’ll be doing anything in the future that you weren’t already doing a moment ago.
Suppose the guess is wrong and the delay doesn’t know this for 50ms, or ~3 frames. Simple—it changes what the players sees to be 3 frames deep on that action’s animation (like firing a weapon) and tells the game logic to overwrite itself with this updated occurrence. To make this jump in visuals less perceptible, your game interpolates (a fancy word for ‘smooths out’) the tiny bit of audio/visual queues you might have missed. From most players perspective, this change is imperceptible.
This paradigm worked exceptionally well for first-person shooters because human movement in a 3D space is continuous and highly predictable. However, it had a major caveat: players were always looking at a slight past representation of their opponents. This is where ideas like leading your shots comes from—like Yancy told Fry, ‘you wanna fire at where they’re going to be, not where they are.’'
Fighting Games & the Genesis of GGPO
Arcades where the original source of multiplayer for fighting games. Consoles had arcade-quality ports as early as the 90s with titles like Street Fighter 2—but without online support, you still had to go to the arcades to get quality practice. Then came Xbox Live and the possibility of competing like you would in the arcades but at home became a real vision. Unfortunately, many of the leading fighting game developers from the home console era hadn’t figured out how to provide this provide this prediction netcode to their games and so any players trying to go online with their skills had to learn how to play around the lag.
In 2006, Capcom released a Street Fighter 2 port onto the Xbox Live Marketplace. It used the same ol’ delay tactics as the other titles and fans were met with an unplayable experience. Variable latency constantly altered the timing of combos, turning a game of sharp reflexes into a sluggish guessing game.
Tony Cannon, a programmer and co-founder of the Evolution Championship Series (EVO), recognized that fighting games required a completely different approach to prediction. Unlike a shooter, a fighting game client cannot simply interpolate an opponent’s position or guess their trajectory; every frame of an animation dictates hurtboxes, invincibility frames, and collision states. Cannon’s solution was a peer-to-peer predictive architecture called GGPO (Good Game Peace Out), introduced in late 2006, which laid the foundation for Rollback as we know it today.
The key difference between Carmack’s model and Cannon’s model was that in a fighting game, the changes need to happen instantly. Because animations and game states are so layered and intricate, making this work required a strict division between game logic and visuals. You can’t just interpolate a character into the correct position—they need to be snapped into the exact frame and moment in the game’s logic, with all the missing inputs correctly and retroactive applied.
Despite GGPO proving as early as 2007 that a match played across a continent could feel like a local arcade experience, mainstream adoption faced immense resistance for over a decade. This was particularly true among Japanese developers, who dominated the fighting game market. Living in a geographically small country with dense, low-latency fiber-optic infrastructure, developers in Japan did not feel the sting of delay-based netcode as much as the international player base.
However, the resistance was not entirely cultural; it was deeply technical. Rollback netcode can’t be dropped into an existing game, it needs complete separation between logic and visuals. If a game has thousands of unoptimized visual assets tied directly to its physics loops, attempting a rollback will cause massive performance drops, audio glitches, and visual tearing. Retrofitting a game built for delay-based infrastructure requires tearing out the foundational architecture of the software—a costly, high-risk engineering endeavor that many studios were reluctant to fund.
… then the pandemic happened
The turning point for client-side prediction came through a combination of open-source altruism and global necessity. In October 2019, Tony Cannon made the core GGPO library open-source under the MIT license. This removed a HUGE licensing barrier, allowing indie developers and engineers worldwide to study and implement the core rollback algorithms freely.
Who would know that just a few months later, Covid would altered the gaming landscape overnight.
Local tournaments and arcades shut down indefinitely. Games relying on delay-based netcode saw their communities collapse, as playing outside of one’s immediate city was functionally impossible. The demand for robust rollback netcode shifted from a niche enthusiast talking point to a commercial necessity for survival.
This era witnessed extraordinary community-driven engineering feats. In 2020, an independent developer named Jas “Fizzi” Laferriere single-handedly introduced a custom rollback netcode infrastructure called Slippi to Super Smash Bros. Melee. When talking with Woolie Madden on his Twitch stream, Fizzi reveals that majority of the work needed to implement rollback into Melee was already done when the game launched. Lightning Mode, a bonus gameplay mode that plays the game extremely fast, had already created that division between logic and visuals. This was the foundation Fizzi relied on when writing the Rollback code. did not long after, he mentioned how none of his work would have been possible if it weren’t for one Melee’s many alternate fighting modes. Upon release, Slippi proved that if a highly complex, analog-heavy game from two decades prior could be modernized, there was no longer any excuse for contemporary titles.
Conclusion
Today, the principles of client-side prediction and rollback have achieved total victory across the landscape of competitive multiplayer games. From arcade fighting games like Street Fighter 6 and Guilty Gear Strive to physics-heavy titles like Rocket League, modern network engineering is built on the reality that the internet will never be perfectly stable.
The evolution of netcode is a testament to the power of predictive software design. By treating latency not as a barrier that forces a game to freeze, but as a statistical variable to be predicted, reconciled, and corrected in the background, engineers found a way to outrun the physical limitations of networks. Multiplayer gaming no longer requires players to wait for the world to sync; instead, our machines quietly guess the future, rewriting the past so smoothly that we never even notice the seams.