# Godot MCP Runtime (npm · godot-mcp-runtime)

Zero-addon MCP server for Godot 4: agents edit, run, and play-test the game.

- Trust score: 78/100 (medium)
- Change this week: +35
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- npm · `godot-mcp-runtime`: 78/100 (this document), [markdown](https://verifymcp.io/servers/erodenn-godot-mcp-runtime/godot-mcp-runtime.md), [page](https://verifymcp.io/servers/erodenn-godot-mcp-runtime/godot-mcp-runtime)

## Channel facts

- Registry: `npm`
- Package: `godot-mcp-runtime`
- Version: `3.2.1`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 86/100
  - No malware found by supply-chain analysis.
  - Only part of the dependency tree could be resolved (94 of 98), so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (94 of 98), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to Erodenn/godot-mcp-runtime).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 22 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 69/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 6397 tokens (~177/item across 36 items; 36 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (44% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add erodenn-godot-mcp-runtime -- npx -y godot-mcp-runtime
```

### Codex

```bash
codex mcp add erodenn-godot-mcp-runtime -- npx -y godot-mcp-runtime
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "erodenn-godot-mcp-runtime": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "godot-mcp-runtime"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add erodenn-godot-mcp-runtime --command npx --arg -y --arg godot-mcp-runtime
```

### Hermes

```yaml
mcp_servers:
  erodenn-godot-mcp-runtime:
    command: "npx"
    args: ["-y", "godot-mcp-runtime"]
```

### Other

```json
{
  "mcpServers": {
    "erodenn-godot-mcp-runtime": {
      "command": "npx",
      "args": [
        "-y",
        "godot-mcp-runtime"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 78, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-02 (score 77, +58)

- [security improvement] Install scripts: unverified → pass
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Provenance: unverified → pass
- [security improvement] Malware scan: unverified → pass
- [security] The attested source repository moved: Erodenn/godot-mcp-runtime
- [functional regression] Tool coverage: 100 → unverified
- [functional improvement] Schema quality: unverified → excellent
- [functional improvement] License: unverified → pass
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Stability: unverified → 0.23
- [functional improvement] Dependency health: unverified → partial
- [functional] First check of Schema quality: unverified
- [functional] Licence: MIT

### 2026-08-01 (score 19, −6)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-31 (score 25, −18)

- [security regression] Malware scan: pass → unverified

### 2026-07-27 (score 43)

First indexed and scored.

## MCP tools (36)

### `launch_editor` (~104 tokens)

Open the Godot editor GUI for a project for the human user. Use only when the user explicitly asks to "open the editor"; for any agent-driven work, use the headless scene/node tools (add_node, set_node_properties, etc.) instead — the editor cannot be controlled programmatically. Returns plain-text confirmation after spawning the editor process. Errors if projectPath has no project.godot.

Input parameters:

- `projectPath` (string, required): Path to the Godot project directory

### `run_project` (~263 tokens)

Spawn a Godot project as a child process with stdout/stderr captured. Required before take_screenshot, simulate_input, get_ui_elements, run_script, or get_debug_output. For a Godot process you launched yourself, use attach_project instead. Verifies MCP bridge readiness before returning success. Returns plain-text status with the assigned bridge port. Call stop_project when done. Errors if projectPath is not a Godot project or another session is already active.

Input parameters:

- `background` (boolean): If true, hides the Godot window off-screen and blocks all physical keyboard and mouse input, while keeping programmatic input (simulate_input, run_script) and screenshots fully active. Useful for aut…
- `bridgePort` (number): TCP port for the MCP bridge. Omit to auto-select a free port (recommended). The chosen port is baked into the project's `mcp_bridge.gd` at inject time, so the running Godot listens on exactly this po…
- `projectPath` (string, required): Path to the Godot project directory
- `scene` (string): Scene to run (path relative to project, e.g. "scenes/main.tscn"). Omit to use the project's main scene.

### `attach_project` (~182 tokens)

Inject the MCP bridge into a Godot process you launch yourself, then wait up to 15s for the bridge to respond. Call BEFORE Godot launches — Godot reads autoloads only at process start, so a late call returns "bridge did not respond." Recommended pattern: kick off the Godot launch in parallel with this call so the wait absorbs startup. Prefer run_project unless MCP must not spawn Godot. Returns plain-text status with the resolved bridge port. Call detach_project or stop_project when done.

Input parameters:

- `bridgePort` (number): TCP port for the MCP bridge. Omit to auto-select a free port (recommended). The chosen port is baked into the project's `mcp_bridge.gd` at inject time, so the running Godot listens on exactly this po…
- `projectPath` (string, required): Path to the Godot project directory

### `detach_project` (~96 tokens)

Clear attached-mode runtime state and remove the injected McpBridge autoload. Does NOT stop the manually launched Godot process — that stays running. Use after attach_project when you are done driving the game from MCP. For spawned sessions (run_project), use stop_project instead. Returns: message confirming detach plus externalProcessPreserved (always true here — that is the point of detach vs stop_project). Errors if called outside an attached session.

Output parameters:

- `externalProcessPreserved` (boolean)
- `message` (string)

### `get_debug_output` (~119 tokens)

Get captured stdout/stderr from a spawned Godot project. Use whenever runtime tools fail unexpectedly — script errors, missing nodes, and crash backtraces all surface here. Requires run_project (not attach_project; attached mode does not capture output). Returns: output/errors (last `limit` lines each, default 200), running (false after exit, null when attached), exitCode after exit, attached:true with empty arrays in attached mode.

Input parameters:

- `limit` (number): Max lines to return (default: 200, from end of output)

Output parameters:

- `attached` (boolean)
- `errors` (array)
- `exitCode` (number|null)
- `output` (array)
- `running` (boolean|null)
- `tip` (string)

### `stop_project` (~103 tokens)

Stop the spawned Godot project and clean up MCP bridge state. Always call when done with runtime testing — even after a crash — to free the single process slot so run_project can be called again. For attached sessions, this detaches without killing the externally launched process. Returns: message, mode ("spawned"/"attached"), externalProcessPreserved (true only for attached), finalOutput and finalErrors (last 200 lines each). Errors if no session is active.

Output parameters:

- `externalProcessPreserved` (boolean)
- `finalErrors` (array)
- `finalOutput` (array)
- `message` (string)
- `mode` (string)

### `take_screenshot` (~238 tokens)

Capture a PNG of the running viewport. responseMode: preview (default — saves full PNG, returns bounded inline preview at 960x540), full (full inline PNG; use for small text or pixel-level inspection), path_only (saved-path only, no inline image). Saved under .mcp/screenshots. Returns: inline image block (full/preview modes), plus path and size of the saved PNG; previewPath/previewSize in preview mode; warnings for non-fatal runtime errors. Errors if no session or bridge times out (default 10000ms).

Input parameters:

- `previewMaxHeight` (number): Maximum preview height in pixels when responseMode is "preview" (default: 540)
- `previewMaxWidth` (number): Maximum preview width in pixels when responseMode is "preview" (default: 960)
- `responseMode` (string): Response payload mode. "preview" returns a bounded inline preview plus paths (default). "full" returns the full inline PNG. "path_only" returns paths only.
- `timeout` (number): Timeout in milliseconds to wait for the screenshot (default: 10000)

Output parameters:

- `path` (string)
- `previewPath` (string)
- `previewSize` (object)
- `responseMode` (string)
- `size` (object)
- `warnings` (array)

### `simulate_input` (~134 tokens)

Simulate sequential input in a running project. Each action's `type` (key, mouse_button, mouse_motion, click_element, action, wait) gates which other fields apply — see per-property docs. For click_element use get_ui_elements first; resolution is by path/name, not visible text. Press/release require two actions; insert wait between for frame ticks. Returns: success, actions_processed, warnings for runtime errors fired by input handlers. Errors if no session or any action fails validation.

Input parameters:

- `actions` (array, required): Array of input actions to execute sequentially. Each object must have a "type" field.

Output parameters:

- `actions_processed` (number)
- `success` (boolean)
- `tip` (string)
- `warnings` (array)

### `get_ui_elements` (~148 tokens)

Walk the running scene tree and return all Control nodes with positions, sizes, types, and text content. Always call this before simulate_input click_element actions to discover valid element names and paths. Requires an active runtime session (run_project or attach_project). visibleOnly defaults true; pass false to include hidden Controls. filter narrows by class. Returns: elements[] with path/type/rect/visible plus optional text/disabled/tooltip.

Input parameters:

- `filter` (string): Filter by Control node type (e.g. "Button", "Label", "LineEdit")
- `visibleOnly` (boolean): Only return nodes where Control.visible is true (default: true). Set false to include hidden elements.

Output parameters:

- `elements` (array)
- `tip` (string)
- `warnings` (array)

### `run_script` (~196 tokens)

Execute a custom GDScript in the live running project with full scene tree access. Requires an active runtime session. Script must extend RefCounted and define func execute(scene_tree: SceneTree) -> Variant. Return values are JSON-serialized (primitives, Vector2/3, Color, Dictionary, Array, and Node path strings). Use print() for debug output — it appears in get_debug_output, not in the result. In spawned mode, stderr runtime errors escalate to errors (when the script returns null) or surface as warnings. Returns: { success, result, warnings?, tip? } where result is the JSON-serialized return value of execute().

Input parameters:

- `script` (string, required): GDScript source code. Must contain "extends RefCounted" and "func execute(scene_tree: SceneTree) -> Variant".
- `timeout` (number): Timeout in ms (default: 30000). Increase for long-running scripts.

Output parameters:

- `result`
- `success` (boolean)
- `tip` (string)
- `warnings` (array)

### `list_autoloads` (~89 tokens)

List all registered autoloads in a project with paths and singleton status. Use first when diagnosing headless failures — broken autoloads crash all headless ops, so this tells you what is loaded. No Godot process required (reads project.godot directly). Returns: [{ name, path, singleton }].

Input parameters:

- `projectPath` (string, required): Path to the Godot project directory

### `add_autoload` (~202 tokens)

Register a new autoload in a project. autoloadPath accepts "res://..." or a project-relative path (auto-prefixed). singleton defaults true (accessible globally by name). No Godot process required. Warning: autoloads initialize in headless mode — a broken script will crash every subsequent headless op; validate before adding. Returns plain-text confirmation with the registered name, path, and singleton flag. Errors if an autoload with the same name already exists; use update_autoload to modify.

Input parameters:

- `autoloadName` (string, required): Name of the autoload node (e.g. "MyManager")
- `autoloadPath` (string, required): Path to the script or scene (e.g. "res://autoload/my_manager.gd" or "autoload/my_manager.gd")
- `projectPath` (string, required): Path to the Godot project directory
- `singleton` (boolean): Register as a globally accessible singleton by name (default: true)

### `remove_autoload` (~89 tokens)

Unregister an autoload from a project by name. Use to recover from a broken autoload that is crashing headless ops. No Godot process required. Returns plain-text confirmation on success. Errors if no autoload with that name exists.

Input parameters:

- `autoloadName` (string, required): Name of the autoload to remove
- `projectPath` (string, required): Path to the Godot project directory

### `update_autoload` (~129 tokens)

Modify an existing autoload's path or singleton flag. Pass either or both — omitted fields keep their current value. Use instead of remove_autoload + add_autoload (single edit, no orphan window). No Godot process required. Returns plain-text confirmation on success. Errors if autoloadName is not registered.

Input parameters:

- `autoloadName` (string, required): Name of the autoload to update
- `autoloadPath` (string): New path to the script or scene
- `projectPath` (string, required): Path to the Godot project directory
- `singleton` (boolean): New singleton flag

### `list_projects` (~115 tokens)

Find Godot projects under a directory by locating project.godot files. Use to discover available projects when the user has not specified one; for inspecting a known project, use get_project_info. recursive:true descends into subdirectories (skipping hidden ones); default false checks only the directory itself and its immediate children. Returns: [{ path, name }], empty array on no matches.

Input parameters:

- `directory` (string, required): Directory to search for Godot projects
- `recursive` (boolean): Whether to search recursively (default: false)

### `get_project_info` (~119 tokens)

Get metadata about a Godot project: name, path, Godot version, and a structure summary (counts of scenes/scripts/assets/other). Omit projectPath to get just the Godot version (useful for capability checks). Returns: { name, path, godotVersion, structure } or { godotVersion } when projectPath is omitted. Errors if projectPath is set but lacks project.godot.

Input parameters:

- `projectPath` (string): Path to the Godot project directory (optional — omit to get Godot version only)

### `get_project_files` (~151 tokens)

Return a recursive file tree of a Godot project. Use to discover project structure when paths are unknown. Pass extensions to filter (e.g. ["gd","tscn"]); maxDepth caps recursion (-1 unlimited). Skips hidden (dot-prefixed) entries and the .mcp directory. Returns: { name, type, path, extension?, children? } (nested tree).

Input parameters:

- `extensions` (array): Filter to only these file extensions (e.g. ["gd", "tscn"]). Omit to include all.
- `maxDepth` (number): Maximum recursion depth. -1 means unlimited (default: -1)
- `projectPath` (string, required): Path to the Godot project directory

### `search_project` (~189 tokens)

Plain-text (substring) search across project files. Use to find references, callers, or signatures across the codebase. Default fileTypes is ["gd","tscn","cs","gdshader"]; caseSensitive default false; maxResults default 100. Skips hidden entries and the .mcp directory. Returns: matches[] (project-relative file, 1-indexed lineNumber, line text) and truncated:true when maxResults was hit — consider raising it.

Input parameters:

- `caseSensitive` (boolean): Case-sensitive search (default: false)
- `fileTypes` (array): File extensions to search (default: ["gd", "tscn", "cs", "gdshader"])
- `maxResults` (number): Maximum matches to return (default: 100)
- `pattern` (string, required): Plain-text string to search for
- `projectPath` (string, required): Path to the Godot project directory

Output parameters:

- `matches` (array)
- `truncated` (boolean)

### `get_scene_dependencies` (~118 tokens)

Parse a .tscn file for ext_resource references (scripts, textures, subscenes). Use to inspect what a scene depends on before refactoring or moving files. Returns: the queried scene path and dependencies[] from ext_resource refs (path, type, optional uid). Errors if scene file does not exist.

Input parameters:

- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string, required): Path to the .tscn file relative to the project root (e.g. "scenes/main.tscn")

Output parameters:

- `dependencies` (array)
- `scene` (string)

### `get_project_settings` (~152 tokens)

Parse project.godot into structured JSON. Use to inspect configured display, input, rendering, etc. settings without launching Godot. Pass section to filter to one INI section (e.g. "display", "application"). Returns: { settings: { [section]: { [key]: value } } } or { settings: { [key]: value } } when section is given. Complex Godot types are returned as raw strings; keys outside any section appear under __global__.

Input parameters:

- `projectPath` (string, required): Path to the Godot project directory
- `section` (string): Filter to a specific INI section (e.g. "display", "application"). Omit for all sections.

### `create_scene` (~161 tokens)

Create a new Godot scene file with a single root node. Writes a fresh .tscn at scenePath. Use when starting a new scene from scratch; for adding nodes to an existing scene, use add_node. rootNodeType defaults to Node2D — pass "Node3D" for 3D scenes or "Control" for UI. Saves automatically. Overwrites silently if the file already exists. Returns: success and the scenePath that was written.

Input parameters:

- `projectPath` (string, required): Path to the Godot project directory
- `rootNodeType` (string): Root node type (default: Node2D)
- `scenePath` (string, required): Scene file path relative to the project (e.g. "scenes/main.tscn")

Output parameters:

- `scenePath` (string)
- `success` (boolean)

### `add_node` (~412 tokens)

Add a node to a Godot scene. Saves automatically. Common spatial properties (position, position3d, rotation, scale, visible, modulate) can be set as top-level params; for any other property, pass it under properties. Vector2/Vector3/Color values auto-convert from {x,y}/{x,y,z}/{r,g,b,a}. parentNodePath defaults to the scene root. Returns a plain-text confirmation message naming the new node and type. Errors if nodeType is not a registered Godot class or parentNodePath does not exist.

Input parameters:

- `modulate` (object): Color modulation (e.g. {"r": 1, "g": 0, "b": 0, "a": 1})
- `nodeName` (string, required): Name for the new node as it appears in the scene tree
- `nodeType` (string, required): Godot node class to instantiate (e.g. "Sprite2D", "CollisionShape2D", "Label")
- `parentNodePath` (string): Parent node path from scene root (e.g. "root/Player"). Defaults to the root node.
- `position` (object): Vector2 position (e.g. {"x": 100, "y": 200})
- `position3d` (object): Vector3 position for 3D nodes (e.g. {"x": 0, "y": 1, "z": 0})
- `projectPath` (string, required): Path to the Godot project directory
- `properties` (object): Additional property values as a JSON object. Top-level params (position, rotation, etc.) take precedence over keys in this dict.
- `rotation` (number): Rotation in radians
- `scale` (object): Vector2 scale (e.g. {"x": 2, "y": 2})
- `scenePath` (string, required): Scene file path relative to the project
- `visible` (boolean): Whether the node is visible

### `load_sprite` (~174 tokens)

Set the texture on an existing Sprite2D, Sprite3D, or TextureRect node. Use this when the node already exists; for new nodes, pass texture via add_node properties. Saves automatically. texturePath must be a real file under projectPath. Returns a plain-text confirmation message naming the loaded texture. Errors if the node is not one of those three classes, or the texture file does not exist.

Input parameters:

- `nodePath` (string, required): Path to the target node from scene root (e.g. "root/Player/Sprite2D")
- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string, required): Scene file path relative to the project
- `texturePath` (string, required): Path to the texture file relative to the project (e.g. "assets/player.png")

### `save_scene` (~143 tokens)

Re-pack and save a scene, optionally to a different path (save-as). Most mutations (add_node, set_node_properties, delete_nodes, etc.) auto-save — only use this for save-as via newPath, or to re-canonicalize a hand-edited .tscn. Overwrites silently. Returns a plain-text confirmation naming the save path. Errors if the scene file does not exist.

Input parameters:

- `newPath` (string): Save to a different path (relative to project) instead of overwriting the original
- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string, required): Scene file path relative to the project

### `export_mesh_library` (~187 tokens)

Export a scene of MeshInstance3D nodes as a MeshLibrary .res file for use in GridMap. Use this when authoring tile palettes for grid-based 3D levels; ignore for 2D or general scene work. The source scene must contain MeshInstance3D children. Pass meshItemNames to export a subset, or omit to export all. Saves the .res to outputPath, overwriting silently. Returns a plain-text confirmation with the exported item count. Errors if the scene contains no valid meshes.

Input parameters:

- `meshItemNames` (array): Names of specific mesh items to export. Omit to export all.
- `outputPath` (string, required): Output path for the MeshLibrary .res file (relative to project)
- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string, required): Scene file path relative to the project

### `batch_scene_operations` (~171 tokens)

Use this instead of chaining add_node / load_sprite / save_scene calls when you have multiple mutations on the same or related scenes — runs in one Godot process (~3s startup avoided per call) and shares an in-memory scene cache, saving once at the end. Each item picks its sub-operation (add_node, load_sprite, save) and supplies its own params; abortOnError stops on first failure (default false continues). Returns: results[] in input order, each tagged with operation and scenePath plus success or error.

Input parameters:

- `abortOnError` (boolean): Stop processing on first error (default: false)
- `operations` (array, required): Ordered list of scene operations. Each item has its own operation and scenePath.
- `projectPath` (string, required): Path to the Godot project directory

Output parameters:

- `results` (array)

### `delete_nodes` (~148 tokens)

Remove one or more nodes (and their descendants) from a scene file. Always-array: pass a single-element nodePaths array for one-off deletes. Saves once at the end. Cannot delete the scene root — that entry returns an error and the rest still process. Returns: results array with one entry per nodePath in input order (success or error message).

Input parameters:

- `nodePaths` (array, required): Node paths from scene root to delete (e.g. ["root/Player/Sprite2D"])
- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string, required): Scene file path relative to the project (e.g. "scenes/main.tscn")

Output parameters:

- `results` (array)

### `set_node_properties` (~181 tokens)

Set one or more node properties on a scene in a single Godot process. Always-array: pass a single-element updates array for one-off edits. Vector2 ({x,y}), Vector3 ({x,y,z}), and Color ({r,g,b,a}) auto-convert; primitives pass through. For other complex GDScript types (Resource, NodePath, etc.), use run_script. abortOnError stops on first failure (default false continues). Saves once at the end. Returns: results[] with one entry per update in input order (success or error).

Input parameters:

- `abortOnError` (boolean): Stop processing on first error (default: false)
- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string, required): Scene file path relative to the project
- `updates` (array, required): Property updates to apply

