# Reverse-engineering case studies · Page 15

> Page 15 of 21, cases 2,801–3,000. 4,025 case studies from 5,191 curated resources, with documented reconstruction methods, scope, and original evidence.

- HTML: <https://awesomerea.org/cases/page/15/>
- 简体中文: <https://awesomerea.org/zh/cases/page/15/index.md>

## Games (108)

- [PTD2 Server: rebuilding Pokémon Tower Defense 2 services](https://awesomerea.org/resources/ptd2-server-case/index.md): Case study · PTD2 Server reconstructs online services for the Flash game Pokémon Tower Defense 2 from analysis of its original SWF. Its PHP endpoints and save codecs support story, gym, one-on-one and trainer-versus modes, with MySQL-backed saves.
- [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.
- [QuestEditorRe: rebuilding the Alien Shooter quest editor](https://awesomerea.org/resources/questeditorre-case/index.md): Case study · QuestEditorRe rebuilds the original QuestEditor as a standalone Windows application and a Win32 DLL compatible with map editors for Alien Shooter 2 and related games. Its C++ implementation edits levels.cfg, levels.db and mission.txt while preserving unknown fields and unchanged bytes where possible, and supports quest links, properties and backups.
- [RA3Bar-RA3QuickLoader: a replacement Red Alert 3 launcher](https://awesomerea.org/resources/ra3bar-ra3quickloader-case/index.md): Case study · RA3Bar-RA3QuickLoader replaces the Red Alert 3 RA3.exe launcher with a Win32 program that starts the game without waiting for the original launcher’s defunct news-server request. It also adds a control center for launch arguments and mods, plus a replay browser that reads match details and repairs some crash-damaged replays.
- [Rampage Arcade: Z80 disassembly and graphics decoding](https://awesomerea.org/resources/rampage-arcade-disassembly-case/index.md): Case study · Rampage Arcade studies the Z80 program ROM of the 1986 MCR-3 arcade game, covering startup, input, sound, sprites, level decoding and hardware interaction. Python scripts and a batch file convert graphics from user-supplied ROMs into images.
- [rd-131655: reconstructing an unreleased Minecraft cave test](https://awesomerea.org/resources/rd-131655-minecraft-cave-test-case/index.md): Case study · rd-131655 recreates an unreleased pre-classic Minecraft cave test from its first public video and contemporary IRC logs. The Java implementation includes cave generation and 8×8×8 chunks, and the project provides a Gradle run task.
- [RECAR: rebuilding the RACER Chrome Experiment server](https://awesomerea.org/resources/recar-racer-server-case/index.md): Case study · RECAR rebuilds the server for the RACER Chrome Experiment game. Its Node.js code provides HTTPS and WebSocket services, with instructions for connecting a separately downloaded official client to the replacement server.
- [recherno: investigating Chernobyl: The Legacy Continues in a custom virtual machine](https://awesomerea.org/resources/recherno-chernobyl-case/index.md): Case study · recherno investigates Chernobyl: The Legacy Continues by running its original Fortran/Win32 engine inside a custom virtual machine. It uses Unicorn to execute the engine and Capstone for debugging. Engine API reconstruction and a Qt GUI for controlling game functions are in progress, with removal of the original binary blobs planned later.
- [Redneck Rampage: source reconstruction for two games](https://awesomerea.org/resources/redneck-rampage-reconstruction-case/index.md): Case study · Redneck-Rampage-RE reconstructs source code for Redneck Rampage and Redneck Rampage Rides Again. The repository contains C and assembly game and engine files and identifies Watcom 10.5 as the build compiler.
- [reEgg: an Egg, Inc. server emulator for version 1.12.13](https://awesomerea.org/resources/reegg-case/index.md): Case study · reEgg reconstructs part of the server behavior used by Egg, Inc. mobile game version 1.12.13 in Python. Developed alongside research into the game's protobuf API, it provides responses for selected first-contact, calendar, contract and event functions while its roadmap lists unfinished services.
- [ReGameDLL_CS: reconstructing the Counter-Strike server GameDLL](https://awesomerea.org/resources/regamedll-cs-case/index.md): Case study · ReGameDLL_CS reconstructs the Counter-Strike server GameDLL from the original HLDS Linux library using its embedded DWARF debug information. The replacement mp.dll or cs.so supports Counter-Strike 1.6 and Condition Zero and adds an extended API and gameplay settings.
- [ReHLDS: reconstructing the Half-Life dedicated server](https://awesomerea.org/resources/rehlds-hlds-case/index.md): Case study · ReHLDS reconstructs the Half-Life dedicated server from DWARF debug information embedded in the Linux HLDS engine_i486.so for builds 6152/6153. Its replacement engine fixes reported defects and provides an extended API for mods and plugins.
- [ReJet: running Jet Set Radio Future's Xbox code on Windows](https://awesomerea.org/resources/rejet-case/index.md): Case study · ReJet runs the European Xbox release of Jet Set Radio Future on Windows from the user's own disc image or extracted files. It loads the game's original x86 code and replaces Xbox graphics, sound and controller interfaces with PC implementations, adding configurable display options.
- [Rerun: rebuilding the Sonic Runners server](https://awesomerea.org/resources/rerun-server-case/index.md): Case study · Rerun rebuilds the Sonic Runners server in C# and ASP.NET Core using earlier research and the Outrun server as a basis. Its source includes login, game, store, leaderboard, and player controllers, while the author says the emulator cannot yet reach the game's main menu and its database setup remains incomplete.
- [RestoRoom: researching a Rec Room server reconstruction](https://awesomerea.org/resources/restoroom-case/index.md): Case study · RestoRoom investigates Rec Room's client-to-server behavior as groundwork for a replacement server. Its current findings list API endpoints and documented rec.net subdomains, with a packet capture in the repository; account, room and relay services are still planned.
- [retruxx: reverse-engineered Hard Truck Apocalypse](https://awesomerea.org/resources/retruxx/index.md): Case study · retruxx is a reverse-engineered Hard Truck Apocalypse project that builds the game executable and separate renderer, input, and sound DLLs. Its 32-bit build matches the original game's memory layouts.
- [Reverse Engineering Scorcher: extracting its resource archive and images](https://awesomerea.org/resources/reverse-engineering-scorcher-case/index.md): Case study · Reverse Engineering Scorcher investigates the 1996 game's asset formats through a Python extractor. The script opens TAGDEN.BIN, extracts its resources and converts R0V images to PNG; the format inventory identifies additional files, including WL3 models and HMP heightmaps, that remain undecoded.
- [Rex: SkoolKit disassembly of both ZX Spectrum game sides](https://awesomerea.org/resources/skrex-case/index.md): Case study · skRex presents disassemblies of both sides of the ZX Spectrum game Rex. The repository stores Side A and Side B SkoolKit source and reference files, and documents rendering the development version to HTML with skool2html.py.
- [Rise of the Robots: a USA SNES disassembly](https://awesomerea.org/resources/rise-of-the-robots-snes-disassembly-case/index.md): Case study · The Rise of the Robots project disassembles the USA SNES release into assembly, ROM maps and extraction scripts. It uses the author's SNES ROM framework and extracts required assets from a user-supplied headerless ROM.
- [rlapi: reconstructing Rocket League’s internal APIs](https://awesomerea.org/resources/rlapi-rocket-league-case/index.md): Case study · rlapi reconstructs Rocket League’s internal HTTP and WebSocket APIs and supplies a Go SDK for them. The documentation maps authentication, custom WebSocket messages, PsySig HMAC signatures, and selected endpoints. Bundled Frida hooks and a local proxy capture traffic, while a PE scanner extracts build information from the game executable.
- [RO3Emu: reconstructing a Ragnarok Online 3 server](https://awesomerea.org/resources/ro3emu-server-case/index.md): Case study · RO3Emu reconstructs a server for the Ragnarok Online 3: Genesis game client. Its C# and .NET 10 code implements multiplayer systems and client-facing message routes, while research notes document observed client behavior and mark uncertain behavior as guesses. The launcher can find an existing game installation or download the game from its update servers.
- [RS Mod: RuneScape server-mechanics reconstruction](https://awesomerea.org/resources/rsmod-runescape-case/index.md): Case study · RS Mod reconstructs RuneScape game-server behavior in Kotlin, with the goal of matching the original mechanics. Its documentation recommends RSProx to inspect client-server packets while developing and checking those mechanics, and the repository contains server, cache and gameplay modules.
- [rsc-server: reconstructing a RuneScape Classic server](https://awesomerea.org/resources/rsc-server-runescape-classic-case/index.md): Case study · rsc-server reconstructs a RuneScape Classic server for the web-based rsc-client and Java mudclient204. Its Node.js implementation handles game packets over TCP or WebSockets, persists world data through rsc-data-server and adds quests, skills and interactions through plugins. The README also describes a browser worker mode.
- [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.
- [rustify-doom: reconstructing Doom in Rust from a stripped binary](https://awesomerea.org/resources/rustify-doom-case/index.md): Case study · rustify-doom reconstructs the Doom engine in Rust from a stripped doomgeneric binary using Rustify. Its source covers game systems, rendering and SDL integration, and its compatibility report compares replay scenarios and recovered requirements against the original build with Freedoom data.
- [samp-client-re: a partial SA-MP client reconstruction](https://awesomerea.org/resources/samp-client-rea-partial-reconstruction-case/index.md): Case study · A documented REA/Ghidra investigation maps SA-MP 0.3.DL-R1 client subsystems to a new C++ DLL, loader and smoke-test executable. The result is an architectural reconstruction with unresolved network and graphics behavior; retail-client compatibility remains unverified.
- [Sapphire: a reconstructed FINAL FANTASY XIV 3.3 server](https://awesomerea.org/resources/sapphire-ffxiv-server-case/index.md): Case study · Sapphire reconstructs a FINAL FANTASY XIV 3.3 game server in C++, with authentication, world configuration and game data. Its development guidance calls for testing behavior against the retail game; the author describes the implementation as incomplete and insecure.
- [Sargon III: recovering move order and its opening-library encoding](https://awesomerea.org/resources/sargon-iii-disassembly-case/index.md): Case study · Studies the Apple II version of Sargon III through a partially commented disassembly, focusing on its move generator and opening-library encoding. Two C utilities help decode and rebuild openings whose one-byte moves index the generator's move order.
- [SC2k-docs: mapping SimCity 2000 files and simulation](https://awesomerea.org/resources/sc2k-docs-case/index.md): Case study · SC2k-docs maps SimCity 2000 file formats and simulation behavior, chiefly for the Windows 95 Special Edition. Its specifications cover .sc2 saves, archives, sprite and text data, and systems such as power, water and traffic.
- [scvk: replacing SimCity 4's renderer with Vulkan](https://awesomerea.org/resources/scvk-case/index.md): Case study · scvk reconstructs SimCity 4's renderer interface as a native Vulkan DLL loaded through the game's GZCOM plugin system. It claims existing renderer class IDs and emulates the cIGZGDriver fixed-function API with pipeline state and shaders for terrain, buildings, lighting, textures and interface drawing.
- [Secret of Evermore: reconstructing ROM formats and game assets](https://awesomerea.org/resources/evermore-re-case/index.md): Case study · Secret of Evermore: reverse engineering documents the Europe/PAL game's ROM layout, compression, maps, sprites, text, scripts and audio. Python extractors use a user-supplied ROM; Mesen2 scripts capture game-rendered results, and Ghidra labels support routine analysis. A pygame viewer displays extracted maps and sprites.
- [Sengoku Basara 4 Sumeragi: rehosting the PS4 game on Windows](https://awesomerea.org/resources/basara-4-sumeragi-native-pc-case/index.md): Case study · Sengoku Basara 4 Sumeragi Native PC provides a Windows runtime for a user-supplied PS4 game folder. It links the game's executable and system modules and adapts shadPS4 graphics components to a Vulkan presentation layer, with launcher controls for display and input.
- [SF1RE: reconstructing the Shining Force analysis database](https://awesomerea.org/resources/sf1re-case/index.md): Case study · SF1RE uses game-specific IDC scripts to rebuild an IDA Pro analysis database for the USA release of Shining Force. Its workflow imports labels and parsing rules, formats the ROM's code and data, and exports a split disassembly for the separate SF1DISASM project to rebuild and compare.
- [sh3-evil-effect: reconstructing Silent Hill 3's Another World Evil effect](https://awesomerea.org/resources/sh3-evil-effect-case/index.md): Case study · sh3-evil-effect recreates the Another World Evil procedural texturing effect from Silent Hill 3. Its implementation uses graphics libraries including GLEW, GLFW, GLM and FreeImage.
- [Shin Megami Tensei: Japanese 1.0 disassembly](https://awesomerea.org/resources/smt1-j10-disasm/index.md): Case study · This is an incomplete disassembly of Shin Megami Tensei for the Super Nintendo, Japanese version 1.0. Each line starts with an address label of the form #_AAAAAA, where AAAAAA is the 24-bit ROM address. One instruction is written per line. MVN and MVP are written with a macro so the standard form assembles. The README says unused code from overwritten builds remains in the ROM.
- [Shittim Server: reconstructing Blue Archive services](https://awesomerea.org/resources/shittim-server-case/index.md): Case study · Shittim Server reconstructs services used by the Steam release of Blue Archive as a local C# ASP.NET Core server backed by SQLite. It redirects and patches the installed client to connect locally, and its Frida capture tool inspects plaintext responses at the client's decryption boundary to inform protocol implementation.
- [Silkroad Online: reconstructing SR_GameServer](https://awesomerea.org/resources/vsro-server-decomp-case/index.md): Case study · Silkroad Online's SR_GameServer is being reconstructed in C++ from research into native server behavior. The repository includes game and server logic, supporting libraries, evidence notes and focused regression tests. Its documented reference is a v1.188 executable, and the implementation remains incomplete.
- [SimCity SNES Disassembly: US ROM disassembly](https://awesomerea.org/resources/simcity-snes-disassembly-case/index.md): Case study · SimCity SNES Disassembly provides assembly sources for the US Super Nintendo release of SimCity. Its asset-extraction script uses a clean, headerless copy of the supported ROM supplied by the user, and the project uses version 1.0.1 of the author's SNES ROM framework.
- [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.
- [sm: a frame-compared Super Metroid reconstruction](https://awesomerea.org/resources/snesrev-sm-case/index.md): Case study · sm reconstructs Super Metroid as a C program and runs it alongside a user-provided ROM for frame-by-frame comparison. It saves a snapshot when it detects a mismatch.
- [sm_disassembly: a relocatable Super Metroid disassembly](https://awesomerea.org/resources/super-metroid-disassembly-case/index.md): Case study · sm_disassembly provides a relocatable assembly disassembly of the SNES game Super Metroid, organized into bank files and based on earlier bank logs. Build scripts extract assets from the user's original NTSC ROM and assemble the source with asar 1.81.
- [SmashUpDerby: reconstructing the Smash Up Derby player](https://awesomerea.org/resources/smashupderby-case/index.md): Case study · SmashUpDerby reconstructs the Smash Up Derby player in C++. The source creates a Windows window, reads player settings from the registry, loads Virtools plugins and initializes a render context.
- [snatcher-port: reconstructing Sega CD Snatcher for desktop](https://awesomerea.org/resources/snatcher-port-case/index.md): Case study · snatcher-port investigates the Sega CD version of Snatcher and builds a desktop Mega CD runtime around code and data supplied from the user's disc. Its findings describe the main and sub CPU roles, while the engine implements game-needed hardware and BIOS services and offers a build-time 68000 translation path.
- [Soldier of Fortune: annotated ZX Spectrum disassembly](https://awesomerea.org/resources/soldier-of-fortune-zx-disassembly-case/index.md): Case study · zx-sof-reveng documents the ZX Spectrum game Soldier of Fortune through a commented Z80 disassembly. The notes map loader behavior, memory regions, graphics data and game-loop calls, including uncertain interpretations marked in the annotations.
- [Sonic the Hedgehog: a generated Sega Master System disassembly](https://awesomerea.org/resources/sonic-master-system-disassembly-case/index.md): Case study · Sonic the Hedgehog disassembles the Sega Master System game from a user-supplied ROM. A Python unpacker and annotation file generate Z80 assembly, which WLA-DX assembles into an output ROM; the repository also includes ROM asset-location and level-viewing tools.
- [SonsOfSparta-PS5 Native: God of War running on Windows](https://awesomerea.org/resources/sons-of-sparta-ps5-native-case/index.md): Case study · SonsOfSparta-PS5 Native runs the PS5 release of God of War: Sons of Sparta on Windows by executing its x86-64 game code through a compatibility layer. The layer reimplements PS5 system libraries and GPU commands, while a first-start process prepares the user’s decrypted game files. The author reports play from the logo into gameplay and identifies later areas as untested.
- [Speedos: a black-box replica of the Spe_ed game model](https://awesomerea.org/resources/speedos-case/index.md): Case study · Speedos reconstructs the Spe_ed game rules as a Mesa model with interfaces shared by the original game. Multi-Minimax agents use the model to simulate future actions, with a Voronoi heuristic for evaluation and iterative deepening for search. The repository includes recorded games from the original for testing the model.
- [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.
- [Splitgate Backend: a local replacement for game service endpoints](https://awesomerea.org/resources/splitgate-backend-case/index.md): Case study · Splitgate Backend implements local TypeScript service routes for the game's backend and redirects Splitgate's AccelByte requests to them through Fiddler or mitmproxy. The repository includes authentication, lobby, profile and WebSocket routes. Its data workflow captures HTTP calls for item and section information.
- [SR1 Creator: rebuilding the Saints Row character creator](https://awesomerea.org/resources/sr1-creator-case/index.md): Case study · SR1 Creator recreates the Saints Row (2006) character creator in a browser using meshes, morph targets, textures and tables read from the user's Saints Reborn folder. JavaScript readers handle VPP packfiles, PEG textures, character meshes and morphs; the author reports comparing geometry and camera behavior with the running game. A photo-fitting view estimates face sliders from landmarks.
- [Star Fox: a matching SNES sound-driver disassembly](https://awesomerea.org/resources/star-fox-spc-driver-case/index.md): Case study · This project disassembles the N-SPC/Kankichi-kun SNES sound-driver variant used in Star Fox and Starwing. Its assembly source separates driver code, sound-effect tables, macros and instrument patches, and the build can compare the resulting SGSOUND0.BIN with an original copy.
- [StarCombat Offline: reconstructing a discontinued game's backend](https://awesomerea.org/resources/starcombat-offline-case/index.md): Case study · StarCombat Offline reconstructs backend services for the discontinued mobile game Star Combat: Space battle Online. Original Python and Android mock servers handle its HTTP and TCP exchanges, while scripts patch a user-supplied Unity IL2CPP client for local addresses and offline behavior; Frida probes support the investigation.
- [Starquake: an annotated Z80 game disassembly](https://awesomerea.org/resources/starquake-disassembly-case/index.md): Case study · Starquake is a work-in-progress disassembly of the 1985 game, with SkoolKit files for the game and its loader. Many routines and data items remain undocumented.
- [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.
- [Summit: reconstructing a World of Warcraft 3.3.5a server](https://awesomerea.org/resources/summit-wow-server-case/index.md): Case study · Summit rebuilds a World of Warcraft 3.3.5a server in Go, with authentication, world-server and packet-handling components. Its supporting tools include a proxy for capturing authentication traffic, a packet dumper and a DBC converter; the author describes using Ghidra during development.
- [Super Mario Advance 2: a Game Boy Advance disassembly](https://awesomerea.org/resources/super-mario-advance-2-disassembly-case/index.md): Case study · Super Mario Advance 2 disassembly reconstructs the Game Boy Advance game as assembly and data source. Its Makefile uses a user-supplied baserom.gba with devkitARM and pokeruby build tools to produce a ROM whose expected SHA-1 is documented.
- [Super Mario Galaxy 2: selected gravity behavior and format reconstruction](https://awesomerea.org/resources/smg2-reverse-engineering-case/index.md): Case study · Super Mario Galaxy 2: selected gravity behavior and format reconstruction implements host-side C++ versions of selected CubeGravity, PlanetGravity and PointGravity operations. It provides bounds-checked readers for Yaz0, RARC, U8, BCSV/JMap, Wii FST and selected J3D metadata, with synthetic-input tests.
- [Super Punch-Out!!: a USA SNES disassembly](https://awesomerea.org/resources/super-punch-out-disassembly-case/index.md): Case study · Super Punch-Out!! is a disassembly of the USA SNES game, organized as assembly source with ROM maps and extraction scripts. It uses the author's SNES ROM framework and requires a clean, headerless user ROM for asset extraction.
- [Super Tennis Disassembly: matching Sega Master System assembly](https://awesomerea.org/resources/super-tennis-sms-case/index.md): Case study · Super Tennis Disassembly reconstructs the Sega Master System game Super Tennis in WLA DX assembly. It targets the Japanese revision 0 and USA/European revision 1 and provides a Docker-based assembly process that emits ROM and debugger symbol files.
- [swemu: reconstructing a SoulWorker server from client packet readers](https://awesomerea.org/resources/swemu-case/index.md): Case study · swemu reconstructs a server for the SoulWorker GB/Steam 2.3.34.7 game client in Rust. Its research log reports REA/Ghidra decompilation and Unicorn execution of client routines to recover packet layouts, encryption, and exchanges used for login, characters, world entry, and early combat.
- [SWGEmu Core3: reconstructing the classic Star Wars Galaxies server](https://awesomerea.org/resources/swgemu-core3-case/index.md): Case study · SWGEmu Core3 reconstructs the server for the pre-Combat Upgrade era of Star Wars Galaxies. Its authors describe reverse-engineering the original behavior from scratch and implementing a new engine and game logic; the repository contains C++ server code and extensive Lua gameplay scripts.
- [Tales of Eternia: structural analysis of the Japanese PlayStation disc](https://awesomerea.org/resources/ps1-talesofeternia-doc-case/index.md): Case study · Tales of Eternia is a structural investigation of disc 1 of the Japanese PlayStation release SLPS-03050. Python tools and committed reports examine ISO 9660 and CD-XA layout, the PS-EXE, LZSS blocks, archive indexes, TIM graphics, audio, video and Shift-JIS text.
- [TamagoC: a Tamagotchi implementation from observation](https://awesomerea.org/resources/tamagoc-case/index.md): Case study · TamagoC implements Tamagotchi-style virtual-pet behaviour from observation. Its C core models feeding, health, happiness, discipline, waste and a play outcome counter.
- [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.
- [Tekken 3 Recompiled: hybrid recompilation and native port research](https://awesomerea.org/resources/tekken3recompiled-case/index.md): Case study · Tekken 3 Recompiled combines a playable hybrid recompilation of the US PlayStation game with an early native PC port. Its tools inspect local BNS, ARC, TIM, VAB, model, XA, and STR data, while the native slice currently uses procedural stage and fighter stand-ins.
- [TF15-Client: rebuilding the Team Fortress Classic client](https://awesomerea.org/resources/tf15-client-case/index.md): Case study · TF15-Client rebuilds the Team Fortress Classic client in C++ for Xash3D FWGS. It provides Android, Linux and Windows builds and uses the valve and tfc folders from a Steam copy of the game.
- [TFM2DB Field Notes: mapping Teamfight Manager 2 database records](https://awesomerea.org/resources/tfm2db-field-notes-case/index.md): Case study · TFM2DB Field Notes maps selected Teamfight Manager 2 database records and provides template-based CSV roundtrip tools. The notes cover the TFM2 gzip wrapper, CRC32, record kinds, dynamic player offsets and fixed-width fields that the importer can patch in a matching database.
- [TH04: recover a DOS bullet-ring helper](https://awesomerea.org/resources/rea-th04-case/index.md): Case study · Inspect a 16-bit PC-98 DOS helper and relate its angle calculation to a pinned reconstruction and historical compiler checks.
- [The Hobbit: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/hobbit-spectrum-disassembly-case/index.md): Case study · The Hobbit documents a disassembly of the ZX Spectrum game in SkoolKit source files. The repository includes annotations and scripts that generate browsable hexadecimal or decimal disassembly pages.
- [The Last of Us Remastered: running the PS4 game on Windows](https://awesomerea.org/resources/tlou-remastered-pc/index.md): Case study · This port runs the PlayStation 4 game The Last of Us Remastered, product CUSA00552 with update 1.11, on Windows. The game's own x86-64 code runs on the PC. A runtime supplies the PS4 system libraries, and a Vulkan renderer from the shadPS4 video core executes the GPU work. TLOU Launcher.exe selects the dumped game folder. A source run places CUSA00552 beside the repository and the update as CUSA00552-patch. The MSYS2 CLANG64 build uses gow3_pc/build.sh after the Vulkan, SDL3, and FFmpeg packages are installed.
- [The Last Story: mapping the LastWorld engine and game formats](https://awesomerea.org/resources/the-last-story-re-case/index.md): Case study · The Last Story research documents the Wii game's LastWorld engine and provides parsers and extractors for archives, text, textures, audio, models and scenes. Its executable analysis uses a custom DOL loader and Gekko SLEIGH language to examine main.dol, including the archive path hash and engine structures. The author reports format coverage and validation against game data.
- [The Legend of Zelda: a work-in-progress NES disassembly](https://awesomerea.org/resources/legend-of-zelda-nes-disassembly-case/index.md): Case study · zeldasource disassembles the NES release of The Legend of Zelda into banked assembly files. Its CC65 build uses an original iNES ROM supplied by the user and checks the rebuilt image against an MD5 checksum.
- [The Oregon Trail: mapping the Apple II disks, programs and data formats](https://awesomerea.org/resources/apple2-theoregontrail-doc-case/index.md): Case study · The Oregon Trail investigation maps the two disk sides of the Apple II game from their bytes. It documents the DOS 3.3 layout, sector-addressed loader, Applesoft programs, machine-language commands, saved variables, picture packing and music files, with Python readers and recorded outputs.
- [The Peacock Project: HITMAN trilogy server replacement](https://awesomerea.org/resources/peacock-hitman-server-case/index.md): Case study · The Peacock Project reconstructs online server functions for the HITMAN World of Assassination trilogy. Its TypeScript server handles game content and features, with documented challenge, progression and XP processing; the authors say it was rewritten after beginning as a LocalGhost fork.
- [The Urbz: Sims in the City: Nintendo DS ARM9 disassembly and function map](https://awesomerea.org/resources/urbz-sims-in-the-city-ds-case/index.md): Case study · urbz-re investigates the USA Nintendo DS release of The Urbz: Sims in the City through an ARM9 split, assembly listings, symbol names, and function notes. Its build script checks a user-supplied ROM and regenerates assembly with ds-decomp 0.12.1. The source tree has no matched C yet; the author reports that 280 ARM9 functions have been read.
- [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.
- [TimeSplitters: Future Perfect — native PC rebuild](https://awesomerea.org/resources/timesplitters-future-perfect-pc-rebuild-case/index.md): Case study · TimeSplitters: Future Perfect is being rebuilt as a native PC game using data imported from the user's Xbox copy. The launcher identifies the disc by the hash of default.xbe, extracts and checks game files, and manages settings and mods. The repository also contains game reconstruction code and a decompilation analysis toolchain.
- [Titanic: an osu! Bancho server reconstruction across client generations](https://awesomerea.org/resources/titanic-osu-bancho-case/index.md): Case study · Titanic reconstructs osu! server services to examine how Bancho works across stable client releases from 2007 through 2026. The repository combines a Python Bancho game server with Go score and web services, database migrations and shared client-version checks.
- [TL2BetaMiniLobby: reconstructing the Torchlight 2 beta lobby](https://awesomerea.org/resources/tl2-beta-mini-lobby-case/index.md): Case study · TL2BetaMiniLobby reconstructs the lobby service required by the May 2012 Torchlight 2 beta. Its C# server handles lobby messages so the beta client can start offline after its configured lobby host is changed to localhost; the author reports testing client version 0.20.8.1.
- [tMock-Server: reconstructing Terraria server handshakes](https://awesomerea.org/resources/tmock-server-case/index.md): Case study · tMock-Server is an unfinished C++ reimplementation of the Terraria server's initial network flow. It uses socket code and packet classes to accept connections, check protocol versions, request passwords, and assign player slots; the README records packet IDs, fields, directions, and structures informed by traffic analysis.
- [tModLoader Mobile: reconstructing selected mod behavior in Android Terraria](https://awesomerea.org/resources/tmodloader-mobile-case/index.md): Case study · tModLoader Mobile investigates selected PC Terraria mod behavior inside Android Terraria through an independently written managed compatibility layer and native bridges. The prototype includes item and time demonstrations, a respawn adapter, texture experiments and research notes; the author reports bounded test outcomes and an unresolved in-process stability issue.
- [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.
- [ToeJam & Earl: an incomplete REV 02 Genesis disassembly](https://awesomerea.org/resources/toejam-earl-disasm-case/index.md): Case study · tje-disasm investigates the REV 02 Sega Genesis release of ToeJam & Earl through assembly source, ROM tools and documented code comparisons with REV 00. Its notes examine function-level differences and possible compiler fingerprints. The project requires a user-supplied REV 02 ROM and describes the disassembly as incomplete.
- [Touhou reconstructions: an agent-driven method across three games](https://awesomerea.org/resources/rea-touhou-reconstruction-method-case/index.md): Case study · An essay published on REA’s site, with pinned evidence notes, describes one author’s agent-driven reconstructions of TH08, TH095 and TH04. It dates milestones from public commits and progress ledgers, separates exact-comparison and playable-build oracles, and documents a TH08 check that missed wrong floating-literal data. Project results remain author-reported, and REA is credited with supplying analysis evidence, not the reconstructions themselves.
- [tpp-server-emulator: a Metal Gear Solid V backend reconstruction](https://awesomerea.org/resources/tpp-server-emulator-case/index.md): Case study · tpp-server-emulator rebuilds the backend used by Metal Gear Solid V: The Phantom Pain. Its C++ server implements game command handlers and database models, while the documentation tracks command coverage and shows how Lua scripts can handle client requests. Configuration supports MySQL or SQLite3.
- [Trashman: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/trashman-disassembly-case/index.md): Case study · Trashman documents a disassembly of the ZX Spectrum game using SkoolKit. The repository contains SkoolKit source and scripts for generating browsable hexadecimal or decimal HTML listings.
- [Twin Cobra: partial Sega Genesis disassembly and scaling analysis](https://awesomerea.org/resources/twin-cobra-disassembly-case/index.md): Case study · Twin Cobra documents a partial disassembly of the Sega Genesis game through an Exodus-generated assembly listing, RAM and ROM maps, object structures and address-indexed tables. A separate analysis traces weapon damage and enemy health scaling to specific memory locations.
- [Twisted Metal (2012) — PS3 Native PC Port: research on a Windows port](https://awesomerea.org/resources/twisted-metal-2012-research/index.md): Case study · This repository collects research toward a native Windows port of the 2012 PlayStation 3 game Twisted Metal. Its public export provides host models, a synthetic Taskset probe and development tasks. Python 3.10 unit tests and a CMake 3.20 host probe exercise those components.
- [Uncharted: The Nathan Drake Collection native Windows port](https://awesomerea.org/resources/uncharted-collection-pc-port-case/index.md): Case study · Runs the PS4 Uncharted: The Nathan Drake Collection’s own x86-64 executables natively on Windows: a runtime supplies the PS4 system libraries and a shadPS4-derived Vulkan renderer executes the GPU work. The port adds a per-game launcher, resolution patches and modern upscaling, and its status table reports all three games playable with listed open issues. It is a compatibility-runtime port rather than a decompilation, and its results remain project-reported.
- [Unicorn Overlord PC: rehosting the PS4 game on Linux and Windows](https://awesomerea.org/resources/unicorn-overlord-pc-case/index.md): Case study · Unicorn Overlord PC runs the PlayStation 4 Unicorn Overlord executable on Linux and Windows through a game-specific loader and host runtime. It adjusts executable addresses, implements imported PS4 system functions and routes GPU commands through a shadPS4-derived Vulkan layer. The author reports playing through the prologue and first chapter battle, with saving and loading working.
- [uo-client: reconstructing the Ultima Online 2.0.7 client](https://awesomerea.org/resources/uo-client-case/index.md): Case study · uo-client reconstructs the Ultima Online T2A 2.0.7 client in C++, including its packet protocol, MUL asset loading and isometric display. The author describes consulting the decompiled original in IDA, recording findings in its database and comparing renderer output and protocol behavior with the original. The client targets the UO Demo shard and includes a JavaScript-driven navigation bot.
- [VerilogBoy: reconstructing Game Boy hardware in Verilog](https://awesomerea.org/resources/verilogboy-game-boy-case/index.md): Case study · VerilogBoy reconstructs a Game Boy-compatible console as Verilog RTL for the Pano Logic G1 FPGA device. Its modules implement the SM83 CPU, pixel processing, audio, DMA, and timers, while CPU notes and test results document the behavior used to guide the implementation.
- [Virtua Cop 2: investigating PC game assets](https://awesomerea.org/resources/re-virtua-cop-2-case/index.md): Case study · The Virtua Cop 2 investigation examines the 1997 PC game's asset files with parsers, ImHex patterns and a browser explorer. The explorer displays models and textures from a selected game directory and offers experimental browsing of stage maps in P_STG*.BIN files.
- [Void Client: rebuilding the Starblast.io client](https://awesomerea.org/resources/void-client-case/index.md): Case study · Void Client is an unfinished JavaScript rewrite of the Starblast.io browser game client based on study of its network protocol. Its current Node.js and browser components provide game-mode selection, server discovery, local WebSocket communication, and parsing and JSON export of some received packets.
- [War Action: re-engineering Sudden Strike Gold 1.2.1](https://awesomerea.org/resources/war-action-case/index.md): Case study · War Action reconstructs Sudden Strike Gold 1.2.1 from its original binaries as separate launcher, renderer, menu and game modules. It documents DirectDraw rendering at three screen sizes, added windowed-mode work and partial menu and gameplay progress; multiplayer remains in progress.
- [Waygate: reconstructing Elden Ring matchmaking services](https://awesomerea.org/resources/waygate-server-case/index.md): Case study · Waygate reconstructs an Elden Ring matchmaking server around the game's multiplayer protocol. Its Rust workspace includes wire serialization, message types, protocol handling and server features for summoning, invasions, player messages, bloodstains and ghosts.
- [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.
- [Wizardry IV: Apple II disk and format investigation](https://awesomerea.org/resources/apple2-wizardryiv-doc-case/index.md): Case study · An investigation of the Apple II release of Wizardry IV uses SYSTEM.RELOC to map five disk sides into a virtual volume and examines the separate sixth side. It studies the game's p-machine program, Huffman text, level maps and leftover files, with purpose-built readers and saved command output supporting the format findings.
- [WolfensteinRPG-RE: a C++ reconstruction of Wolfenstein RPG](https://awesomerea.org/resources/wolfensteinrpg-re-case/index.md): Case study · WolfensteinRPG-RE reconstructs Wolfenstein RPG in C++ for desktop builds. Its source implements gameplay, combat, rendering, and resource loading from a game package, with CMake instructions for Linux and Windows.
- [wotb-dvp: mapping WOTB DVPM and DVPD file structures](https://awesomerea.org/resources/wotb-dvp-case/index.md): Case study · wotb-dvp reconstructs the layout of WOTB DVPM files and the DVPD footer. Its specification maps DVPM metadata, file entries, LZ4 and RFC1951 compression identifiers, CRC32 fields and both footer structures.
- [WoWee: reconstructing a native World of Warcraft client](https://awesomerea.org/resources/wowee-client-case/index.md): Case study · WoWee reconstructs a native World of Warcraft client in C++ with Vulkan rendering, networking and audio. It handles Vanilla 1.12, TBC 2.4.3, WotLK 3.3.5a and Turtle WoW 1.18 through expansion-specific packet parsers and extracts assets from the user's own installation.
- [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.
- [Yoshi's Island: a SNES disassembly for two US ROM revisions](https://awesomerea.org/resources/yoshis-island-snes-disassembly-case/index.md): Case study · A disassembly of Super Mario World 2: Yoshi's Island provides SNES assembly sources and maps for the USA v1.0 and v1.1 ROMs. Its asset-extraction script uses a clean, headerless copy of a supported ROM, and the project builds on the author's SNES ROM framework.
- [Yu-Gi-Oh! Online 3: reconstructing early server exchanges and YPK extraction](https://awesomerea.org/resources/ygo3-research-case/index.md): Case study · ygo3-research reconstructs early Yu-Gi-Oh! Online 3 server exchanges and provides a YPK archive extractor. Its experimental Python server responds to observed authentication, profile, player-list and selection requests and documents packet encryption, length masking and nested data encoding. The client currently stops after player selection.
- [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.
- [zelda_gb_disassembly: Link's Awakening Game Boy disassembly](https://awesomerea.org/resources/zelda-gb-disassembly-case/index.md): Case study · zelda_gb_disassembly records an assembly disassembly of the black-and-white Game Boy version of Zelda: Link's Awakening. Its files are organized by memory bank, and its notes identify bank 0 as the starting point and main routine.
- [zkTH06: reconstructing Touhou 6 gameplay transitions](https://awesomerea.org/resources/zkth06-case/index.md): Case study · zkTH06 reconstructs selected Touhou Koumakyou v1.02h gameplay transitions for replay-driven execution in OpenVM. It compares a Linux reference with observations of the shipped Windows game, implements bounded player, bullet, enemy, and item state transitions, and records differential results and proof obligations. The author reports matching projections over specified replay prefixes.
- [ZZT Disassembly Project: documenting ZZT creature behavior](https://awesomerea.org/resources/zztasm-case/index.md): Case study · The ZZT Disassembly Project documents how creatures and other tile types behave in ZZT by disassembling ZZT.EXE. It publishes annotated assembly, pseudocode for functions and game objects, memory-layout notes, and an IDA database.

## Apps (92)

- [Aegis: trace a login-code calculation](https://awesomerea.org/resources/rea-aegis-case/index.md): Case study · An official APK investigation follows TOTP methods in Aegis and publishes artifact identities and selected Evidence.
- [Notion: trace the clipboard bridge](https://awesomerea.org/resources/rea-notion-case/index.md): Case study · Trace a packaged Electron clipboard path using REA findings and separate source inspection; the dynamic wrapper remains a stated limit.
- [PicoPrint: LX-D02 printer investigation](https://awesomerea.org/resources/picoprint-rea-investigation/index.md): Case study · The author describes REA-assisted Android investigation followed by separate Hermes decompilation to support a Windows BLE printer.
- [ReaCut: video-editor reconstruction](https://awesomerea.org/resources/reacut-reconstruction/index.md): Case study · An independent video editor whose authors document REA-assisted investigation of Jianying/CapCut behavior and project formats. The public implementation includes a local timeline, FFmpeg export and an experimental, lossy draft importer.
- [CF632BLE: a local client from scale-protocol research](https://awesomerea.org/resources/cf632ble-case/index.md): Case study · Reimplements the CF632BLE scale’s BLE protocol and body-composition calculations from research on the vendor’s Unique Health Android app. A static Web Bluetooth client receives measurements, manages device profiles and keeps its history in browser storage.
- [zee-rp: reconstructing supported Axure RP 11 document operations](https://awesomerea.org/resources/zee-rp-case/index.md): Case study · Reads and rewrites supported native Axure RP 11 documents through a binary-record codec, reference-aware cloning and constrained interaction writers. CLI and MCP interfaces expose inspected edits while keeping offline structure checks separate from native application acceptance.
- [Virtual Desktop Streamer: rehosting the platform layer on Linux](https://awesomerea.org/resources/vd-streamer-linux-case/index.md): Case study · An author-reported Claude Code and REA workflow replaces the macOS streamer’s capture, encoding, audio and input layer with Linux implementations while reusing vendor protocol libraries. The documented result targets desktop streaming and video playback, not Windows-only VR game streaming.
- [Open Claude UI: REA-informed interface reference components](https://awesomerea.org/resources/open-claude-ui-case/index.md): Case study · Publishes React components, motion helpers and design-system notes derived from the author’s reported REA investigation of Claude Desktop. It is useful as an interface-reconstruction case, with version-specific observations; a complete assistant application and backend clone remain outside the documented scope.
- [PlxNative: reconstructing a native webOS media-client interface](https://awesomerea.org/resources/plx-native-case/index.md): Case study · An unofficial Plex client built after the author investigated LG webOS native media interfaces with Ghidra and coding agents. It draws its own Rust/OpenGL interface and uses the television’s decoder, with documented host, simulator and real-device test tiers.
- [Windows Calculator: reconstructing percentage rules](https://awesomerea.org/resources/rea-calculator-percent-case/index.md): Case study · REA’s case traces the installed Windows Calculator model DLL to explain different percentage behavior for multiplication/division and other operations. An analyst-selected function is interpreted against public Microsoft source and demonstrated with fixed browser examples.
- [Feishu: an author-reported isolated second app instance](https://awesomerea.org/resources/feishu-dual-instance-case/index.md): Case study · The author reports using Codex and REA analysis to adapt a separate macOS Feishu copy with its own application identity, data directory and single-instance lock. The account describes local signing and separation checks while retaining the original app unchanged.
- [PhotoCraft: editor workflow reconstruction and PSD round-trip boundaries](https://awesomerea.org/resources/photocraft-case/index.md): Case study · The authors describe this Rust image editor as a clean-room reimplementation of Photoshop-style workflows. Its document engine, UI and automation interfaces share editing commands, while the source distinguishes PSD editor round trips from byte preservation in the standalone file codec.
- [WordCraft: document workflow reconstruction and bounded DOCX compatibility](https://awesomerea.org/resources/wordcraft-case/index.md): Case study · The authors describe WordCraft as a clean-room Rust implementation of familiar Microsoft Word workflows. It provides its own document model, layout engine and DOCX reader/writer, with desktop and browser interfaces; source tests exercise selected editing and file-preservation behavior.
- [GridCraft: spreadsheet workflow reconstruction and XLSX round-trip limits](https://awesomerea.org/resources/gridcraft-case/index.md): Case study · The authors describe GridCraft as a clean-room Rust implementation of Excel-style spreadsheet workflows. A workbook model, formula parser and dependency-driven recalculation are connected to XLSX I/O and a shared editing-command layer for desktop, browser and automation interfaces.
- [DeckCraft: presentation workflow reconstruction and bounded PPTX interchange](https://awesomerea.org/resources/deckcraft-case/index.md): Case study · The authors describe DeckCraft as a clean-room Rust implementation of PowerPoint-style presentation workflows. Its slide model, rendering and command layers support desktop/browser editing and PPTX interchange; reviewed source tests check constructed decks and selected preserved package parts.
- [Ledger Reborn: an independent accounting app informed by QuickBooks study](https://awesomerea.org/resources/ledger-reborn-accounting-case/index.md): Case study · The maintainer reports using REA and Ghidra to study selected QuickBooks Desktop for Mac behavior, then independently implements a local accounting application. Its Python/SQLite engine persists double-entry journals, invoices, inventory and payments, while public synthetic fixtures test bounded accounting and rollback behavior.
- [Pocket Tasks: reconstructing task state and persistence](https://awesomerea.org/resources/pocket-tasks-reconstruction-case/index.md): Case study · A teaching case with disclosed prior source access carries a REA-assisted investigation of a small command-line app into a separate Node implementation. It preserves observed task editing, persistence and selection behavior, then compares scoped outputs against fixed expectations and captured reference sessions.
- [Open Scrantic: reconstructing the Johnny Castaway screensaver engine](https://awesomerea.org/resources/open-scrantic-screensaver-case/index.md): Case study · Reconstructs the Johnny Castaway screensaver engine in Rust, with author-disclosed REA and Claude Code use. It reads original files to run recovered animation scripts and calendar-based story state on modern desktops; documented deviations and limited tests stop short of complete behavioral equivalence.
- [Screen Studio: an author-reported REA study of auto-zoom rules](https://awesomerea.org/resources/screen-studio-auto-zoom-case/index.md): Case study · The author reports using REA to map Screen Studio’s Electron package, reading six auto-zoom and cursor rules from its obfuscated code with Claude Code’s help, and having Claude Code write an independent recorder and renderer from those rules. The article describes the commands, evidence, a cursor-alignment check and the clone’s gaps; neither the clone nor the decoded code is published.
- [Claude Code background lab: an REA-informed reimplementation of a desktop animation](https://awesomerea.org/resources/claude-code-background-lab-case/index.md): Case study · Reimplements the glyph-wind background of the Claude desktop app’s Claude Code New session view as an offline WebGL2 page with a 38-slider control panel. The author reports a static REA investigation of the desktop shell and its remote web bundle, followed by a newly written renderer that reuses recovered timing and layout values. It shares the original’s visual vocabulary and interaction model.
- [Notes CSV export: an author-reported REA check of reconstruction oracles](https://awesomerea.org/resources/rea-notes-csv-oracle-mutation-case/index.md): Case study · A Chinese article breaks three versions of a Python CSV exporter that reproduces the Notes teaching app shipped with REA. It shows that a simple export-and-read-back test passes all three, while byte comparisons against the official JavaScript formatter on 215 fixed inputs catch each one. The author also connects REA 6.5.0 over MCP, reruns its JavaScript analysis and checks that an edited evidence record is rejected on import; the article studies acceptance checks.
- [Sofa TV Browser: a remote-friendly BrowseHere alternative](https://awesomerea.org/resources/sofa-tv-browser-browsehere-case/index.md): Case study · An Android TV browser follows BrowseHere's remote-control interaction design with its own implementation. The author reports using REA to inspect the BrowseHere APK and Claude to build Sofa; the repository documents APK releases, screenshots and current feature limits.
- [FastView-REA: a Rust reconstruction of Fast View 5](https://awesomerea.org/resources/fastview-rea-relay-analysis-rebuild-case/index.md): Case study · A Rust desktop reconstruction of Mekhanotronika Fast View 5 uses REA and Ghidra research to reproduce oscillogram analysis and relay-characteristic views. The project publishes behavioral specifications, factual indexes, screenshots and cross-platform builds, with explicit format and visual-fidelity gaps.
- [DiskLens: a WinDirStat-derived disk usage analyzer](https://awesomerea.org/resources/disklens-windirstat-rea-case/index.md): Case study · A Rust/Tauri disk analyzer combines REA/Ghidra investigation of WinDirStat 2.5.0 with source-code ports of its treemap and color handling. Its documentation distinguishes binary-confirmed findings from source-derived algorithms and leaves several file actions and Windows integrations untested.
- [SoundConnect Desktop: a Windows client reusing a reviewed headset engine](https://awesomerea.org/resources/soundconnect-desktop-rea-engine-case/index.md): Case study · A Windows Sony-headphone client adopts existing libmdr/libmdr-bt engine DLLs after a documented REA-assisted binary inventory and source review. The desktop interface is modeled on Sound Connect, while protocol implementation and device support are inherited.
- [rec-rs: an OBS-informed Rust recorder for macOS](https://awesomerea.org/resources/rec-rs-obs-rea-recorder-case/index.md): Case study · A macOS recorder is informed by OBS architecture research using REA package inspection, platform tools and public source references. It offers screen/camera recording and streaming with a deliberately smaller scene/source feature set; the research notes record unavailable native-analysis providers.
- [Sketch: a Paper-shell-informed native Rust canvas](https://awesomerea.org/resources/sketch-paper-rea-canvas-case/index.md): Case study · A Rust canvas models Paper-like editing behavior after REA investigation of the Paper Desktop shell. The hosted editor was not recovered: research separates observed shell integration from inferred editor features, and the new geometric document model differs from Paper HTML/CSS.
- [CADCraft: a clean-room CAD and drafting application in Rust](https://awesomerea.org/resources/cadcraft-case/index.md): Case study · The authors describe CADCraft as an open-source, clean-room computer-aided design and drafting application built in pure Rust. The README documents a 2D/3D CAD workflow with a command line, object snaps, layers, dimensions, hatches, blocks and DXF, and calls the project early development.
- [DesignCraft: a clean-room page layout and publishing studio in Rust](https://awesomerea.org/resources/designcraft-case/index.md): Case study · The authors describe DesignCraft as an open-source, clean-room page layout and desktop publishing studio built in pure Rust. The README documents native and WebAssembly builds and calls the project pre-alpha.
- [EffectCraft: a clean-room motion graphics and compositing studio in Rust](https://awesomerea.org/resources/effectcraft-case/index.md): Case study · The authors describe EffectCraft as an open-source, clean-room motion graphics and visual effects studio built in pure Rust. The README documents native and WebAssembly builds and estimates about 91% of its tracked features.
- [FigCraft: a clean-room interface design and prototyping tool in Rust](https://awesomerea.org/resources/figcraft-case/index.md): Case study · The authors describe FigCraft as an open-source, clean-room interface design and prototyping tool built in pure Rust. The README documents native and WebAssembly builds and estimates about 49% of the parity needed to replace proprietary design tools for real work.
- [FilmCraft: a clean-room nonlinear video editor in Rust](https://awesomerea.org/resources/filmcraft-case/index.md): Case study · The authors describe FilmCraft as an open-source, clean-room nonlinear video editor built in pure Rust. The README documents native and WebAssembly builds and reports about 86% feature breadth and about 56% readiness for real production work.
- [LightCraft: a clean-room photo library and raw developer in Rust](https://awesomerea.org/resources/lightcraft-case/index.md): Case study · The authors describe LightCraft as an open-source, clean-room non-destructive photo library and raw developer built in pure Rust. The README documents native and WebAssembly builds and calls the project alpha.
- [PdfCraft: a clean-room PDF reader and editor in Rust](https://awesomerea.org/resources/pdfcraft-case/index.md): Case study · The authors describe PdfCraft as an open-source, clean-room PDF reader and editor built in pure Rust. The README documents native and WebAssembly builds and reports 57% of tracked features and 94% of commands.
- [SoundCraft: a clean-room digital audio workstation in Rust](https://awesomerea.org/resources/soundcraft-case/index.md): Case study · The authors describe SoundCraft as an open-source, clean-room digital audio workstation built in pure Rust. The README documents native and WebAssembly builds and reports 94% menu coverage, about 70% feature presence and roughly 40% readiness for real work.
- [VectorCraft: a clean-room vector illustration application in Rust](https://awesomerea.org/resources/vectorcraft-case/index.md): Case study · The authors describe VectorCraft as an open-source, clean-room vector illustration application built in pure Rust. The README documents native and WebAssembly builds and reports about 88% of core menu items.
- [Picture Man: a Rust rebuild of the Windows 3.x image editor](https://awesomerea.org/resources/pictureman-case/index.md): Case study · A cross-platform Rust rebuild of Picture Man 1.55 (1991-1993), the true-color image editor for Windows 3.x, per the project README. The README says no original source survived and the algorithms were recovered by disassembling PMAN.EXE and its converter DLLs.
- [RE:Notepad: rebuilding Windows 10 Notepad behavior in Rust](https://awesomerea.org/resources/renotepad-case/index.md): Case study · RE:Notepad reconstructs Windows 10 Notepad behavior in a Rust and Win32 editor with a Windows 11-style interface. The author reports using REA and Ghidra to inspect notepad.exe and records function-linked findings on encoding detection, line endings and editing behavior in a separate specification.
- [Audionic Trance Airbud 850: reconstructing BLE controls for Linux](https://awesomerea.org/resources/audionic-trance-airbud-850-case/index.md): Case study · A Linux client reconstructs Audionic Trance Airbud 850 BLE controls from analysis of the Audionic Suite Android app and Jieli SDK references. It implements RCSP framing, mutual authentication and GTK controls for battery status, audio modes and EQ; the author reports using REA with JADX during the static investigation.
- [JTrac 3: an issue tracker rebuilt after REA analysis of JTrac 2.3.3](https://awesomerea.org/resources/jtrac-3-case/index.md): Case study · JTrac 3 is an independent issue tracker informed by the author's REA MCP study of the JTrac 2.3.3 WAR. Inspection of its bytecode and application files informed a feature catalogue and persistence model; the new implementation uses Java 25, Spring Boot 4, React 19 and PostgreSQL 18 for workflows, custom fields and issue management.
- [Reversed engineering Icsee: a macOS camera viewer informed by REA research](https://awesomerea.org/resources/reversed-engineering-icsee-case/index.md): Case study · Reversed engineering Icsee is a Swift macOS viewer for local iCSee and Xiongmai cameras, informed by REA inspection of an Android app and native SDK and by authenticated RTSP tests. It provides multiview video, local authentication, camera controls and SD-card recording access through a separate macOS implementation.
- [qcywatch: a QCY Watch GT2 client built from its BLE protocol and face format](https://awesomerea.org/resources/qcywatch-case/index.md): Case study · qcywatch reconstructs QCY Watch GT2 control and watch-face upload from the QCY Android app, BLE captures and face files. Its Linux scripts create and upload faces, read device information and battery state, sync time and send notifications. The author reports using REA to recover the face container layout.
- [hexgrab: rebuilding a color picker from a REA study of PowerToys](https://awesomerea.org/resources/hexgrab-case/index.md): Case study · hexgrab is a Windows WPF color picker built after a REA investigation of the shipped PowerToys Color Picker. The author documents findings from its .NET and native DLLs, including timer-based pixel sampling and clipboard retries, then implements a smaller picker with a global hotkey, screen overlay and HEX copying.
- [Windows Live Mail 2012: UI and resource format reconstruction](https://awesomerea.org/resources/wlm2012-research-case/index.md): Case study · Windows Live Mail 2012 research reconstructs the Japanese edition's UI layout, resource and message-store formats from an owned installation. The author used REA for PE resource inventory, Ghidra for DLL loader analysis and Python decoders to document UIB layouts, RLE images, ribbon definitions and ESE read status. The rebuilt mail app remains private; the repository publishes tools, specifications and findings.
- [anova-power-cli: reconstructing G*Power one-way ANOVA calculations](https://awesomerea.org/resources/anova-power-cli-case/index.md): Case study · anova-power-cli reconstructs G*Power 3.1.9.7's one-way ANOVA power calculations in a Python CLI and MCP service. The author describes inspecting G*Power with REA and Ghidra, collecting GUI outputs, and implementing five calculation modes; the author reports 245 matching fields across the stated comparison set. The optional Claude agent and its evaluation code are present, with a live LLM evaluation still pending.
- [Plaude Archiver: local Plaud Note Pro recording transfer](https://awesomerea.org/resources/plaude-archiver-case/index.md): Case study · Plaude Archiver reconstructs the Plaud Note Pro recording transfer protocol from analysis of the Android app, using REA and JADX in the documented workflow. Its macOS client obtains account keys once, establishes the encrypted BLE session, downloads recordings and decrypts them to Ogg Opus files. Protocol notes cover GATT characteristics, packet framing and handshake variants.
- [OpenPDF Studio: rebuilding PDF editing interactions from WPS PDF research](https://awesomerea.org/resources/openpdf-studio-case/index.md): Case study · OpenPDF Studio builds a local macOS PDF editor informed by REA-assisted observation of WPS Office 12.1.28496's PDF interface. Its research records editing interactions and limited Mach-O module inspection, while the implementation uses React, Electron, PyMuPDF and Apple Vision for text and image edits, conversion and OCR.
- [Keymarks: reconstructing Powermarks 3.5 bookmarks and workflows](https://awesomerea.org/resources/keymarks-case/index.md): Case study · Keymarks rebuilds Powermarks 3.5's keyword-based bookmark workflow as a Windows Tauri app with SQLite search and a browser extension. Its author used REA with Ghidra to recover the undocumented pm35.htm record layout from pm.exe and implemented import and export for that format. A separate feature inventory draws on the original manual, changelog, settings and executable strings.
- [MiPods: reconstructing Xiaomi earbuds control on macOS](https://awesomerea.org/resources/mipods-case/index.md): Case study · MiPods reconstructs Xiaomi earbuds control in a macOS menu-bar app using a recovered BLE GATT protocol. Its Swift core handles battery readings, device information and model-dependent noise controls, while research notes document hardware probes, vendor-app analysis and recording-transfer exchanges. A separate report describes REA-assisted analysis of Xiaomi's Mac app.
- [Taskly: rebuilding Trello's Electron desktop shell](https://awesomerea.org/resources/taskly-trello-shell-case/index.md): Case study · Taskly is an offline kanban app whose Electron desktop shell was reconstructed from Trello's app.asar using REA. The analysis covers window inventory, geometry, IPC channels and preloads; the board interface and local document storage are new implementation work. A separate report records the investigated package and recovered shell details.
- [mystery-sdl: porting the Mystery screen saver to SDL2](https://awesomerea.org/resources/mystery-sdl-case/index.md): Case study · mystery-sdl ports the Microsoft Plus! Mystery screen saver to SDL2 on Linux. After REA-assisted analysis of the original binaries, it reimplements sprite, animation and sound services in C, translates the plugin logic, and reads scene data from the user's Mystery.dll.
- [LSX II Volume Fixer: reconstructing volume behavior](https://awesomerea.org/resources/kef-lsx-volume-case/index.md): Case study · Uses measured USB-volume behavior and a macOS audio proxy to map volume keys to a KEF LSX II’s LAN control. The project reports more even steps while forwarding USB audio; the speaker firmware is unchanged.
- [UU Remote on Linux: an unofficial protocol implementation](https://awesomerea.org/resources/uu-remote-linux-protocol-case/index.md): Case study · Implements an unofficial native Linux host for NetEase UU Remote, using protocol behavior the maintainer says was recovered from official-client traffic and shipped programs. The Rust implementation connects selected desktop, input and auxiliary-tool channels to Linux services; an additional Linux viewer remains experimental. The author attributes development to Claude and Codex, without establishing REA use.
- [TCLimate: reconstructing selected TCL Home cloud controls](https://awesomerea.org/resources/tclimate-cloud-controls-case/index.md): Case study · Implements selected TCL Home air-conditioner controls and electricity reporting in a native macOS menu-bar app. It adapts earlier community protocol work and documents an Android-module investigation to recover a separate statistics request. Reported validation checks cloud state.
- [Browserbase plugin: re-hosting Claude in Chrome’s browser bridge](https://awesomerea.org/resources/browserbase-claude-chrome-bridge-case/index.md): Case study · Stands in for the Claude in Chrome extension side of Claude Code’s local browser bridge and runs the requested actions in Browserbase cloud browsers. The author’s thread describes the reverse-engineered framing, a 4-byte little-endian length before each JSON tool call, and the plugin maps 17 named tools onto Stagehand/CDP operations. It is an archived interoperability shim with several placeholder tools.
- [Visor: an independent Ray-Ban Meta glasses client](https://awesomerea.org/resources/visor-ray-ban-meta-client-case/index.md): Case study · Implements an Android replacement for the Meta AI companion app that speaks the Ray-Ban Meta glasses’ own Bluetooth and Wi-Fi Direct protocol, imports media, exposes settings and answers “Hey Meta” with a model the user chooses. The project wiki documents the link layers, encryption, services and Meta-side ownership steps, and lists 153 open questions. Testing is on real glasses rather than test suites, so behavior beyond the stated model and firmware remains unverified.
- [wine-uwp: running packaged Windows Store apps on a patched Wine](https://awesomerea.org/resources/wine-uwp-store-apps-case/index.md): Case study · Extends Wine 11.17 so that signed MSIX Store apps, with Shapr3D as the main target, install and run on Linux without their source or symbols. About 49,000 changed lines add a DirectComposition implementation, composition swap chains and an app-model host, while Microsoft’s own XAML and app-model DLLs, harvested from a Windows 11 image on the user’s machine, run unmodified. The author says Claude did most of the reverse engineering and code; app support is uneven and checked by a project regression suite.
- [RKD Telemetry Extractor: decoding Race-Keeper track-day recordings](https://awesomerea.org/resources/rkd-telemetry-extractor-case/index.md): Case study · Documents the proprietary .rkd telemetry format written by Race-Keeper “Instant Video” recorders, whose bundled player runs only on Windows, and implements matching Python and Go parsers that export GPS and IMU channels as Telemetry Overlay CSV and GPX. The author credits Claude Code with the hex-dump analysis and hypothesis testing, anchored by known car IDs, circuit location and speeds. Field meanings rest on physical cross-checks from the author’s own recordings, and several record types remain partly unknown.
- [Elgato HDR: a userspace capture path for the Elgato 4K X’s 10-bit mode](https://awesomerea.org/resources/elgato-hdr-uvc-capture-case/index.md): Case study · A native macOS app that reaches the Elgato 4K X capture card’s 10-bit P010 video mode, which the project says Apple’s built-in webcam driver does not expose to apps. A root helper detaches that driver and runs the card’s USB Video Class streaming directly through libusb, feeding a Metal HDR viewer, an HDR10 recorder and an editor. Latency figures and device coverage remain author-reported.
- [LGwebOS-menubar: a native macOS remote for LG webOS TVs](https://awesomerea.org/resources/lgwebos-menubar-remote-case/index.md): Case study · A native macOS menu-bar app that pairs with an LG webOS TV over its local encrypted WebSocket interface to launch apps, switch inputs, adjust volume and picture settings, send pointer input and cast selected media. The project credits the public Connect SDK for webOS protocol behavior and reuses PyWebOSTV’s registration manifest. Testing covers one TV on webOS 5.0.
- [Galaxy Buds Client: an unofficial manager built on Samsung’s earbud protocol](https://awesomerea.org/resources/galaxy-buds-client-protocol-case/index.md): Case study · Reimplements control of Samsung Galaxy Buds over their proprietary RFCOMM serial protocol in a cross-platform desktop and Android manager. The author reports recovering the message format by analyzing the earbuds’ binary stream and disassembling Samsung’s official Android apps, and publishes partial packet notes for the 2019 Buds and the Buds+. Beyond the official app’s settings, it exposes battery statistics, diagnostics, factory self-tests, hidden debug information and firmware flashing for supported models.
- [Wino Mail: recreating Windows Mail and Calendar](https://awesomerea.org/resources/wino-mail-case/index.md): Case study · Native Windows client that aims to preserve the familiar Windows Mail and Calendar experience while rebuilding its functionality. The upstream README documents a WinUI 3 interface, mail and calendar providers, contacts, tasks and offline workflows.
- [ScooterLink: reconstructing Honda RoadSync’s handlebar-button protocol](https://awesomerea.org/resources/scooterlink-honda-roadsync-case/index.md): Case study · Replaces Honda RoadSync’s Apple Music-only media control with an iOS app that pairs with a Honda PCX 2025 TFT dash over Bluetooth Low Energy and turns handlebar presses into system-wide commands for any player. The author documents the dash’s BLE services, key exchange, button registration and event bytes, reportedly worked out from the official Android app and logged traffic. Results are author-reported on one PCX125, and the protocol notes separate confirmed from unverified parts.
- [iX500 Scan: a macOS client for the reverse-engineered ScanSnap Wi-Fi protocol](https://awesomerea.org/resources/ix500-scan-scansnap-wifi-case/index.md): Case study · Replaces ScanSnap Home for a Fujitsu/PFU ScanSnap iX500 on macOS with a SwiftUI app and Python service that scan over Wi-Fi through the community-reverse-engineered VENS protocol, or over USB through SANE, and produce searchable PDFs. It vendors bramheerink’s GPL-2.0 driver, extends it for macOS, and documents further handshake and hardware-status fields, including the scan-button bit. Results are author-reported; the repository publishes no tests or captures.
- [WristBeam: reconstructing Garmin’s watch protocol for a Mac companion](https://awesomerea.org/resources/wristbeam-garmin-watch-protocol-case/index.md): Case study · Implements a Garmin watch companion as a native macOS menu-bar app that pairs over Bluetooth, receives live health notifications and original FIT files, and can upload them to Garmin Connect. Source comments attribute its GFDI framing, handshake, file-transfer and status fields to analysis of a supplied Garmin Android package, cross-checked against community implementations such as Gadgetbridge. Device verification covers one watch model, and the opt-in MCP and HTTP interfaces expose only locally cached data.
- [usque: an open reimplementation of Cloudflare WARP’s MASQUE mode](https://awesomerea.org/resources/usque-warp-masque-client-case/index.md): Case study · Reimplements the MASQUE mode of Cloudflare’s WARP client in Go, tunnelling IP traffic over QUIC/HTTP/3 with Connect-IP (RFC 9484) and exposing it as a native TUN device, SOCKS5 or HTTP proxies, TCP-only L4 proxies or port forwarding. RESEARCH.md describes how the author worked out device enrollment, TLS client authentication and Cloudflare’s non-standard cf-connect-ip variant by analyzing the official Android client with Frida, mitmproxy, JADX, IDA Free and Wireshark. It registers with and connects to Cloudflare’s service outside the official client.
- [Webamp: a browser reimplementation of Winamp 2](https://awesomerea.org/resources/webamp-winamp-reimplementation-case/index.md): Case study · Reimplements Winamp 2's main, equalizer and playlist windows in HTML5 and JavaScript, with Web Audio playback, volume, balance and equalizer, and renders original classic .wsz skins, which its documentation says match Winamp 2.9 pixel for pixel; Milkdrop presets run through the Butterchurn WebGL port. It ships as the webamp npm module for embedding in web pages, and the same monorepo runs webamp.org and the skins.webamp.org skin museum. Its webamp-modern prototype targets Winamp 3/5 modern skins with an interpreter for MAKI skin scripts, whose undocumented bytecode format the author reverse engineered and documents in the repository.
- [NOOP: an offline WHOOP strap client built from Bluetooth protocol research](https://awesomerea.org/resources/noop-whoop-ble-client-case/index.md): Case study · Replaces the WHOOP companion app with offline macOS, Android and iOS clients that pair with WHOOP 4.0 and 5.0/MG straps over Bluetooth, decode their vendor GATT frames, offload the strap’s history into local SQLite and compute recovery, strain, HRV and sleep on the device. A versioned protocol reference documents framing, checksums, commands and sensor records per strap family, building on the community my-whoop and goose projects. WHOOP 4.0 is the supported path; deeper WHOOP 5.0/MG metrics and Oura ring support remain experimental.
- [NiimBlue: an independent web client for NIIMBOT label printers](https://awesomerea.org/resources/niimblue-niimbot-printer-client-case/index.md): Case study · Replaces NIIMBOT's own label app with a browser client that designs labels and prints them over Web Bluetooth or Web Serial, with Android (Capacitor) and Windows (Tauri) builds of the same interface. Printer communication comes from the same author's NiimBlueLib, which the README calls the most complete implementation of the NIIMBOT protocol; the protocol is documented on the NIIMBOT Community Wiki, and owners of models that do not print are asked for a packet capture of a print made with the official app. The README says the client runs entirely in the browser and keeps label data there.
- [open_oura: a cloud-free Oura Ring client built on its reverse-engineered BLE protocol](https://awesomerea.org/resources/open-oura-ring-protocol-case/index.md): Case study · Reimplements the Bluetooth Low Energy protocol of the Oura Ring Gen 3/4/5 in Rust crates and an oura command-line client that pairs with, authenticates to and syncs a ring directly, with no Oura account or cloud service. The author reports recovering the GATT layout, packet framing and AES app-auth flow from the decompiled Android app, and porting history-event decoders and several on-device metrics, such as HRV, sleep debt and nightly temperature baselines, from Ghidra decompilations of the app's native libraries. Event bodies are stored raw in SQLite so they can be re-decoded as decoders improve.
- [Sony Headphones Client: a desktop client for Sony’s headset control protocol](https://awesomerea.org/resources/sony-headphones-client-case/index.md): Case study · Recreates part of Sony’s mobile-only Headphones app as a Windows, Linux and macOS desktop client that changes noise-cancelling, ambient-sound and virtual-sound settings over a Bluetooth RFCOMM connection to a paired headset. The author reports reverse engineering the phone app to define its control protocol, and the code rebuilds its message framing, with start and end markers, byte escaping, sequence numbers, a sum checksum and acknowledgements, together with the two set-parameter commands the client sends. Full support is reported for few models, mainly the WH-1000XM3, and the project is archived.
- [cbyge: reconstructing the C by GE smart-bulb cloud protocol](https://awesomerea.org/resources/cbyge-c-by-ge-protocol-case/index.md): Case study · Reimplements the cloud control path of the C by GE (now Cync) smart-bulb app as a Go library and a small self-hosted web app. The author reports decompiling the Android app with Apktool, finding its JSON HTTP API for login and device lists and a separate raw TCP protocol to the vendor's server, then working out that protocol's type-and-length message framing and packet encodings from proxied traffic and the Smali code. The resulting API lists devices, reads their status and sets power, brightness, color tone and RGB color.
- [Clickwill: reconstructing iPod library database editing](https://awesomerea.org/resources/clickwill-case/index.md): Case study · Clickwill reconstructs direct editing of iPod classic and iPod nano music libraries in a Swift Mac app. It reads and writes iTunesDB and ArtworkDB on the device, preserves unknown record bytes, handles hash58 signatures and publishes a byte map that distinguishes measured fields from uncertain ones.
- [Spark Mail: rehosting the Windows desktop app on Linux with Wine shims](https://awesomerea.org/resources/spark-mail-linux-case/index.md): Case study · spark-mail-linux rehosts the Windows Spark Mail desktop app on Linux with Wine, two compatibility DLL shims and launcher scripts. The project documents application startup, browser authentication, notifications, clipboard and file-opening behavior, then patches specific DLL imports and bridges those functions to the Linux desktop.
- [OpenTracks: a UWP port of OpenTracks7 BETA1](https://awesomerea.org/resources/opentracks-uwp-case/index.md): Case study · OpenTracks is an early UWP port of the OpenTracks7 BETA1 Windows Phone music app informed by the author's reverse engineering. Its C# and XAML implementation updates page control access and replaces WP7 MediaPlayerLauncher with UWP media playback APIs.
- [RTO eChalan: investigating a BankBot Android APK](https://awesomerea.org/resources/rto-echalan-android-analysis-case/index.md): Case study · The RTO eChalan report investigates an Android APK impersonating an Indian government eChallan service through manifest review, JADX decompilation and sandbox analysis. The author reports identifying a BankBot variant, a REQUEST_INSTALL_PACKAGES permission, a BIND_VPN_SERVICE entry and extensive obfuscation that limited decompilation.
- [AOL 7.0 Retro Server: reconstructing the P3 server session](https://awesomerea.org/resources/aol7-retro-server-case/index.md): Case study · AOL 7.0 Retro Server implements local Python servers for the 2001 AOL 7.0 client. It reconstructs the proprietary P3 login and security exchange, the handoff between login and BOS servers, and post-login data used to display the welcome screen and buddy list.
- [SteelSeries Overlay Hook: mapping and hooking the GameOverlay swapchain](https://awesomerea.org/resources/steelseries-overlay-hook-case/index.md): Case study · SteelSeries Overlay Hook documents IDA analysis of SteelSeriesGameOverlay.dll’s window, object layout and Direct3D 11 swapchain, then uses recovered offsets in a C++ DLL hook. Its injector and hook render Dear ImGui content through the existing GameOverlay window by intercepting Present and ResizeBuffers.
- [WeChat: recovering SQLCipher keys through CommonCrypto hooks](https://awesomerea.org/resources/wechat-4-1-10-macos-key-case/index.md): Case study · An investigation of WeChat 4.1.10 for macOS reports recovering per-database SQLCipher keys by breaking on CommonCrypto encryption calls in LLDB. It compares that approach with memory scanning and sqlite3_key breakpoints, and describes an offline check against a decrypted SQLite page.
- [Siriously: recovering macOS Writing Tools entry points](https://awesomerea.org/resources/siriously-writing-tools-case/index.md): Case study · Siriously investigates how macOS 27 changed access to Writing Tools and restores its popover through a Services client. The author used Objective-C runtime introspection and behavioral tracing to identify private WritingToolsUI classes, then passes selected text to the popover and writes accepted results back through Accessibility APIs. The findings concern one macOS build.
- [tuya-mobile: a Python reconstruction of Tuya app signing and API calls](https://awesomerea.org/resources/tuya-mobile-security-layer-case/index.md): Case study · tuya-mobile reconstructs Tuya mobile-app request signing, encrypted API calls and MQTT signaling credential derivation in Python. It replaces the app's native libthing_security.so signing step with HMAC-SHA256, SHA256 and MD5 calculations and includes versioned Smart Life and Tuya Smart profiles.
- [ddg-tenor-bridge: replacing Gboard's Tenor search endpoint](https://awesomerea.org/resources/ddg-tenor-bridge-case/index.md): Case study · ddg-tenor-bridge redirects Gboard's Tenor GIF searches to a service that returns DuckDuckGo animated-image results in Tenor v2 response form. Its documented workflow changes Gboard's persisted search URL flag while leaving other Tenor features on their original endpoint.
- [MSP CSV Export Format: reconstructing My Stocks Portfolio exports](https://awesomerea.org/resources/msp-csv-format-case/index.md): Case study · MSP CSV Export Format reconstructs the undocumented CSV export of the My Stocks Portfolio & Market app. The author compared eleven iOS exports, app displays and public translation strings to describe columns, blocks and transaction replay. A dependency-free Python parser and synthetic export exercise the documented rules and flag malformed input.
- [Benro Polaris Firmware Patcher: rebuilding camera control and mapping the app protocol](https://awesomerea.org/resources/benro-polaris-firmware-patcher-case/index.md): Case study · Benro Polaris Firmware Patcher investigates the Polaris camera controller and repacks a user-supplied firmware image with a newer libgphoto2 stack and targeted pgphoto changes. Its documentation maps Benro Connect app behavior and the TCP messages used to control the device. The author reports end-to-end testing with a Canon EOS R5 Mark II.
- [Malware Analysis: a trojanized FL Studio installer and Go stealer](https://awesomerea.org/resources/fl-studio-stealer-analysis-case/index.md): Case study · This malware-analysis report investigates a trojanized FL Studio installer that bundles an Electron/NSIS wrapper and a Go information stealer. The author traces the wrapper statically and studies the payload in an isolated Windows environment with process, registry and network observations, recovering its reported command-and-control mechanism.
- [grsimwrite-mac: reconstructing GRSIMWrite for macOS](https://awesomerea.org/resources/grsimwrite-mac-case/index.md): Case study · grsimwrite-mac reconstructs the Windows GRSIMWrite 4.4.10 SIM-writing workflow in Python for macOS. Its research records card-family profiles and APDU write behavior, while the implementation identifies cards, reads elementary files, writes selected fields, and builds formatting sequences.
- [dola-client: reconstructing Dola's Android app API access](https://awesomerea.org/resources/dola-client-case/index.md): Case study · dola-client reconstructs access to the Dola AI Android app API from captured phone traffic. It provides Python signing and API-call code, a demonstration chat CLI, and session import from a logged-in Android app or browser cookies.
- [mcp-fitbod: mapping Fitbod Android models and backend APIs](https://awesomerea.org/resources/mcp-fitbod-api-case/index.md): Case study · mcp-fitbod maps Fitbod backend endpoints and serialization schemas from decompiled Kotlin models in the Android app, then uses the documented interface in an MCP account client. Its endpoint map and schema notes identify request paths, model fields and wire names, including JSON:API and Moshi naming differences.
- [FlyBird-ProtocolAnalysis: FlyBird client subscription protocol and APXS v2 format](https://awesomerea.org/resources/flybird-protocol-analysis-case/index.md): Case study · FlyBird-ProtocolAnalysis investigates the FlyBird proxy client's subscription delivery and APXS v2 format across Windows, Android, Linux and OpenWrt. Its reports describe client static analysis, process-memory inspection, GDB breakpoints and TLS observation; accompanying code decrypts the envelope and reproduces the documented mTLS request flow using user-supplied account credentials and certificates from the user's installed client.
- [SwiftCUA: reconstructing a macOS computer-use service](https://awesomerea.org/resources/swiftcua-case/index.md): Case study · SwiftCUA reconstructs the behavior of a macOS computer-use service in Swift 6 after studying the Codex Computer Use.app bundle, its local IPC, permissions and input engine. It provides a background service, CLI, JavaScript bridge and MCP servers for accessibility inspection, screenshots and input, with separate research reports on the original.
- [IOSVM: booting iOS 16.5 user space in QEMU on Linux](https://awesomerea.org/resources/iosvm-case/index.md): Case study · IOSVM ports Darwin/XNU components so user-supplied iOS 16.5 user space can boot in QEMU on Linux. Its QMP input channel and web/VNC bridge expose taps, swipes, keyboard input, and rendered frames; the author reports that home-screen boots remain intermittent and rendering uses a CPU rasterizer.
- [BOSS GX-10: reconstructing the TSL preset format](https://awesomerea.org/resources/boss-gx10-tsl-format-case/index.md): Case study · A specification reconstructs the .tsl.json preset format used by BOSS Tone Studio for the GX-10 processor. It maps the JSON structure, hex-encoded parameter arrays, patch names, effect routing and control assignments, with Python examples and research notes.