pcx-ai-toolkit

The Complete AI-Powered Scripting Toolkit for Perception.cx

Turn any LLM into an expert Perception.cx developer.
Complete Enma language docs, every PCX API, coding guidelines, MCP configs, and LSP servers — in one package.

Quick Start · Documentation · AI Skills · MCP Integration · Contributing

The Problem

LLMs don't know Enma. They don't know the Perception.cx API. Ask them to write a PCX script and they hallucinate function names, invent parameters, and produce code that doesn't compile.

The Solution

Give the AI 34,000+ lines of real documentation and 12 coding rules that prevent the most common mistakes. The AI reads the actual docs before writing code, follows real API signatures, and produces scripts that work.

Before:  "Write me an ESP overlay"
AI:      *invents draw_esp(), uses int for addresses, forgets null checks*
Result:  Doesn't compile. Wrong types. Silent crashes.

After:   "Write me an ESP overlay"  (with pcx-ai-toolkit loaded)
AI:      *reads render-api.md, uses draw_rect + draw_text, uint64 addresses, validates pointers*
Result:  Compiles. Runs. Correct API calls.

Quick Start

Linux / macOS / WSL / Git Bash:

git clone --recursive https://github.com/VoidChecksum/pcx-ai-toolkit.git
cd pcx-ai-toolkit
./setup.sh

Windows 10 / 11 (PowerShell):

git clone --recursive https://github.com/VoidChecksum/pcx-ai-toolkit.git
cd pcx-ai-toolkit
powershell -ExecutionPolicy Bypass -File setup.ps1

Drop the rules into your project and the AI reads docs before writing code:

cp rules/CLAUDE.md /path/to/your/pcx-project/   # Linux/macOS
copy rules\CLAUDE.md C:\path\to\your\project\   # Windows

Requirements: Node.js 18+ · Git · Git LFS (for the analysis suite)

Installation Guide

Part 1 — Toolkit (docs, skills, rules, LSP)

This is the main repo. No binary payloads, no build step.

git clone --recursive https://github.com/VoidChecksum/pcx-ai-toolkit.git
cd pcx-ai-toolkit

# Linux / macOS / WSL
./setup.sh

# Windows
powershell -ExecutionPolicy Bypass -File setup.ps1

setup.sh / setup.ps1 installs:

LSP servers (Enma + AngelScript) built from submodules
AI skills registered with Claude Code (if detected)
Skill docs copied to ~/.claude/skills/

Part 1.5 — Auto-Update

To update the toolkit, pull the latest documentation/skills, rebuild LSP servers, and regenerate the llms-index corpus automatically:

Linux / macOS / WSL / Git Bash:

./tools/update-toolkit.sh

Windows 10 / 11 (PowerShell):

powershell -ExecutionPolicy Bypass -File tools/update-toolkit.ps1

Supported flags:

--check / -Check: Check only — prints whether an update is available (exits 1 if update is available, 0 if up to date).
--force / -Force: Force run all post-update hooks (LSP rebuild, skill refresh, index regeneration) even if already up-to-date.
--skip-lsp / -SkipLsp: Skip rebuilding the LSP servers.
--skip-skills / -SkipSkills: Skip copying AI skills to ~/.claude/skills/.
--skip-bundles / -SkipBundles: Skip checking/regenerating the llms-index bundles under docs/.

Part 2 — Analysis Suite (headless, fully automatic)

Installs the static analysis tool permanently for your OS, patches the binaries, generates the license, activates the Python bindings, and wires up the binary analysis MCP server for Claude Code — zero interaction, one command.

Prerequisites

Prerequisite	Linux / WSL	macOS	Windows
Node.js 18+	`sudo apt-get install nodejs`	`brew install node`	installer from nodejs.org
Xvfb	`sudo apt-get install xvfb`	not needed	not needed
Git LFS	`sudo apt-get install git-lfs`	`brew install git-lfs`	git-lfs.github.com
Python 3.11+	installed automatically via uv	installed automatically via uv	installed automatically via uv

Why Xvfb? The installer binary uses Qt for its UI layer even in unattended mode. The script spins up a throwaway virtual display, runs the installer through it, then tears it down. You never see a window.

Install

# Pull the installer binaries (stored in Git LFS, ~3 GB)
git lfs pull

# Linux / macOS / WSL — one command does everything
./installers/install.sh

# Windows — run PowerShell as Administrator if installing to Program Files
git lfs pull
powershell -ExecutionPolicy Bypass -File installers\install.ps1

What happens, step by step

Step	Linux / macOS	Windows
1	Checks Node.js + Xvfb are available	Checks Node.js is available
2	Spins up a Xvfb virtual display	—
3	Runs the native `.run` / `.app.zip` installer silently via `--mode unattended`	Runs `.exe` installer silently via `--mode unattended`
4	`node keygen.js` patches `libida.so` + `libida32.so` (or `.dylib`) in-place	Pre-patched `ida.dll` + `ida32.dll` dropped into the install dir
5	`node keygen.js` writes `idapro.hexlic` to the install dir	Same
6	Installs `uv` if not present	Same
7	Installs Python 3.11+ via uv if not present	Same
8	Activates idalib Python bindings via `py-activate-idalib.py`	Same
9	`uv tool install ida-pro-mcp`	Same
10	Merges `binary-analysis` entry into `~/.claude/mcp.json`	Merges into `%USERPROFILE%\.claude\mcp.json`

