# Reverse-engineering case studies · Page 2

> Page 2 of 21, cases 201–400. 4,025 case studies from 5,191 curated resources, with documented reconstruction methods, scope, and original evidence.

- HTML: <https://awesomerea.org/cases/page/2/>
- 简体中文: <https://awesomerea.org/zh/cases/page/2/index.md>

## Games (200)

- [Dragon Quest IX: matching Nintendo DS decompilation](https://awesomerea.org/resources/dqix-decomp-case/index.md): Case study · 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.
- [Dragon Warrior 3: a matching Game Boy Color disassembly](https://awesomerea.org/resources/dragon-warrior-3-gbc-disassembly-case/index.md): Case study · 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.
- [Dragon Warrior IV: a byte-exact NES disassembly](https://awesomerea.org/resources/dragon-warrior-iv-nes-disassembly-case/index.md): Case study · 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: a commented NES disassembly](https://awesomerea.org/resources/dragon-warrior-disassembly-case/index.md): Case study · 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: matching Driver and porting it to Linux](https://awesomerea.org/resources/driver-1-decomp-case/index.md): Case study · 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: reconstructing the World release in assembly](https://awesomerea.org/resources/duck-hunt-disassembly-case/index.md): Case study · 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.
- [Duke Nukem Zero Hour: decompiling the Nintendo 64 game](https://awesomerea.org/resources/duke-nukem-zero-hour/index.md): Case study · 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: matching source snippets for Duke Nukem 1](https://awesomerea.org/resources/duke1decomp-case/index.md): Case study · 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: matching Duke Nukem II source reconstruction](https://awesomerea.org/resources/duke2reconstructed-case/index.md): Case study · 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: commented MSX disassembly](https://awesomerea.org/resources/dunk-shot-msx-case/index.md): Case study · 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: matching Digimon World 2003 card-game functions](https://awesomerea.org/resources/dw3-decomp-expanded-case/index.md): Case study · 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.
- [DX-Ball: an REA-guided function-level reconstruction with Codex](https://awesomerea.org/resources/dx-ball-rea-reconstruction-case/index.md): Case study · 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.
- [DX-Ball: reconstruct sound panning](https://awesomerea.org/resources/rea-dxball-case/index.md): Case study · Recover one sound-pan function from instructions and constants; upstream cites 3,205 cases and a 63-byte match.
- [Elite: Harmless — a Commodore 64 Elite disassembly](https://awesomerea.org/resources/elite-harmless-case/index.md): Case study · 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: matching PS2 modules of EverQuest Online Adventures: Frontiers](https://awesomerea.org/resources/eqoa-frontiers-decomp-case/index.md): Case study · 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: a work-in-progress GameCube decompilation](https://awesomerea.org/resources/unending-occlusion-eternal-darkness-case/index.md): Case study · 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.
- [Eternal Darkness: Sanity’s Requiem — a matching GameCube decompilation](https://awesomerea.org/resources/eternal-darkness-decomp/index.md): Case study · 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-: exact-function source reconstruction](https://awesomerea.org/resources/eternal-fighter-zero-case/index.md): Case study · 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: matching Neon Genesis Evangelion on Nintendo 64](https://awesomerea.org/resources/eva-decomp-case/index.md): Case study · 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: matching decompilation of Evo's Space Adventure](https://awesomerea.org/resources/esa-psx-case/index.md): Case study · 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: matching Wii decompilation](https://awesomerea.org/resources/excite-truck-decomp-case/index.md): Case study · 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: matching three Nintendo 64 releases](https://awesomerea.org/resources/excitebike-64-decomp-case/index.md): Case study · 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: matching PS2 decompilation and gameplay traces](https://awesomerea.org/resources/extermination-ps2-decomp-case/index.md): Case study · 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: reconstructing the DOS game source](https://awesomerea.org/resources/f15-strike-eagle-2-reconstruction-case/index.md): Case study · 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: a matching GameCube decompilation](https://awesomerea.org/resources/fzero-gx-decomp-case/index.md): Case study · 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.
- [F-Zero GX: matching the GameCube executables from C](https://awesomerea.org/resources/f-zero-gx-decomp-case/index.md): Case study · 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.
- [F-Zero X Expansion Kit: matching decompilation of the disk expansion](https://awesomerea.org/resources/fzerox-expansion-kit/index.md): Case study · 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: a work-in-progress matching Nintendo 64 decompilation](https://awesomerea.org/resources/f-zero-x-decomp-case/index.md): Case study · 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: an early US N64 decompilation](https://awesomerea.org/resources/bttrdrgn-f-zero-x-decomp-case/index.md): Case study · 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: a matching F-19 Stealth Fighter reconstruction](https://awesomerea.org/resources/f19re-case/index.md): Case study · 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.
- [Fable: The Lost Chapters: function-level reconstruction of the PC executable](https://awesomerea.org/resources/fable-the-lost-chapters-decomp-case/index.md): Case study · 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: a work-in-progress decompilation](https://awesomerea.org/resources/fallout-new-vegas-decomp-case/index.md): Case study · 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.
- [Fate/Unlimited Codes: a matching Japanese PS2 decompilation](https://awesomerea.org/resources/fate-unlimited-codes-jp-decomp-case/index.md): Case study · 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: matching reconstruction of the European Fire Emblem ROM](https://awesomerea.org/resources/fe7eu-decomp-case/index.md): Case study · 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.
- [Final Fantasy Crystal Chronicles: GameCube decompilation](https://awesomerea.org/resources/ffcc-decomp/index.md): Case study · 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.
- [Final Fantasy IV: byte-exact Super Famicom disassembly](https://awesomerea.org/resources/ff4-disasm/index.md): Case study · 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.
- [Final Fantasy IX: matching US PlayStation decompilation](https://awesomerea.org/resources/ff9-decomp-case/index.md): Case study · 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.
- [Final Fantasy Tactics Advance: matching decompilation and battle AI analysis](https://awesomerea.org/resources/ffta-battle-ai-decomp-case/index.md): Case study · 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: a matching PlayStation decompilation](https://awesomerea.org/resources/final-fantasy-tactics-decomp-case/index.md): Case study · 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.
- [Final Fantasy Tactics: byte-exact PlayStation decompilation](https://awesomerea.org/resources/fft-decomp/index.md): Case study · 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: a matching SNES disassembly for two ROM versions](https://awesomerea.org/resources/final-fantasy-v-disassembly-case/index.md): Case study · 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.
- [Final Fantasy VII: a matching PlayStation decompilation](https://awesomerea.org/resources/ff7-ps1-matching-decomp-case/index.md): Case study · 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.
- [FINAL FANTASY XIV 1.23b: an experimental matching client decompilation](https://awesomerea.org/resources/ffxiv-123b-matching-decomp-case/index.md): Case study · 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.
- [Fire Emblem: a partial NES disassembly of Shadow Dragon and the Blade of Light](https://awesomerea.org/resources/fe1-case/index.md): Case study · 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.
- [Fire Emblem: Rekka no Ken — matching Japanese Game Boy Advance decompilation](https://awesomerea.org/resources/fe7j-decomp/index.md): Case study · 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: a Nintendo DS decompilation](https://awesomerea.org/resources/fire-emblem-shadow-dragon-decomp-case/index.md): Case study · 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: a matching decompilation of the GBA Fire Emblem release](https://awesomerea.org/resources/fireemblem7u-decomp-case/index.md): Case study · 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: byte-identical Mega Drive source reconstruction](https://awesomerea.org/resources/flicky-src-case/index.md): Case study · 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.
- [Fossil Fighters Champions: matching the Nintendo DS battle overlay](https://awesomerea.org/resources/fossil-fighters-champions-decomp-case/index.md): Case study · 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.
- [Four Swords Adventures: a byte-matching GameCube decompilation](https://awesomerea.org/resources/four-swords-adventures-decomp-case/index.md): Case study · 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: an in-progress Patch 1.1 decompilation](https://awesomerea.org/resources/freelancer-decomp-case/index.md): Case study · 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: decompiling the US GBA release](https://awesomerea.org/resources/friends-of-mineral-town-decomp-case/index.md): Case study · 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.
- [Frogger's Adventures: Temple of the Frog: a matching GBA decompilation](https://awesomerea.org/resources/frogger-adventures-temple-decomp-case/index.md): Case study · 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: an annotated BBC Micro disassembly](https://awesomerea.org/resources/frogman-bbc-micro-case/index.md): Case study · 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.
- [fzgx: a matching F-Zero GX decompilation](https://awesomerea.org/resources/fzgx-nkhoit-decomp-case/index.md): Case study · 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: reconstructing the Red Alert 2: Yuri’s Revenge engine](https://awesomerea.org/resources/gagarin/index.md): Case study · 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.
- [Galaxian³: Project Dragoon — PlayStation matching decompilation](https://awesomerea.org/resources/galaxian3-project-dragoon-decomp-case/index.md): Case study · 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: matching reconstruction of the Android Abyss Engine library](https://awesomerea.org/resources/galaxy-on-fire-2-android-decomp-case/index.md): Case study · 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.
- [Ganbare Goemon 3: a checksum-checked SFC disassembly](https://awesomerea.org/resources/ganbare-goemon-3-disassembly-case/index.md): Case study · 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: Android native-library decompilation](https://awesomerea.org/resources/gangstar-west-coast-hustle-case/index.md): Case study · 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: matching decompilation of Super Mario Galaxy 2](https://awesomerea.org/resources/garigari-case/index.md): Case study · 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.
- [Gauntlet Legends: in-progress Nintendo 64 decompilation](https://awesomerea.org/resources/gauntlet-legends-decomp/index.md): Case study · 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.
- [George of the Jungle: partial matching PS2 decompilation](https://awesomerea.org/resources/george-of-the-jungle-decomp-case/index.md): Case study · 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.
- [Gex 64: Enter the Gecko — matching Nintendo 64 decompilation](https://awesomerea.org/resources/gex64-decomp/index.md): Case study · 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: matching Guitar Hero III PS2 decompilation](https://awesomerea.org/resources/gh3-decomp-case/index.md): Case study · 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: a matching Giten Megami Tensei reconstruction](https://awesomerea.org/resources/giten-megami-tensei-decomp-case/index.md): Case study · 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: partial N64 matching decompilation](https://awesomerea.org/resources/glover-decomp-case/index.md): Case study · 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: matching decompilation of God Hand](https://awesomerea.org/resources/god-hand-decomp-case/index.md): Case study · 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: a matching Nintendo 64 decompilation](https://awesomerea.org/resources/goemons-great-adventure-decomp-case/index.md): Case study · 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: a matching GBA decompilation with overlay comparisons](https://awesomerea.org/resources/golden-sun-gba-decomp-case/index.md): Case study · 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.
- [GoldenEye 007: matching Nintendo 64 decompilation for three releases](https://awesomerea.org/resources/goldeneye-007-matching-decomp-case/index.md): Case study · 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.
- [Gran Turismo 2: reconstructing PS1 executables and overlays](https://awesomerea.org/resources/gt2-reversing-case/index.md): Case study · 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.
- [Gran Turismo 3: A-Spec: matching PS2 executable decompilation](https://awesomerea.org/resources/gt3-decomp-case/index.md): Case study · 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.
- [Gran Turismo 4: an agent-assisted PS2 engine matching decompilation](https://awesomerea.org/resources/gran-turismo-4-matching-decomp-case/index.md): Case study · 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: a matching Robin Hood decompilation](https://awesomerea.org/resources/greenwood-robin-hood-decomp-case/index.md): Case study · 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: matching GBA ROM reconstruction](https://awesomerea.org/resources/gt-advance-3-decomp-case/index.md): Case study · 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: C89 reconstruction of Europa 1400 binaries](https://awesomerea.org/resources/guild-rebrew-europa-1400-case/index.md): Case study · 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: a three-region matching DS reconstruction](https://awesomerea.org/resources/gx-spirit-caller-decomp-case/index.md): Case study · 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.
- [Halo 2: an agent-assisted matching decompilation of an LTCG Xbox build](https://awesomerea.org/resources/halo2-matching-decomp-case/index.md): Case study · 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: a matching GBA decompilation](https://awesomerea.org/resources/hamtaro-heartbreak-decomp-case/index.md): Case study · 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: function-level Windows decompilation](https://awesomerea.org/resources/harry-potter-half-blood-prince-decomp-case/index.md): Case study · 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.
- [Harry Potter and the Sorcerer's Stone: a GBC disassembly](https://awesomerea.org/resources/hpss-disassembly-case/index.md): Case study · 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: matching decompilation of Harvest Moon 64](https://awesomerea.org/resources/hm64-decomp-case/index.md): Case study · 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: reconstructing the Japanese Game Boy ROM](https://awesomerea.org/resources/harvest-moon-gb-disassembly-case/index.md): Case study · 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: a byte-matching PlayStation decompilation](https://awesomerea.org/resources/harvest-moon-back-to-nature-decomp-case/index.md): Case study · 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.
- [Harvest Moon: Back to Nature: matching PS1 executable reconstruction](https://awesomerea.org/resources/backtonature-decompiled-case/index.md): Case study · 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.
- [HarvestMoonSnesDecomp: matching Harvest Moon SNES source in C](https://awesomerea.org/resources/harvest-moon-snes-c/index.md): Case study · 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.
- [Hey You, Pikachu!: an AI-assisted matching N64 decompilation](https://awesomerea.org/resources/ornata-hey-you-pikachu-case/index.md): Case study · 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.
- [Himuro: a matching Fatal Frame PS2 decompilation](https://awesomerea.org/resources/himuro-fatal-frame-decomp-case/index.md): Case study · 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.
- [Homeworld 2 Classic: an in-progress executable and DLL decompilation](https://awesomerea.org/resources/homeworld2classic-case/index.md): Case study · 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: matching Heroes of Might and Magic and its editor](https://awesomerea.org/resources/homm1-decomp-case/index.md): Case study · 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: matching PSP decompilation](https://awesomerea.org/resources/hot-shots-tennis-psp-case/index.md): Case study · 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.
- [Hot Wheels: function-by-function PC executable reconstruction](https://awesomerea.org/resources/hot-wheels-pc-decomp-case/index.md): Case study · 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: matching Hyrule Warriors: Definitive Edition functions](https://awesomerea.org/resources/hwde-decomp-case/index.md): Case study · 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: an AI-assisted matching N64 decompilation](https://awesomerea.org/resources/hybrid-heaven-decomp-case/index.md): Case study · 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: matching reconstruction of the Japanese PlayStation executable](https://awesomerea.org/resources/hybrid-ps1-decomp-case/index.md): Case study · 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: byte-matched PS2 source recovery](https://awesomerea.org/resources/hyper-street-fighter-zero-gold-case/index.md): Case study · 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: matching HyperBlade's Windows executable](https://awesomerea.org/resources/hyperblade-decomp-case/index.md): Case study · 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.
- [ICO decompilation: byte-identical PAL and Japanese PlayStation 2 boot ELFs](https://awesomerea.org/resources/ico-matching-decomp-case/index.md): Case study · 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: reconstructing the Dreamcast executable](https://awesomerea.org/resources/illbleed-decomp-case/index.md): Case study · 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: reconstructing the 1997 game in C++ and Rust](https://awesomerea.org/resources/imperialism-decomp-case/index.md): Case study · 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.
- [Indiana Jones and the Infernal Machine: a matching C decompilation](https://awesomerea.org/resources/infernal-machine-matching-decomp-case/index.md): Case study · 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.
- [Jackal: commented disassembly of the NES game](https://awesomerea.org/resources/nes-jackal-disasm/index.md): Case study · 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.
- [Jawbreaker: an annotated Atari VCS disassembly that compiles to the exact ROM](https://awesomerea.org/resources/jawbreaker-atari-vcs-disassembly-case/index.md): Case study · 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.
- [Jet Set Radio Future: early matching Xbox decompilation](https://awesomerea.org/resources/jsrf-matching-decomp-case/index.md): Case study · 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: matching reconstruction of a Nintendo 3DS executable](https://awesomerea.org/resources/kanken-training-2-decomp-case/index.md): Case study · 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: a byte-matched DOS disassembly](https://awesomerea.org/resources/karateka-dos-disassembly-case/index.md): Case study · 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.
- [Kaze no Notam: matching PlayStation decompilation](https://awesomerea.org/resources/kaze-no-notam-ps1-decomp-case/index.md): Case study · 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: matching decompilation of King's Field IV](https://awesomerea.org/resources/kfiv-decomp-case/index.md): Case study · 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: a Game Boy disassembly](https://awesomerea.org/resources/kid-icarus-omm-disassembly-case/index.md): Case study · 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: an in-progress PS2 main-ELF decompilation](https://awesomerea.org/resources/kingdom-hearts-2-final-mix-decomp-case/index.md): Case study · 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.
- [Kingdom Hearts 358/2 Days: a matching Nintendo DS decompilation](https://awesomerea.org/resources/kingdom-hearts-days-matching-decomp-case/index.md): Case study · 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.
- [Kingdom Hearts: Chain of Memories — matching GBA decompilation](https://awesomerea.org/resources/khcom-decomp-case/index.md): Case study · 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: a GameCube DOL decompilation](https://awesomerea.org/resources/kirby-air-ride-decomp-case/index.md): Case study · 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.
- [Kirby Air Ride: a three-region GameCube decompilation](https://awesomerea.org/resources/kar-kirby-air-ride-case/index.md): Case study · 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: an in-progress Wii decompilation](https://awesomerea.org/resources/kirbys-dream-collection-decomp-case/index.md): Case study · 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.
- [Kirby's Epic Yarn: decompiling the USA Wii release](https://awesomerea.org/resources/kirby-epic-yarn-decomp/index.md): Case study · 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: a Game Boy Color disassembly](https://awesomerea.org/resources/kirby-tilt-n-tumble-disassembly-case/index.md): Case study · 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: a matching Game Boy Advance decompilation](https://awesomerea.org/resources/kirby-nightmare-in-dream-land-decomp-case/index.md): Case study · 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.
- [Klonoa 2: Lunatea's Veil — matching PlayStation 2 decompilation](https://awesomerea.org/resources/kl2-lv-decomp/index.md): Case study · 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 — a matching GBA decompilation](https://awesomerea.org/resources/klonoa-empire-of-dreams-decomp-case/index.md): Case study · 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: matching decompilation of LEGO Batman: The Videogame](https://awesomerea.org/resources/lbtvg-lego-batman-case/index.md): Case study · 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.
- [Legaia 2: Duel Saga: matching the PAL PlayStation 2 executable](https://awesomerea.org/resources/legaia2-decomp-case/index.md): Case study · 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.
- [Legend of Mana: a matching decompilation of the PlayStation game](https://awesomerea.org/resources/legend-of-mana-decomp-case/index.md): Case study · 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: a matching Nintendo Switch decompilation](https://awesomerea.org/resources/lego-city-undercover-decomp-case/index.md): Case study · 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.
- [LEGO Island: source reconstruction with separately reported exact rebuilds](https://awesomerea.org/resources/lego-island-decomp-case/index.md): Case study · 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: a function-matched decompilation of the 1999 Windows game](https://awesomerea.org/resources/lego-racers-decomp-case/index.md): Case study · 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.
- [Lego Star Wars III: an in-progress Wii decompilation](https://awesomerea.org/resources/lego-clone-wars-wii-case/index.md): Case study · 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: matching CD-i program decompilation](https://awesomerea.org/resources/link-faces-of-evil-decomp-case/index.md): Case study · 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: a matching decompilation of EBOOT.BIN](https://awesomerea.org/resources/lbp-psp-decomp-case/index.md): Case study · 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: a byte-exact ZX Spectrum disassembly](https://awesomerea.org/resources/lode-runner-spectrum-disassembly-case/index.md): Case study · 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 — a matching PlayStation decompilation](https://awesomerea.org/resources/lsd-dream-emulator-decomp-case/index.md): Case study · 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: Dream Emulator: a matching PlayStation decompilation](https://awesomerea.org/resources/lsd-decomp-case/index.md): Case study · 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: Dream Emulator: an early PlayStation decompilation](https://awesomerea.org/resources/lsd-dream-emulator-cawfee-decomp-case/index.md): Case study · 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.
- [LSD: Dream Emulator: partial PS1 decompilation and mechanics research](https://awesomerea.org/resources/lsddecomp-case/index.md): Case study · 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: Landstalker US ROM disassembly](https://awesomerea.org/resources/lsusdisasm-landstalker-case/index.md): Case study · 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.
- [Luigi's Mansion: a multi-region GameCube decompilation](https://awesomerea.org/resources/luigis-mansion-lm-decomp-case/index.md): Case study · 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: reconstructing Madagascar's source](https://awesomerea.org/resources/madagascar-decomp-case/index.md): Case study · 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: matching Nintendo 64 decompilation](https://awesomerea.org/resources/madden-football-64-decomp-case/index.md): Case study · 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: matching decompilation of Mafia: The City of Lost Heaven](https://awesomerea.org/resources/mafia-re/index.md): Case study · 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.
- [Majora’s Mask: matching US N64 decompilation](https://awesomerea.org/resources/zelda-mm-decomp-case/index.md): Case study · 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: matching DS decompilation](https://awesomerea.org/resources/mario-luigi-partners-in-time-decomp-case/index.md): Case study · 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.
- [Mario & Luigi: Superstar Saga — byte-matching GBA decompilation](https://awesomerea.org/resources/mlss-decomp/index.md): Case study · 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: a matching European GBA decompilation](https://awesomerea.org/resources/mario-luigi-superstar-saga-europe-decomp-case/index.md): Case study · 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.: Atari VCS matching disassembly](https://awesomerea.org/resources/a26-mb-case/index.md): Case study · 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.
- [Mario Golf: matching Nintendo 64 decompilation](https://awesomerea.org/resources/mario-golf-64/index.md): Case study · 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: matching US and European game code](https://awesomerea.org/resources/mario-kart-ds-decompilation-case/index.md): Case study · 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.
- [Mario Kart DS: an incremental matching decompilation of the European release](https://awesomerea.org/resources/mkds-decomp-case/index.md): Case study · 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.
- [Mario Kart Wii: an in-progress matching decompilation of the PAL release](https://awesomerea.org/resources/mario-kart-wii-decomp-case/index.md): Case study · 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.
- [Mario Kart Wii: matching decompilation of the PAL game](https://awesomerea.org/resources/mkw-decomp-case/index.md): Case study · This is a work-in-progress decompilation of Mario Kart Wii. The supported version named in the README is the PAL release RMCP01.
- [Mario Kart: Double Dash!!: a matching GameCube decompilation of the debug build](https://awesomerea.org/resources/mario-kart-double-dash-decomp-case/index.md): Case study · 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: a US N64 decompilation](https://awesomerea.org/resources/mario-party-2-us-decomp-case/index.md): Case study · 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: a matching Nintendo 64 decompilation](https://awesomerea.org/resources/mario-party-3-decomp-case/index.md): Case study · 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.
- [Mario Party 4: matching GameCube decompilation of the USA releases](https://awesomerea.org/resources/mario-party-4-decomp-case/index.md): Case study · 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: a matching GameCube decompilation](https://awesomerea.org/resources/mario-party-6-decomp-case/index.md): Case study · 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.
- [Mario Strikers Charged: a matching Wii decompilation](https://awesomerea.org/resources/mscharged-decomp/index.md): Case study · 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.
- [Mario Superstar Baseball: a GameCube decompilation](https://awesomerea.org/resources/mario-superstar-baseball-decomp-case/index.md): Case study · 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): a matching USA and Europe disassembly](https://awesomerea.org/resources/mario-tennis-gbc-disasm-case/index.md): Case study · 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: a Game Boy Advance disassembly](https://awesomerea.org/resources/mariovsdk-case/index.md): Case study · 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.
- [Mario-Bros.-Dis: byte-for-byte Mario Bros. NES disassembly](https://awesomerea.org/resources/mario-bros-nes-disasm/index.md): Case study · 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/.
- [Marvel Nemesis: Rise of the Imperfects: a GameCube decompilation](https://awesomerea.org/resources/marvel-nemesis-gamecube-decomp-case/index.md): Case study · 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.
- [Marvel vs. Capcom 2: early Dreamcast matching decompilation](https://awesomerea.org/resources/mvc2-dreamcast-decomp-case/index.md): Case study · 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: matching PS2 decompilation and browser port](https://awesomerea.org/resources/mvc2-ps2-decomp-case/index.md): Case study · 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: a matching GBA decompilation](https://awesomerea.org/resources/medabots-rokusho-decomp-case/index.md): Case study · 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.
- [Medarot Parts Collection: a Game Boy disassembly and translation workspace](https://awesomerea.org/resources/medarot-parts-collection-disassembly-case/index.md): Case study · 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: a partial matching disassembly of Medarot Kabuto](https://awesomerea.org/resources/medarot-kabuto-disassembly-case/index.md): Case study · 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.
- [MediEvil decompilation: an early checksum-gated PlayStation project](https://awesomerea.org/resources/medievil-decomp-case/index.md): Case study · 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: an annotated ca65 NES disassembly](https://awesomerea.org/resources/mega-man-3-ca65-disassembly-case/index.md): Case study · 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: a matching WiiWare decompilation](https://awesomerea.org/resources/mega-man-9-wiiware-decomp-case/index.md): Case study · 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.
- [Mega Man X4: byte-matching PlayStation source reconstruction](https://awesomerea.org/resources/mmx4-decomp/index.md): Case study · 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.
- [Mega Man X5: a matching PlayStation decompilation](https://awesomerea.org/resources/mega-man-x5-decomp-case/index.md): Case study · 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.
- [Mega Man X6: matching PlayStation code and overlay decompilation](https://awesomerea.org/resources/mega-man-x6-matching-decomp-case/index.md): Case study · 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.
- [memory of alessa: an in-progress Silent Hill 3 PS2 matching decompilation](https://awesomerea.org/resources/silent-hill-3-memory-of-alessa-decomp-case/index.md): Case study · 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: FINAL FANTASY XIV 1.23b client and network decompilation](https://awesomerea.org/resources/meteor-ffxiv-decomp-case/index.md): Case study · 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.
- [Metroid II: byte-matching Game Boy disassembly](https://awesomerea.org/resources/metroid-ii-disasm/index.md): Case study · 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.
- [Metroid Prime: the PrimeDecomp matching GameCube decompilation](https://awesomerea.org/resources/primedecomp-metroid-prime-decomp-case/index.md): Case study · 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.
- [Metroid: byte-matched NES disassembly](https://awesomerea.org/resources/metroid-nes-disasm/index.md): Case study · 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: matching Metal Gear Solid Integral source reconstruction](https://awesomerea.org/resources/mgs-reversing-case/index.md): Case study · 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.
- [mh4u-decomp: matching-decompilation progress for Monster Hunter 4 Ultimate](https://awesomerea.org/resources/mh4u-progress/index.md): Case study · 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: matching decompilation and native ports](https://awesomerea.org/resources/mickey-saves-the-day-3d-adventure-case/index.md): Case study · 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: a Mario & Luigi: Dream Team decompilation](https://awesomerea.org/resources/milli4c-dream-team-decomp-case/index.md): Case study · 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: an annotated NES disassembly](https://awesomerea.org/resources/milons-secret-castle-disassembly-case/index.md): Case study · 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.
- [MinecraftLCE: an early-stage Minecraft: Nintendo Switch Edition decompilation](https://awesomerea.org/resources/minecraft-lce-switch-decomp-case/index.md): Case study · 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: reconstructing the NavyFIELD 2.062 client and server stack](https://awesomerea.org/resources/missionfleet-case/index.md): Case study · 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: matching Mario Kart Arcade GP2 main.dol](https://awesomerea.org/resources/mkgp2-decomp-case/index.md): Case study · 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: matching Mario & Luigi: Bowser's Inside Story decompilation](https://awesomerea.org/resources/mlbis-decomp-case/index.md): Case study · 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): matching the PS2 boot executable and overlays](https://awesomerea.org/resources/monster-hunter-2-dos-decomp-case/index.md): Case study · 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: a matching Wii decompilation](https://awesomerea.org/resources/monster-hunter-tri-wii-decomp-case/index.md): Case study · 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.
- [Monster Hunter: matching decompilation of the Japanese PS2 release](https://awesomerea.org/resources/mh1j-decomp/index.md): Case study · 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: PS2 decompilation and PC/Xbox ports](https://awesomerea.org/resources/monster-hunter-ps2-pc-xbox-case/index.md): Case study · 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: matching GameCube decompilation of the USA release](https://awesomerea.org/resources/mortal-kombat-deception-decomp-case/index.md): Case study · 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.
- [Most Wanted Vehicles Decomp: matching vehicle physics from Need for Speed: Most Wanted](https://awesomerea.org/resources/nfs-mw-vehicles-decomp/index.md): Case study · 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: a Game Boy Advance decompilation](https://awesomerea.org/resources/mother-3-decomp-case/index.md): Case study · 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: a checksum-checked Famicom/NES disassembly](https://awesomerea.org/resources/mother-nes-disassembly-case/index.md): Case study · 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: matching PlayStation code and file-format research](https://awesomerea.org/resources/moto-racer-world-tour-case/index.md): Case study · 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: VC6-matched C++ reconstruction](https://awesomerea.org/resources/motocross-madness-2-decomp-case/index.md): Case study · 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: matching source decompilation of Kuon](https://awesomerea.org/resources/mulberry-kuon-case/index.md): Case study · 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: matching GameCube decompilation](https://awesomerea.org/resources/mvp-baseball-2005-decomp-case/index.md): Case study · 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: Windows 95 source reconstruction](https://awesomerea.org/resources/my-teacher-is-an-alien-case/index.md): Case study · 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: matching Nintendo 64 decompilation](https://awesomerea.org/resources/nagano-winter-olympics-98-decomp-case/index.md): Case study · 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.