---
name: export-pipeline
description: Use when exporting and distributing Godot games — export presets, platform settings, CI/CD with GitHub Actions
---

# Export Pipeline in Godot 4.3+

All examples target Godot 4.3+ with no deprecated APIs. GDScript is shown first, C# follows where applicable.

> **Related skills:** **godot-testing** for CI/CD test integration, **godot-optimization** for pre-export performance checks, **responsive-ui** for platform-specific resolution settings, **mobile-development** for Android/iOS export specifics, **web-export** for browser builds and hosting.

---

## 1. Export Presets

### Creating Presets in the Editor

Open **Project → Export**, click **Add…**, and select the target platform. Each preset maps to one entry in `export_presets.cfg`. You can create multiple presets for the same platform (e.g., a debug build and a release build for Windows).

Required one-time setup per platform:
- **Export Templates** must be downloaded via **Editor → Export Templates**.
- Platform-specific toolchains (Android SDK, Xcode, etc.) must be installed separately.

### export_presets.cfg

Godot writes `export_presets.cfg` to the project root. Commit this file: options marked secret (keystore and codesign paths and passwords, the encryption key) go to `.godot/export_credentials.cfg` instead, which must **never** be committed. In CI, supply them via env vars such as `GODOT_ANDROID_KEYSTORE_RELEASE_PASSWORD`.

Example preset structure (Windows release):

```ini
[preset.0]

name="Windows Desktop"
platform="Windows Desktop"
runnable=true
dedicated_server=false
custom_features=""
export_filter="all_resources"
include_filter=""
exclude_filter=""
export_path="build/windows/MyGame.exe"
encryption_include_filters=""
encryption_exclude_filters=""
encrypt_pck=false
encrypt_directory=false

[preset.0.options]

custom_template/debug=""
custom_template/release=""
debug/export_console_wrapper=1
binary_format/embed_pck=true
texture_format/s3tc_bptc=true
texture_format/etc2_astc=false
binary_format/architecture="x86_64"
codesign/enable=false
codesign/timestamp=true
codesign/timestamp_server_url=""
codesign/digest_algorithm=1
codesign/description=""
codesign/custom_options=PackedStringArray()
application/icon=""
application/console_wrapper_icon=""
application/icon_interpolation=4
application/file_version=""
application/product_version=""
application/company_name=""
application/product_name=""
application/file_description=""
application/copyright=""
application/trademarks=""
application/export_angle=0
application/export_d3d12=0
application/d3d12_agility_sdk_multiarch=true
ssh_remote_deploy/enabled=false
ssh_remote_deploy/host="user@host_ip"
ssh_remote_deploy/port="22"
ssh_remote_deploy/extra_args_ssh=""
ssh_remote_deploy/extra_args_scp=""
ssh_remote_deploy/run_script="#!/usr/bin/env bash\nexport DISPLAY=:0\n\"{temp_dir}/{exe_name}\" {cmd_args}"
ssh_remote_deploy/cleanup_script="#!/usr/bin/env bash\nkill $(pgrep -x -f \"{temp_dir}/{exe_name} {cmd_args}\")\nrm -rf \"{temp_dir}\""
```

> The editor rewrites `export_presets.cfg` whenever a preset changes. Do not hand-edit it while the editor is open.

> ⚠️ **Changed in Godot 4.7:** The "runnable" flag moved out of export presets — `runnable=` (shown in the example above for 4.3–4.6) is no longer a per-preset property in `export_presets.cfg`; a 4.7 editor writes a top-level `[runnable_presets]` section (platform name → preset name) in the same file, and still reads the legacy key. Don't be surprised when the line disappears from the file after saving in a 4.7 editor. See [GH-114930](https://github.com/godotengine/godot/pull/114930).