Options

# Custom install location (default: /opt/ida-pro-9.3 or ~/ida-pro-9.3)
./installers/install.sh --prefix /opt/mydir

# Skip MCP server install (just install + patch the suite)
./installers/install.sh --skip-mcp

# Custom install location (default: C:\Program Files\IDA Professional 9.3)
.\installers\install.ps1 -Prefix "D:\tools\ida"

# Skip MCP server install
.\installers\install.ps1 -SkipMcp

Already have it installed?

Skip the 3 GB download — just activate the bindings and wire up MCP:

# Linux / macOS / WSL
./mcp/setup-binary-analysis.sh                            # auto-detect install dir
./mcp/setup-binary-analysis.sh --install-dir /your/path  # explicit path
./mcp/setup-binary-analysis.sh --skip-pkg                # skip package download too

# Windows
.\mcp\setup-binary-analysis.ps1
.\mcp\setup-binary-analysis.ps1 -InstallDir "D:\tools\ida"
.\mcp\setup-binary-analysis.ps1 -SkipPkg

After install

Restart Claude Code. The binary-analysis MCP server is now available:

# Headless — stdio (used automatically by Claude Code)
uvx idalib-mcp --stdio

# HTTP — for persistent sessions or multiple clients
uvx idalib-mcp --host 127.0.0.1 --port 8745

# Optional GUI plugin (connects to a live interactive session via SSE)
pip install ida-pro-mcp && ida-pro-mcp --install

Upgrade the MCP server at any time:

uv tool upgrade ida-pro-mcp

What's Inside

Documentation

110 pages, 35,000+ lines

Complete Enma language spec
All 18 standard library addons
Full C++ SDK embedding guide
Every PCX API (Enma, AngelScript, Lua)
IDE, Extensions, Analyzer docs

AI Skills

23 Claude Code / OMC skills

game-hacking-pcx — doc index, API rules
game-cheat-guidelines — 12 behavioral rules (Enma)
pcx-angelscript-discipline — 10 AS-specific rules (@ handles, &out, array<T>)
pcx-lua-discipline — 10 Lua-specific rules (int subtype, pcall, hot-reload)
pcx-coding-discipline — Karpathy workflow: scripts
pcx-re-discipline — Karpathy workflow: RE
pcx-debug-overlay — diagnostic surfaces separate from production overlay
pcx-knowledge-index — the three surfaces (llms.txt + bundles + MCP) and when to use each
ai-pair-programming — workflow for driving Claude/Cursor/Cline/Aider/Copilot
re-evidence-log — every offset cites its proof (E-NNN cross-refs)
pcx-patch-day-playbook — ordered triage when the game updates
multi-binary-targeting — one script across N game versions / arches / storefronts
script-bundler — packaging, hot-reload boundaries, pre-ship hygiene
pcx-perf-budget — frame-time targets + mono_us profiler recipe
pcx-streamproof — capture-path taxonomy for OBS / Discord / capture cards
mcp-tool-routing — which of the 37 Perception MCP tools for which task
anti-cheat-re — kernel AC methodology
kernel-analysis — driver analysis patterns
deobfuscation — unpacking and string deobfuscation
pcx-bloat-audit — scan code for unnecessary/redundant imports & helpers
pcx-bloat-review — manual code complexity review guidelines
pcx-defer-ledger — cleanup/RAII validation for temporary resources
rust-python-integration — multi-binary Cargo architecture + Python proxies & fallbacks

Auto-trigger on .em / .as / .lua work and PCX topics.

Knowledge Base

23 reference files

Enma + PCX API cheatsheets
Working code patterns (13 recipes)
GUI design patterns (section layout, slider discipline, hotkey conventions)
Cross-language bridge (Enma vs AngelScript vs Lua decision guide)
Offset-finding methodology, RE plugin reference
Aimbot math (atan2, FOV, prediction, smoothing)
Multi-file script organization patterns (extends templates/full-project/)
Network protocol RE (packet capture, dissection, wire-to-memory mapping)
PCX API version matrix (since-version table sourced from changelogs)
Anti-cheat architecture (EAC/BE/Vanguard/...) + kernel-RE tools
5 engine RE references: CryEngine, Frostbite, RE Engine, REDengine, Godot

Tooling & Indexed Knowledge

MCP + LSP + Rules + 3 LLM-knowledge surfaces

Perception MCP (42+ live-process tools)
pcx-knowledge-mcp (search + fetch over 211 docs)
Enma + AngelScript LSPs (syntax, completion, hover)
docs/llms.txt + 6 concatenated context-pack bundles
Rules drop-ins for Claude / Cursor / Cline / Copilot
16 standalone tools (Python + bash, stdlib-only)

Indexed Knowledge Surfaces

Three complementary surfaces let any AI tool reach the toolkit's corpus efficiently. Pick by integration model; see .claude/skills/pcx-knowledge-index/SKILL.md for the full decision tree.

