Reverse-engineering case studies.

This project is a 1:1 disassembly and decompilation of Dragon Quest IX: Sentinels of the Starry Skies for the Nintendo DS. The primary focus is the USA and Japanese versions. European builds are produced from the USA sources.

A Game Boy Color disassembly of Dragon Warrior 3 reconstructs the US ROM from assembly source and extracted game components. Its build takes a user-supplied ROM, produces dq3_en.gbc and compares the rebuilt output with the original.

Reconstructs the US NES release of Dragon Warrior IV as assembly for all 32 physical PRG banks. The project records code classification, labels, pointer recovery, runtime traces, and save evidence, and the author reports a rebuild matching the reference ROM's SHA-256.

Dragon Warrior Disassembly reconstructs the NES game as commented assembly source and includes Ophis to assemble it. A build script can compare checksums between assembled output and original binary files; the author reports that the game’s reverse engineering is complete.

Driver 1 decomp reconstructs Driver: You Are the Wheelman for PlayStation in C while retaining original hand-written assembly routines, and compares rebuilt code with the original executable and overlays. Its Linux port runs the reconstructed game through PsyCross with SDL2 and OpenGL using data extracted from the user's own US Rev 1 disc. The author reports 1248 of 1259 game functions matched across the listed binaries.

Duck Hunt Disassembly reconstructs the game's World release as NES assembly using nesgodisasm and an emulator code/data log. The assembly builds through ca65 and ld65, with a CRC-32 check against the target ROM; RAM-viewer experiments inform its variable notes.

This decompiles Duke Nukem: Zero Hour for the Nintendo 64. The US ROM is named baserom.us.z64. make setup extracts it, and make builds build/us/dukenukemzerohour.z64. The French ROM is baserom.fr.z64 and uses VERSION=fr. The README instructions use Ubuntu 22.04 or WSL2, a MIPS GNU toolchain, Python 3.9 or newer, and splat64. A Docker image dukenukemzerohour contains the same dependencies.

Duke1Decomp contains partial reconstructed source for Duke Nukem 1, accompanying studies of tile rendering, sprite rendering, and collision detection. The author reports that included functions compile with Borland Turbo C 2.0 and Turbo Assembler 1.0 to match the original executable's disassembly exactly.

Duke2Reconstructed rebuilds Duke Nukem II's DOS source in C and assembly from disassembly of the original executable. The author reports that an era-appropriate build produces a byte-identical binary after LZEXE compression, while original names and file organization remain approximations.

Dunk Shot documents the 1986 MSX game's code and data through a commented disassembly generated from a user-provided cartridge image. Its tools trace Z80 control flow, draw graphics from cartridge data, inspect sound pieces and compare the reassembled ROM with the original; the author reports a byte-for-byte match.

dw3-decomp-expanded reconstructs Digimon World 2003 PAL card-game overlay functions as C that compiles to the original MIPS bytes. Each source file records compiler, address and comparison settings, and tools compare it with overlays from the user's disc. The author reports 407 matched functions across CARDGAME, STCRDABM, STCRDDEK and STCRDSHP, with 28 still pending.

The author has Codex use REA’s Ghidra tools to inspect the English DX-Ball 1.07 executable and recover it as typed C/C++, then compiles each function with the original-era Visual C++ 4.0 and compares it byte for byte with the original after mapping relocations. The same source also builds a MinGW Windows game and a portable core library. Exact reconstruction is still in progress; REA’s separate sound-pan showcase covers just one function.

Recover one sound-pan function from instructions and constants; upstream cites 3,205 cases and a 63-byte match.

Elite: Harmless is a full ca65 disassembly of the Commodore 64 release of Elite, taken from the 1986 GMA86 disk, with the code split into flight, docked, text, ship-hull, math, sound and graphics modules. Its build script reassembles the original loader stages and game files, checks them against MD5 sums, and writes a disk image. The same source builds an enhanced variant with a faster multiplication routine and faster line drawing, and a loader document explains the choice of the GMA86 disk and describes the first stage of its copy-protected loader.

EQOA Decomp reconstructs C++ source for PS2 modules of EverQuest Online Adventures: Frontiers. Its tools extract and disassemble functions from user-supplied module images, then compare compiled candidates against instructions, callees and data references. The author reports byte-exact matches across SUPPORT, CLIENT, SETUP, STATION, MCERR and SNDDRV, with remaining functions still open.

Eternal Darkness: Sanity's Requiem is being reconstructed from the USA GameCube release as C source. The repository contains source files, symbol maps and split maps, with a build that reads the user's disc image and an objdiff workflow for comparing objects. The author describes the game and engine code as ongoing work.

This matching decompilation targets Eternal Darkness: Sanity's Requiem for the GameCube, US GEDE01 revision 0. The Redump disc SHA-1 is 2bebaa7a17d69057f8c02fe00349b558abc30ff6. main.dol is 3,156,384 bytes, SHA-1 ea24b6af954876ce072562ff39cdb4c81d32be1f, entry point 0x80005308. The progress table lists 1,265,572 of 2,300,692 code bytes (55.01 percent), 6,285 of 8,214 functions (76.52 percent), and 6,520 of 7,121 objects (91.56 percent).

Eternal Fighter Zero -Memorial- reconstructs source from a locally supplied game executable using Ghidra analysis and a VC7.1 build oracle. Its comparison checks complete COFF function extents after explicitly binding relocation fields. The author reports two exact functions totaling 434 code bytes; the full game and runtime comparison remain unfinished.

EVA-Decomp reconstructs Neon Genesis Evangelion for Nintendo 64 as C and selected original assembly routines. Its build uses historical compilers and a user-provided ROM, then checks the resulting image by SHA-1. The author reports byte-identical output for the main program and eight overlays; a native PC port remains in preparation.

Evo's Space Adventures PSX decompiles the PlayStation game Evo's Space Adventure from an owner-supplied esa.dat executable. Its build extracts and disassembles the executable, then uses GCC, GNU as and maspsx to produce a matching binary; the work is presented as a proof of concept.

Excite Truck is an unfinished matching decompilation of the USA Wii release REXE01. It builds from a user-provided disc image, uses objdiff to compare rebuilt objects, and includes decompdecomp helpers for symbol and function-signature updates. The author reports 9,067 of 13,779 functions exactly matched.

Excitebike 64 reconstructs the LodgeNet, US Rev 1, and European Nintendo 64 releases in a shared C and assembly tree. The build compiles functions at their original addresses, compresses the game image, and checks the rebuilt ROM against each release's SHA-1. The author reports byte-identical results for all three versions; original assets and RSP microcode are taken from user-supplied ROMs.

Extermination reconstructs source for the USA PS2 game's executable and uses a byte-identity build gate across the boot ELF and overlays. Its tools also capture play from the original in a PCSX2 fork, producing input and machine-state traces for comparison with a separate native port.

