Export Your Game to Android in Godot 4 (Full 2026 Walkthrough)

Exporting a Godot 4 game to Android is not hard, but it fails in a specific, predictable way for almost everyone the first time: a version mismatch between three separate pieces of software that all have to agree. Once you understand which three pieces those are and get them lined up, the export itself is a few clicks.

This guide walks the whole path from a finished game to a signed file you can install on a phone or upload to Google Play. It assumes you already have a game you want to ship. If you are still building one, Summer Engine makes real projects that are compatible with Godot 4, which means the export steps below apply to a Summer project exactly as they do to any hand-built Godot project. The free tier covers export with no watermark and no revenue share.

The one thing that breaks most first exports

Android export in Godot depends on three things matching:

1. Your Godot editor version (for example 4.5.1)
2. The export templates you install (must be the same version)
3. The JDK Godot uses to build the Android package (JDK 17 for Godot 4.x)

If your editor is 4.5.1 but you install 4.5 templates, or you point Godot at JDK 21 instead of 17, the export either greys out, throws a cryptic Gradle error, or produces an APK that will not install. Sort these three out before touching anything else and you skip the majority of the pain people hit.

So the order of operations matters. Install the templates and the toolchain first, configure the export second, build last.

Step 1: Install the matching export templates

Open your project in Godot. Go to Editor then Manage Export Templates. If the panel says no templates are installed, click Download and Install. Godot fetches the templates for your exact editor version.

People skip this because the export menu looks like it should just work. It does not. The templates are the platform-specific runtime packaged with your game, and without the Android template the preset has nothing to build with. On a beta or release-candidate Godot build you may need to download the template file manually and use Install from File, since the automatic downloader only knows stable releases.

Step 2: Install the JDK and Android SDK

Godot does not ship the Android toolchain. You install it once on your machine and Godot reuses it for every project.

You need two things:

• A JDK, version 17. Android Gradle builds for current Godot want JDK 17 specifically. A newer JDK like 21 will often fail. Temurin (Eclipse Adoptium) is a reliable free distribution.
• The Android SDK command-line tools. The simplest route is to install Android Studio, which bundles the SDK, the platform tools, and the build tools. If you do not want the full IDE, you can install just the command-line tools, but Android Studio is the path of least resistance for a first export.

After installing, note two folder paths: where the JDK lives, and where the Android SDK lives. You will paste both into Godot in the next step.

{/* IMAGE: Android Studio SDK Manager showing installed platform-tools and build-tools, with the SDK location path highlighted. Screenshot, 1200x675. */}

Step 3: Point Godot at the toolchain

Back in Godot, go to Editor then Editor Settings, and find the Export then Android section in the left sidebar.

Fill in:

• Java SDK Path (or JDK path): the JDK 17 folder from Step 2
• Android SDK Path: the SDK folder from Step 2

Godot validates these as you type. If a path is wrong, you get a red warning right there, which is much easier to fix now than to debug as a failed export later.

This configuration is global to your Godot install, not per project, so you only do it once per machine.

Step 4: Create the Android export preset

Now the export itself. Go to Project then Export. Click Add and choose Android.

You will likely see a red error icon at the top of the preset. That is expected at this stage and it tells you what is still missing. Hover over it to read the message. It is usually pointing at the build template or the keystore, which you handle next.

In the preset options, the settings that matter most for a first build:

• Unique Name (the package identifier, like com.yourstudio.yourgame). This must be unique on the Play Store, so use a real reverse-domain name even for testing.
• Renderer. Set your project to the Mobile renderer for modern phones, or Compatibility for the widest device support including older hardware. You set this in Project Settings under Rendering, and it is the single biggest reason a game runs in the editor but shows a black screen on a phone.
• Architectures. Leave arm64-v8a on; it covers essentially every modern Android device. You can disable armeabi-v7a unless you specifically target very old phones.

Step 5: Install the Android build template

In the Android preset there is a button: Install Android Build Template. Click it.

This copies a Gradle project into your game folder (an android/build directory). Godot uses this to actually assemble the package. You need it for custom builds, for adding plugins later, and it is required for the AAB format that Google Play wants.

If this step errors, it is almost always the JDK or SDK path from Step 3, or a Gradle download being blocked by a firewall. Read the output panel at the bottom of the Godot window; the real error is in there, not in the popup.

Step 6: Set up signing (the keystore)

Android will not install an app that is not signed, so even a test build needs a keystore. There are two cases.

For testing on your own device (debug keystore):

