Skip to main content
Glama

Godot MCP Runtime

npm version npm downloads License: MIT Node.js

An MCP server that gives AI assistants direct access to a running Godot 4.x game. Not just file editing, not just scene manipulation. Actual runtime control: input simulation, screenshots, UI discovery, and live GDScript execution while the game is running.

When you run a project through this server, it injects a lightweight UDP bridge as an autoload, and suddenly the AI can interact with your game the same way a player would: press keys, click buttons, read what's on screen, and run arbitrary code against the live scene tree.

The distinction matters: the AI doesn't just write your game, it can check its work.

No addon required. Most Godot MCP servers that offer runtime support ship as a Godot addon — something you install into your project, commit to version control, and manage as a dependency. This server does none of that. The bridge script is injected on run_project or attach_project, then removed on stop_project or detach_project. Your project files are left exactly as they were. All you need is Node.js and a Godot executable, no addon installation, no project modifications, no cleanup.

Think of it as Playwright MCP, but for Godot. Playwright lets agents verify that a web app actually works by driving a real browser. This does the same thing for games: run the project, take a screenshot, simulate input, read what's on screen, execute a script against the live scene tree. The agent closes the loop on its own changes rather than handing off to you to verify.

This is not a playtesting replacement. It doesn't catch the subtle feel issues that only a human notices, and it won't tell you if your game is fun. What it does is let an agent confirm that a scene loads, a button responds, a value updated, a script ran without errors. That's a fundamentally different development workflow, and it's what this server is built for.

Every operation is its own tool with only its relevant parameters, no operation discriminators, no conditional schemas. Each tool teaches agents how to use it through its description and response messages: what to call next, when to wait, and how to recover from errors.

What It Does

Headless editing. Create scenes, add nodes, set properties, attach scripts, connect signals, manage UIDs, validate GDScript. All the standard operations, no editor window required.

Runtime bridge. When run_project or attach_project is called, the server injects McpBridge as an autoload. This opens a UDP channel on port 9900 (localhost only) and enables:

  • Screenshots: Capture the viewport at any point during gameplay

  • Input simulation: Batched sequences of key presses, mouse clicks, mouse motion, UI element clicks by name or path, Godot action events, and timed waits

  • UI discovery: Walk the live scene tree and collect every visible Control node with its position, type, text content, and disabled state

  • Live script execution: Compile and run arbitrary GDScript with full SceneTree access while the game is running

Background mode. Pass background: true to run_project and the Godot window moves off-screen with physical input blocked: borderless, unfocusable, mouse-passthrough. Programmatic input, screenshots, and all runtime tools work exactly the same. Useful for automated agent-driven testing where the window shouldn't be visible or interactive.

Manual attach mode. When something other than MCP launches the game (a CI pipeline, an external debugger, your own shell), call attach_project first. It injects the bridge and marks the project active without spawning Godot, so when you launch the game manually, runtime tools work against it. The tradeoff: get_debug_output is unavailable in attached mode because stdout and stderr only flow through processes MCP started itself. Use detach_project when done.

The bridge cleans itself up automatically when stop_project or detach_project is called. No leftover autoloads, no modified project files.

Related MCP server: Godot MCP

Quick Start

Prerequisites

That's it. No Godot addon, no project modifications.

Configure Your MCP Client

Add the following to your MCP client config. Works with Claude Code, Claude Desktop, Cursor, or any MCP-compatible client.

Zero-install via npx (recommended):

{
  "mcpServers": {
    "godot": {
      "command": "npx",
      "args": ["-y", "godot-mcp-runtime"],
      "env": {
        "GODOT_PATH": "<path-to-godot-executable>"
      }
    }
  }
}

Or install globally:

npm install -g godot-mcp-runtime
{
  "mcpServers": {
    "godot": {
      "command": "godot-mcp-runtime",
      "env": {
        "GODOT_PATH": "<path-to-godot-executable>"
      }
    }
  }
}

Or clone from source:

git clone https://github.com/Erodenn/godot-mcp-runtime.git
cd godot-mcp-runtime
npm install
npm run build
{
  "mcpServers": {
    "godot": {
      "command": "node",
      "args": ["<path-to>/godot-mcp-runtime/dist/index.js"],
      "env": {
        "GODOT_PATH": "<path-to-godot-executable>"
      }
    }
  }
}