F-15 Strike Eagle 2 reconstructs C and assembly source for selected executables of the MS-DOS game v451.03 from analysis of the original binaries. Its build uses Microsoft C 5.1 and can compare reconstructed executables with originals through mzdiff. The author reports instruction-level matches for C routines compiled with the original toolchain, while some sound-related executables remain outside the reconstruction.

F-Zero GX is a work-in-progress matching C decompilation of the GameCube game's executable code. Its workflow compares functions with objdiff and linked outputs against retail hashes. The targets include the main DOL, main.rel extracted from the encrypted, compressed line__.bin archive, and screen-specific REL modules.

fzgx reconstructs the GameCube release of F-Zero GX as C matched against the game's executable files. Its primary target is the USA Rev 0 disc, including main.dol, main.rel extracted from an encrypted archive and fourteen other REL modules. The project uses compile-and-diff checks per function and hash checks on the sixteen linked targets.

This is a matching decompilation of the F-Zero X Expansion Kit. The Japanese dump is named baserom.jp.ndd and converted to baserom.jp.z64dd. The README says that file must match the checksum in fzerox-expansion.jp.md5.

F-Zero X reconstructs the Nintendo 64 game's source as a work-in-progress matching decompilation. Its build takes a user-supplied US or Japanese revision 1.0 ROM, extracts assets, disassembles code, and rebuilds a ROM whose checksum is checked. The repository contains game C source and per-version asset layouts.

F-Zero X reconstructs parts of the US Nintendo 64 game in C, alongside assembly extracted from the user's ROM. Its build extracts a user-supplied Z64 ROM and produces a ROM with a published SHA-1 target. The author describes the codebase as early research and says its output is not yet suitable as a general modification base.

f19re reconstructs F-19 Stealth Fighter's DOS EGAME.EXE as a disassembly-derived assembly skeleton and incremental C translations. Its build compares the skeleton byte for byte with the original executable and checks C routines against the original machine code using Microsoft C 5.1.

FableDecomp reconstructs the 32-bit Windows Fable: The Lost Chapters executable as VC7.1-compatible C/C++ source, checking functions against retail bytes and behavior. The repository also records engine and file-format findings and an interactive frontend checkpoint. The author reports a September 2026 snapshot of 8,082 byte-identical functions; a playable reconstructed native engine remains unfinished.

Fallout: New Vegas is being reconstructed from the USA 2010-11-10 Fallout_Release_MemDebug.xex in a work-in-progress decompilation. The project builds source with Python and Ninja and configures objdiff to compare rebuilt objects with the original.

Reconstructs functions from the Japanese PS2 release of Fate/Unlimited Codes in C and compares their compiled code with the original executable. The author reports 1,525 of 5,827 game functions matched; unfinished functions are assembled from the user's own game copy during the build.

FE7 EU decomp reconstructs the European Game Boy Advance release of Fire Emblem: Rekka no Ken with a matching ROM build. It maps symbols from the Japanese decompilation to the EU ROM, splits EU assembly, adapts C candidates and checks the rebuilt ROM against the user's dump. The author reports integrated C functions and further EU-specific recovery in progress.

This repository decompiles Final Fantasy Crystal Chronicles for GameCube. The English build supplied a debug symbol file and the PAL build a release symbol file, which recovered function names, parameters, and class hierarchies. Tracked versions are PAL GCCP01, USA GCCE01, and Japan GCCJGC.

This disassembles Final Fantasy IV for the Super Famicom, released as Final Fantasy II on the SNES. It builds the Japanese 1.0 ROM, CRC32 21027C5D, the Japanese 1.1 ROM, CRC32 CAA15E97, the US 1.0 ROM, CRC32 65D0A825, and the US 1.1 ROM, CRC32 23084FCD.

ff9-decomp reconstructs the US PlayStation Final Fantasy IX boot executable and code overlays as C that the author reports compiles to byte-identical binaries. The workflow extracts data from four user-owned discs, while PsyQ SDK code stays in assembly and separate equivalent C supports port work.

Reconstructs selected Final Fantasy Tactics Advance functions in C while mapping battle AI, abilities, jobs, missions and other ROM tables. The author reports 173 functions compiled to matching bytes; remaining ROM regions are incorporated from the user's original during a hash-checked build.

Final Fantasy Tactics decompilation reconstructs the North American PlayStation release SCUS-94221 as C and assembly source. The author reports that its build reproduces the original disc byte for byte; build checks compare functions against stored hashes, and the repository includes architecture and game-mechanics documentation. It extends an acknowledged earlier decompilation.

This is a matching decompilation of the North American PlayStation release of Final Fantasy Tactics, SCUS-94221. The README says every game function is C that compiles to the original bytes, and the rebuilt disc matches byte for byte.

Final Fantasy V Disassembly reconstructs the SNES game as 65c816 and SPC-700 assembly for Japanese 1.0 and RPGe 1.10 builds. Python tools extract graphics, text and other data from a user-provided ROM, while ca65 and ld65 assemble the project. The author reports that the matching ROM stage is complete and readability work continues.

Reconstructs C source for the US PlayStation release of Final Fantasy VII, aiming for code that compiles back to the original main executable and its game overlays. The build splits the user’s disc files with splat, compiles with period cc1-psx compilers and checks every rebuilt file against its SHA-1. A native build against the PsyZ PlayStation-library replacement is compiled in CI but is not documented as a playable port.

Reconstructs portions of the FINAL FANTASY XIV 1.23b game client for a matching Windows executable build. The workflow splits the user-supplied ffxivgame.exe, compiles recovered C++ and assembly, and checks the output against the original.

fe1 reconstructs part of the NES game Fire Emblem: Shadow Dragon and the Blade of Light as assembly. WLA-DX builds a ROM with a listed SHA-1, using bytes from the user's original ROM where disassembly is unfinished; the tree includes code, data, memory layouts, and build rules.

This decompiles Fire Emblem: Rekka no Ken for the Game Boy Advance, Japanese release. It builds FireEmblem7J.gba, SHA-1 037702b1febd5c9535262165bf030551d153de81.

Fire Emblem: Shadow Dragon reconstructs code for the US Nintendo DS game using ds-decomp. The build uses a base ROM, while objdiff compares decompiled code with the ROM; an ARM7 BIOS dump is needed for a matching ROM build.

fireemblem7u reconstructs the USA/Australia GBA release of Fire Emblem as C source that rebuilds a SHA-1-checked ROM. The author reports byte-matched game functions, while scripts extract graphics, music and other data from the player's ROM; a separate host build runs decompiled C on macOS.

Flicky reconstructs the Sega Mega Drive game's 68000 code and Z80 sound driver as annotated assembly. Build scripts split data from the user's ROM, assemble the source, and compare the resulting cartridge image byte for byte; recorded input movies support runtime checks in MAME.

Reconstructs Fossil Fighters Champions' Nintendo DS battle overlay as C compiled with the original mwccarm toolchain, retaining assembly for unmatched functions. The author reports 1,141 of 1,382 overlay functions build-verified, and the repository documents accuracy and damage behavior.

