--- title: "Curated reverse engineering resources · Page 18" url: https://awesomerea.org/resources/page/18/ updated: 2026-11-10 type: page --- # Curated reverse engineering resources · Page 18 > Page 18 of 52, entries 1,701–1,800. 5,191 tools, projects, integrations, case studies, and references for websites, games, apps, native binaries, firmware, and communication protocols. Source-reviewed means descriptions were checked against primary documentation. Each entry page lists the full requirements and sources; this page shows their counts and the review date. - HTML: - JSON: - 简体中文: ## Games (100) - [Voldorium: SoulCalibur Dreamcast port](https://awesomerea.org/resources/voldorium/index.md): Case study · Voldorium is a native Windows and Linux port of SoulCalibur for the Dreamcast, USA release T-1401N V1.000. The README says the game's SH-4 code is statically recompiled to C and linked with a native runtime, adding 16:9 widescreen, arbitrary resolution, and an online versus mode with GGPO rollback. Only that USA release is supported. - [Burnout 3: Takedown — Xbox static recompilation](https://awesomerea.org/resources/burnout3-xbox-recomp-case/index.md): Case study · This repository is a static recompilation of the Xbox version of Burnout 3: Takedown into a native Windows executable. The README says xboxrecomp lifts the game's x86 code to C, and the game boots through its own entry point on that toolkit's Xbox runtime. - [Harvest Moon 64: Recompiled — native port](https://awesomerea.org/resources/harvest-moon-64-recomp-case/index.md): Case study · Harvest Moon 64: Recompiled uses N64: Recompiled to statically recompile Harvest Moon 64 into a native port, with RT64 for rendering. The README lists mod support and Linux and Steam Deck support among its features. - [Golden Balloon: native and browser port of Diddy Kong Racing](https://awesomerea.org/resources/goldenballoon-case/index.md): Case study · Golden Balloon is a native and browser port of the 1997 Nintendo 64 kart racer, built on the Diddy Kong Racing decompilation. The README says the game is compiled for the machine and runs from a ROM you already own. - [Ring Out: native PC port of a GameCube fighting game](https://awesomerea.org/resources/ring-out-case/index.md): Case study · Ring Out is a native PC port of a GameCube fighting game with disc ID GRSEAF, produced by static recompilation. The README says the disc's PowerPC executable is translated ahead of time into C, compiled for x86-64, and run in a Dolphin-derived runtime. - [Call of Duty: Modern Warfare 2 (2009) — statically recompiling the Xbox 360 game](https://awesomerea.org/resources/mw2-recompiled-case/index.md): Case study · This repository runs Call of Duty: Modern Warfare 2 (2009) for the Xbox 360 natively on Linux and Windows by recompiling the game's executables ahead of time. The README lists campaign and multiplayer, including split screen for up to four controllers. - [Killzone for Windows: native port of the PS2 game](https://awesomerea.org/resources/killzone-recomp-case/index.md): Case study · Killzone for Windows is a native Windows port of Killzone for the PlayStation 2. The README says the game's code is recompiled to C++ with PS2Recomp and runs with mouse and keyboard aim, high frame rates, higher resolutions, and ultrawide support. - [Conker's Bad Fur Day: Reloaded — native PC port](https://awesomerea.org/resources/conker-bfd-reloaded-case/index.md): Case study · Conker's Bad Fur Day: Reloaded is a native Windows and Linux port of the Nintendo 64 game, statically recompiled with N64: Recompiled and drawn with RT64. The README describes a Classic mode and a Modern mode with widescreen, high frame rates, and mouse, keyboard, and controller support. - [Recharged: native PC port of Mario Strikers Charged](https://awesomerea.org/resources/recharged-strikers-case/index.md): Case study · Recharged compiles reconstructed source for Mario Strikers Charged into a native program for Windows, Linux, macOS, and Steam Deck. The README says the game's own code runs unchanged while Recharged supplies graphics, sound, controllers, disc access, and saves. - [NSMB Wii Multiplayer Recompilation: native port of New Super Mario Bros. Wii](https://awesomerea.org/resources/nsmb-wii-multiplayer-recomp-case/index.md): Case study · NSMB Wii Multiplayer Recompilation is a native port of New Super Mario Bros. Wii made with static recompilation on WiiCompiled. The README lists Android, Windows, and Linux builds and says the game code is translated to native code ahead of time. - [FH2 Recompiled: static recompilation of Forza Horizon 2](https://awesomerea.org/resources/fh2-recompiled-case/index.md): Case study · FH2 Recompiled is a static recompilation of Forza Horizon 2 for the Xbox 360, targeting Android and Linux. The README says the repository and its release APKs contain no game files or game code. - [Eternal Darkness Recomp: native port of Sanity's Requiem](https://awesomerea.org/resources/eternal-darkness-recomp-case/index.md): Case study · Eternal Darkness Recomp is a native Mac, Windows, and Linux port of Eternal Darkness: Sanity's Requiem for the GameCube. The README says DolRecomp translates the game's PowerPC code to C, which is then compiled for the machine and run on GXRuntime. - [Demon's Souls: native Windows port of the PS3 game](https://awesomerea.org/resources/demons-souls-recomp-case/index.md): Case study · This is a native Windows build of Demon's Souls for the PlayStation 3, USA release BLUS-30443. The README says PPU and SPU code is statically recompiled to C and C++ with ps3recomp and rendered with Direct3D 12. - [Wii Sports: in-progress decompilation](https://awesomerea.org/resources/wii-sports-ogws-case/index.md): Case study · ogws is a work in progress decompilation of Wii Sports. The README names one supported version, US Revision 1, and points build steps to docs/getting_started.md after the disc is dumped. - [SpongeBob SquarePants: Battle for Bikini Bottom — GameCube decompilation](https://awesomerea.org/resources/bfbb-decomp-case/index.md): Case study · This is a work-in-progress decompilation of SpongeBob SquarePants: Battle for Bikini Bottom. The README says it builds main.dol with SHA-1 306526d90b48e99894c3138f5fc8f2716d9fecf6 for the NTSC-U version GQPE78. - [jsSMS: Master System and Game Gear emulator](https://awesomerea.org/resources/jssms-case/index.md): Case study · jsSMS is a JavaScript emulator for Sega Master System and Game Gear ROMs, written to run quickly in mobile browsers. The README says it began as a port of JavaGear and later replaced the interpreter with a dynamic recompiler in src/compiler. - [Free in the Dark: reimplementation of Alone in the Dark](https://awesomerea.org/resources/fitd-case/index.md): Case study · Free in the Dark is an engine reimplementation of the Alone in the Dark games released from 1992 to 1995. The README focuses on the versions sold on Steam and GOG and says some other releases, including the Windows version of Alone in the Dark 3, are incompatible for now. - [OpenNefia: reimplementation of Elona](https://awesomerea.org/resources/opennefia-case/index.md): Case study · OpenNefia is an open-source, moddable engine reimplementation of the roguelike Elona. The README says the project is still a work in progress and that building it requires the .NET 8.0 SDK. - [Banjo-Tooie: decompilation of the NTSC-U ROM](https://awesomerea.org/resources/banjo-tooie-decomp-case/index.md): Case study · Banjo Tooie Decomp is a decompilation of Banjo-Tooie. The README says to place the NTSC-U ROM in the folder as baserom.us.z64, then run make setup and make to split and build it. - [Rood Reverse: decompilation of Vagrant Story](https://awesomerea.org/resources/rood-reverse-case/index.md): Case study · Rood Reverse is a reverse engineering of Vagrant Story for the PlayStation. The README describes splitting and building with make, then decompiling individual functions, including scratches created with make decompme. - [The Legend of Zelda: matching NES disassembly](https://awesomerea.org/resources/zelda1-nes-disassembly-case/index.md): Case study · This repository is a disassembly of The Legend of Zelda. A tool written for the project turns a Mesen .MLB file and the ROM into a listing, and the sources assemble with ca65. The build compares its output with the original ROM. - [Super Smash Bros. 64: matching Nintendo 64 decompilation](https://awesomerea.org/resources/ssb64-decomp-case/index.md): Case study · Super Smash Bros. 64 Decompilation rebuilds the US Super Smash Bros. ROM for the Nintendo 64. The README gives the baserom hashes, extracts assembly and assets with splat, and includes diff and m2c helpers for matching work. - [Harvest Moon 64 Decomp: matching decompilation of Harvest Moon 64](https://awesomerea.org/resources/hm64-decomp-case/index.md): Case study · Harvest Moon 64 Decomp is a matching decompilation of Harvest Moon 64. The README says the US and Japanese versions are fully decompiled, including game functions, data, rodata, library functions, and the DSL for cutscenes and dialogue. - [Mario Kart 64 3DS: porting Mario Kart 64 to Nintendo 3DS](https://awesomerea.org/resources/mario-kart-64-3ds-case/index.md): Case study · Mario Kart 64 3DS is a native Nintendo 3DS port of Mario Kart 64, based on SpaghettiKart. It adds a dual-screen interface, touch menus, and customizable controls and display options. - [Star Haven: a native 3DS port of Paper Mario](https://awesomerea.org/resources/starhaven-case/index.md): Case study · Star Haven is a native Nintendo 3DS port of Paper Mario for the Nintendo 64, built from the pmret/papermario decompilation. The game's own C code runs on the 3DS. - [XenogearsRecomp: static recompilation of Xenogears](https://awesomerea.org/resources/xenogears-recomp-case/index.md): Case study · XenogearsRecomp is a static recompilation of Xenogears (USA) for the PlayStation. It uses PSXRecomp to turn MIPS R3000A code into C and then native x64, and it recompiles an OpenBIOS or retail SCPH1001.BIN backend with the game executable. - [Rayman 3 HD Recompiled: statically recompiling the Xbox 360 game](https://awesomerea.org/resources/rayman3-hd-recompiled-case/index.md): Case study · Rayman 3 HD Recompiled is a native Windows port of Rayman 3 HD for the Xbox 360. The game's code is statically recompiled to run on a PC, and the installer sets it up from the player's own Xbox 360 package. - [Skullburglar: statically recompiling 50 Cent: Blood on the Sand](https://awesomerea.org/resources/skullburglar-case/index.md): Case study · Skullburglar is a native port of 50 Cent: Blood on the Sand for the Xbox 360, statically recompiled with the ReXGlue SDK. Ready-to-play builds target Windows, macOS on Apple silicon, Linux, and the Steam Deck. Version 1.0 adds a renderer written for the port that reads the game's scene from memory. - [NEOTOKYO Rebuild: rebuilding the NEOTOKYO multiplayer game](https://awesomerea.org/resources/neotokyo-rebuild/index.md): Case study · NEOTOKYO Rebuild is a rebuild of NEOTOKYO in the Source SDK 2013 multiplayer branch, updated for the 2025 Team Fortress 2 SDK. The README says it is forked from NeotokyoRevamp/neo. - [SMW: a PS4 port of Super Mario Bros. Wonder](https://awesomerea.org/resources/smw-ps4-case/index.md): Case study · SMW brings BelmanteGu's static recompilation of Super Mario Bros. Wonder to jailbroken PS4 consoles. The game's ARM code was translated to C++ ahead of time and compiled for the PS4 CPU, and its NVN graphics run on Vulkan through Mesa's RADV driver. - [ARMORED CORE for Answer: native Windows port by static recompilation](https://awesomerea.org/resources/acfa-port-case/index.md): Case study · This is a native Windows port of ARMORED CORE for Answer for the PlayStation 3, USA release BLUS30187. A recompiler turns the game's PowerPC code into C++, about 71,000 functions, and the PC compiler builds a 64-bit Windows program. SPU programs are translated ahead of time, and the RSX command stream becomes Direct3D 11. - [Wolfenshine: reimplementing Wolfenstein 3D](https://awesomerea.org/resources/wolfenshine-case/index.md): Case study · Wolfenshine is a cross-platform C# reimplementation of Wolfenstein 3D. It reads the maps, artwork, music, and sounds from the player's copy and renders them with a .NET engine, including a 320 by 200 software renderer and an enhanced lighting mode toggled with F2. - [Paper Mario: The Thousand-Year Door — decompiling the Japanese GameCube release](https://awesomerea.org/resources/ttyd-g8mj01-decomp-case/index.md): Case study · This repository is a work-in-progress decompilation of Paper Mario: The Thousand-Year Door, Japanese version G8MJ01, based on symbol maps from the Paper Mario 2 demo. The README says it aims at the same functionality rather than a 1:1 match. - [Bayshore: a Wangan Midnight Maximum Tune 6 server reimplementation](https://awesomerea.org/resources/bayshore/index.md): Case study · Bayshore is a TypeScript server reimplementation of Wangan Midnight Maximum Tune 6. The README says it is part of Project Asakura. - [Rush 2 Recompiled: native PC build of Rush 2: Extreme Racing USA](https://awesomerea.org/resources/rush2-recompiled-case/index.md): Case study · Rush 2 Recompiled is a native PC build of Rush 2: Extreme Racing USA. The player supplies a USA ROM. Optional USA ROMs add San Francisco Rush 2049, San Francisco Rush, and California Speed. Windows and Linux builds are on the Releases page. - [SkiFree: C reconstruction of version 1.04](https://awesomerea.org/resources/skifree-decomp-case/index.md): Case study · This project reconstructs the 32-bit SkiFree version 1.04 in C. It was developed with Visual Studio 6 and aims to be byte-compatible with the original. The README says all code and data have been converted to C, and exact matching of every function and data segment is still open. - [OpenCrossing Anbernic: porting Animal Crossing to Anbernic handhelds](https://awesomerea.org/resources/opencrossing-anbernic-case/index.md): Case study · OpenCrossing Anbernic runs Animal Crossing for the GameCube on Anbernic handhelds. The game's decompiled C code runs on the handheld CPU, and a translation layer turns GameCube graphics calls into OpenGL ES. It is built from ACreTeam/ac-decomp. - [Mario Kart 64 for Dreamcast: porting the Nintendo 64 game to Dreamcast](https://awesomerea.org/resources/mk64-dc-case/index.md): Case study · Mario Kart 64 for Dreamcast is a Sega Dreamcast port of the n64decomp/mk64 decompilation. The README says the 2026 update adds hardware-mixed audio, a raw PowerVR Fast3D backend, and 30 fps four-player play with music, and that it was tested on physical hardware. - [Super Mario Land Disassembly: rebuilding the Game Boy game](https://awesomerea.org/resources/supermarioland-decomp-case/index.md): Case study · This repository is a disassembly of Super Mario Land. It builds Super Mario Land (World) (Rev A). Sections that are not yet disassembled are filled from the original ROM. - [steins-gate: reimplementing the Steins;Gate visual novel](https://awesomerea.org/resources/steins-gate-case/index.md): Case study · steins-gate is a GPL-licensed reimplementation of the Steins;Gate visual novel. Building it requires libnpa and libnpengine. - [Chronon: reimplementing Anachronox on Quake 2](https://awesomerea.org/resources/chronon-case/index.md): Case study · Chronon is an open-source reimplementation of Anachronox on the Quake 2 engine. The README says the work follows public documentation and observation, and that nothing is playable yet. - [Gears of War 3: a native Windows recompilation](https://awesomerea.org/resources/gow3-recomp-case/index.md): Case study · This is an in-progress native Windows recompilation of retail Xbox 360 Gears of War 3. ReXGlue translates the player's default.xex from PowerPC to C++, which is compiled for x64. The GPU side uses ReXGlue's Xenos renderer on Direct3D 12. - [ZeldaAlttPSNESRecomp: static recompilation of A Link to the Past](https://awesomerea.org/resources/zelda-alttp-snes-recomp-case/index.md): Case study · Zelda ALttP SNES Recomp statically translates the 65816 CPU code of The Legend of Zelda: A Link to the Past into C with snesrecomp. PPU rendering, APU and SPC700 audio, DMA, and hardware registers run through an embedded snes9x core. The README says boot, the overworld, and dungeon sword combat have been checked, across those areas. - [Pokémon Black: Nintendo DS decompilation](https://awesomerea.org/resources/pokeblack-case/index.md): Case study · This repository is a decompilation of Pokémon Black for the Nintendo DS. It builds pokeblack.us.nds, the Version 1.0 USA/EUR NDSi Enhanced ROM. - [smo-recomp: statically recompiling Super Mario Odyssey for Windows](https://awesomerea.org/resources/smo-recomp-case/index.md): Case study · smo-recomp is a native Windows x64 build of Super Mario Odyssey version 1.4.1. The game's AArch64 code is translated to C ahead of time and compiled for the PC, with a project runtime and a Vulkan renderer. - [Forza Motorsport 2 ReGPU: statically recompiling the Xbox 360 game](https://awesomerea.org/resources/forza2-regpu-case/index.md): Case study · Forza Motorsport 2 ReGPU is a native Windows port of Forza Motorsport 2 for the Xbox 360. XenonRecomp statically recompiles the PowerPC executable to x64 C++, 51,034 functions, and a Direct3D 12 renderer replaces Xenos GPU emulation. - [Castlevania 64: matching decompilation of the Nintendo 64 game](https://awesomerea.org/resources/cv64-decomp-case/index.md): Case study · This is a work-in-progress decompilation of Castlevania for the Nintendo 64. The aim is C that compiles to assembly matching the ROM. The README says hardcoded addresses still limit large-scale mods, so the tree is useful as documentation of the game code. - [Dragon Age: Origins — Recompiled](https://awesomerea.org/resources/dao-recomp-case/index.md): Case study · Dragon Age: Origins — Recompiled is a static recompilation of the Xbox 360 game into a native x86-64 Windows program, with a Direct3D 12 renderer based on Xenia's. - [007: NightFire - XBE Recomp — a native port of the Xbox game](https://awesomerea.org/resources/nightfire-recomp-case/index.md): Case study · 007: NightFire XBE Recomp is a native PC port of the original Xbox game. Xbox XBE Recomp statically recompiles the game's x86 code into Windows executables, and the Xbox graphics, sound, and system libraries are reimplemented with Direct3D 12 or 11, XAudio2, and SDL. - [MHForever: statically recompiling Monster Hunter Freedom Unite for PC](https://awesomerea.org/resources/mhforever-case/index.md): Case study · MHForever is a native PC port of Monster Hunter Freedom Unite for the PSP, made by static recompilation. The README says the European, North American, and Japanese releases are supported and complete. - [Rockstar Games presents Table Tennis: Xbox 360 recompilation for PC](https://awesomerea.org/resources/rockstar-table-tennis-case/index.md): Case study · This is a Windows x64 recompilation of Rockstar Games presents Table Tennis for the Xbox 360. The game code is recompiled with ReXGlue SDK 0.10.0 and rendered with DirectX 12. Gameplay is paced at 60 FPS. - [Blast Corps: Recompiled — a native port of Blast Corps](https://awesomerea.org/resources/blastcorps-recomp-case/index.md): Case study · Blast Corps: Recompiled uses N64: Recompiled to statically recompile Blast Corps into a native port, with RT64 for rendering. It accepts only the US 1.1 Nintendo 64 ROM. - [Rogue Galaxy Recompiled: native Windows build of Rogue Galaxy](https://awesomerea.org/resources/rogue-galaxy-recomp-case/index.md): Case study · Rogue Galaxy Recompiled is a native Windows build of the USA PlayStation 2 release SCUS-97490, statically recompiled with PS2Recomp. Version 0.2.0 is an early pre-release. The README says the whole game plays, with full-playthrough testing still pending. - [libnpengine: reimplementing the Nitroplus visual-novel engine](https://awesomerea.org/resources/libnpengine/index.md): Case study · libnpengine is a free implementation of the Nitroplus visual-novel engine. The README says it can run Steins;Gate and names other games from the same authors. - [Perlica RS: reconstructing the Perlica game server](https://awesomerea.org/resources/perlica-rs/index.md): Case study · Perlica RS is a Rust game server. The README says it is compatible with the alpha client, and that the client patch replaces the server address so the client can talk to a local server. It documents login, characters, weapons, equipment, and missions. - [Bomberman Hero: matching decompilation of the Nintendo 64 game](https://awesomerea.org/resources/bmhero-decomp-case/index.md): Case study · This is a work-in-progress decompilation of Bomberman Hero for the Nintendo 64, US release. It builds bmhero.z64. - [Open76: reimplementing Interstate '76 in Unity](https://awesomerea.org/resources/open76/index.md): Case study · Open76 is a Unity reimplementation of Interstate '76. It parses and renders level contents, including cars, and can run the mission stack machines. Driving and camera modes work. The README says the car simulation, including the engine and gearbox, still needs work. - [Tecmo Super Bowl: byte-exact NES disassembly](https://awesomerea.org/resources/tecmo-super-bowl-nes-case/index.md): Case study · This is a disassembly of Tecmo Super Bowl for the NES into 6502 source that rebuilds the original game byte for byte. The README says every instruction and memory location is labeled and commented. - [Scion: reimplementing the SimCity 4 Gonzo/Rizzo framework](https://awesomerea.org/resources/scion-maxis/index.md): Case study · Scion is a reference implementation of the Gonzo/Rizzo framework used by Maxis. It aims at the version in SimCity 4 Deluxe Edition. The README also names SimCity 3000, The Sims 2, and Spore as games that used the framework, and says identical machine code is a stretch goal. - [split2-recomp: statically recompiling TimeSplitters 2 for PC](https://awesomerea.org/resources/split2-recomp-case/index.md): Case study · split2-recomp rebuilds TimeSplitters 2 for the original Xbox as a native program for Windows, macOS, and Linux, including SteamOS and Steam Deck. The build is made on the player's computer from their own copy. - [Pokémon Stadium 2: matching Nintendo 64 decompilation](https://awesomerea.org/resources/pokestadiumgs-case/index.md): Case study · This is a work-in-progress decompilation of Pokémon Stadium 2 for the Nintendo 64, US and Japanese versions. It builds pokestadiumgs-us.z64 and pokestadiumgs-jp.z64. - [Chameleon Twist: Recompiled — a native port of Chameleon Twist](https://awesomerea.org/resources/chameleon-twist-recomp-case/index.md): Case study · Chameleon Twist: Recompiled uses N64: Recompiled to statically recompile the Japanese Nintendo 64 release of Chameleon Twist, with RT64 for rendering. - [God of War — Tobiichi Port: statically recompiling God of War for PC](https://awesomerea.org/resources/tobiichi-gow-case/index.md): Case study · God of War — Tobiichi Port is a native Linux and Windows port of God of War for the PlayStation 2, NTSC-U SCUS-97399. The game's MIPS code is statically recompiled to C++ with PS2Recomp. Rendering uses OpenGL, and the launcher uses Qt 6. - [Final Fantasy VIII: decompiling the PlayStation game](https://awesomerea.org/resources/ff8-decomp-case/index.md): Case study · This is a work-in-progress decompilation of Final Fantasy VIII for the PlayStation, USA SLUS-008.92. Progress is tracked on decomp.dev. - [Chuckie Egg: a BBC game logic reconstruction](https://awesomerea.org/resources/chuckie-egg-bbc-recreation-case/index.md): Case study · Chuckie Egg is recreated in C with level loading, player movement, ducks, lifts, scoring, and rendering backends. A companion offset map records original game-state fields such as player coordinates, level timers, and duck state. - [TMNF Android native port: reconstructing TrackMania Nations Forever for Android](https://awesomerea.org/resources/tmnationsdecomp-case/index.md): Case study · TMNF reconstructs parts of TrackMania Nations Forever 2.11.11 as a native Android 15 game using behavior and data recovered from the Windows executable. Its C++ core reads GBX and NadeoPak files, rebuilds campaign tracks and collision scenes, and drives vehicle simulation and a recovered camera from user-supplied game data. - [Need for Speed: High Stakes: translating disassembly into C](https://awesomerea.org/resources/need-for-speed-high-stakes-decomp-case/index.md): Case study · Need for Speed 4: High Stakes is the subject of an unfinished effort to translate game disassembly into C source. The repository contains game, frontend, and PlayStation related C and C++ files, while the author leaves much of the work on its TODO list. - [Body Harvest: matching US and EU N64 decompilations](https://awesomerea.org/resources/body-harvest-decomp-case/index.md): Case study · Body Harvest reconstructs the US and EU N64 releases of the game in C and assembly, using user-supplied ROMs for extraction and comparison. The author reports byte-exact builds for both regions; the repository also records function-level compiler matching work. - [spikewall: reconstructing the Sonic Runners server](https://awesomerea.org/resources/spikewall-case/index.md): Case study · spikewall reconstructs a server for the discontinued Sonic Runners mobile game using .NET 9 and ASP.NET, drawing on earlier server research. Its documented working flows cover account creation, login, tutorial, information, experience, Story Mode and Timed Mode. Leaderboards, events and support for older clients remain planned. - [SSX Tricky: an in-progress matching PlayStation 2 decompilation](https://awesomerea.org/resources/ssx-tricky-decomp-case/index.md): Case study · SSX Tricky reconstructs source for the NTSC-U PlayStation 2 release and builds it against a user-provided SLUS_203.26 executable. The Ninja build checks the resulting image byte for byte, with tools for locating the first differing symbol and comparing object files. - [SPEED RE: reconstructing the Need for Speed Underground 2 engine](https://awesomerea.org/resources/speed-re-nfsu2-case/index.md): Case study · SPEED RE reconstructs routines from the SPEED engine using Need for Speed Underground 2 PC v1.2 as its reference. It documents recovered physics, collision, camera and HUD code, compares some functions byte-for-byte or through bounded execution, and runs an incomplete Linux driving demo on a user's installation. - [Rage Racer PC: a native port of the PAL PlayStation game](https://awesomerea.org/resources/rage-racer-pc-case/index.md): Case study · Rage Racer PC runs the PAL PlayStation release of Rage Racer as a native Windows, Linux and macOS game. Its C runtime imports models, textures and sky data from a user-supplied disc image and provides both a PS1-style classic renderer and a modern geometry renderer. - [tgm2p-decomp: matching The Grand Master 2 Plus SH-2 code](https://awesomerea.org/resources/tgm2p-decomp-case/index.md): Case study · tgm2p-decomp reconstructs the SH-2 program of Tetris: The Absolute – The Grand Master 2 Plus as C compiled with Hitachi SHC. Its probes compare instructions and literal pools with the arcade ROM, and its build checks linked code against a user-supplied verified ROM set. - [Brave Fencer Musashi decomp port: a hybrid PC runtime with matched C](https://awesomerea.org/resources/brave-fencer-musashi-decomp-port-case/index.md): Case study · Brave Fencer Musashi decomp port is an experimental PC port of the USA PlayStation game that combines compiled host code with a CPU interpreter for unconverted game code. The author reports reconstructing functions as byte-matched C, using selected functions in public builds, and adding further matched source beyond what those builds use. - [Halo 2 engine decompilation: differential recovery for Linux](https://awesomerea.org/resources/halo2-engine-recovery-case/index.md): Case study · Halo 2 engine decompilation recovers selected routines from the original Xbox game into native C for Linux. It compares data arrays, allocation and other engine behavior against original XBE instructions, and provides a host that probes recovered pools and configuration loading. - [EVESharp: reconstructing an EVE Online server](https://awesomerea.org/resources/evesharp-eve-online-case/index.md): Case study · EVESharp is a C# EVE Online server emulator aiming to provide a cluster-based server compatible with Apocrypha 6.14.101786. The repository also documents an adapted evedec utility that finds a key in blue.dll, decrypts EVE Python files and passes them to uncompyle2. - [Final Fantasy II: an NES disassembly and ROM reference](https://awesomerea.org/resources/final-fantasy-ii-nes-disasm-case/index.md): Case study · ff2 collects a disassembly and ROM reference for the NES version of Final Fantasy II. The repository includes an assembly file, ROM and RAM maps, and files for events, NPCs, text, and songs. - [Wowser: rebuilding a World of Warcraft browser client](https://awesomerea.org/resources/wowser-wow-browser-client-case/index.md): Case study · Wowser recreates a World of Warcraft 3.3.5a client in JavaScript and WebGL for the browser. It authenticates, lists realms and characters, joins a game world and logs its packets; a local pipeline serves resources from the user's official client copy. - [Suikoden Recompiled: a PlayStation setup candidate](https://awesomerea.org/resources/suikoden-recompiled-case/index.md): Case study · Suikoden Recompiled provides a PSXRecomp setup recipe for generating and compiling the PlayStation game from a user's SLUS-00292 disc and specified BIOS. It combines title configuration, function seeds and a recomp-ui setup wizard; package setup and gameplay acceptance remain pending. - [cc94: a remake of Sid Meier's Colonization](https://awesomerea.org/resources/cc94-case/index.md): Case study · cc94 remakes the 1994 Sid Meier's Colonization game for web browsers and Linux. Its source implements game and editor controls, while play depends on graphics files from a copy of the original game. The author labels version 0.2.0 an early preview. - [defjam-sw: a static recompilation of Def Jam: Fight for NY](https://awesomerea.org/resources/defjam-sw-case/index.md): Case study · defjam-sw lifts the original Xbox executable of Def Jam: Fight for NY instruction by instruction into C for native Nintendo Switch and Linux builds. Its runtime supplies Xbox kernel, graphics, audio and controller behavior, with game-specific replacements for lifted functions. - [SSX Tricky Recomp: native Linux recompilation of the Xbox game](https://awesomerea.org/resources/ssx-tricky-recomp-case/index.md): Case study · SSX Tricky Recomp generates native code from a user-supplied US retail Xbox copy of SSX Tricky and builds a Linux runtime around it. The source includes an analysis pipeline, Xbox recompilation toolkit patches and graphics, controller and audio integration; the author reports tested races and saves, with progression coverage still incomplete. - [IGI-RE: functional decompilation of Project I.G.I.](https://awesomerea.org/resources/igi-re-case/index.md): Case study · IGI-RE rewrites the EU Project I.G.I. executable in C, function by function, and compares each rewrite with the original through Unicorn-based differential tests and scripted gameplay. It builds a standalone game executable and a DLL for substituting rewrites into the original; the author reports all 5,376 identified game and engine functions rewritten. - [007: Everything or Nothing — an Xbox static recompilation for Windows](https://awesomerea.org/resources/007-everything-or-nothing-recomp-case/index.md): Case study · 007eon-recomp builds a native Windows port of the original Xbox release of 007: Everything or Nothing. Xbox XBE Recomp translates its separate on-foot and driving executables, while native Direct3D, XAudio2 and SDL components replace console services; findings document game-specific code and rendering behavior. - [Boom Street: a Wii decompilation in progress](https://awesomerea.org/resources/boom-street-decomp-case/index.md): Case study · Boom Street is a work-in-progress Wii game decompilation targeting the ST7P01 Rev 0 European release. It builds source against files extracted from the user's disc image and provides objdiff configuration for examining reconstructed objects. - [Free Riders Recompiled: a static recompilation of Sonic Free Riders](https://awesomerea.org/resources/free-riders-recompiled-case/index.md): Case study · Free Riders Recompiled ports the Xbox 360 version of Sonic Free Riders to Windows, Linux and Android by translating PowerPC code with XenonRecomp and Xenos shaders with XenosRecomp. Its native runtime replaces console kernel, graphics, audio, input and Kinect services, while a launcher installs game data from the user's disc image. The author reports working menus and playable races, with other content still incompletely explored. - [Cruising on Broadway: a SkoolKit RAM disassembly](https://awesomerea.org/resources/cruising-on-broadway-disassembly-case/index.md): Case study · Publishes a SkoolKit-generated RAM disassembly of Cruising on Broadway. Linked maps organize routines, data, messages and unused addresses, while individual pages show annotated instructions. - [Samurai Shodown: Warriors Rage Recomp — a PlayStation native build](https://awesomerea.org/resources/samurai-shodown-warriors-rage-recomp-case/index.md): Case study · Samurai Shodown: Warriors Rage Recomp configures PSXRecomp to generate a native build of the USA PlayStation game. The repository includes title symbols, function seeds and code-generation setup; the author reports that the Windows build is playable. - [Snowboard Kids: Recompiled — an N64 static recompilation port](https://awesomerea.org/resources/snowboardkids-recompiled-case/index.md): Case study · Snowboard Kids: Recompiled uses N64Recomp to translate the N64 game into a native port and RT64 to render it. It accepts the North American and Japanese ROMs, loads game assets from the user's copy, and includes game-specific patches for widescreen, frame rate behavior and controls. Its source also supports mods and texture packs. - [Marvel Nemesis: Rise of the Imperfects: a GameCube decompilation](https://awesomerea.org/resources/marvel-nemesis-gamecube-decomp-case/index.md): Case study · mnroi reconstructs C/C++ source for the US GameCube release of Marvel Nemesis: Rise of the Imperfects. Its build uses a project-specific decomp-toolkit fork, a locally supplied disc image and compiler configurations that the author says produce a matching main.dol. - [Carmageddon Android Port: adapting Dethrace for ARM64 phones](https://awesomerea.org/resources/carmageddon-android-port-case/index.md): Case study · Carmageddon Android Port adapts the Dethrace engine reimplementation to Android ARM64 with a launcher, touch and controller input, and OpenGL ES rendering changes. It imports the user's Carmageddon or Splat Pack PC data and keeps their saves separate. The author reports an unresolved intermittent exit during a race. - [Dusklight for PS4: a native Twilight Princess port](https://awesomerea.org/resources/dusklight-ps4-case/index.md): Case study · Dusklight for PS4 adapts the decompilation-based Twilight Princess port into a native PS4 program. Its patches target the game and platform dependencies, while Setup Studio packages the user's GameCube or Wii disc data on a computer for installation on a GoldHEN PS4. - [KameoRecomp: a Windows static recompilation of Kameo](https://awesomerea.org/resources/kameorecomp-case/index.md): Case study · KameoRecomp ports the Xbox 360 game Kameo: Elements of Power to Windows by statically translating its code to C++ and compiling it with the ReXGlue SDK. A Vulkan renderer draws the game's graphics calls, while a launcher installs the required files from the user's ISO. The release adds widescreen display and higher frame-rate options. - [DriveClub Recomp: running the PS4 game on Windows and Linux](https://awesomerea.org/resources/driveclub-recomp-case/index.md): Case study · DriveClub Recomp runs the PS4 release of DriveClub 1.28 on Windows and Linux using the game's own x86-64 code. It reimplements PS4 system libraries, translates GPU commands to Vulkan and loads the update and base-game data from the player's dumps. Its online notes document lobby messages and service calls found in the game's eboot. - [OpenC1: a Carmageddon engine remake](https://awesomerea.org/resources/openc1-case/index.md): Case study · OpenC1 is a C# remake of a driving and wrecking game by Stainless Software. Its source includes engine, vehicle, race, rendering and content handling code, and the listed prerequisites include XNA 3.0 and Nvidia PhysX. - [The Hobbit, native: a routine-by-routine C port of the ZX Spectrum game](https://awesomerea.org/resources/hobbit-1982-native-case/index.md): Case study · The Hobbit, native ports the 1982 ZX Spectrum game to C one Z80 routine at a time, guided by an annotated SkoolKit disassembly. It provides a faithful version preserving register and memory behavior plus a separate edition that fixes identified bugs, with a reference runner that compares routine effects and transcripts against the original. - [MOTHER 3 Recomp: a native GBA game port](https://awesomerea.org/resources/mother-3-recomp-case/index.md): Case study · MOTHER 3 Recomp brings the GBA game to Windows, Linux and Android using gbarecomp and recomp-ui. Its released packages import the player's ROM and provide a launcher, widescreen presentation and patch support; the Android documentation also describes a private build that generates native-recompiled code locally. - [CTR Native: a Crash Team Racing PC port from decompiled source](https://awesomerea.org/resources/ctr-native-port-case/index.md): Case study · CTR Native ports the 1999 PlayStation game Crash Team Racing to Windows and Linux using source from the CTR-ModSDK decompilation. Its own native layer supplies audio, input, memory-card, CD, rendering, and PS1 interface support, with statically linked SDL3 and UDP netplay. Game assets are extracted from the user's NTSC-U disc. - [Tetris Plus: an early Game Boy disassembly](https://awesomerea.org/resources/tetris-plus-game-boy-disassembly-case/index.md): Case study · Reconstructs the USA/Europe Game Boy release of Tetris Plus as RGBDS assembly arranged by ROM bank. The build can compare its output SHA-1 against an original placed in the source directory; the project is at a very early stage. - [James Pond 2: Codename RoboCod — an Amiga static recompilation](https://awesomerea.org/resources/james-pond-2-robocod-recomp-case/index.md): Case study · James Pond 2: Codename RoboCod — Recompiled turns the Amiga game's 68000 instructions into native C++ using a user-provided disk image. Its runtime models Amiga memory, display, audio, and disk behavior, with an interpreter for code the recompiler has not reached; the port also adds widescreen rendering and save controls.