How to Make a Mobile Game in Unity: A Complete Guide

Highlights

• Unity powers over 50% of all mobile games and 71% of the top 1K titles, making it the obvious starting point for any mobile developer.
• Most beginners build first and configure platform settings last, a mistake this guide fixes by walking through every layer in the right order.
• Touch controls, performance, and store compliance are what separate games that ship and earn over those that stall at submission.

Unity powers more than 50% of all mobile games worldwide, with its share of the mobile game engine market projected to reach 55% to 60% by 2026. For anyone building a Unity mobile game, whether as a first project or a commercial release, the same development layers apply: input, monetization, performance, and store submission.

This mobile game tutorial walks through each layer in order, from the decisions a beginner needs to make on day one to the compliance requirements a professional cannot afford to miss before launch.

Why Unity Dominates Mobile and Why it Should be Your Starting Point

The case for Unity as your mobile development engine is straightforward:

• Unity supports over 20 platforms from a single codebase, with no upfront cost on its free Personal tier.
• Mobile and console gaming account for 84% of all revenue in the industry, dwarfing what PC and other platforms generate.
• Unity demonstrates significant dominance in the mobile game sector, powering 71% of the top 1K mobile games.
• Unity's mobile tooling, profiler suite, and monetization integrations are built around mobile constraints first, which means less time fighting the engine and more time building the game.

That consensus is why developers from indie teams to mid-size studios continue to choose Unity Android and Unity iOS development over alternatives, even as competitors like Unreal Engine grow stronger on console and PC.

Setting Up Your Unity Mobile Game Project the Right Way

Most beginners make the same mistake: they build the game first and configure platform settings last. Do the opposite.

The moment you create a project in Unity Hub, switch the platform to Android or iOS in File > Build Settings before writing a single line of code. Platform-specific texture compression, audio encoding, and import settings all apply at this stage. Changing platforms late rewrites asset metadata across the entire project, wasting days of iteration time.

From Player Settings, configure the following before anything else:

• Set your bundle identifier. For example, com.studio.mygame.
• For Unity Android, target at least Android 14 (API Level 34), which Google Play has required for all new submissions since August 2024.
• Switch the scripting backend from Mono to IL2CPP and enable ARM64 architecture. IL2CPP converts managed code to native C++ at build time, improving runtime performance on real devices.
• Use the 2D or Universal Render Pipeline (URP) mobile template. URP gives you scriptable render passes and better per-platform shader control without the overhead of Unity's High Definition Render Pipeline.

How to Build Touch Controls for Unity Android and Unity iOS

Touch input is where mobile games win or lose players in the first thirty seconds.

Unity's New Input System is built from the ground up with modern game development in mind. It decouples input actions from physical devices, so you can define an action like "Jump" and map it to a touchscreen tap, a gamepad button, or a tilt of the phone, all without duplicating code. It is event-driven, meaning your game reacts when input happens rather than constantly checking if a button is pressed, which is far more efficient and produces more responsive controls.

Steps to set up touch controls in this mobile game tutorial:

1. Install the New Input System package from Package Manager (com.unity.inputsystem).
2. Replace the standalone input module on your event system with the input system user interface (UI) input module.
3. Create an Input Actions asset, add an action map called Player, and define a Movement action with action type set to Value and control type set to Vector2.
4. Add an On-Screen Stick component to your joystick canvas image and set its control path to match the movement action.
5. For gesture recognition, enable EnhancedTouchSupport.Enable() at startup and read EnhancedTouch.Touch.activeTouches each frame. Differentiate a tap from a swipe by measuring the delta position over a time threshold.
6. For accelerometer input, retrieve the device's linear acceleration changes along three axes as G-force values using the Input.acceleration property. Map X and Y to a movement action and apply low-pass filtering in code to reduce signal noise before it reaches gameplay logic.

Always provide an on-screen alternative for players whose devices lack gyroscopes or who prefer not to use motion controls.

How to Optimize Performance: The Middle Layer That Determines Store Ratings

A Unity mobile game with poor performance will not survive store reviews, regardless of how good the gameplay is. The median Unity build size has grown 67% over three years to 167 megabytes. Players on budget Android devices expect smooth performance and minimal battery drain, even on that hardware.

Essential performance rules to follow from day one:

