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

# Release readiness checklist for Summer Games

> Ten checks to run before you publish a Summer game or a new version of it, so players can really play it: server scene, online join, saves, pack files and Summer version.

Summer checks every upload: the platforms, the packs and the files they name.
Those checks show that your export is well formed. They can't show that a
player who presses **Play online** gets into a game. This page covers what
the upload checks can't see.

Each check is here because a real release failed without it. We add a check
whenever that happens again.

## Before every release

### Games with a server

* [ ] **Your server starts its server scene.** See
  [check 1](#1-your-server-starts-its-server-scene).
* [ ] **Online join works with the version you release.** See
  [check 2](#2-join-online-with-the-version-you-release).

### Games with online play

* [ ] **Players can find online play** without changing a setting, or you
  decided on purpose that they can't. See
  [check 3](#3-players-can-find-online-play).
* [ ] **Online progress is saved by your server**, not only on the player's
  device. See [check 4](#4-your-server-saves-online-progress).
* [ ] **Players can get back to the title** from inside the game. See
  [check 5](#5-players-can-get-back-to-the-title).

### Every game that uses Summer

* [ ] **Your game doesn't hard-code its Game ID.** See
  [check 6](#6-your-game-doesnt-hard-code-its-game-id).
* [ ] **You exported with a released Summer editor, and your scripts compile
  on the Summer that players get.** See
  [check 7](#7-export-with-a-released-summer-editor).
* [ ] **Your build includes the files and fonts the game uses. The title and
  menus are readable on every platform you ship.** See
  [check 8](#8-every-file-your-game-reads-is-in-the-pack).
* [ ] **You exported with the Summer version the Summer Games apps run.** See
  [check 9](#9-export-with-the-summer-version-the-apps-run).
* [ ] **A signed-in player keeps playing for 3 minutes on each Summer Games
  app, and stays signed in.** See
  [check 10](#10-play-for-three-minutes-while-signed-in).

## The checks

Run the checks on the file you upload: your summer.games `.zip`. Export it
as usual, in the editor (**Project → Export**, the **summer.games** preset) or
with your agent. Use the path your export printed; `build/my-game.summer.zip`
below is an example. Then unpack it and name the Summer Engine executable,
once per terminal. Every check below uses both.

```sh macOS / Linux theme={null}
unzip -o build/my-game.summer.zip -d build/bundle
SUMMER="/Applications/Summer.app/Contents/MacOS/Summer"
# Linux: SUMMER is the engine binary in ~/.summer/engine/
```

```powershell Windows PowerShell theme={null}
Expand-Archive build\my-game.summer.zip -DestinationPath build\bundle -Force
$summer = "$env:LOCALAPPDATA\SummerEngine\current\Summer.exe"
function Run-Summer([int]$seconds, [string]$log, [string[]]$engineArgs) {
  $quoted = ($engineArgs + @('--log-file', $log) | ForEach-Object { '"' + $_ + '"' }) -join ' '
  $p = Start-Process $summer -ArgumentList $quoted -PassThru -NoNewWindow
  if (-not $p.WaitForExit($seconds * 1000)) { $p | Stop-Process }
}
```

On Windows, Summer Engine writes its output only to a log file. `Run-Summer`
starts it with `--log-file`, stops it after the given seconds, and each check
then searches that file.

A server pack you export on its own with your server preset is not the same
file. It can pass a check that the uploaded `.zip` fails.

### 1. Your server starts its server scene

Summer starts your game's server with no scene named. The server pack's own
main scene decides what runs. Your server preset carries the custom feature
`summer_authority`, and `project.godot` sets that feature's main scene to
your server scene:

```ini title="project.godot" theme={null}
[application]

run/main_scene="res://client/main.tscn"
run/main_scene.summer_client="res://client/main.tscn"
run/main_scene.summer_authority="res://authority/main.tscn"
```

```ini title="export_presets.cfg (your server preset)" theme={null}
name="Duel Authority"
platform="Linux"
dedicated_server=true
custom_features="summer_authority"
```

If the preset is missing `summer_authority`, the server starts your
**players'** main scene instead, usually the title screen. That scene never
tells Summer the server is ready, so every online join fails.

**Check it.** Start the server from your `.zip` the way Summer does, with no
scene named:

```sh macOS / Linux theme={null}
"$SUMMER" --headless --verbose --main-pack build/bundle/server.pck
# Stop it with Ctrl+C after a few seconds.
```

```powershell Windows PowerShell theme={null}
Run-Summer 15 build\server.log '--headless','--verbose','--main-pack','build\bundle\server.pck'
Select-String -Path build\server.log -Pattern "Completed load for: 'res://.*tscn'" | Select-Object -First 1
```

Find the first `Completed load for: 'res://…tscn'` line. It
must be your server scene, such as `res://authority/main.tscn`. If it shows
your title or client scene, add `summer_authority` to the server preset's
**Custom Features** and export again.

Local Play always starts your server scene by name, so a game can work
there and still fail this check.

### 2. Join online with the version you release

The check above runs on your computer. Players use a hosted server, so
also test there: right after a new version goes live, open your game in a
Summer Games app, join online and play until you're in the game. Do it
before you tell players about the update. If the join fails, see
[Players can't join online](#players-cant-join-online).

### 3. Players can find online play

A new player should reach online play without changing a setting. If online
play is off by default, for example behind a grown-ups setting, make that a
deliberate choice. Then join online yourself before every release, because
no player will find it broken for you.

### 4. Your server saves online progress

In online play, your server saves each player's progress with
[player progress](https://docs.summerengine.com/build/player-progress.md) and loads it when they join.
Progress kept only on the player's device is lost when they reinstall or
switch device, and players can edit it. To test, play online, earn
something, leave, then join from another device.

### 5. Players can get back to the title

Inside a game, players need a way back to the title screen, such as a pause
menu or a **Leave** button, online and offline. Without one, the only way out
is to close the app.

### 6. Your game doesn't hard-code its Game ID

Start Summer with no Game ID:

```gdscript theme={null}
var result: SummerResult = await Summer.initialize().get_result_or_completed_signal()
```

Summer then takes your game's identity from wherever the game runs: the
Summer Games app, your hosted server or Local Play. The exported `.zip` is
portable, so its `summer.build.json` has no `gameId`. If your code reads
`gameId` from that file and falls back to a made-up ID such as
`"game.my-game"`, the hosted server refuses it with
`game_identity_mismatch`. Your server then stops before it is ready, and
players' online joins fail. The Summer Games app refuses it the same way.

**Check it.** Search your project for `Summer.initialize`. Every call passes
no ID, or an ID your game received from Summer, never a fixed string or a
fallback. Then join online with the released version (check 2). Local Play
and a local run of `server.pck` don't run under a hosted identity, so they
can't catch this.

### 7. Export with a released Summer editor

Use the released Summer editor from the
[download page](https://summerengine.com/download), not a development build.
After you update Summer, export again before you upload.

Your export records which Summer made it, and players' apps run your game on
the released Summer of that version. A development build can call itself a
version that is already released while it has features that version lacks.
Your scripts then use something that isn't there on players' devices. They
fail to load, and the game opens to an empty window for every player. Summer
doesn't compile your scripts when you upload, so the upload still passes.

**Check it.** Read which Summer made your `.zip`:

```sh macOS / Linux theme={null}
cat build/bundle/summer-bundle.json
```

```powershell Windows PowerShell theme={null}
Get-Content build\bundle\summer-bundle.json
```

Under `"export"`, `summerVersion` must be a released Summer version, and
`engineSha` must match the `engineSha` that Summer publishes for that version
at `https://downloads.summer.games/engine-templates/<summerVersion>/manifest.json`
(Summer 0.7.1 and later). If it differs, a development build made the export.
If that address has nothing for your version, update Summer and export again.

Then run your game on that released Summer and look for scripts that fail to
load:

```sh macOS / Linux theme={null}
"$SUMMER" --headless --verbose --main-pack build/bundle/client.pck --quit-after 600 2>&1 | grep -E 'SCRIPT ERROR|Parse Error|Failed to load script'
```

```powershell Windows PowerShell theme={null}
Run-Summer 60 build\client.log '--headless','--verbose','--main-pack','build\bundle\client.pck','--quit-after','600'
Select-String -Path build\client.log -Pattern 'SCRIPT ERROR|Parse Error|Failed to load script'
```

Use the released Summer Engine of that version. The
command must print nothing. Don't rely on the run failing: it finishes
normally even when a script can't load. The run loads your main scene and
autoloads; a script that loads only later in play is checked when you play
to it.

### 8. Every file your game reads is in the pack

Summer packs your scenes, scripts and imported assets for you. A file that
your game opens itself at run time, with `FileAccess` or another call that
reads a `res://` path, is different. If Summer doesn't import the file, for
example a `.bin`, `.json` or `.txt`, it goes into the pack only when your
export preset's **Resources → Filters to export non-resource files/folders**
matches it. Each preset has its own filters, so set them on the
**summer.games** preset that makes your `.zip`. A file the filters leave out
is not an export error: your game just can't find it on players' devices.

Fonts are where this shows first. On iPhone your game can't use the
phone's own fonts, so a `SystemFont` draws every letter as a box there. On
your Mac or PC the same game looks fine, because `SystemFont` finds a font
on your computer.

**Check it.**

1. Search your scripts for files they read by path:

   ```sh macOS / Linux theme={null}
   grep -rn -E 'FileAccess\.|DirAccess\.|load_from_file|load_dynamic_font|ConfigFile' --include='*.gd' .
   ```

   ```powershell Windows PowerShell theme={null}
   Get-ChildItem -Recurse -Filter *.gd | Select-String -Pattern 'FileAccess\.|DirAccess\.|load_from_file|load_dynamic_font|ConfigFile'
   ```

   Note every `res://` file or folder those lines read. Skip `user://`
   paths; those are saves.
2. List what is in your pack. Save this script outside your project, for
   example as `list_pack.gd` in your home folder:

   ```gdscript title="list_pack.gd" theme={null}
   extends SceneTree
   # Prints one "PACK res://..." line per file in the pack.
   func _init() -> void:
       _walk("res://")
       for path in OS.get_cmdline_user_args():
           if not (ResourceLoader.load(path) is Font):
               push_error("Missing or invalid packed font: " + path)
               quit(1)
               return
           print("FONT ", path)
       quit()

   func _walk(dir: String) -> void:
       var d := DirAccess.open(dir)
       if d == null:
           return
       d.include_hidden = true
       for f in d.get_files():
           print("PACK ", dir.path_join(f))
       for s in d.get_directories():
           _walk(dir.path_join(s))
   ```

   Then run it on the `client.pck` from your `.zip`:

   ```sh macOS / Linux theme={null}
   "$SUMMER" --headless --main-pack build/bundle/client.pck --script ~/list_pack.gd
   ```

   ```powershell Windows PowerShell theme={null}
   Run-Summer 60 build\pack.log '--headless','--main-pack','build\bundle\client.pck','--script',"$HOME\list_pack.gd"
   Select-String -Path build\pack.log -Pattern '^(PACK|FONT) '
   ```

   Every file from step 1 must have its own `PACK res://…` line. If one is
   missing, add it to the summer.games preset's non-resource filter, for
   example `fonts/*.bin`, export again and check again.
3. Check the fonts used by your theme, individual labels, rich text and
   scripts. Include bold and italic faces and any fallback used for another
   language or symbol. Import custom fonts such as `.ttf` or `.otf` into
   the game and reference them from the UI. If your code picks a font by
   name at run time, include its resource in the client export preset. For
   an imported font, pass its original path to the listing script after
   `--`, for example `-- res://fonts/Title.ttf`. View the full output and
   look for a `FONT` line for each face. Summer may store the imported data
   under a different name in the pack.
4. Before release, open that build on each platform you ship, on a device or
   clean environment without your development fonts. Read the title, menu
   buttons and a sample from each writing system your game supports. Check
   the actual Summer Games app for iPhone releases. Save a screenshot or
   note the build, platform and text you read. If a letter appears as a box,
   fix the font and repeat the check on the new export.

### 9. Export with the Summer version the apps run

The Summer Games apps for iPhone and Android carry Summer inside them. An
app runs a game exported with the same Summer version line, the first two
numbers such as `0.7`, at the app's patch number or lower. A game exported
with `0.6.x` doesn't start in an app that carries `0.7`, and players see
**The game could not start**. The desktop app gets the right Summer for each
game, so your game can work on Mac and Windows and still fail on every
phone.

**Check it.** Read which Summer made your `.zip`, as in check 7:

```sh macOS / Linux theme={null}
cat build/bundle/summer-bundle.json
```

```powershell Windows PowerShell theme={null}
Get-Content build\bundle\summer-bundle.json
```

Under `"export"`, the first two numbers of `summerVersion` must match the
current Summer release on the
[download page](https://summerengine.com/download). When Summer moves to a
new version line, for example from 0.6 to 0.7, update Summer, export your
game again, upload it as a new version and take it live. Then open it on a
phone, as in [check 2](#2-join-online-with-the-version-you-release).

### 10. Play for three minutes while signed in

While your game runs, it uses Summer services for the signed-in player, such
as analytics, player progress and the store. A short test can end before the
first of those calls. Play long enough to reach them.

**Check it.** Sign in to a Summer Games app on a phone, open the version you
release and play it for at least 3 minutes. Do something that sends one of
your analytics events. The game must not close, and you must still be signed
in afterwards. Do this in each Summer Games app your game targets.

If the game closes or you are signed out, the fault is Summer's, not your
game's. See
[The game closes after about a minute](#the-game-closes-after-about-a-minute).

## Troubleshooting

### Players can't join online

Every online join waits and then fails with `world_start_timeout`, while the
game works in Local Play.

**Most likely causes:**

* **Your server pack starts the wrong scene.** Run
  [check 1](#1-your-server-starts-its-server-scene). If it loads your title or
  client scene, add `summer_authority` to your server preset's **Custom
  Features**, export a new version, upload it and take it live.
* **Your game passes a fixed Game ID.** Run
  [check 6](#6-your-game-doesnt-hard-code-its-game-id). Call
  `Summer.initialize()` with no ID, export a new version, upload it and
  take it live.

**An empty server log does not mean nothing ran.** A release server holds
back what your game prints when it isn't attached to a terminal. Its output
can look empty even while your title scene is running. Use check 1 on your
own computer to see which scene starts.

If checks 1 and 6 pass and joins still fail, ask on
[Discord](https://discord.gg/summerengine) with your game's name and the time
you tried.

### Game opens to a blank window

Your game opens to an empty or black window for every player, while it works
in your editor. Running your `.zip` as in
[check 7](#7-export-with-a-released-summer-editor) prints lines such as
`Parse Error: Static function "…" not found` and
`Failed to load script "res://…"`.

**Most likely cause:** a development build of Summer exported the game, and
your scripts use something the released version doesn't have. Re-export with
the current Summer release from the
[download page](https://summerengine.com/download), upload the new version
and take it live. Run check 7 on the new `.zip` before you upload it.

### Text shows as boxes in the exported game

A box with digits inside is a missing character. This can happen on any
platform when a font is missing from the export, a label uses a font
installed only on your computer, or the font lacks that character. Check
the face assigned to the affected label. Bundle that face and a fallback
that covers the affected text, then export again and read the same label
in the player build. [Check 8](#8-every-file-your-game-reads-is-in-the-pack)

### The game could not start

The Summer Games app on iPhone or Android says **The game could not start**,
while the game works on desktop. Your `.zip` most likely comes from a Summer
version line the app doesn't carry. Run
[check 9](#9-export-with-the-summer-version-the-apps-run): update Summer,
export again, upload the new version and take it live. If the versions match
and it still fails, ask on [Discord](https://discord.gg/summerengine) with
your game's name and the time you tried.

### The game closes after about a minute

A Summer Games app closes your game after 20 to 60 seconds of play with
**Play paused** or **That link can't be opened**, and the player finds they
are signed out.

This happens when a Summer service refuses the player's sign-in while your
game plays. It is Summer's fault, and you don't need to change your game.
Report it on [Discord](https://discord.gg/summerengine) with your game's
name, the app and the time it happened.

## Ask your agent

**Check my game is ready to release.** Your agent runs every check on this page and tells you what fails.

Check that my Summer game is ready to release. Follow
[https://docs.summerengine.com/publishing/release-readiness.md](https://docs.summerengine.com/publishing/release-readiness.md).

* For a game with a server, export the summer.games .zip, take server.pck out
  of it and run it with --main-pack and no scene, as the page shows. Tell me
  which scene it loads first.
* Find every Summer.initialize call and tell me which Game ID it passes.
* Read the export stamp in summer-bundle.json, tell me which Summer version
  and engine made it, and whether that is a released Summer. Run client.pck
  on that released Summer and show me any script that fails to load.
* Find every file my scripts read by path, list client.pck and tell me which
  of those files are missing from it. Check my UI fonts and fallbacks in the
  exported client and show me the title and menu text on each target you test.
* Tell me whether the summerVersion in summer-bundle.json is on the same
  version line as the current Summer release.
* Remind me to play the release for 3 minutes in each Summer Games app while
  signed in (check 10); you can't do that one for me.
* Go through every other check on the page and tell me pass, fail or "I can't
  check this, you need to" for each one.
* Don't change anything until I've seen the list.

***

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.