#	Surface	What it is	Who uses it	Cost
1	`docs/llms.txt`	45 KB structured index (Anthropic / Mintlify convention)	Tools that auto-fetch the convention (Claude, Cursor, ...)	45 KB context
2	`docs/llms-perception-{enma,angelscript,lua}.md`	Per-language concatenated context packs (215 KB - 950 KB)	Aider `/read`, Cursor / Continue `@file`, Copilot paste	bundle size
2	`docs/llms-skills.md` / `llms-knowledge.md`	All 23 skills / all 23 knowledge refs concatenated	Same as above, category-focused	323-350 KB
2	`docs/llms-full.txt`	Full corpus concatenation (~2 MB)	All-language sessions in non-MCP tools	2 MB context
3	`mcp/pcx-knowledge-mcp/`	Python MCP server with `search` / `get_file` / `list_files` / `overview`	Claude Desktop, Cline, Continue, Zed, any MCP-aware tool	one process, <100 ms cold

All static bundles are generated by tools/build-llms-index.py. CI runs build-llms-index.py --check on every push; the build fails if the committed bundles drift from the source.

Combine #2 + #3 for the best of both worlds: small upfront context for your primary language + searchable depth for everything else. Recommended for long sessions.

Perception IDE — Built-In Script Editor and AI Assistant

Script Editor + Settings	AI Chat + Tool Calls
42+ RE Tools available via MCP

_{Screenshots from the Perception IDE documentation}

Directory Structure

