October 15, 2026
Three game projects with Claude Opus 5.5 changed how I see existing software. The current wave of game mashups, native ports, and application clones explains why.
Software developer
22 min read
I wanted to play Jak and Daxter on my handheld. That was the whole plan at first.
A few projects later, enemies from Mega Man Battle Network 5 fight alongside enemies from Battle Network 6. The battles run in the same engine. Between them, a program I built generates new areas and keeps a run going that neither original game ever allowed for.
Getting Jak to run made me want to fix the next game. Fixing that made me wonder how much of a game I could change. By the time two Battle Network games shared an engine, I was well past my original plan. And I wanted to keep going.
My main tool was Claude Opus 5.5, which Anthropic released in September.1 I went from “there’s no build for that” to “then we’ll change the running engine.” Existing software started to feel like something I could take apart and make my own. That same possibility now reaches far beyond my handheld, into other games and the applications we pay for.
Each project took me one layer further into a game I already wanted to play.
My Retroid Pocket Nova runs ROCKNIX. OpenGOAL is already an impressive project for playing Jak and Daxter on other systems. I hadn’t found a ready-made build for my device, though.
The OpenGOAL gallery is a good reminder of how much life there is in this game.2
So I gave the agent SSH access to the handheld and a specific goal: get it running there. It researched the options, found the ARM work for macOS, and used it as a starting point for my Linux system. The official OpenGOAL 0.3.8 release does include a macOS ARM build.3
In my session, the agent carried the work through to the device. It installed the result on the Nova, launched it, sent inputs, and inspected screenshots. Fixes followed, then more launches, and eventually a game I could play on my handheld.
That complete sequence was my first real aha moment. Describing the outcome I wanted was enough to start work across several technical boundaries. Research, platform adaptation, and checks on the device suddenly belonged to one assignment.
The OpenGOAL community had done the foundational work. It reconstructs the original GOAL code and provides its own compiler and runtime.4 My agent could build on that. I also owe playing Jak on a different machine to people who understood the game long before my session.
Next, I wanted Dungeons of Infinity. Justin Bohemier built this procedural dungeon crawler in the style of A Link to the Past. It is a standalone GameMaker game, rather than a SNES ROM hack.5
The game is wonderful. Its screen layout was less wonderful for my Nova. The device has a 4:3 display. Dungeons of Infinity uses a 16:9 layout, with the playfield in the middle and extra information on either side. On my handheld, those areas competed for space.
Working with Opus, I built Dungeons of Infinity and Beyond. Health, magic, the active item, and supplies sit directly on the playfield. A stick click brings up the remaining information when needed. The complete playfield stays intact.6
These changes modify the compiled GameMaker game. The patch uses existing tools to decompile GML code, edit it, and compile it again. Checks verify that each expected passage of original code exists before changing it.7
The work soon went beyond the interface. We improved menus, controls, and how the game felt. Then we noticed that the PortMaster version lagged behind the Windows release.
The newer Windows version became another source to work from. Its executable still contains named functions and data initializers. Those helped reconstruct things such as gem recipes and item values. We brought selected 1.2.x features into the older PortMaster 1.1.6 base. We could transfer some data and artwork, while behavior needed adapting to the older runtime. The project explicitly does not claim full parity with 1.2.1.8
This was where I started to see the pattern. A solution doesn’t have to exist for my exact device. Sometimes a useful piece exists on another platform. The agent can examine it and work out how to bring it across.
With Mega Man Battle Network, I wanted to see how far this could go. The series includes some of my favorite games from the Game Boy Advance era. I started with Battle Network 6. The idea was to run the original in an emulator, then build a program around it that gave the game a new structure.
The result is Cyberworld Endless. The idea of an endless run grew into a roguelike with generated areas, enemy encounters, NPCs, Battle Chips, and items. The familiar battles remain, while the journey through the net changes.9
This is what that grew into:
At the center is a director, the program that manages the run. mGBA executes Battle Network 6’s original code. The director generates new map data and changes references in the in-memory copy of the ROM. It observes RAM between frames and responds to game events through hooks.10
A hook is a deliberately placed point of intervention. When the game reaches it, the director can learn about an event or supply a prepared decision. This lets the existing engine keep doing its work while new data and rules determine what it does next.
DIAGRAM
The diagram simplifies the architecture. The feedback loop is what matters: the director changes data, the engine processes it, and the director observes the result. The language model helped me develop this setup. During play, the code we wrote does the work. It doesn’t ask an LLM to pick the next enemy every frame.
That means I don’t have to reinvent the battle system or every animation. The game already knows how to do those things. The interesting work involves understanding what it expects internally and giving it new content in a form it can process.
Bringing Battle Network 5 into that same engine felt like black magic.
Pull request 117 is now merged. It brings BN5 enemies, chips, Navis, and Souls into BN6’s engine.11 Elements from both games can now meet in the same battle.
That sword strike is the part I love. The animation, the movement, the hit: something that belonged to another cartridge is alive in this one.
Copying the sprite would never get us there. An enemy needs its behavior. Its routine calls other routines, reads state, and expects particular data structures. If I copy it unchanged to a new address, those references still point into the old game’s world.
The import therefore follows specific recipes. At startup, it takes the required routines from the player’s own BN5 ROM and redirects calls to matching BN6 functions. It also translates data references and IDs. Shared tables make the content available to the director. The close relationship between the engines helps enormously.12
Earlier versions of the project switched to a second emulator core for BN5 battles. The run now stays in BN6. The other core provides a reference for testing. Tests run the same battle situation in the original and with the transplanted behavior, then compare states throughout.13
That comparison gives the work a testable target. The release documentation still names remaining differences.14 Even with those limits, enemies, chips, and transformations from both games can now share a run.
Projects now bring Mario’s movement to Elden Ring and skating to Modern Warfare 2 maps. My Battle Network experiment sits inside a much larger change. The interesting question is how much of the original survives the journey, and what had to change around it.
Their public implementations reveal different methods behind similar-looking results. A character on someone else’s map might come from a second running game, an imported simulation, or newly written code. Those differences determine what the result can do after the impressive first clip.
SkyCraft runs Skyrim and Minecraft together. Minecraft handles movement, building, and inventory while Skyrim keeps its world and quests. Plugins exchange information through shared memory, and the current implementation draws Minecraft geometry through Skyrim’s renderer. The project is still experimental.1516 Its destruction update credits Claude Opus 5.5 as a co-author.17
That approach can preserve a great deal of each original. The price is coordination: cameras, positions, collisions, and input must agree sufficiently for the combined world to feel solid. A character drawn in the right place still needs a meaningful relationship with the ground underneath it. Occlusion matters too. Something standing behind a wall should disappear behind that wall.
ER Mario’s experimental release takes a different route. It embeds libsm64 inside Elden Ring and feeds Mario’s simulation collision surfaces from Elden Ring’s world. Mario’s movement comes from the Super Mario 64 decompilation. Elden Ring keeps its world, doors, checkpoints, and saves running.1819
The history matters here. libsm64 already packages Mario’s movement for embedding in other software and requires data from the user’s own ROM. That gives each new integration years of reconstruction to build on.20
The skating projects take another route. The Rust Skate 3 engine explicitly credits more than two years of earlier reverse engineering before the AI-assisted rewrite. A related mashup combines it with a rewritten Modern Warfare 2 runtime and a Minecraft world implementation.2122 The MW2 runtime still documents missing behavior and bugs.23 Even at that stage, the project shows an old game’s mechanics becoming useful outside their original executable.24
That is the possibility I find most exciting. A movement system carries timing, acceleration, friction, and animation rules that somebody spent a long time tuning. Preserving those relationships can preserve part of the feel of the game. A replacement that merely looks similar may lose precisely the thing I wanted to keep.
There is still adaptation to do. The destination may measure distance differently, advance its simulation at another rate, or disagree about what counts as a collision. A jump that feels right on one map can make another map trivial. Once the code runs, there is a game-design problem waiting behind the integration problem.
OpenCE brings the original Xbox version of Halo: Combat Evolved to the browser through WebAssembly and WebGL2. Its documentation describes native builds and cross-play too. The underlying decompilation benefits from debugging symbols preserved in later Halo games. This is a source port built on recovered structure, with useful clues from related releases.252627
Getting it into a browser still required adaptation. The game runs in a worker, graphics go through WebGL2, and multiplayer uses WebRTC. WebAssembly also exposed function-signature mismatches that x86 had tolerated.28 Having source creates options. It does not do the platform work by itself.
A Mac port of Need for Speed: Most Wanted uses recomp-kit. The tool translates x86 code into C, which can then compile for ARM64. A separate layer maps the game’s Direct3D 9 graphics calls to Metal on macOS. Moving CPU instructions alone would leave the game without the platform services it expects.29 The reusable kit separates much of that platform work from the game-specific configuration and fixes.30
The same foundation has already reached Need for Speed: Carbon. Its Mac port builds on the Most Wanted project’s setup, mod, and controller work.3132
That is static recompilation: translate the instructions ahead of time and provide the environment they need. Decompilation aims to recover a higher-level representation that humans can work with. N64Recomp makes this distinction explicit. A port can translate machine instructions fairly directly into C without first recovering the original source architecture.33
These projects open different doors into existing software. My OpenGOAL port used a reconstructed codebase. My Zelda patch changed compiled game scripts. Cyberworld Endless supplies new data and adapted routines to a running engine. SkyCraft connects two programs, while a recompilation port translates instructions and rebuilds the surrounding platform.
The common result is that the original release stops being the only practical form of the game. A different device, interface, world, or set of rules becomes something a small project can attempt.
Reverse engineering has always required forming hypotheses and checking them. The difficult part is moving between the evidence: a function in a disassembler, a memory layout, a compiler error, and something visibly wrong in the game. Current agents can carry an investigation across those representations and keep working after the first plausible answer fails.
A shipped game contains a huge advantage for this work: an executable reference. I can give it an input and observe what it does. For some tasks, I can compare the reconstruction against it automatically. The model gets feedback from something outside its own explanation.
It also rarely starts with a featureless wall of bytes. Disassemblers expose instructions and jump targets. Decompilers recover control flow. Symbols, file formats, and community documentation supply further clues. LLM4Decompile already distinguished reconstructing code from assembly from improving Ghidra’s pseudocode in its 2024 research.34 The model has structured material to reason about, even when names and intent are missing.
The model can turn those clues into candidate explanations. Repeated offsets might describe fields in one structure. A group of values might be an enum. A call might trigger a state change. It can write a candidate implementation, test where it disagrees with the original, and revise the explanation along with the code.
Maurice Heumann’s October report shows how much the acceptance test matters. After agents produced readable but incorrect code for a shooter, his team introduced comparisons against the original compiler output. He reports three months of work and 83% of functions matching at the byte level. The code remains private, so this is a detailed practitioner report, not an independently reproduced result. The verifier also needed protection: agents tried to exclude their work from its checks.35
Recent research tests the same principle at a smaller scale. CHISEL feeds compiler errors and differences found by fuzzing back into successive reconstructions. Its evaluation of 120 functions finds improved recovery, although its checks still accept some incorrect candidates.36 A September study likewise found that passing the supplied tests did not guarantee correct behavior on additional inputs.37
Someone still has to decide what counts as correct and build the comparison. In Cyberworld Endless, that means running a battle in its original engine and checking attacks, damage, and state transitions against the transplant. “It compiled” cannot tell me whether the enemy still fights like itself.
The agent does not need to explain every byte of Dungeons of Infinity to move its HUD. It needs the drawing code, the state that feeds it, and the places where the change can break something else. That smaller scope is a large part of why an ambitious-sounding request can become practical.
Repeated structures help too. Once one table entry or family of routines is understood, nearby cases provide patterns to test. Saved findings, scripts, and tests let the work accumulate beyond a single conversation. Independent functions can become separate jobs. Anthropic’s compiler experiment showed both sides of that: agents worked usefully on distinct failures, but collided when everyone encountered the same large blocking problem.38
For me, the big change is the cost of following a lead. The Nova session crossed research, compilation, installation, inputs, screenshots, and repairs. The agent could keep the investigation moving through all of them. A question I might once have abandoned as too much work became a project I could actually finish.
Better models matter, but the surrounding tools matter with them. A model that can reason about a crash is more useful when it can reproduce it. A model that can suggest a patch is more useful when it can run the patched game. Faster code generation becomes much more valuable when wrong turns are cheap to detect.
What worked in my projects was that combination: Opus 5.5, access to the right tools, and enough feedback to check its guesses.
A program running on my own computer has to expose enough of its machinery for the computer to execute it. Keeping the source private can make understanding that machinery expensive. These projects show why that expense is becoming a less dependable barrier.
There is another route as well: reproduce the behavior without recovering the implementation. Give the original an input, inspect the output, and build something compatible. That can matter commercially long before anyone reconstructs an entire application.
MirrorCode tests this route with command-line programs. Agents receive executables, documentation, and examples, then query the originals and build replacements. Hidden tests evaluate the results separately. The results concern those bounded tasks. Many targets are open source, so prior exposure during training remains a limitation.39
Image editors make the practical stakes easier to see. Photon Studio advertises familiar editing workflows and PSD support, with documented limits on how faithfully files survive opening and saving. It is a separate, freely accessible editor distributed under its own restricted license.4041
PhotoCraft takes an openly documented route: a Rust implementation based on public specifications and observed behavior, with source under permissive licenses. Its feature audit is extensive, but the README still calls it an early alpha.4243
The useful question is which work a replacement can carry reliably. Someone making a thumbnail needs a different slice of an editor from a print studio exchanging complex files with clients. A small replacement could become good enough for the first person while remaining unsuitable for the second.
That is where I expect pressure to arrive first. A competitor does not have to reproduce every feature before it removes someone’s reason to pay for the original. Familiar shortcuts, compatible files, and the few operations a person repeats every day can be enough to make switching attractive.
But a familiar toolbar tells us very little about the difficult cases. A file has to survive saving and reopening. Color handling has to remain consistent. Plugins, large documents, and years of accumulated edge cases can matter more than the number of menu commands. Getting the visible workflow right is a starting point for proving compatibility.
Technical access and permission are separate questions. An open-source license grants rights to use, change, and redistribute the work. Reconstructing code does not grant those rights.44 Game assets have their own rights too.
The European Court of Justice distinguished software functionality from protected expression in the SAS Institute case.45 Decompilation has separate rules. Germany’s Section 69e permits it for interoperability under specific conditions and limits the use of the resulting information.46
For my projects, players bringing their own game data keeps the original work visible as a dependency. Distributing a patch still means checking the rights to the particular code and assets involved.
I cannot celebrate cheaper reconstruction without thinking about whose work gets reconstructed. Bringing an abandoned game back and making a near-identical competitor to a new indie game feel very different to me. The same ability can preserve someone’s work or take an audience away from its creator.
My expectation is that keeping implementation details secret becomes less valuable relative to maintaining a product people trust. Original content, a community, dependable updates, support, and a service that works all matter beyond the executable. Those are reasons a product can remain valuable even when parts of its implementation become easier to reproduce.
Server-side logic also sets a practical boundary. Possessing a client does not give me the service behind it, its private data, or the work of operating it.
My next goal for Cyberworld Endless is online multiplayer. So far, it is a proposal: shared Net Squares, visible other players, chip trading, and an arena. The issue explicitly says that no code exists yet.47
That changes the task again. Until now, my director has needed to understand what one engine does. Online, several computers must agree on what happened. Who decides whether a trade goes through? How do battles handle late inputs? What happens when two clients diverge?
The work so far does not solve those problems. It gives me a game worth trying to solve them for.
The industry is already responding. On 13 October, Xbox announced Xbox Labs while explicitly discussing recent decompilations, Apple Silicon ports, browser builds, and games remixed into other games. The announcement proposes experimentation and tools for developers. It is an early response, not blanket permission for fan projects.48
I would like that response to produce more ways into games: documented formats, useful extension points, and room for players to adapt what they own. If people are already finding ways to change the game, helping them do it well seems worth exploring.
I can imagine the same progression elsewhere: a missing accessibility option becomes a patch, a dead platform gets a maintained port, or one excellent mechanic becomes the starting point for a different game. Making those changes accessible to more people is the possibility that stays with me.
There will be plenty of combinations that are funny for thirty seconds. Building something I want to play for thirty hours still takes taste, testing, and a willingness to maintain it. The exciting part is that I can now spend more of my effort finding out whether an idea is good.
I wanted to play a few old games on my handheld. Now I look at them and wonder which version of them I actually want to play.
Official screenshots used for this article’s cover, Sentinel Beach, and collision view.
The decompilation, compiler, and runtime that my Jak port builds on.
My handheld adaptation, with installation instructions, controls, and the screenshots shown here.
The playable project, its downloads, and the ROMs you need to supply.
A documented example of two running games exchanging state.
What still had to change when reconstructed Xbox code moved into a browser.
A recent account of how strict comparisons with the original changed the agents’ work.
A benchmark for recreating executable programs from observable behavior alone, with clear limits on what its results establish.
Xbox’s response to the current wave of ports and game remixes.