Get Started with Unity and Google Play Games for PC

1. Introduction

Google Play Games logo

Last Updated: 2022-04-25

How do you prepare your game for Google Play Games on PC?

Google Play Games makes it easy to bring your mobile game to Windows PCs. This means that you can grow your player engagement and your audience without having to rearchitect your game or redesign your business model. There are still a few changes that you have to make to give your new PC players the best possible experience.

What you'll learn

This codelab covers the base portions of the requirements checklist to get your game off the ground, and help you prepare your own Unity game for Google Play Games on PC. More in-depth integrations, such as Play Games Sign-On, and the Play Integrity API, are not covered..

  • How to build for the x86 architecture from Unity.
  • How to test and deploy to the Google Play Games emulator.
  • How to modify your user interface to look great on a PC.
  • How to detect if you're running in the Google Play Games emulator, and adapt your game accordingly.

What you'll need

2. Get set up

Open or create a new project

  1. Create a new project using the 2D Platformer Microgame, or open up your own project.

The Unity "new project" screen  The "2D Platformer Microgame" is selected as the template to create.

  1. From the project, select File -> Build Settings and check that you are set up to build for Android.

A screenshot of the Unity "Build Settings" window  The "Android" platform is active.

3. Prepare the Google Play Games emulator

Start by downloading the emulator from this page. If you don't see a download link, check that you're logged in with an account that has been added to the play-mp-emu group. Members of this group are notified when updates to the emulator are available, so make sure that you can receive emails from

After installing it, you should see an Android desktop in a window:

Screenshot of the Google Play Games emulator window  The Android home screen is visible.

This is a fully-featured high-performance Android environment suitable for game development. It should show up in Android Debug Bridge (adb) as a device on localhost:

❯ adb devices
List of devices attached
localhost:6520  device

You need a recent version of adb to detect the emulator. The version bundled with Android Studio works, but adb as shipped with Unity may not. A compatible version is bundled with the emulator, and you can find it at C:\Program Files\Google\HPE_Dev\emulator. For the best developer experience, you may want to install Android Studio and use it to manage your Android SDK.

If the emulator disconnects from adb, reconnect it from the command line like this:

adb connect localhost:6520

4. Configure Unity to build and deploy to the emulator directly (Optional)

The version of adb shipped with Unity may not be compatible with the emulator. To make sure, select File -> Build Settings and check the Run Device dialog to see if it's listed.

Run Device in the "Build Settings" window  The "Run Device" is selected, the only visible elements are "Default device" and "All compatible devices".

Depending on your project, build process, and comfort level, you may opt to either configure Unity to deploy to the Google Play Games emulator directly, or build an APK and deploy it manually with adb install. To deploy it manually requires the fewest changes, but may slow down your iteration cycle.

Deploy to the emulator directly with these two steps:

  1. Configure Unity to use another Unity SDK, ideally the one installed by Android Studio.
  2. Update the Build Tools version to work around a bug in Unity.

Because the version of the Android SDK shipped with Unity probably won't detect the emulator, you use Android Studio to install a more recent SDK.

  1. Open Android Studio and select Edit -> Preferences -> External Tools.
  2. Uncheck Android SDK Tools Installed with Unity, and provide the path to your Android Studio's installation (usually AppData/Local/Android/sdk). Leave the Android NDK option alone.

Screenshot of "External Tools" from the "Preferences" window

when you refresh the connected devices, you should see Google HPE device (localhost:6520) appear in the build window:

Screenshot of the "Build Settings" window  The "Run Device" "Google HPE" is visible.

Depending on the state of this bug and your Unity version, you may also need to change your build tools version. To do this, check that you're generating a mainTemplate.gradle and launcherTemplate.gradle.

  1. Open the Project Settings window to Player Settings and locate the Publishing Settings section.
  2. SScroll down to the Build options and check "Custom Main Gradle Template" and "Custom Launcher Gradle Template", which will generate both Gradle files under Assets\Plugins\Android\.

Screenshot of the "Player" section in the "Project Settings" window.  The checkboxes for "Custom Main Gradle Template" and "Custom Launcher Gradle Template" are both checked.

  1. Replace any instance of the string **BUILDTOOLS** with 30.0.0. In both files, the section of code should now read:
android {
    compileSdkVersion **APIVERSION**
    buildToolsVersion '30.0.0'

5. Deploy to a Chromebook (optional)

You can start developing games for Google Play Games without access to the Google Play Games emulator by using a ChromeOS device. Much like Google Play Games on PC, Chromebooks have keyboards and mice, have large screens, and are available in x86 configurations. We'll use the Android Logcat Unity plugin with the Chromebook..

  1. Open the Package Manager and search for Android Logcat under Unity Registry.

Package Manager window with "Android Logcat" selected to be installed.

You also need to configure your Chromebook for Android development. Start by enabling Linux.

  1. Select Settings -> Developer -> Linux.

Animated image showing how to enable Linux support.  Developer is selected in the Settings window. Then "Turn On" is clicked from "Linux development environment"

Then enable ADB debugging.

  1. Select Settings -> Developers -> Linux development environment -> Develop Android apps -> Enable ADB debugging.

ADB debugging is enabled from the Developer menu.

You'll also want to get your Chromebook's IP address. The easiest way to do this is to

  1. Click the Network Info icon to get your Chromebook's IP address.

Screenshot of the network window open on a Chromebook.

The network info button is clicked, showing the IP address.

  1. Select Window -> Analysis -> Android Logcat to open the Android Logcat window.

Window>Analysis open in Unity with "Android Logcat" selected.

  1. Open the device list It may read No Device if nothing is currently connected.

Android Logcat window shown, device dropdown selected.

  1. Click Other connection options and enter your Chromebook's IP address.

Other Connections window open. An IP address is entered.

  1. Click Connect. You should see a Success window:

A dialog box saying "Success" is open.

Your Chromebook now appears in Unity's Run Device list (you may have to refresh the screen first):

The Unity "Build Settings" window is open. The ChromeOS device is shown under the "Run Device" dropdown.

You can now deploy games to your Chromebook and begin testing and development on PC-like hardware.

6. Deploy a test build

Google Play Games requires that you deploy an x86 version of your game, which is part of how it reaches its performance benchmarks on desktop PCs. All LTS variants of Unity can generate x86 and x86-64 compatible Android builds (labeled "Chrome OS"), and Unity version 2018 and earlier can generate x86 builds. To unlock these architectures, you first need to switch to the IL2CPP scripting backend, which you likely already do in production for arm64 support.

  1. Select File -> Build Settings to open the Build Settings window, and then click Player Settings.

Screenshot of the "Build Settings" window focused on the "Player Settings" button.

  1. Navigate to the Other Settings section and switch your Scripting Backend to IL2CPP.

Screenshot of the "Other Settings" section of "Player Settings"

You should also enable x86 or x86-64 support. To ship on the Google Play Games platform you only need to support x86, although we recommend x86-64.

Screenshot of the Configuration section of Player Settings  "Scripting Backend" is set to "IL2CPP" Target Architectures has "x86 (Chrome OS)" selected and "x86-64 (Chrome OS)" highlighted.

The version of the Frame Pacing library Unity bundles is also incompatible with Google Play Games, and causes your game to crash on launch.

  1. To disable Frame Pacing from the Player Settings window open the Resolution and Presentation section and uncheck Optimized Frame Pacing.

Screenshot "Resolution and Presentation" with "Optimized Frame Pacing' unchecked

You're now ready to build!

  1. Open the Build Settings window again and click Build And Run. Your game appears in the emulator window.

Screenshot of the Google Play Games emulator with the "2D Platformer Microgame" running

If you're not able to deploy your game, check to see if "Google HPE device (localhost:6520)" shows up in your "Run Device" list. If it's missing, ensure that HPE_Dev is running and you can see the Android home screen. If it's still not appearing in your device list, run adb connect localhost:6520 with the exact adb.exe you're using. If you use the Android Logcat Unity plugin, select Tools -> Open Terminal to open a terminal to the directory with the same adb.exe Unity is using.

Screenshot of the "Android Logcat" Unity window with "Tools>Open Terminal" highlighted

7. Adapt your game for PC

When possible, try to make any changes to your game based on platform-agnostic metrics, or the presence of certain features. For example, a player on Android can hook up a mouse and keyboard or plug in a monitor, so changing your control scheme or HUD elements in reaction to your device configuration lets you leverage Google Play Games on PC work across all your supported platforms.

If it makes sense to change logic based on whether or not the player is in Google Play Games or ChromeOS, this script helps you detect it by checking for the HPE_EXPERIENCE system feature:

using UnityEngine;

public class GoogleDeviceUtilities
    private static AndroidJavaObject PackageManager
            var unityPlayerClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            var currentActivity = unityPlayerClass.GetStatic<AndroidJavaObject>("currentActivity");
            return currentActivity.Call<AndroidJavaObject>("getPackageManager");

    public static bool IsChromeOS => PackageManager.Call<bool>("hasSystemFeature", "org.chromium.arc");

    public static bool IsGooglePlayGames =>
        PackageManager.Call<bool>("hasSystemFeature", "");

    public static bool HasKeyboard
            var unityPlayerClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            var currentActivity = unityPlayerClass.GetStatic<AndroidJavaObject>("currentActivity");
            var resources = currentActivity.Call<AndroidJavaObject>("getResources");
            var configuration = resources.Call<AndroidJavaObject>("getConfiguration");
            var keyboard = configuration.Get<int>("keyboard");
            return keyboard == 2; // Configuration.KEYBOARD_QWERTY
    public static bool IsChromeOS => false;
    public static bool IsGooglePlayGames => false;
    public static bool HasKeyboard => true;

PCs have a larger display than the typical Android phone. When possible, we recommend that your HUD takes up no more than 20% of the screen. Since many mobile games use "Scale With Screen Size", changing this to "Constant Physical Size" or "Constant Pixel Size" can be a good first step towards achieving this goal.

Screenshot of the "Canvas Scaler" inspector with "UI Scale Modes" listed  Scale modes visible are "Constant Pixel Size", "Scale With Screen Size", and "Constant Physical Size". "Constant Pixel Size" is selected.

You may also want to dynamically set the quality settings using the QualitySettings.SetQualityLevel command at runtime if you detect that you're running in Google Play Games. The Google Play Games emulator uses ANGLE to issue native DirectX or Vulkan commands from the OpenGL Unity emits, so you can likely achieve a higher graphics fidelity than was available on your mobile game builds.

8. Input handling

Games shipping on Google Play Games should be built around mouse and keyboard input. You will need to plan how to interact with your game with a mouse and keyboard, so take the time now to acquire the Input SDK unitypackage. If you don't see a download on that page, make sure that you are signed in with an account in the play-mp-libs group.

For testing purposes, many games build basic mouse and keyboard controls for development in the editor. When possible, you may want to enable these when you're running on a ChromeOS device or in the Google Play Games emulator.

By default, Google Play Games and ChromeOS convert mouse input into a simulated touch. If you use Input.GetTouch and Input.touchCount, your game continues to work as expected. If you rely on multi-touch input, such as dual thumb controls or pinch to zoom, you need to map the action to key presses. You should also map in-game actions to key presses, such as pressing i to open your inventory, escape to close dialog boxes, and enter to send in-game messages.

The 2D Platformer Microgame uses the arrows to move, and space to jump. If you're using your own game, make sure you have your preferred key bindings for the next step.

9. Input SDK integration

Now that you have your mouse and keyboard controls set up, you need to add Input SDK support. This helps players discover your PC inputs with a handy popover:

  1. After importing the SDK into your project, create a file named InputMappingProviderBehaviour.cs and add these contents:
using System.Collections.Generic;
using Google.Play.InputMapping;
using UnityEngine;
using Input = Google.Play.InputMapping.Input;

public class InputMappingProviderBehaviour : MonoBehaviour
    private void Start()
        Input.GetInputMappingClient().RegisterInputMappingProvider(new MyInputMappingProvider());

    private class MyInputMappingProvider : InputMappingProvider
        public InputMap OnProvideInputMap()
            return new InputMap
                InputGroups = new List<InputGroup> { },
                MouseSettings = new MouseSettings
                    InvertMouseMovement = false,
                    AllowMouseSensitivityAdjustment = false

    private enum ActionIds
  1. Now fill ActionIds with the list of actions you're using in your game. For the 2D Platformer Microgame, the actions are Left, Right, and Jump:
private enum ActionIds
  1. In OnProvideInputMap, create an InputAction for each action. For this you need the name of the action, the input, and then the mouse buttons or keycodes that will be bound to it. For the sample game:
var leftAction = new InputAction
    ActionLabel = "Walk Left",
    UniqueId = (int)ActionIds.Left,
    InputControls = new InputControls
        AndroidKeycodes = new[]

var rightAction = new InputAction
    ActionLabel = "Walk Right",
    UniqueId = (int)ActionIds.Right,
    InputControls = new InputControls
        AndroidKeycodes = new[]

var jumpAction = new InputAction
    ActionLabel = "Jump",
    UniqueId = (int)ActionIds.Jump,
    InputControls = new InputControls
        AndroidKeycodes = new[]
  1. Next, put these input actions into groups.

For the microgame we only have one group, but you can create as many as you need to help your players find the actions they need. Add this to the OnProvideInputMap:

var movementInputGroup = new InputGroup
    GroupLabel = "Movement",
    InputActions = new List<InputAction>
        leftAction, rightAction, jumpAction
  1. Add all the input groups you've created to the input map. Modify the return statement in OnProvideInputMap to read:
return new InputMap
    InputGroups = new List<InputGroup> { movementInputGroup },
    MouseSettings = new MouseSettings
        InvertMouseMovement = false,
        AllowMouseSensitivityAdjustment = false
  1. Finally, add the script you created into your game:

Screenshot of a node named "InputSdk" with "Input Mapping Provider Behaviour" attached

  1. When you deploy your game again, press Shift+Tab to open the in-game overlay.

Screenshot of the "Game options" overlay in the Google Play Games emulator

  1. Click Controls to see the controls you've configured.

Screenshot of the "Controls" overlay in the Google Play Games emulator

10. Remove ads and embedded web views

While we won't cover all of the logic that needs to be updated, there are two items that you can address immediately to both make it through app approval, and give your players a great experience.

First, it's common to use embedded web views for displaying items like your Privacy Policy or Terms of Service. Although these work in Google Play Games, they show up in an embedded "mobile" browser, rather than the player's preferred desktop browser, and may cause some confusion for PC players. Therefore in Unity, if you're using any extensions to show an embedded browser, fall back to Application.OpenURL(url).

Second, ads are not currently permitted in Google Play Games, although you can leave your Ads SDKs in for your mobile and ChromeOS players. Use GoogleDeviceUtilities.IsGooglePlayGames to determine whether or not you should include in-game advertisements. Other payment-related APIs, such as Google Pay, will work as expected.

11. Permissions and features

There are a number of Android features and permissions that are unsupported in Google Play Games. A general rule of thumb is that your PC build should never pop up a permissions dialog. A good thing to do, now that you have your build ready, is go through a typical new install and write down any dialogs you see to add to your "todo" list for submitting your game.

Some Unity games request permissions using the Android.Permission API. You should wrap these in if (GoogleDeviceUtilities.IsGooglePlayGames) checks and go directly to your failure logic if applicable.

12. Desktop optimizations

Google Play Games has a few differences when compared to a typical Android phone, and you may want to configure your game accordingly.

Switch to DXT for texture compression. Common Android texture formats such as ETC are decoded in memory at runtime if they can't be passed through to a player's GPU directly. ASTC gives you the best desktop compatibility, although you need to use a desktop GPU profiling tool in order to verify expected behavior for your game.

The Unity "Build Settings" window open with "Texture Compression" expanded. "DXT (Tegra)" is the highlighted texture compression override.

Since you're running on a desktop GPU now, you may also want to increase your graphics quality. You can adjust it directly in your Project Settings under Quality

Screenshot of the "Quality" section of "Project Settings"

13. Congratulations

You have everything in place to start working on your game for Google Play Games. You can begin testing and iterating on your game. Remember that even though you can keep your same code base, you will want to adapt your game to feel like a native PC game.

What's next?

There is more work to be done to ship a game on Google Play Games:

Finally, much of the work you've done to this point for supporting Google Play Games also helps you ship on ChromeOS, and you should consider supporting that platform along with PC.