Output parameters:

- `results` (array)

### `get_node_properties` (~130 tokens)

Read one or more nodes' current property values from a scene file in a single Godot process. Always-array: pass a single-element nodes array for one-off reads. Per-node changedOnly:true filters out properties matching class defaults (useful for compact diffs). Returns: { results: [{ nodePath, nodeType, properties?, error? }] }; failed reads include error and omit properties.

Input parameters:

- `nodes` (array, required): Nodes to read properties from
- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string, required): Scene file path relative to the project

### `attach_script` (~158 tokens)

Attach an existing GDScript file to a node in a scene. Use after writing the script with the standard file tools and validating it via the validate tool. Replaces any previously attached script. Saves automatically. Returns: success with the resolved nodePath and scriptPath that were attached. Errors if scriptPath does not exist or nodePath is not found.

Input parameters:

- `nodePath` (string, required): Node path from scene root (e.g. "root/Player")
- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string, required): Scene file path relative to the project
- `scriptPath` (string, required): Path to the GDScript file relative to the project (e.g. "scripts/player.gd")

Output parameters:

- `nodePath` (string)
- `scriptPath` (string)
- `success` (boolean)

### `get_scene_tree` (~164 tokens)

Get the scene hierarchy as a nested tree of { name, type, path, script, children }. Use maxDepth:1 for a shallow listing of direct children only; default -1 returns the full tree. parentPath scopes the result to a subtree. Returns the nested tree as JSON text. Errors if scene does not exist or parentPath is not found.

