# Reverse-engineering case studies · Page 4

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

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

## Games (200)

- [tnt-splat: reconstructing The New Tetris for N64](https://awesomerea.org/resources/tnt-splat-new-tetris-case/index.md): Case study · tnt-splat reconstructs The New Tetris for Nintendo 64 from C, assembly and a user-provided ROM. Its documented build uses splat to split the ROM, compiles with a MIPS cross toolchain and compares the resulting ROM against the base image.
- [ToeJam & Earl: matching Sega Genesis decompilation](https://awesomerea.org/resources/toejam-and-earl-case/index.md): Case study · ToeJam & Earl reconstructs two Sega Genesis retail revisions as matched C and readable 68000 and Z80 assembly. Build tools extract typed assets from the user's ROM and compare each rebuilt image with the original; the author reports byte-identical builds for both revisions.
- [Tom and Jerry Tales: matching decompilation of the EU Nintendo DS game](https://awesomerea.org/resources/tom-and-jerry-tales-decomp-case/index.md): Case study · Tom and Jerry Tales reconstructs C source for the EU Nintendo DS game with Metrowerks mwccarm. Its matching process counts a function only when its compiled bytes match the original and the user's ROM still rebuilds byte for byte; the author reports 92.10% matched code and 1889 of 1931 functions in the dated progress table.
- [Tomba!: matching decompilation of four PlayStation releases](https://awesomerea.org/resources/tomba-decomp/index.md): Case study · This matching decompilation of Tomba! builds four PlayStation releases from the same sources. NTSC-U SCUS-94236 has main-executable SHA-1 81cbc79f0230aeb4252e058039f47ac95a777f5a. NTSC-J SLPS-01144 has SHA-1 07d577698ad31ec1a69b9d7b80a7c3f90b650888. PAL SCES-01330 has SHA-1 1d98c6595a49bd8063c906221df1eaa854964cb1. PAL SCES-01331 has SHA-1 f6c383514e5d8367d2eed06400315cf6dd57ef6b. On the European discs the game itself is EXE/MAINn.EXE.
- [Tombi!: matching PlayStation decompilation and native port](https://awesomerea.org/resources/tombi-matching-decomp-case/index.md): Case study · Tombi-Decomp reconstructs PlayStation Tombi! code as C compiled against the original discs and also builds a native Windows, Linux and Android port. Its progress reports compare individual functions byte for byte across PAL, US, Japanese and demo versions; the author reports 99.68% matching game code for the PAL reference.
- [Tony & Friends: New Adventures: a reccmp-guided decompilation](https://awesomerea.org/resources/tony2-decomp-case/index.md): Case study · Tony & Friends: New Adventures reconstructs C and C++ source for the 1999 32-bit Windows game and its bundled sound library. It builds with period Visual C++ toolchains and uses reccmp to compare functions against the original TONY2.EXE; the author reports a few documented near matches.
- [Tony Hawk's Pro Skater: a matching Nintendo 64 decompilation](https://awesomerea.org/resources/thps64-case/index.md): Case study · thps64 reconstructs the C source of Tony Hawk's Pro Skater for Nintendo 64 (US V1.1) from a user-supplied ROM. It splits compressed game code into functions and compares compiled instructions with the original. The author reports a byte-identical default build, 2,449 matching functions and 62 more represented by nonmatching C.
- [Tony Hawk's Underground: a matching PS2 decompilation](https://awesomerea.org/resources/tony-hawks-underground-ps2-decomp-case/index.md): Case study · Tony Hawk's Underground is being reconstructed as matching C++ for the NTSC-U PlayStation 2 release SLUS-20731. The project splits the ELF into functions, compiles each recovered function with a pinned SN Systems toolchain and compares instructions; remaining functions are assembled so the complete build can be checked against the user's disc by SHA-1.
- [Top Spin 4 decompilation: matching Xbox 360 functions against three XEX modules](https://awesomerea.org/resources/top-spin-4-decomp-case/index.md): Case study · Top Spin 4 decompilation reconstructs C source for the Xbox 360 game and compares compiled functions against code in three retail XEX modules. The repository includes reconstructed functions, Ghidra analysis tooling, build configuration and progress reports; the author reports partial exact compiler matches.
- [Touhou 11: instruction-level C++ reconstruction](https://awesomerea.org/resources/touhou-11-reconstruction-case/index.md): Case study · Reconstructs Touhou 11 v1.00a in C++ and compares rebuilt code with the original using objdiff and reccmp. The author reports 360 of 1,094 functions strictly matched; a browser-port layer is present but its stated development gate remains pending.
- [Touhou 6: reconstructing Embodiment of Scarlet Devil 1.02h source](https://awesomerea.org/resources/th06-decomp-case/index.md): Case study · Reconstructs C++ source for the Windows executable of Touhou 6: Embodiment of Scarlet Devil version 1.02h, aiming at an exact rebuild with the original Visual Studio .NET 2002 and DirectX 8 toolchain. reccmp and objdiff compare the rebuilt binary with the user’s original executable function by function. The committed progress badge reports every function implemented and 98.03% byte accuracy.
- [Touhou 7: reconstructing Perfect Cherry Blossom 1.00b source](https://awesomerea.org/resources/th07-decomp-case/index.md): Case study · Reconstructs C++ source for the Windows executable of Touhou 7: Perfect Cherry Blossom 1.00b and its custom.exe configuration tool, built with the original Visual Studio .NET 2002 and DirectX 8 toolchain and compared function by function with the user’s originals through reccmp. The committed progress badges report th07.exe fully implemented at 99.78% accuracy and custom.exe fully matched. The README says the game should be fully playable, but a matching build trips the game’s integrity check, and the cross-platform ports live on separate branches.
- [Touhou 8: an independent matching decompilation of Imperishable Night](https://awesomerea.org/resources/cirno-labs-th08-case/index.md): Case study · Cirno-Labs/th08 reconstructs Touhou 8: Imperishable Night retail 1.00d in C++ and checks the build against the user's original game. The author reports byte matches for all game functions and the standalone executable, using the original MSVC toolchain, per-function comparisons and replay traces.
- [Touhou Eiyashou: matching-source reconstruction of version 1.00d](https://awesomerea.org/resources/gensokyoclub-th08-case/index.md): Case study · Touhou Eiyashou reconstructs C++ source for the Japanese 1.00d release of Touhou 8 and compares rebuilt code with the original executable using reccmp. The public repository contains source, build scripts and mapping data; further decompilation is being developed privately until completion.
- [Tourist Trophy: matching decompilation of the PS2 CORE.TT executable](https://awesomerea.org/resources/tourist-trophy-decomp-case/index.md): Case study · Tourist Trophy decompilation reconstructs functions from the PS2 game's CORE.TT executable as C and C++ compiled with Sony ee-gcc 2.96. Its tools decrypt and split a user-provided executable, compare individual functions and check the complete linked build against the original.
- [Toy Story 2: a PC game decompilation with reccmp comparisons](https://awesomerea.org/resources/toy-story-2-pc-decomp-case/index.md): Case study · Toy Story 2's PC decompilation reconstructs game and Nu3D engine code in C++ and builds a 32-bit executable and PDB for instruction comparison with reccmp. A companion utility decodes the game's RAW packet format and can export packets or selected actor records.
- [Toy Story disassembly: rebuilding the Mega Drive ROM from generated source](https://awesomerea.org/resources/toy-story-mega-drive-disasm-case/index.md): Case study · Toy Story disassembly reconstructs the Mega Drive game's ROM as generated assembly source and compares the rebuilt ROM byte for byte with the user's copy. Its 68000 tracer, ROM maps, RNC decoder, and sprite tools support ongoing recovery of routines, text, and graphics formats. The author reports that the rebuild matches while equivalent named source remains incomplete.
- [Turok 2: Seeds of Evil: a matching Nintendo 64 decompilation](https://awesomerea.org/resources/turok-2-seeds-of-evil-decomp-case/index.md): Case study · Turok 2: Seeds of Evil reconstructs the US 1.0 Nintendo 64 ROM from matched C and assembly. The project uses the SN64 GCC toolchain, per-function comparisons and a SHA-1 rebuild check; the author reports all original C code matched while readability work continues.
- [Turok 3: an archived multi-version decompilation](https://awesomerea.org/resources/turok-3-decomp-case/index.md): Case study · turok3 preserves a Turok 3 decompilation covering several dated builds and the US and EU Nintendo 64 releases. Its workflow extracts code and assets from a user-supplied ROM, builds a selected version and checks the result. The author has ended maintenance.
- [Turok: Rage Wars: matching decompilation of five N64 releases](https://awesomerea.org/resources/abun64-rage-wars-decomp-case/index.md): Case study · Turok: Rage Wars reconstructs C and assembly source for five Nintendo 64 cartridge releases, including German, European and North American variants. The build splits user-supplied ROMs, compiles the source and checks each rebuilt ROM against its original; the author reports near-complete byte matching.
- [Turok: Rage Wars: matching N64 decompilation and Windows port](https://awesomerea.org/resources/turok-rage-wars-decomp-case/index.md): Case study · Turok: Rage Wars aims to reconstruct matching C source for four N64 releases and provides a native Windows port based on the USA v1.1 ROM. The port implements graphics, audio, input and virtual Controller Paks on Windows. The author reports that it runs menus and one-to-four-player matches; the port currently supports USA v1.1.
- [Twilight Princess: a decompilation with fully matching GameCube code](https://awesomerea.org/resources/twilight-princess-decomp-case/index.md): Case study · Reconstructs Twilight Princess source that compiles back to binaries identical to the originals, building GameCube, Wii and Nvidia Shield releases from one codebase through conditional compilation. README reports the GameCube code as completely matching but not every translation unit linked yet, with Debug and Wii alignment ongoing; the repository ships no assets or assembly and will not produce a port.
- [Twisted Metal Re-Arc: matching reconstruction of the Japanese PlayStation game](https://awesomerea.org/resources/twisted-metal-re-arc-case/index.md): Case study · Twisted Metal Re-Arc reconstructs code and data from the Japanese 1995 PlayStation release of Twisted Metal using matching decompilation. Its build splits the user's extracted SIPS_600.07 executable, compiles replacement C units and checks a headerless code-and-data image against the original.
- [Twisted Metal: Black Re-Arc Project: matching PS2 source reconstruction](https://awesomerea.org/resources/twisted-metal-black-re-arc-case/index.md): Case study · Twisted Metal: Black Re-Arc Project reconstructs source for the game's NTSC PlayStation 2 executable through matching decompilation. Its build splits the user's SCUS_971.01 ELF, combines disassembled objects with reconstructed C and C++, and relinks an executable for comparison with the original.
- [u6-decompiled: decompiling Ultima VI: The False Prophet](https://awesomerea.org/resources/u6-decompiled-case/index.md): Case study · This repository decompiles the PC and MS-DOS version of Ultima VI: The False Prophet, version 4.5. It builds GAME.EXE and compares the result with the original. The C portions were built with Borland Turbo C 2.0.
- [Ultima IV: near-matching reconstruction of its DOS executables](https://awesomerea.org/resources/ultima-iv-decompiled-case/index.md): Case study · Ultima IV decompiled reconstructs the PC game's AVATAR.EXE and TITLE.EXE as C and assembly source. The author reports that compiling and linking the recovered files with Microsoft C Compiler 4.00 produces executables about ten bytes different from each original.
- [Underworld Exhumed: reconstructing Ultima Underworld I and II](https://awesomerea.org/resources/underworld-exhumed-case/index.md): Case study · Pairs reconstructed DOS sources with native ports of Ultima Underworld I and II. The upstream documents Exhume-based byte-matching builds, routine-level comparisons and recorded-session replay against DOS.
- [UNO!: a Game Boy Color disassembly](https://awesomerea.org/resources/uno-game-boy-color-disassembly-case/index.md): Case study · UNO! reconstructs the Game Boy Color game's ROM as assembly source. Its RGBDS Makefile assembles the source, links a ROM and offers an MD5 comparison against the recorded target hash.
- [Valkyrie Profile: a partial matching PlayStation decompilation](https://awesomerea.org/resources/valkyrie-profile-decomp-case/index.md): Case study · Valkyrie Profile decomp reconstructs parts of the Japanese Rev 1 PlayStation game as C that compiles to the original bytes. It covers the main executable and four overlays, with remaining functions retained as assembly. The author reports byte-matching outputs for all five units and warns that a build from a fresh clone may need local reference files.
- [Warblade Service Release: decompiling Warblade 1.34 and replacing PTK with SDL](https://awesomerea.org/resources/warblade-service-release-case/index.md): Case study · Warblade Service Release reconstructs Warblade 1.34 game code from its debug build and provides an SDL-based modern release. A PTK branch preserves function-level binary matches, while the SDL branch replaces PTK and BASS and adds window, rendering and interpolation options. Both branches use assets from a local Warblade installation.
- [Wario Land 4: a matching US/EU and Japanese GBA decompilation](https://awesomerea.org/resources/tsilaallaoui-warioland4-case/index.md): Case study · Wario Land 4 reconstructs source for the US/EU and Japanese GBA releases and builds ROMs from user-supplied originals. The author reports C equivalents for all functions while some assembly sites remain; the build uses agbcc and checks its output against version-specific MD5 hashes.
- [Wario Land 4: rebuilding US/EU and Japanese GBA ROMs](https://awesomerea.org/resources/wario-land-4-decomp-case/index.md): Case study · Wario Land 4 is an unfinished GBA decompilation that builds US/EU and Japanese ROM versions from source and assets extracted from the user's base ROM. Its build uses agbcc, ARM binutils and Python tooling, and reports a checksum result for the output.
- [wc2-re: a matching Wing Commander II reconstruction and SDL2 port](https://awesomerea.org/resources/wc2-re-case/index.md): Case study · wc2-re reconstructs Wing Commander II source from its Kilrathi Saga Win32 release and provides an SDL2 port. The C game core and C++ audio library rebuild with Visual C++ 4.1; the author reports that the resulting WC2.EXE matches all 714,752 bytes of the retail executable. The port runs with user-supplied game data on Windows, Linux and macOS.
- [WCW Nitro: a checksum-checked PlayStation decompilation](https://awesomerea.org/resources/wcw-nitro-decomp-case/index.md): Case study · WCW Nitro is a PlayStation game decompilation that rebuilds code from the SLUS_003.97 executable and WGAME.BIN and WMENU.BIN overlays. Its source tree contains reconstructed C files and build configurations; users supply files from their own disc, then run a checksum check on the generated binaries.
- [Whippy: matching decompilation of Kirby's Return to Dream Land](https://awesomerea.org/resources/whippy-kirby-return-to-dream-land-case/index.md): Case study · Whippy reconstructs Kirby's Return to Dream Land source for the USA and Korean Wii releases, comparing rebuilt main.dol files byte for byte with the originals. Its documentation covers the game's MetaFortress checks, linker code merging, object splits and matching workflow.
- [wii-ipl: a decompilation of the Wii Menu (System Menu 4.3)](https://awesomerea.org/resources/wii-menu-ipl-decomp-case/index.md): Case study · A work-in-progress decompilation of the Wii Menu, the console’s System Menu (IPL), targeting version 4.3 in its USA, European, Japanese and Korean builds. It recovers the menu’s own code together with the Revolution SDK, NintendoWare (NW4R), EGG and middleware libraries linked into it, matched unit by unit against the original executable with decomp-toolkit and objdiff. The repository holds no assets or assembly; a build needs the user’s own Wii Menu WAD and yields only main.dol.
- [Winning Eleven 3 Final Ver.: a matching PlayStation reconstruction](https://awesomerea.org/resources/winning-eleven-3-final-ver-case/index.md): Case study · Winning Eleven 3 Final Ver. reconstructs the Japanese PlayStation release's boot executable and five confirmed runtime overlays with an assembly baseline and byte-matching C functions. Its tools extract a user-provided disc, build modules and compare complete output hashes. The author reports 901 functions in matching C; a native PC build remains planned.
- [Wizardry 8 decompilation: reconstructing the Windows game and libraries](https://awesomerea.org/resources/wizardry-8-decomp-case/index.md): Case study · Wizardry 8 decompilation reconstructs the Windows game's executable and supporting libraries as C and C++ and compares rebuilt functions with retail code. Its workflow combines Ghidra analysis, Visual C++ 6 builds, reccmp comparisons and runtime tests; the recovered executable runs with original game data.
- [Wonder: a matching decompilation of Wonder Project J2](https://awesomerea.org/resources/wonder-project-j2-decomp-case/index.md): Case study · Wonder reconstructs code for the Japanese Nintendo 64 release of Wonder Project J2 and rebuilds a hash-checked ROM from the user's copy. Its source tree contains C, assembly and extraction tools, while its notes describe the game's ROM layout and SPI compression variants.
- [Xenoblade Chronicles 2: matching decompilation of the Switch executable](https://awesomerea.org/resources/xc2-decomp-case/index.md): Case study · xc2-decomp reconstructs Xenoblade Chronicles 2 version 1.0.0 C++ for Nintendo Switch and checks functions against the original AArch64 executable. Its Nix environment provides Clang 3.9.1 and analysis tools; check compiles reconstructed functions and reports byte differences. The author reports 37,087 of 48,739 named functions matched.
- [Xenoblade Chronicles 2: Switch source reconstruction](https://awesomerea.org/resources/xenoblade-chronicles-2-case/index.md): Case study · Xenoblade Chronicles 2 reconstructs C++ source for the Nintendo Switch game's version 2.1.0 ARM64 executable. The workflow uses Splat to divide the binary, Ghidra to inspect code and symbols, and objdiff to compare recompiled objects with the user's dumped executable.
- [Xenogears Decompilation: matching the US PlayStation release](https://awesomerea.org/resources/xenogears-decompilation-case/index.md): Case study · Xenogears Decompilation reconstructs source for the US PlayStation 1 release of Xenogears as an in-progress matching build. Its workflow uses splat to split binaries, spimdisasm for disassembly, and objdiff to compare compiled objects.
- [xenogears-decomp-port: matching Xenogears decompilation and native PC port](https://awesomerea.org/resources/xenogears-decomp-port-case/index.md): Case study · xenogears-decomp-port combines a partial matching C decompilation of PlayStation Xenogears with a native Linux x86-64 port. The port runs decompiled game code with PsyCross and SDL2 providing PlayStation hardware and host services, and reads files extracted from the user's own USA Disc 1. The author reports that the r5 release reaches the prologue, Lahan and the first Gear battle.
- [Xenosaga Episode I: an early PS2 matching decompilation](https://awesomerea.org/resources/xenosaga-i-decomp-case/index.md): Case study · Xenosaga-I-Decomp recovers C functions from the NTSC-U PS2 executable of Xenosaga Episode I and compares compiled bytes with the original ELF. Its tools split the executable, extract symbols and track decompilation progress. The author reports a byte-matching full executable build with a small fraction of functions rewritten in C; Japanese releases are planned.
- [xmen2-pc: a matching decompilation and native port of X-Men 2: Clone Wars](https://awesomerea.org/resources/xmen2-pc-case/index.md): Case study · xmen2-pc reconstructs X-Men 2: Clone Wars as handwritten C and ports it to Windows and Linux without 68000 emulation. Its workflow uses a byte-matching disassembly, static recompilation and the original Apple MPW C 3.3 compiler; the author reports machine-code matches for 3,047 C functions and instruction-level comparisons for 117 assembly functions. The port loads graphics, sound and levels from the user's ROM and adds widescreen play, higher display rates and rollback netplay.
- [xmen2disasm: rebuilding X-Men 2 from a matching disassembly](https://awesomerea.org/resources/xmen2disasm-case/index.md): Case study · xmen2disasm reconstructs the Sega Genesis game X-Men 2: Clone Wars as a byte-matching 68000 disassembly. Its build reads data from the user's ROM, and emulator traces support function boundaries, labels and coverage checks. The author reports a byte-identical ROM rebuild; the related C reconstruction and native PC port reside in xmen2-pc.
- [YaPang: matching decompilation of the PangYa client and renderer](https://awesomerea.org/resources/yapang-case/index.md): Case study · YaPang reconstructs the 2011 PangYa client and Direct3D renderer as C++ source checked function by function with objdiff against the original binaries. A separate JP client code area is functionally decompiled for a port. Third-party libraries are excluded from the decompilation.
- [Yoshi's Island: Super Mario Advance 3: an exact-match disassembly](https://awesomerea.org/resources/sma3-disasm-case/index.md): Case study · sma3-disasm reconstructs the US Yoshi's Island: Super Mario Advance 3 ROM as Armips assembly. The author reports an exact full-ROM match and replaces ROM pointers with labels to support edits. Game graphics and sound are extracted from a user-supplied vanilla ROM, while the single-cartridge multiplayer region still needs research.
- [Yu-Gi-Oh! Forbidden Memories: a matching PlayStation decompilation](https://awesomerea.org/resources/ygofm-decomp-case/index.md): Case study · ygofm-decomp reconstructs the North American PlayStation release of Yu-Gi-Oh! Forbidden Memories as C whose compiled functions match the original executable bytes. Unconverted functions remain extracted assembly, and the build hashes both the executable and complete disc image against a user-supplied copy.
- [Yu-Gi-Oh! Forbidden Memories: a regional byte-matching PlayStation decompilation](https://awesomerea.org/resources/yu-gi-oh-forbidden-memories-decomp-case/index.md): Case study · A byte-matching decompilation of Yu-Gi-Oh! Forbidden Memories reconstructs C source for seven regional PlayStation releases. Regional configurations and overlay inventories support rebuilding each PS-X executable against the user's game files; the author reports that some overlay coverage remains in progress.
- [Yu-Gi-Oh! Forbidden Memories: matching PS1 decompilation](https://awesomerea.org/resources/yu-gi-oh-forbidden-memories-ps1-decomp-case/index.md): Case study · Reconstructs the NTSC-U PlayStation release of Yu-Gi-Oh! Forbidden Memories as C compiled with the original PsyQ toolchain. The author reports byte-identical output for all 1,120 in-scope game functions; PsyQ library code and original hand-written assembly remain outside that C scope.
- [Yu-Gi-Oh! GX Tag Force: matching PSP decompilation with REA analysis](https://awesomerea.org/resources/tagforce-decomp-case/index.md): Case study · Yu-Gi-Oh! GX Tag Force reconstructs the North American PSP game's runtime and game modules as C. The build compiles the C with mwccpsp, compares the result with the original and retains unmatched parts as assembly. Architecture notes cite REA evidence from Ghidra analysis of the BOOT module. A playable PC port remains planned.
- [Yu-Gi-Oh! The Duelists of the Roses: a byte-matched PS2 decompilation](https://awesomerea.org/resources/duelists-of-the-roses-decomp-case/index.md): Case study · This decompilation reconstructs the NTSC-U PS2 release of Yu-Gi-Oh! The Duelists of the Roses in C, covering SLUS_205.15 and 762 code modules. Its make check target compares rebuilt files byte for byte with the user's originals. The author reports that the main executable is in C while module functions remain partly in assembly.
- [Yu-Gi-Oh! WCT 2006: GBA ROM disassembly](https://awesomerea.org/resources/ygowct06-case/index.md): Case study · ygowct06 reconstructs the USA GBA release of Yu-Gi-Oh! WCT 2006 from assembly and C source. Its build targets a ROM identified by a published SHA-1 hash and uses a matching base ROM supplied by the user.
- [Zelda II: Famicom Disk System disassembly](https://awesomerea.org/resources/zelda-ii-fds-disassembly-case/index.md): Case study · The Zelda II disassembly reconstructs the initial Famicom Disk System release of The Adventure of Link from a disk image. It includes utilities for building an FDS image, an asset extraction script, and C-like control-flow annotations. The files inside the rebuilt image are meant to match the originals, while the image itself carries local filenames and timestamps.
- [Zelda: The Wand of Gamelon: a matching CD-i decompilation](https://awesomerea.org/resources/zelda-wand-of-gamelon-decomp-case/index.md): Case study · Zelda: The Wand of Gamelon's CD-i main program is reconstructed as C compiled with Apple MPW C 3.0. The author reports byte-identical builds for English, French, German and Dutch versions after extracting data from the user's disc and checking each output hash.
- [Zoids Legacy: byte-matched GBA code reconstruction](https://awesomerea.org/resources/zoids-legacy-decomp/index.md): Case study · This rebuilds 1,130 code regions of Zoids Legacy for the Game Boy Advance, USA, and compares each region's bytes with the ROM. make verify checks the ROM SHA-1 and does not write a ROM. The translation editor is python3 tools/script_editor.py and listens on 127.0.0.1:5097. English and Spanish text files are dialogue-en.json, scene-translation.json, and the Spanish counterparts. The USA ROM is named Zoids Legacy (USA).gba.
- [Zoids Saga Fuzors: a byte-matching GBA decompilation](https://awesomerea.org/resources/zoids-saga-fuzors-decomp-case/index.md): Case study · Zoids Saga Fuzors is reconstructed as C and assembly code for the Japanese Game Boy Advance release. The verifier compiles each listed region at its original address and compares the bytes with the user's ROM; a native build takes remaining bytes from that ROM. The author reports 1,384 byte-matched regions, including 1,330 C functions.
- [Zoids Saga: Japanese GBA code reconstruction](https://awesomerea.org/resources/zoids-saga-one-case/index.md): Case study · Zoids Saga One Decomp reconstructs code regions of the Japanese GBA game as C and assembly. Its verifier checks the user's ROM hash, compiles each listed region at its original address and compares the generated bytes with the ROM; the author reports 1,897 byte-exact regions.
- [180: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/180-disassembly-case/index.md): Case study · 180 documents a SkoolKit disassembly of the ZX Spectrum game. The repository includes SkoolKit source, control and reference files, plus utilities for generating hexadecimal and decimal HTML listings. Building the development listings requires SkoolKit; users need the original game to disassemble its code.
- [4x4e: reconstructing 4x4 Evolution Build 57](https://awesomerea.org/resources/4x4e-case/index.md): Case study · 4x4e reconstructs source for Terminal Reality's 4x4 Evolution Build 57 from analysis of the original binaries. The repository contains game code and DirectX and OpenGL renderers. Its stated goal is a playable implementation; the source is incompatible with the original Build 44 release.
- [A-Team: an Atari 2600 disassembly with PAL conversion](https://awesomerea.org/resources/a-team-atari-2600-disassembly-case/index.md): Case study · A two-bank 6502 disassembly of A-Team for the Atari 2600 assembles with DASM and doubles as the basis for a PAL conversion. Compile switches pick NTSC, PAL 50 Hz or PAL60 colors and timing, and toggle the intro logo and intro glitch fixes, the level-1 border color cycling and a bug fix that keeps the scanline count fixed, each with the original behaviour available. Comments mark the color register writes for backgrounds, characters, missiles, the score panel and the intro screen.
- [abcParkDecomp: an Alphabet Park Adventure decompilation](https://awesomerea.org/resources/abcparkdecomp-case/index.md): Case study · abcParkDecomp reconstructs source for Alphabet Park Adventure. The repository contains C source files, build metadata and a Makefile that invokes the unSP toolchain through Wine; its documentation gives make targets for building and cleaning.
- [acnl-decomp: reconstructing Animal Crossing: New Leaf code and CRO modules](https://awesomerea.org/resources/acnl-decomp-case/index.md): Case study · acnl-decomp reconstructs the USA 1.5 release of Animal Crossing: New Leaf – Welcome amiibo as C++ source for its main code and CRO modules. Its GCC build checks implemented functions against a user-supplied dump using call order, member accesses, constants, references, and decisions rather than byte identity.
- [acnlwa-decomp: an Animal Crossing: New Leaf decompilation](https://awesomerea.org/resources/acnlwa-decomp-case/index.md): Case study · acnlwa-decomp is an in-progress C and C++ reconstruction of Animal Crossing: New Leaf. Its provenance notes track symbol names from ARM ELF mapping symbols, RTTI, Ghidra labels and manual code analysis, distinguishing provisional names from lasting ones.
- [AeroGauge: decompiling the Nintendo 64 game](https://awesomerea.org/resources/aerogauge-n64-decomp/index.md): Case study · This is an early decompilation of AeroGauge for the Nintendo 64, USA release. The ROM is named baserom.z64. The source tree has race logic, audio and DMA code, and libultra files. The README says the project is too early for modifications.
- [afe-decomp: decompilation of Animal Forest e+](https://awesomerea.org/resources/afe-decomp/index.md): Case study · afe-decomp is a work-in-progress decompilation of Animal Forest e+ for the GameCube, the Japanese release どうぶつの森 e+. The README supports revisions GAEJ01_00 and GAEJ01_01 and says the repository contains no game assets or assembly. Windows, macOS, and Linux setups use Python and Ninja, with wibo downloaded for macOS and Linux.
- [agl: decompilation of a Nintendo graphics library](https://awesomerea.org/resources/agl-decomp/index.md): Case study · agl is a decompilation of agl, a C++ library used by first-party Nintendo games for graphics, lighting, and parameter utilities called AAMP. The README points to open-ead/sead for the project goal, contribution guidelines, and build information.
- [Aidyn Chronicles: Ghidra-derived N64 source reconstruction](https://awesomerea.org/resources/aidyn-chronicles-decomp-case/index.md): Case study · Aidyn Chronicles: The First Mage is examined through Splat configurations and symbol tables for debug and NTSC 1.0 builds. The repository contains headers and manually cleaned, Ghidra-derived pseudocode for game source files, which the author describes as untested.
- [Air-Sea Battle: an annotated Atari 2600 disassembly](https://awesomerea.org/resources/air-sea-battle-disassembly-case/index.md): Case study · A labeled and commented 6502 assembly listing reconstructs Air-Sea Battle, Atari's 1977 game for the Atari 2600, on the MiniDig disassembly page. An assembler switch selects the NTSC or PAL build of the 2K ROM. Header notes cover the taller PAL kernel zones, why the NTSC version's EXPERT difficulty gives a missile size of 0, and the two RAM locations, $91 and $92, that the author marks as unused.
- [Alien vs Predator: Atari Jaguar 68000 code reconstructed in C](https://awesomerea.org/resources/alien-vs-predator-jaguar-c-decompilation-case/index.md): Case study · Alien vs Predator (Atari Jaguar) — C Decompilation reconstructs the game's ordinary Motorola 68000 behavior as readable C. The code covers gameplay, audio control, files, rendering orchestration and save support, with host service interfaces for Jaguar-specific operations.
- [Alleyway: annotated Game Boy disassembly and decompilation](https://awesomerea.org/resources/alleyway-game-boy-decomp-case/index.md): Case study · Alleyway documents a Game Boy disassembly and experimental C decompilation of the game's World ROM revision. It names roughly 200 functions and reports findings about an unused tilemap routine, serial-port-based RNG seeding and a paddle wall-clip bug; RGBDS commands assemble the ROM.
- [Amplitude: a PS2 decompilation in progress](https://awesomerea.org/resources/amplitude-2003-case/index.md): Case study · Amplitude (2003) is a decompilation project for the NTSC-U/C retail release. The workflow extracts SCUS_972.58 from a retail ISO, runs configure.py and ninja, and sets up objdiff after a successful build.
- [Angry Birds Decompilation: Lua script recovery](https://awesomerea.org/resources/angry-birds-decomp/index.md): Case study · Angry Birds Decompilation documents recovery of Lua scripts from the PC ports of the Angry Birds games. The README's automatic path runs birdout.py with Python 3, 7-Zip, and a JDK, and the manual path uses OpenSSL, 7-Zip, and unluac. It points readers to their own PC-port files.
- [AutoDestruct-xport: a native port of Auto Destruct](https://awesomerea.org/resources/autodestruct-xport-case/index.md): Case study · AutoDestruct-xport ports the PlayStation game Auto Destruct from decompiled code into a C runtime with Windows and web entry points. Its project notes describe native saves, CD data access, FMV playback and reviewed executable addresses.
- [AutoZone Hot Pursuit: reconstructing Need for Speed: Hot Pursuit](https://awesomerea.org/resources/autozone-hot-pursuit-case/index.md): Case study · AutoZone Hot Pursuit reconstructs the 1998 Need for Speed: Hot Pursuit and Modern Patch in C++ from analysis of their binaries. Its source includes a game framework, a sound module and DirectX 5, 6 and 7 renderer implementations, with documented calling conventions and module callbacks.
- [AZHS: reconstructing Need for Speed: High Stakes 4.50](https://awesomerea.org/resources/azhs-case/index.md): Case study · AZHS reconstructs Need for Speed: High Stakes 4.50 source from the original game binaries. Its technical notes map Watcom and Visual C++ calling conventions, the eacsnd.dll sound module, and several DirectX 6 and 7 renderer variants; complete playability and broader platform support remain goals.
- [Babil Decompilation Project: Final Fantasy IV 3D Remake source reconstruction](https://awesomerea.org/resources/babil-decompilation-project-case/index.md): Case study · Babil Decompilation Project reconstructs C++ source for the Steam version of Final Fantasy IV 3D Remake, targeting its November 2020 update. The repository contains game-structured C++ files and a Visual Studio project with Steamworks and SDL2 dependencies.
- [Back to Skool: a SkoolKit ZX Spectrum disassembly](https://awesomerea.org/resources/back-to-skool-disassembly-case/index.md): Case study · The Back to Skool project publishes a SkoolKit disassembly of the ZX Spectrum game. It provides decimal and hexadecimal browsing builds and can export assembly source from the SkoolKit file.
- [Balloon Fight: disassembly of the NES game](https://awesomerea.org/resources/balloonfight-disasm/index.md): Case study · This is a disassembly of Balloon Fight for the NES, USA. Assembly uses ARM9's bass fork. An iNES build needs the CHR file named BalloonFight.chr.
- [Banjo-Kazooie: Xbox Live Arcade decompilation](https://awesomerea.org/resources/bk360/index.md): Case study · This decompiles the Xbox Live Arcade version of Banjo-Kazooie. The expected default.xex has SHA-1 24f81f8058d1be416d95ccfcb5ebd2503eb4fd47. make split reads bk.yaml, and make regenerates merged.xex. The documented Xbox 360 SDK is version 7645. Comparisons use Visual Studio 2005 SP1 output against GCC for PowerPC, so objdiff shows function-call relocations as different.
- [Battlestations Pacific: an incremental Win32 C++ reconstruction](https://awesomerea.org/resources/battlestations-pacific-reconstruction-case/index.md): Case study · Reconstructs Battlestations Pacific's Win32 executable routine by routine as compilable MSVC C++ from Ghidra analysis. Addressed ledgers record ABI details, evidence, and uncertainty, while a milestone-based executable and focused probes exercise recovered subsystems.
- [Batty: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/batty-disassembly-case/index.md): Case study · batty provides a SkoolKit disassembly of the ZX Spectrum game Batty. The repository contains skool and control sources, reference notes and scripts for building hexadecimal and decimal HTML listings.
- [BIT.TRIP COMPLETE: a Wii decompilation](https://awesomerea.org/resources/bit-trip-complete-case/index.md): Case study · BIT.TRIP COMPLETE is an in-progress Wii decompilation of game ID SVTEXS. Its decomp-toolkit configuration splits the DOL into build objects from a user-supplied disc image, while objdiff supports function comparisons. The repository includes a small set of game-specific C++ sources and build hashes.
- [Black & White: reconstructing the game from its x86 binary](https://awesomerea.org/resources/black-and-white-reconstruction-case/index.md): Case study · Black & White reconstructs the 2001 game's systems in portable C++ using analysis of its original x86 executable. An IDA and Ghidra pipeline walks RTTI vtables to recover class methods; the native viewer runs reconstructed world loading, physics, animation, scripting and audio paths.
- [blackhack: runblack.exe UI widget decompilation](https://awesomerea.org/resources/blackhack-case/index.md): Case study · blackhack rebuilds the SetupControl UI widget classes of runblack.exe as hand-decompiled C, covering buttons, big and tab buttons, check boxes, lists, sliders, edit fields, colour pickers, pictures and graph widgets, along with parts of Lionhead's lhlib. A Detours launcher checks the executable's md5, injects a DLL and swaps original functions for the rebuilt ones through per-version tables of function and data addresses. It also patches the fullscreen setter so runblack.exe always runs windowed.
- [Blast Corps: Nintendo 64 decompilation](https://awesomerea.org/resources/blastcorps-decomp/index.md): Case study · This repository is a decompilation of Blast Corps for the Nintendo 64. Named ROMs are the USA version, USA revision 1, the Japanese Blastdozer, and the European English and German version. Naming of the source and data is still in progress.
- [Blitz_MasterVer22-Decomp: a Splatoon 2 version 3.1.0 decompilation](https://awesomerea.org/resources/splatoon-2-310-decomp-case/index.md): Case study · Blitz_MasterVer22-Decomp reconstructs code from Splatoon 2 version 3.1.0 for Nintendo Switch. Its setup reads the user's main NSO executable, prepares a Clang 4.0.1 build and offers a difference checker for the decompiled code.
- [Blood Omen 2: functional decompilation toward a Switch port](https://awesomerea.org/resources/bloodomen2nx-case/index.md): Case study · BloodOmen2NX functionally decompiles the Spanish Windows PC release of Blood Omen 2 into C++17 for a planned Nintendo Switch port. The Linux host build reads game formats and renders a level for comparison with the original under Wine. The author reports that no chapter can yet be completed and the Switch backend has not begun.
- [Boku Doraemon: Dreamcast executable and model reconstruction](https://awesomerea.org/resources/boku-doraemon-decomp-case/index.md): Case study · Boku Doraemon maps the Japanese Dreamcast game's 1ST_READ.BIN, generates a matching assembly baseline from an owner's disc, and tests C function candidates for equivalent calls, memory writes and results in an SH-4 interpreter. Its committed model map records recognized models, textures, sounds and offsets. The author reports 123 equivalent functions, all from locally supplied SDK source at this checkpoint.
- [Bomberman 64: The Second Attack!: partial N64 decompilation](https://awesomerea.org/resources/bm64tsa-case/index.md): Case study · bm64tsa is an in-progress decompilation of the Japanese and US Nintendo 64 releases of Bomberman 64: The Second Attack!. It combines C and assembly sources with versioned build tooling, extracts from a user-provided base ROM, and lists MD5 hashes for rebuilt ROMs.
- [Boom Street: a Wii decompilation in progress](https://awesomerea.org/resources/boom-street-decomp-case/index.md): Case study · Boom Street is a work-in-progress Wii game decompilation targeting the ST7P01 Rev 0 European release. It builds source against files extracted from the user's disc image and provides objdiff configuration for examining reconstructed objects.
- [Bounce Tales: decompiling the J2ME game](https://awesomerea.org/resources/bounce-tales-decomp/index.md): Case study · This repository is a decompilation of Rovio's Bounce Tales (2008), a J2ME game that shipped on Nokia Series 40 phones. It aims to reproduce the original behavior. A Jademula layer can run it as a Windows application.
- [BS Zelda no Densetsu: a two-version SNES disassembly](https://awesomerea.org/resources/bs-zelda-no-densetsu-disassembly-case/index.md): Case study · BS Zelda no Densetsu disassembles two SNES broadcast ROM versions, Map 1 Week 2 and Week 3, with Week 2 as its base. Its assembly maps and scripts use a clean, headerless user-supplied ROM to extract the game's assets.
- [BTD5-Decomp: a hand-built Bloons TD 5 decompilation](https://awesomerea.org/resources/btd5-decomp-case/index.md): Case study · BTD5-Decomp reconstructs Bloons TD 5 source by hand in C++, using leftover debug information where available to name files and classes. Its intended comparison is between compiled project code and the game executable, while the current source tree remains unbuildable.
- [BugsDecomp: decompiling Bugs Bunny: Lost in Time for PC](https://awesomerea.org/resources/bugsdecomp-case/index.md): Case study · BugsDecomp reconstructs functions from the PC game Bugs Bunny: Lost in Time for versions 1.0 and 1.6. A DLL and launcher patch decompiled functions into the running game, while accompanying notes document function locations and the BZE level-file format.
- [Bumpy's Arcade Fantasy: reconstructing a DOS game in C](https://awesomerea.org/resources/bumpys-arcade-fantasy-decomp-case/index.md): Case study · Bumpy's Arcade Fantasy reconstructs the 1992 DOS game's engine as C source guided by Ghidra analysis. It includes a build target for a faithful executable and a playable target with a host layer, plus Python decoders for PAV, DEC, BUM, VEC, BIN and CAR resources. The original game files are supplied separately by the user.
- [c1: a C port of PlayStation Crash Bandicoot](https://awesomerea.org/resources/crash-bandicoot-c1-port-case/index.md): Case study · Ports the original PlayStation Crash Bandicoot game code to C function by function; its coding standard labels functions with the addresses of their original implementations. Only the PC build, using OpenGL, SDL2 and FluidSynth, currently works; it loads asset files from the user’s game disc and is only partially playable.
- [Call of Duty 2: Big Red One: reconstructing Xbox game code in C++](https://awesomerea.org/resources/cod2-big-red-one-decomp-case/index.md): Case study · Call of Duty 2: Big Red One reconstructs the original Xbox game's code as C++ toward a native Linux and Windows build. Ghidra analysis and function naming support the work; a comparison harness checks rewritten functions against the originals, primarily during gameplay and, for some functions, offline. The author reports 7,067 rewritten functions, while most mission-script functions remain unfinished.
- [Castlevania: Order of Ecclesia — decompiling the Nintendo DS game](https://awesomerea.org/resources/ooe-decomp/index.md): Case study · This is a work-in-progress decompilation of Castlevania: Order of Ecclesia for the Nintendo DS. The supported original cartridges are YR9E00 (USA), YR9J00 (Japan), YR9K00 (Korea), and YR9P00 (PAL), all revision 0. Install steps are in INSTALL.md.
- [ChameleonTwist2v1.0-JP: rebuilding the Japanese Nintendo 64 game](https://awesomerea.org/resources/chameleon-twist-2-jp-case/index.md): Case study · ChameleonTwist2v1.0-JP reconstructs buildable source for the Japanese v1.0 Nintendo 64 release of Chameleon Twist 2. Its workflow splits a user-supplied ROM into build inputs and uses the repository's C source and configuration to rebuild a ROM.
- [Club Penguin Game Day: a work-in-progress DOL reconstruction](https://awesomerea.org/resources/club-penguin-game-day-decomp-case/index.md): Case study · Reconstructs the US revision 0 DOL of Club Penguin Game Day through a buildable assembly tree and PowerPC linker configuration. The project is marked work in progress and requires a clean original DOL plus the specified compiler, linker and devkitPPC assembler.
- [CMR2Decomp: decompiling Colin McRae Rally 2.0](https://awesomerea.org/resources/cmr2-decomp/index.md): Case study · CMR2Decomp is a decompilation of the PC game Colin McRae Rally 2.0. It uses reccmp to check functions and globals. The solution is for Visual Studio 2022, and the code is written so it can still be compiled with MSVC 6.0. CI uses a portable MSVC 6.0.
- [Combat: an annotated Atari 2600 disassembly](https://awesomerea.org/resources/combat-atari-2600-disassembly-case/index.md): Case study · A commented 6502 assembly listing reconstructs Combat, the Atari 2600 tank, biplane and jet game, aiming to explain every instruction, memory location and table. Assembled with DASM it yields an image that differs from the cartridge ROM only in the unwritten padding bytes before the startup vectors. The header maps all 27 game variations to their missile, maze and cloud options, and main-loop routines carry Atari's original names, taken from presentation notes.
- [Computer Archeology: disassembly notes for arcade games](https://awesomerea.org/resources/computerarcheology/index.md): Case study · Computer Archeology stores the markdown disassemblies and notes that its toolchain renders into the pages at computerarcheology.com. Assembly files stay in GitHub-flavored markdown, and a names-in-code pass links memory operands to named definitions. The README starts the renderer with py -m computerarcheology.carender.app.
- [Cosmic Ark: a commented Atari 2600 disassembly with PAL conversion](https://awesomerea.org/resources/cosmic-ark-atari-2600-disassembly-case/index.md): Case study · Cosmic Ark for the Atari 2600 (Imagic, 1982) is reconstructed as an analyzed, labeled and commented 6502 assembly listing with NTSC and PAL builds. The PAL conversion rescales nearly all game speeds through the game's fractional addition so both versions play at the same pace, and optional switches enable size optimizations. The notes point out the leftover code for a non-cooperative two-player mode and the game's heavy use of status flags.
- [Costume Quest: Windows x86 functional decompilation](https://awesomerea.org/resources/costume-quest-decomp-case/index.md): Case study · Costume Quest reconstructs functions from the Windows x86 Steam build 81338 as C++ source intended to match game behavior. The project records original function addresses, marks uncertain or unfinished sections, and builds with xmake and an x86-capable MSVC toolchain using a separately obtained game copy and Steamworks SDK.
- [Crash Bandicoot: The Wrath of Cortex: an early PS2 decompilation](https://awesomerea.org/resources/crash-ps2-case/index.md): Case study · crash-ps2 begins a C decompilation of Crash Bandicoot: The Wrath of Cortex for PS2 NTSC-U v1.00. It contains several reconstructed functions and stubs, with a stated plan to move from functional implementations toward instruction matching and a PS2SDK build.
- [Crash Bash: a PSX decompilation with function comparison](https://awesomerea.org/resources/crash-bash-decomp-case/index.md): Case study · Crash Bash is an ongoing decompilation of the PlayStation game, with recovered code organized by game binary. The documented strategy proposes loading rewritten functions into PCSX-Redux memory and comparing their output with the original functions. Accompanying scripts analyze emulator traces and apply symbols to the results.
- [Crash Tag Team Racing: GameCube decompilation](https://awesomerea.org/resources/crash-tag-team-racing-decomp-case/index.md): Case study · Crash Tag Team Racing is a work-in-progress GameCube decompilation with C and C++ source, symbol maps and build configurations for the USA and Japanese releases. Users provide their own disc image, configure the target and build with Ninja; the Japanese release has not yet been split.
- [Crash Twinsanity: a C++ reconstruction of the PAL PS2 executable](https://awesomerea.org/resources/crash-twinsanity-decomp-case/index.md): Case study · Crash Twinsanity reconstructs the PAL PlayStation 2 game’s executable in C++, using a platform layer and data split from the user’s original executable. The author reports that the build boots and plays in PCSX2 with matching boot state, frame output and saves. The build tools also generate assembly from the user’s executable for a byte-matching comparison.
- [Crazy Taxi decomp: rebuilding the European Dreamcast game from C](https://awesomerea.org/resources/crazy-taxi-decomp-case/index.md): Case study · Crazy Taxi decomp reconstructs the European Dreamcast game's executable with recovered C and per-function SH-4 assembly generated from the user's disc. Its pipeline maps game assets, checks C functions against original behavior and builds a disc image with the reconstructed executable. The author reports a byte-for-byte executable rebuild and a playable game.
- [Dance Central 3: decompiling the Xbox 360 game](https://awesomerea.org/resources/dc3-decomp/index.md): Case study · This repository decompiles Dance Central 3 for Xbox 360, the build dated 16 September 2012. The tree contains no game assets or assembly.
- [Dark Rift: a game decompilation and combat-state analysis](https://awesomerea.org/resources/dark-rift-case/index.md): Case study · Dark Rift is a game decompilation with reconstructed gameplay, audio, model, and system source files. Its research notes map player move IDs through combat states and transition rules loaded from character .db files.
- [dataeast_snddrv: High Seas Havoc sound driver disassembly](https://awesomerea.org/resources/dataeast-snddrv-case/index.md): Case study · dataeast_snddrv is a disassembly of the sound driver Data East used in High Seas Havoc, split into 68000 driver code, a Z80 DAC sample player and a frequency table, assembled with vasm. Its documentation describes the song layout of six track pointers mapped to YM2612 channels, the track command opcodes for tempo, loops, portamento, LFO, panning and DAC samples, and the 32-byte instrument record. Python scripts extract songs, instruments and samples from a ROM of a game that uses the driver.
- [Decompiling Sonic 1: translating 68K disassembly into C++](https://awesomerea.org/resources/decompiling-sonic-1-case/index.md): Case study · Decompiling Sonic 1 translates the game's 68K assembly disassembly into organized C++11 source to study its behavior. The source covers levels, objects, movement, graphics and sound, while accompanying notes explain assembly patterns and inferred semantics.
- [Deus Ex: reconstructed DeusEx.dll native code](https://awesomerea.org/resources/deus-ex-dll-reconstruction-case/index.md): Case study · Reconstructs the native DeusEx.dll game module for Deus Ex from analysis of its retail binary and Unreal Engine 1 interfaces. The project combines decompiler output, disassembly, SDK headers, UnrealScript declarations, and observed behavior; its recovered C++ remains a work in progress.
- [Devilution: reconstructing Diablo's original source](https://awesomerea.org/resources/devilution-case/index.md): Case study · Devilution reconstructs source for the original Diablo game from surviving symbols and debug information in PlayStation and PC releases. Its C++ code builds a replacement for Diablo.exe that uses the user's original game files. The project preserves original behavior, including bugs, and treats Hellfire support as future work.
- [Digimon World 4: a work-in-progress GameCube decompilation](https://awesomerea.org/resources/dw4-gc-case/index.md): Case study · dw4-gc is a work-in-progress decompilation of Digimon World 4 for GameCube, targeting GDJEB2 Rev 1 USA. It configures and builds from a user-provided disc image, then generates objdiff configuration for comparing reconstructed source objects. The repository contains C source, headers, symbols, and split configuration.
- [Dishonored Recompilation: rebuilding the 2013 Win32 game executable](https://awesomerea.org/resources/dishonored-recompilation-case/index.md): Case study · Dishonored Recompilation rebuilds the retail 2013 Win32 game executable as a functional, nonmatching C++ implementation. It combines a reference UE3 source tree with binary analysis, layout checks and runtime comparisons; the author reports that the build reaches the opening boat ride.
- [DisMKW: an in-progress Mario Kart Wii disassembly](https://awesomerea.org/resources/dismkw-case/index.md): Case study · DisMKW reconstructs the NTSC-U release of Mario Kart Wii as PowerPC assembly, covering game and Mario Kart Channel code. Its build uses main.dol and StaticR.rel from the user's copy, while the progress list tracks sections still dependent on binary inclusion.
- [DoConfig-Decompilation: reconstructing Cave Story's options program](https://awesomerea.org/resources/doconfig-decompilation-case/index.md): Case study · DoConfig-Decompilation reconstructs the options program for Cave Story as recompilable C++ source. The author reports that the rebuilt program behaves like the original.
- [DOD13-Client: reconstructing the Day of Defeat 1.3 client library](https://awesomerea.org/resources/dod13-client-case/index.md): Case study · DOD13-Client reconstructs the Day of Defeat 1.3 client library function by function on hlsdk-portable for Xash3D FWGS. It replaces client.dll or client.so, restores weapons, HUD, effects, movement, and menus, and documents engine messages and client mechanics.
- [Donkey Kong Country 2: an SNES disassembly](https://awesomerea.org/resources/donkey-kong-country-2-disassembly-case/index.md): Case study · Donkey Kong Country 2 Disassembly reconstructs the USA 1.0 SNES game's assembly and memory maps. Its Asar scripts extract required assets from a user-supplied, headerless ROM, while the repository keeps the disassembly and patch scaffolding.
- [Donkey Kong Country: a work-in-progress SNES disassembly](https://awesomerea.org/resources/donkey-kong-country-disassembly-case/index.md): Case study · Donkey Kong Country reconstructs assembly source for the SNES US v1.0 release. The work began with snes2asm output and includes game banks, SPC700 audio code, build scripts and notes on the ROM's HiROM layout. The project aims to recreate the game's source through static and dynamic analysis.
- [Donkey-Kong-NES-Disassembly: disassembling the NES game](https://awesomerea.org/resources/dk-nes-disasm/index.md): Case study · This disassembles Donkey Kong for the NES across Rev 0 (Japanese), Rev 1 (International), and the GameCube revision. The README says the code is fully disassembled and that graphics data is not included. It assembles with asm6.
- [DoomRPG-RE: reconstructing Doom RPG in C](https://awesomerea.org/resources/doomrpg-re-case/index.md): Case study · DoomRPG-RE reconstructs Doom RPG as a C program with gameplay, combat, menus, rendering and input modules. Its SDL-based executable loads game data from DoomRPG.zip and builds through CMake with audio and compression dependencies.
- [Duck Hunt: an NES disassembly](https://awesomerea.org/resources/duck-hunt-nes-disassembly-case/index.md): Case study · Duck Hunt reconstructs NES game code and data as assembly files. The project directs users to extract graphics from their own ROM and assemble the source with ASM6N.
- [DuckTales: a Game Boy disassembly](https://awesomerea.org/resources/ducktales-game-boy-disassembly-case/index.md): Case study · DuckTales of Disassembly provides assembly source for the Game Boy version of DuckTales. Its bank and data files can be assembled with RGBDS after graphics are extracted from a user's ROM and the Nintendo logo bytes are supplied.
- [Duke64-RE: reconstructing Duke Nukem 64 in C and assembly](https://awesomerea.org/resources/duke64-re-case/index.md): Case study · Duke64-RE reconstructs the North American Nintendo 64 release of Duke Nukem 64 as C and MIPS assembly. A ROM segment map assigns offsets to game, renderer, audio, and libultra source files; the Makefile invokes MIPS tools and an IDO compiler for the build.
- [DWM2: disassembling Dragon Warrior Monsters 2](https://awesomerea.org/resources/dwm2-case/index.md): Case study · DWM2 is a partial disassembly of Dragon Warrior Monsters 2 with assembly sources and function-level documentation. Its Windows build uses rgbasm, rgblink and rgbfix, then compares the produced ROM with a user-held backup. The author reports a very early byte-similarity result and says documentation progress differs from that figure.
- [dynamitedan: an annotated Dynamite Dan disassembly](https://awesomerea.org/resources/dynamitedan-case/index.md): Case study · dynamitedan presents an annotated disassembly of the 1985 computer game Dynamite Dan. Its SkoolKit files include game and loader listings, with reference files for the game.
- [Eltale Monsters: a ROM-based decompilation](https://awesomerea.org/resources/eltale-monsters-decomp-case/index.md): Case study · Eltale Monsters is a decompilation built from a user-provided base ROM. The repository contains C and assembly sources and instructs users to build with configure and Ninja.
- [Everyone's A Wally: a ZX Spectrum disassembly](https://awesomerea.org/resources/everyones-a-wally-disassembly-case/index.md): Case study · wally is a disassembly of the ZX Spectrum game Everyone's A Wally. Its repository contains SkoolKit sources for the game and loader, Z80 assembly, reference files and build scripts.
- [Exile: an annotated disassembly of the enhanced BBC Micro version](https://awesomerea.org/resources/exile-enhanced-disassembly-case/index.md): Case study · An annotated disassembly reconstructs the enhanced BBC Micro version of Exile, the 1988 Superior Software adventure game, from its binary images, covering the sideways-RAM sample loader, the decryption code and the main game. Technical notes give the address ranges of the sprite plotter, the procedural 256x256 tile landscape generator, the three-list object physics engine, envelope-based sound, NPC mood stimuli and the novella-word copy protection, alongside game-play notes and a list of memory pokes.
- [Extreme-G 2: functional N64 decompilation](https://awesomerea.org/resources/extreme-g-2-n64-decomp-case/index.md): Case study · Reconstructs Extreme-G 2 for Nintendo 64 as C and assembly using IDO 7.1, aiming for functional equivalence rather than a byte-identical C rebuild. The author's notes report byte-exact boot assembly sections; linking and checking the main decompressed code remain pending.
- [Faceball 2000: a SNES USA disassembly](https://awesomerea.org/resources/faceball-2000-disassembly-case/index.md): Case study · Faceball 2000 is represented by SNES assembly sources for the USA release. The project uses a SNES ROM framework and a batch script to extract needed assets from a user's headerless copy before assembly.
- [Fahrenheit: an analytical PS2 prototype decompilation](https://awesomerea.org/resources/santamonica-fahrenheit-case/index.md): Case study · santamonica is an early C++ decompilation of a PS2 prototype of Fahrenheit, also known as Indigo Prophecy. The prototype's RUNTIME.ELF and RUNTIME.MAP supply debugging symbols for analysis, and the build scripts compare the produced ELF with a recorded checksum. The author intends the unfinished work for learning and analysis.
- [Fallout 2 Reference Edition: reverse-engineered C source of the original engine](https://awesomerea.org/resources/fallout2-reference-edition-case/index.md): Case study · Restores C source for Fallout 2’s Windows engine from the original binary, keeping as close to the original as possible with all its imperfections. The resulting fallout2-re.exe is a drop-in replacement for fallout2.exe that runs on the user’s own GOG or Steam copy. README says a few non-essential functions remain undecompiled; the code became the basis of the separate Fallout 2 Community Edition, and its author calls wide publication legally questionable.
- [FFT-1997-Decomp: early Final Fantasy Tactics decompilation](https://awesomerea.org/resources/fft-1997-decomp-case/index.md): Case study · FFT-1997-Decomp is an early decompilation of Final Fantasy Tactics starting with the PlayStation executable SCUS_942.21. The author uses Ghidra 12.1.3 and separates recovered routines into C and assembly files while working through names for functions and data.
- [Final Fantasy VI: a three-version ROM disassembly](https://awesomerea.org/resources/final-fantasy-vi-disassembly-case/index.md): Case study · Final Fantasy VI Disassembly reconstructs assembly and game data for the Japanese Super Famicom and two US SNES releases, using ca65 and ld65 to build ROMs. Its scripts extract required data from a user-provided ROM; the Japanese build fills unused regions with 0xFF and has a different CRC32 from the original.
- [Final Fantasy VIII: decompiling the PlayStation game](https://awesomerea.org/resources/ff8-decomp-case/index.md): Case study · This is a work-in-progress decompilation of Final Fantasy VIII for the PlayStation, USA SLUS-008.92. Progress is tracked on decomp.dev.
- [Final Fantasy X: an early decompilation of International and US alpha builds](https://awesomerea.org/resources/final-fantasy-x-decomp-case/index.md): Case study · Final Fantasy X decompiles the Japanese International release and supports a separate US alpha configuration. Its build extracts a user-supplied PS2 ELF, splits it into files and provides function-level assembly diffing against the target.
- [Fire Emblem: a partial US GBA disassembly and decompilation](https://awesomerea.org/resources/fe7-us-decomp-case/index.md): Case study · fe7_us reconstructs parts of the US Game Boy Advance release of Fire Emblem as assembly and C. The project builds a SHA-1-listed ROM from the user's base ROM and presents its partial decompilation as a modding and research reference.
- [Firefighter: a decompiled DOS game ported to Rust](https://awesomerea.org/resources/firefighter-rust-port-case/index.md): Case study · Eric S. Raymond’s terminal port of Firefighter, Eben Sprinsock’s 1985 DOS shareware game. The project history says ChatGPT 5.5 decompiled the DOS binary to Borland Pascal and translated it to Rust, after which Raymond modernized the interface and corrected a scoring mismatch. Unchanged gameplay is the author’s statement; the intermediate Pascal and any comparison runs are not published.
- [Five Nights at Freddy's: Help Wanted: a Vive 1.0.11 code reconstruction](https://awesomerea.org/resources/help-wanted-vive-decomp-case/index.md): Case study · The project reconstructs code for Five Nights at Freddy's: Help Wanted Vive 1.0.11 in an Unreal Engine project. Its stated aim is functional parity with the game; the author says gameplay remains incomplete and some features may fail.
- [FlyingDodgem: decompiling and porting HOVER!](https://awesomerea.org/resources/flyingdodgem-hover-case/index.md): Case study · FlyingDodgem reconstructs the 1995 game HOVER! as C source and adapts it for Linux and Android. The project uses original MAZES, SOUNDS and DASHRES.DLL data, includes SDL3 platform code, and commits a reccmp comparison report while pursuing behavioral and binary matches.
- [Frogger: SNES disassembly and ROM reconstruction](https://awesomerea.org/resources/frogger-snes-disassembly-case/index.md): Case study · Frogger's SNES port is reconstructed as assembly with ROM and RAM maps, SPC700 audio-engine code, and scripts for extracting assets from an original ROM. The author reports that the disassembly assembles completely; the included Asar-based framework provides the assembly workflow.
- [FS15 Reconstruction: Farming Simulator 15 and GIANTS Engine 6 component recovery](https://awesomerea.org/resources/fs15-reconstruction-case/index.md): Case study · FS15 Reconstruction recovers components of Farming Simulator 15 and GIANTS Engine 6 from the Windows 1.4.2.0 release. It combines decompilation, recovered scripts and native component comparisons with experimental gameplay and Linux hosts. The author reports that original GE6 code reaches a Linux-rendered farm view, while full engine and farming behavior remain incomplete.
- [FUEL: decompilation of the 2009 PC game](https://awesomerea.org/resources/fuel-decomp/index.md): Case study · This decompiles FUEL, the 2009 PC game by Asobo Studio, US retail. The executable FUEL.exe has SHA-256 ac1b2077137b7c6299c344111857b032635fe3d4794bc5135dad7c35feeda856. The build uses the patched MSVC 8.0 compiler and the August 2008 DirectX SDK.
- [Fusion: reconstructing Rovio's game-engine libraries](https://awesomerea.org/resources/fusion-rovio-engine-case/index.md): Case study · Fusion reconstructs Rovio's multiplatform game-engine libraries, chiefly using the iPhone Angry Birds Seasons v4.1.0 executable and its debugging information as references. Its CMake project builds much of the recovered library code for Windows. DRM and in-app-purchase implementations are outside the project's stated scope, and other build types remain unfinished.
- [Gazillionaire: reconstructing the Steam AIR/Flex game](https://awesomerea.org/resources/gazillionaire-reconstruction-case/index.md): Case study · Gazillionaire reconstructs the Steam AIR/Flex release of the game from a user's installation. Scripts export the local game, prepare ActionScript source, build an AIR application and compare generated code with the original SWF. The repository also documents the game's architecture and code-generation experiments.
- [Geometry Dash: reconstructing Android game classes from ARM64 disassembly](https://awesomerea.org/resources/geometry-dash-android-class-reconstruction-case/index.md): Case study · Reconstructs portions of Geometry Dash's Android C++ game classes from ARM64 disassembly, focusing on GameObject, GJBaseGameLayer, memory layouts, area movement, effects, and object state. The repository includes class source and headers and tracks unfinished vtable, trigger, and runtime behavior.
- [Glover: an in-progress Nintendo 64 decompilation](https://awesomerea.org/resources/glover-n64-decomp-case/index.md): Case study · Glover is an in-progress decompilation of the Nintendo 64 game, with C source and assembly for functions that remain nonmatching. Its Makefile defines a MIPS cross-build for the game and separates matching from nonmatching build settings. The author describes Claude as a major contributor to the work.
- [Go Vacation: a halted Wii decompilation](https://awesomerea.org/resources/go-vacation-wii-case/index.md): Case study · Go Vacation is a Wii game decompilation with source and build configurations for several game versions. The author halted work because the game's main code sits in relocatable RSO modules that the decompilation toolkit did not support.
- [Goldeneye 007: a recompilable decompilation of three regional ROMs](https://awesomerea.org/resources/goldeneye-007-gitlab-decomp-case/index.md): Case study · Goldeneye 007 is an ongoing, recompilable decompilation of the Nintendo 64 game. The project lists builds for US, Japanese and European ROMs and extracts required assets from a user-supplied copy of the game.
- [Graffiti Soul: mapping and testing Jet Set Radio Future functions](https://awesomerea.org/resources/graffiti-soul-jsrf-case/index.md): Case study · Maps functions in Jet Set Radio Future's Xbox executable and provides a workflow for patching reconstructed C++ functions into the user's XBE for emulator checks. The repository records selected addresses and subsystem findings while its source tree remains at an early stage.
- [Grand Prix 4 Decompilation: behavior-matched GP4.exe functions](https://awesomerea.org/resources/grand-prix-4-decomp-case/index.md): Case study · Grand Prix 4 Decompilation reconstructs GP4.exe functions as C++ and compares each candidate with the original under generated emulator inputs. Its repository includes a function ledger, input layouts and an in-game hook; the author reports 5,669 functions accepted by differential emulation while a playable replacement remains unfinished.
- [Green Beret: a documented ZX Spectrum disassembly](https://awesomerea.org/resources/zx-spectrum-green-beret-disassembly-case/index.md): Case study · Green Beret documents reverse-engineered assembly for the 1986 ZX Spectrum conversion. Its notes explain an eight-character scrolling region, reusable sprite masks and compressed level-map blocks, alongside the assembly source.
- [Gregory Horror Show: a work-in-progress PS2 decompilation](https://awesomerea.org/resources/gregory-horror-show-ps2-decomp-case/index.md): Case study · Decompiles the PlayStation 2 game Gregory Horror Show through a workflow that unpacks a user-provided ISO, splits its executable, and rebuilds a destination ISO from assembly and C. The repository includes version configuration, build scripts, headers, and source files.
- [gta1_re: reconstructing Grand Theft Auto's executable](https://awesomerea.org/resources/gta1-re-case/index.md): Case study · gta1_re reconstructs Grand Theft Auto's game code in C++ and configures comparison with a specified Grand Theft Auto.exe. The source labels functions and globals with original addresses, while CMake offers a matching build and an SDL3 graphics option.
- [gtasa-reversed: reconstructing Grand Theft Auto: San Andreas code](https://awesomerea.org/resources/gtasa-reversed/index.md): Case study · This project rewrites Grand Theft Auto: San Andreas function by function. The build is a DLL whose reversed functions replace the ones in the game, with a standalone executable as the stated end goal. The supported executable is the compact exe, 5,189,632 bytes. python setup.py configures a windows-msvc x86 Debug build by default, and python setup.py --build compiles it. The README estimates that about 50 to 60 percent of the code is done.
- [Guilty Gear X Plus: decompiling the Korean release](https://awesomerea.org/resources/guilty-gear-x-plus-decomp-case/index.md): Case study · Guilty Gear X Plus is decompiled into game-specific C source, headers and symbol maps for the Korean release. The build starts from an extracted SLPM_645.25 executable, then uses configure.py and Ninja; the repository also contains a decompilation permuter for matching C functions to target assembly.
- [Guxt Decompilation Project: reconstructing the Guxt game source](https://awesomerea.org/resources/guxt-decompilation-case/index.md): Case study · Guxt Decompilation Project reconstructs the 2007 Guxt shooter as C++ source. The author extends earlier work with reverse engineering and fixes; a compiled pxGame.exe uses data files obtained from the original game.
- [Halo 2 engine decompilation: differential recovery for Linux](https://awesomerea.org/resources/halo2-engine-recovery-case/index.md): Case study · Halo 2 engine decompilation recovers selected routines from the original Xbox game into native C for Linux. It compares data arrays, allocation and other engine behavior against original XBE instructions, and provides a host that probes recovered pools and configuration loading.
- [Halo: Combat Evolved — decompiling Xbox build 2342](https://awesomerea.org/resources/halo-combat-evolved-decomp/index.md): Case study · This is a work-in-progress decompilation of Halo: Combat Evolved build 2342. The executable is cachebeta.exe, SHA-256 4cc87b45f721270392a96f1674ed2b5cd4a7bb4355faeab4531d1cf1884d9520, from the PAL debug build. The August 2001 Xbox SDK supplies xbox/bin and xbox/include. configure.py prepares the build. ninja build compiles it and prints progress. On Windows, projects/cachebeta.sln opens in Visual Studio 2022. The README says later Halo debug symbols are used to map types, and that the CEA beta is not identical to the Xbox game.
- [Halo: Combat Evolved: an incremental re-implementation patched into the original Xbox executable](https://awesomerea.org/resources/halo-ce-xbox-reimplementation-case/index.md): Case study · A research project re-implementing the original Xbox Halo: Combat Evolved in C, one function at a time. Rewritten functions are compiled into a separate image and patched into the user’s original executable with redirects from the original implementations, so the hybrid game can be run and debugged in xemu or on an Xbox as work progresses. The project reports an early stage, and its sources document no byte-for-byte comparison with the original code.
- [Haunted House: a commented Atari 2600 disassembly](https://awesomerea.org/resources/haunted-house-disassembly-case/index.md): Case study · Haunted House reconstructs the Atari 2600 game's code as commented assembly in haunted.asm. A DASM command and Makefile build a ROM that can be played in the Stella emulator.
- [hey_you_pikachu: partial N64 ROM decompilation](https://awesomerea.org/resources/hey-you-pikachu-decomp-case/index.md): Case study · hey_you_pikachu reconstructs part of a Pikachu Nintendo 64 ROM in C alongside disassembled MIPS code. Its Makefile assembles and compiles those sources into a ROM, while many functions remain as nonmatching assembly inclusions.
- [Hollywood Poker: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/hollywood-poker-disassembly-case/index.md): Case study · Hollywood Poker documents a disassembly of the ZX Spectrum game made with SkoolKit. The repository holds SkoolKit source, control and reference files and utilities for producing browsable hexadecimal and decimal listings. Building the development listings requires SkoolKit; users need the original game to disassemble its code.
- [Hot Wheels: Velocity X — a partial GameCube decompilation](https://awesomerea.org/resources/hot-wheels-velocity-x-gcn-case/index.md): Case study · Hot Wheels: Velocity X is being decompiled for the GameCube USA GHWE78 release. The repository contains C source, headers, split and symbol configuration, and a build that starts from the user's disc image. Its objdiff configuration supports comparisons of rebuilt objects with the original.
- [How to Be a Complete Bastard: a SkoolKit disassembly](https://awesomerea.org/resources/how-to-be-a-complete-bastard-case/index.md): Case study · How to Be a Complete Bastard is a SkoolKit disassembly of the ZX Spectrum game. The repository keeps .skool source and helper scripts for producing browsable hexadecimal and decimal listings.
- [ht2-rev: reconstructing Hard Truck 2's king.exe in C++](https://awesomerea.org/resources/hard-truck-2-king-exe-case/index.md): Case study · ht2-rev reconstructs Hard Truck 2: King of the Road's king.exe as C++ source for a 32-bit Windows build. The work grew from a byte-matching disassembly and translates the helicopter step and trailer hitch solver from x87 instructions, with tests against the original machine code. It extracts resources from the user's executable at build time and runs with an installed game.
- [Hunchback: an in-progress ZX Spectrum disassembly](https://awesomerea.org/resources/hunchback-spectrum-disassembly-case/index.md): Case study · Hunchback is an in-progress SkoolKit disassembly of the ZX Spectrum game. The repository includes a .skool listing, SkoolKit control and reference files, and a build script for the published disassembly.
- [Hungry Horace: a SkoolKit ZX Spectrum disassembly](https://awesomerea.org/resources/hungry-horace-disassembly-case/index.md): Case study · The Hungry Horace project publishes a SkoolKit disassembly of the ZX Spectrum game. Its source can generate browsable hexadecimal or decimal HTML and an assembly file for an assembler.
- [IEStrikers: decompiling Inazuma Eleven Strikers](https://awesomerea.org/resources/iestrikers-case/index.md): Case study · IEStrikers reconstructs source for Inazuma Eleven Strikers and builds against a main.dol extracted from Inazuma Eleven Go Strikers 2013. The tree contains C/C++ source, headers, symbol configuration, and build scripts; the source reports that constructors and exception tables remain broken.
- [IGI-RE: functional decompilation of Project I.G.I.](https://awesomerea.org/resources/igi-re-case/index.md): Case study · IGI-RE rewrites the EU Project I.G.I. executable in C, function by function, and compares each rewrite with the original through Unicorn-based differential tests and scripted gameplay. It builds a standalone game executable and a DLL for substituting rewrites into the original; the author reports all 5,376 identified game and engine functions rewritten.
- [Ikachan3: decompiling the Nintendo 3DS release](https://awesomerea.org/resources/ikachan3-case/index.md): Case study · Ikachan3 decompiles the Nintendo 3DS version of Ikachan into game source organized by subsystem. Its build uses the armcc compiler, and a user-provided original code.bin enables binary comparison. The repository includes source for player, map, sound and other game components.
- [Indy 500: a first-pass labeled Atari 2600 disassembly](https://awesomerea.org/resources/indy-500-atari-2600-disassembly-case/index.md): Case study · Indy 500 for the Atari 2600 is disassembled with DiStella v3.0 into a 6502 listing carrying a first pass of hand-written labels and comments. Named RAM locations cover game state, scores, speed settings, car positions, collision state and audio channels, and comments mark the mirror-symmetrical racetrack kernel, acceleration handling for both cars and per-game color-palette tables.
- [Jet Force Gemini: a Nintendo 64 decompilation](https://awesomerea.org/resources/jet-force-gemini-decomp-case/index.md): Case study · Jet Force Gemini is the subject of a Nintendo 64 decompilation with C and assembly source. The build defaults to the US ROM and can use the kiosk ROM; the author reports that PAL and Japanese work is minimal or has not started.
- [Jet Set Willy: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/jet-set-willy-disassembly-case/index.md): Case study · Jet Set Willy documents a disassembly of the ZX Spectrum game in SkoolKit source format. The repository provides the annotated source and commands to generate a browsable HTML release or assembly language output.
- [Kaboom!: an annotated Atari 2600 disassembly](https://awesomerea.org/resources/kaboom-atari-2600-disassembly-case/index.md): Case study · A labeled and commented 6502 assembly listing reconstructs Kaboom!, Activision's 1981 paddle game for the Atari 2600, as a 2K ROM source on the MiniDig disassembly page. Assembler switches select NTSC or PAL timing and colors and choose between the original back-and-forth Mad Bomber movement and a smooth variant. Labeled constants cover paddle limits, bomb-group sizes and the display kernels, and comments note bomb-group table entries the game never reads.
- [Karateka: a buildable MS-DOS decompilation](https://awesomerea.org/resources/karateka-msdos-decompiled-case/index.md): Case study · Reconstructs the MS-DOS version of Karateka as C and assembly source that builds KARATEKA.EXE. The documented build uses Lattice C 2.15, MASM 1.25 and DOIT.BAT. The source includes the cutscene animation script engine.
- [keen-clone: a Commander Keen 1 C/SDL2 port](https://awesomerea.org/resources/keen-clone-rea-commander-keen-case/index.md): Case study · A native Linux and browser port of Commander Keen Episode One is documented as a function-by-function REA/Ghidra reconstruction of KEEN1.EXE. Published analysis artifacts accompany the C/SDL2 game; the scope is the first episode.
- [KeeperFX: a rewritten Dungeon Keeper game](https://awesomerea.org/resources/keeperfx-case/index.md): Case study · KeeperFX rewrites Dungeon Keeper as a standalone game after an initial effort to reverse its original executables into usable code. It uses files from the player's original copy and adds higher resolutions, revised controls, bug fixes and new game content.
- [kh-com: Kingdom Hearts: Chain of Memories decompilation](https://awesomerea.org/resources/kh-com-case/index.md): Case study · kh-com reconstructs code from the US Game Boy Advance release of Kingdom Hearts: Chain of Memories. The early source covers startup, initialization, the main loop and interrupt handling; many called routines remain placeholders.
- [Kirby 64: The Crystal Shards — decompiling the Nintendo 64 game](https://awesomerea.org/resources/kirby64-decomp/index.md): Case study · This is a work-in-progress decompilation of Kirby 64: The Crystal Shards. The US ROM is named baserom.us.z64. make setup extracts assets and make builds the project. The setup uses Linux or WSL, python3, git, a MIPS GNU compiler, the qemu-irix package from n64decomp, and uv. The page reports 97 percent of the code matched.
- [Kirby's Dream Land 3: a US and Japanese SNES disassembly](https://awesomerea.org/resources/kirbys-dream-land-3-disassembly-case/index.md): Case study · The Kirby's Dream Land 3 project supplies assembly sources for the US and Japanese SNES versions. It uses a SNES ROM framework and batch scripts to extract game assets from a user's clean, headerless ROM. The repository contains game assembly, RAM maps and sound-engine files.
- [Kirby's Return to Dream Land: an early C/C++ decompilation](https://awesomerea.org/resources/krtdl-decomp-case/index.md): Case study · KRTDL-Decomp is an early reconstruction of Kirby's Return to Dream Land assembly into C and C++. The author plans to use Ghidra to inspect routines, build a symbol map and recompile a DOL for Dolphin; the repository contains game source, assembly and build scripts.
- [Kuru Kuru Kururin: functional GBA decompilation and PC port](https://awesomerea.org/resources/kururin-case/index.md): Case study · kururin reconstructs the European Game Boy Advance Kuru Kuru Kururin in C for functional rather than byte-identical behavior, and builds an SDL2 PC port for Linux and Windows. The author's reported tests run the original and rebuilt ROMs side by side through recorded input, comparing RAM, sound and video; the port loads game data from the user's own ROM.
- [LADX-Decompile: a C reconstruction of Link's Awakening DX](https://awesomerea.org/resources/ladx-decompile-case/index.md): Case study · LADX-Decompile translates Game Boy Color Link's Awakening DX routines into C, organized by cartridge bank and subsystem. Tests compare memory changes with behavior described in the original disassembly; the author reports 906 verified standalone routines across the 4,298-routine whole-game inventory.
- [Larax & Zaco: an REA-exported evidence base and partial routine recovery](https://awesomerea.org/resources/lezac-rea-decompilation-case/index.md): Case study · The author uses REA 6.3.0 with Ghidra to export dossiers, pseudocode and assembly for all 215 discovered procedures in the DOS shareware LEZAC.EXE, then recovers a small set of routines as Pascal and portable C. Recovered code is tested against the original x86 instructions, and a pinned DOSBox-X baseline records original-game runs..
- [Leaflitter: decompiling Paper Mario: Sticker Star for 3DS](https://awesomerea.org/resources/leaflitter-case/index.md): Case study · Leaflitter decompiles the European release of Paper Mario: Sticker Star for Nintendo 3DS. It extracts code.bin from the user's game copy, generates assembly with n3dsdisasm, and builds source with armcc; utilities process Ghidra headers and symbol names, while make generates objdiff configuration.
- [Legacy of Kain: Soul Reaver — a decompilation and port](https://awesomerea.org/resources/kain2/index.md): Case study · This decompiles Legacy of Kain: Soul Reaver by translating its MIPS R3000 code to C, then builds a modern port. The completion badge for SLUS_007.08 reads 78 percent. It uses the Valkyrie emulator layer and SDL2. The listed platforms are Windows 7 through 11, Linux, 64-bit Mac, UWP, Xbox One and Series through UWP, the web through Emscripten, and Android. A WebGL demo is linked from the page. Build steps are in CONTRIBUTING.MD.
- [Lego Battles: a hand-decompiled Nintendo DS reconstruction](https://awesomerea.org/resources/lego-battles-decomp-case/index.md): Case study · Lego Battles reconstructs Nintendo DS game source through manual decompilation, chiefly targeting the European version. Its build combines recovered C/C++ code with assets extracted from the user's ROM; an optional ARM7 BIOS enables a matching ROM build.
- [Lego Island 2: GBA decompilation](https://awesomerea.org/resources/lego-island-2-gba-case/index.md): Case study · Lego Island 2 reconstructs the GBA game's code in C and assembly using bagd. Its documented workflow extracts assets from a user-provided baserom.gba with isle2-tool, generates build files with bagd and builds the ROM.
- [LEGO Racers: an N64 source reconstruction in progress](https://awesomerea.org/resources/lego-racers-case/index.md): Case study · LEGO Racers is an N64 source reconstruction that splits a user-supplied, hash-matched ROM with splat and builds C and C++ source alongside assembly-backed functions. Its configuration recognizes two ROM hashes and generates region-specific build files.
- [LEGO Rock Raiders: a C and C++ decompilation project](https://awesomerea.org/resources/lego-rock-raiders-decompile-case/index.md): Case study · LegoRockRaiders reconstructs LEGO Rock Raiders game code in C and C++. Its source tree covers rendering, audio, input, levels, objects, and gameplay systems, with a CMake build. The project cites a separate LEGO Rock Raiders analysis repository as a resource.
- [libmkb: reconstructing Super Monkey Ball 2 systems as a C++ library](https://awesomerea.org/resources/libmkb-case/index.md): Case study · libmkb is a partial C++ library project aiming to reconstruct Super Monkey Ball 2's physics, camera and control code. Its goals are readable source, behavior close to the original and use with a graphical frontend. The build currently compiles a limited set of modules.
- [LibreGrimrock: 64-bit reconstructions of the Legend of Grimrock engines](https://awesomerea.org/resources/libregrimrock-case/index.md): Case study · LibreGrimrock reconstructs the engines of Legend of Grimrock and Legend of Grimrock 2 as native 64-bit C++ modules from their original executables. The work follows recovered compilation units, class layouts and Lua bindings, while adapting platform libraries and loading data from owners' game installations.