Felix Laurent
It sounds easy to run old games on a modern PC until you actually try. Especially when a game is over 25 years old and was never made for a PC in the first place. Emulators want BIOS files, plugins and per-game tweaks. Fan-made PC ports want compilers, libraries and a build that breaks on a newer Windows setup. We handed all of that to an AI agent and asked for one thing: get the game running, with proper graphics and controls.
Claude Code got three classics running on one Windows 11 PC: Silent Hill (1999), The Legend of Zelda: Majora's Mask (2000) and Pokémon Red (1996). Silent Hill runs at 2560x1440 in 16:9 with mouse aim. Majora's Mask runs as a native Windows game with a modern renderer. On the way the agent hit 13 build failures and fixed every one of them without asking us what to do.
Why old games are hard to run on a modern PC
There are three ways to play an old console game on a PC. Each one asks something different from the player, and each one breaks in its own way.
| Path | What it asks from you | Where it usually breaks |
|---|---|---|
| Emulator | the right emulator, often a console BIOS file, then hours of tuning: graphics plugins, visual glitches, controller mapping, per-game fixes | black screens, broken textures, wrong speed, input lag, settings buried in menus |
| Fan-made PC port | a compiler, a dozen libraries, the build steps from a README, then debugging graphics, setting up controls, resolution and frame rate | the build fails on a newer compiler or a missing tool; the game runs with visual bugs or unusable controls |
| Decompilation | reading machine code and rewriting it as source code | years of expert work before anything runs |
A port gives the best result: native resolution, widescreen, high frame rates, mouse and keyboard. It is also the path that asks the most from a person who only wants to play. That is where we pointed the AI.
Decompilation and reverse engineering in brief
Most fan ports start with reverse engineering. It means studying a finished program to learn how it works without its source code. For old games this is often the only way in: publishers rarely release source code, and some of it is lost for good.
Several techniques do the work. Each one leaves a different kind of code behind.
- Disassembly turns the game's machine code into assembly, a readable list of processor instructions.
- Decompilation goes one step further and rewrites that code as a language like C. In a matching decompilation, the new C compiles back into a file identical to the original, byte for byte. That proves nothing was lost.
- Static recompilation does the translation automatically. A tool converts every function into C at once, without a person rewriting it by hand.
- Reimplementation skips the original code. People write a new engine that behaves like the old one and reads the original game data.
Once the code is readable, porting comes next. Developers replace the console's graphics chip, sound and controller code with PC libraries. A decompilation of a large game can take a fan community years.
What we asked the AI to do
The brief was one sentence in plain words: make the game run on this PC with modern graphics and controls. We did not pick the tools or read any build guides.
We supplied three things. The first was game files dumped from our own copies. The others were approval clicks when Windows asked for admin rights, and a few browser downloads when GitHub was too slow. The agent picked the projects, installed the tools, built the games and set them up.
Without the agent, this would have taken many times longer. In the time it needed for three games, we estimate a person would have finished one at best. Every failure would mean searching for the error and reading guides and forum threads. Many of those turn out not to fit, because they were written for another compiler, another Windows setup or another version of the port.
Silent Hill: one compiler error and a config file
Silent Hill never got a PC release. Fans opened a decompilation of the PlayStation game in 2021, and most of the work landed between late 2024 and October 2026. A separate project, SlickAmogus/silent-hill-decomp, turned that code into a Windows game. Building it means installing a full compiler toolchain called MSYS2.
The agent installed it, fetched the source and started the build. Our connection kept dropping mid-download, so it switched to downloads that resume after a break. It asked us for three archives through the browser when even that stalled.
The first build stopped with a compiler error. The newest compiler clashed with a file in the port over four function names. A player would see a wall of red text and stop there. The agent traced the clash to a change in the compiler's own files and fixed it with one setting for that one file. The second build ran 799 steps and produced the game.
Then it opened the config file and set the game up for our monitor:
- 2560x1440, borderless fullscreen, 16:9 without stretching.
- 60 fps instead of the PlayStation's 30, with MSAA 4x.
- A third-person camera instead of fixed angles, WASD and mouse aim.
The game read our disc image on the first launch. The clip below shows the third-person camera with mouse aim against a flying enemy.
The port also has camera modes the PlayStation never had, including first person.
Both clips are our own gameplay recordings from this build.
Majora's Mask: 12 build failures in a row
Majora's Mask, a Nintendo 64 game from 2000, has an excellent PC port, Zelda 64: Recompiled. A tool called N64Recomp translates each of the game's 17,146 functions into C code. A renderer called RT64 then draws the game on DirectX 12 or Vulkan. The catch is the build: Visual Studio, an extra compiler, a ROM in the right format and dozens of libraries.
The first problems came before any compiling. Our cartridge dump was in a byte-swapped format, so the agent converted it and checked it against the hash the project expects. The recompiler needs the ROM uncompressed, and the usual script was out of reach because GitHub had rate-limited us. So the agent wrote its own decompressor. It unpacked 1,513 compressed files in 5 seconds and checked every one against the reference decoder: 0 mismatches.
The build itself failed 12 times. The project pins its libraries to versions older than the compilers in Visual Studio 2026. Each failure would have stopped a player cold. The agent fixed them one by one without touching the game logic.
| What broke | What the agent did |
|---|---|
| Visual Studio had no C++ tools installed | added them through the Visual Studio installer |
| Libraries sent the compiler flags it does not understand | switched to a compatible mode of the same compiler |
| An old text-formatting library failed under the new compiler, twice | built that library in an older language mode |
| The SDL library clashed with a function the compiler now provides | turned off that part of SDL with a switch SDL itself offers |
| A new compiler warning was treated as an error | turned off that one warning |
| The patch build could not find a command-line shell | added MSYS2's shell without letting it override Microsoft's tools |
| Neither Visual Studio's compiler nor the official LLVM release could build code for the N64's MIPS chip | found one in MSYS2 that can |
| A newer compiler rejected the game patches over pointer types | relaxed that one check for the patch files |
| The wrong linker built Windows files instead of N64 ones | switched to a linker that builds the right format |
| The recompiler itself crashed | found the bug with a memory checker and fixed one line |
| The final step found the same function defined twice | told the recompiler to use the PC version of it |
The crash took the most digging. The recompiler died silently, with no error message at all. The agent rebuilt it with a memory checker, saw it read a special marker as a normal number and changed one condition. After that, the game's 1,798 patch functions went through clean.
The result is a 29 MB executable. It opened on the first launch, and resolution, aspect ratio, frame rate and controls live in the game's own menus.
The clip is the game's opening, recorded on the build described above.
Pokémon Red: running in minutes
Pokémon Red took minutes. The Gen1Recomp project is a new game engine written by hand in Lua. It reads the maps, sprites, text and music from your own cartridge dump.
The agent checked our cartridge dump against the versions the project accepts. It read the project's setup scripts before running them and then ran the same steps itself. The import took 2 seconds, and the game opened in a window. Fullscreen, zoom and a widescreen battle layout are in its options menu.
The sprites, text and music in the clip all come from our own cartridge dump.
What you get on a modern PC
All three games go well beyond what the original consoles could show. The table sums up the settings each port offers.
| Silent Hill | Majora's Mask | Pokémon Red | |
|---|---|---|---|
| Resolution | 2560x1440 | any, up to the monitor's native | resizable window, fullscreen option |
| Widescreen | Hor+ 16:9 | any aspect ratio, including ultrawide | widescreen battle layout |
| Frame rate | 60 fps (30 on PlayStation) | up to the monitor refresh rate (20 on N64) | 60 fps |
| Controls | WASD, mouse aim, third-person camera | keyboard and gamepad, rebindable | keyboard and gamepad, rebindable |
| Extras | quick save, MSAA, randomizer | mods, autosave, gyro aiming | save states, mods, online play |
The agent set up Silent Hill through its config file. Zelda and Pokémon keep the same kind of options in their in-game menus.
Getting a port running vs decompiling from scratch
This test shows what an AI agent does with ports that people already wrote. Claude Code did not decompile any of these games itself. It assembled other people's work, fixed what broke on a 2026 PC and wrote small tools where a step was missing.
A port written from scratch is a different job, and how long it takes depends on the goal. A matching decompilation rebuilds the original file byte for byte. Every function is reworked until each instruction lines up. The Majora's Mask decomp has run since 2018, and Silent Hill's took about two years of active work.
A player does not need that. A port only has to behave like the original, and that target is much closer. Several methods shorten the road:
- Recompile first. Tools like N64Recomp translate every function into C automatically. Our Majora's Mask run did 17,146 functions in 2 seconds.
- Check behavior, not bytes. Run the original in an emulator next to the port with the same input and compare memory and frames. A mismatch points at the broken function.
- Split the work. Each function is a separate task, so many AI agents can work at once while a compiler and a comparison tool check each result.
- Skip what is already known. Console SDKs and common engines make up much of a game's code and can be matched to existing libraries instead of decompiled.
The AI then writes the layer that replaces the console hardware: graphics, sound and input. That is still the hardest part, but it no longer waits on a hand-made decompilation.
The trend is already visible. Kotaku reported on October 9, 2026, on browser ports of Halo: CE, GTA: Vice City and The Simpsons: Hit and Run. Their creators say the games were decompiled and ported overnight with Claude Opus 5.5. The reporter played several and called some of them borderline flawless. The overnight timing and the method are the creators' claims, and the article does not say how much existing fan work the ports reused.
Kotaku's story is part of a wider wave. A roundup by Pasquale Pillitteri collects more projects credited to the same model. On r/decomps, a user posted a PC recompilation of Shadow of the Colossus built with Opus 5.5 and GPT Sol 6.1. The author admitted nobody had checked every colossus by hand. Kotaku also covered a Modern Warfare 2 decompilation by Maurice Heumann that reportedly ran 17 AI agents in parallel.
A post on r/ClaudeAI shows what such a project looks like up close. Its author says Opus 5.5 ported StarFox, StarFox 2 and Sonic CD to Windows, Mac and Linux. The prompt was one line: create a full decompilation of the game so it runs natively. The ports add higher resolutions, frame rates, controller support and true 16:9 in Sonic CD, and the code is public on GitHub. After readers pushed back, the author corrected the post. At least for Sonic CD, the result is closer to a game-specific emulator with static recompilation than to a rebuilt original source code.
That correction is the honest picture of the wave. AI makes old games run natively fast, often through recompilation and emulation rather than true decompilation. Some users also say Opus 5.5 got worse at this work after launch. None of these accounts is independently confirmed.
The table compares three paths. The first two columns are our estimates for an AI agent. The third is getting an existing open-source port running, the approach of this test.
| Game | Platform | Matching decompilation | AI port that behaves like the original (our estimate) | Get an existing port running | Existing port |
|---|---|---|---|---|---|
| Pokémon Red and Blue (1996) | Game Boy | months | 2–5 days | minutes (measured) | Gen1Recomp |
| Silent Hill (1999) | PlayStation | years | 2–6 weeks | one evening, most of it downloads (measured) | SlickAmogus/silent-hill-decomp |
| Majora's Mask (2000) | Nintendo 64 | years | 1–3 weeks | one long evening, most of it downloads and fixes (measured) | Zelda 64: Recompiled |
| Super Mario 64 (1996) | Nintendo 64 | years | 1–3 weeks | a few hours (est.) | built on the sm64 decompilation |
| Ocarina of Time (1998) | Nintendo 64 | years | 1–3 weeks | a few hours (est.) | Ship of Harkinian |
A matching decompilation is a job for months or years. An AI port aimed at behavior shrinks it to days or weeks, and a ready port to hours. The N64 games are faster because a mature recompiler already exists for them, while a PlayStation port still needs more work by hand. The fan projects in the right column took their authors months or years. The AI's job here was the last mile between that work and a player's PC.
Is this legal
None of the three projects includes game data. Each reads graphics, sound and text from a file the player supplies. The safe path is a dump of a disc or cartridge you own.
The port code is open source: GPL-3.0 for the Silent Hill PC layer and for Zelda 64: Recompiled. The games stay under their publishers' copyright. Sharing a ROM, or a build bundled with one, is not covered by any of these projects.
Publishers are already pushing back on AI-made ports. Kotaku reported that a browser Fallout project was dropped after an alleged cease-and-desist from Bethesda. Activision had the Modern Warfare 2 decompilation video taken down. XDA-Developers reported DMCA notices against two Call of Duty browser ports.
AI and the preservation of game history
Old games used to come with a price of entry: the right emulator, the right settings, or the patience to build a port. The people behind these projects did the deep work. The Silent Hill decomp team rebuilt the code by hand, the N64Recomp authors wrote a recompiler, and the Gen1Recomp author rewrote a whole engine.
What changed is the part between their work and your screen. An AI agent now installs the tools, builds the game, fixes what breaks and sets it up for a modern monitor and a mouse.
Decompilation matters most for games nobody will bring back. Some publishers closed long ago, rights get lost in mergers, and many old games will never be re-released. For those, a decompiled port may be the only way they keep running on new hardware. AI makes that work faster and puts it within reach of many more people.
AI has become important for preserving gaming heritage and culture. Now anyone can touch an era that is long gone, and it no longer takes moving mountains. It is enough to hand the job to Claude.
sources
- SlickAmogus/silent-hill-decomp on GitHub – the Silent Hill PC port
- Zelda 64: Recompiled on GitHub – the Majora's Mask port and its build guide
- r/ClaudeAI: Opus 5.5 is insane at decompilation / ports – the StarFox and Sonic CD ports and the author's correction
- Gen1Recomp on GitHub – the Pokémon engine
- Kotaku on AI-made browser ports – the October 2026 report on overnight ports
- Pasquale Pillitteri's roundup of AI decompilation projects – the Shadow of the Colossus and Modern Warfare 2 projects, and the takedowns
