Summer Engine

The Summer Apps in the person's workspaces: id, name, purpose, folder, status (scratch, kept, archived), version, format. Cloud tool: runs on Summer's servers and works without the Summer Engine app open. Requires sign-in: npx -y summer-engine@latest login.

Read or use the fields and buttons a Summer App declared while it is open in the person's Studio tab or editor dock: no fill and no press reads the page; fill [{field, value}] and press an action id use it. Critical actions (delete, publish, pay, send) are pressed only by the person. app_not_open when the app is not open. Cloud tool: runs on Summer's servers and works without the Summer Engine app open. Requires sign-in: npx -y summer-engine@latest login.

Publish a new immutable version of a Summer App: dir (a local folder with index.html at its root) or files [{path, content, encoding}] for code apps, layout for layout apps, plus the manifest. Limits: 10 MB, 300 files, 5 MB per file. The person's Studio tab boots it. An error names the file or rule to fix: fix it and publish again. Cloud tool: runs on Summer's servers and works without the Summer Engine app open. Requires sign-in: npx -y summer-engine@latest login.

Tell Summer about an SDK capability a Summer App needed and did not have, so it can be built for everyone. Cloud tool: runs on Summer's servers and works without the Summer Engine app open. Requires sign-in: npx -y summer-engine@latest login.

See a Summer App without the person: Summer renders its current version (or version) headless with the person's data and returns the picture plus what to fix: console lines, uncaught errors, refused calls, whether the SDK connected and rendered, and the fields, buttons and agent tools it declared. Read-only: writes, sends and paid calls are refused, nothing changes. width 390 for a phone, theme dark, fullPage for the whole scroll, steps to click or press something first (a dialog, a second state); out also saves the PNG. It waits until the app's calls settle. Use it after every publish. Cloud…

The agent tools (name, description, input JSON Schema) and the data collections (record fields and types) a Summer App declares. Run a tool with summer_app_call; read or write the collections with summer_app_data. Cloud tool: runs on Summer's servers and works without the Summer Engine app open. Requires sign-in: npx -y summer-engine@latest login.

Rename a Summer App, change its purpose or folder, or set its status: kept (the team keeps it), archived (hidden from the app list; restore with scratch or kept), scratch. Archive the scratch apps you made that the person did not keep. Cloud tool: runs on Summer's servers and works without the Summer Engine app open. Requires sign-in: npx -y summer-engine@latest login.

Mount a piece on a surface: turn it so its given LOCAL backAxis faces into the surface (opposite the hit normal) with its upAxis kept toward worldUp, then seat its measured back face (the extreme of its visible bounds along backAxis, not its origin) at standoff from the surface. Pipes, gutters, lamps, AC units, signs, fire escapes. Place the piece near its mount first (summer_instantiate_scene with position); this tool turns it and pushes it onto the surface. Find the surface with surface (a node: the ray runs from the subject's origin to the nearest point of that node's bounds) or ray {origi…

Execute multiple operations (a multi-node build) in a single call. Each op is forwarded to the engine VERBATIM: this is also how you reach engine ops without a dedicated tool. UNDO: when nothing in the list forces a split (see SPLITS), the whole batch is ONE undo step (one Ctrl+Z). Single-only ops split the list into sequential requests, and EACH chunk is its own undo step (the receipt shows the chunks). Ops use the individual tools' format: - {"op": "AddNode", "parent": "/", "type": "MeshInstance3D", "name": "Floor"} - {"op": "SetProp", "path": "Floor", "key": "position", "value": "Vector3(…

Run any Summer operation by name (from summer_search) with its input. Engine operations run here; cloud ones run on Summer's server with the same approvals: money, publishing and live changes answer needs_approval with a link. 3.x tool names work too.

Save, list, or delete named camera viewpoints for the edited 3D scene. A bookmark is a fixed pose (position, look_at, fov) stored IN THE PROJECT at res://.summer/camera_bookmarks.json, so it survives sessions and machines — the scene file is never touched. WHY: screenshots taken from a preset framing re-fit the scene bounds every time, so a before/after pair shifts whenever anything moves; a bookmark is the same pose every time, which makes before/after comparison real. Save once, then reuse on every capture: summer_screenshot target:"scene" framing:"bookmark" bookmark_name:"<name>" (add mark…

Capture real gameplay frames without a running editor: starts the game in Summer Engine's offscreen verify instance (--summer-offscreen: a real renderer, a window parked offscreen with no focus, never on screen), lets it run waitSeconds, runs steps, and saves PNG frames of what the game draws, HUD included. Use for store screenshots (1920x1080 landscape or 1080x1920 portrait). The main scene is often a title menu: pass the game's own flags in args (after "--", e.g. ["--autostart"]), a gameplay scene, or steps that play like a player: [{press:"Play"}, {wait:3000}, {key:"Space"}, {action:"jump"}…

Check the status of an async generation job. summer_generate_3d and summer_generate_motion return a jobId; call this with it every 15-30 seconds until status is "completed" or "failed". A completed job carries the result: assetId (3D), rigAssetId (rig=true), animationAssetId or result.assets (motion), with file URLs. Import with summer_import_asset_by_id. Status values: waiting, active, completed, failed, delayed, unknown. Cloud tool — runs on Summer's servers and works WITHOUT the Summer Engine app open. Requires authentication: run 'npx -y summer-engine@latest login' first.

Clear the editor's Output panel. Useful before running the game to get a clean slate for error checking.

Move and turn one piece so its port meets another piece's port, facing it: pipe to pipe, duct to duct, gutter section to funnel or outlet. A port is an open-loop id from summer_inspect_asset on that node's scene ("+Y" = the outermost open loop facing +Y in the piece's own axes, "+Y#2" the next one facing +Y; resolved on the live node's meshes in its own frame, so the id is the same in every pose), a Marker3D (or any Node3D) name under the node whose -Z axis points out of the port, or an open-loop index in the same stable order. The subject turns by the shortest rotation that makes its port di…

Connect a signal between two nodes so the connection is SAVED in the scene. Signals are Godot's event system — they notify when something happens. Common signals: - "body_entered" / "body_exited" — Area3D/Area2D detects physics bodies - "pressed" — Button clicked - "timeout" — Timer finished - "area_entered" — Area detects another area - "input_event" — CollisionObject received input The receiver should have the method (a script method, or a built-in such as queue_free); a missing one is saved anyway and reported in warnings. scenePath must be a .tscn. PERSISTENCE IS VERIFIED: the engine's …

Make one finished, postable piece of content for a game and put it in the team's Review (Studio > Grow > Content), on this computer: it picks the reference from Summer's library that fits today (a format the game has not posted, what changed in the repo), studies its cuts and caption look, measures the footage, maps each reference shot to a clip window with motion, cuts to the reference's timings, draws the captions in its style, mixes at -14 LUFS, checks hook, motion per shot, safe zones, length and loudness, renders the reference side by side, uploads and saves the piece (failed checks: a dr…

Create a support-ready Markdown report for /summer debug. Use this when the user says "/summer debug", asks to send Summer a bug report, or needs a portable artifact from a failing Codex, cloud or agent session. The report includes Summer doctor checks, engine health, diagnostics, console output, debugger errors/warnings, and an agent handoff prompt. It omits auth tokens and project file contents, but the user should still review it before sending because local paths and stack traces may appear.

Create a new empty scene file. Writes a minimal .tscn through the identity-bound engine with a create-only guard: it fails if the path already exists, and it never touches the currently open scene. The new scene is on disk but NOT opened. Call summer_open_scene to start editing it, then summer_add_node to build it out. Recommended workflow: 1) Call summer_get_project_context 2) Call summer_create_scene with a new res:// path 3) Call summer_open_scene with that path

