AI Game Decompilation and PC Ports: Tools, Prompts and Projects Explained
How AI-assisted game decompilation works, which tools help, how to write verifiable prompts, and how mature PC ports differ from experimental AI projects.
AI can help explain unfamiliar assembly, propose C functions and repeat compile-and-compare cycles. That makes old-game research more approachable, but it does not turn a ROM into a polished PC game with one prompt. For players, a maintained port with the right data requirements is usually more useful than an AI progress percentage. For developers, the productive unit is a small function or runtime bug with a reproducible test.
Why this movement is growing—and what is actually new
The current wave combines coding agents with years of community work on disassemblers, matching projects, renderers and static recompilers. PC Gamer reported the conflict around AI-driven ports in July 2026; more recent community discussion concerns rushed releases and attribution. These reports demonstrate an active movement, not a reliable ranking of the “most popular” tools or a count of stable games.
Treat author-declared AI involvement, independent play reports and release history as separate evidence. A video reaching a title screen proves less than a reproducible build and a complete-playthrough checklist. This review uses official project material and outside reporting; AirMore did not independently play through these games.
Decompilation, recompilation and emulation are different
Matching decompilation reconstructs C/C++ that, with the original compiler and settings, reproduces target machine code. Byte matching is a strong check on the functions and build scope actually compared; it does not recover original comments, design intent or automatically provide a modern operating-system layer.
Static recompilation mechanically translates instructions into host-compilable code. The output may look like register operations rather than normal human-written game logic. It can avoid some runtime CPU translation, but still needs graphics, audio, timing, input, file access and platform services. An emulator instead implements the guest environment while running the original program, often with dynamic recompilation. Native ports can still emulate selected hardware behavior.
An AI recreation from screenshots is yet another task: it approximates visible behavior and may invent unseen logic. Do not call it a matching decompilation. Compiling successfully, matching bytes and playing correctly are three different milestones.
AI tools: agents, Ghidra and the bridge between them
Claude Code: iterative repository work

Useful for reading build instructions, editing a narrow patch and running compiler/tests with approval. Supply relevant assembly and tool output rather than asking it to guess a complete game.
Its availability and model usage limits depend on your plan; an advertised coding capability does not establish game compatibility. Review each patch and respect model restrictions.
Codex: another coding-agent workflow

Can assist with repository analysis, patch proposals and build/test loops. Its value here is repeatable interaction with files and verification tools, not a special “port this console” command.
Record the model and settings when comparing agents. Neither an agent’s confident explanation nor a successful build substitutes for instruction or behavior checks.
GhidraMCP: exposes analysis to an agent

This bridge exposes Ghidra operations such as decompilation, function listing and renaming. Ghidra produces the disassembly/pseudocode; the language model interprets it and proposes edits. The bridge itself is not a game emulator.
Renaming functions can improve navigation without proving semantics. Confirm processor settings and types, keep a copy of the analysis database and review write operations before applying them.
The translation engines beneath the AI headlines
N64Recomp: MIPS instructions to C

A deterministic static translator driven by binary metadata and configuration. Symbol boundaries, overlays and indirect calls need appropriate handling; a runtime and renderer are still needed.
The documented build requires CMake 3.20+, a C++20 compiler and recursive submodules. Building this tool is only the toolchain step, not a universal ready-to-play game port. It does not require an LLM to perform instruction translation.
XenonRecomp: PowerPC instructions to C++

Targets Xbox 360 executables. XenonAnalyse can help identify functions and jump tables, but the README warns that there is no fully generic solution for every jump-table pattern.
It explicitly does not supply the runtime that makes the game work. Graphics shader translation and platform services are additional work. Do not present its existence as proof that an arbitrary title is supported.
Established PC ports: useful benchmarks, not automatic AI credits
Zelda64Recomp: the masked, time-loop adventure

An established static-recompilation reference for the adventure starring a blond, green-capped hero. The repository lists v1.2.2 as its latest release at this check and documents native desktop support, graphics improvements and mods.
The team explicitly prohibits generative AI contributions and states that it does not use them. Do not credit its finished work to AI or submit AI patches. Use a supported original data version; support for the related earlier adventure is not interchangeable with the released game.
Shipwright / Ship of Harkinian: the earlier time-travel adventure

A mature source-port reference built on a decompilation and libultraship, rather than evidence of a new AI breakthrough. The project provides desktop releases and requires a supported original ROM; its compatibility list, not merely a familiar game cover, determines suitability.
For a first run, download the correct release, extract it, launch soh.exe on Windows or the matching application on Linux/macOS and supply the supported copy when prompted. The port prepares its asset archive locally. Distinguish release builds from explicitly experimental continuous-integration builds.
UnleashedRecomp: the blue speedster’s day/night adventure

A substantial Xbox 360-to-PC static port, with Windows/Linux releases and an installer. The README requires supported US/EU game files plus the title update; the Japanese release is not supported. DLC is optional. This is an established technical example, not an AI-authorship claim.
The installer distinguishes containers via Add Files from raw content directories via Add Folder; the latter does not search an arbitrary directory recursively for everything. Preserve unmodified source data and follow integrity checks. Its feature list does not prove every PC configuration or mod is stable.
AI-declared projects: promising results with narrower evidence
LASRecomp: the toy-like island adventure