If Godot is on your PATH, you can omit GODOT_PATH entirely. The server will auto-detect it. Set "DEBUG": "true" in env for verbose logging.

Verify

Ask your AI assistant to call get_project_info. If it returns a Godot version string (e.g., 4.4.stable), you're connected and working.

Tools

Project Management

Tool

Description

launch_editor

Open the Godot editor GUI for a project

run_project

Run a project and inject the MCP bridge. Pass background: true to hide the window

attach_project

Inject the MCP bridge for a project you'll launch yourself

detach_project

Remove the injected bridge after manual-launch use, leaving the external process alone

stop_project

Stop the running project and remove the bridge (also detaches attached-mode state)

get_debug_output

Read stdout/stderr from an MCP-spawned project (unavailable in attached mode)

list_projects

Find Godot projects in a directory

get_project_info

Get project metadata and Godot version

Runtime (requires run_project or attach_project first)

After run_project, or after attach_project plus launching Godot manually, wait 2-3 seconds for the bridge to initialize before using these tools.

Tool

Description

take_screenshot

Capture a PNG of the running viewport

simulate_input

Send batched input: key, mouse, click_element, action, wait

get_ui_elements

Get all visible Control nodes with positions, types, and text

run_script

Execute arbitrary GDScript at runtime with full SceneTree access

Scene Editing (headless)

All mutation operations save automatically. Use save_scene only for save-as (newPath) or to re-canonicalize a .tscn file.

Tool

Description

create_scene

Create a new scene file

add_node

Add a node to an existing scene (supports promoted spatial params)

load_sprite

Set a texture on a Sprite2D, Sprite3D, or TextureRect

save_scene

Re-pack and save the scene, or save-as with newPath

export_mesh_library

Export scenes as a MeshLibrary for GridMap

batch_scene_operations

Run multiple add_node/load_sprite/save ops in a single Godot process

Node Editing (headless)

All mutation operations save automatically.

Tool

Description

get_scene_tree

Get the full scene tree hierarchy (use maxDepth: 1 for shallow listing)

get_node_properties

Read properties from a node

batch_get_node_properties

Read properties from multiple nodes in one process

set_node_property

Set a property on a node

batch_set_node_properties

Set multiple properties in one process

attach_script

Attach a GDScript to a node

duplicate_node

Duplicate a node within the scene

delete_node

Remove a node from the scene

get_node_signals

List all signals on a node with their connections

connect_signal

Connect a signal to a method on another node

disconnect_signal

Disconnect a signal connection

Project Config (no Godot process required)

These tools edit project.godot directly or read the filesystem. Safe to use even when autoloads are broken.

Tool

Description

list_autoloads

List all registered autoloads with paths and singleton status

add_autoload

Register a new autoload

remove_autoload

Unregister an autoload by name

update_autoload

Modify an existing autoload's path or singleton flag

get_project_settings

Read settings from project.godot by section and key

get_project_files

Get the project file tree with types and extensions

search_project

Search for a string across project source files

get_scene_dependencies

List all resources a scene depends on

Validation: validate

Validate before attaching or running. Catches syntax errors and missing resource references before they cause headless crashes or runtime failures. Supports scriptPath, source (inline GDScript), scenePath, or a targets array for batch validation.

UIDs: manage_uids (Godot 4.4+)

Operation

Description

get

Get a resource's UID

update

Resave all resources to update UID references

Architecture

src/
├── index.ts                # MCP server entry point, routes tool calls
├── tools/
│   ├── project-tools.ts    # Project, runtime, autoload, filesystem, search, settings
│   ├── scene-tools.ts      # Scene creation, node addition, sprite loading, batch ops, UIDs
│   ├── node-tools.ts       # Node properties, scripts, tree, duplication, signals
│   └── validate-tools.ts   # GDScript and scene validation
├── scripts/
│   ├── godot_operations.gd # Headless GDScript operations
│   └── mcp_bridge.gd       # UDP autoload for runtime communication
└── utils/
    └── godot-runner.ts     # Process spawning, output parsing, shared validation helpers

Headless operations spawn Godot with --headless --script godot_operations.gd, perform the operation, and return JSON. Runtime operations communicate over UDP with the injected McpBridge autoload.

How the Bridge Works

