> ## Documentation Index
> Fetch the complete documentation index at: https://docs.summerengine.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Summer Apps in Summer Engine: project access, docks and plugins

> How a Summer App reads and changes your open Summer Engine project, which editor operations it may use, and how to dock it or pair it with an editor plugin.

> [!NOTE]
>
> **Coming with the next Summer Engine update.** Nothing on this page works yet: editor docks, apps that read or write your game files, the `summer.engine.*` calls, the `apps.dock` operation and paired plugins all need that release. Until then, keep an app's data in Summer with `summer.data` collections.

## How an app reaches your engine

* **Inside Summer Engine** (the Studio tab or a dock), engine calls go straight to your open project.
* **In a browser**, they reach your running Summer Engine through Summer when the desktop app is online and signed in. If no engine is connected, the call fails with `engine_offline`; show "Open in Summer Engine".
* If more than one Summer Engine is open, a call fails with `engine_target_ambiguous` until one is picked: `summer.engine.targets()` lists them and `summer.engine.useTarget(instanceId)` picks one. Studio also asks the person "Which Summer Engine?".
* If only a Summer Engine too old for apps is open, a call fails with `engine_update_required`.

An app needs `engine:read` or `engine:write` in its [manifest](https://docs.summerengine.com/apps/manifest.md). It may read and write only the files it declares in `engineFiles`, plus `res://addons/<plugin>/` when it declares a `plugin`. `summer.engine.onEvent` and `summer.engine.plugin.*` work only inside Summer Engine.

## What an app may do

Allowed operations (`summer.engine.ops`, 1 to 50 per call):

| Kind | Operations | Permission |
| - | - | - |
| Scene changes | `AddNode`, `SetProp`, `RemoveNode`, `MoveNode`, `ReparentNode`, `ReplaceNode`, `InstantiateScene`, `SetResourceProperty`, `ConnectSignal`, `OpenScene`, `SaveScene`, `Undo` | `engine:write` |
| Imports | `ImportFromUrl`, `ImportFromUrlBatch` | `engine:write` |
| Play | `PlayGame`, `StopGame` | `engine:write` |
| Read and look | `Grep`, `SearchInFiles`, `IsGameRunning`, `GameSnapshot`, `ViewportSnapshot`, `ScenePreview`, `GetWorldSnapshot`, `DiffWorldSnapshot`, `SelectNode`, `Navigate` | `engine:read` |

Values are Godot strings, not JSON objects: `"position": "Vector3(0, 10, 0)"`, `"light_color": "#fffef0"`. Scene changes edit `scenePath` (a `res://` `.tscn` or `.scn` file; default: the scene open in the editor).

More rules:

* `SaveScene` saves only `.tscn` and `.scn` files.
* Imports write asset files outside `res://addons/`, unless the path is declared.
* Scene changes may not carry script source.

Never allowed from an app: running scripts, editor scripts or shell commands; deleting, moving or renaming files; writing or reading files outside the declared paths; project settings; extracting zip files; editor-window screenshots. Summer enforces these rules, and the engine enforces them again.

## Docks

An app can dock as an editor panel (left, right or bottom). Docks stay in your editor layout per project. Ask your agent. It runs the `apps.dock` operation from the `summer-engine` npm package (its npm MCP tool is `summer_app_dock`):

```json theme={null}
{ "action": "open", "appId": "<app id>", "slot": "bottom" }
```

`slot` is `left`, `right` (default) or `bottom`. `apps.dock` also closes a dock (`"action": "close"`) and lists docks (`"action": "list"`). On engine builds without app docks it answers `engine_lacks_op`; open the app in the Studio tab instead. On the app page, **Dock in editor** does the same in the desktop app.

## Plugins

An agent can build an editor plugin (`res://addons/<name>/`) together with an app. Declare it as `"plugin": { "name": "<name>" }` in the manifest; the app may then also read and write the plugin's folder. The npm package's `engine.enable_plugin` operation (the `summer_enable_plugin` tool) turns the plugin on in the open project and reports the result.

The app and the plugin message each other through the engine, inside Summer Engine only:

* **In the app:** `summer.engine.plugin.send(message)` and `summer.engine.plugin.onMessage(fn)`.
* **In the plugin:** bind it to the app with `summer_app_id="<app id>"` in the `[plugin]` section of its `plugin.cfg`. While the plugin is enabled, the `SummerApps` editor singleton receives and sends:

```gdscript theme={null}
SummerApps.message_received.connect(func(app_id, message): print(app_id, message))
SummerApps.send("<app id>", {"kind": "rows-changed"})  # OK, ERR_UNAVAILABLE or ERR_UNAUTHORIZED
```

`send` delivers only to the app the plugin is bound to, at most 64 KB of JSON, from the main thread. `SummerApps` exists only in the editor; exported games do not have it.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.