> ## 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.

# Export your game for Summer Games

> Which build Summer Games takes for iPhone, Android, Mac, Windows and the web, how summer_export_game makes it, and where export templates come from.

The Summer Games store takes two kinds of build. Which one you need depends on where players run your game.

| Kind | Players run it | Platforms | Made by |
| - | - | - | - |
| **Store bundle** | inside the Summer Games apps | iPhone, Android, Mac, Windows | `summer_export_game` (default) |
| **Web build or download** | in the browser on summer.games, or as a file they download | web, Mac, Windows | `summer_export_game` with `format: "download"` |

![Three kinds of build. A store bundle zip runs in the Summer Games apps on iPhone, Android, and for multiplayer games Mac and Windows. A web build zip with index.html plays on summer.games in the browser. A download is a Mac or Windows app that players download.](https://mintcdn.com/summer-18f03259/lAIp8hql2BjHQCvb/images/guide-art/publishing/builds-light.svg?fit=max\&auto=format\&n=lAIp8hql2BjHQCvb\&q=85\&s=4f775c8eed9404dbb5a34c1caf8416fa)

## Which one do I need?

| Target | Build | Store platform | Rule |
| - | - | - | - |
| iPhone | store bundle | `ios` | any game |
| Android | store bundle | `android` | any game; needs Summer Engine 0.7.1 or later |
| Mac app | store bundle | `macos` | multiplayer games (with a server) only |
| Windows app | store bundle | `windows` | multiplayer games (with a server) only |
| Web (play in the browser) | web build | `web` | Forward+ or Mobile projects. A standard Godot Web export (Compatibility renderer) also plays: upload its `.zip` in Studio |
| Mac download | download | `macos-universal` | any game |
| Windows download | download | `windows-x64` | any game |

`store.upload_file` (the tool `summer_publish_build` in the npm MCP) uploads every kind. See [Upload and publish](https://docs.summerengine.com/publishing/upload-and-submit.md).

A game **without a server** can use the store bundle only for iPhone and Android. For Mac and Windows it uses a download.

One store bundle serves every platform it lists, so it carries every texture format those platforms need: ETC2/ASTC for iPhone, Android and Mac, S3TC/BPTC for Windows. In **Project Settings → Rendering → Textures**, turn on the formats your platforms need.

## Export with your agent

The local summer-engine MCP runs Summer Engine on your computer without a window. You do not need to open the editor.

**You need Summer Engine 0.7.0 or later.** Older engines cannot make summer.games exports. `summer doctor` warns when the installed engine is too old, and `summer_export_game` stops before it changes anything. Update with `summer install --yes`, or download the latest Summer Engine from [summerengine.com/download](https://summerengine.com/download).

```json title="Store bundle for iPhone and Android" theme={null}
{ "tool": "summer_export_game", "targets": ["ios", "android"] }
```

```json title="Web build" theme={null}
{ "tool": "summer_export_game", "targets": ["web"] }
```

```json title="Mac download" theme={null}
{ "tool": "summer_export_game", "targets": ["macos"], "format": "download" }
```

```json title="Windows download" theme={null}
{ "tool": "summer_export_game", "targets": ["windows"], "format": "download" }
```

| Input | Meaning |
| - | - |
| `project` | Folder with `project.godot`. Defaults to the open project, then the working folder. |
| `targets` | Bundle: any of `macos`, `windows`, `ios`, `android` (omit for every platform the project declares). Download: exactly one of `web`, `macos`, `windows`. |
| `format` | `bundle` (default) or `download`. `["web"]` means `download`. |
| `out` | Output path. Defaults to `<project>/.summer/exports/`. |
| `debug` | `true` for a debug build. |
| `timeoutSeconds` | Default 900. The first export imports every asset, so it is slow. |

It returns the file path, its SHA-256, its size, and for a bundle the manifest: main scene, platforms and whether it has a server. For a download it also returns the store platform to upload it as.

For a store bundle the MCP writes a named preset `summer.games <targets>` into `export_presets.cfg`. It only changes that preset's platform options.

When an export fails, the result names the engine's own `ERROR:` lines. Read them first: they say what to fix.

## Hosted games: the source graph

A game with a server splits its files into a client part and a server part. `deployment/source-domains.json` (the source graph) says which folders belong to which part. The `authority_engine` roots are server only: the client pack leaves them out.

If the export fails with an error like this, a file the client needs sits inside a server-only root:

```text theme={null}
compositionPath res://game/net/caper_composition.tres is in the source graph's authority_engine domain, which the client pack leaves out
```

Fix: narrow the `authority_engine` root to the server-only files, so the shared files (such as the network composition `.tres`) stay in the client pack.

```json title="deployment/source-domains.json" theme={null}
{
  "schema": "summer.source-domain-graph.v1",
  "roots": [
    { "domain": "shared", "paths": ["content", "game/domain"] },
    { "domain": "authority_engine", "paths": ["game/net/authority.tscn", "game/net/caper_authority.gd"] }
  ],
  "dependencies": []
}
```

A game laid out on Summer Engine 0.6 can hit this on 0.7 when its server root is the whole network folder. The `multiplayer-project` skill explains every file of a hosted game.

## Export in the editor

Open **Project → Export**, pick the **summer.games** preset and click **Export Project**. You get one `.zip`. See [Publish your game](https://docs.summerengine.com/build/publish.md).

## What is in each file

> [tab] Store bundle
>
> A `.zip` in the `summer.bundle.v1` format:
>
> | Entry | What it is |
> | - | - |
> | `summer-bundle.json` | The manifest: Summer version, engine, main scene, platforms, file hashes. |
> | `client.pck` | Your game for players. |
> | `server.pck` | Multiplayer games: the server. |
> | `config/` | Multiplayer games: Summer settings. |
>
> At most 16 entries and 40 GiB. The platforms in the manifest must match the platforms you upload it for. Summer runs `client.pck` on its own engine in the Summer Games apps, so you need no export template.

> [tab] Web build
>
> A `.zip` with `index.html` at its root. At most 500 MiB, 2,000 files and 200 MiB per file. With thread support off, summer.games plays it in a frame on the game page; a build with threads opens in its own tab.
>
> `summer_export_game` builds it on Summer's **WebGPU** web template (`web_summer_jspi_release.zip`), with threads off, for projects on the Forward+ or Mobile renderer; it refuses Compatibility projects. summer.games plays any web export, so a standard Godot Web export on the Compatibility renderer (WebGL 2) works too: zip the export folder and upload it under **Play in the browser** in Studio.

> [tab] Download
>
> * **Mac:** a `.app` in a `.zip`, named `<name>-macos-universal.zip`. Ad hoc signed by the MCP.
> * **Windows:** an `.exe` with the game pack inside, zipped as `<name>-windows-x64.zip`.
>
> At most 20 GiB. Players download it from your game page.

## Export templates

Only web builds and downloads need export templates. Store bundles do not.

**What you already have:** the Mac app of Summer Engine comes with the Mac template, the Windows app with the Windows templates. Both can come with the web template pair. Linux and cloud editors have none.

**Get the missing ones** from Summer's CDN with your agent:

```json title="List what you have and what is published" theme={null}
{ "tool": "summer_export_templates", "action": "list" }
```

```json title="Install the web template" theme={null}
{ "tool": "summer_export_templates", "action": "install", "platforms": ["web"] }
```

| Input | Meaning |
| - | - |
| `action` | `list` or `install`. |
| `platforms` | `web`, `macos`, `windows`, `linux`, `ios`, `android`. Default `["web"]`. |
| `includeDebug` | Also install debug templates. |
| `summerVersion` | Your Summer Engine version (Help → About, for example `0.7.1`). Read for you on Mac; needed on Windows and Linux. |

The MCP checks each file's SHA-256 before it installs it. Do not use the editor's own template download: it fetches stock templates, not Summer's.

**Where templates go.** The engine looks in its own folder first, then in your user folder:

| System | Folder |
| - | - |
| Mac | `Summer.app/Contents/Resources/export_templates/<version>/`, then `~/Library/Application Support/Godot/export_templates/<version>/` |
| Windows | `<Summer folder>\export_templates\<version>\`, then `%APPDATA%\Godot\export_templates\<version>\` |
| Linux | `~/.local/share/godot/export_templates/<version>/` |

`<version>` is the engine's full version, for example `4.7.2.stable` (or `4.7.2.stable.mono`) for Summer Engine 0.7.x.

The CDN address is `https://downloads.summer.games/engine-templates/<summerVersion>/manifest.json`.

Templates are on the CDN from Summer Engine 0.7.1. For 0.7.0, `summer_export_templates` answers `templates_not_published`: update Summer Engine, or use the templates that came with it.

## File names and versions

* Give every upload a new version: `vMAJOR.MINOR.PATCH`, for example `v1.0.0`, then `v1.0.1`.
* Download files are named `<name>-macos-universal.zip` and `<name>-windows-x64.zip`.
* The default output folder `<project>/.summer/exports/` is ignored by the editor and by git.

## Icons

* **Store icon:** the icon on your store page comes from your store art, never from the build. See [Store art](https://docs.summerengine.com/publishing/store-art.md).
* **Download icon:** Mac and Windows downloads use your project icon (**Project Settings → Application → Config → Icon**).

## Signing

You do not need to sign anything for the Summer Games store.

* **Summer Games apps** (iPhone, Android, Mac, Windows): Summer signs the apps that run your game. No App Store account, no keystore.
* **Mac download:** the MCP signs it ad hoc. It is not notarized.
* **Windows download:** no signing needed.

Selling your game in other stores needs their own signing. That is outside this guide.

## Ask your agent

**Export my game for Summer Games.** Your agent picks the right build for each platform and exports it.

Export my Summer game for Summer Games. Use the Summer Engine MCP and follow
[https://docs.summerengine.com/publishing/export.md](https://docs.summerengine.com/publishing/export.md).

* My platforms: \[PLATFORMS, for example "iPhone, Android and the web"].
  If I didn't say, read them from my project.
* Pick the right build for each: the store bundle for the Summer Games apps,
  a web build for the browser, a download for Mac or Windows if my game has
  no server.
* Install any export template that is missing with summer\_export\_templates.
* Export with summer\_export\_game and tell me each file, its platforms and
  its size. Don't upload anything yet.

## Next

[Upload and publish](https://docs.summerengine.com/publishing/upload-and-submit.md).

***

Does this not help you? [Reach out on Discord!](https://discord.gg/summerengine)


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