> **Godot 4.7+:** Sparse PCK exports (patch packs) support encrypting the file index, complementing the existing `encrypt_pck` / `encrypt_directory` preset options. ([GH-113920](https://github.com/godotengine/godot/pull/113920))

---

## 2. Platform-Specific Settings

| Platform  | Key Setting / Consideration                                                                                                                      |
|-----------|--------------------------------------------------------------------------------------------------------------------------------------------------|
| **Windows** | Set `application/icon` (.ico file). Codesigning requires a `.pfx` certificate; set `codesign/enable=true` and supply `codesign/identity` + `codesign/password` via env vars. Without codesigning, Windows SmartScreen will warn users. |
| **Linux**   | No codesigning required. The binary is written executable (0755); re-run `chmod +x` if an upload or archive step drops the bit. Ship as a tarball or AppImage for distribution. |
| **macOS**   | Requires notarization for Gatekeeper to allow launch without warning. Set `codesign/codesign` (rcodesign, or Xcode codesign on a Mac) and `notarization/notarization` (rcodesign or Xcode notarytool); the export submits for notarization. `Info.plist` entries are `application/*` (bundle ID, version) and `privacy/*` (usage descriptions). |
| **Web**     | Compatibility renderer only, and no C#. The preset's `variant/thread_support` is off by default (Godot 4.3+), so the build runs on any static host; a threaded build needs `Cross-Origin-Opener-Policy: same-origin` and `Cross-Origin-Embedder-Policy: require-corp` headers. Exported output is a `.html` + `.js` + `.wasm` + `.pck` bundle. Details: **web-export**. |
| **Android** | Requires a keystore for release signing. Set `keystore/release` to the `.keystore` path and supply `keystore/release_user` + `keystore/release_password` via env vars. Declare permissions in the preset under `permissions/*`. Set `package/unique_name` to a reverse-DNS string (e.g., `com.studio.mygame`). |
| **iOS**     | Requires a valid Apple provisioning profile (`.mobileprovision`). Set `application/bundle_identifier`, `application/code_sign_identity_release`, and `application/provisioning_profile_uuid_release`. Distribution builds require an App Store distribution certificate. |

> **Godot 4.8+:** Windows, Linux and macOS presets gain `debug/export_debug_symbols`, which ships a `.debugsymbols` file (`.dSYM` on macOS) beside the executable; it needs a same-named symbols file next to the export template. Android gains `gradle_build/minification` (R8, release builds).

---

## 3. Export from CLI

Run Godot in headless mode to export without opening the GUI. This is the standard approach for CI/CD.

### Release Export

```bash
godot --headless --export-release "Windows Desktop" build/windows/MyGame.exe
```

### Debug Export

```bash
godot --headless --export-debug "Windows Desktop" build/windows/MyGame.exe
```

### Export .pck Only (no executable)

Use `--export-pack` when you only want to ship updated game data alongside a fixed engine binary (e.g., DLC or patch distribution):

```bash
godot --headless --export-pack "Windows Desktop" build/windows/MyGame.pck
```

> **Godot 4.7+:** When exporting patch PCKs for Android, an APK or AAB can be provided as the base pack, extending PCK-patching workflows to Android builds. ([GH-116553](https://github.com/godotengine/godot/pull/116553))

### Packing In-Memory Data (Godot 4.7+)

`PCKPacker.add_file_from_buffer(target_path, data, encrypt = false)` packs a `PackedByteArray` straight into a PCK — no temp file on disk — which is handy when generating patch content from a build script:

```gdscript
var build_info: String = "v" + ProjectSettings.get_setting("application/config/version", "dev")
var packer := PCKPacker.new()
packer.pck_start("user://patch_1.pck")
packer.add_file_from_buffer("res://data/build_info.txt", build_info.to_utf8_buffer())
packer.flush()
```

```csharp
string buildInfo = "v" + ProjectSettings.GetSetting("application/config/version", "dev").AsString();
var packer = new PckPacker();
packer.PckStart("user://patch_1.pck");
packer.AddFileFromBuffer("res://data/build_info.txt", buildInfo.ToUtf8Buffer());
packer.Flush();
```

### Key CLI flags

| Flag | Purpose |
|------|---------|
| `--headless` | No display server; required for server/CI environments |
| `--export-release "Preset Name" path` | Export using release template |
| `--export-debug "Preset Name" path` | Export using debug template |
| `--export-pack "Preset Name" path` | Export .pck resource pack only |
| `--quit-after N` | Quit after N main-loop iterations (rarely needed for export) |

> The preset name in the CLI flag must match `name=` in `export_presets.cfg` exactly, including capitalisation and spaces.

---

## 4. CI/CD with GitHub Actions

Run `godot --headless --export-release` inside a GitHub Actions matrix that builds Windows, Linux, and Web artifacts on every push and tagged release. Use [`chickensoft-games/setup-godot@v2`](https://github.com/chickensoft-games/setup-godot) to install the engine + export templates (set `use-dotnet: true` for C# projects). Inject the version from `git describe` before export so `application/config/version` is correct in the binary.

See [references/ci-cd-github-actions.md](references/ci-cd-github-actions.md) for the full `.github/workflows/export.yml` with matrix presets, artifact upload, and Linux executable bit handling.

---

## 5. Versioning

Set the version in `application/config/version` and read it at runtime with `ProjectSettings.get_setting()`. To inject a version from git at export time, run a `--script` tool (a script extending `SceneTree`) that calls `git describe --tags --always --dirty` through `OS.execute()` before the export step. Tags follow Semantic Versioning (`v1.2.3`).

> See [references/versioning.md](references/versioning.md) for the runtime version label, the `inject_version.gd` tool, and the tag convention.

---

## 6. Distribution: itch.io and Steam

**itch.io** uses the [Butler](https://itch.io/docs/butler/) CLI: `butler push build/windows/ my-studio/my-game:windows --userversion "$VERSION"`. Channel names follow a convention (`windows`, `linux`, `macos`, `web`, `android`). In CI, the [`Ayowel/butler-to-itch@v1`](https://github.com/Ayowel/butler-to-itch) action pushes all artifacts at once; store the API key as the `BUTLER_API_KEY` secret.

**Steam** requires three pieces: the Steamworks SDK (non-redistributable, keep out of public repos), the [GodotSteam](https://godotsteam.com/) addon for engine bindings, and depot configurations driven by `steamcmd +run_app_build app_build.vdf`. Steam integration is outside the export pipeline itself.

See [references/distribution-itch-steam.md](references/distribution-itch-steam.md) for full butler install instructions, channel naming table, the `deploy-itch` GitHub Actions job, and the Steam component breakdown. For the release side — the 21-day app-fee wait, the two-week Coming Soon minimum, review times, store asset sizes, demo and Next Fest deadlines, and discount rules — see [references/steam-release-planning.md](references/steam-release-planning.md).

---

## 7. Shader Baker (Godot 4.5+)

Godot 4.5 introduces the **Shader Baker**, an export-time tool that pre-compiles shaders for the target platform. It mainly shortens first-launch load time, most on Direct3D 12 and Metal where shader conversion is slow. It does not remove pipeline-compilation stutter, which still needs pipeline precompilation.

### Enabling

In **Project → Export**, open a preset and locate the **Shader Baker** section. Tick **Enabled** (`shader_baker/enabled`, off by default). There is no backend picker: it bakes for the target platform's `rendering/rendering_device/driver` setting, on the Forward+ and Mobile renderers only.

> The Shader Baker makes exports slightly slower and the PCK a few megabytes larger. The baked shaders are embedded in the `.pck` file.

### Impact by Platform

| Platform | Backend | Benefit |
|----------|---------|---------|
| macOS / iOS | Metal | Largest gain — skips the slow SPIR-V → Metal shader conversion at first load |
| Windows | D3D12 | Large gain — skips SPIR-V → DXIL conversion; pipeline creation still happens at runtime |
| Android (Mobile renderer) | Vulkan | Shorter first load; no effect on the Compatibility (GLES3) renderer |
| Linux / Windows | Vulkan | Smaller improvement — Vulkan consumes SPIR-V directly |

### CI Workflow Note

The Shader Baker runs automatically when exporting via the editor GUI or CLI (`--export-release`). It is controlled by the preset, not a separate CLI flag. Caveat: the editor can only bake for drivers its own OS supports — a Linux runner bakes Vulkan only, so D3D12 presets need a Windows runner and Metal presets a macOS runner.

```bash
# Shader Baker runs as part of normal export (no extra flag needed).
godot --headless --export-release "Windows Desktop" build/windows/MyGame.exe
```

---

## 8. Windows Export — Native Resource Editing (Godot 4.5+)

Godot 4.5+ writes `.exe` metadata (version, icon, copyright, company) natively from the preset's `application/*` fields — no external `rcedit` download, so drop any CI `rcedit` step. Earlier versions need `rcedit`.

> See [references/windows-resource-editing.md](references/windows-resource-editing.md) for the field table, icon formats and setup.

---

## 9. Checklist

- [ ] Export templates downloaded for the target Godot version (Editor → Export Templates)
- [ ] `export_presets.cfg` committed to version control
- [ ] Secrets (keystore passwords, codesign passwords, API keys) stored in env vars or CI secrets, never in the file
- [ ] Each preset has a unique `name=` that matches the CLI `--export-release` argument exactly
- [ ] Output directories created before the export command runs (`mkdir -p`)
- [ ] Linux binary still executable after packaging (`chmod +x` if the bit was lost)
- [ ] `application/config/version` in project.godot is populated at export time from a git tag
- [ ] Web export: thread support left off, or the host sends `COOP` + `COEP` headers (see **web-export**)
- [ ] Android release preset uses a signed keystore, not the debug keystore
- [ ] macOS builds intended for distribution are codesigned and notarized
- [ ] Artifacts are uploaded per-platform in CI so individual platform builds can be downloaded
- [ ] itch.io channels follow the naming convention (windows, linux, macos, web, android)
- [ ] Butler API key stored as a CI secret, not hardcoded
- [ ] Steam depot configs are kept out of public repositories
- [ ] Steam launch date checked against the fixed lead times (21-day fee wait, two-week Coming Soon, 7-business-day reviews)
- [ ] Shader Baker enabled for D3D12 and Metal targets (Forward+/Mobile only), exported from a Windows / macOS host respectively (Godot 4.5+)
- [ ] Windows `.exe` metadata (version, icon, company name) set in the export preset — rcedit no longer required (Godot 4.5+)
