# Curated reverse engineering resources · Page 25

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

## Games (100)

- [flOw: static recompilation of the PS3 game for Windows](https://awesomerea.org/resources/flow-ps3-recomp-case/index.md): Case study · flOw lifts PowerPC functions from the PS3 game's EBOOT.elf to C and links them against ps3recomp host libraries for a Windows executable. The author reports a host-driven frame loop and D3D12 rendering through a host-side scene builder; the game state machine still blocks full gameplay.
- [Rosebed: porting Minecraft Beta 1.7.3 to Zig](https://awesomerea.org/resources/rosebed-minecraft-beta-case/index.md): Case study · Rosebed ports decompiled Minecraft Beta 1.7.3 source to Zig as a client and dedicated server. The author reports matching game behavior, seeded worlds and multiplayer compatibility with the original. Builds are described for desktop, browser, Android and iOS, with original game assets fetched separately.
- [OpenPREY: a replacement engine for PREY (2006)](https://awesomerea.org/resources/openprey-prey-2006-case/index.md): Case study · OpenPREY adapts a Quake4Doom-derived engine to run PREY (2006) from the player's original installation on Windows, Linux and macOS. It checks the game's PK4 asset layout, supports its game-module loading model, and adds SDL3 windowing, modern display modes and diagnostic tooling.
- [Rails: an OCaml reconstruction of Railroad Tycoon](https://awesomerea.org/resources/rails-railroad-tycoon-case/index.md): Case study · Rails rebuilds the 1990 Railroad Tycoon game in OCaml, implementing railroad construction, train management, AI rivals and economy systems. It loads the user's original DOS PIC, PAN and DTA data files and uses SDL2 for its interface and presentation.
- [Illbleed decomp: reconstructing the Dreamcast executable](https://awesomerea.org/resources/illbleed-decomp-case/index.md): Case study · Illbleed decomp reconstructs the Japanese Dreamcast game's executable from a user-supplied disc. Its scripts generate per-function SH-4 assembly, maps and model information, then compare rebuilt bytes and test recovered C for behavioral equivalence. The author reports 2,049 named functions and no completed C functions in the published progress table.
- [World of Goo Vita: rehosting the Android game on PS Vita](https://awesomerea.org/resources/world-of-goo-vita-case/index.md): Case study · World of Goo Vita runs the Android version of World of Goo on PS Vita by loading its ARMv7 library into memory, replacing Android imports with native functions and applying runtime patches. The loader uses the user's own paid Android game files, including libworldofgoo.so and asset folders.
- [OpenJPB: rebuilding Jedi Power Battles for PC](https://awesomerea.org/resources/openjpb-case/index.md): Case study · OpenJPB rebuilds the Windows release of Star Wars: Episode I: Jedi Power Battles as a replacement engine. It derives game-owned structures and behavior from the retail executable and PDB, provides portable reconstructed modules and a Win32 host, and loads assets from the user's Steam or GOG installation.
- [Mech Commander 2: reconstructing the closed engine from interface headers](https://awesomerea.org/resources/mc2-mech-commander-2-case/index.md): Case study · mc2 reimplements the closed Mech Commander 2 engine using available interface headers and ports the game to 64-bit Linux and Windows. The author reports finishing the game on Linux; networking and parts of the sound system remain incomplete.
- [mortar-eng: LSW game scene and character reconstruction](https://awesomerea.org/resources/mortar-eng-lsw-case/index.md): Case study · mortar-eng reconstructs parts of an LSW game runtime in C++. Its NUP and HGP readers load scene models and character data, including meshes, textures, joints and transforms, into resource objects used by scene-loading and rendering code.
- [DriftDroid: an Android port of statically recompiled Mario Kart Wii](https://awesomerea.org/resources/driftdroid-case/index.md): Case study · DriftDroid adapts WiiCompiled's static recompilation of Mario Kart Wii into a native Android app. It adds touch and motion controls, Vulkan and OpenGL ES rendering paths, and disc import for game data from the user's PAL RMCP01 copy; a separate builder handles Switch builds and optional Android game packs.
- [Super Punch-Out!!: a USA SNES disassembly](https://awesomerea.org/resources/super-punch-out-disassembly-case/index.md): Case study · Super Punch-Out!! is a disassembly of the USA SNES game, organized as assembly source with ROM maps and extraction scripts. It uses the author's SNES ROM framework and requires a clean, headerless user ROM for asset extraction.
- [PROTOTYPE — native PC port: rehosting the PS4 games on Windows](https://awesomerea.org/resources/prototype-pc-port-case/index.md): Case study · PROTOTYPE — native PC port runs the PS4 bundle's x86-64 game code directly on Windows, replacing PS4 system libraries and translating GPU commands to Vulkan through a shadPS4 video core. Game-specific fixes address timing, saves and rendering; PROTOTYPE 2 support is experimental.
- [Ar tonelico II: matching decompilation of the Japanese PS2 release](https://awesomerea.org/resources/ar-tonelico-ii-decomp-case/index.md): Case study · Ar tonelico II decomp reconstructs C source for the Japanese PS2 release SLPS_258.19 and checks compiled functions against the retail binary byte by byte. The author reports 4,800 of 10,923 functions matched as of 2026-10-27; the build uses the original EE compiler toolchain.
- [Virtua Fighter 3 Recomp: native port of the Model 3 arcade game](https://awesomerea.org/resources/virtua-fighter-3-recomp-case/index.md): Case study · Virtua Fighter 3 Recomp runs the arcade game's PowerPC program as native ARM64 or x86-64 code translated from the user's ROM at startup. Its own runtime models the Sega Model 3 board, tile generator, and Real3D graphics, with native rendering and input on desktop systems.
- [Pokémon XD: Gale of Darkness: a matching GameCube decompilation](https://awesomerea.org/resources/pokemon-xd-gale-of-darkness-decomp-case/index.md): Case study · Reconstructs Pokémon XD: Gale of Darkness for GameCube as C/C++ source targeting a byte-identical retail build. Functions count as matched when objdiff finds identical machine code, and builds are checked against the retail DOL SHA-1. The author reports a local snapshot of 50.01% matched US code and 21.35% matched data.
- [Juiced 2 Recompiled: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/juiced-2-recompiled-case/index.md): Case study · Juiced 2 Recompiled builds a native Windows port of the Xbox 360 Juiced 2: Hot Import Nights by statically translating the user's executable with ReXGlue. It supplies a game-specific function fix list, SDK patches for code generation, texture layout and music, and a launcher with a heap workaround. The author reports that the preview boots, plays through Career league 7 and saves, while graphics and performance faults remain.
- [WipEout Omega Collection: a native PS4 game port for PC](https://awesomerea.org/resources/wipeout-omega-collection-pc-case/index.md): Case study · wipeout_pc runs WipEout Omega Collection's original PS4 x86-64 code on PC with a replacement system runtime and shadPS4-derived Vulkan graphics core. It documents executable preparation, import mapping and game profiles by title ID; one executable runs WipEout HD, Fury and 2048 using files from the user's own PS4 dump.
- [LSD: Dream Emulator: partial PS1 decompilation and mechanics research](https://awesomerea.org/resources/lsddecomp-case/index.md): Case study · lsddecomp is an early decompilation of selected code from the PlayStation game LSD: Dream Emulator, with research on its dream timer. Its workflow extracts game data from the user's SLPS_015.56 file, rebuilds the executable and compares the result; the author describes the decompilation as assumption-heavy.
- [Super Mario RPG: an SNES disassembly assembled with extracted assets](https://awesomerea.org/resources/super-mario-rpg-disassembly-case/index.md): Case study · Super Mario RPG reconstructs the SNES game's code as assembly with ROM maps and supporting scripts. The framework extracts assets from a user-supplied ROM, then assembles the game with Asar; its build script lists US and Japanese ROM options.
- [SpartanPort: a native PC port of God of War III Remastered](https://awesomerea.org/resources/spartanport-case/index.md): Case study · SpartanPort ports the PS4 release of God of War III Remastered to Windows and Linux using the player's own game dump. It runs the game's x86-64 code through a native runtime, uses Vulkan graphics components and includes a loader that rewrites selected instructions for CPUs lacking MOVBE, BMI1 or LZCNT.
- [LEGOLAND, portable: a cross-platform port from matching decompiled source](https://awesomerea.org/resources/legoland-port-case/index.md): Case study · LEGOLAND, portable turns a matching decompilation of the 1999 game into builds for Windows, Linux, Android and browsers. It adds program startup code, replaces the game's assembly routines with C, and substitutes Windows graphics, input, audio and other APIs with SDL3 and supporting libraries. Installation reads game data from the user's CD or disc image.
- [Shadow of the Colossus — native Windows port of the PS4 game](https://awesomerea.org/resources/shadow-of-the-colossus-oussama-pc-case/index.md): Case study · Shadow of the Colossus runs the PS4 game's x86-64 code directly on Windows 10/11 while translating its graphics to Vulkan. This port supports the named EU 1.01 and US 1.00 releases, loads a user-provided game dump, and implements the system functions the game needs.
- [Burnout 2: a matching PlayStation 2 decompilation](https://awesomerea.org/resources/burnout-2-decomp-case/index.md): Case study · Burnout 2 reconstructs the PlayStation 2 game from an August 2002 debug build into C and C++ for a byte-matching CodeWarrior build. The repository includes compiler-behavior probes and models for matching generated instructions. The author reports full implementation of the beta and about 70% matching; retail builds remain future work.
- [The Simpsons Game — Android Evolved: an ARM64 recompilation port](https://awesomerea.org/resources/the-simpsons-game-android-recomp-case/index.md): Case study · The Simpsons Game — Android Evolved ports statically recompiled Xbox 360 game code to Android ARM64 using ReXGlue, SDL3 and Vulkan 1.1. It adds Android launcher and touch controls, renderer adjustments and diagnostic tools. The author reports reaching the title screen and animated introduction on a Galaxy S25 Ultra.
- [GD's Melee: a PC port of Super Smash Bros. Melee's matching decompilation](https://awesomerea.org/resources/gds-melee-case/index.md): Case study · GD's Melee builds a native Windows and Linux port of Super Smash Bros. Melee NTSC 1.02 from the game's matching decompilation. It adds native rendering, rollback online play, m-ex mod support and Lua scripting while loading game data from the user's disc.
- [UA_source: a reimplementation of the Urban Assault engine](https://awesomerea.org/resources/ua-source-case/index.md): Case study · UA_source reimplements the Urban Assault engine in C++ and plays using files from the user's original game copy. It documents Linux and Windows builds with SDL2, OpenGL, OpenAL and other media libraries, and exposes options for rendering and original game behavior.
- [New Super Mario Bros. U: a native Wii U recompilation](https://awesomerea.org/resources/nsmbu-recomp-case/index.md): Case study · nsmbu-recomp builds a native New Super Mario Bros. U program from a user's Wii U game copy through its installer and runtime. It supports Windows, macOS, Linux, Android and iOS, with course and world-map save states and up to four controllers. The project documents supported USA and European revisions and experimental wider display and higher frame rates.
- [OpenNFS: rebuilding classic Need for Speed games](https://awesomerea.org/resources/opennfs-classic-nfs-case/index.md): Case study · OpenNFS is an early C++ engine project that aims to recreate Need for Speed 1–5 using original game data. It has loaders for tracks, cars, images and music from selected PC and PlayStation releases, Bullet-based vehicle dynamics and shaders for dynamic lighting and shadows; loader coverage and gameplay remain incomplete.
- [Sonic CD 2011: an RSDKv3 Dreamcast port](https://awesomerea.org/resources/sonic-cd-dreamcast-port-case/index.md): Case study · Sonic CD 2011 for SEGA Dreamcast ports the reconstructed RSDKv3 engine to Dreamcast with platform-specific graphics, audio, input, saving and video code. It converts selected audio assets from a user-provided mobile Data.rsdk while leaving other game data in the archive.
- [Wind Waker HD Recompiled for Android — Plus: an Android static recompilation port](https://awesomerea.org/resources/wind-waker-hd-android-plus-case/index.md): Case study · Wind Waker HD Recompiled for Android — Plus runs The Legend of Zelda: The Wind Waker HD on ARM64 Android through static recompilation of Wii U PowerPC code and Vulkan rendering. This fork adds Brazilian Portuguese translation, a HUD editor, .wua archive input and controller improvements; the app extracts and builds from a user-provided game dump.
- [OpenRedFaction: reconstructing Red Faction for PC and Original Xbox](https://awesomerea.org/resources/open-red-faction-case/index.md): Case study · OpenRedFaction reconstructs Red Faction game behavior in a shared C and C++ runtime targeting PC and a stock 64 MiB Original Xbox. It examines the installed PC executable and game archives, implements campaign systems, and compares focused PC and XEMU diagnostics.
- [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.
- [Swordigo Vita: an Android executable port to PS Vita](https://awesomerea.org/resources/swordigo-vita-case/index.md): Case study · Swordigo Vita runs the Android ARMv7 build of Swordigo on PS Vita by loading its executable, resolving imports with native functions and applying patches. Users provide the Android APK and extract the required executable and assets.
- [Dr. Mario: a hash-checked NES disassembly](https://awesomerea.org/resources/dr-mario-nes-disassembly-case/index.md): Case study · Dr. Mario reconstructs the NES game's original NTSC and revision A releases as ca65 6502 assembly. The build extracts art from the user's original ROM, assembles both variants, and compares their MD5 hashes with expected outputs.
- [sundog: reconstructing SunDog's p-system runtime](https://awesomerea.org/resources/sundog-frozen-legacy-case/index.md): Case study · sundog ports the Atari ST game SunDog: Frozen Legacy to modern platforms by implementing its UCSD Pascal p-system interpreter in C. It runs the original p-code from the player's disk image, reimplements graphics assembly routines and uses SDL2 and OpenGL ES for host input and display.
- [Calico: Atari Jaguar DOOM port with renderer reverse engineering](https://awesomerea.org/resources/calico-doom-case/index.md): Case study · Calico ports Atari Jaguar DOOM to PC while retaining the original game's behavior where possible. The author reverse engineered Jaguar-specific renderer assembly and cross-referenced gameplay assembly with related C sources; the port loads a user-supplied ROM or extracted jagdoom.wad.
- [Mario Sports Mix: an early Wii decompilation](https://awesomerea.org/resources/mario-sports-mix-decomp-case/index.md): Case study · MSM-decomp begins a source reconstruction of Mario Sports Mix for the European RMKP01 Wii release. It provides game-specific configuration, one C++ game source file, build scripts and an objdiff workflow driven by the user's disc image.
- [Mario Superstar Baseball: work-in-progress GameCube decompilation](https://awesomerea.org/resources/mssb-decomp-case/index.md): Case study · Mario Superstar Baseball reconstructs source for the US GameCube release GYQE01. Its workflow extracts main.dol and aaaa.dat from the user's game, decompresses REL modules, configures a ninja build, and compares compiled objects with objdiff. The project describes itself as unfinished.
- [OpenMC2: incrementally rewriting Midnight Club 2](https://awesomerea.org/resources/openmc2-case/index.md): Case study · OpenMC2 incrementally rewrites Midnight Club 2 while calling the installed game's original binary for functions it has yet to replace. Its Windows source and hooks support a partial reconstruction that runs alongside the original executable; development is abandoned.
- [ddg-recomp: a static recompilation of Densha de GO! FINAL](https://awesomerea.org/resources/ddg-recomp-case/index.md): Case study · ddg-recomp builds native ports of the PC game Densha de GO! FINAL by translating x86 functions from the user's perfect.exe into C. Replacement SDL3 code supplies Windows and Direct3D 8 services across desktop and ARM handheld targets. The author reports playable driving but lists missing movies and untranslated library paths.
- [Bomberman Hero: Recompiled: an N64 static recompilation](https://awesomerea.org/resources/bmhero-recompiled-case/index.md): Case study · Bomberman Hero: Recompiled uses N64Recomp to translate the North American Nintendo 64 game into a native port rendered through RT64. It loads assets from the user's ROM and adds game-specific patches, display options and mod support.
- [ReMoM: reconstructing Master of Magic from its executables](https://awesomerea.org/resources/remom-master-of-magic-case/index.md): Case study · ReMoM reconstructs Master of Magic from its original executables by disassembling and translating game code to C. Its engine builds for modern platforms and loads LBX resources and CONFIG.MOM from the user's original version 1.31 copy.
- [Wave Race 64: Recompiled — an early N64 static recompilation](https://awesomerea.org/resources/chronic-wave-race-64-recomp-case/index.md): Case study · Wave Race 64: Recompiled applies N64Recomp and RT64 to a native PC port of Wave Race 64. Its build requires the player's USA Rev A ROM; the author reports that the current result boots only to two boxes of noise.
- [Piglet's Big Game: a GameCube decompilation](https://awesomerea.org/resources/piglets-big-game-decomp-case/index.md): Case study · Piglet's Big Game reconstructs source for the USA and PAL English GameCube releases of the game. Its build takes the user's disc image, and its objdiff configuration supports comparisons between rebuilt objects and the original.
- [Forza Motorsport 4: a native PC static recompilation](https://awesomerea.org/resources/forza-motorsport-4-native-pc-recompilation-case/index.md): Case study · Forza Motorsport 4 is brought to Windows by translating the Xbox 360 USA Rev 1 game's PowerPC code into C++ with ReXGlue. A project runtime supplies graphics, audio, input and storage services, while a launcher installs data from the player's discs and configures controls; the author reports local menu and race runs.
- [Tekken Tag Tournament 2: a Wii U static-recompilation port](https://awesomerea.org/resources/tekken-tag-2-wii-u-recomp-case/index.md): Case study · The Tekken Tag Tournament 2 port translates the European Wii U v16 PowerPC executable to C++ ahead of time and builds it for Linux x86-64. Its runtime implements Cafe OS services and converts GX2 graphics work to Vulkan; game-specific hooks add display, input and practice features.
- [World of Goo: WiiWare decompilation](https://awesomerea.org/resources/world-of-goo-wiiware-decomp-case/index.md): Case study · World of Goo is an unfinished decompilation of the European WiiWare release WGOP. The repository contains game-specific C++ source and build configuration; its workflow extracts a user-provided WAD, builds with Python and ninja, and compares rebuilt objects with objdiff.
- [Donkey Kong: reconstructing arcade gameplay from descriptions and video](https://awesomerea.org/resources/donkey-kong-arcade-remake-case/index.md): Case study · The Donkey Kong arcade remake recreates the 1981 game's four stages in C++ with Allegro5, using published descriptions of original mechanics and observations from play videos. The author reports that rolling barrels are close to the original while other behaviors and movement timing differ; the repository contains the game logic without its assets.
- [Spyro the Dragon: testing C reconstructions through function hooks](https://awesomerea.org/resources/spyro-the-dragon-function-reconstruction-case/index.md): Case study · Spyro the Dragon reconstructs selected PlayStation game functions as readable C for behavioral comparison. The workflow compares compiled instruction counts, places replacement functions in extra RAM and redirects original entry points to test them in PCSX-Redux.
- [Sega Rally Championship: lifting Model 2A i960 code to a host runtime](https://awesomerea.org/resources/sega-rally-model2-recomp-case/index.md): Case study · The Sega Rally Championship project compiles lifted i960 code from the Model 2A arcade game into a host executable. It pairs game and library C with a portable Model 2 runtime, disassembly artifacts and ROM extraction scripts. On first run, the host extracts the required data from user-supplied board dumps and offers cold-boot and practice-start targets.
- [Blackmoor reconstruction project: recovering Nancy Drew: Curse of Blackmoor Manor](https://awesomerea.org/resources/blackmoor-reconstruction-case/index.md): Case study · Blackmoor reconstruction project recovers the x86 GAME.EXE of Nancy Drew: Curse of Blackmoor Manor and develops a native ARM64 macOS port. It records function boundaries, assembly recovery and binary findings, and the author reports a source build matching the original executable's SHA-256. The native port remains incomplete and unplayable.
- [Armored Core Recomp: a PlayStation static-recompilation recipe](https://awesomerea.org/resources/armored-core-recomp-case/index.md): Case study · Armored Core Recomp supplies a PSXRecomp project for the USA PlayStation release of Armored Core. Its title configuration records executable layout, disc fingerprints and seed addresses, and the build generates game code locally from the user's disc.
- [Astral Chain PC: a Switch static-recompilation port](https://awesomerea.org/resources/astral-chain-pc-case/index.md): Case study · Astral Chain PC translates the Switch game's ARM64 code to C for a native Windows x64 build. Its host runtime supplies Switch services, while a modified NVN layer maps graphics to Vulkan; the build extracts and translates files from the player's own game dump.
- [Fukami: a Ridge Racer V static-recompilation port](https://awesomerea.org/resources/fukami-ridge-racer-v-case/index.md): Case study · Fukami builds native Windows, Apple silicon macOS and Steam Deck versions of Ridge Racer V by translating its PS2 MIPS code to C++ ahead of time. Its runtime models PS2 timing and services, recompiles VU microcode and integrates a PCSX2-derived GS renderer, using the player's own disc image.
- [WWE 2K14 PC Recomp: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/wwe-2k14-pc-recomp-case/index.md): Case study · WWE 2K14 PC Recomp builds a Windows port of the Xbox 360 game through the ReXGlue static recompilation SDK. It reads the user's ISO or extracted game folder and includes game-specific patches and a launcher for graphics, controls, languages, DLC, and mods.
- [Knack for PC: running the PS4 game with a replacement runtime](https://awesomerea.org/resources/knack-pc-case/index.md): Case study · Knack for PC ports the PlayStation 4 game Knack to Windows and Linux by running its original x86-64 code with replacement PS4 system libraries and a Vulkan graphics core. The Knack-specific work covers imported system functions, fixed-address memory, NGS2 audio layouts, and graphics translation. The author reports that the first chapters play from start to end; later chapters remain untested.
- [Wii Play: a Rev 1 Wii decompilation with objdiff comparison](https://awesomerea.org/resources/wii-play-rhae-case/index.md): Case study · Wii Play reconstructs C and C++ source for the Wii game's USA Rev 1 release. Its build takes a local disc image, and its objdiff configuration lets contributors compare rebuilt objects while source and symbol files change.
- [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.
- [Black: an Xbox static recompilation for Apple Silicon macOS](https://awesomerea.org/resources/black-macos-recomp-case/index.md): Case study · black-recomp ports the Xbox game Black to Apple Silicon macOS by statically lifting its x86 functions to C and compiling them for arm64. It supplies game-specific host code, handwritten guest functions, analysis seeds and reproduction scripts, while a sibling xboxrecomp runtime provides Xbox kernel, graphics and audio services. The author reports first-mission interaction with unresolved boot instability, camera drift and silent game audio.
- [devilution-nx: a Nintendo Switch port of reconstructed Diablo](https://awesomerea.org/resources/devilution-nx-case/index.md): Case study · devilution-nx ports the DevilutionX reconstruction of Diablo to Nintendo Switch. It provides Joy-Con and touch controls, Switch homebrew builds and instructions for loading DIABDAT.MPQ from the player's original Diablo disc or GOG copy. Its documentation traces the underlying reconstruction to IDA analysis and recovered C code.
- [Super Mario Bros Remastered: Godot recreations of four Mario games](https://awesomerea.org/resources/super-mario-bros-remastered-case/index.md): Case study · Super Mario Bros Remastered recreates four Super Mario Bros. games in Godot, with revised physics, new levels and characters, and a custom level editor. Players supply an original SMB1 NES ROM; the project provides the Godot game source.
- [MultiBootSystem: decompiling the Ocarina of Time Master Quest menu](https://awesomerea.org/resources/multibootsystem-master-quest-menu-case/index.md): Case study · MultiBootSystem reconstructs source for the main menu of the Zelda: Ocarina of Time Master Quest GameCube disc. Its build uses the user's extracted main.dol, Python and ninja, with objdiff configuration for comparing rebuilt objects.
- [opensims2: reconstructing The Sims 2 engine](https://awesomerea.org/resources/opensims2-engine-case/index.md): Case study · opensims2 reimplements The Sims 2 engine in C++ for 64-bit macOS and Windows, reading content from the user's own game installation. The repository includes DBPF and game-data analysis, executable findings, gameplay systems and command-line inspection tools.
- [raw(gl): Another World engine reimplementation](https://awesomerea.org/resources/rawgl-another-world-case/index.md): Case study · raw(gl) reimplements the Another World engine while reading data from the original game. Its interpreter supports Amiga, Atari, DOS, Windows 3.1, 3DO and anniversary releases; accompanying notes describe virtual-machine bytecode and platform-specific resource formats.
- [inFAMOUS First Light: rehosting the PS4 game on Windows](https://awesomerea.org/resources/infamous-first-light-pc-case/index.md): Case study · inFAMOUS First Light is rehosted on Windows by running the PlayStation 4 game's x86-64 code directly on the PC processor. A replacement PS4 runtime supplies system-library functions, and a Vulkan renderer handles graphics; the player supplies the original game dump.
- [OpenLRR: incrementally rebuilding LEGO Rock Raiders](https://awesomerea.org/resources/openlrr-rock-raiders-case/index.md): Case study · OpenLRR incrementally rebuilds the PC game LEGO Rock Raiders by implementing and replacing game and engine functions. Unreplaced behavior continues to use the user’s original executable and game assets. Its MakeExe tool adds an import for openlrr.dll and redirects the original entry point to the replacement code.
- [PanzerMortyr: a Mortyr 2093-1944 engine reimplementation](https://awesomerea.org/resources/panzermortyr-case/index.md): Case study · PanzerMortyr reimplements the Mortyr 2093-1944 engine as a replacement executable that loads original game data. The author reports reverse engineering archive, map and model formats and recreating observed enemy behavior, movement physics and game balance. Written mostly in Ü, it supports Windows and GNU/Linux; game data can come from an installation or a CD image.
- [Boktai 3: matching GBA decompilation and script analysis](https://awesomerea.org/resources/boktai-3-case/index.md): Case study · Boktai 3 reconstructs Shin Bokura no Taiyou: Gyakushuu no Sabata as C that the author reports rebuilds the GBA ROM byte for byte. It also decodes the game's GCL scene scripts, text, sprites and maps, and provides a local studio for inspecting their links to game code.
- [Mario Paint Recomp: a static recompilation of Mario Paint](https://awesomerea.org/resources/mario-paint-recomp-case/index.md): Case study · Mario Paint Recomp ports the SNES game Mario Paint to PC by translating 65816 routines into C while snesrecomp supplies SNES hardware behavior and interpreter fallback. Its headless tour and conformance tool compare selected routines with the original ROM; the author reports 57 of 103 hand-ported routines reached by the tour pass the checks.
- [Vagrant Story Native: a Windows source port of the PlayStation game](https://awesomerea.org/resources/vagrant-story-native-case/index.md): Case study · Vagrant Story Native ports the PlayStation release of Vagrant Story to Windows x64 in C++. It adapts prior decompilation work into native game systems, converts data from the user's disc, and documents remaining engine and content gaps.
- [pokegold-ko: Korean Pokémon Gold and Silver disassembly](https://awesomerea.org/resources/pokegold-ko-case/index.md): Case study · pokegold-ko is an incomplete disassembly of the Korean Pokémon Gold and Silver releases for Game Boy Color. The repository includes assembly banks and utilities, while the author states that further disassembly and labeling are required before it can rebuild either ROM.
- [Rayman Arena: an early Frida-assisted reconstruction](https://awesomerea.org/resources/rayman-arena-decomp-case/index.md): Case study · Rayman Arena is an early C++ reconstruction of routines from the PC game, with a Frida patch that replaces game routines. Its documented workflow calls for decompiling with Ghidra, cleaning up the output with Clang tools, and editing it by hand.
- [Ratchet & Clank: Size Matters — scoped PS2 matching decompilation](https://awesomerea.org/resources/ratchet-clank-size-matters-decomp-case/index.md): Case study · Ratchet & Clank: Size Matters decomp reconstructs source for US and European PS2 boot executables and level modules against retail bytes. The project separates authored C matches from assembly baselines and records accepted placements and compiler evidence for bounded portions of the game.
- [SUPERCOPTER: decompiled MS-DOS Pascal source](https://awesomerea.org/resources/supercopter-decompiled-case/index.md): Case study · SUPERCOPTER is a decompiled source reconstruction of the MS-DOS game in Turbo Pascal. The repository contains Pascal source, a reference source file and an include file. The author identifies Turbo Pascal 3.01A and Borland's Graph library as the original build environment.
- [OpenTTD: recreating Transport Tycoon Deluxe](https://awesomerea.org/resources/openttd-case/index.md): Case study · OpenTTD recreates Transport Tycoon Deluxe as an open-source transport simulation game, aiming to mimic the original while adding features. It runs with free OpenGFX, OpenSFX and OpenMSX data sets, or with graphics, sound and music files copied from the user's original game.
- [Test Drive Enhanced: an SDL3 port of the 1987 game](https://awesomerea.org/resources/test-drive-enhanced-case/index.md): Case study · Test Drive Enhanced ports the 1987 DOS game to SDL3 using the author's C reimplementation of its driving simulation and game flow. Its engine notes link that implementation to reverse-engineering specifications and disassembly of TDEGA.EXE; this version adds higher-resolution road rendering and optional elements from the Amiga release.
- [Tony Hawk's Pro Skater Recompiled: a PlayStation setup project](https://awesomerea.org/resources/tony-hawks-pro-skater-recompiled-case/index.md): Case study · Tony Hawk's Pro Skater Recompiled supplies a PSXRecomp configuration and recomp-ui flow for generating a native build from the user's PlayStation disc. The project contains title symbols, function seeds and build scripts. Its Windows, Linux and macOS setup packages are described as candidates pending package checks.
- [khdays-vita: a PS Vita port of Kingdom Hearts 358/2 Days](https://awesomerea.org/resources/khdays-vita-case/index.md): Case study · khdays-vita compiles the Kingdom Hearts 358/2 Days decompilation into a native PS Vita program. Its platform layer replaces Nintendo DS graphics, audio, card and touch-screen behavior using VitaSDK and vitaGL, while loading game data from the user's European cartridge dump.
- [guzzler-disasm: a commented game disassembly](https://awesomerea.org/resources/guzzler-disasm-case/index.md): Case study · guzzler-disasm documents a game through dissected, commented assembly and hardware, RAM and graphics definitions. Its Makefile builds a ROM from the disassembly, while a comparison script checks the result against the original. A planned web view for screens and sprites is marked TODO.
- [dw3-decomp-expanded: matching Digimon World 2003 card-game functions](https://awesomerea.org/resources/dw3-decomp-expanded-case/index.md): Case study · dw3-decomp-expanded reconstructs Digimon World 2003 PAL card-game overlay functions as C that compiles to the original MIPS bytes. Each source file records compiler, address and comparison settings, and tools compare it with overlays from the user's disc. The author reports 407 matched functions across CARDGAME, STCRDABM, STCRDDEK and STCRDSHP, with 28 still pending.
- [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.
- [sena-rs: reimplementing SoftPAL for Koikake](https://awesomerea.org/resources/sena-rs-case/index.md): Case study · sena-rs reimplements the SoftPAL engine in Rust for Koikake, with a PAL virtual machine, asset handling, script disassembly and decompiler components. It runs from an external game installation and provides builds for desktop, mobile, WebAssembly and experimental console targets. The author states that console hardware execution has not been tested.
- [Proving Ground Recompiled: a native Tony Hawk's Proving Ground port](https://awesomerea.org/resources/proving-ground-recompiled-case/index.md): Case study · Proving Ground Recompiled builds a native PC port of Tony Hawk's Proving Ground from its Xbox 360 PowerPC executable. ReXGlue translates game code to C++ ahead of time, while a project runtime renders through Vulkan and adds frame pacing, display, and launcher controls. The author reports playable Windows gameplay; Linux gameplay remains untested.
- [Ms. Pac-Man: Tengen NES disassembly](https://awesomerea.org/resources/ms-pac-man-tengen-disassembly-case/index.md): Case study · Ms. Pac-Man records an assembly disassembly of the 1990 Tengen NES release, with source files for game data, maze layouts, sounds, and routines. The build uses CC65; graphics must be extracted from the user's ROM.
- [Major Havoc: an arcade game disassembly](https://awesomerea.org/resources/major-havoc-disassembly-case/index.md): Case study · major-havoc-dasm publishes a disassembly of Major Havoc across assembly files for the game's alpha, gamma, and vector ROM components.
- [Castlevania III: a PRG ROM disassembly with extraction tools](https://awesomerea.org/resources/castlevania-iii-disassembly-case/index.md): Case study · The Castlevania III disassembly organizes the NES game's PRG code and data as assembly source, with scripts for data extraction and tilemap generation. Its build links the reconstructed PRG content with a user-supplied original CHR ROM.
- [Motocross Madness 2: VC6-matched C++ reconstruction](https://awesomerea.org/resources/motocross-madness-2-decomp-case/index.md): Case study · Motocross Madness 2 decomp reconstructs readable C++ for selected functions and classes in the retail x86 game. It compiles candidates with VC6 SP3 and compares their resolved machine code with retail bytes; the full source build still lacks providers needed to link a playable game.
- [Rayman Origins Recompiled: translating the Xbox 360 game for desktop and Android](https://awesomerea.org/resources/rayman-origins-recompiled-case/index.md): Case study · Rayman Origins Recompiled translates the Xbox 360 game's PowerPC executable to native C++ for desktop and Android. A game-specific detector recovers jump tables missed by XenonAnalyse, while host code supplies Xbox 360 services and a Vulkan renderer draws frames with translated shaders. The author reports gameplay with audio and controls on Apple Silicon macOS and Android.
- [The Force Engine: rebuilding the Jedi Engine for Dark Forces](https://awesomerea.org/resources/the-force-engine-case/index.md): Case study · The Force Engine rebuilds the Jedi Engine to run Star Wars: Dark Forces on modern systems using the user's original game copy. Its source includes game and engine code derived from analysis of the original executables, alongside a software renderer, GPU renderer, mod loader, and level editor. Outlaws support is planned but is not yet playable.
- [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.
- [Cosmo-Engine: a replacement engine for Cosmo's Cosmic Adventure](https://awesomerea.org/resources/cosmo-engine-cosmic-adventure-case/index.md): Case study · Cosmo-Engine supplies a C engine for playing Cosmo's Cosmic Adventure using a copy of the original game. Its source includes game, actor, map, file, video and audio components, with CMake builds using SDL2 and SDL_mixer.
- [Comix Zone XBLA: Xbox 360 binary analysis and static recompilation](https://awesomerea.org/resources/comix-zone-xbla-recompiled-case/index.md): Case study · Comix Zone XBLA analyzes the Xbox 360 release's XEX2 binary and reports translating its PowerPC code to C++ with XenonRecomp. The investigation maps PE sections, imports and an embedded Genesis emulator with 68K, Z80, YM2612 and video components. Function-boundary fixes and ReXGlue runtime implementation remain pending.
- [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.
- [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.
- [Verdite2: a RecompOne port of King's Field](https://awesomerea.org/resources/verdite2-kings-field-case/index.md): Case study · Verdite2 ports the North American PlayStation release of King's Field, SLUS-00158, to PC with RecompOne static recompilation. It contains function maps, runtime patches and documentation for the game's executable and disc handling. The project adds widescreen display, modern controls and rendering changes, and reports playability from start to finish.
- [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.
- [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.
- [Tekken 6 Native Online: recompilation with rollback netplay](https://awesomerea.org/resources/tekken-6-native-online-case/index.md): Case study · Tekken 6 Native Online builds a PC port from the user's Xbox 360 Tekken 6 disc by translating Default.xex to C++ with ReXGlue. Its game-side code adds rollback snapshots, input handling and determinism work, while a Qt launcher manages builds and matchmaking.
- [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.
- [Jet Force Gemini Recomp: a native Windows recompilation](https://awesomerea.org/resources/jet-force-gemini-recomp-case/index.md): Case study · Jet Force Gemini Recomp provides a native Windows x64 recompilation of the Nintendo 64 game that loads game data from an imported North American ROM. It includes a rendering, audio and save runtime, a launcher and optional modern controls. The author reports a campaign verification run using testing mods and a prepared save; console accuracy remains under validation.