Godot can use an auto-generated debug keystore. In Editor then Editor Settings then Export then Android, there are fields for a debug keystore, user, and password. Godot can create the debug keystore for you, and the standard debug credentials are well known (the keystore user is androiddebugkey). This is fine for installing on hardware you control. Never ship a debug-signed build publicly.

For release (your own keystore):

When you are ready to distribute, generate a release keystore. You can do this from a terminal with the keytool command that ships with your JDK:

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

It asks for a password and some identity details. Then, in the Android export preset, expand the Keystore section and fill in the release keystore path, the alias, and the passwords.

Critical: back up this keystore file and its passwords somewhere safe. If you publish to Google Play with this keystore and then lose it, you can never push an update to that app again under the same identity. This is the one mistake in mobile that is genuinely unrecoverable, so treat the file like a password.

Step 7: Export

With the build template installed and signing set, the red error on the preset should be gone. Now choose your output.

• Export Project with an .apk filename gives you a single installable file. Copy it to a phone and tap it (you may need to allow installs from unknown sources), or install it over USB. This is what you use for testing and for non-store distribution like itch.io.
• Export Project with an .aab filename gives you an Android App Bundle for the Google Play Store. Google Play only accepts AAB for new apps.

For a quick on-device test, the fastest path is the one-click deploy: plug your phone in with USB debugging enabled, and a small Android icon appears in the top-right of the Godot editor. Click it and Godot builds, installs, and launches the game on the connected device in one action, with the remote debugger attached so you can read errors live.

{/* IMAGE: Godot editor toolbar showing the one-click Android deploy button (small Android robot icon) lit up with a connected device. Screenshot, 800x400. */}

Common errors and what they actually mean

• Red error on the preset, "Export templates not found": Step 1, the template version does not match your editor version. Reinstall templates for the exact version.
• "No valid Java SDK" or "JDK not found": Step 3 path is wrong, or you installed a JDK other than 17. Install JDK 17 and re-point it.
• Gradle build fails with a long stack trace: Read the Godot output panel, not the popup. Most often a JDK version mismatch, a blocked download, or a package name with invalid characters (use lowercase reverse-domain, no spaces or hyphens in the identifier).
• Installs but black screen on launch: Wrong renderer for the device (switch to Mobile or Compatibility) or textures too large for the mobile GPU. Run over USB with the remote debugger to read the Android log.
• "App not installed" on the phone: Usually a signing problem, or you already have a different-signed version of the same package installed. Uninstall the old one first.
• Game runs but controls do nothing: Your input map assumes a keyboard. Mobile needs touch input, which we cover next.

The part export does not solve: making it playable with fingers

Exporting is mechanical. The harder mobile problem is that a game built for keyboard and mouse is not playable on a touchscreen, and no export setting fixes that. You need:

• On-screen touch controls. A virtual joystick, tap-to-act buttons, or gesture input, depending on the genre.
• Screen scaling that survives many aspect ratios. Phones range from tall and narrow to wide tablets. Set a stretch mode (canvas_items, keep aspect) so your UI does not get clipped or stranded.
• Bigger hit targets. Buttons sized for a mouse cursor are too small for a thumb.

This is where an AI-native workflow saves real time. In Summer you describe the change in plain language, like add a virtual joystick for movement and a fire button bottom-right, and make the HUD scale to the screen, and it edits the actual project. Because the output is a standard project compatible with Godot 4, the touch controls it adds are normal Godot nodes you can open and tune by hand. Start a mobile-friendly project from the templates gallery and adapt it.

If you are building the game itself from scratch, How to Make a Game with AI covers the build loop, and How to Make a 2D Game with AI goes deep on one small project end to end. Both produce projects that follow the exact export steps above.

Free versus paid, honestly

Everything in this guide is free. The Godot toolchain (editor, templates, JDK, SDK) costs nothing. Building and exporting an Android APK or AAB from Summer is on the free tier with no watermark and no revenue share; you only pay for more AI usage on larger projects, and you can see the limits on the pricing page. The one cost outside your control is the one-time 25 dollar Google Play developer account, and only if you want to be on the Play Store. Sideloading an APK to your own phone, or distributing on itch.io, is free.

After Android: the rest of the launch

A signed Android build is one platform. If you are also targeting desktop, Publish Your Game on Steam walks through the Steam side, which has its own signing-free but fee-based process. The good news is that a project compatible with Godot 4 exports to Windows, macOS, Linux, web, and Android from the same Project then Export menu, so once you have done Android, the others are the same workflow with a different preset.

Get the three versions lined up, install the build template, sign the build, and you have a game running on a real phone. To go from idea to that exportable project without writing the boilerplate yourself, start in the AI game maker or grab the desktop app from the download page.