How to Make a Godot Mobile Game for Android and iOS

To make a mobile game in Godot, set your project up for phones (renderer, screen size, orientation and touch controls), then export it with Godot's Android and iOS export presets. Android builds work from Windows, Mac or Linux once Java and the Android SDK are installed. iPhone builds need a Mac with Xcode. This guide covers every step, from your first touch control to the game running on your own phone.

Plan a game that fits a phone

People play phone games in short bursts: on the bus, in a queue, between other things. They hold the phone with one or two thumbs, often with the sound off. The best mobile games are built around that.

• Keep controls simple. Tap, swipe or one on-screen stick works better than six buttons.
• Make buttons big. A fingertip needs about 90 by 90 pixels in a 720 by 1280 project. Smaller buttons cause missed taps.
• Pick portrait or landscape early. Portrait suits one-thumb games, and landscape suits games that need two thumbs.
• Save often. Phones close apps without warning when a call comes in or the battery runs low.

Still choosing what to build? Our mobile game roadmap helps you pick an idea and an engine. This guide assumes you already know Godot's basics, which how to make a game in Godot 4 teaches.

Project settings for phones

Some of these options only appear when Advanced Settings is switched on, at the top right of the Project Settings window.

1. Choose a renderer. Godot has three. Compatibility supports the widest range of phones, back to Android 7. Mobile needs Android 9 or newer and suits 3D games on newer phones. For a 2D game, Compatibility is the safe choice. You can switch later by clicking the renderer name in the top-right corner of the editor.
2. Set the screen size. Open Project > Project Settings > Display > Window. For a portrait game, set Viewport Width to 720 and Viewport Height to 1280.
3. Set the stretch rules. In the same section, set Stretch Mode to canvas_items and Aspect to expand. Your game then scales to any screen without black bars.
4. Lock the orientation. Under Handheld, set Orientation to portrait, or leave it on landscape.
5. Test touch with a mouse. Under Input Devices > Pointing, turn on Emulate Touch From Mouse. Mouse clicks then act like fingers, so you can test touch code on your PC.

To preview a tall phone shape on your PC, set Window Width Override and Window Height Override (under Display > Window) to 360 and 780. These only change the test window, not the phone build.

Touch controls: joystick, buttons and swipes

Godot 4.7 added a built-in VirtualJoystick node. Put it inside a CanvasLayer, so it stays fixed on the screen, and move it to the bottom-left corner. In the Inspector, set its four actions to your own Input Map actions, such as move_left and move_right. Your existing Input.get_vector() or Input.get_axis() code then works with the stick, with no changes. Its Joystick Mode can be Fixed, Dynamic (the stick jumps to where your thumb lands inside its area) or Following (the stick also follows a thumb that slides out of that area). On older Godot versions, use a joystick add-on from the asset library instead.

A TouchScreenButton works the same way. Give it a picture, set its Action to jump and set Visibility Mode to TouchScreen Only, so it hides on PCs. For taps and swipes, read the touch events yourself:

extends Node2D

const MIN_SWIPE := 80.0  # pixels a finger must travel
var touch_start := Vector2.ZERO

func _unhandled_input(event: InputEvent) -> void:
    if event is InputEventScreenTouch:
        if event.pressed:
            touch_start = event.position  # finger went down
        else:
            var move: Vector2 = event.position - touch_start
            if move.length() < MIN_SWIPE:
                print("Tap at ", event.position)
            elif absf(move.x) > absf(move.y):
                print("Swipe ", "right" if move.x > 0 else "left")
            else:
                print("Swipe ", "down" if move.y > 0 else "up")

Each finger has its own number in event.index, so you can track two thumbs at once. Remember that a finger covers part of the screen. Keep important action away from where thumbs rest.

Screen sizes, notches and safe areas

Phones come in many shapes. Most are taller than the classic 9:16 shape of a 720 by 1280 project. With the expand setting, nothing gets cut off: taller phones simply see more of your game world. The extra space appears below your 720 by 1280 area. If a Camera2D follows the action, it is split between the top and the bottom instead. Either way, let your background art continue past the edges.

The safe area is the part of the screen that no notch, camera hole, rounded corner or home bar covers. Godot reports it with DisplayServer.get_display_safe_area(). Put your HUD inside a MarginContainer, set its anchor preset to Full Rect so it fills the screen, and give it this script:

extends MarginContainer

func _ready() -> void:
    var safe := DisplayServer.get_display_safe_area()
    var window := Vector2(DisplayServer.window_get_size())
    # Convert phone pixels into your 720 x 1280 game pixels.
    var ratio := get_viewport_rect().size / window
    var top := safe.position.y * ratio.y
    var bottom := (window.y - safe.end.y) * ratio.y
    add_theme_constant_override("margin_top", int(top))
    add_theme_constant_override("margin_bottom", int(bottom))

For landscape games, add margin_left and margin_right the same way. Inside the container, use anchors to pin buttons to corners: select a Control node and pick a corner from the anchor presets button in the toolbar above the viewport.

Set up Android export

You do this setup once per computer. It is the longest part, but Godot tells you in red text what is still missing.

1. Install Java. Godot's Exporting for Android page recommends OpenJDK 17.
2. Install the Android SDK, the toolkit Google provides for building Android apps. The easiest way is Android Studio. Open its SDK Manager and install the parts that Godot's page lists, in the versions it names: Platform-Tools, Build-Tools, an Android SDK Platform, Command-line Tools, CMake and the NDK.
3. Tell Godot where they are. Open Editor > Editor Settings, find Export > Android, and set Java SDK Path and Android SDK Path.
4. Install the export templates. In Editor > Manage Export Templates, install the Android templates.
5. Add the Android preset. Open Project > Export, click Add... and choose Android. Under Package, set Unique Name to something like com.yourname.coinjumper, using only lowercase letters, numbers and dots.

