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):

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

Godot 4.7+: Sparse PCK exports (patch packs) support encrypting the file index, complementing the existing encrypt_pck / encrypt_directory preset options. (GH-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.

---

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

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

Debug Export

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):

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)

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:

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()

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

---

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.

# 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+)

Before Godot 4.5, modifying .exe metadata (version info, icon, copyright, company name) on Windows required the external rcedit tool. Godot 4.5 handles all of this natively at export time — no rcedit download or configuration needed.

What is Edited Natively

Export Preset Field	Effect on .exe
application/file_version	File version shown in Properties → Details
application/product_version	Product version
application/company_name	Company name
application/product_name	Product name
application/file_description	Description
application/copyright	Legal copyright
application/icon	Icon image (ICO, PNG, WebP or SVG) converted and embedded as the executable icon

Setup

1. Open Project → Export → Windows Desktop preset.
2. Fill in the application/* fields under Application in the preset options.
3. Export normally — Godot writes the metadata into the .exe directly.

Removing rcedit from CI: If your project previously downloaded rcedit in CI and called it as a post-export step, you can remove that step. The fields in the export preset replace it entirely for Godot 4.5+.

---

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+)