When run_project or attach_project is called:

  1. mcp_bridge.gd is copied into the project directory

  2. It's registered as an autoload in project.godot

  3. Godot launches with the bridge listening on 127.0.0.1:9900. With run_project, MCP spawns the process; with attach_project, you launch it yourself.

  4. Runtime tools send JSON commands to the bridge and await responses

  5. stop_project or detach_project removes the bridge script and autoload entry

Files generated during runtime (screenshots, executed scripts) are stored in .mcp/ inside the project directory. This directory is automatically added to .gitignore and has a .gdignore so Godot won't import it.

Broken Autoloads

If any registered autoload fails to initialize (syntax error, missing resource, display dependency), Godot's headless process will crash before any operation runs. Use list_autoloads and remove_autoload to inspect and remove the failing autoload. These tools edit project.godot directly, with no Godot process involved.

Acknowledgments

Built on the foundation laid by Coding-Solo/godot-mcp for headless Godot operations.

Developed with Claude Code.

License

MIT

Available Tools

43 tools
add_autoloadA

Register a new autoload. autoloadPath takes res://... or a project path. singleton defaults to true. No Godot process is used. An autoload that stops the engine before a headless operation is dispatched fails all of them: run validate on it first. Returns: autoload { name, path, singleton } read back from project.godot, and a tip. Errors if the name exists (use update_autoload), or a singleton shares its name with a class_name a project script declares (the engine then drops the script).

Inputs: projectPath (required), autoloadName (required), autoloadPath (required), singleton. Returns: tip, autoload, warnings

add_nodeA

Add a node to a scene, or instance another scene when nodeType is a scene path. Saves automatically. Values in properties are checked against each property's declared type; a mismatch errors (Property Values in docs/tools.md). Returns: nodeName, nodeType and nodePath, read back after the add; warnings leads when Godot renamed the node or a value will not be saved. Errors and adds nothing if the type, parent or a property is invalid. Errors while a runtime session is live on this project.

Inputs: nodeName (required), nodeType (required), scenePath (required), projectPath (required), +7 more. Returns: nodeName, nodePath, nodeType, warnings

attach_scriptA
Idempotent

Attach a GDScript or C# script to a node in a scene, replacing any script it had. Check the script with the validate tool first. C# needs the Godot .NET build with the class compiled into the project assembly. Saves automatically. Returns: nodePath and scriptPath. Errors if the script cannot be instantiated (parse errors, @abstract, or an unbuilt C# class), or if scriptPath or nodePath does not exist. Errors while a runtime session is live on this project.

Inputs: nodePath (required), scenePath (required), scriptPath (required), projectPath (required). Returns: nodePath, warnings, scriptPath

batch_scene_operationsA
Destructive

Run several scene mutations in one process; every mutated scene is saved at the end. Use instead of chaining add_node, load_sprite, set_node_properties or save_scene. Each item sets operation (save stands for save_scene) and takes that tool's params. abortOnError stops at the first failure; later items return skipped: true. Returns: results[] in input order: operation, scenePath, success, error or skipped, plus the operation's own fields. Errors while a runtime session is live on this project.

Inputs: operations (required), projectPath (required), abortOnError. Returns: results, warnings

check_projectA
Read-only

Get project metadata and the Godot version, plus a runtime block. runtime.activeSession, sessionMode and bridgeResponsive describe the current session, projectPath its project (null when none), liveSessions all live ones. With projectPath, runtime.project is that project's session: live, exited or none. Returns: { name?, projectPath?, structure?, godotVersion, runtime }; warnings leads if structure is partial or the engine is newer than the project. Errors if projectPath lacks project.godot.

Inputs: projectPath. Returns: name, runtime, warnings, structure, +2 more

connect_signalA

Connect a signal on a source node to a method on a target node and persist it in the .tscn. Use get_node_signals first to confirm the names. Saves automatically. Returns: nodePath, signal, targetNodePath, method and connected, which is read back from the saved scene (null with a leading warning if that read failed). Errors if the signal or method does not exist or the connection already exists. Errors while a runtime session is live on this project.

Inputs: method (required), signal (required), nodePath (required), scenePath (required), +2 more. Returns: method, signal, nodePath, warnings, +2 more

create_resourceA
Destructive

