Summarise a Godot project: name, target engine version, main scene, autoloads, input actions, enabled features and a resource-type breakdown.

List project.godot settings as section/key/value entries, optionally filtered to one section.

Set or add a setting in project.godot. The section is created if missing. Use type="raw" to write a Godot literal verbatim (e.g. a Vector2 or PackedStringArray).

List installed editor addons under addons/, with their plugin.cfg metadata and enabled state.

List project resources as res:// paths, optionally filtered by extension (e.g. ".tscn", ".gd"). Skips .godot/ and .gdignore-marked folders.

Parse a resource into structured JSON-ish output. Scenes (.tscn) and resources (.tres) yield their node tree, ext/sub resources and connections; scripts (.gd/.cs) yield an outline of classes, functions, signals, exports and variables.

Create a new resource from a template: a GDScript (gdscript) or C# (csharp) script, a scene (scene) or a generic resource (resource). Fails if the target exists unless overwrite=true.

Find resources that reference a given resource, by scanning scenes, resources and scripts for its res:// path, filename, UID, or preload/load usage.

Provision the Godot toolchain for a project: resolve the target version, download/locate the editor binary, install matching export templates, and (by default) install the godot_mcp live-control bridge addon. Safe to run repeatedly.

Import/reimport the project headlessly, compiling scripts and generating the .godot cache. Surfaces script and scene errors. This is the Godot equivalent of a compile check.

Export a project using a preset from export_presets.cfg. Mode "release"/"debug" produce a runnable bundle; "pack" produces a .pck/.zip data pack. With no preset, lists the available presets.

Remove generated artifacts: the .godot cache, legacy .import folder, and optionally the export/ output.

Run diagnostics: confirm a usable editor binary, version alignment with the project, export template availability, and whether the project imports cleanly.

Launch the project (or a specific scene) as a child process and return a handle. With live=true the godot_mcp bridge is enabled (auto-installed if needed) so you can inspect the scene tree, eval expressions, hot reload and screenshot the running game.

Terminate a running game by handle (or the only running game). Attempts a clean bridge quit before SIGTERM/SIGKILL.

Return recent stdout/stderr from a running or finished game.

List all launched games this session, running and exited, with their handles and status.

Query a running game via its bridge: engine version, FPS, frame count, current scene and node count.

Dump the live scene tree of a running game (node names, types and attached scripts).

Run GDScript in the running game and return the result as a string. The code is compiled as a real script, so autoload singletons (e.g. GameState), method calls and await all work. A bare expression is auto-wrapped to return its value; multi-line code should return explicitly. The locals tree (SceneTree), root (Window) and scene (current scene) are provided. Examples: "GameState.last_health", "scene.get_node("Player").position", "return await some_node.some_async()".

Set a property on a node in the running scene by node path (e.g. "Player", "Player/Sprite2D").

Reload GDScript files and/or the current scene in the running game without restarting it. Pass script res:// paths to reload, and/or reload_scene=true to reinstantiate the current scene.

Send a raw JSON command to the godot_mcp bridge (advanced). Supported commands: ping, info, scene_tree, eval, set_property, reload, screenshot, quit. Payload is merged into the request.

Parse a GDScript file headlessly with --check-only and report any parse/compile errors without running the game.

Install (or refresh) the godot_mcp live-control bridge addon and its autoload in the project. Normally handled by godot_setup or godot_run, but available explicitly.

Capture the current frame of a running game (launched with godot_run live=true, non-headless) and return it as an image. Optionally also saves a PNG to disk.

Search the Godot class reference for the target version: matches class names, brief descriptions, and method/member/signal names. Returns ranked hits.

Return the reference documentation for a Godot class: inheritance, description, methods, properties, signals and constants.

Launch Godot editor for a specific project

Run the Godot project and capture output

Get the current debug output and errors

Stop the currently running Godot project

Get the installed Godot version

List Godot projects in a directory

Retrieve metadata about a Godot project

Create a new Godot scene file

Add a node to an existing scene

Load a sprite into a Sprite2D node

Export a scene as a MeshLibrary resource

Save changes to a scene file

Get the UID for a specific file in a Godot project (for Godot 4.4+)

Update UID references by resaving resources (4.4+)

Screenshot the running game (returns base64 PNG)

Click at a position in the running Godot game window

Send a key press or input action to the running game

Move the mouse in the running Godot game

Get visible UI elements from the running game

Get scene tree structure of the running game

Execute GDScript in the running game. Use "return" for values.

Get a property value from any node in the running game by its path

Set a property on a node in the running game

Call a method on any node in the running game with optional arguments

Get node info: class, properties, signals, methods, children

Load a PackedScene and add it as a child of a node in the running game

Remove and free a node from the running game's scene tree

Switch to a different scene file in the running game

Pause or unpause the running game

Get performance metrics (FPS, memory, draw calls)

Wait N frames in the running game

Read scene file as JSON node tree (headless)

Modify node properties in a scene file (headless)

Remove a node from a scene file (headless)

Read project.godot as structured JSON

Modify a project.godot setting

List project files, optionally filtered by extension

Connect a signal from one node to a method on another node in the running game

Disconnect a signal connection in the running game

Emit a signal on a node in the running game, optionally with arguments

Control an AnimationPlayer node: play, stop, pause, or list animations

Tween a node property in the running game

Get all nodes belonging to a specific group in the running game

Find all nodes of a specific class type in the running game

Move a node to a new parent in the running game's scene tree

Attach a GDScript to a scene node (headless)

Create a .tres resource file (headless)

Read a text file from a Godot project

Create or overwrite a text file in a Godot project

Delete a file from a Godot project

Create a directory inside a Godot project

Get new push_error/push_warning messages since last call

Get new print output from the running game since last call

Hold a key down without auto-releasing

Release a previously held key

Send mouse scroll wheel event at position

Drag mouse between two points over N frames

Send gamepad button or axis input event

Create a new Godot project from scratch

Add, remove, or list autoloads in a Godot project

Add, remove, or list input actions and bindings

Create or modify export preset configuration

Get active camera position, rotation, and size

Move or rotate the active camera

Cast a ray and return collision results

Get audio bus layout and playing streams

Create a new node of any type at runtime

Set a shader parameter on a node's material

Play, stop, or pause an AudioStreamPlayer node

Set volume, mute, or solo on an audio bus

Query a navigation path between two points

Get or set cells in a TileMapLayer node