Everything Is Everything Now
This is the full, combined version of this piece. It brings together my original article, an interview with a technology professional who has worked in the field since 1996, and a follow-up where I went into the GitHub repos behind the viral clips to see what they actually do. Some of what I wrote the first time held up. Some of it didn't, and I've corrected it here.
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 some of that work takes days. That's part of why your feed is full of Mario running around Elden Ring, Minecraft inside other games, and Skate tricks in Call of Duty, usually captioned with some version of "AI rewrote it in Rust."
When I actually opened the repos, most of those clips turned out to be smaller than the captions. Some are two games running at once with glue between them. Some are years of human reverse engineering with an AI-assisted coat of paint. A couple are just pirated games. I couldn't find a single case of an AI taking a finished commercial game apart and rebuilding it from scratch on its own.
The bigger story still isn't Mario. Programs used to stay separate mostly because getting their code back was so hard, and that difficulty is shrinking. If anything that runs on your own computer can be pulled apart and rebuilt faster than its makers planned for, then games, Photoshop and tax software are less protected than anyone 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.
The Minecraft mashups are the same idea. They aren't new games. Minecraft runs with a Fabric mod, the other game runs with its own mod, and a bridge passes state back and forth through hooks and shared memory. You need to own both games, and both have to be open.
Minecraft is always one half for a simple reason: it's written in Java. Java JAR files decompile into something very close to the original source, and Mojang has never worked hard to obscure it. Feed that to an AI and you get readable code quickly.
Skyrim, Elden Ring and GTA V are a different animal. They ship as native machine code with no public source. Modders get in from the outside: a DLL gets loaded through something like SKSE or Mod Engine 2, then finds the functions it cares about by searching for byte signatures and memory offsets. From there it hooks input, camera updates, damage and rendering, and injects its own draw calls into DirectX.
That's also why these projects are fragile. One patch from the developer can move every address the hooks depend on, and the whole thing stops working. And it's why you never see Skyrim inside Elden Ring. Two closed native games give you nothing easy to grab onto.
It's still impressive that any of this works in real time. But it isn't a playable fusion. The skeptics calling these clips smoke and mirrors are right about a lot of them.
Not all of them, though.
How software actually gets made
To see why the rest matters, you need a rough idea of how programs get built.
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.
Not all software works this way, and the difference explains why this is happening to games and desktop apps specifically. An IT veteran with about thirty years in the field splits programming languages into two groups. Interpreted languages like Python, PHP and JavaScript stay as readable text the whole time. The computer reads that text and runs it on the fly, which is why you can right-click almost any web page, hit "view source" and see how it was built. Compiled languages are the other group. They're used for faster, heavier software like Photoshop and most big games, and they're the ones that get turned into machine code.
That machine code was the protection. As he puts it, you'd have to be extremely smart, extremely bored, or both to read it, and for a program the size of Adobe's suite it would take so long that it was effectively impossible.
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 very 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.
One correction to how this often gets described: what comes back isn't the original source code. The veteran is careful about this. So much gets stripped out during compiling that the rebuilt version is working source code, not a copy of what the developers wrote. It does the same thing, and you can change it, but the names, the structure and the reasoning behind it are a reconstruction, not the studio's.
What the clips actually are
After the first version of this article went up, I went and looked at how a few of the biggest clips actually work. That changed some of what I believed.
Take the Modern Warfare 2, Skate 3 and Minecraft mashup, which got the loudest claims. People said Claude rewrote all three games in Rust to make a new one. It didn't. The MW2 part sits on top of an existing Rust recreation of the game's runtime, and it reads MW2 files you already own. The Skate 3 part is another existing Rust project, about two years old, built on human reverse engineering research. It needs your own extracted Xbox 360 executable and data folder. The Minecraft part uses open source Rust crates that already existed and pulls game data straight from Mojang.
So the work was assembly. Three puzzles' worth of pieces, with the edges trimmed until they fit. That's real effort and it's kind of fun. It just isn't what the tweets described.
The browser versions are a different story. They run on WebAssembly, which lets compiled C, C++ or Rust run inside a browser sandbox. Compile the engine to WebAssembly, add the maps, models, audio and scripts, write a compatibility layer so it talks to the browser, and an old PC game will run in a tab.
The catch is where those assets come from. One project, Vibe Slops 2, was just Black Ops 2 in a browser. It got a DMCA takedown almost immediately, which surprised nobody. A Black Ops 1 port is murkier. Its GitHub page tells you to supply around 11 GB of your own game data. I didn't, and it ran anyway. The download manifest shows about 931 MB of unpacked Black Ops data landing in the browser on its own. Maybe the instruction is there to keep automated copyright scanners off the repo. Maybe whoever built it didn't fully understand what they'd shipped. Either way, it's handing out the game.
The original Xbox version of Halo: Combat Evolved also runs in a web browser now, 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 also reports of Windows games being ported to Mac in about two hours. Those results are real. What's less clear in most of these cases is how much of the decompiling an AI actually did and how much already existed from years of fan work.
Most of the viral "AI decompiled this" posts fall into one of five buckets:
- A native game recompiled or reimplemented for WebAssembly.
- A new engine that loads data from a copy of the game you own.
- A browser recreation that redistributes copyrighted assets.
- Two real games running side by side with a bridge between them.
- Something new that only resembles the game in the headline.
So can AI decompile a whole game on its own? Not that I could find. The closest things are the Skate 3 engine, which rests on two years of people doing the reverse engineering by hand, and the Black Ops 1 port, which uses real decompiled engine code compiled to WebAssembly. Whether an AI did that decompilation or it already existed somewhere, I can't say. I didn't dig that far.
There's also an article claiming AI has decompiled 83% of MW2. There's no source anyone can inspect. Until there is, it's a number in a headline and nothing more.
None of this means AI isn't speeding up the work. It clearly is. It means the clips are running ahead of what's actually been done.
Why this isn't just piracy or vibe coding
Two objections come up a lot. Piracy has existed forever, so what's new? And people were already asking AI to "make me Photoshop," so isn't this the same thing?
Neither is the same.
Piracy gets you a free copy of the finished program. The veteran's summary is that it removes the copy protection and usually adds some malware. What it doesn't do is let you change anything. You get the program exactly as it shipped, minus the price tag.
Vibe coding has a different limit. An AI writing software from a description can only produce patterns it has seen before. Big programs and games have features buried deep inside them that a model has never come across, so a "make me Photoshop" request will miss them, because the model doesn't know they exist.
Decompiling avoids both problems. You get the whole feature set of the real program, and you get it in a form you can edit. His example: say Photoshop has a thousand features and you use a hundred. With recovered source code, you could have an AI strip out the other nine hundred and keep only what you need. The result would probably run faster and be easier to use. Piracy can't do that, and vibe coding can't get you all the features to begin with.
Everything is everything
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, 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 clip still shows the difference between an overlay and the real thing. Skate's old speed-boost glitch works inside the mashup, and a glitch doesn't come through a green screen. It only comes along when the real logic does. The honest footnote, from the repo, is that the real logic here came from two years of human reverse engineering, not an afternoon of prompting. The mechanic moved. The hard part of moving it was mostly done by people.
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, and each year it gets cheaper to make that happen.
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 shrinking.
The Photoshop thing
Games are the fun example. Adobe 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."
I got a more sobering look when I tried the Premiere and After Effects recreations that run on Linux. This is the one I actually wanted to work, because Adobe on Linux would change my setup. You can do a lot of what the real apps do. It also crashes more than Premiere, which is saying something if you've ever used Premiere. Most effects, exports and encoding run on the CPU instead of the GPU, and for me that alone rules it out. A 14 minute video taking an hour to render is one of the open issues. You can't drag just the video or just the audio onto the timeline. When I checked, there were 363 other open issues.
The developers are honest about it. They put the Premiere recreation at 50 to 60% ready for professional work and After Effects at 30 to 50%. Your existing plugins won't load, and your existing project files won't open. I'm still watching it. The project is about two weeks old, already this far along, and they're closing issues fast. Six months from now it could be stable. It isn't today.
Both of those still matter. Most Adobe 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 getting weaker fast.
The online wall
The veteran's main point is about architecture, and it limits all of this. Decompiling only works on software you can actually get your hands on. If a program runs on a company's servers, the code never reaches your machine, so there's nothing to decompile.
He also argues that the industry was already heading that way. A lot of software has moved to the web, Adobe included. And for companies selling business software, he doesn't think offline users matter much anymore. His reasoning: if you don't have a reliable internet connection, you probably weren't going to spend hundreds of dollars on Photoshop in the first place. He compares it to when web developers stopped worrying about people on older browsers. At some point a company decides those users aren't its customers and builds for everyone else.
So his prediction is that more software gets pushed online, partly because of this.
That works for big business software. It works less well for two groups. The first is games, because a lot of people play offline, on trips, on planes, or without paying for mobile data abroad. The second is small and independent developers, who can't afford to keep servers running forever just to protect their code. He points out the same thing happened with piracy twenty years ago: the smallest players were the least able to protect themselves and were hurt the most. Decompiling is likely to repeat that.
The legal question nobody can answer yet
There's an older idea called clean room design. One person studies a program and writes a detailed description of what it does. A second person, who has never seen the program, writes new code from that description. Because the new code was never copied, it has historically been a way to rebuild software legally. Some people are now asking whether AI decompiling is a kind of automated clean room, and whether it launders the copying.
The veteran's answer is that nobody knows, and nobody will until a judge decides. He notes that the US government's own guidance on fair use comes with a reminder that it isn't strictly written into law. In practice, fair use gets decided when someone with enough money and a strong enough case takes it to court.
He also makes a point that gets lost in the clips: code is only one layer of intellectual property. If you decompile a game and rebuild it with the same maps, characters and art, you'll get sued over those even if the code itself somehow holds up. The browser ports that ship the game's actual data are the clearest example, and the Black Ops 2 takedown shows how fast that goes. He mentions Nintendo going after the makers of Palworld as an example of a company with money taking action when it thinks the law is on its side.
The same applies to Photoshop. If your rebuild has the same menus in the same places and the same options drop down when you click, the design itself may be protected separately from the code. If you change the design enough to be safe, you've made a new program that people have to learn from scratch. At that point, for most businesses, paying for the original is easier.
Just because you can
This is where the veteran is most skeptical. He points to something called total cost of ownership: what a tool really costs once you add maintenance, support, training and the time spent fixing it. On that measure, he thinks a company decompiling Adobe to save on subscriptions is a bad idea in almost every case. The subscription includes updates and fixes. A rebuilt copy includes neither, unless you pay someone to maintain it. The Linux Premiere recreation, with hundreds of open issues, is a good picture of what that maintenance looks like.
His analogy is his car. He knows how to change his own oil but hasn't in fifteen years, because paying someone is cheap and it just gets done. He also points out that Netflix reduced piracy for a while not by stopping it, but by being easier than it. Most people would rather pay a small amount and have the thing work. Would you rather risk a rebuilt game breaking when you're 90% through it, or pay for a version that works to the end?
He makes the same argument about business software in general. Salesforce at around $50 a seat sounded expensive to him once, until he worked out that it's a small fraction of what a company already pays the person using it. Most companies, his example is Walmart, aren't going to decompile anything. They'll keep paying.
Where it actually matters
The veteran doesn't think the important use is games or Photoshop. He thinks it's infrastructure.
He brings up the original reason many IT people wanted open source in the early 2000s. It wasn't mainly about price. It was that companies were running code they had no way to inspect. If something broke, they had to wait for the vendor to find and fix it, because the compiled code was unreadable. Decompiling changes that. It lets people see what software they already run is actually doing.
The bigger example is data centers. A company running a million GPUs is also running a million copies of an operating system, and most of that operating system does things those machines don't need. He remembers MySQL working with a customer years ago to build a stripped-down version of Linux that only ran their database across a thousand servers. With AI, a company could do the same thing far more easily: keep only what's needed to run the GPUs and remove the rest. That means better performance and fewer security holes.
The numbers make it worthwhile. Rebuilding an operating system might cost millions, which is small next to the cost of a million GPUs. And even a 1% efficiency gain across a million GPUs running all day, every day, adds up to a lot of electricity. In his words, rebuilding Doom is a curiosity. This is the real application.
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, or a browser port quietly handing out someone else's game.
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 keeps making code easier to recover, 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.
It also doesn't prove that AI can take a whole commercial game apart on its own. The best examples I found still lean on years of human work, on data you supply from your own copy, or on assets nobody had the right to hand out.
And it doesn't mean the "SaaS apocalypse" was right. Earlier this year, the fear was that AI could rebuild products like Salesforce, so nobody would pay for them anymore. The veteran thinks that misunderstood what people are buying. A Salesforce customer isn't mainly paying for the interface. They're paying for the backend: integrations with other tools, data that won't disappear, and systems that stay up when a server part fails. He knows a company with a full team that does nothing but integrations. For the cloud services he pays for himself, he says the hardware and software are the least valuable part. What he's buying is the service only going down for a couple of hours a year, and not having to deal with it when it does. Decompiling doesn't copy any of that.
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.
The part that bugs me
I'd be lying if I said none of this was cool. Getting three games from different eras to share a world is a fun trick, and an Adobe clone this far along in two weeks is a little startling.
But it leaves me with a strange, flat feeling. I think of code as something close to art. Everyone writes it a bit differently, and you can often tell who solved a problem by how they solved it. When the work turns into a prompt, that fingerprint fades. And decompiled code makes it stranger still, since what comes back works like the original but carries none of the original author's choices. Maybe that's just progress. It still feels like something is being lost.
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 is getting less safe, and a lot of what we built, from game preservation to software licensing, depended on that tedium.
Talking to someone who has spent thirty years in server rooms made one thing clearer. The flashy part is the least important part. Most businesses will keep paying for software because what they're really paying for is reliability, not code. The people most exposed are the ones who can least afford it: small studios and independent developers shipping offline software. The biggest gains will probably go to the companies large enough to rebuild an operating system just to save 1% on power.
Digging through the repos made another thing clear. The tech is moving faster than anyone can write about it, so some of this will be out of date by next week. What probably won't change is the gap between what a clip claims and what the code actually does. Before you share the next "AI rebuilt this game" post, open the GitHub page. It usually tells a much smaller story.
One last detail. The host of the video that first 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, and plenty of them are oversold, but the important part is how easy this is becoming. Everything is becoming everything, and we should probably decide what we want that to look like before it gets decided for us.