---
title: "Curated reverse engineering resources · Page 20"
url: https://awesomerea.org/resources/page/20/
updated: 2026-11-10
type: page
---

# Curated reverse engineering resources · Page 20

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

## Games (100)

- [hi-octane202x: reconstructing Hi-Octane and its level editor](https://awesomerea.org/resources/hi-octane202x-case/index.md): Case study · hi-octane202x is a C++ reconstruction of Bullfrog's Hi-Octane that uses data extracted from the user's original game files. It implements vehicle physics, weapons and HUD elements, with basic computer-driver steering and attacks. Its level editor can change textures, terrain heights, columns and map entities.
- [Burnout Revenge: statically recompiling the Xbox 360 game](https://awesomerea.org/resources/burnout-revenge-recomp-case/index.md): Case study · The Burnout Revenge port recompiles the USA Xbox 360 game for native macOS and Linux execution with XenonRecomp and a project runtime. It installs game content from the player's disc image and adds PC display, control and save options.
- [Back to Skool: a SkoolKit ZX Spectrum disassembly](https://awesomerea.org/resources/back-to-skool-disassembly-case/index.md): Case study · The Back to Skool project publishes a SkoolKit disassembly of the ZX Spectrum game. It provides decimal and hexadecimal browsing builds and can export assembly source from the SkoolKit file.
- [Carpocalypse 2: a Carmageddon 2 decompilation and native port](https://awesomerea.org/resources/carpocalypse2-case/index.md): Case study · Carpocalypse 2 decompiles Carmageddon 2 and builds native Linux and Android versions using data from the player's original installation. Its build offers a period MSVC matching path and a modern toolchain path, with SDL3 graphics support and documented remaining work.
- [Bomberman Land Touch 2: a Nintendo DS matching decompilation](https://awesomerea.org/resources/bomberman-land-touch-2-decomp-case/index.md): Case study · Bomberman Land Touch 2 reconstructs code for the Nintendo DS game and builds against a user-supplied USA ROM. Its symbol maps, source files and build process support byte comparison with the original; a matching build also requires an ARM7 BIOS image.
- [Crash Team Racing: High Octane: a Vita, PC and browser source port](https://awesomerea.org/resources/crash-team-racing-high-octane-case/index.md): Case study · Crash Team Racing: High Octane ports the ctr-native Crash Team Racing code to PlayStation Vita, Windows and web browsers. It adds widescreen rendering, higher frame rates, post-processing, replay controls and platform-specific multiplayer features while reading game data from the player's US PlayStation disc dump.
- [Blast Corps: matching N64 decompilation and native port](https://awesomerea.org/resources/doridian-blast-corps-case/index.md): Case study · Blast Corps reconstructs four N64 releases as matching source and builds a native port from that code for Linux, Windows, macOS and WebAssembly. The port reads the user's ROM for game data; the author reports byte-for-byte ROM rebuilds and a full tool-assisted-run replay.
- [Mario Golf: a Game Boy Color disassembly](https://awesomerea.org/resources/mgolf-disassembly-case/index.md): Case study · mgolf provides an assembly disassembly of Mario Golf for Game Boy Color. Its build workflow uses RGBDS and make or redo to produce the USA ROM and debug symbols; the repository includes bank-level assembly and a ROM SHA-1 target.
- [TA: Byte Tactics — matching decompilation of Total Annihilation](https://awesomerea.org/resources/ta-byte-tactics-case/index.md): Case study · TA: Byte Tactics reconstructs Total Annihilation v3.1 functions as C++ compiled with Visual C++ 5.0 SP3. Its checker compares each compiled function with TotalA.exe while accounting for linker-filled bytes; the author reports 1,973 byte-matched functions.
- [Death Road to Canada Lite: porting the Android game to PS Vita](https://awesomerea.org/resources/death-road-to-canada-lite-case/index.md): Case study · Death Road to Canada Lite runs the Android game on PS Vita through a native loader that resolves imports and patches its ARMv7 executable in memory. Setup uses libmain.so and assets extracted from the player's APK, together with a bundled mod that simplifies maps for Vita play.
- [Banjo-Tooie (XBLA): a ReXGlue PC port](https://awesomerea.org/resources/banjo-tooie-xbla-recomp-case/index.md): Case study · The Banjo-Tooie XBLA port uses ReXGlue to translate the Xbox 360 game's PowerPC code into C++ for Windows and Linux. It supplies game-specific recompilation settings, a host harness and a launcher that extracts data from the user's XBLA package. The author reports gameplay on Windows and Steam Deck, while later areas remain lightly tested.
- [ReFreedomFighters: reconstructing Freedom Fighters formats and functions](https://awesomerea.org/resources/refreedomfighters-case/index.md): Case study · ReFreedomFighters reconstructs Freedom Fighters file formats and PC executable functions, with Python decoders for audio, textures, scripts, scenes, and navigation data. It also supplies C++ function ports and game-specific RE helpers. The author reports 12,703 published ports tested against the original, while documenting checker gaps and pending rechecks.
- [Blitz_MasterVer22-Decomp: a Splatoon 2 version 3.1.0 decompilation](https://awesomerea.org/resources/splatoon-2-310-decomp-case/index.md): Case study · Blitz_MasterVer22-Decomp reconstructs code from Splatoon 2 version 3.1.0 for Nintendo Switch. Its setup reads the user's main NSO executable, prepares a Clang 4.0.1 build and offers a difference checker for the decompiled code.
- [acnlwa-decomp: an Animal Crossing: New Leaf decompilation](https://awesomerea.org/resources/acnlwa-decomp-case/index.md): Case study · acnlwa-decomp is an in-progress C and C++ reconstruction of Animal Crossing: New Leaf. Its provenance notes track symbol names from ARM ELF mapping symbols, RTTI, Ghidra labels and manual code analysis, distinguishing provisional names from lasting ones.
- [FuseRecomp: a native static recompilation of FUSE](https://awesomerea.org/resources/fuse-recomp-case/index.md): Case study · FuseRecomp statically recompiles the Xbox 360 game FUSE to native x86-64 for Windows and Linux using ReXGlue. Game-specific hooks and patches run with the user's extracted disc files, while configuration covers graphics, input and local split-screen play.
- [VeryFat Dungeon: a Wii Fit Plus decompilation](https://awesomerea.org/resources/veryfat-dungeon-wii-fit-plus-case/index.md): Case study · VeryFat Dungeon is a work-in-progress decompilation of Wii Fit Plus for the USA Rev 0 Wii release. It holds C and C++ reconstruction sources, symbols and split configuration. A build made from the user's disc image produces objects that can be compared with the original using objdiff.
- [2014 FIFA World Cup Brazil: a ReXGlue Windows recompilation](https://awesomerea.org/resources/fifa-world-cup-2014-recompiled-case/index.md): Case study · 2014 FIFA World Cup Brazil Recompiled translates the Xbox 360 game code to C++ with ReXGlue and builds a native Windows port. A launcher selects and checks the user’s disc image or game folder; the repository contains game fixes, SDK patches and build instructions while generating translated code locally.
- [PaxDino: a Turok: Rage Wars static recompilation](https://awesomerea.org/resources/paxdino-turok-rage-wars-case/index.md): Case study · PaxDino statically recompiles the Nintendo 64 game Turok: Rage Wars with N64Recomp for a native PC port on N64ModernRuntime and RT64. Its own analysis, hooks and library patches support widescreen rendering, modern controls, local multiplayer and netplay.
- [Street Fighter III 2nd Impact: a matching CPS3 program decompilation](https://awesomerea.org/resources/sfiii2-cps3-decomp-case/index.md): Case study · Street Fighter III 2nd Impact reconstructs the CPS3 arcade program as C and SH-2 assembly. The build uses the Hitachi SHC toolchain, reads graphics pattern tables from the user's ROM set, checks the linked program against the arcade program's SHA-1, and compares rebuilt SIMM chips with the supplied ROM chips. The byte-match figures are the author's report.
- [Shin Megami Tensei III: Nocturne: matching PS2 decompilation](https://awesomerea.org/resources/smt3-nocturne-decomp-case/index.md): Case study · Shin Megami Tensei III: Nocturne reconstructs readable C source for the US PlayStation 2 release and checks the linked executable against the retail SHA-1. Its build also assembles annotated VU microcode and retains assembly for unfinished functions. The author reports that a dated snapshot recovered 66.32% of game-code bytes from C.
- [RatchetPort: a PS4 Ratchet & Clank runtime for Windows](https://awesomerea.org/resources/ratchetport-case/index.md): Case study · RatchetPort runs the PS4 version of Ratchet & Clank (2016), CUSA01047 USA v1.00, through a native Windows runtime derived from SpartanPort with shadPS4 rendering components. Its game-specific research identifies executable sites for timing, motion blur and resolution work. The author reports 30 FPS gameplay on one RTX 5070 Laptop configuration, while compatibility and long-session stability remain unresolved.
- [doukutsu-rs: a Rust reimplementation of the Cave Story engine](https://awesomerea.org/resources/doukutsu-rs-case/index.md): Case study · doukutsu-rs reimplements the Cave Story engine in Rust and runs on separately supplied game data. It supports the original freeware release, Cave Story+ and Nintendo Switch data, with additional controls and platform ports.
- [Sonic the Fighters: an i960 program ROM disassembly](https://awesomerea.org/resources/sonic-the-fighters-disassembly-case/index.md): Case study · stfdisasm reconstructs the i960 program ROM of Sonic the Fighters as assembly source. The build instructions use i960 assemblers and a Python splitter to produce two interleaved ROM files, which the tool can compare against listed MD5 hashes; the author says the build is not yet shiftable.
- [Rampage Recompiled: static ports of two N64 games](https://awesomerea.org/resources/rampage-recompiled-case/index.md): Case study · Rampage Recompiled builds native ports of Rampage: World Tour and Rampage 2: Universal Tour by running N64Recomp on the user's N64 ROMs. Project symbol maps, stubs, and hooks feed generated code into N64ModernRuntime and RT64. The author reports both games boot and play, with controller-pak saves still absent.
- [Chameleon Twist 2: a native port by static recompilation](https://awesomerea.org/resources/chameleon-twist-2-recompiled-case/index.md): Case study · Statically recompiles the Japanese Nintendo 64 release of Chameleon Twist 2 into a native port using N64Recomp and RSPRecomp, with RT64 rendering. The build uses a user-provided ROM and includes menus, input configuration, and graphics options.
- [Forza Horizon 2 Recompiled: an experimental Xbox 360 static recompilation](https://awesomerea.org/resources/forza-horizon-2-recompiled-case/index.md): Case study · Forza Horizon 2 Recompiled uses a vendored ReXGlue SDK to translate the Xbox 360 game's XEX code into C++ for a native Windows build. Game-specific hooks address two boot crashes; the author reports that the current build stalls at the loading screen while waiting on a kernel semaphore.
- [Resident Evil Director's Cut Dual Shock: a matching PlayStation decompilation](https://awesomerea.org/resources/resident-evil-directors-cut-dual-shock-decomp-case/index.md): Case study · Resident Evil Director's Cut Dual Shock reconstructs C source for the US PlayStation game's main program and 12 overlays. The author reports that all 13 program files rebuild to the original bytes with GCC 2.6.3; the repository also documents game logic, RAM use and disc contents.
- [Twilight Princess HD: statically recompiling the Wii U game for macOS](https://awesomerea.org/resources/twilight-princess-hd-recomp-case/index.md): Case study · Twilight Princess HD: Recompiled translates the Wii U game's Zelda.rpx PowerPC code to C and runs it as a native Apple Silicon macOS app. It adapts a Wind Waker HD recompilation runtime with Cafe OS services and Metal graphics to Twilight Princess HD; the author reports title-screen and early Ordon Village play.
- [Egg of Time: a static-recompilation port of Chrono Trigger DS](https://awesomerea.org/resources/egg-of-time-chrono-trigger-ds-case/index.md): Case study · Egg of Time builds a native PC port of Chrono Trigger for Nintendo DS by statically translating its ARM9 code to C. Its pipeline extracts a user-supplied ROM, derives function and relocation data with ds-decomp, and links generated code with a runtime for DS hardware behavior.
- [OpenYR: reconstructing the Yuri's Revenge engine](https://awesomerea.org/resources/openyr-engine-case/index.md): Case study · OpenYR reimplements the engine behavior of Command & Conquer: Yuri's Revenge in C++ from observed gameplay, disassembly research and documentation. Its modules cover game state, combat, AI and audio, with parsers planned or implemented for Mix, INI, SHP and VXL resources.
- [THPS2 Demo Decompilation: a function-matching PlayStation reconstruction](https://awesomerea.org/resources/thps2-demo-decomp-case/index.md): Case study · THPS2 Demo Decompilation publishes recovered C/C++ for the PlayStation Tony Hawk's Pro Skater 2 competition demo. The author reports exact object-code matches for 1,635 of 1,646 functions; the public snapshot can compile-check source units but excludes inputs needed to reproduce the match measurement.
- [Snowboard Kids 2: Recompiled — a native N64 static recompilation](https://awesomerea.org/resources/snowboard-kids-2-recompiled-case/index.md): Case study · Snowboard Kids 2: Recompiled ports the Nintendo 64 game to native systems through N64: Recompiled, using RT64 for rendering. It loads assets from the user's North American ROM and includes game-specific patches, display options, and mod support. Build instructions describe ROM decompression, code generation, and compilation.
- [Cinnamon: porting a GameMaker: Studio runner reconstruction to Nintendo consoles](https://awesomerea.org/resources/cinnamon-gamemaker-runner-case/index.md): Case study · Cinnamon ports the Butterscotch reimplementation of the GameMaker: Studio bytecode runner to Nintendo 3DS, Wii and Wii U. It supports bytecode versions 16 and 17 and includes a 3DS preprocessor that converts a user's data.win textures and audio for the console.
- [Monster Hunter 2 (Dos): matching the PS2 boot executable and overlays](https://awesomerea.org/resources/monster-hunter-2-dos-decomp-case/index.md): Case study · Monster Hunter 2 (Dos) reconstructs the PS2 game's code as C and assembly for its original compiler. The author reports that the boot executable and twelve code overlays rebuild byte for byte, while licensed libraries and game data come from the user's version 1.04 copy. The repository also documents matching methods, function names and data structures.
- [SD Gundam: Dimension War Recompiled: a Virtual Boy static recompilation](https://awesomerea.org/resources/sd-gundam-dimension-war-recompiled-case/index.md): Case study · SD Gundam: Dimension War Recompiled builds a native Windows version of the Japanese Virtual Boy game with vbrecomp and recomp-ui. It generates cartridge code from the user's ROM and includes optional English, color and adaptive widescreen mods plus tools comparing opening-mission state and output against Beetle.
- [Wave Race 64: Recompiled: a native N64 static-recompilation port](https://awesomerea.org/resources/wave-race-64-recompiled-case/index.md): Case study · Wave Race 64: Recompiled builds a native Windows, Linux and macOS port from the player's USA Rev A ROM using N64Recomp. Its code adds widescreen, draw-distance options and an optional water renderer, while technical documents record game internals and rendering investigations.
- [Mega Man 3: an annotated ca65 NES disassembly](https://awesomerea.org/resources/mega-man-3-ca65-disassembly-case/index.md): Case study · Mega Man 3 reconstructs the US NES game as annotated ca65 assembly across its code banks. The repository also documents the frame loop, entity logic, collision, MMC3 bank switching and data table formats. Its build produces a ROM that the author reports matches the original byte for byte.
- [DinoPad: bringing Dinosaur Planet Recompiled to Apple devices](https://awesomerea.org/resources/dinopad-dinosaur-planet-case/index.md): Case study · DinoPad adapts Dinosaur Planet: Recompiled into native macOS, iPhone and iPad applications. Its Apple layer adds ROM import, touch controls, Metal and mobile runtime changes, save handling and lifecycle support around the existing static recompilation; the public base edition includes Prototype Mode.
- [Goof Troop: an SNES disassembly of the USA release](https://awesomerea.org/resources/goof-troop-snes-disassembly-case/index.md): Case study · The Goof Troop SNES disassembly provides assembly source and asset-extraction scripts for the USA release. It uses the author's SNES ROM framework and takes a clean, headerless original ROM for extracting assets needed by the project.
- [Mario & Luigi: Superstar Saga: a matching European GBA decompilation](https://awesomerea.org/resources/mario-luigi-superstar-saga-europe-decomp-case/index.md): Case study · Mario & Luigi: Superstar Saga is a matching decompilation of the European GBA release using C compiled with agbcc. Configuration generates comparison assembly from the user's ROM. Decompiled functions are compared with their original instructions, while undecompiled functions come from generated assembly. The author reports a byte-identical combined ROM build.
- [Toy Story 2: a PC game decompilation with reccmp comparisons](https://awesomerea.org/resources/toy-story-2-pc-decomp-case/index.md): Case study · Toy Story 2's PC decompilation reconstructs game and Nu3D engine code in C++ and builds a 32-bit executable and PDB for instruction comparison with reccmp. A companion utility decodes the game's RAW packet format and can export packets or selected actor records.
- [Pokémon FireRed: an early GBA disassembly](https://awesomerea.org/resources/cosarara-pokefirered-case/index.md): Case study · The Pokémon FireRed disassembly project contains an early assembly reconstruction of the GBA game. Its Makefile combines local ROM input with assembly source, assembles and links it with the ARM toolchain, and produces a GBA file for comparison.
- [WHITE ALBUM 2: an Apple port of a reconstructed game engine](https://awesomerea.org/resources/white-album-2-apple-port-case/index.md): Case study · The WHITE ALBUM 2 Apple port adapts a Godot 4 .NET reimplementation of the game's engine for iPhone, iPad, Vision Pro, Apple TV, and Apple silicon Macs. It adds platform input and performance work, reads scripts and media from the user's PC copy, and includes an ASF/WMV playback extension.
- [mkxp: reimplementing RPG Maker's RGSS runtime](https://awesomerea.org/resources/mkxp-rgss-case/index.md): Case study · mkxp implements the RGSS interface used by RPG Maker XP, VX, and VX Ace, with the goal of running games made with those tools natively. Its C++ engine handles rendering, audio, input, and files, and provides MRI and experimental mruby bindings for game scripts.
- [Soldier of Fortune: annotated ZX Spectrum disassembly](https://awesomerea.org/resources/soldier-of-fortune-zx-disassembly-case/index.md): Case study · zx-sof-reveng documents the ZX Spectrum game Soldier of Fortune through a commented Z80 disassembly. The notes map loader behavior, memory regions, graphics data and game-loop calls, including uncertain interpretations marked in the annotations.
- [Evo's Space Adventures PSX: matching decompilation of Evo's Space Adventure](https://awesomerea.org/resources/esa-psx-case/index.md): Case study · Evo's Space Adventures PSX decompiles the PlayStation game Evo's Space Adventure from an owner-supplied esa.dat executable. Its build extracts and disassembles the executable, then uses GCC, GNU as and maspsx to produce a matching binary; the work is presented as a proof of concept.
- [DuckHuntNESRecomp: a Duck Hunt static recompilation with mouse Zapper](https://awesomerea.org/resources/duck-hunt-nes-recomp-case/index.md): Case study · DuckHuntNESRecomp runs the NES game Duck Hunt on PC using NESRecomp, compiling seeded 6502 code paths to C and running unseen code through a cycle interpreter. The shared runner maps mouse input to the Zapper; a project note records fixes to trigger polarity and crosshair defaults. The author reports working menus and gameplay, while audio mixing remains unfinished.
- [Medal of Honor: Frontline: a multi-image GameCube static recompilation](https://awesomerea.org/resources/moh-frontline-gc-recomp-case/index.md): Case study · Medal of Honor: Frontline GC Recomp translates the USA GameCube game's PowerPC executable chain into a native host module with DolRecomp. ModernGekko supplies memory, graphics, audio and input services, while runtime hashes distinguish the boot and restart stub images that overlap in guest memory.
- [KH_COM_VITA: porting Kingdom Hearts: Chain of Memories to PS Vita](https://awesomerea.org/resources/kh-com-vita-case/index.md): Case study · KH_COM_VITA ports the GBA Kingdom Hearts: Chain of Memories decompilation to PS Vita by compiling the game's C for Vita ARM and replacing GBA video, DMA, interrupts, audio, BIOS and save services. Its source includes a Vita platform layer and patch; the author reports working early gameplay and a completed first battle, with later areas still under test.
- [Fallout Community Edition: reimplementing the Fallout engine](https://awesomerea.org/resources/fallout-community-edition-case/index.md): Case study · Fallout Community Edition reimplements Fallout for Windows, Linux, macOS, Android and iOS. It replaces the original executable while reading game assets from the user's copy, and includes engine bug fixes and quality-of-life improvements.
- [Yoshi's Island: a SNES disassembly for two US ROM revisions](https://awesomerea.org/resources/yoshis-island-snes-disassembly-case/index.md): Case study · A disassembly of Super Mario World 2: Yoshi's Island provides SNES assembly sources and maps for the USA v1.0 and v1.1 ROMs. Its asset-extraction script uses a clean, headerless copy of a supported ROM, and the project builds on the author's SNES ROM framework.
- [OpenVIII: a C# engine reconstruction of Final Fantasy VIII](https://awesomerea.org/resources/openviii-monogame-case/index.md): Case study · OpenVIII rewrites the Final Fantasy VIII game engine in C# and MonoGame for Windows and Linux. Its replacement engine reads the user's original game files and contains code for archives, battle systems, audiovisual playback and other game systems.
- [Ridge Racer (PSP): bit-exact decompilation of BOOT.BIN](https://awesomerea.org/resources/ridge-racer-psp-decomp-case/index.md): Case study · Ridge Racer (PSP) reconstructs the game's BOOT.BIN as C and C++ and checks functions against retail bytes with a patched PSP GCC 1.3.1 compiler. A headless PPSSPP runner supports behavioral comparisons. The author reports 4,513 byte-exact game functions in the November 2026 progress snapshot.
- [Uncharted Collection PC: running the PS4 trilogy on Windows](https://awesomerea.org/resources/uncharted-collection-zorde23-case/index.md): Case study · Uncharted Collection PC runs the PS4 Uncharted trilogy on Windows by executing the original x86-64 game code over replacement PS4 system libraries and a Vulkan graphics layer. The fork adapts a pre-existing runtime to the collection and documents game-specific fixes, controls and remaining performance issues.
- [WarioRecomp: a native Wario Land: Shake It! port by static recompilation](https://awesomerea.org/resources/wariorecomp-wario-land-shake-it-case/index.md): Case study · WarioRecomp builds a native PC port of the US Wii release of Wario Land: Shake It! by statically recompiling its PowerPC code to C++ with WiiCompiled. Native libraries replace Wii video, audio, controller, disc and save services, while the launcher imports the user's disc and builds the port locally.
- [Ace Combat 3: Electrosphere: PlayStation recompilation and Android port](https://awesomerea.org/resources/ace-combat-3-electrosphere-case/index.md): Case study · Ace Combat 3: Electrosphere is a PlayStation game reconstruction that documents the European and US discs, asset formats and executable code, then translates MIPS code to C for native builds. It also provides an Android APK that reads a player's own disc image through an interpreter. The author reports function-level validation and playable missions while native recompilation remains in progress.
- [saga: matching decompilation of LEGO Star Wars: The Complete Saga](https://awesomerea.org/resources/saga-lego-star-wars-decomp-case/index.md): Case study · saga reconstructs source for the Android x86 release of LEGO Star Wars: The Complete Saga, aiming to compile to the original machine code. Its build and matching tools compare locally supplied game binaries with reconstructed code; the README badge reports 90.02% matching progress.
- [Asura's Wrath Recompiled: a static Xbox 360 recompilation](https://awesomerea.org/resources/asuras-wrath-recompiled-case/index.md): Case study · Asura's Wrath Recompiled ports the Xbox 360 game by statically translating its PowerPC executable to C++23 with ReXGlue. Its build instructions cover Linux, Windows and Android, while runtime setup reads extracted files from the user’s ISO.
- [Falltergeist: reimplementing the Fallout 2 engine](https://awesomerea.org/resources/falltergeist-fallout-2-case/index.md): Case study · Falltergeist reimplements the Fallout 2 engine in C++ and SDL for desktop platforms. It loads the user's original master.dat and critter.dat data and includes readers for game formats, while gameplay systems such as combat AI and full scripting remain on its roadmap.
- [masseffect-nx: statically recompiling Mass Effect for Nintendo Switch](https://awesomerea.org/resources/masseffect-nx-case/index.md): Case study · masseffect-nx ports the Xbox 360 release of Mass Effect to Nintendo Switch by translating PowerPC code from default.xex to C++ with ReXGlue and compiling it for ARM64. A project Vulkan renderer handles the game's GPU commands, while its installer converts Xenos shader microcode from the user's game files to SPIR-V.
- [CannonBall: rewriting the OutRun arcade engine in C++](https://awesomerea.org/resources/cannonball-outrun-case/index.md): Case study · CannonBall rewrites the OutRun arcade game's 68000 and Z80 assembly as a C++ engine. It reads graphics and audio from the user's original ROMs and supports higher frame rates, widescreen output and SDL2-based rendering.
- [Pea Shootin' Pete: matching reconstruction of PETE.EXE](https://awesomerea.org/resources/pea-shootin-pete-decomp-case/index.md): Case study · Pea Shootin' Pete reconstructs DOS PETE.EXE functions as C and assembly using Borland C++ 3.1. Its tools repair gaps in a Ghidra export, compile candidates in DOSBox X, and compare instruction shape and bytes while reporting address-field differences. The author reports 94 exact function matches among 454 targets.
- [ds2-nx: porting Dead Space 2 to Nintendo Switch](https://awesomerea.org/resources/ds2-nx-case/index.md): Case study · ds2-nx adapts a ReXGlue static recompilation of Dead Space 2 for Nintendo Switch as a homebrew NRO. Switch-specific code handles disc swapping and rendering through deko3d, while a separate toolchain translates dumped Xbox 360 Xenos shaders into a library and, optionally, a DKSH cache.
- [MCX360 Edition: recompiling Minecraft: Xbox 360 Edition for iPhone](https://awesomerea.org/resources/mcx360-edition-case/index.md): Case study · MCX360 Edition recompiles Minecraft: Xbox 360 Edition Title Update 9 ahead of time with ReXGlue for an iPhone app. The port uses Vulkan over Metal through MoltenVK and includes an iOS app manifest, build scripts and SDK patch; players supply the matching disc and title-update files.
- [The New Tetris: a matching Nintendo 64 decompilation](https://awesomerea.org/resources/the-new-tetris-decomp-case/index.md): Case study · The New Tetris project reconstructs source for the US 1.0 Nintendo 64 game through static and dynamic analysis. Its build uses a user-provided ROM to extract assets and assembly, compiles the recovered C source, and checks the output ROM against a documented MD5. The source reconstruction is described as work in progress.
- [Carbon: an Xbox 360 static recompilation and renderer investigation](https://awesomerea.org/resources/nfs-carbon-recomp-case/index.md): Case study · Carbon is a ReXGlue recompilation project for Need for Speed: Carbon with native renderer and Android host code. Its investigation notes describe Vulkan rendering work and report per-frame GPU command-processor measurements from an Android run on an Adreno device.
- [Jade Cocoon on Bevy: a Rust engine reimplementation](https://awesomerea.org/resources/jade-cocoon-on-bevy-case/index.md): Case study · Jade Cocoon on Bevy reimplements Jade Cocoon: Story of the Tamamayu in Rust and Bevy for Windows. It reads tables and scene scripts from the user's European PlayStation disc image. The author reports story progression through the ending, with battles, creature systems, media and local saves, while noting remaining differences.
- [World Driver Championship: Recompiled — an N64 static recompilation](https://awesomerea.org/resources/world-driver-championship-recompiled-case/index.md): Case study · World Driver Championship: Recompiled builds an experimental native Windows port from the user's USA Nintendo 64 ROM. N64Recomp and RSPRecomp translate CPU code and BOSS graphics microcode, while RT64 renders low-level RDP commands. The author reports testing through menus and Hawaii practice driving.
- [Castlevania 64: matching USA v1.0 overlays](https://awesomerea.org/resources/cv64-overlays-decomp-case/index.md): Case study · Castlevania 64 - Overlays Decompilation reconstructs selected code overlays from the USA v1.0 Nintendo 64 game as C source. Its Ubuntu build uses IDO 7.1 and nOVL, then checks each generated overlay's SHA-1 against the decompressed original.
- [Dragon Warrior IV: a byte-exact NES disassembly](https://awesomerea.org/resources/dragon-warrior-iv-nes-disassembly-case/index.md): Case study · Reconstructs the US NES release of Dragon Warrior IV as assembly for all 32 physical PRG banks. The project records code classification, labels, pointer recovery, runtime traces, and save evidence, and the author reports a rebuild matching the reference ROM's SHA-256.
- [Xenogears Decompilation: matching the US PlayStation release](https://awesomerea.org/resources/xenogears-decompilation-case/index.md): Case study · Xenogears Decompilation reconstructs source for the US PlayStation 1 release of Xenogears as an in-progress matching build. Its workflow uses splat to split binaries, spimdisasm for disassembly, and objdiff to compare compiled objects.
- [BTD5-Decomp: a hand-built Bloons TD 5 decompilation](https://awesomerea.org/resources/btd5-decomp-case/index.md): Case study · BTD5-Decomp reconstructs Bloons TD 5 source by hand in C++, using leftover debug information where available to name files and classes. Its intended comparison is between compiled project code and the game executable, while the current source tree remains unbuildable.
- [OpenScreamer: reconstructing Screamer and Screamer 2](https://awesomerea.org/resources/openscreamer-case/index.md): Case study · OpenScreamer reimplements the DOS games Screamer and Screamer 2 as a C/SDL2 program for Linux and Windows. It reads files from the user's game folders and includes unpackers, Ghidra scripts, viewers and notes mapping game formats and behavior to the original programs.
- [Moto Racer World Tour: matching PlayStation code and file-format research](https://awesomerea.org/resources/moto-racer-world-tour-case/index.md): Case study · Moto Racer World Tour reconstructs the PAL PlayStation game's boot and main executables with byte-matching builds while replacing assembly with recovered C and C++. Its documentation maps the disc, MR3.DAT archive and formats including VRM textures, SDF scenes and DPS movies. Python tools extract, inspect, edit and repack those files from a user-provided disc.
- [Midnight Club: Los Angeles Recomp: an experimental Android ARM64 port](https://awesomerea.org/resources/midnight-club-la-android-recomp-case/index.md): Case study · Midnight Club: Los Angeles Recomp adapts ReXGlue's static translation of the Xbox 360 game's PowerPC code into C++ for Android ARM64. The fork adds Android packaging, private game-data import, C++ integration and ReXGlue patches. The README reports that a user test reached car selection; development and testing centered on a Galaxy S23.
- [HK: Dual Souls: an AYN Thor port of Hollow Knight](https://awesomerea.org/resources/dual-souls-case/index.md): Case study · HK: Dual Souls ports Hollow Knight v1.5.12620 to the AYN Thor Android handheld through a same-version Unity rebuild from the user's GOG or Steam copy. Its runtime adds a second-screen HUD, map, inventory and charms, while patch tooling prepares game data on the device. Some shaders are reconstructed approximations.
- [Turok 2: Seeds of Evil: a matching Nintendo 64 decompilation](https://awesomerea.org/resources/turok-2-seeds-of-evil-decomp-case/index.md): Case study · Turok 2: Seeds of Evil reconstructs the US 1.0 Nintendo 64 ROM from matched C and assembly. The project uses the SN64 GCC toolchain, per-function comparisons and a SHA-1 rebuild check; the author reports all original C code matched while readability work continues.
- [Chibi-Robo: PIA: matching GameCube DOL decompilation](https://awesomerea.org/resources/chibi-robo-pia-decomp-case/index.md): Case study · Chibi-Robo: PIA is an unfinished C/C++ decompilation of the USA GameCube release that aims to rebuild a matching DOL. Its build uses a copy of the game extracted with Dolphin, and its objdiff configuration supports object-level comparisons during reconstruction.
- [Bloody Roar Extreme: an original Xbox XBE recompilation](https://awesomerea.org/resources/bloody-roar-extreme-recomp-case/index.md): Case study · Bloody Roar Extreme Recomp builds a native Windows x64 port of the original Xbox fighting game with the Xbox XBE Recomp toolchain. It supplies configurations for the USA, European and Japanese executables and a host with Vulkan rendering, audio and controller support.
- [Crash Bandicoot: The Wrath of Cortex: an early PS2 decompilation](https://awesomerea.org/resources/crash-ps2-case/index.md): Case study · crash-ps2 begins a C decompilation of Crash Bandicoot: The Wrath of Cortex for PS2 NTSC-U v1.00. It contains several reconstructed functions and stubs, with a stated plan to move from functional implementations toward instruction matching and a PS2SDK build.
- [SoulCalibur Vita: running the Android game on PS Vita](https://awesomerea.org/resources/soulcalibur-vita-case/index.md): Case study · SoulCalibur Vita adapts the Android version of SoulCalibur to PS Vita by loading its ARMv7 executable into memory, resolving imports with native functions and patching behavior needed for the port. The repository contains the loader and Android compatibility implementations, while installation uses the player's APK and OBB files.
- [The Last Guardian: a native PC port of the PS4 executable](https://awesomerea.org/resources/the-last-guardian-pc-port-case/index.md): Case study · The Last Guardian PC port runs the PS4 game's original executable as native CPU code while replacing PS4 system services and translating graphics to Vulkan. Its loader and runtime use a user-provided dump of the game and update 01.03; an optional library from the user's console firmware supplies audio. The author reports playable Linux sessions, while Windows gameplay remains untested.
- [metal-slug-x-recomp: a Neo Geo static recompilation and native runtime](https://awesomerea.org/resources/metal-slug-x-recomp-case/index.md): Case study · metal-slug-x-recomp maps Metal Slug X's 68000 code with recursive disassembly and MAME traces, translates instructions to C, and implements Neo Geo video, sound and memory services in a native Windows runtime. Personal builds generate translated code from the user's game files; distributed builds use an interpreter.
- [The Bard's Tale: byte-matching reconstruction of BARD.EXE](https://awesomerea.org/resources/bards-tale-msdos-decomp-case/index.md): Case study · The Bard's Tale reconstructs the 1987 MS-DOS BARD.EXE as C and assembly modules built with Microsoft C 4.0 and LINK 3.51 /EXEPACK. Its scripts rebuild the root program and three overlays, then compare the result with a user-provided executable; the author reports a byte-identical full rebuild.
- [Hunters Recomp: a dual-screen Metroid Prime Hunters Android port](https://awesomerea.org/resources/hunters-recomp-case/index.md): Case study · Hunters Recomp adapts a static recompilation of Metroid Prime Hunters for the AYN Thor's dual-screen Android hardware. Its app shell adds touch mapping, twin-stick controls and a GLES 3.2 renderer; game code is generated from the user's cartridge dump.
- [Naruto: Clash of Ninja: static recompilation of five GameCube releases](https://awesomerea.org/resources/clash-of-ninja-recomp-case/index.md): Case study · Naruto: Clash of Ninja static recompilation builds native versions of five GameCube releases from user-supplied discs. Its launcher generates each game's symbol map and project files locally, translates PowerPC code to C, and links against a runtime for GameCube hardware.
- [Dragon Quest II: rebuilding NES releases from disassembly](https://awesomerea.org/resources/dragon-quest-ii-nes-disassembly-case/index.md): Case study · Disassembles Dragon Quest II and Dragon Warrior II for the NES into banked assembly and rebuilds the US and Japanese ROMs from user-provided originals. Configuration splits ROM banks and assets, while the build compares output checksums with the destination version.
- [Mario Party 2: a US N64 decompilation](https://awesomerea.org/resources/mario-party-2-us-decomp-case/index.md): Case study · Mario Party 2 reconstructs the US Nintendo 64 game as C source and assembly mapped to ROM addresses. Its build requires a supplied baserom.us.z64, uses Splat to split the ROM, and configures comparison with the rebuilt output.
- [Burnout CRASH!: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/burnout-crash-recomp-case/index.md): Case study · Burnout CRASH! translates the Xbox 360 XBLA game's PowerPC executables into C++ with ReXGlue for a native Windows build. Its configuration identifies additional engine functions and EASharp switch tables, while native hooks replace a few failing guest functions.
- [EATF: Eric & the Floaters disassembly](https://awesomerea.org/resources/eatf-eric-floaters-case/index.md): Case study · EATF presents a disassembly of Eric & the Floaters, with game routines in address-ranged assembly files and data in separate files. Its sources can be assembled with SjASM+.
- [Digimon World 3: matching PlayStation decompilation of three regional releases](https://awesomerea.org/resources/digimon-world-3-decomp-case/index.md): Case study · Digimon World 3 decomp reconstructs the PlayStation game's executable, 21 overlays and stage files as C source for European, USA and Japanese releases. The author reports that builds from the shared source match the corresponding original binaries byte for byte; the build checks its outputs against SHA-1 values stored in the repository's version configurations.
- [Ultima IV: a matching Master System rebuild and PC port](https://awesomerea.org/resources/ultima-iv-sms-recompiled-case/index.md): Case study · Rebuilds the Sega Master System version of Ultima IV: Quest of the Avatar from a disassembly and ports its routines to native C for PC. The ROM build is checked byte for byte against a user-supplied release, while shadow execution compares C rewrites with the original code's state and can also compare timing.
- [Vault13: a Rust reimplementation of the Fallout 2 engine](https://awesomerea.org/resources/vault13-fallout-2-case/index.md): Case study · Vault13 reimplements the Fallout 2 engine in Rust using files from a local game directory. Its source covers DAT archives, maps, graphics, inventory, dialogue and script execution, while the documented demo offers limited movement and display controls.
- [Ogre Battle 64: a native port through N64 static recompilation](https://awesomerea.org/resources/ogre-battle-64-recomp-case/index.md): Case study · The Ogre Battle 64 port statically recompiles the USA Rev A N64 game into a native PC executable with N64Recomp. Its build pipeline splits and links ROM code, recompiles the main program and bank units, and processes RSP microcode; a separate browser build uses WebGL2.
- [Super Mario All-Stars: partial static recompilation and native port](https://awesomerea.org/resources/super-mario-all-stars-recompiled-case/index.md): Case study · Builds a native Super Mario All-Stars port from the player's specified SNES ROM using snesrecomp and game-specific bank analysis inputs. Super Mario Bros. and The Lost Levels are mostly translated ahead of time; Super Mario Bros. 2 and 3 use a built-in interpreter. The port provides desktop and Android builds with a launcher and controller support.
- [Mario Party 3: a matching Nintendo 64 decompilation](https://awesomerea.org/resources/mario-party-3-decomp-case/index.md): Case study · Mario Party 3 reconstructs the US Nintendo 64 game's code as C while generating assembly for unmatched functions from the user's ROM. Its build uses Splat for ROM splitting, compiles the source, and includes comparison and SHA-1 checking workflows.
- [Advance Wars: Dual Strike: a matching Nintendo DS decompilation](https://awesomerea.org/resources/advance-wars-dual-strike-decomp-case/index.md): Case study · Advance Wars: Dual Strike reconstructs C source for the US/Australia Nintendo DS release. The project reports that compiling it with the original Metrowerks compiler reproduces the retail ROM byte for byte; its build extracts data from the user's cartridge dump and compares the resulting ROM and modules with the original.
- [Powerslave EX: rebuilding the PlayStation game on Kex Engine](https://awesomerea.org/resources/powerslave-ex-case/index.md): Case study · Powerslave EX reconstructs the PlayStation Powerslave game on Kex Engine 3.0, combining recovered game logic with new collision and AI systems. Its research files document MIPS disassembly, extraction code and partial findings about the ZED format; the engine uses converted game data rather than the CD data directly.
- [meteor-decomp: FINAL FANTASY XIV 1.23b client and network decompilation](https://awesomerea.org/resources/meteor-ffxiv-decomp-case/index.md): Case study · meteor-decomp reconstructs functions and network behavior from five FINAL FANTASY XIV 1.23b Windows client executables. It combines byte-matching C++ work with Ghidra analysis of vtables, packet dispatch, Blowfish lobby encryption and resource-pack chunks; the author reports partial matching coverage and unresolved work.
- [Quest 64: Recompiled — a static recompilation port](https://awesomerea.org/resources/quest-64-recompiled-case/index.md): Case study · Quest 64: Recompiled turns the North American N64 release of Quest 64 into a native port through N64Recomp static translation. RT64 renders the game, and the program loads assets from the player's ROM. The port adds configurable graphics, controls and mod support.