# Curated reverse engineering resources · Page 13

> Page 13 of 52, entries 1,201–1,300. 5,191 tools, projects, integrations, case studies, and references for websites, games, apps, native binaries, firmware, and communication protocols.

Source-reviewed means descriptions were checked against primary documentation. Each entry page lists the full requirements and sources; this page shows their counts and the review date.

- HTML: <https://awesomerea.org/resources/page/13/>
- JSON: <https://awesomerea.org/api/v1/resources.json>
- 简体中文: <https://awesomerea.org/zh/resources/page/13/index.md>

## Games (100)

- [Money Idol Exchanger: a Game Boy ROM disassembly](https://awesomerea.org/resources/money-idol-exchanger-disassembly-case/index.md): Case study · Money Idol Exchanger is a banked assembly disassembly of the Game Boy game. Its RGBDS Makefile assembles the sources into game.gb, and the project specifies an MD5 goal for comparing the resulting ROM.
- [Lilium Salvation: reconstructing Dark Salvation engine support](https://awesomerea.org/resources/lilium-salvation-case/index.md): Case study · Lilium Salvation reimplements engine support for Dark Salvation on a Lilium Arena codebase. It runs the game's existing QVMs from user-supplied data files and adds display modes; the author says versions 1.0.6 and 1.0.7 were tried through the first level.
- [Rise of Legends: static recompilation of the Win32 game](https://awesomerea.org/resources/rise-of-legends-static-recomp-case/index.md): Case study · Rise of Legends statically recompiles the game's final Win32 executable to native C with pcrecomp, then runs the lifted code in a 32-bit host that maps the original image and binds its imports. The author reports playable Quick Battle skirmishes and progress into the Vinci campaign's first mission from a build assembled using the user's retail discs.
- [AC1_RE: Armored Core analysis and matching decompilation](https://awesomerea.org/resources/ac1-re-case/index.md): Case study · AC1_RE documents and analyzes the North American PlayStation release of Armored Core, including its executable, overlays, mission pipeline, text system and asset formats. It provides behavioral C models, matching-decompilation work, Ghidra scripts, extraction and repacking tools, and local viewers for game structures.
- [OpenDAoC: recreating a Dark Age of Camelot server](https://awesomerea.org/resources/opendaoc-core-case/index.md): Case study · OpenDAoC recreates a Dark Age of Camelot server focused on the 1.65 game experience. Its C# code handles game sessions and packets, and its protocol notes describe optional RSA key transport and RC4 packet encryption for 1.127 and 1.130 clients.
- [Fallout 2 Community Edition: a cross-platform Fallout 2 reimplementation](https://awesomerea.org/resources/fallout-2-community-edition-case/index.md): Case study · Fallout 2 Community Edition reimplements Fallout 2 as a cross-platform game engine that uses data from the player's own copy. The C++ source includes combat, art, audio, and interface components; the project adds engine fixes and quality-of-life changes while retaining the original gameplay.
- [OpenBiohazard2: a Go engine reimplementation of Resident Evil 2](https://awesomerea.org/resources/openbiohazard2-case/index.md): Case study · OpenBiohazard2 reimplements the original Resident Evil 2 engine in Go with OpenGL rendering and data from the user's game installation. The code includes room scripts, game state, rendering and parsers for game file formats. Audio, enemy AI and several gameplay systems remain unfinished.
- [Sonic 1 C Port: reconstructing Mega Drive game code in C](https://awesomerea.org/resources/sonic-1-c-port-case/index.md): Case study · Sonic 1 C Port translates Sonic the Hedgehog revision 1 code from a Mega Drive ROM into C, then manually repairs generated control flow. A Rust runner and Speedshoes emulation framework compare C-side game state with the original and support instruction-level accuracy checks.
- [Aironauts: an early PlayStation decompilation of OUTROE.EXE](https://awesomerea.org/resources/aironauts-decomp-case/index.md): Case study · Aironauts-decomp reconstructs source for the OUTROE.EXE executable of the PAL PlayStation game Aironauts. It extracts the user's disc files, splits the executable into assembly and data, and attempts to rebuild an executable that passes the project's comparison check; current C work focuses on SDK functions.
- [FNV-nx: an experimental Fallout: New Vegas PC-to-Switch recompilation](https://awesomerea.org/resources/fnv-nx-case/index.md): Case study · FNV-nx investigates a native Nintendo Switch port of Fallout: New Vegas by translating PC x86 code ahead of time and implementing Windows ABI services and a Vulkan graphics path. The repository documents Ghidra analysis and diagnostic tests; the author reports a Switch hardware test that reached the game menu and opening movie, while gameplay loading remains unverified.
- [TF15-Client: rebuilding the Team Fortress Classic client](https://awesomerea.org/resources/tf15-client-case/index.md): Case study · TF15-Client rebuilds the Team Fortress Classic client in C++ for Xash3D FWGS. It provides Android, Linux and Windows builds and uses the valve and tfc folders from a Steam copy of the game.
- [Wario World: an in-progress GameCube decompilation](https://awesomerea.org/resources/wario-world-decomp-case/index.md): Case study · Wario World reconstructs the US GameCube game's code through an in-progress decompilation and disassembly. The repository provides assembly, linker configuration and a build workflow; the author reports that the current disassembly can be reassembled.
- [sekiro-rs: a Rust and Bevy reconstruction of Sekiro](https://awesomerea.org/resources/sekiro-rs-case/index.md): Case study · sekiro-rs rebuilds parts of Sekiro: Shadows Die Twice in Rust and Bevy using data extracted from a user's Steam installation. It interprets Havok Script and behavior graphs, TAE events and Lua AI scripts, reads game formats including FLVER and MSB, and rewrites engine combat rules identified through static analysis.
- [DBZ Budokai 1 HD Collection: a Windows static recompilation and mod pipeline](https://awesomerea.org/resources/dbz-budokai-1-hd-recomp-case/index.md): Case study · DBZ Budokai 1 HD Collection builds a Windows port by statically recompiling the Xbox 360 game's PowerPC code with ReXGlue SDK. Its launcher selects USA or EU assets, and its mod tools overlay AFS entries and convert character models between Budokai releases.
- [Project Gotham Racing: an Xbox static recompilation for Windows](https://awesomerea.org/resources/project-gotham-racing-recomp-case/index.md): Case study · Project Gotham Racing is ported from the original Xbox to Windows by statically recompiling the game's x86 code with Xbox XBE Recomp. The port supplies Windows implementations of Xbox graphics, sound and system interfaces and builds the game from the user's disc. Its findings also document XBE sections and the GOTHPOK asset container.
- [Folklore: a PS3 static recompilation for Windows](https://awesomerea.org/resources/folklore-recompiled-case/index.md): Case study · Folklore statically recompiles the PS3 game's PowerPC and SPU code from a player-supplied disc into C++ and a native Windows executable. The port uses ps3recomp with project patches, reimplements the SPURS job system and renders through Direct3D 12. The author reports that it boots and plays on the author's PC, with rough edges.
- [SMG-3DS: an unfinished Super Mario Galaxy port to New 3DS](https://awesomerea.org/resources/smg-new-3ds-native-port-case/index.md): Case study · SMG-3DS ports Super Mario Galaxy to New 3DS by compiling Petari's decompiled game code and implementing the Wii interfaces it calls. The port translates GX graphics to PICA200 and runs the Wii audio DSP in software. The author reports playable but slow hardware performance, and the project is archived.
- [GT Advance 3: matching GBA ROM reconstruction](https://awesomerea.org/resources/gt-advance-3-decomp-case/index.md): Case study · GT Advance 3 reconstructs the US Game Boy Advance ROM from C, assembly and registered data generators. The author reports an 8 MiB byte-identical build and tracks compiler-generated C matches separately from assembly-backed functions and preserved data payloads.
- [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.
- [NSMBWiicompiled: a Windows static recompilation of New Super Mario Bros. Wii](https://awesomerea.org/resources/nsmbwiicompiled-case/index.md): Case study · NSMBWiicompiled converts New Super Mario Bros. Wii PAL revision 1 into a native Windows game through static recompilation. Its translator parses PowerPC code from Wii DOL files and emits C++ for a native runtime, while the player's disc supplies game assets. The port adds resolution, widescreen, input and multiplayer options.
- [Torchlight Rekindled: a portable engine following the Xbox 360 game](https://awesomerea.org/resources/torchlight-rekindled-case/index.md): Case study · Torchlight Rekindled implements an engine for the 2009 game Torchlight, following the logic of its Xbox 360 release. It uses OGRE 14 and ParticleUniverse for rendering, runs on Switch, mobile and desktop platforms, and reads a user's PC or Xbox 360 game archive at runtime.
- [Midnight Ghost Stone: a native Metal Gear Solid recompilation](https://awesomerea.org/resources/midnight-ghost-stone-case/index.md): Case study · Midnight Ghost Stone builds a native PC version of the PlayStation Metal Gear Solid from its USA v1.0 discs. It statically recompiles most MIPS game logic, substitutes selected decompiled C routines checked against the executable, and presents locally imported meshes and textures through Vulkan. The author labels the Linux and Windows alpha packages experimental and unqualified for a complete campaign.
- [Maniac Mansion: a commented C64 engine and loader disassembly](https://awesomerea.org/resources/maniac-mansion-c64-explained-case/index.md): Case study · Maniac Mansion's Commodore 64 engine and special disk loaders are documented in a reconstructed, commented disassembly. The material groups more than 500 routines into modules covering rendering, audio, input, resource loading and the script interpreter; the author reports that all code is commented.
- [B3-Express: statically recompiling Bayonetta 3 for Windows](https://awesomerea.org/resources/b3-express-case/index.md): Case study · B3-Express ports Bayonetta 3 v1.2.0 to Windows by recompiling its ARM64 code to x86 with a modified ScarletNX runtime. An NVN-level Vulkan renderer draws the game, and a launcher checks an extracted game dump, copies its files and compiles the code on the user's PC. The repository also contains diagnostic notes on rendering and runtime issues.
- [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.
- [eZeus: rebuilding Zeus: Master of Olympus from original game files](https://awesomerea.org/resources/ezeus-case/index.md): Case study · eZeus reimplements Zeus: Master of Olympus and its Poseidon expansion as a C++ game using the player's original files. It supports the original adventures and adds optional behavior such as an alternate walker implementation and building two cities at once.
- [Helion: rebuilding a Doom-compatible engine](https://awesomerea.org/resources/helion-doom-engine-case/index.md): Case study · Helion rebuilds a Doom-compatible engine with static rendering and state management for dynamic map changes. It reads user-supplied IWAD game data and supports WADs targeting vanilla Doom, Boom, MBF, MBF21, ID24 and part of UDMF.
- [MILLI4C: a Mario & Luigi: Dream Team decompilation](https://awesomerea.org/resources/milli4c-dream-team-decomp-case/index.md): Case study · MILLI4C reconstructs C++ source for the US 1.0 release of Mario & Luigi: Dream Team, targeting a matching build of its code.bin. The repository includes game source, headers, CRO configuration and a build script that produces code.bin and MILLI4C.axf.
- [007: From Russia with Love: an original Xbox recompilation for PC](https://awesomerea.org/resources/007-from-russia-with-love-xbe-recomp-case/index.md): Case study · 007: From Russia with Love - XBE Recomp ports the original Xbox game to Windows using Xbox XBE Recomp. It compiles code from the user's USA or European game files for PC on first start, with a runtime that adds display, graphics and input options.
- [SegaSonic The Hedgehog: arcade code reconstructed in C](https://awesomerea.org/resources/segasonic-hedgehog-decomp-case/index.md): Case study · SegaSonic The Hedgehog reconstructs the Sega System 32 arcade game's NEC V60 and Z80 programs as readable C. Its tools disassemble and decompile code, extract assets from the user's MAME ROM set, and compare game, video and sound behavior with reference runs frame by frame. The author reports Windows play for the SDL2 port; Linux and macOS builds had not been tried.
- [OpenGD: a Geometry Dash gameplay reimplementation](https://awesomerea.org/resources/opengd-case/index.md): Case study · OpenGD reimplements Geometry Dash gameplay in C++ on Axmol, aiming to match the original game. It requires resources from Geometry Dash 2.1 or 2.2; the documented gameplay rewrite currently leaves levels unplayable.
- [Extreme-G Recompiled: an incomplete N64 static recompilation](https://awesomerea.org/resources/extreme-g-recompiled-case/index.md): Case study · Extreme-G Recompiled analyzes the N64 game's custom LZSS ROM blocks and prepares its MIPS code for N64Recomp translation to C for a native Windows build. The project includes function symbols and an SDL2/RT64 runtime scaffold; the author reports that startup reaches audio initialization before crashing because a data section is uninitialized.
- [OpenPol: an early Polanie reimplementation](https://awesomerea.org/resources/openpol-polanie-case/index.md): Case study · OpenPol reimplements the Polish RTS Polanie in Rust and includes tools for reading and extracting its data formats. The current program plays intros, loads some game files, and displays the main menu and cursor; other gameplay remains unfinished.
- [GT2 RecompOne: Gran Turismo 2 static recompilation with multiplayer](https://awesomerea.org/resources/gt2-recompone-case/index.md): Case study · GT2 RecompOne translates Gran Turismo 2's PlayStation MIPS code into C# ahead of time and runs it as a .NET program with replacement console services. Game-specific hooks and symbol maps support an added multiplayer mode with LAN discovery, direct UDP connections and a relay.
- [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.
- [Vange-rs: reimplementing Vangers in Rust](https://awesomerea.org/resources/vange-rs-vangers-case/index.md): Case study · vange-rs reimplements Vangers in Rust with wgpu graphics, aiming to reproduce its worlds, vehicles and single-player behavior using original game resources. The repository includes a playable road binary, model and level viewers, resource conversion tools and technical notes on rendering and data formats.
- [Animal Crossing gcNX: a native Switch port of the GameCube decompilation](https://awesomerea.org/resources/animal-crossing-gcnx-case/index.md): Case study · Animal Crossing gcNX ports the decompiled GameCube game to Nintendo Switch by compiling its code for ARM and translating GX graphics to OpenGL ES. It reads game resources from the user's USA disc image; the repository also documents an Android port built on the same decompilation.
- [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.
- [NeoXResearch: investigating NeoX archives and Python bytecode](https://awesomerea.org/resources/neoxresearch-neox-format-case/index.md): Case study · NeoXResearch investigates NetEase's NeoX game engine through static analysis and dynamic debugging of its native library. It documents NPK archive headers and metadata entries, the file-loading and decryption path, and changes to Python bytecode opcodes. Python scripts support NPK unpacking, decryption and bytecode repair.
- [Powerslide Remake: rebuilding the arcade racer on original game data](https://awesomerea.org/resources/powerslide-remake-case/index.md): Case study · Powerslide Remake reconstructs the arcade racer's main features in a cross-platform C++ application built on Ogre. It reads the original game's data.pf, gameshell.pf and store.pf archives and provides racing, AI and multiplayer features. Builds target Windows, Linux and Android.
- [Big Brain Academy: Wii Degree — an in-progress matching decompilation](https://awesomerea.org/resources/big-brain-academy-wii-degree-case/index.md): Case study · Big Brain Academy: Wii Degree is a work-in-progress Wii decompilation with C and C++ source for EGG, nw4r, and SDK components. Its build configuration records matching status per object and checks the rebuilt RYWE01 main.dol against a SHA-1 target.
- [Kirby's Tilt 'n' Tumble: a Game Boy Color disassembly](https://awesomerea.org/resources/kirby-tilt-n-tumble-disassembly-case/index.md): Case study · Kirby's Tilt 'n' Tumble is represented as banked Game Boy Color assembly built with RGBDS. The repository includes assembly for the cartridge banks and a Makefile target that compares the rebuilt ROM with a stored MD5 reference.
- [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.
- [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.
- [NHL Legacy: Xbox 360 static recompilation and Vulkan port](https://awesomerea.org/resources/nhl-legacy-recomp-case/index.md): Case study · Uses ReXGlue to statically recompile the Xbox 360 NHL Legacy executable into a native Windows program. A game-specific Vulkan renderer and host code handle presentation, while a builder prepares an installation from the player's ISO or extracted game folder. The source also documents graphics investigations and diagnostic tools.
- [OCTR: a native CTR Nitro-Fueled PC port with online play](https://awesomerea.org/resources/octr-nitrofueled-pc-case/index.md): Case study · OCTR adapts Crash Team Racing: Nitro-Fueled's PS4 executable to Windows and Linux while running its x86-64 code directly on the host CPU. A replacement PS4 runtime and shadPS4-derived Vulkan renderer support the game, and this fork adds community-server races, private rooms, friends, and the Pit Stop.
- [Battle Arena Toshinden Recompiled: a PlayStation static recompilation](https://awesomerea.org/resources/battle-arena-toshinden-recompiled-case/index.md): Case study · Battle Arena Toshinden Recompiled generates native code from the USA PlayStation release using psxrecomp and a user-supplied 14-track disc. It adds title-specific widescreen, frame blending and roster mods, with a launcher for disc setup and two-player rollback netplay.
- [Fallout-NV-MacOS: static recompilation of Fallout: New Vegas for Apple Silicon](https://awesomerea.org/resources/fallout-nv-macos-case/index.md): Case study · Fallout-NV-MacOS translates the 32-bit Windows executable of Fallout: New Vegas through Ghidra P-code into C for native Apple Silicon builds. A host supplies Win32 and COM shims plus Direct3D 9-to-Metal rendering, while a differential tester compares translated functions with the original x86 instructions in Unicorn. The author reports an hour of scripted play; audio, Bink video, and gamepad support remain unfinished.
- [Bomberman 64: Recompiled — an N64 static recompilation](https://awesomerea.org/resources/bomberman-64-recompiled-case/index.md): Case study · Bomberman 64: Recompiled statically recompiles the US Nintendo 64 release of Bomberman 64 into a native port with N64: Recompiled. RT64 supplies rendering, while headers and selected functions from the separate decompilation project support patches and enhancements.
- [BrawlerPad: an Apple-platform port of Super Smash Bros. 64](https://awesomerea.org/resources/brawlerpad-smash-64-apple-port-case/index.md): Case study · BrawlerPad adapts the BattleShip Super Smash Bros. 64 source port for Apple Silicon macOS, iPhone and iPad. Its patches add Metal app integration, user-ROM resource extraction, touch controls and controller lifecycle handling while compiling the decompiled game code ahead of time.
- [Future Cop: L.A.P.D.: a PlayStation static recompilation kit](https://awesomerea.org/resources/future-cop-lapd-recomp-case/index.md): Case study · Future Cop: L.A.P.D. configures PSXRecomp and a setup host to generate and compile the European PlayStation game locally from a user's disc and BIOS. The repository contains game identity, symbol seeds and build files; the author reports a Windows clean setup, compilation and headless start check.
- [Azura: a native Gears of War 3 port from static recompilation](https://awesomerea.org/resources/azura-case/index.md): Case study · Azura builds a native macOS, Linux or Windows version of Gears of War 3 by translating the user's Xbox 360 PowerPC executable to C++ with ReXGlue. Its runtime replaces console services and graphics with Metal or Vulkan backends, while a Tauri launcher prepares the user's game files.
- [Champions of Norrath: matching PS2 function reconstruction](https://awesomerea.org/resources/champions-of-norrath-decomp-case/index.md): Case study · Champions of Norrath reconstructs C functions for the PlayStation 2 release SLUS-20565 and compares compiled output byte for byte with the user's game copy. The saved decompdecomp project separates matching functions from unfinished attempts. The author reports 6,018 matches among 8,984 functions.
- [PSP2I_Recomp: a native Phantasy Star Portable 2 Infinity port](https://awesomerea.org/resources/psp2i-recomp-case/index.md): Case study · PSP2I_Recomp uses psprecomp to generate native code from Phantasy Star Portable 2 Infinity's PSP EBOOT.BIN and builds host programs for Windows, Android and experimental Apple Silicon macOS. Its source supplies game hooks, rendering, SDL3 input and audio integration.
- [Hybrid Heaven: Recompiled: a native N64 port](https://awesomerea.org/resources/hybrid-heaven-n64-port-case/index.md): Case study · Hybrid Heaven: Recompiled statically recompiles the USA release of Hybrid Heaven with N64Recomp into a Windows and Linux port. It supplies game-specific code loading, widescreen presentation and controller support; the author reports progress through the first battles.
- [Forza Motorsport 3: Xbox 360 static recompilation for PC](https://awesomerea.org/resources/hl360-forza3-case/index.md): Case study · Forza Motorsport 3 is being statically recompiled from its Xbox 360 PowerPC executable into C++ for a native Windows port. ReXGlue generates the code, while the project supplies console services and a launcher that installs and checks data from the user's two discs.
- [Xbox 360 Quake 4 decomp: static recompilation with a native renderer](https://awesomerea.org/resources/xbox-360-quake4-decomp-case/index.md): Case study · Xbox 360 Quake 4 decomp builds a Windows port by translating a user-supplied Xbox 360 Quake 4 executable with ReXGlue and attaching game-specific hooks. Its alternate q4hle build routes the game's Direct3D calls through a native D3D11 renderer; the author reports testing the opening levels and documents remaining crashes and limited audio testing.
- [Golden Sun Recompiled for Android: an on-device recompilation port](https://awesomerea.org/resources/golden-sun-recompiled-android-case/index.md): Case study · Golden Sun Recompiled for Android ports the Golden Sun recompilation workflow to Android and builds game code from the player's ROMs on the device. It supports Golden Sun and The Lost Age, with touch controls, renderer options and save transfer between the games.
- [wage-engine: a World Builder adventure engine reimplementation](https://awesomerea.org/resources/wage-world-builder-engine-case/index.md): Case study · wage-engine reimplements the World Builder engine for classic Mac graphic text adventures in Java. It loads Mac resource data for scenes, characters, objects, sound, and scripts, and converts script bytes into readable commands.
- [Weltall: rebuilding Xenogears in Unreal Engine 5](https://awesomerea.org/resources/weltall-xenogears-case/index.md): Case study · Weltall rebuilds the PlayStation game Xenogears as a native Unreal Engine 5 port that reads content from the user's disc images. Its source implements field and battle rendering, game systems, input, saves, and disc-data handling. The author reports checking gameplay behavior against the original code and completing a playthrough of both discs.
- [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.
- [GHMetalRecomp: a Windows static recompilation of Guitar Hero: Metallica](https://awesomerea.org/resources/ghmetalrecomp-case/index.md): Case study · GHMetalRecomp statically recompiles the Xbox 360 Guitar Hero: Metallica executable for native Windows play using ReXGlue and the user's disc. Its game-specific code and launcher add controller and microphone support, display options and fixes described in per-issue engineering notes.
- [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.
- [The Urbz: Sims in the City: Nintendo DS ARM9 disassembly and function map](https://awesomerea.org/resources/urbz-sims-in-the-city-ds-case/index.md): Case study · urbz-re investigates the USA Nintendo DS release of The Urbz: Sims in the City through an ARM9 split, assembly listings, symbol names, and function notes. Its build script checks a user-supplied ROM and regenerates assembly with ds-decomp 0.12.1. The source tree has no matched C yet; the author reports that 280 ARM9 functions have been read.
- [OpenTESArena: a new engine for The Elder Scrolls: Arena](https://awesomerea.org/resources/opentesarena-case/index.md): Case study · OpenTESArena rebuilds the 1994 DOS game The Elder Scrolls: Arena in a new C++ engine using separately obtained game assets. It implements combat, items, shops, citizens, travel, and most character creation, while documenting original-game behavior and parsing Arena asset formats. Quests, spells, and saving remain unfinished.
- [Nightmare Creatures II: a PlayStation local recompilation kit](https://awesomerea.org/resources/nightmare-creatures-ii-recomp-case/index.md): Case study · Nightmare Creatures II provides a title-specific psxrecomp setup kit for the USA PlayStation release. A setup wizard accepts the user's disc image and SCPH-1001 BIOS, then generates and compiles the game locally through psxrecomp and recomp-ui. The repository includes game configuration, symbols and setup code.
- [rr-pc-port: reconstructing a playable Ridge Racer race on PC](https://awesomerea.org/resources/rr-pc-port-case/index.md): Case study · rr-pc-port reconstructs a playable PC race slice of the 1994 PlayStation Ridge Racer by re-expressing game logic in portable C. It ports selected functions and fixed-point driving behavior, reads course and resource data from the user's local game files, and renders through an optional SDL2 host. Its roadmap separates confirmed behavior from documented approximations.
- [Rewritten: a functional reconstruction of Minecraft Xbox 360 Title Update 2](https://awesomerea.org/resources/minecraft-xbox-360-rewritten-case/index.md): Case study · Rewritten is a functional C++ decompilation project for Minecraft Legacy Console Edition Title Update 2 on Xbox 360. It aims to recreate the game's behavior without byte matching; the contribution notes describe using a patched TU2 XEX with Ghidra or IDA Pro.
- [Rampage: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/rampage-spectrum-disassembly-case/index.md): Case study · Rampage documents the ZX Spectrum game's code as a SkoolKit disassembly. Its source tree contains the .skool listing and reference files, with a script to generate a browsable HTML version.
- [Panzer Dragoon Saga: Saturn asset-format research and extraction tools](https://awesomerea.org/resources/pds-tools-case/index.md): Case study · This Panzer Dragoon Saga project investigates Sega Saturn disc and asset formats. The repository documents MCB/CGB models, CPK video, PRG subtitles and audio formats, with Python extractors and browser viewers. The author reports results for model, video, music, font and texture extraction and conversion.
- [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.
- [Diddy Kong Racing: matching N64 decompilation](https://awesomerea.org/resources/diddy-kong-racing-case/index.md): Case study · Diddy Kong Racing reconstructs the N64 game's source code and builds against a user-supplied ROM. It extracts assets locally and compares rebuilt function assembly with the base ROM; the author reports complete decompilation for the default US version while documentation remains unfinished.
- [The Sims Bustin' Out: early GameCube decompilation and symbol mapping](https://awesomerea.org/resources/sims-bustin-out-gamecube-case/index.md): Case study · The Sims Bustin' Out GameCube decompilation targets the USA Rev 0 G4ME69 release. It combines decomp-toolkit build configuration, initial C files, and custom scripts that infer possible symbol matches from another GameCube decompilation. The author describes the split mapping as very early and largely heuristic.
- [Professor Layton: Pandora's Box HD: rehosting the Android game on Vita](https://awesomerea.org/resources/professor-layton-pandoras-box-hd-vita-case/index.md): Case study · This Vita port runs Professor Layton: Pandora's Box HD by loading its Android ARMv7 executable, resolving imports with native functions, and applying compatibility patches. The loader uses game files supplied from an Android APK and OBB, with version 1.0.1 documented as tested.
- [PSPRecomp: statically recompiling GTA: Vice City Stories into a native Windows build](https://awesomerea.org/resources/psprecomp-vice-city-stories-case/index.md): Case study · Provides a PSP static-recompilation framework that analyzes Allegrex/MIPS executables and emits C++ for a native host runtime. Its Vice City Stories profile checks in code generated for the US ULUS-10160 executable, plus HLE, Direct3D 12 rendering, audio and input layers. The decrypted executable and game data come from the user’s own copy, and no gameplay status is published.
- [HaloPad: Halo on Apple devices through a decompilation port and x86 recompilation](https://awesomerea.org/resources/halopad-project-reach-case/index.md): Case study · Brings Halo: Combat Evolved to iPhone, iPad and Apple silicon Macs through two engines. The Xbox edition builds a pinned OpenCE port of the community Xbox decompilation, while Custom Edition translates the user’s own haloce.exe 1.10 from x86 to ARM64 ahead of time, with HaloPad supplying Windows, Direct3D 9, input, audio and network services. The project discloses substantial AI assistance and records device results in a status log.
- [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.
- [Jet Set Radio Future: early matching Xbox decompilation](https://awesomerea.org/resources/jsrf-matching-decomp-case/index.md): Case study · An early matching decompilation of the North American standalone Xbox release of Jet Set Radio Future, hosted on Codeberg. Contributors delink default.xbe into per-source object files in Ghidra, then write C++ that compiles to matching objects with Visual C++ 7.0, compared with objdiff. Its README reports 1.50% of the XBE decompiled so far and disallows contributions made with large language models.
- [darling-lol: running the macOS League of Legends client on Linux through Darling](https://awesomerea.org/resources/darling-lol-league-linux-case/index.md): Case study · Patches the Darling macOS compatibility layer so that Riot’s macOS League of Legends client and game run on x86-64 Linux. The changes span Darling and 30 of its components, including Metal/Indium, AppKit, QuartzCore, CoreAudio, the kernel shim and darlingserver, with build, install and launch tooling. It is an experimental rehosting layer; playability and frame-rate results are author-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.
- [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.
- [DirectMusic: an open reimplementation of Microsoft’s music API](https://awesomerea.org/resources/dmusic-directmusic-reimplementation-case/index.md): Case study · Re-implements DirectMusic, the adaptive-soundtrack API Microsoft shipped with early DirectX, as a portable C11 library that loads a game’s segment, style and DLS instrument files and renders the music to PCM. The README lists only the Gothic and Gothic II (Night of the Raven) soundtracks as tested, and as working “somewhat” correctly; the project calls itself incomplete and under heavy development. Instruments play through a vendored TinySoundFont synthesizer after DLS-to-SoundFont conversion.
- [memory of alessa: an in-progress Silent Hill 3 PS2 matching decompilation](https://awesomerea.org/resources/silent-hill-3-memory-of-alessa-decomp-case/index.md): Case study · Decompiles the PS2 executable and 40 overlays of Silent Hill 3 (NTSC-U v1.02) into C for Metrowerks CodeWarrior, and works alongside on the Silent Hill 2 engine, whose debug symbols from a 2001 prototype supply original names for shared code. Builds link with generated assembly for unmatched functions and are checked by SHA-256 against committed hashes. The README calls the project early-stage; decomp.dev reports about 9% of Silent Hill 3 functions and 58% of Silent Hill 2 functions matched at the pinned commit.
- [Azel: reverse engineering Panzer Dragoon Saga into native C++](https://awesomerea.org/resources/azel-panzer-dragoon-saga-reimplementation-case/index.md): Case study · Reconstructs the Sega Saturn RPG Panzer Dragoon Saga as native C++, rewriting the game’s SH-2 routines for its kernel, field, town, battle, menu and audio systems. The rewritten code loads the user’s original disc files and reads their tables by Saturn address, rendering through bgfx and SDL with ImGui debugging views. README calls the project very early: the opening is semi-playable, with bugs, up to the Arachnoth battle, and no byte-matching rebuild is attempted.
- [OpenTS2: an open-source reimplementation of The Sims 2 in Unity](https://awesomerea.org/resources/opents2-sims2-engine-case/index.md): Case study · Reimplements The Sims 2 in the Unity engine, reading the user’s Ultimate Collection installation through its own C# code for the game’s DBPF packages and asset formats, which the project also aims to offer as modular libraries. README reports an early stage: a basic main menu with a neighborhood chooser, neighborhood previews and a basic neighborhood view, while the tree also holds lot, build-mode, Sim and SimAntics code. README credits FreeSO for much of its code and structure.
- [Skate 3 Mobile: an Android ARM64 fork of Skate3Recomp](https://awesomerea.org/resources/skate3-mobile-android-recomp-case/index.md): Case study · Carries the Skate3Recomp static recompilation of the Xbox 360 Skate 3 to Android: rexglue translates the configured PowerPC guest functions, and Android Clang compiles them into ARM64 libraries linked against a compatibility runtime. Runtime hooks pass the game’s meshes, textures and shader state to a native Vulkan scene renderer, and this fork adds SDL3 input and audio, a multitouch overlay and handheld performance profiles. The author calls it an experimental developer build that is playable on the Anbernic RG406V.
- [SwitchWakerHD: a Nintendo Switch port of the Wind Waker HD recompilation](https://awesomerea.org/resources/switchwakerhd-switch-port-case/index.md): Case study · Ports the ZeldaWWHDRecomp static recompilation of The Wind Waker HD to the Nintendo Switch as homebrew, adding a libnx platform layer and a renderer that draws the game’s GX2 graphics with deko3d, with translated shaders compiled on the console by uam. Game code is recompiled locally from the user’s own Wii U dump, so no Switch binaries are released. README reports the game playable handheld and docked at stock clocks, at 26–30 fps in its own measurements, and states that nearly all of the Switch work was written by Claude Code under human direction and hardware testing.
- [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.
- [outrun: a Sonic Runners custom server](https://awesomerea.org/resources/outrun-sonic-runners-server-case/index.md): Case study · Reimplements the game server for the Sonic Runners mobile game as a Go service, so Android and iOS clients redirected to it can log in, play Timed and Story modes and use the shop, roulettes, character and Chao progression, events, notices and basic rankings. The README says it was reverse engineered from the Sonic Runners Revival server, on whose code it bases much of its own; it serves about 40 HTTP endpoints of the client's API, decrypts and encrypts AES-CBC request payloads and keeps player state in a bbolt database.
- [Destruction Derby 64: a matching decompilation of the US ROM](https://awesomerea.org/resources/destruction-derby-64-decomp-case/index.md): Case study · A matching decompilation of the US Nintendo 64 ROM of Destruction Derby 64. The user supplies baserom.z64, SHA-1 a2c0799e13566d1b723299592cfcac9387f25fa7; the default make target rebuilds the ROM and sha1sum checks it against dd64.sha1.
- [Legend of Mana: a matching decompilation of the PlayStation game](https://awesomerea.org/resources/legend-of-mana-decomp-case/index.md): Case study · A matching decompilation of Legend of Mana on the PlayStation. The user supplies the North American executable SLUS_010.13, SHA-1 d11dfdd50d412ac3fa3e2eb80fbde138da118f27; make verify-bins checks the rebuilt main executable and overlays against the disc files.
- [ScummVM: replacement executables for classic adventure games](https://awesomerea.org/resources/scummvm-engine-case/index.md): Case study · Replaces the executables of classic adventure games and RPGs with one program that runs the user's original data files. It began with LucasArts SCUMM games and now names many other titles.
- [OpenJKDF2: C reimplementation of Jedi Knight: Dark Forces II](https://awesomerea.org/resources/openjkdf2/index.md): Case study · OpenJKDF2 is a function-by-function reimplementation of Jedi Knight: Dark Forces II in C. The README lists 64-bit Windows, macOS, and Linux builds that use SDL2, OpenAL, and OpenGL 3.3, plus ARM64 Android, Nintendo DSi, Dreamcast, 32-bit Windows, and an Emscripten WebAssembly build. Source files follow the original game layout, using symbols from the Grim Fandango Remaster ports and assertions from other games, and the tree includes the byacc and flex versions used to parse COG scripts.
- [Crackdown Recompiled: native PC port of Xbox 360 Crackdown](https://awesomerea.org/resources/crackdown-recompiled-case/index.md): Case study · Native PC recompilation of the Xbox 360 game Crackdown. Static recompilation with the ReXGlue SDK produces a Windows build using Direct3D 12 and an experimental native Linux and Steam Deck build using Vulkan. The repository does not contain the game files, and the recompiled C++ is generated from the user's own disc.
- [AC6Recomp: static recompilation of Ace Combat 6](https://awesomerea.org/resources/ac6-recomp/index.md): Case study · AC6Recomp is a native PC port of Ace Combat 6: Fires of Liberation built with the ReXGlue SDK. The README says the Xbox 360 PowerPC game code is statically recompiled to x86-64, while visible rendering stays in the vendored RexGlue/Xenia graphics backend. It describes the project as a work in progress that can boot and run in game.
- [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.
- [AC4-Port: native Windows port of Armored Core 4](https://awesomerea.org/resources/ac4-port/index.md): Case study · AC4-Port is an unofficial native Windows build of ARMORED CORE 4 for the PS3 USA release BLUS30027. The README describes static recompilation of about 3.6 million PowerPC instructions into C++, with SPU programs translated ahead of time, RSX commands drawn through Direct3D 11, and shaders converted to HLSL. The repository leaves out game data, game code, and keys.
- [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.
- [RSDKv2 Decompilation: Retro Engine v2](https://awesomerea.org/resources/rsdkv2-decomp/index.md): Case study · RSDKv2 Decompilation is a decompilation of Retro Engine v2, the engine used by the 2008 Sonic Nexus demo. The README adds a built-in mod loader, a settings.ini file, and debug keys, and it builds with CMake. Running it requires Sonic Nexus 2008 demo assets, which are left out of the repository.
- [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.