fsa reconstructs The Legend of Zelda: Four Swords Adventures for GameCube as byte-matched source. Its build checks compiled game and library units against the original main.dol; the author reports partial game-code matching and a byte-identical linked DOL for the completed split units. Library code is partly imported from other decompilation projects.

Freelancer reconstructs C++ source for the game's Patch 1.1 executables and DLLs as a work-in-progress decompilation. Its configurations split individual modules, while engine libraries within scope are reimplemented in the separate Liberty project.

Friends of Mineral Town reconstructs the US Game Boy Advance release of Harvest Moon: Friends of Mineral Town from C++, C and assembly source. Its build produces a ROM with a stated SHA-1 target, and the setup uses a user-supplied base ROM for comparison.

The project reconstructs Frogger's Adventures: Temple of the Frog for Game Boy Advance as C and assembly compiled with agbcc. Its build extracts data from a user-provided USA baserom and checks the output ROM by SHA1. The author reports a byte-identical build while substantial code, naming and data reconstruction work remains.

FROGMAN reconstructs a BBC Micro platform game as annotated 6502 BeebASM source. The author dumped memory after the encrypted loader ran in an emulator, disassembled and labeled the game code, and reports byte-exact reassembly. The repository also documents memory layout, level maps, and the loader's XOR chain.

F-Zero GX reconstructs C source for the GameCube game's main.dol and REL modules, comparing builds with retail files. Its tools extract and unpack main.rel from the user's disc image, while unmatched functions are linked from that copy; the author reports roughly 30% of code matched.

gagarin reconstructs the Command & Conquer: Red Alert 2 — Yuri's Revenge engine from retail gamemd.exe v1.001 with the MSVC 6.0 compiler. At source snapshot ce91a761 (2026-10-27), 10,307 of 19,778 functions are matched (52.1 percent) and 784 more are partial. Matched bodies cover 716,425 of 3,878,653 listed function bytes. The target image's SHA-256 is recorded in reccmp-project.yml.

cannon-seed reconstructs C source for Galaxian³: Project Dragoon on PlayStation across Japanese and European boot executables and game payloads. Its build pipeline splits target executables, compiles candidates with a pinned toolchain, and compares rebuilt images with retail SHA-1 hashes. The repository also retains assembly for nonmatching functions.

Galaxy on Fire 2 reconstructs C++ for the Android game's Abyss Engine library, libgof2hdaa.so. Its NDK r18b build compiles ARM objects, links a shared library and compares functions and symbols with the original; notes record unresolved type and control-flow matches.

The Ganbare Goemon 3 project reconstructs the Super Famicom game's ROM as assembly, with bank maps and notes on asset, compression and text formats. Its build extracts required data from the user's unmodified v1.0 ROM and can compare the result with the documented SHA-1.

Gangstar: West Coast Hustle is being decompiled from its Android ARM library libsanangeles.so into C++ intended to reproduce retail bytes. The project maps symbols and original source-file names, stores unmatched functions as named assembly, and records matching work by gameplay area. The author reports 4,661 game functions in scope and 24.40% matched bytes.

Garigari reconstructs the USA Wii release SB4E01 Rev 0 of Super Mario Galaxy 2 as C and C++ source. Contributors build against main.dol extracted from their own game and use objdiff to compare compiled objects and functions with the original binary.

This is an in-progress decompilation of Gauntlet Legends for the Nintendo 64, US release. The ROM is named baserom.z64. A matching build reports CIC-NUS-6102, CRC 0x729B5E32 and 0xB728D980, and OK for the boot, tower, transitions, boss, and game segments.

The George of the Jungle and the Search for the Secret decompilation reconstructs the USA PS2 game's main CPU code with a byte-matched assembly baseline and selected C/C++ functions compared against the retail executable. Its tooling extracts boot files from the user's disc, builds a hybrid ELF and reports function-level byte matches; the author reports 24,396 matched C/C++ code bytes.

This is a matching decompilation of Gex 64: Enter the Gecko for the Nintendo 64, USA release. The ROM is named gex64.z64 and must be big-endian Z64. make split extracts it, make build rebuilds it, and make diff must match the original before a change is submitted. Most of the game compiles without -mips3. Some files require -mips3.

gh3-decomp reconstructs the USA PlayStation 2 release of Guitar Hero III: Legends of Rock as C++ compiled with the game's original compiler. Its build extracts the executable from the user's disc image, splits it, and compares the linked result byte for byte; the author reports that 28.78% of game code is matching C++.

Giten reconstructs the 1999 Windows DDS.EXE of Giten Megami Tensei: Tokyo Mokushiroku in C and C++, comparing functions with retail output from MSVC 5.0 SP3. The build takes original resource payloads from a user-supplied executable. The author's MAX score reports 2,626 of 2,659 target functions exact, while the current score is 2,581.

Glover reconstructs part of the North American N64 game's code in C alongside assembly segments. Its build takes a user-provided base ROM, and its progress script classifies functions using the built ELF and locally generated nonmatching assembly files.

god-hand-decomp reconstructs the NTSC-U PS2 release of God Hand as C/C++ that is checked against the retail boot ELF. It starts from assembly generated by splat, replaces functions individually, and uses objdiff plus a full-file SHA-256 comparison to track matching output. The author reports that the current build remains byte-identical to the retail boot ELF.

Goemon's Great Adventure reconstructs the Nintendo 64 US game's code as C and supplies tools to rebuild its ROM from a user-provided copy. The author reports that the reconstructed ROM matches the original byte for byte and that all 5,838 game functions match at the instruction level. The build extracts assets from the user's ROM and rebuilds them alongside the code.

Golden Sun reconstructs source for the USA GBA game from an earlier disassembly and checks a rebuilt ROM against the original. Its patched GCC 2.96 build also compares all 96 code overlays, while C source, assembly fragments, linker scripts, and symbol maps track the ongoing recovery.

Reconstructs GoldenEye 007’s Nintendo 64 code as C source that rebuilds the US, Japanese and PAL ROMs. Assets come from a user-supplied US ROM, with Japanese and PAL differences taken from their own ROMs, and the default build compares each output with a recorded SHA-1. The README still calls the project work in progress, while a mutable status page reports all 208 files done; it is distinct from the separately curated PC port.

gt2-reversing reconstructs code for Gran Turismo 2's PlayStation release from the North American 1.2 simulation disc. Its build produces the SCUS_944.88 executable and six overlay executables from user-supplied originals, while the source tree contains C implementations, symbols and split configurations.

gt3-decomp reconstructs C and C++ for Gran Turismo 3: A-Spec's PS2 CORE.GT3 executable, NTSC-U v1.00. It compiles functions with the original ee-gcc toolchain, checks instructions per function, and SHA-1-compares a full build that combines matched source with disassembly from the user's executable; the author reports partial matching progress.