Input parameters:

- `maxDepth` (number): Maximum recursion depth. -1 for unlimited (default: -1). 1 returns only direct children.
- `parentPath` (string): Scope to a subtree starting at this node path (e.g. "root/Player")
- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string, required): Scene file path relative to the project

### `duplicate_node` (~188 tokens)

Duplicate a node and its descendants in a Godot scene. Use to clone a configured subtree without re-creating it node-by-node via add_node. newName defaults to the original name + "2"; targetParentPath defaults to the original parent. Saves automatically. Returns: success with originalPath and the newPath where the duplicate now lives — use newPath for follow-up edits. Errors if nodePath does not exist or targetParentPath cannot accept children.

Input parameters:

- `newName` (string): Name for the duplicated node (default: original name + "2")
- `nodePath` (string, required): Node path from scene root to duplicate
- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string, required): Scene file path relative to the project
- `targetParentPath` (string): Parent node path for the duplicate (default: same parent as original)

Output parameters:

- `newPath` (string)
- `originalPath` (string)
- `success` (boolean)

### `get_node_signals` (~149 tokens)

List all signals defined on a node and their current connections. Use before connect_signal/disconnect_signal to verify signal/method names. The connections[].target field uses Godot absolute path format (/root/Scene/Node) — convert to scene-root-relative (root/Node) before passing to connect/disconnect_signal. Returns: nodeType and signals[], each with name and current connections (signal/target/method). Errors if node not found.