pcx-ai-toolkit/
│
├── docs/                             110 pages of documentation
│   ├── enma/                         ── Enma language, addons, SDK (50 files)
│   │   ├── llms-language.md              Complete language reference (2,861 lines)
│   │   ├── llms-sdk.md                   Complete SDK reference (832 lines)
│   │   ├── lang-*.md                     Language guide (10 files)
│   │   ├── addon-*.md                    18 standard library addons
│   │   └── sdk-*.md                      SDK embedding guide (17 files)
│   │
│   └── perception/                   ── Perception.cx platform APIs
│       ├── *.md                          Enma APIs (17 files)
│       ├── angelscript/                  AngelScript APIs (23 files)
│       └── lua/                          Lua APIs (17 files)
│
├── .claude/skills/                   ── AI Skills (23)
│   ├── game-hacking-pcx/                Doc index + coding rules
│   ├── game-cheat-guidelines/           12 behavioral guidelines (Enma)
│   ├── pcx-angelscript-discipline/      10 AS-specific rules
│   ├── pcx-lua-discipline/              10 Lua-specific rules
│   ├── pcx-coding-discipline/           Karpathy workflow — writing scripts
│   ├── pcx-re-discipline/               Karpathy workflow — reverse engineering
│   ├── ai-pair-programming/             Driving Claude/Cursor/Cline/Aider/Copilot well
│   ├── re-evidence-log/                 Evidence-citation discipline (E-NNN cross-refs)
│   ├── pcx-patch-day-playbook/          Patch-day triage workflow (7 steps)
│   ├── multi-binary-targeting/          One script, N versions/arches/storefronts/channels
│   ├── script-bundler/                  Packaging + ship-day hygiene + .emb workflow
│   ├── pcx-perf-budget/                 Frame-time targets + profiler recipe
│   ├── pcx-streamproof/                 Capture-path taxonomy for OBS / Discord / cards
│   ├── pcx-debug-overlay/               Diagnostic / profiler / status overlay (gated, read-only)
│   ├── pcx-knowledge-index/             How AI tools reach the corpus: llms.txt + bundles + MCP
│   ├── mcp-tool-routing/                Decision guide across the 37 Perception MCP tools
│   ├── deobfuscation/                   Unpacking and string deobfuscation
│   ├── pcx-bloat-audit/                 Scan code for unnecessary/redundant imports & helpers
│   ├── pcx-bloat-review/                Manual code complexity review guidelines
│   ├── pcx-defer-ledger/                Cleanup/RAII validation for temporary resources
│   ├── rust-python-integration/         Multi-binary Cargo architecture + Python proxies & fallbacks
│   ├── anti-cheat-re/                   Kernel AC RE methodology (6 steps)
│   └── kernel-analysis/                 Driver analysis patterns (WDM/KMDF)
│
├── knowledge/                        ── Quick References
│   ├── enma-cheatsheet.md                Language quick-ref card
│   ├── pcx-api-cheatsheet.md             All APIs at a glance
│   ├── pcx-version-matrix.md             Since-version API matrix (sourced from changelogs.md)
│   ├── pcx-cross-language-bridge.md      Enma vs AngelScript vs Lua decision guide
│   ├── gui-design-patterns.md            PCX sidebar layout + slider/hotkey/color discipline
│   ├── script-organization-patterns.md   Multi-file project organization beyond full-project/
│   ├── anti-cheat-architecture.md        EAC/BE/Vanguard/GG architecture + detection matrix
│   ├── kernel-re-tools.md                Kernel RE tool reference (WinDbg, HyperDbg, Volatility, etc.)
│   ├── common-patterns.md                13 working code recipes
│   ├── re-plugins-and-tools.md           IDA/Ghidra plugins, FLIRT sigs, diffing, ret-sync
│   ├── offset-methodology.md             Sig scanning methodology
│   ├── aimbot-math.md                    angles, FOV, prediction, recoil comp, smoothing
│   ├── engine-cryengine.md               CryEngine family (Hunt: Showdown, Star Citizen, KCD)
│   ├── engine-frostbite.md               Frostbite (Battlefield, FIFA, Anthem, Andromeda)
│   ├── engine-godot.md                   Godot 3.x / 4.x (Brotato, Cassette Beasts, Halls of Torment)
│   ├── engine-re-engine.md               RE Engine (RE2/3/4, MH Rise/Wilds, SF6, DD2)
│   ├── network-protocol-re.md            Packet capture + dissection + wire-to-memory mapping
│   └── engine-redengine.md               REDengine (Cyberpunk 2077, Witcher 3)
│
├── installers/                       ── Analysis Suite Installers (Git LFS)
│   ├── install.sh                        Full install — Linux / macOS / WSL
│   ├── install.ps1                       Full install — Windows
│   ├── keygen.js                         License generator + in-place patcher
│   ├── ida-pro_93_x64linux.run           Linux x64 installer  [LFS]
│   ├── ida-pro_93_armlinux.run           Linux ARM64 installer [LFS]
│   ├── ida-pro_93_x64mac.app.zip         macOS x64 installer  [LFS]
│   ├── ida-pro_93_armmac.app.zip         macOS ARM64 installer [LFS]
│   ├── ida-pro_93_x64win.exe             Windows x64 installer [LFS]
│   └── kg_patch/win/                     Pre-patched Windows DLLs [LFS]
│
├── rules/                            ── Project Rules
│   ├── CLAUDE.md                         Drop-in for Claude Code
│   ├── CURSOR.md                         Drop-in `.cursorrules` for Cursor
│   ├── CLINE.md                          Drop-in custom instructions for Cline (VS Code agent)
│   ├── COPILOT.md                        Drop-in `.github/copilot-instructions.md` for GitHub Copilot
│   ├── AGENTS.md                         6 agent role definitions
│   └── KARPATHY.md                       Work-discipline drop-in (4 principles)
│
├── mcp/                              ── MCP Configs
│   ├── perception-mcp-config.json        42+ tool definitions
│   ├── claude-code-setup.md              Claude Code guide
│   ├── cursor-setup.md                   Cursor guide
│   ├── aider-setup.md                    Aider CLI integration (.aider.conf.yml, CONVENTIONS.md)
│   ├── continue-setup.md                 Continue extension (VS Code / JetBrains) integration
│   ├── zed-setup.md                      Zed editor MCP + agent panel setup
│   ├── binary-analysis-setup.md          Binary analysis MCP reference
│   ├── setup-binary-analysis.sh          MCP-only setup (if already installed)
│   ├── setup-binary-analysis.ps1         MCP-only setup — Windows
│   └── pcx-knowledge-mcp/                MCP server: search + fetch over the toolkit corpus
│
├── lsp/                              ── Language Servers (submodules)
│   ├── enma-lsp/                         Enma: completion + diagnostics
│   └── angel-lsp-pcx/                   AngelScript: completion + diagnostics
│
├── visualstudio/                     ── Visual Studio 2022 Extensions
│   ├── EnmaVS/                           Enma ILanguageClient (.vsix source)
│   └── AngelScriptVS/                    AngelScript ILanguageClient (.vsix source)
│
├── templates/                       ── Starter Scripts
│   ├── hello-world.em                    Minimal lifecycle + render
│   ├── overlay-basic.em                  GUI menu + config-driven overlay
│   ├── aimbot-skeleton.em                Closest-target-in-FOV with smoothing + RIP resolver
│   ├── minimap.em                        Rotation-aware radar with rim clamping
│   ├── full-project/                     5-file Enma project scaffold
│   └── full-project-as/                  3-file AngelScript scaffold (globals.as, feature.as, main.as)
│
├── signatures/source-engine/         ── Signature Examples
├── signatures/unreal-engine/         ── UE Reversal (GWorld, GObjects, Dumper-7)
├── signatures/anti-cheat/            ── AC Driver Patterns (EAC, BE, Vanguard, callbacks)
├── signatures/unity-il2cpp/          ── IL2CPP Patterns (metadata, static fields, schemas)
├── signatures/source2-engine/        ── Source 2 Patterns (schema system, entity list, W2S)
├── signatures/obfuscation/           ── Protector ID Patterns (VMP, Themida, OLLVM, packers)
│
├── tools/                            ── Standalone RE Tools (Python, no deps beyond stdlib)
│   ├── identify-protector.py            Detect VMProtect/Themida/UPX/etc. by sections + byte sigs
│   ├── pe-section-analyzer.py           Entropy analysis, packing detection, anomaly flagging
│   ├── resolve-api-hashes.py            Resolve API hashes (ROR13, CRC32, DJB2, FNV-1a, MurmurHash3, SDBM)
│   ├── dump-strings-xor.py              Extract XOR-encrypted strings (brute-force single-byte keys)
│   ├── anti-debug-scanner.py            Flag anti-debug surfaces in a PE (PEB / RDTSC / IsDebuggerPresent / window class)
│   ├── module-export-mapper.py          List exports; cross-reference which consumers import each
│   ├── offset-diff.py                   Diff named sigs between two binary versions (patch-day workflow)
│   ├── sig-uniqueness-checker.py        Verdict per sig: UNIQUE / AMBIGUOUS / STALE / BRITTLE
│   ├── pattern-format-converter.py      Round-trip patterns: IDA / Ghidra / x64dbg / CE / Enma / C
│   ├── dumper-to-enma.py                Dumper-7 / IL2CPPDumper / hazedumper → offsets.em
│   ├── binary-diff-summary.py           High-level diff between two PE versions (% changed, verdict)
│   ├── evidence-log-validator.py        Cross-check offsets.em vs evidence/<hash>.md citations
│   ├── script-linter.py                 Light 12-guidelines static check on .em files
│   ├── pre-ship-check.sh                Pre-release hygiene checklist (12 checks, --json output)
│   ├── install-re-tools.sh              One-command installer: IDA/Ghidra plugins + Python packages
│   └── build-llms-index.py              Generate docs/llms.txt + bundles (--check for CI drift)
├── setup.sh                          One-command LSP + skills install
├── CONTRIBUTING.md                   Contribution guide
└── LICENSE                           MIT

