# Curated reverse engineering resources · Page 2

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

## Websites (28)

- [WeHeartIt API Endpoints: recovering paths from the Android app](https://awesomerea.org/resources/weheartit-api-endpoints-case/index.md): Case study · WeHeartIt API Endpoints catalogs HTTP paths recovered from decompiled WeHeartIt Android app version v9.0.1.RC-GP-Free(21892). It groups the former service's paths by GET, POST, DELETE and PUT, covering accounts, collections, entries, search and messaging.
- [FacebookUnsentMessage: reconstructing Messenger history sync](https://awesomerea.org/resources/facebook-unsent-message-case/index.md): Case study · FacebookUnsentMessage recreates the Messenger web client's MQTT-over-WebSocket history sync channel in Node.js. It authenticates with the user's browser cookies, requests replay from a sequence ID and scans message deltas for a specified message ID.
- [Dih Pinterest: reconstructing a Pinterest search site's page and data flow](https://awesomerea.org/resources/dih-pinterest-case/index.md): Case study · Dih Pinterest reconstructs the search interface and data flow of searchpinterest.vercel.app as a static web app with an optional Vercel proxy. Its report describes a page hidden in zero-width characters, the site's search API flow and an exposed client-side database token. The repository includes small encoder and decoder scripts for the cloaking scheme.
- [urja-api: reconstructing the Urja Meter Ops portal API](https://awesomerea.org/resources/urja-api-meter-ops-case/index.md): Case study · urja-api reconstructs access to the Urja Meter Ops web portal as a typed TypeScript service and REST API. The author traced browser requests and replayed them to document login cookies, signed bulk export, JSON endpoints and SvelteKit data pages; the adapter turns those responses into meter, transformer and energy-reading routes.
- [muse-cli: reconstructing the muse.ai personal gateway protocol](https://awesomerea.org/resources/muse-cli-case/index.md): Case study · muse-cli implements terminal access to the muse.ai personal gateway using behavior derived from its web client bundle. It obtains access tokens over HTTPS, connects to a personal VM through a Noise-XX WebSocket, and exchanges protobuf-framed requests and events. The accompanying notes document transport framing and gateway methods.
- [MAX Messenger: documenting WebSocket and TCP message formats](https://awesomerea.org/resources/max-messenger-protocol-case/index.md): Case study · MAX Messenger API Documentation maps the messenger's WebSocket JSON and TCP MessagePack exchanges from browser traffic and direct request experiments. It records INIT and LOGIN steps, request fields, opcodes, chat and messaging operations, plus binary TCP framing and compression behavior.
- [Tesla Dashcam Decryptor: decoding encrypted dashcam recordings](https://awesomerea.org/resources/tesla-dashcam-decrypt-case/index.md): Case study · Tesla Dashcam Decryptor reconstructs the local decryption flow used by dashcam.tesla.com for Tesla 2026.20 encrypted recordings. The write-up describes intercepting browser requests and WebCrypto calls to identify file metadata, key retrieval and chunked AES-128-CBC decryption; a Python tool applies the flow to batches of clips.
- [transferit-py: reconstructing transfer.it upload and download exchanges](https://awesomerea.org/resources/transferit-py-case/index.md): Case study · transferit-py reconstructs transfer.it file-transfer exchanges from its public web client and implements Python library and CLI clients. Its research maps MEGA-backed API commands, ephemeral sessions, AES-128-CTR encryption with CBC-MAC and WebSocket upload framing. The client uploads folders and streams decrypted downloads.
- [github-websocket-pipelines-api: probing GitHub Actions live-log messages](https://awesomerea.org/resources/github-websocket-pipelines-api-case/index.md): Case study · github-websocket-pipelines-api probes GitHub Actions' undocumented live-log WebSocket interface. Its TypeScript client finds an in-progress run, obtains a socket URL through GitHub's live-log endpoints, sends a JSON handshake and WatchRunAsync request with a record separator, and prints incoming messages.
- [Inception Chat: reconstructing a chat page from design and prompt captures](https://awesomerea.org/resources/inception-chat-extraction-case/index.md): Case study · Inception Chat reconstructs the public chat.inceptionlabs.ai landing page from observed desktop and mobile layouts, deployed CSS tokens and captured suggested prompts. The repository records measurements and provenance in design documents and JSON, then uses them in a React 19, Vite and Tailwind chat interface with a Bun API server.
- [pipepipe-sabr: reconstructing YouTube SABR streaming](https://awesomerea.org/resources/pipepipe-sabr-case/index.md): Case study · pipepipe-sabr reconstructs YouTube SABR/UMP streaming behavior from source-level analysis of PipePipe and implements a separate Python client. It handles segmented sessions, signature parameters, downloading and browser playback, with a protocol report mapping fields and a Node-based PO Token component. The author reports a complete 20-minute test download.
- [MUSIC DIVER MyPage API: mapping the game's private web endpoints](https://awesomerea.org/resources/music-diver-mypage-api-case/index.md): Case study · MUSIC DIVER MyPage API documents the private HTTP endpoints behind the game's MyPage service and implements a self-hosted proxy for player statistics. Its reference covers authentication, profile and music requests, rankings, payloads and response structures; the server adds caching and historical rank snapshots.
- [Weathercloud JS API: mapping the private station-data endpoints](https://awesomerea.org/resources/weathercloud-js-case/index.md): Case study · Weathercloud JS API maps the private station-data endpoints of the Weathercloud web application and implements a TypeScript client for them. Its reference records request methods, headers, parameters and response fields for weather readings, profiles, statistics and device searches.
- [tutti-api: reconstructing a tutti.ch private API client](https://awesomerea.org/resources/tutti-api-case/index.md): Case study · tutti-api reconstructs client access to the tutti.ch private API in TypeScript, covering search filters, listings, seller profiles, messaging, and Auth0 login. Its documentation identifies inferred request constraints, a captured Android client header set, session-token exchange, and NDJSON chat streams.
- [tiktok-xgnarly-decoded: reconstructing TikTok's X-Gnarly signature format](https://awesomerea.org/resources/tiktok-xgnarly-decoded-case/index.md): Case study · tiktok-xgnarly-decoded reconstructs the X-Gnarly request parameter used by TikTok's web client and implements its 5.1.3-ZTCA form in JavaScript. Its format account covers a 16-field TLV payload, custom base64 alphabet, embedded random key and ChaCha-style cipher. Tests include synthetic round trips and field checks against a captured parameter.
- [Skylight API: reconstructing the Skylight Calendar web API](https://awesomerea.org/resources/skylight-api-case/index.md): Case study · Skylight API documents Skylight Calendar's web API from browser HAR captures and publishes the resulting OpenAPI specification. Its CLI filters Skylight requests, redacts sensitive values, normalizes URL paths, infers response schemas, and generates Swagger UI or ReDoc pages.
- [canopy-dotmatrix: reconstructing davidluft.com's dot-matrix window](https://awesomerea.org/resources/canopy-dotmatrix-case/index.md): Case study · Reconstructs the dot-matrix window on davidluft.com from its public JavaScript bundle and scene payloads. A JavaScript engine decodes six-bit temporal-delta luminance and color fields, then renders individually animated dots; an interactive page and frame exporter demonstrate the result. The author reports comparing output with browser screenshots.
- [Drama Live: analysing its Android and web clients and rebuilding an API client](https://awesomerea.org/resources/dramalive-analysis-case/index.md): Case study · Drama Live analysis documents the Android APK and web PWA of the IPTV player, including their component stacks, endpoint maps and content-source flows. It implements a Flutter client and Node reference backend around the described Xtream Codes player_api.php contract, with synthetic and locally served test media.
- [The Blind Walleye: a static rebuild of the marketing site](https://awesomerea.org/resources/blind-walleye-static-case/index.md): Case study · Rebuilds the public Blind Walleye site as a Next.js app. The shipped capture source/pages/index.html is one input page, and node scripts/compare-visual.mjs pixel-diffs the replica against the capture and exits 1 if any page exceeds the diff threshold.
- [LoreMaps: a static rewrite of a fantasy-map atlas](https://awesomerea.org/resources/loremaps-atlas-case/index.md): Case study · A static Astro atlas rewritten from the project’s earlier ASP.NET MVC site. Shipped map definitions in src/maps name each tile pyramid, image size, and meters-per-pixel scale, and npm run build writes the static site to dist/.
- [NewPipe: an Android front end for YouTube and PeerTube](https://awesomerea.org/resources/newpipe-streaming-client-case/index.md): Case study · NewPipe is an Android front end for YouTube, YouTube Music and PeerTube. It gets service data from public APIs where available and otherwise parses websites or uses internal APIs to search and play streams.
- [Omada API Toolkit: reconstructing the Controller Web API v2](https://awesomerea.org/resources/omada-api-toolkit-case/index.md): Case study · Omada API Toolkit reconstructs TP-Link Omada Controller Web API v2 from browser DevTools observations and real controller use. Its Node.js helper implements the controller ID, CSRF token and session-cookie login flow, while the endpoint reference records payloads for VLANs, ACLs, SSIDs, mDNS and access-point settings.
- [zoomer: reconstructing Zoom meeting bot communication](https://awesomerea.org/resources/zoomer-case/index.md): Case study · zoomer reconstructs Zoom Web SDK meeting communication in a Go library for in-meeting bots. Its documentation maps WebSocket message types for chat, roster, and controls, while the code handles RTP streams and partial audio, video, and screen-share paths.
- [Google Earth: reconstructing 3D satellite asset formats and access](https://awesomerea.org/resources/earth-reverse-engineering-case/index.md): Case study · earth-reverse-engineering investigates Google Earth's 3D satellite mode and reconstructs its resource URL structure, octree metadata, Protobuf asset formats, and mesh and texture decoding steps. The repository includes a native and WebAssembly flycam client, a JavaScript model exporter, and a rocktree Protobuf schema.
- [Simple SPK Server: reconstructing a Synology package repository](https://awesomerea.org/resources/simple-spk-server-case/index.md): Case study · Simple SPK Server reconstructs a package repository service for Synology Package Center based on the author's study of Synology and SynoCommunity repositories. Its PHP code serves local SPK files and browser listings, extracting package information and icons from each package.
- [Playwright MCP](https://awesomerea.org/resources/playwright-mcp/index.md): Integration · Drive browser interactions through structured accessibility snapshots to investigate reproducible web behavior.
- [Burp Suite MCP Server](https://awesomerea.org/resources/burp-suite-mcp-server/index.md): Integration · PortSwigger's Burp Suite extension serves an MCP endpoint, plus a packaged stdio proxy, so agents can query proxy HTTP and WebSocket history, send HTTP/1.1 or HTTP/2 requests, and open Repeater or Intruder tabs.
- [Spectral](https://awesomerea.org/resources/spectral-mcp/index.md): Integration · Analyze captured application HTTP traffic with an LLM to generate MCP tools, OpenAPI 3.1 specifications, or GraphQL schemas. Generated tools call the observed API directly after capture and authentication setup.

## Games (72)

- [Il2CppDumper](https://awesomerea.org/resources/il2cppdumper/index.md): Tool · Recover IL2CPP metadata and dummy assemblies, and generate helper scripts for native analysis tools; method code is not restored.
- [RenderDoc](https://awesomerea.org/resources/renderdoc/index.md): Tool · Inspect frame captures, draw calls, shaders, and graphics resources in your own game or graphics application.
- [AssetRipper](https://awesomerea.org/resources/assetripper/index.md): Tool · Analyze Unity game files, inspect asset dependencies, and convert supported assets into Unity project formats.
- [Cpp2IL](https://awesomerea.org/resources/cpp2il/index.md): Tool · Recover managed representations from Unity IL2CPP builds using binary and metadata analysis; reconstruction remains a work in progress.
- [UndertaleModTool](https://awesomerea.org/resources/undertalemodtool/index.md): Tool · Browse and modify supported GameMaker data files, extract assets, and decompile or compile GML VM code. Includes room editing, scripted changes, a CLI, and the reusable UndertaleModLib library.
- [frida-il2cpp-bridge](https://awesomerea.org/resources/frida-il2cpp-bridge/index.md): Tool · Inspect IL2CPP classes, methods, and fields in a live process, and trace or intercept method calls without supplying global-metadata.dat. Complements static IL2CPP dumpers with runtime observation.
- [objdiff](https://awesomerea.org/resources/objdiff/index.md): Tool · Compare functions and data in reference and rebuilt object files to guide matching decompilation. Displays instruction-level differences, demangles C++ symbols, and can rebuild when source files change.
- [decomp-permuter](https://awesomerea.org/resources/decomp-permuter/index.md): Tool · Randomly or systematically permutes one C function, recompiling each variant and scoring it against a target object file to search for matching compiler output. PERM macros specify manual alternatives, and the optional permuter@home mode distributes runs to other workers.
- [asm-differ](https://awesomerea.org/resources/asm-differ/index.md): Tool · Diffs original and rebuilt assembly for one function or ROM address to guide matching decompilation; its watch mode can rerun make when sources change. The README describes it as decomp.me’s default diff viewer and points to objdiff as a modern alternative.
- [UE Explorer](https://awesomerea.org/resources/ue-explorer/index.md): Tool · Explore Unreal packages through class, property, and dependency trees; decompile and export UnrealScript classes, inspect bytecode, and examine structured binary data.
- [GARbro](https://awesomerea.org/resources/garbro/index.md): Tool · Browse recognized visual-novel resource archives as folders, preview their contents, and extract images or audio with conversion to common formats.
- [Godot RE Tools](https://awesomerea.org/resources/godot-re-tools/index.md): Tool · Recover supported Godot project files, GDScript and imported resources from exported games. Includes PCK inspection and extraction, script decompilation, and resource conversion for examining and rebuilding project structure.
- [UE4SS](https://awesomerea.org/resources/ue4ss/index.md): Tool · Inspect Unreal Engine games at runtime through live UObject property views, reflected C++ header dumps, property mappings and actor dumps. Lua and C++ APIs support experiments while reconstructing game structures.
- [FModel](https://awesomerea.org/resources/fmodel/index.md): Tool · Explore Unreal Engine game archives with CUE4Parse-backed package and property inspection, asset previews and export. The 2026 summer release adds USD world export for reconstructing supported scene content.
- [N64: Recompiled](https://awesomerea.org/resources/n64recomp/index.md): Tool · Statically recompiles N64 MIPS binaries into C functions from symbol metadata, emitting function lookups and relocation macros so a runtime can handle statically linked and relocatable overlays. The output needs a runtime such as N64ModernRuntime; the repository also includes RSP microcode and mod tooling.
- [XenonRecomp](https://awesomerea.org/resources/xenonrecomp/index.md): Tool · Converts Xbox 360 PowerPC executables into C++ that can be compiled for other platforms, with the XenonAnalyse companion detecting jump tables and function boundaries. Output is a literal instruction translation rather than decompiled code and needs a runtime that the project does not supply.
- [decomp.me](https://awesomerea.org/resources/decomp-me/index.md): Tool · Collaborative decompilation website for matching work: its compile service builds candidate source with a selected platform compiler, assembles the target assembly and diffs the two objects with asm-differ. m2c drafts initial decompilations for its MIPS, PowerPC, ARM and SuperH platforms. The 18 platform definitions span N64, PlayStation, PS2, PSP, GameCube/Wii, Wii U, DS, GBA, 3DS, Switch, Saturn, Dreamcast and Xbox 360 plus IRIX, Mac OS X, MS-DOS, Win32 and Android x86.
- [splat](https://awesomerea.org/resources/splat/index.md): Tool · Binary splitter for decompilation and modding projects: a YAML config says where and how to cut an N64 ROM or PSX, PS2 or PSP binary into code, data and asset segments. A scan phase disassembles code and data, with MIPS handled by spimdisasm; a split phase writes the files and a linker script for rebuilding the input. Custom segment types can extend the pipeline.
- [m2c](https://awesomerea.org/resources/m2c/index.md): Tool · Decompiler for matching projects that turns GNU as-format 32-bit MIPS, ARM, PowerPC and SuperH assembly into draft C, with partial C++ support. A target combines platform, compiler (IDO, GCC or MetroWerks CodeWarrior) and language; context files supply types, and it can infer unknown struct fields and emit global initializers. The README places it alongside splat, asm-differ and decomp-permuter, and decomp.me calls it for initial decompilations.
- [decomp-toolkit](https://awesomerea.org/resources/decomp-toolkit/index.md): Tool · GameCube/Wii matching-decompilation toolkit that analyzes DOL and REL executables and, from a project configuration, splits them into relocatable objects plus an ldscript.lcf for CodeWarrior's linker, so decompiled objects can replace original ones while the relinked binary is checked against the original. Analysis covers function boundaries, a Metrowerks/SDK signature database, relocations, sections and data objects, and objects are written without an assembler. Its CLI also handles disc images, archives, compression formats, CodeWarrior demangling and DWARF dumps.
- [ido-static-recomp](https://awesomerea.org/resources/ido-static-recomp/index.md): Tool · Statically recompiles the IRIX MIPS programs of SGI's IDO 5.3 and 7.1 C toolchain, such as cc, cfe, uopt, ugen and as1, into native Linux, macOS and Windows executables, so matching decompilation projects can build with the original compiler code on modern hosts. It recompiles compilers, not games: it neither decompiles nor translates game code.
- [PS2Recomp](https://awesomerea.org/resources/ps2recomp/index.md): Tool · Experimental static recompiler that translates MIPS R5900 code from PlayStation 2 ELF executables into C++ and links it with a bundled runtime. ps2xAnalyzer or a Ghidra export script produces a per-game TOML of functions, stubs, skips and instruction patches; ps2xRecomp emits a literal instruction-by-instruction translation; ps2xRuntime and ps2xIOP supply guest memory, syscall dispatch, IOP module execution with HLE fallbacks and partial, largely stubbed GS/VU hardware. Getting a game to run remains per-game porting work.
- [Xenosaga I Decomp Compatibility Kit](https://awesomerea.org/resources/decomp-compat-kit/index.md): Tool · Checks a PS2 matching decompilation from outside its own build: the C is recompiled with a stock, unpatched ee-gcc 2.96 and assembler, then each function is byte-compared against the original and every difference is classified by its likely toolchain cause. Companion scripts export ELF symbol tables to CSV and convert them to splat symbol files. Defaults target Xenosaga Episode I; the README says the method generalises but the defaults do not.
- [GB Recompiled](https://awesomerea.org/resources/gb-recompiled/index.md): Tool · Static recompiler that turns Game Boy and Game Boy Color ROMs into portable C projects: it decodes and analyzes banked LR35902 code, emits C with machine-readable metadata, and links it with a shared SDL2 runtime for video, audio, input, saves and hardware timing. Jump targets that static analysis missed fall back to an interpreter. The repository also carries differential, replay and frame and audio capture tooling, plus a Pokémon Crystal port that builds native features on hooks into the exact ROM.
- [dtk-template](https://awesomerea.org/resources/dtk-template/index.md): Tool · Project template for starting GameCube and Wii matching-decompilation repositories around decomp-toolkit. Its configure.py generates a ninja build that analyzes and splits the game's DOL and REL files from per-version config.yml, symbols.txt and splits.txt files, compiles the decompiled C/C++ with period Metrowerks compilers, relinks the result and checks it against recorded SHA-1 hashes. It also wires in objdiff for per-object diffing, progress reporting for decomp.dev and an example GitHub Actions workflow.
- [N64ModernRuntime](https://awesomerea.org/resources/n64modernruntime/index.md): Tool · Runtime for N64Recomp static recompilations and traditional source ports of N64 games, made of two libraries. ultramodern reimplements core libultra services (threads, message queues, timers, controllers, audio, RSP task handling and VI timing) and leaves controller input, audio playback and the graphics renderer, with RT64 recommended, to callbacks the host project registers. librecomp bridges N64Recomp-generated code to ultramodern and adds overlay handling, PI DMA ROM reads, and EEPROM, SRAM and Flash RAM saves.
- [REDscript](https://awesomerea.org/resources/redscript/index.md): Tool · Compiler and decompiler toolkit for REDscript, a statically typed, object-oriented language for writing scripts for REDengine, CD Projekt's engine used in Cyberpunk 2077. Its Rust crates parse and analyze source, generate bytecode with monomorphization of generics, decompile .redscripts bytecode bundles back into REDscript source, read and write REDengine's native binary format, and provide a drop-in replacement for CD Projekt's scc script compiler plus a C API with source mapping. The CLI exposes decompile, compile, lint and format commands; the language server and debugger live in a separate redscript-ide repository.
- [Spice86](https://awesomerea.org/resources/spice86/index.md): Tool · PC emulator for executing, reverse engineering and rewriting real-mode DOS programs whose source code is unavailable. While a program runs it builds a control-flow graph, and on exit it dumps memory, execution flow, Ghidra-compatible symbols and a self-contained, runnable C# project whose generated functions override the original assembly, so analysts can rewrite them function by function into readable code while the program keeps working. It also provides a GDB remote server with custom analysis commands, a built-in debugger with a C-header structure viewer, an optional HTTP memory API and an MCP server whose tools cover CPU, memory, breakpoints, CFG and device state; an optional Ghidra plugin imports the dumps.
- [PS2 Web Recomp](https://awesomerea.org/resources/ps2-web-recomp/index.md): Tool · Statically recompiles PlayStation 2 games for the browser: eerecomp translates the Emotion Engine code of a game's boot executable into C++ that is compiled to WebAssembly, and a runtime emulates the rest of the console, including a high-level EE kernel, an interpreted I/O processor running the disc's IRX modules, the vector units, SPU2 sound and the Graphics Synthesizer on WebGPU compute shaders. Its port script repeats headless runs to find functions reached through pointers and vector-unit microprograms to compile ahead of time, then builds the web page and a native runner.
- [xboxrecomp](https://awesomerea.org/resources/xboxrecomp/index.md): Tool · Static-recompilation toolkit for original Xbox games: a Python pipeline parses a retail XBE, disassembles it, classifies library functions, recovers calling conventions and lifts every x86 function to C. The generated code is compiled in a separate game project that links the toolkit's runtime libraries, which stand in for the Xbox kernel and translate Direct3D 8, NV2A, audio and input to Direct3D 11 and Win32 APIs, or to SDL2 and OpenGL on Linux and macOS.
- [PCSX-Redux](https://awesomerea.org/resources/pcsx-redux/index.md): Tool · PlayStation 1 emulator forked from PCSX and built around development and reverse engineering, with an interpreter and dynamic recompiler, software and OpenGL renderers, a MIPS debugger, VRAM viewer, SPU and GPU debugging tools, and a built-in GDB server that its documentation connects to gdb, IDA Pro and Ghidra's debugger. A LuaJIT API exposes breakpoints, memory and registers, an assembler and an ISO builder, and an optional REST web server can dump RAM and VRAM. The repository also holds the OpenBIOS replacement BIOS, PS-EXE conversion and packing tools, a Psy-Q object-file converter, Ghidra scripts for exchanging symbols and overlays with the emulator, and PS1 hardware designs.
- [Il2CppInspector](https://awesomerea.org/resources/il2cppinspector/index.md): Tool · Static analysis tool for Unity IL2CPP applications that reads an IL2CPP binary with its global-metadata.dat and outputs the application's type structure and method addresses as C# stub code, .NET assembly shim DLLs for decompilers such as ILSpy and dnSpy, IDA and Ghidra Python scripts that apply symbols and types, C++ type scaffolding and JSON address maps. Three APIs, also published as a NuGet package, and a plugin SDK expose the binary metadata, .NET type model and C++ model for custom analysis. The README describes these outputs as metadata and stubs; method source code remains unrecovered.
- [MelonLoader](https://awesomerea.org/resources/melonloader/index.md): Tool · Mod loader for Unity games on both the Mono and IL2CPP runtimes, which loads plugins and mods from folders in a locally installed game; on Windows a proxy DLL, version.dll by default, starts it with the game. For IL2CPP games its assembly generator runs Cpp2IL and Il2CppInterop to produce managed interop assemblies, and HarmonyX and MonoMod are bundled for runtime patching. Its logs can capture Unity player output and Harmony messages, and debug options provide a Mono debug server for Mono games and a wait-for-debugger option for IL2CPP games.
- [BepInEx](https://awesomerea.org/resources/bepinex/index.md): Tool · Plugin and patching framework for Unity Mono, Unity IL2CPP and .NET Framework games such as XNA, FNA and MonoGame titles, which loads mods and analysis plugins into a locally installed game. Plugins patch methods at runtime with the bundled HarmonyX and MonoMod.RuntimeDetour, while preloader patchers rewrite managed assemblies with Mono.Cecil before the game loads them; on IL2CPP games it runs Cpp2IL and Il2CppInterop to generate interop assemblies from the game binary and global-metadata.dat. Its guides also cover configuration, logging, and debugging plugins and game assemblies with dnSpy.
- [ReXGlue SDK](https://awesomerea.org/resources/rexglue-sdk/index.md): Tool · Experimental SDK for statically recompiling Xbox 360 executables into portable C++23 that runs natively on Windows, Linux and macOS. Its rexglue CLI scaffolds a per-game CMake project and, from a TOML config, analyzes a XEX binary (import resolution, PDATA, block discovery, gap filling, jump resolution and call-target validation) before translating each PowerPC instruction into C++; a runtime derived from Xenia's emulator core, with D3D12 or Vulkan graphics, hosts the generated code. Generated functions are weak aliases that native C++ overrides or mid-function hooks can replace, so a port can be refined one function at a time.
- [ps3recomp](https://awesomerea.org/resources/ps3recomp/index.md): Tool · Toolkit and runtime for statically recompiling PlayStation 3 games into native executables. Python tools parse PS3 ELF and PRX files, find functions and firmware imports, and lift PPU and SPU code to C/C++; a project template links that code with a C/C++ runtime providing LV2 system calls, high-level emulation of the system libraries and RSX graphics translation to Direct3D 12, Metal or Vulkan.
- [Nebula (NebulaFD)](https://awesomerea.org/resources/nebulafd/index.md): Tool · Work-in-progress decompiler for games made with Clickteam Fusion 2.5, with fixes for older Multimedia Fusion 1.5 files. Its .NET console app reads Windows executables, Android APKs, iOS IPAs, CCN data files and existing MFA projects, then runs plug-in tools: an MFA Parser that writes the game back out as an editable Fusion project, and an Asset Dumper for images, sounds, music, fonts, icons, shaders and packed files.
- [swe1r-assets-unity: Racer model-block editor sample](https://awesomerea.org/resources/swe1r-assets-unity/index.md): Tool · Work-in-progress Unity editor sample for importing and modifying Star Wars Episode I: Racer model blocks, then serializing them back through swe1r-assets. Its editor includes an unmodified import/export byte-comparison command; it is an asset-format workflow rather than a reimplementation of the game.
- [LuaJIT Decompiler v2](https://awesomerea.org/resources/luajit-decompiler-v2/index.md): Tool · Decompiles LuaJIT bytecode files back into Lua source, written as a replacement for the older Python LuaJIT decompiler. The README reports full support for gotos and for stripped bytecode, including reconstructed locals and upvalues, and its boolean-expression recovery follows a published decompilation algorithm. It processes single files or whole folders and writes .lua output.
- [NTRGhidra](https://awesomerea.org/resources/ntrghidra/index.md): Tool · Ghidra loader and plugin for Nintendo DS programs. It checks the .nds header, maps either the ARM9 or the ARM7 binary at its RAM address together with the console's memory regions and I/O register labels, decompresses SDK-compressed ARM9 code and overlays, and fills the overlays the user selects at import, while an optional overlay-manager plugin swaps overlays in and out afterwards. The repository also keeps a small Ghidra Function ID database of NitroSDK 3.0 routines for function identification.
- [mgbdis](https://awesomerea.org/resources/mgbdis/index.md): Tool · Python disassembler that turns a Game Boy or Game Boy Color ROM, including multi-bank ROMs, into RGBDS-compatible assembly plus a Makefile that reassembles it, so the rebuilt ROM can be compared with the input. An optional .sym file beside the ROM supplies labels and marks code, data, text, padding and 1bpp/2bpp tile-image blocks; images are written as PNG files that rgbgfx converts back, text can use custom character maps, and hardware registers get hardware.inc names. The README explains that SM83 instructions vary in length and data is interleaved with code, so marked code blocks keep it from disassembling mid-instruction.
- [ghidra-allegrex](https://awesomerea.org/resources/ghidra-allegrex/index.md): Tool · Ghidra processor module for the Allegrex CPU of the PlayStation Portable, derived from Ghidra's MIPS module. It adds Allegrex-specific instructions, VFPU disassembly and basic decompilation, the PSP calling convention, and an ELF loader that detects PSP executables and applies the PSP-specific type A and B relocation sections, with rebasing after import. Bundled scripts import and export PPSSPP .sym function-label files, and an exporter writes kernel modules as relocatable object files for linking.
- [GM8Decompiler](https://awesomerea.org/resources/gm8decompiler/index.md): Tool · Command-line tool that turns games built with GameMaker 8.0 or 8.1 back into editable .gmk or .gm81 project files. It reads the gamedata section that a built executable carries next to the runner and writes its settings, sprites, sounds, backgrounds, paths, scripts, fonts, timelines, objects, rooms, extensions, included files and GML code in the project format matching the game's version. A Rust rewrite on the OpenGMK project's gm8exe library that replaced the team's fork of WastedMeerkat's gm81decompiler, it is now developed in the OpenGMK repository alongside the GM8Emulator runner reimplementation.
- [UELib (Unreal-Library)](https://awesomerea.org/resources/uelib-unreal-package-library/index.md): Tool · C# library that reads Unreal Engine 1, 2 and 3 package files such as .u, .upk and .udk, auto-detects a matching game build and deserializes their exports, imports and properties. Its main goal is decompiling UnrealScript bytecode back to source by reconstructing classes, states, functions, structs, enums and default properties; it also deserializes fonts, sounds, palettes and textures. The README’s per-game compatibility table runs from Unreal and Deus Ex to Splinter Cell, Mass Effect and the Batman: Arkham games, and the separate UE Explorer GUI is built on it.
- [DiztinGUIsh](https://awesomerea.org/resources/diztinguish/index.md): Tool · Windows disassembler for Super NES ROMs in which the user marks bytes as code or data, steps through 65816 code while the tool tracks the M and X flags and the data bank and direct page registers, adds labels and comments, and exports assembly for the asar assembler that the README says compiles back into the original binary. Execution context can come from BizHawk or BSNES trace logs, BSNES usage maps and BizHawk code/data logs, or live capture over a socket from a custom bsnes-plus build. Project files keep the annotations in merge-friendly XML with a link and checksum for the ROM rather than the ROM itself, so several people can work on one disassembly.
- [Zygisk-Il2CppDumper](https://awesomerea.org/resources/zygisk-il2cppdumper/index.md): Tool · Zygisk module by Perfare, the Il2CppDumper author, that dumps type metadata from inside a Unity IL2CPP Android app while it runs. Built for one package name, it waits for the app to load libil2cpp.so, resolves the runtime's il2cpp API exports, walks the classes of every loaded assembly and writes dump.cs to the app's files directory, listing namespaces, classes, interfaces and enums with field offsets, properties and method signatures annotated with RVA and virtual addresses. On x86 devices running an ARM build of the app, it loads its ARM library through the Houdini native bridge.
- [UABEA](https://awesomerea.org/resources/uabea/index.md): Tool · Cross-platform reader and writer for the asset bundles and serialized asset files of Unity games, an independent project that started from the archived UABE. Its README presents it as a modding and research tool rather than an extractor and points users who only want to extract assets to AssetRipper or AssetStudio; it opens bundles from Unity's Addressables system, whose CRC checks must be cleared with a separate tool before edited bundles load. It builds on AssetsTools.NET with Cpp2IL and Mono.Cecil, and the repository includes texture, audio-clip, font and text-asset plugins.
- [AssetStudio](https://awesomerea.org/resources/assetstudio/index.md): Tool · Tool for exploring, extracting and exporting the assets and asset bundles of Unity versions 3.4 to 2022.1. It converts Texture2D and Sprite images to PNG, TGA, JPEG or BMP and AudioClip to MP3, OGG, WAV, M4A or FSB, with FSB-to-WAV conversion, and exports fonts, meshes as OBJ, text assets, shaders, movie and video clips and MonoBehaviour data as JSON; models export from the scene hierarchy, and Animators export to FBX with their bound AnimationClips. MonoBehaviour export asks for the folder holding the assemblies, such as Managed, or, for IL2CPP builds, the dummy DLLs that Il2CppDumper generates.
- [vgmstream](https://awesomerea.org/resources/vgmstream/index.md): Tool · Library and tools that decode streamed, prerecorded video game audio in hundreds of formats and codecs, from common game engine files to single-game codecs, including looped music, subsongs, companion files, custom containers and encryption keys. TXTH text descriptors add support for further formats, including raw audio, and TXTP files set per-file options such as forced looping or merging files. It ships as the vgmstream-cli decoder, which converts supported files to WAV, the vgmstream123 player and plugins for Winamp, foobar2000, XMPlay and Audacious, and an online web player is available at vgmstream.org.
- [pkg-to-anyps5](https://awesomerea.org/resources/pkg-to-anyps5/index.md): Tool · pkg-to-anyps5 extracts PS5 debug game packages or game folders into the layout expected by the AnyPS5 relinker. It parses FIH, PFS and NAPS structures, decodes supported Kraken blocks, and unwraps fake-signed SELF executables and modules into ELF files.
- [dfsdk](https://awesomerea.org/resources/dfsdk/index.md): Tool · dfsdk dumps Delta Force object metadata by enumerating its object array, decoding per-entry XOR-encrypted names and walking class super chains and property lists. The README documents name-pool addressing, pointer masking, selected field offsets and example output.
- [KBot](https://awesomerea.org/resources/kbot/index.md): Tool · KBot inspects and transforms Total Annihilation and TA: Kingdoms game files, pairing a Go CLI with a proprietary format reference. It decompiles COB bytecode to BOS source, disassembles scripts, checks round trips and examines formats including HPI archives, GAF sprites, TNT maps and 3DO models.
- [BNDExtract](https://awesomerea.org/resources/bndextract-kuon/index.md): Tool · BNDExtract is a Go command-line tool for extracting the ALL.BND archive used by Kuon and some other FromSoftware PlayStation 2 games. It takes a .bnd file and an output directory, providing access to the archive's contents for inspection.
- [RE4METoolbox](https://awesomerea.org/resources/re4me-toolbox/index.md): Tool · RE4METoolbox provides command-line utilities for examining and modifying Resident Evil 4 Mobile Edition files. RE4MEAcvTool unpacks and repacks ACV .bin archives, while RE4METextTool converts Mission and Resource .bin text files to TSV and repacks edited text.
- [Aspyr Archive Tool](https://awesomerea.org/resources/aspyr-archive-tool/index.md): Tool · Aspyr Archive Tool unpacks and rebuilds Android OBB archives used by three Aspyr game ports: Star Wars: Knights of the Old Republic II, Jade Empire: Special Edition and Fahrenheit: Indigo Prophecy Remastered. Its command-line options support full or selective compression and a CRC64 checksum for Jade Empire.
- [ScriptSource-Dumper](https://awesomerea.org/resources/scriptsource-dumper/index.md): Tool · ScriptSource-Dumper extracts scripts from Call of Duty: Black Ops II scriptsrc.clump archives. Its C++ parser reads the archive table of contents and data chunks, locates the internal name table, and writes files under their recovered names and directories.
- [.AUP-File-Type-Decryptor-and-Viewer](https://awesomerea.org/resources/dragon-soul-aup-viewer/index.md): Tool · .AUP-File-Type-Decryptor-and-Viewer is a local browser tool for inspecting Dragon Soul .aup game asset files. It implements the documented LZSS variant, previews image, audio and text formats, and exports files while preserving folder structure. The README specifies the four-byte size header and ring-buffer command stream.
- [Universal GBA Pokedex](https://awesomerea.org/resources/universal-gba-pokedex/index.md): Tool · Universal GBA Pokedex scans Game Boy Advance Pokémon ROMs to locate and display evolution, name and item tables. It searches byte signatures, scores candidate tables using text and pointer patterns, and aligns entries against known anchors instead of requiring fixed offsets.
- [VG Reverse Engineering](https://awesomerea.org/resources/vainglory-replay-decoder/index.md): Tool · VG Reverse Engineering decodes Vainglory: Community Edition replay files into recorded player names, heroes, K/D/A, items, gold and scoreboard counters. Its offline tools also export JSON and CSV, maintain a SQLite catalog and document VGR record and event interpretation. Output records provenance and leaves unsupported values unresolved.
- [Chip-8 Emulator and c8-disassembler](https://awesomerea.org/resources/chip8-emulator-disassembler/index.md): Tool · The c8-disassembler in Chip-8 Emulator translates CHIP-8 ROM opcodes into assembly instructions. Its source and sample Pong ROM listing show the supported output; the repository also contains a companion emulator whose SDL2 display is marked as work in progress.
- [BGI Converter TGA](https://awesomerea.org/resources/bgi-ethornell-converter-tga/index.md): Tool · BGI Converter TGA analyzes BGI-Ethornell game image files and converts custom RGB or RGBA layouts and BMP images into 32-bit TGA. Its C++17 utility detects formats from headers, reports dimensions and offsets, and supports single-file or batch conversion.
- [Xenus DT1 Decompiler](https://awesomerea.org/resources/xenus-dt1-decompiler/index.md): Tool · Xenus DT1 Decompiler extracts DT1 and DT2 texture caches from Xenus 2: White Gold and Boiling Point: Road to Hell; its current decoder has not been tested with The Precursors. Its C# decoder reimplements behavior recovered from VELoader.dll, handles zlib and UCL NRV2E streams, and exports DDS or converted image formats.
- [psp-media-slopkit](https://awesomerea.org/resources/psp-media-slopkit/index.md): Tool · psp-media-slopkit analyses PSP XMB ICON1.PMF and SND0.AT3 files using format findings derived from retail game samples. Its Python CLI checks media against documented XMB limits, converts video and audio into icon media, and inserts the results into a homebrew EBOOT.PBP. FINDINGS.md records PSMF container fields, H.264 constraints and AT3 playback behaviour.
- [DualRip](https://awesomerea.org/resources/dualrip/index.md): Tool · DualRip extracts Nintendo DS sound effects and music from SDAT archives and Nintendo 3DS audio from CSAR archives, including ROM inputs. It parses sequence, wave and stream formats, emulates the consoles' sound drivers for rendering and exports WAV files with loop points through CLI and GUI frontends.
- [YGO-PoC Toolset](https://awesomerea.org/resources/ygo-poc-toolset/index.md): Tool · YGO-PoC Toolset handles resource and save formats from Yu-Gi-Oh! Power of Chaos – Joey the Passion. Its unpacker extracts compressed game resource files such as data.dat, while PoCTools decrypts, edits and re-encrypts system.dat saves; the repository also includes a card editor and DLL mod loader.
- [FH6 Model Tools](https://awesomerea.org/resources/fh6-model-tools/index.md): Tool · FH6 Model Tools parses reverse-engineered Forza Horizon 6 asset formats, including burG model and texture containers. Python converters export car meshes to GLB or OBJ, textures to DDS, and selected material, palette, lighting, and ambient-occlusion data to readable outputs.
- [Ed1th's PvZ Toolkit](https://awesomerea.org/resources/ed1ths-pvz-toolkit/index.md): Tool · Ed1th's PvZ Toolkit inspects and edits Plants vs. Zombies resource archives and files through a desktop or web interface backed by Rust format libraries. Its workspaces cover RSB/RSG, PAK and DZip archives, RTON and NEWTON data, PAM animation, Compiled Text and Wwise WEM audio, among other formats.
- [kenshi-modkit](https://awesomerea.org/resources/kenshi-modkit/index.md): Tool · kenshi-modkit parses and writes Kenshi .mod and .base files and reads its .save, .zone and .platoon files using Python. Its format notes document filetypes 15–17 and inferred typecodes, while utilities dump records, compare saves, detect mod conflicts and check byte-identical round trips.
- [ffxii-tza-tools](https://awesomerea.org/resources/ffxii-tza-tools/index.md): Tool · ffxii-tza-tools documents and processes FINAL FANTASY XII The Zodiac Age character formats, including .ca animations, .cm models and .phyre assets. Its Python tools decode chunk structures, export models and animations to glTF, edit curves and repack @FRP containers from files extracted from the user’s game copy.
- [sims-package2glb](https://awesomerea.org/resources/sims-package2glb/index.md): Tool · sims-package2glb extracts models from The Sims 2, 3 and 4 .package files into glTF binary files. Its Rust parsers handle DBPF containers, RefPack compression, RCOL and GMDC geometry, textures, materials and recolours. The documentation records format findings including Sims 4 DST texture planes and relative RCOL chunk references.
- [vc64_240p](https://awesomerea.org/resources/vc64-240p/index.md): Tool · vc64_240p analyses and patches the N64 Virtual Console emulator inside Wii WAD channels to output 240p. It finds render-mode structures by pattern, changes video fields and disables deflicker; an optional patch removes the emulator's dark filter.
- [Unrpyc](https://awesomerea.org/resources/unrpyc/index.md): Tool · Unrpyc is a tool that decompiles compiled Ren'Py game scripts into readable script files. It runs from the command line or through files placed in a game's directory; it does not extract RPA archives.