Skip to main content
Glama
Sign In
Universal Game Modder

Universal Game Modder

by doritoman90000
OverviewSchemaSourceRelated ServersDiscussionsAdmin
JavaScript
Local

Universal Game Modder

One MCP server to inspect and mod any game — driven by an AI agent.

Universal Game Modder (UGM) is a local Model Context Protocol server that gives an AI agent (like Claude in Claude Code) hands for game reverse-engineering and modding: it auto-detects a game's engine, then exposes a toolset for analyzing and patching the binaries — all running locally on your own machine, no cloud, no telemetry.

This is the free open-core edition (v0.1.3).

⚠️ Responsible-use notice

UGM is a general-purpose binary-analysis and interoperability tool. It is meant for modding, interoperability, security research, and education on software you legally own or are authorized to analyze. You are responsible for how you use it. Before installing, read ACCEPTABLE_USE.md and LICENSE-EULA.md.

Related MCP server: erdgraph

What's in the free edition

  • One stdio MCP server that an agent connects to and drives.

  • Game-engine auto-detection — point it at a game directory; it identifies Unity (Mono / IL2CPP), Unreal, Godot, Java, and native binaries from file signatures.

  • Native binary analysis + patching toolset — PE header analysis, hex read/write/search/replace, IDA-style pattern scanning, string extraction, checksums, and binary diffing, running natively in-process (no external tools required).

The guided game-modder workflow skill and the delegated decompilation backends land in a later release; this edition is the MCP server + engine detection + the native toolset.

Not in the free edition (Pro tier)

The web dashboard, the delegated Unity/Unreal/JAR decompilation backends, and native disassembly are part of the Pro tier and are not included here. The free edition is fully functional on its own for engine detection and native binary work.

Requirements

  • Node.js 18+ (uses ES modules and better-sqlite3)

  • Claude Code or any MCP-capable client

  • Windows / macOS / Linux (native tools are cross-platform; the smallest cut ships no OS-specific binaries)

Install

# from the repo root
./setup.ps1

Or manually (dist/ ships prebuilt; there is nothing to compile in this edition):

npm install

Then register the server with your MCP client. For Claude Code, add to your MCP config:

{
  "mcpServers": {
    "universal-game-modder": {
      "command": "node",
      "args": ["dist/index.js"]
    }
  }
}

On first run, ugm.config.json ships with empty placeholders — the free edition needs no external paths. (The Pro delegate backends are where those get filled in.)

Config resolution