Decompiles Gran Turismo 4’s PS2 engine executable (CORE.GT4, NTSC-U v1.01) into one C or C++ source per function for Sony’s ee-gcc 2.96, matching public libraries such as newlib and Expat from their own source. The README credits AI agents (Anthropic’s Claude) driving the project’s tools with most of the matching, each function accepted only on a compiler-and-judge comparison, and reports 95.4% of functions and 83.6% of code bytes matched for an October 2026 commit. A local full build links sources at their original addresses, fills the rest from disassembly and compares SHA-1 with the user’s executable.

Greenwood reconstructs Robin Hood: The Legend of Sherwood v1.1 as C++ intended to compile into byte-identical machine code with Microsoft Visual C++ 6.0 SP6. The repository contains game-specific source for actors, artificial intelligence and other systems, and uses compiled-function comparison tools to track matching progress. The author reports 4,723 of 6,113 game functions decompiled.

GT Advance 3 reconstructs the US Game Boy Advance ROM from C, assembly and registered data generators. The author reports an 8 MiB byte-identical build and tracks compiler-generated C matches separately from assembly-backed functions and preserved data payloads.

Guild Rebrew reconstructs Europa 1400: The Guild as C89 source built with the original MSVC6 toolchains. Rebrew workflows compare functions, data and layout against a server DLL and two client executables. The author reports a byte-identical server build; the two client reconstructions remain incomplete.

GX Spirit Caller Decomp reconstructs Yu-Gi-Oh! GX Spirit Caller for the European, US and Japanese Nintendo DS releases using C and assembly. The author reports byte-identical ROM builds across all three regions; much matching assembly still awaits conversion into readable C.

A work-in-progress matching decompilation of Halo 2 for the original Xbox: contributors write C and C++ that the period compiler, building the whole program with link-time code generation, must turn back into the retail executable's bytes function by function. The README reports just under half of the game-function bytes matched and leaves a native port for a later stage. It discloses that much of the maintainer's work runs in Claude and Codex coding-agent lanes.

Hamtaro: Ham-Ham Heartbreak reconstructs the European AH3P revision 0 GBA game as C and assembly that builds a specified 16 MiB ROM. Its technical notes cover startup, graphics, actors, scripts, text, sound and saves, and describe ROM equality checks against the original image.

Harry Potter and the Half-Blood Prince — Decompilation reconstructs functions from the Windows hp6.exe as C and readable MASM, then compares rebuilt machine code with the executable. A Capstone-based tool emits C candidates from x86 control flow; the author reports 4,689 exact function matches among 10,992 inventoried functions.

HPSS-Disassembly reconstructs the Game Boy Color Harry Potter and the Sorcerer's Stone as RGBDS assembly. It uses a specified user-dumped ROM as baserom.gbc and offers a compare target that checks the rebuilt hpss.gbc against stored hashes.

Harvest Moon 64 Decomp is a matching decompilation of Harvest Moon 64. The README says the US and Japanese versions are fully decompiled, including game functions, data, rodata, library functions, and the DSL for cutscenes and dialogue.

Harvest Moon GB Disassembly reconstructs the Japanese Game Boy release as banked assembly. The project tracks named labels and gives an MD5 reference for the compiled game while its disassembly remains in progress.

Harvest Moon: Back to Nature reconstructs the USA PlayStation release SLUS_011.15 as matching C source. It rebuilds the executable and 13 overlays byte for byte, and can check a full disc image against SHA-1 hashes when supplied with the user's disc. The build records one SDK-word patch and original padding bytes as exceptions.

backtonature-decompiled reconstructs the US PlayStation release of Harvest Moon: Back to Nature as C that compiles to a byte-identical SLUS_011.15 executable. Its build generates reference assembly and game data locally from a user-provided copy, then checks individual functions and the full executable.

This rewrites Harvest Moon for the SNES, USA, as C and checks every routine against the original. The progress line says 45,176 of 45,176 instructions and 778 of 778 routines match. The USA ROM SHA-256 is 73a3aa87ddd5ce5df5ba51292316f42b6e128280179b0a1b11b4dcddc17d4163. Release v0.2.0-beta runs on Windows, macOS 11 or newer, Linux x86-64, and Android 8 or newer. The Windows program is HarvestMoonNative.exe.

Reconstructs Hey You, Pikachu! for N64 as C with retained assembly for low-level routines, using AI assistance and a SHA-1 comparison against the retail ROM. Documentation traces its voice interaction, actor scripts and runtime architecture.

Reconstructs Fatal Frame’s PS2 executable as C for the US, EU and Japanese releases, built with the original EE-GCC 2.9 toolchain and checked by SHA-1 against the user’s own executables. Committed objdiff reports list the US and EU code as fully matched and the Japanese code as partial, and a few routines still rely on assembly or byte patches. Porting to modern hardware is a stated later goal, not part of this repository.

Homeworld2Classic reconstructs Homeworld 2's executable and DLL modules in C++ as an ongoing decompilation. Its source tree contains game and platform code, and the project publishes objdiff matching reports for Homeworld2.exe and individual libraries. The author describes the work as unfinished.

homm1-decomp reconstructs the Buka 2003 Heroes of Might and Magic game and scenario editor as C++ source using the original Visual C++ 6.0 SP5 toolchain under Wine. The author reports that HEROES.EXE and EDITOR.EXE rebuild byte-identically and that every targeted function matches. The repository also documents earlier Windows 95 versions, matching tools and compiler behavior.

Hot Shots Tennis: Get a Grip reconstructs the PSP game's main executable and Game Sharing program in C and C++. It compiles candidate functions with the original compiler and accepts exact-byte matches; the author reports 12,780 matched functions across the two game modules as of 2026-11-02.

Reconstructs functions from a Hot Wheels PC game executable as C++ and compares compiled results with the original through objdiff. Ghidra-derived function addresses, sizes, symbols and relocations guide the per-function work.

HWDE-decomp reconstructs functions from Hyrule Warriors: Definitive Edition update 1.0.1 as C++ intended to match the AArch64 main module. Its checker compiles source with specified Clang flags, resolves relocations, and compares function words with an original module extracted by the user.

Hybrid Heaven reconstructs the 1999 Nintendo 64 game as C that is compared byte for byte with a user-supplied ROM. The repository includes function matching, register tracing, ROM packing and agent orchestration tools, plus per-batch research on model-assisted decompilation. The author reports 78.75% of code bytes matched at the stated update.

Hybrid reconstructs the Japanese 5.877 PlayStation game's P69.EXE as linked assembly, C and classified data. The author reports an exact hash match for the rebuilt executable, while only a small portion is matching C; the repository also documents recovered MUF material and LEV level structures.

Hyper Street Fighter Zero Gold reconstructs the hidden PS2 game Hyper Street Fighter Zero as C source, with one file per matched function. Its round-trip tools compile the recovered C, assemble remaining code, link a full image and compare it byte for byte with the user's original. The author reports the project is about 91% complete; a native PC hardware-abstraction layer remains unfinished.

hyperblade-decomp reconstructs the HyperBlade HYPERX.EXE v1.0.0.1 source and scores byte matches per function with reccmp. Its source is organized by game subsystem and compiled with Visual C++ 6.0 SP3; a separate bring-up build runs a basic game mode. The author reports that most game functions match exactly.

