Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault

No arguments

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

This server publishes no instructions, or was last inspected before Glama recorded them.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": true
}
logging
{}
prompts
{
  "listChanged": true
}
resources
{
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
rql-mutateA

RQL (Reflection Query Language, reference: https://ai-game.dev/docs/rql). Change the live Godot editor with an RQL query whose last stage is set or call. All-or-nothing: every target and value is checked before anything is written; a failure changes nothing. Several changes in one call: separate statements with ; — each ends with set or call and is its own all-or-nothing change and undo step; nothing runs unless every statement parses, and the first failure stops the rest (earlier changes stay). Undoable in the editor (Ctrl+Z). Scene edits mark the scene unsaved (save with editor | call SaveScene()); edited resource files (res://….tres) are saved to disk automatically. dry_run=true returns the receipt ($ref, member, old, new) without changing anything. The receipt leaves out assignments that found the value already set; they are counted ("N unchanged assignment(s) not listed"). Do exactly the change requested; a read-only member fails with readonly-member instead of being approximated. Destructive cleanup over what a query finds (Free, DeleteResource, DeleteFolder on matches, not on paths the user named) takes two turns: list what matches with rql-query, show the list to the user and end your turn; delete only after the user confirms in a later message. When you map a misspelt or approximate name to an existing node, resource or member, tell the user which one you used. set path = expr, ... assign members (paths may go through structs: set Position.Y = Position.Y + 1); values see each target: $ and $index (its position in the stream entering set / call) call Method(args) invoke a method the tools expose Examples: nodes | where name == "Player" | set Position = "(0, 1, 0)" move a node nodes | where class == "OmniLight3D" | set props["light_energy"] = props["light_energy"] * 2, props["light_color"] = "#ffcc88" Godot properties by their snake_case name nodes | where name starts-with "Enemy" | set Visible = false hide every enemy nodes | where name starts-with "Enemy" | sort name | set Position.X = $index * 2 spread the matches along X godot.resource("res://materials/red.tres") | set props["albedo_color"] = "(1, 0, 0, 1)" edit a resource file (saved to disk) root | call AddChild("Node3D", "Props") new child node of a class; the receipt's result column holds its $ref range(0, 100) | call editor.CreateNode("MeshInstance3D", {name: "Cube" + $, parent: "Props", position: [($ % 10) * 2, 0, floor($ / 10) * 2], mesh: {class: "BoxMesh"}}) bulk create: a 10 x 10 grid of cubes in one call and one undo step (one receipt row per node with its $ref; a long receipt lists the first 50 and counts the rest) [["CoinA", 0], ["CoinB", 3]] | call editor.InstantiateScene("res://scenes/enemy.tscn", {name: $[0], parent: "Props", position: [$[1], 1, 0]}) one scene instance per list entry nodes | where name starts-with "Cube" | set Scale = Scale * 1.5 vectors and colors compute component-wise nodes | where name starts-with "Cube" | set Position = [Position.X, 0, Position.Z] * 2 numeric lists compute like vectors ([x, 0, z] * k); vector functions: length, normalize, distance, dot, lerp nodes | where name starts-with "Cube" | sort name | set Position = [10 * cos(2 * pi() * $index / $count), 0, 10 * sin(2 * pi() * $index / $count)] evenly on a circle of radius 10 ($count = the matches; sin cos atan2 pi deg rad) nodes | where name == "Props" | call InstantiateScene("res://scenes/enemy.tscn") instance a scene as a child nodes | where name == "Crate" | call Duplicate() copy next to it (returns the copy) nodes | where name == "Floor" | set Mesh = {$type: "PlaneMesh", Size: "(20, 20)"} a new embedded resource (mesh, shape, material, environment …) of a concrete class, with its members; a script class_name works too nodes | where name == "Crate" | call Reparent(godot.find("Props")) reparent (keeps the global transform) nodes | where name == "Crate" | call MoveChild(0) reorder among its siblings (-1 = last) nodes | where name == "Old" | call Free() remove a node (undoable, like Delete in the Scene dock) editor | set selection = [godot.find("Player")] change the editor selection editor | call SaveScene() write the edited scene to its .tscn editor | call CreateResource("res://materials/blue.tres", "StandardMaterial3D") new resource file (a Godot class or a script class_name) editor | call MoveResource("res://materials/blue.tres", "res://materials/old/blue.tres") move / rename a file (its .import / .uid sidecars move with it) editor | call DeleteResource("res://materials/old/blue.tres") delete a file and its sidecars editor | call NewScene("res://scenes/new.tscn", "Node2D", "Main") create, save and open a scene (path, root class, root name) editor | call OpenScene("res://scenes/level.tscn") open a scene file editor | call Reimport(["res://materials/red.tres"]) re-import files (no argument: full filesystem scan) editor | call ClearConsole() clear the captured editor log nodes | where name starts-with "Enemy" | call AddToGroup("enemies") add nodes to a group (saved with the scene; set groups = [...] replaces them) nodes | where name == "Enemy1" | call Connect("tree_exited", godot.find("Player"), "_on_enemy_died") connect a signal to a method of the target's script (saved with the scene) nodes | where name == "Enemy1" | get connections | where method == "on_enemy_died" | call Disconnect() remove a connection project | set settings["display/window/size/viewport_width"] = 1280 any project setting by its path (saved to project.godot) project | call AddInputAction("jump", ["Key:Space", "JoypadButton:A"]) new input action with its events inputActions | where name == "jump" | call AddEvent("Key:W") add an event to an input action (RemoveEvent, set events = [...], set deadzone) project | call AddAutoload("Game", "res://scenes/game.gd") register an autoload singleton godot.resource("res://tiles/terrain.tres") | call AddAtlasSource("res://tiles/terrain.png") add a texture to a TileSet (returns the source id) godot.resource("res://tiles/terrain.tres") | get sources | get atlas | call CreateTilesFromTexture() create tiles in the non-transparent grid cells godot.resource("res://ui/theme.tres") | set colors["Button/font_color"] = "#ffcc00", constants["HBoxContainer/separation"] = 8 edit Theme items layers | where kind == "3d_physics" and index == 2 | set name = "enemies" name a layer (saved to project.godot) nodes | where name == "Wall" | set layerNames["collision_mask"] = [1, "enemies"] a layer mask by layer names (numbers for unnamed layers) godot.resource("res://materials/water.tres") | set params["speed"] = 2, params["tint"] = "#3388ff" shader uniforms of a ShaderMaterial (null or call ClearParam(name) reverts one) godot.resource("res://meshes/tiles.tres") | call CreateItem("Floor", "res://meshes/floor.tres") add a MeshLibrary item (set its shapes, navigationMesh … on the returned row) nodes | where class == "OmniLight3D" | set name = name.replace("Lamp", "Light") bulk rename (replace, replace-regex, substring, pad …) files | where path == "res://tiles/terrain.png" | set importSettings["mipmaps/generate"] = true change an import option (re-imports the file; a .wav file loops with the import option edit/loop_mode = 2; on an AudioStreamWAV resource set LoopMode = "Forward", its loop_mode 2 is PingPong) Editor state: editor | set isPlaying = true / false runs / stops the main scene; editor | call PlayScene("res://…") runs one scene; what the game prints and its errors: rql-query gameLog. editor | call Undo() / Redo() steps the editor's undo history like Ctrl+Z (returns the action; rql-query editor | select undoHistory lists the scene's and the global history); editor | call ReloadScene() reloads the edited scene from its file; NewScene(path, "res://base.tscn") makes an inherited scene. Baking: a VoxelGI node bakes global illumination with call CallMethod("bake") (set its Size around the level first); LightmapGI has no scriptable bake in Godot (only the editor toolbar's Bake Lightmaps), so say so instead of reporting a bake. Bulk create: range(start, end) or a list literal streams items, and call editor.CreateNode(class, {…}) / editor.InstantiateScene(path, {…}) runs once per item ($ and $index are the item's); the options are name, parent (a node, its path or ref("Node3D#…"); the scene root by default) and Godot properties of the new node (position, rotation_degrees, scale, mesh, visible …; local, not global*). Every item is checked before the first node is made; all of them are one undo step. By name, the options stay one object: call editor.CreateNode({className: "Node3D", options: {name: "Pivot"}}). Object literals build values and resources (meshes, shapes, materials …, script and GDExtension Resource classes too), never nodes (AddChild / CreateNode create those; pass an existing node by godot.find("Name"), path or ref): set Position = {x: 1, y: 2, z: 3}; set Mesh = {$type: "BoxMesh", Size: [1, 2, 1]} builds a new resource of a concrete class. Map entries streamed by get write through their map: … | get colors | where Key starts-with "Button/" | set Value = "#ffffff". Up to 200 targets per statement; for an intended bulk change of more objects pass max_targets = the match count (at most 1000): still all-or-nothing and one undo step. Nodes inside a scene instance take property changes (saved as overrides; the instance gets Editable Children) but are removed, renamed or moved in their own scene.

Query part: the RQL of rql-query (full guide and the sources in its description); godot.resources("Texture2D"), godot.resource(path), godot.find("Name"), ref("Node3D#1234"). Stages: where, select, sort, first N, get , recurse children. Operators: == != < > and or not, contains, starts-with, $ is Node3D, cond ? a : b; conditions are booleans (where Mesh != null, has(Mesh)). Paths a.b.c, list[0], props["key"]. Vectors/colors as "(1, 2, 3)" or "#ff8800"; enums as strings.

rql-queryA

RQL (Reflection Query Language, reference: https://ai-game.dev/docs/rql). Run a read-only RQL query against the live Godot editor and return compact rows. One precise query beats many exploratory calls; independent reads go in one call separated by ; (a result block each). Changes need rql-mutate.

RQL: source | stage | stage ... Sources: nodes (every node of the edited scene, depth-first, root included), root (the edited scene root), selection, scenes (open scenes), files (every res:// file the editor knows; on request size (bytes), importedSize, deps, missingDeps, usedBy (scenes / resources that load it) and importSettings["option"]), folders (path fileCount folderCount empty), classes (Godot classes, ClassDB), console (captured editor log entries), gameLog (what the game run from the editor printed: Sequence LogType Message StackTrace), editor (editor state, undoHistory / redoHistory, and operations), project (project settings: settings["section/key"], name, mainScene; input map, autoload and global group calls), settings (every project setting: name section value type changed), inputActions (name events deadzone builtIn), autoloads (name path singleton order), groups (name nodes count global), layers (kind index name: the project's layer names), tools (every MCP tool of this editor, hidden ones included: name title visible description; a hidden tool is not offered to this client: to use one, ask the user to show it in the AI Game Developer dock). Resources: godot.resources("StandardMaterial3D") or godot.resources("Texture2D", "res://art"), godot.resource("res://materials/red.tres"). ref("Node3D#1234") resolves a $ref; godot.find("Player") or godot.find("Level/Player") a node by unique name or path below the scene root; godot.group("enemies") the nodes of a group; godot.callable("Player", "_on_hit") a Callable. Stages: where filter (a boolean condition: where Mesh != null, where has(Mesh), where children.count() > 0) select a b.c alias=(expr) project columns (wrap computed expressions in parentheses) sort [desc], ... stable sort first N | skip N | count get replace each item by a member (lists are flattened) recurse children [max-depth=N] [include-self=false] walk the scene tree (input items included by default) distinct [expr] | sum expr | min expr | max expr | avg expr group-by expr rows key|count; group-by a, b (or kind=class) gives one column per key, then count; group-by class | select key, count, avgY = items.avg(Position.Y) Expressions: == != < <= > >= and or not + - * / %; contains, starts-with, ends-with (case-insensitive); matches "regex"; x in [a, b]; x is null; x is not null; $ is Node3D (includes subclasses); has(member). Conditional: cond ? a : b, e.g. select name kind=($ is MeshInstance3D ? "mesh" : "other"). Text: replace(s, from, to) (case-insensitive), replace-regex(s, pattern, repl) ($1 = group 1), substring(s, start[, length]), split(s, sep), trim(s), pad(v, width[, fill]) — also as methods: name.replace("Old", "New"), name.substring(0, 4). Literals: numbers, "strings", true/false/null, lists [a, b], objects {x: 1, y: 2}; groups == ["enemies"] compares a list. Paths: a.b.c, list[0], map["key"]; .member on a list maps over its elements. List methods: .any(pred) .all(pred) .count([pred]) .sum(e) .min(e) .max(e) .first([pred]); inside them bare names refer to the element, falling back to the outer item. Meta: $ (current item), $ref (stable id such as Node3D#1234), $type, $path, $index, $depth. Enums compare to strings; == on strings is case-sensitive. Godot: every node has name, path (below the scene root, "." = root), class (the Godot class, e.g. "OmniLight3D"), parent, owner, children (list), childCount, index, script (res:// path), groups (list) and id; signals, connections (persistent: signal target method flags), incoming and overrides (how a scene instance differs from its scene file: node property value template) are read on request (select connections, get overrides). Members are the C# properties (Position, Rotation, Scale, Visible, Text …), matched case-insensitively, so position works too; Rotation is in radians, RotationDegrees in degrees. Every Godot property, including GDScript script variables (in the editor: @export ones, every one of a @tool script) and GDExtension properties, is in props["snake_name"] (e.g. props["light_energy"], props["speed"] on a scripted node); a Godot array lists the values it holds (get props["items"] | where props["price"] > 10). Vectors / colors print as (x, y, z); write "(1, 2, 3)", [1, 2, 3] or {x: 1, y: 2, z: 3}; colors also "#ff8800". Vector2/3/4, their integer variants (whole results only) and Color compute component-wise (set Scale = Scale * 1.5, Position + [0, 1, 0]); Quaternion, Basis and transforms do not. Lists of numbers compute too ([Position.X, 0, Position.Z] * 2), and length(v), normalize(v), distance(a, b), dot(a, b), lerp(a, b, t) take vectors or lists (distance(Position, godot.find("Player").Position) < 5). Units: meters in 3D, pixels in 2D. A resource path "res://…" works wherever a resource is expected, a node path or name wherever a node is expected. Freed nodes read as null. Input events are text: "Key:Space", "Key:Ctrl+S", "PhysicalKey:W", "Mouse:Left", "JoypadButton:A", "JoypadMotion:LeftX-". A TileSet has sources (id kind atlas texture tileCount), physicsLayers, terrainSets, customDataLayers; an atlas source has tiles (coords size data). A Theme has maps keyed "ControlType/item": colors, constants, fonts, fontSizes, icons, styleboxes. A ShaderMaterial has uniforms (name type default value overridden) and params["uniform"] (typed by the shader; null reverts to the default); a MeshLibrary has items (id name mesh meshTransform shapes navigationMesh preview). Layer masks by name: layerNames["collision_mask"] on any object with layer properties is a list of layer names (a number for an unnamed layer). Callables are "Player::_on_hit" (target::method); RIDs are read-only "RID(…)"; a Projection is 16 numbers. Navigate with paths or get; select only projects output columns. Results come back as compact rows (header line, then col|col). Long results are truncated — refine with where/first or use count. Unknown members produce warnings with suggestions (in rql-mutate a misspelt member that leaves no target is an error); rql-schema(type) lists a type's members and Godot properties.

Language rules:

  • Conditions are booleans. where, and / or / not, ?: and the predicates of .any() .all() .count() .first() take a comparison or has(), never a bare value: where material != null (or has(material)), where count > 0, where name != "", where len(tags) > 0. A number, string, object or list there fails with type-mismatch; null counts as false.

  • cond ? a : b (the same as if(cond, a, b)) picks a value and evaluates only the taken branch: set y = (y < 0 ? 0 : y). Inside select, wrap computed values in parentheses: select kind = (intensity > 2 ? "bright" : "dim").

  • Lists compare by value, in order: tags == ["a", "b"], x in [[1, 2], [3, 4]]; distinct and group-by merge equal lists.

  • group-by gives rows with key (or one column per key), count and the group's items: group-by kind | select key, count, avg = items.avg(weight); also items.sum(e), items.min(e), items.max(e), items.count(pred), items.first().name. Group by the item's type with $type (group-by $type); a bare type is a member that most items do not have.

  • Receipts list only real changes: a set row whose value stayed the same is left out and counted as unchanged, so no rows with N unchanged means the values already matched.

  • call Method(args) runs the method of each item (the items must be objects). call source.Method(args) runs the method of that one source object once per stream item, with $, $index, $path and $depth in the arguments being the item's; every call counts against the target limit, and every argument is checked before the first call (a dry run checks without calling).

  • Bulk create: range(start, end[, step]) streams numbers (end excluded), and a list literal streams its elements, so one call creates many objects: range(0, 150) | call editor.CreateNode("Node3D", {name: "Tile" + $, position: [($ % 15) * 2, 0, floor($ / 15) * 2]}) builds a 15-wide grid, [["Lamp", [0, 2, 0]], ["Sun", [6, 4, 0]]] | call editor.CreateNode("OmniLight3D", {name: $[0], position: $[1]}) one object per entry. The receipt has one row per call with the $ref of the created object.

  • Vectors and colors the host marks as component-wise compute component by component: set Scale = Scale * 1.5, Position + [0, 1, 0], Position - Offset, -Velocity, v / 2. Adding a number to a vector is a type-mismatch (add [x, y, z] instead); quaternions and other types without that mark stay type-mismatch. Lists of numbers are vectors too: [x, 0, z] * k, [1, 2] + [3, 4]. Vector functions work on both: length(v) (or v.length(), magnitude), normalize(v), distance(a, b), dot(a, b), lerp(a, b, t); len(x) stays the size of a string or list.

  • Trigonometry is in radians: sin, cos, tan, asin, acos, atan, atan2(y, x), pi(), deg(x), rad(x); trigonometric results are rounded (sin(pi()) is 0). In a set value or call argument $count is the number of items entering the stage ($index runs 0 to $count - 1), so set position = [5 * cos(2 * pi() * $index / $count), 0, 5 * sin(2 * pi() * $index / $count)] lays the items out on a circle of radius 5.

  • A missing map entry reads as null: props["k"] == null and props["k"] is null are true without the entry, and has(props["k"]) tests whether it exists. A misspelt member is not null: it stays unknown and is reported.

  • Arguments by name: call Method({name: value, ...}) with one object literal that no overload takes as a whole binds each key to the parameter of that name; parameters left out keep their defaults, and an unknown name fails listing the parameters: range(0, 10) | call editor.CreateNode({className: "Node3D", options: {name: "Tile" + $, position: [$ * 2, 0, 0]}}). Engine objects (scene objects, nodes, actors) are never built from an object literal: pass an existing one, e.g. ref("Type#id"). Value-like assets and owned subobjects that the host marks are built from a typed literal: set mesh = {$type: "TypeName", size: 2}.

  • Several statements in one call: separate them with ; and they run in order, each with its own result block headed [i/n] (at most 10 per call). A read runs every statement. In a change every statement must end with set or call and is its own all-or-nothing change that sees the earlier ones; nothing runs unless every statement parses and ends with set or call, and the first one that fails (a misspelt member included) stops the rest (the earlier changes stay).

Examples: nodes | where name contains "Enemy" | select $ref name class path nodes | where $ is Node3D and Position.Y > 0 | select name Position nodes | where class == "OmniLight3D" | select name props["light_energy"] props["light_color"] root | recurse children | where childCount == 0 | select path class godot.resources("StandardMaterial3D") | select path props["albedo_color"] files | where ext == "tscn" | select path scenes | select name path active classes | where parent == "Light3D" | select name console | where logType == "Error" | sort sequence desc | first 5 | select message editor | select isPlaying editedScene selection godot.group("enemies") | select name path nodes | where name == "Player" | get incoming | select source signal method settings | where section == "display" and changed | select name value inputActions | where builtIn == false | select name events autoloads | select name path singleton godot.resources("TileSet") | get sources | select id kind texture tileCount godot.resource("res://materials/water.tres") | get uniforms | select name type default value overridden nodes | where class == "StaticBody3D" | select name layerNames["collision_layer"] layerNames["collision_mask"] layers | where kind == "3d_physics" and name != "" | select index name godot.resources("MeshLibrary") | get items | select id name mesh nodes | group-by class, scripted=(script is not null) nodes | where $ is Node3D | group-by class | select key, count, avgY = items.avg(Position.Y) nodes | where $ is Node3D | sort distance(Position, [0, 0, 0]) | first 3 | select name dist = (distance(Position, [0, 0, 0])) nodes | where $ is Node3D | select name kind=($ is MeshInstance3D ? "mesh" : $ is Light3D ? "light" : "other") files | where type contains "Material" and usedBy.count() == 0 | select path files | where missingDeps.count() > 0 | select path missingDeps files | where not (path starts-with "res://addons/") | sort size desc | first 5 | select path size importedSize nodes | where SceneFilePath != "" and overrides.count() > 0 | select name overrides editor | select undoHistory redoHistory

rql-schemaA

RQL (Reflection Query Language, reference: https://ai-game.dev/docs/rql). Without a type: RQL sources, functions, the installed extensions (Particles, Tilemap …), and the node classes present in the edited scene (with counts), plus the Node members. With an extension name: its guide with examples. With a type name (e.g. "Node3D", "OmniLight3D", "StandardMaterial3D", "Vector3", "editor"): that type's members (name type; ro = read-only), methods, and its Godot properties (props["name"]). Use it before querying an unfamiliar class.

screenshot-cameraA

Capture a screenshot from a specific Camera3D (or Camera2D) in the edited scene and return it as a PNG image for direct LLM inspection. Identify the camera with 'nodeRef' (instanceId preferred, else a scene-tree path). The camera's own world is rendered into a temporary off-screen SubViewport at the requested 'width'x'height', so the editor's live selection/camera is left untouched. Output edges are capped to keep the response transportable. NOTE: rendering needs a real GPU — a Godot launched with '--headless' yields an empty image, surfaced here as a structured error rather than a blank PNG. The image otherwise exists only in this conversation: when the user wants the picture as a file, pass 'savePath' and the PNG is also written inside the project (the result states 'Saved to ').

Argument types — give these arguments as RQL values (as in rql-mutate): {key: value, …}, [a, b], "text", 1.5, true, ref("Node3D#12") from a query result, godot.find("Name"); leave out keys you do not need: NodeRef — a node: ref("Node3D#12") from a query, godot.find("Name"), an instance id, or its path below the scene root as text ("Level/Player")

screenshot-isolatedA

Render a target Node3D in ISOLATION (only the target is visible, in its own world) from a chosen camera angle, framed automatically to its bounding box, lit by a default directional light, and return the result as a PNG image for direct LLM inspection. Identify the target with 'nodeRef'. Choose the view with 'cameraView' (Front/Back/Left/Right/Top/Bottom). Pick a 'background' (SolidColor or Transparent) and, for SolidColor, a hex 'backgroundColor'. The target is rendered via a temporary off-screen copy, so the edited scene is never mutated. Output is a square 'resolution'x'resolution' PNG, capped to keep the response transportable. NOTE: rendering needs a real GPU — a Godot launched with '--headless' yields an empty image, surfaced here as a structured error rather than a blank PNG. The image otherwise exists only in this conversation: when the user wants the picture as a file, pass 'savePath' and the PNG is also written inside the project (the result states 'Saved to ').

Argument types — give these arguments as RQL values (as in rql-mutate): {key: value, …}, [a, b], "text", 1.5, true, ref("Node3D#12") from a query result, godot.find("Name"); leave out keys you do not need: NodeRef — a node: ref("Node3D#12") from a query, godot.find("Name"), an instance id, or its path below the scene root as text ("Level/Player")

screenshot-viewportA

Capture the Godot editor's main viewport (the 3D or 2D editing surface) and return it as a PNG image for direct LLM inspection. Set 'mode' to '3d' (default) for the 3D editor viewport or '2d' for the 2D editor viewport. The longest output edge is capped to keep the response transportable; oversized captures are scaled down (aspect preserved). NOTE: the viewport must have a live GPU render — a Godot launched with '--headless' has no rendering device and yields an empty image, which surfaces here as a structured error rather than a blank PNG. The image otherwise exists only in this conversation: when the user wants the picture as a file, pass 'savePath' and the PNG is also written inside the project (the result states 'Saved to ').

script-attach-to-nodeA

Attach a script (C# '.cs' or GDScript '.gd') to a Node in the currently edited Godot scene — the Godot analog of adding a MonoBehaviour to a GameObject. Identify the target with 'nodeRef' (instanceId preferred, else scene-tree path) and the script with 'scriptPath' (a res:// script file that must exist). Pass an empty/whitespace/null 'scriptPath' to DETACH (clear) the node's script. The script resource is loaded and set via Node.SetScript; the scene is marked unsaved (persist with rql-mutate 'editor | call SaveScene()'). Returns the script's structured ScriptInfo on attach, or an identity record with a 'detached' status on clear.

Argument types — give these arguments as RQL values (as in rql-mutate): {key: value, …}, [a, b], "text", 1.5, true, ref("Node3D#12") from a query result, godot.find("Name"); leave out keys you do not need: NodeRef — a node: ref("Node3D#12") from a query, godot.find("Name"), an instance id, or its path below the scene root as text ("Level/Player")

script-buildA

Build the project's C# (dotnet build, Debug configuration like the editor's builds) so C# scripts written with 'script-create' / 'script-update' load: new [GlobalClass] types, changed node scripts. The build runs in the background; when it succeeds Godot reloads the C# assembly and the plugin reconnects, and the result (the compiler warnings, or the compiler errors) is delivered after that reload through the request's requestId. Tool calls made while the reload is pending are refused with a retryable error: retry them a few seconds later.

script-createA

Create a NEW Godot script file (C# '.cs' or GDScript '.gd') under res:// with the provided source. Fails if a file already exists at the path — use 'script-update' to overwrite. GDScript content is syntax-validated before write (invalid '.gd' is rejected and nothing is written); C# is accepted as-is (no in-editor compiler) and the post-write build settle surfaces compile errors. Missing parent directories are created. For a '.cs' file the editor filesystem reimports and BOUNDED-settles before returning (then 'script-build' builds the project and loads the new type); a '.gd' file only needs a filesystem update. Returns a structured ScriptInfo.

script-deleteA

Delete a Godot script file (C# '.cs' or GDScript '.gd') from the res:// filesystem. Fails if no file exists at the path. The script's identity (path, language) is captured BEFORE deletion and returned for confirmation. The file is removed with DirAccess, along with its Godot '.uid' sidecar when present, then the editor filesystem is rescanned and (for a '.cs' file) BOUNDED-settles. WARNING: nodes/resources referencing the deleted script will break — verify with 'script-read' first. A loaded copy is detached from the path, so an open scene still using it embeds it on its next save. Returns a structured ScriptInfo.

script-executeA

Compiles and runs C# in the Godot editor: plain statements with the last expression as the result (own usings, local classes, await allowed), or a declared class 'className' with static method 'methodName'. Returns the result and the printed output (Console; GD.Print on Godot 4.5+). Guarded: an endless loop is stopped when its time budget ('timeout', default 30 s) runs out, and runaway recursion is stopped, with an error, and the process keeps running. Threads and tasks the code starts (new Thread, Task.Run, ThreadPool) are stopped at their next loop iteration or call once the run ends (a warning counts them); timers, async void code after its first await and work blocked in a wait are not, so join or await what you start.

Argument types — give these arguments as RQL values (as in rql-mutate): {key: value, …}, [a, b], "text", 1.5, true, ref("Node3D#12") from a query result, godot.find("Name"); leave out keys you do not need: SerializedMemberList — named values {count: 3, label: "x", target: ref("Node3D#12")}: each is passed as a parameter of the value's type (a node, string, int, float, bool)

script-readA

Read a Godot script file (C# '.cs' or GDScript '.gd') under res:// and return its content + metadata (res:// path, language, line count). Supports an optional 1-based 'lineFrom'/'lineTo' slice for partial reads (indices are clamped — out-of-range values read at-most the whole file). Pair with 'script-update'/'script-create' to write back. The file is read with Godot's FileAccess so it works on any res:// path (imported or not). Returns a structured ScriptInfo.

script-updateA

Overwrite an EXISTING Godot script file (C# '.cs' or GDScript '.gd') under res:// with the provided source. Fails if no file exists at the path — use 'script-create' to create one. GDScript content is syntax-validated before write (invalid '.gd' is rejected and the existing file is left untouched); C# is accepted as-is (no in-editor compiler) and the post-write build settle surfaces compile errors. For a '.cs' file the editor filesystem reimports and BOUNDED-settles before returning (then 'script-build' loads the changed type); a '.gd' file only needs a filesystem update so the editor re-parses it. Use 'script-read' to inspect the current content first. Returns a structured ScriptInfo.

script-validateA

Validate GDScript ('.gd') files and return STRUCTURED parse/compile diagnostics — the on-demand 'is the project error-free?' query. Closes the gap where the agent gets NO feedback on GDScript parse errors and assumes the game runs fine. Inputs:

  • 'scriptPath' (optional): a single res:// '.gd' path to validate. Omit to scan every '.gd' under res:// (capped at FullScanFileCap). Result (ScriptDiagnosticsResult): 'ok' (true when no errors), 'diagnostics' [{ path, line, message, severity }], counts, a 'truncated' flag (true when a full scan hit the file cap, so 'ok' is NOT a whole-project all-clear), and a 'fidelity' note:

  • Godot 4.5+: 'Precise' — exact line + message captured via the engine Logger hook.

  • Godot < 4.5: 'Coarse' — per-file pass/fail with the engine error code (no line/message text). GDScript warnings (unused variables, shadowed names, … as enabled in Project Settings → Debug → GDScript) come back with severity Warning on Godot 4.5+ for scripts without errors (res://addons/ skipped like the editor does); they do not make 'ok' false. C# ('.cs') files are NOT validated here (Godot has no in-editor C# compiler to reach cheaply); their compile errors surface through the project build. Pair with the RQL 'console' source (rql-query 'console | where logType == "Error"'), which on Godot 4.5+ also captures engine GDScript parse errors passively.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A4.3/5.0

Scored across 14 tools

Disambiguation4/5

The rql-query (read-only) vs rql-mutate (write) split is crisp, and script-* tools are clearly separated by lifecycle stage. The only mild overlaps are the three screenshot-* tools (camera vs viewport vs isolated) and the fact that script-attach-to-node duplicates something rql-mutate could do via set Script, but descriptions disambiguate both cases well.

Naming Consistency4/5

All names are lowercase kebab-case with a consistent domain prefix (rql-, screenshot-, script-) plus an action or target. Minor deviation: some suffixes are verbs (rql-mutate, script-create) while others are nouns/adjectives (rql-schema, screenshot-camera, screenshot-isolated), but the grouping is still highly predictable.

Tool Count5/5

14 tools is in the ideal range, and the surface is economically designed: the expressive RQL pair absorbs dozens of potential granular operations, so the remaining tools (screenshots, script lifecycle) each earn their place.

Completeness5/5

The domain of Godot editor automation is covered end to end: read/query (rql-query, rql-schema), write (rql-mutate covering scenes, resources, project settings, input actions, tilemaps), full script CRUD plus build/validate/execute, and visual verification via three screenshot tools. No obvious lifecycle gap or dead end remains.

Maintenance

ActivityActive
ResponsivenessUsually handled