Documentation Coverage

107 out of 107 gitbook pages — 100% coverage of both the Enma and Perception.cx documentation.

Corpus	Files	Lines	Coverage
Enma Language	50	13,518	Every type, operator, control flow, function, pointer, struct, class, template, coroutine, exception, FFI, annotation, module, preprocessor + all 18 addons + full SDK
PCX Enma APIs	17	3,915	Proc, Render, GUI, Input, CPU, Zydis, Unicorn, Net, Win, Filesystem, Sound, Lifecycle, MCP, IDE, Extensions, Analyzer
PCX AngelScript APIs	23	10,820	All of the above + Intrinsics, Zydis Encoder, Bit Reinterpret, Mutex, Atomic Types, CS2 Extended
PCX Lua APIs	17	5,779	All core APIs in Lua syntax
Total	110	35,222

Plus 7 generated bundles at docs/llms-*.{txt,md} (~4.5 MB total) — the indexed-knowledge surface generated by tools/build-llms-index.py. See the Indexed Knowledge Surfaces section above.

Enma Language Docs Breakdown

Language Guide — 10 files, 3,150 lines (click to expand)

File	Lines	Topics
`lang-basics.md`	267	Types, variables, constants, operators, control flow
`lang-functions.md`	247	Parameters, defaults, refs, out, variadic, lambdas, closures
`lang-pointers.md`	357	Heap pointers, address-of, member access, null, return-by-ref
`lang-structs-and-classes.md`	912	Value/ref types, inheritance, vtable, interfaces, mixins, operators
`lang-templates.md`	173	Generic structs and functions, monomorphization
`lang-advanced.md`	562	Delegates, namespaces, coroutines, exceptions, smart ptrs, FFI
`lang-annotations.md`	209	packed, align, reflect, serialize, export, dll, custom
`lang-modules.md`	100	Import system, aliased imports, .emb, multi-module linking
`lang-pre-processor.md`	77	#define, #ifdef, #include, #pragma
`lang-semantics-and-limits.md`	181	Guarantees, compile-time rejects, what doesn't exist

Standard Library Addons — 18 files, 2,528 lines (click to expand)

Addon	Lines	Key Types / Functions
Core	42	`print`, `println`
Strings	165	`format`, `to_int`, `split`, `replace`, `substr`, interpolation
Arrays	119	`T[]`, `push`, `pop`, `sort`, `contains`, `slice`
Maps	200	`map<K,V>`, `imap<V>`, `get`, `set`, iteration
Math	137	`sin`, `cos`, `atan2`, `sqrt`, `clamp`, `lerp`, `random`
SIMD	128	SSE2: `f32x4`, `i32x4` vector ops
Vectors	135	`vec2`, `vec3`, `vec4`
3D Math	182	`quat`, `mat4`
Variant	130	Type-erased value container
Atomic	94	`aint32`, `aint64` atomic ops
Bits	117	`popcount`, `clz`, `ctz`, `bswap`, `rotl`
Time	95	`time_ms`, `time_us`, ISO 8601, `sleep`
Regex	61	`match`, `find`, `replace`, `split`, captures
File	125	Sandboxed file I/O (permission-gated)
Thread	120	`mutex`, `lock_guard`, `condition_variable`
Hash Set	89	`hash_set<T>`
Sorted Map	89	`sorted_map<K,V>` ordered iteration
List	192	Double-ended O(1) push/pop
JSON	108	`json_parse`, `json_stringify`, `json_value`

SDK Embedding Guide — 17 files, 3,795 lines (click to expand)

File	Lines	Topic
`sdk-quick-start.md`	126	Minimal embedding example
`sdk-engine-lifecycle.md`	166	Create, configure, destroy
`sdk-compilation.md`	65	Compile from source/files
`sdk-execution.md`	103	Contexts, execute, read returns
`sdk-calling-functions.md`	82	Pass arguments from host
`sdk-globals.md`	79	Read/write script globals
`sdk-type-registration.md`	862	type_builder — expose native types
`sdk-native-functions.md`	446	Register host-callable functions
`sdk-hot-reload.md`	64	Replace code at runtime
`sdk-serialization-and-linking.md`	97	.emb binaries, multi-module
`sdk-introspection.md`	317	List functions, annotations, IR dump
`sdk-lifecycle.md`	227	Deterministic RAII, no GC
`sdk-debug-and-gc.md`	202	Debug hooks, budgets, heap stats
`sdk-error-handling.md`	116	Compile/runtime error reporting
`sdk-safety.md`	121	Fault trapping, sandboxing, permissions
`sdk-custom-addons.md`	576	Build your own addon
`sdk-api-reference.md`	411	Complete function listing

AI Skills

`game-hacking-pcx` — Documentation Router

Forces the AI to read the correct doc file before writing any PCX API call.

User:  "Write me a render overlay"
AI:    → reads docs/perception/render-api.md (264 lines)
       → reads docs/perception/lifecycle-and-routines.md (134 lines)
       → writes code using real function signatures