Input parameters:

- `nodePath` (string, required): Node path from scene root (e.g. "root/Button")
- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string, required): Scene file path relative to the project

Output parameters:

- `nodePath` (string)
- `nodeType` (string)
- `signals` (array)

### `connect_signal` (~224 tokens)

Connect a signal on a source node to a method on a target node, persisting the connection in the .tscn. Use after get_node_signals to confirm the signal name on the source and the method name on the target. Connecting the same signal+method pair twice creates a duplicate connection — call get_node_signals first if uncertain. Saves automatically. Returns a plain-text confirmation naming the source, signal, target, and method. Errors if the signal does not exist on the source node or the method does not exist on the target node.

Input parameters:

- `method` (string, required): Method name on the target node to call when the signal fires
- `nodePath` (string, required): Source node path from scene root
- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string, required): Scene file path relative to the project
- `signal` (string, required): Signal name on the source node (e.g. "pressed", "body_entered")
- `targetNodePath` (string, required): Target node path from scene root that receives the signal

### `disconnect_signal` (~155 tokens)

Remove an existing signal connection between two nodes, persisting the change in the .tscn. Use get_node_signals first to confirm the connection exists; recovery requires reconnecting via connect_signal. Saves automatically. Returns a plain-text confirmation naming the disconnected signal and target. Errors if the connection does not exist.

