Godot MCP

Godot debug: continue, pause, step_into/over/out (returns the new location and locals), or evaluate an expression in a stopped game (process runs).

Godot debug: is the game stopped (breakpoint, error, pause)? Call stack and variables (locals, members, globals) of a frame.

Godot docs: class reference for an engine or project class, or one member ("Class.member"), as markdown.

Godot docs: search the offline class reference (engine + project classes) by class/member name or words.

Godot editor: open this project in the Godot editor and wait until the MCP plugin connects (the plugin must be enabled in the project).

Godot editor: read messages, warnings and errors printed by the editor process (plugin and tool scripts, import errors; not a running game's prints). Repeats are merged with a count. Page with "since".

Godot editor: get/set the selected nodes, open a script at a line, save all scenes and scripts, or show a toast.

Godot export: change an export preset's fields/options, or create a preset, in export_presets.cfg.

Godot export: list export presets (platform, path, filters, options; secrets redacted) and whether export templates are installed.

Godot export: build the game with an export preset (release, debug, pack-only .pck/.zip, or patch); long-running.

Godot files: delete a file (and its .uid/.import sidecars). Deleting a folder requires recursive: true. This cannot be undone.

Godot files: replace an exact snippet in a text file (old_text -> new_text). old_text must match exactly once unless replace_all. GDScript files are then checked for parse and type errors (as godot_script_validate).

Godot files: list a project folder (res://...). Skips .godot/ and .git/; hides .uid/.import sidecars and, when recursive, addons/ contents unless all. Use recursive with a glob-like "pattern" (e.g. "*.tscn") to find files by type.

Godot files: move or rename a file or folder, carrying its .uid/.import sidecar files. References by uid:// keep working; plain res:// references in other files are NOT updated.

Godot files: read a text file (script, scene .tscn, resource .tres, shader, config) with line numbers. Use offset/limit for long files.

Godot files: search text across project files (scripts, scenes, resources, shaders). Literal by default; set regex for a regular expression.

Godot files: create or overwrite a text file (e.g. a .gd script or .gdshader). GDScript files are then checked for parse and type errors (as godot_script_validate). Prefer godot_files_edit for small changes to existing files.

Godot game: change the running game with ops in order: set properties, call a method (returns its value, awaits coroutines), spawn, remove, change/reload scene. Stops at the first failing op; earlier ops stay (no undo, nothing saved).

Godot game: evaluate code in the running game: an Expression with self = node (default; autoloads and singletons by name), or a GDScript body of func run(node, tree, inputs) (use return). Off unless the server runs with --allow-eval.

Godot game: current values of a live node: script variables and non-default properties (or listed ones, "prop:sub" ok), groups; optionally signal connections and script methods.

Godot game: send input steps in order (keys, actions, clicks on positions or nodes, drags, scroll, typing, joypad, touch, waits). Reports the Control and physics object under each click.

Godot game: performance monitors of the running game (fps, frame times, memory, objects, draw calls...); optionally sample frames (stats, spikes) and profile script functions.

Godot game: record the game's input events (real and injected) with timestamps, stop to get them as compact JSON (or save to a file), and replay them with the original timing.

Godot game: screenshot the running game (window, a node's viewport, or a region) or the editor's 2D/3D view, scaled down. Can save it and diff against a saved image.

Godot game: pause/resume the whole game (Godot's suspend: no node processes; SceneTree.paused untouched), step frames or physics ticks, set speed, or wait for a node, signal, condition, frames or seconds.

Godot game: the running game's live nodes as a flat list (path, class, script, rect/pos, visible text). Filters list matches only; text "Start" finds the button to click.

Godot router: run any read-only operation found with godot_tools (inspect scenes, nodes, files, output).

Godot router: run any operation found with godot_tools that changes the project, scenes, files or editor state.

Description is built at runtime.

Godot world: paint a TileMapLayer/GridMap with ordered ops (set, erase, fill_rect, terrain; clear wipes all cells). One undo step.

Godot world: read a TileMapLayer/GridMap: cells, bounds and the TileSet tiles/terrains or MeshLibrary items to paint with.

Godot import: show an asset's importer, non-default options (full: all), uid and whether its imported files exist (imports new assets first).

Godot import: change an asset's import options (or importer) and reimport it.

Godot project: edit the input map (actions and their key/mouse/gamepad bindings), applied in order and saved to project.godot.

Godot world: bake a NavigationRegion2D/3D from its child colliders, meshes, GridMaps and TileMapLayers.

Godot world: shortest path between two points over the scene's baked navigation regions.

Godot node: find nodes in a scene by name (glob/substring), type (incl. subclasses), group, script or property value.

Godot node: add or remove a node's groups (saved in the scene). Undoable in the editor.

Godot node: instance a .tscn as a linked sub-scene under a parent, optionally with Editable Children. Undoable in the editor.

Godot node: move a node to another position among its siblings (draw/process order). Undoable in the editor.

Godot project facts from project.godot: name, Godot version, main scene, autoloads, input action names, renderer, enabled plugins, C# and test framework detection.

Godot project: enable or disable editor plugins (addons) and list the available ones.

Godot project: change project settings (project.godot); null resets one to its default. Values are converted to each setting's type.

Godot project settings: read raw values from project.godot, filtered by key prefix (e.g. "display/window", "input/jump"). Only non-default values are stored in the file.

Godot project: health check for missing dependencies, stale or duplicate UIDs, script compile errors, broken autoloads, main scene and plugins.

Godot resource: create a resource file of any Resource class (materials, Theme, Gradient, shapes...) or a .gdshader with code.

Godot resource: list a file's dependencies (missing ones flagged), optionally the files that use it; resolves uid:// paths.

Godot resource: read a .tres/.res/.gdshader (or uid://): class, uid, non-default properties, shader uniforms, theme items.

Godot resource: set properties of an existing resource file and save it (undoable in the editor; open scenes update).

Godot run: read output and errors of a game started with godot_run_start (process or editor mode). Use level "error" to see only errors, and "since" (the "next" value from the last call) to page.

Godot run: start the game (main scene, the current scene, or a given scene). Returns a run_id; read errors and prints with godot_run_output, stop with godot_run_stop.

Godot run: stop a running game (the given run_id, the latest process run, or the game playing in the editor).

Godot scene: close a scene tab in the editor. Refuses unsaved changes unless save or discard is true.

Godot scene: create a new scene file that inherits a base scene (like "New Inherited Scene"); opens it in the editor.

Godot signal: connect a node's signal to a method (saved in the scene), optionally creating the handler stub in the target's script.

Godot signal: remove a saved signal connection from a scene. Undoable in the editor.

Godot signal: list saved signal connections of a node or scene and flag problems (missing/mismatched handlers, unconnected _on_* methods).

Godot status: call this first. Shows the project, whether the live editor is connected (open scenes, unsaved changes, playing state), the Godot executable found, and running games.

Godot test: run GUT or GdUnit4 tests headlessly (all, a folder, a file or one test name); returns totals and failures with file:line.

Godot world: create/edit a TileSet .tres: atlas sources, collision (one-way), navigation, occlusion, terrains, custom data, per-tile values, alternative tiles, animation. Saved at once.

Godot visual: apply a Control layout preset, anchors/offsets, size flags or minimum size. Undoable.

Godot visual: compile shader code or a .gdshader/VisualShader file and report errors with line numbers.

Godot visual: edit or create a VisualShader .tres with ordered node ops (add, connect, set...).

Godot visual: list a VisualShader's nodes (id, class, properties) and connections per shader type.