Contains: file-by-file index of all 107 docs, critical Enma type rules, address type requirements, RAII notes.

`game-cheat-guidelines` — 12 Behavioral Rules

#	Rule	What It Prevents
1	Ground every offset	Hours wasted on stale offsets from an old SDK version
2	`uint64` for all addresses	Sign-extension corruption on high usermode addresses
3	Validate every pointer	Silent null reads returning plausible-looking garbage
4	Separate update from render	Overlay stutter when memory reads block the draw path
5	Sigs over hardcodes	Script breaking on every game patch
6	One feature, one file	2000-line monoliths that can't be hot-reloaded
7	Construct colors/vecs per frame	Pointless globals for 4-byte stack-allocated structs
8	`f` suffix on float32	Silent float64→float32 truncation in vertex buffers
9	Minimize memory writes	Unnecessary detection surface area
10	W2S once, correctly	Behind-camera coordinate mirroring, wrong matrix layout
11	GUI for all tunables	Recompiling just to change a distance threshold
12	Verify with the binary	Trusting stale cached offsets over live reality

Each rule includes wrong/right code examples using real Perception.cx APIs.

`pcx-coding-discipline` — Karpathy Workflow for Writing Scripts

The four Karpathy principles rewritten for script development: state the target and tradeoff before coding, ship the simplest feature that works, keep edits to one feature per diff, and define "done" as visible success criteria on the live target — not "it compiles."

`pcx-re-discipline` — Karpathy Workflow for Reverse Engineering

The same four principles for offset work: hypothesize and cite evidence before trusting a field, find the shortest unique signature, re-verify only what a patch broke, and trust live memory over a stale SDK. The discipline layer above game-cheat-guidelines' code-shape rules.

`anti-cheat-re` — Kernel Anti-Cheat RE Methodology

Six-step workflow for reversing kernel-level anti-cheat systems (EAC, BattlEye, Vanguard, GameGuard, XIGNCODE3): map the component stack, catalog every kernel callback, trace the driver↔user-mode communication channel, identify what the AC actually scans for, analyze from below the AC's observation layer, and verify findings against live behavior.

`kernel-analysis` — Driver Analysis Patterns

Technical patterns for reversing Windows kernel drivers: identify WDM vs KMDF, extract the IOCTL dispatch table and decode CTL_CODE, enumerate registered kernel callbacks with structures and WinDbg commands, analyze integrity check routines (hashing, RDTSC timing, CPUID hypervisor detection, unsigned driver scanning), decode obfuscation layers (import resolution, encrypted strings, control flow flattening, VMProtect), and reconstruct shared memory communication channels.

Plus 12 more skills

pcx-angelscript-discipline · pcx-lua-discipline · re-evidence-log · pcx-patch-day-playbook · multi-binary-targeting · script-bundler · pcx-perf-budget · pcx-streamproof · pcx-debug-overlay · pcx-knowledge-index · ai-pair-programming · mcp-tool-routing

Browse the full set at .claude/skills/. Every skill auto-triggers on relevant keywords / file extensions.

Knowledge Base

Enma Cheatsheet

knowledge/enma-cheatsheet.md — 164 lines

Every primitive type with size, all conversion rules, control flow, functions, structs vs classes, templates, arrays, maps, strings, pointers, coroutines, exceptions, modules, preprocessor, annotations.

PCX API Cheatsheet

knowledge/pcx-api-cheatsheet.md — 232 lines

Every function signature across all 13 Perception.cx APIs: Proc, Render, GUI, Input, CPU, Zydis, Unicorn, Net, Win, Filesystem, Sound, Lifecycle, MCP.

Common Patterns

knowledge/common-patterns.md — 339 lines

13 complete working examples:

Process attach + module resolve
Pattern scan + RIP resolution
Entity list with null guards
World-to-screen (4x4 matrix)
Box overlay + health bars
Snaplines, distance text
Angle calc, smooth interp
GUI menu, config save/load
Minimap / radar with rotation
Full script skeleton

Offset Methodology

knowledge/offset-methodology.md — 130 lines

Pattern scanning, wildcard strategy, RIP-relative resolution table, pointer chain walking, struct_dump discovery, IDA/Ghidra cross-referencing, offset table format, patch stability analysis.

Anti-Cheat Architecture

knowledge/anti-cheat-architecture.md

Per-AC architecture reference (EAC, BattlEye, Vanguard, GameGuard, XIGNCODE3, Theia): components, driver behavior, communication protocols, known detection vectors, detection technique matrix. Includes AC-by-game mapping for all PCX-supported titles.

Kernel RE Tools

knowledge/kernel-re-tools.md

Tool reference for kernel-level RE: static analysis (IDA, Ghidra, r2), kernel debugging (WinDbg, VirtualKD-Redux, HyperDbg), memory forensics (Volatility 3, MemProcFS, PCILeech), runtime monitoring (Process Monitor, IRPMon), driver development/testing (WDK, OSR Driver Loader), and Perception.cx kernel integration.

RE Plugins & Tools

knowledge/re-plugins-and-tools.md

