export-pipeline
Use when exporting and distributing Godot games — export presets, platform settings, CI/CD with GitHub Actions
How do I install this agent skill?
npx skills add https://github.com/jame581/godotprompter --skill export-pipelineIs this agent skill safe to install?
- Gen Agent Trust Hubpass
This skill provides a standard and secure guide for Godot 4.3+ export pipelines, including CI/CD integration. It correctly advises using environment variables for sensitive credentials and utilizes well-known tools from the Godot community.
- Socketpass
No alerts
- Snykwarn
Risk: MEDIUM · 1 issue
What does this agent skill do?
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.cfgwhenever 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 inexport_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_directorypreset 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. |
Godot 4.8+: Windows, Linux and macOS presets gain
debug/export_debug_symbols, which ships a.debugsymbolsfile (.dSYMon macOS) beside the executable; it needs a same-named symbols file next to the export template. Android gainsgradle_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
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=inexport_presets.cfgexactly, 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.gdtool, 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
.pckfile.
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+)
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 for the field table, icon formats and setup.
9. Checklist
- Export templates downloaded for the target Godot version (Editor → Export Templates)
-
export_presets.cfgcommitted 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-releaseargument exactly - Output directories created before the export command runs (
mkdir -p) - Linux binary still executable after packaging (
chmod +xif the bit was lost) -
application/config/versionin project.godot is populated at export time from a git tag - Web export: thread support left off, or the host sends
COOP+COEPheaders (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
.exemetadata (version, icon, company name) set in the export preset — rcedit no longer required (Godot 4.5+)
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/jame581/godotprompter/export-pipeline">View export-pipeline on skillZs</a>