Android XR & AI Glasses: Developer Guide 2026

Key Takeaways

• Android XR Platform: Google's new OS for smart glasses and headsets, launching with Project Aura and Samsung partnership in late 2025
• Gemini AI Integration: Enables multimodal understanding with real-time visual analysis and natural language interaction
• SDK Developer Preview 3: Available now with emulator, spatial UI components, and Jetpack Compose XR support
• Snapdragon AR2 Gen 2: Qualcomm processor powers lightweight, all-day wearable form factor with sub-20ms latency
• Context-Aware Design: Design for interfaces that enhance rather than distract from real-world activities

Android XR Technical Specifications

Specification	Value
SDK Version	Developer Preview 3
API Level	35+
IDE	Android Studio Ladybug
UI Framework	Jetpack Compose XR
Processor	Snapdragon AR2 Gen 2
AI Runtime	Gemini Nano + Pro
Partners	Samsung, XREAL
Launch	Late 2025 / 2026

Understanding Android XR: Developer Tutorial Introduction

In this comprehensive Android XR developer tutorial, you'll learn how to build immersive apps for Google's next major spatial computing platform. Android XR represents Google's unified platform for extended reality devices, announced in December 2024 as the foundation for a new generation of smart glasses, wired XR glasses, and mixed reality headsets. Unlike smartphone AR through ARCore, Android XR is a purpose-built operating system designed from the ground up for augmented reality glasses Android development.

With 3 billion active Android devices globally and existing Android development skills transferring directly to XR, this platform offers the fastest path to extended reality development. Whether you're building for the $1,799 Samsung Galaxy XR headset or upcoming AI glasses from design partners like Warby Parker and Gentle Monster, this tutorial covers everything from SDK setup to production deployment.

Smart Glasses (Project Aura)

Lightweight, everyday-wearable glasses designed for ambient computing and contextual assistance throughout your day.

• All-day battery life target
• Gemini AI assistant built-in
• Heads-up notifications
• Real-time translation

Mixed Reality Headsets

Immersive devices for entertainment, productivity, and creative applications with full spatial computing capabilities.

• High-resolution passthrough
• Hand and eye tracking
• Spatial audio system
• Multi-window workspace

Samsung Partnership: Google and Samsung announced a strategic partnership at Galaxy Unpacked, with Samsung developing an Android XR headset using their expertise in displays and hardware manufacturing. This builds on their previous collaboration with Galaxy Watch.

Android XR vs Apple Vision Pro vs Meta Quest: Complete Comparison

Choosing the right XR platform is a strategic business decision. This comprehensive comparison helps developers and decision-makers evaluate Android XR against Apple Vision Pro and Meta Quest 3 across cost, capabilities, and ecosystem factors.

Platform Comparison Matrix

Factor	Android XR (Galaxy XR)	Apple Vision Pro	Meta Quest 3
Price	$1,799	$3,499	$499
Target Market	Enterprise + Consumer	Premium Consumer	Gaming + Consumer
AI Integration	Gemini (Best in Class)	Siri (Limited)	Meta AI (Growing)
Display Quality	4K per eye, 90Hz	4K per eye, 120Hz	Lower resolution
Developer Ecosystem	Android (Largest)	Apple (Premium)	Meta (Gaming Focus)
Weight	545g	750g (Heaviest)	515g (Lightest)
Form Factors	Headsets + AI Glasses + Wired Glasses	Headset Only	Headset Only
Hand Tracking	Yes	Yes	Yes
Eye Tracking	Yes	Yes	Yes
Passthrough Mode	High-resolution color	Best-in-class	Color passthrough
Processor	Snapdragon XR2+ Gen 2	Apple M5	Snapdragon XR2 Gen 2

Choose Android XR If

• Cost matters for enterprise deployment
• Existing Android development skills
• Gemini AI integration is priority
• Need glasses form factor options
• Targeting 3B Android user base

Choose Vision Pro If

• Premium experience is priority
• Deep Apple ecosystem integration
• Highest display quality needed
• Budget is less constrained
• SwiftUI development preferred

Choose Quest 3 If

• Gaming is primary use case
• Lowest cost entry point needed
• Social VR experiences priority
• Large existing VR app library
• Consumer-focused applications

Market Insight: IDC projects the XR headset market growing 30% annually through 2028. Gartner estimates 50% of large enterprises will have XR pilot programs by 2027. Android XR's 48% lower total cost of ownership compared to Vision Pro makes it the leading choice for enterprise deployments.

