# Curated reverse engineering resources · Page 4

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

## Games (100)

- [GunZRs: a Rust reimplementation of GunZ: The Duel](https://awesomerea.org/resources/gunzrs-rea-rust-reimplementation-case/index.md): Case study · A Rust/Bevy port reads GunZ: The Duel files from the user’s installation and provides native releases, browser build tooling, screenshots and a documented REA/Ghidra investigation framework. Its LAN uses the port’s own protocol, with retail-server compatibility unverified; movement behavior is inferred, with gameplay parity unproven.
- [Does reverse engineering need a bigger model? General and specialist models in Touhou reconstruction](https://awesomerea.org/resources/rea-bigger-model-essay-case/index.md): Case study · An essay on REA’s site by N0zoM1z0 (13 October 2026) uses dated Touhou reconstruction commits to ask whether exact function matching needs a larger general model, a compiler-specialist model or better retrieval. It walks through TH09, TH095, TH04 and TH08 cases where later GPT-6-series sessions closed stubborn matches, and the TH08 audit that found accepted functions with wrong floating constants. Specialist and reinforcement-learning comparisons are proposed as future experiments; no trained specialist was evaluated.
- [sh23ds: a native 3DS reconstruction of Silent Hill 2](https://awesomerea.org/resources/sh23ds-case/index.md): Case study · sh23ds rebuilds Silent Hill 2: Director's Cut as a native C engine for Nintendo 3DS using the player's PC game data. Game logic, camera, lighting and events were reconstructed from the PC executable; the research notes report analysis with Ghidra and REA. The author reports a complete playthrough in Azahar, while real-console testing and some PC behaviors remain unfinished.
- [Bully Decompiled: an Unreal reconstruction of Bully: Scholarship Edition](https://awesomerea.org/resources/rea-bully-case/index.md): Case study · Rea Bully studies Bully: Scholarship Edition's executable, Lua 5.0 scripts, and asset formats with REA, Ghidra, and local recovery tools, then builds an Unreal Engine 5.8 exploration runtime from those findings. The author reports a Windows developer preview with 85 assembled zones across 47 areas, sampled traversal checks, and selected characters and interactions.
- [Rally Trophy Decomp: function-matched reconstruction of Rally Trophy 1.01](https://awesomerea.org/resources/rally-trophy-decomp-case/index.md): Case study · Rally Trophy Decomp reconstructs first-party functions from Rally Trophy 1.01 as C++ and compares locally compiled x86 code with the shipped Windows executable. Its function maps and subsystem notes record analysis findings, and the documented workflow associates nontrivial binary findings with REA evidence IDs.
- [Brickwork: a DX-Ball-inspired browser game from REA and Ghidra findings](https://awesomerea.org/resources/brickwork-case/index.md): Case study · Brickwork is a browser brick-breaker reconstructed from the author's REA and Ghidra study of DX-Ball's Windows executable and asset formats. Its TypeScript engine uses HTML5 Canvas and WebAudio for gameplay, procedural graphics and sound, with a board editor and mobile mode.
- [RappelzCore & RappelzRust: reconstructing a Rappelz NoLimits client and server](https://awesomerea.org/resources/rappelzcore-rappelzrust-case/index.md): Case study · RappelzCore and RappelzRust reconstruct a Rappelz NoLimits server and game client in Rust from analysis of the customized SFrame.exe client. The author documents REA and Ghidra work on client functions, resource formats and packet layouts; both components are described as under development.
- [Drift City Rebuild: a Unity client and server from game analysis](https://awesomerea.org/resources/driftcity-unity-case/index.md): Case study · Drift City Rebuild rebuilds the online racing game as a Unity client that reads data from the user's installed copy, with a new Node.js server for offline or hosted play. Its reverse-engineering notes document REA/Ghidra analysis of DriftCity.exe and record format readers for NayaPack, NIF, DDS and other game data. The author reports roughly 94% code conversion.
- [NFS Most Wanted (2005): a Unity rebuild from speed.exe analysis](https://awesomerea.org/resources/nfsmw-unity-case/index.md): Case study · NFS Most Wanted (2005) rebuilds the PC game's systems in Unity from function-by-function study of speed.exe and reads cars, world, audio and other content from the user's installation. Its analysis notes report using REA with Ghidra, and its code includes game-data readers, runtime systems and standalone .NET probes. The author reports a playable offline career and 98% code-port coverage.
- [ff-recomp: Freedom Fighters statically recompiled for native hosts](https://awesomerea.org/resources/ff-recomp-freedom-fighters-case/index.md): Case study · ff-recomp statically translates the Windows x86 executable of Freedom Fighters into C for a native host runtime. The runtime loads the player's executable and game data, while shims supply Windows APIs, Direct3D 8, sound and input services. The author reports that the macOS build reaches the title screen; the PlayStation Vita build remains unfinished. Its function-rewrite plan uses Ghidra through ReVa and REA MCP servers.
- [Pokémon X: native C reconstruction of game logic and field data](https://awesomerea.org/resources/pokemon-x-reconstruction-case/index.md): Case study · Pokémon X reconstruction rebuilds selected Nintendo 3DS game logic and asset handling in portable C, with an SDL2 field slice for walking, dialogue and wild battles. Its native tools decode local game data, and the analysis notes document a live REA MCP workflow for move-resource investigation. The author reports extensive checks of reconstructed subsystems; the field slice remains incomplete.
- [rea-doom-term: a text-only reconstruction of DOOM](https://awesomerea.org/resources/rea-doom-term-case/index.md): Case study · rea-doom-term rebuilds DOOM (1993) as a playable Rust terminal game with WAD parsing, fixed-point math, movement, combat, and text raycasting. Its evidence log links reconstructed subsystems to original source functions and tests; the terminal renderer uses a different visibility and texturing approach.
- [swemu: reconstructing a SoulWorker server from client packet readers](https://awesomerea.org/resources/swemu-case/index.md): Case study · swemu reconstructs a server for the SoulWorker GB/Steam 2.3.34.7 game client in Rust. Its research log reports REA/Ghidra decompilation and Unicorn execution of client routines to recover packet layouts, encryption, and exchanges used for login, characters, world entry, and early combat.
- [Sonic Adventure DX: matching reconstruction of the 2014 Steam executable](https://awesomerea.org/resources/sadx-decomp-case/index.md): Case study · Reconstructs C and C++ source for the 2014 Steam release of Sonic Adventure DX, comparing compiled functions with the retail executable. It uses Visual C++ 2010 SP1 to produce matching machine code and reccmp to check matches. The project aims to rebuild the whole executable byte for byte, one function at a time.
- [Subway Runner 3D: rebuilding Subway Surfers movement rules](https://awesomerea.org/resources/subway-runner-3d-case/index.md): Case study · Subway Runner 3D is a procedural Three.js endless runner modeled on Subway Surfers movement and presentation. The author reports using REA and frame-by-frame observation of the original to derive speed, acceleration, jump and gravity values, then implementing lane movement, obstacles and power-ups for browsers and an Android WebView build.
- [UGH!: a C++ port of the 1992 DOS game](https://awesomerea.org/resources/ugh-port-case/index.md): Case study · UGH! ports the 1992 DOS game routine by routine from analysis of UGH.EXE into C++23 and SDL 3. It reads graphics, levels and sound from the user's executable, models VGA Mode X behavior and ports the AdLib driver. Project guidance records use of a REA plugin with Ghidra during analysis.
- [Rockport Native: reconstructing Need for Speed: Most Wanted on macOS](https://awesomerea.org/resources/rockport-native-nfs-mw-case/index.md): Case study · Rockport Native reconstructs the PlayStation 2 release of Need for Speed: Most Wanted as a macOS game using a Swift and Metal engine and data converted from the player's ISO. The project documents disc formats, game systems and a Ghidra and REA disassembly workflow; the author reports a playable Mac release and remaining gameplay gaps.
- [Genma Recomp: an Xbox port with REA investigations of Warlords HD](https://awesomerea.org/resources/genma-recomp-case/index.md): Case study · Genma Recomp statically translates the original Xbox Genma Onimusha executable to C++ for a native Windows port and experimental Linux build. Separate investigations use REA, Ghidra and Frida to examine controls and loading in the Onimusha: Warlords HD executable, with findings documented alongside the port.
- [Larax & Zaco: an REA-exported evidence base and partial routine recovery](https://awesomerea.org/resources/lezac-rea-decompilation-case/index.md): Case study · The author uses REA 6.3.0 with Ghidra to export dossiers, pseudocode and assembly for all 215 discovered procedures in the DOS shareware LEZAC.EXE, then recovers a small set of routines as Pascal and portable C. Recovered code is tested against the original x86 instructions, and a pinned DOSBox-X baseline records original-game runs..
- [openNG2: a static recompilation of Ninja Gaiden II for Windows](https://awesomerea.org/resources/openng2-case/index.md): Case study · openNG2 turns the Xbox 360 Ninja Gaiden II into a native Windows build through ReXGlue static recompilation and game-specific host code. Its launcher builds from a user-owned World release and Title Update #2; the research ledger records evidence from REA, Ghidra and code generation while the port adds PC display and input features.
- [Yu-Gi-Oh! GX Tag Force: matching PSP decompilation with REA analysis](https://awesomerea.org/resources/tagforce-decomp-case/index.md): Case study · Yu-Gi-Oh! GX Tag Force reconstructs the North American PSP game's runtime and game modules as C. The build compiles the C with mwccpsp, compares the result with the original and retains unmatched parts as assembly. Architecture notes cite REA evidence from Ghidra analysis of the BOOT module. A playable PC port remains planned.
- [MLB Power Pros 2008 Recomp: a Wii static recompilation and mixed analysis workflow](https://awesomerea.org/resources/mlb-power-pros-2008-recomp-case/index.md): Case study · MLB Power Pros 2008 Recomp translates the Wii game's main.dol and ovl_main.rel from PowerPC to C++ with Wiicompiled for Windows and Linux builds. It adds title-specific runtime patches and editing tools for rosters, textures and stadiums. Its analysis workflow uses REA through MCP, which supports x86/x64 PE executables.
- [Burnout Dominator Reversed: a PS2 static recompilation](https://awesomerea.org/resources/burnout-dominator-reversed-case/index.md): Case study · Burnout Dominator Reversed builds a native PC port of the European PS2 release by translating its main CPU code with PS2Recomp and its vector-unit programs into C++. It uses paraLLEl-GS for graphics and supplies I/O and audio subsystems; the author reports play through the last World Tour event.
- [LASRecomp: Link’s Awakening static recompilation](https://awesomerea.org/resources/lasrecomp/index.md): Case study · A native desktop reconstruction of the 2019 Switch version of Link’s Awakening using static recompilation. The author attributes most code, tooling and reverse-engineering work to Claude Code with human direction and review.
- [ArkWeb: a two-game movement and collision experiment](https://awesomerea.org/resources/arkweb-two-game-case/index.md): Case study · Runs Spider-Man Remastered and Arkham Knight together, streaming Gotham collision into Spider-Man’s physics world and compositing his rendered frame into Arkham. It is an experimental runtime bridge between the two running games.
- [Perfect Dark: matching Nintendo 64 decompilation](https://awesomerea.org/resources/perfect-dark-matching-decomp-case/index.md): Case study · Reconstructs Perfect Dark’s Nintendo 64 code with a documented matching-ROM build. The project combines reconstructed source with assets from a user-supplied original ROM, then checks version-specific artifact hashes. It is a reproducible-build research case, distinct from the separate native PC port; matching results remain project-reported here.
- [Super Mario Sunshine: a native PC port from an AI-assisted decompilation](https://awesomerea.org/resources/sms-pc-port-case/index.md): Case study · Builds a native PC port of Super Mario Sunshine’s North American release from a pinned matching-decompilation fork, adding a host platform layer for graphics, disc, audio, input and OS services. The fork’s README says AI was used extensively to reconstruct and match its code; the port documents scripted regression hashes and lockstep comparisons with retail captures. Functions that do not yet match can still behave differently from retail, and the game must come from the user’s own disc image.
- [Majora’s Mask: matching US N64 decompilation](https://awesomerea.org/resources/zelda-mm-decomp-case/index.md): Case study · Recreates a C source base for The Legend of Zelda: Majora’s Mask from information in the game and static or dynamic analysis, then rebuilds the US Nintendo 64 ROM. The build takes assets and assembly from a user-supplied ROM and checks the output against stored MD5 checksums. The team states it will not produce a PC port; the separately curated Zelda 64: Recompiled only credits it for headers and some functions.
- [DLSSNR-AMD: reimplementing DLSS 5 neural rendering for RDNA4](https://awesomerea.org/resources/dlssnr-amd-neural-rendering-case/index.md): Case study · Reimplements the neural-rendering network of NVIDIA’s DLSS 5 library as Vulkan compute shaders for AMD RX 9000 (RDNA4) cards and supplies it to games through an NGX-compatible core and ReShade or Vulkan-layer routes. The weights are not distributed: installers extract them, hash-checked, from the user’s own nvngx_dlssnr.dll 310.9.16 or 310.8.0. The project compares its output with NVIDIA’s DLL on an RTX 5090 and reports close, not bit-identical, pictures.
- [Breath of the Wild: per-function matching decompilation of the Switch executable](https://awesomerea.org/resources/botw-decomp-case/index.md): Case study · Reimplements part of Breath of the Wild’s Switch v1.5.0 main executable in C++ and checks each function against the original machine code. The project calls itself a hybrid decompilation/reimplementation: it contains no assets, its ELF holds only reimplemented functions and cannot run the game, and porting is an explicit non-goal.
- [Skyward Sword: Wii decompilation with hash-checked relinking](https://awesomerea.org/resources/skyward-sword-decomp-case/index.md): Case study · Reconstructs C++ source for The Legend of Zelda: Skyward Sword’s Wii main.dol and REL modules, starting from the user’s NTSC-U 1.0 (SOUE01) disc files. Objects marked matching are compiled from source and linked with objects split from the original, and the result is checked against SHA-1 hashes; the repository ships no assets or assembly and focuses on source reconstruction, with porting outside the project scope.
- [2 Ship 2 Harkinian: a native Majora’s Mask port built on the decompilation](https://awesomerea.org/resources/2ship2harkinian-mm-port-case/index.md): Case study · Builds native Windows, Linux and macOS versions of The Legend of Zelda: Majora’s Mask from an adapted copy of the zeldaret/mm decompilation, with libultraship reimplementing N64 SDK functions. Game data comes from a user-supplied ROM and is packed into an archive that custom asset packs can override. It targets a playable PC port with enhancements.
- [Ship of Harkinian: a native Ocarina of Time port built on the decompilation](https://awesomerea.org/resources/ship-of-harkinian-oot-port-case/index.md): Case study · Builds Ocarina of Time as a native PC application from the OoT decompilation’s source, with libultraship standing in for the N64 libultra SDK and DirectX 11, OpenGL or Metal rendering. No game assets are shipped: they are converted from the user’s supported ROM into an .o2r archive, and the port adds save states, alternate and custom assets and other enhancements.
- [The Minish Cap: a GBA decompilation targeting five ROMs](https://awesomerea.org/resources/zelda-tmc-decomp-case/index.md): Case study · Recreates a C source base for The Legend of Zelda: The Minish Cap from information in the game and static or dynamic analysis, building five Game Boy Advance ROMs: USA, EU, JP and two demos. Each version takes its assets from a user-supplied original ROM, and normal builds check the output’s SHA-1 hash. The project remains a work in progress, and some parts of the ROM may not yet be shiftable.
- [Ocarina of Time: decompilation with MD5-checked ROM builds for 16 versions](https://awesomerea.org/resources/ocarina-of-time-decomp-case/index.md): Case study · Recreates a C source base for Ocarina of Time that rebuilds 16 Nintendo 64, GameCube and iQue Player ROM versions, using information from the game and static and dynamic analysis. Assets come from the user’s own ROM and each default build is checked against that version’s MD5; README states the project is not producing a PC port and still calls the repository a work in progress.
- [Project Arwing: Star Fox recompiled from a matching disassembly](https://awesomerea.org/resources/project-arwing-star-fox-recomp-case/index.md): Case study · Disassembles Star Fox’s 65816 and SuperFX code from runtime coverage and recursive descent, reassembles it into the original ROM, then translates it statically to C on a from-scratch SNES runtime for Windows, macOS and Linux. Code never reached in recorded sessions, and RAM code that no longer matches the ROM, falls back to an interpreter; the README reports identical per-frame hashes for both paths. The generated C is a mechanical translation rather than hand-decompiled source, and results remain project-reported.
- [Project Arwing (2): Star Fox 2 recompiled from a matching disassembly](https://awesomerea.org/resources/project-arwing-2-star-fox-2-recomp-case/index.md): Case study · Rebuilds Star Fox 2 from a coverage-seeded 65816 and SuperFX disassembly that reassembles to the original ROM, then translates it statically to C for native Windows, macOS and Linux builds. Unreached code and RAM code that differs from the ROM run through an interpreter, and the README reports identical per-frame hashes against interpreted runs. It accepts the SNES Classic release image, not the 1995 prototypes; results remain project-reported.
- [Little Planet: Sonic CD recompiled from a matching disassembly](https://awesomerea.org/resources/little-planet-sonic-cd-recomp-case/index.md): Case study · Disassembles every executable file on the Sonic CD disc from runtime coverage and recursive descent, reassembles them byte-identically, and translates the code statically to C on a from-scratch Mega-CD runtime that replaces the BIOS with a high-level implementation. Recompiled blocks run only where memory still holds the code they came from, and a script compares 96 stage runs frame by frame against the interpreter. The project also patches in widescreen and per-zone saves; results remain project-reported.
- [vf2-decomp: differentially validated Virtua Fighter 2 recovery](https://awesomerea.org/resources/vf2-decomp-differential-recovery-case/index.md): Case study · Recovers Virtua Fighter 2 Version 2.1’s Sega Model 2A i960 program into portable, non-matching C17, accepting each recovered path only when it matches a reference i960 executor at controlled boundaries. The repository adds ROM validation, i960 and 68000 analysis tools, a bounded Model 2A hardware model and snapshot-based differential runners. README states that it is not yet a playable port; match flow, combat, physics, AI, rasterization and much of the audio remain open.
- [z2rs: an incremental Rust reconstruction of Zelda II checked against an emulator](https://awesomerea.org/resources/z2rs-zelda2-reconstruction-case/index.md): Case study · Rebuilds Zelda II: The Adventure of Link (NES) in Rust for desktop, browser and Android by replacing the game’s 6502 routines one at a time. A built-in interpreter still runs the user’s ROM and hands ported routines to Rust, while a verifier compares RAM, sprites, palette and frames with a reference emulator. It is a behavioral, clean-room-style reconstruction guided by a community disassembly, with a standalone engine still in progress.
- [sm64ex: an enhanced Super Mario 64 PC port from the decompilation](https://awesomerea.org/resources/sm64ex-pc-port-case/index.md): Case study · Builds native Super Mario 64 executables from decompiled source, extending the sm64-port fork of the n64decomp reconstruction with renderer, input, camera, save-format and external-data options. Game assets are extracted from the user’s own ROM at build time. It is an enhanced native port.
- [Ghostship: a libultraship native port of Super Mario 64](https://awesomerea.org/resources/ghostship-sm64-port-case/index.md): Case study · Builds Super Mario 64 as a native PC, Switch and Android program by compiling decompilation-style game source against the libultraship platform library. A bundled extractor converts the user’s US or Japanese ROM into an O2R archive at first launch or build time. The project ships modern renderers, configuration menus and mod-archive loading.
- [Super Mario Sunshine: an in-progress matching GameCube decompilation](https://awesomerea.org/resources/sms-matching-decomp-case/index.md): Case study · Reconstructs Super Mario Sunshine’s C++ source so that the original Metrowerks compiler reproduces byte-identical object files for four GameCube releases and the Switch 3D All-Stars build. The target binary comes from the user’s own disc image, and objdiff compares rebuilt objects function by function. The work is incomplete, and the repository publishes contribution rules for AI agents alongside its human workflow.
- [Dusklight: a native Twilight Princess port built on the decompilation](https://awesomerea.org/resources/dusklight-twilight-princess-port-case/index.md): Case study · Reimplements Twilight Princess as a native application for desktop and mobile platforms, building on the zeldaret/tp decompilation and the Aurora GameCube/Wii compatibility layer. It runs from the user’s own disc image with no bundled assets and aims to stay accurate to the original while adding options, enhancements and mods.
- [Metaforce: a Metroid Prime engine reimplementation rebuilt on the decompilation](https://awesomerea.org/resources/metaforce-metroid-prime-case/index.md): Case study · Started in 2015 as a reverse-engineered reimplementation of the Metroid Prime engine, Metaforce has been rewritten on top of the PrimeDecomp matching decompilation. Its native app compiles that game code as non-matching C++ for desktop and mobile through the Aurora GameCube compatibility layer and loads a user-selected disc image. The README says builds are unavailable while the rewrite stabilizes.
- [Super Mario Sunshine (USA): an AI-assisted matching decompilation fork](https://awesomerea.org/resources/sms-english-gmse01-decomp-case/index.md): Case study · Extends the doldecomp Super Mario Sunshine decompilation to the North American GMSE01 release. The README says AI was used extensively, and the repository’s agent rules, work order and progress files describe batch-based Claude and Codex orchestration. Its rebuilt DOL is reported byte-identical, but unfinished objects are still linked from code extracted from the user’s disc.
- [Donkey Kong 64: Recompiled — an N64Recomp native port](https://awesomerea.org/resources/dk64-recompiled-case/index.md): Case study · Uses N64Recomp to statically recompile the US Nintendo 64 release of Donkey Kong 64 into a native port, with RT64 as the renderer. The port borrows headers and some functions from the in-progress DK64 decompilation for patches and enhancements. Its build uses a checked-in symbol dump and the ROM, with no decompilation ELF or decompiled source as the build input.
- [Twilight Princess: a decompilation with fully matching GameCube code](https://awesomerea.org/resources/twilight-princess-decomp-case/index.md): Case study · Reconstructs Twilight Princess source that compiles back to binaries identical to the originals, building GameCube, Wii and Nvidia Shield releases from one codebase through conditional compilation. README reports the GameCube code as completely matching but not every translation unit linked yet, with Debug and Wii alignment ongoing; the repository ships no assets or assembly and will not produce a port.
- [Castlevania: Symphony of the Night: matching decompilation across PlayStation, PSP and Saturn builds](https://awesomerea.org/resources/sotn-matching-decomp-case/index.md): Case study · Recreates C source for Castlevania: Symphony of the Night from its PlayStation, PSP and Saturn binaries, aiming for code that compiles byte for byte to the original game files. The work-in-progress build combines decompiled code with assets and assembly extracted from a user-supplied disc image, then checks per-version SHA-1 hashes. Native PC experiments in the same tree are documented as unfinished.
- [LEGO Island, portable: a multi-platform port of the decompiled source](https://awesomerea.org/resources/lego-island-portable-case/index.md): Case study · Adapts the LEGO Island decompilation into a portable build for desktop, mobile, console, DOS and Web targets. Windows-only subsystems are replaced with SDL3, miniaudio, iniparser and a custom Direct3D Retained Mode re-implementation, while core gameplay is meant to stay unchanged. It ports reconstructed source rather than checking byte-identical binaries, so it is distinct from the exact-rebuild decompilation case.
- [c1: a C port of PlayStation Crash Bandicoot](https://awesomerea.org/resources/crash-bandicoot-c1-port-case/index.md): Case study · Ports the original PlayStation Crash Bandicoot game code to C function by function; its coding standard labels functions with the addresses of their original implementations. Only the PC build, using OpenGL, SDL2 and FluidSynth, currently works; it loads asset files from the user’s game disc and is only partially playable.
- [Metroid Prime Port: an AI-assisted native port of the PrimeDecomp decompilation](https://awesomerea.org/resources/metroid-prime-port-case/index.md): Case study · Compiles the PrimeDecomp decompilation of Metroid Prime’s game and engine code as native C++20 for Linux, Windows and Android, with an experimental macOS build. Aurora supplies the GameCube SDK compatibility layer and rendering, and the port reads a user-supplied disc image at run time. The author states that parts were written with AI coding assistants under their oversight.
- [The Wind Waker: a GameCube decompilation with hash-checked relinking](https://awesomerea.org/resources/wind-waker-decomp-case/index.md): Case study · Reconstructs source for The Wind Waker’s GameCube executable and REL modules across the USA/Korea, PAL and Japanese releases and a Japanese kiosk demo. Matched units are compiled from source and linked with objects split from the user’s disc, then checked against per-version SHA-1 hashes; the repository ships no assets or assembly and covers the GameCube game, not the HD remaster.
- [Sonic Mania: a game-code decompilation for the RSDKv5 engine](https://awesomerea.org/resources/sonic-mania-decomp-case/index.md): Case study · Reconstructs Sonic Mania’s game code in C and builds it with the separately decompiled RSDKv5 or RSDKv5U engine for Windows, Linux, Switch and Android. Assets must come from an official Sonic Mania (Plus) release; the project adds a mod loader and can build several retail versions. Its license describes the code as mostly functionally the same as the original, not byte-matching.
- [MediEvil Recomp: a PlayStation static recompilation to C#](https://awesomerea.org/resources/medievil-recomp-case/index.md): Case study · Statically recompiles the North American PlayStation release of MediEvil into C# with the RecompOne recompiler and runtime. The runtime stands in for BIOS, GPU, CD-ROM and other hardware services, and project patches change rendering, widescreen and terrain behavior. README describes the project as a recompilation and labels it an open beta.
- [Crash Bandicoot 2 Recompiled: a PSXRecomp native build](https://awesomerea.org/resources/crash2recomp-case/index.md): Case study · A Windows launcher that uses the PSXRecomp recompiler and runtime to translate the user’s Crash Bandicoot 2: Cortex Strikes Back disc to C and compile it locally, so the game runs as native code with an emulated PlayStation hardware layer. The repository holds the launcher, a patched vendored runtime and a long bring-up log; it distributes no game code or data.
- [Petari: a matching Super Mario Galaxy decompilation](https://awesomerea.org/resources/petari-smg-decomp-case/index.md): Case study · Reconstructs Super Mario Galaxy’s Wii code as C++ that rebuilds, object by object, against main.dol files extracted from the user’s own Japanese, North American, PAL or Korean disc. Matched objects are linked from source and checked with objdiff and a target hash. The project describes itself as a work in progress, separate from any PC port, and says it does not accept AI-generated decompilation.
- [Wind Waker HD Recomp: a native port by static recompilation of the Wii U game](https://awesomerea.org/resources/wind-waker-hd-recomp-case/index.md): Case study · Statically recompiles The Wind Waker HD’s Wii U PowerPC code to C ahead of time, reimplements the Cafe OS libraries the game uses and implements GX2 graphics on Metal or Vulkan, producing native macOS, Linux, Windows and Android builds without a Cemu runtime. All game code and data are generated locally from the user’s own dump; an experimental macOS-only build can instead run functions from the separate ZeldaWWHDDecomp/wwhd decompilation.
- [Castlevania 64: Recompiled — a beta static-recompilation port](https://awesomerea.org/resources/cv64-recompiled-case/index.md): Case study · Uses N64Recomp to statically recompile the US 1.0 Nintendo 64 release of Castlevania into a native PC port rendered with RT64. Game-specific C patches build against headers from a separate Castlevania 64 decompilation. A beta release tagged at the reviewed commit reports a working build with known issues, while the README there still describes an unfinished project.
- [RSDKv5 Decompilation: reconstructing Retro Engine v5 and v5U](https://awesomerea.org/resources/rsdkv5-engine-decomp-case/index.md): Case study · Reconstructs the Retro Engine (RSDK) v5 and v5 Ultimate runtime, the engine that runs Sonic Mania’s game code, and builds it for Windows, Linux, Switch and Android. RSDKv5U can also run RSDKv3 and RSDKv4 games such as Sonic CD and Sonic 1 & 2. The project adds a mod loader, a shader compiler and extra Windows backends, and ships no game data.
- [C2C: hybrid recompilation and hand decompilation of Crash Bandicoot 2](https://awesomerea.org/resources/c2c-crash2-hybrid-recompilation-case/index.md): Case study · An early reverse-engineering effort on PlayStation Crash Bandicoot 2 that converts the engine’s MIPS machine code directly into a very large C file and runs it against a modified PCSX-R emulator library for hardware I/O. Translated functions are meant to be decompiled by hand and moved into ordinary C, gradually replacing the mechanical translation.
- [MediEvil decompilation: an early checksum-gated PlayStation project](https://awesomerea.org/resources/medievil-decomp-case/index.md): Case study · Decompiles the US PlayStation release of MediEvil toward C source that rebuilds its main executable, game executable and 26 overlays. splat splits the user's own disc files, and the default build compares all 28 outputs with SHA-1 checksums. README describes the project as a work in progress and publishes no progress figure.
- [Conker's Bad Fur Day: Recompiled — an N64Recomp native port](https://awesomerea.org/resources/cbfd-recompiled-case/index.md): Case study · Statically recompiles the US Nintendo 64 release of Conker’s Bad Fur Day with N64Recomp into a native Windows, Linux and macOS port on N64ModernRuntime and RT64. Function names and boundaries come from a vendored, still mostly assembly decompilation, while the recompiled code is taken from the user’s ROM so unmatched decompiled C cannot change behavior. The author reports heavy use of Claude Code across the project.
- [ProjectCane: a native PC port of Sly Cooper and the Thievius Raccoonus](https://awesomerea.org/resources/projectcane-sly1-pc-port-case/index.md): Case study · Rebuilds the NTSC PlayStation 2 release of Sly Cooper and the Thievius Raccoonus as a native C++ game for Windows and Linux, running on data extracted from the player's own disc image. The README reports the full game as playable while work continues on accuracy and remaining differences from the original. It does not describe its reverse-engineering method or relate the port to the separate sly1 decompilation.
- [Firefighter: a decompiled DOS game ported to Rust](https://awesomerea.org/resources/firefighter-rust-port-case/index.md): Case study · Eric S. Raymond’s terminal port of Firefighter, Eben Sprinsock’s 1985 DOS shareware game. The project history says ChatGPT 5.5 decompiled the DOS binary to Borland Pascal and translated it to Rust, after which Raymond modernized the interface and corrected a scoring mismatch. Unchanged gameplay is the author’s statement; the intermediate Pascal and any comparison runs are not published.
- [Kingdom Hearts 358/2 Days: native PC port built on a matching decompilation](https://awesomerea.org/resources/khdays-native-pc-port-case/index.md): Case study · Compiles the C of the khdays-decomp matching decompilation for Windows x64 and supplies a native platform layer for the Nintendo DS hardware, SDK services and sound driver. README reports the whole game running without an ARM interpreter; its rendering, controls, mod support and network multiplayer are the port’s own additions. This decompilation-based port builds on the byte-matching DS reconstruction.
- [ico-pc: a native ICO port compiled from the PS2 decompilation](https://awesomerea.org/resources/ico-pc-port-case/index.md): Case study · Compiles the decompiled C of the PlayStation 2 game ICO natively for Windows, Linux, Android, iPhone and Apple-silicon Macs, with host code standing in for the PS2 hardware and Sony libraries. No PS2 code is interpreted or recompiled, and the program reads the player's PAL disc image on first start. It is a native port of a separately byte-matched decompilation, with documented divergences and optional enhancements.
- [Sly Cooper and the Thievius Raccoonus: matching PlayStation 2 decompilation](https://awesomerea.org/resources/sly1-matching-decomp-case/index.md): Case study · Reconstructs source code for SCUS_971.98, the NTSC-U PlayStation 2 executable of Sly Cooper and the Thievius Raccoonus, as a work-in-progress matching decompilation. Functions not yet matched are still assembled from code split out of the user's own executable, and the build checks the linked ELF's SHA-1. The result runs in PCSX2 with the original disc for assets.
- [Pokémon Emerald: a matching Game Boy Advance decompilation](https://awesomerea.org/resources/pokemon-emerald-decomp-case/index.md): Case study · Reconstructs Pokémon Emerald for the Game Boy Advance as buildable C source, with game scripts and data kept as assembler directives. The default agbcc build produces pokeemerald.gba, and make compare checks it against the SHA-1 of the original English ROM; an optional modern-GCC build is not hash-checked. Graphics and audio sources are committed in the tree, so the documented build reads no base ROM.
- [Paper Mario: matching Nintendo 64 decompilation for four releases](https://awesomerea.org/resources/paper-mario-matching-decomp-case/index.md): Case study · Reconstructs Paper Mario’s Nintendo 64 code as C source that rebuilds the US, Japanese, PAL and iQue ROMs. The build takes assets and comparison inputs from a user-supplied original ROM, then checks each output against a recorded SHA-1. Mutable project reports list no remaining nonmatching functions, while the README still calls the decompilation work in progress; it is distinct from the PaperBoat native port.
- [Budokai Tenkaichi 3: a native PC port built on a matching decompilation](https://awesomerea.org/resources/tenkaichi3-pc-port-case/index.md): Case study · Compiles the decompiled code of Dragon Ball Z: Budokai Tenkaichi 3 (PS2, USA release SLUS-21678) for PC on a new renderer, sound, input and platform layer rather than an emulator. The game code comes from the separate BT3-Decompiled matching decompilation, and the game's data is read from the user's own disc image. The README reports the full game loop and experimental online play and says AI helped make the project; these results remain project-reported.
- [D2R Mobile: rehosting Diablo II: Resurrected’s Switch program on Apple devices](https://awesomerea.org/resources/d2r-mobile-switch-rehost-case/index.md): Case study · Runs the Nintendo Switch release’s own aarch64 program natively on iPhone, iPad and Apple silicon Macs, rewriting only instructions that depend on the Horizon kernel and supplying its system services and the NVN graphics API on Metal. Shaders are translated offline from the user’s files, and the project adds its own touch interface and endgame features. It is a rehosting compatibility layer.
- [Ratchet & Clank: a matching PS2 decompilation with a documented agent workflow](https://awesomerea.org/resources/rac1-matching-decomp-case/index.md): Case study · Reconstructs C source for SCES_509.16, the PAL v2.00 PlayStation 2 executable of Ratchet & Clank (2002), with every function linked at its retail address. Functions not yet decompiled are still built from disassembly generated from the user's own executable, and the build audits functions, layout and the whole image against retail. The project documents an LLM-agent matching workflow and written build-fidelity rules for what counts as a match.
- [Banjo: Recompiled — an N64Recomp Banjo-Kazooie native port](https://awesomerea.org/resources/banjo-recompiled-case/index.md): Case study · Uses N64Recomp to statically recompile the US 1.0 Nintendo 64 release of Banjo-Kazooie into a native port on N64ModernRuntime, rendered by RT64 and extended with mod support. Like Zelda 64: Recompiled, it is built through static recompilation; a symbols repository generated from the Banjo-Kazooie decompilation supplies function names for locating code in the ROM and writing patches.
- [Pokémon FireRed and LeafGreen: a matching Game Boy Advance decompilation](https://awesomerea.org/resources/pokemon-firered-leafgreen-decomp-case/index.md): Case study · Reconstructs the English Game Boy Advance releases of Pokémon FireRed and LeafGreen as buildable C source, with game scripts and data kept as assembler directives. Default agbcc builds produce six ROM images, covering both games' 1.0 and 1.1 releases and two variants labeled switch, each checked against its own SHA-1 manifest. Graphics and audio sources are committed in the tree, so the documented build reads no base ROM.
- [PaperBoat: a native Paper Mario port built on the decompilation](https://awesomerea.org/resources/paperboat-paper-mario-port-case/index.md): Case study · Compiles Paper Mario decompilation sources, credited to the pmret and Paper Mario DX projects, into a native US-version application on libultraship. Torch converts the user’s own ROM into a local asset archive, and the port adds rendering backends, enhancements and archive-based mods. Desktop releases are published, while Android, iOS and web builds are documented on the development branch.
- [Halo 2: an agent-assisted matching decompilation of an LTCG Xbox build](https://awesomerea.org/resources/halo2-matching-decomp-case/index.md): Case study · A work-in-progress matching decompilation of Halo 2 for the original Xbox: contributors write C and C++ that the period compiler, building the whole program with link-time code generation, must turn back into the retail executable's bytes function by function. The README reports just under half of the game-function bytes matched and leaves a native port for a later stage. It discloses that much of the maintainer's work runs in Claude and Codex coding-agent lanes.
- [DiabloWeb: a WebAssembly browser port built on Devilution](https://awesomerea.org/resources/diabloweb-devilution-wasm-port-case/index.md): Case study · Runs Diablo in web browsers by compiling a stripped-down fork of Devilution, the community reconstruction of the game’s original source, to WebAssembly behind a React front end. The fork removes the Storm, DiabloUI, DirectX and Windows dependencies and reworks event handling for the browser. It is a port built on a reconstruction and reports no matching or behavior-equivalence checks of its own.
- [pokered: a matching Pokémon Red and Blue disassembly](https://awesomerea.org/resources/pokered-disassembly-case/index.md): Case study · Reconstructs the Game Boy games Pokémon Red and Blue as RGBDS assembly, with graphics and data kept as editable source files. One tree builds the USA/Europe Red and Blue ROMs, a Blue debug build and patches for the Virtual Console releases, each checked against a recorded SHA-1. It is a full disassembly rather than a decompilation into a higher-level language.
- [Lighthouse: a Banjo-Kazooie PC port built on the decompilation](https://awesomerea.org/resources/lighthouse-banjo-kazooie-port-case/index.md): Case study · A native Windows, Linux and macOS port of Banjo-Kazooie that compiles game C sources, many tagged with their Banjo-Kazooie decompilation file paths, against libultraship, a reimplementation of the N64 SDK. Torch extracts the user’s ROM into an asset archive, and the port adds Anchor multiplayer, romhack and language-pack support and a randomizer. Unlike Banjo: Recompiled, it builds from decompiled source rather than statically recompiling the ROM’s code.
- [Lost Odyssey Recomp: statically recompiling an Xbox 360 RPG into native ports](https://awesomerea.org/resources/lost-odyssey-recomp-case/index.md): Case study · Translates Lost Odyssey’s Xbox 360 PowerPC executable with patched XenonRecomp tooling and runs the generated code on a native runtime that renders through Direct3D 12, Vulkan or Metal. Windows, Linux, macOS and Android packages import the user’s own disc data. The maintainer documents development with Claude Code and Codex CLI and records each release separately from validation and acceptance.
- [Super Smash Bros. Melee: a matching GameCube decompilation with a shiftable build](https://awesomerea.org/resources/melee-matching-decomp-case/index.md): Case study · A matching decompilation of Super Smash Bros. Melee's US 1.02 release (GALE01) that rebuilds main.dol from C with the original Metrowerks compilers and checks it against the retail SHA-1. decomp.dev reports the code fully decompiled and linked at the reviewed commit, and the README says current work is mostly naming and cleanup. Because the build can be shifted, a separate non-matching mode lets modders add code to a DOL run with their own disc dump.
- [pokecrystal: a matching Pokémon Crystal disassembly](https://awesomerea.org/resources/pokecrystal-disassembly-case/index.md): Case study · Reconstructs the Game Boy Color game Pokémon Crystal as RGBDS assembly, with graphics, maps and data stored as editable sources. One tree builds the international 1.0 and 1.1 releases, the Australian release, two debug builds and a Virtual Console patch, each checked against a recorded SHA-1. Companion documentation covers script command formats and known bugs in the original game.
- [Pokémon HeartGold and SoulSilver: a work-in-progress, checksum-matched DS disassembly](https://awesomerea.org/resources/pokemon-heartgold-soulsilver-disassembly-case/index.md): Case study · Rebuilds the US Nintendo DS releases of Pokémon HeartGold and SoulSilver from a work-in-progress disassembly in which part of the code has been decompiled to C. Each default build checks the ARM9 and ARM7 binaries, the filesystem and the complete ROM against per-game SHA-1 manifests. README warns that, because decompilation is incomplete, edits that change code or data layout can crash the game.
- [FFTARecomp: static recompilation of Final Fantasy Tactics Advance](https://awesomerea.org/resources/fftarecomp-gba-static-recomp-case/index.md): Case study · Recompiles the user’s Final Fantasy Tactics Advance (USA) Game Boy Advance ROM ahead of time into native code for Windows, Linux and Steam Deck, building on JRickey’s gba-recomp toolkit. ARM and Thumb code is translated to C and compiled locally, while a Rust runtime models the console’s graphics, sound, DMA, timers and BIOS calls. The port adds widescreen, zoom, fast-forward and remappable controls.
- [SymphonyRecomp: a RecompOne static recompilation of Symphony of the Night](https://awesomerea.org/resources/symphonyrecomp-case/index.md): Case study · Statically recompiles the North American PlayStation release of Castlevania: Symphony of the Night into C# with BlackLabelHQ’s RecompOne, whose runtime simulates the BIOS, memory-mapped I/O, GPU and CD-ROM so the game runs natively without a console BIOS. Per-overlay function maps and patches add widescreen, quality-of-life, randomizer and cheat features. References from the SOTN decompilation help name functions in this recompilation.
- [The Two Towers Recompiled: an original Xbox static-recompilation port](https://awesomerea.org/resources/two-towers-recompiled-case/index.md): Case study · Statically recompiles the x86 code of The Lord of the Rings: The Two Towers (Xbox, USA, 2002) into C with the bundled xboxrecomp toolkit, producing native Windows, Linux and experimental macOS builds. The recompiled sources are generated locally from the player's own default.xbe, and game data comes from their disc image or extracted folder. README reports the game as fully playable, with visual, frame-rate and mod issues listed.
- [Melee Unlocked: a Windows source port and static recompilation of Melee](https://awesomerea.org/resources/melee-unlocked-case/index.md): Case study · A beta Windows build of Super Smash Bros. Melee (NTSC 1.02) with two engines: a source port that compiles the doldecomp decompilation as a native library, and a static recompilation that translates the retail DOL's PowerPC code and Slippi's Gecko codes into C++. Both run on a native runtime with Direct3D rendering, unlocked display rates and natively implemented Slippi rollback play. The user's own ISO supplies all game data, and the README says the work was AI-assisted.
- [pokeruby: a matching Pokémon Ruby and Sapphire decompilation](https://awesomerea.org/resources/pokeruby-decomp-case/index.md): Case study · Reconstructs the Game Boy Advance games Pokémon Ruby and Sapphire as C source built with pret's agbcc compiler, alongside assembly data scripts and editable graphics. Matching builds cover the English 1.0, 1.1 and 1.2 revisions, debug builds and the first German editions, each checked against a stored SHA-1. A separate modern-GCC target is not expected to match.
- [Vandal Hearts: native PC port built on matching decompilations](https://awesomerea.org/resources/vandal-hearts-pc-port-case/index.md): Case study · Builds on shao113’s matching decompilation of PlayStation Vandal Hearts, adds a Japanese matching tree, and carries both through to a native Windows and Linux port. SDL2, OpenGL or Metal and OpenAL backends replace the console’s GPU, GTE, CD-ROM/XA, SPU, MDEC and pad interfaces, and one executable runs the USA, Asia and Japan discs. The matching builds are still checked on every change; PC-only features such as Tactical Mode and HD packs are opt-in.
- [Pokémon Platinum: a checksum-matched Nintendo DS decompilation](https://awesomerea.org/resources/pokemon-platinum-decomp-case/index.md): Case study · Reconstructs the US Nintendo DS release of Pokémon Platinum as C source that rebuilds revision 1 by default and revision 0 on request. The default make target runs Meson checks of the code binaries, filesystem and complete ROM against SHA-1 manifests. README still calls the project work in progress; its contributing guide says the code is entirely C but much of it remains obfuscated, leaving documentation and tooling as the main work.
- [Saints Reborn: a ReXGlue static recompilation of Saints Row](https://awesomerea.org/resources/saints-reborn-recomp-case/index.md): Case study · An unofficial native Windows port of Saints Row (Xbox 360, 2006) that statically recompiles the game's PowerPC executable to C++ for x86-64 with the ReXGlue SDK, which also reimplements the console's kernel, GPU (on Direct3D 12), audio and input. A recompiler manifest, game-specific function overrides and an SDK patch make the result run, and each user builds it locally from their own disc. The README reports the game fully playable with built-in co-op and lists known issues.
- [Pokémon Platinum PC Port: a native port built on the pret decompilation](https://awesomerea.org/resources/pokemon-platinum-pc-port-case/index.md): Case study · Builds native 64-bit Windows and Linux executables of Pokémon Platinum from a fork of pret’s decompilation, replacing NitroSDK with the author’s libntr libraries; the same tree keeps the DS ROM build and an experimental Switch target. README says the game should be playable from start to finish but may crash or show graphical bugs. Prebuilt binaries require the player’s own US ROM, and the fork’s default build no longer runs pret’s checksum tests.
- [MikuPan: a native Fatal Frame PC port built on the Himuro decompilation](https://awesomerea.org/resources/mikupan-fatal-frame-port-case/index.md): Case study · Ports the PS2 game Fatal Frame to native PC builds without emulation; its repository description names the Himuro decompilation as its basis. Stubs replace PS2 kernel calls and a new SDL3-based layer handles rendering, audio and UI, while game data comes from the user’s own disc. The README calls the port very early work and publishes no matching or fidelity checks.
- [Starfox 64: Recompiled — an N64Recomp static-recompilation port](https://awesomerea.org/resources/starfox64-recompiled-case/index.md): Case study · Uses N64: Recompiled to statically recompile the US 1.1 (Rev A) Nintendo 64 release of Star Fox 64 into a native port for Windows, Linux and macOS, rendered with RT64. Its patches and enhancements draw on headers and some functions from the separate sf64 decompilation; the port is built through static recompilation. The README reports high-frame-rate, widescreen and mod support, with assets loaded from the user's own ROM.
- [Syphon Filter: The Omega Strain — matching PS2 executable decompilation](https://awesomerea.org/resources/syphon-filter-omega-strain-decomp-case/index.md): Case study · Reconstructs much of the NTSC-U PlayStation 2 executable of Syphon Filter: The Omega Strain as C; with the remaining functions kept as split assembly, the build reproduces the retail SCUS_972.64 byte for byte. Committed objdiff reports track per-function matching against the user’s own executable. This is a matching-decompilation case; progress figures remain project-reported.
- [Animal Crossing: a native PC port of the GameCube decompilation](https://awesomerea.org/resources/animal-crossing-pc-port-case/index.md): Case study · Runs Animal Crossing’s decompiled GameCube C code natively on 32-bit x86, replacing the GX graphics API with an OpenGL 3.3 translation layer and console services with SDL2-based platform code. Game assets are read at startup from the user’s own disc image instead of being shipped. It is a port built on ACreTeam’s ac-decomp.
- [GoldenEye 007: matching Nintendo 64 decompilation for three releases](https://awesomerea.org/resources/goldeneye-007-matching-decomp-case/index.md): Case study · Reconstructs GoldenEye 007’s Nintendo 64 code as C source that rebuilds the US, Japanese and PAL ROMs. Assets come from a user-supplied US ROM, with Japanese and PAL differences taken from their own ROMs, and the default build compares each output with a recorded SHA-1. The README still calls the project work in progress, while a mutable status page reports all 208 files done; it is distinct from the separately curated PC port.
- [Starship: a Star Fox 64 PC port built from the decompilation](https://awesomerea.org/resources/starship-sf64-pc-port-case/index.md): Case study · A native PC port of Star Fox 64 that compiles the game's decompiled C code against libultraship, an N64 porting library that reimplements libultra and renders through Fast3D. On first run it uses the Torch tool to turn the user's US ROM into an asset archive, and it ships for Windows, Linux, macOS and Switch. The README of the separate Starfox 64: Recompiled static recompilation calls this port its sibling, built with different technology.
- [CTR Turbocharged: a PC sourceport built on the Crash Team Racing decompilation](https://awesomerea.org/resources/ctr-turbocharged-port-case/index.md): Case study · Extends the Crash Team Racing: High Octane sourceport, which derives from the CTR Native port of the CTR-ModSDK PlayStation decompilation, into Windows and Linux builds with a native 3D renderer, selectable aspect ratios and frame rates up to 240 FPS. The decompiled game code still assumes 32-bit pointers and loads assets from the player’s own NTSC-U disc image. Renderer, timing and option tests exist, but device coverage and fidelity remain project-reported.