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

# Curated reverse engineering resources · Page 17

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

## Games (100)

- [BOTWRecomp: a native Apple Silicon recompilation of Breath of the Wild](https://awesomerea.org/resources/botwrecomp-case/index.md): Case study · BOTWRecomp builds a native Apple Silicon version of the Wii U Breath of the Wild from a user's dump. It translates the game's PowerPC code into C ahead of time, adapts Cafe OS services in a native runtime, and renders GX2 graphics through Metal.
- [Darkflame Universe: LEGO Universe server reconstruction](https://awesomerea.org/resources/darkflame-universe-case/index.md): Case study · Darkflame Universe reconstructs a LEGO Universe server for use with the original game client. Its C++ source contains authentication, chat and game-server components, while the setup guide describes local server configuration and database options.
- [GalaxyPad: porting Super Mario Galaxy to iPhone and iPad](https://awesomerea.org/resources/galaxypad-super-mario-galaxy-case/index.md): Case study · GalaxyPad ports Super Mario Galaxy to iPhone and iPad using MacioGalaxy and Petari-derived native game code. Its current engine compiles for Apple silicon, renders with Metal and adds touch, controller and gyro controls; players import their own supported Wii image.
- [DisMKW: an in-progress Mario Kart Wii disassembly](https://awesomerea.org/resources/dismkw-case/index.md): Case study · DisMKW reconstructs the NTSC-U release of Mario Kart Wii as PowerPC assembly, covering game and Mario Kart Channel code. Its build uses main.dol and StaticR.rel from the user's copy, while the progress list tracks sections still dependent on binary inclusion.
- [Turtles in Time: a three-region SNES disassembly](https://awesomerea.org/resources/tmnt-iv-turtles-in-time-snes-case/index.md): Case study · The Turtles in Time SNES disassembly covers the USA, European PAL and Australian PAL ROMs of Teenage Mutant Ninja Turtles IV. It uses the author's SNES ROM framework and an asset extraction script that reads the user's clean ROM.
- [Army of Two: The 40th Day — an Xbox 360 static recompilation preview](https://awesomerea.org/resources/army-of-two-40th-day-recomp-case/index.md): Case study · Army of Two: The 40th Day Recomp translates the Xbox 360 game's default.xex PowerPC code to C++ with ReXGlue for a Windows x64 build. The repository adds title-specific function configuration, fixes and launch settings. The author reports menus, the first Shanghai chapter and a Highrise combat segment working, while later gameplay requires more engine functions, boss scripts and saves.
- [Thimbleweed Park Vita: an Android executable port to PS Vita](https://awesomerea.org/resources/thimbleweed-park-vita-case/index.md): Case study · Thimbleweed Park Vita runs the Android ARMv7 build of Thimbleweed Park on PS Vita by loading its executable, resolving Android imports to native functions and applying runtime patches. Users provide the game's APK and OBB files.
- [MegaManX3SNESRecomp: a Mega Man X3 static recompilation](https://awesomerea.org/resources/mega-man-x3-snes-recomp-case/index.md): Case study · MegaManX3SNESRecomp applies snesrecomp to the US SNES release of Mega Man X3, running covered 65816 paths natively and falling back to an interpreter elsewhere. Its game-specific code handles startup and display behavior, while symbol annotations and coverage data guide regeneration. The author reports opening scenes and early gameplay, with wider stage coverage and audio checks still open.
- [Karateka: a byte-matched DOS disassembly](https://awesomerea.org/resources/karateka-dos-disassembly-case/index.md): Case study · Karateka reconstructs the 1986 DOS game's MZ executable as modular x86 assembly. Its build assembles the sources with NASM and compares the result byte for byte with a user-supplied KARATEKA.EXE.
- [PaperShip: a PC port of Paper Mario 64](https://awesomerea.org/resources/papership-paper-mario-port-case/index.md): Case study · PaperShip ports Paper Mario 64 decompilation source to PC with a custom platform layer on libultraship. It maps Nintendo 64 graphics, audio, input, and ROM access to desktop backends while reading game assets from the user's US ROM. The author reports playtesting through Chapter 2.
- [bbport: a native Bloodborne runtime for Linux and Windows](https://awesomerea.org/resources/bbport-bloodborne-case/index.md): Case study · bbport runs the original Bloodborne 1.09 x86-64 game code on Linux and Windows by preparing its executable as a memory image and replacing PS4 system libraries with a game-specific runtime. Its renderer translates PS4 GPU commands and shaders to Vulkan; the author reports playable areas, sound, saving and gamepad support.
- [Project Carrot: rebuilding a Jazz Jackrabbit 2-style engine](https://awesomerea.org/resources/project-carrot-case/index.md): Case study · Project Carrot develops a C++ engine modeled on Jazz Jackrabbit 2 using converted resources from a user's copy. Its source includes game systems and JJ2 format handling; companion tools extract Anims.j2a assets and convert tilesets and levels. The author describes the project as progressing slowly.
- [Afterhours 2015: Need for Speed online-service reconstruction](https://awesomerea.org/resources/afterhours-2015-case/index.md): Case study · Afterhours 2015 reconstructs online services for Need for Speed (2015) as a Rust server and local launcher. The workspace implements stream framing, tagged fields, typed backend and world messages, and content preparation from the player's installation; the author reports live checks for selected gameplay and garage flows.
- [Cypress: reconstructing Plants vs. Zombies dedicated servers](https://awesomerea.org/resources/cypress-pvz-servers-case/index.md): Case study · Cypress reconstructs dedicated-server behavior for Plants vs. Zombies: Garden Warfare 1, Garden Warfare 2 and Battle for Neighborville. A C++ DLL loaded by each game hooks Frostbite functions for connections, level loading and commands, while a desktop launcher and backend services provide server discovery and relay functions. The project targets specified game versions and requires a legally owned copy.
- [Chronicle: matching decompilation and port of Dark Cloud](https://awesomerea.org/resources/chronicle-dark-cloud-case/index.md): Case study · Chronicle decompiles and ports the PlayStation 2 game Dark Cloud. It aims to rebuild matching text and data sections for the NTSC 1.02 and PAL review executables and the TITLE.BIN and DUN.BIN overlays. Build configurations cover PS2 images and native ports using data extracted from a user's disc.
- [Frontier Elite II Intro Player: reconstructing the game's intro renderer and audio](https://awesomerea.org/resources/frontier-elite-ii-intro-player-case/index.md): Case study · Frontier Elite II Intro Player recreates the Frontier: Elite II intro renderer and audio playback in C for Amiga and SDL platforms. It reads models and music from an original game executable, implements the game's 16-bit 3D model bytecode, and includes a model compiler and decompiler. The author reports that most of the original graphics code is covered, while 2D and navigation rendering remain incomplete.
- [Peggle 2 for Mac: an Apple Silicon static recompilation](https://awesomerea.org/resources/peggle-2-mac-case/index.md): Case study · Peggle 2 for Mac statically translates the Xbox 360 game's PowerPC code to C++ with XenonRecomp for Apple Silicon. Its runtime replaces console kernel calls, renders translated shaders through Metal, decodes XMA audio with FFmpeg and accepts a player's own game file during local installation.
- [Winning Eleven 3 Final Ver.: a matching PlayStation reconstruction](https://awesomerea.org/resources/winning-eleven-3-final-ver-case/index.md): Case study · Winning Eleven 3 Final Ver. reconstructs the Japanese PlayStation release's boot executable and five confirmed runtime overlays with an assembly baseline and byte-matching C functions. Its tools extract a user-provided disc, build modules and compare complete output hashes. The author reports 901 functions in matching C; a native PC build remains planned.
- [Power Dozer: statically recompiling Blast Corps](https://awesomerea.org/resources/power-dozer-case/index.md): Case study · Power Dozer statically recompiles Blast Corps USA Rev 1 with N64Recomp and runs it through N64ModernRuntime and RT64 on Windows and Linux. The game code is generated locally from the player's ROM; the project documents beta checks and remaining graphics, audio and gameplay coverage work.
- [Ace Combat 3: Electrosphere — a local PlayStation static recompilation](https://awesomerea.org/resources/ace-combat-3-electrosphere-recomp-case/index.md): Case study · The Ace Combat 3: Electrosphere project configures psxrecomp and recomp-ui to generate a native build of the USA PlayStation release from a user's disc image. It includes title-specific symbols, configuration and a setup host that collects local inputs. The author reports gameplay in a private package, with exact release-package checks still open.
- [Know Your Role Recomp: a native PlayStation wrestling game port](https://awesomerea.org/resources/know-your-role-recomp-case/index.md): Case study · Know Your Role Recomp builds a native Windows port of the 2000 PlayStation wrestling game from the user's NTSC-U disc image. RecompOne translates the game's MIPS code to C#, and its runtime replaces graphics, sound, CD-ROM, controller and BIOS services. The author reports reaching all 14 disc programs in testing.
- [OpenDriverEngine: a shared engine reconstruction for Driver 1 and 2](https://awesomerea.org/resources/opendriverengine-case/index.md): Case study · OpenDriverEngine is a C++ project to run Driver 1 and Driver 2 content through a shared engine. Its TODO list marks LEV level, texture and model loading, Driver 2 physics, and a decompiled reimplementation of Driver 1 car cosmetics as done. The README specifies content conversion and Lua game logic as project goals.
- [gh3-decomp: matching Guitar Hero III PS2 decompilation](https://awesomerea.org/resources/gh3-decomp-case/index.md): Case study · gh3-decomp reconstructs the USA PlayStation 2 release of Guitar Hero III: Legends of Rock as C++ compiled with the game's original compiler. Its build extracts the executable from the user's disc image, splits it, and compares the linked result byte for byte; the author reports that 28.78% of game code is matching C++.
- [Sonic the Fighters: a work-in-progress Model2b decompilation](https://awesomerea.org/resources/sonic-the-fighters-decomp-case/index.md): Case study · Sonic the Fighters is being reconstructed from its Model2b arcade code, with a mostly assembly-language disassembly intended for function-by-function conversion to C/C++. A Makefile and extraction script use the user's schamp and sfight ROM archives to build program binaries and extract supported data.
- [Mother 3: a Game Boy Advance decompilation](https://awesomerea.org/resources/mother-3-decomp-case/index.md): Case study · Mother 3 reconstructs Game Boy Advance game code into a buildable source tree targeting a ROM with a specified SHA-1. Its setup uses the Japanese original as baserom.gba, and the included Salsa tool reads and writes the game’s main and miscellaneous text.
- [Tingle Tuner: matching Wind Waker GBA client reconstruction](https://awesomerea.org/resources/tingle-tuner-decomp-case/index.md): Case study · Tingle Tuner reconstructs the GBA client that The Wind Waker sends to a linked Game Boy Advance, covering Japanese, US, PAL and demo builds. Its C, assembly and LZ77 packer rebuild hash-checked client images from user-supplied discs, while separate documentation maps the GameCube-to-GBA JOY bus protocol.
- [Hell Night: Dark Messiah Recompiled: a PlayStation PC build](https://awesomerea.org/resources/hellnight-recompiled-case/index.md): Case study · Hell Night: Dark Messiah Recompiled builds a native PC version of the European PlayStation game Hellnight by generating game code locally with PSXRecomp. It supplies disc identity settings, a setup launcher and patches for video positioning, tiled filtering and supersampling; the author reports early gameplay and save/load checks on Windows.
- [FINAL FANTASY XIV 1.23b: an experimental matching client decompilation](https://awesomerea.org/resources/ffxiv-123b-matching-decomp-case/index.md): Case study · Reconstructs portions of the FINAL FANTASY XIV 1.23b game client for a matching Windows executable build. The workflow splits the user-supplied ffxivgame.exe, compiles recovered C++ and assembly, and checks the output against the original.
- [Retro-Sonic 3D: a decompilation with an SDL/OpenGL renderer](https://awesomerea.org/resources/retro-sonic-3d-decompilation-case/index.md): Case study · Retro-Sonic 3D Decompilation reconstructs Retro-Sonic 3D: Sky Worlds in C++ and adds a mod loader. Its default build replaces the original DirectX 7 renderer with OpenGL and SDL; running it requires assets from the 2005 demo.
- [unturned-godot: porting Unturned maps and gameplay to Godot](https://awesomerea.org/resources/unturned-godot-case/index.md): Case study · unturned-godot ports Unturned map content and selected gameplay to Godot 4.7 with C# readers for the game's serialized data. It loads terrain, objects, foliage, roads, audio and characters from a Steam installation, with movement, zombies and multiplayer at an experimental stage.
- [Test Drive II Enhanced: a C reimplementation of the EGA game](https://awesomerea.org/resources/test-drive-ii-enhanced-case/index.md): Case study · Test Drive II Enhanced reimplements the EGA Test Drive II: The Duel executable in C and runs it through SDL3 with the player's original game files. Its replacement road renderer draws at higher resolution and 60 frames per second with a longer draw distance, while a classic mode retains the earlier view. A stage viewer reads the game's scenery data for camera exploration.
- [WiiCompiled: a Mario Kart Wii static recompilation port for Xbox UWP](https://awesomerea.org/resources/wiicompiled-xbox-uwp-case/index.md): Case study · WiiCompiled's Xbox UWP port builds the static recompilation of Mario Kart Wii as a packaged application for Xbox Series consoles. It adds fixes for MSVC compilation and AppContainer startup, Direct3D 12 rendering through aurora and Dawn, memory use, and controller mapping; the author reports play on an Xbox Series S in Developer Mode.
- [OpenXvT: X-Wing vs. TIE Fighter reimplementation](https://awesomerea.org/resources/openxvt-case/index.md): Case study · OpenXvT reimplements Star Wars: X-Wing vs. TIE Fighter and its Balance of Power expansion for Windows, macOS and Linux using the player's original game data. Its source includes flight, asset, audio and rendering systems, with classic and enhanced graphics modes and cross-platform multiplayer.
- [OverBlood-xport: an OverBlood PlayStation decompilation port](https://awesomerea.org/resources/overblood-xport-case/index.md): Case study · OverBlood-xport ports reconstructed code from the PlayStation game OverBlood. Its C startup code loads the original SLUS_004.64 executable, mounts extracted resources from DATA and loads KROM15.BIN before entering the game.
- [Earthworm Jim 2 Recompiled: a PlayStation static recompilation](https://awesomerea.org/resources/earthworm-jim-2-recomp-case/index.md): Case study · Earthworm Jim 2 Recompiled converts the PlayStation game's MIPS boot loader and 19 executables to C with psxrecomp for a Windows build made from the user's disc. It includes game-specific setup scripts and an optional partial widescreen patch. The author reports that all 17 levels load and play; transitions and the ending still lack end-to-end validation.
- [Blue Stinger Recompiled: a Dreamcast static recompilation](https://awesomerea.org/resources/blue-stinger-recompiled-case/index.md): Case study · Blue Stinger Recompiled translates the Dreamcast game's SH-4 code instruction by instruction into C++20 for a Windows x64 port. Its builder extracts a user-supplied CDI disc image and generates the executable, while native PC implementations replace file, input, save, movie, audio and graphics services; the author compares behavior with Flycast.
- [Golden Sun: a symbolized Game Boy Advance disassembly](https://awesomerea.org/resources/golden-sun-disassembly-case/index.md): Case study · Golden Sun reconstructs the Game Boy Advance game's known code as symbolized assembly. Its build compares the generated US ROM by SHA-1 and checks uncompressed map-code overlays separately against data from a user-supplied ROM.
- [Alundra Recompiled: a PlayStation setup host for local recompilation](https://awesomerea.org/resources/alundra-recompiled-case/index.md): Case study · Alundra Recompiled provides a PlayStation game configuration and setup host that uses psxrecomp to generate a native build from the user's disc. The repository also carries title-specific symbol mappings and a knowledge report for the European release.
- [NFS Online Server: reconstructing Need for Speed online services](https://awesomerea.org/resources/nfs-online-server-case/index.md): Case study · NFS Online Server reconstructs online services for Need for Speed: Underground 2, Most Wanted (2005) and Carbon. Python services handle game-specific bootstrap, lobby, race relay and Carbon FESL traffic, while three Zig-built Windows ASI plugins connect the original clients to the replacement services.
- [Zeliard: DOS engine analysis and an SDL2 source port](https://awesomerea.org/resources/zeliard-dos-reconstruction-case/index.md): Case study · Reconstructs Zeliard's DOS engine and resource handling as documented C code and an SDL2 port that reads the user's original game files. Its tools extract SAR archives, decode compressed payloads and regenerate disassembly; technical notes map the boot chain, overlays and driver interfaces.
- [MeitouClient: reconstructing the Kenshi engine](https://awesomerea.org/resources/meitouclient-kenshi-case/index.md): Case study · MeitouClient is a C# and .NET 10 reimplementation of the Kenshi engine that aims to run original game content, mods and saves unchanged. Its documentation records Kenshi data-file load order, format details and behavior derived from analysis of the original executable. An installed copy of Kenshi is required.
- [Apocalypse Recompiled: a PlayStation setup recipe for static recompilation](https://awesomerea.org/resources/apocalypse-recompiled-case/index.md): Case study · Apocalypse Recompiled packages a PSXRecomp setup recipe for the SLES-00460 PlayStation game. Its title configuration and function seeds support local generation and compilation from the user's disc and European BIOS; the release candidate documents pending setup and gameplay checks.
- [Hitman 5 Server: reconstructing Absolution and Sniper Challenge services](https://awesomerea.org/resources/hitman-5-server-case/index.md): Case study · Hitman 5 Server reconstructs the web services used by Hitman: Absolution and Hitman: Sniper Challenge, with C# endpoints and a configurable client hook. Its documentation traces client startup requests, metadata parsing and message templates; the author says much of the server currently responds with mocked data.
- [Caesar II Reconstruction: byte-matched DOS source and Windows function comparisons](https://awesomerea.org/resources/caesar-ii-reconstruction-case/index.md): Case study · Caesar II Reconstruction recovers C and assembly for the 1995 game and rebuilds its DOS PS.EXE with Watcom C. Its toolkit compares code and initialized data with the original, while a separate MSVC 4.0 workflow compares Windows functions against CAESAR2.EXE. The author reports a byte-exact DOS rebuild outside generated debug information.
- [Harry Potter and the Sorcerer's Stone: a GBC disassembly](https://awesomerea.org/resources/hpss-disassembly-case/index.md): Case study · HPSS-Disassembly reconstructs the Game Boy Color Harry Potter and the Sorcerer's Stone as RGBDS assembly. It uses a specified user-dumped ROM as baserom.gbc and offers a compare target that checks the rebuilt hpss.gbc against stored hashes.
- [King's Field 2: a PS1 static recompilation for PC](https://awesomerea.org/resources/kings-field-2-pc-case/index.md): Case study · King's Field PC ports King's Field 2 from PlayStation to PC through PS1Recom MIPS-to-C static recompilation. Its game-function sources run with a PsyX-based PlayStation compatibility layer, CD handling and keyboard, mouse and gamepad input.
- [tower-together: reconstructing SimTower's simulation for multiplayer](https://awesomerea.org/resources/tower-together-case/index.md): Case study · tower-together reconstructs SimTower's simulation as a multiplayer browser game. A TypeScript simulation core runs in a Cloudflare Worker and clients, while documented behavior notes and captured traces from the original executable guide comparisons of state at each tick. The project supplies its own interface and assets.
- [The Great Escape: an annotated ZX Spectrum disassembly](https://awesomerea.org/resources/the-great-escape-disassembly-case/index.md): Case study · The Great Escape reconstructs the 48K ZX Spectrum game from its tape image into annotated assembly and a cross-referenced HTML disassembly using SkoolKit. Its build can generate emulator-loadable TAP and Z80 images and documents decoded graphics, characters, items and game behavior.
- [Mario Artist Paint Studio: a Nintendo 64DD decompilation](https://awesomerea.org/resources/mario-artist-paint-studio-case/index.md): Case study · Mario Artist Paint Studio Decompilation reconstructs code from the Nintendo 64DD game's disk image. Its build setup uses a specific user-provided D64 dump, splat extraction and a MIPS toolchain; the repository contains reconstructed C source and headers.
- [Hot Wheels: Velocity X — a partial GameCube decompilation](https://awesomerea.org/resources/hot-wheels-velocity-x-gcn-case/index.md): Case study · Hot Wheels: Velocity X is being decompiled for the GameCube USA GHWE78 release. The repository contains C source, headers, split and symbol configuration, and a build that starts from the user's disc image. Its objdiff configuration supports comparisons of rebuilt objects with the original.
- [The Sims: Bustin' Out: a matching GameCube decompilation](https://awesomerea.org/resources/bustin-out-gamecube-decomp-case/index.md): Case study · The Sims: Bustin' Out project reconstructs parts of the USA G4ME69 GameCube executable in C and C++, using SN Systems ProDG for game code. A patched decomp-toolkit splits main.dol into objects; the build substitutes matching source objects and compares the relinked executable with the user's disc copy. The author reports 6.24% of code matched.
- [strahlender-xnu: native recompilation of Pokémon Brilliant Diamond](https://awesomerea.org/resources/strahlender-xnu-case/index.md): Case study · strahlender-xnu builds native apps for Pokémon Brilliant Diamond by translating the game’s ARM64 code ahead of time from a user-supplied dump. Its runtime replaces Switch operating-system services and its graphics interface, rendering through Metal on Apple devices and Vulkan on Linux and Windows.
- [pokemonstadium: a work-in-progress Pokémon Stadium decompilation](https://awesomerea.org/resources/pokemonstadium-case/index.md): Case study · pokemonstadium reconstructs the US Nintendo 64 Pokémon Stadium ROM as a work-in-progress mix of assembly and C source. Its setup extracts a user-supplied baserom.z64, and its Makefile assembles the extracted material into a ROM.
- [Legendary Wings: a ROM-local NESRecomp Windows port](https://awesomerea.org/resources/legendary-wings-nes-to-pc-case/index.md): Case study · Legendary Wings NES to PC builds a native Windows port by running NESRecomp on a user-supplied Legendary Wings ROM and compiling game-specific C code. It adds presentation, animation and collision hooks; the remastered artwork currently concentrates on the first level.
- [Crash Bandicoot: The Wrath of Cortex: a GameCube decompilation](https://awesomerea.org/resources/crash-wrath-of-cortex-gc-decomp-case/index.md): Case study · Crash Bandicoot: The Wrath of Cortex is being reconstructed as GameCube source for the USA Rev 0 release. The repository contains recovered source, object splits, symbol maps, and a ProDG 3.5 build configuration; its workflow uses decomp-toolkit and objdiff to compare rebuilt units with the user's original main.dol.
- [Yoshi's Island DS: an early DSD and Ghidra decompilation](https://awesomerea.org/resources/yoshis-island-ds-decomp-case/index.md): Case study · Begins a decompilation of Yoshi's Island DS USA 1.0 using DSD and Ghidra. The repository contains ROM configuration and symbol files for the ARM9 and overlays, with a small C source tree for recovered code.
- [Racing 8 DX Recomp: statically recompiling Mario Kart 8 Deluxe](https://awesomerea.org/resources/racing-8-dx-recomp-case/index.md): Case study · Racing 8 DX Recomp builds Mario Kart 8 Deluxe for Linux by translating user-supplied AArch64 game code to C and compiling it ahead of time with a patched suyu-derived engine. Its launcher handles local inputs, while a native graphics path and plugins provide Vulkan rendering and upscaling. Android support is in development, and Windows support is planned.
- [Phantasy Star Online Ver. 2: a hybrid Dreamcast matching decompilation](https://awesomerea.org/resources/phantasy-star-online-ver-2-dreamcast-case/index.md): Case study · Phantasy Star Online Ver. 2 is being reconstructed from C/C++ and typed static data for its European Dreamcast release. Complete function ranges are compared with the decoded executable; unmatched code is supplied through fallback assembly generated from the user's dump. The author reports that the matching source covers part of the executable.
- [Magic Carpet: a DOS game reconstruction and Windows port](https://awesomerea.org/resources/magic-carpet-native-port-case/index.md): Case study · Magic Carpet reconstructs Bullfrog's 1994 DOS game as a Windows x64 C++17 and SDL2 port from analysis of carpet.exe. The repository includes Ghidra naming data, format documentation and a DOSBox reference harness; the author reports matching simulation ticks and rendered frames in recorded comparisons.
- [MaskPad: an iPhone and iPad port of Majora's Mask](https://awesomerea.org/resources/maskpad-case/index.md): Case study · MaskPad adapts the 2 Ship 2 Harkinian Majora's Mask source port into a native iPhone and iPad app. It supplies iOS patches, Metal rendering, touch controls and local extraction from a user-provided ROM, with scripts to build an unsigned IPA.
- [Giten: a matching Giten Megami Tensei reconstruction](https://awesomerea.org/resources/giten-megami-tensei-decomp-case/index.md): Case study · Giten reconstructs the 1999 Windows DDS.EXE of Giten Megami Tensei: Tokyo Mokushiroku in C and C++, comparing functions with retail output from MSVC 5.0 SP3. The build takes original resource payloads from a user-supplied executable. The author's MAX score reports 2,626 of 2,659 target functions exact, while the current score is 2,581.
- [Dragon Warrior 3: a matching Game Boy Color disassembly](https://awesomerea.org/resources/dragon-warrior-3-gbc-disassembly-case/index.md): Case study · A Game Boy Color disassembly of Dragon Warrior 3 reconstructs the US ROM from assembly source and extracted game components. Its build takes a user-supplied ROM, produces dq3_en.gbc and compares the rebuilt output with the original.
- [Rigel Engine: a Duke Nukem II engine reimplementation](https://awesomerea.org/resources/rigel-engine-case/index.md): Case study · Rigel Engine reimplements Duke Nukem II in C++ using findings from disassembly of the original game binaries. It replaces the DOS executable while reading the user's original game data, and adds widescreen display, smooth scrolling, quick saves and controller support.
- [Mega Man X5: a matching PlayStation decompilation](https://awesomerea.org/resources/mega-man-x5-decomp-case/index.md): Case study · mmx5 reconstructs C source for the US PlayStation release of Mega Man X5. Its build uses a period toolchain and original link order to compare the boot executable SLUS_013.34 and code overlays inside ROCK_X5.BIN with a user-supplied disc dump.
- [Castlevania: Symphony of the Night: a Vita shared-library port](https://awesomerea.org/resources/sotn-vita-library-port-case/index.md): Case study · The Castlevania: Symphony of the Night Vita project loads a game shared library through a custom ELF loader. Its source implements relocation, symbol handling and ARM and Thumb hooks, while the build targets the Vita SDK.
- [SSB-X: a Super Smash Bros. port for the original Xbox](https://awesomerea.org/resources/ssb-x-super-smash-bros-xbox-port-case/index.md): Case study · SSB-X ports the N64 Super Smash Bros. to the original Xbox using an existing Dreamcast port's game code. It reimplements the Dreamcast port's PowerVR, AICA, controller, storage and threading services on Xbox hardware, while generating game content from the user's US ROM during the build.
- [Mario Party 1 US Decomp: rebuilding the US Nintendo 64 game](https://awesomerea.org/resources/mario-party-1-us-decomp-case/index.md): Case study · Mario Party 1 US Decomp reconstructs the US Nintendo 64 game's code as buildable C sources. Its build uses a user-provided big-endian .z64 ROM, runs setup and make, and provides comparison controls in the Makefile.
- [f19re: a matching F-19 Stealth Fighter reconstruction](https://awesomerea.org/resources/f19re-case/index.md): Case study · f19re reconstructs F-19 Stealth Fighter's DOS EGAME.EXE as a disassembly-derived assembly skeleton and incremental C translations. Its build compares the skeleton byte for byte with the original executable and checks C routines against the original machine code using Microsoft C 5.1.
- [Hot Wheels: function-by-function PC executable reconstruction](https://awesomerea.org/resources/hot-wheels-pc-decomp-case/index.md): Case study · Reconstructs functions from a Hot Wheels PC game executable as C++ and compares compiled results with the original through objdiff. Ghidra-derived function addresses, sizes, symbols and relocations guide the per-function work.
- [SpaghettiPad: Mario Kart 64 iOS port integration](https://awesomerea.org/resources/spaghettipad-mario-kart-64-ios-case/index.md): Case study · SpaghettiPad adapts the decompilation-based SpaghettiKart port of Mario Kart 64 for iPhone and iPad. Its mobile integration adds Metal rendering, analog touch steering, Bluetooth controller routing, game-data import and optional texture-pack loading. Builds require the player's supported US 1.0 ROM.
- [Sargon III: recovering move order and its opening-library encoding](https://awesomerea.org/resources/sargon-iii-disassembly-case/index.md): Case study · Studies the Apple II version of Sargon III through a partially commented disassembly, focusing on its move generator and opening-library encoding. Two C utilities help decode and rebuild openings whose one-byte moves index the generator's move order.
- [Final Fantasy Tactics Advance: matching decompilation and battle AI analysis](https://awesomerea.org/resources/ffta-battle-ai-decomp-case/index.md): Case study · Reconstructs selected Final Fantasy Tactics Advance functions in C while mapping battle AI, abilities, jobs, missions and other ROM tables. The author reports 173 functions compiled to matching bytes; remaining ROM regions are incorporated from the user's original during a hash-checked build.
- [Final Fantasy Legends 2: Game Boy disassembly](https://awesomerea.org/resources/final-fantasy-legends-2-disassembly-case/index.md): Case study · Final Fantasy Legends 2 Disassembly maps Game Boy game code into assembly files for battle, audio, maps, menus and system functions. Its memory map labels RAM and hardware registers and uses an external FinalFantasyLegend2.gb image as the assembly background.
- [Rusty MCLA: rebuilding Midnight Club: Los Angeles in Rust](https://awesomerea.org/resources/rusty-mcla-midnight-club-los-angeles-case/index.md): Case study · Rusty MCLA rebuilds Midnight Club: Los Angeles Complete Edition as a Rust game engine for Windows using data prepared from the user's Xbox 360 disc image. Its format tools handle the disc, archives, resources, scripts and shaders, while a function registry tracks work against the original executable. The author reports about 17 percent of functions closed and lists online play and several hardware features as later work.
- [sm: a frame-compared Super Metroid reconstruction](https://awesomerea.org/resources/snesrev-sm-case/index.md): Case study · sm reconstructs Super Metroid as a C program and runs it alongside a user-provided ROM for frame-by-frame comparison. It saves a snapshot when it detects a mismatch.
- [DOAX3 Fortune PC: porting Dead or Alive Xtreme 3 Fortune to Windows](https://awesomerea.org/resources/doax3-fortune-pc-case/index.md): Case study · DOAX3 Fortune PC adapts Dead or Alive Xtreme 3 Fortune version 01.19 for Windows x64. Its inherited native runtime executes the game's x86-64 guest code, while a shadPS4-derived graphics core translates GPU commands and shaders to Vulkan. The author reports tested routes through the title, casino and several activities, with partial coverage of volleyball and Pool Hopping.
- [LegendOfZeldaNESRecomp: static recompilation of The Legend of Zelda](https://awesomerea.org/resources/zelda-nes-recomp/index.md): Case study · LegendOfZeldaNESRecomp is a static recompilation of The Legend of Zelda for the NES, built with nesrecomp and described as an in-development preview. The Windows quick start asks for a Legend of Zelda (USA) ROM, and the cycle build uses the original USA PRG0 ROM. Project code covered by the README is under the PolyForm Noncommercial License 1.0.0.
- [B2recomp: static recompilation of Bayonetta 2](https://awesomerea.org/resources/b2recomp/index.md): Case study · B2recomp is an unofficial static recompilation of the Nintendo Switch version of Bayonetta 2 for Windows. The README says it translates that version's AArch64 program code to C on the user's PC from the user's dumped copy, then runs it with a reimplemented system layer and maps the NVN graphics API to Vulkan.
- [BlueWake: static recompilation of The Wind Waker](https://awesomerea.org/resources/bluewake/index.md): Case study · BlueWake is a static recompilation of the GameCube game The Legend of Zelda: The Wind Waker that runs natively on iPhone, iPad, Mac, Windows, and Linux. The README describes touch controls, controller support, and mods, and it names Windows 10 or 11 ready-made builds plus repository builds for Apple platforms and x86-64 Linux.
- [Abyss Engine: clean-room Diablo 2 engine](https://awesomerea.org/resources/abyss-engine/index.md): Case study · Abyss Engine is a clean-room reimplementation of the Diablo 2 engine in C, aimed at a portable base that can be modded. The README says it uses no original game code and will not be compatible with the original save files or multiplayer systems.
- [afe-decomp: decompilation of Animal Forest e+](https://awesomerea.org/resources/afe-decomp/index.md): Case study · afe-decomp is a work-in-progress decompilation of Animal Forest e+ for the GameCube, the Japanese release どうぶつの森 e+. The README supports revisions GAEJ01_00 and GAEJ01_01 and says the repository contains no game assets or assembly. Windows, macOS, and Linux setups use Python and Ninja, with wibo downloaded for macOS and Linux.
- [Black 2006 Recomp: Windows recompilation of BLACK](https://awesomerea.org/resources/black-2006-recomp/index.md): Case study · Black 2006 Recomp is an experimental Windows recompilation of the original Xbox release of BLACK (2006), built with XboxRecomp. The README lists a Direct3D 11 renderer, keyboard and mouse, XInput, video settings, a PC launcher, and native audio, and says movies are enabled by default.
- [sead: decompilation of Nintendo EAD libraries](https://awesomerea.org/resources/sead/index.md): Case study · sead is a decompilation of the engine and libraries developed by Nintendo EAD, now EPD, as found in New Super Mario Bros. U and other games. The README describes engine/ as the standard library, nw_ptcl as a wrapper around NintendoWareForCafe Eft, and agl as the graphics library. It says a byte-identical rebuild is out of reach without the NSMBU compiler, and the current goal is matching functionality and efficiency.
- [sh2-nx: Switch port of Silent Hill 2](https://awesomerea.org/resources/sh2-nx/index.md): Case study · sh2-nx is a native Nintendo Switch port of the PC version of Silent Hill 2, Director's Cut / Restless Dreams, with support for Silent Hill 2: Enhanced Edition packs. The game's x86 executable is statically recompiled to C and compiled for the Switch ARM64 CPU, and the Windows layer it expects is reimplemented with SDL2, OpenGL, and FFmpeg. The README also documents a Linux x86-64 build.
- [BotW Recompiled for Windows: Wii U Breath of the Wild](https://awesomerea.org/resources/botw-native/index.md): Case study · BotW Recompiled for Windows runs the Wii U version of Breath of the Wild on Windows 10 and 11. The README says the PowerPC game code is statically recompiled to C++ on a Cafe OS runtime, and that Cemu's Latte GPU layer draws through Vulkan. It says the project is a work in progress and not a full-game release.
- [Wipeout XL Recompiled: PSXRecomp port of Wipeout XL](https://awesomerea.org/resources/wipeoutxl-recomp/index.md): Case study · Wipeout XL Recompiled is an unofficial PSXRecomp project for Wipeout XL (USA), SCUS-94351. Setup kits for Windows 10/11 x64, Linux x64, and macOS 15 on Intel and Apple Silicon generate the game code on the user's machine from a Redump-style CUE and all 12 BIN tracks. The runtime uses OpenBIOS and SDL3.
- [BOTWRecompAndroid: Android port of Breath of the Wild](https://awesomerea.org/resources/botwrecomp-android/index.md): Case study · BOTWRecompAndroid is an Android port of The Legend of Zelda: Breath of the Wild for Switch versions 1.0.0, 1.6.0, 1.8.2, and 1.9.0. The README says the game code can be recompiled into C on the phone, or run directly on the phone's ARM64 CPU in an experimental Native Mode, with the NVN graphics API translated to Vulkan. It is built on LAS Recomp and LASRecompAndroid.
- [Brawl Recompiled: native Windows port of Super Smash Bros. Brawl](https://awesomerea.org/resources/brawl-recompiled/index.md): Case study · Brawl Recompiled is a native Windows port of Super Smash Bros. Brawl made by statically recompiling the game's PowerPC code, main.dol and all 126 REL modules, to C++ with WiiCompiled. The README says boot, saves, the menus tested so far, VS battles, attract demos, the start of Classic mode, and the opening of the Subspace Emissary work, and that the project is unfinished.
- [Carnage3D: open-source remake of Grand Theft Auto 1](https://awesomerea.org/resources/carnage3d/index.md): Case study · Carnage3D is an open-source remake of Grand Theft Auto 1. The README describes the project as an early stage and links a WebAssembly build tested in Chrome 85 and Firefox 81, both 64-bit. The Linux build instructions use clang and name GLEW, GLM, Mesa, X11, and OpenAL development packages.
- [freeablo: a cross-platform reimplementation of the Diablo 1 engine](https://awesomerea.org/resources/freeablo/index.md): Case study · Cross-platform reimplementation of the Diablo 1 game engine. The README says the project is archived, that original data files are required, and that the current build can walk the town, animate players and NPCs, enter the dungeon, fight with melee and limited ranged and magic attacks, drop loot, and buy and sell items.
- [God of War — Native PC: static recompilation of the PS2 game](https://awesomerea.org/resources/gow-native-pc-case/index.md): Case study · God of War — Native PC is a native Windows port of God of War for the PlayStation 2, NTSC-U SCUS-97399, built by statically recompiling MIPS R5900 code to C++. The README also describes an experimental Linux and Steam Deck launcher and build pipeline.
- [D2MOO: reimplementation of Diablo II](https://awesomerea.org/resources/d2moo-case/index.md): Case study · D2MOO is a reimplementation of Diablo II with patching facilities for modders. The README says the project aims to stay close to the original game and does not yet provide bug fixes.
- [SunPad: Super Mario Sunshine on Apple platforms](https://awesomerea.org/resources/sunpad-case/index.md): Case study · SunPad runs Super Mario Sunshine on iPhone, iPad, Apple silicon Mac, and experimental Apple TV through ahead-of-time recompilation, with Metal rendering, touch controls, controller support, and local game-image import.
- [Metal Slug XX: recompiling the game with ReXGlue](https://awesomerea.org/resources/metal-slug-xx-recomp/index.md): Case study · A modified ReXGlue SDK tree for running Metal Slug XX. The README says the repository stores no Metal Slug XX files and that a legal copy has to be supplied. It also marks the project as early development, with breaking public API changes expected.
- [Eternal Sonata Reprise: statically recompiling Eternal Sonata for PC](https://awesomerea.org/resources/eternal-sonata-reprise-case/index.md): Case study · Eternal Sonata Reprise is a static recompilation of Eternal Sonata for PC. The README says both the Xbox 360 and PlayStation 3 versions can be played in any region, while building the executable requires the Xbox 360 PAL version.
- [Reburn 3: reimplementation of Burnout 3 Takedown](https://awesomerea.org/resources/reburn3-case/index.md): Case study · Reburn 3 is a work-in-progress open-source reimplementation of Burnout 3: Takedown. The README calls it a rewrite and says it is currently playable on Windows and Wine through Cxbx-Reloaded.
- [Burnout 3: Takedown — native Windows port](https://awesomerea.org/resources/burnout3-pc/index.md): Case study · A native Windows port of the PlayStation 2 game Burnout 3: Takedown. The README says the game's program is translated to C++ and compiled for the PC, with 60 frames per second or the display refresh rate, up to four times the PlayStation 2 resolution, widescreen, and controller rumble.
- [CoD3Recomp: static recompilation of Call of Duty 3](https://awesomerea.org/resources/cod3recomp/index.md): Case study · CoD3Recomp is a static recompilation of Call of Duty 3 for Xbox 360 to native x86-64, using XenonRecomp. The README says the PowerPC code translates to C++, that 19,462 functions are translated, and that all 179 Xbox 360 kernel imports are implemented. It says the project is still in development.
- [Hell's Gate: a static recompilation of Dante's Inferno](https://awesomerea.org/resources/hells-gate-recomp/index.md): Case study · PC port of Dante's Inferno from the Xbox 360, built with the ReXGlue SDK. The README says the PowerPC executable is translated ahead of time into portable C++ and compiled into a native program. It says the project replaces the game's Direct3D layer with its own renderer.
- [PvZ-Portable: a reimplementation of Plants vs. Zombies GOTY](https://awesomerea.org/resources/pvz-portable/index.md): Case study · Cross-platform reimplementation of Plants vs. Zombies: Game of the Year Edition. The README says the code is a manual reimplementation from community research, . It names Linux, Windows, macOS, Android, iOS, WebAssembly, and Switch, using OpenGL ES 2.0 and SDL, with a browser build that still needs the player's game data.