Business Case & ROI Analysis for Android XR Development

Understanding the business value of Android XR development helps justify investment to stakeholders. This section provides concrete cost estimates and ROI calculations for enterprise XR deployments.

Enterprise Pilot Cost Calculator (50 Devices)

Investment:

• Hardware (50 x $1,799): $89,950
• Development (300 hours x $150): $45,000
• Training & Deployment: $15,000
• Total Investment: $149,950

Projected Returns (Field Service):

• Time saved per technician/day: 2 hours
• Daily savings (50 x 2hrs x $50): $5,000
• Annual savings (250 work days): $1,250,000
• First Year ROI: 733%

Development Timeline

Activity	Duration
Basic XR App	2-6 months
Mobile App Adaptation	2-4 weeks
Learning Curve (Android devs)	2-4 weeks
Production Deployment	1-2 weeks

Development Costs

Item	Cost
Basic XR App	$30K-$60K
Complex Enterprise App	$80K-$150K
Development Hours	200-400 hrs
Test Hardware	$1,799/device

Market Opportunity

Metric	Value
Android Users	3 billion
XR Market Growth	30% annually
Enterprise Adoption (2027)	50% of large cos
Cost Advantage vs Vision Pro	48% lower

Why Develop for Android XR Now: First-mover advantage in emerging platforms is significant. Developers who start now with emulators will have 12-18 month head starts when consumer hardware launches. Skills transfer directly from existing Android development, reducing learning curves and enabling faster time-to-market.

SDK Developer Preview 3 Tutorial

Released in December 2025, Developer Preview 3 brings increased stability for headset APIs and opens development for AI Glasses. This release includes the new XR Glasses emulator in Android Studio for testing glasses-specific experiences.

What's New in Developer Preview 3

XR Glasses Emulator: New emulator in Android Studio for AI Glasses development with accurate FoV, resolution, and DPI matching.

Dynamic glTF Loading: Jetpack SceneCore now supports loading 3D models via URIs and creating PBR materials at runtime.

Widevine DRM Support: SurfaceEntity component enhanced with full DRM support for protected video content playback.

360° Video Rendering: New sphere and hemisphere shapes for immersive 360° and 180° video experiences.

ARCore Geospatial: Location-based content and accurate wayfinding with ARCore geospatial features for XR.

Body Tracking (Beta): Experimental body tracking plus QR code and ArUco marker recognition capabilities.

SDK Component Versions

Component	Version	Status
xr-core	1.0.0-alpha03	DP3
xr-compose	1.0.0-alpha03	DP3
xr-runtime	1.0.0-alpha03	DP3
play-services-gemini	1.0.0	Stable
ARCore XR	1.43.0+	Stable

Project Aura from XREAL: Google partnered with XREAL to reveal the first wired XR glasses running Android XR. Project Aura features a 70° field of view with optical see-through technology, targeting 2026 availability.

Project Aura & Wired XR Glasses Development

Project Aura from XREAL represents the first wired XR glasses running Android XR, developed in partnership with Google. Unlike standalone headsets, wired glasses offload processing to a companion device (smartphone or external battery pack with touchpad), enabling lighter form factors for extended wear. This section covers the technical specifications and development considerations for wired XR glasses.

Uniquely, Project Aura also supports iOS devices, making it a cross-platform option for developers targeting both Android and Apple ecosystems. The external battery pack doubles as a touchpad controller, providing input without requiring hand tracking in all scenarios.

Hardware Specifications

Component	Specification	Developer Impact
Processor	Qualcomm Snapdragon AR2 Gen 2	Dedicated AI NPU for on-device inference
Display	MicroLED waveguide, 1080p per eye	Design for 52° FOV constraints
Cameras	Dual 12MP + depth sensor	Environment understanding APIs available
Audio	Open-ear spatial speakers + 3 mics	Spatial audio SDK for immersive sound
Battery	Integrated + companion battery pack	Power profiling tools critical
Connectivity	WiFi 6E, Bluetooth 5.3, Ultra Wideband	Phone companion mode for heavy processing
Latency	Sub-20ms motion-to-photon	Frame timing APIs for smooth rendering

Form Factor Priorities

• <50g: Weight target for all-day comfort
• Standard: Prescription lens compatibility
• IP54: Dust and splash resistance