Create a .tres resource file from an engine Resource class or a GDScript resource script (class_name or path), with property values set. Values are checked against declared types as in set_node_properties (Property Values in docs/tools.md). Refuses an existing file unless overwrite is true. Returns: resourcePath, resourceType, scriptPath and properties read back from the saved file. Errors on an unknown type or property, and while a runtime session is live on this project.

Inputs: type (required), projectPath (required), resourcePath (required), overwrite, +1 more. Returns: warnings, properties, scriptPath, resourcePath, +1 more

create_sceneA
Idempotent

Create a new scene file with a single root node, written to scenePath. Use to start a scene from scratch; to add nodes to an existing scene use add_node. rootNodeType defaults to Node2D: pass "Node3D" for 3D or "Control" for UI. Saves automatically and overwrites an existing file silently. Returns: the scenePath that was written. Errors while a runtime session is live on this project.

Inputs: scenePath (required), projectPath (required), rootNodeType. Returns: warnings, scenePath

delete_nodesA
Destructive

Remove one or more nodes, with their descendants, from a scene. Always-array: pass a single-element nodePaths array for a one-off delete. Saves once at the end. The scene root, a node inside an instanced scene, and a node inherited from a base scene cannot be deleted: that entry reports an error and the rest still process. Returns: results[], one entry per nodePath in input order, each with success or error. Errors while a runtime session is live on this project.

Inputs: nodePaths (required), scenePath (required), projectPath (required). Returns: results, warnings

disconnect_signalA
Destructive

Remove a signal connection between two nodes and persist the change in the .tscn. Use get_node_signals first to confirm the connection exists; connect_signal puts it back. Saves automatically. Returns: nodePath, signal, targetNodePath, method and connected, read back from the saved scene: false once the connection is gone, null with a leading warning if that read failed. Errors if the connection does not exist. Errors while a runtime session is live on this project.

Inputs: method (required), signal (required), nodePath (required), scenePath (required), +2 more. Returns: method, signal, nodePath, warnings, +2 more

duplicate_nodeA

Duplicate a node and its descendants, instead of rebuilding it with add_node. newName defaults to the original name plus "2"; targetParentPath to the parent of the original. Keeps the saved signal connections like the editor; copySignals false drops them. Saves automatically. Returns: nodePath (copied node), newNodePath (read back). Errors if nodePath or targetParentPath is not found, nodePath is the root, or a runtime session is live.

Inputs: nodePath (required), scenePath (required), projectPath (required), newName, +2 more. Returns: nodePath, warnings, newNodePath

export_mesh_libraryA
Destructive

Export a scene's MeshInstance3D children as a MeshLibrary for GridMap. The outputPath extension sets the format: .tres is text (prefer it: readable, diffable), .res is binary. Not for 2D scenes. meshItemNames picks a subset, else all. Overwrites silently. Returns: outputPath, itemCount, itemNames read from the saved library; warnings leads when a requested name was not exported. Errors if no valid meshes, or while a runtime session is live.

Inputs: scenePath (required), outputPath (required), projectPath (required), meshItemNames. Returns: warnings, itemCount, itemNames, outputPath

get_debug_outputA
Read-only

Read captured stdout/stderr from a spawned Godot project. Use whenever a runtime tool fails unexpectedly: script errors, missing nodes and crash backtraces surface here. Still works after the process exits or crashes; the logs are kept until stop_project. Returns: projectPath, sessionMode, output and errors (last limit lines each, default 200), running (false after exit) and exitCode after exit. An attached session captures nothing: output, errors and running are null and warnings leads.

Inputs: limit. Returns: tip, errors, output, running, +4 more

get_node_propertiesA
Read-only

Read the current property values of one or more nodes from a scene file, in one Godot process. Always-array: pass a one-element nodes array for one node. Per-node changedOnly: true leaves out properties that match the class defaults. Returns: results[] in input order: { nodePath, nodeType, properties }, or { nodePath, error } when not found. Values use the input shapes of set_node_properties. warnings leads when changedOnly had no defaults to compare. Errors if the scene cannot be loaded.

Inputs: nodes (required), scenePath (required), projectPath (required). Returns: results, warnings

get_node_signalsA
Read-only

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 is already scene-root-relative in the "root/..." form connect_signal/disconnect_signal accept as targetNodePath (a self-connection reports as "root") - pass it straight through with no conversion. Returns: nodeType and signals[], each with name and current connections (signal/target/method). Errors if node not found.