Rebuilds the boot ELFs of ICO’s PAL (SCES-50760) and Japanese (SCPS-11003) PlayStation 2 discs from one source tree with the game’s original compiler versions, and checks that every loaded byte and the whole ELF file match the disc’s SHA-1. The 73 data-only archive members are generated at build time from the user’s own ELF, so most read-only data still comes from the disc rather than from source. Separate branches target the USA, Korean and August 2001 prototype builds, and the catalog’s ICO PC port is a fork of this tree.

Illbleed decomp reconstructs the Japanese Dreamcast game's executable from a user-supplied disc. Its scripts generate per-function SH-4 assembly, maps and model information, then compare rebuilt bytes and test recovered C for behavioral equivalence. The author reports 2,049 named functions and no completed C functions in the published progress table.

Imperialism reconstructs the 1997 Windows game's executable as ABI and behavior faithful C++ using Ghidra evidence, the original MSVC 5.0 toolchain and reccmp comparisons. A separate Rust implementation imports retail files and uses process-isolated differential tests against named behavioral captures.

This decompilation reconstructs C source for the 1.0 and 1.2 releases of Indiana Jones and the Infernal Machine. The game's original compilers rebuild source files, whose code, data and layout are checked against slices of a user-supplied Indy3D.exe; the resulting executable is checked by hash. The author reports a byte-identical rebuilt executable that includes small library sections and unused bytes copied from the original input.

This is a commented disassembly of Jackal for the NES. Graphical data is omitted. With ASM6n and the original ROM supplied as input, the code assembles back to that ROM. Version 1.0 says the enemy logic and the main bank are documented, and that the sound engine in bank 0 still needs work. The ROM layout is in Main.asm.

Tiger Electronic Toys' 1982 Atari VCS game Jawbreaker is disassembled into labeled and commented 6502 assembly that compiles to the exact ROM image. Notes explain how sprite positions are kept as combined fine-motion and coarse values and how an inverted playfield masks the maze, and record that joystick input is read from $0288 instead of SWCHA; assembler switches select an NTSC or PAL build and an optional no-defeat mode.

An early matching decompilation of the North American standalone Xbox release of Jet Set Radio Future, hosted on Codeberg. Contributors delink default.xbe into per-source object files in Ghidra, then write C++ that compiles to matching objects with Visual C++ 7.0, compared with objdiff. Its README reports 1.50% of the XBE decompiled so far and disallows contributions made with large language models.

Kanken Training 2 decomp reconstructs the Nintendo 3DS game's code.bin as C/C++ compiled with an ARM toolchain and compared byte for byte with the original. It records function analysis, matching recipes and checkpoint results. The author reports 2,832 accepted matching functions out of 4,545 creditable functions; readability work remains.

Karateka reconstructs the 1986 DOS game's MZ executable as modular x86 assembly. Its build assembles the sources with NASM and compares the result byte for byte with a user-supplied KARATEKA.EXE.

Reconstructs the PlayStation game Kaze no Notam as C compiled with PSX-patched GNU C and maspsx. The author reports that all 648 game functions pass isolated byte comparisons and that the executable rebuild is byte-identical; PsyQ SDK code remains in assembly.

kfiv-decomp reconstructs King's Field: The Ancient City's USA PlayStation 2 executable as matching C and assembly. Its build extracts a user-supplied disc, splits the executable with splat, and checks the linked ROM SHA-1; the author reports a byte-identical result while much game code remains assembly.

Kid Icarus: Of Myths and Monsters reconstructs the Game Boy game's code and data as a documented RGBDS disassembly. The build uses an owner-supplied baserom.gb, extracts graphics and assembles a ROM; the project gives an MD5 value for checking the result.

Kingdom Hearts 2 Final Mix reconstructs C++ source for the PlayStation 2 game's main ELF. Contributors add function symbols and implementations, rebuild with the project's compiler setup, and compare objects in objdiff. The author reports recovering class definitions and file layout from an E3 kiosk demo PS3 port of Kingdom Hearts 2.

Reconstructs the ARM9 program and overlays of the EU Nintendo DS release of Kingdom Hearts 358/2 Days as C that recompiles byte for byte with CodeWarrior. README reports all 306 modules byte-identical, with about 99.5% of functions in real C and library assembly counted separately; the ARM7 binary is outside its scope. The repository holds no ROM, game assets or extracted disassembly and produces no playable build.

This is a matching decompilation of Kingdom Hearts: Chain of Memories for the Game Boy Advance. It targets the US, Japanese, and European versions.

Kirby Air Ride reconstructs a GameCube main.dol from C and assembly source for the US/Korean release. Its build targets a stated SHA-1 and uses a user-provided clean DOL with GameCube SDK and CodeWarrior tools.

KAR reconstructs Kirby Air Ride code for the USA, Japan and Europe GameCube releases using decomp-toolkit and CodeWarrior build settings. It keeps source, symbols and split metadata for comparison with the user's extracted discs; data-split notes describe source ownership inferred from strings, cross-references and layout.

Kirby's Dream Collection is a work-in-progress decompilation of the USA Rev 0 Wii release. Its build uses reconstructed C and C++ source and an owner's disc image to produce main.dol. The tree includes symbols and splits and generates objdiff configuration for comparing rebuilt object files with the original.

This repository is a work-in-progress decompilation of Kirby's Epic Yarn. The supported version is RK5E01, the USA revision 0. The tree contains no game assets or assembly.

Kirby's Tilt 'n' Tumble is represented as banked Game Boy Color assembly built with RGBDS. The repository includes assembly for the cartridge banks and a Makefile target that compares the rebuilt ROM with a stored MD5 reference.

Kirby: Nightmare in Dream Land decomp reconstructs the USA Game Boy Advance game in C with small runtime sections retained as labelled assembly. The author reports a byte-identical ROM build checked by SHA-1, plus shift and emulator boot checks; graphics, audio and other assets are taken from the user's own cartridge dump.

This is a matching decompilation of Klonoa 2: Lunatea's Veil for PlayStation 2, NTSC SLUS_201.51. Debug symbols came from the executable on Demo Disc 2.3. The README says ee-gcc 2.9-991111-01 produces matching code most of the time, and that the project is early and may fail to build.

Klonoa: Empire of Dreams reconstructs the USA Game Boy Advance game as C that aims to build a byte-identical ROM. It generates assembly for unfinished functions from the user's ROM, replaces functions with C, checks the ROM hash and records emulator experiments about game behavior.

lbtvg reconstructs C++ source for the 2008 PC game LEGO Batman: The Videogame and compares builds against a reference executable. The project includes game-specific source, build configuration, and scripts for binary analysis and matching. The author reports 18.53% match progress; reference binaries are supplied locally by the user.

Legaia2-Decomp reconstructs the PAL PlayStation 2 release of Legaia 2: Duel Saga as readable C with a byte-for-byte executable match as its goal. Its tree includes recovered source, Ghidra scripts, build tools and a browser viewer for models, textures, audio, motions and effects from the user's disc image.

