Executive Summary
Use Unity when your business application needs interactive 3D content, or Android Studio when it needs a native Android interface. Setup is complete when the required tools are installed, the project passes its configuration checks and your test device or emulator is available.
These instructions follow the official Android XR documentation. Check Aura-specific development ports, firmware menus and permissions against the onboarding instructions supplied with your unit. This guide does not claim physical testing on Aura.
Choose Your Development Route
Choose Unity if your project will use 3D models, interactive training or simulation, or if your developers already work with Unity and C#. Unity gives you a visual workspace for arranging content and configuring XR features. You can set up the environment without writing code or building a prototype.
Choose Android Studio if you are extending an Android business application or creating native interfaces such as work instructions, forms or task panels. It uses Kotlin and Google’s Jetpack XR libraries. Either route can later connect to business systems through an API, a defined way for software to exchange information. Base your choice on the application interface and your team’s skills.
Main development editor:
- Unity route: Unity Editor, installed through Unity Hub
- Android Studio route: Android Studio
Language for later development:
- Unity route: C#
- Android Studio route: Kotlin
Android build tools:
- Unity route: Android Build Support, including SDK, NDK and OpenJDK
- Android Studio route: Android SDK tools, installed through SDK Manager
Core XR support:
- Unity route: OpenXR Plugin, installed through Unity Package Manager
- Android Studio route: Jetpack XR SDK libraries, downloaded through Gradle
Platform-specific XR support:
- Unity route: Unity OpenXR: Android XR package
- Android Studio route: XR project template and required Jetpack XR libraries
What the XR tools mean:
- Unity route: OpenXR is a common interface between an XR app and its device runtime, the system software that runs XR features
- Android Studio route: Jetpack XR SDK is Google’s collection of libraries for native spatial interfaces and XR features
Connection and diagnostics:
- Unity route: ADB, the Android Debug Bridge tool
- Android Studio route: ADB and Android Studio Logcat, which displays diagnostic messages
Prepare Your Workstation and Development Access
Prepare a supported development computer, reliable internet access for downloading dependencies, an approved company project folder and a USB data cable. Emulator requirements differ from editor requirements, so check Google’s XR emulator hardware page before relying on a virtual device. A virtual device is a software simulation of an Android device. [4]
Use an Aura unit with authorized developer access, its supplied glasses connection and the development connection documented by XREAL. Confirm regional supply and kit onboarding before committing to a workshop date. Current XREAL pages and regional pages may differ on availability, and a product listing alone does not establish delivery timing. [1]
For business work, confirm your organization’s Unity license eligibility and any relevant Industry terms before using Unity commercially. Use company-controlled source control, approved package sources and test data. Android Studio and Unity are development tools for professional applications; installing them does not establish enterprise management support on Aura.
Route A: Set Up the Unity Development Environment
This route installs Unity and its Android tools, creates an empty project and enables Android XR support. It prepares the workspace for later development.
Step 1 | Install the Unity Editor
Unity Hub manages your editor installations. The Unity Editor is the workspace where you configure projects and later develop your application.
Install Unity Hub from Unity’s official website and open it. Go to Installs, then Install Editor. To get full support for puck trackpad input and other features, choose a supported Unity 6.5 (or newer) release that is compatible with the Android XR package you will use. Google’s setup page currently specifies 6000.0.58f2 or higher; newer package requirements also apply. [5]
Step 2 | Add the Android Build Tools
These modules allow Unity to turn your project into an Android application.
XREAL Aura runs Android XR, so it needs an Android application that its operating system can install and run. Your Unity project contains editable files for development. The Android build tools package and compile those files into an installable app, usually an APK for device testing.
In the installation modules, select Android Build Support and its sub-items, then click Continue and complete the installation prompts. The tools to install are:
· Android SDK (Software Development Kit)
· Android NDK (Native Development Kit): Turns lower-level code into a form that the device’s processor can run.
· JDK (Java Development Kit)
For an existing editor, return to Unity Hub > Installs, open the editor’s menu, choose Add modules, select the same items and then click Installs.
Step 3 | Create a Project
An empty project gives you a place to configure the Android XR development environment.
In Unity Hub, open Projects > New project. Select the installed editor and choose Universal 3D. Name the project AuraDevelopmentSetup, choose a folder and select Create project. Universal 3D uses URP, the Universal Render Pipeline that draws your application’s graphics.
Step 4 | Check the Tool Paths
Unity needs to know where its compatible Android build tools are installed.
In the Unity Editor, open Edit > Preferences > External Tools (Unity > Settings or Preferences on macOS). Keep Unity’s supplied SDK (Android platform tools), NDK (native-code compiler tools) and JDK (Java build tools) selected. These versions are matched to your Unity Editor, which helps avoid build errors. Do not replace them with unrelated Android Studio tool versions just because both are installed.
Configure Your XREAL Aura Development Environment in Unity
OpenXR is an open standard that helps XR applications communicate with compatible device runtimes. In Unity, use OpenXR Plugin for the core connection and Unity OpenXR: Android XR for Android XR support, both installed through Package Manager. AR Foundation is Unity’s common interface for supported AR features, such as environment understanding.
Step 1 | Select the Android XR Build Target
The build target tells Unity which platform the application must run on.
Open File > Build Profiles. In Unity 6.1 or newer, add or select the Android XR platform profile and switch to it. According to Unity’s documentation, this can install the compatible Android XR package automatically. If your supported editor uses the Android platform instead, select Android and configure OpenXR manually. [7]
Step 2 | Install the OpenXR Packages
Packages add the software components that connect your Unity scene to Android XR.
Open Window > Package Management > Package Manager, or Window > Package Manager in editors with the older menu layout. Check that OpenXR Plugin and Unity OpenXR: Android XR are installed. If the Android XR package is missing, use the plus menu > Add package by name and enter com.unity.xr.androidxr-openxr. The core OpenXR package identifier is com.unity.xr.openxr. Let Package Manager resolve compatible dependencies. [6]
Step 3 | Enable the XR Provider
Installing a package makes it available; enabling the provider allows the application to use it.
Open Edit > Project Settings > XR Plug-in Management. On the Android tab, enable OpenXR. Open the OpenXR section below it and enable the Android XR feature group. Enable Android XR: Session when using AR Foundation features. Enable Android XR: AR Session for version 1.0. Avoid enabling unrelated providers for this build. [8]
Step 4 | Validate the Project
Validation identifies settings that would prevent a supported XR build.
Open XR Plug-in Management > Project Validation and select Android. Review and resolve the required issues, then check again. Package-specific validation requirements take priority over settings copied from an older tutorial.
Step 5 | Keep Input Requirements Simple
Only enable features that your planned application requires and that the target device supports.
Leave optional input features for the application development stage unless your project or template requires them. Enabling an eye gaze or controller profile does not add that hardware to Aura. Review any required interaction settings in Project Validation before continuing.
Google’s Android XR Extensions for Unity is an additional package with extra features. It is separate from Unity OpenXR: Android XR. You do not need to add it just because the names sound similar. Add it when your application needs a feature it provides. [9]
Check Rendering and Android Build Settings
Vulkan is the graphics interface used to send rendering work to the GPU. In Edit > Project Settings > Player, select Android > Other Settings. If Auto Graphics API is enabled, clear it and place Vulkan first. For a simple URP baseline, disable HDR in the URP asset and post-processing in its renderer asset. Google recommends these settings for Android XR. [5]
In the same Player settings, set a unique package identifier such as com.yourcompany.aurapilot. Under Configuration, select IL2CPP and ARM64 for the physical device build. IL2CPP converts C# code into native code, and ARM64 is the processor architecture the build targets. Check the installed package validation and device requirements for any additional constraints.
Google lists API 24 as the OpenXR loader minimum, not as Aura’s operating system version. Use a minimum API level that also satisfies every installed package, and an installed target SDK supported by your editor and distribution requirements. Configure GameActivity as the application entry point, clear Activity, and enable Resizable Activity under Resolution and Presentation, as Google directs. [5]
Route B: Set Up the Android Studio Development Environment
This route installs Android Studio, downloads the Android development tools and creates an XR project from Google’s template. It prepares the native Android workspace for later application development. You can also create an emulator to check that the project builds and launches.
Setup overview: install Android Studio → download Android tools → create an XR project → check dependencies → prepare a test target.Android Studio is Google’s development environment for Android applications. Kotlin is the programming language used here. Jetpack XR SDK provides native spatial UI and XR libraries, while Jetpack Compose describes interfaces in Kotlin code.
Step 1 | Install the XR-Compatible Editor
The recommended Android Studio version includes the XR tools and templates used in this route.
Download the Android Studio build recommended on Google’s XR setup page. The current guidance recommends the latest Canary build. If necessary, install it alongside your normal stable version. Canary is an early development release, so record the exact version your team uses. [10]
Step 2 | Download the Android Development Tools
SDK Manager installs the components needed to build, run and inspect your application.
On the welcome screen, open More Actions > SDK Manager. Under SDK Tools, install or update Android SDK Build-Tools, Android Emulator and Android SDK Platform-Tools, plus the Layout Inspector version listed in Google’s current instructions. Click Apply and accept the licenses. [10]
Step 3 | Create the XR Project
An XR template provides a starting application with a spatial structure already in place.
Open New Project. Select XR in the templates list, then the immersive template for XR headsets or wired XR glasses. Do not select an audio glasses or display glasses template. Click Next, name the project AuraBusinessPanel, set a company package name if offered, choose a save folder and click Finish. [11]
Step 4 | Let the Project Download Dependencies
Gradle sync prepares the libraries and build configuration before you edit the application.
Wait for Gradle sync to finish. Gradle is the build system that downloads dependencies and compiles the app. Open the Project panel and find app/build.gradle.kts, or the app module’s Gradle file. Keep the template’s mutually compatible versions, and do not upgrade individual XR libraries at random.
Step 5 | Check Android API Requirements
API settings must meet the requirements of the template and every library you use.
Check the Jetpack XR SDK setup page against your template. The published baseline is minSdk 24 and compileSdk 34 or higher. Use higher values when your chosen libraries or template require them. compileSdk is the Android API used for compiling, while minSdk sets the oldest supported Android API. [12]
The SDK setup page lists Runtime, SceneCore, Compose for XR, Material Design for XR and ARCore for Jetpack XR dependencies. Add only what the application uses. SceneCore manages spatial content, and ARCore for Jetpack XR provides supported perception capabilities. Preview versions can change, so use the template and release notes together rather than pasting in an old dependency block.
If your template does not include the base XR libraries automatically, make sure your app/build.gradle.kts reflects the following baseline dependencies:
android {
compileSdk = 34 // or higher value your template sets
defaultConfig {
minSdk = 24
}
}
dependencies {
// Jetpack XR SDK core dependencies
implementation("androidx.xr.runtime:runtime:1.1.0-alpha02")
implementation("androidx.xr.scenecore:scenecore:1.1.0-alpha01")
implementation("androidx.xr.compose:compose:1.0.0-beta02")
implementation("androidx.xr.compose.material3:material3:1.0.0-alpha17")
}
At the time of research, Compose for XR 1.0.0-beta02 (October 21, 2026) requires Kotlin 2.2, and its release notes say it depends on SceneCore 1.0.0-rc01, which has a known memory leak. The workaround is to declare SceneCore 1.0.0 or newer yourself, which the dependency block above already does. This is one reason to record the full dependency set rather than describing any latest installation as production-ready. [13]
Run on an XR Emulator Before Hardware Is Available
Step 1 | Create a Virtual XR Device
The emulator lets you check the software before a physical Aura unit is available.
Open Tools > Device Manager, then Add a new device > Create Virtual Device. Select XR as the form factor and choose XR Glasses for the wired-glasses workflow. [4]
Step 2 | Install the Required System Image
The system image supplies the Android XR operating environment for the virtual device.
Choose the preview system image that Google’s guide requires for XR Glasses, download it if prompted and finish creating the virtual device. Start it from Device Manager.
Step 3 | Run the Application
Android Studio builds the project and installs it on the selected virtual device.
In Android Studio’s top toolbar, choose the app run configuration and the running XR virtual device. Click Run. Let Android Studio build and install the unmodified template. You do not need to customize its interface for this environment check.
Step 4 | Check the Result
A successful build and launch confirm that the installed tools can process the template.
Check that the template opens without a build or launch error. This validates the basic software setup, not Aura optics, physical tracking, performance or production readiness.
Connect XREAL Aura to the Development Computer
ADB, short for Android Debug Bridge, lets a development computer install applications on an Android device and read its diagnostic logs. Both Unity and Android Studio can use it.
According to XREAL’s Aura FAQ, both USB-C ports on the compute puck support standard ADB debugging with Android Studio, but its specification table lists full ADB support under the Glasses Port only, so use that port if possible. Keep the glasses connected as instructed. DisplayPort mirroring and an authorized ADB connection are different functions, so seeing your laptop screen in the glasses does not prove that the development connection works.
Step 1 | Enable Authorized Debugging
Debugging allows your development computer to install and inspect test applications.
On the Android XR system, open Settings and enable Developer options and USB debugging using the instructions for your firmware. Standard Android usually exposes Developer options when you repeatedly select Build number, but the exact Aura menu path was not established in the public sources we reviewed. If the supplied onboarding path differs, use that instead. [14]
Step 2 | Connect and Authorize the Computer
This wired debugging workflow requires a USB data connection and approval on the device.
Connect the host using a USB data cable and the documented development port. On the device, approve the computer’s debugging authorization prompt. On Windows, install the manufacturer’s ADB driver if the system requires one. [14]
Step 3 | Check That ADB Sees the Device
The device list confirms that the connection is ready before you attempt to build and run.
In Android Studio, open SDK Manager and note the Android SDK Location. In your terminal, open that SDK’s platform-tools folder and run the appropriate command below.
# Windows PowerShell, inside platform-tools
.\adb.exe devices -l
# macOS or Linux, inside platform-tools
./adb devices -l
Expected result: your device serial number followed by device. If it says unauthorized, approve the prompt. If the list is empty, check the cable, host port, debugging setting and driver. If more than one device or emulator is connected, select the intended target explicitly.
Confirm That Your Development Environment Is Ready
Unity Readiness Checks
Step 1 | Check the Build Profile
Check the setup before you start application development.
Open File > Build Profiles and confirm that Android XR, or the Android profile configured for XR, is active. Confirm that the required Android build modules are available for this editor.
Step 2 | Check Packages and Validation
The project must have its required XR packages installed and enabled.
In Package Manager, check OpenXR Plugin and Unity OpenXR: Android XR. In Project Settings > XR Plug-in Management, confirm the Android OpenXR provider and the Android XR feature group. Resolve any required issues under Project Validation.
Step 3 | Check the Target Device
A recognized device completes the connection part of the setup.
In Build Profiles, refresh Run Device and check that your authorized Aura unit appears. If it does not, check the ADB connection and Unity’s External Tools paths. You can configure the project before hardware is available, but physical deployment validation has to wait until you have a device.
Android Studio Readiness Checks
Confirm that Gradle sync finishes without errors, that SDK Manager has the required tools installed and that the XR emulator or authorized Aura device appears in the target selector. Run the unmodified XR template if a test target is available. Open View > Tool Windows > Logcat to inspect launch errors. Logcat displays Android diagnostic messages.
How Unity and Android Studio Work Together
Unity can build Android applications with its own supported tools, so you do not need Android Studio to configure a Unity project. Android Studio can still help with emulator management and Android diagnostics such as Logcat. It is worth highlighting that the Android XR emulator does not support simulating apps built with Unity, Godot, Unreal Engine or OpenXR, so Unity builds need a physical Aura. For a native Kotlin application, Android Studio is your main workspace and Unity is unnecessary.
For later Android build customization, Unity can export a Gradle project for Android Studio. You do not need this step for the initial setup. Keep Unity’s own supported build tools selected unless your integration specifically requires an export workflow.
Troubleshooting the First Setup
- Android build target is unavailable: Add Android Build Support to the exact Unity Editor installation
- Android XR group is missing: Check the package identifier, compatibility and Android target tab
- Gradle sync fails: Read the first build error, then check the SDK installation and matched dependency versions
- Required packages or features are missing: Check Package Manager, the active Android target and the Android XR feature group
- Project Validation shows errors: Review each required issue and apply the fix for your installed package version
- Device is unauthorized: Approve the debugging prompt on the device
- Install fails on emulator: Check the APK architecture against the emulator system image
Conclusion
Setting up an XREAL Aura development environment means installing compatible tools, preparing an Android XR project, enabling the right platform support and checking the device connection. Unity suits projects that will use interactive 3D content, while Android Studio suits native Android interfaces. A clear, repeatable setup helps businesses reduce configuration problems and gives developers a reliable foundation for building and testing applications.
Planning development for XREAL Aura? Talk to VR Expert about hardware access, software requirements and rollout support.
Explore business XR hardware and support at: https://ai.vr-expert.com/

























