How AI Is Decompiling Classic Video Games in Days, Not Years
AI agents are decompiling games like Snowboard Kids and rebuilding classics like Super Mario World in days. Here's how the process works.
What does it mean to decompile a game?
Decompiling a game means taking the machine code a console or PC actually runs and working backward to recover something resembling the original source code. A programmer writes source code that humans can read and edit. A compiler turns that into machine code, the efficient but unreadable instructions a computer executes. Decompiling reverses that process: you know what the program does (Mario jumps when you press a button), but you don’t know the exact code that produces that behavior. You have to guess, test, and refine until the behavior matches.
This used to take fan communities years. The decompilation project for Super Smash Bros. Melee, for instance, has been an ongoing, multi-year effort involving a large volunteer team. Now, AI coding agents are compressing that timeline dramatically, with some game decompilation projects going from years of manual effort to weeks or even days.
TL;DR
- Decompiling reverses compiled machine code back into readable source by guessing code, testing it against the real game’s behavior, and refining until it matches.
- The recreated code is never identical to the original because compilers strip comments, rename variables, and simplify logic (for example, turning “2 + 3” into just “5”) during the original compilation.
- Decompilation is a near-perfect fit for AI because it’s a verifiable loop: an agent writes code, checks whether it reproduces the target behavior, and repeats without fatigue until it succeeds.
- A developer named Chris Lewis decompiled the N64 game Snowboard Kids, cutting a project that once took him nearly two years down to 84 days using AI assistance.
- Game mashups (Mario in Elden Ring, skateboarding in Call of Duty) rely on a spectrum of techniques, from simple asset swaps to full pass-through mods that run two game engines simultaneously, to AI rebuilding mechanics or entire rule systems from scratch.
- The same loop logic that works for decompiling games is being applied to recreating general software (an open-source Photoshop clone called Photo Craft) and even to unsolved math problems, suggesting that any task with a checkable right answer is now within reach of AI agents.
- If software’s only defensibility was the code itself, that moat is weakening. Value is shifting toward services, support, and the parts of a product that aren’t easily copied.
Why does AI make decompiling so much faster?
Decompiling has always been a guess-and-check process. You write a candidate piece of code, run it, and see if it reproduces the known behavior. If it does, you move to the next chunk. If not, you try again. That loop structure, something with a clear, verifiable goal, is exactly the kind of problem AI coding agents handle well.
Several factors compound to make this faster than human-only teams:
- Parallelization. Instead of one person or a small team working through a game function by function, chunks of the task can be split across many AI agents running at the same time.
- Raw coding speed. AI agents generate and test code far faster than a human writing and debugging by hand.
- No fatigue. An agent doesn’t need breaks, sleep, or motivation. It just keeps iterating against the verification target until it converges on a match.
Stack those together and a job that took a human developer roughly two years can shrink to under three months, as happened with the Snowboard Kids decompilation effort led by Chris Lewis.
Why isn’t the recreated code identical to the original?
If AI is working backward from the compiled game to recover the logic, a natural question is why it doesn’t reconstruct the exact original source, down to variable names and comments. The answer is that a lot of that information is permanently discarded during compilation. Comments are stripped out. Variable and function names often disappear or get replaced with generic labels. The compiler also simplifies and rearranges logic for efficiency.
A simple illustration: if a function is written to return “2 + 3,” the compiler may just reduce that to “return 5,” since that’s the only output that matters at runtime. Decompiling that machine code later will recover “return 5,” not the original arithmetic expression. The practical result is the same: the game plays, looks, and behaves identically, even though the underlying code is a different, functionally equivalent implementation rather than a line-for-line copy.
How are people mashing up different games?
Beyond straight decompilation, a wave of game mashup projects (Mario dropped into Elden Ring, Spider-Man swapped into a Batman game, skateboard mechanics layered onto Call of Duty) has shown up online. These rely on a few distinct techniques, increasing in complexity:
- Asset swaps. The simplest approach. One character’s visual assets are replaced with another’s, essentially a skin. The underlying behavior stays the same as the original game; only the appearance changes.
- Pass-through mods. Two games run simultaneously, and a connective layer syncs them. In one example, Minecraft was linked into GTA: the Minecraft engine manages its own blocks and physics, while the mod aligns the cameras, merges the rendered output, and passes events between the two engines, so an explosion in Minecraft triggers a corresponding explosion in GTA’s world.
- Mechanic transplants. A specific behavior, like Mirror’s Edge-style parkour or skateboard physics, gets moved into another game’s engine. Sometimes the original code can be dropped in directly; other times AI studies how the mechanic behaves (without access to its source) and recreates equivalent logic inside the new game.
- Full rebuilds. The most resource-intensive approach: writing a complete replacement for the game’s underlying software by studying what the original does and reimplementing the needed parts. This gives creators the most control over how two games combine, but it’s also the most demanding, and realistically only became practical with AI doing the bulk of the implementation work.
Seven tools to build an app. Or just Remy.
Editor, preview, AI agents, deploy — all in one tab. Nothing to install.
Does this logic extend beyond video games?
Yes, and that’s arguably the bigger story. The same technique used to decompile a game, which is pointing AI at a piece of software’s observable behavior and having it recreate equivalent functionality without ever seeing the source code, has already been applied to general software. One notable example is an open-source clone of Adobe Photoshop, called Photo Craft, built by someone who pointed AI at a local copy of the real application and had it study and replicate behavior from scratch.
The implication: if this works for a commercial creative tool like Photoshop, there’s no clear reason it wouldn’t work for other paid software products, from Premiere to spreadsheet tools to internal business applications. Any software whose behavior can be observed and verified becomes a target for this kind of recreation.
That has a direct consequence for anyone building a software business: if a product’s defensibility rests solely on “we wrote this code and you can’t,” that protection is weaker than it used to be. Durable value increasingly comes from things that aren’t just code, like ongoing support, enterprise integrations, training, trust, and continuous updates.
Why does this matter beyond gaming and software?
The underlying pattern, give an AI agent a verifiable goal and let it loop until it hits that goal, isn’t specific to decompiling games. It applies to anything with a checkable right answer. That includes mathematics: AI systems have been used to work through open math problems by exhaustively trying approaches, something that doesn’t require creativity so much as persistence and the ability to verify a correct proof once found. It extends naturally to scientific and engineering problems where a correct answer is checkable even if the path to it isn’t obvious upfront, including efforts like Google’s AlphaEvolve project, which analyzed Google’s own infrastructure code and surfaced efficiency improvements with meaningful cost savings at scale.
The common thread across game decompilation, software recreation, and automated math and science research is the same: wherever there’s a way to verify success, AI agents can be set loose to iterate toward it without getting tired or giving up.
Frequently Asked Questions
What is the difference between decompiling and modding a game?
Decompiling recovers a working, readable version of a game’s underlying code by reverse-engineering the compiled machine code. Modding typically works on top of an existing game, swapping assets, adding mechanics, or connecting two games together, without necessarily reconstructing the full original codebase.
Why can’t AI recover the exact original source code of a game?
Because compilation is a lossy process. Comments, original variable names, and certain structural choices get discarded or simplified when source code is turned into machine code, so that information simply isn’t recoverable from the compiled output alone. What AI reconstructs is functionally equivalent code, not a byte-for-byte match.
How long does it take to decompile a game with AI now?
Timelines vary by game complexity, but projects that historically took a couple of years of dedicated human effort have been completed in a matter of weeks to a few months using AI-assisted workflows, and that pace continues to shrink as coding models improve.
Is it legal to decompile and mod commercial video games?
Decompilation and mashup projects discussed in the gaming community typically exist in a legal gray area and often rely on fair use or hobbyist norms rather than explicit permission from publishers. This article describes the technical process; it isn’t legal guidance on any specific project.
Does this mean software companies are no longer valuable?
Not exactly. It means that code alone is a weaker moat than it used to be, since AI can study and recreate software behavior without access to source code. Companies that offer more than just the software itself, like support, integrations, and ongoing updates, remain positioned to hold value even as recreation becomes easier.