Print or save the book

Game Hacking Academy

How games work, down to the bytes

00000000  47 61 6D 65 20 48 61 63  6B 69 6E 67 20 41 63 61  |Game Hacking Aca|
00000010  64 65 6D 79                                       |demy|

The title as it sits in memory: one byte per letter, written in hexadecimal.

155 lessons in 15 chapters. Printed from mustcodeal.github.io/rust-game-hacking-book, built 2026-10-18.

Grew out of the original Game Hacking Academy by attilathedud (gamehacking.academy). Published under the Apache License 2.0.

Choose a size before opening the browser’s Print dialog. Save as PDF is an option in that dialog. The complete book includes every lesson, diagram, code sample, and image; preparing it takes longer than a single lesson.

One lesson

On any lesson page, use Print this lesson in the reader toolbar. The current page is already loaded, so its print dialog can open immediately when its visuals are ready.

Find a lesson

One chapter

Open only the chapter you need. Its print page includes all of that chapter’s lessons, in reading order.

1. 1. Computer, Game, and Code Foundations10 lessons
2. 2. Following Instructions and Addresses10 lessons
3. 3. Typed Memory, Ownership, and Object Layouts11 lessons
4. 4. Game State and Bounded Decisions10 lessons
5. 5. Executable Maps, Instruction References, and Scans11 lessons
6. 6. Windows Processes and Callable Interfaces11 lessons
7. 7. Camera Geometry and Rendering APIs11 lessons
8. 8. In-Process Tools, Input, and Integration10 lessons
9. 9. Network Messages, Authority, and IPC10 lessons
10. 10. Game Files, Mods, and Artifact Trust10 lessons
11. 11. NPC Policy, Lua, and Script Execution11 lessons
12. 12. Loaders, Kernel Services, and Trust Boundaries10 lessons
13. 13. Physical Memory, Machines, and Hardware10 lessons
14. 14. Versioned Evidence, State, and Integrity10 lessons
15. 15. Defensive Design and Anti-Cheat10 lessons

Complete book

Prepare all 155 lessons, then print or save them together. Chapters load one at a time, so you can see progress or cancel before opening the print dialog.

Prepare complete book

The complete book has not been loaded.

Contents

1. Computer, Game, and Code Foundations

1. 1.1 Reasoning from Evidence
2. 1.2 How a Computer Runs a Game
3. 1.3 Game Fundamentals
4. 1.4 Programming Fundamentals
5. 1.5 Rust Primer: Logic in Code
6. 1.6 Hacking Fundamentals
7. 1.7 A Windows Lab You Can Reset
8. 1.8 How Memory Actually Works
9. 1.9 What a Memory Scan Really Finds
10. 1.10 Bits, Masks, Shifts, and Rotations

2. Following Instructions and Addresses

1. 2.1 What a Debugger Can Reveal
2. 2.2 How Source Becomes a Running Process
3. 2.3 How Assembly Describes a Running Game
4. 2.4 Breakpoints: One Moment of Program State
5. 2.5 From a Game Value to the Code That Changes It
6. 2.6 Tracing an Action Through Its Callers
7. 2.7 Why Addresses Move
8. 2.8 How Pointer Paths Survive Restarts
9. 2.9 How Detours Change Control Flow
10. 2.10 What a Working Detour Must Preserve

3. Typed Memory, Ownership, and Object Layouts

1. 3.1 Safe Boundaries for Game Memory
2. 3.2 Rust: Missing Values, Failures, and States
3. 3.3 Rust: Collections, Bounds, and Bytes
4. 3.4 Rust: Borrowed Views and Useful Interfaces
5. 3.5 Rust: Cleanup and Helpful Errors
6. 3.6 How Bytes Become Numbers and Pointers
7. 3.7 How External Tools Read Game Memory
8. 3.8 How C++ Objects Appear in Memory
9. 3.9 Object-Oriented Clues in Machine Code
10. 3.10 How Collections Live and Die in Memory
11. 3.11 How Text Becomes Bytes in a Game

4. Game State and Bounded Decisions

1. 4.1 Game Engines: Input, Simulation, and Rendering
2. 4.2 From One Player to a Game-State Snapshot
3. 4.3 Why Snapshots Need Guarded Actions
4. 4.4 Coordinates, Vectors, and Directions
5. 4.5 Maps as Grids of Game State
6. 4.6 Automation as a Feedback Loop
7. 4.7 From Coordinates to Target Selection
8. 4.8 Pathfinding on a Game Map
9. 4.9 When Changed State Becomes an Event
10. 4.10 How NPCs Sense and Decide

5. Executable Maps, Instruction References, and Scans

1. 5.1 What a Windows Executable Contains
2. 5.2 File Offsets, RVAs, and Live Addresses
3. 5.3 DLL Exports and Forwarded Names
4. 5.4 Instruction Reference: Values and Integer Arithmetic
5. 5.5 Instruction Reference: Decisions, Stack, and Bits
6. 5.6 Instruction Reference: Scalar Floating-Point Values
7. 5.7 Byte Signatures and Pattern Scanning
8. 5.8 Memory Regions and Value Scanning
9. 5.9 Instruction Decoding and Disassembly
10. 5.10 Event Tracing for Windows
11. 5.11 Parallel Scanning and Stable Snapshots

6. Windows Processes and Callable Interfaces

1. 6.1 The Running Game as a Process
2. 6.2 Game Runtimes and Object Lifetimes
3. 6.3 Process Access Rights
4. 6.4 Handle Ownership and Lifetimes
5. 6.5 Virtual Address Spaces and Page Protections
6. 6.6 Threads, Contexts, and Stacks
7. 6.7 What a DLL Function Promises Its Caller
8. 6.8 How an Engine Orders and Shares Its Work
9. 6.9 Windows Input: Polling, Events, and Messages
10. 6.10 Debug Events and Software Breakpoints
11. 6.11 Sampling Game State Under Load

