Tools

List the local Godot projects this server knows: the current one (the project its editor bridge serves) and the desktop app's recent projects, each with path, name, Godot version, whether it still exists, and whether an editor is listening for it. Pass one of these paths as project_path to the read-only static tools to inspect a second project without disturbing the connected editor session; project_path accepts only the projects listed here.

Get Godot project metadata (name, Godot version, main scene, autoloads, feature tags). Works with the editor closed; project_path reads another project from list_projects instead.

List files in the Godot project (excludes the .godot cache and .import sidecars by default). project_path lists another project from list_projects instead.

Read a UTF-8 text file inside the Godot project. project_path reads it from another project in list_projects instead.

Create or edit a file in the project. With the editor open it also refreshes the file there: a .gd file is compiled (compiled true/false with parse errors) and the editor's loaded copy and open script tab take the new source, and an open scene file is reloaded in the editor (scene_reloaded), or scene_note explains why not when the editor has unsaved changes to it. Requires Safe Edit or Full Control mode; for protected files (project.godot, .godot cache, the Godot MCP Studio addon) Full Control writes and Safe Edit asks first.

Delete a file in the project. Destructive: Full Control runs it, Safe Edit asks first.

Copy a file within the project (sidecars are regenerated by the editor). Requires Safe Edit or Full Control.

Create a directory (and any missing parents) inside the project. Requires Safe Edit or Full Control.

Move or rename a file within the project, carrying its .import and .uid sidecars so Godot keeps import settings and UID references. Requires Safe Edit or Full Control.

Search the text contents of project files (grep-like). Skips the .godot cache and, by default, the addons folder. project_path searches another project from list_projects instead.

List scene (.tscn) files with their root node name and type. Works with the editor closed; project_path lists another project from list_projects instead.

Get the resource dependencies (ext_resource paths) referenced by a scene file. A dependency moved since the scene was saved is listed at its current path when its uid still resolves.

List GDScript/C# scripts with their class_name and extends. Works with the editor closed; project_path lists another project from list_projects instead.

Get all project.godot settings as structured JSON (sections and keys).

Get project statistics: file counts by kind and total script lines.

Find assets, resources, scenes, and shaders that nothing in the project references (no res:// path or uid:// use anywhere), so dead files can be reviewed and removed. Works with the editor closed.

Detect dependency cycles between scenes and resources (ext_resource references). Cycles make scenes hard to reason about and can break preloading. Works with the editor closed.

Find project files by path, case-insensitive. A plain pattern is a substring match; a pattern with * or ? is a glob, where * and ? stay within one folder and ** spans folders. A glob without / matches file names in any folder (*.tscn), one with / matches the whole path (scenes/**/*.gd). project_path searches another project from list_projects instead.

Get the tree of the scene currently open in the Godot editor (requires the editor to be open with the Godot MCP Studio addon enabled). Pass path to get only that node's subtree. Nesting stops 40 levels below the starting node: a deeper node lists no children and carries children_omitted with its path, so call again with that path to continue.

Get recent editor bridge activity log lines (connection and command events, not full editor stdout, and not script or import errors). To compile-check a script use validate_script.

Capture a screenshot of the Godot editor's main viewport so you can see the current editor state. Pass max_width (for example 960) for a cheap downscaled preview and omit it when fine detail matters.

Describe the open scene's visible layout as structured text: per node its type, path, on-screen rect or world position, text, color, texture, and mesh. The non-visual alternative to get_editor_screenshot for AI clients that cannot see images. Pass include_hidden to include invisible nodes.

Set several properties on a node in one call and one undo step. `properties` maps property names to values (arrays for vectors/colors). Requires Safe Edit or Full Control.

Add a Timer with wait_time, autostart, and one_shot in one call, optionally connecting its timeout signal to a method on another node. Requires Safe Edit or Full Control.

Set the same property on many nodes in one call and one undo step, e.g. hide every enemy at once. Requires Safe Edit or Full Control.

Read the same properties from many nodes in one call, a row per node, for auditing scene state without a request per node.

Set a property on every node of a class across every saved scene in the project (a cross-scene refactor). Open scenes are skipped and reported; changes save to disk and are not undoable. Full Control runs it, Safe Edit asks first.

Get the nodes the user currently has selected in the editor's scene tree. The way to see what the user is pointing at.

Select a node in the editor's scene tree and focus the inspector on it, so the user can see the node being discussed. Requires Safe Edit or Full Control.

Get the editor properties of a node in the open scene (path relative to the scene root).

Search the open scene for nodes by class (with inheritance) and/or name substring. The fast way to navigate a large scene.

Open a scene (.tscn) in the editor so live scene tools act on it, waiting a few editor frames for the tab switch. If the file changed on disk after the editor loaded it, the editor reloads it first (reloaded_from_disk); if the editor also has unsaved changes the result carries a warning instead, and reload true takes the disk version. The editor is shared by every connected AI client and the user: one edited scene and one undo history, so another client can switch scenes between your calls. Pass edited_scene to scene-editing tools to make them refuse to touch any other scene.

Close an open scene tab in the editor: the scene being edited, or the open scene at path. Refuses while the scene has unsaved changes, so call save_scene first. Closes one tab per call and replies once the tab is closed (closed true). Use this instead of run_editor_script to close scenes. Needs Godot 4.5 or newer. Requires Safe Edit or Full Control.

Create a new scene file with a root node and open it. Requires Safe Edit or Full Control.

Add a node of the given class under a parent in the open scene. Requires Safe Edit or Full Control.

Instance a scene (.tscn) as a child node in the open scene, the way reusable game objects are composed. Requires Safe Edit or Full Control.

Duplicate a node (and its children) within the open scene. Requires Safe Edit or Full Control.

Delete a node from the open scene. Destructive: Full Control runs it, Safe Edit asks first.

Rename a node in the open scene. Requires Safe Edit or Full Control.

Move a node to a new parent in the open scene. Requires Safe Edit or Full Control.

Set a property on a node in the open scene. Vector/color values accept arrays like [x, y]. Requires Safe Edit or Full Control.

Connect a signal from one node to a method on another, optionally binding extra arguments (binds). Refuses a connection that already exists, a method whose parameter count cannot take the signal's arguments plus binds, and a method the receiver does not have (unless allow_missing_method is true). Requires Safe Edit or Full Control.

Save the scene currently open in the editor to disk. Never silently replaces a newer file: if the file changed on disk after the editor loaded it, an editor copy without unsaved changes is reloaded instead (reloaded_from_disk), and one with unsaved changes is refused unless overwrite is true. Requires Safe Edit or Full Control.

Undo the most recent editor action, the way Ctrl+Z does: it picks whichever of the open scene's history and the global history (theme, animation and other resource edits) holds the newest action, including every change made through these tools. The history is shared with the user and every other connected AI client, so the newest action may not be yours: check the returned action names undone, and pass edited_scene so it refuses to act on another scene. Returns the action names undone and whether more undo or redo is available. Requires Safe Edit or Full Control.

Redo the last undone editor action across the open scene's history and the global history, in the order the actions were made, the way Ctrl+Shift+Z does. Like editor_undo it works on the history every client and the user share. Returns the action names redone and whether more undo or redo is available. Requires Safe Edit or Full Control.

Turn a node's subtree into a reusable .tscn (Godot's Save Branch as Scene) and replace the branch with an instance of it, the way prefabs are built. Requires Safe Edit or Full Control.

Read a script file's source via the editor.

Create a new script file and compile it; the result carries compiled true/false and any parse errors with line numbers. Requires Safe Edit or Full Control.

Replace the source of an existing script file and compile it; the result carries compiled true/false and any parse errors with line numbers. The editor's loaded copy and any open script tab switch to the new source, so nodes see new exports and a later save or run cannot write the old text back (script_editor_note says when unsaved tab edits were replaced). Requires Safe Edit or Full Control.

Compile-check GDScript source (or an existing script) without running it; reports whether it is valid and lists parse errors with line numbers.