Gemini Live API Integration: Complete Developer Guide

The Gemini Live API is the AI backbone of Android XR, providing multimodal understanding that combines what you see, hear, and say into contextual intelligence. This deep integration enables context-aware computing experiences impossible on traditional devices. For developers, Gemini integration happens via the Firebase AI Logic SDK with support for streaming audio/visual input.

Gemini for AI glasses enables real-time conversational AI that sees what you see. Unlike standard chatbot APIs, Gemini Live maintains continuous context through conversation history, location awareness, and visual scene understanding. This allows building contextual assistants that proactively offer help based on the user's current situation.

Visual Understanding

Real-time analysis of what you're looking at:

• Object Recognition — Identify products, plants, landmarks instantly
• Text Extraction — Read and translate signs, menus, documents
• Scene Understanding — Contextual awareness of environments
• Face Recognition — Optional memory aid for contacts

Conversational AI

Natural language interaction with context:

• Voice Commands — Hands-free control of all features
• Follow-up Questions — Maintains conversation context
• Proactive Suggestions — Offers help based on situation
• Multi-turn Tasks — Complex workflows via conversation

Gemini API Integration Example

// Request visual analysis from Gemini
val geminiService = GeminiXR.getInstance(context)

// Capture current field of view
val visualContext = captureFieldOfView()

// Send multimodal query
val response = geminiService.query(
    text = "What restaurant is this and what's on the menu?",
    image = visualContext.currentFrame,
    location = getCurrentLocation(),
    conversationHistory = sessionHistory
)

// Display response in AR overlay
spatialUI.showInfoCard(
    content = response.text,
    anchor = visualContext.pointOfInterest,
    duration = CardDuration.UNTIL_DISMISSED
)

On-Device vs Cloud Processing: Gemini Nano runs locally on the Snapdragon AR2's NPU for instant responses and privacy-sensitive tasks. Complex queries automatically route to Gemini Pro in the cloud. Apps can specify processing preference based on use case.

Android XR Emulator Setup Tutorial

Getting started with Android XR app development requires Android Studio with XR extensions and the latest SDK tools. This tutorial walks through the complete Android XR emulator setup process to configure your development environment for both headset and AI glasses development.

The XR Glasses emulator introduced in Developer Preview 3 provides accurate content visualization matching real device specifications for Field of View (FoV), resolution, and DPI. This allows developers to test glasses apps without physical hardware, significantly reducing the barrier to entry for XR development.

Step 1: Install Android Studio XR

Download the latest Android Studio with XR support:

# Download from developer.android.com
Android Studio Ladybug or later required
# Enable XR plugins
Settings → Plugins → Android XR Support

Step 2: Configure SDK Components

Install Android XR SDK and emulator:

# In SDK Manager
SDK Platforms → Android XR (API 35+)
SDK Tools → Android XR Emulator
SDK Tools → Android XR Image (System Images)

Step 3: Create XR Virtual Device

Set up emulator for testing:

# In Device Manager
Create Device → XR Category → Android XR Headset
Select system image: Android XR Preview
# Configure GPU for rendering
Graphics: Hardware - GLES 3.0+

Step 4: Add XR Dependencies

Configure Gradle for XR development:

// build.gradle.kts
dependencies {
    implementation("androidx.xr:xr-core:1.0.0-alpha03")
    implementation("androidx.xr:xr-compose:1.0.0-alpha03")
    implementation("androidx.xr:xr-runtime:1.0.0-alpha03")
    implementation("com.google.android.gms:play-services-gemini:1.0.0")
}

Building Your First XR App

Let's build a simple XR application that displays floating information cards in the user's environment. This example demonstrates the core concepts of spatial UI and environment awareness.

MainActivity.kt - Basic XR Application

class MainActivity : XrActivity() {
    private lateinit var spatialSession: SpatialSession

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Initialize spatial session
        spatialSession = SpatialSession.Builder(this)
            .setFeatures(
                SpatialFeature.PLANE_DETECTION,
                SpatialFeature.SPATIAL_ANCHORS,
                SpatialFeature.HAND_TRACKING
            )
            .build()

        // Set up Compose XR content
        setContent {
            XrTheme {
                SpatialScaffold(
                    session = spatialSession
                ) {
                    FloatingInfoPanel()
                }
            }
        }
    }
}

