Every game ships as a finished thing. A sealed codebase, signed off. QA ran their passes. The obvious collision holes got plugged. Enemies got balanced. And then, within 72 hours of the disc hitting shelves, someone is clipping through the final boss door—backwards—while holding a potion nobody even used during testing. That’s not bad design. That’s just what happens when a game leaves the nest and lands in the hands of speedrunners.
I’m Jax Moreno. I’ve been chasing glitched-out leaderboard times since I could hold a controller without dropping the damn thing. I don’t look at games like somebody’s curated tour. I look at them like machines. Beautiful, flawed, exploitable machines. And the real art happens when somebody cracks the machine open in a way the original coders never saw coming.
The Accidental Playtesters
Devs build a game with a mental model of how you’ll move through it. Walk this way. Jump here. Fight that. Watch the cutscene. Speedrunners strip that model down to its bare components immediately. We don’t give a damn about the intended path. We care about the actual path—the one hiding in the physics engine, the memory allocation, those frame-perfect input windows QA never had time to stress-test.
Look at Super Mario 64. The backwards long jump wasn’t some planned feature. It was a side effect. Negative speed values would accumulate when Mario’s movement vector got inverted in specific camera states. Nobody sat in a Nintendo conference room and said, “Let’s let players build infinite velocity and launch through parallel universes.” That trick surfaced because thousands of runners put in tens of thousands of hours grinding the same staircase, over and over, feeling out the exact analog stick angle where the math falls apart. Developers can’t replicate that kind of obsessive pressure testing. They’ve got deadlines. We’ve got obsession.
Speedrunners become the most rigorous QA team a game never paid for. We find seams in the geometry not because we’re hunting bugs, but because we’re hunting a time save. Every wall turns into a question: Can I clip this? Every loading zone is a challenge: Can I skip it? Every enemy’s aggro radius? A puzzle: Can I mess with the AI to move three frames faster? The developer’s intent evaporates the second we start asking those questions. What’s left is raw mechanics, and mechanics don’t lie.
The Language of Exploits
Every speedrunning community builds its own vocabulary for the unintended stuff. We talk about wrong warps, clips, zipping, ACE—arbitrary code execution. These aren’t glitches in the pejorative sense. They’re techniques. They get labbed, routed, and optimized with the same kind of mechanical respect a fighting game player gives a one-frame link. A wrong warp isn’t a mistake. It’s a precise manipulation of the game’s memory pointer so that when you go through a door, the game loads the credits room instead of the next level. That’s not random chaos. That’s reverse engineering by feel.
Think about the Ocarina of Time any% route. For years it meant careful navigation, picking up items, boss fights. Then somebody figured out you could wrong warp from the Deku Tree straight to the Ganon fight using a precise sequence of backflips, bottle swings, and a very specific frame of taking damage. The whole game collapsed into a few minutes of setup. The devs spent years crafting a sprawling adventure. Speedrunners found a backdoor in the memory management and walked right to the final boss. That discovery wasn’t a cheat. It was a deeper understanding of how the Nintendo 64 handles scene transitions than most of the original programmers had.
That’s the thing. Speedrunners often understand the technical guts of a game better than the people who made it. Not because we’re smarter, but because we’re looking at the finished artifact from the outside, with no assumptions about what’s supposed to happen. A developer sees a locked door and thinks, “The player needs the key from the fire dungeon.” A speedrunner sees a locked door and thinks, “What if I can load the fire dungeon’s ‘door open’ flag by backflipping into this torch while taking damage?” The developer built the lock. The runner studies the lock’s code.
When the Community Outpaces the Patch
Modern games get patched. Constantly. Developers spot a speedrun trick, label it a bug, and push an update. Sometimes they’re right—infinite money glitches in an online economy wreck the experience for everyone. But a lot of the time, they’re patching a single-player trick that nobody would ever hit during normal play. The speedrunning community’s response is always the same: we roll back the patch, or we find a new route. The machine evolves. We evolve with it.
Look at Elden Ring. FromSoftware patched the famous “zip” glitch that let players teleport across the map by abusing the animation system. Within days, runners had found new zips. They’d mapped the exact frame windows where the patched code still had vulnerabilities. The developer’s patch just became another obstacle to route around. The game isn’t a fixed text anymore. It’s a conversation between the creators and the most dedicated players, each side probing the other’s limits.
Some of the most legendary discoveries happen because of patches. The Halo 2 speedrun community built entire routes around “sword flying,” which was technically patched out in later versions of the game. So runners kept playing the unpatched disc. They maintained an older version of the machine specifically because it was more interesting than the sanitized one. Developers might see that as a rejection of their fixes. I see it as a recognition that the original, messy code had a depth worth preserving.
The Nostalgia of the Broken
There’s a strange nostalgia that hits watching an old speedrun. Not just for the game itself, but for the specific version of the game where a particular glitch actually worked. I remember watching Pokémon Red runs that used the old man glitch to encounter Mew. That wasn’t just a cool trick. It was an artifact of a specific cartridge revision, a moment in time before Game Freak cleaned up the item underflow bug. The run is a time capsule. The glitch is the artifact.
That nostalgia cuts both ways, though. I get critical of games that ship so polished they leave zero room for happy accidents. A perfectly airtight game is a dead game to a speedrunner. It’s a museum piece behind glass. The games I keep coming back to—the Super Metroids, the Half-Lifes, the Dark Souls—are full of jagged edges. Their developers left gaps in the physics, and those gaps turned into playgrounds. A wall you can clip through with a well-timed jump isn’t a flaw. It’s an invitation.
The critical side of me gets frustrated when modern devs over-patch. Not every unintended interaction needs to be scrubbed out. Some of them become the identity of the game. Wave dashing in Super Smash Bros. Melee was an exploit. Nintendo tried to scrub it from later entries. And yet the competitive community stuck with Melee for two decades specifically because that physics quirk gave the game a movement depth no sequel could match. The developers never intended it, but the community recognized it as mechanically superior to the intended design. That’s the tension at the heart of speedrunning: we’re not just playing the game. We’re editing it through play.
The Respect Mechanics Demand
I treat game mechanics with the same respect a machinist treats a lathe. They have tolerances. They have failure modes. They have undocumented behaviors that only show themselves under extreme conditions. A speedrunner’s job is to map those behaviors, document them, and push them to their limit. When I spend three hours trying to land a frame-perfect pause buffer to manipulate an RNG seed, I’m not cheating the game. I’m having a conversation with its deepest logic.
And the developers? The good ones get it. Some of them leave intentional gaps. Celeste shipped with advanced movement tech the dev knew speedrunners would find—hyperdashing, wallbouncing. Those weren’t bugs. They were gifts. But the truly magical discoveries are the ones nobody left on purpose. The Super Mario World credits warp, where a precise series of inputs writes arbitrary code to the SNES memory using koopa shells and Yoshi’s tongue—that wasn’t a gift. That was a deep, accidental property of the hardware itself, discovered decades after release. No developer planned it. No developer could have planned it. It’s the game’s own language, spoken back to it by someone who listened harder than anyone expected.
So next time you see a speedrun that blasts through a 40-hour RPG in under an hour, don’t call it a glitchfest. Call it mechanical archaeology. The runner didn’t break the game. They read the schematics, found the hidden switches, and revealed what the machine was always capable of doing. The developers built a world. The speedrunners built a map of everything that world actually contains—intended or not.
FAQ
Why do speedrunners prefer older, unpatched versions of games?
Older versions often hold onto exploits that later patches fix. Wrong warps or physics glitches can save serious time and open up routes that are impossible in updated releases. For a lot of runners, the unpatched version is the more interesting version mechanically, even if it’s technically less polished.
Is using glitches in a speedrun considered cheating?
Not inside the speedrunning community, as long as the run sticks to the category rules. Categories like “any%” allow any in-game exploit short of external hardware or cheat devices. Glitches are seen as techniques that demand just as much skill and practice as intended gameplay. Separate categories, like “glitchless,” exist for runners who prefer to steer clear.
Do game developers ever get upset about speedrunning exploits?
Reactions are all over the map. Some devs see exploits as bugs and patch them out, especially in online games where they mess with other players. Others embrace the community’s creativity and leave unintended mechanics alone. A few even design subtle movement options knowing speedrunners will sniff them out. The healthiest relationship is when devs recognize speedrunning as a form of deep engagement, not a problem to solve.
How do speedrunners find new glitches years after a game’s release?
Through community knowledge sharing, brute-force experimentation, and technical analysis. Tools like memory viewers and emulator scripts let runners peek at the game’s internal state. Even without tools, thousands of runners trying thousands of things will eventually stumble onto edge cases. Once a weird behavior gets spotted, the community picks it apart frame by frame until it’s a reproducible technique.
