# Reverse-engineering case studies · Page 3

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

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

## Games (200)

- [NASCAR Heat 2002: a matching GBA decompilation and SDL2 port](https://awesomerea.org/resources/nascar-heat-2002-gba-decomp-case/index.md): Case study · Reconstructs the US Game Boy Advance release of NASCAR Heat 2002 as a byte-matching source build and compiles the same game code into an SDL2 desktop port. The build extracts graphics, tracks, music, and samples from a user-supplied ROM; the author reports that make check reproduces the retail ROM.
- [New Super Mario Bros. Wii: matching decompilation of the PAL game](https://awesomerea.org/resources/nsmbw-decomp/index.md): Case study · This decompiles New Super Mario Bros. Wii from the PALv1 binaries. A dumped disc supplies main.dol and four rel.LZ files. tools/uncompress_lz.py decompresses the rel files. main.dol is renamed wiimj2d.dol and placed in original with the rel files. The MD5 of wiimj2d.dol is ddab9e5dca53d8c18bf4051b927e822e. CodeWarrior for Embedded PowerPC goes in compilers/Wii/1.1. ./configure.py then ninja links a dol and rel files that match the originals. ./progress.py --verify-bin checks them. Linux and macOS use wibo or Wine.
- [New Super Mario Bros.: an early Nintendo DS matching decompilation](https://awesomerea.org/resources/nsmb-ds-decomp-case/index.md): Case study · nsmb reconstructs source for the Nintendo DS game New Super Mario Bros., with active comparison work on the US A2DE release. Its workflow extracts a user-dumped ROM, delinks modules and generates an objdiff configuration to compare reconstructed code with game code; a complete ROM build remains unavailable.
- [NFL Street 2: an evidence-tracked GameCube matching decompilation](https://awesomerea.org/resources/nfl-street-2-decomp-case/index.md): Case study · NFL Street 2 reconstructs C and C++ source for the USA GameCube release with a byte-identical executable as its goal. The build inserts reconstructed units into an original-object baseline and checks the resulting main.dol hash; a trial tool compares individual functions. Configuration files record names, unit boundaries and supporting evidence.
- [NHL 94 Genesis: a matching Sega Genesis disassembly](https://awesomerea.org/resources/nhl-94-genesis-case/index.md): Case study · NHL 94 Genesis reconstructs the Sega Genesis game's assembly and compares the assembled retail build byte for byte with a user-supplied ROM. Its build extracts graphics, sound and names from that ROM, while segment checks compare individual address ranges.
- [NHLPA93Genesis: matching disassembly of three NHLPA Hockey 93 revisions](https://awesomerea.org/resources/nhlpa93genesis-case/index.md): Case study · NHLPA93Genesis reconstructs NHLPA Hockey 93 for Sega Genesis as 68000 and Z80 assembly. Its build extracts graphics, sound and names from a user-provided ROM, assembles the code and compares Rev 0, Rev A or Rev B output byte for byte with the corresponding original.
- [OB64 Decomp: matching Ogre Battle 64 from MIPS assembly to C](https://awesomerea.org/resources/ogre-battle-64-decomp-case/index.md): Case study · Reconstructs the US Rev 0 release of Ogre Battle 64 from source-owned MIPS assembly, replacing accepted functions with C that matches linked bytes and the full ROM. Its workflow records compiler and relocation constraints, tests each replacement, and keeps the original ROM and toolchains outside the repository.
- [Ocarina of Time 3D: a hash-checked 3DS decompilation](https://awesomerea.org/resources/ocarina-of-time-3d-decomp-case/index.md): Case study · Ocarina of Time 3D reconstructs source for the USA release of The Legend of Zelda: Ocarina of Time 3D through static and dynamic analysis. Its Windows build produces oot3d.axf and code.bin, with an MD5-based matching check; rebuilding romfs.bin and the full 3DS image remains future work.
- [Ocarina of Time Master Quest: matching debug disassembly](https://awesomerea.org/resources/ocarina-mq-debug-disasm/index.md): Case study · This is a disassembly of The Legend of Zelda: Ocarina of Time Master Quest, debug version. It builds zelda_ocarina_mq_dbg.z64, MD5 717179476af84133b14ff73af87db57a.
- [Ocarina of Time: decompilation with MD5-checked ROM builds for 16 versions](https://awesomerea.org/resources/ocarina-of-time-decomp-case/index.md): Case study · Recreates a C source base for Ocarina of Time that rebuilds 16 Nintendo 64, GameCube and iQue Player ROM versions, using information from the game and static and dynamic analysis. Assets come from the user’s own ROM and each default build is checked against that version’s MD5; README states the project is not producing a PC port and still calls the repository a work in progress.
- [Okamiden: a work-in-progress Nintendo DS matching decompilation](https://awesomerea.org/resources/okamiden-decomp-case/index.md): Case study · Okamiden is being reconstructed as C source for the USA Nintendo DS release, with compiled ARM9 code compared against the original. The project uses ds-decomp, Metrowerks CodeWarrior ARM and objdiff; the author reports three matched ARM9 source units and keeps nonmatching reconstructions separate. Work is at an early stage.
- [oot-vc: decompiling the Wii Virtual Console N64 emulator](https://awesomerea.org/resources/oot-vc-case/index.md): Case study · oot-vc reconstructs the N64 emulator used in Wii Virtual Console releases of Ocarina of Time, Super Mario 64, and Mario Kart 64. It builds against a user-extracted content1.app and provides DOL and function diffing tools, with work mainly focused on the Japanese Ocarina of Time release.
- [open-spyro: matching decompilation of Spyro the Dragon](https://awesomerea.org/resources/open-spyro-case/index.md): Case study · open-spyro rebuilds Spyro the Dragon's PlayStation executable and 37 overlays byte for byte from matched C and retained original assembly. Its build uses a locked GCC 2.7.2 toolchain and per-function instruction diffs. The author reports that all counted game-code bytes match; readability cleanup continues.
- [Over the Hedge: an ongoing PlayStation 2 matching decompilation](https://awesomerea.org/resources/over-the-hedge-ps2-decomp-case/index.md): Case study · Over the Hedge reconstructs source for the retail NTSC-U PlayStation 2 game, targeting a build identical to its original executable. The repository contains C++, assembly, splat configuration and a PS2 build script for the ongoing decompilation.
- [Pac-Man NES Source Reconstruction: seven byte-identical cartridge revisions](https://awesomerea.org/resources/pac-man-nes-source-reconstruction-case/index.md): Case study · Pac-Man NES Source Reconstruction rebuilds seven official Famicom and NES Pac-Man revisions from shared, annotated 6502 ca65 modules. Its build rules extract data from a user's ROM and compare assembled output byte for byte with each available original; a relocated build also has a recorded longplay check in MAME.
- [Paper Mario: matching Nintendo 64 decompilation for four releases](https://awesomerea.org/resources/paper-mario-matching-decomp-case/index.md): Case study · Reconstructs Paper Mario’s Nintendo 64 code as C source that rebuilds the US, Japanese, PAL and iQue ROMs. The build takes assets and comparison inputs from a user-supplied original ROM, then checks each output against a recorded SHA-1. Mutable project reports list no remaining nonmatching functions, while the README still calls the decompilation work in progress; it is distinct from the PaperBoat native port.
- [Paper Mario: The Thousand-Year Door: an early matching GameCube decompilation](https://awesomerea.org/resources/paper-mario-ttyd-decomp-case/index.md): Case study · A work-in-progress matching decompilation of Paper Mario: The Thousand-Year Door that targets the Japanese Rev 0 GameCube release (G8MJ01), rebuilding MarioSt.dol and 31 REL modules with the original Metrowerks compilers and checking each against a stored SHA-1. The build splits these binaries from a user-supplied disc image, and objdiff compares objects during development. decomp.dev reported 12.10% of code matched at the reviewed commit.
- [Paper Mario: The Thousand-Year Door: seven-version matching decompilation](https://awesomerea.org/resources/ttyd-seven-version-decomp-case/index.md): Case study · This Paper Mario: The Thousand-Year Door fork reconstructs one C source tree for three GameCube retail releases and four demos. The author reports that each build reproduces its main executable and area REL files byte for byte; version-specific configurations and architecture notes accompany the code.
- [Paperboy: an in-progress matching Nintendo 64 decompilation](https://awesomerea.org/resources/paperboy-n64-decomp-case/index.md): Case study · Paperboy reconstructs C and C++ for the Nintendo 64 game, replacing assembly inclusions function by function. Its build uses a user-supplied ROM and the original SN compiler, compares functions with asm-differ and checks the NTSC output against a SHA-1 checksum.
- [Parasite Eve II: matching PlayStation decompilation of the USA release](https://awesomerea.org/resources/parasite-eve-2-decomp-case/index.md): Case study · Parasite Eve II Decompilation reconstructs the USA PlayStation game's executable, resident and title overlays, and code packages as buildable C. The author reports byte-identical output using the original GCC toolchain and checksum checks against the user's two game discs; the repository also documents game formats and matching techniques.
- [parasite-eve-decomp-port: matching decompilation and native Linux port of Parasite Eve](https://awesomerea.org/resources/parasite-eve-decomp-port-case/index.md): Case study · parasite-eve-decomp-port contains a matching C decompilation of parts of Parasite Eve's USA PlayStation executable and a native Linux port that runs decompiled game code. Builds extract remaining assembly and data from the user's Disc 1 image; the author reports that a native-only release plays through Day 1 and reaches the opening of Day 2.
- [Pea Shootin' Pete: matching reconstruction of PETE.EXE](https://awesomerea.org/resources/pea-shootin-pete-decomp-case/index.md): Case study · Pea Shootin' Pete reconstructs DOS PETE.EXE functions as C and assembly using Borland C++ 3.1. Its tools repair gaps in a Ghidra export, compile candidates in DOSBox X, and compare instruction shape and bytes while reporting address-field differences. The author reports 94 exact function matches among 454 targets.
- [Pebble Beach Golf Links: a byte-matched Mega Drive reconstruction](https://awesomerea.org/resources/pebble-beach-golf-links-mega-drive-decomp-case/index.md): Case study · Reconstructs the European Mega Drive release of Pebble Beach Golf Links from a locally supplied ROM. The project represents the 68000 game code, Z80 audio driver, tables, and asset pipelines in source, then checks the build against the original SHA-256. The author reports a byte-identical 2 MiB ROM build and documents remaining semantic naming work.
- [Pepsiman: a matching PlayStation decompilation](https://awesomerea.org/resources/pepsiman-matching-decomp-case/index.md): Case study · Reconstructs C source for the Japanese PlayStation release of Pepsiman, including its main executable and 22 code overlays. The build compares output byte for byte with files extracted from a user-supplied retail disc.
- [Perfect Dark: matching Nintendo 64 decompilation](https://awesomerea.org/resources/perfect-dark-matching-decomp-case/index.md): Case study · Reconstructs Perfect Dark’s Nintendo 64 code with a documented matching-ROM build. The project combines reconstructed source with assets from a user-supplied original ROM, then checks version-specific artifact hashes. It is a reproducible-build research case, distinct from the separate native PC port; matching results remain project-reported here.
- [persona-psx: matching decompilation of Megami Ibunroku Persona](https://awesomerea.org/resources/persona-psx-case/index.md): Case study · persona-psx reconstructs the Japanese PlayStation release of Megami Ibunroku Persona as C source. Its documentation covers loading game overlays into Ghidra and IDA and adjusting source structure until compiled routines match the original bytes. The work remains in progress.
- [PES6 decompilation: matching the PS2 PAL executable and overlays](https://awesomerea.org/resources/pes6decomp-case/index.md): Case study · PES6 decompilation reconstructs C source for the PlayStation 2 PAL release of Pro Evolution Soccer 6, covering its resident executable, 26 executable overlays and an auxiliary ELF. Local builds compare recovered functions with the user's game inputs; the author reports 10,930 exact function matches and separately tracks provisional nonmatching C.
- [Petari: a matching Super Mario Galaxy decompilation](https://awesomerea.org/resources/petari-smg-decomp-case/index.md): Case study · Reconstructs Super Mario Galaxy’s Wii code as C++ that rebuilds, object by object, against main.dol files extracted from the user’s own Japanese, North American, PAL or Korean disc. Matched objects are linked from source and checked with objdiff and a target hash. The project describes itself as a work in progress, separate from any PC port, and says it does not accept AI-generated decompilation.
- [Phantasy Star Online Episode I & II Plus: matching GameCube decompilation](https://awesomerea.org/resources/pso-gc-decomp/index.md): Case study · This is a matching decompilation of Phantasy Star Online Episode I & II Plus for the GameCube, USA version 1.02, product code GPOE8P. The disc SHA-1 is 0ff155311f4cc57951c03baeb1a8cc15de5fe1cd. The executable files/PsoV3.dol has SHA-1 0d85744b51d7379efb025a943d0cd5aaae2191a3.
- [Phantasy Star Online Ver. 2: a hybrid Dreamcast matching decompilation](https://awesomerea.org/resources/phantasy-star-online-ver-2-dreamcast-case/index.md): Case study · Phantasy Star Online Ver. 2 is being reconstructed from C/C++ and typed static data for its European Dreamcast release. Complete function ranges are compared with the decoded executable; unmatched code is supplied through fallback assembly generated from the user's dump. The author reports that the matching source covers part of the executable.
- [Phantom Hourglass: an early-stage matching Nintendo DS decompilation](https://awesomerea.org/resources/phantom-hourglass-ds-decomp-case/index.md): Case study · Recreates C++ source for The Legend of Zelda: Phantom Hourglass by hand-decompiling its European and US Nintendo DS releases, using the dsd toolkit to delink code from a user-supplied ROM and rebuild the ROM. objdiff tracks matches function by function, and the default build compares the output ROM with a stored SHA-1. The work is at an early stage: decomp.dev reported 2.82% of code matched at the reviewed commit.
- [Pikmin 2: a fully matched GameCube decompilation across five releases](https://awesomerea.org/resources/pikmin-2-matching-decomp-case/index.md): Case study · A fan decompilation of Pikmin 2 that rebuilds main.dol for five GameCube releases (USA retail, two USA demos, PAL and Japan) with the original Metrowerks compilers, checking each against a stored SHA-1. The build reads main.dol from the user’s own copy of each release. decomp.dev reported all code matched and fully linked for every version at the reviewed commit, and a non-matching mode builds the US DOL entirely from C++ for modding.
- [Pilotwings64Decomp: matching decompilation of Pilotwings 64](https://awesomerea.org/resources/pilotwings-64-decomp-case/index.md): Case study · Pilotwings64Decomp reconstructs the North American Pilotwings 64 release as a matching source build. The repository includes C sources, versioned ROM configurations, extraction and rebuild steps, and documentation of the game's custom asset filesystem.
- [pokecrystal: a matching Pokémon Crystal disassembly](https://awesomerea.org/resources/pokecrystal-disassembly-case/index.md): Case study · Reconstructs the Game Boy Color game Pokémon Crystal as RGBDS assembly, with graphics, maps and data stored as editable sources. One tree builds the international 1.0 and 1.1 releases, the Australian release, two debug builds and a Virtual Console patch, each checked against a recorded SHA-1. Companion documentation covers script command formats and known bugs in the original game.
- [pokered: a matching Pokémon Red and Blue disassembly](https://awesomerea.org/resources/pokered-disassembly-case/index.md): Case study · Reconstructs the Game Boy games Pokémon Red and Blue as RGBDS assembly, with graphics and data kept as editable source files. One tree builds the USA/Europe Red and Blue ROMs, a Blue debug build and patches for the Virtual Console releases, each checked against a recorded SHA-1. It is a full disassembly rather than a decompilation into a higher-level language.
- [pokerevo: PAL Wii game decompilation](https://awesomerea.org/resources/pokerevo-pal-decomp-case/index.md): Case study · pokerevo is a decompilation of the PAL Wii release of Pokémon Battle Revolution that builds a main.dol identified by a published SHA-1 hash. Its build uses a clean PAL 1.0 DOL and the specified compiler package.
- [pokeruby: a matching Pokémon Ruby and Sapphire decompilation](https://awesomerea.org/resources/pokeruby-decomp-case/index.md): Case study · Reconstructs the Game Boy Advance games Pokémon Ruby and Sapphire as C source built with pret's agbcc compiler, alongside assembly data scripts and editable graphics. Matching builds cover the English 1.0, 1.1 and 1.2 revisions, debug builds and the first German editions, each checked against a stored SHA-1. A separate modern-GCC target is not expected to match.
- [Pokémon Battle Revolution: matching decompilation of the Wii game](https://awesomerea.org/resources/pbr-decomp/index.md): Case study · This is a matching decompilation of Pokémon Battle Revolution for the Wii, PAL RPBP01 revision 0. On 2026-10-12, 6,410 of 13,890 functions matched (21.05 percent), and 2.32 percent was in finished units linked into the build. python configure.py and ninja check main.dol against config/RPBP01/build.sha1. The disc image starts in orig/RPBP01/.
- [Pokémon Black: Nintendo DS decompilation](https://awesomerea.org/resources/pokeblack-case/index.md): Case study · This repository is a decompilation of Pokémon Black for the Nintendo DS. It builds pokeblack.us.nds, the Version 1.0 USA/EUR NDSi Enhanced ROM.
- [Pokémon Colosseum: continued GameCube matching decompilation](https://awesomerea.org/resources/pokemon-colosseum-continued-decomp-case/index.md): Case study · Pokémon Colosseum continues a GameCube matching decompilation with additional C and data reconstruction, a measured progress ledger, and native Windows build support. It covers the GC6E01 DOL and 25 REL modules. The author reports byte-identical rebuilt outputs using original fallback objects where source reconstruction remains incomplete.
- [Pokémon Dash: a byte-matched Nintendo DS decompilation](https://awesomerea.org/resources/pokemon-dash-decomp-case/index.md): Case study · pokemon-dash-decomp reconstructs source for the USA Nintendo DS release of Pokémon Dash and checks functions against exact compiled bytes while rebuilding the ROM byte for byte. It uses Metrowerks mwccarm and contains generated source, configuration and progress data; the author reports partial code matching.
- [Pokémon Emerald: a matching Game Boy Advance decompilation](https://awesomerea.org/resources/pokemon-emerald-decomp-case/index.md): Case study · Reconstructs Pokémon Emerald for the Game Boy Advance as buildable C source, with game scripts and data kept as assembler directives. The default agbcc build produces pokeemerald.gba, and make compare checks it against the SHA-1 of the original English ROM; an optional modern-GCC build is not hash-checked. Graphics and audio sources are committed in the tree, so the documented build reads no base ROM.
- [Pokémon FireRed and LeafGreen: a matching Game Boy Advance decompilation](https://awesomerea.org/resources/pokemon-firered-leafgreen-decomp-case/index.md): Case study · Reconstructs the English Game Boy Advance releases of Pokémon FireRed and LeafGreen as buildable C source, with game scripts and data kept as assembler directives. Default agbcc builds produce six ROM images, covering both games' 1.0 and 1.1 releases and two variants labeled switch, each checked against its own SHA-1 manifest. Graphics and audio sources are committed in the tree, so the documented build reads no base ROM.
- [Pokémon HeartGold and SoulSilver: a fork reporting a complete LLM-agent decompilation](https://awesomerea.org/resources/pokeheartgold-llm-agent-decomp-case/index.md): Case study · Continues pret’s HeartGold/SoulSilver disassembly in a separate fork that reports the US Nintendo DS releases fully decompiled to C and C++ with LLM agents, while both ROMs still rebuild byte-for-byte against their retail SHA-1s. A checked-in progress report counts about 99% of mapped code bytes as C or C++, and a batch-by-batch work log records each replaced assembly range and the hash checks that followed. README says pret does not accept AI-generated code and does not want to be associated with the fork.
- [Pokémon HeartGold and SoulSilver: a work-in-progress, checksum-matched DS disassembly](https://awesomerea.org/resources/pokemon-heartgold-soulsilver-disassembly-case/index.md): Case study · Rebuilds the US Nintendo DS releases of Pokémon HeartGold and SoulSilver from a work-in-progress disassembly in which part of the code has been decompiled to C. Each default build checks the ARM9 and ARM7 binaries, the filesystem and the complete ROM against per-game SHA-1 manifests. README warns that, because decompilation is incomplete, edits that change code or data layout can crash the game.
- [Pokémon Platinum: a checksum-matched Nintendo DS decompilation](https://awesomerea.org/resources/pokemon-platinum-decomp-case/index.md): Case study · Reconstructs the US Nintendo DS release of Pokémon Platinum as C source that rebuilds revision 1 by default and revision 0 on request. The default make target runs Meson checks of the code binaries, filesystem and complete ROM against SHA-1 manifests. README still calls the project work in progress; its contributing guide says the code is entirely C but much of it remains obfuscated, leaving documentation and tooling as the main work.
- [Pokémon Puzzle League: matching Nintendo 64 decompilation](https://awesomerea.org/resources/puzzleleague64/index.md): Case study · This is a matching decompilation of Pokémon Puzzle League for the Nintendo 64. The default build is the USA version. A big-endian ROM is named baserom.usa.z64 under config/usa. The build uses splat and reports a matching ROM.
- [Pokémon Rumble: an early Wii decompilation](https://awesomerea.org/resources/pokemon-rumble-decomp-case/index.md): Case study · The Pokémon Rumble project reconstructs C and C++ source for the Wii game, targeting USA revision WPSE01_01. Its workflow extracts main.dol from the owner's WAD, builds with Ninja and uses objdiff to compare changed objects; the author describes the work as very early.
- [Pokémon Stadium 2: matching Nintendo 64 decompilation](https://awesomerea.org/resources/pokestadiumgs-case/index.md): Case study · This is a work-in-progress decompilation of Pokémon Stadium 2 for the Nintendo 64, US and Japanese versions. It builds pokestadiumgs-us.z64 and pokestadiumgs-jp.z64.
- [Pokémon Stadium: matching Nintendo 64 decompilation](https://awesomerea.org/resources/pokestadium/index.md): Case study · This is a work-in-progress decompilation of the US version of Pokémon Stadium. A successful build produces pokestadium.z64, MD5 ed1378bc12115f71209a77844965ba50. The US 1.0 ROM goes in baseroms/us/baserom.z64. make init extracts it and make reassembles it. Debian and Ubuntu installs use make, git, build-essential, binutils-mips-linux-gnu, and Python newer than 3.7, plus the packages in requirements.txt.
- [Pokémon Sword and Shield: matching Pawn script decompilation](https://awesomerea.org/resources/swsh-pawn-scripts-case/index.md): Case study · Pokémon Sword and Shield's Pawn AMX scripts are reconstructed from game files. The disassembler emits code representations and data sections; a compile tool builds the repository's scripts with gf-pawncc, compares the generated representations and checks binary hashes against the game files.
- [Pokémon XD: Gale of Darkness: a matching GameCube decompilation](https://awesomerea.org/resources/pokemon-xd-gale-of-darkness-decomp-case/index.md): Case study · Reconstructs Pokémon XD: Gale of Darkness for GameCube as C/C++ source targeting a byte-identical retail build. Functions count as matched when objdiff finds identical machine code, and builds are checked against the retail DOL SHA-1. The author reports a local snapshot of 50.01% matched US code and 21.35% matched data.
- [Pokémon XD: matching GameCube decompilation](https://awesomerea.org/resources/xd-decomp/index.md): Case study · This repository is a decompilation of Pokémon XD: Gale of Darkness for GameCube. The goal is a matching retail binary. Supported versions are GXXE01, USA revision 0, and NXXJ01, the Japanese demo disc revision 0.
- [Psychonauts: matching Lua scripts and PC engine functions](https://awesomerea.org/resources/psychonauts-decomp-case/index.md): Case study · Psychonauts decompiles the PC game's modified Lua 4.0 scripts and portions of its 32-bit x86 engine into source checked by per-function byte comparisons. Its tools extract scripts from a user-owned game copy, rebuild them with a patched Lua compiler, and compare engine objects with Psychonauts.exe. The author reports all script functions matching and the engine still early in progress.
- [pw: a matching decompilation of the Pokéwalker firmware](https://awesomerea.org/resources/pokewalker-matching-decomp-case/index.md): Case study · Reconstructs as C the firmware of the Pokéwalker, the pedometer accessory for Pokémon HeartGold and SoulSilver, for its Renesas H8/38606 microcontroller. With artwork from the user’s retail firmware image and a supported Renesas compiler suite, the README reports a byte-identical rebuild of the 48 KiB image; without that image, original placeholder art gives a non-matching reference build. The author describes disassembling and decompiling the retail binary, the HeartGold/SoulSilver ROMs and the candidate compilers, alongside published hardware research.
- [ra2-decomp: a matching decompilation of Yuri's Revenge](https://awesomerea.org/resources/ra2-decomp-yuris-revenge-case/index.md): Case study · ra2-decomp reconstructs Command & Conquer: Red Alert 2 – Yuri's Revenge 1.001 as C++ and checks compiled functions against gamemd.exe byte for byte. It maps function addresses, source files and hashes, while recording unmatched attempts separately. The author reports 79% of the game's code bytes matched as of 6 November 2026.
- [Rage of Mages / Allods: matching reconstruction of the 1998 engine](https://awesomerea.org/resources/rom1-decomp-case/index.md): Case study · Reconstructs C++ source for the 1998 Rage of Mages / Allods engine and compares compiled functions with a specified ALLODS.EXE build. The project records executable structure, relocations and serialization findings, alongside build and matching tools. The author reports 329 exact functions out of 6,897 engine functions.
- [Rally Trophy Decomp: function-matched reconstruction of Rally Trophy 1.01](https://awesomerea.org/resources/rally-trophy-decomp-case/index.md): Case study · Rally Trophy Decomp reconstructs first-party functions from Rally Trophy 1.01 as C++ and compares locally compiled x86 code with the shipped Windows executable. Its function maps and subsystem notes record analysis findings, and the documented workflow associates nontrivial binary findings with REA evidence IDs.
- [Rampage 2: Universal Tour: matching PlayStation decompilation](https://awesomerea.org/resources/rampage-2-universal-tour-case/index.md): Case study · Rampage 2: Universal Tour is being reconstructed as matching C for the USA PlayStation release SLUS-00742. Its build reads the executable and two overlays from an owned disc image, first rebuilding them from split assembly and then replacing functions with C. The author reports a byte-identical split-assembly build and 97.1% of game code matched from C.
- [Ratatouille: matching the January 2006 prototype](https://awesomerea.org/resources/ratatouille-2006-prototype-case/index.md): Case study · The project reconstructs C/C++ source for the January 18, 2006 Ratatouille prototype and compares builds with four original GameCube ELF variants. It uses build scripts and objdiff for function-level comparison; the author reports that matched code is byte-identical while the overall decompilation remains unfinished.
- [Ratchet & Clank 3: matching PlayStation 2 decompilation](https://awesomerea.org/resources/rac3-matching-decomp-case/index.md): Case study · rac3-decomp reconstructs Ratchet & Clank 3 PlayStation 2 core and level programs from C and assembly, checking compiled functions against PAL and NTSC-U retail code. It tracks shared functions across versions and links functions at retail addresses; the author reports substantial matching progress while many level functions remain in assembly.
- [Ratchet & Clank Collection: PS3 executable analysis and matching reconstruction](https://awesomerea.org/resources/ratchet-clank-collection-ps3-case/index.md): Case study · Ratchet & Clank Collection analyzes four PS3 retail executables for the BCUS98282 release and develops C and C++ bodies to match their bytes. Its Python tools inspect SELF and PPU ELF structures, bound functions, compare related builds, and grade reconstructed bodies. The author reports six matching bodies at the documented checkpoint.
- [Ratchet & Clank Future: Tools of Destruction: early PS3 matching decompilation](https://awesomerea.org/resources/ratchet-clank-tools-of-destruction-decomp-case/index.md): Case study · Ratchet & Clank Future: Tools of Destruction is an early matching decompilation of the USA PlayStation 3 release. Its tools inspect the package, SELF container and decrypted PPU ELF, recover function boundaries and compare compiled C bodies with retail bytes. The author reports byte-exact results for an initial set of functions while the full executable remains a long-term target.
- [Ratchet & Clank: a matching PS2 decompilation with a documented agent workflow](https://awesomerea.org/resources/rac1-matching-decomp-case/index.md): Case study · Reconstructs C source for SCES_509.16, the PAL v2.00 PlayStation 2 executable of Ratchet & Clank (2002), with every function linked at its retail address. Functions not yet decompiled are still built from disassembly generated from the user's own executable, and the build audits functions, layout and the whole image against retail. The project documents an LLM-agent matching workflow and written build-fidelity rules for what counts as a match.
- [Ratchet & Clank: Going Mobile: output-matched Java reconstruction](https://awesomerea.org/resources/going-mobile-java-reconstruction-case/index.md): Case study · Ratchet & Clank: Going Mobile reconstructs ten Java classes for game version 1.1.0. Its pipeline compiles with Sun javac 1.4.1, runs ProGuard 3.2 and WTK 2.2 preverification, then compares methods and class files with retail output; the author reports exact matches for all ten classes.
- [Ratchet & Clank: Size Matters — scoped PS2 matching decompilation](https://awesomerea.org/resources/ratchet-clank-size-matters-decomp-case/index.md): Case study · Ratchet & Clank: Size Matters decomp reconstructs source for US and European PS2 boot executables and level modules against retail bytes. The project separates authored C matches from assembly baselines and records accepted placements and compiler evidence for bounded portions of the game.
- [Ratchet & Clank: Up Your Arsenal — byte-exact PlayStation 2 decompilation](https://awesomerea.org/resources/rac3-uya-decomp/index.md): Case study · This is a matching decompilation of Ratchet & Clank: Up Your Arsenal for the PlayStation 2, NTSC-U SCUS-97353. It builds frontbin.elf, boot_elf.elf, and i5bootn.elf byte for byte. Their SHA-1 values are 3bc94ee895e4b4af9b5602a229af599c1103b542, 487975305f8a263c750dfede50391b575ed07835, and 71f3ecfc54c3d24d1475ef9efe8228fbfe59d65f.
- [Rayman: matching decompilation of the PAL PS2 main executable](https://awesomerea.org/resources/rayman-pal-ps2-decomp-case/index.md): Case study · This project decompiles the PAL PlayStation 2 Rayman main executable, SLES_500.44, into C and hand-written assembly. Its build links an ELF at the original addresses and compares the main image and individual functions byte for byte with a locally supplied reference. The author reports 856 of 5,645 functions matching.
- [re4: a byte-identical decompilation of the Resident Evil 4 GameCube debug build](https://awesomerea.org/resources/re4-gamecube-debug-decomp-case/index.md): Case study · Reconstructs C and C++ source for the two-disc Resident Evil 4 GameCube debug prototype (G4BE08) and rebuilds main.dol and all 114 REL overlays with the compilers the README names, checking every output against a SHA-1 list. Function names are Capcom’s own from the debug build’s Bio4.sym files, and most struct and field names are aligned from the PS2 debug build’s debug information. The project’s research log says AI agents did the matching work; byte identity is project-reported.
- [ReC98: the Touhou PC-98 Restoration Project](https://awesomerea.org/resources/rec98-touhou-pc98-restoration-case/index.md): Case study · Reconstructs C++ and assembly source for the first five Touhou games, released by ZUN for the NEC PC-9801 in 1997–1998, under a rule that no master commit may change the decompressed program image or relocations of any original executable as compared by the project’s mzdiff tool. TH01 was fully decompiled in August 2022; code not yet decompiled stays in the tree as IDA-generated disassembly, and the project’s blog documents what each part of ZUN’s code does. Separate debloated and anniversary branches restructure the code and fix bugs as bases for ports and mods.
- [Resident Evil Director's Cut Dual Shock: a matching PlayStation decompilation](https://awesomerea.org/resources/resident-evil-directors-cut-dual-shock-decomp-case/index.md): Case study · Resident Evil Director's Cut Dual Shock reconstructs C source for the US PlayStation game's main program and 12 overlays. The author reports that all 13 program files rebuild to the original bytes with GCC 2.6.3; the repository also documents game logic, RAM use and disc contents.
- [Resident Evil: Code: Veronica — matching Dreamcast decompilation](https://awesomerea.org/resources/recv-dc-decomp/index.md): Case study · This is a matching decompilation of Resident Evil: Code: Veronica for the Dreamcast, US version. The current target is the main executable, 1ST_READ.bin. It uses the Sonic Adventure 2 Dreamcast decompilation as a template.
- [Rhythm Tengoku Arcade: SH-4 decompilation and asset-format reconstruction](https://awesomerea.org/resources/rhythm-tengoku-arcade-decomp-case/index.md): Case study · Reconstructs parts of Rhythm Tengoku Arcade's SH-4 program as C and assembly and implements round-trip tools for DTPK audio packages, STX textures and layered data ROMs. The author reports exact rebuilds for selected functions and asset packages while the game-code reconstruction remains partial.
- [Ridge Racer (PSP): bit-exact decompilation of BOOT.BIN](https://awesomerea.org/resources/ridge-racer-psp-decomp-case/index.md): Case study · Ridge Racer (PSP) reconstructs the game's BOOT.BIN as C and C++ and checks functions against retail bytes with a patched PSP GCC 1.3.1 compiler. A headless PPSSPP runner supports behavioral comparisons. The author reports 4,513 byte-exact game functions in the November 2026 progress snapshot.
- [River Raid: an annotated ZX Spectrum disassembly](https://awesomerea.org/resources/river-raid-zx-disassembly-case/index.md): Case study · River Raid is reverse-engineered from its ZX Spectrum 48K tape image into an annotated SkoolKit disassembly. Pasmo assembles the generated source for comparison with a game snapshot, and the repository records gameplay-loop and data-structure findings. The author reports a byte-identical build while routine documentation is still in progress.
- [Rock Band 3: agent-assisted Xbox 360 matching decompilation](https://awesomerea.org/resources/freeqaz-rock-band-3-xenon-case/index.md): Case study · rb3-xenon reconstructs Rock Band 3 Xbox 360 code in C++ and compares compiler output with the retail executable function by function. It uses the original MSVC Xbox 360 toolchain and extensive game-specific analysis and workflow code; the author reports 98.9% of game-code functions byte matched.
- [Rogue Byte: matching decompilation of Sly 2: Band of Thieves](https://awesomerea.org/resources/rogue-byte-sly-2-case/index.md): Case study · Rogue Byte reconstructs the USA PlayStation 2 release of Sly 2: Band of Thieves as readable C/C++ through a matching decompilation workflow. It splits a user-supplied executable, compiles recovered functions with the original compiler and checks the linked image byte for byte; the same C is also checked against the optional PAL executable.
- [Rogue Galaxy: a matching PlayStation 2 decompilation](https://awesomerea.org/resources/rogue-galaxy-decomp-case/index.md): Case study · Rogue Galaxy reconstructs the NTSC-U PlayStation 2 game's main executable and five overlays as C or C++. Its build extracts remaining library code and data values from the user's disc, then compares all six linked images with the retail files; the author reports byte-identical outputs.
- [RTWDecomp: matching decompilation of Rome: Total War Gold](https://awesomerea.org/resources/rtwdecomp-rome-total-war-case/index.md): Case study · RTWDecomp reconstructs source for the Steam release of Rome: Total War Gold from its Windows x86 RomeTW.exe. It splits the PE into translation units, uses Visual C++ 6.0 SP6 and objdiff to compare compiled functions, and publishes findings on command-line options, console commands and gameplay mechanics.
- [Rugrats: Scavenger Hunt: matching reconstruction of the USA N64 release](https://awesomerea.org/resources/rugrats-scavenger-hunt-case/index.md): Case study · Rugrats: Scavenger Hunt reconstructs the USA Nintendo 64 game with matching C, reviewed assembly, symbolic RSP code and descriptions of initialized data. Its tools rebuild CPU units with recorded compiler pipelines and compare code and non-code regions with a player-supplied ROM. The author reports complete executable-byte and ROM-inventory coverage.
- [saga: matching decompilation of LEGO Star Wars: The Complete Saga](https://awesomerea.org/resources/saga-lego-star-wars-decomp-case/index.md): Case study · saga reconstructs source for the Android x86 release of LEGO Star Wars: The Complete Saga, aiming to compile to the original machine code. Its build and matching tools compare locally supplied game binaries with reconstructed code; the README badge reports 90.02% matching progress.
- [SCD Disasm: Sonic CD disassembly](https://awesomerea.org/resources/scd-disasm-case/index.md): Case study · SCD Disasm reconstructs Sonic CD's Sega Mega CD program files from disassembly, initially using the V0.02 prototype. It organizes reused engine functions into shared source files with linker scripts for the disc files; the author reports that the resulting binary objects can be assembled into an ISO that runs in an emulator.
- [Scooby-Doo! Night of 100 Frights: matching GameCube decompilation](https://awesomerea.org/resources/scooby-doo-night-of-100-frights-case/index.md): Case study · The Scooby-Doo! Night of 100 Frights project reconstructs GameCube source for two USA disc revisions and builds main.dol executables checked against original SHA-1 hashes. It uses decomp-toolkit, target-specific split and symbol maps, compiler profiles and reconstructed C/C++ source. Users provide their own game disc; original disc files remain outside the repository.
- [Scott Pilgrim vs. The World: The Game: a Switch function reconstruction](https://awesomerea.org/resources/scott-pilgrim-switch-decomp-case/index.md): Case study · The project reconstructs Scott Pilgrim vs. The World: The Game – Complete Edition for Nintendo Switch as C and C++ functions. It checks complete compiled function extents against the original executable and documents gameplay structures and bounded behavior comparisons; the author reports partial exact-match coverage, while a linked game build remains unfinished.
- [sead: a decompilation of Nintendo’s first-party C++ standard library](https://awesomerea.org/resources/sead-nintendo-library-decomp-case/index.md): Case study · Decompiles sead, the C++ standard library that Nintendo statically links into its first-party games, covering containers, heaps, strings, math, file devices, threads, the game framework and graphics. Compile-time presets target the recent versions used by Breath of the Wild, Super Mario Odyssey, Splatoon 3, Tears of the Kingdom and Super Mario Bros. Wonder, and game decompilations such as Breath of the Wild pull it in as a submodule. Names come from debugging symbols and assertions in retail titles, and the README warns that many inlined and templated names are guesses.
- [Secret Agent Clank: matching PlayStation 2 decompilation](https://awesomerea.org/resources/rac-secret-agent-clank-decomp-case/index.md): Case study · Secret Agent Clank reconstructs C and C++ source for the US and PAL PlayStation 2 releases, including the boot executable and SNR2 level modules. Its workflow tracks function bodies and placements, compares builds against retail hashes, and records progress by version. The author describes the work as ongoing.
- [Serial Experiments Lain: matching PlayStation decompilation and native port](https://awesomerea.org/resources/lain-psx-decompiled-case/index.md): Case study · Serial Experiments Lain is reconstructed as C source for the PlayStation release and ported to Windows, macOS and Linux through a reimplementation of PlayStation SDK calls. The author reports that the rebuilt executable matches the retail binary byte for byte; the native client reads media and data from the user's two original discs.
- [SF1DISASM: a reassemblable Shining Force disassembly](https://awesomerea.org/resources/sf1disasm-case/index.md): Case study · SF1DISASM documents Shining Force as structured, commented 68k assembly and provides scripts to rebuild the US ROM. Its split step extracts data chunks from the user's original ROM before the build step assembles the source and extracted data. The project aims for a rebuilt ROM identical to the original.
- [SF2RE: reconstructing Shining Force II disassembly in IDA](https://awesomerea.org/resources/sf2re-case/index.md): Case study · SF2RE records Shining Force II reverse-engineering work as IDA Pro IDC scripts rather than a checked-in ROM image. The scripts initialize and annotate an IDA database from the USA ROM, parse game structures and export a split disassembly to SF2DISASM, where a vanilla build can be checked for bit-perfect output.
- [Shadow of the Colossus: matching decompilation of the PS2 release](https://awesomerea.org/resources/shadow-of-the-colossus-decomp-case/index.md): Case study · Shadow of the Colossus reconstructs functions from the NTSC-U PlayStation 2 game in C and checks rebuilt machine code against a user-provided original. Its build workflow compares output byte for byte, while function files and shared headers hold the recovered code and types. The author reports that 582 of 1,043 functions match exactly.
- [Shadow the Hedgehog: a matching GameCube decompilation](https://awesomerea.org/resources/shadow-gc-decomp-case/index.md): Case study · Shadow the Hedgehog reconstructs C++ source for the USA Rev 0 GameCube release using the original Metrowerks toolchain. The project compares its rebuilt main.dol with the retail executable byte for byte and publishes function progress, symbols and compiler research notes.
- [Shadow the Hedgehog: a three-region GameCube decompilation](https://awesomerea.org/resources/shadow-the-hedgehog-decomp-case/index.md): Case study · Shadow the Hedgehog decomp reconstructs source for the USA, Japanese and European/Australian GameCube releases. Its build extracts inputs from a user-owned disc image, compiles reconstructed files with pinned tools and uses objdiff for object-level comparison.
- [Shaun Palmer's Pro Snowboarder: a PS2 decompilation and format study](https://awesomerea.org/resources/shaun-palmers-pro-snowboarder-decomp-case/index.md): Case study · SPPS reconstructs Shaun Palmer's Pro Snowboarder for PlayStation 2 as C source and rebuilds game executables with splat and a matching-function workflow. Its notes document release hashes and the game's DATA.DAT asset archive, including sector-based entry offsets and sizes.
- [Shin Megami Tensei III: Nocturne: matching PS2 decompilation](https://awesomerea.org/resources/smt3-nocturne-decomp-case/index.md): Case study · Shin Megami Tensei III: Nocturne reconstructs readable C source for the US PlayStation 2 release and checks the linked executable against the retail SHA-1. Its build also assembles annotated VU microcode and retains assembly for unfinished functions. The author reports that a dated snapshot recovered 66.32% of game-code bytes from C.
- [Shining Force CD: a reassemblable game disassembly](https://awesomerea.org/resources/sfcd-disasm-case/index.md): Case study · SFCDDISASM provides an assembly disassembly of Shining Force CD for documenting and editing the game. Its scripts split a user-supplied US ISO into data chunks and combine them with the assembly; the author reports that the rebuilt ISO matches the original bit for bit. Some disassembly formatting remains unfinished.
- [Shining in the Darkness: a rebuildable 68k disassembly](https://awesomerea.org/resources/shining-in-the-darkness-disassembly-case/index.md): Case study · Shining in the Darkness is reconstructed as a 68k assembly listing intended for documentation and fan projects. Scripts split data chunks from the user's original US ROM and assemble them with the code. The author reports that the resulting ROM is bit identical to the original.
- [Shiren the Wanderer 2: matching N64 decompilation](https://awesomerea.org/resources/shiren-2-n64-decomp-case/index.md): Case study · Shiren the Wanderer 2 reconstructs most mapped CPU functions of the Japanese Nintendo 64 game as matching C and C++ source; the accounted CPU catalogue also includes classified handwritten assembly and libgcc helpers. The author reports byte-identical full-ROM acceptance builds.
- [Shox: Rally Reinvented: a function-level PlayStation 2 matching decompilation](https://awesomerea.org/resources/shox-rally-reinvented-decomp-case/index.md): Case study · shox-rr-decomp reconstructs C++ functions from the PlayStation 2 game Shox: Rally Reinvented. It uses the SN Systems GCC 2.95.2-EE toolchain through a Wine container and compares candidate objects with locally assembled retail references, checking machine-code bytes and relocations. The author reports a partial inventory of matched functions.
- [Sid Meier's SimGolf: source reconstruction of the English 1.03 release](https://awesomerea.org/resources/simgolf-decomp-case/index.md): Case study · Sid Meier's SimGolf reconstructs C and C++ source for the English 1.03 game's executable and three DLLs, comparing recompiled functions with the originals. The author reports instruction matches for every function, while the final linked files retain differences. Kaitai Struct definitions document several save, course, golfer and sprite-bank formats.
- [Silent Hill: matching PlayStation decompilation of the executable and overlays](https://awesomerea.org/resources/silent-hill-decomp-case/index.md): Case study · Reconstructs Silent Hill’s PlayStation code, the main executable plus its engine, screen and map overlays, as C that rebuilds byte-identical binaries from the user’s own NTSC-U 1.1 disc image. The project focuses on matching and naming. decomp.dev reports every function matched for the pinned commit, while data migration, shiftable builds and documentation remain open.
- [Skies of Arcadia Legends: matching GameCube decompilation](https://awesomerea.org/resources/skies-of-arcadia-legends-decomp-case/index.md): Case study · The Skies of Arcadia Legends project reconstructs C source for the USA GameCube release and builds a byte-identical main.dol from a user-provided disc image. It tracks function-level matches, uses objdiff for comparison and documents compiler behavior affecting Sega's Ninja graphics library; some matched library code is imported with attribution.
- [SkiesOfArcadiaLegends-Decomp: Skies of Arcadia Legends GameCube decompilation by ogdanimal](https://awesomerea.org/resources/skies-of-arcadia-legends-decomp-ogdanimal-case/index.md): Case study · Skies of Arcadia Legends reconstructs C source for the USA Rev 0 GameCube main.dol and checks rebuilt code with objdiff and compiler probes. It documents game systems including menus, cameras, sound and the frame loop while identifying separately imported SDK and MusyX code. The author reports 82 game functions linked from C in its October 2026 status block.
- [Skyward Sword: Wii decompilation with hash-checked relinking](https://awesomerea.org/resources/skyward-sword-decomp-case/index.md): Case study · Reconstructs C++ source for The Legend of Zelda: Skyward Sword’s Wii main.dol and REL modules, starting from the user’s NTSC-U 1.0 (SOUE01) disc files. Objects marked matching are compiled from source and linked with objects split from the original, and the result is checked against SHA-1 hashes; the repository ships no assets or assembly and focuses on source reconstruction, with porting outside the project scope.
- [Sly 2: Band of Thieves: a matching PS2 decompilation](https://awesomerea.org/resources/sly-2-matching-decomp-case/index.md): Case study · Sly 2: Band of Thieves reconstructs the USA PlayStation 2 executable as C and C++ built with period ee-gcc and SN assembler tools. Per-function compilation and relocation-aware comparison check the output against the owner's disc; the author reports that all 6,662 functions match byte for byte.
- [Sly Cooper and the Thievius Raccoonus: matching PlayStation 2 decompilation](https://awesomerea.org/resources/sly1-matching-decomp-case/index.md): Case study · Reconstructs source code for SCUS_971.98, the NTSC-U PlayStation 2 executable of Sly Cooper and the Thievius Raccoonus, as a work-in-progress matching decompilation. Functions not yet matched are still assembled from code split out of the user's own executable, and the build checks the linked ELF's SHA-1. The result runs in PCSX2 with the original disc for assets.
- [SMW NES Disassembly: disassembling the Famicom Super Mario World port](https://awesomerea.org/resources/smw-nes-disassembly-case/index.md): Case study · SMW NES Disassembly is a work-in-progress assembly disassembly of the unlicensed Famicom port of Super Mario World. Its build extracts assets from the user's ROM and assembles the source; the contribution guide calls for checking the assembled ROM against the final version's code.
- [Snowboard Kids 2: an LLM-assisted N64 matching decompilation](https://awesomerea.org/resources/snowboardkids2-decomp-case/index.md): Case study · A public matching decompilation of the N64 game Snowboard Kids 2, begun in 2024 with community decompilation tools. The author’s dated posts document Claude, Codex and GLM workflows, including headless one-shot loops, similarity-based function scheduling and hook-guarded, hash-checked builds, through a reported complete function match.
- [Snowboard Kids Plus: a matching PlayStation decompilation](https://awesomerea.org/resources/snowboard-kids-plus-case/index.md): Case study · Snowboard Kids Plus reconstructs C for the Japanese PlayStation release SLPS-01823 and rebuilds its boot executable with remaining assembly. A build script extracts data from the user's disc image and checks that the resulting executable matches the original byte for byte. The SNB.DAT data file is extracted unchanged.
- [Snowboard Kids: an agent-assisted N64 matching decompilation](https://awesomerea.org/resources/snowboardkids-matching-decomp-case/index.md): Case study · A matching decompilation of the original Nintendo 64 Snowboard Kids that rebuilds SHA1-identical North American and Japanese ROMs from a user-supplied ROM. The author’s 84-day post-mortem describes coding agents run through his Nigel harness alongside m2c, the permuter and a shared file of compiler learnings, and declines to credit LLMs alone for the speed-up. It is a separate project from the Snowboard Kids 2 decompilation.
- [Snowboard Kids: an early matching Nintendo 64 disassembly](https://awesomerea.org/resources/sonicdcer-snowboard-kids-case/index.md): Case study · The sk project reconstructs the US Nintendo 64 Snowboard Kids ROM from a user-supplied original, using static or dynamic analysis to build a source base. Its present work is described as mostly disassembly; the build workflow extracts needed assets and assembly locally and checks the rebuilt ROM against an MD5 hash.
- [Solomon's Key: byte-identical source reconstruction of three NES releases](https://awesomerea.org/resources/solomons-key-nes-reconstruction-case/index.md): Case study · Solomon's Key NES source reconstruction rebuilds the USA, European, and Japanese releases from shared ca65 assembly. The build extracts private CHR data from a user-supplied ROM, then compares rebuilt revisions byte for byte with the originals. Documentation covers the game architecture, RAM map, data formats, and subsystem behavior.
- [som-decomp: reconstructing Secret of Mana from a cartridge ROM](https://awesomerea.org/resources/som-decomp-case/index.md): Case study · som-decomp reconstructs the North American SNES release of Secret of Mana with matching 65816 and SPC700 assembly, readable C routines and documentation of combat, AI, maps, menus and audio. Its build extracts data from the user's ROM and the author reports a byte-exact rebuilt image; captured-state differential checks cover much of the recovered C.
- [Sonic 3 and Sonic & Knuckles: a byte-identical source reconstruction fork](https://awesomerea.org/resources/sonic3k-source-reconstruction-case/index.md): Case study · A source reconstruction fork rebuilds three regional Sonic the Hedgehog 3 ROMs, Sonic & Knuckles and the Sonic 3 & Knuckles lock-on composition byte for byte from user-provided images. Beyond the inherited disassembly, it organizes 68000 and Z80 source by subsystem and adds ROM identity checks, MAME runtime comparisons and bounded content round trips and edits.
- [Sonic Advance 1 & 2: a matching GBA decompilation with widescreen ports](https://awesomerea.org/resources/sonic-advance-1-2-decomp-port-case/index.md): Case study · Reconstructs Sonic Advance and Sonic Advance 2 for the Game Boy Advance as C that rebuilds six hash-listed ROMs with SAT-R’s agbcc fork, and compiles the same code into widescreen SDL ports for Linux, macOS and Windows plus PSP and PS2 builds. README reports Sonic Advance 2 built entirely from C with about 60 functions still non-matching. Extracted graphics, music and data are committed, so the builds read no original ROM.
- [Sonic Advance 3: an AI-assisted match of one enemy module](https://awesomerea.org/resources/sa3-marun-ai-decomp-case/index.md): Case study · Macabeus’s dated study describes prompting Claude Sonnet 3.5 and DeepSeek R1 with assembly, similar decompiled functions and structs to write matching C for Marun, one enemy module of the community Sonic Advance 3 GBA decompilation. The resulting pull request replaced that module’s assembly and was merged; the author calls the setting unusually AI-friendly, and the project now bars LLM-origin contributions.
- [Sonic Adventure decomp: rebuilding the Dreamcast executable from a local disc](https://awesomerea.org/resources/sonic-adventure-decomp-case/index.md): Case study · Sonic Adventure decomp reconstructs the European Dreamcast game's executable from a user-supplied disc, using per-function SH-4 assembly files as a byte-matching build baseline. Its tools split the executable, map text and models, disassemble SH-4 code, and compare recovered C functions against original behavior; the author reports that no C functions are complete yet.
- [Sonic Adventure DX: an early matching decompilation of the 2014 Steam release](https://awesomerea.org/resources/sonic-adventure-dx-steam-decomp-case/index.md): Case study · Sonic Adventure DX is being reconstructed from its 2014 Steam executable as C and C++ source that matches retail machine code function by function. The project uses the identified Visual C++ 2010 SP1 compiler, game-specific function and code-generation maps, and reccmp scores to compare rebuilt functions. The author reports an early stage with six exact function matches.
- [Sonic Adventure DX: matching reconstruction of the 2014 Steam executable](https://awesomerea.org/resources/sadx-decomp-case/index.md): Case study · Reconstructs C and C++ source for the 2014 Steam release of Sonic Adventure DX, comparing compiled functions with the retail executable. It uses Visual C++ 2010 SP1 to produce matching machine code and reccmp to check matches. The project aims to rebuild the whole executable byte for byte, one function at a time.
- [Sonic Battle: a matching GBA decompilation](https://awesomerea.org/resources/sonic-battle-decomp-case/index.md): Case study · Sonic Battle decomp reconstructs the USA Rev 0 Game Boy Advance game as matching C and assembly. Its build checks the user's ROM hash, compiles recovered code with agbcc and compares a linked whole-ROM image with the original. The author reports 51.81% of executable text decompiled to C; handwritten assembly accounts for additional reproduced bytes.
- [Sonic Riders: matching decompilation of the GameCube game](https://awesomerea.org/resources/sonic-riders-decomp/index.md): Case study · This is a work-in-progress decompilation of Sonic Riders for the GameCube, USA. It builds sonicriders.dol, SHA-1 e90a13504974b917a675d59f07014e0e817c5e5d.
- [Sonic Rush Adventure: an in-progress matching DS decompilation](https://awesomerea.org/resources/sonic-rush-adventure-decomp-case/index.md): Case study · Sonic Rush Adventure reconstructs the Nintendo DS game as a work-in-progress matching decompilation targeting the EU revision 00 ROM. The repository contains categorized disassembly and C sources, with matching functions still being developed.
- [Sonic the Fighters: an i960 program ROM disassembly](https://awesomerea.org/resources/sonic-the-fighters-disassembly-case/index.md): Case study · stfdisasm reconstructs the i960 program ROM of Sonic the Fighters as assembly source. The build instructions use i960 assemblers and a Python splitter to produce two interleaved ROM files, which the tool can compare against listed MD5 hashes; the author says the build is not yet shiftable.
- [Sonic the Hedgehog (2006): Xbox 360 source reconstruction](https://awesomerea.org/resources/sonic-2006-decomp-case/index.md): Case study · The Sonic the Hedgehog (2006) project reconstructs source for the Xbox 360 game. It builds against a user-provided XEX and uses objdiff to compare compiled objects with the original while contributors replace functions with C++ source.
- [Sonic the Hedgehog 2: byte-identical REV00 and REV01 source reconstruction](https://awesomerea.org/resources/sonic-the-hedgehog-2-source-reconstruction-case/index.md): Case study · The Sonic the Hedgehog 2 Source Reconstruction extends Sonic Retro's disassembly into shared 68000 and Z80 source for retail REV00 and REV01. It organizes modules by subsystem, models selected game data formats, and checks rebuilt ROMs byte for byte against the user's own images; the author also reports MAME runtime comparisons.
- [Soul Reaverse: reconstructing Legacy of Kain: Soul Reaver](https://awesomerea.org/resources/soul-reaverse-case/index.md): Case study · Soul Reaverse reconstructs Legacy of Kain: Soul Reaver’s PlayStation MIPS code as C from a prerelease executable with debugging symbols. Its source covers the main executable and gameplay overlays, with build and comparison configuration for matching reconstructed functions against the original.
- [Space Cadet Pinball: matching reconstruction of the XP SP3 executable](https://awesomerea.org/resources/space-cadet-pinball-matching-case/index.md): Case study · Space Cadet Pinball reconstructs source for the Windows XP SP3 game executable and compares builds with the original using reccmp. The author reports that all targeted functions match and roughly 95% of the whole executable matches; other releases are used as references.
- [Space Jockey: an exact-ROM Atari 2600 disassembly](https://awesomerea.org/resources/space-jockey-atari-2600-disassembly-case/index.md): Case study · A labeled and commented 6502 assembly listing reconstructs Space Jockey, US Games' first Atari 2600 game from 1982, and sets the TIA read base so it compiles to the exact 2K ROM image. An assembler switch selects NTSC or a PAL listing taken from the Carrere Video release, whose changes to vertical blank timing and colors are documented. Header notes discuss the origin of its horizontal positioning routine, and comments label obstacle attributes such as shot and firing flags.
- [spectrum-saboteur1-rev: matching disassembly of Saboteur](https://awesomerea.org/resources/spectrum-saboteur1-rev-case/index.md): Case study · spectrum-saboteur1-rev reconstructs assembly for the 1985 ZX Spectrum game Saboteur in a single sabot1core.asm file. The author reports that assembling it with pasmo produces a byte-for-byte match with a memory image.
- [Splashdown: a matching PS2 decompilation and Linux port](https://awesomerea.org/resources/splashdown-case/index.md): Case study · Splashdown reconstructs C++ source for the NTSC-U PlayStation 2 game and builds a native Linux x86-64 port from it. The project checks reconstructed functions and the linked executable against retail bytes and a SHA-1 hash. The author reports that all 4,356 game functions match and that the Linux port plays the full game at 30 FPS.
- [SpongeBob SquarePants: Battle for Bikini Bottom — GameCube decompilation](https://awesomerea.org/resources/bfbb-decomp-case/index.md): Case study · This is a work-in-progress decompilation of SpongeBob SquarePants: Battle for Bikini Bottom. The README says it builds main.dol with SHA-1 306526d90b48e99894c3138f5fc8f2716d9fecf6 for the NTSC-U version GQPE78.
- [Spyro 2: Gateway to Glimmer: matching PlayStation decompilation](https://awesomerea.org/resources/spyro-2-gateway-to-glimmer-case/index.md): Case study · Spyro 2: Gateway to Glimmer is being reconstructed as matching C for the European PlayStation release SCES-021.04. The build uses GCC 2.7.2 and an ASPSX 2.56-compatible pipeline for the main executable and 32 WAD overlays. The author reports a byte-identical rebuild of the executable, overlays, and complete WAD while C replacement remains partial.
- [Spyro 2: Ripto's Rage!: an in-progress PlayStation decompilation](https://awesomerea.org/resources/spyro-2-riptos-rage-decomp-case/index.md): Case study · Spyro 2: Ripto's Rage! reconstructs the NTSC-U revision 0 PlayStation executable and overlays from C source and assembly. The project targets byte-identical output, uses an older MIPS compiler for game source and keeps unmatched routines in assembly.
- [ssgdecomp: reconstructing Super Solvers: Gizmos & Gadgets!](https://awesomerea.org/resources/ssgdecomp-case/index.md): Case study · ssgdecomp reconstructs Super Solvers: Gizmos & Gadgets! with the aim of producing a bit-identical Windows executable. It uses the original ssgwin32.exe as an incremental starting point, builds with the period Borland toolchain, and compares PE sections and disassembly; its documented helpers inspect compiler output, import tables and OMF objects.
- [SSX 3: an in-progress matching PS2 decompilation](https://awesomerea.org/resources/ssx3-decomp-case/index.md): Case study · SSX 3 reconstructs source for the NTSC-U PlayStation 2 game with the goal of matching its executable. The repository includes C++ source, build configuration and working notes on functions, data structures and subsystems such as rider physics, animation and world streaming.
- [SSX Tricky: an in-progress matching PlayStation 2 decompilation](https://awesomerea.org/resources/ssx-tricky-decomp-case/index.md): Case study · SSX Tricky reconstructs source for the NTSC-U PlayStation 2 release and builds it against a user-provided SLUS_203.26 executable. The Ninja build checks the resulting image byte for byte, with tools for locating the first differing symbol and comparing object files.
- [SSX: a work-in-progress matching PS2 decompilation](https://awesomerea.org/resources/ssx-2000-decomp-case/index.md): Case study · SSX reconstructs the NTSC-U PlayStation 2 release of SSX (2000) as a matching decompilation. The repository includes game-specific C/C++ source, symbol maps and build scripts, and its compiler notes record recovered EE-GCC flags. The work remains in progress.
- [Star Fox 64: a complete matching Nintendo 64 decompilation](https://awesomerea.org/resources/sf64-matching-decomp-case/index.md): Case study · Reconstructs C source for the US 1.1 (Rev A) Nintendo 64 release of Star Fox 64 that, compiled with the IDO compiler through a static recompilation, rebuilds a ROM with the published MD5; the README badge counts all 2,951 functions as matching. Code and assets are split from the user’s own ROM at build time, and the repository contains no assets or assembly. The separately curated Starship PC port compiles this C code, while Starfox 64: Recompiled takes headers and some functions from it for its patches.
- [StarTropics: a byte-matched NES disassembly](https://awesomerea.org/resources/startropics-disassembly-case/index.md): Case study · Reconstructs StarTropics (USA) as labelled ca65 assembly across its 32 PRG banks and compares the resulting ROM byte for byte with the user's copy. Python tools generate the assembly from annotations, decode game data and export debugger labels.
- [Street Fighter III 2nd Impact: a matching CPS3 program decompilation](https://awesomerea.org/resources/sfiii2-cps3-decomp-case/index.md): Case study · Street Fighter III 2nd Impact reconstructs the CPS3 arcade program as C and SH-2 assembly. The build uses the Hitachi SHC toolchain, reads graphics pattern tables from the user's ROM set, checks the linked program against the arcade program's SHA-1, and compares rebuilt SIMM chips with the supplied ROM chips. The byte-match figures are the author's report.
- [Stretch Panic: matching decompilation of three PlayStation 2 releases](https://awesomerea.org/resources/stretch-panic-decomp-case/index.md): Case study · Stretch Panic reconstructs three PlayStation 2 releases from shared C/C++ source and compares each rebuilt executable’s loaded image byte for byte with the original. Its build splits a user-provided executable with splat, compiles matched functions with a pinned CodeWarrior toolchain, and assembles remaining functions; the author reports 589 of 1,351 game functions matched.
- [Summoner 2: matching PlayStation 2 decompilation](https://awesomerea.org/resources/summoner-2-ps2-decomp-case/index.md): Case study · Reconstructs the PlayStation 2 version of Summoner 2 as C++ source that is compared with the original executable. Splat separates executable units, objdiff checks functions, and the build links matched units from source while rejecting byte differences.
- [Summoner: A Goddess Reborn: an in-progress GameCube decompilation](https://awesomerea.org/resources/summoner-goddess-reborn-decomp-case/index.md): Case study · sgr reconstructs source for the USA GameCube release of Summoner: A Goddess Reborn. Its build uses the user's disc image and generated configuration, while objdiff compares rebuilt objects as the C and C++ decompilation progresses.
- [Super Mario 64 DS: matching decompilation with relocation checks](https://awesomerea.org/resources/sm64ds-decomp-case/index.md): Case study · Reconstructs Super Mario 64 DS functions as C/C++ and permitted assembly primitives, comparing compiled output with a user-supplied cartridge dump. Independent relocation-destination checks strengthen the matching gate; integration into the PC port is tracked separately.
- [Super Mario 64: ROM reconstruction with explicit comparison gates](https://awesomerea.org/resources/sm64-decomp-case/index.md): Case study · Reconstructs Super Mario 64 source for Japanese, North American, European, Shindou and iQue releases. Its build files distinguish original-ROM hash comparison from nonmatching or modified configurations, while source naming and documentation remain ongoing.
- [Super Mario Advance 2: exact-match GBA disassembly](https://awesomerea.org/resources/sma2-disasm-case/index.md): Case study · SMA2 disasm reconstructs the US Game Boy Advance ROM of Super Mario World: Super Mario Advance 2 as Armips assembly. The author reports an exact full-ROM rebuild, with ROM pointers replaced by labels and graphics and sound extracted locally from an original ROM.
- [Super Mario Advance 4: an exact-match Armips disassembly](https://awesomerea.org/resources/sma4-disasm-case/index.md): Case study · Super Mario Advance 4: Super Mario Bros. 3 U rev 1 is reconstructed as Armips assembly that the author reports reassembles to an exact ROM match. The project replaces ROM pointers with labels and supplies scripts to extract required graphics and sound data from the player's original ROM. A Wii U Virtual Console variant is supported when its data is supplied.
- [Super Mario Bros. Deluxe: partial exact-match disassembly](https://awesomerea.org/resources/super-mario-bros-deluxe-disasm-case/index.md): Case study · Reconstructs banks of the US version 1.1 Super Mario Bros. Deluxe ROM as WLA DX assembly. The author reports exact matches for the listed code and level-data banks and selected graphics banks, apart from the calculated checksum; other graphics banks and some pointer formats remain unresolved.
- [Super Mario Bros. Meta-Disassembly: six 8-bit engine variants](https://awesomerea.org/resources/smb-meta-disassembly-case/index.md): Case study · Super Mario Bros. Meta-Disassembly organizes six 8-bit Super Mario Bros. engine releases in one assembly codebase. Preprocessor definitions select release-specific code, while extraction scripts obtain assets from iNES or FDS game images. The assembly includes control-flow commentary.
- [Super Mario Bros.: ca65 reconstruction of seven releases](https://awesomerea.org/resources/super-mario-bros-disassembly-case/index.md): Case study · Super Mario Bros. Disassembly reconstructs seven NES, Vs. System, and Famicom Disk System releases as readable ca65 modules. Its build splits assets from user supplied images, rebuilds each supported revision, and compares the result byte for byte with the original; documentation maps source modules and game data formats.
- [Super Mario Land Disassembly: rebuilding the Game Boy game](https://awesomerea.org/resources/supermarioland-decomp-case/index.md): Case study · This repository is a disassembly of Super Mario Land. It builds Super Mario Land (World) (Rev A). Sections that are not yet disassembled are filled from the original ROM.
- [Super Mario Odyssey: per-function matching decompilation of the Switch executable](https://awesomerea.org/resources/odyssey-decomp-case/index.md): Case study · Reconstructs C++ source for Super Mario Odyssey’s Switch 1.0 main executable and checks each function against the original AArch64 machine code with the shared nx-decomp-tools checker. At the pinned commit its function list marks 18,996 of 74,171 functions matching. The README warns that the build remains an unplayable source reconstruction, the repository ships no game assets, and Nintendo libraries such as sead and agl come from open-ead’s separate reconstructions.
- [Super Mario Sunshine (USA): an AI-assisted matching decompilation fork](https://awesomerea.org/resources/sms-english-gmse01-decomp-case/index.md): Case study · Extends the doldecomp Super Mario Sunshine decompilation to the North American GMSE01 release. The README says AI was used extensively, and the repository’s agent rules, work order and progress files describe batch-based Claude and Codex orchestration. Its rebuilt DOL is reported byte-identical, but unfinished objects are still linked from code extracted from the user’s disc.
- [Super Mario Sunshine: an in-progress matching GameCube decompilation](https://awesomerea.org/resources/sms-matching-decomp-case/index.md): Case study · Reconstructs Super Mario Sunshine’s C++ source so that the original Metrowerks compiler reproduces byte-identical object files for four GameCube releases and the Switch 3D All-Stars build. The target binary comes from the user’s own disc image, and objdiff compares rebuilt objects function by function. The work is incomplete, and the repository publishes contribution rules for AI agents alongside its human workflow.
- [Super Monkey Ball: a GameCube disassembly and decompilation](https://awesomerea.org/resources/super-monkey-ball-decomp-case/index.md): Case study · Super Monkey Ball Decompilation reconstructs code from the NTSC-U GameCube release of Super Monkey Ball as C and assembly. The project builds supermonkeyball.dol and specifies the target file's SHA-1 hash; the reconstruction remains in progress.
- [Super Paper Mario: a selective matching Wii decompilation](https://awesomerea.org/resources/super-paper-mario-decomp-case/index.md): Case study · spm-decomp reconstructs selected Super Paper Mario code for Wii releases, chiefly the two PAL revisions, using decomp-toolkit and matching-object annotations. Its build reads a user-provided disc image; the project explicitly confines work to selected game components rather than the full game or a platform port.
- [Super Smash Bros. 64: matching Nintendo 64 decompilation](https://awesomerea.org/resources/ssb64-decomp-case/index.md): Case study · Super Smash Bros. 64 Decompilation rebuilds the US Super Smash Bros. ROM for the Nintendo 64. The README gives the baserom hashes, extracts assembly and assets with splat, and includes diff and m2c helpers for matching work.
- [Super Smash Bros. Brawl: an early matching Wii decompilation](https://awesomerea.org/resources/smash-bros-brawl-decomp-case/index.md): Case study · A work-in-progress matching decompilation of Super Smash Bros. Brawl that targets the USA Rev 2 Wii release (RSBE01_02), splitting main.dol and 126 REL modules from a user-supplied disc image and checking the rebuilt binaries against stored SHA-1 values. objdiff compares objects during development, and six other regional revisions are listed but commented out of the supported set. decomp.dev reported 1.27% of code matched at the reviewed commit.
- [Super Smash Bros. Melee: a matching GameCube decompilation with a shiftable build](https://awesomerea.org/resources/melee-matching-decomp-case/index.md): Case study · A matching decompilation of Super Smash Bros. Melee's US 1.02 release (GALE01) that rebuilds main.dol from C with the original Metrowerks compilers and checks it against the retail SHA-1. decomp.dev reports the code fully decompiled and linked at the reviewed commit, and the README says current work is mostly naming and cleanup. Because the build can be shifted, a separate non-matching mode lets modders add code to a DOL run with their own disc dump.
- [Surround: an annotated Atari VCS disassembly that compiles to the exact 2K ROM](https://awesomerea.org/resources/surround-atari-vcs-disassembly-case/index.md): Case study · Atari's 1977 VCS game Surround is disassembled into labeled and commented 6502 assembly that compiles to the exact 2K ROM image. The listing names the zero-page variables, the game-variation flags for speed-up, wraparound, erase, diagonal movement and single-player play, the joystick and switch masks, and the score and playfield drawing routines, with a compile switch for NTSC or PAL builds.
- [Syndicate: a matching decompilation of the DOS game](https://awesomerea.org/resources/syndicate-matching-decompilation-case/index.md): Case study · Syndicate reconstructs the DOS game's code in C, compiling functions with a period Watcom toolchain and comparing the resulting machine code with the original. The repository also contains decoded assembly, game architecture notes and scripts for tracking matches and rebuilding an executable. The author reports that the rebuilt DOS program reaches playable missions.
- [Syphon Filter: The Omega Strain — matching PS2 executable decompilation](https://awesomerea.org/resources/syphon-filter-omega-strain-decomp-case/index.md): Case study · Reconstructs much of the NTSC-U PlayStation 2 executable of Syphon Filter: The Omega Strain as C; with the remaining functions kept as split assembly, the build reproduces the retail SCUS_972.64 byte for byte. Committed objdiff reports track per-function matching against the user’s own executable. This is a matching-decompilation case; progress figures remain project-reported.
- [TA: Byte Tactics — byte-matching Total Annihilation source reconstruction](https://awesomerea.org/resources/byte-tactics/index.md): Case study · TA: Byte Tactics is a matching decompilation of Total Annihilation (Cavedog, 1997). The C++ in src/ is written to compile with Visual C++ 5.0 into the same bytes as TotalA.exe. The README says all 3,267 game functions match.
- [TA: Byte Tactics — matching decompilation of Total Annihilation](https://awesomerea.org/resources/ta-byte-tactics-case/index.md): Case study · TA: Byte Tactics reconstructs Total Annihilation v3.1 functions as C++ compiled with Visual C++ 5.0 SP3. Its checker compares each compiled function with TotalA.exe while accounting for linker-filled bytes; the author reports 1,973 byte-matched functions.
- [tactical-decomp: matching recovery of Final Fantasy Tactics](https://awesomerea.org/resources/tactical-decomp-case/index.md): Case study · tactical-decomp reconstructs the USA PlayStation release of Final Fantasy Tactics as C89 matched against the original executable and disc blobs. It splits user-supplied disc data, replaces assembly stubs function by function and checks rebuilt bytes with comparison tools. A related static recompilation directory uses the decompilation's address map as input.
- [Tag Force 5 Decompilation: matching the PSP game's code](https://awesomerea.org/resources/tag-force-5-decomp-case/index.md): Case study · Tag Force 5 Decompilation reconstructs C source for the PSP release ULES-01474 of Yu-Gi-Oh! 5D's Tag Force 5. Its workflow extracts the user's ISO, analyses Allegrex code with Ghidra and splat, and compares Metrowerks-compiled functions against target assembly with relocation-aware diffs. The author reports 15 of 16 text functions matched in rel_movie_viewer.
- [Tecmo Super Bowl: byte-exact NES disassembly](https://awesomerea.org/resources/tecmo-super-bowl-nes-case/index.md): Case study · This is a disassembly of Tecmo Super Bowl for the NES into 6502 source that rebuilds the original game byte for byte. The README says every instruction and memory location is labeled and commented.
- [Tenchu 1: a PlayStation decompilation of Shinobi Gaisen](https://awesomerea.org/resources/tenchu-shinobi-gaisen-decomp-case/index.md): Case study · The Tenchu 1 project reconstructs code for the PlayStation game Shinobi Gaisen through a split, C compilation and reassembly pipeline. Its documentation reports 175 exact C functions recovered for the ending executable and describes per-function matching work across the game's executables.
- [Tetris Plus: an early Game Boy disassembly](https://awesomerea.org/resources/tetris-plus-game-boy-disassembly-case/index.md): Case study · Reconstructs the USA/Europe Game Boy release of Tetris Plus as RGBDS assembly arranged by ROM bank. The build can compare its output SHA-1 against an original placed in the source directory; the project is at a very early stage.
- [Tetris: an annotated Game Boy disassembly](https://awesomerea.org/resources/game-boy-tetris-disassembly-case/index.md): Case study · Tetris reconstructs the Game Boy World Rev A release as an assembly listing generated with gbdasm and annotated by hand. The README gives RGBDS assembly and linking commands plus file and MD5 comparisons for checking the rebuilt ROM.
- [Tetris: byte-matching Game Boy disassembly](https://awesomerea.org/resources/tetris-gb-disassembly/index.md): Case study · This is a disassembly of Tetris for the Game Boy. It compiles 1:1 to the official Tetris (World) ROM. Code annotation and data annotation are still listed as unfinished.
- [tgm2p-decomp: matching The Grand Master 2 Plus SH-2 code](https://awesomerea.org/resources/tgm2p-decomp-case/index.md): Case study · tgm2p-decomp reconstructs the SH-2 program of Tetris: The Absolute – The Grand Master 2 Plus as C compiled with Hitachi SHC. Its probes compare instructions and literal pools with the arcade ROM, and its build checks linked code against a user-supplied verified ROM set.
- [TH04: rebuilding Lotus Land Story’s four PC-98 programs from source](https://awesomerea.org/resources/th04-reconstruction-case/index.md): Case study · Reconstructs source for the Japanese PC-98 Touhou 4: Lotus Land Story and rebuilds all four DOS programs, MAIN.EXE, OP.EXE, MAINE.EXE and ZUN.COM, with a pinned Borland toolchain under Wine. Function acceptance against the original binaries is tracked separately from emulator replays that compare inputs, RNG, object pools and video with the original game. Complete-campaign, original-timing and byte-identity goals remain open.
- [TH05: reconstructing Touhou 5's PC-98 programs](https://awesomerea.org/resources/th05-reconstruction-case/index.md): Case study · TH05 reconstructs source for the Japanese PC-98 Touhou 5: Mystic Square programs MAIN.EXE, OP.EXE, MAINE.EXE and ZUN.COM. Maintained C/C++ and reviewed assembly are compared against bounded original code and data extents, including raw bytes and relocation order. The project reports accepted units separately from its still unmeasured overall authored-byte goal.
- [th06: an independently matching Touhou 6 decompilation](https://awesomerea.org/resources/cirno-labs-th06-case/index.md): Case study · th06 reconstructs C++ source for Touhou 6: Embodiment of Scarlet Devil retail version 1.02h from the original executable. The workflow uses headless Ghidra analysis, the original MSVC and DirectX toolchain under Wine, and byte comparisons of functions and the whole executable. The author reports that all 511 game functions and the rebuilt executable match the original, with replay traces compared separately.
- [TH06: reconstructing Japanese 1.02h authored functions](https://awesomerea.org/resources/th06-strict-reconstruction-case/index.md): Case study · TH06 reconstructs the Japanese 1.02h game executable using a maintained source tree based on GensokyoClub/th06 and a pinned VC7.0 build. Its scripts compare complete function extents and COFF relocations; the author reports exact matches for 493 reviewed authored functions.
- [th07: reconstructing Touhou 7 retail 1.00b](https://awesomerea.org/resources/cirno-th07-case/index.md): Case study · th07 reconstructs C++ for the retail 1.00b executable of Touhou 7: Perfect Cherry Blossom using Ghidra analysis, the original Visual C++ .NET 2002 toolchain and byte comparisons against a user supplied game copy. The author reports that its standalone executable matches all 650,752 bytes of the original and documents replay trace comparisons.
- [TH08: exact-source reconstruction and separately tested ports](https://awesomerea.org/resources/th08-reconstruction-case/index.md): Case study · Reconstructs the original Japanese Touhou 8 version 1.00d against its binary and original compiler, then adapts the recovered code for other platforms. Source presence, strict function matching, whole-executable identity and playable-port checks are recorded as different milestones.
- [TH095: function-level reconstruction of Shoot the Bullet 1.02a](https://awesomerea.org/resources/th095-reconstruction-case/index.md): Case study · Reconstructs source for the original Japanese Touhou 9.5: Shoot the Bullet 1.02a executable, accepting function exactness only through reproducible byte comparison of pinned Visual C++ .NET 2003 builds against one hash-attested target. The whole program also compiles and links into a playable Windows i386 executable, while README keeps playability, function matching and whole-executable identity as separate statuses.
- [TH10: reconstructing Mountain of Faith 1.00a](https://awesomerea.org/resources/th10-reconstruction-case/index.md): Case study · TH10 reconstructs the Japanese 1.00a executable of Mountain of Faith as source checked against native code. It records function boundaries, origins and exact comparisons separately, while the complete Windows i386 build and runtime behavior remain open.
- [TH11: byte-exact source reconstruction of Subterranean Animism](https://awesomerea.org/resources/th11-reconstruction-case/index.md): Case study · TH11 reconstructs source for the original Japanese 1.00a executable of Touhou 11: Subterranean Animism. It records function boundaries and origins, compiles maintained C and C++ with a pinned VC9 toolchain, and compares complete generated code and relocations with the target.
- [The Bard's Tale: byte-matching reconstruction of BARD.EXE](https://awesomerea.org/resources/bards-tale-msdos-decomp-case/index.md): Case study · The Bard's Tale reconstructs the 1987 MS-DOS BARD.EXE as C and assembly modules built with Microsoft C 4.0 and LINK 3.51 /EXEPACK. Its scripts rebuild the root program and three overlays, then compare the result with a user-provided executable; the author reports a byte-identical full rebuild.
- [The Great Escape: an annotated ZX Spectrum disassembly](https://awesomerea.org/resources/the-great-escape-disassembly-case/index.md): Case study · The Great Escape reconstructs the 48K ZX Spectrum game from its tape image into annotated assembly and a cross-referenced HTML disassembly using SkoolKit. Its build can generate emulator-loadable TAP and Z80 images and documents decoded graphics, characters, items and game behavior.
- [The Incredibles: matching GameCube decompilation](https://awesomerea.org/resources/incredibles-gc/index.md): Case study · This is a matching decompilation of The Incredibles for the GameCube, USA GICE78, built on Heavy Iron's EvilEngine. The retail main.dol has SHA-1 c7413be2fba5b8cc47b7506ecb7785677a4a1c12 and is copied to orig/GICE78/sys/main.dol. The project uses decomp-toolkit. Matched code is shared with the Ratatouille prototype and Rise of the Underminer decompilations.
- [The Jungle Book: a Game Boy disassembly with level-analysis tools](https://awesomerea.org/resources/jungle-book-gb-disassembly-case/index.md): Case study · The Jungle Book project disassembles the Game Boy game into banked assembly and supplies tools to extract assets from a user's ROM. Its analysis utilities render level maps, decompress LZ77 data, inspect level objects, and export animation frames; the author reports a byte-exact rebuild when the extracted assets are supplied.
- [The Legend of Zelda: A Link to the Past: matching Japanese 1.0 disassembly](https://awesomerea.org/resources/alttp-jp-disasm/index.md): Case study · This is a disassembly of the Japanese 1.0 version of The Legend of Zelda: A Link to the Past. It assembles with the included alttp.futaba file and the Futaba assembler. An accurate build has CRC32 3322EFFC and SHA-1 E7E852F0159CE612E3911164878A9B08B3CB9060.
- [The Legend of Zelda: matching NES disassembly](https://awesomerea.org/resources/zelda1-nes-disassembly-case/index.md): Case study · This repository is a disassembly of The Legend of Zelda. A tool written for the project turns a Mesen .MLB file and the ROM into a listing, and the sources assemble with ca65. The build compares its output with the original ROM.
- [The Legend of Zelda: Ocarina of Time 3D: a USA code.bin decompilation](https://awesomerea.org/resources/oot3d-before-public-decomp-case/index.md): Case study · This project reconstructs source for the USA release of The Legend of Zelda: Ocarina of Time 3D using game data and static or dynamic analysis. Its Windows build produces oot3d.axf and a code.bin checked against the original MD5; rebuilding romfs.bin and the full .3ds image remains planned.
- [The Minish Cap: a GBA decompilation targeting five ROMs](https://awesomerea.org/resources/zelda-tmc-decomp-case/index.md): Case study · Recreates a C source base for The Legend of Zelda: The Minish Cap from information in the game and static or dynamic analysis, building five Game Boy Advance ROMs: USA, EU, JP and two demos. Each version takes its assets from a user-supplied original ROM, and normal builds check the output’s SHA-1 hash. The project remains a work in progress, and some parts of the ROM may not yet be shiftable.
- [The New Tetris: a matching Nintendo 64 decompilation](https://awesomerea.org/resources/the-new-tetris-decomp-case/index.md): Case study · The New Tetris project reconstructs source for the US 1.0 Nintendo 64 game through static and dynamic analysis. Its build uses a user-provided ROM to extract assets and assembly, compiles the recovered C source, and checks the output ROM against a documented MD5. The source reconstruction is described as work in progress.
- [The Oregon Trail: matching Win32 executable and DLL reconstruction](https://awesomerea.org/resources/oregon-trail-win32-decomp-case/index.md): Case study · This matching decompilation reconstructs C++ functions from the 1996 Windows release of The Oregon Trail, targeting Oregon32.exe and OREGON32.DLL. It compares functions compiled with Visual C++ 4.0 against the originals while accounting for relocated operands; the author reports 35,926 recovered instructions out of 64,499 inventoried.
- [The Sims: Bustin' Out: a matching GameCube decompilation](https://awesomerea.org/resources/bustin-out-gamecube-decomp-case/index.md): Case study · The Sims: Bustin' Out project reconstructs parts of the USA G4ME69 GameCube executable in C and C++, using SN Systems ProDG for game code. A patched decomp-toolkit splits main.dol into objects; the build substitutes matching source objects and compares the relinked executable with the user's disc copy. The author reports 6.24% of code matched.
- [The Sims: Bustin' Out: an AI-driven partial GBA matching decompilation](https://awesomerea.org/resources/sims-bustin-out-gba-decomp-case/index.md): Case study · Rebuilds the USA/Europe Game Boy Advance release of The Sims: Bustin' Out byte for byte while gradually replacing ROM regions with matching C compiled by agbcc. The README calls it an AI-driven experiment in which almost all code, analysis and tooling are AI-generated. Most of the ROM is still copied from the user’s dump.
- [The Urbz: Sims in the City: GameCube matching decompilation](https://awesomerea.org/resources/urbz-sims-in-the-city-gamecube-case/index.md): Case study · The Urbz: Sims in the City GameCube decompilation reconstructs game code for the GUBE69 release. Its decomp.wtf and decomp-toolkit workflow configures a main.dol rebuild, compares the result byte for byte with the user's copy, and uses objdiff to inspect function progress. The repository includes game-specific C sources, symbols, and split configuration.
- [The Wind Waker: a GameCube decompilation with hash-checked relinking](https://awesomerea.org/resources/wind-waker-decomp-case/index.md): Case study · Reconstructs source for The Wind Waker’s GameCube executable and REL modules across the USA/Korea, PAL and Japanese releases and a Japanese kiosk demo. 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 ships no assets or assembly and covers the GameCube game, not the HD remaster.
- [THPS2 Demo Decompilation: a function-matching PlayStation reconstruction](https://awesomerea.org/resources/thps2-demo-decomp-case/index.md): Case study · THPS2 Demo Decompilation publishes recovered C/C++ for the PlayStation Tony Hawk's Pro Skater 2 competition demo. The author reports exact object-code matches for 1,635 of 1,646 functions; the public snapshot can compile-check source units but excludes inputs needed to reproduce the match measurement.
- [Thrasher: Skate and Destroy: a matching PlayStation decompilation](https://awesomerea.org/resources/thrasher-skate-decomp-case/index.md): Case study · Thrasher: Skate and Destroy is being reconstructed function by function as C for its US PlayStation executable. The author reports a byte-identical full build from C and assembly, using a pinned PsyQ-era compiler, per-function comparison and a final SHA-1 check.
- [Thunderball: decompilation of Peggle Deluxe](https://awesomerea.org/resources/thunderball/index.md): Case study · Thunderball aims to decompile the English 1.01 executable of Peggle Deluxe from the Steam release. The README says many names come from unstripped ports cross-referenced with the Windows binary, and accuracy checks use reccmp. The repository omits the game assets.
- [Thunderclap: decompiling the Xbox Hulk game for a native port](https://awesomerea.org/resources/thunderclap-case/index.md): Case study · Thunderclap reconstructs the Xbox release of The Incredible Hulk: Ultimate Destruction in C++ for a planned native port. It byte-compares smaller functions with the original compiler and checks larger functions through differential execution against the original. The author reports source for all game functions and a Wine build that reaches the first mission.
- [Tiger Woods PGA Tour 2004: a matching GameCube decompilation](https://awesomerea.org/resources/tiger-woods-pga-tour-2004-decomp-case/index.md): Case study · tw2004 reconstructs the USA revision 0 GameCube main.dol of Tiger Woods PGA Tour 2004 as C source. Its build compares the output with the retail executable; the author reports byte-identical matching for all 7,647 functions, while naming and documentation work continues.
- [Tingle Tuner: matching Wind Waker GBA client reconstruction](https://awesomerea.org/resources/tingle-tuner-decomp-case/index.md): Case study · Tingle Tuner reconstructs the GBA client that The Wind Waker sends to a linked Game Boy Advance, covering Japanese, US, PAL and demo builds. Its C, assembly and LZ77 packer rebuild hash-checked client images from user-supplied discs, while separate documentation maps the GameCube-to-GBA JOY bus protocol.