@Composable
fun FloatingInfoPanel() {
    val planeState = rememberPlaneDetectionState()

    // Anchor card to detected surface
    SpatialPanel(
        anchor = planeState.primaryPlane,
        offset = Offset3D(0f, 1.5f, -1f), // 1.5m up, 1m in front
        size = PanelSize(0.4f, 0.3f) // 40cm x 30cm
    ) {
        Card(
            modifier = Modifier.fillMaxSize(),
            colors = CardDefaults.cardColors(
                containerColor = Color.White.copy(alpha = 0.9f)
            )
        ) {
            Column(
                modifier = Modifier.padding(16.dp),
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                Text(
                    text = "Welcome to Android XR",
                    style = MaterialTheme.typography.headlineSmall
                )
                Spacer(modifier = Modifier.height(8.dp))
                Text(
                    text = "This panel is floating in your space",
                    style = MaterialTheme.typography.bodyMedium
                )
            }
        }
    }
}

Key Components

SpatialSession: Core runtime managing environment tracking, anchors, and input. Configure required features at initialization.

SpatialPanel: Container for 2D UI content positioned in 3D space. Supports anchoring to planes, objects, or world coordinates.

XrTheme: Material Design adapted for XR with legibility optimizations, depth cues, and spatial interaction patterns.

Spatial UI Design Patterns for AI Glasses

Designing spatial UI for XR requires new thinking about interface placement, user attention, and context awareness. Unlike headset development where users expect immersive experiences, transparent display UI for AI glasses must enhance rather than replace the real world. Follow these patterns to create comfortable, intuitive experiences.

The key difference between designing for AI glasses vs headsets: glasses are all-day wearable devices where users are primarily engaged with the real world. Interfaces should be glanceable, contextual, and minimally intrusive. Use Jetpack Compose Glimmer components designed specifically for optical see-through displays.

Glanceable Information Architecture

Users wearing glasses can't afford to be distracted. Design interfaces that communicate essential information at a glance.

Do:

• Large, high-contrast text (min 24sp)
• Icon-first, label-second layouts
• Progressive disclosure of details
• Automatic dismissal timers

Don't:

• Dense text paragraphs
• Multiple competing notifications
• Persistent overlays blocking view
• Small interactive targets

Comfort Zone Placement

Place content in the user's natural viewing zone to prevent neck strain and eye fatigue during extended use.

// Comfort zone constants (relative to user's head)
object ComfortZone {
    val OPTIMAL_DISTANCE = 0.75f..1.5f  // 75cm-150cm
    val VERTICAL_ANGLE = -15f..15f      // degrees from horizon
    val HORIZONTAL_ANGLE = -30f..30f    // degrees from center

    val PERIPHERAL_OK = 30f..60f        // for glanceable alerts
    val AVOID_ZONE = 60f..90f           // causes neck strain
}

Context-Aware Triggering

Show information when it's relevant, hide it when it's not. Use environmental and behavioral cues to determine timing.

Gaze Duration: Trigger after 500ms+ sustained gaze at object

Temporal Context: Restaurant hours near mealtime, not midnight

Activity State: Suppress during driving, exercise, meetings

Performance Optimization

XR devices have strict performance requirements—maintaining 90fps while managing thermal constraints and battery life. Optimization isn't optional; it's essential for usable applications.

Performance Budgets

Metric	Budget
Frame time budget	11.1ms max
Draw calls per frame	<100
Triangles rendered	<100K
Texture memory	<256MB
CPU AI inference	<5ms

Optimization Techniques

• Use level-of-detail (LOD) for 3D objects
• Implement occlusion culling aggressively
• Batch static geometry at build time
• Use foveated rendering when available
• Profile with Android GPU Inspector

Power-efficient rendering pattern

class OptimizedRenderer : XrRenderer {
    private val staticCache = SpatialCache()
    private var lastUpdateTime = 0L

    override fun onFrame(frameState: FrameState) {
        // Skip redundant updates (target 15fps for static UI)
        val timeSinceUpdate = frameState.time - lastUpdateTime
        if (!hasChanges && timeSinceUpdate < 66_000_000) {
            renderCached(staticCache)
            return
        }

        // Adaptive quality based on thermal state
        val quality = when (frameState.thermalState) {
            ThermalState.NOMINAL -> RenderQuality.HIGH
            ThermalState.FAIR -> RenderQuality.MEDIUM
            ThermalState.SERIOUS -> RenderQuality.LOW
            ThermalState.CRITICAL -> RenderQuality.MINIMAL
        }

        renderScene(quality)
        staticCache.update(currentScene)
        lastUpdateTime = frameState.time
    }
}

