re-game

Reverse engineer Unity, Unreal, Lua bytecode, and GPU shaders in game binaries.

64|9|Updated Aug 17, 2026
One-click install
npx skills add https://github.com/dslsdzc/rev-skills --skill re-game-dslsdzc
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: re-game
Source: https://github.com/dslsdzc/rev-skills/tree/main/.claude/skills/re-game
Command: npx skills add https://github.com/dslsdzc/rev-skills --skill re-game-dslsdzc

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Game reverse engineering requires navigating engine-specific formats (Unity mono/IL2CPP, Unreal GObjects), dynamic memory addresses that change every launch, script VM bytecode variants, and GPU shader IRs—each with incompatible tooling and version-specific pitfalls. ## Core Features & Use Cases - Engine Identification & Dumping: Distinguish Unity mono vs IL2CPP vs Unreal builds, then use Il2CppDumper or UnrealFinder to recover class/method signatures and function addresses. - Memory Analysis with Cheat Engine: Perform value scans, pointer-chain scans for ASLR-stable addresses, and locate functions via write-access breakpoints. - Lua/LuaJIT Bytecode Analysis: Identify VM versions by magic bytes, parse instruction layouts per version, extract constant tables, and hook luaL_loadbuffer/lua_pcall to intercept scripts. - Shader Reverse Engineering: Disassemble SPIR-V, DXBC/DXIL, and reconstruct GLSL, locating constant buffers and rendering entry points. - Use Case: Analyze an IL2CPP Unity game by dumping global-metadata.dat, mapping method addresses from script.json, then patching target functions in a sandboxed VM isolated from anti-cheat systems. ## Quick Start Analyze this Unity game directory and help me dump the IL2CPP metadata and locate the player health function address.

Frequently Asked Questions about re-game

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I reverse engineer an IL2CPP Unity game?▼

Use Il2CppDumper on the game executable and global-metadata.dat to produce dump.cs with class signatures and script.json with method addresses. Then load those addresses into a debugger or decompiler like Ghidra to analyze and patch target functions.

How to find stable memory addresses in games with Cheat Engine?▼

Run a value scan, change the value in-game, then use Next Scan to narrow results. Since ASLR changes addresses each launch, use Pointer Scan to save a pointer chain (.pt file) or express addresses as module base plus offset.

What is the difference between Lua and LuaJIT bytecode?▼

Standard Lua bytecode starts with \x1bLua plus a version byte, while LuaJIT uses \x1bLJ with its own version numbering. Their instruction sets are incompatible—LuaJIT uses ABC/AD formats with no Bx field, and LuaJIT 2.0 and 2.1 are mutually incompatible.

Why does my Lua bytecode disassembler produce garbage output?▼

The version detection is likely wrong—Lua 5.1 through 5.4 each have different instruction layouts, and 5.4 changed opcode width to 7 bits. Check the magic bytes and version byte first, and watch for obfuscated files with truncated or XOR-masked headers.

Can I analyze games with anti-cheat like EAC or BattlEye?▼

Only in a fully isolated environment: a dedicated offline VM with snapshots, never on live online sessions. Anti-cheat drivers detect debuggers, memory edits, and virtualization, so analyze detection points statically and restore snapshots afterward.

DXBC vs DXIL shader formats—which disassembler do I need?▼

Shader Model 5.x and below use DXBC bytecode with SHDR/SHEX chunks, while SM6+ uses DXIL, an LLVM bitcode-style format. Both share the DXBC container magic, so check the shader model version first and look for the DXIL sub-object for SM6+.