Inputs: nodePath (required), scenePath (required), projectPath (required). Returns: signals, nodePath, nodeType

get_project_filesA
Read-only

Return the file tree of a Godot project. Use to discover project structure when paths are unknown. subfolder lists one folder as the root (maxDepth counts from it). extensions filters files (e.g. ["gd","tscn"]) and drops directories with no match; maxDepth -1 is unlimited. Skips dot-prefixed entries. Returns: the root node { name, type, path, children[] }; a child is a file, a directory, or a link (not followed). A directory not opened or unreadable has children null; warnings leads then.

Inputs: projectPath (required), maxDepth, subfolder, extensions. Returns: name, path, type, children, +2 more

get_project_settingsA
Read-only

Parse project.godot into JSON without launching Godot. Use to inspect display, input and rendering settings. Pass section for one INI section. Returns: settings as { [section]: { [key]: value } }, or { [key]: value } plus section. Strings are unescaped, an empty value is null, complex values stay raw text. Keys before any section are under global. warnings leads when the section is absent, a value is unterminated or empty, a line is not as Godot writes it, or a setting is assigned twice.

Inputs: projectPath (required), section. Returns: section, settings, warnings

get_scene_dependenciesA
Read-only

Parse a .tscn file for ext_resource references (scripts, textures, subscenes). Use to see what a scene depends on before refactoring or moving files. Returns: scenePath and dependencies[], one per ext_resource reference (path, type, optional uid). warnings leads when ext_resource lines could not be read. Errors if the file does not exist or is not a text scene or resource.

Inputs: scenePath (required), projectPath (required). Returns: warnings, scenePath, dependencies

get_scene_treeA
Read-only

Get a scene's node hierarchy as a nested tree. maxDepth: 1 lists only direct children; the default -1 is the whole tree. parentPath scopes to one subtree. Returns: the root node { name, type, path, script, children[] }, every child the same shape; path is a root/... node path the node tools accept, script a res:// path or an empty string. A node cut by maxDepth has children null and a childCount, and warnings leads. Errors if the scene or parentPath is not found.

Inputs: scenePath (required), projectPath (required), maxDepth, parentPath. Returns: name, path, type, script, +3 more

get_ui_elementsA
Read-only

List the running scene Controls with rect, type and text. Call before simulate_input click_element to find names and paths. Needs a runtime session. visibleOnly (default true) drops hidden Controls and ones clipped out of view. filter narrows by class; root limits the list to one Control and its descendants. Returns: projectPath, elements[] with path/type/rect/visible/onScreen (visibleRect if clipped), optional text/disabled/tooltip. Errors on a non-Control filter or an unknown root.

Inputs: root, filter, visibleOnly. Returns: tip, elements, warnings, projectPath

launch_editorA

Open the Godot editor GUI for a project, for the human user. Use only when the user asks to open the editor; for agent-driven work use the headless scene and node tools (add_node, set_node_properties, etc.), since the editor cannot be controlled programmatically. Returns: projectPath, the editor process pid and message. Errors if projectPath has no project.godot or the editor process does not start.

Inputs: projectPath (required). Returns: pid, message, projectPath

list_autoloadsA
Read-only

List the autoloads registered in a project, with their paths and singleton flags. Use first when diagnosing headless failures: an autoload that stops the engine before an operation is dispatched fails every headless operation. Reads project.godot directly, no Godot process. Returns: autoloads[], each { name, path, singleton }, one per name (the last assignment, which the engine keeps); empty when none. warnings leads when a line is not listed or is not in the form Godot writes.

Inputs: projectPath (required). Returns: warnings, autoloads

list_projectsA
Read-only

Find Godot projects under a directory by locating project.godot files. Use when no project is named; to inspect a known one use check_project. recursive: true descends into subdirectories (skipping .git, .godot, node_modules, etc.); the default checks the directory and its immediate children. Returns: projects[], each { projectPath, name }, name being config/name else the folder name. warnings leads when a path could not be read or a link was not followed. Errors if directory is not a directory.

Inputs: directory (required), recursive. Returns: projects, warnings

load_spriteA
Idempotent