Privacy & Security Considerations for AI Glasses

Camera-equipped AI glasses raise significant privacy concerns that developers must address proactively. Unlike smartphones where recording is obvious, glasses can capture video and audio continuously without clear indication to bystanders. Building privacy-respecting applications is essential for user adoption and avoiding regulatory issues.

Developer Responsibilities

• Use mandatory recording LED indicators when camera is active
• Implement on-device processing with Gemini Nano for sensitive data
• Provide clear data deletion controls and retention policies
• Implement automatic recording restrictions in sensitive locations
• Use explicit opt-in for any face or voice data processing

Bystander Awareness

• Show processing status indicators visible to others when appropriate
• Consider audio cues for recording start/stop
• Blur faces in captured images unless explicitly consented
• Implement geofencing to disable recording in private spaces
• Provide transparency reports on data collection

Privacy-Conscious Camera Access Pattern

class PrivacyAwareCameraService : XrCameraService {
    override fun onCameraAccess(request: CameraRequest): CameraResponse {
        // Check location restrictions
        if (isRestrictedLocation(currentLocation)) {
            return CameraResponse.Denied(
                reason = "Camera disabled in this location"
            )
        }

        // Activate recording indicator (mandatory)
        activateRecordingLED()

        // Use on-device processing for privacy
        val processor = if (request.containsFaces) {
            GeminiNano.localProcessor() // Never sends to cloud
        } else {
            GeminiPro.cloudProcessor()
        }

        return CameraResponse.Granted(
            processor = processor,
            autoBlurFaces = true,
            maxRetentionHours = 24
        )
    }
}

Enterprise Data Policies: For enterprise deployments, implement Mobile Device Management (MDM) integration to enforce organizational data policies. This includes restricting camera access to approved applications, enforcing encryption for stored data, and maintaining audit logs of sensitive operations.

Enterprise Use Cases for Android XR

Enterprise applications offer the clearest ROI for Android XR development. Field service, retail, healthcare, and manufacturing all have measurable productivity gains from hands-free information access and AI-assisted operations. This section covers high-value industry applications.

Field Service & Manufacturing

Hands-free work instructions and AI-assisted diagnostics:

• Real-time work instructions overlaid on equipment
• Gemini-powered equipment manual translation
• AI-assisted defect detection during inspections
• Remote expert support with shared POV video

ROI Example: 50% reduction in training time, 2+ hours saved per technician daily

Retail & Customer Experience

Staff productivity and personalized customer service:

• Instant product information via visual search
• Inventory location display for warehouse navigation
• Customer preference display for personalized service
• Training overlays for new employee onboarding

ROI Example: 40% lower hardware cost vs Vision Pro, faster checkout times

Healthcare & Medical Training

Surgical assistance and medical education:

• Anatomy overlays during surgical procedures
• Patient data display without breaking sterile field
• Remote specialist consultation with shared view
• Training simulations for complex procedures

ROI Example: Reduced errors, faster training, better patient outcomes

Developer Productivity Tools

XR-enhanced development workflows:

• Floating documentation windows while coding
• Code review with spatial diff visualization
• AR debugging overlays on physical devices
• Meeting attendance while maintaining code context

ROI Example: Reduced context switching, enhanced collaboration

Enterprise Deployment Advantage: Android XR's enterprise MDM support and familiar Android management tools make large-scale deployments simpler than competing platforms. Organizations can leverage existing IT infrastructure and security policies, reducing deployment friction and TCO.

Common Mistakes to Avoid

XR development introduces unique pitfalls that can ruin user experience. Learn from common mistakes to build better applications.

Ignoring Motion Sickness

Artificial locomotion and camera movements cause nausea in many users. Unlike gaming VR, everyday wearables need to prioritize comfort above all.

Solution: Lock content to real-world anchors. Never move the camera programmatically. Use fade transitions instead of animated movements. Provide instant-teleport navigation options.

Overcrowding the Field of View

Treating XR like a desktop with unlimited screen space leads to overwhelming, unusable interfaces that block the user's view of the real world.

Solution: Limit simultaneous UI elements to 3-5 maximum. Use peripheral hints that expand on gaze. Implement aggressive auto-dismiss. Always maintain clear sightlines for safety.