A matching decompilation of Legend of Mana on the PlayStation. The user supplies the North American executable SLUS_010.13, SHA-1 d11dfdd50d412ac3fa3e2eb80fbde138da118f27; make verify-bins checks the rebuilt main executable and overlays against the disc files.

LEGO City Undercover Decompilation reconstructs functions from the Nintendo Switch game in C++. The project uses symbols from the game's dumped main executable and checks rebuilt functions against the original binary, with contributor instructions for analysis in IDA or Ghidra.

Reconstructs the English LEGO Island 1.1 source for its original 32-bit Windows target. The project distinguishes function-comparison reports, ReproBit’s reported byte-identical retail rebuilds and ordinary developer builds; its modern portable adaptation is a separate repository.

LEGO Racers reconstructs the 1999 game's 32-bit Windows executable and GolDP.dll as C++ source, comparing rebuilt functions with the retail machine code through reccmp. The author reports that the game executable is almost fully decompiled and playable, while the software renderer remains unfinished.

LegoCloneWarsWii reconstructs code for the Wii release of Lego Star Wars III: The Clone Wars, targeting USA and EU Rev 0 debug builds. It configures a build from the user's disc image with Python and Ninja and supplies objdiff configuration for comparing compiled objects during decompilation.

Link: The Faces of Evil Decompilation reconstructs the Philips CD-i game's cdi_link main program as C source. Its build compiles functions with Apple MPW C 3.0, places them in the module and compares the resulting SHA-1 with the original from a user's disc. The author reports matching builds for English, French, German and Dutch releases.

LittleBigPlanet PSP reconstructs code from the game's UCUS98744 disc version 2.00 executable as C and C++. Its checker compiles each source with a recorded compiler profile and compares the resulting function bytes with the original. The author reports 5,020 individually matched functions; a whole-module build of the published proofs has not been measured.

Lode Runner is mapped as named, documented ZX Spectrum 48K assembly covering the loader, play loop, actor states, editor, and data. The build uses SjASMPlus and checks a byte-exact output with embedded MD5 references or a binary diff against the original.

LSD: Dream Emulator reconstructs the Japanese PlayStation release SLPS-01556 in documented C source. Its build uses the user's retail disc and Psy-Q SDK inputs, then checks the output SHA-1; the author reports that every game function is completed and the executable matches byte for byte.

lsd-decomp reconstructs C source for the SLPS-01556 PlayStation release of LSD: Dream Emulator and checks the rebuilt executable by SHA-1. It documents the dream graph, links, randomness and engine systems with function addresses, alongside emulator-based observations; the author reports that all game functions rebuild to the retail bytes.

LSD Decompiled is an early-stage C decompilation of the PlayStation game LSD: Dream Emulator. Its documented workflow uses a user-supplied game executable and a MIPS cross-toolchain, then checks the rebuilt executable's hash. Many functions and filenames are still being identified.

lsddecomp is an early decompilation of selected code from the PlayStation game LSD: Dream Emulator, with research on its dream timer. Its workflow extracts game data from the user's SLPS_015.56 file, rebuilds the executable and compares the result; the author describes the decompilation as assumption-heavy.

LSUSDISASM documents the US Landstalker ROM as organized 68k assembly and data descriptions. Its split script extracts omitted binary chunks from the user's original ROM, and its build script reassembles the source with those chunks. The author reports a bit-identical rebuilt ROM.

The archived Luigi's Mansion project reconstructs source for USA, Japanese and two PAL GameCube revisions. It builds from a user-provided disc image and provides objdiff configuration to compare reconstructed objects with the originals; its README points to a newer continuation.

MadagascarDecomp is a work-in-progress C++ decompilation of the 2005 game Madagascar. Its build uses Visual C++ Toolkit 2003 and RenderWare Graphics SDK, with reccmp scripts for comparing compiled output to an original Game.exe.

Madden Football 64 decompilation reconstructs portions of the USA Rev 0 Nintendo 64 game's code and maps its packed ROM layout. Build commands recover the resident program, compare compiled C units byte for byte with retail code and track assembly references separately. The author reports 19.60% of whole-program code as matching decompiled C at the documented snapshot.

Mafia-RE decompiles Mafia: The City of Lost Heaven (Illusion Softworks, 2002) for versions 1.0, 1.1, 1.2, and Steam's 2010 setup rebuild. Version 1.2 is the main target. The README says rw_data.dll, IJoy.dll, and setup.exe already build byte-for-byte with the original toolchains, while Game.exe has been started.

Recreates a C source base for The Legend of Zelda: Majora’s Mask from information in the game and static or dynamic analysis, then rebuilds the US Nintendo 64 ROM. The build takes assets and assembly from a user-supplied ROM and checks the output against stored MD5 checksums. The team states it will not produce a PC port; the separately curated Zelda 64: Recompiled only credits it for headers and some functions.

Mario & Luigi: Partners in Time is a work-in-progress C and C++ decompilation of the European Nintendo DS release, generated with AI under human direction and supervision. The author reports a byte-for-byte ROM rebuild; matching source is gradually replacing assembly, with emulator checks used to confirm game behavior.

This is a decompilation of Mario & Luigi: Superstar Saga for the Game Boy Advance, US version. It builds mlss.gba, SHA-1 7c303cdde5061ee329296948060b875cb50ba410.

Mario & Luigi: Superstar Saga is a matching decompilation of the European GBA release using C compiled with agbcc. Configuration generates comparison assembly from the user's ROM. Decompiled functions are compared with their original instructions, while undecompiled functions come from generated assembly. The author reports a byte-identical combined ROM build.

Mario Bros. reconstructs assembly for the Atari VCS release and provides a script to extract required assets from a ROM. The project says the disassembly should produce a one-to-one ROM image and includes C-like comments explaining control flow.

This matching decompilation of Mario Golf for the Nintendo 64, North America NMFE revision 0, rebuilds the original ROM byte for byte. baserom.z64 has SHA-1 e2c4e7a905b29529b49a1619a401fe699224829b. make setup downloads the KMC GCC 2.7.2 and binutils 2.6 toolchain. make extract splits the ROM with splat. make writes build/mariogolf64.z64 and checks it against the baserom.

Mario Kart DS decompilation reconstructs the US and European Nintendo DS releases in C for byte comparison with the original game code. The build uses ds-decomp, Metrowerks CodeWarrior through wibo, and objdiff; the author reports matched-code progress of 83.30% for the US release and 83.60% for Europe.

mkds-decomp incrementally reconstructs the European Mario Kart DS ARM9 code in C. Candidate functions are compiled with mwccarm, compared against cartridge bytes with relocation checks, and incorporated into a ROM rebuild checked by SHA-1. The author reports that unmatched spans remain original-byte gap objects during the partial reconstruction.