7. Camera Geometry and Rendering APIs

1. 7.1 Camera Frames and Projection
2. 7.2 The Rendering Pipeline and Its State
3. 7.3 OpenGL Draw Calls and State
4. 7.4 Render Categories and Color Probes
5. 7.5 Camera Rays, Collisions, and Crosshairs
6. 7.6 Aim Geometry and Target Selection
7. 7.7 Recoil, Spread, and Camera Motion
8. 7.8 Radar Coordinates and Marker Filtering
9. 7.9 World-to-Screen Projection and Overlays
10. 7.10 Direct3D Interfaces and Vtables
11. 7.11 Direct3D Draw Calls and Bound State

8. In-Process Tools, Input, and Integration

1. 8.1 In-Process DLLs and Loader Boundaries
2. 8.2 DLL Loading Across Process Boundaries
3. 8.3 Detours and Reversible Patches
4. 8.4 Import Table Hooks
5. 8.5 How a Game Reads Input
6. 8.6 Menus as State and Command Interfaces
7. 8.7 In-Game Menus and Text Rendering
8. 8.8 Render Snapshots and Feature Integration
9. 8.9 Tool Architecture, Commands, and Cleanup
10. 8.10 Hooks as Live Control-Flow Changes

9. Network Messages, Authority, and IPC

1. 9.1 Messages, Streams, and Multiplayer
2. 9.2 What the Server Can See
3. 9.3 Protocol Capture and Message Framing
4. 9.4 Message Parsing and Serialization
5. 9.5 Protocol State Machines and Replay
6. 9.6 Clients, Handshakes, and Chat Automation
7. 9.7 Local Proxies and Bidirectional Streams
8. 9.8 Shared Memory Between Processes
9. 9.9 Named Pipes and Local Message Framing
10. 9.10 How the Source Engine Works

10. Game Files, Mods, and Artifact Trust

1. 10.1 Game Files and Live Memory
2. 10.2 Save Formats and Safe Editing
3. 10.3 Binary Saves and Hex Editing
4. 10.4 Textures and Asset Replacement
5. 10.5 Data-Driven Game Mods
6. 10.6 Mod Archives and Safe Extraction
7. 10.7 Reversible Mods and Manifests
8. 10.8 File Hashes and Digital Signatures
9. 10.9 Build Identity and Versioned Evidence
10. 10.10 Encryption and Key Lifecycles

11. NPC Policy, Lua, and Script Execution

1. 11.1 How an NPC Sees, Chooses, and Remembers
2. 11.2 Why Games Use Lua
3. 11.3 Lua Tables, Functions, and Metatables
4. 11.4 The Host–Script Boundary
5. 11.5 Snapshots as a Script Interface
6. 11.6 State Machines for Lua Automation
7. 11.7 Script Budgets, Errors, and Recovery
8. 11.8 What Any Computer Can Compute
9. 11.9 From Lua Source to a Tiny Virtual Machine
10. 11.10 Values, Tables, Strings, and Garbage Collection
11. 11.11 Call Frames, Closures, and Upvalues

12. Loaders, Kernel Services, and Trust Boundaries

1. 12.1 DLL Identity and Search Order
2. 12.2 DLL Loading and the Loader Lock
3. 12.3 Dynamic Windows API Resolution
4. 12.4 What an Operating System Kernel Does
5. 12.5 From Win32 Calls to Kernel Services
6. 12.6 System Calls and Privilege Checks
7. 12.7 How Device Drivers Work
8. 12.8 Driver Requests and Device Registers
9. 12.9 The Kernel Trust Boundary
10. 12.10 Failure Modes at Trust Boundaries

13. Physical Memory, Machines, and Hardware

1. 13.1 DMA and Physical Memory
2. 13.2 Virtual-to-Physical Address Translation
3. 13.3 Hypervisors and Virtual Machines
4. 13.4 Guest Execution and Address Translation
5. 13.5 Firmware and Bare-Metal Rust
6. 13.6 How Game Consoles Are Built
7. 13.7 Hardware Debugging with JTAG
8. 13.8 JTAG Scan Chains and Debug Access
9. 13.9 How Emulators Work
10. 13.10 Emulator Timing and State

14. Versioned Evidence, State, and Integrity

1. 14.1 Object Layouts Across Game Updates
2. 14.2 Call Tracing and Bounded Logs
3. 14.3 Crash Dumps as Process Snapshots
4. 14.4 Capture Provenance and Validation
5. 14.5 Game State and Invariants
6. 14.6 Telemetry as Evidence of Game Behavior
7. 14.7 Integrity Checks and Their Boundaries
8. 14.8 Anti-Debug Signals and Responses
9. 14.9 When Game Values Are Encoded
10. 14.10 Obfuscated Values and Reversible Transforms

15. Defensive Design and Anti-Cheat

1. 15.1 Why Games Need Anti-Cheat
2. 15.2 Server Plugins, Counters, and False Flags
3. 15.3 What Client Protection Can See
4. 15.4 How Detections Work
5. 15.5 Layers, Trust, and Review
6. 15.6 Cheat Categories from the Defender's Side
7. 15.7 Control Gaps in Toy Defenses
8. 15.8 Control Gaps in Game Logic
9. 15.9 Anti-Cheat in Modern Games
10. 15.10 Designing a Game That Is Hard to Cheat In

The complete book has not been prepared. Open this page on screen and choose “Prepare complete book” before printing.