Index of every page on this site: llms.txt
All skills
jame581 avatar

/export-pipeline

@426e8ab
by Jan Mesarčjame581/godotprompter979 stars
63
Run it yourself

Use when exporting and distributing Godot games — export presets, platform settings, CI/CD with GitHub Actions

Use this Skill: https://skilld.dev/gh/jame581/godotprompter/export-pipeline

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈32 tokens for metadata: the name and description. ≈3.7k when used: this file. ≈4.1k more on demand in 5 files.

Description uses 1.6% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈128 characters, or 1.6%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

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.

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

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

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

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 warning7d3 checks · Risk SAFE
  • Gen Agent Trust Hub7d

    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.

  • Socket7d

    No alerts

  • Snyk7d

    Risk: MEDIUM · 1 issue

Signed by skilld at 426e8ab. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 6 days ago.

Activeupdated last week

README badge

README badge for jame581/godotprompter/export-pipeline