The server reads the first of these that exists and merges it over built-in defaults:

  1. the file named by the UGM_CONFIG environment variable

  2. ugm.config.local.json next to package.json — your machine-specific paths; keep it out of version control (the repo's .gitignore already does)

  3. ugm.config.json — the tracked file, placeholders only

So you can fill in backend paths without ever editing a file that could end up in a release or a pull request.

Quickstart

Once connected, ask your agent to work through these. Every example below is executed against a real binary before each release — see Verified examples.

Parameter naming: file-level tools take file_path (and file_path_a / file_path_b for comparisons). Game-directory tools take game_path. Disassembly tools take binary_path.

1. Detect what a game is built with:

detect_engine  { "game_path": "C:\\Path\\To\\Game" }

2. Set it as the active target:

load_game  { "game_path": "C:\\Path\\To\\Game" }

3. Analyze a binary:

analyze_file_format  { "file_path": "...\\SomeBinary.dll" }   # magic bytes, managed vs native
analyze_pe_full      { "file_path": "...\\SomeBinary.exe" }   # PE headers, sections, data directories

4. Search and inspect:

extract_strings          { "file_path": "...", "min_length": 8 }
extract_dll_classes      { "file_path": "...", "search_terms": ["Health","Damage"] }
pattern_scan             { "file_path": "...", "pattern": "48 8B ?? ?? ?? ?? ??" }
search_binary_pattern    { "file_path": "...", "patterns": ["maxHealth"] }

5. Patch and verify:

hex_read       { "file_path": "...", "offset": 4096, "length": 64 }
hex_replace    { "file_path": "...", "search_hex": "90 90", "replace_hex": "EB 00" }
calculate_checksums       { "file_path": "..." }              # before/after integrity
compare_binaries_detailed { "file_path_a": "...", "file_path_b": "..." }

6. Disassemble (native, included):

disassemble_function  { "binary_path": "...\\SomeBinary.exe", "rva": 4096 }
disassemble_range     { "binary_path": "...\\SomeBinary.exe", "rva": 4096 }

Full free-edition tool list

These 29 tools run entirely in-process and need no external backend.

Native binary tools (19) — all take file_path unless noted: Detection / PE: analyze_pe_full, analyze_file_format, analyze_dll_structure, rva_to_offset (+rva), offset_to_rva (+offset) Hex: hex_read (+offset), hex_write (+offset,hex_data), hex_search (+hex_pattern), hex_replace (+replace_hex) Scanning: pattern_scan (+pattern), pattern_scan_all (+pattern), search_binary_pattern (+patterns) Strings / classes: extract_strings, extract_strings_advanced, extract_dll_classes Integrity / diff: calculate_checksums, compare_binaries_detailed (file_path_a,file_path_b) Godot: analyze_godot_pck Disassembly: disassemble_function (binary_path,rva)

Workflow / session tools (10): detect_engine, load_game, game_status, find_steam_games, mod_this_game, find_gameplay_values, build_and_deploy, debug_mod, scaffold_mod, list_available_tools

What the server also lists (Pro backends)

For transparency: the server advertises 100 tools total. The other 64 are the Unity (27), Unreal (11), and Java/JAR (26) decompilation suites, which route to external Pro-tier backend executables. They appear in the tool list, but calling one without a configured backend returns a clear error:

ERROR: Backend unity-decompiler not configured (missing executable path)

That is expected behavior in the free edition, not a defect. Configure their paths in ugm.config.json (Pro) to enable them.

Verified examples

The Quickstart calls above are not aspirational. Each release is gated on a verification pass that executes them against a real PE binary and requires every one to return real data. The v0.1.3 pass (2026-09-02, on the restored release cut) ran the gate's 20 documented calls plus 3 clean-failure checks; results are recorded in VERIFICATION.md.

License

The UGM code is released under the MIT License. Use of the tool is additionally governed by LICENSE-EULA.md and ACCEPTABLE_USE.md. Third-party components used by the Pro-tier backends are attributed in licenses/.

Changelog

See CHANGELOG.md. Current version: v0.1.3 — the config can no longer ship machine paths, and the release was restored and re-verified after a disk incident. v0.1.2 fixed engine detection; v0.1.1 fixed the docs and added the gate.

Available Tools

100 tools
analyze_bepinex_logC

Analyze BepInEx log for errors, warnings, and patch issues.

Inputs: log_path (required).

analyze_dll_structureB

Analyze the overall structure of a DLL: sections, imports, exports summary.

Inputs: file_path (required).

analyze_file_formatB

Detect file format from magic bytes. Works with PE, ELF, Mach-O, ZIP, Java class, and other formats.

Inputs: file_path (required).

analyze_godot_pckC

Analyze a Godot .pck archive and list its contents.

Inputs: file_path (required), filter.

analyze_pe_fullB

Full PE (Portable Executable) analysis. Shows headers, sections, data directories, and whether it is managed (.NET) or native.

Inputs: file_path (required).

analyze_save_formatC

Analyze game save system by examining SaveManager classes.

Inputs: assembly (required).

build_and_deployC

Compile a mod project and deploy the output to the game mods directory.

Inputs: project_path (required), deploy_path, build_command.

calculate_checksumsC

Calculate MD5, SHA1, SHA256 checksums for a file.

Inputs: file_path (required).

compare_binaries_detailedC

Compare two binary files and show differences.

Inputs: file_path_a (required), file_path_b (required), max_diffs.

compare_signaturesC

Compare expected Harmony patch signature with actual target method.

Inputs: target_type (required), patch_params (required), game_assembly (required), target_method (required), +1 more.

compile_pluginC

Compile a BepInEx plugin C# source file using Roslyn.

Inputs: output_path (required), source_files (required), managed_directory (required), bepinex_core_directory (required), +1 more.

debug_modC

Analyze mod logs to diagnose errors and suggest fixes.

Inputs: log_path, game_path.

decode_assetsA

Universal Asset Decoder. Reads a PR-1 autopsy catalog, cracks open Unity .assets containers, and decodes their members back into The Model (decoded=1, decoded_path set): Texture2D -> PNG (streamed pixels from sibling .resS), Mesh -> glTF .glb + .obj (plain/uncompressed; compressed noted+deferred), and AudioClip -> WAV (PCM) / OGG (bare Vorbis); FSB5-wrapped Vorbis + other codecs are noted+deferred. Read-only on game files; decoded files + DB rows are the only writes. Pass either db_path (the .autopsy.db) or game_path (whose default .autopsy/ DB is used). Optional out_dir overrides where decoded files land; asset_kinds restricts to textures, meshes, or audio.

Inputs: limit, db_path, out_dir, game_path, +1 more.

decompile_methodB

Decompile a single method to C# source code.

Inputs: assembly (required), type_name (required), method_name (required), parameter_count.

decompile_typeC

Decompile a type to full C# source code.

Inputs: assembly (required), type_name (required).

detect_engineB

Scan a game directory and detect what engine it uses (Unity, Unreal, Godot, Java, etc.). Returns engine type, runtime, and primary assembly path.

Inputs: game_path (required).

detect_networkingC

Detect networking frameworks and flag unsafe-to-patch methods.

Inputs: assembly (required).

diff_assembliesC

Compare two assembly versions to show changes.

Inputs: new_assembly_path (required), old_assembly_path (required), limit, show_methods.

disassemble_functionA

Disassemble a function starting at an RVA in a native PE (x86-64). Linear sweep from the entry RVA to the first terminal instruction (ret/iret) or max_bytes, whichever comes first — a PR-3.1 boundary heuristic (CFG-accurate bounds arrive with the call-graph in PR-3.2), so the function EXTENT is tagged provenance=inferred while the decoded bytes themselves are verified. Read-only on the binary. Writes a 'function' row into The Model when db_path/game_path is supplied and the binary is catalogued.

Inputs: rva (required), binary_path (required), db_path, game_path, +1 more.

disassemble_rangeA

Disassemble an arbitrary byte range of a native PE (x86-64) starting at an RVA. Resolves the RVA to its section and file offset, reads ONLY that slice (read-only on the binary), and decodes it with Capstone. Returns the instruction listing. If db_path or game_path is given AND the binary is catalogued in that autopsy DB, the decoded instructions are also summarized into The Model as a 'function' row spanning the range (provenance=verified for the bytes). Pure read-only when no DB is supplied.

Inputs: rva (required), binary_path (required), length, db_path, +1 more.

extract_dll_classesA

Extract class names from a .NET DLL using stream-based analysis. Works with very large files.

Inputs: file_path (required), max_classes, search_terms.

extract_stringsC

Simple string extraction from a binary file.

Inputs: file_path (required), filter, min_length.

extract_strings_advancedC

Extract ASCII and UTF-16 strings from a binary file with filtering.

Inputs: file_path (required), filter, encoding, min_length, +1 more.

find_blueprints_of_typeB

Search for all Blueprint assets inheriting from a parent class.

Inputs: parent_class (required), limit, path_filter.

find_gameplay_valuesC

Search for gameplay-related values (health, damage, speed, money, etc.) across the game code. Works with any engine by using the appropriate search tools.

Inputs: search_terms (required), assembly_path (required).

find_referencesC

Find all references to a method or field.

Inputs: assembly (required), type_name (required), member_name (required), limit.

find_renamed_typesB

Find types likely renamed after a game update.

Inputs: new_assembly_path (required), old_assembly_path (required), min_similarity.

find_steam_gamesB

Search configured Steam library paths for installed games. Optionally filter by name.

Inputs: filter.

game_statusA

Get the current session state including loaded game, engine type, cached analysis data, and mod build status.

Inputs: no named parameters.

generate_harmony_patchC

Generate correct Harmony patch class for a specific method.

Inputs: assembly (required), type_name (required), method_name (required), patch_type, +2 more.

generate_pluginC

Generate complete BepInEx 5 plugin template with Harmony patching.

Inputs: plugin_guid (required), plugin_name (required), author, version, +4 more.

get_class_hierarchyC

Get inheritance chain for a Blueprint class.

Inputs: asset_path (required), max_levels.

get_inheritance_treeB

Get full inheritance tree for a type (ancestors and descendants).

Inputs: assembly (required), type_name (required).

get_method_ilC

Get raw IL bytecode for a method.

Inputs: assembly (required), type_name (required), method_name (required).

get_serialized_fieldsC

Get all serialized fields for a MonoBehaviour or ScriptableObject.

Inputs: assembly (required), type_name (required).

gorebox_generate_discovery_modB

Generate a GoreBox Lua mod that discovers all available API functions, globals, tables, and callbacks. Writes results to a dump file in the mod folder. Use this when you need to learn what Lua API is available in a game that uses Lua scripting.

Inputs: mods_dir (required), mod_name.

gorebox_generate_modC

Generate a GoreBox-compatible Lua mod with proper info.json and main.lua. Creates a ready-to-use mod in the Mods directory.

Inputs: lua_code (required), mod_name (required), mods_dir (required), version, +4 more.

gorebox_list_modsB

List all installed GoreBox mods with their info.json contents and file structure.

Inputs: mods_dir (required).

gorebox_read_api_dumpA

Read and parse an API discovery dump file generated by gorebox_generate_discovery_mod. Returns structured information about all discovered globals, functions, tables, and callbacks.

Inputs: dump_path (required), filter.

hex_readC

Read raw bytes from a file at a specific offset.

Inputs: offset (required), file_path (required), length.

hex_replaceC

Replace bytes at a specific offset or replace a pattern throughout the file.

Inputs: file_path (required), replace_hex (required), offset, search_hex.

hex_searchC

Search for a hex pattern in a binary file.

Inputs: file_path (required), hex_pattern (required), max_results.

hex_writeC

Write raw bytes to a file at a specific offset.

Inputs: offset (required), hex_data (required), file_path (required).

inspect_typeA

Inspect type structure (fields, properties, methods) without decompiling method bodies.

Inputs: assembly (required), type_name (required).

jar_add_fileC

Add a file from disk into the JAR.

Inputs: jar_path (required), session_id (required), source_path (required), overwrite.

jar_add_file_contentC

Write text content as a new file in the JAR.

Inputs: content (required), jar_path (required), session_id (required), encoding.

jar_closeA

Close a JAR session and clean up temp files.

Inputs: session_id (required), cleanup.

jar_compile_javaC

Compile Java source code and optionally inject into JAR.

Inputs: class_name (required), session_id (required), source_code (required), classpath, +3 more.

jar_detect_mod_infoC

Auto-detect mod loader, version, and structure from JAR contents.

Inputs: session_id (required).

jar_diffC

Show differences between original and modified file.

Inputs: class_path (required), session_id (required).

jar_edit_class_constantsC

Edit numeric constants in .class file bytecode.

Inputs: class_path (required), session_id (required), replacements (required), occurrence, +1 more.

jar_edit_constant_poolC

Edit constants by their exact constant pool index.

Inputs: edits (required), class_path (required), session_id (required).

jar_edit_fileC

Edit a text file within the JAR.

Inputs: file_path (required), session_id (required), new_content (required).

jar_hex_editC

Write raw bytes at a specific offset in a file.

Inputs: offset (required), hex_data (required), class_path (required), session_id (required).

jar_hex_viewB

Read raw bytes from a .class file as hex dump.

Inputs: class_path (required), session_id (required), length, offset.

jar_inspect_constant_poolC

Dump the constant pool of a .class file.

Inputs: class_path (required), session_id (required), filter_type, filter_value.

jar_listC

List contents of an opened JAR file.

Inputs: session_id (required), max_results, filter_pattern.

jar_list_sessionsB

List all active JAR sessions.

Inputs: no named parameters.

jar_openC

Open and extract a JAR file for exploration and editing.

Inputs: jar_path (required), session_id.

jar_preset_applyC

Apply a saved preset of constant edits.

Inputs: session_id (required), preset_name (required), reverse.

jar_preset_listB

List all saved edit presets.

Inputs: no named parameters.

jar_preset_saveC

Save a named preset of constant edits for reuse.

Inputs: edits (required), class_path (required), description (required), preset_name (required), +1 more.

jar_read_classC

Read and decompile a Java .class file.

Inputs: class_path (required), session_id (required), decompile, extra_classpath.

jar_read_fileC

Read a text file from the JAR.

Inputs: file_path (required), session_id (required).

jar_repackC

Repack the modified JAR file with all changes.

Inputs: session_id (required), output_path.

jar_restore_fileB

Restore a file from backup to undo modifications.

Inputs: class_path (required), session_id (required).

jar_scaffold_modC

Generate a minimal Minecraft mod JAR structure.

Inputs: mod_id (required), mod_name (required), output_dir (required), author, +3 more.

jar_searchC

Search within JAR for classes, methods, or strings.

Inputs: session_id (required), search_term (required), search_type.

jar_search_bytecodeC

Search for numeric values or strings in bytecode.

Inputs: session_id (required), search_value (required), file_filter.

jar_search_opcodesC

Search for bytecode opcode patterns in .class files.

Inputs: pattern (required), session_id (required), file_filter.

list_assetsB

List assets in loaded game with file sizes.

Inputs: limit, offset, path_filter, type_filter.

list_available_toolsA

List all tools available for the currently loaded game engine, grouped by category.

Inputs: engine.

list_exportsB

List all exports in a package without reading full properties.

Inputs: asset_path (required).

list_monobehavioursC

List all MonoBehaviour components in assembly.

Inputs: assembly (required), limit, filter.

list_patchable_methodsC

List all methods in a type that can be Harmony patched.

Inputs: assembly (required), type_name (required), filter, include_inherited.

list_scriptableobjectsC

List all ScriptableObject types in assembly.

Inputs: assembly (required), filter.

list_typesC

List all types (classes, structs, enums, interfaces) in a loaded assembly.

Inputs: assembly (required), kind, limit, filter, +1 more.

load_assemblyA

Load a .NET assembly (DLL) for analysis. Must be called before other Unity tools.

Inputs: assembly_path (required), managed_directory.

load_gameA

Set a game as the active modding target. Auto-detects engine, sets up session state, and returns what tools are available for this game type.

Inputs: game_path (required), game_name.

mod_this_gameA

End-to-end game modding assistant. Detects engine, analyzes game structure, and returns a modding plan with available tools and next steps. Start here when modding a new game.

Inputs: game_path (required), objective.

offset_to_rvaB

Convert a file offset to a Relative Virtual Address (RVA) in a PE file.

Inputs: offset (required), file_path (required).

open_gameB

Open a game directory for Unreal asset reading. Scans for .pak/.ucas/.utoc files.

Inputs: game_path (required), aes_key, ue_version.

pattern_scanB

IDA-style pattern scan with wildcards. Searches for byte patterns in PE sections.

Inputs: pattern (required), file_path (required), section, max_results.

pattern_scan_allB

Scan entire file for a pattern (not limited to a section).

Inputs: pattern (required), file_path (required), max_results.

read_assetC

Read all exports and properties from an asset.

Inputs: asset_path (required), max_depth.

read_asset_exportC

Read a specific named export from an asset.

Inputs: asset_path (required), export_name (required), max_depth.

read_blueprintC

Read Blueprint class definition, components, and default properties.

Inputs: asset_path (required), max_depth.

read_datatableB

Read a DataTable asset with all rows and field values.

Inputs: asset_path (required), limit, row_filter.

read_playerprefsC

Read Unity PlayerPrefs from Windows registry.

Inputs: company_name (required), product_name (required), filter.

read_unity_assets_infoC

List Unity asset files in game data directory.

Inputs: data_directory (required).

rva_to_offsetB

Convert a Relative Virtual Address (RVA) to a file offset in a PE file.

Inputs: rva (required), file_path (required).

scaffold_modC

Generate a mod project skeleton from templates. Creates project files, plugin class, and build configuration.

Inputs: mod_name (required), output_dir (required), mod_guid, framework, +1 more.

search_assetsC

Search for assets by name (case-insensitive).

Inputs: query (required), limit.

search_binary_patternC

Search for text patterns in a binary file using stream-based approach.

Inputs: patterns (required), file_path (required), max_results.

search_codeC

Search across assembly for types, methods, fields, or string literals.

Inputs: pattern (required), assembly (required), limit, scope.

unpack_gameA

CATALOG-FIRST universal unpacker. Recursively walks an ENTIRE game install, classifies and sha256-hashes EVERY file, and persists the catalog into a SQLite .autopsy.db (game/binary/asset/data_store tables, provenance on every row). Read-only: never writes game files. Containers (.pak/.pck/.bundle/...) are catalogued as single rows, never expanded (per-format extraction is a later slice). Idempotent: re-running on the same game re-opens the DB and upserts, no duplicate rows.

Inputs: game_path (required), db_path.

unreal_game_statusC

Check current state of Unreal asset reader.

Inputs: no named parameters.

validate_assemblyC

Validate compiled plugin DLL for missing references and conflicts.

Inputs: plugin_path (required), managed_directory (required).

validate_patch_targetB

Validate that a Harmony patch target method exists with expected signature.

Inputs: assembly (required), type_name (required), method_name (required), expected_params, +1 more.

verify_patchesC

Verify Harmony patch targets in plugin still exist in game assembly.

Inputs: plugin_path (required), game_assembly (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Deploy Server
    Claude Code, inside the Godot 4 editorFlockbay puts an AI agent in the real Godot 4 editor: it writes GDScript, runs your game and fixes what breaks. Free, or bring your own Claude Code or Codex.flockbay.comAd

    TDQS

    C2.8/5.0

    Scored across 100 tools

    Disambiguation2/5

    Many tools have overlapping purposes across search, hex, decompilation, and session management. For example, pattern_scan, pattern_scan_all, search_binary_pattern, hex_search, and jar_search_opcodes are all pattern/byte searches, while load_game, open_game, mod_this_game, and detect_engine all initialize game contexts. This creates a high risk of misselection.

    Naming Consistency3/5

    Most names use snake_case with readable prefixes like jar_ and gorebox_, but the verb/noun ordering is mixed: pattern_scan and hex_read are noun-first, while build_and_deploy and find_gameplay_values are verb-first. It is readable but not a single predictable convention.

    Tool Count1/5

    100 tools is an extreme surface for one server, well beyond the 15-tool guideline. The set is bloated with overlapping utilities and multiple engine-specific clusters, making discovery and selection unwieldy.

    Completeness4/5

    The surface covers a broad game-modding lifecycle: engine detection, Unity/Unreal/Godot/JAR analysis, native disassembly, mod generation, compilation, deployment, verification, and repair. Minor gaps exist, such as Godot mod generation/repacking and explicit mod uninstall, but core workflows are covered.

    Maintenance

    ActivityStale
    ResponsivenessNo recent community issues

    Resources

    Related MCP Connectors

    Related MCP Servers

    • PyMemoryEditor

      PyMemoryEditorofficial

      JeanExtreme002
      A
      license
      A
      quality
      B
      maintenance
      Let an AI agent read, write and scan the memory of running processes on Windows, Linux and macOS, Cheat Engine style: value scans, refinement and pointer chains.
      14
      21,576 PyPI
      225
      MIT

    • erdgraph

      nickjoven
      A
      license
      B
      quality
      C
      maintenance
      Enables agents to explore a static RTTI, call, and cross-reference graph of a game executable, querying functions, classes, vtables, strings, globals and memory through search, disassembly, signature and SQL tools. It also supports a provenance-tracked naming lifecycle where labels are proposed with evidence, reviewed, and ported across game patches.
      18
      MIT

    • Antardrishti

      divyanshu-iitian
      A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI agents to locally analyze and reverse engineer binaries through a compact 12-tool MCP interface for triage, function discovery, disassembly/decompilation, cross-references, strings/imports, call graphs, memory reads, annotations, and binary diffs.
      1
      MIT