Attach a script resource to a node in the open scene. Requires Safe Edit or Full Control.

Scaffold a single-script state machine on one node and attach it: a State enum, change_state, empty _enter_state/_exit_state match arms, and one physics handler per state. This is not a node-per-state machine. Requires Safe Edit or Full Control.

Inspect a Theme resource: defaults and every defined type/item (colors, constants, fonts, icons, styleboxes).

Set a single Theme color item (type + name). Scene-safe and reversible via Ctrl+Z after reload of dependent controls; requires Safe Edit or Full Control.

Assign a Theme .tres to a Control through editor undo so the style is serialized and visible before Play. Requires Safe Edit or Full Control.

Inspect a Curve resource: domain/value ranges, bake resolution, and every point with tangents.

Inspect a Gradient resource: interpolation settings and ordered color stops.

Inspect SpriteFrames from a .tres path or an AnimatedSprite2D/3D node: animations, FPS, loop, and frames.

Inspect a TileSet from a .tres path or a TileMapLayer node: sources, layers, and terrains.

Style one Control through undoable theme overrides (font size, color, outline, min size, modulate). Requires Safe Edit or Full Control.

Assign a Texture2D as a Button/Control icon through editor undo. Requires Safe Edit or Full Control.

Replace an OptionButton's items in one undoable call (text/id/disabled/icon). Requires Safe Edit or Full Control.

Add a dialog node under a parent: accept (AcceptDialog), confirmation (ConfirmationDialog with a cancel button), or file (FileDialog with file_mode, access and filters for save and load menus). Sets title and button text. Requires Safe Edit or Full Control.