Input parameters:

- `method` (string, required): Method name on the target node
- `nodePath` (string, required): Source node path from scene root
- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string, required): Scene file path relative to the project
- `signal` (string, required): Signal name on the source node
- `targetNodePath` (string, required): Target node path from scene root

### `validate` (~271 tokens)

Validate GDScript syntax or scene file integrity using headless Godot. Use before attach_script or run_script to catch parse errors early. Single-target: provide exactly one of scriptPath, source, or scenePath. Batch: provide a targets array — runs all in one Godot process. Returns { valid, errors: [{ line?, message }] } for single, or { results: [{ target, valid, errors }] } for batch. Line numbers appear when Godot's stderr includes them (not always). Returns valid:false on any parse error; never throws.

Input parameters:

- `projectPath` (string, required): Path to the Godot project directory
- `scenePath` (string): [single] Path to a .tscn scene file relative to the project to validate (e.g. "scenes/main.tscn")
- `scriptPath` (string): [single] Path to a .gd file relative to the project to validate (e.g. "scripts/player.gd")
- `source` (string): [single] Inline GDScript source code to validate. Written to a temporary file and validated against the project.
- `targets` (array): [batch] Array of targets to validate in a single Godot process. Each item must have exactly one of: scriptPath, source, or scenePath.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/erodenn-godot-mcp-runtime/godot-mcp-runtime#diagnostics

## Score history

- 2026-08-03: 78
- 2026-08-02: 77
- 2026-08-01: 19
- 2026-07-31: 25
- 2026-07-29: 43
- 2026-07-28: 43
- 2026-07-27: 43

## Links

- npm package: https://www.npmjs.com/package/godot-mcp-runtime
- Socket report: https://socket.dev/npm/package/godot-mcp-runtime
- Repository: https://github.com/Erodenn/godot-mcp-runtime
- Changelog RSS feed: https://verifymcp.io/servers/erodenn-godot-mcp-runtime/godot-mcp-runtime/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/erodenn-godot-mcp-runtime/godot-mcp-runtime/changelog.json
- HTML version of this page: https://verifymcp.io/servers/erodenn-godot-mcp-runtime/godot-mcp-runtime