Gamedev Shipping

Ship the game — export, build & release (per engine · per platform)

Take a finished project from editor → signed, correctly-configured artifact → live on the right target (desktop / web / mobile / store), with the platform gotchas that silently break a build handled up front. This skill owns the packaging and release boundary; the engine skills own the code that runs inside the artifact.

project ──[engine export/build]──▶ artifact ──[per-platform sign/config]──▶ target
Godot templates·Unity Build Profiles·Unreal Shipping    desktop·web·mobile    Steam·Play·App Store·itch

Version anchors (what "current" means here — July 2026)

When NOT to use — and who owns it instead

Decision rules (settle these before touching a build)

Export / build per engine

Godot — Editor ▸ Manage Export Templates (match version), then Project ▸ Export, add one preset per platform. Headless for CI:

godot --headless --export-release "Windows Desktop" build/game.exe
godot --headless --export-release "Web"             build/index.html
# Android AAB needs the Gradle build template + JDK 17 + a release keystore (see references)

Web preset toggles: Thread Support (⇒ needs COOP/COEP) and Extensions Support. Android needs Project ▸ Install Android Build Template (enables Use Gradle Build).

Unity — File ▸ Build Profiles (formerly Build Settings). Create a profile per platform; override Player Settings per profile (company/product name, bundle id, icons, scripting backend). iOS/Android/WebGL force IL2CPP. CI headless:

Unity -quit -batchmode -nographics -projectPath . \
  -buildTarget Android -executeMethod BuildScript.PerformBuild -logFile -

Android: tick Build App Bundle (Google Play) for AAB; set the keystore in Publishing Settings. WebGL: threads ⇒ COOP/COEP; keep decompression fallback for hosts that can't set gzip/br headers.

Unreal — build configurations, not "modes": Debug, DebugGame, Development (test packaged builds — keeps logs/console), Test, Shipping (release — strips logging, most optimized). Package via Platforms ▸ <target> ▸ Package Project, the Project Launcher, or UAT for CI:

RunUAT BuildCookRun -project="Game.uproject" -platform=Win64 \
  -clientconfig=Shipping -cook -stage -pak -package -archivedirectory=build

Android adds -distribution for an AAB; iOS requires a Mac + provisioning. Run the platform Turnkey/SDK setup once (Android Studio + NDK, or Xcode) or the cook fails.

→ full per-engine preset/flag tables: references/mobile-and-desktop.md and references/stores-and-ci.md.

Per-platform

Desktop (Windows / macOS / Linux) — the simplest path

macOS notarization (the step everyone forgets):

codesign --deep --force --timestamp --options runtime \
  --sign "Developer ID Application: Studio (TEAMID)" Game.app
ditto -c -k --keepParent Game.app Game.zip
xcrun notarytool submit Game.zip --keychain-profile "AC" --wait   # store creds once via store-credentials
xcrun stapler staple Game.app                                     # staple so it verifies offline

--options runtime (Hardened Runtime) is mandatory for notarization. Codesign every bundled .dylib/helper before the outer .app, inside-out.

Web — the header trap (read this before blaming your build)

Threaded WebAssembly builds (Godot with Thread Support, Unity WebGL with threads) use SharedArrayBuffer, which browsers gate behind cross-origin isolation. The server must send:

Cross-Origin-Opener-Policy: same-origin
Cross-Origin-Embedder-Policy: require-corp

Missing them ⇒ SharedArrayBuffer is not defined, a hang, or a blank canvas — even though the files are fine. Where to set them:

• Netlify _headers, Vercel vercel.json headers, nginx add_header — set both on the game path.
• itch.io — tick "This file will be played in the browser" ▸ SharedArrayBuffer support; itch sets the headers for you.
• GitHub Pages — cannot set headers. Use a non-threaded export, or the coi-serviceworker shim (a service worker that re-serves with the headers).

COEP: require-corp also means every cross-origin subresource (fonts, analytics, embeds) must send CORP/CORS or it's blocked. Godot C#/.NET has no web export at all — use GDScript.

→ per-host configs, the service-worker shim, COEP subresource fallout, a self-test snippet and the Godot vs Unity web specifics: references/web-export-headers.md.

Mobile

Android — needs JDK 17 and the engine's Gradle build template. Ship AAB to Play (Google re-signs and generates per-device APKs), APK for sideload/itch/direct. Generate a release keystore once and reuse it forever (lose it = you can't update the app without Play App Signing key reset):

keytool -genkey -v -keystore release.keystore -alias game \
  -keyalg RSA -keysize 2048 -validity 10000

Keep the keystore + passwords out of git (CI secret). versionCode must increase every upload.

iOS — Mac + Xcode + Apple Developer account. Bundle ID must match an App ID; pick a provisioning profile (development / ad-hoc / App Store) and a signing certificate. Archive, then upload to App Store Connect / TestFlight via Xcode Organizer or Transporter. CFBundleVersion must increase per upload.

→ full keystore + Play App Signing, provisioning/TestFlight, Windows Authenticode and Linux AppImage/Flatpak walkthroughs: references/mobile-and-desktop.md.