A more direct example of the AI-assisted wave: the creator publicly described extensive AI use, and the repository documents a static port for desktop platforms. Community attention is substantial, but the creator also acknowledged imperfections.
Treat it as an AI-declared project to evaluate, not a substitute for a fully verified stability report. Check the current release, supported revision and known issues before trying your own data. Do not confuse it with the older no-AI projects featuring a similarly dressed hero.
N64Recomp-browser: an AI-declared web layer

The README says it was written almost entirely with Claude. It adds Emscripten/WebGPU support to an existing recompilation stack, and pages load a player’s own ROM instead of bundling one. This is browser integration on top of prior infrastructure, not proof that AI invented the recompiler.
Its author describes release checklists, but those are author reports, not AirMore playthroughs. Browser/WebGPU support, audio, input, storage and each game’s fork need separate testing. A working web demo should not be described as universal desktop-port stability.
How to start a small, verifiable project
Start with homebrew, public-domain code, your own small game or a project that explicitly accepts AI contributions. Establish the exact binary revision and hash, CPU architecture, endianness, compiler/toolchain and permission to work on it. Keep original data outside Git. Make a baseline build and save its complete log before asking the agent to change anything.
For analysis, install the Ghidra version supported by the chosen GhidraMCP release, import the binary and select the correct processor/language if the format cannot identify it. Run auto-analysis, inspect a known small function and record its address and callers. The checked bridge README specifies Ghidra 12.1.4; install its matching extension through File → Install Extensions, restart, then enable GhidraMCPPlugin in the Developer configuration. Install uv or the documented Python alternative. The configuration below is an MCP-client example, not a universal settings-file path. Keep the bridge on localhost.
Connect one coding agent, confirm it can list functions and read disassembly, and initially approve only analysis operations. Pick a bounded leaf function; export its disassembly, relevant types and callers. Let the agent propose source, compile it with the correct toolchain and compare instructions or differential-test behavior against a trusted reference. Commit only a verified improvement. Never improve a progress number by replacing unimplemented behavior with a success-returning stub.
When the target is a PC port, proceed separately through boot, input, renderer, audio, saving, loading, timing and scene transitions. A translated CPU function does not implement a console SDK. Test original-speed behavior before high-frame-rate enhancements. On a mature existing project, use its pinned build instructions rather than assuming one generic CMake command builds every game.
{
"mcpServers": {
"ghidra": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/LaurieWired/GhidraMCP",
"ghidra-mcp",
"--ghidra-server",
"http://127.0.0.1:8080/"
]
}
}
} Three prompts that produce work you can check
Give the agent an explicit evidence boundary, the target revision, a single task, allowed files and a pass/fail test. Ask it to label assumptions and show commands and real results. The templates below are for code you are entitled to analyze and projects that permit this workflow; replace the bracketed fields with actual information.
If a model refuses a request, explain legitimate ownership and scope accurately or use an original/homebrew exercise. Do not hide the target behind a nickname to evade its restrictions. Descriptive game labels in editorial prose do not change the rights to code or assets.
Prompt 1
Audit only. I am authorized to analyze [target]. Read README and contribution rules first; stop if AI work is prohibited. Record [binary hash], architecture, compiler and baseline build command. Do not modify code. Separate observed facts from assumptions; propose one small function and the verification needed. Prompt 2
Work only on [function/address] in [allowed files]. Use the supplied disassembly, types and callers. Preserve integer width, signedness, overflow, endianness and side effects. Propose the smallest C/C++ change, run [exact build/compare command], and report the real mismatch. Do not change tests, original bytes or compiler settings to force a pass. Stop after [attempt budget]. Prompt 3
Investigate [reproducible port bug] on [build/OS]. Compare expected reference behavior and the supplied trace. Keep unrelated systems unchanged. Add a regression check, show the minimal patch and actual test results. If evidence is missing, request the precise trace instead of inventing behavior. Mark the result unverified until it passes. Choosing a playable build, budgeting and respecting project rules
For playing, prefer tagged releases from the project’s own repository, supported operating systems, an explicit input-data version, recent issue triage and save compatibility information. Back up saves before testing mods or experimental builds. A repository star count or an AI-generated completion claim is not a crash-free guarantee. If you only want to play an established port, you do not need an AI subscription or Ghidra.
For development, budget model usage, repeated compiler runs, manual debugging and full-game testing. Parallel agents can duplicate guesses and edits unless functions have separate ownership. A smaller model may be economical for naming and summaries; use tougher tasks to compare reasoning quality and verified patches, not token speed alone. Keep secrets and unnecessary binary/assets out of cloud prompts.
A project’s source license, original game content and permitted AI contributions are separate questions. Owning a copy does not by itself grant redistribution rights. Use your own supported data, do not distribute ROMs, keys or extracted assets, and respect the project’s contribution policy. Avoid downloading prepacked “everything included” bundles. The practical recommendation is to choose a maintained release for playing and one small, testable, permitted task for learning.
Checked November 16, 2026. Documentary review of official repositories, author statements and outside reporting; no game was independently ported or played through by AirMore. AI-assisted drafting and editorial covers are distinguished from real repository screenshots. Availability and project policies can change.