One pose rendered as a grid of debug views next to the beauty pass: beauty, lighting (light only: direction, pools, dead-dark areas), unshaded (albedo: texture quality, value grouping), normals (world-space, x red y green z blue: seams, flipped or faceted normals), overdraw (stacked transparent layers), wireframe (triangle density, floating or duplicated pieces). Use it on the weakest shot of a sheet to see WHY it reads badly. lighting/unshaded/overdraw/wireframe are the engine's Viewport debug draw modes; normals uses an unshaded override material on a private copy (normal maps and alpha cut…

Enable an editor plugin in the open project (res://addons/<name>/, for example one paired with a Summer App) and report the real result: enabled with the autoloads it registered, or why it failed (code SCRIPT_ERROR, NOT_TOOL, NOT_EDITOR_PLUGIN, CFG_MISSING, TIMEOUT, ...). Older Summer Engine builds only queue the enable; then the result says queued: true and enabled: null, and you check summer_get_debugger_errors before relying on the plugin.

Export the game in the exact file the Summer Games store takes, with the installed Summer Engine headless (no window). format "bundle" (default): the summer.games .zip the Summer apps run on iPhone, Android, macOS and Windows; targets picks the platforms (a game without a server: ios and android only); upload it with summer_publish_build. format "download" with one target: web (an HTML5 .zip on Summer's WebGPU Forward+ web template, played on summer.games), macos (.app zip, macos-universal) or windows (.exe zip, windows-x64); these need the export template from summer_export_templates and are …

List, download and install Summer Engine export templates from Summer's CDN into the folder the installed engine reads, checking each file's sha256. Needed only for summer_export_game format "download": web (Summer's WebGPU Forward+ template), macos, windows. Store bundles (format "bundle") need no template. action list shows what is installed and published; action install fetches the platforms asked (default web).

Fabricate a 3D mesh asset by running a Blender Python (bpy) script in the USER'S OWN installed Blender — headless, supervised by the engine — then import the exported .glb into the project and optionally instantiate it into the open scene. Blender is a dependency the user installs; Summer never bundles, downloads, or brands it. WHEN — the three asset classes neither generation nor the free library serve well: - modular kits with exact dimensions and snapping (walls, pipes, fences, rails: array + boolean + bevel, one shared material) — generation cannot hold size and style across 30 pieces; - …

Frame one or more nodes with a camera fitted to their WORLD bounds and render it with the scene's REAL WorldEnvironment, lights, fog and tonemap (unlike summer_screenshot nodePath, which only works with the flat preview environment). Pick the side with direction (front/back/left/right/top/iso) or an explicit from vector; fill sets how much of the frame they span. bookmark_name also saves the fitted pose so every later render (summer_shot_sheet, summer_debug_views, summer_screenshot framing:"bookmark") lines up with it. marks:true adds numbered labels mapped to node paths. An explicit from is…

Smart framing: find good camera poses for a shot type automatically, measured in-engine against the real geometry. It runs in the open editor; use it to look at the scene as a player would. shot: establishing (wide), eye_level (from a spawn node at player eye height), low_angle (hero, near the ground looking up: the camera moves closer and widens its FOV instead of sinking into the ground), detail (close-up), corridor (down a lane or corridor found inside the subject by a free-space scan, preferring the view in from its open end, walls on both sides). How: candidate poses on a ring/hemispher…

Control the clock of the RUNNING game and list instances. action:'pause' suspends it (GamePause — Engine time frozen, physics inactive; SceneTree.paused untouched), 'resume' lifts the suspension, 'step' advances EXACTLY frames (1..600) of kind 'physics' (default) or 'process' and leaves the game suspended (GameStep), 'speed' sets the user time scale (GameSpeed, 0.25 = quarter speed), 'instances' lists every live game instance (ListGameInstances: name, mode, pid, attached, breaked, scene, seed, fixed_fps, deterministic, summer_capture). Frame stepping is how you make exact assertions: pause ->…

Drive the RUNNING game's input like a player would. action:'script' schedules up to 1000 timed synthetic events (SimulateInputScript): [{at_frame: 0, type:'action', action:'move_right', hold_ms: 500}, {at_frame: 30, type:'action', action:'jump', hold_ms: 50}]; types action | key (keycode / physical_keycode) | mouse_click (position [x,y], button) | axis (action_negative/action_positive, signed strength) | raw ({class, props} — a recorded InputEvent). clock 'frame' (at_frame, exact) or 'ms' (at_ms — exact only when the instance runs with fixed_fps, else approximate; the result reports clock_mapp…

State AND pixels of ONE frame of the RUNNING game, atomically (GameProbe): the live scene tree (tree {path, depth, limit}), up to 64 property reads (props ['/root/Main/Player:position', '/root/Main/HUD/Health:value']) and a screenshot of the game viewport, all stamped with the SAME frame counters. This is the evidence tool of the playtest loop — the only read where "what the tree says" and "what the screen shows" cannot come from different moments. You SEE the screenshot as an image block; the text block carries the frame stamp ({frame: {process_frames, physics_frames, frames_drawn}, image_fr…

Generate a 3D model via Summer Engine Studio. Available models: - "hunyuan" (default) — Hunyuan 3D v3.1 Pro, high quality - "trellis" — Trellis 2, fast and detailed - "meshy" — Meshy, legacy option Model ids are an ALLOWLIST, not a passthrough. An unrecognised id is rejected with 400 listing the accepted ids. Available kinds: - "text-to-3d" (default) — From text description. Requires 'prompt'. Internally generates a 3D-optimized reference image first, then converts to 3D. - "image-to-3d" — From your own image. Requires 'imageUrl'. - "texture" — Generate textures for a model.…

Generate audio using AI providers via Summer Engine Studio. Capabilities: - "text_to_speech" — Convert text to spoken audio. Requires 'text'. Optional 'voiceId'. - "sound_effects" — Generate sound effects from description. Requires 'text'. Optional 'durationSeconds', 'modelId', 'loop'. - "music" — Generate background music. Requires 'prompt'. Optional 'durationSeconds'. - "text_to_dialogue" — Multi-voice dialogue. Requires 'inputs' array of {text, voiceId} objects. Sound-effect models (modelId; omit it to use the person's approved default, else ElevenLabs): - "eleven_text_to_sound_…

Generate an image using AI models via Summer Engine Studio. Known models: - "nano-banana-2" — High quality, supports txt2img and img2img (used when no model and no size is asked) - "gemini-flash" — Google Gemini 2.5 Flash, fast - "flux-2" — FLUX.2, good for specific styles Model ids are an ALLOWLIST, not a passthrough. An unrecognised id is rejected with 400 and the response lists every accepted id — it is not silently swapped. Two modes: - txt2img (default): just pass prompt - img2img (edit): pass prompt + referenceImageUrl to edit/transform an existing image Style presets: …

Generate animation clips for a rigged 3D model via Summer Engine Studio. Backends (pick one): - "meshy-library" (default) — a curated mocap clip by motionName on a Summer-rigged humanoid (rigAssetId from summer_generate_3d with options.rig=true). Fast (~30s), real mocap quality. Names that always work: idle, walk, run, jump, attack; anything else must be an exact library name. - "text-to-motion" — custom 2-second clips (60 frames) from text prompts on ANY of your own rigged models: humanoid, animal, creature, cartoon plant, prop (GLB/FBX 3d_model, one skinned armat…

Make one sound effect with several models (default three) and show the versions to the person on a Summer Studio page, where they listen and approve one or more. The approved model becomes their default for sound effects. Use it for the first sound effect in a chat after the person said yes to "three versions to pick from", or whenever they want to compare. The page opens in their open Summer Studio tab when there is one, else in the browser (open:false skips the browser and only returns reviewUrl). Then tell the person the returned "say" text and call summer_get_choices with the choiceSetId…

Generate a video using AI models via Summer Engine Studio. Known models (text-to-video): - "ltx" (default) — LTX Video, fast - "kling" — Kling 2 Master, high quality - "kling-turbo" — Kling 2.5 Turbo Pro - "minimax" — MiniMax - "veo3" — Google Veo 3, premium Known models (image-to-video, when imageUrl provided): - "ltx" (default), "kling", "minimax" If imageUrl is provided, switches to image-to-video mode. Pass provider-specific params in 'options' (negative_prompt, num_frames, etc.). Returns the generated video URL and asset metadata. Cloud tool — runs on Summer's servers and …

AI-first operating guide for Summer Engine MCP. Call this at the start of a fresh chat before touching scenes. It returns the observe-first loop, content routing (reuse -> import -> generate -> script), physical invariants, cost rules, the verification ladder, honesty rules, anti-patterns, and recovery steps.

Fetch one asset by exact Summer asset ID. Use this after a generation job returns assetId/rigAssetId/animationAssetId, or after summer_list_my_assets/search results when you need the stable file URL, download URL, viewer URL, metadata, license, visibility, parent chain, or provider details. Cloud tool — works WITHOUT the Summer Engine app open.

Get a downloadable URL for a specific asset file. Today this usually returns the Cloudinary URL plus Summer's download proxy. The response shape is future-proofed for signed URLs, so prefer this tool over handing users raw fileUrl when they explicitly ask to download. Cloud tool — works WITHOUT the Summer Engine app open.

Read the person's approved planning board for this game: the look (palette, description, picture), the characters, the place, the first-minute storyboard and the cards they picked, with a version that changes when the board does. The look and the picked cards come back as images you can see. Read the board at the start of each build step and compare your screenshot against its images (palette, shapes and proportions, camera angle, composition); fix the biggest difference. Use the picked card pictures as referenceImageUrl for summer_generate_image to make sprites and backgrounds in the same lo…

Description is built at runtime.

Read recent messages from the editor's Output panel (print() output, editor-side warnings and errors). SCOPE: the editor console ONLY. Runtime errors from a played game are collected by the debugger, not the console — right after summer_play this tool can honestly report errors 0 while summer_get_debugger_errors holds several. Never treat this tool alone as the post-play verdict: read summer_get_diagnostics (console + debugger + script errors together) first, then come here for message bodies. Every result carries a "_scope" note restating this. Output is post-processed for token economy: co…

Read runtime errors from the debugger. These occur while the game is running (null references, missing nodes, physics errors). Different from console output — these come from the debugger, not print statements. For warning text, use summer_get_debugger_warnings (separate tool — engine returns warning count here but not the bodies). Output is deduped: identical errors firing every frame collapse into one entry with a "(×N)" count suffix. A "_filter" summary tells you exactly what was collapsed or truncated. Use raw=true to bypass shaping when you really need every entry.

Read runtime warnings from the debugger panel. Warnings are non-fatal issues the game flags during play: missing optional resources, dead signal connections, deprecated API use, large allocations, physics warnings, etc. Returns structured entries with file/line/function/error_descr/callstack — same shape as summer_get_debugger_errors but filtered to severity = "warning". Engine-internal warnings without a source file are filtered out as noise. Use this when summer_get_diagnostics shows a non-zero `debugger.warnings` count and you want to see what they actually say.

Quick overview of all errors and warnings from the editor console, the runtime debugger, and script errors together. Returns error counts and a guidance message. ALWAYS call this FIRST before diving into summer_get_console or summer_get_debugger_errors. It tells you where to look. It is also THE post-play read: a played game's runtime errors land in the debugger section here (and in summer_get_debugger_errors), never in the editor console — summer_get_console alone can honestly report errors 0 right after a play session that produced several. By default the response is a prioritized view: er…

Get essential project context before editing. The default payload is COMPACT (a few KB): - project name and project path, current scene path, main scene path - sceneSummary: the open scene's root node and node count (not its tree) - health: the engine's scalar status fields plus capability COUNTS - projectMemory: the .summer summary — GameSoul/build-plan/memory files and `pin` (.summer/project.json: which template at which commit started this project, toolkit version, created_at) - warnings: capabilitySkewWarning (only when the engine build and this CLI have drifted apart — non-fatal; ex…

Scene tree of the RUNNING GAME — live runtime state, not the edited scene. Use it during playtests to see what actually spawned: dynamically created enemies/projectiles/UI, autoloads, pooled nodes — everything summer_get_scene_tree (an EDITOR read) can never show. Inspecting live keeps the bug alive; stopping the game to look usually resets it. Returns {tree: {name, class, path, children}, total_nodes, truncated}. Depth/limit are capped and truncation is declared — never assume a capped tree is complete. Drill into one node's live properties with summer_inspect_runtime_node. Needs a running …

Get a scene tree. Pass scenePath to read that exact in-memory/open scene; omit it only when you intentionally want the currently visible editor scene. Scene mutations load their explicit target, so a follow-up targeted read does not require OpenScene. The engine defaults to depth 2 and limit 200 nodes and SILENTLY truncates deeper hierarchies (the response then carries truncated: true and a visited count lower than the real node count). Pass an explicit depth (e.g. 10) to read a full tree — a 102-node scene returns only 61 nodes at the defaults.

Check a GDScript file for parse/compile errors without running the game. Use after writing or editing a .gd file to verify it compiles. Returns line numbers, error messages, and severity. Much faster than running the game to discover script errors.

Discover the same Guided workflow recipes shown in Summer Engine Studio. Call without workflowId to list every workflow and its support level. Call with an id to get the exact starter prompt, ordered steps, required MCP tools, and honest limitations. A "manual" support level means Studio still has a visual handoff that MCP cannot perform automatically; do not pretend that stage ran.

Take a store game live for players: release its uploaded bundle Build (publicationId, or the newest upload) to every platform that passed Summer's automated checks, and publish its store page, through the same store routes Studio uses; then watch until players get it. It runs without an owner approval while the person's Agent permissions allow Publish (the default). First call with confirm=false: it reads the page, the Build and its per-platform checks and what players get now, and returns live, blocked (each failure with its fix), needs_changes (Summer's decision and feedback) or confirmation…

Description is built at runtime.

Search the asset library and import the best match into the project in one step. Use when the user wants a specific type of asset added: "Add a tree to the scene", "Import a wooden barrel". Searches, picks the top result, downloads and imports it, then optionally adds it to the scene. Requires authentication. If the user gets an auth error, they need to run 'npx -y summer-engine@latest login' in their terminal first. Summer Engine must be running.

Import an exact Summer asset ID into the current project. Use this when the asset was just generated, selected from my assets, or returned by search. Unlike summer_import_asset, this does not search or guess: it fetches the asset by ID, downloads it through Summer Engine, and runs Godot's import pipeline. For 3D models, pass parent and scenePath to instantiate it in that exact scene; it does not need to be the active editor tab. Requires the Summer Engine app to be open with the project loaded (generation itself does not — only this import step does).

Download a file from a URL and import it into the project. Triggers Godot's full import pipeline — generates .import files, extracts textures from .glb models, creates materials. Use this for: - 3D models (.glb, .gltf, .obj) - Textures (.png, .jpg, .webp) - Audio (.ogg, .wav, .mp3) - Video (.mp4, .mov, .webm, .ogv): Summer Engine plays only Ogg Theora, so any other video is converted to .ogv first and lands at the path with .ogv; the answer names it. The path is auto-inferred from the URL filename if not specified. After import, the asset is immediately usable in scenes.

Download multiple files from URLs in one operation. Performs a single filesystem scan after all downloads, which is faster than importing one at a time. A video (.mp4, .mov, .webm) is converted to Ogg Theora first and lands at its path with .ogv.

Search Poly Haven's CC0 HDRI library and import one as environment lighting. The single cheapest visual-quality upgrade for a 3D scene: a real HDRI sky lights and reflects the whole world. Searches ~1,000 CC0 HDRIs on Poly Haven's public API (no account, no key), downloads the .hdr/.exr through the engine's import pipeline into res://sky/, and returns a ready-to-run summer_run_script snippet that wires it into the WorldEnvironment (PanoramaSkyMaterial + sky ambient/reflections). Pass query ("sunset beach", "night city", "studio") to search, or assetId for an exact Poly Haven id. resolution 2…

Set up input controls. Creates the action if it doesn't exist, then binds events to it. Event format: - Keyboard: { type: "key", key: "W" } or { type: "key", key: "Space" } - Mouse button: { type: "mouse_button", button: 1 } (1=left, 2=right, 3=middle) - Common keys: "W", "A", "S", "D", "Space", "Shift", "E", "Escape", "Up", "Down", "Left", "Right" Example: Bind jump to Space and W: name: "jump", events: [{ type: "key", key: "Space" }, { type: "key", key: "W" }]

Measure a 3D asset file (.tscn/.scn/.glb/.gltf, or a Mesh resource) WITHOUT adding it to any scene: it is loaded and instanced off-scene in the editor, measured, and freed. Call it once per kit piece before placing it, instead of guessing size, origin or facing. Returns (all in the asset root's own frame, the frame position/rotation apply in), the facing evidence first: - summary {aabb, origin {fraction, label e.g. "x:center y:min z:min"}, plane_pairs, port_like_loops [loop ids], triangles, mesh_count, anchor_count, collision_count, warnings?}. plane_pairs: the 2 largest pairs of opposite pla…

Get all editable properties of a node with their current values, types, and resource info. Call this before modifying a node to understand its current state. Returns every property the Godot inspector would show. Each prop carries the engine's raw Variant.Type integer as "type" plus its name as "type_name" (e.g. type 5 = TYPE_VECTOR2, 20 = TYPE_COLOR, 24 = TYPE_OBJECT); resource-valued props also carry resource_type / resource_path. Reads the currently OPEN scene — "path" is relative to its root (there is no scenePath argument; open the scene first if needed). Example: inspect a light to se…

Read a resource: a material, mesh, shape, texture, environment, or a scene/model file. Two forms, pass exactly one: - path: a resource FILE ('res://materials/ground.tres', a mesh 'res://kit/meshes/wall_01.res', 'res://models/player.glb'), loaded read-only in the editor. A Mesh returns its AABB, surface_count and per surface the primitive, vertex and index counts, attributes, triangles and material (class, path or embedded, albedo for standard materials), plus the unique materials and blend shapes. A scene or model (.tscn/.glb/.gltf) returns its node count, the first 40 nodes with type, instan…

Live properties of ONE node in the RUNNING GAME: {node: {path, class, properties, children_names}} with a curated common-property set (transform, visibility, physics state, ...). The runtime counterpart of summer_inspect_node (which reads the EDITED scene) — use it to answer "what are this enemy's actual stats right now", "where IS the player", "did that flag flip" without stopping the game and losing the state. Find the path with summer_get_runtime_tree first — runtime paths (e.g. '/root/Main/Enemies/Goblin3') often differ from edited-scene paths because nodes are spawned, renamed, or repare…

Add an existing scene or 3D model as a child node. Use this to: - Add a .tscn prefab (reusable scene) as a child - Add a .glb/.gltf 3D model into the scene - Compose scenes from smaller scenes (e.g., add a "Player" scene into a "Level" scene) The scene must already exist in the project. Use summer_import_from_url first if importing from external sources. PASS target_size FOR IMPORTED MODELS. Downloaded/generated .glb assets arrive at arbitrary scale (a "chair" can be 40 units tall). target_size uniformly scales the instanced subtree so its largest world-AABB dimension equals that many units …

Check if the game is currently running. Returns the active scene path if running.

Report how library entries (skills, examples, templates, collections, references, tools) worked out, so Summer can fix and re-rank them — reports fix the entries this user's own future sessions load. Call once at a natural checkpoint with all entries used; fire-and-forget (1s cap, silent failure, never blocks). Only report outcome 'worked' after in-engine verification (playtest or screenshot passed). What is sent: the library entry ids you used (entry_id), one outcome word per entry, your optional note and deviation (280 characters max each, about the entry itself), engine_version, agent_model…

List or search the signed-in user's generated and uploaded assets. Use this after generation jobs complete, when the user says "the model I made", "my last character", or when you need to retrieve an asset before importing it into the local project. Returns exact asset IDs plus file/import URLs. Use summer_get_asset for full metadata or summer_import_asset_by_id to import a specific result. Cloud tool — works WITHOUT the Summer Engine app open.

Measure placement between specific nodes from their visible-mesh bounds (evidence visual_aabb). Read-only, never saves. Complements summer_starcast (which reports clearance around ONE node in 26 directions). mode pair (a, b): per axis {gap (> 0 clearance, < 0 overlap depth), relation gap|touching|overlap, a/b intervals, delta_min/max/center (b minus a)} and boxes_overlap. Catches facade gaps and modules that overlap. mode plane (nodes, face): whether that face of every node lies on one plane: {coplanar, plane (median), spread, nodes [{path, face, deviation, off_plane: proud|recessed}]}. Catch…

Inspect whether two explicit world-space points are connected by the targeted 3D scene's built-in Godot navigation map without changing or saving the scene. Returns navigation readiness and its reason, map iteration and region counts, requested and layer-filtered snapped endpoints, snap distances, conservative reachability, full route length, and at most 16 deterministic route points. A path is reachable only when it terminates at both snapped endpoints within the reported tolerance. ready:false means navigation evidence is unavailable, not that the route is unreachable. In particular, map i…

Open the exact summerengine.com page or Summer Engine editor surface the user wants to LOOK at, by intent name — or, with open:false, return the URL / engine op without opening anything. The result ALWAYS carries the resolved url or op, also after opening, so you can tell the user where they landed. WHEN: the user wants to see, check, or decide something: "open my billing page", "show me my published games", "take me to pricing", "open the MCP setup guide for Cursor", "show me the scene", "select the Player node", "open player.gd". NOT for getting a result (add a node, set a property, publish…

Open the project's configured main scene from project settings. Safer than guessing scene names like main.tscn/Main.tscn. Call this when you get "no scene open".

Open a scene file in the editor. Use this to switch between scenes. Do not guess paths. Prefer: 1) summer_get_project_context (read mainScene) 2) summer_open_main_scene (open known main scene) 3) summer_open_scene only when user gave an explicit path.

Move one node so its bounds face sits against another node's bounds face along one axis: facade modules edge to edge, a storey stacked on the one below, a cornice on a wall. Optionally line up the other two axes (min, center or max), per axis. Example: next module to the right, same base height, same front plane: {axis:"x", side:"max", gap:0, alignOtherAxes:{y:"min", z:"max"}}. Bounds are the visible GeometryInstance3D AABBs (the definition summer_align_distribute_3d uses; evidence visual_aabb). space "local" uses the reference's own axes for rotated facades. When the subject is inside the r…

Start the game. With no parameters it runs QUIETLY inside Summer Engine's viewport (the 'main' instance); scene runs one level or UI screen instead of the main scene. Playing the game in the editor's real window is allowed and expected: then summer_screenshot target:'game' to see it, summer_stop when done. One editor at a time. QUIET BY DEFAULT (focus:false, PlayGame agent:true): the user usually works on the same machine, so the EDITOR stays put. It does not switch to the Game tab or take keyboard focus (nor follow the game's later focus report), and skips the render-health self-check that …

Set a project setting in project.godot. Common settings: - "application/config/name" — project name - "application/run/main_scene" — main scene path - "rendering/renderer/rendering_method" — "forward_plus", "mobile", or "gl_compatibility" - "display/window/size/viewport_width" — window width - "display/window/size/viewport_height" — window height - "physics/3d/default_gravity" — gravity value (float)

Create a Summer project on this computer from a template, with no shell: the built-in 3d-basic (sky, sun, ground and a hero; no download) unless template names another. Writes it into dir, or into <name> next to the session's project, in the session's folder, or in ~/Documents/Summer; never inside another project. A folder that already holds project.godot is left as it is. Returns projectPath. Next: summer_projects_open_local with that path.

Open a project on this computer in Summer Engine, in the background, and wait until it connects (an editor that has it open is used as it is; an editor with another project open switches to it in the same window); this session's engine tools then work on it. When Summer Engine is not installed it answers engine_not_running: ask the person, and only with their yes call again with install: true (about 660 MB, free). A first open can take a few minutes: the answer says to call again. It adds summer-preview to the session folder's .claude/launch.json (Claude Code Desktop's Browser pane), and previ…

Upload an export from summer_export_game to the creator's game on summer.games, through the same store upload Studio uses, straight from disk. A store bundle (format bundle): declare, upload parts, seal, wait until Summer makes the Build, name its client pack and wait for Summer's automated checks on each platform (checks: passed, or failed with the code and the fix). A web build or native download (format download): upload it as the game's store version for its platform (web, macos-universal, windows-x64, linux-x64; read from the last export) and wait until Summer has checked it. First call w…

Cast one ray from any point in an open scene, before anything is placed there: find the wall, floor or ceiling in front of a point and its normal. (summer_starcast casts from an existing node's bounds; this casts from an arbitrary origin.) evidence auto (default): physics first (collider hit: exact point and normal); if physics hits nothing, the nearest visible-mesh AABB hit, declared with fallback:true and fallback_reason. Physics needs the scene to be the active editor tab (only that scene's bodies are in the editor's physics space); otherwise auto falls back to visual AABBs. When physics h…

Read a text file from the engine-bound project and return its full-file sha256 receipt. Use the returned sha256 as expected_sha256 when overwriting an existing file. Paths must begin with res://. READ BIG FILES IN PARTS instead of all at once: - offset + limit page the file: lines by default (unit:'bytes' for a byte range on UTF-8 boundaries). The result's data.window gives start_line/end_line, total_lines, next_offset (null at the end) and eof. - For JSON: json_path picks one value ('pieces.wall_a', 'items[3]'); keys keeps matching object keys (['wall_*']); keys_only lists key names only. d…

Load one library entry by id (<kind>/<slug>, as returned by summer_search_library). Skills: the SKILL.md body plus metadata (status, use_when, related) and how to invoke the skill in your host (bare slug). Tools: how to call it (MCP name, `summer tool <slug> --args`, engine requirement, authority) plus the descriptor. Templates: the pinned repo @ commit and tree digest (or built-in) and the `summer create <slug>` command. References: the markdown body. Hosted skills (publish-your-game, store-listing, store-art, grow-analytics; also by their summer://skills/<slug> URI): the current text from th…

Read the newest engine events in ONE zero-wait poll — what just happened (saves, plays, op receipts, script errors, imports, selection) and, above all, the CURSOR: its next_seq is the `since` to hand summer_wait_for_event BEFORE you trigger the action you will wait on. since omitted = the newest `limit` sequence numbers (a kinds filter applies inside that window, so fewer may come back). since:0 = the whole retained ring from the oldest, paged — pass next_seq back as since while truncated is true. since:N = everything after N. Each event is {seq, kind, ts, data}; kinds (v1): op.applied, op.f…

Remove a node from the scene tree. All children are removed too. Cannot remove the root node. Supports undo. Destructive operation: do not delete multiple top-level nodes unless the user explicitly requests destructive changes.

Instance copies of one scene along a straight line in one call: wall clamps every 0.45 m, braces every 0.8 m, fence posts, a row of window modules. Give start plus end (with spacing or count) or start plus direction (with count and spacing); positions are in the parent's local space. align (start|center|end) places the leftover length when spacing does not divide the line. Each copy is an InstantiateScene (the engine runs each alone), named <namePrefix>_<n>; the copies' transforms (position, rotationDegrees, scale) are then set in one request and the scene is saved once: N copies cost N + 2 en…

Replace a node with a different scene/model or node type, keeping its parent, sibling index, name, transform and property overrides, and the children the scene added under it. Use it to swap a kit piece for another (a wall host for a door host), a placeholder for a prefab, or a StaticBody3D for a RigidBody3D. Give exactly one of scene or type. The scenePath must be a .tscn. PERSISTENCE IS VERIFIED: the tool saves, reads the saved .tscn back and checks that the node at path now instances the new scene (or has the new type), under the same parent, with every child present. persisted:true is pr…

Safely replace text in an existing project file through the identity-bound engine. The MCP server reads the complete file, requires a unique match by default, computes the new content, and submits a sha256-guarded WriteFile. Set replace_all:true only when every exact occurrence should change.

Run a GDScript EditorScript in a FRESH HEADLESS editor spawned against the ON-DISK project. Cold path: a whole child editor boots, runs your script once, and exits — seconds to tens of seconds depending on the project and the script (about 2 s end to end on a small template project; large projects can spend 30 s+ just booting). USE FOR batch/project-wide jobs that should not block the live editor: re-saving many scenes, sweeping resources, mass import fixes, generating .tres assets, long bakes. It sees ONLY what is saved on disk — unsaved live edits in the open editor are INVISIBLE to it, and…

Run a GDScript snippet INSIDE the live editor, against the scene named by scenePath (opened first when it is not the edited one; the person's tab comes back after the run). Without scenePath it runs against the currently OPEN scene. This is the scene-scripting workhorse: one script replaces long chains of add-node/set-prop calls, and it can compute (loops, randomness, math, procedural meshes) what individual CRUD ops cannot. SCRIPT CONTRACT — write ONLY the body below; do not add extends/@tool lines (missing ones are prepended and reported in 'normalizations'): func run(ctx): var roo…

Drive and read animation in the RUNNING game. target:'player' = an AnimationPlayer (cmd state|play|pause|stop|seek|speed — RuntimeAnimation); target:'tree' = an AnimationTree state machine (cmd state|travel|start|stop|set_param|get_param — RuntimeAnimationTree); target:'bones' = a Skeleton3D's live bone poses (GetRuntimeBones, read-only). Default cmd is 'state' (read-only), so the same tool answers "which clip is playing", "which state is the machine in" and "where is the hand bone" before and after an action. player returns state {current_animation, assigned_animation, position, length, spee…

Call ONE method on a node in the RUNNING game and get its return value: 'take_damage' [25], 'get_velocity', 'has_method', 'start_wave' [3]. The direct way to trigger gameplay code and read its answer without wiring input or waiting for a timer. Returns {path, method, return, return_type, return_truncated, frame}; return is a Godot literal string for math values. Arguments are JSON scalars/arrays/objects or Godot literal strings ('Vector3(0, 1, 0)'); Object/RID arguments are refused (bad_args). failure_reason call_error carries call_error_detail (the method raised); method_not_found means chec…

Set ONE property on a node in the RUNNING game — the live object, never the scene file (nothing is saved; the change dies with the run). Use it to put the game into the state you want to test without playing there by hand: teleport the player ('/root/Main/Player' position 'Vector3(0, 2, 0)'), set health to 1, flip a flag, toggle visibility. Returns {path, property, value_before, value_after, applied, transport, frame}. READ applied: false means the read-back did not match (failure_reason not_applied) — a script rewrites the value every frame, or the literal type was wrong. Math values in and …

Spawn a PackedScene into the RUNNING game (action:'spawn' — SpawnRuntimeScene) or free a live node (action:'free' — FreeRuntimeNode). Stage a test in seconds: drop three goblins under '/root/Main/Enemies' with props {position: 'Vector3(4, 0, -2)', health: 10}, or remove the boss to test the empty-arena path. Nothing touches the scene file. spawn returns {node: {path, class}, renamed_to?, prop_warnings[], frame} — use node.path (absolute) for follow-up set/call/probe; unknown props land in prop_warnings, they never fail the spawn. free returns {path, queued, freed}: mode 'queue_free' (default)…

Save an explicit scene to disk. Mutation tools already append one save; use this for a standalone save or save-as.

Audit a 3D scene in one fast, read-only call: it walks every node and subnode and lists likely visual and placement problems, sorted by severity. Each issue is a flag to LOOK at, never an auto-fix. Checks (pick with checks; the verifying-scenes skill explains each): - through_hole: ray grids through each facade line that pass the wall AND reach the building's far side (an insert narrower than its frame, a missing module). Props do not close an opening. - exposed_edge: edges of walls, bands, piers and corner blocks nothing covers within 4-7 mm, seen from walkable space, with a 2-60 cm reveal, …

Capture a frame from Summer Engine and return it as an image you can look at directly. Use this to visually verify your work (it reads the real open editor or game window; that is allowed and expected): scene layout, asset placement, scale, framing, missing/untextured assets, or runtime gameplay state. You see the actual pixels — no description layer in between. Lighting and materials are only truthfully shown by the "viewport" and "game" targets — see the note on "scene" below. target: "viewport" (default) — the editor's CURRENT view (whatever scene/tab is open). No game boot. Use for edi…

Find any Summer operation by describing the job in plain words: engine, assets, store, pricing, analytics and the rest. Returns the best matches with their exact input schema, effect and approval. Next: summer_call with the name.

Search for game assets in the Summer Engine ecosystem. **Free for all users** with rate limits. Sources: - "library" (default) — Public asset library (25k+ community assets). Free. - "my_assets" — Your own generated/uploaded assets. Free. Query is optional. - "all" — Search both library and your assets. Uses hybrid search: keywords + semantic similarity. Finds assets by name AND by meaning. Returns asset names, types, each asset's art style, preview URLs, and import-ready file URLs. Keep a game in ONE art direction: pass style (the game's chosen family) so clashing styles are left out,…

Search the Summer library — skills, tools, templates, references, examples, collections — by describing the task in plain words ('make stylized water', 'the player falls through the floor', 'which tool reads script errors'). This is the FIRST MOVE for any task: even a 1% chance the library covers it means you search, then read the entry you pick with summer_read_library before acting — never act on a summary alone. Ranking: BM25 over ids, summaries, use_when lines and facets with kind-aware priors and related-entry boosts (the same ranker the routing eval gates). When this install ships regist…

Select a node in the editor's scene tree and show it in the inspector panel. Useful for focusing the editor on a specific node.

Set a property on a node. This is the primary way to configure nodes after adding them. VALUE FORMAT — Godot string syntax for complex types: - Vector3: "Vector3(0, 10, 0)" — position, scale, rotation_degrees - Vector2: "Vector2(100, 200)" — 2D position, size - Color: "Color(1, 0.5, 0, 1)" — RGBA, always 4 components, values 0.0-1.0 - Transform3D: "Transform3D(1,0,0, 0,1,0, 0,0,1, 0,5,0)" — basis + origin - Resource class name: "BoxMesh", "SphereMesh", "StandardMaterial3D" — auto-instantiated - Numbers: 1.5, 42 — native JSON - Booleans: true, false — native JSON - Strings: "hello" — native JS…

Set a nested property on a resource attached to a node. Use when you need to modify a sub-property of a resource, like: - CollisionShape3D shape size: nodePath="./Player/CollisionShape3D", resourceProperty="shape", subProperty="size", value="Vector3(1, 2, 1)" - Material albedo color: nodePath="./Floor", resourceProperty="material_override", subProperty="albedo_color", value="Color(0.2, 0.5, 0.2, 1)" - Mesh size: nodePath="./Box", resourceProperty="mesh", subProperty="size", value="Vector3(2, 2, 2)"

Render several bookmarks and/or explicit poses into ONE labelled grid image in a single call: same tile size, same view, real lighting. Use it after every change to see all hero views at once instead of N screenshots. compare_previous:true turns each bookmark into a row of [previous | now | difference map] and reports the share of pixels that changed and where. Each bookmark keeps exactly one previous render (its compare baseline) at res://.summer/shots/<bookmark>.jpg (JPEG, <= 1024 px; the folder is capped at 20 MB, oldest first). Only compare_previous:true or update_previous:true replaces i…

Detect and crop every distinct game asset from an existing image asset sheet. Use the assetId returned by summer_generate_image (or another Summer image asset). The same guided workflow used in Studio removes the sheet background when needed, detects named/category-aware bounding boxes, crops each item, and uploads the slices. Returns source dimensions plus the generated slice URLs, names, categories, bounding boxes, and widget metadata when the sheet contains UI controls. Cloud tool — runs on Summer's servers and works WITHOUT the Summer Engine app open. Requires authentication: run 'npx -…

Description is built at runtime.

Diff two world snapshots into exactly what changed: added/removed node paths, changed nodes with the fields that moved (pos, scale, material fingerprint, ...), and per-class count deltas. Reads like a receipt — no wading through two full dumps. Standard use: take summer_world_snapshot BEFORE a mutation batch, mutate, then call this with from_id (to_id omitted = the engine takes a fresh snapshot now). Verify the diff matches your INTENT: exactly the nodes you meant to add were added, nothing you didn't touch changed, nothing vanished. An empty diff after a "successful" mutation is a red flag —…

Read a 3D spatial rundown for one exact node in an exact scene without moving it or saving the scene: 26 directional clearance casts (6 axes, 12 edges, 8 corners) from the subject's bounds, contact-or-overlap evidence, grounded state, and, in full detail, bounded nearby-object lists. Use it before and after placing an object to learn which side is blocked, by what, and at what distance. detail 'summary' (default) is a placement report of at most 5 KB: subject position and size, grounded and contactStatus, deduplicated contact paths, one compact record per direction (status open|blocked, neare…

Start here for any substantial AI game-building task. Takes the user's goal and returns the recommended Summer workflow: skill routes, MCP tool groups, host-file boundaries, asset policy, user confirmation gates, and verification steps. This is the router before deep skills and before mutating the project.

Stop the running game. Use after runtime verification or when you intentionally need to restart the running instance; ordinary editor scene mutations do not require a blanket stop. Pass instance to stop ONE offscreen instance started with summer_play {instance, mode:'offscreen'} (the result reports was_playing and killed); omit it for the editor's main game.

Fill the store page sections store.update_listing does not edit, on the store page draft: genres (1-5 genre tag ids from store.get_listing tags), features, credits, languageSupport, systemRequirements, contentSurvey (the age questionnaire: every answer, none included) and aiDisclosure (how AI was used; an empty uses list means no AI). Each section given replaces that section, null clears it, an omitted one keeps its value. A published page gets a new draft first. Saving never publishes: take it live with summer_go_live. Needs "summer login --store".

Description is built at runtime.

Bring the store game's items in line with summer.items.json in the project root, matched by each item's slug (the creator key the game's code uses, e.g. emote_ponder), so the same file gives the staging game and the production game the same items. First call with confirm=false: it checks the file, reads the game's items by slug and returns the plan (create, update with the changed fields, unchanged, blocked with the reason, and the game's items the file does not name, which are never changed) for the gateway this machine is set to; show it to the user. With confirm=true it uploads the changed …

Ghost-test one 3D node at an explicit candidate global pose without moving it or saving the scene. Use this before placing a prop in a shelf, cubby, doorway, platform, or dense set. The compact result reports known overlap evidence, grounded state, signed floor gap, and at most eight overlapping object paths. Physics evidence uses enabled collider shapes; because Godot exposes no query-completeness bit, its overlap count is labeled a lower bound and an otherwise-clear physics result reports fits:null rather than claiming proof. visual_aabb evidence is a broad-phase fallback that also catches …

List the editor's named actions, or invoke ONE by name exactly as its menu item / shortcut would — the primary way to drive the editor UI. (preview — needs an engine build with UiListActions/UiInvoke) SCENE WORK IS NOT UI WORK: to add, move, retune, or read nodes use summer_run_script, the scene tools, summer_world_snapshot and summer_screenshot — never by clicking through the editor. UI ops are for editor-workflow steps a human would do with the mouse: open Project Settings or the Import dock, switch the 2D/3D/Script main screen, clear a dialog that is blocking input, read what a dock curren…

Activate ONE editor control by its summer_ui_tree path through the control's own input path — a synthetic click for buttons, the public setter + signal for tabs, text fields and ranges — or dismiss a visible dialog (action:'dismiss_dialog'). Mutates editor state; the result's state is READ BACK from the control after the action, not echoed. (preview — needs an engine build with UiActivate/UiDismissDialog) SCENE WORK IS NOT UI WORK: to add, move, retune, or read nodes use summer_run_script, the scene tools, summer_world_snapshot and summer_screenshot — never by clicking through the editor. UI …

PNG of the editor window (or one dock / dialog / control's rect) returned as an image you can look at — the PIXELS-LAST fallback of the UI ladder: use it to see layout, an unfamiliar panel, or to sanity-check what the tree described, never to pick click coordinates (there is no coordinate click; summer_ui_activate takes paths). For the 3D/2D viewport, a scene render, or the running game use summer_screenshot instead — that is the visual-verification tool for scene work, and scene work itself goes through summer_run_script and the scene tools, never through the editor UI. (preview — needs an en…

Structured tree of the live editor UI — every visible Control with its class, path, rect, text/tooltip and state (checked, enabled, focused, tabs + current_tab, value/min/max, selected item) — or, with root:'dialogs', every visible dialog/popup and whether one is BLOCKING input. The structured alternative to a screenshot: the tree states outright what exists and what is clickable, at a fraction of the tokens, and its paths are what summer_ui_activate takes. (preview — needs an engine build with UiTree/UiDialogs) SCENE WORK IS NOT UI WORK: to add, move, retune, or read nodes use summer_run_scr…

Show the person what you are working on: the editor's view (home, chat, 3d, 2d, script, game, studio), its right rail (files, scene, inspector, output, none), what to focus (a res:// script or scene, or a node path) and the nodes to frame the camera on. Changes only what is on screen. The navigate-summer skill says which view fits which moment.

Block until the engine emits a matching EVENT, or a bounded timeout elapses — the replacement for sleeping and re-polling. Use it right after summer_play to wait for play.started (the game actually booting), after a long op (import, script, save) to wait for op.applied / op.failed by requestId instead of guessing a delay, and during a playtest to catch script.error the moment it fires. Event kinds (v1): op.applied, op.failed, script.error, play.started, play.stopped, scene.saved, scene.opened, import.completed, selection.changed, snapshot.published. Each event is {seq, kind, ts, data}; seq is…

Description is built at runtime.

Create or safely overwrite a complete text file through the identity-bound engine. For a new file, set create_only:true. For an existing file, first call summer_read_file and pass its sha256 as expected_sha256. Exactly one guard is required; unguarded writes fail closed. Supports scripts, .tscn scenes, .tres resources, JSON, docs, and project config.

High-resolution close look at part of a frame: region [x, y, w, h] (fractions of the frame) or mark N from a marks render of the same pose. The camera renders the EXACT sub-frustum of that region at full output resolution, so you see real texture detail, seams, gaps and floating pieces, not upscaled pixels. A region is honoured exactly (no pad by default, never widened to an aspect ratio: the image takes the region's own aspect, with dark bars only for extreme shapes); a mark gets pad 0.15. Use after a sheet or debug view shows something suspicious. view picks beauty or a debug view. Returns …