# Curated reverse engineering resources · Page 12

> Page 12 of 52, entries 1,101–1,200. 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/12/>
- JSON: <https://awesomerea.org/api/v1/resources.json>
- 简体中文: <https://awesomerea.org/zh/resources/page/12/index.md>

## Games (100)

- [OpenCrossing-Xbox: an original Xbox port of Animal Crossing](https://awesomerea.org/resources/opencrossing-xbox-case/index.md): Case study · OpenCrossing-Xbox compiles the decompiled GameCube code of Animal Crossing for the original Xbox and reads data from the user's USA Rev 0 disc image. Its Xbox-specific layer adapts video, audio, input, memory and file paths, including a renderer path to the NV2A GPU.
- [The Minish Cap: a native PC port of the GBA decompilation](https://awesomerea.org/resources/minish-cap-pc-port-case/index.md): Case study · The Minish Cap PC port compiles the GBA game's recovered C source for Linux, Windows and macOS. It replaces GBA hardware with SDL3, a software PPU renderer and agbplay audio, extracts assets from the user's ROM, and currently supports the USA and EU releases for native play.
- [Shittim Server: reconstructing Blue Archive services](https://awesomerea.org/resources/shittim-server-case/index.md): Case study · Shittim Server reconstructs services used by the Steam release of Blue Archive as a local C# ASP.NET Core server backed by SQLite. It redirects and patches the installed client to connect locally, and its Frida capture tool inspects plaintext responses at the client's decryption boundary to inform protocol implementation.
- [Luigi's Mansion: a multi-region GameCube decompilation](https://awesomerea.org/resources/luigis-mansion-lm-decomp-case/index.md): Case study · The archived Luigi's Mansion project reconstructs source for USA, Japanese and two PAL GameCube revisions. It builds from a user-provided disc image and provides objdiff configuration to compare reconstructed objects with the originals; its README points to a newer continuation.
- [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.
- [Shadow the Hedgehog: a PS2 static recompilation checkpoint](https://awesomerea.org/resources/shadow-the-hedgehog-ps2-recomp-case/index.md): Case study · Shadow the Hedgehog Recomp translates the PS2 game's MIPS and VU code into native C++ with PS2Recomp and links it to ps2xRuntime. The author reports static compilation, linking and bootloader initialization; video bypass, menus, input and 3D gameplay remain unfinished.
- [MadagascarDecomp: reconstructing Madagascar's source](https://awesomerea.org/resources/madagascar-decomp-case/index.md): Case study · MadagascarDecomp is a work-in-progress C++ decompilation of the 2005 game Madagascar. Its build uses Visual C++ Toolkit 2003 and RenderWare Graphics SDK, with reccmp scripts for comparing compiled output to an original Game.exe.
- [Robotron: 2084: a ZX Spectrum disassembly](https://awesomerea.org/resources/robotron-2084-spectrum-case/index.md): Case study · Robotron: 2084 is a SkoolKit disassembly of the ZX Spectrum game. The repository stores the SkoolKit source and control files and provides a script to generate browsable hexadecimal or decimal listings.
- [River Raid: an annotated ZX Spectrum disassembly](https://awesomerea.org/resources/river-raid-zx-disassembly-case/index.md): Case study · River Raid is reverse-engineered from its ZX Spectrum 48K tape image into an annotated SkoolKit disassembly. Pasmo assembles the generated source for comparison with a game snapshot, and the repository records gameplay-loop and data-structure findings. The author reports a byte-identical build while routine documentation is still in progress.
- [StarshipPad: bringing the Star Fox 64 source port to iOS](https://awesomerea.org/resources/starshippad-case/index.md): Case study · StarshipPad adapts the decompilation-based Star Fox 64 source port Starship into an iPhone and iPad application. Its maintained patches and build scripts add Metal rendering, touch flight controls, controller handling and local ROM import through Files.
- [MeleePad: a native Apple static recompilation of Super Smash Bros. Melee](https://awesomerea.org/resources/meleepad-melee-port-case/index.md): Case study · MeleePad ports Super Smash Bros. Melee to iPhone, iPad and Apple Silicon Mac by compiling PowerPC code translated from a player-supplied GameCube disc into ARM64 code ahead of time. It joins a Dolphin-derived runtime to Metal, UIKit, Apple audio and touch or physical controls.
- [Shaun Palmer's Pro Snowboarder: a PS2 decompilation and format study](https://awesomerea.org/resources/shaun-palmers-pro-snowboarder-decomp-case/index.md): Case study · SPPS reconstructs Shaun Palmer's Pro Snowboarder for PlayStation 2 as C source and rebuilds game executables with splat and a matching-function workflow. Its notes document release hashes and the game's DATA.DAT asset archive, including sector-based entry offsets and sizes.
- [Einhander: a PlayStation static recompilation project](https://awesomerea.org/resources/einhander-recompiled-case/index.md): Case study · Einhander configures psxrecomp to generate a native build of the PlayStation game from a user-supplied disc. Its repository includes game configuration, function seeds, symbol synchronization and trace analysis scripts, with recomp-ui used for the launcher.
- [Banjo-Tooie: a partial DLL decompilation and ROM build](https://awesomerea.org/resources/wedarobi-banjo-tooie-decomp-case/index.md): Case study · banjo2 reconstructs Banjo-Tooie DLL code for Nintendo 64 ROM builds. Its Makefile selects North American, Japanese, European or Australian versions and includes a matching-output option; project notes document compiling and comparing individual DLL binaries.
- [RTWDecomp: matching decompilation of Rome: Total War Gold](https://awesomerea.org/resources/rtwdecomp-rome-total-war-case/index.md): Case study · RTWDecomp reconstructs source for the Steam release of Rome: Total War Gold from its Windows x86 RomeTW.exe. It splits the PE into translation units, uses Visual C++ 6.0 SP6 and objdiff to compare compiled functions, and publishes findings on command-line options, console commands and gameplay mechanics.
- [Spyro 2: Gateway to Glimmer: matching PlayStation decompilation](https://awesomerea.org/resources/spyro-2-gateway-to-glimmer-case/index.md): Case study · Spyro 2: Gateway to Glimmer is being reconstructed as matching C for the European PlayStation release SCES-021.04. The build uses GCC 2.7.2 and an ASPSX 2.56-compatible pipeline for the main executable and 32 WAD overlays. The author reports a byte-identical rebuild of the executable, overlays, and complete WAD while C replacement remains partial.
- [Serial Experiments Lain: matching PlayStation decompilation and native port](https://awesomerea.org/resources/lain-psx-decompiled-case/index.md): Case study · Serial Experiments Lain is reconstructed as C source for the PlayStation release and ported to Windows, macOS and Linux through a reimplementation of PlayStation SDK calls. The author reports that the rebuilt executable matches the retail binary byte for byte; the native client reads media and data from the user's two original discs.
- [Wobbledogs: reconstructing Unity managed assemblies](https://awesomerea.org/resources/wobbledogs-case/index.md): Case study · Wobbledogs reconstructs the Steam Windows game's managed assemblies by decompiling IL with ILSpy and recompiling the resulting C# with Roslyn against the game's Mono profile. Scripts export assemblies from an owned install, repair documented decompiler artifacts, package a runnable tree, and compare code and boot behavior. The author reports a 69.80% code match.
- [Redneck Rampage: source reconstruction for two games](https://awesomerea.org/resources/redneck-rampage-reconstruction-case/index.md): Case study · Redneck-Rampage-RE reconstructs source code for Redneck Rampage and Redneck Rampage Rides Again. The repository contains C and assembly game and engine files and identifies Watcom 10.5 as the build compiler.
- [Ladder: reconstructing the CP/M arcade game in Go](https://awesomerea.org/resources/ladder-cpm-case/index.md): Case study · Ladder reimplements the 1982 CP/M arcade game in Go. The author observes the original in a CP/M emulator and consults an earlier Java version while rebuilding its platform, ladder and falling-object gameplay; development remains in progress.
- [dRally: a native Death Rally port for Linux and BSD](https://awesomerea.org/resources/drally-case/index.md): Case study · dRally is a C and SDL2 project to port Death Rally (1996) to Linux and BSD. Its installation instructions use asset archives extracted from the original game.
- [Crazy Taxi: an Xbox 360 XBLA static recompilation for PC](https://awesomerea.org/resources/ctxbla-crazy-taxi-case/index.md): Case study · ctxbla statically recompiles the 2010 Xbox 360 XBLA release of Crazy Taxi into native x86-64 PC code with XenonRecomp and ReXGlue. The repository documents STFS and XEX extraction, executable-section analysis, game-specific stubs, and input and timing fixes. The author reports that the runtime reaches gameplay, while in-game audio is absent and some gameplay events can crash.
- [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.
- [MUA PC Port: three Xbox 360 games statically recompiled](https://awesomerea.org/resources/mua-bundle-recompiled-case/index.md): Case study · MUA PC Port statically recompiles three related Xbox 360 games into separate native programs using ReXGlue. A shared launcher installs each game from the user's disc image and starts its runtime on Windows, with experimental Linux and Steam Deck support.
- [OpenOrion2: a partial Master of Orion II remake and save viewer](https://awesomerea.org/resources/openorion2-case/index.md): Case study · OpenOrion2 is a partial C++ remake of Master of Orion II: Battle at Antares that reads the original game's LBX resources and saved games. Its current interface can load existing saves as a viewer; starting a new game and gameplay remain unimplemented.
- [ClayFighter 64: recompiling and combining two N64 ClayFighter games](https://awesomerea.org/resources/clayfighter64-case/index.md): Case study · ClayFighter 64 builds a native Linux and Windows game from statically recompiled ClayFighter 63⅓ CPU and RSP audio code, adding four characters from ClayFighter: Sculptor's Cut. Its installer checks both user-supplied USA ROMs and assembles the combined game data locally; RT64 handles rendering.
- [Chronoshift: incrementally rebuilding Command & Conquer: Red Alert](https://awesomerea.org/resources/chronoshift-red-alert-case/index.md): Case study · Chronoshift incrementally reimplements Command & Conquer: Red Alert in C++. Its launcher and DLL supply rewritten game functions while the original executable supplies functions still pending, so the current build targets the English 3.03 beta patch.
- [The Simpsons: Hit & Run: an Android port with native touch controls](https://awesomerea.org/resources/simpsons-hit-and-run-android-case/index.md): Case study · The Simpsons: Hit & Run Android adapts an earlier Switch and PS Vita port of the game for Android. It adds native touch controls and an in-game control-layout editor, supports external controllers, and loads assets supplied from the player's PC copy.
- [PES6 native: a Windows recompilation of Pro Evolution Soccer 6](https://awesomerea.org/resources/pes6-native-case/index.md): Case study · PES6 native builds a Windows x64 version of the European Xbox 360 release of Pro Evolution Soccer 6 by translating its PowerPC code to C++ with ReXGlue. The repository supplies project manifests, a ReXGlue SDK patch, native host code, an ISO extractor, and a builder that uses the player's own game copy.
- [Need for Speed: Underground 2: an Xbox static recompilation for Switch and Linux](https://awesomerea.org/resources/nfsu2-switch-linux-recompilation-case/index.md): Case study · nfsu2-sw turns the NTSC-U original Xbox release of Need for Speed: Underground 2 into native Nintendo Switch and Linux builds. Its vendored xboxrecomp toolkit lifts default.xbe to C, while the project adds host integration, renderer options, audio and game-specific overrides; game data comes from the player's extracted disc.
- [Halo CE Decomp Remix: VR, PC and Android port](https://awesomerea.org/resources/halo-ce-decomp-remix-vr-case/index.md): Case study · Adapts the Halo: Combat Evolved Xbox decompilation into builds for standalone VR headsets, Windows PC and Android. The port adds VR interaction and controller handling, PC and mobile launch paths, game-data import and campaign networking. It draws on the OpenCE port and requires the player's Halo game data.
- [PTCGP Private Server: a local Pokémon TCG Pocket service](https://awesomerea.org/resources/ptcgp-private-server-case/index.md): Case study · PTCGP Private Server replaces selected Pokémon TCG Pocket 1.8.1 online services with local HTTPS and gRPC endpoints for profiles, collections and pack openings. A Windows controller routes a rooted Android client's traffic to per-device servers, checks the client build and imports game data from the user's installation.
- [Prototype: incremental behavioral decompilation through a hooked DLL](https://awesomerea.org/resources/prototype-incremental-decomp-case/index.md): Case study · Prototype incrementally reconstructs functions from the 2009 PC game's engine DLL as readable C++. A proxy xinput1_3.dll redirects calls to replacement functions; the project saves Ghidra annotations and checks replacement behavior against the original at runtime. The author reports 28 replaced functions.
- [Blues Brothers: rewritten engines for three Titus games](https://awesomerea.org/resources/blues-brothers-engine-case/index.md): Case study · blues rewrites the engines of Blues Brothers and Blues Brothers: Jukebox Adventure in C, with support for Prehistorik 2. It loads original Amiga or DOS data files and adds horizontal scrolling and configurable screen size.
- [Dejavu: reimplementing classic Game Maker](https://awesomerea.org/resources/dejavu-game-maker-case/index.md): Case study · Dejavu reimplements classic Game Maker in Rust to run existing projects and games on modern platforms. Its source includes GML parsing, compilation and interpretation, project reading, and a game runtime; the CLI accepts GMK projects, EXE games, and GML scripts. The implementation is early-stage, with GML and drag-and-drop code running while more APIs remain to be added.
- [Tom and Jerry: War of the Whiskers: an experimental GameCube decompilation](https://awesomerea.org/resources/wotwdecomp-case/index.md): Case study · wotwdecomp reconstructs the GameCube game Tom and Jerry: War of the Whiskers with C++ and assembly and builds a specified main.dol. Its Makefile combines reconstructed functions, remaining assembly, and the required GameCube toolchains. The author describes the build as experimental because unresolved hardcoded pointers prevent shifting it for general changes.
- [Recompia: a native Pokémon Pokopia build for Windows](https://awesomerea.org/resources/recompia-case/index.md): Case study · Recompia builds a native Windows version of the Switch 2 game Pokémon Pokopia from the user's extracted game files. The project extends pokopia-native with its own game-build code and launcher, and describes a setup process that compiles the game and prepares a shader cache. It also documents Linux use through Proton.
- [Link's Awakening DX: static recompilation of the Game Boy Color ROM](https://awesomerea.org/resources/links-awakening-dx-static-recomp-case/index.md): Case study · LinksAwakening converts a user-supplied The Legend of Zelda: Link's Awakening DX Game Boy Color ROM into C and builds a native Windows program. It uses gb-recompiled for code translation and runtime support, with an interpreter fallback for unresolved jumps and tools that compare hardware traces against SameBoy.
- [OpenMCM2: a Rust engine reconstruction of Motocross Madness 2](https://awesomerea.org/resources/xshxdex98-openmcm2-case/index.md): Case study · OpenMCM2 rebuilds the Motocross Madness 2 engine in Rust from a study of the original game. It reads the user's game files, including RS2 archives, terrain, scenes, models and UI data, and implements racing, bike physics, menus and network races between OpenMCM2 copies. The author reports that some jump landings, rough ground and object collisions still differ from the original.
- [MetroidPrimeHuntersRecomp: a native Metroid Prime Hunters recompilation](https://awesomerea.org/resources/metroid-prime-hunters-recomp-case/index.md): Case study · MetroidPrimeHuntersRecomp builds a native alpha of Metroid Prime Hunters USA revision 0 with ndsrecomp and a player-supplied ROM. It includes game-specific execution coverage, controls and rendering work. A separate investigation documents the game's Wi-Fi datagram framing and typed messages.
- [Rex: SkoolKit disassembly of both ZX Spectrum game sides](https://awesomerea.org/resources/skrex-case/index.md): Case study · skRex presents disassemblies of both sides of the ZX Spectrum game Rex. The repository stores Side A and Side B SkoolKit source and reference files, and documents rendering the development version to HTML with skool2html.py.
- [Rock Band 3: agent-assisted Xbox 360 matching decompilation](https://awesomerea.org/resources/freeqaz-rock-band-3-xenon-case/index.md): Case study · rb3-xenon reconstructs Rock Band 3 Xbox 360 code in C++ and compares compiler output with the retail executable function by function. It uses the original MSVC Xbox 360 toolchain and extensive game-specific analysis and workflow code; the author reports 98.9% of game-code functions byte matched.
- [Sonic the Fighters (PC): a ReXGlue native port](https://awesomerea.org/resources/sonic-fighters-xbla-pc-case/index.md): Case study · Sonic the Fighters (PC) uses a game-specific ReXGlue manifest to translate the player's XBLA default.xex from PowerPC instructions into C++ and build a native PC or Linux program. The author describes the current port as single player and controller driven.
- [payne-recomp: a native recompilation of Max Payne for Xbox](https://awesomerea.org/resources/payne-recomp-case/index.md): Case study · payne-recomp translates the PAL Xbox release of Max Payne into C on the user's machine and builds native Windows or Apple Silicon programs against DirectXbox-Recomp. Game-specific seeds, symbols and overrides accompany the build; the author reports that all 67 levels load in short scripted checks.
- [Ozymandias: a Godot engine reconstruction for Pharaoh and Zeus](https://awesomerea.org/resources/ozymandias-pharaoh-engine-case/index.md): Case study · Ozymandias recreates the engine of the city-building games Pharaoh, Zeus and related titles in Godot 3.6 Mono. Its project tree contains game-system scripts, scenes and interface code that use files from an original game installation. The author describes the current implementation as early, with basic structure and menu logic.
- [VerilogBoy: reconstructing Game Boy hardware in Verilog](https://awesomerea.org/resources/verilogboy-game-boy-case/index.md): Case study · VerilogBoy reconstructs a Game Boy-compatible console as Verilog RTL for the Pano Logic G1 FPGA device. Its modules implement the SM83 CPU, pixel processing, audio, DMA, and timers, while CPU notes and test results document the behavior used to guide the implementation.
- [The Urbz: Sims in the City: GameCube matching decompilation](https://awesomerea.org/resources/urbz-sims-in-the-city-gamecube-case/index.md): Case study · The Urbz: Sims in the City GameCube decompilation reconstructs game code for the GUBE69 release. Its decomp.wtf and decomp-toolkit workflow configures a main.dol rebuild, compares the result byte for byte with the user's copy, and uses objdiff to inspect function progress. The repository includes game-specific C sources, symbols, and split configuration.
- [OpenMU: a reconstructed MU Online server and packet reference](https://awesomerea.org/resources/openmu-case/index.md): Case study · OpenMU reconstructs a MU Online server from scratch, focusing on the Season 6 Episode 3 English client protocol. Its C# implementation is accompanied by packet references that map identifiers, byte fields, send conditions and effects on the game client.
- [The Hobbit: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/hobbit-spectrum-disassembly-case/index.md): Case study · The Hobbit documents a disassembly of the ZX Spectrum game in SkoolKit source files. The repository includes annotations and scripts that generate browsable hexadecimal or decimal disassembly pages.
- [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.
- [Another World JS: a browser port interpreting the game's bytecode](https://awesomerea.org/resources/another-world-js-case/index.md): Case study · Another World JS ports Another World to an HTML5 browser runtime by implementing its 26 game bytecode opcodes in JavaScript. Extraction scripts convert original DOS and 15th anniversary data files into JavaScript input; the port adds palette switching, alternate resolutions and rewind.
- [OpenBarnyard: decompiling Barnyard and the TOSHI 2.0 engine](https://awesomerea.org/resources/openbarnyard-case/index.md): Case study · OpenBarnyard reconstructs C++ source for the Windows game Barnyard and its TOSHI 2.0 engine. The repository contains game and engine source, progress tooling and Windows project generation scripts.
- [DirkSimple: reconstructing Dragon's Lair and Cliff Hanger game logic](https://awesomerea.org/resources/dirksimple-laserdisc-games-case/index.md): Case study · DirkSimple reconstructs Dragon's Lair and Cliff Hanger laserdisc game logic in Lua, playing user-supplied original footage through a C FMV runtime. It accepts Ogg Theora video with matching timing and can be built as a standalone SDL player or a libretro core.
- [Professor Layton: Lost Future HD Vita: an Android executable port](https://awesomerea.org/resources/layton-lost-future-hd-vita-case/index.md): Case study · Professor Layton: Lost Future HD Vita runs the Android ARMv7 game executables on PS Vita by loading them into memory, resolving imports with native functions and applying patches. The user supplies the Android APK and OBB files.
- [OMK: reconstructing the Omikron game engine](https://awesomerea.org/resources/omk-omikron-engine-case/index.md): Case study · OMK reimplements the engine of Omikron: The Nomad Soul in C++20 using files from a user's game copy. Its documentation records asset formats, the script VM and game state, while the engine covers opening sequences, city exploration, menus and combat; the author reports that a cold-start event trace matches all 42 recorded original events.
- [ReStuff: recompiling Naughty Bear Gold Edition](https://awesomerea.org/resources/naughty-bear-restuff-case/index.md): Case study · ReStuff statically recompiles the Xbox 360 game Naughty Bear Gold Edition using the ReXGlue SDK. Its host code includes Vulkan rendering, guest D3D hooks, texture decoding and shader translation, while diagnostic scripts and reports track game-specific boot and graphics behavior.
- [HALBERD: a PC port of Kirby 64](https://awesomerea.org/resources/halberd-kirby-64-port-case/index.md): Case study · HALBERD ports the Kirby 64: The Crystal Shards decompilation to PC with libultraship for rendering and input, and Torch for extracting resources from the user's N64 ROM. Its own platform code supplies libultra shims and runtime bridges; the author reports working menus and level loading.
- [Arcanum Community Edition: rebuilding Arcanum for modern systems](https://awesomerea.org/resources/arcanum-community-edition-case/index.md): Case study · Arcanum Community Edition rebuilds Arcanum as a replacement executable for modern operating systems while using data from the player's game installation. Its C source covers game and engine modules, with named APIs and annotations in some areas and unresolved names in others.
- [Erupe: reconstructing Monster Hunter Frontier online services](https://awesomerea.org/resources/erupe-monster-hunter-frontier-case/index.md): Case study · Erupe reconstructs Monster Hunter Frontier's online server in Go, providing sign-in, entrance and channel services for game clients. Its code handles game messages and quest data, and an accompanying TCP observer decrypts and records position-bearing packets for protocol work.
- [T.O.R.E-Fighters: rebuilding Jane's Fighters Anthology in Rust](https://awesomerea.org/resources/tore-fighters-case/index.md): Case study · T.O.R.E-Fighters rebuilds Jane's Fighters Anthology in Rust around observed player-visible behavior. It imports resources from the player's retail copy, implements flight and quick missions, and documents original formats, feature coverage and approximations where behavior remains uncertain.
- [Tokyo Jungle Recompiled: a PS3 static recompilation bring-up](https://awesomerea.org/resources/tokyo-jungle-recompiled-case/index.md): Case study · Tokyo Jungle Recompiled translates the PS3 game's PowerPC executable into native PC code with ps3recomp and supplies game-specific loading, import and runtime glue. Its investigation documents PPU functions, SPU workloads, asset loading and a main-loop wait that currently blocks geometry rendering.
- [rushrecomp: static recompilation and analysis of Sonic Rush](https://awesomerea.org/resources/rushrecomp-case/index.md): Case study · rushrecomp translates Sonic Rush's Nintendo DS ARM9 and ARM7 code to C ahead of time with ndsrecomp and maintains a parallel manual x86-32 path based on decompiled subsystems. Its notes map ROM functions and hardware accesses, while the manual path records partial function coverage and unresolved stubs.
- [Champions: Return to Arms: byte-matched PS2 function reconstruction](https://awesomerea.org/resources/champions-return-to-arms-ps2-case/index.md): Case study · Champions: Return to Arms reconstructs independently authored C++ for the US v2.00 PlayStation 2 game, checking complete functions against the original executable byte by byte. The author reports eight matching functions covering 64 bytes; the repository includes a function ledger, verifier and sanitized comparison receipt.
- [Fallout: New Vegas: a work-in-progress decompilation](https://awesomerea.org/resources/fallout-new-vegas-decomp-case/index.md): Case study · Fallout: New Vegas is being reconstructed from the USA 2010-11-10 Fallout_Release_MemDebug.xex in a work-in-progress decompilation. The project builds source with Python and Ninja and configures objdiff to compare rebuilt objects with the original.
- [Tokimeki Memorial: Forever With You: a PS1 decompilation in progress](https://awesomerea.org/resources/tokimeki-memorial-ps1-decomp-case/index.md): Case study · tokimemo is a work-in-progress reconstruction of Tokimeki Memorial: Forever With You for PlayStation version 1.1. It records executable segments and symbol addresses in a PS1 splat configuration, with assembly source and a Makefile for rebuilding the target executable.
- [Tekken 6 Recomp: an Xbox 360 static recompilation](https://awesomerea.org/resources/tekken-6-recomp-case/index.md): Case study · Tekken 6 Recomp generates native code from the Xbox 360 release of Tekken 6 using a patched ReXGlue SDK. It provides a game manifest, host code and runtime compatibility patches, with build paths for Windows and macOS. Its builders extract the user's own game image before code generation.
- [Dungeon Keeper Remake: a C++ engine for the original game data](https://awesomerea.org/resources/dungeon-keeper-remake-case/index.md): Case study · Dungeon Keeper Remake is a C++ remake of Dungeon Keeper being developed with DirectX 11 and XAudio2 for use with the original game installation. The project uses RNC decompression for compressed assets and a Smacker decoder for game videos.
- [BrightEyes: recreating Realms of Arkania games](https://awesomerea.org/resources/brighteyes-case/index.md): Case study · BrightEyes reverse engineers MS-DOS-era games and aims to recreate them for modern platforms. It began with Realms of Arkania: Blade of Destiny, and the repository contains C, C++, assembly and build files.
- [Demon's Souls PC: a PS3 static recompilation for Windows](https://awesomerea.org/resources/demons-souls-pc-case/index.md): Case study · Demon's Souls PC ports the North American PS3 release of Demon's Souls to Windows x64 by lifting PowerPC and SPU code to C and linking it with replacements for PS3 system libraries. It uses Direct3D 12, WASAPI and a .NET launcher; the author reports booting through Boletarian Palace 1-1 on one reference machine.
- [Final Fantasy Dimensions Vita: rehosting the Android game on PS Vita](https://awesomerea.org/resources/final-fantasy-dimensions-vita-case/index.md): Case study · Final Fantasy Dimensions Vita runs the Android release of Final Fantasy Dimensions on PS Vita by loading its ARMv6 executable into memory. The loader resolves Android imports with native functions and applies patches; the player supplies the game's APK and OBB data.
- [Shinobi Legions: Saturn code analysis and PC port](https://awesomerea.org/resources/shinobi-legions-saturn-pc-port-case/index.md): Case study · Reconstructs Shinobi Legions for PC from analysis of its Sega Saturn SH-2 code and disc formats. A C11 and SDL2 port rewrites game functions while retaining the original memory layout; the author reports that the title, 18 stages, bosses, and ending run using files extracted from the user's disc.
- [WHITE ALBUM2: a shared engine migration from static recompilation](https://awesomerea.org/resources/white-album2-shared-engine-case/index.md): Case study · The WHITE ALBUM2 port shares game logic between Windows x64 and Android ARM64 while migrating from a hybrid static recompilation to a native C++ compatibility engine. Current native components handle save flags, script behavior and resource processing; the delivered shared-aot build still uses recompiled functions. Original PAK files remain external.
- [JSettlers: a Java remake of The Settlers III](https://awesomerea.org/resources/jsettlers-case/index.md): Case study · JSettlers recreates The Settlers III as a Java game for Windows, Linux and Android. Its own engine and game code use GFX and SND files from an original or demo installation, with MAP files optional. The author describes the project as alpha software.
- [Street Fighter II Recompiled: a CPS1 static recompilation](https://awesomerea.org/resources/street-fighter-ii-recompiled-case/index.md): Case study · Street Fighter II Recompiled translates the CPS1 arcade game's Motorola 68000 code into C using ROM analysis, Capstone disassembly and a project-specific generator. Its native build links to a sibling CPS1 runtime for video, audio and input; the author reports reaching the character-select screen.
- [World of Kartcraft: porting Crash Team Racing physics into WoW](https://awesomerea.org/resources/world-of-kartcraft-case/index.md): Case study · World of Kartcraft ports Crash Team Racing's driving model, read from a decompilation, into a Rust World of Warcraft 1.12.1 client. It recreates kart handling, powerslides and boosts in Azeroth while setup extracts kart data from the user's CTR disc and reads a separate WoW installation. The project documents the physics port and the resulting multiplayer kart systems.
- [tkdr-recomp: a PSP static recompilation of Tekken: Dark Resurrection](https://awesomerea.org/resources/tkdr-recomp-case/index.md): Case study · tkdr-recomp runs the PSP release of Tekken: Dark Resurrection by translating its MIPS executable ahead of time to C for native builds or WebAssembly in the browser. A custom runtime supplies PSP library calls, scheduling, graphics, audio, and input. The author reports working boot, menus, movies, saves, and full matches, with Quick Battle explored from boot.
- [DishSoap: an Android port of The Dishwasher: Dead Samurai](https://awesomerea.org/resources/dishsoap-dishwasher-android-port-case/index.md): Case study · DishSoap ports the Xbox 360 game The Dishwasher: Dead Samurai to Android using managed code decompiled locally from the owner's game copy. Repository code provides MonoGame platform shims, an on-device content importer, audio decoding, controls and save support; building from source also requires manual XNA-to-MonoGame edits.
- [Wanted: Monty Mole: a ZX Spectrum disassembly](https://awesomerea.org/resources/monty-mole-disassembly-case/index.md): Case study · monty is a SkoolKit disassembly of the 1984 ZX Spectrum game Wanted: Monty Mole. The repository includes separate skool sources for the game and loader, plus control files and a build script.
- [Biohazard Outbreak decomp: matching PS2 game reconstruction](https://awesomerea.org/resources/biohazard-outbreak-decomp-case/index.md): Case study · Biohazard Outbreak decomp reconstructs C for the Japanese PS2 releases of Biohazard Outbreak and File 2, checking locally rebuilt executables and overlays against the originals. Its extraction, survey and function-comparison tools operate on user-supplied discs; the author reports 238 byte-matching File 1 functions, while File 2 C decompilation has not started.
- [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.
- [nfsmw-nx: statically recompiling Need for Speed: Most Wanted for Switch](https://awesomerea.org/resources/nfsmw-nx-case/index.md): Case study · nfsmw-nx ports the Xbox 360 release of Need for Speed: Most Wanted (2005) to Nintendo Switch through static recompilation. ReXGlue translates the game's PowerPC default.xex to C++, while a Switch runtime supplies console services and a Vulkan renderer on NVK draws its graphics. Installation derives shaders and game data from the player's own disc.
- [swos-port: a DOS Sensible World of Soccer port with recorded behaviour checks](https://awesomerea.org/resources/swos-port-case/index.md): Case study · swos-port adapts the DOS Sensible World of Soccer 96/97 to C++ and SDL. It combines generated translations of original assembly routines with rewritten systems and compares port state frame by frame against recordings from the DOS game.
- [lastwar-client: reconstructing Last War's network layer](https://awesomerea.org/resources/lastwar-client-case/index.md): Case study · lastwar-client reconstructs the network layer of the mobile game Last War: Survival Game in Go. Based on APK analysis and captured traffic, it implements GSL RSA/AES bootstrap, SFS2X framing and the SFSObject binary codec, and publishes a dossier of commands, fields and live observations.
- [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.
- [Super Mario Bros. Deluxe: partial exact-match disassembly](https://awesomerea.org/resources/super-mario-bros-deluxe-disasm-case/index.md): Case study · Reconstructs banks of the US version 1.1 Super Mario Bros. Deluxe ROM as WLA DX assembly. The author reports exact matches for the listed code and level-data banks and selected graphics banks, apart from the calculated checksum; other graphics banks and some pointer formats remain unresolved.
- [Luigi's Mansion (3DS): partial ARM source reconstruction](https://awesomerea.org/resources/luigis-mansion-3ds-decomp-case/index.md): Case study · Luigi's Mansion (3DS) Decompilation recovers C source from the Nintendo 3DS release, with implemented formatter, startup, runtime and game-state functions. Its tools extract a user-provided decrypted dump, generate ARM disassembly and run headless Ghidra analysis; the main game entry remains unfinished.
- [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.
- [Trashman: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/trashman-disassembly-case/index.md): Case study · Trashman documents a disassembly of the ZX Spectrum game using SkoolKit. The repository contains SkoolKit source and scripts for generating browsable hexadecimal or decimal HTML listings.
- [Summoner 2: matching PlayStation 2 decompilation](https://awesomerea.org/resources/summoner-2-ps2-decomp-case/index.md): Case study · Reconstructs the PlayStation 2 version of Summoner 2 as C++ source that is compared with the original executable. Splat separates executable units, objdiff checks functions, and the build links matched units from source while rejecting byte differences.
- [3D Pinball — Space Cadet: a Nintendo DS port of the decompilation](https://awesomerea.org/resources/3dpinball-nds-case/index.md): Case study · 3dpinball-nds adapts the Space Cadet Pinball decompilation into a Nintendo DS port built with BlocksDS. Its ARM7 and ARM9 source implements the handheld platform layer, while game data comes from the user's Windows release.
- [Doraemon 1: decompiling Nobita to Mittsu no Seireiseki](https://awesomerea.org/resources/doraemon-1-decomp-case/index.md): Case study · Doraemon 1 decompiles the Nintendo 64 game Doraemon: Nobita to Mittsu no Seireiseki into C and assembly that build a doraemon.z64 image from a user-supplied ROM. The repository includes game source, headers and a build workflow with a stated output MD5.
- [openDarkEngine: rebuilding support for Dark Engine game data](https://awesomerea.org/resources/opendarkengine-case/index.md): Case study · openDarkEngine rebuilds an engine for data files from the original Dark Engine games. Its current code displays levels and objects, while its documentation describes incomplete lighting, simulation and scripting and a planned replacement of the Ogre3D renderer.
- [PC-ROA: statically recompiling Ragnarok Odyssey ACE for PC](https://awesomerea.org/resources/pc-roa-ragnarok-odyssey-ace-case/index.md): Case study · PC-ROA investigates the PS3 disc and executable of Ragnarok Odyssey ACE and statically recompiles the game's code to C++ for a PC runtime. Its repository includes disc readers, format documentation, extraction tools, and a separate reimplementation used for comparison. The author reports that the current build reaches the first quests and fights.
- [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.
- [SkiFree SDL: an SDL2 port of decompiled SkiFree](https://awesomerea.org/resources/skifree-sdl-case/index.md): Case study · SkiFree SDL adapts an existing decompilation of the Microsoft Entertainment Pack game SkiFree into a cross-platform SDL2 source port. It contains the C source and CMake build files, while the player supplies original graphics and icon resources for the build.
- [Gran Turismo 2: reconstructing PS1 executables and overlays](https://awesomerea.org/resources/gt2-reversing-case/index.md): Case study · gt2-reversing reconstructs code for Gran Turismo 2's PlayStation release from the North American 1.2 simulation disc. Its build produces the SCUS_944.88 executable and six overlay executables from user-supplied originals, while the source tree contains C implementations, symbols and split configurations.
- [Lunar 2: Eternal Blue Complete: a PlayStation decompilation](https://awesomerea.org/resources/lunar-2-psx-decomp-case/index.md): Case study · The project reconstructs code for the PlayStation release of Lunar 2: Eternal Blue Complete, identified as SLUS_010.71. Its build extracts code and data from the user's game files and rebuilds boot.dat, while C sources, symbols and an asm-differ workflow support continued function work.
- [ReGTA Chinatown Wars PSP Recompilation: a native Windows port](https://awesomerea.org/resources/regta-chinatown-wars-case/index.md): Case study · ReGTA Chinatown Wars PSP Recompilation targets the Europe v1.01 PSP release of Grand Theft Auto: Chinatown Wars for a Windows x64 port. Its C++20 mainline compiles original MIPS control flow ahead of time and supplies PSP services, graphics and audio; the repository also documents analysis of the original executable.
- [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.
- [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.