Godot ARM64 Export Checklist for Steam Frame Games

Why an x86_64 Build Will Not Cut It on Steam Frame

Steam Frame is an ARM based headset and docked Linux target, so your existing x86_64 Linux build will fail to launch even if the game logic is perfect. That shift is why recent ARM64 work matters for Godot developers, from the reported ARM64 build of Half-Life: Alyx for Steam Frame to the full native ARM64 Linux port of Factorio.

A clean godot arm64 export needs four things: the right Godot templates, a separate ARM64 preset, bundled system libraries, and a VR test pass on real OpenXR hardware. This checklist walks through each one in order.

1. Lock Your Godot Version and Templates

ARM64 export bugs are almost always version mismatches. Do this first and do not skip it.

1. Use Godot 4.2 or newer. ARM64 Linux templates are stable there, and OpenXR mobile rendering is much improved over 4.0.
2. In the editor, open Editor, Manage Export Templates and install the templates that match your exact editor build, for example 4.3.stable.
3. Confirm the templates on disk. Look for linux_release.arm64 in your templates folder:

ls ~/.local/share/godot/export_templates/4.3.stable/

1. Freeze the version for the team. Commit a file such as export_version.txt with the editor version and template checksum, and build only from that version on CI.

Tip: keep one machine or container as your exporter. Mixed editor versions are the fastest way to get a preset that says arm64 but embeds x86_64 binaries.

2. Create a Dedicated ARM64 Linux Preset

Do not reuse your Steam Deck preset. Duplicate it and change the architecture and paths.

1. Go to Project, Export, duplicate your Linux preset, and rename it Linux ARM64 Steam Frame.
2. Set these options:

1. Under Resources, enable Export with Debug for your first three test builds. You need full logs until input and performance are stable.
2. Under Features, make sure you list Linux and ARM64, not x86_64.
3. Export once and check the binary:

file builds/steam-frame/game.arm64
ldd builds/steam-frame/game.arm64 | head -n 40
chmod +x builds/steam-frame/game.arm64

file must report ARM aarch64. If ldd shows missing libX11, libGL, or libvulkan entries, fix that in step 3 before you test VR.

If logs get noisy, treat AI as a debugger to unblock your export work rather than asking it to rewrite the project.

3. Bundle Linux Dependencies for a Steam Runtime Target

Steam Frame runs a SteamOS style runtime, not your Ubuntu workstation. Assume plain Arch libraries are missing.

1. Prefer the Steam Runtime. Test your build inside pressure-vessel or with steam-runtime-run.sh before you upload to Steam.
2. Bundle Godot specific shared libraries next to the binary when needed, including libgodot_openxr.so if you built OpenXR extensions from source.
3. Keep this folder layout:

steam-frame/
  game.arm64
  game.pck
  lib/
    libgodot_openxr.so
  README-frame.txt

1. Avoid hard coded absolute paths in OS.execute, autoloads, or GDExtension loader scripts. Use OS.get_executable_path() and relative res:// or user:// paths.
2. Run a dependency smoke test on a clean ARM64 Linux VM or device:

./game.arm64 --headless --quit-after 60
./game.arm64 --check-only --resolution 1280x720

The first command validates startup without a display. The second catches missing rendering libraries before you put on the headset.

4. Tune Performance for ARM GPUs

ARM integrated GPUs punish overdraw, shadow cascades, and uncompressed textures. Plan for 20 to 30 percent lower GPU headroom than a Steam Deck at the same resolution.

1. Start with the Mobile rendering method, not Forward Plus, unless your scene is very light. In Godot 4 this selects a clustered mobile renderer that behaves better on tiled GPUs.
2. Switch texture compression to ETC2 and ASTC and reimport. S3TC alone loads on ARM but wastes memory and bandwidth.
3. Apply this baseline:

• Shadows: single directional cascade, 2048 max, disable contact shadows
• Glow and SSAO: off for first pass, re-enable one at a time
• MSAA: 2x for VR, evaluate 4x only after profiling
• Physics ticks: 60, not 120, unless gameplay requires it
• Occlusion culling: on for interior scenes

1. Profile on device with the Godot profiler and radeontop, nvtop, or Steam performance overlay equivalents. Capture frame time, physics time, and draw calls in both headset and docked flat mode.
2. Add a simple in game quality menu with Low, Balanced, and High presets that change scaling and shadows. Steam Frame users switch between standalone and docked often.

When you automate these checks, tool access changes AI game development because an assistant that can read profiler output and preset files finds regressions faster than chat alone.

5. Validate VR Input With OpenXR

A flat Linux build that runs is only half done. Steam Frame needs a full OpenXR action map test.

1. Enable the OpenXR plugin and set your project to use the OpenXR action map, not legacy joypad polling for hands.
2. Map every interaction explicitly:

• Left and right grip, trigger, thumbstick, menu, and system reserved buttons
• Haptics strength and duration per interaction
• Pointer pose for UI versus grip pose for held objects

1. Add a startup safety check in GDScript:

func _ready() -> void:
  var xr := XRServer.find_interface("OpenXR")
  if xr == null or not xr.is_initialized():
    show_flat_fallback("OpenXR not initialized. Check headset connection.")
    return
  enable_vr_player()

1. Test this sequence on hardware:

• Cold boot into the game from Steam, no editor connected
• Controller tracking loss and regain
• Chaperone boundary show and hide
• Suspend, resume, and quit to Steam overlay
• 15 minute thermal session with frame timing logged

1. Log dropped frames by eye and by numbers. In OpenXR, reprojection hides small misses, so check Engine.get_frames_drawn() trends and Steam frame timing graphs, not only perceived smoothness.

Final Pre Upload Smoke Test

Run this list before you push to a Steam beta branch:

• [ ] file confirms aarch64 and version matches templates
• [ ] Clean ARM64 VM launch with --headless --quit-after 60
• [ ] Steam Runtime launch in both flat and VR modes
• [ ] No absolute paths, no missing lib files in ldd output
• [ ] Mobile renderer, ETC2 and ASTC textures, quality presets work
• [ ] All OpenXR actions trigger, haptics fire, fallback UI shows if headset is off
• [ ] 15 minute headset run with stable frame times and no thermal throttle warnings

Ship the ARM64 build as a separate Steam depot or beta branch first. That lets Steam Frame testers opt in while Deck and desktop players stay on x86_64, and it gives you clean crash reports per architecture.