How AI Is Powering Viral Game Mashups Like Mario in Elden Ring
Mario in Elden Ring, skating in Call of Duty, Spider-Man in Gotham. Here's how AI-assisted modding makes these game mashups possible.
What’s actually happening in these AI game mashup videos?
Clips of Mario running through Elden Ring, players skating through Call of Duty maps, or Spider-Man swinging through a Batman game aren’t simple skin swaps dressed up for clicks. They’re the result of fans using AI coding tools to decompile games, read their behavior, and rebuild pieces of them inside other engines. The common thread across nearly all of these projects is AI handling the grunt work of reverse-engineering software, a process that used to take skilled human teams years and now takes AI-assisted individuals weeks or less.
TL;DR
- Game mashups fall into four distinct technical categories, ranging from simple cosmetic swaps to full engine rebuilds, each requiring a different level of effort and AI involvement.
- Decompiling turns a game’s compiled machine code back into readable, editable source code, and AI can now do in days what used to take human fan teams years.
- Chris Lewis’s decompilation of Snowboard Kids dropped from a nearly two year manual effort to 84 days once AI entered the workflow, and that timeline keeps shrinking.
- Pass-through mods, like the one that put Minecraft inside GTA, keep both games running simultaneously and sync their cameras, physics, and events in real time.
- Mechanic transplants move a specific behavior, like skateboarding physics or parkour, from one game’s engine into another, either by porting code directly or having AI recreate the behavior from observation.
- Full rebuilds recreate a game’s entire rule set from scratch, the most labor-intensive approach but also the one AI enables most dramatically.
- The same decompile-and-rebuild logic is spreading beyond games, with projects already cloning software like Photoshop from observed behavior rather than source code.
Everyone else built a construction worker.
We built the contractor.
One file at a time.
UI, API, database, deploy.
How does AI decompile a video game?
When a programmer writes a game, that source code gets run through a compiler that turns it into machine code, the instructions a computer or console actually executes. Machine code isn’t readable by humans in any practical sense. Decompiling means working backward from that machine code to recover something like the original logic: you know what the game does (Mario jumps when you press a button), but you don’t know the exact code producing that behavior.
Historically, this has been slow, manual, and collaborative. Decompiling Super Smash Bros. Melee has been an ongoing community project for years. The work involves constant guessing and checking: write some code, run it, see if it reproduces the expected behavior, adjust, repeat.
That loop, write, test, verify, iterate, is exactly the kind of task AI coding models handle well. AI doesn’t get tired, doesn’t need breaks, and can run that verification loop continuously. Multiple agents can also work on different chunks of a decompilation project in parallel. The result: projects that once took a dedicated team years can now be done by far smaller groups, or individuals, in a fraction of the time. Chris Lewis’s decompilation of Snowboard Kids is a concrete example, going from a nearly two-year solo effort to 84 days once he brought AI into the process.
One wrinkle worth understanding: AI-decompiled code is rarely identical to the original source. Compilers throw away comments, rename or discard variable names, and simplify logic during compilation (a function that calculates 2 + 3 might just compile down to “return 5”). So when AI works backward from machine code, it reconstructs code that behaves identically but isn’t a line-for-line match. For modding purposes, that doesn’t matter. The game plays, looks, and feels the same, which is all a modder needs.
What are the four techniques behind game mashups?
Once a game’s logic is exposed or understood well enough, enthusiasts combine it with other games using one of a few approaches, increasing in complexity:
Skins and asset swaps. The simplest technique. A character’s visual assets get replaced with another character’s model and textures, but the underlying behavior stays the same. Batman might look like Spider-Man, but he still moves and fights like Batman underneath. This is the oldest and easiest form of modding and doesn’t require much from AI beyond asset generation.
Pass-through mods. Here, two games run at the same time, and a mod builds a live connection between them. Each engine keeps handling its own internal logic (Minecraft manages its blocks and creature behavior, for instance), while the mod synchronizes cameras, merges rendered output, and passes events between the two. In a Minecraft-inside-GTA mashup, when TNT explodes in Minecraft’s engine, the pass-through layer tells GTA’s engine to trigger an explosion in the matching location. Getting wall alignment and physics to agree between two separate engines running simultaneously is the hard part.
Other agents ship a demo. Remy ships an app.
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
Mechanic transplants. This moves a specific gameplay behavior, not the whole game, from one title into another. Think skateboard physics dropped into a shooter, or parkour movement systems from a game like Mirror’s Edge grafted onto an RPG like Skyrim. This requires capturing precise rules: acceleration curves, jump height, how the character collides with walls, and re-implementing them inside the target engine. Sometimes modders can port the source code directly if it’s available. Increasingly, AI is used to study the mechanic’s behavior without access to its code and then recreate an equivalent version in the new engine, something that wasn’t realistically possible before recent coding models.
Full rebuilds. The most intensive option: recreating a game’s entire codebase and rule set from scratch. This means studying the original game closely, figuring out what every system does, and reimplementing the parts needed for the mashup. It gives modders the most control and produces the most convincing results, but it takes the most time and leans almost entirely on AI to be feasible for an individual or small team.
Why is this suddenly possible now?
The short answer is that AI coding models got dramatically better, faster, and cheaper at writing and verifying code in parallel. Decompilation and recreation projects are a near-perfect fit for current AI capabilities because they’re verifiable: at any point, you can check whether the AI’s guess actually reproduces the target behavior. That verifiable loop, propose code, test it, compare the result, adjust, is something models can run continuously without supervision, and running many such loops in parallel across different parts of a codebase compresses a multi-year project into days or weeks.
This isn’t limited to old console games. The same logic is being applied to recreate entire pieces of commercial software by observing their behavior rather than reading their source code. One widely shared example involved AI watching a local, legitimately owned copy of Photoshop, inferring what each button and menu did, and rebuilding equivalent functionality as free, open-source software. The same approach has been applied to office software like Excel. If this generalizes, it raises real questions for any company whose competitive advantage is the software itself rather than services, support, or data built on top of it.
Is this legal, and should modders worry about it?
This is genuinely murky territory, and the transcript source doesn’t offer a legal verdict, nor should this article pretend to. Decompiling a game you own for personal study and modding has a long, mostly tolerated history in hobbyist communities, but distributing decompiled code, assets, or AI-recreated clones of copyrighted software is a different matter and can run into intellectual property claims from the original publisher. The practical reality is that enforcement has been inconsistent, and the speed at which AI now produces these recreations is outpacing any clear legal consensus. Anyone building or sharing this kind of project should treat the legal risk as real, not theoretical.
Frequently Asked Questions
What does it mean to decompile a game?
Decompiling takes a game’s compiled machine code, the form a console or computer actually runs, and works backward to reconstruct readable, editable logic. The rebuilt code won’t be identical to the original source (comments and variable names are lost in compilation), but it can reproduce identical behavior.
How is AI different from older decompiling methods?
Remy is new. The platform isn't.
Remy is the latest expression of years of platform work. Not a hastily wrapped LLM.
Older decompiling relied on human teams manually guessing and verifying code over months or years, as with the long-running Super Smash Bros. Melee project. AI runs the same guess-and-verify loop automatically and in parallel across many parts of a codebase, which is why projects that once took years, like the Snowboard Kids decompilation, dropped to months.
What’s a pass-through mod?
A pass-through mod runs two separate games simultaneously and builds a live connection between them, syncing cameras, combining rendered visuals, and relaying events (like an explosion) from one engine to the other in real time. It’s the technique behind mashups like Minecraft appearing inside GTA.
Can this same approach clone regular software, not just games?
Yes. The same idea, having AI observe a program’s behavior and rebuild equivalent functionality, has already been used to create free, open-source recreations of commercial tools like Photoshop, without access to the original source code.
Does this mean game studios and software companies are in trouble?
Not automatically, but it does shift where value comes from. If a company’s only advantage is the software’s functionality, AI-driven recreation makes that advantage easier to erode. Durable advantages are more likely to come from services, enterprise support, ongoing updates, and things that aren’t purely verifiable code behavior.