Complete reference for the installed RE toolkit: 6 IDA plugins (hrtng deobfuscation, CodeXplorer vtable recovery, ClassInformer RTTI, SigMakerEx pattern generation, FIRST function fingerprints, RevEng.AI similarity), 4 Ghidra extensions (GhidrAssist LLM integration, BinDiffHelper, OOAnalyzer C++ recovery, RevEng.AI), 3 FLIRT signature databases (51 pre-selected MSVC v15 sigs), Diaphora + BinDiff for cross-patch analysis, ret-sync for live debugger↔disassembler sync, and 2,438 reversed r5sdk headers.

Plus 17 more knowledge files

Browse the full set at knowledge/. Topics include: aimbot-math · gui-design-patterns · script-organization-patterns · pcx-version-matrix · pcx-cross-language-bridge · network-protocol-re · 5 engine RE references (CryEngine, Frostbite, RE Engine, REDengine, Godot) · obfuscation taxonomy · deobfuscation tools · game targets · custom draw patterns · community tools.

MCP Integration

Perception MCP Server

42+ tools exposed via JSON-RPC — connect any MCP-compatible AI to Perception's live tooling.

Full tool list (click to expand)

Process Memory read_memory · read_typed_value · find_pattern · read_pointer_chain · read_string · memory_write

Analysis disassemble · struct_dump · find_xrefs · find_string_refs · find_function_bounds · analyze_function · trace_register · analyze_vtable · read_rtti · generate_signature · build_call_graph

Scanning scan_string · scan_wstring · scan_pointer_to · scan_value · scan_changed · diff_memory

Process Info list_processes · get_process_info · get_module_exports · get_module_imports

Files & Scripts read_file · write_file · edit_file · search_text · find_references · check_script · validate_script · execute_script · get_script_api · web_search

Config: mcp/perception-mcp-config.json

Supported AI Tools

Tool	How	Guide
Claude Code	Skills + CLAUDE.md + MCP	`claude-code-setup.md`
Claude Desktop	`pcx-knowledge-mcp` for search; bundles for preload	`pcx-knowledge-mcp/README.md`
Cursor	`.cursorrules` + MCP + `@docs` bundles	`cursor-setup.md`
Cline	MCP config + `rules/CLINE.md`	Wire `pcx-knowledge-mcp` per the README
Aider	`CONVENTIONS.md` + `/read` bundles	`aider-setup.md`
Continue	`.continue/config.yaml` `mcpServers` block	`continue-setup.md`
Zed	`context_servers` in `settings.json`	`zed-setup.md`
GitHub Copilot	`.github/copilot-instructions.md` + bundle excerpts	`rules/COPILOT.md`
Perception IDE	Native — built-in AI chat	Add `docs/` as workspace folder
Any OpenAI-compatible	System prompt + docs	Paste `rules/CLAUDE.md` into prompt

Templates

Ready-to-fill starter scripts, all following the 12 guidelines. See templates/.

Template	What it demonstrates
`hello-world.em`	Minimal script — lifecycle, render routine, text drawing
`overlay-basic.em`	GUI menu, config-driven rendering, update/render separation, input polling, FPS readout
`aimbot-skeleton.em`	FOV-based closest-target picker with smoothing + RIP-relative offset resolver
`minimap.em`	Rotation-aware player-relative radar with rim clamping + GUI tunables
`full-project/`	5-file Enma scaffold: `globals` · `offsets` · `feature` · `menu` · `main` — one concern per file
`full-project-as/`	3-file AngelScript scaffold: `globals.as` · `feature.as` · `main.as` — parallel to the Enma version

Each is a correct skeleton: the structure and API calls are real, the offsets and read logic are placeholders you fill for your target.

Editor Extensions

Prebuilt extensions are attached to every release — no build step needed. Both VS Code and Visual Studio 2022 are supported.

VS Code

Download the .vsix, then command palette (Ctrl+Shift+P) → Extensions: Install from VSIX...

Extension	Language	Provides
`enma-language-*.vsix`	Enma (`.em`)	Syntax highlighting, completion, hover docs (full Perception API bundled), diagnostics, snippets
`angel-lsp-*.vsix`	AngelScript (`.as`)	Syntax highlighting, completion, hover docs, diagnostics, Perception API surface

Visual Studio 2022

Double-click the .vsix, or Extensions → Manage Extensions → Install from VSIX. Requires Node.js 18+ on PATH.

Extension	Language	Provides
`PcxEnmaVS.vsix`	Enma (`.em`)	Completion, hover docs, diagnostics via LSP
`PcxAngelScriptVS.vsix`	AngelScript (`.as`)	Completion, hover docs, diagnostics via LSP

VS extensions are native ILanguageClient MEF components — see visualstudio/ for source and build details.

All extensions are MIT-licensed builds of enma-lsp and angel-lsp-pcx.

Manual / headless LSP

setup.sh / setup.ps1 build the servers from source. Wire them into any LSP client:

# Linux / macOS
Enma:        node lsp/enma-lsp/server/dist/server.js --stdio
AngelScript: node lsp/angel-lsp-pcx/server/out/server.js --stdio

# Windows
Enma:        node lsp\enma-lsp\server\dist\server.js --stdio
AngelScript: node lsp\angel-lsp-pcx\server\out\server.js --stdio

Project Rules

`rules/CLAUDE.md` — Drop-In Project Config

Copy into any PCX scripting project. Covers:

Language and API declarations
Documentation paths
Coding standards (address types, float suffixes, RAII, conversions)
The 12 guidelines in one-line form
Recommended file structure