Set the texture on an existing Sprite2D, Sprite3D or TextureRect. For a new node, pass texture in add_node properties instead. Saves automatically. texturePath must be a file under projectPath. Returns: nodePath, nodeType and texturePath, read back from the node after the assignment. Errors if the node is not one of those three classes or the texture file does not exist. Errors while a runtime session is live on this project.

Inputs: nodePath (required), scenePath (required), projectPath (required), texturePath (required). Returns: nodePath, nodeType, warnings, texturePath

move_nodesA

Move nodes to another parent and/or child position in a scene, each subtree kept whole (owners, groups, connections). Always-array moves, applied in order. Saves once at the end. Returns: results[] per move with success, newNodePath and index read back, or error; warnings leads when a NodePath value no longer leads where it did. Refused per entry: the root, a node inside an instance or inherited, a target inside the node, a name taken at the target. Errors while a runtime session is live.

Inputs: moves (required), scenePath (required), projectPath (required). Returns: results, warnings

profile_projectA

Profile a window: GDScript function costs, fps, monitors; visual adds CPU/GPU ms per render stage, timeline both over time. Requires run_project with profiling: true. Blocks for seconds (default 5, max 30; longer: start_profiler). Times are elapsed, not CPU; never sum totalMs (rows overlap). Returns: warnings first, projectPath, complete, fps, slowFrames, rows, frame, servers, worstFrame, monitors, visual, timeline. Errors if profiling is off, a capture is open or the game exits mid-window.

Inputs: top, sort, track, visual, +7 more. Returns: fps, rows, sort, frame, +21 more

remove_autoloadA
Destructive

Unregister an autoload from a project by name. Use to recover from an autoload that stops the engine before headless operations are dispatched. No Godot process is used. Returns: removed (the name) and autoloads[], the entries that remain, read back from project.godot. Errors if no autoload has that name.

Inputs: projectPath (required), autoloadName (required). Returns: removed, autoloads

render_movieA
Destructive

Render frames frames of the project (or scene) in a separate movie-writer run: no bridge, session or input (to interact: run_project, simulate_input). mode check (default): stats, likelyBlank, motion, inline frames, files deleted. frames: keeps PNGs. video: .avi/.ogv, no stats. Returns: frameCount, likelyBlank, anyMotion, samples, paths, bytesWritten; warnings leads if unmeasured or unconfirmed. Needs a display; asks the user once per project. Errors on timeout, failed run or live session.

Inputs: projectPath (required), fps, mode, scene, +3 more. Returns: fps, mode, path, scene, +21 more

run_projectA
Destructive

Start a runtime session: spawn the project (stdout/stderr captured; asks the user to confirm the first time per project), or with attach: true wait for a Godot you launch yourself (nothing spawned or captured). Required before take_screenshot, simulate_input, get_ui_elements and run_script; returns once the bridge answers. It becomes current; others keep running. Returns: projectPath, sessionMode, bridgePort, message; warnings leads on a start caveat. Errors if the bridge never answers.

Inputs: projectPath (required), scene, attach, profiling, +2 more. Returns: message, warnings, bridgePort, projectPath, +1 more

run_scriptA
Destructive

Run GDScript in the running game. It must extend RefCounted and define func execute(scene_tree: SceneTree) -> Variant; execute may await, cut off at the timeout (not cancelled). Return is JSON-serialized: vectors as {x,y[,z,w]}, Color as {r,g,b,a}, a Node as {class,name,path}. Compiled with project warnings. Returns: projectPath, result, warnings, tip. Spawned: a runtime error is an error if result is null, else a warning. Attached: errors are unobservable. Asks the user once per project.

Inputs: script (required), timeout. Returns: tip, result, warnings, projectPath

save_sceneA
Idempotent

Re-pack and save a scene, optionally to another path (save-as). The mutation tools save by themselves: use this only for save-as via newPath, or to re-canonicalize a hand-edited .tscn. Overwrites silently. A newPath file gets no uid of its own. Returns: scenePath (loaded) and savedScenePath (written, confirmed on disk); warnings leads if the save dropped content. Errors while a runtime session is live on this project.

Inputs: scenePath (required), projectPath (required), newPath. Returns: warnings, scenePath, savedScenePath

search_projectA
Read-only