A work-in-progress matching decompilation of Mario Kart Wii that targets the PAL release (RMCP01), rebuilding main.dol and the StaticR.rel module from C and C++ with Metrowerks compilers and checking both against stored SHA-1 values. The build splits these binaries from a user-supplied disc image, and objdiff compares objects during development. The README’s progress badges point to a decomp.dev page that did not resolve at review, and the default branch was last updated in September 2025.

This is a work-in-progress decompilation of Mario Kart Wii. The supported version named in the README is the PAL release RMCP01.

A work-in-progress 1:1 decompilation of Mario Kart: Double Dash!! that rebuilds the GameCube main.dol of the US debug build (MarioClub_us) from C and C++ with the original Metrowerks compilers, checking it against a stored SHA-1. The build splits the binary from a user-supplied disc image, and objdiff compares objects during development. decomp.dev reported 47.09% of code matched at the reviewed commit; a European retail target is configured but marked as not working yet.

Mario Party 2 reconstructs the US Nintendo 64 game as C source and assembly mapped to ROM addresses. Its build requires a supplied baserom.us.z64, uses Splat to split the ROM, and configures comparison with the rebuilt output.

Mario Party 3 reconstructs the US Nintendo 64 game's code as C while generating assembly for unmatched functions from the user's ROM. Its build uses Splat for ROM splitting, compiles the source, and includes comparison and SHA-1 checking workflows.

Reconstructs Mario Party 4’s GameCube main executable and REL modules as C source that rebuilds both USA releases. The build analyzes the user’s own disc image and checks every linked output against version-specific SHA-1 lists. PAL and Japanese work is stale and no PC port exists yet; matching results remain project-reported here.

Mario Party 6 reconstructs source for the GameCube USA Revision 0 main executable and REL modules. Its build uses files extracted from the user's disc, compares reconstructed objects with objdiff and checks rebuilt output against retail SHA-1 hashes; source recovery remains incomplete.

This is a matching decompilation of Mario Strikers Charged for the Wii. The USA revision 1, R4QE01, is reported complete: 100 percent of the code matches and links. Its main.dol SHA-1 is e96d2298067b70652752145b4e63644e6e1b1560. Europe, Japan, and Korea are also configured.

mssb-dtk is an in-progress decompilation of Mario Superstar Baseball's USA Rev 0 release. It includes C source, symbol and split maps, and decomp-toolkit configuration. Its objdiff workflow compares rebuilt objects with objects derived from the user's extracted game files.

Mario Tennis (GBC) reconstructs the USA and Europe Game Boy Color releases as named RGBDS assembly. The build extracts graphics, audio and other data from a user-provided ROM, then reassembles and compares the result with the retail image; subsystem notes cover game logic and data formats.

Mario vs. Donkey Kong is disassembled into ARM assembly and C sources that build a Game Boy Advance ROM with a specified MD5 hash. The build uses a user-provided US ROM, devkitARM and pokeruby-tools.

This is a byte-for-byte disassembly of Mario Bros. for the NES. It covers the NTSC World release, the PAL European release, and a GameCube version. It assembles with cc65. Graphics are ripped from a ROM with the Python script in misc/.

mnroi reconstructs C/C++ source for the US GameCube release of Marvel Nemesis: Rise of the Imperfects. Its build uses a project-specific decomp-toolkit fork, a locally supplied disc image and compiler configurations that the author says produce a matching main.dol.

Starts a matching decompilation of the North American Dreamcast release of Marvel vs. Capcom 2: New Age of Heroes. Its tools extract and descramble 1ST_READ.BIN, split SH-4 code and data using a configuration map, and compare reconstructed C against the retail executable.

Marvel vs. Capcom 2 reconstructs the NTSC-U PS2 game's code as C checked byte for byte against the retail executable, then compiles that code for a WebAssembly and WebGL2 port. The author reports 99.93% code coverage, a byte-exact ELF rebuild and end-to-end browser play; desktop ports are planned.

Medabots: Rokusho Version reconstructs the USA Game Boy Advance game's functions as C compiled with agbcc. Its build inserts graphics, sound and other data from the user's baserom, then compares the resulting ROM with the original. The author reports all functions decompiled and a matching ROM build; module reorganization continues.

medarot1-pc disassembles parts of Medarot Parts Collection for Game Boy and maintains text, tilemap, and tileset extraction tools for a translation workspace. Its build overlays the reconstructed parts on a user-supplied ROM and compares the output with the original.

medarot reconstructs portions of the Game Boy game Medarot Kabuto in assembly while importing unreconstructed ranges from baserom.gbc. Its RGBDS build compares the resulting ROM against that base ROM.

Decompiles the US PlayStation release of MediEvil toward C source that rebuilds its main executable, game executable and 26 overlays. splat splits the user's own disc files, and the default build compares all 28 outputs with SHA-1 checksums. README describes the project as a work in progress and publishes no progress figure.

Mega Man 3 reconstructs the US NES game as annotated ca65 assembly across its code banks. The repository also documents the frame loop, entity logic, collision, MMC3 bank switching and data table formats. Its build produces a ROM that the author reports matches the original byte for byte.

Mega Man 9 is being reconstructed as C source for the US WiiWare release WR9E, with the original CodeWarrior toolchain used to match game functions. The build combines reconstructed units with split original objects and compares the resulting DOL against the target SHA-1. The author reports 1,760 exact game-function matches out of 2,941; source remains split by function.

This is a matching decompilation of Mega Man X4 for PlayStation. The same C source builds byte-matching executables for the US release SLUS_005.61, the Japanese SLPS_009.02, and the European SLES_011.76, plus a native Linux port for the US and Japanese versions. The Sega Saturn build is non-matching.

mmx5 reconstructs C source for the US PlayStation release of Mega Man X5. Its build uses a period toolchain and original link order to compare the boot executable SLUS_013.34 and code overlays inside ROCK_X5.BIN with a user-supplied disc dump.

mmx6 reconstructs the US v1.1 PlayStation Mega Man X6 boot executable and ROCK_X6.BIN code overlays as C source. Its build uses the era's toolchain and checks each produced binary against the original hash; the repository includes source, overlay configurations and matching workflow documentation.

Decompiles the PS2 executable and 40 overlays of Silent Hill 3 (NTSC-U v1.02) into C for Metrowerks CodeWarrior, and works alongside on the Silent Hill 2 engine, whose debug symbols from a 2001 prototype supply original names for shared code. Builds link with generated assembly for unmatched functions and are checked by SHA-256 against committed hashes. The README calls the project early-stage; decomp.dev reports about 9% of Silent Hill 3 functions and 58% of Silent Hill 2 functions matched at the pinned commit.

meteor-decomp reconstructs functions and network behavior from five FINAL FANTASY XIV 1.23b Windows client executables. It combines byte-matching C++ work with Ghidra analysis of vtables, packet dispatch, Blowfish lobby encryption and resource-pack chunks; the author reports partial matching coverage and unresolved work.

This disassembles Metroid II: Return of Samus for the Game Boy. The assembled ROM has MD5 9639948ad274fa15281f549e5f9c4d87. The documented tools are rgbds 1.0.1 and Python 3.13.