`rules/KARPATHY.md` — Work-Discipline Drop-In

Companion to CLAUDE.md. Where CLAUDE.md covers what the code looks like, this covers how to work: the four Karpathy principles (think before coding, simplicity first, surgical changes, goal-driven execution) condensed to one screen and framed for cheat development. Copy both into your project.

`rules/CURSOR.md` — Cursor `.cursorrules` Drop-In

Parallel to rules/CLAUDE.md but tailored for Cursor's tighter token budget. Copy to project root as .cursorrules or paste into Cursor's Rules for AI setting.

`rules/CLINE.md` — Cline (VS Code) Custom Instructions

Custom instructions for the Cline VS Code AI agent. Includes Cline-specific notes on auto-approval gating (read-only MCP tools safe, write/execute gated), Plan/Act mode workflow, and token-budget guidance.

`rules/COPILOT.md` — GitHub Copilot Drop-In

Save as .github/copilot-instructions.md for repo-wide application, or paste into Copilot's custom-instructions field. Copilot-specific notes on what it's good/bad at, steering via // from: docs/... comments above the cursor.

`rules/AGENTS.md` — Multi-Agent Role Definitions

Six specialist roles for orchestrated workflows:

Agent	Responsibility
reverse-engineer	Binary analysis, sig generation, offset discovery
script-writer	Enma/AngelScript implementation following all rules
offset-maintainer	Post-patch offset table updates and verification
feature-builder	Feature implementation using common patterns
reviewer	Correctness, style, and detection surface review
anti-cheat-researcher	Kernel AC analysis, callback mapping, driver RE

Contributing

See CONTRIBUTING.md for full details.

Fork and clone with --recursive
Add or improve: docs, patterns, templates, sigs, knowledge files
Test with ./setup.sh on a clean clone
Open a PR

New working patterns and documentation improvements are especially welcome.

License

MIT

Credits

Perception.cx · Enma Language · enma-lsp · angel-lsp-pcx

Name		Name	Last commit message	Last commit date
.claude/skills		.claude/skills
.github		.github
assets		assets
docs		docs
installers		installers
knowledge		knowledge
lsp		lsp
mcp		mcp
rules		rules
signatures		signatures
templates		templates
tools		tools
visualstudio		visualstudio
.editorconfig		.editorconfig
.gitattributes		.gitattributes
.gitignore		.gitignore
.gitmodules		.gitmodules
CHANGELOG.md		CHANGELOG.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
SuggestionsEnma.txt		SuggestionsEnma.txt
VERSION		VERSION
pyproject.toml		pyproject.toml
setup.ps1		setup.ps1
setup.sh		setup.sh

Latest commit

History

Folders and files

Repository files navigation

pcx-ai-toolkit

The Complete AI-Powered Scripting Toolkit for Perception.cx

The Problem

The Solution

Quick Start

Installation Guide

Part 1 — Toolkit (docs, skills, rules, LSP)

Part 1.5 — Auto-Update

Part 2 — Analysis Suite (headless, fully automatic)

Prerequisites

Install

What happens, step by step

Options

Already have it installed?

After install

What's Inside

Documentation

AI Skills

Knowledge Base

Tooling & Indexed Knowledge

Indexed Knowledge Surfaces

Perception IDE — Built-In Script Editor and AI Assistant

Directory Structure

Documentation Coverage

Enma Language Docs Breakdown

AI Skills

game-hacking-pcx — Documentation Router

game-cheat-guidelines — 12 Behavioral Rules

pcx-coding-discipline — Karpathy Workflow for Writing Scripts

pcx-re-discipline — Karpathy Workflow for Reverse Engineering

anti-cheat-re — Kernel Anti-Cheat RE Methodology

kernel-analysis — Driver Analysis Patterns

Plus 12 more skills

Knowledge Base

Enma Cheatsheet

PCX API Cheatsheet

Common Patterns

Offset Methodology

Anti-Cheat Architecture

Kernel RE Tools

RE Plugins & Tools

Plus 17 more knowledge files

MCP Integration

Perception MCP Server

Supported AI Tools

Templates

Editor Extensions

VS Code

Visual Studio 2022

Manual / headless LSP

Project Rules

rules/CLAUDE.md — Drop-In Project Config

rules/KARPATHY.md — Work-Discipline Drop-In

rules/CURSOR.md — Cursor .cursorrules Drop-In

rules/CLINE.md — Cline (VS Code) Custom Instructions

rules/COPILOT.md — GitHub Copilot Drop-In

rules/AGENTS.md — Multi-Agent Role Definitions

Contributing

License

About

Resources

Contributing

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

`game-hacking-pcx` — Documentation Router

`game-cheat-guidelines` — 12 Behavioral Rules

`pcx-coding-discipline` — Karpathy Workflow for Writing Scripts

`pcx-re-discipline` — Karpathy Workflow for Reverse Engineering

`anti-cheat-re` — Kernel Anti-Cheat RE Methodology

`kernel-analysis` — Driver Analysis Patterns

`rules/CLAUDE.md` — Drop-In Project Config

`rules/KARPATHY.md` — Work-Discipline Drop-In

`rules/CURSOR.md` — Cursor `.cursorrules` Drop-In

`rules/CLINE.md` — Cline (VS Code) Custom Instructions

`rules/COPILOT.md` — GitHub Copilot Drop-In

`rules/AGENTS.md` — Multi-Agent Role Definitions