Beating Super Mario World in 41 Seconds by Reprogramming It From Within

Imagine sitting down to beat a game that, played normally, eats up hours of jumping, dodging, and dragon-riding. Now imagine finishing it in about 41 seconds — not by playing faster, but by reaching into the game's brain and rewriting it from the inside. That is exactly what the Super Mario World "credits warp" does. The current world record, held by Brazilian speedrunner FURiOUS (Matheus Furtado), clocks in at 41.022 seconds, set on 11 June 2020 and recognized by Guinness World Records. He spends more time clicking through menus than actually playing a level. The trick behind it is one of the most beautiful pieces of accidental hacking in gaming history.

A game that runs on RAM it shouldn't

To understand the warp, you need one idea: a console doesn't really know the difference between "data" and "code." Both are just numbers in memory. A little pointer called the program counter walks through memory, picks up the next number, and does whatever that number tells it to do. Normally the program counter only ever walks across the chip that holds the actual game — the cartridge ROM. The genius of Arbitrary Code Execution, or ACE, is convincing that pointer to go for a walk somewhere it was never meant to: into the working memory (RAM) that the game uses to track Mario, the enemies, and everything on screen.

If you can steer the program counter into RAM, and you can control what numbers are sitting in that RAM, then those numbers stop being game state and become instructions. You are no longer playing Super Mario World. You are programming it, live, with a controller, while it runs.

The Chuck that Yoshi was never supposed to swallow

Here is where it gets gloriously absurd. In Super Mario World, Yoshi can gulp down most enemies — but he is not supposed to be able to eat a Chargin' Chuck, the helmeted football-player enemy. There is no code for "what happens when Yoshi eats a Chuck," because the designers never imagined it could happen.

Speedrunners force it anyway. Using a coin-eating glitch, they get Yoshi to hold an "empty" sprite — the game knows his mouth is full but has no idea of what. A Chargin' Chuck then spawns into that empty slot, and the game suddenly believes Yoshi is chewing a Chuck. When it tries to handle this impossible event, it looks up a response in a table — and finds nothing. The program counter falls off the edge of the map into "open bus," reading the last value left on the memory line ($01). That stray byte becomes the first instruction of a brand-new program, and the program counter starts marching through RAM.

Writing code with the position of sprites

So what's in that RAM? This is the part that feels like magic. The console keeps a table of every sprite's X coordinate — basically, how far left or right each enemy and shell is on the screen. The credits warp turns that table into a tiny program.

By placing Koopa shells, egg shards, and stun-splat animations at precise horizontal positions, the runner is literally writing bytes. The X position of a shell here, the spot where Mario turns around there, the exact pixel where he stands on the frame before Yoshi swallows the Chuck — each of these becomes one number in the program the console is about to run. Get them lined up in the right order and the resulting "code" is a single, deliberate command: jump straight to the address of the end credits. The game obeys instantly. The screen fades, the music swells, and the credits roll — a full adventure compressed into a handful of carefully parked sprites.

Why this is harder than it looks

You might think the hard part is the theory. It's not — the theory was reverse-engineered years ago by people poring over disassembled ROM. The hard part is doing it with your hands, at full speed, with frame-perfect precision. The X position of Mario on the single frame before he's eaten gets baked into the code, so being one pixel off corrupts the program. A version of this trick famously requires plugging in extra controllers with buttons held down by rubber bands, because the values on those idle controller ports also get read as part of the code being assembled.

Pioneered in 2015 by SethBling — who first crawled to the credits in 5 minutes 59 seconds — the technique has been refined relentlessly. Each new discovery shaved off seconds, dropping from minutes to a single minute to the sub-42-second runs of today. What started as a curiosity became a precision sport.

The kicker

There is something poetic buried in this stunt. The people who do it aren't cheating the game; they are demonstrating a profound truth about all computers — that the wall between "what a program is" and "what it's working on" is thinner than we like to believe. A red shell parked at the right pixel is, to the machine, indistinguishable from a line of code. Mario's creators built a cheerful platformer about a plumber and a dinosaur. Hidden inside it, all along, was a tiny programmable computer waiting for someone clever enough to feed it a Chuck.