Testing Only in Emulator

The emulator can't replicate real-world conditions—varying lighting, moving environments, physical comfort over time, or actual tracking quality.

Solution: Test on real hardware as soon as available. Create diverse environment test scenarios. Conduct extended wear sessions (30+ minutes). Test in low-light and bright outdoor conditions.

Neglecting Privacy Indicators

Camera-enabled glasses raise social concerns. Apps that don't clearly indicate recording or processing will create user distrust and social friction.

Solution: Use mandatory recording LED indicators. Show processing status to bystanders when appropriate. Implement automatic recording restrictions in sensitive locations. Provide clear data deletion controls.

Always-On Processing

Running continuous computer vision or AI inference destroys battery life and generates uncomfortable heat against the user's face.

Solution: Implement intelligent activation triggers (wake words, gaze, gestures). Cache recognition results for static environments. Use low-power coprocessors for ambient sensing. Provide clear power mode options to users.

Ignoring Battery Constraints

Error: Building compute-intensive AR features without optimizing for wearable battery life.

Impact: 30-minute battery drain destroys user experience and limits practical use cases.

Fix: Use edge offloading, optimize render pipelines, and implement aggressive power management with activity-based switching.

Desktop UI Patterns on Glasses

Error: Porting mobile/desktop interfaces directly to spatial computing.

Impact: Cluttered field of view, eye strain, and unusable experiences in real-world contexts.

Fix: Design glanceable interfaces with minimal persistent elements. Use audio feedback and contextual appearance over constant visual overlays.

Overlooking Privacy by Design

Error: Building camera/audio features without clear consent mechanisms.

Impact: App rejection, user backlash, and potential legal issues in privacy-conscious markets.

Fix: Implement visible recording indicators, on-device processing where possible, and explicit opt-in for any face/voice data.

Waiting for Consumer Hardware

Error: Delaying development until Samsung/Google glasses ship.

Impact: 12-18 month development lag behind competitors who started with emulators.

Fix: Start building with Android XR Emulator now. Concepts and most code transfer directly to physical devices at launch.

Underestimating Multimodal Complexity

Error: Treating voice, gesture, and gaze as separate input channels.

Impact: Inconsistent, frustrating interactions that fail in real-world use.

Fix: Design unified input flows where voice confirms gaze selection and gestures augment both. Test with actual users walking, talking, and multitasking.

Real Agency Applications

Marketing agencies have unique opportunities to leverage Android XR for client experiences and internal productivity. Here are practical applications we're exploring.

Retail Analytics Overlays

Equip field researchers with XR glasses that overlay real-time analytics on store displays during retail audits.

• SKU-level performance metrics on products
• Competitor positioning comparisons
• Planogram compliance checking
• Voice-noted observations synced to CRM

Event Experience Enhancement

Create AR-enhanced conference and trade show experiences that connect physical presence with digital content.

• Attendee recognition with conversation context
• Interactive booth demonstrations
• Real-time translation for international events
• Navigation and scheduling assistance

Client Presentation Environments

Build immersive pitch environments that let clients experience campaigns in simulated real-world contexts.

• Virtual billboard placements in context
• Retail display mockups in store environments
• Social media feed simulations
• A/B testing with eye tracking analytics

Hands-Free Production

Enable creative teams to work hands-free during photo shoots, video production, and on-site content creation.

• Shot list and storyboard overlays
• Real-time color grading previews
• Client feedback integration via voice
• Asset library access with visual search

Getting Started Now: While consumer hardware is coming in late 2025, agencies can start building expertise today. The emulator provides full SDK access, and concepts transfer from existing AR platforms like ARCore. Starting development now positions you to deliver XR solutions when hardware launches.

FAQ

When will Android XR glasses be available to consumers?

Google has announced Project Aura smart glasses with a targeted late 2025 release, with Samsung's XR headset expected around the same timeframe. Developer Preview 3 is currently available for building and testing applications.

What programming languages are used for Android XR development?

Android XR development primarily uses Kotlin and Java, with Jetpack Compose for UI. The SDK also supports C++ for performance-critical components and OpenXR for cross-platform VR/AR experiences.

Do I need special hardware to develop for Android XR?

During the preview phase, you can use the Android XR Emulator included with Android Studio. For testing on actual hardware, you'll need compatible XR devices once they become available to developers.

How does Android XR differ from ARCore?

