# Curated reverse engineering resources · Page 26

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

## Games (100)

- [G1R Deluxe: a LÖVE2D port of eleven Pokémon games](https://awesomerea.org/resources/g1r-deluxe-pokemon-port-case/index.md): Case study · G1R Deluxe ports eleven Pokémon games, from Red and Blue through Emerald, into a Lua engine running on LÖVE2D. It draws engine and map behavior from pret disassemblies and C, then decodes graphics, game data and audio programs from each player's ROM during import.
- [Princess Maker 4: a Japanese DS decompilation in progress](https://awesomerea.org/resources/princess-maker-4-case/index.md): Case study · Princess Maker 4 is a work-in-progress hand decompilation of the Japanese Nintendo DS game. It reconstructs C source using symbol and relocation configuration and extracts required assets from a user-supplied decrypted ROM.
- [Super Mario Sunshine: a PAL native PC port with Aurora rendering](https://awesomerea.org/resources/super-mario-sunshine-pal-aurora-port-case/index.md): Case study · Super Mario Sunshine PAL PC port compiles the GMSP01 decompilation for native Windows and replaces GameCube platform services with host implementations. Its Aurora bridge renders GX through WebGPU on Direct3D or Vulkan, and the project adds widescreen, 60 fps, configurable controls and optional mod support.
- [Cosmore: reconstructing Cosmo's Cosmic Adventure](https://awesomerea.org/resources/cosmore-case/index.md): Case study · Cosmore reconstructs the DOS source of Cosmo's Cosmic Adventure 1.20 in C and assembly for its three episodes. It builds with Borland Turbo C and Turbo Assembler and compares executable load images against the originals; the author reports 96.30% byte agreement, with remaining differences attributed to data layout.
- [FNC Reborn: a Fight Night Champion static-recompilation port](https://awesomerea.org/resources/fnc-reborn-case/index.md): Case study · FNC Reborn builds a Windows port of Fight Night Champion from the player's Xbox 360 disc using ReXGlue static recompilation. Its game-specific code adds frame-rate controls, a boxer-following camera and a settings tab, while its installer extracts the disc and builds the executable locally.
- [LSUSDISASM: Landstalker US ROM disassembly](https://awesomerea.org/resources/lsusdisasm-landstalker-case/index.md): Case study · LSUSDISASM documents the US Landstalker ROM as organized 68k assembly and data descriptions. Its split script extracts omitted binary chunks from the user's original ROM, and its build script reassembles the source with those chunks. The author reports a bit-identical rebuilt ROM.
- [Fire Emblem: Shadow Dragon: a Nintendo DS decompilation](https://awesomerea.org/resources/fire-emblem-shadow-dragon-decomp-case/index.md): Case study · Fire Emblem: Shadow Dragon reconstructs code for the US Nintendo DS game using ds-decomp. The build uses a base ROM, while objdiff compares decompiled code with the ROM; an ARM7 BIOS dump is needed for a matching ROM build.
- [Master Of Olympus Java Remake: an unfinished Java reconstruction](https://awesomerea.org/resources/master-of-olympus-java-remake-case/index.md): Case study · Master Of Olympus Java Remake recreates parts of Master of Olympus in Java, including city, building, AI, map and rendering systems. The author says the game is at an early, unfinished stage and requires assets from the original game.
- [Eternal Darkness: a work-in-progress GameCube decompilation](https://awesomerea.org/resources/unending-occlusion-eternal-darkness-case/index.md): Case study · Eternal Darkness: Sanity's Requiem is being reconstructed from the USA GameCube release as C source. The repository contains source files, symbol maps and split maps, with a build that reads the user's disc image and an objdiff workflow for comparing objects. The author describes the game and engine code as ongoing work.
- [SSX: a work-in-progress matching PS2 decompilation](https://awesomerea.org/resources/ssx-2000-decomp-case/index.md): Case study · SSX reconstructs the NTSC-U PlayStation 2 release of SSX (2000) as a matching decompilation. The repository includes game-specific C/C++ source, symbol maps and build scripts, and its compiler notes record recovered EE-GCC flags. The work remains in progress.
- [TimeSplitters: a PS2 static recompilation for PC and original Xbox](https://awesomerea.org/resources/timesplitters-ps2-recomp-case/index.md): Case study · TimeSplitters recompiles the USA PlayStation 2 game's MIPS program and VU microcode into C++ with PS2Recomp for native Windows, Linux and original Xbox builds. Its runtime models PS2 graphics, sound and IOP services. The Windows and Linux builds extract data from the player's disc dump on first launch; Xbox game files are prepared on a Windows PC.
- [Daggerfall Unity: recreating Daggerfall in Unity](https://awesomerea.org/resources/daggerfall-unity-case/index.md): Case study · Daggerfall Unity recreates Daggerfall in the Unity engine for Windows, Linux and macOS. It reads textures, models and sounds from a separate DOS Daggerfall copy and adds widescreen support, updated lighting, controls and mod support.
- [OpenSAGE: rebuilding the SAGE engine for Command & Conquer: Generals](https://awesomerea.org/resources/opensage-engine-case/index.md): Case study · OpenSAGE reimplements the SAGE strategy-game engine with an initial focus on Command & Conquer: Generals and Zero Hour. Its code parses original formats including .map, .w3d and .ini, and the author describes studying data files and observed game behavior. Rendering and game logic remain incomplete.
- [Nebula: an anime-game server emulator](https://awesomerea.org/resources/nebula-anime-game-server-case/index.md): Case study · Nebula emulates a server for an anime game and connects to regional PC clients through redirected requests. Its documented features include characters, inventory, quests, gacha, friends and several game modes. The server uses game data placed in a resources directory.
- [Dig Dug – native PC port: reconstructing the arcade board](https://awesomerea.org/resources/dig-dug-native-case/index.md): Case study · Dig Dug – native PC port re-creates the arcade board's three Z80 processors, shared memory, Namco I/O, video and wavetable sound in C# so user-supplied game ROM code runs on Windows and Linux. Its developer switches disassemble the Z80 programs and trace I/O, code coverage and memory writes.
- [OpenNox: a cross-platform reconstruction of the Nox engine](https://awesomerea.org/resources/opennox-engine-reconstruction-case/index.md): Case study · OpenNox ports and extends the Nox game engine with Go and C code for cross-platform play, preservation and modding. Its contributor documentation describes analyzing an incompletely understood codebase with a C parser and refactoring it while replacing platform dependencies with Go, SDL2 and OpenAL. The project reports campaign and online play support.
- [OUO: a reconstructed Ultima Online demo server](https://awesomerea.org/resources/ouo-case/index.md): Case study · OUO reconstructs the Ultima Online demo server from UoDemo.exe as a C99 program for POSIX systems. Its function-by-function workflow uses disassembly of the original executable, while added server systems and protocol changes support later Ultima Online clients.
- [OpenTitus: porting the Titus the Fox and Moktar engine](https://awesomerea.org/resources/opentitus-case/index.md): Case study · OpenTitus ports the DOS game engine used by Titus the Fox and Moktar into a C program for Linux and Windows. It parses files from the user's original games, including SQZ levels, sprites and images, and uses titus.conf to select their paths and game-specific settings.
- [Test Drive III Enhanced: an SDL3 port of the reconstructed racing game](https://awesomerea.org/resources/test-drive-iii-enhanced-case/index.md): Case study · Test Drive III Enhanced ports a reconstructed Test Drive III: The Passion engine to a native SDL3 program. It keeps a faithful game core while adding smoother high-resolution rendering, longer draw distance, steering changes and a launcher. The program loads the player's original executable and data files.
- [Final Fantasy V: a matching SNES disassembly for two ROM versions](https://awesomerea.org/resources/final-fantasy-v-disassembly-case/index.md): Case study · Final Fantasy V Disassembly reconstructs the SNES game as 65c816 and SPC-700 assembly for Japanese 1.0 and RPGe 1.10 builds. Python tools extract graphics, text and other data from a user-provided ROM, while ca65 and ld65 assemble the project. The author reports that the matching ROM stage is complete and readability work continues.
- [Babil Decompilation Project: Final Fantasy IV 3D Remake source reconstruction](https://awesomerea.org/resources/babil-decompilation-project-case/index.md): Case study · Babil Decompilation Project reconstructs C++ source for the Steam version of Final Fantasy IV 3D Remake, targeting its November 2020 update. The repository contains game-structured C++ files and a Visual Studio project with Steamworks and SDL2 dependencies.
- [Extermination: matching PS2 decompilation and gameplay traces](https://awesomerea.org/resources/extermination-ps2-decomp-case/index.md): Case study · Extermination reconstructs source for the USA PS2 game's executable and uses a byte-identity build gate across the boot ELF and overlays. Its tools also capture play from the original in a PCSX2 fork, producing input and machine-state traces for comparison with a separate native port.
- [REDPRO2: a partial New Super Mario Bros. U decompilation](https://awesomerea.org/resources/redpro2-case/index.md): Case study · REDPRO2 is a partial C++ decompilation of the US v1.3.0 release of New Super Mario Bros. U. It began with the graphics system and expanded into other game systems for research and documentation; the source tree includes graphics, actor, enemy and player modules.
- [FE7 EU decomp: matching reconstruction of the European Fire Emblem ROM](https://awesomerea.org/resources/fe7eu-decomp-case/index.md): Case study · FE7 EU decomp reconstructs the European Game Boy Advance release of Fire Emblem: Rekka no Ken with a matching ROM build. It maps symbols from the Japanese decompilation to the EU ROM, splits EU assembly, adapts C candidates and checks the rebuilt ROM against the user's dump. The author reports integrated C functions and further EU-specific recovery in progress.
- [Sneak King: an original Xbox static recompilation](https://awesomerea.org/resources/sneaky-whopper-recomp-case/index.md): Case study · Sneak King statically recompiles the original Xbox game into a native Windows port and an experimental WebAssembly build. A vendored xboxrecomp pipeline lifts functions from the user's default.xbe into C, while project code supplies Xbox runtime services and translates Direct3D 8 graphics through OpenGL ES 3 and ANGLE.
- [rb2: Dragon Ball Z Budokai HD recompiled with ReXGlue](https://awesomerea.org/resources/dbz1-budokai-hd-case/index.md): Case study · DBZ1 is a ReXGlue-based recompilation project for Dragon Ball Z Budokai HD. It provides a function-map configuration and a native host that loads the game's XEX image, initializes the runtime and opens a game window.
- [Final Fantasy 4: The After Years Vita: rehosting the Android executable](https://awesomerea.org/resources/final-fantasy-after-years-vita-case/index.md): Case study · Final Fantasy 4: The After Years Vita runs the Android game's executable on PS Vita through a native loader. The loader maps the executable into memory, resolves Android imports to Vita functions and patches behavior needed for the port.
- [Guitar Hero III: Legends of Rock — Recomp: Xbox 360 code on PC and Android](https://awesomerea.org/resources/guitar-hero-iii-recomp-case/index.md): Case study · Guitar Hero III: Legends of Rock — Recomp translates the Xbox 360 game's PowerPC code to C++ for PC and Android builds using a ReXGlue-derived toolchain. It keeps generated code local to the user's disc, adds a launcher that checks the executable hash, and documents the QB script archive format used for translation work.
- [KAR-Decomp: an annotated Kirby Air Ride disassembly](https://awesomerea.org/resources/kar-decomp-case/index.md): Case study · KAR-Decomp uses decomp-toolkit to build an annotated Kirby Air Ride disassembly that preserves ROM offsets and adds or revises symbol names. Its DTK branch contains assembly and reports a compiling North American version; the Japanese and PAL editions currently generate splits and assembly.
- [Mega Man X4 Recompiled: a native PSXRecomp build with co-op](https://awesomerea.org/resources/mega-man-x4-recompiled-case/index.md): Case study · Mega Man X4 Recompiled uses PSXRecomp to generate a native Windows or Linux build from the player's original Mega Man X4 USA PlayStation disc. The title-specific runtime and launcher add optional local and networked two-player co-op, display options and game-specific modifications.
- [Libre40: a static-recompilation port of Army of Two: The 40th Day](https://awesomerea.org/resources/libre40-case/index.md): Case study · Libre40 builds a native Windows host for the Xbox 360 release of Army of Two: The 40th Day using ReXGlue static recompilation. Its extraction and code-generation scripts use the player's disc image to produce local game files and recompiled source; the author reports playable single-player gameplay.
- [Pokémon Stadium 2: a partial USA 1.0 decompilation](https://awesomerea.org/resources/pokemon-stadium-2-partial-decomp-case/index.md): Case study · The project partially reconstructs the USA 1.0 release of Pokémon Stadium 2 as C source for research. It includes game and math source units, symbol-address lists, a ROM build recipe using baserom.z64, and a diff script.
- [BG3SE-macOS: rebuilding the Baldur's Gate 3 Script Extender](https://awesomerea.org/resources/bg3se-macos-baldurs-gate-3-case/index.md): Case study · BG3SE-macOS rebuilds the Baldur's Gate 3 Script Extender for macOS using Ghidra analysis of the Mac game binary and the Windows extender's architecture as a reference. It patches a Mach-O load command to inject a dylib, hooks game functions, and exposes Lua scripting APIs for mods; the author reports partial behavioral parity with the Windows implementation.
- [G-Engine: rebuilding Gabriel Knight 3 around its original data](https://awesomerea.org/resources/g-engine-gabriel-knight-3-case/index.md): Case study · G-Engine reimplements the engine needed to play Gabriel Knight 3: Blood of the Sacred, Blood of the Damned on Windows, macOS and Linux using the original game's data. Its C++ code parses Barn asset bundles and handles the game's Bink and AVI videos; the source credits earlier reverse engineering of BRN, BSP and ACT formats. The author reports a completable game with remaining bugs and missing noncritical features.
- [Haunted House: a commented Atari 2600 disassembly](https://awesomerea.org/resources/haunted-house-disassembly-case/index.md): Case study · Haunted House reconstructs the Atari 2600 game's code as commented assembly in haunted.asm. A DASM command and Makefile build a ROM that can be played in the Stella emulator.
- [Magiczna kula Papatki: reconstructing the game and Magnum Engine](https://awesomerea.org/resources/magiczna-kula-papatki-case/index.md): Case study · mkp reconstructs source for Magiczna kula Papatki and its Magnum Engine v2.0 engine. The current effort focuses on the engine, using original gratka3d.exe and ME2.dll files with objdiff reports to track decompilation changes.
- [Super Mario Advance 2: a Game Boy Advance disassembly](https://awesomerea.org/resources/super-mario-advance-2-disassembly-case/index.md): Case study · Super Mario Advance 2 disassembly reconstructs the Game Boy Advance game as assembly and data source. Its Makefile uses a user-supplied baserom.gba with devkitARM and pokeruby build tools to produce a ROM whose expected SHA-1 is documented.
- [sm64-gba: Super Mario 64 movement and collision on GBA](https://awesomerea.org/resources/sm64-gba-physics-port-case/index.md): Case study · sm64-gba ports Super Mario 64 movement and collision code to Game Boy Advance and adds a software-rendered playable demo. Its harness compares Mario's state frame by frame with an unmodified decompilation; the author reports bit-for-bit matches in emulator tests.
- [ToeJam & Earl: an incomplete REV 02 Genesis disassembly](https://awesomerea.org/resources/toejam-earl-disasm-case/index.md): Case study · tje-disasm investigates the REV 02 Sega Genesis release of ToeJam & Earl through assembly source, ROM tools and documented code comparisons with REV 00. Its notes examine function-level differences and possible compiler fingerprints. The project requires a user-supplied REV 02 ROM and describes the disassembly as incomplete.
- [homm1-decomp: matching Heroes of Might and Magic and its editor](https://awesomerea.org/resources/homm1-decomp-case/index.md): Case study · homm1-decomp reconstructs the Buka 2003 Heroes of Might and Magic game and scenario editor as C++ source using the original Visual C++ 6.0 SP5 toolchain under Wine. The author reports that HEROES.EXE and EDITOR.EXE rebuild byte-identically and that every targeted function matches. The repository also documents earlier Windows 95 versions, matching tools and compiler behavior.
- [CR1:U: a reconstructed Chaos Rings engine for original game data](https://awesomerea.org/resources/cr1-u-chaos-rings-case/index.md): Case study · CR1:U reimplements Chaos Rings as a native C++ engine using behavior and format findings from the iPad HD release. It loads original iOS, Android or Vita data from the user's copy and includes parsers for archives, events, models, textures, audio and saves.
- [The Simpsons Game: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/the-simpsons-game-recomp-case/index.md): Case study · The Simpsons Game port translates the US Xbox 360 game's PowerPC code into C++ ahead of time for a native Windows x64 build. It provides handwritten platform services, audio, input, and a Direct3D 11 renderer with an optional Vulkan path; the author reports that all levels load.
- [DarkFO: a browser engine reimplementation of Fallout 2](https://awesomerea.org/resources/darkfo-fallout-2-case/index.md): Case study · DarkFO rebuilds the Fallout 2 engine in TypeScript and Python for a web browser. Its setup script extracts and converts data from the user's installed game, including archives and FRM images. The author lists map loading, movement, dialog and barter among working areas, while combat and saving remain limited.
- [COD3 Reborn: continuing a Call of Duty 3 static recompilation](https://awesomerea.org/resources/cod3-reborn-case/index.md): Case study · COD3 Reborn builds a native Windows port of Call of Duty 3 by translating its Xbox 360 PowerPC executable and level libraries with XenonRecomp. It links the generated code to a kernel, graphics and audio runtime inherited from an earlier port, then adds title-specific investigation and fixes. The author reports that individual levels load and render, while campaign-wide play and several graphics and input issues remain unresolved.
- [F-Zero GX: matching the GameCube executables from C](https://awesomerea.org/resources/f-zero-gx-decomp-case/index.md): Case study · fzgx reconstructs the GameCube release of F-Zero GX as C matched against the game's executable files. Its primary target is the USA Rev 0 disc, including main.dol, main.rel extracted from an encrypted archive and fourteen other REL modules. The project uses compile-and-diff checks per function and hash checks on the sixteen linked targets.
- [Sonic Battle: a matching GBA decompilation](https://awesomerea.org/resources/sonic-battle-decomp-case/index.md): Case study · Sonic Battle decomp reconstructs the USA Rev 0 Game Boy Advance game as matching C and assembly. Its build checks the user's ROM hash, compiles recovered code with agbcc and compares a linked whole-ROM image with the original. The author reports 51.81% of executable text decompiled to C; handwritten assembly accounts for additional reproduced bytes.
- [NBlood: reverse-engineered ports of Build-engine games](https://awesomerea.org/resources/nblood-build-games-case/index.md): Case study · NBlood provides reverse-engineered ports of Build-engine games using EDuke32 technology. Its NBlood, PCExhumed and Rednukem programs cover Blood, Exhumed or PowerSlave, and several Duke Nukem 3D-derived games; users supply the relevant game data.
- [ValkyrieRecomp: a PlayStation static recompilation of Valkyrie Profile](https://awesomerea.org/resources/valkyrie-profile-recomp-case/index.md): Case study · ValkyrieRecomp configures PSXRecomp to generate a native PC build of the USA PlayStation release of Valkyrie Profile from a user-supplied disc. It adds a launcher for selecting the two discs, rendering options and controller support; compatibility testing remains in progress.
- [Sonic Riders: Zero Gravity: a PlayStation 2 prototype decompilation](https://awesomerea.org/resources/sonic-riders-zero-gravity-decomp-case/index.md): Case study · SR2 reconstructs source for the September 2007 PlayStation 2 prototype of Sonic Riders: Zero Gravity. Its Python and Ninja build uses an ELF supplied by the user, and objdiff compares reconstructed objects against the original. Architecture notes describe the game’s task and object system.
- [3 on 3 NHL Arcade: an Xbox 360 static recompilation for PC](https://awesomerea.org/resources/3-on-3-nhl-arcade-recomp-case/index.md): Case study · 3 on 3 NHL Arcade is ported to Windows by translating its Xbox 360 PowerPC executable to C++ with ReXGlue and compiling it for the PC. A launcher prepares files from the user's XBLA package, while an Android arm64 build is described as reaching the title screen and menus.
- [Zoids Saga: Japanese GBA code reconstruction](https://awesomerea.org/resources/zoids-saga-one-case/index.md): Case study · Zoids Saga One Decomp reconstructs code regions of the Japanese GBA game as C and assembly. Its verifier checks the user's ROM hash, compiles each listed region at its original address and compares the generated bytes with the ROM; the author reports 1,897 byte-exact regions.
- [Burnout Recompilation: building a Windows port from an Xbox disc](https://awesomerea.org/resources/burnout-recompilation-case/index.md): Case study · Burnout Recompilation builds a native Windows version of the original Xbox Burnout from the user's disc image. Its launcher extracts the image, translates XBE code to C with xboxrecomp and compiles the result locally, using game-specific seed lists and manual overrides. The author reports playable races in the early 0.1.0 release.
- [RA3Bar-RA3QuickLoader: a replacement Red Alert 3 launcher](https://awesomerea.org/resources/ra3bar-ra3quickloader-case/index.md): Case study · RA3Bar-RA3QuickLoader replaces the Red Alert 3 RA3.exe launcher with a Win32 program that starts the game without waiting for the original launcher’s defunct news-server request. It also adds a control center for launch arguments and mods, plus a replay browser that reads match details and repairs some crash-damaged replays.
- [NX2navi: static recompilation of Ocarina of Time for Windows](https://awesomerea.org/resources/nx2navi-ocarina-of-time-switch-2-case/index.md): Case study · NX2navi statically recompiles the Nintendo Switch 2 version of The Legend of Zelda: Ocarina of Time into a Windows x86-64 application. Its pipeline lifts ARM64 modules to C, implements console services on the host, and renders through Vulkan. A launcher builds the port locally from the user's game files.
- [Luigi's Mansion: a PS5 port of the static recompilation](https://awesomerea.org/resources/luigis-mansion-ps5-port-case/index.md): Case study · Luigi's Mansion for the PlayStation 5 ports an existing static recompilation of the GameCube game to PS5 homebrew. Its builder translates code from the user's USA disc into C++ and compiles it for the console, while this repository supplies PS5 platform shims, input, build scripts and builder apps. The author reports play through file selection into the game.
- [Advance Wars: a byte-identical GBA reconstruction](https://awesomerea.org/resources/advancewars-decomp-case/index.md): Case study · advancewars reconstructs the USA Game Boy Advance release of Advance Wars as assembly and C that build a byte-identical ROM. Its build uses devkitARM and agbcc, incorporates a user-supplied baserom, and checks the output against the listed game hash.
- [Wind Waker HD for PlayStation 5: a port of ZeldaWWHDRecomp](https://awesomerea.org/resources/ps5-wind-waker-hd-case/index.md): Case study · Wind Waker HD for PlayStation 5 ports ZeldaWWHDRecomp to a homebrew-enabled PS5, compiling Wii U PowerPC code from the user's dump and drawing GX2 graphics through the recompilation's Vulkan renderer on RADV. The author reports reaching the first island after the prologue on one console; later areas remain unmeasured.
- [2 Ship 2 Harkinian for PS4: a native Majora's Mask port](https://awesomerea.org/resources/2ship2harkinian-ps4-case/index.md): Case study · 2 Ship 2 Harkinian for PS4 adapts the decompilation-based Majora's Mask port to jailbroken PlayStation 4 consoles. It uses the OpenOrbis toolchain and Piglet rendering, with patches and technical notes covering PS4 platform integration and hardware-specific audio, memory and graphics issues.
- [SSX On Tour: a PSP static recompilation for PC](https://awesomerea.org/resources/ssx-on-tour-psp-recomp-case/index.md): Case study · SSX On Tour translates the PSP game's Allegrex MIPS executable into C++ ahead of time for Linux and Windows. Its project-specific tools load PRX data, discover functions and generate code locally; the PC runtime supplies PSP kernel services, GE rendering through OpenGL and SDL audio.
- [rlvm: a RealLive interpreter reimplementation](https://awesomerea.org/resources/rlvm-case/index.md): Case study · rlvm reimplements the RealLive interpreter so VisualArts games can run on Linux and macOS using their own SEEN.TXT game directories. It supports KOE, NWK and OVK voice archives and implements rlBabel line breaking for compatible English patches.
- [Super Mario Bros.: an Atari Lynx port from NES disassembly](https://awesomerea.org/resources/super-mario-bros-lynx-port-case/index.md): Case study · The Super Mario Bros. Atari Lynx port adapts the NES game's 6502 logic to the Lynx 65C02 using a complete disassembly. Adapter code maps NES tile rendering to Suzy sprites, APU output to Mikey audio, and controller input to the Lynx joypad; artwork and level data are extracted from the user's ROM at build time.
- [War1gus: a Stratagus reimplementation of Warcraft: Orcs & Humans](https://awesomerea.org/resources/war1gus-case/index.md): Case study · War1gus reimplements Warcraft: Orcs & Humans for the Stratagus engine using graphics and sounds extracted from the user’s original game. Its scripts and campaigns support modern mouse controls, larger unit selections, additional multiplayer factions and a map editor.
- [u5d: a semantic-match Ultima V decompilation](https://awesomerea.org/resources/u5d-ultima-v-case/index.md): Case study · u5d reconstructs C source for Ultima V: Warriors of Destiny and compares it with the MS-DOS v1.16 program at the assembly-semantic level. The author reports that the modern version can be played through to the ending using original game data. The author reports approximately 95% matching for ULTIMA.EXE, excluding assembly functions, and approximately 95% for the overlays.
- [Skate 2 PC: recompiling the Xbox 360 game for Windows](https://awesomerea.org/resources/skate-2-pc-case/index.md): Case study · Skate 2 PC recompiles the Xbox 360 version of Skate 2 into a native Windows port using ReXGlue. It translates graphics through Direct3D 12, checks the supplied game revision during import, and adds controller input, local saves, and selectable rendering and frame rate profiles.
- [Mulberry: matching source decompilation of Kuon](https://awesomerea.org/resources/mulberry-kuon-case/index.md): Case study · Mulberry works toward a matching C source decompilation of the PlayStation 2 game Kuon. Its build uses a user-provided game executable and PS2-specific binutils; contributors replace assembly translation units in the project configuration with reconstructed C.
- [REinforced: extending the Flashback engine reimplementation](https://awesomerea.org/resources/reinforced-flashback-case/index.md): Case study · REinforced extends the REminiscence reimplementation of the 1992 Flashback game engine. Its C++ engine reads original PC, Amiga or Macintosh files and offers widescreen display modes, graphics scaling, saves and audio playback.
- [abcParkDecomp: an Alphabet Park Adventure decompilation](https://awesomerea.org/resources/abcparkdecomp-case/index.md): Case study · abcParkDecomp reconstructs source for Alphabet Park Adventure. The repository contains C source files, build metadata and a Makefile that invokes the unSP toolchain through Wine; its documentation gives make targets for building and cleaning.
- [DQ8Recomp: an experimental Dragon Quest VIII static recompilation](https://awesomerea.org/resources/dq8recomp-case/index.md): Case study · DQ8Recomp translates Dragon Quest VIII's PlayStation 2 MIPS code to C++ locally with PS2Recomp and links it to a runtime implementing the services the game uses. The source includes function maps, Ghidra analysis tooling and an SDL3 GPU renderer; the author reports that the NTSC-U build reaches field gameplay.
- [Deathchase: annotated game disassembly](https://awesomerea.org/resources/deathchase-disassembly-case/index.md): Case study · deathchase documents the 1983 game Deathchase as an annotated disassembly. Its SkoolKit source files hold the game and loader disassemblies, accompanied by a reference file.
- [Destruction Derby Raw: a local PSXRecomp build](https://awesomerea.org/resources/destruction-derby-raw-recomp-case/index.md): Case study · Destruction Derby Raw uses PSXRecomp and recomp-ui to generate and compile a native build from the user's USA PlayStation disc and BIOS. The title kit contains configuration and symbol seeds. The author reports Windows setup and headless-start checks and playable private-build testing with menu and movie artifacts.
- [reB3: reconstructing Burnout 3 from Xbox code and disc data](https://awesomerea.org/resources/reb3-case/index.md): Case study · reB3 reconstructs Xbox Burnout 3: Takedown as a C runtime using equations and behavior recovered from default.xbe and formats read from the user's disc. Its notes cite executable addresses for physics, collision, scoring and AI, while extraction code loads track and vehicle material at runtime. The author reports a playable racing harness with career mode absent.
- [Let's Go Recomp: statically recompiling Pokémon Let's Go for Windows](https://awesomerea.org/resources/lets-go-recomp-case/index.md): Case study · Let's Go Recomp ports the Nintendo Switch games Pokémon: Let's Go, Eevee! and Let's Go, Pikachu! to Windows through static recompilation. It translates their ARM64 code to C and provides a runtime for Switch services, NVN graphics through Vulkan, audio and controllers. The build uses the player's extracted game files.
- [Unreal Championship 2: an Xbox static recompilation for Windows](https://awesomerea.org/resources/unreal-championship-2-recomp-case/index.md): Case study · Unreal Championship 2 is statically recompiled from an ISO image of the user's original Xbox game into a native Windows program with xboxrecomp. The project translates game code to C and adds game-specific runtime code, D3D11 graphics support and toolkit patches.
- [Crash Bandicoot 3: Warped Recompiled: a PSXRecomp setup host](https://awesomerea.org/resources/crash-bandicoot-3-warped-recompiled-case/index.md): Case study · Crash Bandicoot 3: Warped Recompiled packages a PSXRecomp setup recipe for generating a native build from the user's PlayStation disc and BIOS. The recomp-ui wizard collects those inputs; the author reports a Windows development build while package setup and gameplay acceptance remain pending.
- [WWE '13 Recomp: an Xbox 360 static recompilation](https://awesomerea.org/resources/wwe13-recomp-case/index.md): Case study · WWE '13 Recomp translates the Xbox 360 game's PowerPC code to C++ with ReXGlue for native Windows and Linux builds. A launcher imports the user's game files and required title update, while game-specific patches address graphics, input, saves and content handling.
- [Mega Man Legends 2: a PlayStation static recompilation setup kit](https://awesomerea.org/resources/mega-man-legends-2-recomp-case/index.md): Case study · Mega Man Legends 2 provides a setup kit that generates and compiles a PlayStation static recompilation from the user's European SLES-03556 disc and SCPH-5552 BIOS. Its game configuration, function seeds and setup code work with psxrecomp and recomp-ui. The author reports a Windows setup and headless start check for version 0.1.0.
- [Imabikisō: an experimental PS3-to-PC static recompilation](https://awesomerea.org/resources/imabikiso-pc-recompilation-case/index.md): Case study · Imabikisō uses ps3recomp to run locally generated PS3 game code as a Windows program. Its repository adds runtime patches, a native runner and tools for extracting, inspecting and patching script archives; the author reports rendering the opening and first classroom text.
- [Karateka: a buildable MS-DOS decompilation](https://awesomerea.org/resources/karateka-msdos-decompiled-case/index.md): Case study · Reconstructs the MS-DOS version of Karateka as C and assembly source that builds KARATEKA.EXE. The documented build uses Lattice C 2.15, MASM 1.25 and DOIT.BAT. The source includes the cutscene animation script engine.
- [Gow2HD-Windows: a Windows static recompilation of God of War II HD](https://awesomerea.org/resources/gow2hd-windows-case/index.md): Case study · Gow2HD-Windows translates the PPU and SPU code of the PS3 release of God of War II HD into C/C++ for a Windows x64 build. A PS3 library reimplementation supplies Direct3D 12 rendering, WASAPI audio and XInput or keyboard input, while the launcher builds from the user's game files.
- [Harrier Attack: a SkoolKit ZX Spectrum disassembly](https://awesomerea.org/resources/harrier-attack-disassembly-case/index.md): Case study · harrierattack records a SkoolKit disassembly of the ZX Spectrum game Harrier Attack. Its source files generate browsable HTML listings in hexadecimal and decimal views.
- [benilla: reconstructing the World of Warcraft 1.12.1 client](https://awesomerea.org/resources/benilla-wow-client-case/index.md): Case study · benilla reconstructs the World of Warcraft 1.12.1 client in Rust and Bevy, drawing on reverse-engineering findings from benilla-re. It reads MPQ archives and game assets from the user's installation, implements the original server protocol, and runs the stock FrameXML and Lua interface with addons.
- [New Super Mario Bros.: an early Nintendo DS matching decompilation](https://awesomerea.org/resources/nsmb-ds-decomp-case/index.md): Case study · nsmb reconstructs source for the Nintendo DS game New Super Mario Bros., with active comparison work on the US A2DE release. Its workflow extracts a user-dumped ROM, delinks modules and generates an objdiff configuration to compare reconstructed code with game code; a complete ROM build remains unavailable.
- [TetrisGBRecomp: a static recompilation of Game Boy Tetris](https://awesomerea.org/resources/tetris-gb-recomp-case/index.md): Case study · TetrisGBRecomp statically translates the Game Boy Tetris version 1.0 ROM into C for native PC execution. Its configuration identifies the ROM and entry points, while a dispatch manifest supplies harvested function seeds; the gb-recompiled runtime models Game Boy graphics, audio and memory. The author reports all game modes playable.
- [Test Drive III: The Passion: a reverse-engineered SDL3 port](https://awesomerea.org/resources/test-drive-iii-sdl3-case/index.md): Case study · Test Drive III: The Passion is reconstructed in C as an SDL3 port that reads the player's original DOS game files. The project documents recovered functions and resource formats, including pictures, 3D objects, maps, and sound. Its VGA version covers the cars, courses, menus, traffic, replay, results, and scores; several original graphics and sound modes remain outside the port.
- [Tapir: reimplementing the RGSS game runtimes](https://awesomerea.org/resources/tapir-rgss-case/index.md): Case study · Tapir reimplements the RGSS, RGSS2 and RGSS3 runtimes used by RPG Maker XP, VX and VX Ace games. It provides a C runtime with graphics, audio and input components and documents Linux builds and RTP installation. A test suite is set up to exercise the original RGSS runtimes supplied by the user.
- [Stuntman PC: a native port from the PlayStation 2 program](https://awesomerea.org/resources/stuntman-pc-case/index.md): Case study · Stuntman PC translates the PlayStation 2 game's program into C++ and runs it through a native host with Vulkan graphics. It builds from a user-owned European SLES-50288 disc image, while the bundled PS2 port engine supplies analysis, lifting, behavior checks and replacements for console services.
- [Sonic the Hedgehog Recompiled Runner: a Genesis static recompilation](https://awesomerea.org/resources/sonic-the-hedgehog-recompiled-runner-case/index.md): Case study · Sonic the Hedgehog Recompiled Runner uses a Genesis recompiler to analyze a Sonic 1 ROM and emit native C functions for its 68K routines. Its game-specific runner executes those functions with a backend for VDP graphics, bus behavior, Z80 scheduling, audio synthesis and controllers. Adaptive widescreen and higher refresh presentation are optional features.
- [The Legend of Zelda: Ocarina of Time 3D: a USA code.bin decompilation](https://awesomerea.org/resources/oot3d-before-public-decomp-case/index.md): Case study · This project reconstructs source for the USA release of The Legend of Zelda: Ocarina of Time 3D using game data and static or dynamic analysis. Its Windows build produces oot3d.axf and a code.bin checked against the original MD5; rebuilding romfs.bin and the full .3ds image remains planned.
- [Burnout 3 for PlayStation 5: a port of Takedawn](https://awesomerea.org/resources/ps5-burnout-3-case/index.md): Case study · Burnout 3 for PlayStation 5 ports Takedawn's original Xbox static recompilation of Burnout 3: Takedown to PS5. Its console layer uses Vulkan on RADV, maps Xbox memory into PS5 memory and handles sound-register accesses through page-fault traps.
- [Gran Turismo 2 PC, VR & Browser: a native multiplatform port](https://awesomerea.org/resources/gran-turismo-2-pc-vr-browser-case/index.md): Case study · Gran Turismo 2 PC, VR & Browser ports Arcade and Simulation modes to desktop, Quest, PCVR and browser targets through shared C++ game code, with WebAssembly and WebGL2 for browser play. Players supply supported BIN/CUE disc images, and the project provides importers, build scripts and native rendering and input code. Optional tools decode selected Gran Turismo 4 car data from a separate player-owned disc.
- [TwistedMetal1234Recomp: rebuilding four PlayStation Twisted Metal games](https://awesomerea.org/resources/twisted-metal-1234-recomp-case/index.md): Case study · TwistedMetal1234Recomp builds native Windows programs for the first four PlayStation Twisted Metal games through psxrecomp, with a unified launcher. Game-specific hooks adjust frame pacing, widescreen terrain drawing and HUD placement, while framework patches expose related display settings. The generated C is produced locally from each user's disc image.
- [DWM2: disassembling Dragon Warrior Monsters 2](https://awesomerea.org/resources/dwm2-case/index.md): Case study · DWM2 is a partial disassembly of Dragon Warrior Monsters 2 with assembly sources and function-level documentation. Its Windows build uses rgbasm, rgblink and rgbfix, then compares the produced ROM with a user-held backup. The author reports a very early byte-similarity result and says documentation progress differs from that figure.
- [FROGMAN: an annotated BBC Micro disassembly](https://awesomerea.org/resources/frogman-bbc-micro-case/index.md): Case study · FROGMAN reconstructs a BBC Micro platform game as annotated 6502 BeebASM source. The author dumped memory after the encrypted loader ran in an emulator, disassembled and labeled the game code, and reports byte-exact reassembly. The repository also documents memory layout, level maps, and the loader's XOR chain.
- [Lester the Unlikely: SNES disassembly and ROM maps](https://awesomerea.org/resources/lester-the-unlikely-disassembly-case/index.md): Case study · Lester the Unlikely Disassembly reconstructs the USA SNES game in assembly with RAM and ROM maps and asset-extraction scripts. It uses the project's included SNES ROM framework and requires the user's clean, headerless ROM to extract game assets.
- [F.LF: rebuilding Little Fighter 2 for the web](https://awesomerea.org/resources/f-lf-case/index.md): Case study · F.LF rebuilds Little Fighter 2 as a JavaScript and HTML5 game engine for desktop and mobile browsers. It converts the original game's dat files to JSON and implements characters, backgrounds, versus matches, WebSocket player networking, and selectable AI. Its core library supplies graphics, controls, and network modules.
- [Harold: reimplementing the Fallout 2 engine for browsers](https://awesomerea.org/resources/harold-fallout-2-case/index.md): Case study · Harold reimplements the Fallout 2 engine in TypeScript and Python for WebGL 2 browsers, building on darkfo. Setup converts archives and assets from a user's installed copy; the current engine covers map loading, movement, dialogue and some quests while documenting incomplete combat and saving.
- [Road Rash for 3DO: a functional C reconstruction](https://awesomerea.org/resources/road-rash-3do-decomp-case/index.md): Case study · Road Rash for 3DO reconstructs the USA release as functional C source targeting the 3DO DevKit. The repository covers game and runtime routines and documents behavior-preserving changes to road rendering, animation decoding, simulation and audio paths.
- [fefw-recomp: a static recompilation of Fire Emblem: Fortune's Weave](https://awesomerea.org/resources/fefw-recomp-case/index.md): Case study · fefw-recomp translates the Nintendo Switch 2 game Fire Emblem: Fortune's Weave into C++ for a native Windows port. Its AArch64 recompiler processes game modules, and a companion runtime supplies console services and Vulkan graphics. A launcher prepares the program from the user's decrypted game dump.
- [Rise of the Robots: a USA SNES disassembly](https://awesomerea.org/resources/rise-of-the-robots-snes-disassembly-case/index.md): Case study · The Rise of the Robots project disassembles the USA SNES release into assembly, ROM maps and extraction scripts. It uses the author's SNES ROM framework and extracts required assets from a user-supplied headerless ROM.
- [OpenMoonstone: reimplementing Moonstone from its original game files](https://awesomerea.org/resources/openmoonstone-case/index.md): Case study · OpenMoonstone reimplements the Amiga and DOS game Moonstone in Rust with SDL2. It loads resources from a user-supplied DOS copy and contains code for combat, campaign maps and resource extraction, along with IDA analysis scripts. The documented campaign map remains in development.