• Mobile projects must balance frame rates against battery life and thermal throttling. Instead of pushing the limits of your device at 60 frames per second (FPS), consider running at 30 FPS as a compromise. Set Application.targetFrameRate to 30 and QualitySettings.vSyncCount to 0 in a bootstrap script.
• Use Unity Profiler in Deep Profile mode to identify CPU bottlenecks in scripts.
• Use Memory Profiler to track allocation patterns and eliminate garbage collection spikes that cause frame stutters.
• Replace Instantiate and Destroy calls for frequently spawned objects with an object pool.
• Use ASTC texture compression for both Unity Android and Unity iOS builds.
• Run a build report before submission to find the largest asset contributors, then move post-launch content into Addressables to keep the initial download lean.

Unity Mobile Game Monetization: Ad Mediation and In-App Purchases

Monetization infrastructure wired in before soft launch consistently outperforms code added after release. Two systems need to be in place.

For ad mediation, Google AdMob and ironSource (now Unity LevelPlay) are the dominant platforms for a Unity mobile game.

Steps to connect them:

1. Create an AdMob account and register your app separately for Android and iOS.
2. Import the Google Mobile Ads Unity Plugin via Package Manager.
3. In AdMob, create a Mediation Group for your ad format and add ironSource as a bidding ad source.
4. On the ironSource side, configure settings in the ironSource Ads UI, add ironSource Mobile to AdMob's ad partners list, and import the ironSource Ads SDK and adapter into your Unity project. Install via OpenUPM: openupm add com.google.ads.mobile.mediation.ironsource.
5. Implement the General Data Protection Regulation (GDPR) and US state privacy consent before initializing either software development kit (SDK).
6. Test only with test ad unit IDs until the release binary is final, then disable test mode before building for submission.

For in-app purchases, use Unity in-app purchase (IAP) (com.unity.purchasing). A compliance point that beginners regularly miss: as of August 31, 2025, Google Play requires Billing Library version 7.0.0 or newer, and Unity IAP version 5.0.0, released August 7, 2025, ships with Billing Library 8.0.0. Projects still on Unity IAP 4.x will have updates rejected.

Additionally, the IAP setup steps are:

• Define products in a singleton IAPManager.
• Match product IDs exactly between Unity, the Play Console, and App Store Connect.
• Validate receipts server-side against Google's Developer API or Apple's App Store Server API before delivering any durable goods to the player.

Submitting Your Game to Google Play and the App Store

For Unity Android:

• A Google Play Developer account costs a one-time $25 USD fee.
• New individual developers must complete a testing period with 20 real users over 14 consecutive days before officially publishing their apps. Plan this into your launch schedule.
• Google Play requires new applications to be an Android App Bundle (AAB) instead of an APK. In Build Settings, enable Build App Bundle (Google Play) and disable Development Build before exporting.
• Upload to the Internal Testing track, run the testing window, then promote to Production.
• Complete the Data Safety form, disclosing which SDKs collect user data, and include a privacy policy uniform resource locator (URL).

For Unity iOS:

• Apple Developer Program membership costs $99 per year.
• Unity's iOS build generates an Xcode project. Archive it in Xcode and use TestFlight for beta testing before final submission.
• Apple charges a 15% to 30% commission on in-app purchases, with the 15% rate applying to developers earning under $1M annually through the Small Business Program.
• Review typically takes one to three days, but incomplete metadata or inaccurate privacy disclosures extend that significantly.

On App Store Optimization:

• Google Play caps titles at 30 characters and short descriptions at 80 characters. Front-load your primary keyword in the title because Google indexes it directly for search ranking.
• Apple does not index the full description, so use the dedicated 100-character keyword field for terms not already in your title.
• Complete the International Age Rating Coalition (IARC) content rating questionnaire accurately. Misrepresented ratings result in removal.

The Professional Mindset: Build in Order, Profile Continuously, Ship Compliant

The developers who ship consistently are not the ones with the most creative ideas. They are the ones who treat every layer, input, performance, monetization, and store compliance as a release requirement rather than an afterthought. Unity gives you the engine. This mobile game tutorial gives you the order.

Start a small project, profile it on a real device, integrate monetization before soft launch, and follow the submission steps for both Unity Android and Unity iOS without skipping compliance documentation.

That sequence, repeated across projects, is what turns a beginner into a professional.