Executive Summary
This guide shows you how to create an XREAL Aura business app in Android Studio using Kotlin and the Jetpack XR SDK. You will create a project, add the spatial interface library, paste in a small task panel example and run it in the XR Glasses emulator before testing on Aura hardware.
The example displays work instructions and lets users acknowledge each task. It is a starting point for a business application and does not include permanent work records or verification that a physical task was completed. The code follows the reviewed documentation but has not been compiled or tested on Aura hardware.
Introduction
Building an XREAL Aura business app starts in Android Studio, where you write Kotlin code and use the Jetpack XR SDK to add a spatial interface. This guide takes you from creating a project to running it in an emulator and testing it on Aura. As a simple example, you will build a panel that displays work instructions and lets a user acknowledge each task.
XREAL Aura combines wired glasses with an Android XR computing puck. Follow the Android XR workflow for wired XR glasses, not the separate workflow for phone-projected audio and display glasses. For hardware context, see the VRX XREAL Aura overview and XREAL's official Aura page. [1]
Before You Start
· Use a company-approved computer with internet access for the initial downloads
· Check Google's XR emulator system requirements, which currently cover supported Windows and macOS configurations [2]
· For physical testing, get the Aura glasses, their compute puck and the kit's developer connection instructions
Availability: Confirm regional supply with VR Expert. XREAL's current page prioritizes the US, Canada, Japan and South Korea. Older reservation lists should not be treated as confirmed European delivery. [1]
Step 1: Install Android Studio and Its SDK Tools
Start by installing Android Studio and the SDK tools you need to build the app, run a simulated XR device and connect to hardware.
Google recommends Android Studio Canary for XR. Canary is a preview edition with newer tools and potentially unfinished features. You can install it alongside your existing Android Studio.
· Open Android Studio Preview, download the appropriate installer and complete the installation wizard.
· On the Android Studio welcome screen, select More Actions > SDK Manager. If a project is already open, use Tools > SDK Manager in the top menu.
· In the SDK Manager settings window, find the SDK Platforms and SDK Tools tabs above the list of installable packages. Both tabs are part of the same SDK Manager window.
· Select SDK Tools. Check Android SDK Build-Tools, Android Emulator and Android SDK Platform-Tools. Keep them selected if they are already installed, and apply any available updates. Build-Tools prepares the app's installation file, Emulator runs simulated devices, and Platform-Tools includes ADB, the device connection tool.
· Click Apply, review the selected downloads, accept the required licenses and wait for the installation to finish. Click OK to close the window.
The SDK Platforms tab installs the Android platform used to compile the app. The required version comes from the project configuration. Create the project in Step 2, then use its compileSdk setting to select the matching platform. Step 6 covers the XR emulator's system image, which supplies the operating system for the simulated device.
Checkpoint: The three SDK tools are installed. You can now create the project. [3, 13]
Step 2: Create the XREAL Aura Business App Project
The XR project template creates the app's starting files and build configuration. Follow Google's Android XR project instructions for your installed version of Android Studio. [4]
· In Android Studio, return to the welcome screen and click New Project, or choose File > New > New Project.
· Select XR in the template list, then select the template for XR headsets and wired XR glasses. Google's project page no longer names the templates (it says to choose the template that corresponds to the type of XR device you want to build for), and names can change between Canary releases, so take the exact name from the IDE for the screenshot. Do not choose the audio or display glasses template, which creates a phone-projected experience.
· Click Next. Enter AuraTaskPanel in Name. In Package name, enter com.example.aurataskpanel for this tutorial. Select Kotlin if a language option appears. The package name identifies the app's code and can be customized for your organization. You enter it in Android Studio as a dot-separated identifier, without https:// or a web address path.
Then keep the generated template's build settings and click Finish. Wait for the first Gradle sync to complete. Sync makes Android Studio read the build configuration and resolve its dependencies.
Open View > Tool Windows > Project, then select Android in the pane's view selector. You will use these files:
· MainActivity.kt: app > kotlin+java > com.example.aurataskpanel. This file contains the app's entry point and interface. Some versions label the source folder java
· AndroidManifest.xml: app > manifests. This file declares the app's entry point, permissions and launch settings
· build.gradle.kts (Module :app): Gradle Scripts. This file configures the app's build and libraries
Install the Platform Your Project Requests
The compileSdk setting tells Android Studio which Android API set to use when building the app. Install the matching SDK platform. Do not choose one based only on the brand of the glasses.
· In the Android Studio Project pane, open Gradle Scripts > build.gradle.kts (Module :app). In the android block, find compileSdk. A value such as compileSdk = 36 means the project needs Android API 36. This number is an example, not a required value for every Aura project.
· If the value points to a catalog entry, such as libs.versions.compileSdk, open Gradle Scripts > libs.versions.toml and read the referenced value. If the template uses a preview name or a nested compileSdk configuration, keep that setting and use its matching platform.
· Open Tools > SDK Manager > SDK Platforms. Select the row whose API Level matches the project's setting. Click Apply, complete the download, then click OK.
· Return to the project and select File > Sync Project with Gradle Files, or click Sync Now if a banner offers it. Gradle sync reads the build settings and downloads the libraries the project requires.
Keep the template's platform setting. If Android Studio reports a missing platform, install that platform instead of lowering compileSdk to avoid the download. You select the XR device image used for testing separately in Step 6. [13]
Checkpoint: The required SDK platform is installed, and the Build or Sync tool window shows no unresolved errors.
Step 3: Add the XR Library and Check Kotlin Compatibility
Add Jetpack Compose for XR to give the app spatial panel components, and check Kotlin compatibility so the project can build that library without version errors. This example uses XR Compose 1.0.0-beta02 (October 21, 2026, still the newest release), which requires Kotlin 2.2 according to Google's release notes. The same notes say beta02 depends on SceneCore 1.0.0-rc01, which has a known memory leak, so add implementation(“androidx.xr.scenecore:1.0.0”) or newer to the Compose line in Step 3.
Check the Kotlin Version Once
· In Android Studio, expand Gradle Scripts, then open libs.versions.toml. When present, this file is the project's central list of library and plugin versions.
· Under [versions], look for the Kotlin entry, typically kotlin = "2.2.0" or another 2.2.x version. Keep the compatible version supplied by the current template.
· If the project uses the org.jetbrains.kotlin.plugin.compose plugin, its version must match Kotlin. Templates typically make both refer to the same Kotlin version entry. Keep that link intact.
· If there is no Kotlin entry or catalog, inspect the top-level build.gradle.kts for explicitly declared Kotlin plugins. Some newer build configurations manage Kotlin through the Android build tooling. In that case, keep the generated configuration and check the toolchain's Kotlin compatibility if a build error appears. Do not add a second Kotlin plugin just to create a version entry.
If the template already provides compatible Kotlin tooling, change nothing. If a build reports that Kotlin is too old for the XR library, update the project's Kotlin tooling and any matching Compose compiler plugin together, using the supported configuration for that template. Avoid changing unrelated build settings.
Add the Spatial Interface Dependency
· Open Gradle Scripts > build.gradle.kts (Module :app).
· Find the existing dependencies { ... } block.
· Look for an XR Compose dependency, either written directly or through an alias such as implementation(libs.androidx.xr.compose). If an alias already exists, set its referenced XR Compose version to 1.0.0-beta02 in libs.versions.toml. Do not add the same library twice.
· If XR Compose is missing, add this line inside the existing dependencies block:
implementation("androidx.xr.compose:compose:1.0.0-beta02")Keep the template's other dependencies. In particular, the code below uses standard Material 3, the library that supplies its buttons, text and theme, and Activity Compose, which hosts Compose content in an Android Activity.
Sync and Continue
Click Sync Now in the editor banner, or select File > Sync Project with Gradle Files. Wait for the download and configuration process to finish.
Checkpoint: Sync completes without dependency or Kotlin compatibility errors. When sync succeeds, keep the remaining generated build settings, then open MainActivity.kt to add the interface. If sync reports a dependency error, compare the named component with Google's Jetpack XR SDK setup page. [6]
Step 4: Build the Task Panel in Kotlin
The interface displays task text with a Mark complete button and a Restart demo button. You can later replace the sample instructions with an approved workplace procedure.
In the same MainActivity.kt file in Android Studio, keep the package line if your package differs, then replace the rest of the file with the code below. Remove the template's old sample functions and preview functions from this file so there is only one MainActivity. An Activity is an Android entry point that hosts an interface. The example below includes the Activity and its imports.
package com.example.aurataskpanel
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.xr.compose.platform.LocalSpatialCapabilities
import androidx.xr.compose.spatial.Subspace
import androidx.xr.compose.subspace.SpatialPanel
import androidx.xr.compose.subspace.layout.SubspaceModifier
import androidx.xr.compose.subspace.layout.height
import androidx.xr.compose.subspace.layout.width
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
MaterialTheme(colorScheme = darkColorScheme()) {
TaskApp()
}
}
}
}
@Composable
private fun TaskApp() {
val steps = listOf(
"Check that the training area is clear.",
"Confirm the training device is charged.",
"Open the approved training application."
)
var completed by rememberSaveable { mutableIntStateOf(0) }
val content: @Composable () -> Unit = {
TaskPanel(
steps = steps,
completed = completed,
onComplete = {
if (completed < steps.size) completed++
},
onRestart = { completed = 0 }
)
}
if (LocalSpatialCapabilities.current.isSpatialUiEnabled) {
Subspace {
SpatialPanel(
modifier = SubspaceModifier
.width(640.dp)
.height(540.dp)
) {
content()
}
}
} else {
content()
}
}
@Composable
private fun TaskPanel(
steps: List<String>,
completed: Int,
onComplete: () -> Unit,
onRestart: () -> Unit
) {
val finished = completed >= steps.size
Surface(modifier = Modifier.fillMaxSize()) {
Column(
modifier = Modifier
.fillMaxSize()
.verticalScroll(rememberScrollState())
.padding(24.dp),
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
Text("Training station preparation", fontSize = 28.sp)
Text("Demo procedure v1.0", fontSize = 18.sp)
Text(
"$completed of ${steps.size} tasks acknowledged",
fontSize = 20.sp
)
Text(
if (finished) "Checklist complete"
else "Task ${completed + 1}: ${steps[completed]}",
fontSize = 26.sp
)
Text(
"Your confirmation does not verify physical work.",
fontSize = 18.sp
)
Button(
onClick = onComplete,
enabled = !finished,
modifier = Modifier
.fillMaxWidth()
.heightIn(min = 64.dp)
) {
Text("Mark complete", fontSize = 22.sp)
}
OutlinedButton(
onClick = onRestart,
modifier = Modifier
.fillMaxWidth()
.heightIn(min = 64.dp)
) {
Text("Restart demo", fontSize = 22.sp)
}
}
}
}What the Code Does
· steps holds the instruction text
· completed counts acknowledgments and prevents advancing past the last task
· rememberSaveable retains that small value through supported Android screen recreation and state restoration. It is not permanent storage
· LocalSpatialCapabilities checks whether spatial UI is available [7]
· Subspace creates an area for spatial content, and SpatialPanel places the interface inside it [8]
· The fallback branch shows the same content in a normal window when spatial UI is unavailable
The dp unit scales layout dimensions for screen density. The sp unit scales text and respects font size preferences. The scroll container keeps longer instructions reachable. Treat the panel size as a starting point and check readability on Aura.
Checkpoint: Android Studio recognizes the imports and shows no Kotlin syntax errors. If your installed library requires an experimental API opt-in, use the exact annotation named in the compiler diagnostic and check the API reference for that release.
Step 5: Check How the App Starts in Android XR
Configure the launch mode so Android XR can open the app with the spatial layout used in this example.
On Aura glasses, Home Space and Full Space are already built into Android XR and control how running apps appear. The XR Glasses emulator provides these modes for development, so you do not need to install anything separately.
In the Android Studio Project pane, open app > manifests > AndroidManifest.xml and inspect the MainActivity entry. Keep its MAIN and LAUNCHER intent filter, exported setting and generated theme. For Compose-managed Full Space, the relevant property is shown below. If the template already declares a launch property at the application or Activity level, edit the existing value instead of duplicating it. [9]
<!-- Inside the existing MainActivity element -->
<property
android:name="android.window.PROPERTY_XR_ACTIVITY_START_MODE"
android:value="XR_ACTIVITY_START_MODE_FULL_SPACE_MANAGED" />Managed Full Space means Android manages the spatial scene for the Activity. The UNMANAGED value is intended for apps that render through OpenXR, a cross-platform XR interface. This Compose example does not use it. Check the manifest constants reference when comparing templates. [9]
In the existing application element, also keep or add android:enableOnBackInvokedCallback="true" so the spatial panel receives back events, as documented in Google's panel guide. Its example sets the attribute on the activity element, but it is also valid on the application element. Do not add camera, microphone or scene understanding permissions for this static checklist. It does not read the room or identify objects. [8]
Step 6: Create an XR Glasses Emulator and Run the App
Run the app on a simulated XR glasses device before connecting Aura. An emulator simulates a device on your computer, and an AVD is its saved configuration.
· In Android Studio, open Tools > Device Manager. Click the add device control and choose Create Virtual Device.
· Under Form Factor, choose XR, then XR Glasses. Click Next.
· Select the Preview API system image required for the XR Glasses profile and download it if prompted. Match the supported image architecture to your computer. Finish the configuration.
· Start the AVD using its play control. Wait for the Android XR environment to finish loading.
· In the Android Studio top toolbar, select the app run configuration and the running XR Glasses device. Click Run, the green triangle.
The emulator installs and opens the app. Use its input controls to activate Mark complete. If the panel stays in Home Space, check the manifest and the environment's Full Space controls before changing the Kotlin layout. See the official AVD instructions.
Run this acceptance check:
· The first screen shows zero of three tasks acknowledged and the first instruction
· Each Mark complete activation advances exactly one instruction
· The third activation shows Checklist complete and disables Mark complete
· Restart demo restores the first instruction and zero acknowledgments
· Longer text remains reachable by scrolling
· The content still appears when spatial UI is unavailable
A successful emulator test validates part of the application logic and layout. It does not validate Aura optics, input reliability or suitability for the workplace.
Step 7: Deploy to Authorized Aura Hardware
The steps below follow the standard Android debugging process. Aura's menus and connection options can vary by software version, so follow the kit-specific instructions where they differ.
Connect Aura and Run the App
· Start Aura with the glasses connected and open its Settings app
· In the Aura settings interface, enable Developer options and debugging using the kit's instructions. Get the developer setup guide if those controls are unavailable
· Connect the computer to the compute puck's Charging Port (left side) with a USB data cable and leave the glasses connected to the Glasses Port (right side). If that doesn't work, plug it into the right side port for full ADB support.
· Accept the device's debugging authorization prompt. A managed device may require administrator approval
· In the Android Studio top toolbar, select Aura in the device dropdown and click Run
· On Aura, repeat the task panel checks from Step 6, including advancing tasks and restarting the checklist
Troubleshoot the Device Connection
If Aura does not appear in the Android Studio target selector, verify the connection using ADB:
- Open View > Tool Windows > Terminal in Android Studio.
- Run the following command:
adb devices -lCheck the output:
· If your device is listed with device, it is connected and authorized.
· If it shows unauthorized, put on the glasses and accept the USB debugging prompt on the screen.
· If the list is empty, check the USB data cable again, make sure the computing puck is powered on, and confirm that USB debugging is still enabled in Settings.
Conclusion
Building your first XREAL Aura business app starts with Android Studio, Kotlin and the Jetpack XR SDK, then progresses from a simple work instructions panel to emulator testing and deployment on authorized hardware. This approach gives businesses a focused way to evaluate whether spatial instructions improve a real workflow before investing in integrations and a fleet rollout. Once the panel is readable, usable and validated on Aura, the next step is to connect approved procedures and reliable work records to the company's systems.
Talk to VR Expert about Aura availability and the hardware, software development and support requirements for your business pilot.

