Replace a node with a new class (the editor's Change Type), including the scene root, keeping the name, children and their owners, groups, metadata, compatible properties, signal connections and editable instance flags; undoable. keep_script keeps the script and its exported values when the new class fits it. Nodes inside instanced or inherited scenes are refused; change them in their own scene. Requires Safe Edit or Full Control.

Toggle a node's scene-unique name so scripts can reference it as %Name. Requires Safe Edit or Full Control.

Align Node2D or Control nodes along the x or y axis using the first node as the reference. Requires Safe Edit or Full Control.

Distribute Node2D or Control nodes evenly along x or y with explicit spacing. Requires Safe Edit or Full Control.

Report whether the Godot editor bridge is connected and, when it is not, why: no pairing token, no addon listening on the port, pairing rejected, edition mismatch, the project closed in Godot, or an unresponsive editor. When disconnected it first tries to reconnect (reconnect_attempted), then reports editor_responding, the port, the last disconnect and what the project's pairing file says. Works with the editor closed. Call this first when a live tool says the editor is not connected.

List every tool this MCP server ships. Optionally search names/descriptions or include full input schemas. Use this instead of guessing which Godot tools exist.

Show the verified source, edition, bundle version, per-skill content versions, installation targets, and usage insights and feedback status for this project's generated agent content.

Record that a bundled Godot MCP Studio skill is guiding the current task. Call it once right after you load a skill's SKILL.md for the task, with that skill's exact name. Reports only the skill ID, content/client versions, edition, and an opaque project ID. Pro usage insights are on by default and can be turned off in desktop Settings; this tool returns disabled and stores nothing when they are off or unavailable. Call at most once per skill per task.

Send privacy-limited feedback to the Godot MCP Studio team yourself, without asking the user. Kinds: tool_error when an MCP tool fails, misbehaves, or returns wrong or confusing output, improvement for a missing capability (confirm with list_tools first) or a tool that should behave better, idea for a new feature, workflow, or skill suggestion, praise for something that worked especially well. Optionally name the tool_name or skill_name it concerns. Keep the message short and generic: never include the user's request, prompts, project details, source code, file content, credentials, usernames, or paths. Always on in Pro, whatever the usage insights setting; Lite returns disabled and stores nothing. Returns accepted false with reason rate_limited when this install sent too much recently; do not retry immediately.

Get a website-managed Godot best-practice guide for a topic: proven patterns, tool sequences, and reference links. Call without a topic to list the guides available for this edition. Read the matching guide before building a feature in that area.

List the signals a node can emit (built-in and script-defined), with their argument names.

List the existing signal connections coming out of a node (signal, target node, method).

Disconnect a signal connection between two nodes in the open scene. Requires Safe Edit or Full Control.

List groups: a node's groups when `path` is given, otherwise every group used in the open scene.

Add a node to a group (persisted into the scene). Requires Safe Edit or Full Control.

Remove a node from a group in the open scene. Requires Safe Edit or Full Control.

List the node paths in a given group within the open scene.

Run an arbitrary GDScript snippet inside the editor. The snippet must define `func run():` and may return a value. Has full access to the editor API for automation the fixed tools don't cover. Executes code; Full Control runs it, Safe Edit asks first.

List instantiable Godot classes, optionally filtered. Defaults to Node types. Discover what nodes exist before adding them.

Describe a Godot class: its properties, methods, and signals from ClassDB. The way to learn a node's API without guessing.

Run the project's main scene. First registers class_name scripts the editor has not indexed yet (written outside the editor) and waits up to 15 seconds for a running scan, so new class_name types resolve in the game; script_classes reports what it refreshed. Waits up to 8 seconds for the game runtime to connect and reports game_connected, so game_* tools work right after it returns true. A game that was already running is stopped and replaced (replaced_running_game), and game_connected waits for the new game only. When the runtime does not connect, for example because the game stopped in the debugger on a parse error, script_errors lists each script that does not compile with path, line and message. Executes project code; Full Control runs it, Safe Edit asks first.

Run a specific scene. First registers class_name scripts the editor has not indexed yet (written outside the editor) and waits up to 15 seconds for a running scan, so new class_name types resolve in the game; script_classes reports what it refreshed. Waits up to 8 seconds for the game runtime to connect and reports game_connected, so game_* tools work right after it returns true. A game that was already running is stopped and replaced (replaced_running_game), and game_connected waits for the new game only. When the runtime does not connect, for example because the game stopped in the debugger on a parse error, script_errors lists each script that does not compile with path, line and message. Executes project code; Full Control runs it, Safe Edit asks first.

Stop the running game, including any extra multiplayer test instances launched from the editor.

Report whether a scene is currently running in the editor.

Write and run a game test: provide `body` with check(cond, msg) assertions (or a full `source`). The body may await; it is awaited before checks and failures are counted. Runs in a headless Godot subprocess and reports pass/fail, check counts and output. Executes code; Full Control runs it, Safe Edit asks first.

List the running game instances the editor bridge can reach: index (0 = the editor's own play session, 1 = the play_multiplayer host, 2+ = its clients), pid, and whether each has connected. Pass an index as `instance` to any game_* tool to target it.

Get the live scene tree of the RUNNING game (start it with play_project/play_scene/play_multiplayer first). Pass path to get only that node's subtree. Nesting stops 40 levels below the starting node: a deeper node lists no children and carries children_omitted with its path, so call again with that path to continue.

Get every error, script error, and warning the RUNNING game has raised (push_error, crashes in scripts). New game errors also arrive automatically in the new_errors field of your next tool result; call this for the full list, or with after_sequence to poll without clearing. Each entry is tagged with the instance and pid it came from.

Get the print() output the RUNNING game has produced, for reading debug logs live.

Sample a node property in the RUNNING game over time (up to 8 seconds) and return the series. The way to verify motion, physics, and animation actually happen. To watch a property while input plays, pass monitor to game_simulate_sequence instead.

Restart the RUNNING game's current scene, for fast iteration without stopping and replaying. Requires Safe Edit or Full Control.

Get a node's live property values in the RUNNING game.

Set a property on a node in the RUNNING game (does not persist to the scene file). The value is converted to the property's declared type, so vectors, colors and rects accept arrays or {"x": x, "y": y} objects. Requires Safe Edit or Full Control.

Call a method on a node in the RUNNING game and return its result. JSON args are converted to the method's declared parameter types, so Vector2i, Vector3, Color, Rect2, NodePath and similar arguments accept [x, y] arrays or {"x": x, "y": y} objects; a value that cannot be converted is refused with the expected type. Executes game code; Full Control runs it, Safe Edit asks first.

Cast a native Godot 3D physics ray in the RUNNING game. Use world-space from/to points, or camera_path plus an optional screen position for FPS hitscan and line-of-sight verification. Returns collider, hit position, normal, shape and face indices.

Simulate player input in the RUNNING game: an input action, key press, mouse click, mouse motion, or hover. Mouse x/y and dx/dy are in viewport coordinates (the project's base resolution, the same space as game_find_ui and game_describe_screen rects), converted to window pixels for stretch modes; mouse events without x/y continue from the last simulated pointer position. type hover moves the virtual pointer to x/y, waits a frame and returns the hovered control's path, type, text and cursor_shape, so hover states and custom cursors can be asserted; it does not move your real OS pointer unless warp_cursor is true, and script_mouse_position shows what get_global_mouse_position() reads. type type_text types text into a LineEdit, TextEdit or SpinBox (path, or the focused field) as real key presses. Requires Safe Edit or Full Control.

Run a timed multi-step input sequence in the RUNNING game (combos, run-and-jump, menu flows): steps of action/key/mouse events with hold and delay timing, plus wait steps. The whole sequence plays inside the game on physics frames, so tool-call latency never stretches it; use pressed true/false steps to hold one input while tapping another. Inputs still held at the end are released, and unknown actions are refused. Mouse motion carries the held mouse buttons, so press, move and release steps perform a real Control drag and drop. Pass monitor to sample a property on the same frames while it plays. Requires Safe Edit or Full Control.

Wait until a node exists in the RUNNING game (spawns, scene changes, opening UI) or a timeout passes, then report which. Use before asserting on nodes that appear asynchronously.

List interactive UI in the RUNNING game (buttons, inputs, sliders, and custom controls that handle gui_input) with text as displayed (translated; text_key holds the key when it differs; label_texts lists further Label, RichTextLabel or Button text inside a clickable control), rect [x, y, width, height] in viewport coordinates (the project's base resolution, usable directly as game_simulate_input mouse x/y), and disabled/focus state, optionally filtered by text. The map of what is clickable right now.

Find UI layout overflow in the RUNNING game: Controls whose minimum size is larger than the viewport, children whose minimum size pushes them out of a fixed size parent, and controls partly outside the viewport. Each issue lists sizes, the overflow in pixels, the child chain whose minimum size drives it, the cause (many stacked children, custom_minimum_size, unwrapped text, texture size) and a fix hint. Reports the outermost offender per branch and skips ScrollContainer content.

Describe what the RUNNING game shows on screen as structured text: visible UI (with text and rect), on-screen sprites/bodies/meshes (with position and texture), and the active 2D/3D camera. The non-visual alternative to game_screenshot for AI clients that cannot see images.

Click a button/control in the RUNNING game by its visible text (or exact path), via real simulated mouse press and release at its center. Text matches what is displayed, so translated text works as well as the translation key, and it also matches Label, RichTextLabel or Button text anywhere inside a button or a custom control that handles gui_input; the click lands on the innermost such clickable control, not on the label. The returned position is in viewport coordinates, matching game_find_ui. Requires Safe Edit or Full Control.

Start recording the player's real input (keys, mouse) with timestamps in the RUNNING game, for building regression replays from an actual session. Requires Safe Edit or Full Control.

Stop the input recording in the RUNNING game and return the captured events (also kept in the game for game_replay_input).

Replay recorded input events with their original timing in the RUNNING game (background playback; observe with screenshots or monitors). Omit events to replay the last recording. Requires Safe Edit or Full Control.

Assert a node property in the RUNNING game against an expected value (eq, ne, gt, lt, ge, le, contains) and get a pass/fail with the actual value. The building block for automated play-test checks.

Capture a screenshot of the RUNNING game's viewport so you can see what the player sees. Pass max_width (for example 640) for a cheap downscaled preview and omit it when fine detail matters. Not available on an instance launched with headless_host.

Get live performance metrics of the RUNNING game: FPS, frame times, memory, node count, draw calls.

Set the RUNNING game's engine time scale (slow motion / fast forward). Requires Safe Edit or Full Control.

Pause or unpause the RUNNING game's scene tree. Requires Safe Edit or Full Control.

Report physics contacts in the RUNNING game: floor/wall/ceiling and slide collisions for character bodies, overlaps for areas, colliding bodies for rigid bodies. Empty path walks the whole scene. The way to debug why something is (not) colliding.

Capture a short sequence of viewport frames from the RUNNING game as PNGs (motion the agent can review), spaced over time. Returns the saved frame paths.

Set the RUNNING game viewport's debug draw mode (disabled, unshaded, wireframe, overdraw, normal_buffer) to inspect rendering. Requires Safe Edit or Full Control.

Import an animated GIF from the selected Godot project into a local Image Studio artwork. Every GIF frame becomes its own saved PNG frame named <output_name>-01, -02 and so on, and the reported detected_fps comes from the GIF's own frame delays. Pass animation_id to append the frames to an existing timeline in order, or build one afterwards with configure_image_studio_animation. Limited to 240 frames and refuses a GIF whose frames change size. Free, offline, never uploads artwork, and requires Safe Edit or Full Control.

Write a local Image Studio animation into the selected Godot project as one animated GIF, at the animation's own frame rate, looping when the animation loops. Use it to preview or share a clip; the per-frame PNGs and the SpriteFrames handoff remain the way to bring artwork into a game. Refuses to overwrite an existing file. Free, offline, never uploads artwork, and requires Safe Edit or Full Control.

Write local Image Studio animations into the selected Godot project as one zip archive holding a PNG per frame, named <animation>_<direction>-01.png, which is the same layout the web download produces. Leave animation_ids empty to archive every animation in the artwork that has saved frames; empty animations are skipped and listed in skipped_empty_animations. Refuses to overwrite an existing file. Free, offline, never uploads artwork, and requires Safe Edit or Full Control.

Create or edit a persistent local Image Studio skeleton: create a rig from a template (create_humanoid with template humanoid, quadruped, or bird), add/update/remove custom bones, set angle constraints and influence handles, set/remove frame pose keyframes, bind artwork, toggle IK, or clear the rig. Uses normalized coordinates and rejects stale project state. Free, offline, and never calls an image provider. Requires Safe Edit or Full Control.

Generate pixel art sprites, tiles, icons, sprite sheets, or animations with hosted Image Studio AI, or edit, inpaint, cut out, or vary a saved artwork, instead of writing Python/PIL or other scripts. This is the paid route: it spends the user's Image Studio credits, and only after they review the price and approve it in the desktop app; drawing with create_image_studio_project is the free local route. This tool cannot approve, reserve credits, or call a provider. Target project_id or new_project. The proposal is checked against the same rules the app and server apply before it is saved, so an invalid combination returns an error naming the field and the fix and never reaches the approval queue. Presets with a fixed camera, such as character_side or map_top_down (all listed under preset), take camera_view auto. render_style, model_tier and pro_style apply only to generate and variation, the animation fields only to animation_set, and tile_mode only to tiles_seamless; each field lists its allowed values and canvas sizes. Pixel presets accept max_colors (1 to 256) and a palette of hex colours to lock the output to. Always set name to a short label for the result, such as mine_east or hero idle; the desktop uses it for the timeline clip, layer, and saved file names. Poll get_image_studio_generation_request: a failed request carries the reason in error and the next step in hint. Then export_image_studio_asset the output into the Godot project. Requires Safe Edit or Full Control.

List recent MCP-proposed hosted Image Studio requests and their desktop approval, provider queue, completion, failure, or cancellation state. Filter by status (one value or a list) and project_id; limit defaults to 20 with open requests first, then newest first. Read-only and never contacts a provider.

Get one MCP-proposed hosted Image Studio request, including whether it awaits desktop review/approval and its reserved, queued, running, waiting-provider, storing, completed, failed, canceled, or reconciliation state. download_failed means the job finished and was paid but the desktop could not import the result yet; the user can retry the import from the desktop Approvals page. A request in storing for over 2 minutes carries a hint: it is paid and waits for the desktop app to import it, so never request it again. A failed request carries the specific reason in error, such as a content filter, canvas size or style mismatch, and the next step in hint; send a corrected request with a new idempotency_key instead of asking the user to retry. Read-only.

Request cancellation of an MCP-proposed hosted Image Studio job. Unsubmitted proposals cancel immediately; a submitted job remains cancel_requested until the desktop app performs the required device-signed cancellation, including jobs in reconciliation_required. If the provider had already charged, the job keeps running and its result is still imported. Requires Safe Edit or Full Control.

Copy a saved local Image Studio asset into the selected Godot project as a new PNG (`res://<destination_folder>/<output_name>.png`). Completes the artwork pipeline after generation or editing without a manual desktop step. Refuses to overwrite existing project files; pass the inspected asset SHA-256 to reject stale exports. With the editor open it waits briefly for the import and returns editor_imported; when that is false, retry before using the PNG in a scene. Free, offline, never uploads artwork, and requires Safe Edit or Full Control.

Start here for game art (pixel art, sprites, tiles, icons, animations): lists local Image Studio projects and returns the agent guide with exact pixel, mask, animation, transform, privacy, and concurrency examples. Call it before the first art task instead of writing an image script. Free, runs locally, never uploads artwork.

Start free local pixel art (sprites, tiles, icons, animation frames) on a blank Image Studio canvas with a mode, palette, style notes, and a first animation, when no listed project fits. Use this instead of writing Python/PIL or other scripts to draw game art. Free, runs locally, never uploads artwork. Then inspect it, draw with apply_image_studio_pixel_patch, and export_image_studio_asset into the Godot project. Requires Safe Edit or Full Control.

Copy an existing PNG from the selected Godot project into a local Image Studio project as a source, frame, or mask. The original project file is never changed; a frame can optionally join an animation. Free, offline, stale-write protected, and requires Safe Edit or Full Control.

Flip, rotate, nearest-neighbor resize, crop transparent borders, reduce the palette, or remove a white background, saved as a new local Image Studio asset. Use this instead of a Python/PIL script for these edits. Requires the inspected asset hash and never overwrites its source. Free and runs locally. Requires Safe Edit or Full Control.

Slice a saved Image Studio sprite sheet into up to 256 complete frame PNGs in row-major order, optionally appended to an animation, instead of cutting it with a script. Requires the inspected asset hash, ignores partial edge cells, and preserves the source. Free and runs locally. Requires Safe Edit or Full Control.

Update a local Image Studio project's name, editor mode, palette, style notes, master reference, or selected asset with stale-write protection. Free, offline, never uploads artwork, and requires Safe Edit or Full Control.

Create, rename, retime, duplicate, or replace the ordered frames of a local Image Studio animation. Frame changes preserve saved image assets and prune pose keys for removed frame IDs. Free, offline, never uploads artwork, and requires Safe Edit or Full Control.

Place saved tiles on a local Image Studio tile map, resize the grid up to 32 by 32, clear it, or switch the desktop workspace between the artwork canvas and the tile map. Each placement names a column, a row, and a saved tile asset, on either the terrain or the object layer. Free, offline, never uploads artwork, and requires Safe Edit or Full Control.

Replace a local Image Studio layer stack and optionally flatten it into a new frame using normal, multiply, screen, or add blending, opacity, visibility, ordering, and pixel offsets. Source assets remain unchanged; the rendered frame can join an animation. Free, offline, never uploads artwork, and requires Safe Edit or Full Control.

Inspect a local Image Studio project and an exact PNG pixel region. Returns project palette, assets, animations, SHA-256, lossless row run-length data, and an attached PNG visual preview for multimodal AI clients. Read larger artwork in bounded tiles. Free, offline, and never uploads artwork.

Draw or edit pixel art locally with exact pixel replacements on an Image Studio artwork or mask: copy a saved asset, or omit base_asset_id to draw on a transparent canvas. Use this instead of Python/PIL or other scripts to draw sprites, tiles, icons, or animation frames. Free, runs locally, never calls an image provider. Creates a new PNG, preserves the original, and can append frame outputs to an animation. Pass pixels inline as edits, or for large patches write the same edits array (or an object with an edits key) to a .json file inside the Godot project and pass its res:// path as edits_path; give exactly one. Requires the inspected project timestamp and asset SHA-256 to reject stale edits. Requires Safe Edit or Full Control.

Clean up a project image as pixel art into a new PNG: nearest-neighbor resize, transparent-border trim, palette reduction, alpha cleanup, and isolated-pixel cleanup. Use this instead of a Python/PIL script to downscale or palettize art. Free, runs locally, never uploads the image. Requires Safe Edit or Full Control and Image Studio enabled.

List project asset files, optionally filtered by kind (texture, audio, scene, script, model, font, resource).

Get an image asset's pixel dimensions; check this before slicing a sprite sheet or sizing a tileset.

Compare two images pixel by pixel (before/after screenshots, texture revisions): changed-pixel ratio, changed-region bounding box, and an optional saved red-mask diff image.

Translate between uid:// identifiers and res:// paths, in either direction. Scenes and scripts reference resources by uid.

Copy an external local asset into res://, import it with the optional import settings applied from the first import, and report editor_imported once the editor has imported it (a new folder is scanned first). Requires Full Control; Safe Edit asks first.

Set import parameters for an asset and reimport it, e.g. {"edit/loop_mode": 2} to make a WAV loop forward (0 Detect From WAV, 1 Disabled, 2 Forward, 3 Ping-Pong, 4 Backward). Requires Safe Edit or Full Control.

Reimport up to 100 existing assets without changing their import settings. Useful after repairing missing or stale imported artifacts. Requires Safe Edit or Full Control.

Rescan the project filesystem so files written outside the editor are picked up and imported. Call this after writing a new file into a folder the editor has not seen, such as a freshly installed template or generated art, when a tool reports an asset is not imported. Requires Safe Edit or Full Control.

Replace all control points on a Curve resource (particle scale/alpha curves, easing). Optionally set domain and value range and bake resolution. Requires Safe Edit or Full Control.

Replace a Gradient resource's colors, offsets, interpolation mode (linear/cubic/constant), and color space (srgb/linear_srgb/oklab/oklch). Requires Safe Edit or Full Control.

Get a resource's class, name, and stored properties.

Create a Resource (.tres/.res) of any Resource subclass with initial properties. Requires Safe Edit or Full Control.

Set properties on an existing Resource file. Unknown property names and values that do not convert to the property's type are refused and nothing is saved. Requires Safe Edit or Full Control.

Read a Resource file's class and stored properties.

Create a Curve resource (.tres) from [[x, y], ...] control points, for particle scale/alpha curves and easing. Requires Safe Edit or Full Control.

Create a Gradient resource (.tres) from colors and optional offsets, for particle color ramps and shader ramps. Requires Safe Edit or Full Control.

List the animations on an AnimationPlayer node.

Create an animation on an AnimationPlayer node. Requires Safe Edit or Full Control.

Add a value track to an animation targeting a node's property. Requires Safe Edit or Full Control.

Insert a keyframe on an animation track. Values coerce to the property's type. Requires Safe Edit or Full Control.

Get an animation's length, loop flag, and tracks.

Add an AnimationTree with a state-machine root, wired to an AnimationPlayer and active. The base for blend/state animation. Requires Safe Edit or Full Control.

Add a state (an animation) to an AnimationTree's state machine. Requires Safe Edit or Full Control.

Connect two states in an AnimationTree's state machine, optionally auto-advancing. Requires Safe Edit or Full Control.

The states and transitions of an AnimationTree's state machine.

Remove an animation from an AnimationPlayer's library. Requires Safe Edit or Full Control.

Author a simple property tween (move/fade/scale over time) as an AnimationPlayer animation with two keyframes, without writing GDScript; the player is created under the target when none is given. Requires Safe Edit or Full Control.

Add an AnimatedSprite2D with multiple named SpriteFrames animations cut from one sprite-sheet grid (hframes x vframes), each mapped to frame indices with fps and loop. For a single quick animation, use add_animated_sprite. Requires Safe Edit or Full Control.

Rename an animation inside an AnimationPlayer's library. Requires Safe Edit or Full Control.

Set animations on a SpriteFrames resource or AnimatedSprite2D. Each animation accepts explicit frames [{texture, duration?}, ...] or a sprite-sheet slice {texture, hframes, vframes, from?, to?, row?}. Requires Safe Edit or Full Control.

List every track on an animation: index, type, node path, property, interpolation mode, loop_wrap, update_mode, and key count.

Create or reconfigure an animation track: type (VALUE, TRANSFORM3D, ROTATION_3D, SCALE_3D, BEZIER, AUDIO, ANIMATION, METHOD, BLEND_SHAPE), NodePath:property, interpolation, loop_wrap, update_mode. Supports native Ctrl+Z. Requires Safe Edit or Full Control.

Replace or merge keyframes on an animation track from a [{time, value}, ...] array. Requires Safe Edit or Full Control.

Delete an animation track by index; undoable via native Ctrl+Z. Requires Safe Edit or Full Control.

Remove a single keyframe from an animation track by key_index or by time. Requires Safe Edit or Full Control.

Add a node to an AnimationTree BlendTree graph. type is one of: animation, blend_2, blend_3, one_shot, add_2, add_3, blend_space_1d, blend_space_2d, blend_tree, state_machine, time_scale, time_seek, transition. Full Godot class names are not accepted. Supports graph position and type-specific properties. Requires Safe Edit or Full Control.

Connect two nodes in an AnimationTree's BlendTree graph; to_input is a port index or port name. Requires Safe Edit or Full Control.

Remove a named node from an AnimationTree's BlendTree graph. Requires Safe Edit or Full Control.

Add an AudioStreamPlayer (plain, 2d, or 3d) with its stream, bus, and autoplay set in one call. Requires Safe Edit or Full Control.

Audit every audio player in a subtree (default: whole scene): stream, bus (and whether it exists), volume, autoplay; plus the bus list.

List the audio buses and their volumes.

Add an audio bus. Requires Safe Edit or Full Control.

Set an audio bus's volume/mute/send. Requires Safe Edit or Full Control.

Persist the current audio bus layout to res://default_bus_layout.tres. Requires Safe Edit or Full Control.

Add an audio effect (reverb, delay, chorus, distortion, compressor, limiter, phaser, eq, lowpass, highpass, amplify, pitch_shift) to a bus with property overrides. Requires Safe Edit or Full Control.

Create an AudioStreamRandomizer from audio files with pitch and volume variation, saved as .tres and optionally assigned to a player, for non-repetitive sound effects. Requires Safe Edit or Full Control.

List the project's input actions and their events. Godot's built-in ui_* actions are hidden unless include_builtin is true; hidden_builtin reports how many were left out.

Add an input action. Requires Safe Edit or Full Control.

Bind a physical key to an input action. Requires Safe Edit or Full Control.

Remove an input action. Destructive: Full Control runs it, Safe Edit asks first.

Bind an input event to an action: key, mouse_button, joy_button, or joy_axis. Covers keyboard, mouse, and gamepad. Requires Safe Edit or Full Control.

Paint a single cell on a TileMapLayer. Requires Safe Edit or Full Control.

Fill a rectangle of cells on a TileMapLayer. Requires Safe Edit or Full Control.

Read a TileMapLayer cell's source and atlas coords.

Clear all cells on a TileMapLayer. Destructive: Full Control runs it, Safe Edit asks first.

List the used cells of a TileMapLayer, a page at a time: total is the full count and next_offset is set while more cells remain.

Paint many TileMapLayer cells in one call: `cells` is [[x, y], ...] sharing one source/atlas tile. The bulk way to lay out a level. Requires Safe Edit or Full Control.

Create a TileSet resource from an atlas texture (grid of tile_width x tile_height tiles), save it as .tres, and optionally assign it to a TileMapLayer. Requires Safe Edit or Full Control.

A TileMapLayer's tileset summary: tile size, atlas sources with their textures and grids, and used cell count. Check this before painting.

Paint connected autotile terrain across TileMapLayer cells using the TileSet terrain rules. Requires Safe Edit or Full Control.

Configure a TileSet atlas source: assign the atlas texture, set tile region size, separation, margins, and optionally auto-create tiles. Requires Safe Edit or Full Control.

Add physics, navigation, and occlusion layers to a TileSet resource; each layer is a JSON object with optional mask/collision/navigation properties. Requires Safe Edit or Full Control.

Configure terrain sets and their named terrains on a TileSet resource; terrain_sets is [{mode?, terrains: [{name, color?}, ...]}, ...] with mode match_corners_and_sides, match_corners or match_sides. Requires Safe Edit or Full Control.

Set per-tile data on TileSet tiles: collision, navigation, terrain assignment, probability, and custom data. tiles is [{source_id, atlas_x, atlas_y, physics?: [{layer, full: true} or {layer, polygons: [[[x, y], ...]]}], navigation?, terrain_set?, terrain?, probability?}, ...]; polygon points are relative to the tile centre. Requires Safe Edit or Full Control.

Add a Line2D from [[x, y], ...] points with width, color, and closed flag, for trails, lasers, and drawn shapes. Requires Safe Edit or Full Control.

Add a CanvasModulate that tints every node on the canvas, for day/night and mood. Requires Safe Edit or Full Control.

Add a PointLight2D or DirectionalLight2D with color, energy, and (for point lights) a texture; a point light without one gets a default radial gradient texture so it lights up. Requires Safe Edit or Full Control.

Add a LightOccluder2D with an occluder polygon from [[x, y], ...] points, so 2D lights cast shadows. Requires Safe Edit or Full Control.

Add a Parallax2D layer with a scroll scale and repeat size, for scrolling layered backgrounds. Requires Safe Edit or Full Control.

Add a Polygon2D from [[x, y], ...] points with a fill color, for flat shapes without art. Requires Safe Edit or Full Control.

Set position, rotation_degrees, and/or scale on a Node2D or Control in one call. Vectors are [x, y] arrays. Requires Safe Edit or Full Control.

Generate a solid or checkerboard placeholder PNG inside the project, so scenes are visible and playable before real art exists. Requires Safe Edit or Full Control.

Assign a Texture2D to a node's texture property (Sprite2D, TextureRect, ...). Requires Safe Edit or Full Control.

Add a Sprite2D with its texture and position in one call. Requires Safe Edit or Full Control.

Add an AnimatedSprite2D with one SpriteFrames animation sliced from a sprite-sheet grid (h_frames x v_frames), ready to play. For several named animations from one sheet, use add_sprite_frames instead. Requires Safe Edit or Full Control.

Add a Camera2D, optionally enabled (the one the game uses) with position and zoom. Requires Safe Edit or Full Control.

Set a Camera2D's scroll limits and optional position smoothing, so the camera stops at level edges and eases toward its target. Requires Safe Edit or Full Control.

Add a Decal that projects a texture onto surfaces (bullet holes, blob shadows, signage) with a size and position. Requires Safe Edit or Full Control.

Add a ReflectionProbe for local reflections, with a size and box projection. Requires Safe Edit or Full Control.

Add a SubViewport with a render size, for minimaps, render targets, and 3D-in-2D. Requires Safe Edit or Full Control.

Add a GridMap with an optional MeshLibrary and cell size, for 3D tile-based levels. Requires Safe Edit or Full Control.

Set a GridMap cell to a MeshLibrary item (item -1 clears the cell). Requires Safe Edit or Full Control.

Create a StandardMaterial3D from a named preset (metal, chrome, plastic, rubber, glass, emissive, toon, unshaded) with an optional tint, save it as .tres, and optionally assign it. Requires Safe Edit or Full Control.

Add 3D text: a MeshInstance3D with a TextMesh, with font size, extrusion depth, and color. Requires Safe Edit or Full Control.

Generate a terrain: a noise-displaced mesh from size, resolution, height, seed, and frequency, with optional trimesh collision. Requires Safe Edit or Full Control.

Set the boolean operation (union, subtraction, intersection) on a CSG shape, for carving and combining level geometry. Requires Safe Edit or Full Control.

Scatter instances of a mesh over an area with one MultiMeshInstance3D: seeded random positions, rotations, and scales, for trees, rocks, and props. Requires Safe Edit or Full Control.

Add a SpringArm3D camera boom that keeps its child camera out of walls, with length and an optional Camera3D child, for third-person cameras. Requires Safe Edit or Full Control.

Add global illumination: a VoxelGI probe (realtime) or LightmapGI (baked), for bounced light. Requires Safe Edit or Full Control.

Add a 3D primitive mesh (box, sphere, cylinder, capsule, plane, prism, torus). Requires Safe Edit or Full Control.

Add a 3D light (directional, omni, spot). Requires Safe Edit or Full Control.

Add a Camera3D. Requires Safe Edit or Full Control.

Set a StandardMaterial3D (albedo color, metallic, roughness) on a MeshInstance3D. Requires Safe Edit or Full Control.

Add a CSG shape (box, sphere, cylinder, torus) with a boolean operation (union to build, subtraction to carve) for 3D level blockout. Collision on by default. Requires Safe Edit or Full Control.

Create a real Godot StandardMaterial3D resource (color, metallic, roughness, emission, albedo/normal textures, transparency, cull mode), save it as .tres, and optionally assign it in the edited scene. Generates no gameplay script. Requires Safe Edit or Full Control.

Edit a MeshInstance3D material as an undoable serialized editor resource, including res:// texture properties; shared materials are duplicated into a scene-local override first. Generates no gameplay script. Requires Safe Edit or Full Control.

Tune an existing WorldEnvironment: glow/bloom, fog, tonemap (linear/reinhard/filmic/aces), and ambient energy, beyond the initial add_environment. Requires Safe Edit or Full Control.

Orient a Node3D to look at a target node or along a direction vector, for cameras, turrets, and AI. Requires Safe Edit or Full Control.

Set position, rotation_degrees, and/or scale on a Node3D in one call. Vectors are [x, y, z] arrays. Requires Safe Edit or Full Control.

Add a WorldEnvironment with a procedural sky, sky ambient light, and optionally a shadowed sun. One call makes an empty 3D scene look lit. Requires Safe Edit or Full Control.

Fill a box, shell, floor, or line of GridMap cells in one call. Requires Safe Edit or Full Control.

Populate the items of a PopupMenu, or of a MenuButton's popup, from a JSON array [{label, id?, disabled?, checkable?, icon?}, ...]; optionally clear existing items first. Safe Edit via native Ctrl+Z. Requires Safe Edit or Full Control.

Populate a MenuBar with named PopupMenu children from a menus array [{name, items: [{label, id?, ...}, ...]}, ...]. Creates the MenuBar at path (default scene root). Requires Safe Edit or Full Control.

Populate an ItemList from a JSON items array [{text, icon?, disabled?, selectable?, tooltip?}, ...]; optionally clear existing items first. Requires Safe Edit or Full Control.

Add a Control node (Label, Button, Panel, ...) with its text and anchors preset in one call. The quick way to build UI. Requires Safe Edit or Full Control.

Apply a Control anchors preset (center, full_rect, top_wide, ...) like the editor's Layout menu, the sane way to lay out UI. Requires Safe Edit or Full Control.

Add a layout container (vbox, hbox, grid, margin, center, panel, scroll, ...) with grid columns, child sizing flags, separation, and an anchors preset, so responsive layouts are one call instead of manual anchor math. Requires Safe Edit or Full Control.

Assign an imported Godot Texture2D resource to a TextureRect/TextureButton through undoable editor history, with stretch and expand settings serialized in the scene. Generates no gameplay script. Requires Safe Edit or Full Control.

Add a ProgressBar (health/mana/stamina) with min, max, value, and optional fill and background colors, styled through theme overrides in one call. Requires Safe Edit or Full Control.

Connect a button's pressed signal (or toggled/button_down) to a method on a target node in one call, the most common UI wiring. Requires Safe Edit or Full Control.

Import a .ttf/.otf/.woff font and assign it as a per-node override, a Theme's default font, or both, so text uses a real typeface. Requires Safe Edit or Full Control.

Add a Marker2D/Marker3D (auto-detected from the parent) at an optional position, for spawn points and reference transforms. Requires Safe Edit or Full Control.

Add a RemoteTransform2D/3D (auto-detected) that drives a target node's transform, for camera rigs and followers. Requires Safe Edit or Full Control.

Add a Path2D/Path3D (auto-detected) with a curve built from points, for patrol routes and rails. Requires Safe Edit or Full Control.

Add a PathFollow2D/3D under a Path node, with progress and loop, so a node moves along the path. Requires Safe Edit or Full Control.

Add a VisibleOnScreenNotifier2D/3D (auto-detected) for on-screen detection, spawn/despawn, and culling. Requires Safe Edit or Full Control.

Add a MultiplayerSpawner that replicates spawned scenes under a path, for networked games. Requires Safe Edit or Full Control.

Add a MultiplayerSynchronizer that replicates a node's properties across the network. Requires Safe Edit or Full Control.

Create a complete high-level multiplayer setup using Godot's built-in networking: a NetworkManager autoload script (ENetMultiplayerPeer host/join/leave with peer connection signals) and, when player_scene is set, a MultiplayerSpawner in the open scene that replicates that scene per player. No third-party addon needed. Requires Safe Edit or Full Control.

List the editor plugins installed under addons/: folder, name, version, author, and whether each is enabled.

Enable or disable an installed editor plugin by its addons/ folder name (rescans the filesystem first so a just-installed addon is found). If the plugin's commands still report 'Method not found' afterwards, focus the editor window once and retry. Enabling runs the plugin's code inside the editor, so it requires Full Control (Safe Edit asks first); disabling requires Safe Edit or Full Control.

Search the official Godot Asset Library (godotengine.org) for addons: title, author, license, support level, version, and the asset id install_addon needs. Read-only network request.

Install any addon from the official Godot Asset Library by asset id: downloads it, verifies the archive, and stages its addons/ folder into the project with zip-slip protection. Works for every GDScript addon (Dialogic, Phantom Camera, LimboAI's script edition, and so on); call enable_plugin with the returned folder afterwards. Addons that ship native GDExtension binaries are installed only when the asset is on the built-in reviewed list (currently GodotSteam, asset id 2445); those always ask the user for a second confirmation listing the binaries and need an editor restart instead of enable_plugin. Other native addons are refused with manual install instructions. Requires Full Control; Safe Edit asks first.

List every bone of a Skeleton3D (index, name, parent, rest position). Point at the skeleton or any ancestor of an imported model.

Pose one bone of a Skeleton3D by name or index: position, rotation_degrees, scale. Requires Safe Edit or Full Control.

Reset every bone of a Skeleton3D back to its rest pose. Requires Safe Edit or Full Control.

Describe a MeshInstance3D: surfaces with materials and vertex counts, blend shapes with values, AABB, and skeleton path.

Set a blend-shape weight on a MeshInstance3D by shape name, for facial expressions and morphs. Requires Safe Edit or Full Control.

List animations inside a scene file, including imported .glb/.gltf/.fbx models: every AnimationPlayer with animation names, lengths, and loop modes.

Create a Skeleton3D from a bone list ({name, parent, position, rotation_degrees} each), for custom rigs. Requires Safe Edit or Full Control.

Append a bone to a Skeleton3D with a parent bone, rest position, and rotation. Requires Safe Edit or Full Control.

Set a bone's rest transform (position, rotation_degrees, scale) by name or index, and pose it there. Requires Safe Edit or Full Control.

Create a Skeleton2D with a hierarchy of Bone2D nodes for cutout animation. Requires Safe Edit or Full Control.

Create a BoneMap resource for animation retargeting, optionally using SkeletonProfileHumanoid. Requires Safe Edit or Full Control.

Auto-build a humanoid BoneMap from a Skeleton3D in the open scene by name-matching its bones to SkeletonProfileHumanoid, and report which required bones stayed unmapped. Optionally saves a .tres. Use this to retarget imported animations and validate missing mappings before wiring a RetargetModifier3D or setting the retarget bone_map in a model's .import options. Requires Safe Edit or Full Control.

Add a LookAtModifier3D under a Skeleton3D to drive a bone toward a target. Requires Safe Edit or Full Control.

Add an IK chain modifier under a Skeleton3D so a bone chain reaches a target node, using Godot 4.4+ solvers (two_bone, ccdik, fabrik, jacobian). The chain is auto-generated between root_bone and end_bone. Not the deprecated SkeletonIK3D. Requires Safe Edit or Full Control.

Add a CSGPolygon3D extruded from a 2D outline for fast level geometry. Requires Safe Edit or Full Control.

Add an OccluderInstance3D with a BoxOccluder3D resource for occlusion culling. Requires Safe Edit or Full Control.

Add a BoneAttachment3D under a Skeleton3D, bound to a named bone, for attaching weapons and props. Requires Safe Edit or Full Control.

Set a body's PhysicsMaterial: friction, bounce, rough, absorbent, for ice, rubber, and game feel. Requires Safe Edit or Full Control.

Add a CollisionPolygon2D/3D (auto-detected) from [[x, y], ...] points; the 3D polygon extrudes by depth. Requires Safe Edit or Full Control.

Add a ShapeCast2D/3D (auto-detected) with a sphere or box shape and cast vector, for thick raycasts like melee sweeps and ground checks. Requires Safe Edit or Full Control.

Generate collision for a MeshInstance3D (e.g. an imported model): a static trimesh for level geometry or a convex hull for dynamic bodies. Requires Safe Edit or Full Control.

Add a complete 3D physics body in one call: body (character, static, rigid, or area), a fitted collision shape (box, sphere, capsule), and a matching visible mesh. Requires Safe Edit or Full Control.

Add a CollisionShape2D/3D (auto-detected) with a sized shape under a physics body/area. size takes the same form as add_body_2d/add_body_3d: rectangle [w, h], box [w, h, d], circle or sphere [radius], capsule [radius, height]. Requires Safe Edit or Full Control.

Set collision_layer/collision_mask bitmasks on a physics body/area. Requires Safe Edit or Full Control.

Get a node's collision type, dimension, layer, and mask.

Add a RayCast2D/RayCast3D (auto-detected from the parent) with target vector, collision mask, and enabled flag in one call. Requires Safe Edit or Full Control.

Set collision_layer/collision_mask by their project-settings layer names instead of raw bitmasks, so intent survives renumbering. Requires Safe Edit or Full Control.

Add a complete 2D physics body in one call: body (character, static, rigid, or area), a fitted collision shape, and optionally a sprite. The building block for players, platforms, enemies, and pickups. Requires Safe Edit or Full Control.

Configure a Theme resource in one call: default font size, base scale, and bulk colors/constants/font_sizes/fonts/icons/styleboxes arrays whose entries name the control type and item, e.g. colors [{theme_type: "Label", name: "font_color", color: [1, 1, 1, 1]}]. Supports Safe Edit via native Ctrl+Z. Requires Safe Edit or Full Control.

Merge another Theme resource's entries into the target Theme, preserving existing entries that are not overwritten. Requires Safe Edit or Full Control.

Create a Theme resource (.tres). Requires Safe Edit or Full Control.

Set a theme constant. Requires Safe Edit or Full Control.

Set a theme font size. Requires Safe Edit or Full Control.

Set a flat StyleBox (background color, corner radius, border, content margin) on a theme entry, e.g. a Button's normal state or a Panel's panel. Requires Safe Edit or Full Control.

Create a .gdshader file. Requires Safe Edit or Full Control.

Read a shader's source.

Replace a shader's source. Requires Safe Edit or Full Control.

Assign a shader to a node as a ShaderMaterial. Requires Safe Edit or Full Control.

Set a uniform on a node's ShaderMaterial (assign_shader first). Requires Safe Edit or Full Control.

List the uniforms a node's shader exposes, with current values.

Write a ready-made 2D shader preset (outline, flash, dissolve, scroll, grayscale, wave) as a .gdshader and optionally assign it to a node. Requires Safe Edit or Full Control.

Create a VisualShader resource (.tres) with a given mode (canvas_item, spatial, particles, sky, fog) and optionally assign it as a ShaderMaterial to a node. Requires Safe Edit or Full Control.

Get a VisualShader's mode, graph nodes (id, type, position, properties), and connections for all shader types.

Add a VisualShaderNode to a VisualShader graph with optional id, position [x,y], and type-specific properties. Returns the assigned node id. Requires Safe Edit or Full Control.

Set a property on a VisualShaderNode by its id and property name. Requires Safe Edit or Full Control.

Connect two VisualShaderNodes (from_node:from_port → to_node:to_port) in the given shader type graph. Requires Safe Edit or Full Control.

Disconnect two VisualShaderNodes in the given shader type graph. Requires Safe Edit or Full Control.

Remove a VisualShaderNode by id from the shader graph; disconnects its edges automatically. Requires Safe Edit or Full Control.

Add a NavigationRegion (2D/3D auto-detected) under a parent. Requires Safe Edit or Full Control.

Add a NavigationAgent (2D/3D auto-detected) under a parent. Requires Safe Edit or Full Control.

Get a navigation node's type and layers.

Bake a NavigationRegion2D/3D from the geometry under it, so agents can path immediately. Requires Safe Edit or Full Control.

Set navigation/avoidance layer bitmasks on a navigation region, agent, link, or obstacle. Each accepts a bitmask int or an array of layer numbers (1-32). Requires Safe Edit or Full Control.

Add a NavigationLink2D/3D (auto-detected) connecting two positions, for jumps, ladders, and teleports across the navmesh. Requires Safe Edit or Full Control.

Add a NavigationObstacle2D/3D (auto-detected) with a radius that agents route around. Requires Safe Edit or Full Control.

Add a GPUParticlesCollisionBox3D/Sphere3D so 3D particles collide with it. Requires Safe Edit or Full Control.

Add a GPUParticles node (2D/3D auto-detected) with a process material. Requires Safe Edit or Full Control.

Set particle process properties: amount, lifetime, gravity, velocity (single or min/max range), scale, color, direction, spread, emission shape (point/sphere/sphere_surface/box/ring with radius or extents), one_shot, explosiveness, preprocess. Requires Safe Edit or Full Control.

Give particles a color-over-lifetime ramp from [r,g,b,a] stops, serialized into the process material. Requires Safe Edit or Full Control.

Inspect a GPUParticles node's full configuration: emission state, one_shot, explosiveness, and the process material's direction, spread, velocity range, gravity, color, scale range, emission shape, and color ramp.

Add a ready-made VFX particle node (muzzle_flash, explosion, sparks, smoke, fire, rain, snow) with a tuned ParticleProcessMaterial, instead of configuring one by hand. Requires Safe Edit or Full Control.

Configure the game window in one call: resolution, fullscreen, stretch mode/aspect, and title (the window title is the project name, application/config/name). Requires Safe Edit or Full Control.

Set the scene the game starts with (application/run/main_scene), validating the scene exists. The last step that makes a project runnable. Requires Safe Edit or Full Control.

Read a project setting value.

Set a project setting value and save. Requires Safe Edit or Full Control. Settings under editor_plugins/ load editor code, so they require Full Control (Safe Edit asks first); use enable_plugin for that.

Register an autoload singleton: a scene, or a script that extends Node (other scripts are refused). Requires Safe Edit or Full Control.

Remove an autoload singleton. Destructive: Full Control runs it, Safe Edit asks first.

Compile every GDScript in the project and report the ones that fail, each with the first error's line and message. Great for finding what's broken. The running Godot MCP Studio plugin's own scripts are never recompiled; skipped_live_plugin and skipped_hint report them. Folders the editor never indexes (a nested project.godot or a .gdignore) are listed in skipped_folders instead of compiled. By default (wait_for_scan) it first registers class_name scripts written outside the editor and blocks while the editor is scanning, up to scan_timeout_s (15 seconds), so you never need a retry loop; script_classes reports what it refreshed.

List the editor configuration warnings (the yellow triangles) on nodes in the open scene.

Every error and warning the editor process has raised since the addon started (script errors, import problems), whether or not a tool result already showed it. Pass clear to reset the buffer. Tool results carry a new_errors list automatically, so call this only to see the full history.

Read the editor's captured errors and warnings with kind filtering, sequence filtering and script backtraces; the same buffer as get_editor_errors, plus the running game's errors when include_game is set. Reports whether capture is supported (Godot 4.5+). Pass after_sequence to poll only newer entries, or clear to reset the buffer.

One-call project health check. Always runs the static checks: missing res:// and uid:// references, uids shared by two files, leftover .import and .uid files, import artifacts, assets never imported, dependency cycles, main scene, broken autoloads, add-on installed and enabled, add-on and server versions, a stale play-test autoload, input actions used in code but missing from the Input Map, Godot version support, physics tick rate, pixel-art stretch mode, export presets, git ignore rules for .godot/, and unused resources. With the editor connected it also compiles every script, reads the open scene's node warnings, and reports editor and game errors logged in the last 5 minutes. Returns healthy true/false, the problem count, and one entry per check with details. Errors and warnings are problems: run it after every few authoring steps and fix them before building more. Info entries are optional suggestions and never make the report unhealthy. project_path runs only the static checks on another project from list_projects, without touching the connected editor.

Create or replace an export preset in export_presets.cfg for a target platform. Preset-level keys in options (include_filter, exclude_filter, export_filter, export_files, custom_features, encryption filters, encrypt_pck, script_export_mode and the rest of the [preset.N] keys) go to the preset section; other keys, e.g. binary_format/embed_pck, go to [preset.N.options]. export_presets.cfg is a protected file: Full Control writes it, Safe Edit asks first.

List the project's export presets (name, platform, runnable, output path).

Start exporting/building the project with a preset to an output path in a background Godot process. Returns immediately with started, pid, output_path, and log_path; poll get_export_status with those values until running is false. Needs the matching export templates installed. Executes a build; Full Control runs it, Safe Edit asks first.

Check a background export started by export_project: whether the export process is still running, whether the output file exists with its size and modification time, the tail of the export log, and success once the process has stopped and output_path was given.

Create a complete main-menu scene with title, Play, and Quit buttons, wired to a script. Requires Safe Edit or Full Control.

Create a pause-menu scene that toggles with ui_cancel and provides Resume and Quit buttons. Pass main_menu to make Quit return to a menu scene instead of exiting. Requires Safe Edit or Full Control.

Create a settings-menu scene with master volume, fullscreen, and Back controls persisted through ConfigFile. Back hides the menu when it is embedded in another scene; pass main_menu so Back returns to that scene when the settings menu runs as its own scene. Requires Safe Edit or Full Control.

Create and register a ConfigFile-based save-system autoload with typed save/load/delete helpers. Requires Safe Edit or Full Control.

Launch 2-8 independent game instances for live multiplayer testing; instance 1 is the intended host, 2+ the clients. Returns one {index, pid} entry per instance and, like play_scene, first registers class_name scripts written outside the editor, then waits up to 8 seconds for their runtimes to connect, so game_* tools can target them by `instance` right away; stop_playing ends them. Anything in arguments or instance_arguments reaches the game as user arguments, readable with OS.get_cmdline_user_args(). Requires Full Control; Safe Edit asks first.

Launch Godot Movie Maker mode to record a scene to a movie file for trailers or bug reports. Requires Full Control; Safe Edit asks first.

Author a script-free day/night cycle as a serialized looping AnimationPlayer track that rotates a DirectionalLight3D. Visible and editable in Godot before Play. Requires Safe Edit or Full Control.

Author a script-free minimap rig from serialized SubViewport, orthographic Camera3D, and RemoteTransform3D nodes. Visible and editable in Godot before Play. Requires Safe Edit or Full Control.

Create a Translation resource from key/value messages and register it with the project. Requires Safe Edit or Full Control.

Set the locale used for editor preview and the next game run. Requires Safe Edit or Full Control.

List the Godot MCP Studio Pro templates this license can install: slug, name, summary, kind (addon or content), version, the supported Godot version range, file count, download size, license and tags. Reusable systems such as an inventory or dialogue system, fetched from the product API with your license. Read-only network request, works in every permission mode. Use preview_template next to see exactly what a template would write.

Dry run an install: fetch the signed manifest for a template slug, verify its Ed25519 signature against the pinned key, and return the exact write plan without touching disk. Reports every project-relative path that would be created, which of them already exist and would be overwritten, the total byte size, whether the template is addon shaped, and whether the project's Godot version is inside the template's supported range. Pass destination to preview a content template at a specific folder; addon templates always preview under addons/<slug>/. Also refuses a manifest that lists two paths differing only in case, because they would collide on Windows and on a default macOS filesystem and one file would be silently lost. For an addon template that is already installed, also returns the update plan it compares against the install receipt: which files update_template would add, which unmodified files it would replace, which files it would keep untouched because you edited them, which files at the destination are not the template's at all, and which unmodified files the new version drops and would remove. Content templates are installed once and are never updated in place, so they get no update plan. Read-only, works in every permission mode. Show this plan to the person before calling install_template or update_template.

Install a Pro template into the project after verifying it end to end. Fetches the signed manifest, verifies its Ed25519 signature against the pinned key, downloads the archive, checks every extracted file against its manifest sha256, refuses any entry the manifest does not list, any path escape, symlink or non-regular entry, and any archive over the size, file-count or compression-ratio caps. Files are staged inside the project and only then moved into place, so a failure never leaves a half written system. Nothing from the archive is ever executed during the install, though an addon template you later enable does run its code inside the editor, which the Safe Edit prompt says plainly. An addon template installs under addons/<slug>/ and destination must be omitted; a content template needs a project-relative destination inside the project that is not addons/, .godot/, .godot_mcp/, .git/ or .import/. Refuses an install outside the template's supported Godot version range. Existing files are never replaced unless overwrite=true, and the refusal names the files that blocked it; when the blocked destination already holds an installed addon template, the refusal points at update_template, which replaces only the files you never edited. A successful install records a receipt under .godot_mcp/templates/<slug>.json listing every path it wrote and the sha256 it wrote there. Write risk: runs in Safe Edit and Full Control. Replacing existing files is destructive, so overwrite=true over a real collision runs in Full Control and asks first in Safe Edit. Call preview_template first.

Update an already installed addon template to the version the catalog now publishes, replacing only the files you never touched. Compares every file against the install receipt written at install time: a file missing from disk is written, a file whose sha256 still matches the receipt is replaced, a file whose sha256 differs was edited by you and is left exactly as it is, a file at the destination the receipt does not list is not the template's and is left alone, and a file the new version drops is removed only when it is still unmodified. The reply names every file in each of those groups, and preview_template shows the same split before anything happens. Verifies the signed manifest, the archive and every sha256 exactly as install_template does, stages inside the project, and rolls the whole update back if any step fails or if a file changed on disk after the plan was made. Only addon templates, which live under addons/<slug>/, can be updated: a content template is installed once and becomes part of your project, so it is never updated in place. Needs an install receipt at .godot_mcp/templates/<slug>.json, which install_template writes. Write risk: runs in Safe Edit and Full Control. Replacing or removing files is destructive, so an update that touches any existing file runs in Full Control and asks first in Safe Edit, naming the counts.