Everything Is Everything Now
By Lyle Heartman
Here's the short version first.
AI models have gotten very good at decompiling software, which means taking the raw machine code a computer runs and turning it back into source code a person can read and change. Fan projects used to spend years on this. Now it can take days, sometimes hours. That's why your feed is full of Mario running around Elden Ring, Minecraft mechanics in Pokémon, and Skate tricks in Call of Duty.
Some of those clips are tricks and some aren't. The tricks are two games running at once, with one character drawn over the other. The real ones are games that have been taken apart, rewritten and stitched together.
The bigger story isn't Mario. Programs used to stay separate mostly because getting their code back was so hard, and that difficulty is going away. If anything that runs on your own computer can be pulled apart and rebuilt this fast, then games, Photoshop and tax software are much less protected than their makers assumed. That leads to a question I can't answer cleanly: should games, and software in general, be open source? I think some of them should, and I'll explain where I draw the line.
Here's the longer version.
The two-discs-in-the-tray feeling
One comment under one of these clips has stuck with me: "This is what I thought would happen when I put two discs in the tray as a kid."
That's the best description of the first reaction. You can shoot Tom Nook with a Halo rifle. You can put Balatro's card mechanics into a Pokémon game, and it uses your actual team and items. Every kid who wanted to take the best part of one game and put it into another is now watching it happen.
It's cool, and I won't pretend it isn't. But the longer you look, the stranger it gets.
Some of it is a magic trick
The most viral clips use something called pass-through. Two games run at the same time and share information through memory. One game knows an enemy is nearby, how far away it is and how much health it has, and that data gets passed to the other game.
The Spider-Man-in-Batman clips work this way. Spider-Man's model is drawn over the Batman game while Batman's animations play underneath. In some shots you can't tell. In others he shows up on top of the menu text, and you can see it's basically a green screen.
It's still impressive that this works in real time. But it isn't a playable fusion. It's an overlay. The skeptics calling these clips smoke and mirrors are right about some of them.
Only some, though.
The part that isn't a trick
To see why the rest matters, you need a rough idea of how games get made.
A programmer writes source code. It has names like "player" and "shield", comments, and clear breaks between sections, so other people can read it. An Xbox doesn't read any of that. Its processor reads machine code, which is just a stream of instructions moving numbers around. A compiler turns the human version into the machine version, and each kind of hardware needs its own compiler.
Compiling strips out everything meant for humans. The names, comments and structure are all gone.
Decompiling means rebuilding the human version from what's left. For years the main method was guess and check. You wrote what you thought a piece of code looked like, compiled it, and compared the result with the original. If it didn't match, you changed a "greater than" to an "equals" and tried again, one line at a time. Whole communities spent close to a decade on a single game.
Current AI models are extremely good at this kind of work. Programmers who love AI and programmers who barely use it keep saying the same thing: if you can check an answer quickly, these models get good at the task shockingly fast. Decompiling is the clearest example. You guess, compile and compare, and the result is either right or wrong. A model can repeat that loop forever without getting bored.
The results are already out there. The original Xbox version of Halo: Combat Evolved now runs in a web browser at over 120 frames per second, and by most accounts it looks better than the official PC port. People are playing multiplayer on it. There are reports of Windows games being ported to Mac in about two hours.
What "everything is everything" actually means
For decades, every program was its own island. A game's walking system belonged to that game, and a climbing mechanic belonged to the studio that built it. If you wanted Mirror's Edge parkour in another game, someone had to build it again from scratch.
A game developer pointed out that almost every studio does exactly that. They rebuild walking, climbing and combat from the ground up for every game. Almost every game reinvents almost every wheel.
Once code can be recovered, its parts can be moved. The parkour is just parkour and the climbing is just climbing. Someone can pull the movement code out of Mirror's Edge, rewrite it (often in Rust), and drop it into a completely different game. At that point it isn't Mirror's Edge anymore. It's the movement, living somewhere else.
The Skate-in-Modern-Warfare clip shows the difference. It isn't an overlay. Skate's real mechanics are running inside another game, and you can tell because Skate's old speed-boost glitch still works. A glitch doesn't come through a green screen. It only comes along when the real code does.
Think about the early Assassin's Creed climbing that fans say was never matched, or the Nemesis system that stayed locked inside one series. In theory, any of these can now go anywhere.
So "everything is everything" is a claim about boundaries. The line between one product and another was mostly held in place by how hard it was to cross. The legal barrier was always thinner than people assumed. The real barrier was the effort, and the effort is disappearing.
The Photoshop thing
Games are the fun example. Photoshop is the one that made me stop.
Photoshop is about as locked down as software gets. It's huge and old, and big teams have been building it for decades. If any program was safe just because it was so complicated, it was this one.
Then Photon Studio appeared, which is essentially a rebuilt Photoshop. The person who tested it uses Photoshop every day for thumbnails. He ran it on his own monitor, used it the way he always does, and got the same results. He couldn't find a single feature he relies on that was missing.
That needs some care. It's one person's test, and his use is ordinary. A professional retoucher or print designer who works in the program's obscure corners might find gaps. Photoshop has decades of edge cases, color-management quirks and plugin support that are hard to match. "I couldn't find a difference" is not the same as "it's identical."
The first statement still matters a lot, though. Most Photoshop users only ever touch a small part of the program. If a rebuild covers that part, the thing people pay a monthly subscription for stops being exclusive. The price was never really held up by the obscure features. It was held up by the fact that nobody could copy the whole thing.
Now apply that to every program you pay for and run on your own machine: TurboTax, video editors, audio tools. Their protection was never that the code was truly secret. It was that recovering it would take too long to be worth it. That's security by obscurity, and it's failing fast.
Should games be open source?
Both easy answers to this are wrong, I think.
The case for yes.
Games die. Servers shut down, hardware becomes obsolete, studios close, and something people loved turns into a file that won't run anywhere. Open source is the best preservation tool we have. Halo running in a browser and playable with friends shows it. Fans did what the owners didn't.
There's also the wheel problem. If the best versions of common systems were shared, new games could start further along and put their effort into ideas instead of plumbing.
Old games are the simplest case. When a game is decades old and nobody sells or supports it anymore, keeping its code locked away doesn't help anyone.
The case for no.
Games are also how people pay rent. Imagine a small team spends three years on a game, then releases it into a world where anyone can rewrite and republish it within a week. They have no moat. Roblox already shows what happens: popular games get cloned within days, and the clones are usually worse. Faster rewriting means more of that, and most of it would be low-effort copies chasing someone else's audience.
Open source also works best when there's a community with a reason to contribute. Dumping a finished commercial game's code online doesn't automatically create one. Sometimes all it produces is clones.
Where I land.
The answer depends on a game's age and status. One rule won't cover everything.
- Old and abandoned games: open them up. If nobody is selling or supporting a game, preservation should win.
- Games still on sale: the people who made them deserve time to earn from them. Releasing the code after a set number of years seems fair.
- Engines, tools and common mechanics: these should lean open, since they're the wheels everyone keeps reinventing.
The uncomfortable part is that we may not get to decide. If AI can recover the code anyway, the question shifts from "should this be allowed" to "what do we do now that it's possible." Companies can fight it with lawyers, but they can't make the work hard again. Their better move might be to compete on what can't be copied: online services, community, ongoing updates, and the quality of the team behind the game.
What this doesn't prove
Some limits matter here. Software that depends on online servers is much harder to copy this way, because the important parts never reach your machine. The dramatic claims, like "your bank is next" or "encryption is finished," go well past the evidence. Security has generally kept up with new attack tools, and nothing here shows modern encryption breaking.
The real point is narrower: anything that runs entirely on your own computer can now be recovered far faster than the people who built it planned for.
I don't know how it plays out for people, either. Free Photoshop alternatives could help students, hobbyists and anyone priced out of professional tools. They could also drain the businesses that pay for development, and then development slows down. Both could happen.
Where that leaves us
The more I look into this, the less patience I have for either side of the usual AI argument. One side says it's flawless and we should go full speed ahead. The other says it's all hype. Neither describes what's actually happening.
What's actually happening is narrower and stranger than either. Work that stayed safe only because it was tedious isn't safe anymore, and a lot of what we built, from game preservation to software licensing, depended on that tedium.
One last detail. The host of the video that got me thinking about this says he isn't technical. Using these tools, he spent six hours and ended up with Bloons running inside Age of Empires.
That's six hours, from someone who calls himself slow, and it's what I'd remember from all of this. The Mario clips are fun, but the important part is how easy this has become. Everything is becoming everything, and we should probably decide what we want that to look like before it gets decided for us.