How Slippi Gave a 2001 GameCube Game Rollback Netcode It Never Had

Super Smash Bros. Melee was developed by HAL Laboratory and published by Nintendo for the GameCube. It first reached Japan on November 21, 2001, and North America on December 3,

2001. Its multiplayer was local: up to four players sharing one console and one screen. There was no online mode to patch, because the game was never built with one.

That is the first thing to get straight, because everything else in this story follows from it. Slippi did not improve an existing online mode. It added one to a game that had none, and it did so from outside the game, without access to the original source code. The work was reverse engineering plus emulation, not an official update. Slippi is a community project, not a Nintendo product, and nothing in this article should be read as Nintendo endorsing it.

The older approach to online fighting games is delay-based netcode. Both machines wait until they have each other's confirmed inputs, then advance one frame together. When the connection is slow, the whole game waits, and every button press feels late. Dolphin's built-in NetPlay worked this way, and for casual play it was usable. For a game as fast and input-tight as Melee, waiting was the problem itself.

Rollback takes the opposite trade. Each machine acts on its local input immediately, guesses what the opponent is doing, and keeps simulating. When the real opponent input arrives a few frames later, the machine compares it with its guess. If the guess was right, nothing visible happens. If it was wrong, the machine rewinds to the last correct state and replays the corrected inputs up to the present frame. Your own buttons never feel late, because they never waited.

The price is paid elsewhere. A wrong guess that has already been shown on screen must be corrected in public, so a character can appear to snap from one position to another. Rollback implementations usually also keep a small input-delay buffer, so that fewer guesses are wrong in the first place. The art of the technique is balancing those two costs: a little delay to keep corrections rare, and fast correction when they still happen.

Rollback needs three things, and a game console from 2001 was not built to provide any of them on demand. First, the game must be deterministic: the same inputs from the same starting state must always produce the same result, or replaying corrected inputs would land somewhere different. Second, the program must be able to save and restore its full state quickly, many times per second, because every correction is a rewind. Third, both machines must agree on exactly which inputs happened on which frame.

An emulator changes that equation, because it already holds the entire simulated machine in its own memory. The project built on a Dolphin fork called Ishiiruka, and its game-side changes live in a public assembly repository known as slippi-ssbm-asm. In plain terms, small assembly patches injected into the running game report inputs and game events outward, and the emulator core handles the network exchange and the rewind. The game itself never learned to be online. The shell around it learned to rewind it.

Community discussion of the work stresses one practical detail that is easy to miss: simply using the emulator's ordinary save states was not fast enough for frame-by-frame rollback. The team had to find a way to generate game states inside the game itself. This article does not reproduce that mechanism as code, because the public discussion describes the approach without giving a short, verifiable snippet, and inventing one would be worse than omitting it. The honest summary is that state generation, not just prediction, was the hard part.

Slippi did not start as netcode. It was publicly launched on June 18, 2018, after a private beta, and its first release was about replays and statistics: matches were automatically saved as small .slp replay files, and tools could read those files to compute match statistics. A separate console-side build, Nintendont-Slippi, could mirror live console inputs into Dolphin, which let tournaments stream high-quality emulator footage instead of raw console video.

The netcode arrived later. On June 22, 2020, an update to the custom Dolphin build introduced rollback netcode and integrated matchmaking, so players could queue against random opponents without an external website. The timing mattered: in-person tournaments had largely shut down since March 2020, and Slippi became the dominant way to keep competitive Melee alive. The project is led by Fizzi, with major contributions from UnclePunch, Nikki, and metaconstruct, and Fizzi later announced he would work on Slippi full-time.

Matchmaking then grew a memory. On January 19, 2021, version 2.2.4 introduced a hidden matchmaking rating into random unrated matches, narrowing the search range sharply for low-rated players while keeping a wide range for average and stronger players, so new players would not be fed to experts match after match. Later releases kept iterating on the competitive ruleset, including version 3.5.0 in August 2025, which unfroze Pokemon Stadium's transformations. The pattern is consistent: one game, one community, steady small changes, all outside any official update channel.

Slippi is tuned to one specific revision of the game: Melee NTSC 1.02. That is not a preference, it is a requirement of the method. Rollback only works if both machines simulate the same game, and different revisions can differ in ways that break that agreement. If the two simulations drift apart, no amount of rewinding can reconcile them, because each machine is correctly replaying a different game. Pinning one revision is how a community project buys the determinism that an official developer would normally guarantee by shipping one build to everyone.

Rollback is often described as almost lagless, and that phrasing should be treated as a description of feel, not a measurement. It does not make packets travel faster, it does not repair packet loss, and it does not turn a wireless connection with jitter into a wired one. On a bad connection, corrections become frequent and visible, and at some point no netcode can save the match. Players who want the best result still care about connection quality first, because rollback only decides how gracefully the remaining delay is hidden.

The unofficial status also has real consequences. When The Big House Online planned to run Melee online with Slippi, Nintendo sent a cease and desist letter claiming the project infringed its copyrights, and the event was cancelled. SmashWiki records that Nintendo has not proven that infringement claim in court, and the episode fed the FreeMelee movement. The lesson for developers is not legal advice, it is a scope warning: a community retrofit lives at the mercy of the rights holder in a way an officially licensed netcode never does. This article gives no steps for obtaining the game, because the game itself is not part of Slippi, and how a reader sources it is outside what this article teaches.

The earlier model for this whole technique is GGPO, short for Good Game Peace Out, created by Tony Cannon. GGPO predicts the opponent's inputs, simulates without waiting, and on a mismatch rolls back to the last correct state and replays the corrected inputs. Cannon announced on October 9, 2019 that GGPO was open source under the MIT License, after it had already powered online play for games like Skullgirls, Killer Instinct, and Street Fighter III: Third Strike Online Edition.

That history matters, and it must be stated exactly. GGPO is the reference model, and Slippi belongs to the same family of technique. This article does not claim that Slippi ships GGPO code, because no source checked for this article establishes that code lineage, and the two projects are described separately in the public record. What Slippi provably shares with GGPO is the idea: predict, rewind, replay. The Melee-specific half, injecting patches into a 2001 GameCube game and rewinding it inside an emulator, is Slippi's own work.

What this article does not claim. It contains no code, because no short, verifiable code snippet for Slippi's state generation was established from the sources checked, and the article does not pretend to have run or tested any Slippi build. It reports no frame counts, ping figures, or latency measurements of its own. The often-quoted claim that rollback feels almost lagless is treated here as a description of feel, not a measurement. Community discussion mentions a native input-delay detail for Melee on original hardware, but that figure is second-hand discussion, so this article does not assert it as fact. Current launcher version numbers are deliberately omitted, because secondary summaries disagree on them and no single primary release note was verified for this article. Slippi is a community project, not a Nintendo official feature, and this article provides no instructions for obtaining the game.