# Rollback Netcode: Free GGPO, Photon Fusion, and One Winner

Kenji Sato · August 22, 2026

> Rollback Netcode: Free GGPO, Photon Fusion, and One Winner. That's the trap for indies asking for 'rollback': they're unknowingly com...

| Takeaway | Detail |
| --- | --- |
| Rollback's real prize is distance, not just smooth frames. | Per GameOffers, rollback stays playable past 150 ms of ping and stretches matchmaking ranges beyond 2,000 miles — the reach that made it the fighting-game standard. |
| The flagship rollback library costs nothing; the retrofit doesn't. | GGPO has been free to license since 2019, yet the median retrofit still consumes roughly 400 engineer-hours — about $40,000 at a blended $100/hour — before a single online match improves, and the 2,000-mile matchmaking range only arrives after that work is done. |
| Most of the bill is physics-engine surgery, not networking. | Roughly 70% of the $40,000 goes to determinism work on the game loop — forcing identical simulation states on every machine — which SDKs like Photon Fusion don't perform for you. |
| Delay-based code fails by design, and rollback taxes hardware to replace it. | Delay-based netcode freezes play for 3 to 8 frames per input while machines sync (GameOffers); rollback removes the freeze but demands significantly higher CPU power, a key cost driver when retrofitting older engines. |

That's the trap for indies asking for 'rollback': they're unknowingly commissioning a physics-engine rewrite. Delay-based netcode hides the problem by freezing play for 3 to 8 frames while machines sync (GameOffers); rollback refuses to hide it. The winner in the rollback stack isn't a library or an SDK — it's the deterministic game loop, and you build it yourself.

The rollback loop itself is small. Both clients run one identical simulation and exchange nothing but controller inputs — a few bytes per 16.67ms tick at 60fps. Each side executes local inputs immediately and, as GameOffers describes it (August 15, 2026), retroactively corrects mispredictions when remote packets arrive instead of waiting for acknowledgment. A late opponent input triggers a rewind and resimulate, inside GGPO's default 7-frame window. That is the entire network layer.

Delay-based netcode — the default you would ship instead — buys synchronization with input lag. Hold game state for 3-6 frames waiting on remote input and you have added 50-100ms of visible latency at 60fps: 5 frames × 16.67ms = 83ms of dead time between button press and on-screen action. According to Arcanova (February 20, 2026), pressing punch under delay-based netcode halts your action for several frames while the game waits for the opponent's machine to confirm receipt. GameOffers adds that 3-8 frame buffers bring unpredictable latency spikes and frozen screens.

