# Curated reverse engineering resources · Page 31

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

## Games (100)

- [Reach Cache Debug: recompiling a Halo debug executable](https://awesomerea.org/resources/reach-cache-debug-recomp-case/index.md): Case study · Reach Cache Debug Recomp uses ReXGlue to recompile halo3_cache_debug.xex from a Reach-era Xbox 360 debug build. It supplies debug-service stubs, memory and socket hooks, and virtual filesystem mappings for the executable.
- [Ogrebattle64: decompiling the North American game release](https://awesomerea.org/resources/ogrebattle64-case/index.md): Case study · Ogrebattle64 decompiles the North American release of the game using a user-provided ROM. Its build process extracts assets from baserom.z64 before running make, and a separate make target generates an m2c context file for function work.
- [Leaflitter: decompiling Paper Mario: Sticker Star for 3DS](https://awesomerea.org/resources/leaflitter-case/index.md): Case study · Leaflitter decompiles the European release of Paper Mario: Sticker Star for Nintendo 3DS. It extracts code.bin from the user's game copy, generates assembly with n3dsdisasm, and builds source with armcc; utilities process Ghidra headers and symbol names, while make generates objdiff configuration.
- [DDR 1st Mix: static recompilation and freeze analysis](https://awesomerea.org/resources/ddr-1st-mix-recomp-case/index.md): Case study · DDR 1st Mix recompiles the PlayStation release SLPM-86222 by translating its MIPS code to C with PSXRecomp and building a native executable. Game-specific hooks address runtime behavior, and the author documents tracing an animation error into a cyclic display list that caused freezes.
- [SF1DISASM: a reassemblable Shining Force disassembly](https://awesomerea.org/resources/sf1disasm-case/index.md): Case study · SF1DISASM documents Shining Force as structured, commented 68k assembly and provides scripts to rebuild the US ROM. Its split step extracts data chunks from the user's original ROM before the build step assembles the source and extracted data. The project aims for a rebuilt ROM identical to the original.
- [Homeworld 2 Classic: an in-progress executable and DLL decompilation](https://awesomerea.org/resources/homeworld2classic-case/index.md): Case study · Homeworld2Classic reconstructs Homeworld 2's executable and DLL modules in C++ as an ongoing decompilation. Its source tree contains game and platform code, and the project publishes objdiff matching reports for Homeworld2.exe and individual libraries. The author describes the work as unfinished.
- [Freelancer: an in-progress Patch 1.1 decompilation](https://awesomerea.org/resources/freelancer-decomp-case/index.md): Case study · Freelancer reconstructs C++ source for the game's Patch 1.1 executables and DLLs as a work-in-progress decompilation. Its configurations split individual modules, while engine libraries within scope are reimplemented in the separate Liberty project.
- [Goldeneye 007: a recompilable decompilation of three regional ROMs](https://awesomerea.org/resources/goldeneye-007-gitlab-decomp-case/index.md): Case study · Goldeneye 007 is an ongoing, recompilable decompilation of the Nintendo 64 game. The project lists builds for US, Japanese and European ROMs and extracts required assets from a user-supplied copy of the game.
- [BT2 Recomp: a Budokai Tenkaichi 2 PS2 static recompilation](https://awesomerea.org/resources/bt2-recomp-case/index.md): Case study · BT2 Recomp translates the North American PlayStation 2 release of Dragon Ball Z: Budokai Tenkaichi 2 to native Windows C++ with PS2Recomp. Its runtime supplies memory, system services and Vulkan GS rendering for the translated game code. The author reports playable versus battles and runs of story mode, Ultimate Battle Z, tournaments and training lessons without input; memory-card saving remains unconfirmed.
- [Pizza Legacy: reimplementing Pizza Tycoon](https://awesomerea.org/resources/pizza-legacy-case/index.md): Case study · Pizza Legacy rebuilds the 1994 DOS game Pizza Tycoon, also released as Pizza Connection, in a C++20 engine that loads the original game's assets. The author reports that the major gameplay systems support a complete playthrough. The remake also adds optional bug fixes, autosaving, and support for modern displays and controls.
- [SkyboundTOTK: a native static recompilation of Tears of the Kingdom](https://awesomerea.org/resources/skyboundtotk-case/index.md): Case study · SkyboundTOTK statically recompiles The Legend of Zelda: Tears of the Kingdom into a native Windows or Linux executable. Its build translates the game's AArch64 code to C, compiles it locally, supplies expected runtime services and translates graphics work and shaders for WebGPU. The author describes graphics and compatibility as incomplete.
- [ssgdecomp: reconstructing Super Solvers: Gizmos & Gadgets!](https://awesomerea.org/resources/ssgdecomp-case/index.md): Case study · ssgdecomp reconstructs Super Solvers: Gizmos & Gadgets! with the aim of producing a bit-identical Windows executable. It uses the original ssgwin32.exe as an incremental starting point, builds with the period Borland toolchain, and compares PE sections and disassembly; its documented helpers inspect compiler output, import tables and OMF objects.
- [Twisted Metal: Rust reimplementation of the 2012 PS3 game](https://awesomerea.org/resources/twisted-metal-native-engine-case/index.md): Case study · Twisted Metal reimplements the 2012 PS3 game's engine in Rust for Linux and macOS. Its tools extract a user's disc image, convert models, textures, collision and handling data, and support scene viewing and an early driving simulation with placeholder physics.
- [Mario Bros.: Z80 arcade disassembly](https://awesomerea.org/resources/mb-mario-bros-case/index.md): Case study · Mario Bros. reconstructs assembly for the Z80 arcade game, beginning with the marioja MAME ROM set. It uses GNU Z80 binutils for CPU code and asm48 for sound code; graphics data is outside the project's stated scope.
- [DisruptorRecomp: statically recompiling Disruptor for PC](https://awesomerea.org/resources/disruptor-recomp-recompteam-case/index.md): Case study · DisruptorRecomp turns the PlayStation game Disruptor into a native Windows and Linux program using PSXRecomp and a patched runtime. Its launcher reads the player's USA disc image; the project adds PC display and control options while retaining an alpha status.
- [Ordoor: reimplementing the Strategy Engine for four games](https://awesomerea.org/resources/ordoor-strategy-engine-case/index.md): Case study · Ordoor rebuilds the Strategy Engine used by Warhammer 40,000: Chaos Gate, Soldiers At War, Squad Leader, and Wages of War. Its format work and viewers cover maps, menus, graphics, sound, and video to varying degrees; gameplay mechanics remain unfinished.
- [fzgx: a matching F-Zero GX decompilation](https://awesomerea.org/resources/fzgx-nkhoit-decomp-case/index.md): Case study · F-Zero GX reconstructs C source for the GameCube game's main.dol and REL modules, comparing builds with retail files. Its tools extract and unpack main.rel from the user's disc image, while unmatched functions are linked from that copy; the author reports roughly 30% of code matched.
- [Commander Genius: Commander Keen game interpreter](https://awesomerea.org/resources/commander-genius-case/index.md): Case study · Commander Genius reimplements an interpreter for Commander Keen 1–6 and Keen Dreams in C++, using the original games' data files to run their gameplay on modern systems. It also includes partial support for Cosmo's Cosmic Adventure, alongside SDL 2.0, Lua mod support, and multiplayer features.
- [Harvest Moon GB Disassembly: reconstructing the Japanese Game Boy ROM](https://awesomerea.org/resources/harvest-moon-gb-disassembly-case/index.md): Case study · Harvest Moon GB Disassembly reconstructs the Japanese Game Boy release as banked assembly. The project tracks named labels and gives an MD5 reference for the compiled game while its disassembly remains in progress.
- [OpenPete: a static recompilation of Spyro the Dragon for PC](https://awesomerea.org/resources/openpete-case/index.md): Case study · OpenPete ports the 1998 PlayStation game Spyro the Dragon to PC by translating its executable to C and compiling it ahead of time. A custom runtime handles PlayStation library calls, while a game-aware renderer supports high frame rates, widescreen display and texture replacement. The port reads game content from a user-supplied NTSC-U disc.
- [butterfly: emulating DDR A online services](https://awesomerea.org/resources/butterfly-ddr-a-service-case/index.md): Case study · butterfly emulates the e-AMUSEMENT service used by DDR A so the game can connect to a local server. Its Java code handles profiles, scores, options and rivals, with support code for the service's packet encryption and compression.
- [tmuf_physics: reconstructing TrackMania Forever physics](https://awesomerea.org/resources/tmuf-physics-case/index.md): Case study · tmuf_physics is a C library that reads installed TrackMania Nations and United Forever data to simulate vehicle physics and race rules. It offers reference and optimized backends, reads and writes replays, and includes pack-format findings. The author reports tick-for-tick agreement with the game on 11,758 replays.
- [Ninja Cop: disassembly of two GBA releases](https://awesomerea.org/resources/ninjacop-case/index.md): Case study · Ninja Cop reconstructs assembly for the GBA releases Ninja Cop and Ninja Five-O and provides commands to build both ROM versions. The author reports that all code has been disassembled; code and data documentation, graphics extraction, and readable strings remain unfinished.
- [WebFun: reimplementing the Desktop Adventures game engine](https://awesomerea.org/resources/webfun-desktop-adventures-case/index.md): Case study · WebFun recreates the engine behind Indiana Jones and His Desktop Adventures and Yoda Stories as a web application. The project shows game play, mobile controls, save inspection, asset editing, debug overlays, and script coverage views.
- [OpenPrivateer: reconstructing Wing Commander: Privateer](https://awesomerea.org/resources/openprivateer-case/index.md): Case study · OpenPrivateer reconstructs Wing Commander: Privateer and its Righteous Fire add-on for modern systems using the player's original game files. Its engine loads original archives and saves, runs mission scripts, and recreates flight and combat using findings from game data and executable disassembly. Basic multiplayer and modding features are available, with further work in progress.
- [spectrum-saboteur1-rev: matching disassembly of Saboteur](https://awesomerea.org/resources/spectrum-saboteur1-rev-case/index.md): Case study · spectrum-saboteur1-rev reconstructs assembly for the 1985 ZX Spectrum game Saboteur in a single sabot1core.asm file. The author reports that assembling it with pasmo produces a byte-for-byte match with a memory image.
- [SnapPad: a Pokémon Snap static recompilation for Apple devices](https://awesomerea.org/resources/snappad-pokemon-snap-case/index.md): Case study · SnapPad builds a native Apple version of Pokémon Snap from a user-supplied US ROM using the game's decompilation, N64Recomp, RSPRecomp, and RT64. Its integration supplies Metal rendering, touch and controller input, private ROM setup, and persistent saves for iPhone, iPad, and Apple silicon Mac.
- [pokerevo: PAL Wii game decompilation](https://awesomerea.org/resources/pokerevo-pal-decomp-case/index.md): Case study · pokerevo is a decompilation of the PAL Wii release of Pokémon Battle Revolution that builds a main.dol identified by a published SHA-1 hash. Its build uses a clean PAL 1.0 DOL and the specified compiler package.
- [sm64synth: Rust port of the Super Mario 64 audio engine](https://awesomerea.org/resources/sm64synth-case/index.md): Case study · sm64synth ports the reconstructed Super Mario 64 audio engine to Rust as a reference implementation. Its music player and WAV renderer use sound assets extracted from a compatible game ROM; the implementation is based on the European version.
- [God of War II: an Android arm64 static recompilation build kit](https://awesomerea.org/resources/god-of-war-ii-android-case/index.md): Case study · God of War II is the target of an Android arm64 build kit that translates the PS2 game's Emotion Engine executable to C++ with PS2Recomp. The kit adds an Android host layer, an ISO importer and a raw Vulkan Graphics Synthesizer backend. The author reports that the APK builds, while boot, graphics, input and audio work on a physical device remains pending.
- [SkiesOfArcadiaLegends-Decomp: Skies of Arcadia Legends GameCube decompilation by ogdanimal](https://awesomerea.org/resources/skies-of-arcadia-legends-decomp-ogdanimal-case/index.md): Case study · Skies of Arcadia Legends reconstructs C source for the USA Rev 0 GameCube main.dol and checks rebuilt code with objdiff and compiler probes. It documents game systems including menus, cameras, sound and the frame loop while identifying separately imported SDK and MusyX code. The author reports 82 game functions linked from C in its October 2026 status block.
- [Castlevania: Curse of Darkness — a native PC port by static recompilation](https://awesomerea.org/resources/castlevania-curse-of-darkness-pc-case/index.md): Case study · Castlevania: Curse of Darkness is ported from PlayStation 2 to Windows by translating its MIPS code to C++ and rebuilding PS2 hardware functions as PC code. The project includes a recompiler, a VU1 microprogram compiler, graphics and I/O implementations, and game hooks for widescreen display, a minimap and sprinting. Game-derived code is generated locally from the user's European disc image.
- [Secret Agent Clank: matching PlayStation 2 decompilation](https://awesomerea.org/resources/rac-secret-agent-clank-decomp-case/index.md): Case study · Secret Agent Clank reconstructs C and C++ source for the US and PAL PlayStation 2 releases, including the boot executable and SNR2 level modules. Its workflow tracks function bodies and placements, compares builds against retail hashes, and records progress by version. The author describes the work as ongoing.
- [Thunderclap: decompiling the Xbox Hulk game for a native port](https://awesomerea.org/resources/thunderclap-case/index.md): Case study · Thunderclap reconstructs the Xbox release of The Incredible Hulk: Ultimate Destruction in C++ for a planned native port. It byte-compares smaller functions with the original compiler and checks larger functions through differential execution against the original. The author reports source for all game functions and a Wine build that reaches the first mission.
- [Decomp-no-Me-UN5Decomp: reconstructing Naruto Shippuden 5 functions](https://awesomerea.org/resources/decomp-no-me-un5-case/index.md): Case study · Decomp-no-Me-UN5Decomp reconstructs C functions for the PlayStation 2 game Naruto Shippuden: Ultimate Ninja 5 from its MIPS R5900 executable. Splat prepares assembly and extracted data from a user-supplied executable; a matching command compiles individual C functions and compares their machine code with the original.
- [Turok: Rage Wars: matching decompilation of five N64 releases](https://awesomerea.org/resources/abun64-rage-wars-decomp-case/index.md): Case study · Turok: Rage Wars reconstructs C and assembly source for five Nintendo 64 cartridge releases, including German, European and North American variants. The build splits user-supplied ROMs, compiles the source and checks each rebuilt ROM against its original; the author reports near-complete byte matching.
- [Kabus22 Linux: a native reconstruction of the Kabus 22 engine](https://awesomerea.org/resources/kabus22-linux-case/index.md): Case study · Kabus22 Linux reimplements the 3D GameStudio A6 and A7 engine behavior used by Kabus 22 in C++20. Its native runtime reads the user's original WDL scripts and assets, with OpenGL and optional Vulkan rendering, and the repository documents executable analysis and asset formats.
- [Super Monkey Ball Jr.: GBA disassembly](https://awesomerea.org/resources/smbjr-case/index.md): Case study · Super Monkey Ball Jr. provides a minimal, buildable disassembly of the GBA game. Its make build uses a user-provided USA ROM named baserom.gba and devkitarm.
- [Arcanum project: porting the game to iOS and macOS](https://awesomerea.org/resources/arcanum-ios-port-case/index.md): Case study · The project ports the game to iOS and macOS with a C++ and Metal renderer that loads tile .art files extracted from the user's original game into an Arcanum Revitalized folder. Its current build renders the crash-sector terrain and a moving player character on physical iOS devices.
- [reDM2: reconstructing Dungeon Master II in C](https://awesomerea.org/resources/redm2-case/index.md): Case study · reDM2 reconstructs the DOS release of Dungeon Master II in C from its shipped SKULL.EXE executable. It separates game code from linked libraries and compares ported functions with the originals using Unicorn emulation, memory-write checks, and captured game-state snapshots. The author reports that some functions remain blocked by missing emulator capabilities.
- [Banjo-Kazooie: rebuilding the game from base ROMs](https://awesomerea.org/resources/banjo-kazooie-rebuild-case/index.md): Case study · Banjo-Kazooie provides a workflow to extract from a user-supplied base ROM and build the game in full or by module. It lists US, Japanese and PAL ROM variants; the author reports 100.0000% progress.
- [Freenukum: a Duke Nukem 1 clone](https://awesomerea.org/resources/freenukum-case/index.md): Case study · Freenukum recreates the 1991 DOS game Duke Nukem 1 using Rust and the original game's graphics data. It provides a data installation tool and is still missing opponents and some level items.
- [SCD Disasm: Sonic CD disassembly](https://awesomerea.org/resources/scd-disasm-case/index.md): Case study · SCD Disasm reconstructs Sonic CD's Sega Mega CD program files from disassembly, initially using the V0.02 prototype. It organizes reused engine functions into shared source files with linker scripts for the disc files; the author reports that the resulting binary objects can be assembled into an ISO that runs in an emulator.
- [1oom: Master of Orion engine recreation](https://awesomerea.org/resources/1oom-case/index.md): Case study · 1oom recreates the Master of Orion (1993) game engine using LBX files from version 1.3 of the original game. It includes a classic interface, a command-line interface, LBX viewing and editing utilities, and converters for graphics and saved games.
- [OpenRSC: reconstructing RuneScape Classic servers](https://awesomerea.org/resources/openrsc-case/index.md): Case study · OpenRSC rebuilds a RuneScape Classic server framework using black-box reverse engineering and study of RSC+ gameplay replays. Its configurable server supports reconstructed game behavior and optional features such as quests, clans and an auction house.
- [Carrier Command Reverse Engineering: seven executable reconstructions](https://awesomerea.org/resources/carrier-command-re-case/index.md): Case study · Carrier Command Reverse Engineering maintains annotated, reassemblable sources for seven DOS, Amiga, Atari ST and Mac releases of Carrier Command. Its tools unpack originals, identify functions and compare assembled executables byte for byte with user-supplied files. DOS version overlays and M68K offset maps share annotations across releases.
- [pso-gc: Phantasy Star Online Episode I & II GameCube decompilation](https://awesomerea.org/resources/pso-gc-case/index.md): Case study · pso-gc decompiles Phantasy Star Online Episode I & II for GameCube. The project contains assembly, source code, headers, tools and Makefile-based build files for the game.
- [OpenGuimo: GUIMO gameplay reimplemented in Godot](https://awesomerea.org/resources/openguimo-case/index.md): Case study · OpenGuimo recreates the 1997 DOS platformer GUIMO in Godot 4.7, translating rules recovered from guimo.exe 2.2 into GDScript. It reads levels, pictures, sound and music from the user's guimo.jbc archive and documents several bugs found while examining the original executable.
- [OpenE2140: Earth 2140 gameplay reimplemented in C++](https://awesomerea.org/resources/opene2140-cpp-case/index.md): Case study · OpenE2140 is a C++ reimplementation of Earth 2140 gameplay that loads the original game's WD archives for sprites, effects and levels. It includes map drawing, basic entities and unit statistics; orders, weapons, audio, AI and multiplayer remain on its roadmap.
- [mw-tools: reconstructing a MythWar I server](https://awesomerea.org/resources/mw-tools-mythwar-case/index.md): Case study · mw-tools develops a MythWar I server from scratch using the game client. The project seeks old gameplay videos or recordings to help replicate original features. Its TypeScript code targets Node 16 and includes a script that creates the client's door.dat server-list file for local play. The server currently lacks data storage, multiplayer and most game features.
- [Tower Toppler: reimplementing Nebulus](https://awesomerea.org/resources/tower-toppler-case/index.md): Case study · Tower Toppler reimplements the rotating-tower puzzle platformer Nebulus with newly drawn graphics. The author reports behavior close to the original after comparison, and the current game uses SDL for graphics and sound. A level editor supports new towers and missions.
- [Super Mario Bros. Meta-Disassembly: six 8-bit engine variants](https://awesomerea.org/resources/smb-meta-disassembly-case/index.md): Case study · Super Mario Bros. Meta-Disassembly organizes six 8-bit Super Mario Bros. engine releases in one assembly codebase. Preprocessor definitions select release-specific code, while extraction scripts obtain assets from iNES or FDS game images. The assembly includes control-flow commentary.
- [GFXFileManager: Silkroad Online file manager replacement](https://awesomerea.org/resources/gfxfilemanager-case/index.md): Case study · GFXFileManager implements a reverse-engineered replacement for Silkroad Online's Joymax File Manager interface. Its DLL loads game files directly from disk instead of the pk2 container and logs function calls. The implementation remains incomplete: file creation, deletion, directory handling and archive browsing are unavailable.
- [Zelda II: Famicom Disk System disassembly](https://awesomerea.org/resources/zelda-ii-fds-disassembly-case/index.md): Case study · The Zelda II disassembly reconstructs the initial Famicom Disk System release of The Adventure of Link from a disk image. It includes utilities for building an FDS image, an asset extraction script, and C-like control-flow annotations. The files inside the rebuilt image are meant to match the originals, while the image itself carries local filenames and timestamps.
- [Domino-Chain: recreating Pushover](https://awesomerea.org/resources/domino-chain-case/index.md): Case study · Domino-Chain recreates the 1992 puzzle game Pushover, in which players arrange dominoes to trigger a chain reaction. It adds levels, domino types, graphics and music, and can load original Pushover levels from a player's copy.
- [Super Mario Bros. 3: Famicom disassembly](https://awesomerea.org/resources/smb3-famicom-disassembly-case/index.md): Case study · smb3 disassembles the initial Family Computer release of Super Mario Bros. 3 and adds C-like annotations for branches and loops. An extraction script obtains assets from a headered iNES ROM before building with the cc65 6502 toolchain.
- [DSDS: Dark Souls 1 map viewer and engine reimplementation](https://awesomerea.org/resources/dsds-dark-souls-1-map-viewer-case/index.md): Case study · DSDS reimplements parts of the Dark Souls 1 engine to display game maps from a Steam installation of Prepare to Die Edition. Its notes list open questions about MSB map parts and how material definitions lead to compiled shaders; map objects, MSB events and regions, and collision are unimplemented.
- [Frogger: SNES disassembly and ROM reconstruction](https://awesomerea.org/resources/frogger-snes-disassembly-case/index.md): Case study · Frogger's SNES port is reconstructed as assembly with ROM and RAM maps, SPC700 audio-engine code, and scripts for extracting assets from an original ROM. The author reports that the disassembly assembles completely; the included Asar-based framework provides the assembly workflow.
- [Doki Doki/Super Mario Bros. 2 Disassembly — Famicom and NES game disassembly](https://awesomerea.org/resources/doki-doki-super-mario-bros-2-case/index.md): Case study · Doki Doki/Super Mario Bros. 2 Disassembly covers Yume Kojo: Doki Doki Panic for the Famicom Disk System and Super Mario Bros. 2 and Super Mario USA for NES/Famicom. It provides a modifiable disassembly, includes bintofdf and fdtc for building a disk image, and extracts required assets from a game image.
- [Donkey Kong Disassembly: Arcade Z80 and sound code](https://awesomerea.org/resources/donkey-kong-disassembly-case/index.md): Case study · Donkey Kong Disassembly reconstructs the arcade game's Z80 CPU and sound code as assembly for known MAME ROM sets. Its build targets produce ROM files and compare their checksums with recorded values; graphics data is excluded.
- [kh-com: Kingdom Hearts: Chain of Memories decompilation](https://awesomerea.org/resources/kh-com-case/index.md): Case study · kh-com reconstructs code from the US Game Boy Advance release of Kingdom Hearts: Chain of Memories. The early source covers startup, initialization, the main loop and interrupt handling; many called routines remain placeholders.
- [Air-Sea Battle: an annotated Atari 2600 disassembly](https://awesomerea.org/resources/air-sea-battle-disassembly-case/index.md): Case study · A labeled and commented 6502 assembly listing reconstructs Air-Sea Battle, Atari's 1977 game for the Atari 2600, on the MiniDig disassembly page. An assembler switch selects the NTSC or PAL build of the 2K ROM. Header notes cover the taller PAL kernel zones, why the NTSC version's EXPERT difficulty gives a missile size of 0, and the two RAM locations, $91 and $92, that the author marks as unused.
- [Berzerk: a commented Atari 2600 disassembly](https://awesomerea.org/resources/berzerk-atari-2600-disassembly-case/index.md): Case study · Berzerk for the Atari 2600 (Atari, 1982) is reconstructed as a labeled, commented 6502 assembly listing that assembles to the exact original ROM image, with a switch for the NTSC or PAL build. The notes cover the game's sprite-drawing technique, PAL frame-delay values set at 1.2 times the NTSC ones, unused diagonal robot-fire values left in the ROM, unused RAM and the roughly 12-second launch of Evil Otto.
- [Combat: an annotated Atari 2600 disassembly](https://awesomerea.org/resources/combat-atari-2600-disassembly-case/index.md): Case study · A commented 6502 assembly listing reconstructs Combat, the Atari 2600 tank, biplane and jet game, aiming to explain every instruction, memory location and table. Assembled with DASM it yields an image that differs from the cartridge ROM only in the unwritten padding bytes before the startup vectors. The header maps all 27 game variations to their missile, maze and cloud options, and main-loop routines carry Atari's original names, taken from presentation notes.
- [Cosmic Ark: a commented Atari 2600 disassembly with PAL conversion](https://awesomerea.org/resources/cosmic-ark-atari-2600-disassembly-case/index.md): Case study · Cosmic Ark for the Atari 2600 (Imagic, 1982) is reconstructed as an analyzed, labeled and commented 6502 assembly listing with NTSC and PAL builds. The PAL conversion rescales nearly all game speeds through the game's fractional addition so both versions play at the same pace, and optional switches enable size optimizations. The notes point out the leftover code for a non-cooperative two-player mode and the game's heavy use of status flags.
- [Donkey Kong: an annotated Atari VCS disassembly that rebuilds the cartridge](https://awesomerea.org/resources/donkey-kong-atari-vcs-disassembly-case/index.md): Case study · Coleco's 1982 Atari VCS cartridge of Donkey Kong is disassembled into labeled and commented 6502 assembly kept byte-identical to the cartridge, down to a filler byte that pushes the audio frequency table to the next page. Comments outline the overscan, vertical blank and kernel main loop and the horizontal positioning routine, and an NTSC switch selects the PAL listing, which retimes vertical blank and overscan for 312 scan lines and changes colours and sound frequencies.
- [Elite: Harmless — a Commodore 64 Elite disassembly](https://awesomerea.org/resources/elite-harmless-case/index.md): Case study · Elite: Harmless is a full ca65 disassembly of the Commodore 64 release of Elite, taken from the 1986 GMA86 disk, with the code split into flight, docked, text, ship-hull, math, sound and graphics modules. Its build script reassembles the original loader stages and game files, checks them against MD5 sums, and writes a disk image. The same source builds an enhanced variant with a faster multiplication routine and faster line drawing, and a loader document explains the choice of the GMA86 disk and describes the first stage of its copy-protected loader.
- [Exile: an annotated disassembly of the enhanced BBC Micro version](https://awesomerea.org/resources/exile-enhanced-disassembly-case/index.md): Case study · An annotated disassembly reconstructs the enhanced BBC Micro version of Exile, the 1988 Superior Software adventure game, from its binary images, covering the sideways-RAM sample loader, the decryption code and the main game. Technical notes give the address ranges of the sprite plotter, the procedural 256x256 tile landscape generator, the three-list object physics engine, envelope-based sound, NPC mood stimuli and the novella-word copy protection, alongside game-play notes and a list of memory pokes.
- [Indy 500: a first-pass labeled Atari 2600 disassembly](https://awesomerea.org/resources/indy-500-atari-2600-disassembly-case/index.md): Case study · Indy 500 for the Atari 2600 is disassembled with DiStella v3.0 into a 6502 listing carrying a first pass of hand-written labels and comments. Named RAM locations cover game state, scores, speed settings, car positions, collision state and audio channels, and comments mark the mirror-symmetrical racetrack kernel, acceleration handling for both cars and per-game color-palette tables.
- [Jawbreaker: an annotated Atari VCS disassembly that compiles to the exact ROM](https://awesomerea.org/resources/jawbreaker-atari-vcs-disassembly-case/index.md): Case study · Tiger Electronic Toys' 1982 Atari VCS game Jawbreaker is disassembled into labeled and commented 6502 assembly that compiles to the exact ROM image. Notes explain how sprite positions are kept as combined fine-motion and coarse values and how an inverted playfield masks the maze, and record that joystick input is read from $0288 instead of SWCHA; assembler switches select an NTSC or PAL build and an optional no-defeat mode.
- [Kaboom!: an annotated Atari 2600 disassembly](https://awesomerea.org/resources/kaboom-atari-2600-disassembly-case/index.md): Case study · A labeled and commented 6502 assembly listing reconstructs Kaboom!, Activision's 1981 paddle game for the Atari 2600, as a 2K ROM source on the MiniDig disassembly page. Assembler switches select NTSC or PAL timing and colors and choose between the original back-and-forth Mad Bomber movement and a smooth variant. Labeled constants cover paddle limits, bomb-group sizes and the display kernels, and comments note bomb-group table entries the game never reads.
- [Outlaw: a reverse-engineered Atari 2600 source listing](https://awesomerea.org/resources/outlaw-atari-2600-disassembly-case/index.md): Case study · Outlaw for the Atari 2600 (Atari, 1978) is reverse-engineered into commented 6502 source that compiles with DASM. Named RAM variables cover the playfield arrays, scores, bullets in each gun, sound state and obstacle positions, and the commented code walks through the score and magazine display, the main four-line display kernel, gun reloading, select handling, movement and bullet bouncing.
- [Pitfall!: an annotated Atari VCS disassembly of scene generation and the kernel](https://awesomerea.org/resources/pitfall-atari-vcs-disassembly-case/index.md): Case study · Activision's 1982 Atari VCS game Pitfall! is disassembled into labeled and commented 6502 assembly (version 0.9). Notes explain how a reversible LFSR generates the 255 jungle scenes, which bits of the random number select ground objects, scene type, tree pattern and wall position, and how the nine-stripe display kernel draws Harry, the liana, holes, ladder and wall; assembler switches add optional optimizations, screensaver code and a training mode.
- [Red vs. Blue: an annotated Atari 2600 multi-sprite demo disassembly](https://awesomerea.org/resources/red-vs-blue-atari-2600-disassembly-case/index.md): Case study · A labeled and commented 6502 assembly listing reconstructs Red vs. Blue, a 1981 Atari 2600 multi-sprite demo that later became RealSports Football. The listing labels the vertical sync and timer loop, the display kernel for the red and blue animated players, eight animation frames of player graphics, and the horizontal-position and sprite-copy tables. A comment marks a frame-timing counter that has no effect on the animation rate.
- [River Raid: an annotated Atari VCS disassembly of river generation and the kernel](https://awesomerea.org/resources/river-raid-atari-vcs-disassembly-case/index.md): Case study · Activision's 1982 Atari VCS game River Raid is disassembled into labeled and commented 6502 assembly (version 0.9). Notes explain how random river sections of 16 blocks ending in a bridge are generated, how one fuel tank, enemy or house is placed per block, how a two-line kernel repeated twelve times draws each 32-line block with hardware-only collision checks, and how the score lives directly in the display pointers; switches add screensaver code and a training mode.
- [Space Jockey: an exact-ROM Atari 2600 disassembly](https://awesomerea.org/resources/space-jockey-atari-2600-disassembly-case/index.md): Case study · A labeled and commented 6502 assembly listing reconstructs Space Jockey, US Games' first Atari 2600 game from 1982, and sets the TIA read base so it compiles to the exact 2K ROM image. An assembler switch selects NTSC or a PAL listing taken from the Carrere Video release, whose changes to vertical blank timing and colors are documented. Header notes discuss the origin of its horizontal positioning routine, and comments label obstacle attributes such as shot and firing flags.
- [Starmaster: a commented Atari 2600 disassembly](https://awesomerea.org/resources/starmaster-atari-2600-disassembly-case/index.md): Case study · Starmaster for the Atari 2600 (Activision, 1982) is disassembled with DiStella v2.0 and then analyzed, named and commented into readable 6502 source. Named constants describe the 6x6 sector map, starbases, enemy IDs, star field, warp and laser timing and enemy fire distance, and an OPTIMIZE switch swaps in code improvements the author identified while studying the routines.
- [Surround: an annotated Atari VCS disassembly that compiles to the exact 2K ROM](https://awesomerea.org/resources/surround-atari-vcs-disassembly-case/index.md): Case study · Atari's 1977 VCS game Surround is disassembled into labeled and commented 6502 assembly that compiles to the exact 2K ROM image. The listing names the zero-page variables, the game-variation flags for speed-up, wraparound, erase, diagonal movement and single-player play, the joystick and switch masks, and the score and playfield drawing routines, with a compile switch for NTSC or PAL builds.
- [A-Team: an Atari 2600 disassembly with PAL conversion](https://awesomerea.org/resources/a-team-atari-2600-disassembly-case/index.md): Case study · A two-bank 6502 disassembly of A-Team for the Atari 2600 assembles with DASM and doubles as the basis for a PAL conversion. Compile switches pick NTSC, PAL 50 Hz or PAL60 colors and timing, and toggle the intro logo and intro glitch fixes, the level-1 border color cycling and a bug fix that keeps the scanline count fixed, each with the original behaviour available. Comments mark the color register writes for backgrounds, characters, missiles, the score panel and the intro screen.
- [Venture: a reverse-engineered Atari 2600 source listing](https://awesomerea.org/resources/venture-atari-2600-disassembly-case/index.md): Case study · Venture for the Atari 2600 (Coleco) is reverse-engineered into commented 6502 source with a DASM build command that writes a listing, symbol table and binary. Comments document the screen region used for rooms, sprite timesharing in the moving-wall room, monster status values, shot range, collision handling and per-room playfield offsets, and every graphics table carries a visual comment of its pixels; two RAM bytes are marked unused by the original code.
- [blackhack: runblack.exe UI widget decompilation](https://awesomerea.org/resources/blackhack-case/index.md): Case study · blackhack rebuilds the SetupControl UI widget classes of runblack.exe as hand-decompiled C, covering buttons, big and tab buttons, check boxes, lists, sliders, edit fields, colour pickers, pictures and graph widgets, along with parts of Lionhead's lhlib. A Detours launcher checks the executable's md5, injects a DLL and swaps original functions for the rebuilt ones through per-version tables of function and data addresses. It also patches the fullscreen setter so runblack.exe always runs windowed.
- [Donkey Kong Meta-Disassembly: matching Famicom and Famicom Disk System rebuilds](https://awesomerea.org/resources/fc-dk-donkey-kong-disassembly-case/index.md): Case study · Annotated 6502 disassembly of Nintendo's Donkey Kong for the Family Computer and the Famicom Disk System that reassembles with cc65 into ROM images checked by CRC against the released versions. Build targets cover the original and global revisions, the e-Reader, Animal Crossing and Wii and 3DS Virtual Console releases. CHR tile data is extracted from the user's own iNES or FDS image, and the code carries C-like control-flow comments.
- [dataeast_snddrv: High Seas Havoc sound driver disassembly](https://awesomerea.org/resources/dataeast-snddrv-case/index.md): Case study · dataeast_snddrv is a disassembly of the sound driver Data East used in High Seas Havoc, split into 68000 driver code, a Z80 DAC sample player and a frequency table, assembled with vasm. Its documentation describes the song layout of six track pointers mapped to YM2612 channels, the track command opcodes for tempo, loops, portamento, LFO, panning and DAC samples, and the 32-byte instrument record. Python scripts extract songs, instruments and samples from a ROM of a game that uses the driver.
- [Opengate: a client and server remake of Jumpgate](https://awesomerea.org/resources/opengate-jumpgate-case/index.md): Case study · Opengate remakes NetDevil's online space game Jumpgate in C++ as a game client, a game server and a state server built on OGRE, CEGUI, Bullet and Boost asio, which log in through a metaserver whose requests the project documents. Its data recreates the Jumpgate sector map with jumpgate links and faction ships such as the Tauseti Lady Kickstart, and its design notes list item prices, scale ships from NetDevil's DirectX models and include an item data set that uses data extracted from NetDevil's JOSSH database.
- [ACEmulator: Asheron's Call server emulator](https://awesomerea.org/resources/acemulator-case/index.md): Case study · ACEmulator rebuilds the Asheron's Call MMORPG server in C#, aiming to reproduce the game world as it was when the official servers closed in January 2017. The source implements the client network protocol (packets, game actions, events and messages), physics, world objects and a loader for the client's .dat files, backed by MySQL or MariaDB. Server options switch individual retail behaviours, such as door holding and fast buffing, on or off.
- [ZCure: a rewritten Blacklight: Retribution v3.02 master server](https://awesomerea.org/resources/zcure-case/index.md): Case study · ZCure rewrites the master server of Blacklight: Retribution v3.02 in .NET 8, based on the ZCAPI library decompiled from BLRCrashReporter.exe of an older build. It serves authentication, users, funds, friends, mail, inventory, loadouts, store, clans, missions, stats, matchmaking and game-server management over TCP/HTTP, with a UDP presence server. Its documentation describes the message format (begin and end markers, header, optional zlib compression, colon-delimited serialization) and the XXTEA encryption taken from the decompiled ZCAPI.
- [strkexeu: Desert Strike and Jungle Strike DOS loader disassembly and unpacker](https://awesomerea.org/resources/strkexeu-case/index.md): Case study · strkexeu documents how the DOS releases of Desert Strike: Return to the Gulf and Jungle Strike keep their game executables packed inside DAT files behind a small loader EXE. It contains a Turbo Assembler disassembly of the original DESERT.EXE/JUNGLE.EXE loader, with macros for each game and an optional CD check, and a single-file C unpacker that extracts the game EXEs. A technical note specifies the RLE and Huffman-forest compression.
- [2ooM: decoding Master of Orion II's LBX data for a remake](https://awesomerea.org/resources/2oom-master-of-orion-ii-case/index.md): Case study · 2ooM works toward a remake of Master of Orion II that runs on the original game's data files. Its liblbx library and the lbxtool and lbximg tools list and extract LBX archives and decode the game's multi-frame 256-colour LBX images to PNG, applying base palettes from fonts.lbx and override palettes for player colours, with an md5-based regression test against the original archives. Notes record the music format and map stream.lbx and streamhd.lbx entries to named tracks, and the engine repository holds a plugin-based skeleton with a virtual file system and SDL and FFmpeg modules.
- [FreeSci: a QuakeC reimplementation of Scientist Hunt](https://awesomerea.org/resources/freesci-scientist-hunt-case/index.md): Case study · FreeSci reimplements Scientist Hunt, a Half-Life multiplayer mod about containing rapidly multiplying scientists, as a QuakeC game for FreeHL and the Nuclide SDK. The source covers client HUD and team menus, server rules for the hunt, stealth, slaughter, madness, invasion and fear modes, scientist monster behaviour, spawn-data parsing, player movement and entity definitions for the mod's weapons.
- [FreeSynd: Syndicate engine reimplementation](https://awesomerea.org/resources/freesynd-case/index.md): Case study · FreeSynd reimplements the engine for Bullfrog's Syndicate using the original game's data files. Its source covers missions, rendering, sound and gameplay; the changelog documents work on vehicle pathfinding and mission inspection. The project runs on Windows, Linux and Mac.
- [The Last Ninja Remix: rebuilding the 1990 Amiga game in C++](https://awesomerea.org/resources/last-ninja-remix-case/index.md): Case study · Rebuilds the 1990 Amiga version of System 3's The Last Ninja Remix in C++, loading game data from the user's ADF disk images of the original. The source includes an ADF disk reader, actor, enemy, room, level and HUD code, and keeps disassembly labels such as sub_46A2 and word_14D6 for the routines and variables it reproduces. The first level is completable.
- [Sarien: a portable reimplementation of Sierra's AGI interpreter](https://awesomerea.org/resources/sarien-agi-interpreter-case/index.md): Case study · Sarien reimplements Sierra On-Line's Adventure Game Interpreter (AGI) in C so that AGI games such as Leisure Suit Larry, King's Quest II and Mixed-Up Mother Goose run across many platforms. It executes the compiled Logic bytecode and handles AGI graphic, text and sound resources, including Amiga and Apple IIgs versions and AGDS games, and adds extras such as a debugger console, picture and dictionary viewers and three-channel PCM sound. The Hacker's Guide documents the interpreter's architecture, drivers, graphics and sound; the project later merged into ScummVM.
- [soniccdrespinned: a cross-platform Sonic CD port built on the decompiled code](https://awesomerea.org/resources/soniccdrespinned-case/index.md): Case study · soniccdrespinned is a cross-platform port of Sonic CD that runs the decompiled stage, special-stage, time-warp and title-screen code on a newly written platform layer. That layer decompresses the original SZDD-packed CMP sprite and tile bitmaps, streams ADX music from the US or Japanese AFS soundtrack, and renders through SDL 1.2 or SDL2, with PC and PSP input backends.
- [The Crystal Scrolls: a Crystal Space engine for The Elder Scrolls III: Morrowind](https://awesomerea.org/resources/crystal-scrolls-case/index.md): Case study · Reimplements the engine of The Elder Scrolls III: Morrowind on the Crystal Space 3D engine, loading the BSA and ESM files of an installed Morrowind with Tribunal and Bloodmoon. Plugins cover a BSA virtual file system, NIF mesh loading through niflib, terrain, skybox and game logic. The docs describe how NIF scene trees and animations are converted, how plugin reference IDs are remapped when several master files load, and list original Morrowind bugs with their causes, fixes and status in the engine.
- [shadowheartsdecompilation: Shadow Hearts PS2 runtime classes decompiled to C++](https://awesomerea.org/resources/shadow-hearts-decompilation-case/index.md): Case study · shadowheartsdecompilation reconstructs C++ source for the core runtime classes of the PS2 game Shadow Hearts. It covers CThread, CTimer, CPoller, CPolling, CPolObj, CDrawObj, CDrawPolling, CDraw, CApp, CPause, FVector and Matrix, with each method annotated with its address in the original executable and written against Emotion Engine kernel calls and hardware timer registers.
- [SMBDIS.ASM: a comprehensive Super Mario Bros. disassembly](https://awesomerea.org/resources/smbdis-super-mario-bros-disassembly-case/index.md): Case study · SMBDIS.ASM reconstructs the NES game Super Mario Bros. as a single commented 6502 assembly file of about 16,000 lines. It names the PPU, APU and joypad registers and the game RAM variables, comments routines such as the sound engine, player movement and enemy handling, and lays out the metatile graphics table, level, enemy object, area object and music data; it assembles with x816 once the user supplies the character ROM data and an iNES header.
- [skcollectioncport: Sonic & Knuckles Collection rebuilt in C](https://awesomerea.org/resources/skcollectioncport-case/index.md): Case study · skcollectioncport reconstructs the Windows game Sonic & Knuckles Collection as C and C++ source. It covers player and character objects, per-zone objects, the game, opening and stage-select modes, save data, collision and scrolling, map and sprite-pattern tables, and a Win32 front end whose functions are decompiled from the PC executable by address, including the software VDP renderer, sound, registry and controller handling.
- [Donkey Kong 64: matching N64 decompilation](https://awesomerea.org/resources/dk64-decomp-case/index.md): Case study · A matching decompilation of the US release of Donkey Kong 64 for the Nintendo 64, rebuilding the ROM from C source organised by the boot segment, global code and overlays named arcade, jetpac, bonus, boss, menu, minecart, multiplayer, race and critter. The build splits the user's own ROM, compiles with IDO 5.3 and 7.1 compiler builds kept in ido/, and a verify target compares the rebuilt ROM with the original; objdiff and asm-differ support function-level comparison. The progress badge reports 4096 of 4502 functions.
- [TurokEX: rebuilding PC Turok on the Kex engine](https://awesomerea.org/resources/turokex-case/index.md): Case study · TurokEX reimplements the PC version of Turok on the Kex engine, with the game's actors, enemy AI, weapons, pickups, areas and HUD written as AngelScript classes. Its KPFGen converter reads the original CARTFILE.DAT and Turok.exe and packs their textures, fonts, sounds, models, levels and particle effects into a game.kpf archive. The engine side covers OpenGL rendering, collision and physics, OpenAL sound, a console, ENet networking and an SDL2 platform layer.
- [RenderDoc MCP](https://awesomerea.org/resources/renderdoc-mcp/index.md): Integration · Expose existing RenderDoc captures to an agent for bounded frame, pipeline, resource, and shader inspection.