# Curated reverse engineering resources · Page 23

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

## Games (100)

- [Halo CE on RG35XX H: porting Halo: Combat Evolved to H700 handhelds](https://awesomerea.org/resources/halo-ce-rg35xx/index.md): Case study · This is a native ARM64 port of the Halo: Combat Evolved decompilation OpenCE to the Anbernic RG35XX H and other Allwinner H700 handhelds with a Mali-G31 GPU. The game build is Xbox 01.01.14.2342. The README reports 60 frames per second in menus and about 40 to 55 in campaign at the default scale, under Knulli.
- [SpeedBreaker: Carbon — statically recompiling Need for Speed: Carbon](https://awesomerea.org/resources/speedbreaker-carbon/index.md): Case study · SpeedBreaker: Carbon is a static recompilation of the Xbox 360 version of Need for Speed: Carbon (2006). The only supported disc is the USA Collector's Edition. Packages cover SteamOS, Linux, Mac, and a Windows beta. An experimental iPhone and iPad build is also described.
- [Maniac Mansion: annotated demo and retail script disassembly](https://awesomerea.org/resources/maniac-mansion-disasm/index.md): Case study · This repository is a commented disassembly of Maniac Mansion scripts for the v0 demo and the retail release, plus spreadsheets of rooms, objects, variables, and sounds. The README says the files are not meant to be recompiled. The .c extension is only for highlighting.
- [Ace Combat 3: static recompilation for Windows](https://awesomerea.org/resources/ace-combat-3-recomp/index.md): Case study · This is a native Windows port of Ace Combat 3: Electrosphere. The MIPS code is translated to C ahead of time and linked against rewritten Psy-Q libraries. ac3.exe draws in software. ac3_enhanced.exe adds a Vulkan renderer with higher resolution, 16:9, and a longer draw distance.
- [Def Jam Vendetta Recompiled: statically recompiling the PS2 game for Windows](https://awesomerea.org/resources/def-jam-vendetta-recomp/index.md): Case study · Def Jam Vendetta Recompiled turns the PlayStation 2 game into a native Windows program with PS2Recomp. paraLLEl-GS redraws the graphics chip on Vulkan. The target is the USA disc, SLUS-20639, as an ISO or CHD.
- [Marchwind 64: statically recompiling Super Robot Wars 64](https://awesomerea.org/resources/srw64-recomp/index.md): Case study · Marchwind 64 is a native recompilation of Super Robot Wars 64, the 1999 Nintendo 64 game. It runs on Windows, macOS, Linux, Steam Deck, Android, and Nintendo Switch, with English, Simplified Chinese, Traditional Chinese, and Korean text, plus widescreen and an optional HD art pack.
- [Mafia-RE: matching decompilation of Mafia: The City of Lost Heaven](https://awesomerea.org/resources/mafia-re/index.md): Case study · Mafia-RE decompiles Mafia: The City of Lost Heaven (Illusion Softworks, 2002) for versions 1.0, 1.1, 1.2, and Steam's 2010 setup rebuild. Version 1.2 is the main target. The README says rw_data.dll, IJoy.dll, and setup.exe already build byte-for-byte with the original toolchains, while Game.exe has been started.
- [Mario Strikers Charged: a matching Wii decompilation](https://awesomerea.org/resources/mscharged-decomp/index.md): Case study · This is a matching decompilation of Mario Strikers Charged for the Wii. The USA revision 1, R4QE01, is reported complete: 100 percent of the code matches and links. Its main.dol SHA-1 is e96d2298067b70652752145b4e63644e6e1b1560. Europe, Japan, and Korea are also configured.
- [Burnout 2: static recompilation of the original Xbox game](https://awesomerea.org/resources/burnout2-recomp/index.md): Case study · This is a static recompilation of the original Xbox game Burnout 2: Point of Impact. The Windows build is the main target. Linux, Steam Deck, and macOS builds are described as experimental and still needing gameplay, sound, and performance checks. Release 1.14 adds a camera field-of-view slider, texture-pack installation, and initial scripting.
- [SMT NINE Recomp: native port of Shin Megami Tensei NINE](https://awesomerea.org/resources/smt-nine-recomp/index.md): Case study · SMT NINE Recomp is a native Windows port of Shin Megami Tensei NINE for the original Xbox, built with xboxrecomp. The default build is Japanese, translated from the player's Japanese retail disc. A Chinese translation is optional. Config can import an ISO patched with an English translation.
- [Resident Evil: Code: Veronica — matching Dreamcast decompilation](https://awesomerea.org/resources/recv-dc-decomp/index.md): Case study · This is a matching decompilation of Resident Evil: Code: Veronica for the Dreamcast, US version. The current target is the main executable, 1ST_READ.bin. It uses the Sonic Adventure 2 Dreamcast decompilation as a template.
- [OpenSith: reimplementing the Jedi Knight: Dark Forces II engine](https://awesomerea.org/resources/opensith/index.md): Case study · OpenSith reimplements the engine of Star Wars: Jedi Knight — Dark Forces II in Unity. It renders JKL levels and animates 3DO models. There is no COG parser or COG virtual machine, so the game is not playable, though a level can be walked around.
- [Silent Hill 3: a native Nintendo Switch port](https://awesomerea.org/resources/sh3-nx/index.md): Case study · sh3-nx is a native Nintendo Switch port of the PC version of Silent Hill 3, release v0.06. The x86 executable is statically recompiled to C and compiled for ARM64. Direct3D 8, DirectSound, DirectInput, and kernel32 are reimplemented on SDL2 and OpenGL.
- [Miyoo64: porting fifteen Nintendo 64 games to Miyoo Mini](https://awesomerea.org/resources/miyoo64/index.md): Case study · Miyoo64 runs fifteen Nintendo 64 games natively on the Miyoo Mini, Mini Plus, and Mini Flip, built from their decompilation projects. Each game reads a ROM the player owns and builds what it needs on the device. The listed USA ROMs include Perfect Dark revision 1, Mario Kart 64, Ocarina of Time 1.0, and Super Mario 64.
- [Mario & Luigi: Superstar Saga — byte-matching GBA decompilation](https://awesomerea.org/resources/mlss-decomp/index.md): Case study · This is a decompilation of Mario & Luigi: Superstar Saga for the Game Boy Advance, US version. It builds mlss.gba, SHA-1 7c303cdde5061ee329296948060b875cb50ba410.
- [Crackdown 2: Xbox 360 static recompilation](https://awesomerea.org/resources/crackdown2-recomp/index.md): Case study · This is a static recompilation of Crackdown 2 using ReXGlue SDK 0.5.0. The Windows debug preset is win-amd64-debug. The README says the result is in-game but not playable yet.
- [Croc: Legend of the Gobbos — a PlayStation decompilation](https://awesomerea.org/resources/croc-decomp/index.md): Case study · This repository decompiles Croc: Legend of the Gobbos for PlayStation, aiming at the same binary as the commercial game. The current base is the European demo SLED-00038, chosen because it contains symbols. The planned retail target is SLUS-00530.
- [ChronoStorm: reimplementing the Red Alert 2 and Yuri’s Revenge engines](https://awesomerea.org/resources/chronostorm/index.md): Case study · ChronoStorm reimplements the engines of Command & Conquer: Red Alert 2 and Yuri's Revenge in Python and Pygame. It extracts MIX archives and renders SHP sprites and VXL voxels. Map parsing and the isometric grid are still open.
- [Sonic Riders: matching decompilation of the GameCube game](https://awesomerea.org/resources/sonic-riders-decomp/index.md): Case study · This is a work-in-progress decompilation of Sonic Riders for the GameCube, USA. It builds sonicriders.dol, SHA-1 e90a13504974b917a675d59f07014e0e817c5e5d.
- [Mega Man X4: byte-matching PlayStation source reconstruction](https://awesomerea.org/resources/mmx4-decomp/index.md): Case study · This is a matching decompilation of Mega Man X4 for PlayStation. The same C source builds byte-matching executables for the US release SLUS_005.61, the Japanese SLPS_009.02, and the European SLES_011.76, plus a native Linux port for the US and Japanese versions. The Sega Saturn build is non-matching.
- [SSX 3: statically recompiling the PS2 game to Rust](https://awesomerea.org/resources/ssx3-decomp/index.md): Case study · This is a native Rust port of SSX 3 for PlayStation 2, USA SLUS_207.72. The game code was statically recompiled to Rust and is being replaced function by function. Rendering, movies, sound, files, controllers, and the memory card are native. The README says every race, freestyle event, and Conquer the Mountain are playable, on macOS, Windows, and Linux, with an experimental browser build.
- [Quest 64: decompiling the Nintendo 64 game](https://awesomerea.org/resources/quest64-decomp/index.md): Case study · This repository decompiles Quest 64. The US ROM is named baserom.us.z64. The build is ./configure and ninja.
- [The Legend of Zelda: A Link to the Past: matching Japanese 1.0 disassembly](https://awesomerea.org/resources/alttp-jp-disasm/index.md): Case study · This is a disassembly of the Japanese 1.0 version of The Legend of Zelda: A Link to the Past. It assembles with the included alttp.futaba file and the Futaba assembler. An accurate build has CRC32 3322EFFC and SHA-1 E7E852F0159CE612E3911164878A9B08B3CB9060.
- [Coney: reimplementing The Warriors](https://awesomerea.org/resources/coney/index.md): Case study · Coney reimplements The Warriors (2005) in C++ for Windows, Linux, and macOS. The PlayStation 2 version is the reference for how the game plays, and the Xbox port is a second source for rendering and assets. With a disc it plays the startup movies and the front end, and runs levels as far as the missions page records.
- [WWE SmackDown vs. Raw 2010: statically recompiling the Xbox 360 game](https://awesomerea.org/resources/svr2010-recomp/index.md): Case study · This recompiles the Xbox 360 version of WWE SmackDown vs. Raw 2010. The game code is recompiled and drawn by a native renderer: Direct3D 12 on Windows, and Vulkan on Linux and the Steam Deck. The README says it runs at 60 fps, with resolution choices from 480p to 8K. Windows runs the release directly. The Linux and Steam Deck steps run that Windows release through Proton.
- [Noble Archimedes: recompiling Castlevania: Curse of Darkness for PC](https://awesomerea.org/resources/noble-archimedes/index.md): Case study · Noble Archimedes recompiles Castlevania: Curse of Darkness. The primary path turns the original Xbox release into native x64 code with Direct3D 12 and XAudio2. An experimental PlayStation 2 path covers the USA release SLUS-21168. The Windows beta compiles the game locally from the player's USA Xbox files on first run.
- [Crackdown: Xbox 360 static recompilation](https://awesomerea.org/resources/crackdown-recomp/index.md): Case study · This recompiles Crackdown title update 0 for the Xbox 360 with ReXGlue SDK 0.2.2. The README says the project is unfinished.
- [Guitar Hero II: a proof-of-concept Xbox 360 recompilation](https://awesomerea.org/resources/gh2-recomp/index.md): Case study · This is a proof-of-concept recompilation of Guitar Hero II for the Xbox 360, using the ReXGlue SDK. The README says performance is poor and the build is prone to crashes.
- [Fire Emblem: Rekka no Ken — matching Japanese Game Boy Advance decompilation](https://awesomerea.org/resources/fe7j-decomp/index.md): Case study · This decompiles Fire Emblem: Rekka no Ken for the Game Boy Advance, Japanese release. It builds FireEmblem7J.gba, SHA-1 037702b1febd5c9535262165bf030551d153de81.
- [Neon Genesis Evangelion 64: Nintendo 64 decompilation](https://awesomerea.org/resources/evangelion64-decomp/index.md): Case study · This is a work-in-progress decompilation of Neon Genesis Evangelion 64. The ROM is named evangelion.z64. The documented steps are make setup, then make.
- [Resident Evil: Code: Veronica X — decompiling the GameCube release](https://awesomerea.org/resources/recvx-gc-decomp/index.md): Case study · This is a work-in-progress decompilation of Resident Evil: Code: Veronica X for the GameCube. The supported version is GCDE08, the USA release. The player copies a disc image into orig/GCDE08, then runs python configure.py and ninja.
- [OpenRakis: reverse engineering Cryo’s Dune](https://awesomerea.org/resources/openrakis/index.md): Case study · OpenRakis is a work-in-progress reverse-engineering project for Cryo's Dune. The README describes the PC DOS floppy and CD layouts, an asm directory for the original x86 DOS assembly, and an 8086 16-bit real-mode IDA setup for DNCDPRG.EXE with entry CS 1ED.
- [Phantasy Star Online Episode I & II Plus: matching GameCube decompilation](https://awesomerea.org/resources/pso-gc-decomp/index.md): Case study · This is a matching decompilation of Phantasy Star Online Episode I & II Plus for the GameCube, USA version 1.02, product code GPOE8P. The disc SHA-1 is 0ff155311f4cc57951c03baeb1a8cc15de5fe1cd. The executable files/PsoV3.dol has SHA-1 0d85744b51d7379efb025a943d0cd5aaae2191a3.
- [StarCraft 64: a native port by static recompilation](https://awesomerea.org/resources/starcraft64-recomp/index.md): Case study · This is a native port of StarCraft 64, NTSC-U. N64Recomp translates the MIPS code to C, and a software renderer draws the game's display lists. The ROM must match SHA-1 a36d91b5aac7bb95df0d7de5f9814f5270e25c2b after byte-order normalization. The README says the single-player campaign, menus, Encyclopedia, saves, and sound work. macOS on Apple Silicon and Android arm64 from Android 9 are the accepted platforms. Windows x86_64 and Linux x86_64 packages are cross-built.
- [Live & Recompiled: recompiling Conker: Live & Reloaded for PC](https://awesomerea.org/resources/conker-live-recompiled/index.md): Case study · Live & Recompiled is a native Windows and Linux port of the original Xbox game Conker: Live & Reloaded, built on Xbox XBE Recomp. It renders with Vulkan and supports single-player and multiplayer. The supported USA disc default.xbe has SHA-1 2232a1b3874d67b4bb4cf53a940420d2dab59535. The Microsoft Store backwards-compatible release is also accepted.
- [Ty the Tasmanian Tiger: decompiling the USA release](https://awesomerea.org/resources/ty-decomp/index.md): Case study · This is a work-in-progress decompilation of Ty the Tasmanian Tiger. The supported version is GTYE69, the USA release. The player extracts sys/main.dol to orig/GTYE69, then runs python configure.py and ninja.
- [Castlevania Chronicles: a cross-platform recompilation](https://awesomerea.org/resources/castlevania-chronicles-recomp/index.md): Case study · This recompiles Castlevania Chronicles for Windows, macOS, and Linux with RecompOne. Release 0.3.10 has packages for Windows x64, macOS on Apple Silicon, and Linux x64, and each package includes the .NET runtime. The player selects a USA SLUS-01384 disc image, CUE/BIN or CHD. The first launch prepares the game code.
- [ISSD Native: recompiling International Superstar Soccer Deluxe](https://awesomerea.org/resources/issd-native/index.md): Case study · ISSD Native recompiles International Superstar Soccer Deluxe for the Super Nintendo, USA release, into C. The supported dump is a headerless SFC of 2,097,152 bytes, internal title SUPERSTAR SOCCER 2, SHA-256 d2fe66c1ce66c65ce14e478c94be2e616f9e2cad374b5783a6a64d3c1a99cfa9. Release v0.6.0-beta.1 covers Windows, Linux, Steam Deck, and Android 8.0 or newer. Gameplay advances at 60 Hz.
- [reo: recompiling Resident Evil Outbreak for Windows](https://awesomerea.org/resources/reo-outbreak/index.md): Case study · reo recompiles Resident Evil Outbreak for the PlayStation 2, NTSC-U SLUS-20765, to native Windows x86-64 with PS2Recomp. The README says a scripted boot reaches the first scenario in J's Bar, drawn by the game's own code, at about 35 times slower than real time. Sound output is not implemented, and play past that point has not been tried.
- [WWE SmackDown vs. Raw 2008: statically recompiling the Xbox 360 game](https://awesomerea.org/resources/svr2008-recomp/index.md): Case study · This recompiles the Xbox 360 version of WWE SmackDown vs. Raw 2008. The game code is recompiled and drawn by a native renderer: Direct3D 12 on Windows, and Vulkan on Linux and the Steam Deck. The README says it runs at 60 fps, with resolution choices from 480p to 8K. Windows runs the release directly. The Linux and Steam Deck steps run that Windows release through Proton.
- [DinoTale: a static-recompilation port of Yoshi's Story](https://awesomerea.org/resources/dinotale-case/index.md): Case study · DinoTale statically recompiles Yoshi's Story with N64Recomp for Windows and Linux, using N64ModernRuntime and RT64 for execution and rendering. Its game-specific work maps overlays and functions and adds display modes, controls and renderer fixes.
- [Eden: partial Project Eden reconstruction](https://awesomerea.org/resources/eden-project-eden-case/index.md): Case study · Eden begins a Windows reconstruction of the 2001 game Project Eden, targeting a DirectX 9 build. Its C++ source covers a game window, error codes, an optional CD check, and partial DirectX and input initialization. The stated goal is to reach the game's main menu.
- [Space Cadet Pinball: matching reconstruction of the XP SP3 executable](https://awesomerea.org/resources/space-cadet-pinball-matching-case/index.md): Case study · Space Cadet Pinball reconstructs source for the Windows XP SP3 game executable and compares builds with the original using reccmp. The author reports that all targeted functions match and roughly 95% of the whole executable matches; other releases are used as references.
- [Mabecs International Superstar Soccer 2000: a three-version N64 static recompilation](https://awesomerea.org/resources/iss2000-recomp-case/index.md): Case study · Mabecs International Superstar Soccer 2000 turns three N64 releases into native Windows and Linux builds through N64Recomp, N64ModernRuntime and RT64. Its own symbols, overlay work, hooks and runtime patches support widescreen rendering, player detail and online matches. Generated game code is produced locally from a user-supplied ROM.
- [Hey You, Pikachu!: an AI-assisted matching N64 decompilation](https://awesomerea.org/resources/ornata-hey-you-pikachu-case/index.md): Case study · Reconstructs Hey You, Pikachu! for N64 as C with retained assembly for low-level routines, using AI assistance and a SHA-1 comparison against the retail ROM. Documentation traces its voice interaction, actor scripts and runtime architecture.
- [MediEvil: a native PC port of the 2019 PS4 game](https://awesomerea.org/resources/medievil-2019-pc-port-case/index.md): Case study · MediEvil for PC runs the 2019 PS4 game's own x86-64 executable on Windows through replacement PS4 system libraries and a shadPS4-based Vulkan graphics core. The launcher accepts the user's unpacked game folder or fake PKG and supplies patches, resolution controls and input support.
- [DOA2U Native PC Port: an Xbox game static recompilation](https://awesomerea.org/resources/doa2u-native-pc-port-case/index.md): Case study · DOA2U Native PC Port lifts the DOA2 Xbox executable from the user's Disc 2 copy to C and links it with a native runtime. That runtime replaces Xbox kernel, Direct3D 8, DirectSound, and input services for Windows, macOS, and Linux builds.
- [openage: a Genie Engine reconstruction for Age of Empires games](https://awesomerea.org/resources/openage-case/index.md): Case study · openage reconstructs the Genie Engine used by Age of Empires, Age of Empires II and Star Wars: Galactic Battlegrounds. Its C++ engine and Python media converter use assets from the user's original games and convert them into openage formats. The author states that gameplay is currently almost nonfunctional while the simulation is rebuilt.
- [CTR-NitroFueled-PC: a Windows port of Crash Team Racing: Nitro-Fueled](https://awesomerea.org/resources/ctr-nitrofueled-pc-case/index.md): Case study · CTR-NitroFueled-PC ports the PS4 release of Crash Team Racing: Nitro-Fueled to Windows 10 and 11 using the player's decrypted game files. It executes the original x86-64 game code on the CPU, supplies a replacement PS4 runtime and translates graphics through a shadPS4-derived Vulkan renderer; the fork adds the Windows loader and system layer.
- [MKSM Recomp: a PS2 static recompilation of Mortal Kombat: Shaolin Monks](https://awesomerea.org/resources/mksm-recomp-case/index.md): Case study · MKSM Recomp statically recompiles the NTSC-U PS2 release of Mortal Kombat: Shaolin Monks toward native PC execution. It combines ELF analysis, MIPS and VU to C++ generation, an EE and IOP runtime, Ghidra scripts, tests and game-specific investigation notes. The author reports progress through menus and the opening movie to distorted scene drawing.
- [WiiLink WFC: a Nintendo Wi-Fi Connection server replacement](https://awesomerea.org/resources/wiilink-wfc-server-case/index.md): Case study · WiiLink WFC implements a replacement Nintendo Wi-Fi Connection server for Nintendo DS and Wii games. Its Go source contains service components for game clients, and the repository includes a PostgreSQL schema for server data.
- [Tenchu: Return from Darkness — an Xbox static recompilation for Windows](https://awesomerea.org/resources/tenchu-return-from-darkness-recomp-case/index.md): Case study · TenchuRFDRecomp builds a native Windows port of the original Xbox game Tenchu: Return from Darkness by recompiling code from the user's disc image. The repository supplies game-specific startup hooks, graphics and audio adapters, controls and mod support; the author describes the release as an alpha.
- [BombermanRecomp: statically recompiling Super Bomberman for Windows](https://awesomerea.org/resources/bomberman-recomp-case/index.md): Case study · BombermanRecomp statically recompiles the North American SNES release of Super Bomberman into a native Windows program. A pinned snesrecomp engine generates C from a hash-checked user ROM; the project adds an interactive Win32 host with video, audio and SRAM persistence plus a deterministic headless host. Its changelog reports battle gameplay in a 3,000-frame test.
- [Sparta: a static-recompilation port of God of War: Ghost of Sparta](https://awesomerea.org/resources/sparta-ghost-of-sparta-case/index.md): Case study · Sparta builds a native port of the PSP God of War: Ghost of Sparta by translating its MIPS program to C++ ahead of time. It links game-specific configuration with PortableKit's PSP services and a GE-to-Vulkan renderer. The author reports the opening level running on Windows, Apple Silicon macOS and Android.
- [Cars Race-O-Rama Recompiled: an Xbox 360 recompilation](https://awesomerea.org/resources/cars-race-o-rama-recompiled-case/index.md): Case study · Cars Race-O-Rama Recompiled uses ReXGlue v0.3 to recompile the Xbox 360 game into a native executable. It runs with game data extracted from the user's ISO into an assets folder beside the executable. The author reports that it can be played from start to finish, with slowdowns and lighting errors.
- [Kirby's Dream Land: a Game Boy disassembly with ROM comparison](https://awesomerea.org/resources/kdreamlanddis-case/index.md): Case study · Kirby's Dream Land is reconstructed as Game Boy assembly that can be assembled into a ROM and compared with the original. The repository contains assembly source and a Makefile using rgbasm, rgblink and rgbfix before the ROM comparison.
- [Tamagotchi P1 for FPGAs: reconstructing the handheld hardware](https://awesomerea.org/resources/fpga-tamagotchi-p1-case/index.md): Case study · Tamagotchi P1 for FPGAs reconstructs the handheld's CPU and surrounding hardware for Analogue Pocket and MiSTer. Its design follows Epson CPU specifications, uses microcode for control, and draws on disassembly of the Tamagotchi ROM to examine a disputed instruction behavior.
- [Bomberman 64: The Second Attack!: partial N64 decompilation](https://awesomerea.org/resources/bm64tsa-case/index.md): Case study · bm64tsa is an in-progress decompilation of the Japanese and US Nintendo 64 releases of Bomberman 64: The Second Attack!. It combines C and assembly sources with versioned build tooling, extracts from a user-provided base ROM, and lists MD5 hashes for rebuilt ROMs.
- [open-iw: investigating Inner Worlds' packed game resources](https://awesomerea.org/resources/open-iw-inner-worlds-case/index.md): Case study · open-iw investigates the packed resources inside the DOS game Inner Worlds 1.2 while working toward a rebuild. Its notes describe the executable's resource header, file-list entries, offsets and alignment uncertainty; a C utility supports extraction experiments.
- [coastline: reconstructing Top Gear Rally across N64 and PC releases](https://awesomerea.org/resources/coastline-top-gear-rally-case/index.md): Case study · coastline reconstructs Top Gear Rally source across three Nintendo 64 releases and two Windows renderer libraries. It builds N64 cartridge images using user-provided ROM assets, compares reconstructed routines with original code and provides an SDL 3 game build.
- [Yu-Gi-Oh! Forbidden Memories: matching PS1 decompilation](https://awesomerea.org/resources/yu-gi-oh-forbidden-memories-ps1-decomp-case/index.md): Case study · Reconstructs the NTSC-U PlayStation release of Yu-Gi-Oh! Forbidden Memories as C compiled with the original PsyQ toolchain. The author reports byte-identical output for all 1,120 in-scope game functions; PsyQ library code and original hand-written assembly remain outside that C scope.
- [MediEvil Recompiled: building the PlayStation game through psxrecomp](https://awesomerea.org/resources/medievil-psxrecomp-setup-case/index.md): Case study · MediEvil Recompiled supplies a setup host for statically recompiling the US PlayStation release of MediEvil with psxrecomp and building it with recomp-ui. Its configuration, symbols and diagnostics guide support local generation from the user's disc and retail BIOS. The author reports a successful Release build and short startup run; gameplay checks remain open.
- [OpenRaider: a rewritten engine for Tomb Raider 1–3](https://awesomerea.org/resources/openraider-rewrite-case/index.md): Case study · OpenRaider reimplements an engine for Tomb Raider 1, 2 and 3 using their original asset files. Its C++ code includes level loaders for all three versions, rendering and audio components, and support for custom maps based on those engines.
- [Tactical-Retreat: rebuilding Counter-Strike 1.5 gameplay in QuakeC](https://awesomerea.org/resources/tactical-retreat-case/index.md): Case study · Tactical-Retreat rebuilds Counter-Strike 1.5 game logic for the QuakeC-based Rad-Therapy and FTEQW stack. Its entity notes map hostage, bomb, buy-zone and other CS behaviors to source implementations, while original game data is supplied separately.
- [TwinEngine: a Little Big Adventure 1 engine rewrite](https://awesomerea.org/resources/twinengine-lba1-case/index.md): Case study · TwinEngine rewrites the Little Big Adventure 1 engine in C to run the original game from its installation files. Its source covers rendering, scenes, actors, scripts and HQR resources; the project describes the engine as beta-stage.
- [LEGO Dimensions PC: a PS4-to-Windows native port](https://awesomerea.org/resources/lego-dimensions-pc-case/index.md): Case study · LEGO Dimensions PC ports PS4 LEGO Dimensions version 01.24 to Windows x64 by adapting its executable and rewriting PS4 system-library behavior. It translates GCN graphics to Vulkan; preparation from a user-supplied game dump converts the executable and translates the game's shaders before play.
- [Boku Doraemon: Dreamcast executable and model reconstruction](https://awesomerea.org/resources/boku-doraemon-decomp-case/index.md): Case study · Boku Doraemon maps the Japanese Dreamcast game's 1ST_READ.BIN, generates a matching assembly baseline from an owner's disc, and tests C function candidates for equivalent calls, memory writes and results in an SH-4 interpreter. Its committed model map records recognized models, textures, sounds and offsets. The author reports 123 equivalent functions, all from locally supplied SDK source at this checkpoint.
- [Thexder: NES level and disassembly analysis](https://awesomerea.org/resources/thexder-nes-analysis-case/index.md): Case study · Thexder examines the NES/Famicom game through an IDA analysis file and a PHP level renderer. The renderer reads tile values and object records at fixed offsets in the game ROM and outputs a level image.
- [linyaga: a Yaga game runtime for Pajama Sam and Putt-Putt](https://awesomerea.org/resources/linyaga-yaga-engine-case/index.md): Case study · linyaga supplies a replacement runtime for two Humongous Entertainment Yaga games: Pajama Sam: Life is Rough When You Lose Your Stuff and Putt-Putt: Pep's Birthday Surprise. Its C host exposes resource, animation, video and audio functions to Python code and reads the user's original game files.
- [O21: a black-box remake of U95](https://awesomerea.org/resources/o21-u95-case/index.md): Case study · O21 rebuilds the 1995 Windows game U95 as an F# open-source remake. Its author describes a black-box process based on observing the running game and reading its data files; the current engine includes rendering, menus, bonuses and some enemy behaviour but is not yet playable.
- [Mario Superstar Baseball: a GameCube decompilation](https://awesomerea.org/resources/mario-superstar-baseball-decomp-case/index.md): Case study · mssb-dtk is an in-progress decompilation of Mario Superstar Baseball's USA Rev 0 release. It includes C source, symbol and split maps, and decomp-toolkit configuration. Its objdiff workflow compares rebuilt objects with objects derived from the user's extracted game files.
- [OB64 Decomp: matching Ogre Battle 64 from MIPS assembly to C](https://awesomerea.org/resources/ogre-battle-64-decomp-case/index.md): Case study · Reconstructs the US Rev 0 release of Ogre Battle 64 from source-owned MIPS assembly, replacing accepted functions with C that matches linked bytes and the full ROM. Its workflow records compiler and relocation constraints, tests each replacement, and keeps the original ROM and toolchains outside the repository.
- [Excite Truck: matching Wii decompilation](https://awesomerea.org/resources/excite-truck-decomp-case/index.md): Case study · Excite Truck is an unfinished matching decompilation of the USA Wii release REXE01. It builds from a user-provided disc image, uses objdiff to compare rebuilt objects, and includes decompdecomp helpers for symbol and function-signature updates. The author reports 9,067 of 13,779 functions exactly matched.
- [Gravity Rush Remastered: a native PC port of the PS4 game](https://awesomerea.org/resources/gravity-rush-remastered-pc-case/index.md): Case study · Gravity Rush Remastered's PC port runs the PS4 game's original x86-64 executable on Windows with replacement PS4 system libraries. It uses shadPS4's video core to translate graphics commands and shaders to Vulkan and reads an unpacked copy supplied by the player; the author reports a full story play-through.
- [Sims 3 in Bevy: a Rust reimplementation of The Sims 3](https://awesomerea.org/resources/sims-3-bevy-case/index.md): Case study · Sims 3 in Bevy reimplements The Sims 3 in Rust using Bevy and data from the player's installation. A separate baking step converts packages into a local cache of textures, meshes and world data; format notes document resource layouts and gameplay tuning used by the implementation.
- [Booty: a ZX Spectrum game disassembly](https://awesomerea.org/resources/booty-disassembly-case/index.md): Case study · Booty documents the ZX Spectrum game through a SkoolKit disassembly and associated reference files. The repository provides a script that generates a browsable HTML version from its development sources.
- [Ocarina of Time 3D: a hash-checked 3DS decompilation](https://awesomerea.org/resources/ocarina-of-time-3d-decomp-case/index.md): Case study · Ocarina of Time 3D reconstructs source for the USA release of The Legend of Zelda: Ocarina of Time 3D through static and dynamic analysis. Its Windows build produces oot3d.axf and code.bin, with an MD5-based matching check; rebuilding romfs.bin and the full 3DS image remains future work.
- [mk8-recomp: a native Mario Kart 8 Deluxe static recompilation](https://awesomerea.org/resources/mk8-recomp-case/index.md): Case study · mk8-recomp develops a native Mario Kart 8 Deluxe application that connects statically recompiled CPU modules to native graphics, audio, input and storage services. The author reports completion of a four-course Mushroom Cup sequence and documents runtime measurements and remaining compatibility work. Public outputs are limited to authored source and game-free tooling.
- [Mega Man 1 Disassembly: buildable US and Japanese assembly](https://awesomerea.org/resources/mm1dasm-case/index.md): Case study · Mega Man 1 Disassembly supplies compilable assembly for the US Mega Man and Japanese Rockman releases. Its cc65 and make build combines the repository's assembly with banks 0–3 and part of the level data extracted from the player's original ROM.
- [Skool Daze: a ZX Spectrum game disassembly](https://awesomerea.org/resources/skool-daze-disassembly-case/index.md): Case study · Skool Daze records a SkoolKit disassembly of the ZX Spectrum game. Its .skool and reference files can be rendered as browsable HTML or exported to assembler-ready source using SkoolKit commands.
- [My Teacher is an Alien: Windows 95 source reconstruction](https://awesomerea.org/resources/my-teacher-is-an-alien-case/index.md): Case study · My Teacher is an Alien reconstructs the 1997 Windows 95 adventure game in C++ from Ghidra disassembly. The project compiles with MSVC 4.20 and compares rebuilt functions, calls, globals and data against the original full-game and demo binaries; the author reports both versions are playable.
- [Re-Cherry: recompiling Lollipop Chainsaw](https://awesomerea.org/resources/re-cherry-lollipop-chainsaw-case/index.md): Case study · Re-Cherry builds a ReXGlue-based version of the Xbox 360 game Lollipop Chainsaw from a user's extracted game image. Its C++ host sources include game hooks and a costume switcher, and the build invokes ReXGlue code generation before CMake compilation.
- [Yu-Gi-Oh! Forbidden Memories: a regional byte-matching PlayStation decompilation](https://awesomerea.org/resources/yu-gi-oh-forbidden-memories-decomp-case/index.md): Case study · A byte-matching decompilation of Yu-Gi-Oh! Forbidden Memories reconstructs C source for seven regional PlayStation releases. Regional configurations and overlay inventories support rebuilding each PS-X executable against the user's game files; the author reports that some overlay coverage remains in progress.
- [Space Station Silicon Valley: a static-recompilation port](https://awesomerea.org/resources/space-station-silicon-valley-recompiled-case/index.md): Case study · Space Station Silicon Valley: Recompiled turns the N64 game's code into a native port with N64Recomp. RT64 renders the game, including S2DEX sprite and background display lists through a project fork, while runtime patches add widescreen and other host features.
- [Doom64EX: a reverse-engineered recreation of Doom 64](https://awesomerea.org/resources/doom64ex-case/index.md): Case study · Doom64EX recreates Doom 64 as a buildable engine with added modding features. Its data generator produces the required WAD and soundfont files from a user-supplied Doom 64 ROM.
- [AscNet: reconstructing a Punishing: Gray Raven server](https://awesomerea.org/resources/ascnet-punishing-gray-raven-case/index.md): Case study · AscNet reconstructs a server for Punishing: Gray Raven. Its C# code includes TCP game sessions, HTTP account and configuration endpoints, and handlers for game features. A companion parser reads packet captures, reassembles length-prefixed TCP messages, decrypts them and decodes MessagePack requests, responses and pushes into JSON.
- [Lego Island 2: GBA decompilation](https://awesomerea.org/resources/lego-island-2-gba-case/index.md): Case study · Lego Island 2 reconstructs the GBA game's code in C and assembly using bagd. Its documented workflow extracts assets from a user-provided baserom.gba with isle2-tool, generates build files with bagd and builds the ROM.
- [Colony Wars: Red Sun — a local PSXRecomp build](https://awesomerea.org/resources/colony-wars-red-sun-recomp-case/index.md): Case study · Colony Wars: Red Sun uses PSXRecomp and recomp-ui to generate and compile a native build from the user's USA PlayStation disc and BIOS. Its title kit includes configuration, symbol seeds and a movie-centering hook. The author reports Windows setup and headless-start checks and play testing on a private build.
- [Puniemu: a Yo-kai Watch Puni Puni server emulator](https://awesomerea.org/resources/puniemu-yokai-watch-case/index.md): Case study · Puniemu recreates a C# server for Yo-kai Watch Puni Puni. Its source handles account creation and game data while implementing the client's AES-based request and response encoding, including compressed responses and salted SHA-1 digests.
- [re-Sonic06Demo: a ReXGlue recompilation of the Sonic the Hedgehog (2006) demo](https://awesomerea.org/resources/re-sonic06demo-case/index.md): Case study · re-Sonic06Demo uses the ReXGlue SDK to recompile the Sonic the Hedgehog (2006) demo and build a native executable. The author reports that the demo can be played from start to finish, with slowdowns especially during videos; it currently supports gamepad input only.
- [Gravity Rush 2: a PS4 runtime port for PC](https://awesomerea.org/resources/gravity-rush-2-pc-case/index.md): Case study · The Gravity Rush 2 PC port runs the PS4 game's original x86-64 code on a host CPU while replacing PS4 services and translating GPU work to Vulkan. It adapts a shared runtime for Gravity Rush 2 and reads the user's own CUSA03694 game and update files.
- [GoldenEye64Recomp: a macOS and Linux static recompilation port](https://awesomerea.org/resources/goldeneye64-recomp-case/index.md): Case study · GoldenEye64Recomp ports the GoldenEye 007 recompilation to macOS and Linux with N64Recomp and RT64, using a user-supplied Nintendo 64 ROM. A standard build generates game code during compilation; a clean build recompiles functions in memory at launch. The project documents platform changes and fixes to runtime messaging, rendering and recompilation behavior.
- [The Simpsons Arcade: an Xbox 360 static recompilation](https://awesomerea.org/resources/simpsons-arcade-recomp-case/index.md): Case study · The Simpsons Arcade port translates the Xbox 360 game's PowerPC executable into C++ with XenonRecomp and runs it through ReXGlue's native runtime. Its repository records XEX analysis, switch-table work, game-specific stubs and fixes for frame pacing and guest timebase scaling.
- [Duck Hunt Disassembly: reconstructing the World release in assembly](https://awesomerea.org/resources/duck-hunt-disassembly-case/index.md): Case study · Duck Hunt Disassembly reconstructs the game's World release as NES assembly using nesgodisasm and an emulator code/data log. The assembly builds through ca65 and ld65, with a CRC-32 check against the target ROM; RAM-viewer experiments inform its variable notes.
- [A Link to the Past: an annotated US disassembly for Asar](https://awesomerea.org/resources/asar-us-alttp-disassembly-case/index.md): Case study · AsarUSALTTPDisassembly reorganizes and annotates assembly for the US SNES release of The Legend of Zelda: A Link to the Past. It adapts earlier disassembly work for Asar, adds labels, RAM maps and notes based on the author's research, and aims for an exact ROM rebuild once its build is complete.
- [Crimson Skies: static recompilation and runtime bring-up](https://awesomerea.org/resources/crimson-skies-recomp-case/index.md): Case study · Crimson Skies statically translates the game's x86 Win32 executable to C and connects it to native MFC and DirectX libraries through import bridges and callbacks. The repository contains game-specific function maps, a generation pipeline and runtime code; the author reports reaching the GOS game shell, while asset loading, gameplay and a modern renderer remain pending.
- [sctools: Sega Channel image extraction and nsf.exe decompilation](https://awesomerea.org/resources/sctools-sega-channel-case/index.md): Case study · sctools contains an approximate, nonmatching C decompilation of nsf.exe and a C++ tool that extracts files from Sega Channel game distribution images.
- [Rebellion 2: a Unity remake of Star Wars: Rebellion](https://awesomerea.org/resources/rebellion-2-case/index.md): Case study · Rebellion 2 recreates the 1998 strategy game Star Wars: Rebellion in Unity. The source includes campaign simulation, AI, interfaces and modding support; the author reports that the single-player campaign is playable while multiplayer and replacement 3D tactical combat remain unfinished. Installation requires ownership of a supported original game.
- [freeaoe: an Age of Empires 2 engine rebuilt from observation](https://awesomerea.org/resources/freeaoe-case/index.md): Case study · freeaoe rebuilds an Age of Empires 2 engine in C++ from observed gameplay and public knowledge. It loads original game data directly, including scenarios, campaigns, graphics and AI scripts; support for Star Wars: Galactic Battlegrounds remains in progress.
- [Peach's Castle Tech Demo: an nddemo decompilation](https://awesomerea.org/resources/peachs-castle-tech-demo-decomp-case/index.md): Case study · nddemo decompiles the Peach's Castle Tech Demo using C and C++ source alongside address-annotated assembly. The repository includes a Makefile for the NDDEMO build.