Godot MCP

Godot addon: install or update addons/godot_mcp (the editor bridge and game runtime this server needs) from the copy bundled with the server, and enable it in project.godot.

Godot animation: create/remove/rename animations and add tracks and keys on an AnimationPlayer. ops run in order as one undo step; track paths are "Node:property" relative to the player's root_node.

Godot animation: read or edit the SpriteFrames of an AnimatedSprite2D/3D (or a .tres): add/rename/remove animations, speed/loop, frames cut from a sprite sheet. No ops = summary.

Godot animation: list an AnimationPlayer's libraries and animations, or with animation the tracks and keys of one. Pass library (a .tres) instead of a scene player to read an AnimationLibrary file.

Godot animation: build an AnimationTree state machine, blend space or blend tree (states, transitions, start/end, blend points). ops run in order as one undo step.

Godot animation: show an AnimationTree's graph (states, transitions, blend points, blend tree nodes) and its parameters.

Godot audio: list the audio buses (volume, mute, solo, send) and their effects from the project's bus layout.

Godot audio: add, remove, rename, move and set buses (volume, mute, solo, send) and their effects; saves the bus layout.

Godot project: add, remove or reorder autoloads (global singletons loaded at startup).

Godot scene: apply up to 100 scene edits (node.add, node.set, signal.connect, ...) to one scene in order, all-or-nothing; one undo step in the editor.

Godot code: GDScript errors and warnings for .gd files or a folder, from the language server.

Godot code: hover docs, definition, references, signature, completion or highlights at a position in a .gd file.

Godot code: rename a GDScript symbol across the project via the language server (skips comments/strings). dry_run previews.

Godot code: outline of a .gd file (funcs, signals, vars, consts, classes with lines), or find symbols by name with query.

Godot debug: list, add, remove or clear breakpoints of a game started with godot_run_start (process mode), running or stopped.

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 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: add a node of a built-in type (e.g. Sprite2D, CollisionShape2D, Label) or an instance of a .tscn scene, with optional initial properties. Undoable in the editor.

Godot node: duplicate a node (with children, script and properties) next to the original.