Android only installs apps that are signed, which means stamped with a digital key that proves who built them. For test builds, Godot creates a debug keystore (a file holding a test key) for you once the Java SDK path is set.

Test on your own phone

1. Turn on developer mode. On the phone, open Settings > About phone and tap Build number seven times. Then turn on USB debugging in the new Developer options menu. Menu names vary a little between brands.
2. Connect the phone with a USB cable and accept the "Allow USB debugging?" message on its screen.
3. Mark the preset as Runnable. Tick Runnable on your Android preset in the export window.
4. Click the Android icon. It appears in the top-right corner of the editor, next to the run buttons. Godot builds the game, installs it and starts it on the phone. Your print() messages and errors appear in Godot's Output and Debugger.

This one-click deploy uses ADB, Android's developer tool. Google is rolling out developer verification for Android apps. It started on 30 September 2026 for apps from some app stores in Brazil, Indonesia, Singapore and Thailand, and it goes worldwide in 2027. Google says installing your own builds with ADB keeps working without it. If you want to send test builds to friends' phones, check Google's current rules with a parent first.

Build an AAB for Google Play

Google Play wants an Android App Bundle (an .aab file), not an APK. Godot makes one with a Gradle build, which compiles a fresh Android project for your game.

1. Install the build template. Choose Project > Install Android Build Template. Godot adds an android folder to your project. Leave it there.
2. Switch the preset to Gradle. In the Android preset, turn on Use Gradle Build and set Export Format to AAB.
3. Create a release keystore. The keytool program comes with Java. Open a terminal (Command Prompt on Windows) in the folder where the file should go and run the command below.

keytool -genkey -keystore game.jks -alias game -keyalg RSA -validity 10000

It asks for a password, then for a name and other details, which you can skip with Enter. Type yes to confirm at the end. If the terminal cannot find keytool, type its full path instead: it sits in the bin folder of your Java installation.

4. Fill in the keystore fields. In the preset, set Release to the game.jks file, Release User to the alias (game) and Release Password to your password. Godot's docs say the keystore and key passwords must currently be the same.
5. Set the version. Raise Version > Code by one for every upload. Google Play rejects a code it has already seen.
6. Export without debug. Click Export Project and untick Export With Debug.

As of November 2026, a Google Play developer account costs a one-time US$25 and its owner must be at least 18, so a parent or guardian has to own it. New personal accounts must run a closed test with at least 12 testers for 14 days in a row before the game can go public. Since 31 August 2026, new apps and updates must also target Android 16 (API level 36), which means they are built for that Android version. Godot 4.7 already targets API level 36 by default, so leave the preset's Target SDK field empty unless a newer rule needs a higher number. Rules change often; see Google's page on testing requirements for new personal accounts and our guide on how to publish a game on Google Play.

Export for iPhone and iPad

Apple's build tool, Xcode, only runs on macOS. So you need a Mac for the last step, even if you make the game on Windows. Godot turns your game into an Xcode project, and Xcode builds the app. Godot's Exporting for iOS page has the details.

1. Set up the Mac. Install Xcode from the Mac App Store and open your Godot project on the Mac. Install the iOS export templates.
2. Add the iOS preset. In Project > Export, add iOS. Fill in App Store Team ID, the 10-character code from your Apple developer account, and a Bundle Identifier like com.yourname.coinjumper.
3. Export the Xcode project into an empty folder.
4. Run it on your iPhone. Open the .xcodeproj file in Xcode, connect the iPhone, pick it as the target and press Run. On the iPhone, turn on Developer Mode under Settings > Privacy & Security when asked.

With a free Apple Account, Xcode can install the game on up to three of your own devices, but the app stops opening after seven days until you rebuild it. Publishing on the App Store needs the Apple Developer Program, which costs 99 USD a year as of November 2026 and must be joined by an adult. Apple's membership comparison lists the limits, and our guide on publishing on the App Store covers TestFlight (Apple's beta-testing app) and App Review. After the first Xcode build, Godot's one-click deploy can also install new versions on a connected iPhone.

Make it run smoothly on phones

• Test on a cheap or old phone. If it runs well there, it runs well almost everywhere.
• Watch the numbers. During one-click deploy, the Debugger's Monitors and Profiler tabs show live frame rate and memory from the phone.
• Keep images small. A 64-pixel coin does not need a 2048-pixel picture. Big textures eat memory and make downloads larger.
• Go easy on effects. Many lights, particles and full-screen shaders slow phones down and drain the battery.
• Cap the frame rate. Set Application > Run > Max FPS to 60 in Project Settings (with Advanced Settings on). Some phones redraw 120 times a second, which a calm puzzle game does not need.
• Pause in the background. When the player switches apps, pause the game. Add this function to the script on your main scene's root node:

func _notification(what: int) -> void:
    # The player switched apps or locked the phone.
    if what == NOTIFICATION_APPLICATION_PAUSED:
        get_tree().paused = true  # then show your pause menu

Set your pause menu's Process > Mode to When Paused in the Inspector, or it freezes along with the game. Save progress to a file in user://, a folder that stays safe between updates. Finally, play for 15 minutes straight. If the phone gets hot, lower the frame rate or cut effects.

When your game is ready, see how other developers present theirs among the Godot games and indie mobile games on Mutop100.