---
name: export-pipeline
description: Use when exporting and distributing Godot games — export presets, platform settings, CI/CD with GitHub Actions
title: export-pipeline
canonical_url: https://skilld.dev/gh/jame581/godotprompter/export-pipeline
last_updated: 2026-11-13T22:06:02.000Z
---

> Index of every page on this site: [llms.txt](https://skilld.dev/llms.txt)

> **Skill from skilld.dev.** Follow the user's requested action.
> If the user asked to fork this Skill, follow the fork workflow below. Do not execute the Skill instructions while copying it.
> Otherwise, follow the instructions below for this session. You do not need to install anything.
>
> Supporting files, fetch one when the Skill refers to it: [references/ci-cd-github-actions.md](https://skilld.dev/api/skills-raw/jame581/godotprompter/export-pipeline/references/ci-cd-github-actions.md), [references/distribution-itch-steam.md](https://skilld.dev/api/skills-raw/jame581/godotprompter/export-pipeline/references/distribution-itch-steam.md), [references/steam-release-planning.md](https://skilld.dev/api/skills-raw/jame581/godotprompter/export-pipeline/references/steam-release-planning.md), [references/versioning.md](https://skilld.dev/api/skills-raw/jame581/godotprompter/export-pipeline/references/versioning.md), [references/windows-resource-editing.md](https://skilld.dev/api/skills-raw/jame581/godotprompter/export-pipeline/references/windows-resource-editing.md).
>
> If the user asked to install this Skill, run `npx skilld install jame581/godotprompter/export-pipeline`. Install writes the Skill files into the project, so every session loads them.
>
> ## Fork workflow
>
> A fork creates an editable local Skill with its original author and licence. The request authorizes copying and local installation.
> 1. Check `./skills/export-pipeline`, the project lockfile, and selected Agent targets together. If the local directory or installed Skill exists, stop. Never overwrite an existing directory or Agent target.
> 2. Read [source metadata](https://skilld.dev/api/v1/skills/jame581/godotprompter/export-pipeline) once. Use sourceUrl, sourceCommit, skillPath, sourceGone, and license. If the source is gone or its path is missing, stop. If license is null, read licence files at the source commit.
> 3. Fetch only the source commit into a temporary Git repository. Do not clone full history. Derive repository_url from sourceUrl, including repository renames. If sourceCommit is absent, resolve the sourceUrl ref once. Set source_commit to that actual commit. Run these commands in one shell call:
>
> ```sh
> git init --quiet "$temporary_dir"
> git -C "$temporary_dir" fetch --quiet --depth=1 "$repository_url" "$source_commit"
> git -C "$temporary_dir" checkout --quiet --detach FETCH_HEAD
> ```
>
> Read applicable licence declarations and notices at that commit. If copying is not permitted, report the restriction and stop.
> 4. Inspect source entries together, then copy the directory containing skillPath into `./skills/export-pipeline`. Use the user's path if selected. Keep the original SKILL.md, relative links, scripts, binary assets, and executable modes. Exclude .git metadata. Reject symlinks and paths outside the Skill directory. After checking entries, use cp -a where available. A regular source directory needs no custom copy script. Do not save this page wrapper as SKILL.md.
> Preserve author credit, notices, and applicable licence files from repository or parent directories. Add PROVENANCE.md with the Skill page, source URL, actual commit, original path, and licence. Retain any existing PROVENANCE.md and record new provenance separately. Batch source inspection, copying, and provenance work where practical.
> 5. In the project root, run `skilld install ./skills/export-pipeline --mode copy --plain`. If skilld is unavailable, use `npx skilld install ./skills/export-pipeline --mode copy --plain`. This known command needs no help lookup. Install does not support --json. Use detected Agent targets, or add --agent for the targets the user selected. Install the local path, never the upstream selector. If installation fails, preserve the local copy and report the exact failure.
> 6. Confirm the local lockfile source and installed Agent copies once. Report the local path, actual commit, and Agent targets. After edits, reinstall the same local path. Upstream updates must not replace it. Do not publish or push unless the user asks.

# 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](https://skilld.dev/api/skills-raw/jame581/godotprompter/export-pipeline/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](https://skilld.dev/api/skills-raw/jame581/godotprompter/export-pipeline/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](https://skilld.dev/api/skills-raw/jame581/godotprompter/export-pipeline/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](https://skilld.dev/api/skills-raw/jame581/godotprompter/export-pipeline/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](https://skilld.dev/api/skills-raw/jame581/godotprompter/export-pipeline/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+)