ARCore is Google's AR platform for smartphones, while Android XR is a complete operating system designed specifically for dedicated XR hardware like smart glasses and headsets. Android XR builds on ARCore capabilities but adds full OS features, spatial computing, and Gemini AI integration.

Can existing Android apps run on Android XR?

Yes, existing Android apps can run on Android XR in a 2D panel mode. However, to take full advantage of spatial features, apps need to be adapted using the Android XR SDK and spatial UI components.

What role does Gemini AI play in Android XR?

Gemini AI provides multimodal understanding for Android XR, enabling natural language interaction, real-time visual analysis, contextual assistance, and intelligent automation based on what the user sees and hears.

Is Android XR open source like Android?

Android XR is built on the Android Open Source Project (AOSP) foundation, but some components, particularly Gemini integration and certain XR-specific features, may be proprietary Google services similar to Google Play Services on Android phones.

What's the difference between Project Aura and Samsung's XR device?

Project Aura is Google's reference design for lightweight smart glasses focused on everyday wear, while Samsung's device is expected to be a more immersive mixed reality headset. Both run Android XR but target different use cases.

How do I get early access to Android XR development?

Download Android Studio with Android XR support, install the Android XR SDK through SDK Manager, and use the XR Emulator for testing. Join the Android Developers community for updates on hardware developer programs.

What are the main challenges in XR app development?

Key challenges include optimizing for limited battery and thermal constraints, designing intuitive spatial interfaces, handling real-world environment variations, ensuring user comfort to prevent motion sickness, and building for privacy-conscious contexts.

What is Project Aura from XREAL?

Project Aura from XREAL is the first Android XR device in the wired XR glasses category, developed in partnership with Google. It features a 70-degree field of view, optical see-through technology, and is targeted for 2026 availability. Google shared a first look at the device in December 2025.

What's new in Android XR SDK Developer Preview 3?

Developer Preview 3 brings increased stability for headset APIs and opens development for AI Glasses. Key features include the XR Glasses emulator in Android Studio, dynamic glTF model loading, Widevine DRM support, ARCore geospatial features, QR/ArUco code tracking, and experimental body tracking.

What is the XR Glasses emulator?

The XR Glasses emulator is a new tool in Android Studio designed for AI Glasses development. It provides accurate content visualization matching real device specifications for Field of View (FoV), resolution, and DPI, allowing developers to test glasses apps without physical hardware.

Does Android XR support Unity development?

Yes, Android XR provides Unity tools alongside native development. Google announced Unity integration at I/O 2025, allowing developers to use familiar 3D development workflows while targeting Android XR devices.

Is Android XR worth developing for vs Apple Vision Pro?

For most developers and enterprises, Android XR offers better ROI. Key advantages: 48% lower hardware cost ($1,799 Samsung Galaxy XR vs $3,499 Vision Pro), superior Gemini AI integration, existing Android skills transfer directly, and access to 3 billion Android users. Vision Pro excels for premium consumer experiences where display quality matters most.

What's the real development cost for an Android XR app?

Development costs typically range from $30K-$60K for basic XR apps (200-400 hours). Hardware for testing: $1,799 per Samsung Galaxy XR device. Learning curve: 2-4 weeks for experienced Android developers. For enterprise pilots with 50 devices, expect total investment around $135K with potential first-year productivity savings exceeding $1M in field service use cases.

What is Jetpack Compose Glimmer?

Jetpack Compose Glimmer is the new UI toolkit introduced in Developer Preview 3 specifically for AI glasses with transparent displays. It provides lightweight overlay components optimized for optical see-through displays, ensuring readability in varied lighting conditions while minimizing distraction from real-world activities.

How does Gemini Live API work on AI glasses?

Gemini Live API enables real-time conversational AI that sees what you see. It processes camera feed, audio input, and location context to provide contextual assistance. For developers, integration happens via Firebase AI Logic SDK with support for streaming audio/visual input and on-device processing through Gemini Nano for privacy-sensitive operations.

What's the difference between AI glasses and XR headsets?

AI glasses (like Google's upcoming designs with Warby Parker and Gentle Monster) prioritize all-day wearability with lightweight form factors and audio-first or minimal display experiences. XR headsets (like Samsung Galaxy XR) offer full immersive experiences with passthrough mode, hand tracking, and spatial computing for productivity and entertainment. Choose glasses for contextual assistance, headsets for immersive applications.