# Curated reverse engineering resources · Page 28

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

## Games (100)

- [Super Mario Sunshine: a PS5 port of the decompiled game](https://awesomerea.org/resources/ps5-sunshine-case/index.md): Case study · PS5_Sunshine adapts the decompilation-based Super Mario Sunshine PC port to PlayStation 5 with platform code, SDL drivers and build patches. It compiles game code for the console and reads models, levels, sound and movies from the user's North American disc image.
- [Sonic Rush Adventure: an in-progress matching DS decompilation](https://awesomerea.org/resources/sonic-rush-adventure-decomp-case/index.md): Case study · Sonic Rush Adventure reconstructs the Nintendo DS game as a work-in-progress matching decompilation targeting the EU revision 00 ROM. The repository contains categorized disassembly and C sources, with matching functions still being developed.
- [reone: reconstructing the Knights of the Old Republic engine](https://awesomerea.org/resources/reone-kotor-engine-case/index.md): Case study · reone reconstructs an engine for Star Wars: Knights of the Old Republic and The Sith Lords in C++ using public file-format information and observations of the games and their resources. It loads files from a legally obtained copy, with SDL 2 and OpenGL 3.3 used by the custom engine.
- [Call of Duty 2: Big Red One: a native loader for the Xbox game](https://awesomerea.org/resources/cod2-bro-native-loader-case/index.md): Case study · Call of Duty 2: Big Red One runs on Linux and Windows through a native loader that maps the original Xbox x86 game code into a PC process and replaces Xbox platform services. Parts of the renderer, sound system and game code are rewritten as source, with function names grounded in Ghidra analysis and rewritten functions checked against the original through a comparison harness.
- [mgcarpet: reconstructing the Magic Carpet games with turn comparisons](https://awesomerea.org/resources/mgcarpet-case/index.md): Case study · mgcarpet rebuilds Magic Carpet, Hidden Worlds and Magic Carpet 2 in a Rust engine that imports data from the user's game copies. Its simulation is compared turn by turn with state and input recorded from retail executables in instrumented DOSBox; the author reports matching certified recordings while tracking exceptions. Rendering and audio are rewritten separately, with deliberate differences documented.
- [PANGYA Mobile: reconstructing the shutdown game service](https://awesomerea.org/resources/pangya-mobile-server-case/index.md): Case study · PANGYA Mobile reconstructs a self-hosted service for game version 1.0.21 and patches the user's APK to connect to it. Its TypeScript server handles login, lobby, story, shops and other game functions, using game data from the APK and asset bundles; a protobuf schema describes network messages.
- [ssb64-dc: porting Super Smash Bros. to Dreamcast](https://awesomerea.org/resources/ssb64-dc-dreamcast-port-case/index.md): Case study · ssb64-dc ports the N64 Super Smash Bros. decompilation to Sega Dreamcast. It replaces N64 graphics, audio, and memory paths with Dreamcast implementations, while build tools convert assets from the user's US ROM. The author describes the port as playable but still affected by minor visual issues.
- [Red Dead Revolver - XBE Recomp: an original Xbox static recompilation port](https://awesomerea.org/resources/red-dead-revolver-xbe-recomp-case/index.md): Case study · Red Dead Revolver - XBE Recomp ports the original Xbox game to Windows through static recompilation with Xbox XBE Recomp. It uses game files supplied by the user and adds display and graphics settings, texture dumping and replacement, and keyboard, mouse and controller input.
- [Cranked: reconstructing the Playdate runtime](https://awesomerea.org/resources/cranked-playdate-case/index.md): Case study · Cranked reconstructs a runtime for Playdate console games by emulating its ARM processor with Unicorn and implementing the Playdate API across native, Lua and C++ calls. Development compares program execution with the official simulator, and the emulator accepts .pdx directories or .pdx.zip archives. The author reports compatibility mainly with SDK demos so far.
- [Wario Land 4: rebuilding US/EU and Japanese GBA ROMs](https://awesomerea.org/resources/wario-land-4-decomp-case/index.md): Case study · Wario Land 4 is an unfinished GBA decompilation that builds US/EU and Japanese ROM versions from source and assets extracted from the user's base ROM. Its build uses agbcc, ARM binutils and Python tooling, and reports a checksum result for the output.
- [Alien vs Predator: reconstructing the Atari Jaguar cartridge](https://awesomerea.org/resources/alien-vs-predator-jaguar-case/index.md): Case study · Alien vs Predator reconstructs the 1994 Atari Jaguar game's Motorola 68000 code and cartridge build from source. The build combines reconstructed and exact-fit modules with data extracted locally from the user's World retail image; the author reports a byte-for-byte match of the resulting cartridge.
- [SF33RDSXBRecompo: an Xbox 3rd Strike native port](https://awesomerea.org/resources/sf33rdsxbrecompo-case/index.md): Case study · SF33RDSXBRecompo ports the Xbox version of Street Fighter III: 3rd Strike to Windows, Linux and Android using C game logic from 3s-decomp-ogxb. It replaces Xbox services with SDL3, Vulkan or OpenGL, OpenAL and SQLite, while importing game archives and sound banks from the player's disc.
- [Urban Reign PC Port: a PS2 static recompilation](https://awesomerea.org/resources/urban-reign-pc-port-case/index.md): Case study · Urban Reign PC Port translates the USA PlayStation 2 game's code into C++ for native Windows and Linux builds. It uses the PCSX2 renderer through DirectX 11 or Vulkan and adds higher internal resolutions, widescreen display and multiplayer controls. Code generation reads the user's own SLUS-21209 disc image.
- [Real War: a function-level PC game decompilation](https://awesomerea.org/resources/real-war-decomp-case/index.md): Case study · Real War decompiles the 2001 PC game into C source, mapping files and symbols to virtual executable addresses. Its tools diff functions, rebuild the executable, verify the result, and inspect the game's BIGFILE, BSE, KVAG, SPT, and TGC asset formats.
- [Angry Birds ARM64: reconstructing the Angry Birds 1.4.2 Android runtime](https://awesomerea.org/resources/angry-birds-arm64-case/index.md): Case study · Angry Birds ARM64 rebuilds the native runtime of Angry Birds 1.4.2 for AArch64 Android devices so the game's Lua logic can run with locally supplied game data. The work uses ARMv7 runtime analysis and behavioral comparisons to reconstruct rendering, input, physics bridges, audio, persistence and Android lifecycle services.
- [FreeHeroes: a Heroes of Might and Magic III engine recreation](https://awesomerea.org/resources/freeheroes-case/index.md): Case study · FreeHeroes recreates Heroes of Might and Magic III in a C++ engine with a battle emulator and a one-time converter for original SoD, HotA and HD game resources. It can also start with substitute resources; the author describes the project as unfinished.
- [Ratatouille: matching the January 2006 prototype](https://awesomerea.org/resources/ratatouille-2006-prototype-case/index.md): Case study · The project reconstructs C/C++ source for the January 18, 2006 Ratatouille prototype and compares builds with four original GameCube ELF variants. It uses build scripts and objdiff for function-level comparison; the author reports that matched code is byte-identical while the overall decompilation remains unfinished.
- [Scooby-Doo! Mystery Mayhem: a Rust and Bevy PS2 game port](https://awesomerea.org/resources/scooby-doo-mystery-mayhem-pc-case/index.md): Case study · Scooby-Doo! Mystery Mayhem is a Rust and Bevy PC port of the PlayStation 2 game, built from reverse-engineered engine and game-logic modules. It loads levels, media and module data at runtime from the owner's ISO, with notes tracing MIPS module behavior and engine interfaces.
- [Battlezone: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/battlezone-spectrum-disassembly-case/index.md): Case study · Battlezone documents a SkoolKit disassembly of the ZX Spectrum game and provides scripts that generate a browsable HTML listing. The repository contains the game's SkoolKit source, control file and reference files.
- [Kanken Training 2: matching reconstruction of a Nintendo 3DS executable](https://awesomerea.org/resources/kanken-training-2-decomp-case/index.md): Case study · Kanken Training 2 decomp reconstructs the Nintendo 3DS game's code.bin as C/C++ compiled with an ARM toolchain and compared byte for byte with the original. It records function analysis, matching recipes and checkpoint results. The author reports 2,832 accepted matching functions out of 4,545 creditable functions; readability work remains.
- [sm_disassembly: a relocatable Super Metroid disassembly](https://awesomerea.org/resources/super-metroid-disassembly-case/index.md): Case study · sm_disassembly provides a relocatable assembly disassembly of the SNES game Super Metroid, organized into bank files and based on earlier bank logs. Build scripts extract assets from the user's original NTSC ROM and assemble the source with asar 1.81.
- [Pepsiman: a matching PlayStation decompilation](https://awesomerea.org/resources/pepsiman-matching-decomp-case/index.md): Case study · Reconstructs C source for the Japanese PlayStation release of Pepsiman, including its main executable and 22 code overlays. The build compares output byte for byte with files extracted from a user-supplied retail disc.
- [Freedom: mapping Freedom Fighters scene and asset formats](https://awesomerea.org/resources/freedom-fighters-formats-case/index.md): Case study · Freedom investigates Freedom Fighters map-data formats used by the Glacier engine. Python tools dump GMS entities, PRM geometry, TEX textures, LOC localization, and ZGF font data; the author reports exporting scenes and models to OBJ while several format fields remain unresolved.
- [Bloodborne: a native Windows port of the PS4 executable](https://awesomerea.org/resources/bloodborne-pc-windows-port-case/index.md): Case study · Bloodborne PC Windows Port runs the PS4 game's x86-64 executable directly on a Windows PC. It adapts a Linux port with Win32 memory, threading, and file services, while a shadPS4-based core translates PS4 graphics to Vulkan; the user supplies the decrypted game files.
- [wkbre: reconstructing the Warrior Kings engine](https://awesomerea.org/resources/wkbre-case/index.md): Case study · wkbre reimplements the Warrior Kings and Warrior Kings: Battles engine to open original game data, load levels and render the world. Its current editor can modify savegames and terrain and create skirmish maps for the original engine; gameplay in the replacement engine remains under development.
- [RodLegacy: reimplementing Street Rod and Street Rod 2](https://awesomerea.org/resources/rodlegacy-case/index.md): Case study · RodLegacy reimplements Street Rod and Street Rod 2 in C++ for modern systems, reading game data from user-supplied Amiga disk images. Its game code covers cars, races, scenes, sound and save files, with optional car-set mixing and several soundtrack sources. The author describes both games as playable while development and bug fixing continue.
- [OpenSC2K: recreating SimCity 2000 in Rust and Godot](https://awesomerea.org/resources/opensc2k-case/index.md): Case study · OpenSC2K recreates SimCity 2000 with a Godot front end and Rust libraries for simulation, file formats, rendering, audio and scripting. It imports graphics, text, sound and music from the player's own game copy and supports original .sc2 city files alongside its extended .sc2x format.
- [Another World Suite: a WebAssembly engine and debugger](https://awesomerea.org/resources/another-world-suite-case/index.md): Case study · Another World Suite implements the Another World game engine in Rust and compiles it to WebAssembly for browser use. Its frontend includes a debugger with thread and register views, plus resource views for scripts, bitmaps, palettes and sounds.
- [Amplitude: reconstructed PlayStation 2 game source](https://awesomerea.org/resources/wavelength-amplitude-case/index.md): Case study · Amplitude reconstructs source for the 2003 PlayStation 2 rhythm game and builds its main executable and IOP modules with ps2dev tools. A user-provided North American or European disc supplies assets for a rebuilt image. The author reports playable builds of both releases; the European DNAS2 online library remains unrecovered.
- [OpenNFS1: rebuilding the original Need for Speed from CD data](https://awesomerea.org/resources/opennfs1-case/index.md): Case study · OpenNFS1 rebuilds the original Need for Speed in C# and MonoGame using data from the 1995 game CD. Its source includes parsers for track, vehicle, texture and audio data alongside a replacement racing engine.
- [Rumble Fighter: an early executable decompilation](https://awesomerea.org/resources/rumble-fighter-decomp-case/index.md): Case study · Rumble Fighter reconstructs parts of the game's Windows executables in C++. The project reports function coverage and similarity for rumblefighter.exe, RumbleLauncher.exe and Home.exe, and builds with CMake, NMake and an MSVC installation.
- [rawpsx: an Another World engine reimplementation for PlayStation](https://awesomerea.org/resources/rawpsx-another-world-case/index.md): Case study · rawpsx rewrites the Another World engine in C for the original PlayStation, adapting the earlier rawgl implementation with PSn00bSDK. It reads BANKxx and MEMLIST.BIN from a player's DOS copy and builds a PlayStation ISO. The author reports that the software-rendering branch runs the full DOS version.
- [GLOVER-R: a native recompilation of Glover](https://awesomerea.org/resources/glover-r-case/index.md): Case study · GLOVER-R recompiles Glover for Windows and Linux from a user-supplied Nintendo 64 ROM, using a game-specific patch pipeline that checks hooks against original instructions. It adds widescreen rendering, frame interpolation, configurable controls and a modern camera. The author reports Windows gameplay testing; Linux and Steam Deck gameplay testing remains pending.
- [Pokémon Snap: a work-in-progress Nintendo 64 decompilation](https://awesomerea.org/resources/pokemon-snap-decomp-case/index.md): Case study · pokemonsnap reconstructs source for the US Nintendo 64 release of Pokémon Snap. Its setup uses a user-supplied ROM, runs extraction and disassembly through configure.py, and rebuilds a ROM with Ninja. The repository contains game C and assembly files, build configuration, and comparison tooling.
- [Mario Kart Wii 3DS: a native port built from the player's disc](https://awesomerea.org/resources/mkw-3ds-case/index.md): Case study · Mario Kart Wii 3DS continues a native Nintendo 3DS port of Mario Kart Wii, building an installable CIA from the player's USA disc image. The builder converts courses, characters, vehicles, menus, movies and sound; the runtime uses recreated kart physics and 3DS-specific rendering, audio and menus.
- [Redline Recompiled: Forza Motorsport ported by static recompilation](https://awesomerea.org/resources/redline-recompiled-forza-motorsport-case/index.md): Case study · Redline Recompiled ports the 2005 Xbox release of Forza Motorsport to Windows by statically translating the game’s x86 code and supplying new graphics, sound and input layers. Its launcher extracts and builds from the user’s USA Rev 1 disc image or game folder. The project includes an x86-to-C lifter, function-discovery tools and a host runtime.
- [Desktop Adventures: a ScummVM engine for Indiana Jones and Yoda Stories](https://awesomerea.org/resources/scummvm-deskadv-case/index.md): Case study · Desktop Adventures reconstructs a ScummVM engine for Indiana Jones Desktop Adventures and Yoda Stories. It detects original and demo releases by file hashes, reads DAW and DTA resources, loads cursors from the original executables, and provides graphics and sound components.
- [Ratchet & Clank: Going Mobile: output-matched Java reconstruction](https://awesomerea.org/resources/going-mobile-java-reconstruction-case/index.md): Case study · Ratchet & Clank: Going Mobile reconstructs ten Java classes for game version 1.1.0. Its pipeline compiles with Sun javac 1.4.1, runs ProGuard 3.2 and WTK 2.2 preverification, then compares methods and class files with retail output; the author reports exact matches for all ten classes.
- [F0X: an Apple platform port of F-Zero X](https://awesomerea.org/resources/f0x-f-zero-x-case/index.md): Case study · F0X ports F-Zero X to Apple Silicon macOS, iPhone and iPad using G-Diffuser's decompiled game logic. Maintained patches connect the game to libultraship/Fast3D's Metal backend, while Torch extracts a local game archive from the player's US revision 0 ROM.
- [Resident Evil 3: Nemesis Recompiled: a PlayStation setup candidate](https://awesomerea.org/resources/resident-evil-3-nemesis-recomp-case/index.md): Case study · Resident Evil 3: Nemesis Recompiled provides a title-specific PSXRecomp setup candidate for the European PlayStation release. Its wizard is configured to take the user's SLES-02529 disc, matching SBI companion and SCPH-5502/5552 BIOS for local code generation and compilation. The repository includes configuration, seed data and setup code.
- [Hazard: Revenge — a reconstructed Hazard engine using SDL](https://awesomerea.org/resources/hazard-revenge-case/index.md): Case study · Hazard: Revenge rebuilds the engine of the Korean action RPG Hazard, routing its Windows and DirectX calls through SDL while retaining the game's logic. It supports desktop and iOS builds and reads three separately supplied game PAK files.
- [Open1560: partial reconstruction of Midtown Madness build 1560](https://awesomerea.org/resources/open1560-case/index.md): Case study · Open1560 partially reimplements Midtown Madness Sneak Preview Beta build 1560 in C++, retaining assembly for functions not yet rewritten. Its source adds an OpenGL renderer, controller support and fixes, while its methodology notes identify builds and discuss disassembly. Running it requires data from a user's installation of the original game.
- [Need for Speed: SHIFT: an Xbox 360 ReXGlue recompilation](https://awesomerea.org/resources/nfs-shift-xbox360-recomp-case/index.md): Case study · Need for Speed: SHIFT is being reconstructed from its Xbox 360 PowerPC executable through ReXGlue ahead-of-time translation to C++ and a native Linux runtime. Game-specific work covers XEX analysis, kernel integration and Xenos command rendering through Vulkan. The author reports that the retail boot chain reaches Menu Setup state 2, where it currently stalls.
- [Crash Twinsanity for Windows: adapting a PS2 decompilation to native Windows](https://awesomerea.org/resources/crash-twinsanity-windows-case/index.md): Case study · Crash Twinsanity for Windows adapts an existing C++ decompilation and Mac port of the PAL PlayStation 2 game to native 64-bit Windows. It adds Windows calling-convention and memory handling, frame pacing and game-specific crash fixes, while reading game data from the user's disc image. The author reports playing the release through to the credits.
- [.hack//INFECTION: an early matching PlayStation 2 decompilation](https://awesomerea.org/resources/dothack-infection-decomp-case/index.md): Case study · .hack//INFECTION reconstructs source for the North American PlayStation 2 release and uses objdiff to compare compiled functions with objects generated from the user’s retail executable. Its initial progress scope covers resident Emotion Engine functions, with one function reported as matching after call-relocation normalization. Overlays, VU microcode and IOP modules remain outside that scope.
- [Persona 3 FES Recompiled: a PS2 static recompilation](https://awesomerea.org/resources/persona-3-fes-recompiled-case/index.md): Case study · Persona 3 FES Recompiled translates the PS2 game's MIPS R5900 executable to C++ and runs it with replacement EE, IOP, graphics, audio, and storage services. Its game-specific function map and configuration drive the recompiler. The author reports play through the opening story and a Tartarus area loaded from a memory card save; sound effects are silent and battles remain untested.
- [Hamtaro in Pieces: an incomplete Game Boy Color disassembly](https://awesomerea.org/resources/hamtaro-in-pieces-case/index.md): Case study · Hamtaro in Pieces disassembles the North American Game Boy Color release of Hamtaro: Ham-Hams Unite!. RGBDS assembles the recovered source, using a user-supplied base ROM for incomplete regions, and the Makefile compares the resulting ROM with the original. Crystal tools support the build.
- [Doom 64 EX+: a continuation of the Doom 64 recreation](https://awesomerea.org/resources/doom64ex-plus-case/index.md): Case study · Doom 64 EX+ continues the Doom 64 engine recreation with support for the 2020 remaster's IWAD, Lost Levels and KPF content. Its C source uses SDL3 and adds PWAD loading and other modding features, running on assets from the user's remaster copy.
- [libmkb: reconstructing Super Monkey Ball 2 systems as a C++ library](https://awesomerea.org/resources/libmkb-case/index.md): Case study · libmkb is a partial C++ library project aiming to reconstruct Super Monkey Ball 2's physics, camera and control code. Its goals are readable source, behavior close to the original and use with a graphical frontend. The build currently compiles a limited set of modules.
- [tactical-decomp: matching recovery of Final Fantasy Tactics](https://awesomerea.org/resources/tactical-decomp-case/index.md): Case study · tactical-decomp reconstructs the USA PlayStation release of Final Fantasy Tactics as C89 matched against the original executable and disc blobs. It splits user-supplied disc data, replaces assembly stubs function by function and checks rebuilt bytes with comparison tools. A related static recompilation directory uses the decompilation's address map as input.
- [kfiv-decomp: matching decompilation of King's Field IV](https://awesomerea.org/resources/kfiv-decomp-case/index.md): Case study · kfiv-decomp reconstructs King's Field: The Ancient City's USA PlayStation 2 executable as matching C and assembly. Its build extracts a user-supplied disc, splits the executable with splat, and checks the linked ROM SHA-1; the author reports a byte-identical result while much game code remains assembly.
- [Twisted Metal: lifting the PS3 game into a native Windows build](https://awesomerea.org/resources/twisted-metal-2012-static-recompilation-case/index.md): Case study · Twisted Metal lifts the 2012 PS3 game's PowerPC EBOOT.BIN into C++ and links it with ps3recomp for a native Windows build. Its analysis notes cover imports, function boundaries, SPU images and boot behavior; the author reports reaching a match and drawing its HUD while the 3D world remains blocked.
- [Nightmare Creatures: PlayStation executable analysis and native PC port](https://awesomerea.org/resources/nightmare-creatures-pc-port-case/index.md): Case study · Nightmare Creatures ports the USA PlayStation game to macOS, Windows, and Linux using a user-supplied CHD image. Its runtime interprets the original processor code while native components handle graphics, sound, input, and saves; separate tools analyse the game's executables and progressively translate code into C.
- [OpenSpidey: a native Spider-Man (2000) PC rebuild](https://awesomerea.org/resources/openspidey-spider-man-port-case/index.md): Case study · OpenSpidey rebuilds the PC version of Spider-Man (2000) as a native SDL3 and OpenGL application using an attributed earlier decompilation and the player's own game data. Its setup imports files from a disc ISO or installed folder, and a comparison tool places original game functions beside rebuilt DLL functions. The author describes the game restoration and matching decompilation as unfinished.
- [Yakuza: an in-progress PlayStation 2 decompilation](https://awesomerea.org/resources/ogre-yakuza-decomp-case/index.md): Case study · Ogre-Decomp is an in-progress decompilation of the PlayStation 2 game Yakuza. Its script runs splat splitting, assembly delinking and MWCC compilation, while configuration maps the game's main and game overlays and records target hashes.
- [Spider-Man (2002): a static recompilation of the Xbox game for Windows](https://awesomerea.org/resources/spider-man-2002-xbox-pc-case/index.md): Case study · The Spider-Man (2002) PC port uses xboxrecomp to translate the original Xbox game's code to C for a native Windows executable. A user-supplied default.xbe and data directory feed the build; the repository adds game-specific rendering, controls, settings and optional enhancements generated from that copy.
- [Digimon Digital Card Battle: a three-region matching decompilation](https://awesomerea.org/resources/dcb-decomp-case/index.md): Case study · dcb_decomp reconstructs the PlayStation Digimon Digital Card Battle executable and overlays in C and assembly for US, Japanese and European releases. The author reports byte-identical builds of game code and data from one source tree, measured with objdiff. The repository records remaining source-form workarounds and assembly in linked PsyQ library code.
- [Kirby Air Ride: a GameCube DOL decompilation](https://awesomerea.org/resources/kirby-air-ride-decomp-case/index.md): Case study · Kirby Air Ride reconstructs a GameCube main.dol from C and assembly source for the US/Korean release. Its build targets a stated SHA-1 and uses a user-provided clean DOL with GameCube SDK and CodeWarrior tools.
- [BearBirdPad: a Banjo-Kazooie recompilation port for iPhone and iPad](https://awesomerea.org/resources/bearbirdpad-banjo-kazooie-ios-case/index.md): Case study · BearBirdPad ports the BanjoRecomp version of Banjo-Kazooie to iPhone and iPad. Its iOS integration adds Metal rendering, movable touch controls, controller handling, local ROM import and save storage. Build scripts generate the game module from a player's supported NTSC-U 1.0 ROM.
- [Fable: The Lost Chapters: function-level reconstruction of the PC executable](https://awesomerea.org/resources/fable-the-lost-chapters-decomp-case/index.md): Case study · FableDecomp reconstructs the 32-bit Windows Fable: The Lost Chapters executable as VC7.1-compatible C/C++ source, checking functions against retail bytes and behavior. The repository also records engine and file-format findings and an interactive frontend checkpoint. The author reports a September 2026 snapshot of 8,082 byte-identical functions; a playable reconstructed native engine remains unfinished.
- [Alone in the Dark: The New Nightmare — a two-disc PlayStation recompilation](https://awesomerea.org/resources/alone-in-the-dark-new-nightmare-recomp-case/index.md): Case study · Alone in the Dark: The New Nightmare Recompiled configures psxrecomp to build a native program from the European two-disc PlayStation release. Its setup host validates both disc images, handles their shared executable and uses a user-supplied regional BIOS. The author reports separate startup tests for both discs; an in-game disc change remains to be tested.
- [WoWee: reconstructing a native World of Warcraft client](https://awesomerea.org/resources/wowee-client-case/index.md): Case study · WoWee reconstructs a native World of Warcraft client in C++ with Vulkan rendering, networking and audio. It handles Vanilla 1.12, TBC 2.4.3, WotLK 3.3.5a and Turtle WoW 1.18 through expansion-specific packet parsers and extracts assets from the user's own installation.
- [Hobbit Recompiled: an Apple Silicon recompilation of LEGO The Hobbit](https://awesomerea.org/resources/hobbit-recompiled-case/index.md): Case study · Hobbit Recompiled translates the 32-bit Intel Mac release of LEGO The Hobbit into C and builds an Apple Silicon app. Its analysis records functions, imports and switch tables. The runtime replaces macOS imports and uses SDL2 in place of the game's Cocoa front end; setup reads the player's Steam copy.
- [Fusion: reconstructing Rovio's game-engine libraries](https://awesomerea.org/resources/fusion-rovio-engine-case/index.md): Case study · Fusion reconstructs Rovio's multiplatform game-engine libraries, chiefly using the iPhone Angry Birds Seasons v4.1.0 executable and its debugging information as references. Its CMake project builds much of the recovered library code for Windows. DRM and in-app-purchase implementations are outside the project's stated scope, and other build types remain unfinished.
- [jpog-decomp: rebuilding Jurassic Park: Operation Genesis and Toshi](https://awesomerea.org/resources/jpog-decomp-case/index.md): Case study · jpog-decomp rebuilds Jurassic Park: Operation Genesis and its Toshi engine in C++20, replacing original functions one at a time. Its 32-bit Windows build compares reconstructed DLL exports with the original, while a portable SDL3 and bgfx shell targets Windows, Linux and macOS. The author reports that the hybrid build opens a game window and that the portable build remains an early developer shell.
- [Yoshi's Island: Super Mario Advance 3: an exact-match disassembly](https://awesomerea.org/resources/sma3-disasm-case/index.md): Case study · sma3-disasm reconstructs the US Yoshi's Island: Super Mario Advance 3 ROM as Armips assembly. The author reports an exact full-ROM match and replaces ROM pointers with labels to support edits. Game graphics and sound are extracted from a user-supplied vanilla ROM, while the single-cartridge multiplayer region still needs research.
- [OpenCoD1: a Call of Duty multiplayer reconstruction](https://awesomerea.org/resources/opencod1-call-of-duty-case/index.md): Case study · OpenCoD1 reconstructs the multiplayer engine, client, dedicated server and game modules of Call of Duty 1.1 from source. Its Windows and Visual Studio build produces executables and DLLs installed beside the user’s original game assets. The author describes the effects system and other subsystems as unfinished.
- [Syndicate: a matching decompilation of the DOS game](https://awesomerea.org/resources/syndicate-matching-decompilation-case/index.md): Case study · Syndicate reconstructs the DOS game's code in C, compiling functions with a period Watcom toolchain and comparing the resulting machine code with the original. The repository also contains decoded assembly, game architecture notes and scripts for tracking matches and rebuilding an executable. The author reports that the rebuilt DOS program reaches playable missions.
- [Devil May Cry 3: a matching PlayStation 2 decompilation](https://awesomerea.org/resources/dmc3-decomp-case/index.md): Case study · Devil May Cry 3 reconstructs the PlayStation 2 game's executable as C and C++ compiled with its original toolchains. The project compares individual functions instruction by instruction and checks the linked USA build against the original SHA-1; the author reports 48.77% of code bytes matched for that version.
- [DesktopAdventures: reconstructing the Desktop Adventures engine](https://awesomerea.org/resources/desktopadventures-engine-case/index.md): Case study · DesktopAdventures recreates the engine used by Indiana Jones and His Desktop Adventures and Yoda Stories in C. It parses named DAT sections and documents IACT script layout using observed data and disassembly of script routines. Linux and 3DS are the documented working platforms.
- [Soul Reaverse: reconstructing Legacy of Kain: Soul Reaver](https://awesomerea.org/resources/soul-reaverse-case/index.md): Case study · Soul Reaverse reconstructs Legacy of Kain: Soul Reaver’s PlayStation MIPS code as C from a prerelease executable with debugging symbols. Its source covers the main executable and gameplay overlays, with build and comparison configuration for matching reconstructed functions against the original.
- [The World Ends With You: reconstructing the Nintendo DS codebase](https://awesomerea.org/resources/the-world-ends-with-you-ds-case/index.md): Case study · The World Ends With You reconstructs the Nintendo DS game's code for its US and Japanese releases. The project builds from user-supplied ROMs and documents asset formats including PACK archives, graphics, text, fonts and tables.
- [D2Decomp: rebuilding the Diablo II: Lord of Destruction engine](https://awesomerea.org/resources/d2decomp-diablo-ii-case/index.md): Case study · D2Decomp reimplements the Diablo II: Lord of Destruction 1.14d engine for Linux, Windows and macOS using the user's game data. Ghidra analysis informs the code, while Unicorn runs original functions for behavior comparisons. The author reports that all five acts play through; multiplayer hosting and a dedicated server remain unfinished.
- [StarCraft: Ghost — an Xbox executable statically recompiled for Windows](https://awesomerea.org/resources/starcraft-ghost-xbox-recomp-case/index.md): Case study · The StarCraft: Ghost Xbox recompilation translates the game's x86 executable into C with XboxRecomp and links it to a Windows runtime. Game-specific patches adjust generated code; the author reports tested mission loading, gameplay and transitions, with further coverage still pending.
- [Cristalis: statically recompiling Crystal Defenders for Windows](https://awesomerea.org/resources/cristalis-crystal-defenders-case/index.md): Case study · Cristalis ports the Xbox 360 game Crystal Defenders to native Windows by translating its PowerPC code to C++ ahead of time with XenonRecomp and running it on a game-specific runtime. It reads images, audio, music, and text from the user's own game copy; the author reports finishing the game on a small number of machines. A Linux version is experimental.
- [Batty: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/batty-disassembly-case/index.md): Case study · batty provides a SkoolKit disassembly of the ZX Spectrum game Batty. The repository contains skool and control sources, reference notes and scripts for building hexadecimal and decimal HTML listings.
- [Kirby's Adventure: an in-progress NES disassembly](https://awesomerea.org/resources/kirbys-adventure-nes-case/index.md): Case study · Kirby's Adventure is reconstructed as a work-in-progress NES assembly source tree with program and graphics banks. Build scripts configure the toolchain and assemble a ROM, while bundled helpers include an Actionscript bytecode dumper for the game.
- [ZT1-Engine: reconstructing Zoo Tycoon 1 from zoo.exe](https://awesomerea.org/resources/zt1-engine-case/index.md): Case study · ZT1-Engine reimplements Zoo Tycoon 1 for modern Windows by recovering game rules from zoo.exe and comparing behavior with the original. It reads art, sound, and other files from the player's installation and includes a lab for examining original addresses and execution traces. The author describes base-game freeform play as available in alpha, while expansion features and save parity remain incomplete.
- [BattleTanx: an in-progress matching N64 decompilation](https://awesomerea.org/resources/battletanx-n64-decomp-case/index.md): Case study · BattleTanx reconstructs the North American Nintendo 64 game as C and assembly, with builds checked against a user-supplied cartridge dump. The repository includes source, symbol files and build configuration. The author reports 22.71% of code bytes and 830 of 1,736 functions matched at the stated update.
- [OpenRoads: a SkyRoads reimplementation using original data files](https://awesomerea.org/resources/openroads-case/index.md): Case study · OpenRoads reimplements SkyRoads in TypeScript with HTML5 rendering while loading the original game's art, music and level files. The repository includes game code and notes on the original data and rendering, and the application can also run under Node.js with Oculus Rift support.
- [TribesPad: native ARM64 ports of Tribes 2 and Starsiege: Tribes](https://awesomerea.org/resources/tribespad-case/index.md): Case study · TribesPad translates the x86 code of Tribes 2 and Starsiege: Tribes ahead of time into native ARM64 for iPhone, iPad and Mac. Its runtime supplies Windows services, a Metal graphics path, audio, input and networking; mobile builds add touch and controller controls. Game-specific translation and runtime configurations accompany investigation records.
- [BotW Recompiled: a Wii U Breath of the Wild port for Apple Silicon](https://awesomerea.org/resources/botw-recompiled-case/index.md): Case study · BotW Recompiled ports the Wii U release of The Legend of Zelda: Breath of the Wild to iPhone and Apple Silicon Macs by translating U-King.rpx PowerPC functions into C++. A project Cafe OS runtime supplies system services, while a modified Cemu Latte layer renders through Metal.
- [Shadow of the Colossus: matching decompilation of the PS2 release](https://awesomerea.org/resources/shadow-of-the-colossus-decomp-case/index.md): Case study · Shadow of the Colossus reconstructs functions from the NTSC-U PlayStation 2 game in C and checks rebuilt machine code against a user-provided original. Its build workflow compares output byte for byte, while function files and shared headers hold the recovered code and types. The author reports that 582 of 1,043 functions match exactly.
- [DOA3: an Android port of Dead or Alive 3](https://awesomerea.org/resources/doa3-android-port-case/index.md): Case study · DOA3 adapts statically recompiled Dead or Alive 3 Xbox code for Android ARM64. Its runtime uses OpenGL ES 3 for graphics and SDL3 for audio and input, while the launcher reads resources directly from the user's USA ISO; the author reports startup, menus and a fight on one device.
- [The SpongeBob SquarePants Movie Game: a work-in-progress decompilation](https://awesomerea.org/resources/spongebob-squarepants-movie-decomp-case/index.md): Case study · The SpongeBob SquarePants Movie Game project reconstructs source for the GGVE78 NTSC game release. Its C and C++ tree, split and symbol configuration, and Ninja build operate on a user-supplied disc image; objdiff supports comparison of rebuilt objects.
- [International Superstar Soccer Deluxe: an SNES disassembly of the USA release](https://awesomerea.org/resources/international-superstar-soccer-deluxe-snes-case/index.md): Case study · International Superstar Soccer Deluxe is an SNES disassembly based on the USA ROM. Its assembly files cover ROM mapping, RAM mapping, macros, SPC700 material, and asset pointers, while batch scripts extract assets from a user-supplied clean, headerless ROM using the author's SNES ROM framework.
- [Twin Cobra: partial Sega Genesis disassembly and scaling analysis](https://awesomerea.org/resources/twin-cobra-disassembly-case/index.md): Case study · Twin Cobra documents a partial disassembly of the Sega Genesis game through an Exodus-generated assembly listing, RAM and ROM maps, object structures and address-indexed tables. A separate analysis traces weapon damage and enemy health scaling to specific memory locations.
- [Deep Sea: a native Windows recompilation of The Wind Waker](https://awesomerea.org/resources/deep-sea-wind-waker-case/index.md): Case study · Deep Sea builds a native Windows port of The Legend of Zelda: The Wind Waker from the user's USA GameCube disc. Its setup kit checks disc hashes, translates main.dol and 415 REL modules with DolRecomp, and compiles a local game DLL for the ModernGekko runtime. Game-specific additions include widescreen, frame interpolation and cutscene skipping.
- [Alleyway: a checksum-matched Game Boy disassembly](https://awesomerea.org/resources/alleyway-gb-case/index.md): Case study · Alleyway reconstructs the 1989 Game Boy game as assembly source organized by audio, display, input, physics, and stage code. Its build script emits a 32 KiB ROM with published CRC32 and SHA-1 hashes, and accompanying notes identify unused routines and behaviors.
- [Oogie's Revenge Recomp: an Xbox static recompilation for PC](https://awesomerea.org/resources/oogies-revenge-recomp-case/index.md): Case study · Oogie's Revenge Recomp builds a Windows port of the USA Xbox game Tim Burton's The Nightmare Before Christmas: Oogie's Revenge by translating x86 functions into C++ with xboxrecomp. Its runtime replaces Xbox kernel and SDK services, while a Direct3D 11 renderer translates the game's Direct3D 8 shaders to HLSL. Game data comes from the player's disc image.
- [cttt-decomp: Captain Toad: Treasure Tracker Switch decompilation](https://awesomerea.org/resources/cttt-decomp-case/index.md): Case study · cttt-decomp reconstructs C++ code for the Nintendo Switch version 1.3.0 of Captain Toad: Treasure Tracker. Its build scripts use a user-provided game executable, and check.py compares reconstructed output with the original. The repository contains game source files, headers and function data.
- [OpenCiv3: rebuilding Civilization III in Godot](https://awesomerea.org/resources/openciv3-case/index.md): Case study · OpenCiv3 rebuilds Civilization III as a Godot and C# strategy game with Lua gameplay rules. It can read BIQ and SAV data plus images and animations from a local Civ3 installation, while a standalone mode uses placeholder graphics; the author describes the current game as pre-alpha.
- [Midnight Club: Los Angeles — RECOMP: an Xbox 360 static recompilation for PC](https://awesomerea.org/resources/midnight-club-los-angeles-recomp-case/index.md): Case study · Midnight Club: Los Angeles — RECOMP translates the Xbox 360 game's PowerPC executable into native x64 C++ for Windows using ReXGlue. The repository supplies game hooks, executable patches and a documented map of Xenos register state; its native graphics path currently reads and logs that state in shadow mode.
- [Beetle Adventure Racing!: a matching Nintendo 64 decompilation](https://awesomerea.org/resources/beetle-adventure-racing-decomp-case/index.md): Case study · bar-decomp reconstructs the US Nintendo 64 release of Beetle Adventure Racing! from C source and data extracted from a user-owned base ROM. Its build compares the resulting ROM with a recorded hash; other regional releases are planned.
- [Ratchet & Clank: Up Your Arsenal — byte-exact PlayStation 2 decompilation](https://awesomerea.org/resources/rac3-uya-decomp/index.md): Case study · This is a matching decompilation of Ratchet & Clank: Up Your Arsenal for the PlayStation 2, NTSC-U SCUS-97353. It builds frontbin.elf, boot_elf.elf, and i5bootn.elf byte for byte. Their SHA-1 values are 3bc94ee895e4b4af9b5602a229af599c1103b542, 487975305f8a263c750dfede50391b575ed07835, and 71f3ecfc54c3d24d1475ef9efe8228fbfe59d65f.
- [3D Pinball – Space Cadet: a PlayStation 2 port](https://awesomerea.org/resources/space-cadet-ps2/index.md): Case study · This ports the Space Cadet pinball decompilation to the PlayStation 2. It is built with the PS2SDK. Game data from 3D Pinball Space Cadet or the Full Tilt! Pinball Cadet table goes in mass:/APPS/3DPINBALL on USB storage. The README says the Full Tilt table works on PCSX2 and not on real hardware.
- [God Hand Recompiled: statically recompiling God Hand for Windows](https://awesomerea.org/resources/godhand-recomp/index.md): Case study · This recompiles God Hand for the PlayStation 2, USA SLUS-21503, into a Windows program with PS2Recomp. The README says play has been tested from the opening through stage 3, past the Gorilla Mask and Mad Midget Five fights, at 60 fps and 3x resolution. Later stages and the ending have not been played.
- [FireRedLeafGreenRecomp: recompiling Pokémon FireRed and LeafGreen for PC](https://awesomerea.org/resources/firered-leafgreen-recomp/index.md): Case study · This statically recompiles Pokémon FireRed and Pokémon LeafGreen, USA version 1.0, to native PC with gbarecomp. FireRed SHA-1 is 41cb23d8dccc8ebd7c649cd8fbb58eeace6e2fdc. LeafGreen SHA-1 is 574fa542ffebb14be69902d1d36f1ec0a4afd71e. The README says both games boot through the BIOS intro into gameplay. Code the static recompiler has not covered runs in an interpreter the first time, then is JIT-compiled and remembered.
- [Ridge Racer Type 4: PlayStation static recompilation](https://awesomerea.org/resources/ridge-racer-type4-recomp/index.md): Case study · This recompiles Ridge Racer Type 4 for the PlayStation with PSXRecomp. The project configuration targets the USA release SLUS-00797. The Windows launcher expects Ridge_Racer_4_Recompiled.exe beside launcher/ and bios/. It can use the bundled OpenBIOS or a BIOS the player supplies.
- [Star Fox: a native SNES recompilation](https://awesomerea.org/resources/starfox-snes-recomp/index.md): Case study · This statically recompiles Star Fox for the Super Nintendo into native C with snesrecomp. The required ROM is an unheadered 1 MiB dump of Star Fox (USA) version 1.2, SHA-256 82E39DFBB3E4FE5C28044E80878392070C618B298DD5A267E5EA53C8F72CC548. The README says the game boots and that attract mode, menus, route selection, training, and gameplay have passed basic testing. An optional widescreen renderer is included.