# Curated reverse engineering resources · Page 11

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

## Games (100)

- [Ms. Pac-Man: Namco NES disassembly](https://awesomerea.org/resources/ms-pac-man-nes-namco-case/index.md): Case study · Ms. Pac-Man reconstructs assembly source and data layouts for the 1993 Namco/Now Production NES release. The repository separates maze and screen layout data from the main disassembly and directs users to extract graphics from their own ROM before assembling with CC65.
- [Mario Party 6: a partial GameCube decompilation](https://awesomerea.org/resources/mario-party-6-partial-decomp-case/index.md): Case study · MarioParty6 partially decompiles the GameCube game Mario Party 6. Its two C source files cover random-number routines and dynamic-module loading, with headers, a symbol map and a script that compiles the source files.
- [Shiren the Wanderer 2: matching N64 decompilation](https://awesomerea.org/resources/shiren-2-n64-decomp-case/index.md): Case study · Shiren the Wanderer 2 reconstructs most mapped CPU functions of the Japanese Nintendo 64 game as matching C and C++ source; the accounted CPU catalogue also includes classified handwritten assembly and libgcc helpers. The author reports byte-identical full-ROM acceptance builds.
- [Call of Duty 3: a multiplayer ReXGlue recompilation checkpoint](https://awesomerea.org/resources/call-of-duty-3-multiplayer-recomp-case/index.md): Case study · Call of Duty 3 Recompilation applies ReXGlue to the game's multiplayer executable. Its code defines PowerPC hooks and network-service stubs, while a function table names game routines for code generation. The project represents an early game-specific recompilation checkpoint.
- [Rugrats: Search for Reptar: a Rust reconstruction of the PlayStation game](https://awesomerea.org/resources/rugrats-search-for-reptar-case/index.md): Case study · rugrats reconstructs the North American PlayStation game Rugrats: Search for Reptar as a native Rust PC game using data read from the player's own disc. Separate readers decode models, rooms, animation, sound and cinematics, while a new runtime implements controls, physics, level rules and saving. The author reports start-to-finish playability and records reverse-engineering findings in a worklog and format reference.
- [snatcher-port: reconstructing Sega CD Snatcher for desktop](https://awesomerea.org/resources/snatcher-port-case/index.md): Case study · snatcher-port investigates the Sega CD version of Snatcher and builds a desktop Mega CD runtime around code and data supplied from the user's disc. Its findings describe the main and sub CPU roles, while the engine implements game-needed hardware and BIOS services and offers a build-time 68000 translation path.
- [FPC Atomic: reconstructing Atomic Bomberman multiplayer](https://awesomerea.org/resources/fpc-atomic-bomberman-case/index.md): Case study · FPC Atomic recreates Atomic Bomberman multiplayer in Free Pascal, replacing its IPX networking with TCP/IP and adding custom AI and SDL2 controller support. Players can extract assets from their own game disc or generate original graphics and sounds with the included asset generator.
- [L4D PC Recomp: a Left 4 Dead Xbox 360 boot harness](https://awesomerea.org/resources/l4d-pc-recomp-case/index.md): Case study · L4D PC Recomp uses XenonRecomp to lift Left 4 Dead's Xbox 360 PowerPC modules into C++ for a Windows x64 boot harness. The repository provides per-module configs, a guest-memory arena, dispatch table and kernel stubs. Its documented progress reaches launcher and filesystem initialization; rendering and gameplay remain unfinished.
- [Shining Force CD: a reassemblable game disassembly](https://awesomerea.org/resources/sfcd-disasm-case/index.md): Case study · SFCDDISASM provides an assembly disassembly of Shining Force CD for documenting and editing the game. Its scripts split a user-supplied US ISO into data chunks and combine them with the assembly; the author reports that the rebuilt ISO matches the original bit for bit. Some disassembly formatting remains unfinished.
- [d3b-emu: reconstructing a Diablo III Beta server](https://awesomerea.org/resources/d3b-emu-diablo-iii-beta-case/index.md): Case study · d3b-emu reconstructs a server for Diablo III Beta client version 0.3.0.7447 in C# and .NET 8. Based on an earlier mooege version, it updates opcodes and message definitions and implements beta-era game systems, while Battle.net handling, item persistence and skill accuracy remain incomplete.
- [Armored Core: a European-disc recompilation setup host](https://awesomerea.org/resources/armored-core-pal-psxrecomp-case/index.md): Case study · Armored Core Recompiled packages a psxrecomp setup host for the European PlayStation release of Armored Core. It accepts the user's disc image and generates and builds the translated game locally with recomp-ui. The author reports private-package gameplay while exact-package acceptance checks remain open.
- [Portal 2: static recompilation for Apple silicon](https://awesomerea.org/resources/portal-2-apple-silicon-recomp-case/index.md): Case study · Portal 2 is statically recompiled from its Linux x86 modules into a native ARM64 application for macOS and iPhone. Preparation tools lay out ELF modules and apply relocations; a lifter emits C functions that are compiled with a runtime for libc, threading, SDL2, graphics and Steam interfaces. The author reports playable builds on Mac and iPhone.
- [oot-vc: decompiling the Wii Virtual Console N64 emulator](https://awesomerea.org/resources/oot-vc-case/index.md): Case study · oot-vc reconstructs the N64 emulator used in Wii Virtual Console releases of Ocarina of Time, Super Mario 64, and Mario Kart 64. It builds against a user-extracted content1.app and provides DOL and function diffing tools, with work mainly focused on the Japanese Ocarina of Time release.
- [TOMB4: decompiling the PC version of Tomb Raider 4](https://awesomerea.org/resources/tomb4-case/index.md): Case study · TOMB4 reconstructs source for the PC version of Tomb Raider 4. The repository contains C and C++ game routines, Windows build projects, a changelog of game fixes and installation instructions that use an existing game installation.
- [NetspherePirates: an S4 League Patch 34 server emulator](https://awesomerea.org/resources/netspherepirates-s4-league-case/index.md): Case study · NetspherePirates recreates a server for the S4 League Patch 34 client, identified as EU v1139 Season 1. Its C# source defines game login outcomes, channel responses and serialized server information.
- [The Order: 1886: a native PC runtime for the PS4 game](https://awesomerea.org/resources/the-order-1886-pc-port-case/index.md): Case study · The Order: 1886 PC port runs the user's PS4 game executable natively on a Windows x86-64 processor through replacement system libraries. It uses the shadPS4 video core to translate PS4 GPU commands and shaders to Vulkan; the author reports reaching a rendered prologue with CUSA00035 version 01.02.
- [Pac-Man Championship Edition: a native PC static recompilation](https://awesomerea.org/resources/pac-man-championship-edition-pc-recomp-case/index.md): Case study · Pac-Man Championship Edition recompiles the Xbox 360 Live Arcade game's PowerPC code to x86-64 for a native Windows build using ReXGlue. Game-specific hooks adjust frame pacing and playfield placement, and an optional mode rearranges Championship Mode mazes. The repository also records Xbox 360 imports found during an earlier XenonRecomp attempt.
- [Open4DBoxing: static recompilation of 4D Sports Boxing](https://awesomerea.org/resources/open4dboxing-case/index.md): Case study · Open4DBoxing rebuilds the DOS game 4D Sports Boxing by recompiling four game executables and five sound drivers from machine code into C. A project runtime models DOS, BIOS, video and sound hardware, while SDL2 provides the frontend; the author reports comparisons with the original in DOSBox-X.
- [Super Paper Mario: a selective matching Wii decompilation](https://awesomerea.org/resources/super-paper-mario-decomp-case/index.md): Case study · spm-decomp reconstructs selected Super Paper Mario code for Wii releases, chiefly the two PAL revisions, using decomp-toolkit and matching-object annotations. Its build reads a user-provided disc image; the project explicitly confines work to selected game components rather than the full game or a platform port.
- [Project Vekta: a static recompilation of Killzone HD](https://awesomerea.org/resources/project-vekta-case/index.md): Case study · Project Vekta builds a native Linux or Windows port of the PS3 game Killzone HD by translating its PPU and SPU code to C++ with a patched ps3recomp. Its runtime replaces PS3 services and replays graphics commands through Vulkan; players generate the game code locally from their own files.
- [Re-Comprehend: rebuilding Penguin Software adventure engines](https://awesomerea.org/resources/re-comprehend-case/index.md): Case study · Re-Comprehend reimplements the Comprehend and Graphics Magician engines for Penguin Software adventures including Transylvania, Crimson Crown and OO-Topos. It reads the user's original DOS game files, preserves the original save format, and offers data dumps and runtime commands for inspecting objects, rooms and state.
- [Monster Hunter: PS2 decompilation and PC/Xbox ports](https://awesomerea.org/resources/monster-hunter-ps2-pc-xbox-case/index.md): Case study · Monster Hunter decompiles Japanese PS2 releases of Monster Hunter, Monster Hunter G and Monster Hunter 2 into C checked against users' discs, then runs the reconstructed code on PC and the original Xbox through new platform layers. The tools survey ELF symbols, extract AFS data and overlays, and compare compiled functions with original bytes. The author reports playable PC and Xbox builds for the first two games, while Monster Hunter 2 remains at an early port stage.
- [Dark Rift: a game decompilation and combat-state analysis](https://awesomerea.org/resources/dark-rift-case/index.md): Case study · Dark Rift is a game decompilation with reconstructed gameplay, audio, model, and system source files. Its research notes map player move IDs through combat states and transition rules loaded from character .db files.
- [RestoRoom: researching a Rec Room server reconstruction](https://awesomerea.org/resources/restoroom-case/index.md): Case study · RestoRoom investigates Rec Room's client-to-server behavior as groundwork for a replacement server. Its current findings list API endpoints and documented rec.net subdomains, with a packet capture in the repository; account, room and relay services are still planned.
- [WWE 2K14 Recomp: a native Windows port by Xbox 360 static recompilation](https://awesomerea.org/resources/wwe-2k14-recomp-case/index.md): Case study · WWE 2K14 Recomp builds a native Windows x64 port by translating the Xbox 360 game's PowerPC code into C++ ahead of time with ReXGlue. Its game-specific work maps functions in title update 2.0.1.0 and repairs startup, cloth, texture and timing behavior. The author reports working menus, exhibition matches and saves, while several modes remain incompletely tested.
- [Glover: partial N64 matching decompilation](https://awesomerea.org/resources/glover-decomp-case/index.md): Case study · Glover reconstructs part of the North American N64 game's code in C alongside assembly segments. Its build takes a user-provided base ROM, and its progress script classifies functions using the built ELF and locally generated nonmatching assembly files.
- [Ratchet & Clank Future: Tools of Destruction: early PS3 matching decompilation](https://awesomerea.org/resources/ratchet-clank-tools-of-destruction-decomp-case/index.md): Case study · Ratchet & Clank Future: Tools of Destruction is an early matching decompilation of the USA PlayStation 3 release. Its tools inspect the package, SELF container and decrypted PPU ELF, recover function boundaries and compare compiled C bodies with retail bytes. The author reports byte-exact results for an initial set of functions while the full executable remains a long-term target.
- [SWGEmu Core3: reconstructing the classic Star Wars Galaxies server](https://awesomerea.org/resources/swgemu-core3-case/index.md): Case study · SWGEmu Core3 reconstructs the server for the pre-Combat Upgrade era of Star Wars Galaxies. Its authors describe reverse-engineering the original behavior from scratch and implementing a new engine and game logic; the repository contains C++ server code and extensive Lua gameplay scripts.
- [WinWar: rewriting Warcraft: Orcs & Humans with original game data](https://awesomerea.org/resources/winwar-case/index.md): Case study · WinWar rewrites Warcraft: Orcs & Humans as a C# and MonoGame desktop port for Windows, Linux and macOS. It loads the original game's WAR art and level files from a user-supplied retail or demo copy. The project is archived.
- [Project Topaz: a Final Fantasy XI server emulation](https://awesomerea.org/resources/project-topaz-case/index.md): Case study · Project Topaz recreates an online server for Final Fantasy XI with C++ services, Lua game scripts and SQL data. Some retail game behavior remains unimplemented.
- [The Legend of Zelda: Spirit Tracks: hand-decompiled Nintendo DS source](https://awesomerea.org/resources/spirit-tracks-decomp-case/index.md): Case study · A work-in-progress hand decompilation recreates source for the Nintendo DS game The Legend of Zelda: Spirit Tracks. Its build accepts an owned base ROM for asset extraction and lists Japanese, European and US releases, with Europe Revision 0 as the default.
- [reUndr: a PS5 port of Need for Speed: Underground](https://awesomerea.org/resources/reundr-ps5-case/index.md): Case study · reUndr ports the original Xbox Need for Speed: Underground to homebrew-enabled PS5 consoles using an existing static recompilation and a PS5 replacement runtime for graphics, audio, input, and system services. It imports game data from the user's USA Xbox disc image.
- [COD6-NX: Xbox 360 Modern Warfare 2 recompilation for Switch](https://awesomerea.org/resources/cod6-nx-modern-warfare-2-case/index.md): Case study · COD6-NX ports the Xbox 360 Call of Duty: Modern Warfare 2 to Nintendo Switch by recompiling game code for ARM64 with ReXGlue. Its custom Vulkan renderer consumes the game's PM4 command ring and manages textures, pipelines and render targets; development notes record observed rendering failures.
- [YaPang: matching decompilation of the PangYa client and renderer](https://awesomerea.org/resources/yapang-case/index.md): Case study · YaPang reconstructs the 2011 PangYa client and Direct3D renderer as C++ source checked function by function with objdiff against the original binaries. A separate JP client code area is functionally decompiled for a port. Third-party libraries are excluded from the decompilation.
- [tomb3: decompiling PC Tomb Raider 3](https://awesomerea.org/resources/tomb3-tomb-raider-3-case/index.md): Case study · tomb3 reconstructs the PC Tomb Raider 3 game as C++ source. Its changelog reports a completed decompilation and newly compiled executable, alongside renderer changes, gameplay fixes, and support for the game's original installed data.
- [Pokémon Aurora Ticket Distribution: a GBA disassembly](https://awesomerea.org/resources/aurora-ticket-distribution-case/index.md): Case study · Pokémon Aurora Ticket Distribution's US GBA ROM is reconstructed as assembly and C source. The repository includes a Makefile, linker configuration and setup instructions for building auroraticket.gba against a user-provided original ROM.
- [Birdman64: a native Pilotwings 64 port](https://awesomerea.org/resources/birdman64-case/index.md): Case study · Birdman64 ports Pilotwings 64 to native PC play by compiling decompiled game source against a user-supplied US ROM during first-time setup. Its runtime adds widescreen rendering, modern controls and two-player split-screen; the project also describes experimental Android support and iOS test builds.
- [BakuganBB-recomp: an accessible PC recompilation of Bakugan Battle Brawlers](https://awesomerea.org/resources/bakuganbb-recomp-case/index.md): Case study · BakuganBB-recomp is an early PC recompilation project for the Xbox 360 game Bakugan Battle Brawlers, with Linux as its first target. Its code includes speech and spatial-audio components intended to improve accessibility for blind players, while investigation notes document the executable, runtime imports and game interfaces.
- [Butterscotch: rebuilding the GameMaker: Studio runner](https://awesomerea.org/resources/butterscotch-case/index.md): Case study · Butterscotch reimplements the GameMaker: Studio runner in C so exported games can execute on additional platforms. It interprets GameMaker bytecode and documents support for WAD versions 8 through 17, with desktop, web, and console targets. Bytecode support remains in progress, and native-code YYC and GMRT games are outside its stated scope.
- [Sly 2: Band of Thieves: a matching PS2 decompilation](https://awesomerea.org/resources/sly-2-matching-decomp-case/index.md): Case study · Sly 2: Band of Thieves reconstructs the USA PlayStation 2 executable as C and C++ built with period ee-gcc and SN assembler tools. Per-function compilation and relocation-aware comparison check the output against the owner's disc; the author reports that all 6,662 functions match byte for byte.
- [FreQuency: reconstructed PlayStation 2 source and runtime](https://awesomerea.org/resources/frequency-ps2-reconstruction-case/index.md): Case study · FreQuency reconstructs source and runtime components for the 2001 PlayStation 2 rhythm game. Its build uses ps2dev compilers for the Emotion Engine and IOP, reconstructed Sony library routines, and an optional user-supplied disc image to create a Mode 2 CD image with rebuilt executable and EZMIDI.IRX files.
- [BarrelPad: an Apple port of the reconstructed Diddy Kong Racing engine](https://awesomerea.org/resources/barrelpad-diddy-kong-racing-case/index.md): Case study · BarrelPad adapts Golden Balloon's decompilation-based Diddy Kong Racing port for Mac, iPhone, and iPad. It adds Apple lifecycle integration, game-specific touch and controller input, and local loading of the user's ROM while the reconstructed game logic runs as native host code.
- [Gauntlet Dark Legacy: a C++ and Vulkan engine reconstruction](https://awesomerea.org/resources/gauntlet-dark-legacy-pc-port-case/index.md): Case study · Gauntlet Dark Legacy is ported to Windows and Linux through a C++ and Vulkan reconstruction of its engine. The build reads the game's asset tree extracted from the user's USA GameCube disc; the repository supplies engine code, shaders and asset setup scripts.
- [HPCOS GC: Harry Potter and the Chamber of Secrets recompiled for PC](https://awesomerea.org/resources/hpcos-gc-recomp-case/index.md): Case study · HPCOS GC uses DolRecomp to translate the GameCube PowerPC code of Harry Potter and the Chamber of Secrets for a native PC runtime based on ModernGekko. Its title-specific additions include dynamic widescreen, field-of-view controls and a PC settings menu; subsequent development moved to GekkoAOT.
- [GearsUE3: rebuilding Gears of War around Xenia dynarecs](https://awesomerea.org/resources/gearsue3-case/index.md): Case study · GearsUE3 is developing a native engine port for the Xbox 360 Gears of War games, with Gears of War 1 as its active target. Its planned product combines Xenia Xenon dynarecs and system services with title-specific native function overrides. The repository records code maps and reverse-engineering findings. The current launcher cannot start that product because image loading and runtime composition remain unwired.
- [Test Drive II: The Duel: an SDL3 reconstruction of the DOS EGA game](https://awesomerea.org/resources/test-drive-2-sdl3-case/index.md): Case study · Test Drive II: The Duel is reimplemented in C for SDL3 from analysis of the DOS EGA game. The port loads the user's original executable and data, while accompanying tools unpack EXEPACK files, disassemble x86 code and decode resource archives. Function indexes, porting specifications and file-format notes document the reconstruction.
- [azure: matching decompilation of Azure Dreams](https://awesomerea.org/resources/azure-dreams-decomp-case/index.md): Case study · azure reconstructs source for the PlayStation game Azure Dreams and builds PSX executables from a user-supplied CD image. Its workflow extracts code and data, compiles C with a source-built PSY-Q 4.1-compatible compiler, and documents per-function matching work and unresolved overlays.
- [Street Fighter Alpha 3 MAX: a partial PSP decompilation with a native runtime](https://awesomerea.org/resources/street-fighter-alpha-3-max-decomp-case/index.md): Case study · Street Fighter Alpha 3 MAX: Decomp reconstructs the PSP game's functions as readable C inside a native PC runtime. Functions not yet decompiled are translated from the PSP program during the build, while parity tests compare selected runs frame by frame. The author reports 412 of 14,881 functions decompiled; the US ULUS-10062 disc supplies the program and assets.
- [Chrono Trigger: a matching SNES US 1.0 disassembly](https://awesomerea.org/resources/chrono-trigger-us-disassembly-case/index.md): Case study · Chrono Trigger US 1.0 is reconstructed as banked SNES assembly with symbolic pointer tables and RAM labels. A build script extracts data blobs from the user's ROM, assembles the source with asar, and checks that the result is byte-identical to the input ROM.
- [Tetris: an annotated Game Boy disassembly](https://awesomerea.org/resources/game-boy-tetris-disassembly-case/index.md): Case study · Tetris reconstructs the Game Boy World Rev A release as an assembly listing generated with gbdasm and annotated by hand. The README gives RGBDS assembly and linking commands plus file and MD5 comparisons for checking the rebuilt ROM.
- [YodaStoriesNG: rebuilding Yoda Stories and Indiana Jones from their data files](https://awesomerea.org/resources/yodastoriesng-case/index.md): Case study · YodaStoriesNG reimplements Star Wars: Yoda Stories and Indiana Jones and His Desktop Adventures in C# and SDL2 using each game's original data file. It parses tiles, zones, puzzles and IACT scripts, reconstructs world generation, and provides script disassembly and other inspection windows. The author reports complete Yoda Stories play and remaining Indiana Jones puzzle gaps.
- [Mario Party 5: a GameCube decompilation](https://awesomerea.org/resources/mario-party-5-decomp-case/index.md): Case study · Mario Party 5 is reconstructed as a work-in-progress GameCube decompilation for the USA Rev 0 release. The project uses a user-owned disc image, Python configuration and Ninja builds; its source tree contains C code and symbol maps for the main program and REL modules.
- [Lordran Native: rehosting Dark Souls: Remastered on Apple devices](https://awesomerea.org/resources/lordran-native-case/index.md): Case study · Lordran Native ports the Nintendo Switch release of Dark Souls: Remastered to Apple devices by running its ARM64 code directly. A rewriter adapts kernel-dependent instructions, a host supplies Horizon services, and a Metal layer implements NVN graphics. The project packages locally supplied NSP files and keys into macOS or unsigned iOS builds.
- [Airborne Ranger: lifting a DOS game into a C port](https://awesomerea.org/resources/airborne-ranger-port-case/index.md): Case study · Airborne Ranger ports the 1987 DOS game to C by lifting AR.EXE and its TANDYSND.EXE overlay with a masm2c-style translator, then hand-checking the output against the reference binaries. An SDL2 frontend runs with the player's original files, and the repository includes lifted code, generation scripts and tests.
- [FM4-Recomp: a Forza Motorsport 4 static recompilation](https://awesomerea.org/resources/fm4-recomp-case/index.md): Case study · FM4-Recomp statically recompiles the Xbox 360 release of Forza Motorsport 4 for Windows x64 using ReXGlue. Based on Pinyon Shift, it provides game-specific analysis configurations, runtime hooks, SDK patches and a disc-verifying launcher. Its 0.1.0 changelog reports a playable Windows preview.
- [Need for Speed: Most Wanted for Android — Xbox static recompilation for Android](https://awesomerea.org/resources/mostwanted-android-case/index.md): Case study · Need for Speed: Most Wanted for Android ports the original Xbox Black Edition to Android arm64 by translating its x86 XBE code to C++ with XboxXBE-Recomp. A Vulkan host renders the game, while SDL3 handles windowing, input and audio; the port also provides touch controls and graphics settings.
- [mgs_reversing: matching Metal Gear Solid Integral source reconstruction](https://awesomerea.org/resources/mgs-reversing-case/index.md): Case study · mgs_reversing reconstructs Metal Gear Solid Integral for PlayStation as C source intended to compile to the same assembly as the original. The author reports that the SLPM_862.47, SLPM_862.48 and SLPM_862.49 main executables are fully decompiled; work on stage overlays continues.
- [SSX 3: an in-progress matching PS2 decompilation](https://awesomerea.org/resources/ssx3-decomp-case/index.md): Case study · SSX 3 reconstructs source for the NTSC-U PlayStation 2 game with the goal of matching its executable. The repository includes C++ source, build configuration and working notes on functions, data structures and subsystems such as rider physics, animation and world streaming.
- [Sonic Generations Recompiled: an Xbox 360 static recompilation](https://awesomerea.org/resources/sonic-generations-recompiled-case/index.md): Case study · Sonic Generations Recompiled translates the Xbox 360 game's PowerPC code into native C++ with XenonRecomp and builds host services for kernel calls, audio, input, files and graphics. A newer Windows path uses ReXGlue with Vulkan graphics experiments; the author describes both paths as incomplete for game-level play.
- [Dino Crisis - Modern Edition: a disc-built Windows recompilation](https://awesomerea.org/resources/dino-crisis-modern-edition-case/index.md): Case study · Dino Crisis - Modern Edition rebuilds the PlayStation game Dino Crisis as a native Windows program from the user's disc image. Its installer recompiles the game code to C and combines it with a runtime supplying a new renderer, camera, controls and mod support; the repository includes build scripts and hooks for supported disc versions.
- [Hunchback: an in-progress ZX Spectrum disassembly](https://awesomerea.org/resources/hunchback-spectrum-disassembly-case/index.md): Case study · Hunchback is an in-progress SkoolKit disassembly of the ZX Spectrum game. The repository includes a .skool listing, SkoolKit control and reference files, and a build script for the published disassembly.
- [Sonic Adventure 2 — Nintendo Switch port: an Xbox 360 static recompilation](https://awesomerea.org/resources/sa2-nx-case/index.md): Case study · The Sonic Adventure 2 Nintendo Switch port translates the Xbox 360 game's default.xex and stage-data module to C++ with ReXGlue and draws through a deko3d renderer. Its repository includes game-specific code, renderer changes and notes on executable behavior. The author reports near-60 FPS single-player results in tested scenes, with heavier two-player scenes running slower.
- [WindowWaker: a Windows port of The Wind Waker from decompiled code](https://awesomerea.org/resources/windowwaker-port-case/index.md): Case study · WindowWaker builds a native Windows port of The Legend of Zelda: The Wind Waker from a community decompilation of the USA GameCube release. The fork adds a Windows build and presentation interpolation for 60 and 120 FPS while game simulation remains at 30 Hz; the build generates asset headers from the user's disc image.
- [SW_RACER_RE: selected functions from Star Wars Episode I: Racer](https://awesomerea.org/resources/sw-racer-re-case/index.md): Case study · SW_RACER_RE maps and reimplements selected functions from Star Wars Episode I: Racer to support game modifications. Symbol files and Ghidra scripts record recovered addresses, while a dinput.dll hook can replace original functions with reconstructed code during play.
- [Call of Duty 2: Big Red One: reconstructing Xbox game code in C++](https://awesomerea.org/resources/cod2-big-red-one-decomp-case/index.md): Case study · Call of Duty 2: Big Red One reconstructs the original Xbox game's code as C++ toward a native Linux and Windows build. Ghidra analysis and function naming support the work; a comparison harness checks rewritten functions against the originals, primarily during gameplay and, for some functions, offline. The author reports 7,067 rewritten functions, while most mission-script functions remain unfinished.
- [Destruction Derby 2 Recompiled: a PlayStation setup host for local static recompilation](https://awesomerea.org/resources/destruction-derby-2-recomp-case/index.md): Case study · Destruction Derby 2 Recompiled provides a setup host and game-specific configuration for locally generating a PlayStation static recompilation from the user's USA disc. It uses PSXRecomp and recomp-ui, with function seeds and symbol mapping. Project notes document a multi-BIN disc identity correction, and the author reports gameplay in a private build.
- [Citadel: a System Shock fan remake](https://awesomerea.org/resources/citadel-system-shock-case/index.md): Case study · Citadel recreates the 1994 System Shock in Unity, aiming to retain the original game while adding 3D models, station details, particles and sound effects. Its Unity project contains gameplay scripts and assets, and it reads audio from the user's System Shock RES data.
- [Project 8 Plus: a native recompilation of Tony Hawk's Project 8](https://awesomerea.org/resources/project-8-plus-case/index.md): Case study · Project 8 Plus builds a native PC port of the PS3 Tony Hawk's Project 8 from a user's game copy. Its launcher uses RPCS3 for setup decryption and ps3recomp for static recompilation, then adds display options, texture upscaling, and Lua mod support.
- [OpenOMF: a multi-platform remake of One Must Fall 2097](https://awesomerea.org/resources/openomf-one-must-fall-2097-case/index.md): Case study · OpenOMF is a remake of the 1994 DOS fighting game One Must Fall 2097 for Linux, macOS, Windows and other platforms. It includes networking intended to make multiplayer easier to use than the original game's IPX setup.
- [ClassicUO: Ultima Online Classic Client reimplementation](https://awesomerea.org/resources/classicuo-case/index.md): Case study · ClassicUO recreates the Ultima Online Classic Client in C# on FNA-XNA. Its source includes game asset loaders and client logic for a separately obtained installation, and the authors describe testing primarily against free shards.
- [WET: a ReXGlue Xbox 360 PC port](https://awesomerea.org/resources/wet-recomp-case/index.md): Case study · WET is a PC port of the Xbox 360 game built with ReXGlue from the user's disc image. Its setup script applies input patches and generates game code, while the project supplies host code, ultrawide display changes and Windows and Linux build paths.
- [Sonic the Hedgehog: a generated Sega Master System disassembly](https://awesomerea.org/resources/sonic-master-system-disassembly-case/index.md): Case study · Sonic the Hedgehog disassembles the Sega Master System game from a user-supplied ROM. A Python unpacker and annotation file generate Z80 assembly, which WLA-DX assembles into an output ROM; the repository also includes ROM asset-location and level-viewing tools.
- [minecraft: a Minecraft Xbox 360 recompilation prototype](https://awesomerea.org/resources/minecraft-xbox-360-recomp-case/index.md): Case study · minecraft configures ReXGlue to recompile Minecraft: Xbox 360 Edition into a native program using extracted game files. It includes a title configuration, build wiring and an application entry point. The author reports that the current build displays only a black screen.
- [Super Monkey Ball 2 Sakura Edition Vita: an Android game port](https://awesomerea.org/resources/super-monkey-ball-2-sakura-edition-vita-case/index.md): Case study · Super Monkey Ball 2 Sakura Edition Vita runs the Android game on PS Vita by loading its ARMv7 executable, resolving imports with native functions and applying platform patches. The setup uses the player's APK and downloaded cache files from versions released before the game became free to play.
- [F-Zero X: a work-in-progress matching Nintendo 64 decompilation](https://awesomerea.org/resources/f-zero-x-decomp-case/index.md): Case study · F-Zero X reconstructs the Nintendo 64 game's source as a work-in-progress matching decompilation. Its build takes a user-supplied US or Japanese revision 1.0 ROM, extracts assets, disassembles code, and rebuilds a ROM whose checksum is checked. The repository contains game C source and per-version asset layouts.
- [Sheep, Dog 'n' Wolf: a decompiled multiplatform implementation](https://awesomerea.org/resources/sheep-dog-n-wolf-rewooled-case/index.md): Case study · Rewooled reconstructs the PC game Sheep, Dog 'n' Wolf from machine-code analysis and runs it on Windows, macOS and Linux using SDL3. Its source covers the game engine, objects, input and rendering, while the runtime reads assets from the user's game copy.
- [Monster Hunter Tri: a matching Wii decompilation](https://awesomerea.org/resources/monster-hunter-tri-wii-decomp-case/index.md): Case study · Monster Hunter Tri is an in-progress matching decompilation of the USA Wii release RMHE08 in C and C++. Its build links matching reconstructed units with original bytes for unfinished regions, then checks main.dol against a recorded SHA-1. The project tracks split translation units, symbols and per-function scores, and documents compiler-matching techniques and build checks.
- [RedBaron_Recomp: a Snoopy Flying Ace Xbox 360 recompilation](https://awesomerea.org/resources/redbaron-snoopy-flying-ace-case/index.md): Case study · RedBaron_Recomp builds a native Windows x64 version of the Xbox 360 game Snoopy Flying Ace with ReXGlue and ReXAuto. Its launcher extracts the player's game files, generates code and compiles the port locally; repository patches adapt the runtime for graphics, controls and online services.
- [X-Settlers: reconstructing Settlers 3/4 maps and rendering](https://awesomerea.org/resources/x-settlers-case/index.md): Case study · X-Settlers is an early C++17 reimplementation effort for The Settlers 3/4 that renders map terrain and documents Settlers 3 map partitions. Its format notes identify map information, player and team data, previews, areas, buildings and resources. Loading graphics and maps directly from an original installation remains planned.
- [KlingonWin10WPF: rebuilding the Star Trek: Klingon FMV player](https://awesomerea.org/resources/klingonwin10wpf-case/index.md): Case study · KlingonWin10WPF rebuilds the FMV player for Star Trek: Klingon Immersion Studies as a Windows application using the user's original disc videos. Its code handles scenes, clickable hotspots and saves, with video playback through libVLC. The author reports missing button lighting in one scene, no save prompt on exit and hotspot drift after some window resizing.
- [Space Invaders 8080 Static Recompiler: an arcade ROM to C++ translation](https://awesomerea.org/resources/space-invaders-8080-recomp-case/index.md): Case study · Space Invaders 8080 Static Recompiler translates the 1978 arcade game's Intel 8080 ROM into generated C++ before execution. Its lifter uses a linear sweep and branch-target discovery, while an SDL3 runner models I/O ports, a shift register, video output and timed interrupts. The four original ROM files are supplied by the user.
- [Ikachan3: decompiling the Nintendo 3DS release](https://awesomerea.org/resources/ikachan3-case/index.md): Case study · Ikachan3 decompiles the Nintendo 3DS version of Ikachan into game source organized by subsystem. Its build uses the armcc compiler, and a user-provided original code.bin enables binary comparison. The repository includes source for player, map, sound and other game components.
- [NFL Street 2: an evidence-tracked GameCube matching decompilation](https://awesomerea.org/resources/nfl-street-2-decomp-case/index.md): Case study · NFL Street 2 reconstructs C and C++ source for the USA GameCube release with a byte-identical executable as its goal. The build inserts reconstructed units into an original-object baseline and checks the resulting main.dol hash; a trial tool compares individual functions. Configuration files record names, unit boundaries and supporting evidence.
- [Settlers.ts: decoding Settlers 4 data for a browser remake](https://awesomerea.org/resources/settlers-ts-case/index.md): Case study · Settlers.ts builds a browser-based Settlers 4 remake in TypeScript using files from the user's game installation. Its readers decode LIB archives, graphics, maps and saves, while WebGL renders map landscapes. Object drawing, settlers, buildings and game logic are listed as future work.
- [XC2 Recomp: statically recompiling Xenoblade Chronicles 2](https://awesomerea.org/resources/xc2-recomp-case/index.md): Case study · XC2 Recomp statically translates the Nintendo Switch game Xenoblade Chronicles 2 into a native x86-64 application for Windows and Linux. Its setup extracts the user's game and update files, lifts ARM64 code, and builds a runtime with Vulkan rendering. The author reports that the early build reaches the title screen and runs through the opening battle into Goldmouth.
- [OpenDrakan: reconstructing Drakan's Riot Engine](https://awesomerea.org/resources/opendrakan-case/index.md): Case study · OpenDrakan reconstructs Riot Engine for Drakan: Order of the Flame on GNU/Linux. Its C++ project loads original game levels, includes an SRSC data extractor, and documents database structures and UDP/TCP network exchanges.
- [Pal3.Unity: reconstructing Sword and Fairy 3 and Wenqing Pian in Unity](https://awesomerea.org/resources/pal3-unity-case/index.md): Case study · Pal3.Unity reimplements The Legend of Sword and Fairy 3 and its Wenqing Pian expansion in C# and Unity. It rewrites game logic and reproduces behaviour and effects while loading assets from the user's original game installation.
- [DoomRPG-RE: reconstructing Doom RPG in C](https://awesomerea.org/resources/doomrpg-re-case/index.md): Case study · DoomRPG-RE reconstructs Doom RPG as a C program with gameplay, combat, menus, rendering and input modules. Its SDL-based executable loads game data from DoomRPG.zip and builds through CMake with audio and compression dependencies.
- [Mario & Luigi: Partners in Time: matching DS decompilation](https://awesomerea.org/resources/mario-luigi-partners-in-time-decomp-case/index.md): Case study · Mario & Luigi: Partners in Time is a work-in-progress C and C++ decompilation of the European Nintendo DS release, generated with AI under human direction and supervision. The author reports a byte-for-byte ROM rebuild; matching source is gradually replacing assembly, with emulator checks used to confirm game behavior.
- [Wreckless: recompiling The Yakuza Missions for Windows](https://awesomerea.org/resources/wreckless-yakuza-missions-recomp-case/index.md): Case study · Wreckless uses xboxrecomp to translate the original Xbox game's x86 code into C and compile a native Windows executable. Its analysis documents XBE sections, kernel imports, function recovery and ABI work. The author reports that initialization runs but rendering and gameplay are still blocked by an indirect call into a function body.
- [Star Wars Trilogy Arcade: a native PC port from PowerPC static recompilation](https://awesomerea.org/resources/star-wars-trilogy-arcade-native-case/index.md): Case study · Star Wars Trilogy Arcade is ported to PC by statically translating its PowerPC game code to C++ and supplying new graphics, sound and control systems. The project documents Sega Model 3 Step 2.1 hardware and uses a Vulkan renderer; its build requires the player’s own Rev. A arcade ROM.
- [ppengine: a Pole Position remake from arcade ROM analysis](https://awesomerea.org/resources/ppengine-case/index.md): Case study · ppengine recreates Atari's Pole Position as a 3D game using logic reverse engineered from the arcade ROMs. Its C source builds a playable client with steering, braking, acceleration and gear changes, while the title screen remains unfinished.
- [SwitchWaker: a native port of The Wind Waker from decompiled source](https://awesomerea.org/resources/switchwaker-case/index.md): Case study · SwitchWaker ports the GameCube game The Wind Waker to Mac, Linux and Switch by compiling imported decompiled source and running it through a new platform layer with Aurora rendering. Build scripts generate required asset headers from a user's GZLE01 or GZLP01 revision 0 disc.
- [The Phantom Menace: a PlayStation static recompilation and matching decompilation](https://awesomerea.org/resources/phantom-menace-psx-recomp-case/index.md): Case study · The Phantom Menace project runs a static recompilation of the USA Rev 1 PlayStation game natively on desktop and M5Stack Tab5. Its recompiler translates MIPS code into C at build time and runs it with a PlayStation hardware runtime. A matching decompilation aims to replace the generated code function by function; the author reports native gameplay, while the initial handwritten C functions remain nonmatching.
- [Dragon Quest IV: a Nintendo DS decompilation of the European release](https://awesomerea.org/resources/dqiv-decomp-case/index.md): Case study · DQIV-DECOMP reconstructs the European Nintendo DS release of Dragon Quest IV as C++ using ds-decomp. Its build consumes a user-supplied ROM, compiles the reconstructed ARM9 code and overlays with Ninja, and offers objdiff comparisons; an ARM7 BIOS dump enables the optional matching-ROM build.
- [Ghost in the Shell: a PlayStation recompilation setup host](https://awesomerea.org/resources/ghost-in-the-shell-psxrecomp-case/index.md): Case study · Ghost in the Shell Recompiled is a PSXRecomp setup host for the European PlayStation game. The wizard accepts the user's CUE disc and BIOS, then generates and builds the translated code locally. The author records acceptance of a corrected Windows development build and leaves package setup, gameplay and save checks open.
- [Professor Layton: Curious Village HD Vita: an Android game rehosting port](https://awesomerea.org/resources/layton-vita-case/index.md): Case study · Professor Layton: Curious Village HD Vita runs the Android game on PS Vita by loading its ARMv7 executable, resolving Android imports with native functions and patching platform behavior. The loader uses the player's APK and OBB data; the author notes occasional video problems and slow animation after puzzle solutions.
- [ReMech2: rebuilding MechWarrior 2 from decompiled code and original game data](https://awesomerea.org/resources/remech2-mechwarrior-2-case/index.md): Case study · ReMech2 rebuilds MechWarrior 2: 31st Century Combat for Windows and Linux using a Rust runtime and decompiled C/C++ game code from the related demech2 project. It loads data from the user's original disc or installation and adds modern input, audio, rendering and widescreen support.
- [Wonder: a matching decompilation of Wonder Project J2](https://awesomerea.org/resources/wonder-project-j2-decomp-case/index.md): Case study · Wonder reconstructs code for the Japanese Nintendo 64 release of Wonder Project J2 and rebuilds a hash-checked ROM from the user's copy. Its source tree contains C, assembly and extraction tools, while its notes describe the game's ROM layout and SPI compression variants.
- [BattleTanx: Global Assault: an N64 static recompilation port](https://awesomerea.org/resources/battletanx-global-assault-recomp-case/index.md): Case study · BattleTanx: Global Assault is ported to PC by statically recompiling its Nintendo 64 code with N64Recomp and running it on N64ModernRuntime with RT64 rendering. The repository includes a corrected function-boundary map, game-specific runtime changes and a log of the investigations behind them.