Plain-text (substring, not regex) search across project files; the text goes in pattern. Default fileTypes ["gd","tscn","cs","gdshader"]; caseSensitive false; maxResults integer >= 1, default 100. Skips hidden entries and .mcp. Returns: matches[] (project-relative file, 1-indexed lineNumber, line), truncated, filesSearched, fileTypes. warnings leads when no file had a searched extension or a path was unreadable. Errors if pattern holds a line break or a parameter is undeclared.

Inputs: pattern (required), projectPath (required), fileTypes, maxResults, +1 more. Returns: matches, warnings, fileTypes, truncated, +1 more

set_node_propertiesA
Idempotent

Set node properties in a scene in one Godot process. Always-array: one update for a one-off edit. Each value is checked against the property's declared type, never stored as a zero (Property Values in docs/tools.md). A Dictionary or Array value replaces the stored one whole; send every key. Saves once. Returns: results[], one per update in input order, each with success, error or skipped; warnings leads when a value is set but not saved. Errors while a runtime session is live.

Inputs: updates (required), scenePath (required), projectPath (required), abortOnError. Returns: results, warnings

set_project_settingA
Idempotent

Set one project.godot setting without launching Godot. Pass value (JSON, converted to a Godot literal) or literal (raw Godot text, e.g. "Vector2i(1280, 720)"), not both. Rewrites the last assignment in place or adds key/section; other lines stay byte for byte. Refuses autoload/* (use the autoload tools). Returns: { section, key, value read back, created, sectionCreated, previous? }.

Inputs: key (required), section (required), projectPath (required), value, +1 more. Returns: key, value, created, section, +3 more

set_resource_propertiesA
Idempotent

Set property values in an existing .tres resource file and save it. Properties not named, sub-resources and uids stay as the file has them. A Dictionary or Array value replaces the stored one whole; send every key. Values are checked against declared types as in set_node_properties (Property Values in docs/tools.md); one invalid name or value errors and writes nothing. Returns: resourcePath, resourceType, scriptPath, the named properties read back. Errors while a runtime session is live.

Inputs: properties (required), projectPath (required), resourcePath (required). Returns: warnings, properties, scriptPath, resourcePath, +1 more

simulate_inputA
Destructive

Send input actions. key, mouse_button, action: omit pressed to tap; set it to hold or release. click_element takes a node path or name (see get_ui_elements), not text, and scrolls its target into view. Returns: projectPath, success, results[]: ok, hit, scrolled, signals, changes, watch, mouse_motion position (as delivered), errors (spawned only); warnings leads if errors is partial. An invalid batch injects nothing; a failure skips the rest. A covered or clipped click is refused.

Inputs: actions (required), watch. Returns: results, success, warnings, still_held, +1 more

start_profilerA

Start a profiler capture and return at once, so simulate_input, run_script and screenshots drive the game while it records; timeline and track show where frames drop. Requires run_project with profiling: true. Stops itself after seconds (default 30, max 60); read it with stop_profiler. Unattended window: use profile_project. Returns: warnings if any, projectPath, active, visual, timeline, timelineMs, firstFrame, captureLimit, maxSeconds. Errors if a capture is running or profiling was off.

Inputs: track, visual, seconds, timeline, +5 more. Returns: active, visual, timeline, warnings, +5 more

stop_profilerA

Stop the start_profiler capture of the current session and rank what it recorded; one that hit its time limit is read back as-is, re-readable with another sort. Times are elapsed, not CPU; inclusive rows overlap, never sum totalMs. Returns: the profile_project payload: warnings first, projectPath, complete (false if cut short), fps, slowFrames, rows, frame, servers, worstFrame, monitors, plus visual and timeline when started with them. Errors if no capture was started.

Inputs: top, sort. Returns: fps, rows, sort, frame, +21 more

stop_projectA
Destructive

End the current session now and remove the bridge, cutting off a runtime call in progress. A spawned Godot is stopped; an attached one is detached, not killed. Other sessions keep running; none becomes current. Also frees a spawned game that exited by itself (alreadyExited). Returns: projectPath, message, sessionMode, externalProcessPreserved, alreadyExited, exitCode, killUnconfirmed, finalOutput, finalErrors; warnings leads if the kill or cleanup was unconfirmed. Errors if nothing is running.

Inputs: no named parameters. Returns: pid, message, exitCode, warnings, +7 more

switch_projectA
Idempotent

Point the runtime tools (screenshots, input, UI, run_script, debug output, profiling, stop_project) at another project's session. Needed only when several sessions exist; run_project makes its own session current. A session whose game exited can be selected to read its logs or stop it: live is then false and warnings leads. Returns: projectPath, previousProjectPath, live, sessionMode, bridgePort, bridgeResponsive, message. Errors if the project has no session, listing the live ones.

Inputs: projectPath (required). Returns: live, message, exitCode, warnings, +5 more

take_screenshotA
Read-only

Save a PNG of the running viewport under .mcp/godot-runtime/screenshots/ (kept after stop_project). responseMode: preview (default; inline, fits default 960x540, max 1920x1080), full (inline PNG, for small text), path_only (no image). Returns: projectPath, path, size, stats {chromatic, dominant, distinct, likelyBlank} from the full PNG, so a blank frame shows without vision. warnings leads if stats is null or the image is too big to inline. Errors: no session, no frame rendered, bridge timeout.

Inputs: timeout, responseMode, previewMaxWidth, previewMaxHeight. Returns: path, size, stats, warnings, +4 more

update_autoloadA
Idempotent

Change an existing autoload's path or singleton flag. Pass autoloadPath, singleton or both; errors if neither is given. An omitted field keeps its current value. Use instead of remove_autoload plus add_autoload: one edit, no window where the autoload is missing. No Godot process is used. Returns: autoload { name, path, singleton } read back from project.godot. Errors if autoloadName is not registered, or if the result is a singleton named like a class_name a project script declares.

Inputs: projectPath (required), autoloadName (required), singleton, autoloadPath. Returns: autoload, warnings

validateA

Validate GDScript syntax or scene integrity in headless Godot. Use before attach_script or run_script. Give exactly one of scriptPath, source or scenePath, or a targets array (one process); an unknown key is an error. checks needs scenePath and instantiates the scene, running each attached script's _init(). Returns: { warnings?, valid, errors } for one target, { warnings?, results: [{ target, valid, errors }] } for targets; an invalid result always has an error.

Inputs: projectPath (required), checks, source, targets, +2 more. Returns: valid, errors, results, warnings

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 43 tools

    Disambiguation4/5

    Most tools have clearly scoped resource-and-action boundaries, and descriptions explicitly route ambiguous pairs such as profile_project versus start_profiler/stop_profiler, launch_editor versus run_project, save_scene versus auto-save, and batch_scene_operations versus single mutations. Still, with 43 tools there are several near-overlaps (load_sprite/set_node_properties, create_scene/add_node, get_project_settings/check_project) that require reading descriptions to choose correctly.

    Naming Consistency4/5

    All tool names use snake_case and almost all are verb-first (get_, set_, add_, remove_, create_, run_, stop_), giving a predictable pattern. Minor deviations such as validate (single verb) and batch_scene_operations (noun-heavy phrasing) are small and still readable.

    Tool Count2/5

    43 tools is well above the 25-tool threshold and forces agents to choose from many edge-case operations; the scope is broad but still feels over-fragmented across runtime, profiling, scene editing, resources, autoloads, and project settings. Some specialized tools like export_mesh_library, render_movie, duplicate_node, and move_nodes earn their place only in narrow workflows.

    Completeness4/5

    Coverage is broad: project discovery/settings, autoload CRUD, scene/node lifecycle and signals, scripts/validation, runtime sessions, screenshots/input/UI, profiling, and movie rendering. Minor gaps remain around file-level deletion/rename and resource read/delete (create_resource and set_resource_properties exist without matching get/delete), but core workflows are covered.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      A Model Context Protocol server that enables AI assistants to interact with the Godot game engine, allowing them to launch the editor, run projects, capture debug output, and control project execution.
      14
      6,695
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides a comprehensive integration between LLMs and the Godot Engine, enabling AI assistants to intelligently manipulate project files, scripts, and the live editor. It supports advanced workflows including version-aware documentation querying, automated E2E game testing, and real-time visual context capture.
      26
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      A local MCP server plus a bundled Godot editor addon that lets an AI agent create, inspect, run, debug, and export real Godot 4.6 games through tools.
      2
      PolyForm Small Business 1.0.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      A TypeScript MCP server bridging MCP clients to Godot 4 editor, enabling scene, node, script editing and more via WebSocket.
      187 npm
      MIT