Get Godot project name, engine version, main scene, viewport size, renderer and autoloads

List the project filesystem as a nested tree of directories and files

Search project file names by case-insensitive substring or glob pattern

Grep project file contents and return matching file, 1-based line number and text

Read one project setting by key, or dump all settings matching a section prefix

Set one project setting and save project.godot

Resolve a uid:// identifier to its res:// project path

Resolve a res:// project path to its uid:// identifier

Register a scene or script as an autoload singleton and save project settings

Remove an autoload singleton by name and save project settings

Load a resource file and return its class and editor-visible properties

Set properties on an existing resource file and save it back to disk

Create a resource of the given class, apply properties and save it to disk

Render an image or texture resource to a base64 PNG, downscaled so its longest side is at most max_size pixels

Get the node tree of the currently edited scene as nested name/type/path/script records

Read the raw .tscn text of a scene file on disk

Create a new scene file on disk with the given root node type, without opening it in the editor

Open an existing scene file in the editor and make it the edited scene

Delete a scene file from disk together with its .import sidecar

Instance a packed scene as a child node of the currently edited scene

Run the project: mode 'main', 'current', or a res:// scene path to play that scene

Stop the running game and clean up the bridge IPC temp files in its user dir

Save the currently edited scene, optionally to a new res:// path (save-as); refuses to overwrite a scene open in another inactive tab

List every node's exported script variables in a scene file, with current values, Variant types and hints

Add a MeshInstance3D using a primitive mesh_type or a mesh loaded from mesh_file; rotation is in degrees

Add a 3D light from a light_type or a preset (sun, indoor, dramatic); rotation and spot_angle are in degrees

Set a fresh StandardMaterial3D as a MeshInstance3D surface override — omitted params reset to class defaults, replacing any previous override

Create or reconfigure a WorldEnvironment with sky, ambient, tonemap, fog, glow, SSAO, SSR and SDFGI settings; reconfiguring an existing node is not undoable

Create or reconfigure a Camera3D; fov, rotation are in degrees and look_at is a world-space target; reconfiguring an existing node is not undoable

Create or reconfigure a GridMap with a MeshLibrary and paint cells; painted cells are not undoable

Add a node of a ClassDB class or project class_name script under a parent in the edited scene

Delete a node from the edited scene (the scene root cannot be deleted)

Duplicate a node with its children under the same parent in the edited scene

Reparent a node to a new parent in the edited scene

Set one property on a node; compound values travel as constructor strings like Vector2(100, 200) or #ff0000

List a node's editor-visible properties, optionally filtered by name prefix

Create a Resource subclass instance and assign it to a node property

Apply a Control layout anchor preset to a Control node

Rename a node in the edited scene

Connect a node signal to a method on a target node, persisted into the scene file

Disconnect a node signal from a method on a target node

List the groups a node belongs to

Set a node's full group membership, adding and removing to match the desired set

Find every node in the edited scene that belongs to a group

List the nodes currently selected in the editor scene tree

Select nodes in the editor scene tree and optionally show them in the Inspector

Clear the editor scene tree selection

List .gd/.cs/.gdshader files under a project path with their class_name or extends

Read the full text of a script or shader file from the project

Create a .gd or .cs script file, generating a GDScript template when content is empty

Edit a script file using exactly one mode: replacements list, content+start_line line-range replace, content alone full replace, or insert_at_line+text

Attach an existing script resource to a node in the edited scene

List the scripts currently open in the Godot script editor

Compile-check a GDScript file without attaching it, returning validity as data

Create a shader file, generating a template for the given shader_type when content is empty

Read the full source code of a shader file

Edit a shader file using exactly one mode: content for a full replace, or a replacements list of literal search/replace items

Wrap a shader in a new ShaderMaterial and assign it to a node in the edited scene

Set one shader uniform on a node's existing ShaderMaterial

List every shader uniform and its current value on a node's ShaderMaterial

Collect recent editor errors and warnings from the editor log file, script editor compile markers and the debugger Errors tab

Tail the editor's log file (user://logs/godot.log), keeping only lines containing a case-sensitive substring filter

Capture a PNG screenshot of the Godot editor window; empty save_path returns base64, otherwise the image is written to disk

Capture a PNG screenshot of the running game's viewport; empty save_path returns base64, otherwise the image is written to disk

Run GDScript in the editor process as the body of run(); call _mcp_print(v) to emit output and return a value to send it back; file and resource write APIs are refused unless allow_unsafe_editor_io is true

Push old content out of view in the editor Output panel by printing blank lines (cosmetic only, nothing is deleted)

Reload the Godot MCP Bridge plugin; the WebSocket connection drops briefly and auto-reconnects

Trigger a rescan of the project filesystem in the editor

List every signal declared by a node in the open scene with its argument types and current connections

Compare two PNG images (res:// or user:// path, or raw base64) pixel by pixel and return the change count plus a red-highlighted diff image

Enable or disable automatic dismissal of blocking modal dialogs in the editor

Get the 3D editor viewport camera global position, rotation in degrees, fov and clip planes

Move the 3D editor viewport camera in world space; look_at is applied after rotation_degrees and overrides it

Send a keyboard event to the running game by key name such as W, SPACE, ESCAPE or F1 (dropped if no game is running)

Click a mouse button at viewport pixel x,y in the running game, auto-releasing so UI buttons fire (dropped if no game is running)

Move the mouse to viewport pixel x,y in the running game with an optional motion delta and held-button mask (dropped if no game is running)

Press or release a named InputMap action in the running game (dropped if no game is running)

Send an ordered batch of input events to the running game, one event every frame_delay frames (dropped if no game is running)

List InputMap actions with their deadzone and bound events, optionally including builtin ui_* actions

Create or replace an InputMap action's bindings in project settings and in the live editor InputMap

Run an ordered input/wait/assert/screenshot scenario against the running game, optionally launching a scene first

Assert a property of a node in the running game against an expected value using the given operator

Assert that text is visible in any Control element of the running game

Hammer the running game with random input actions for a duration in seconds and report crashes and new log errors

Summarize every assertion recorded this plugin session and optionally clear the collected results

Dump the live scene tree of the running game from the tree root, including autoloads

Read live property values of a node in the running game

Set one property on a live node in the running game and return its old and new value

Capture a burst of viewport frames from the running game as base64 PNGs, spaced by frame_interval frames

Sample properties of a live node over several frames to observe how they change over time

Run GDScript inside the running game process; code runs as the body of run(root: Node), use print() for output, no top-level func definitions and no await

Start recording player input events in the running game; mouse motion is recorded unfiltered and can be voluminous

Stop input recording in the running game and return the recorded event list

Replay recorded input events into the running game, honoring their time_ms timeline scaled by speed

Find live nodes in the running game whose attached script path contains the given substring

Read an autoload singleton at /root/ in the running game

Read properties of several live nodes in one round trip; missing nodes report inline instead of failing

List visible Control nodes in the running game with their text, global rect and center point in screen pixels

Press the first visible button in the running game whose text matches, programmatically rather than via the mouse

Poll the running game until a node exists at the given path or the timeout in seconds elapses