Start Building

Godot 4.4 Android Export Crashes on Launch - Mobile Export Fix

Your Godot 4.4 project exports to Android and installs, but the app crashes as soon as you open it. You see a black screen, a flash, or an immediate return to the launcher with no in-game error message. This is frustrating when the same project runs fine in the editor or on desktop.

This guide walks you through the most common causes of Godot 4.4 Android export crashes on launch and how to fix them step by step.

The Problem

  • You export an Android preset (APK or AAB) from Godot 4.4.
  • The build completes and installs on a device or emulator.
  • When you launch the app, it crashes immediately (or after a brief black/flash screen).
  • You may see a system "App has stopped" dialog, or the app simply closes.
  • The game runs correctly in the editor or on desktop export.

This usually points to a configuration, permission, or runtime environment issue specific to the Android export, not to your game logic alone.

Why This Happens

Missing or wrong Android SDK/NDK:
Godot 4.4 needs a valid Android SDK and a compatible NDK version. If the path is wrong, the NDK is missing, or the version is unsupported, the exported runtime can fail to start or crash on init.

Export templates vs. custom build:
Android export uses different binaries than desktop. If Android export templates are not installed or are the wrong version (e.g. 4.3 templates with 4.4), the engine may crash at startup.

Permissions and manifest:
Required permissions (e.g. storage, vibration) must be declared in the Android manifest. Godot generates this from project settings; if something is misconfigured or a plugin injects invalid XML, the system can kill the app on launch.

Architecture and min SDK:
Building for the wrong ABI (e.g. arm64-v8a not included on a 64-bit-only device) or setting min SDK too high for the device can prevent the app from running or cause early native crashes.

GDScript/.NET and first scene:
Rarely, a script error or missing resource in the first scene (e.g. autoload or main scene) only shows up on Android because of different load order or threading. A bad autoload can crash before any scene is shown.

Solution 1: Verify Android SDK and NDK (Recommended First Step)

Godot must point to a correct Android SDK and a compatible NDK.

Step 1: Open Export Settings

  1. In Godot 4.4, go to Editor → Editor Settings (or Project → Project Settings for project-specific overrides).
  2. Open Export → Android (or Export and then the Android section).
  3. Check Android SDK path and Android NDK path.

Step 2: Install or Fix SDK/NDK

  1. If either path is empty or invalid, download the Android command-line tools or install Android Studio and use its SDK path (e.g. C:\Users\<You>\AppData\Local\Android\Sdk on Windows).
  2. In SDK Manager, install:
    • Android SDK Platform (e.g. API 34 or the version Godot 4.4 recommends).
    • NDK (Side by side) – use a version compatible with Godot 4.4 (often NDK 25 or 26; check Godot Android documentation).
  3. In Godot, set Android NDK path to the NDK folder inside the SDK (e.g. Sdk/ndk/25.2.9519653).

Step 3: Re-export and Test

  1. Export your project to Android again.
  2. Install the new APK on a device or emulator and launch.

Verification: If the app now opens (even to a black or loading screen) instead of crashing instantly, the issue was likely SDK/NDK. If it still crashes, continue to the next steps.

Solution 2: Install or Update Android Export Templates

Android export uses engine templates that must match your Godot version.

  1. In Godot 4.4, go to Editor → Manage Export Templates.
  2. If Android (or "All") templates are missing or outdated, click Download and Install and wait for the correct version (e.g. 4.4.x).
  3. Ensure you use standard templates if your project is GDScript, or .NET templates if you use C#.
  4. Re-export to Android and test launch again.

Verification: A clean export with the right templates often fixes "crash on first frame" or native library load failures.

Solution 3: Check Permissions and Export Options

  1. Go to Project → Export, select your Android preset.
  2. Under Options, review:
    • Permissions: Only enable permissions you actually need (e.g. Access network state, Vibration). Removing unnecessary permissions can avoid conflicts or policy-related kills on some devices.
    • Min SDK and Target SDK: Set Min SDK to a value your test device supports (e.g. 24 or 26). If Min SDK is higher than the device API level, the app may not run or may crash.
    • Support 64-bit: If your device is 64-bit only, ensure arm64-v8a (or the appropriate 64-bit ABI) is enabled in the export preset.
  3. Under Architectures, leave at least arm64-v8a (and armeabi-v7a if you need 32-bit) so the build matches common devices.
  4. Export again and launch.

Verification: The app should no longer be killed by the system for permission or ABI mismatch. If it still crashes, the cause may be in-engine (next step).

Solution 4: Simplify First Scene and Autoloads

If the crash is consistent and logs point to script or resource load:

  1. Temporarily set the main scene to a new, empty scene (single Node2D or Node3D, no scripts).
  2. Export to Android and launch. If the empty scene runs without crashing, the issue is likely in your real main scene or an autoload.
  3. Re-enable autoloads one by one and test after each, or simplify the main scene (disable scripts, remove custom resources) until the crash stops. That narrows down the offending script or asset.
  4. Check for threads or signals that run at startup; on Android, timing can differ and expose bugs that do not appear on desktop.

Verification: If the minimal project runs on device, reintroduce content until you find the script or resource that triggers the crash, then fix or defer that logic for Android.

Alternative Fixes and Edge Cases

  • Debug build: Export a Debug Android build and install it. Use adb logcat or Android Studio’s Logcat to see the stack trace when the app crashes. Look for "FATAL EXCEPTION" or Godot/engine errors to get the exact cause.
  • Clean rebuild: Delete the project’s .godot cache (with the editor closed), reopen the project, and re-export. Corrupted cache can sometimes cause Android-only failures.
  • Plugins: If you use Android plugins (e.g. ads, billing), disable them temporarily. A misconfigured or incompatible plugin can crash the app on startup.
  • Device-specific: Test on another device or emulator. Some devices have stricter memory or GPU requirements; a crash on one device but not another can point to device-specific limits or drivers.

Prevention Tips

  • After upgrading Godot (e.g. 4.3 → 4.4), re-download Manage Export Templates and confirm Android SDK/NDK paths in Editor Settings.
  • Keep Min SDK and Target SDK in a range that matches your target devices and store requirements.
  • Use Debug export and adb logcat when something goes wrong; the stack trace saves a lot of guesswork.
  • Bookmark the Godot Android export documentation for your engine version and refer to it when adding plugins or changing export options.

Related Problems and Links

  • Export templates not found: If Godot says export templates are missing, see our Godot 4.3 Export Templates Not Found - Platform Export Fix for download and path steps; the same idea applies to 4.4.
  • Godot 4.4 export fails with "Platform not configured": Ensure Android is enabled in Export and that you have at least one Android preset; check Godot Export documentation for your version.
  • For a full mobile and export workflow, see our Godot guide and the export section on deployment.

If this fix worked for you, bookmark it for quick reference and share it with other Godot devs shipping to Android. If the app still crashes after these steps, capture the crash log from Logcat and use the error message to search for the specific exception or engine line; that will point you to the next fix.