# Curated reverse engineering resources · Page 27

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

## Games (100)

- [Marvel vs. Capcom 2: early Dreamcast matching decompilation](https://awesomerea.org/resources/mvc2-dreamcast-decomp-case/index.md): Case study · Starts a matching decompilation of the North American Dreamcast release of Marvel vs. Capcom 2: New Age of Heroes. Its tools extract and descramble 1ST_READ.BIN, split SH-4 code and data using a configuration map, and compare reconstructed C against the retail executable.
- [Chocolate Strife: reconstructing Strife from its DOS executable](https://awesomerea.org/resources/chocolate-strife-case/index.md): Case study · Chocolate Strife recreates Strife: Quest for the Sigil within Chocolate Doom from analysis of the original DOS executable. Its authors disassembled and decompiled the executable, compared findings with released Doom and Heretic source, and implemented compatible behavior in the port.
- [Haze Recomp: an experimental PlayStation 3 static recompilation](https://awesomerea.org/resources/haze-recomp-case/index.md): Case study · Haze Recomp uses ps3recomp to lift the PlayStation 3 game Haze and supporting firmware code into a native Windows build from a user-supplied disc image. Its scripts handle disc extraction, executable decryption, PPU and SPU translation, and runtime building. The author reports working menus, opening-scene gameplay, audio and checkpoint saves, while campaign coverage remains in development.
- [Wanderer: reimplementing Project Nomads](https://awesomerea.org/resources/wanderer-project-nomads-case/index.md): Case study · Wanderer reimplements the 2002 game Project Nomads in Java with libGDX, using assets from the original game. Its documented asset formats include models converted from Nebula NVX, textures converted from NTX, and animations converted from NAX; a story guide maps the original TCL scripts to JavaScript. The project aims to retain the original gameplay while fixing flaws.
- [SF2RE: reconstructing Shining Force II disassembly in IDA](https://awesomerea.org/resources/sf2re-case/index.md): Case study · SF2RE records Shining Force II reverse-engineering work as IDA Pro IDC scripts rather than a checked-in ROM image. The scripts initialize and annotate an IDA database from the USA ROM, parse game structures and export a split disassembly to SF2DISASM, where a vanilla build can be checked for bit-perfect output.
- [Def Jam: Fight for NY XBE Recomp: a native Linux port](https://awesomerea.org/resources/def-jam-fight-for-ny-linux-case/index.md): Case study · Def Jam: Fight for NY XBE Recomp builds a native Linux port of the original Xbox game by translating its x86 XBE into C++ ahead of time. The port implements Xbox kernel and XDK services at the API level, renders through Vulkan, and uses SDL3 for sound and input. The author reports booting through menus and into fights while gameplay testing continues.
- [RampageRE: a native reconstruction of Rampage: Total Destruction](https://awesomerea.org/resources/rampagere-case/index.md): Case study · RampageRE rebuilds Rampage: Total Destruction for native platforms using a PS2Recomp static recompilation as a reference and replacement code for game formats, rendering, and systems. Its documentation covers scripts, bundles, effects, monsters, and other game data; the port reads data from the player's PS2 disc.
- [OpenTennis: a Hot Shots Tennis rewrite checked against the PS2 game](https://awesomerea.org/resources/opentennis-hot-shots-tennis-case/index.md): Case study · OpenTennis rebuilds the 2007 PlayStation 2 game Hot Shots Tennis in Rust and Bevy for desktop, mobile and browser play. It reads models, textures and other game data from the user’s US disc image at runtime. The author compares ball physics, timing, rules and AI frame by frame with recordings of the original; research tools inspect executable overlays and game formats.
- [Pyskool: reimplementing Skool Daze and Back to Skool](https://awesomerea.org/resources/pyskool-case/index.md): Case study · Pyskool reimplements the ZX Spectrum games Skool Daze and Back to Skool in Python and Pygame. Its shared engine supports configuration-file and Python-code customization, and its setup generates the launchers, images, configuration and sounds used to play.
- [OpenVice: a C# port of Grand Theft Auto: Vice City](https://awesomerea.org/resources/openvice-case/index.md): Case study · OpenVice ports Grand Theft Auto: Vice City to a C# engine that uses the original game's files. It parses RenderWare data, renders through OpenTK, uses BEPU Physics and decodes ADF radio audio alongside MP3 playback.
- [BellPad: an Apple platform port of Animal Crossing](https://awesomerea.org/resources/bellpad-animal-crossing-port-case/index.md): Case study · BellPad ports the original US GameCube Animal Crossing to Apple Silicon macOS, iPhone and iPad using a decompiled game core. It adds Apple platform integration, Metal-backed rendering, local disc import, input handling and save support through tracked compatibility patches.
- [LandSandBoat: an FFXI server emulator](https://awesomerea.org/resources/landsandboat-ffxi-server-case/index.md): Case study · LandSandBoat implements a server emulator for FFXI. The repository contains server code and game data definitions, while its mission-status notes map values in a field of packet 0x56 to mission events.
- [Mother: a checksum-checked Famicom/NES disassembly](https://awesomerea.org/resources/mother-nes-disassembly-case/index.md): Case study · Mother reconstructs the Famicom/NES game as assembly for its Japanese release and English localization. Configuration splits banks and version-specific assets from user-supplied ROMs; build scripts produce NES 2.0 ROMs and compare their checksums with the selected originals. The assembly separates game data, object scripts, vectors, music, and other code.
- [SpaceRanger: a Toy Story 2 Nintendo 64 static recompilation](https://awesomerea.org/resources/spaceranger-toy-story-2-case/index.md): Case study · SpaceRanger statically recompiles the USA Nintendo 64 release of Toy Story 2: Buzz Lightyear to the Rescue into a Windows port rendered by RT64. Its configuration and runtime adapters handle the game's overlays and generate translated code from the user's ROM during the build.
- [The Need for Speed: a functional 3DO source reconstruction](https://awesomerea.org/resources/need-for-speed-3do-decomp-case/index.md): Case study · The Need for Speed's 3DO release is reconstructed as a C codebase targeting the 3DO DevKit. Its build extracts assets from the user's game image and links the reconstructed executable into a new ISO. The author targets functional equivalence rather than a byte-identical rebuild.
- [GoldenEye 007: a Nintendo 3DS port from decompiled source](https://awesomerea.org/resources/goldeneye-3ds-port-case/index.md): Case study · The GoldenEye 007 3DS port adapts the existing Nintendo 64 decompilation to Nintendo 3DS with rendering, input, audio, storage and timing interfaces. The author reports that the Dam level runs with movement, collision, guards, weapons and mission state while the port remains unfinished.
- [Crash Bash: a PSX decompilation with function comparison](https://awesomerea.org/resources/crash-bash-decomp-case/index.md): Case study · Crash Bash is an ongoing decompilation of the PlayStation game, with recovered code organized by game binary. The documented strategy proposes loading rewritten functions into PCSX-Redux memory and comparing their output with the original functions. Accompanying scripts analyze emulator traces and apply symbols to the results.
- [Klonoa: Empire of Dreams — a matching GBA decompilation](https://awesomerea.org/resources/klonoa-empire-of-dreams-decomp-case/index.md): Case study · Klonoa: Empire of Dreams reconstructs the USA Game Boy Advance game as C that aims to build a byte-identical ROM. It generates assembly for unfinished functions from the user's ROM, replaces functions with C, checks the ROM hash and records emulator experiments about game behavior.
- [Pebble Beach Golf Links: a byte-matched Mega Drive reconstruction](https://awesomerea.org/resources/pebble-beach-golf-links-mega-drive-decomp-case/index.md): Case study · Reconstructs the European Mega Drive release of Pebble Beach Golf Links from a locally supplied ROM. The project represents the 68000 game code, Z80 audio driver, tables, and asset pipelines in source, then checks the build against the original SHA-256. The author reports a byte-identical 2 MiB ROM build and documents remaining semantic naming work.
- [Megarocket: seven Commander Keen games reconstructed in Godot](https://awesomerea.org/resources/megarocket-commander-keen-case/index.md): Case study · Megarocket ports Commander Keen 1–6 and Keen Dreams into one Godot 4 program using function-level reconstructions of the DOS games. It reads art, levels and sound from the user's copies and documents regression comparisons of pictures and frame timing against recorded DOS play.
- [Bandersnatch: an annotated ZX Spectrum code disassembly](https://awesomerea.org/resources/bandersnatch-zx-spectrum-case/index.md): Case study · Bandersnatch annotates a disassembly of ZX Spectrum code featured in Black Mirror: Bandersnatch. The repository contains compressed and decompressed assembly files, a checksum helper and a run script. The source can be assembled with z80asm and run in a ZX Spectrum emulator.
- [Army of Two Recompilation: a ReXGlue native port](https://awesomerea.org/resources/army-of-two-rexglue-port-case/index.md): Case study · Army of Two Recompilation translates the player's Xbox 360 Army of Two executable into C++ with a game-specific ReXGlue SDK fork and builds a native host. Its Windows build uses a Direct3D 12 renderer; the author reports testing the opening areas, while Linux and macOS builds remain experimental.
- [Kirby's Dream Land 3: a US and Japanese SNES disassembly](https://awesomerea.org/resources/kirbys-dream-land-3-disassembly-case/index.md): Case study · The Kirby's Dream Land 3 project supplies assembly sources for the US and Japanese SNES versions. It uses a SNES ROM framework and batch scripts to extract game assets from a user's clean, headerless ROM. The repository contains game assembly, RAM maps and sound-engine files.
- [MELEE360: porting Super Smash Bros. Melee to Xbox 360](https://awesomerea.org/resources/melee360-case/index.md): Case study · MELEE360 ports reconstructed Super Smash Bros. Melee code to a native Xbox 360 XEX. It adapts the game to PowerPC, D3D9/Xenos and XInput while reading original resources from a user-supplied NTSC-U 1.02 disc image. The author reports bounded Xenia tests, with campaign content and physical-console operation still incomplete.
- [f2bgl: reimplementing the Fade To Black engine](https://awesomerea.org/resources/f2bgl-case/index.md): Case study · f2bgl reimplements the engine of the 1995 game Fade To Black in C++. It loads files from the original PC release or demo and provides rendering, input, audio and save-state handling through an SDL2-based build.
- [Rook: reconstructing the Roblox engine](https://awesomerea.org/resources/rook-roblox-engine-case/index.md): Case study · Rook reconstructs a Roblox-compatible engine in Rust so user-supplied places can run outside Roblox. It loads .rbxl, .rbxm, .rbxlx and .rbxmx files and implements Luau scripting, an instance model, physics and rendering; its behavior notes and conformance cases compare results with Roblox Studio.
- [Mario Kart: Double Dash!!: a GameCube static recompilation port](https://awesomerea.org/resources/mario-kart-double-dash-recomp-case/index.md): Case study · Mario Kart: Double Dash!! is ported by translating its GameCube PowerPC code to C ahead of time and linking it with gcn-recomp's graphics, audio, disc and controller runtime. The repository contributes game function metadata, hooks and build scripts; the author reports reaching a Grand Prix race with sound from a blank memory card.
- [Ice Rage: an Android native-library port for Linux ARM handhelds](https://awesomerea.org/resources/ice-rage-arm-port-case/index.md): Case study · Ice Rage runs on Linux ARM handhelds through a bionic ELF loader that maps the game's Android armeabi-v7a library and supplies required Android interfaces. The author reports successful loading, audio, rendering and menus on an R36S; a full match remains unplayed.
- [acnl-decomp: reconstructing Animal Crossing: New Leaf code and CRO modules](https://awesomerea.org/resources/acnl-decomp-case/index.md): Case study · acnl-decomp reconstructs the USA 1.5 release of Animal Crossing: New Leaf – Welcome amiibo as C++ source for its main code and CRO modules. Its GCC build checks implemented functions against a user-supplied dump using call order, member accesses, constants, references, and decisions rather than byte identity.
- [Gazillionaire: reconstructing the Steam AIR/Flex game](https://awesomerea.org/resources/gazillionaire-reconstruction-case/index.md): Case study · Gazillionaire reconstructs the Steam AIR/Flex release of the game from a user's installation. Scripts export the local game, prepare ActionScript source, build an AIR application and compare generated code with the original SWF. The repository also documents the game's architecture and code-generation experiments.
- [hey_you_pikachu: partial N64 ROM decompilation](https://awesomerea.org/resources/hey-you-pikachu-decomp-case/index.md): Case study · hey_you_pikachu reconstructs part of a Pikachu Nintendo 64 ROM in C alongside disassembled MIPS code. Its Makefile assembles and compiles those sources into a ROM, while many functions remain as nonmatching assembly inclusions.
- [Kirby's Dream Collection: an in-progress Wii decompilation](https://awesomerea.org/resources/kirbys-dream-collection-decomp-case/index.md): Case study · Kirby's Dream Collection is a work-in-progress decompilation of the USA Rev 0 Wii release. Its build uses reconstructed C and C++ source and an owner's disc image to produce main.dol. The tree includes symbols and splits and generates objdiff configuration for comparing rebuilt object files with the original.
- [Ozymandias (Julius): adapting a city-building engine to Pharaoh](https://awesomerea.org/resources/ozymandias-julius-case/index.md): Case study · Ozymandias (Julius) adapts the Julius/Augustus city-building engine to run Pharaoh and its Cleopatra expansion using the player's original assets. The unfinished implementation loads original saves and supports early campaign missions, with systems including houses, farming, trading and campaign progression.
- [Paper Cut: a native Paper Mario: The Thousand-Year Door port](https://awesomerea.org/resources/paper-cut-thousand-year-door-case/index.md): Case study · Paper Cut ports Paper Mario: The Thousand-Year Door to Windows, macOS, Linux, iOS and Android using C code from a decompilation. Aurora replaces the GameCube graphics, audio, input, disc and memory card layers with WebGPU/Dawn and SDL3. The port reads the user's disc image and supports the Japanese, US and European releases.
- [Mario Party 6: a matching GameCube decompilation](https://awesomerea.org/resources/mario-party-6-decomp-case/index.md): Case study · Mario Party 6 reconstructs source for the GameCube USA Revision 0 main executable and REL modules. Its build uses files extracted from the user's disc, compares reconstructed objects with objdiff and checks rebuilt output against retail SHA-1 hashes; source recovery remains incomplete.
- [OoT: Recompiled: a native Ocarina of Time static recompilation](https://awesomerea.org/resources/oot-recompiled-jonb-case/index.md): Case study · OoT: Recompiled builds a native Windows version of Ocarina of Time from a user-supplied Nintendo 64 NTSC-U 1.0 ROM. N64Recomp translates MIPS code to C, N64ModernRuntime supplies console services, and RT64 renders display lists through Direct3D 12. Game-specific C patches replace selected original functions.
- [Garigari: matching decompilation of Super Mario Galaxy 2](https://awesomerea.org/resources/garigari-case/index.md): Case study · Garigari reconstructs the USA Wii release SB4E01 Rev 0 of Super Mario Galaxy 2 as C and C++ source. Contributors build against main.dol extracted from their own game and use objdiff to compare compiled objects and functions with the original binary.
- [inFAMOUS 2: a static recompilation for Apple-silicon macOS](https://awesomerea.org/resources/infamous2-macos-recomp-case/index.md): Case study · inFAMOUS 2 translates the PS3 digital release NPUA80638's PowerPC and SPU code to C/C++ and compiles it into a native Apple-silicon macOS game with Metal graphics. Built on ps3recomp and a community fork, the port rebuilds from the player's own copy. The author reports menus, cutscenes, and early New Marais gameplay in an alpha build.
- [SMM2 Recomp: a Super Mario Maker 2 static recompilation](https://awesomerea.org/resources/smm2-recomp-case/index.md): Case study · SMM2 Recomp translates Super Mario Maker 2 v3.0.3 AArch64 code into C ahead of time and builds it for native platforms. Its runtime supplies Switch system services and renders NVN graphics through Metal or Vulkan. The launcher generates game-derived code and data locally from the player's dump.
- [Turok: Rage Wars: matching N64 decompilation and Windows port](https://awesomerea.org/resources/turok-rage-wars-decomp-case/index.md): Case study · Turok: Rage Wars aims to reconstruct matching C source for four N64 releases and provides a native Windows port based on the USA v1.1 ROM. The port implements graphics, audio, input and virtual Controller Paks on Windows. The author reports that it runs menus and one-to-four-player matches; the port currently supports USA v1.1.
- [Friends of Mineral Town: decompiling the US GBA release](https://awesomerea.org/resources/friends-of-mineral-town-decomp-case/index.md): Case study · Friends of Mineral Town reconstructs the US Game Boy Advance release of Harvest Moon: Friends of Mineral Town from C++, C and assembly source. Its build produces a ROM with a stated SHA-1 target, and the setup uses a user-supplied base ROM for comparison.
- [JUS Decomp: a native port of the Nintendo DS game JUS](https://awesomerea.org/resources/jus-decomp-case/index.md): Case study · JUS Decomp statically recompiles the Nintendo DS game JUS into a native Windows and Linux port using ndsrecomp and a ROM supplied by the player. Its repository includes ARM9 and ARM7 decompilation metadata, runner patches, a reference-checking pipeline and runtime mod support.
- [TomodachiLifeDecomp: early 3DS decompilation](https://awesomerea.org/resources/tomodachi-life-decomp-case/index.md): Case study · TomodachiLifeDecomp begins reconstructing the US 1.0 Nintendo 3DS release of Tomodachi Life. Its C/C++ sources and symbol files are paired with scripts to build code.bin, compare symbols through asm-differ, and calculate progress. The author describes it as an early work in progress.
- [Animal Crossing: an Android port of the GameCube decompilation](https://awesomerea.org/resources/acgc-android-port-case/index.md): Case study · Animal Crossing Android Port runs decompiled GameCube game code natively on Android, building on an existing PC port. It translates GX graphics to OpenGL ES 3 and adds touch controls, a launcher that imports the user’s disc image, and on-device texture conversion.
- [SupComDecomp: reference decompilation of Forged Alliance](https://awesomerea.org/resources/supcom-decomp-case/index.md): Case study · SupComDecomp presents a C++ reference decompilation of the base Supreme Commander: Forged Alliance executable. It uses class type information, vestigial DLL symbols and assertion paths to recover names and source structure; the author states that the source does not compile.
- [OpenZT2: a Rust engine reimplementation of Zoo Tycoon 2](https://awesomerea.org/resources/openzt2-engine-case/index.md): Case study · OpenZT2 reimplements the Zoo Tycoon 2 engine in Rust and Bevy for use with the player's own game files. It renders original materials through Bevy with patched vkd3d-shader and MojoShader libraries and includes game systems for animals, construction, and visitors.
- [PacManRecomp: a native recompilation of NES Pac-Man](https://awesomerea.org/resources/pacmanrecomp-case/index.md): Case study · PacManRecomp builds a native Windows version of the 1993 Namco NES Pac-Man by translating the player's ROM from 6502 code to C with NESRecomp. Its launcher, runtime, and game additions are in the repository; the released package generates the game-code DLL on the player's computer. It also adds settings, high scores, mod support, and optional gameplay changes.
- [Bejeweled LIVE + decomp: a Windows Phone game ported to MonoGame](https://awesomerea.org/resources/bejeweled-live-plus-monogame-case/index.md): Case study · Bejeweled LIVE + decomp ports decompiled C# source from the Windows Phone 7 release of Bejeweled Classic to MonoGame. Its solution contains game, graphics, audio and interface code and builds after the user supplies the original XAP assets.
- [Shadow of the Colossus: a PS3 static recompilation reaching the flip loop](https://awesomerea.org/resources/shadow-of-the-colossus-ps3-recomp-case/index.md): Case study · Shadow of the Colossus uses ps3recomp to lift the PS3 HD remaster's EBOOT and eight SPU images into a native Windows build. The author reports that the build reaches cellGcmInit and the display flip loop, then stalls before opening nico.psarc because SPURS 2.0 support is missing.
- [Golden Sun Recompiled: native ports of two GBA games](https://awesomerea.org/resources/golden-sun-recompiled-case/index.md): Case study · Golden Sun Recompiled builds native Windows and Linux ports of Golden Sun and Golden Sun: The Lost Age from user-supplied GBA ROMs. A modified gbarecomp engine translates ARM and Thumb code to C++, while separate game configurations and shared port code support both titles.
- [Valkyrie Profile: a partial matching PlayStation decompilation](https://awesomerea.org/resources/valkyrie-profile-decomp-case/index.md): Case study · Valkyrie Profile decomp reconstructs parts of the Japanese Rev 1 PlayStation game as C that compiles to the original bytes. It covers the main executable and four overlays, with remaining functions retained as assembly. The author reports byte-matching outputs for all five units and warns that a build from a fresh clone may need local reference files.
- [Pilotwings64Decomp: matching decompilation of Pilotwings 64](https://awesomerea.org/resources/pilotwings-64-decomp-case/index.md): Case study · Pilotwings64Decomp reconstructs the North American Pilotwings 64 release as a matching source build. The repository includes C sources, versioned ROM configurations, extraction and rebuild steps, and documentation of the game's custom asset filesystem.
- [Star Fox: a matching SNES sound-driver disassembly](https://awesomerea.org/resources/star-fox-spc-driver-case/index.md): Case study · This project disassembles the N-SPC/Kankichi-kun SNES sound-driver variant used in Star Fox and Starwing. Its assembly source separates driver code, sound-effect tables, macros and instrument patches, and the build can compare the resulting SGSOUND0.BIN with an original copy.
- [VeronicaRecomp: a PC static recompilation of Resident Evil CODE:Veronica](https://awesomerea.org/resources/veronicarecomp-case/index.md): Case study · VeronicaRecomp uses ReXGlue SDK to statically recompile Resident Evil CODE:Veronica for native PC. Its CMake project includes a code generation target and builds an executable; users extract the required assets from their own game copy. The author describes the current build as playable but unfinished.
- [Pinball Fantasies Reassembled: recreating the DOS game engine](https://awesomerea.org/resources/pinball-fantasies-reassembled-case/index.md): Case study · Pinball Fantasies Reassembled recreates the 1993 DOS game engine in Rust using files from an original copy. Its technical notes map the MZ executables, per-table PRG programs, interrupt interfaces, sound drivers and user-data formats. The source includes asset readers, table simulation and tools for dissecting original files.
- [Metal Mutant: a browser engine reconstructed from the DOS game](https://awesomerea.org/resources/metal-mutant-web-case/index.md): Case study · Metal Mutant in the browser reimplements the 1991 DOS game's engine in JavaScript and runs the player's original scripts, graphics and sounds. It rewrites the interpreter, object scheduler, renderer, interrupts and PC-speaker audio routine by routine; the author reports frame-by-frame memory and screen comparisons with the original.
- [Kirby: Nightmare in Dream Land: a matching Game Boy Advance decompilation](https://awesomerea.org/resources/kirby-nightmare-in-dream-land-decomp-case/index.md): Case study · Kirby: Nightmare in Dream Land decomp reconstructs the USA Game Boy Advance game in C with small runtime sections retained as labelled assembly. The author reports a byte-identical ROM build checked by SHA-1, plus shift and emulator boot checks; graphics, audio and other assets are taken from the user's own cartridge dump.
- [Pilotwings 64: Recompiled — a native N64 static recompilation port](https://awesomerea.org/resources/pilotwings-64-recompiled-case/index.md): Case study · Pilotwings 64: Recompiled ports the USA N64 game to Windows and Linux with N64Recomp. Game-specific C patches widen the 3D view and move the HUD, while matrix interpolation supports higher display frame rates.
- [BugsDecomp: decompiling Bugs Bunny: Lost in Time for PC](https://awesomerea.org/resources/bugsdecomp-case/index.md): Case study · BugsDecomp reconstructs functions from the PC game Bugs Bunny: Lost in Time for versions 1.0 and 1.6. A DLL and launcher patch decompiled functions into the running game, while accompanying notes document function locations and the BZE level-file format.
- [Kirby 64: Recompiled — a ROM-based native port](https://awesomerea.org/resources/kirby-64-recompiled-case/index.md): Case study · Kirby 64: Recompiled builds a native executable for Kirby 64 from a user-provided NK4E.z64 ROM. The repository includes C++ host code and a build configuration, and directs users to build with Make and Clang.
- [Raptor: porting a reconstructed Call of the Shadows codebase](https://awesomerea.org/resources/raptor-source-port-case/index.md): Case study · Raptor ports a reverse-engineered Raptor: Call of the Shadows codebase to modern desktop systems and Android. Its build uses CMake and SDL2, while the game loads GLB assets supplied from the player's own shareware or full version.
- [NFS Carbon NX: a Switch recompilation of Need for Speed: Carbon](https://awesomerea.org/resources/nfs-carbon-nx-case/index.md): Case study · NFS Carbon NX ports the Xbox 360 release of Need for Speed: Carbon to Nintendo Switch by translating its PowerPC executable to C++ and compiling it for ARM64. Its Vulkan renderer draws Xenos commands through Mesa NVK, while game-specific fast paths cover audio, cutscenes, texture handling and uploads. Standard and Collector's Edition builds share the runtime.
- [dream: Dream: Land of Giants disassembled and reimplemented in C](https://awesomerea.org/resources/dream-land-of-giants-case/index.md): Case study · dream reconstructs the SNES prototype Dream: Land of Giants through a byte-matching 65816 and SPC700 disassembly and a C reimplementation. A harness runs the original ROM beside converted routines and compares memory, graphics, audio, and processor state under scripted input.
- [3S Decomp OGXB: original Xbox Street Fighter III: 3rd Strike decompilation](https://awesomerea.org/resources/3s-decomp-ogxb-case/index.md): Case study · 3S Decomp OGXB reconstructs the original Xbox Street Fighter III: 3rd Strike executable as C, carrying shared bodies from a PS2 decompilation and analysing Xbox-specific code. Its tools scan the retail XBE, compare compiled functions with retail bytes, and relink objects into the image; the author reports a byte-identical relinked XBE.
- [Pokepark Wii: an in-progress Wii decompilation](https://awesomerea.org/resources/pokepark-wii-decomp-case/index.md): Case study · Pokepark Wii decomp reconstructs source for the USA Rev 0 Wii release of Pokepark Wii. The repository has game source files and R8AE01 build configuration; its workflow reads the user's disc image, generates build files and uses Ninja and objdiff for source comparison.
- [Golden Sun: a matching GBA decompilation with overlay comparisons](https://awesomerea.org/resources/golden-sun-gba-decomp-case/index.md): Case study · Golden Sun reconstructs source for the USA GBA game from an earlier disassembly and checks a rebuilt ROM against the original. Its patched GCC 2.96 build also compares all 96 code overlays, while C source, assembly fragments, linker scripts, and symbol maps track the ongoing recovery.
- [Medabots: Rokusho Version: a matching GBA decompilation](https://awesomerea.org/resources/medabots-rokusho-decomp-case/index.md): Case study · Medabots: Rokusho Version reconstructs the USA Game Boy Advance game's functions as C compiled with agbcc. Its build inserts graphics, sound and other data from the user's baserom, then compares the resulting ROM with the original. The author reports all functions decompiled and a matching ROM build; module reorganization continues.
- [Castlekeep: a Stronghold 1 engine reimplementation](https://awesomerea.org/resources/castlekeep-stronghold-case/index.md): Case study · Castlekeep reimplements Stronghold 1 as a C++ game engine. Its code initializes a world, loads assets, generates terrain and renders it through an SDL2 platform layer and OpenGL renderer.
- [Snipes: porting the 1982 DOS game from its executable](https://awesomerea.org/resources/snipes-dos-port-case/index.md): Case study · Snipes ports the 1982 DOS text-mode game from reverse-engineered executable code to modern C++ builds. It offers SDL and Windows console front ends and adds replay recording and playback. The author reports identical game logic to the original.
- [OpenDeathValley: Desperados file readers and script disassembly](https://awesomerea.org/resources/opendeathvalley-case/index.md): Case study · OpenDeathValley develops an engine for Desperados: Wanted Dead or Alive around readers for the game's resource files. Its C code parses DVD, DVF, DVM, SCB and other formats, can extract selected images as BMP files, and includes an SCB script disassembler with named game functions.
- [West Bank: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/west-bank-disassembly-case/index.md): Case study · westbank presents a SkoolKit disassembly of West Bank, the ZX Spectrum version of Bank Panic. It stores the annotated skool source and scripts for generating hexadecimal or decimal HTML disassembly pages.
- [Emerald 3DS: a native Nintendo 3DS port of Pokémon Emerald](https://awesomerea.org/resources/emerald-3ds-case/index.md): Case study · Emerald 3DS ports Pokémon Emerald's decompiled game code to native Nintendo 3DS execution. A C bridge supplies GBA register, video, audio and input behavior on ARM11, while a builder derives game data from the user's supported ROM; the port adds a touch interface and an optional voxel overworld.
- [Final Fantasy Tactics Recompiled: a local PlayStation recompilation](https://awesomerea.org/resources/finfantac-recomp-case/index.md): Case study · Final Fantasy Tactics Recompiled uses PSXRecomp to generate and compile the USA PlayStation game's code from a user-supplied disc. Its setup kits target Windows, Linux and macOS and include a game-specific framework patch and optional 16:9 battle view. The author reports validation of the title, church scenes and first battle; full-game behavior remains untested.
- [Ocarina of Time: an NTSC 1.0 ROM disassembly](https://awesomerea.org/resources/oot-ntsc-1-disassembly-case/index.md): Case study · Ocarina of Time 1.0 Disassembly records the NTSC 1.0 Nintendo 64 game's code as assembly files for documentation. The project splits actor routines and the central code file into named sections, with a file map showing memory addresses and subsystem purposes.
- [Silkroad Online: reconstructing SR_GameServer](https://awesomerea.org/resources/vsro-server-decomp-case/index.md): Case study · Silkroad Online's SR_GameServer is being reconstructed in C++ from research into native server behavior. The repository includes game and server logic, supporting libraries, evidence notes and focused regression tests. Its documented reference is a v1.188 executable, and the implementation remains incomplete.
- [Dragon Ball Z: Buu's Fury: a byte-checked GBA disassembly](https://awesomerea.org/resources/dragon-ball-z-buus-fury-disassembly-case/index.md): Case study · Dragon Ball Z: Buu's Fury disassembly rebuilds the US Game Boy Advance release from ARM and Thumb assembly, a small amount of C, and generators that recover assets from the user's ROM. The build checks the result against the retail digest and tracks which bytes still come from raw slices. The author reports that 94.0959% of ROM bytes are produced from tracked source.
- [Super Tennis Disassembly: matching Sega Master System assembly](https://awesomerea.org/resources/super-tennis-sms-case/index.md): Case study · Super Tennis Disassembly reconstructs the Sega Master System game Super Tennis in WLA DX assembly. It targets the Japanese revision 0 and USA/European revision 1 and provides a Docker-based assembly process that emits ROM and debugger symbol files.
- [AceCombat3-xport: an Ace Combat 3 PlayStation decompilation port](https://awesomerea.org/resources/acecombat3-xport-case/index.md): Case study · AceCombat3-xport ports reconstructed code from the Project Nemo edition of the PlayStation game Ace Combat 3: Electrosphere. Its startup code loads ACE3.BIN from DATA, while an extraction script processes the game's resource archives and XA sectors.
- [Killzone Shadow Fall: a native Windows port with Vulkan graphics](https://awesomerea.org/resources/killzone-shadow-fall-pc-case/index.md): Case study · Killzone Shadow Fall for PC runs the PS4 game's code directly on a Windows CPU and translates its graphics to Vulkan at runtime. Its launcher points to a user-supplied version 01.81 game dump containing eboot.bin; the author reports campaign playability in a public beta.
- [cuwo: reconstructing the Cube World server protocol](https://awesomerea.org/resources/cuwo-cube-world-server-case/index.md): Case study · cuwo reconstructs a Cube World server in Python and C++ and documents implemented player, combat, world and object messages. A bundled MITM proxy supports reverse engineering by manipulating and injecting packets between the client and server.
- [PsyDoom: a native PC port of PlayStation Doom and Final Doom](https://awesomerea.org/resources/psydoom-case/index.md): Case study · PsyDoom ports PlayStation Doom and Final Doom to modern PCs from code derived from the PlayStation machine code. The author describes a gradual conversion from emulated MIPS instructions to C++, emulates the original GPU and SPU behavior, and adds an optional Vulkan renderer. The author reports matching four recorded playthroughs when given the same player inputs.
- [ClassiCube: a clean-room reconstruction of Minecraft Classic](https://awesomerea.org/resources/classicube-case/index.md): Case study · ClassiCube recreates the 2009 Minecraft Classic client in C through a documented clean-room reverse-engineering approach. It supports single-player and compatible multiplayer play across desktop, mobile, browser and several console platforms, with optional custom blocks, models and environment colors.
- [Way of the Samurai 2: a native port from hand-decompiled PS2 code](https://awesomerea.org/resources/way-of-the-samurai-2-native-case/index.md): Case study · Way of the Samurai 2 runs the PS2 game's hand-decompiled MIPS functions as native C++ with OpenGL and SDL2 host layers. It loads data from the user's NTSC-U disc and includes a reconstructed Sol script compiler and VM; the author reports play through to the ending with visual and timing limits.
- [smt4-recomp: a 3DS Shin Megami Tensei IV static recompilation](https://awesomerea.org/resources/smt4-recomp-case/index.md): Case study · smt4-recomp builds a native PC version of the USA 3DS release of Shin Megami Tensei IV by translating its ARM code to C with 3dsrecomp. Zakuro supplies the kernel, services, graphics and sound runtime; project overrides add widescreen and gameplay options.
- [Dragon Quest Monsters German: a banked Game Boy Color disassembly](https://awesomerea.org/resources/dragon-quest-monsters-german-case/index.md): Case study · Dragon Quest Monsters German is a Game Boy Color disassembly organized into banked assembly files. Its RGBDS Makefile assembles the source and links a game.gbc ROM.
- [Hybrid Heaven: an AI-assisted matching N64 decompilation](https://awesomerea.org/resources/hybrid-heaven-decomp-case/index.md): Case study · Hybrid Heaven reconstructs the 1999 Nintendo 64 game as C that is compared byte for byte with a user-supplied ROM. The repository includes function matching, register tracing, ROM packing and agent orchestration tools, plus per-batch research on model-assisted decompilation. The author reports 78.75% of code bytes matched at the stated update.
- [Shining Force III Recomp: a Sega Saturn static recompilation for PC](https://awesomerea.org/resources/shining-force-iii-recomp-case/index.md): Case study · Shining Force III Recomp generates C++ from the SH-2 code on supported Sega Saturn discs and compiles a native PC port with graphics, sound, and storage services. Exact-content profiles cover the original US Scenario 1 and selected translated revisions of Scenarios 1–3; the author reports playable selected Windows routes.
- [Dangerous Dave 2: Modification Edition: a configurable remake](https://awesomerea.org/resources/dangerous-dave-2-modification-edition-case/index.md): Case study · Dangerous Dave 2: Modification Edition recreates Dangerous Dave 2 as a configurable engine that loads external mod packs. It supports resizable levels, animated tiles, resource packs and a Tiled-based editor; its new level format needs a converter for original levels.
- [agario-client: reconstructing the earlier agar.io client protocol](https://awesomerea.org/resources/agario-client-case/index.md): Case study · agario-client is a Node.js implementation of an earlier agar.io client protocol. It connects over WebSockets, parses game packets, and provides API methods for movement, spawning and spectating alongside events for ball-state changes. The author stopped development after a later game update changed the client implementation.
- [The Simpsons Arcade Game: recompiling the PS3 arcade wrapper](https://awesomerea.org/resources/simpsons-arcade-ps3-case/index.md): Case study · The Simpsons Arcade Game PS3 project recompiles the PSN release's PowerPC EBOOT into a native PC program with ps3recomp. It lifts captured SPU jobs and documents how the EBOOT emulates the original arcade hardware while interpreting the 6809 game ROM. The author reports playable Stage 1 gameplay, saving and two-instance online co-op.
- [AutoDestruct-xport: a native port of Auto Destruct](https://awesomerea.org/resources/autodestruct-xport-case/index.md): Case study · AutoDestruct-xport ports the PlayStation game Auto Destruct from decompiled code into a C runtime with Windows and web entry points. Its project notes describe native saves, CD data access, FMV playback and reviewed executable addresses.
- [god-hand-decomp: matching decompilation of God Hand](https://awesomerea.org/resources/god-hand-decomp-case/index.md): Case study · god-hand-decomp reconstructs the NTSC-U PS2 release of God Hand as C/C++ that is checked against the retail boot ELF. It starts from assembly generated by splat, replaces functions individually, and uses objdiff plus a full-file SHA-256 comparison to track matching output. The author reports that the current build remains byte-identical to the retail boot ELF.
- [Paperboy: an in-progress matching Nintendo 64 decompilation](https://awesomerea.org/resources/paperboy-n64-decomp-case/index.md): Case study · Paperboy reconstructs C and C++ for the Nintendo 64 game, replacing assembly inclusions function by function. Its build uses a user-supplied ROM and the original SN compiler, compares functions with asm-differ and checks the NTSC output against a SHA-1 checksum.
- [FinFan: rebuilding Final Fantasy from ROM analysis](https://awesomerea.org/resources/finfan-case/index.md): Case study · FinFan remakes the original Final Fantasy in C++ and Allegro using graphics and data tables extracted from a user-supplied US ROM. The author based much of the game code on a published disassembly, disassembled further sections and inferred behavior from observation, while changing several menus and battle features.
- [Project Picori: a native PC port of The Legend of Zelda: The Minish Cap](https://awesomerea.org/resources/project-picori-minish-cap-port-case/index.md): Case study · Project Picori ports The Legend of Zelda: The Minish Cap to native Linux, Windows and macOS builds using SDL3, a software PPU renderer and agbplay audio. It validates a user-provided USA, EU or JP ROM by SHA-1 and extracts the runtime assets needed by the port.
- [Doshin the Giant: a GameCube decompilation in progress](https://awesomerea.org/resources/doshin-the-giant-decomp-case/index.md): Case study · Doshin the Giant is a work-in-progress decompilation of the European GameCube release GKDP01. The project builds reconstructed C and C++ source using Python configuration and Ninja with a supplied disc image, and generates objdiff configuration for comparing object files with the original.
- [Oracles: reconstructing the Zelda Oracle games in Godot](https://awesomerea.org/resources/zelda-oracles-godot-reconstruction-case/index.md): Case study · Oracles reconstructs The Legend of Zelda: Oracle of Ages and Oracle of Seasons with a shared C# engine in Godot. It imports data from a pinned disassembly and uses original ROM behavior for timing, object order, collisions and state. Ages is described as playable; Seasons currently covers its opening and selected early-game rooms and events.
- [Dr. Mario 64: a GameCube decompilation](https://awesomerea.org/resources/drmario64-gc-case/index.md): Case study · drmario64-gc reconstructs source for the GameCube port of Dr. Mario 64 in Nintendo Puzzle Collection. The work targets Japanese Rev 0, builds against the user's disc image, and supplies source, symbol maps and split configuration for object-level comparison with objdiff.
- [Dr. Mario 64: matching decompilation across three releases](https://awesomerea.org/resources/dr-mario-64-decomp-case/index.md): Case study · Dr. Mario 64 reconstructs the Nintendo 64 game's code as a matching source build. It provides C and assembly sources, ROM extraction and rebuilding commands, and separate configurations for the US, iQue, and Gateway versions.
- [Open Annihilation: a Total Annihilation engine reimplementation](https://awesomerea.org/resources/open-annihilation-case/index.md): Case study · Open Annihilation reimplements a Total Annihilation game engine in C++20 and runs it with data from the player's copy of the original game. Its source covers the simulation, user interface, multiplayer, mod handling, and platform support, alongside module and file-format documentation.