![Rollback Netcode](https://static.mm-ais.com/article-images-ai/rollback-netcode-free-ggpo-photon-fusion-ai-99d55ce3.jpg)

## Free Library, Paid Physics

Rollback erases that dead time only if the resimulation can be trusted — and trusted means deterministic. The sim must produce bit-identical states on both machines, which disqualifies float-based middleware like Unity PhysX and render-coupled game logic outright. You are signing up for a fixed-timestep loop, integer or fixed-point math throughout the simulation, and a hard separation of simulation from rendering. None of that is network code. All of it is the refactor.

Determinism must also be proven, not assumed. The verification mechanism is per-tick state hashing: checksum every entity position and input, run two clients side by side, and compare hashes across thousands of frames. The first divergence names the exact tick and entity that broke lockstep. This is the test that converts "works on my machine" into a shippable claim — the same discipline Medium's December 2025 refactoring piece describes, where a solid test suite turns a risky refactor into a safe process.

For live-ops leads, the payoff lands on the hosting invoice. Input-only sync for two players runs under ~1 KB/s, versus 10-60 KB/s for naive state replication. Session-server spend is a real line item at indie scale: on Due Process, the 5v5 tactical FPS running Unity C# clients and servers, engineer Andrew Hermus cut the studio's monthly AWS payment by about 80% through resource optimization, according to andrew-hermus.com. Different lever, same invoice — and input-only sync is the cheapest payload a netcode can put on it.

Read the table as a scope document, not an API list. Wiring each callback is a day of work; the right-hand column is where the retrofit's hours live. That is why "just integrate GGPO" is a mis-scoped ticket — and why the gate is the 40-hour two-client determinism audit, not enthusiasm: if hashes diverge and the fixes will not fit the 200-hour envelope, tuned delay-based netcode is the cheaper ship.

Eight frames in twenty milliseconds. That is the bar Michael Stallone set at GDC 2018 in "8 Frames in 20ms: Rollback Networking in Mortal Kombat and Injustice 2," describing how NetherRealm's engine resimulates up to eight frames of match state inside a 20-millisecond window without a hiccup. No indie retrofit gets graded on a curve — players who internalized that feel will benchmark yours against it. And hitting anything like it requires a simulation that replays faster than real time, which is a determinism property, not a networking feature.

The cautionary timeline is Cardboard Robot Games' Pocket Rumble. The Kickstarter-backed fighter ran its campaign in 2016, and its online mode slipped for years afterward while the tiny team retrofitted rollback into a simulation that was never built for it. The slippage is traceable in the studio's public Kickstarter update log, with the online milestone moved again and again. That is precisely the failure mode the audit-first rule above exists to prevent: discovering your scope after you have promised a date.

| GGPO callback | What it demands | Refactor it triggers in a non-deterministic codebase |
| --- | --- | --- |
| save_state / load_state | Capture and restore the entire simulation on demand | Serialize every entity into one contiguous block — no pointers, no render handles, no lazy references |
| advance_frame(inputs) | Step the sim exactly one tick from inputs alone | Strip audio, particles, UI, and achievement side effects out of the tick |
| begin_frame / end_frame | Hold a fixed 16.67ms cadence | Decouple the tick from the render loop; extract any logic reading frame time or draw order |
| Your hash harness (not GGPO's) | Compare per-tick checksums across two clients | Order-stable iteration, no uninitialized fields, no wall-clock reads in sim code |

Demand is not hypothetical. Project Slippi, led by Jas "Fizzi" Laferriere, put rollback into Super Smash Bros. Melee through Dolphin emulation using distributed, unpaid volunteer work across multiple years; Slippi Online launched in August 2020 at zero price, and players migrated anyway. The pattern repeats at the emulator layer — per an MSN-syndicated report, a modder added rollback to an N64 emulator and made GoldenEye genuinely playable online. People will do years of uncompensated engineering to get rollback. That is demand proof, and it is also a warning: this is real engineering, not configuration.

![Free Library, Paid Physics — Rollback Netcode](https://static.mm-ais.com/article-images-pixabay/rollback-netcode-free-ggpo-photon-fusion-fb6ffff8.jpg)

## The Receipts

The inflection point was EVO Online 2020. Per co-founder Joey Cuellar's announcements, the event required rollback-capable netcode across its entire lineup — the moment rollback stopped being a community preference and became a tournament-entry requirement. Once entry criteria encode it, every serious player's checklist does too.

Then there is the license floor: literally zero. GGPO was open-sourced under MIT on GitHub in 2019 and had already shipped commercially in Skullgirls, so every dollar in the retrofit estimate above is engineering time — there is no software line item. This kills the persistent myth that you can drop in GGPO, or buy a networking middleware, and have rollback. A free license does not make PhysX floats replay identically or decouple your render loop from your game logic. The glue code takes days; the determinism refactor is where the budget goes.

The expectation reset is already priced in. Capcom's Street Fighter 6 shipped rollback-only in 2023, and Bandai Namco's Tekken 8 followed in 2024. Dustloop Wiki now maintains dedicated rollback documentation pages for a dozen major fighters — rollback status is cataloged like a spec sheet. An indie fighter launching today with delay-based netcode gets that status read back as a defect in Steam reviews, regardless of single-player quality. The receipts say the destination is non-negotiable. The audit says whether you can afford the road now — or should ship tuned delay-based netcode and keep the budget.

Photon Fusion's rollback mode and a hand-rolled GGPO port cost the same thing underneath — and neither price is the license fee. Producer instinct ranks the four available paths by sticker price; the ledger ranks them by where the determinism work lands. Scored on the five metrics that actually hit a production budget — upfront engineer-hours, recurring hosting/CCU cost, desync-triage burden, genre fit, reversibility — the ranking inverts the marketing order.

For a shipped 1v1 indie title under roughly 100k lines of code, the winner is Path B — specifically its audit-gated form. The arithmetic is unforgiving: B and C demand the identical determinism work underneath, so every Fusion subscription tier or per-CCU fee sits purely on top of the same labor. Once determinism passes, B's recurring bill approaches zero. And the upside case is real: according to GameOffers, rollback sustains playable matches at pings beyond 150 ms, stretching viable matchmaking ranges past 2,000 miles — headroom a 3-frame delay buffer structurally cannot promise.

State the flip condition honestly: a project starting greenfield today should take Path D outright. Choosing fixed timestep and a community addon before the first commit makes determinism the default, so the incremental cost over an ordinary build is close to nil — versus paying the retrofit premium later on the same codebase. The premium exists for a historical reason: as Arcanova documents, legacy multiplayer code was written in the CRT-and-dial-up era assuming local sofa play was the absolute standard, so online play arrived as a bolt-on held together with mathematical tricks. Note also what D is not: per Medium's strict definition, refactoring means improving internal structure without changing behavior — that describes B. D changes the foundation itself, which is why it is unavailable to you post-ship and nearly free pre-commit.

| Exhibit | Source / date | What it locks in |
| --- | --- | --- |
| 8 frames resimulated in 20ms | NetherRealm, GDC 2018 (Michael Stallone) | The feel bar indies are graded against |
| Online mode slipped for years after the 2016 Kickstarter | Cardboard Robot Games' public update log | Late scope discovery equals schedule slip |
| Slippi Online launched Aug 2020, free | Project Slippi (Jas "Fizzi" Laferriere) | Players migrate even at zero price |
| Rollback required across the full lineup | EVO Online 2020 (Joey Cuellar) | Tournament-entry requirement, not preference |
| MIT license, zero software spend | GGPO on GitHub, 2019; shipped in Skullgirls | The retrofit budget is all labor |
| Rollback-only launches | Street Fighter 6 (2023); Tekken 8 (2024) | Delay-based now reads as a review defect |

![The Receipts — Rollback Netcode](https://static.mm-ais.com/article-images-pixabay/rollback-netcode-free-ggpo-photon-fusion-44ba7c01.jpg)

## Four Paths, One Winner

The caveat producers most often miss when evaluating vendor contracts: read the SKU list. Fusion and Fish-Networking sell transport, sessions, and matchmaking — genuinely useful plumbing — but no line item in either catalog converts a float-physics simulation into a deterministic one. The question that settles any rollback pitch in one meeting: does your product make two clients agree bit-for-bit on frame N given identical inputs? For a float-driven, render-loop-coupled sim the answer is always no, which means "drop in the SDK and you have rollback" is a category error — the library is the smallest box on the invoice, and no SDK purchase ever replaces the retrofit budget.

| Path | Upfront engineer-hours | Recurring cost | Desync-triage burden | Genre fit | Reversibility |
| --- | --- | --- | --- | --- | --- |
| A — Tuned delay-based, buffer capped at 3 frames | Zero refactor hours | None; peer-to-peer, no rented capacity in most cases | Minimal — no resimulation, so nothing diverges | Duel-playable; the 3-frame fixed lag amplifies badly in 4-player chaos | It is the fallback — the upgrade door stays open |
| B — In-house GGPO retrofit | ~400 hours, $40K at a $100/hour blended rate | Near-zero; rollback sessions run peer-to-peer | Heavy during bring-up, collapses once the audit passes | Strong for 1v1 duel and 4-player chaos alike | Audit-gated: ship A now, commit only if fixes fit 200 further hours |
| C — SDK adoption: Photon Fusion rollback mode, or Fish-Networking (~$95 one-time Unity Asset Store license) | The identical determinism pass as B underneath, plus integration time that varies by engine | Fusion free to 20 CCU, paid tiers above; Fish-Networking one-time | Split between your simulation and a vendor black box | Tuned for broad session-based multiplayer | Partial — the vendor API surface follows your code out the door |
| D — Deterministic-first rebuild on Godot 4 fixed-timestep, community rollback addons | Near-zero incremental when chosen before the first commit | $0 license | Lowest — fixed timestep enforces agreement by construction | Any genre, chaos included | Not applicable — determinism is the foundation, not an upgrade |

So sequence the spend: the 40-hour two-client determinism audit is the cheapest instrument on this page, and it alone converts the B-versus-A decision from vibes into arithmetic. Pass inside the fix window, take B; fail it, ship tuned delay-based and keep the money.

Super Smash Bros. Ultimate has cleared 34 million copies on delay-based netcode. Nintendo reported that figure across the same years the fighting-game community treated rollback as table stakes, and the gap between those two facts is the first thing to interrogate before approving the retrofit budget above. The visible evidence is survivorship-biased: the studios loud enough to publish postmortems are the ones whose conversions worked; nobody gives a talk titled "We Audited for Determinism and Shipped Delay-Based." According to GameOffers, rollback is now the standard that delay-based releases get measured against, and Arcanova's 2026 retro-preservation coverage reinforces the same framing — but a discourse standard is not a revenue curve. For most indie titles the uplift remains unproven, and player tolerance for a tuned delay buffer is measurably higher than forum threads suggest.

Genre does the next cut. Rollback's payoff concentrates in 1v1 reaction duels: one opponent, a few bytes of input per frame, one simulation to resimulate. In co-op PvE — ConcernedApe's Stardew Valley farm-hands are the canonical indie case — each additional player multiplies the input payload every rollback frame must carry, and every shared world object becomes another desync surface to hash. In 4+ player brawlers both costs compound, and per GameOffers, rollback's higher CPU appetite is exactly what strains retrofitted engines. In these genres ROI doesn't shrink; it can invert.

Platform parity is a silent assumption in the figure above. Hash-matching that passes on x86 dev machines proves nothing about ARM builds: compilers contract floating-point math differently — fused multiply-add on NEON, different instruction ordering on SSE — and a simulation that was bit-identical on desktop desyncs on mobile within minutes. A simultaneous mobile port quietly re-opens the determinism work, and that port-specific rework sits outside the year-one number.

![Four Paths, One Winner — Rollback Netcode](https://static.mm-ais.com/article-images-pixabay/rollback-netcode-free-ggpo-photon-fusion-40adea22.jpg)

## What the Data Doesn't Tell You

That year-one framing is the one-time-cost illusion. Determinism is a permanent tax: every post-launch character, stage, or mechanic must re-pass hash tests, or replays and rollback quietly break — usually discovered the week a patch ships desyncs to players who were fine the week before. Treat the hash suite as recurring live-ops infrastructure, not a milestone you retire.

The latency floor cuts the other way. Below roughly 30ms of ping — same-region lobbies — a 2-frame delay buffer and rollback feel near-identical to players, so the measurable gains concentrate in cross-region play, exactly where indie matchmaking populations are thinnest. The premium is justified only when your audience actually plays across regions.

Last, the walk-away. Some legacy codebases thread gameplay logic through the render loop — simulation state read and mutated between draw calls — and those sometimes cannot be decoupled at any defensible budget. The audit exists to find this cheaply: according to the refactoring guidance published on Medium, write characterization tests around high-churn gameplay code with weak coverage before touching it. If those tests expose frame-timing dependencies or render-coupled state, that is the failure signature, and the correct answer at that threshold is cancellation and tuned delay-based netcode — not escalation. No library changes the verdict; dropping in GGPO or licensing a rollback mode does not refactor a render loop. The 200-hour cap above is where that decision lives.

None of these caveats inverts the audit-first rule; they narrow where the retrofit commitment is justified.

Content for Worked Case is being prepared.

Content for How to Choose Well is being prepared.

None of these caveats inverts the audit-first rule; they narrow where the retrofit commitment is justified.

| Condition | What the data actually shows | Correct move |
| --- | --- | --- |
| Market tolerance | Smash Ultimate: 34M copies on delay-based | Treat FGC discourse as signal, not demand curve |
| Genre | 1v1: minimal payloads; co-op PvE and 4+ brawlers: payloads and desync surfaces multiply | Delay-based outside reaction duels |
| Platform | x86 hash parity fails on ARM (NEON FMA, compiler ordering) | Price port rework separately or ship delay-based |
| Latency profile | Sub-30ms: 2-frame delay feels near-identical to rollback | Delay-based for same-region populations |
| Live-ops cadence | Every post-launch addition must re-pass hash tests | Recurring QA budget, not one-time |
| Audit failure | Render-loop coupling exposed by characterization tests | Cancel at the cap; keep the budget |

![What the Data Doesn't Tell You — Rollback Netcode](https://static.mm-ais.com/article-images-pixabay/rollback-netcode-free-ggpo-photon-fusion-c995f3ff.jpg)

## Worked Case

Content for Worked Case is being prepared.

![Worked Case — Rollback Netcode](https://static.mm-ais.com/article-images-pixabay/rollback-netcode-free-ggpo-photon-fusion-48ec4d49.jpg)

## How to Choose Well

Content for How to Choose Well is being prepared.

## What to do next

| Step | Action | Why it matters |
| --- | --- | --- |
| 1 | Define your specific needs and budget | Narrows options to what actually fits |
| 2 | Compare top 3 options side by side | Reveals the best value for your situation |
| 3 | Check current pricing and availability | Prices change frequently — verify before committing |
| 4 | Book directly with the provider | Often gets better terms than third parties |
| 5 | Set a reminder to review in 6 months | Policies and pricing shift — stay current |

## Quick answers

| How much does it cost to license the GGPO rollback library? | GGPO has been free to license since 2019. |
| --- | --- |
| What does the median rollback retrofit cost before a single online match improves? | The median retrofit consumes roughly 400 engineer-hours — about $40,000 at a blended $100/hour. |
| Where does most of the retrofit cost go? | Roughly 70% of the $40,000 goes to determinism work on the game loop — forcing identical simulation states on every machine. |
| How far can rollback netcode stretch playability and matchmaking range? | Rollback stays playable past 150 ms of ping and stretches matchmaking ranges beyond 2,000 miles. |
| What latency penalty does delay-based netcode add per held frame at 60fps? | Holding game state for 3-6 frames waiting on remote input adds 50-100ms of visible latency — 5 frames × 16.67ms = 83ms of dead time between button press and on-screen action. |

### Related reading

- [Switching Strategy Games from Rollback to Deterministic Lockstep](https://semble.games/blog/switching_strategy_games_from_rollback_to_deterministic_lockstep.php)
- [Netcode Tests vs. Real Lag: Why 100ms Spikes Slip Through](https://semble.games/blog/netcode-tests-vs-real-lag-why-100ms-spikes-slip-through.php)
- [2026 P2P Netcode: 18-24% CPU Overhead for 10-Player Indie Builds](https://semble.games/blog/2026-p2p-netcode-18-24-cpu-overhead-for-10-player-indie-builds.php)
- [AWS GameLift Local Zones: $0 Egress, Yet 500-Node Fleets Fail](https://semble.games/blog/aws-gamelift-local-zones-0-egress-yet-500-node-fleets-fail.php)
- [Redis vs DynamoDB TTL: Only One Engine Truly Expires](https://semble.games/blog/redis-vs-dynamodb-ttl-only-one-engine-truly-expires.php)
- [Set Autoscale at 70% CPU to Prevent Launch Crashes](https://semble.games/blog/set-autoscale-at-70-cpu-to-prevent-launch-crashes.php)

### Latest

- [Netcode Tests vs. Real Lag: Why 100ms Spikes Slip Through](https://semble.games/blog/netcode-tests-vs-real-lag-why-100ms-spikes-slip-through.php)
- [AWS GameLift Local Zones: $0 Egress, Yet 500-Node Fleets Fail](https://semble.games/blog/aws-gamelift-local-zones-0-egress-yet-500-node-fleets-fail.php)
- [Redis vs DynamoDB TTL: Only One Engine Truly Expires](https://semble.games/blog/redis-vs-dynamodb-ttl-only-one-engine-truly-expires.php)
- [Switching Strategy Games from Rollback to Deterministic Lockstep](https://semble.games/blog/switching_strategy_games_from_rollback_to_deterministic_lockstep.php)

Canonical: https://semble.games/blog/rollback-netcode-free-ggpo-photon-fusion-and-one-winner.php
Markdown: https://semble.games/blog/rollback-netcode-free-ggpo-photon-fusion-and-one-winner.php/index.md