Mario in Elden Ring, Spider-Man in Arkham City: How AI Game Mashups Work, and Why the Cloud Is the Real Worry

Last week we wrote about coding models joined to reverse-engineering tools and the wave of decompiled game mashups that followed. A new video from Basic Dev adds the piece that post skipped. It takes two of the viral clips apart technically, then argues that the industry's likely response is worse for players than the mashups themselves (Basic Dev, 2026).

The video is embedded below. The timestamps jump to the matching moment.

Technique one: a mod built from parts that already existed

The first case is Mario running through Elden Ring (watch from 1:00). Basic Dev read the project's open-source code. As they understand it, the AI did not recreate Mario. It assembled existing projects (watch from 1:40):

• libsm64, a library that packages Mario 64's movement code for use in other engines. It has existed since 2020 (libsm64 contributors, 2020).

• The Super Mario 64 decompilation, which supplies the model. libsm64 is itself derived from it (n64decomp contributors, 2019).

• The game files, from which textures, sounds and animations are extracted. They must come from a Mario 64 copy the player supplies (watch from 2:00).

• Mod Engine 3, an existing modding framework that loads it all into Elden Ring (garyttierney, 2022) (watch from 2:40).

The trick inside the game is old-fashioned. The player character is not deleted. It is made invisible and Mario's model is drawn on top, because the game still needs that character to walk through doors and rest at sites of grace (watch from 3:00). A cutscene bug gives it away: a crumpled Mario appears inside the hidden character's head (watch from 3:20).

Basic Dev's broader point is worth keeping: it is much easier for AI to generate something that already exists. That helps explain why so many of the mashups feature Mario.

Technique two: two games running at once

The Spider-Man and Arkham City mashup works differently. It is not really a mod. Both games run at the same time and exchange data through shared memory (watch from 4:00; 4:40):

• Arkham City sends terrain. It sends the buildings and objects in front of the player, roughly fifty blocks out.

• Spider-Man rebuilds that terrain. It rebuilds Arkham City as an invisible layer floating above its own New York. Spider-Man can swing from those structures and collide with them, and the city underneath stays untouched.

• Spider-Man sends the player back. It returns Spider-Man's position, actions and inputs. Arkham City hides Batman and puts Spider-Man in Batman's place, which is why you can still hear Batman catching the wind (watch from 5:00; 5:20).

Basic Dev calls this pass-through. It is impressive in a clip and fragile in play. Combat falls apart, and a single frame shows Spider-Man floating above the on-screen text. Their verdict is "Unplayable" (watch from 5:40; 6:00).

The part that worries them

Neither technique is the concern. The concern is what made them possible (watch from 6:20). Basic Dev shows ordinary-looking Terraria gameplay and says someone pointed a frontier coding model at the game's files. The model decompiled and recompiled the game until it ran, which leaves a complete working codebase (watch from 6:40). That allows rough mods, and it also allows redistributing the whole game, "and that's where the problem lies" (watch from 7:20).

The explanation of why this is new is the strongest part of the video (watch from 7:40; 8:00; 8:20). Reverse engineering by hand is a loop:

• load the binary into a disassembler such as Ghidra (National Security Agency, 2019);

• make Mario jump and watch which code changes;

• trace it back and write C that you think matches;

• compile it, compare it with the original, and repeat for the whole game.

That loop took enormous time and skill, so it worked as a kind of protection. It is also exactly the loop agents are now good at: write, compile, compare, retry (watch from 9:00). The same applies to any installed software. Basic Dev points to REA, short for "Reverse Engineer Anything". It is an MCP server that connects agents to reverse-engineering tools, and its pitch is to see a feature you like and understand how it works down to the binary (morluto, 2026) (watch from 9:20).

The Terraria and browser-port examples are Basic Dev's claims, and we have not verified them. The direction matches what we reported last week.

The fix nobody wants

Basic Dev is careful to say they are not an AI doomer (watch from 9:40). A short sketch frames the stakes: this is about the security and copyright protection of software in general, not one game (watch from 10:00).

The prediction comes at the end. The quickest way to stop AI decompilation is never to ship the compiled code: stream the product from the cloud instead. Basic Dev notes that Xbox, PlayStation and Steam already run cloud projects, and expects publishers to push them harder. The video claims Grand Theft Auto VI will reach PC only through Xbox Cloud Gaming. We found no announcement from Rockstar or Microsoft saying so, so treat it as Basic Dev's expectation (watch from 10:40; 11:00).

The objection is about ownership. Streaming means players own even less of what they buy, and cloud play is a worse experience. Basic Dev ends hoping to be wrong (watch from 11:20; 11:40).

What to take from it

Three things are worth separating:

• The mashups are mostly assembly. They are existing decompilations, libraries and mod loaders, glued together faster than before. Credit belongs to the communities that built those parts, often over years.

• The cost of reverse engineering has fallen. That is real and affects all software, not only games. "Too tedious to copy" was never a security model, and it is now visibly failing.

• Locking software in the cloud trades one loss for another. It protects code by taking away local ownership, offline play and preservation. As our game preservation piece argued, software outlives its machines only when it can be separated from them.

References

Basic Dev. (2026, October 7). AI is destroying gaming... [Video]. YouTube. https://www.youtube.com/watch?v=g2QG9EdIs0Y

garyttierney. (2022). me3: A framework for modding and instrumenting games [Computer software]. GitHub. https://github.com/garyttierney/me3

libsm64 contributors. (2020). libsm64: Mario 64 as a library for use in external game engines [Computer software]. GitHub. https://github.com/libsm64/libsm64

morluto. (2026). REA: Reverse Engineer Anything [Computer software]. GitHub. https://github.com/morluto/rea

n64decomp contributors. (2019). sm64: A Super Mario 64 decompilation [Computer software]. GitHub. https://github.com/n64decomp/sm64

National Security Agency. (2019). Ghidra [Computer software]. GitHub. https://github.com/NationalSecurityAgency/ghidra