Reconstructs C++ source for Metroid Prime’s GameCube executable and its NES-emulator module so that CodeWarrior builds match the originals, across the USA, Korean, PAL and Japanese releases, with early configurations for demo discs and three Wii releases. Matched units are compiled from source and linked with objects split from the user’s disc, then checked against per-version SHA-1 hashes; the repository contains no game assets or assembly. The separately curated Metaforce and Metroid Prime Port build their native ports on this code.

This disassembles Metroid for the NES. The ROM has eight 16 KB banks. Banks 00 through 06 swap into lower memory, and bank 07 stays in upper memory. The included build script assembles the banks with Ophis and compares each output MD5 with the original binaries.

mgs_reversing reconstructs Metal Gear Solid Integral for PlayStation as C source intended to compile to the same assembly as the original. The author reports that the SLPM_862.47, SLPM_862.48 and SLPM_862.49 main executables are fully decompiled; work on stage overlays continues.

This repository tracks a matching decompilation of Monster Hunter 4 Ultimate for the Nintendo 3DS, European version 1.1. It publishes report.json, an objdiff progress report of function names, addresses, sizes, and match percentages. The README says the source, tools, and game data are not in the repository.

Mickey Saves the Day 3D Adventure reconstructs the game's C/C++ source and builds ports for Apple Silicon macOS and WebAssembly. The author reports checking functions against Visual C++ 5.0 or 6.0 output byte by byte; the ports read game data from a user-supplied German or British English CD image.

MILLI4C reconstructs C++ source for the US 1.0 release of Mario & Luigi: Dream Team, targeting a matching build of its code.bin. The repository includes game source, headers, CRO configuration and a build script that produces code.bin and MILLI4C.axf.

Milon's Secret Castle reconstructs the US NES game as annotated assembly that builds with asm6f. A verification script compares the built ROM with the original, while Mesen Lua scripts visualize doors, movement, hitboxes and room secrets.

Decompiles Minecraft: Nintendo Switch Edition v1.0.17, a Legacy Console Edition release, into C++ that is compared function by function with the original executable using a patched Clang 4.0.1 and the open-ead Switch decompilation tools. The README explains the choice of the Switch build for its matchable Clang toolchain and type information, with names ported from the symbol-bearing Wii U Edition. At the reviewed commit the function list marks about 11% of functions decompiled, most of them matching; the result cannot run the game.

MissionFleet reconstructs the historical NavyFIELD 2.062 client and server stack using byte-level decompilation evidence and a Rust server implementation. The author reports a byte-matched inventory spanning client and server modules, most of it represented by instruction streams rather than readable C++. Its Rust login transport implements framing, checksums and liveness probes; authentication and the game and save services remain incomplete.

mkgp2-decomp reconstructs the PowerPC main.dol of the Japanese Mario Kart Arcade GP2 release as C/C++ intended to rebuild byte identically with CodeWarrior. It uses decomp-toolkit for analysis and builds, with the original executable supplied locally by the user.

mlbis reconstructs the Nintendo DS game Mario & Luigi: Bowser's Inside Story as C/C++ source intended to match the retail ROM byte for byte. Its tooling compiles units with CodeWarrior, compares functions and data objects against delinked ROM targets, and relinks modules for byte comparison.

Monster Hunter 2 (Dos) reconstructs the PS2 game's code as C and assembly for its original compiler. The author reports that the boot executable and twelve code overlays rebuild byte for byte, while licensed libraries and game data come from the user's version 1.04 copy. The repository also documents matching methods, function names and data structures.

Monster Hunter Tri is an in-progress matching decompilation of the USA Wii release RMHE08 in C and C++. Its build links matching reconstructed units with original bytes for unfinished regions, then checks main.dol against a recorded SHA-1. The project tracks split translation units, symbols and per-function scores, and documents compiler-matching techniques and build checks.

This repository decompiles the first Japanese PlayStation 2 release of Monster Hunter. The disc files are SLPM_654.95 and AFS_DATA. A successful build compares the ELF and overlays byte for byte. The README says the main ELF still has a few mismatches and overlay matching is currently turned off.

Monster Hunter decompiles Japanese PS2 releases of Monster Hunter, Monster Hunter G and Monster Hunter 2 into C checked against users' discs, then runs the reconstructed code on PC and the original Xbox through new platform layers. The tools survey ELF symbols, extract AFS data and overlays, and compare compiled functions with original bytes. The author reports playable PC and Xbox builds for the first two games, while Monster Hunter 2 remains at an early port stage.

Mortal Kombat: Deception decomp reconstructs the USA GameCube release as C and C++ source. Its setup checks a user-supplied retail disc, downloads the configured compilers and matching tools, then builds a main.dol whose expected result is checked against the original.

This is a matching decompilation of the vehicle physics in Need for Speed: Most Wanted. Functions are compiled with MSVC 7.1 so the assembly matches the retail executable.

Mother 3 reconstructs Game Boy Advance game code into a buildable source tree targeting a ROM with a specified SHA-1. Its setup uses the Japanese original as baserom.gba, and the included Salsa tool reads and writes the game’s main and miscellaneous text.

Mother reconstructs the Famicom/NES game as assembly for its Japanese release and English localization. Configuration splits banks and version-specific assets from user-supplied ROMs; build scripts produce NES 2.0 ROMs and compare their checksums with the selected originals. The assembly separates game data, object scripts, vectors, music, and other code.

Moto Racer World Tour reconstructs the PAL PlayStation game's boot and main executables with byte-matching builds while replacing assembly with recovered C and C++. Its documentation maps the disc, MR3.DAT archive and formats including VRM textures, SDF scenes and DPS movies. Python tools extract, inspect, edit and repack those files from a user-provided disc.

Motocross Madness 2 decomp reconstructs readable C++ for selected functions and classes in the retail x86 game. It compiles candidates with VC6 SP3 and compares their resolved machine code with retail bytes; the full source build still lacks providers needed to link a playable game.

Mulberry works toward a matching C source decompilation of the PlayStation 2 game Kuon. Its build uses a user-provided game executable and PS2-specific binutils; contributors replace assembly translation units in the project configuration with reconstructed C.

MVP Baseball 2005 reconstructs C++ source for the USA GameCube release and compares built functions with the retail main.dol. Its configured units include Nintendo and EA libraries plus early game geometry code; the remaining program is assembled from a user-supplied disc image.

My Teacher is an Alien reconstructs the 1997 Windows 95 adventure game in C++ from Ghidra disassembly. The project compiles with MSVC 4.20 and compares rebuilt functions, calls, globals and data against the original full-game and demo binaries; the author reports both versions are playable.

Nagano Winter Olympics '98 decompilation reconstructs the USA Nintendo 64 release with compiled source and a mapped ROM data region. Its verification commands compare relocated program bytes with a user-provided retail ROM, while analysis files classify and reproduce non-code intervals. The author reports complete byte matching for catalogued functions and initialized data.