Today at I/O, we announced new ways to vibe design with Stitch, transforming your design experience into a live, collaborative partnership with the Stitch Agent — allowi…
Intelligent eyewear combines new hardware and the power of Gemini, you can get directions, send texts and snap photos — without taking out your phone.
We're expanding our tools to help you understand how content was created and edited across the web.
We're introducing new tools to take your ideas from a prompt to a production-ready application, including updates to Google Antigravity, an enhanced Gemini API and nativ…
Announcing new voice capabilities in Gmail, Docs and Keep, a new design tool called Google Pics and updates to AI Inbox.
Today, we are excited to introduce Wear OS 7, a major update that brings a new era of power efficiency and intelligence to users and developers alike.
We recognize that watches are essential, all-day companions to your users. That’s why we're continuing to invest in power optimizations so your users can do more with their favorite apps. For watches upgrading from Wear OS 6 to Wear OS 7, average users can expect up to 10% improvement in battery life.
As part of a broader rollout to the Android ecosystem, select watches arriving later this year will come with Gemini Intelligence, providing proactive and personalized help to our users so they can focus on what matters.
With Wear OS 7, we’re introducing new system capabilities and enhanced developer tools. New user-facing features like Live Updates, and enhanced media controls deliver a smarter, more intuitive personalized experience on the wrist. And with enhancements to our developer toolkit such as Wear Compose 1.6 and AppFunctions, developers will be able to streamline their apps for efficient, intuitive experiences on the wrist.
Let's dive right in!
You can now try out the next version of Google’s smartwatch platform, Wear OS 7 Canary Emulator, based on Android 17 that's arriving later this year.
The new emulator allows you to get hands-on with the developer features and tools mentioned above while testing your app for compatibility with the upcoming platform.
Check out what’s changed and start testing your app today.
Today, we’re excited to introduce the next step in the evolution of Tiles: flexible and dynamic Wear Widgets.
Powered by Jetpack Glance and the new RemoteCompose framework, Wear Widgets offer greater expressiveness and consistency with Compose than the Tiles ProtoLayout libraries. Wear Widgets support two new card layouts—small and large, that align perfectly with the 2x1 and 2x2 formats on mobile, ensuring your designs feel cohesive across devices, while still allowing you to optimize your designs for the wrist.
It’s easy to adapt the UI from the mainSlot of your full-screen tile to a 2x2 Widget. Take a look!
Check out the Widgets I/O Talk later this week for full details on the new features, and try out our Widgets Getting Started Guide to add a Widget to your Wear OS experience.
Wear OS 7 brings Live Updates to watches!
You can use Live Updates to surface real-time, important information from your watch or mobile app, providing your users with timely updates at a glance.
In your watch app, use Live Updates instead of the Ongoing Activities API to provide local update publishing on all Wear 7 devices. For supporting OEMs, Live Updates published by your phone app will also be bridged to users' watches.
Check out how Just Eat provides updates to their users, above!
For more information, check out Notifications on Wear OS.
The AppFunctions API allows developers to integrate their apps with agents and assistants, like Google Gemini, enabling users to complete tasks using voice, often replacing the need for step-by-step, manual navigation with your UI.
For example, to start a run with the Samsung Health app, users are able to tell Gemini: “Start tracking my run.”
We’re currently running an Early Access Program for any developers who are interested. Sign up in our form to express your interest.
Also coming soon, without any development effort at all, users will be able to invoke and track automated app tasks, for selected phone apps, directly from their watch, like placing an order with DoorDash!
Keep an eye out for these flexible options on how to prepare and connect your app to the Android intelligence system on our developer blog.
Wear OS 7 enhances the System Media Controls, giving users more control and seamless experiences for their media.
Users can now personalize their media auto-launch experience per-app directly from the System Media Controls on the watch.
For any app where the user has ‘Auto-launch Settings’ toggled on, media controls will automatically appear on the watch when media is started on the phone.
Developers with an existing implementation of media apps that extend on the watch can benefit from this feature without additional effort.
Managing audio output is now easier than ever with the new Remote Output Switcher integrated into the System Media Controls.
When listening to media on a paired phone, users can effortlessly switch the device the media is played back on directly from their wrist.
To go along with all these new features for users, we’re introducing some powerful enhancements to our developer toolkits to help developers prepare for the future of Wear OS!
As the foundation for Wear OS development, Compose for Wear OS 1.6 has arrived.
It includes powerful updates including:
Developers can Integrate with Navigation 3 to provide a more flexible and Compose-idiomatic way to handle navigation on Wear OS.
Posted by John Zoeller, Developer Relations Engineer @Composable
fun WearApp() {
val backStack = rememberNavBackStack(MenuScreen)
WearAppTheme {
AppScaffold {
val entryProvider = remember {
entryProvider<NavKey> {
entry<MenuScreen> { GreetingScreen() }
entry<ListNavScreen> { ListScreen() }
}
}
val swipeDismissableSceneStrategy = rememberSwipeDismissableSceneStrategy<NavKey>()
NavDisplay(
backStack = backStack,
entryProvider = entryProvider,
sceneStrategies = listOf(swipeDismissableSceneStrategy)
)
}
}
}Significant improvements are here for advanced list management with TransformingLazyColumn, including enhanced padding support via the new minimumVerticalContentPadding modifier, and other new features like snapping and reverse layout.
val listState = rememberTransformingLazyColumnState()
val transformationSpec = rememberTransformationSpec()
/*
* TransformingLazyColumn takes care of the horizontal and vertical
* padding for the list and handles scrolling.
*/
ScreenScaffold(scrollState = listState) { contentPadding ->
TransformingLazyColumn(
state = listState,
contentPadding = contentPadding
) {
item {
ListHeader(
modifier = Modifier
.fillMaxWidth()
.transformedHeight(this, transformationSpec)
.minimumVerticalContentPadding(
ListHeaderDefaults.minimumTopListContentPadding
),
transformation = SurfaceTransformation(transformationSpec)
) { Text(text = "Header") }
}
}
}
The all new LocalAmbientModeManager is optimized for handling ambient flows, giving developers greater control over how their ambient experiences are presented to users.
override fun onCreate(savedInstanceState: Bundle?) {
setContent {
val ambientModeManager = rememberAmbientModeManager()
CompositionLocalProvider(LocalAmbientModeManager provides ambientModeManager) {
val localAmbientModeManager = LocalAmbientModeManager.current
val ambientMode = localAmbientModeManager?.currentAmbientMode
Column(
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally,
modifier = Modifier.fillMaxSize(),
) {
val ambientModeName =
when (ambientMode) {
is AmbientMode.Interactive -> "Interactive"
is AmbientMode.Ambient -> "Ambient"
else -> "Unknown"
}
val color = if (ambientMode is AmbientMode.Ambient) Color.Gray
else Color.Yellow
Text(text = "$ambientModeName Mode", color = color)
}
}
}
}
While we encourage developers to adopt the new Wear Widgets, we will continue to support our Protolayout and Tiles libraries for some time, and we’ve got new stable versions of both.
Protolayout 1.4 and Tiles 1.6 work together to provide several notable new features including:
ImageResource can now be directly inlined within a layout, and Tiles now support automatic resource collection through ProtoLayoutScope,removing the need for manual resource mapping and splitting into separate methods. In addition to better code quality, this improves Tiles loading latency via consolidation into a single binder call from system to the provider service.Material3TileService – an all-encompassing suspend function which returns both tile layout and resources, while automatically managing the MaterialScope and ProtoLayoutScope to simplify the development experience.TileService instances can now be grouped in the manifest to enable dynamic switching between different services that represent the same tile.Check out the new Tiles sample here.
Watch Face Format version 5 (WFF5) is now available with a host of new features to make it easier to build watch faces, including:
TextCircular have additional alignment options, including verticalAlign on the same baseline for multiple text elements.isAutoSize can now be used on TextCircular,and a new attribute, minSize, has been added to the Font element to limit the minimum size when autosizing is enabled.Group and ComplicationSlot elements now support blend mode, in addition to existing support on Part* elements.Stroke and WeightedStroke elements now include a join attribute.childSettingIds and complicationSlotIds on User Style Options.Check out our new developer guidance to learn more about WFF 5.
With these updates, there’s never been a better time to develop an app on Wear OS. These technical resources are a great place to learn more about how to get started:
We’re looking forward to seeing the experiences that you build on Wear OS!
Explore this announcement and all Google I/O 2026 updates on io.google.
Today, we are excited to announce that official support for Unreal Engine and Godot has arrived for Android XR. Alongside these engine expansions, we are also launching new tools designed to boost your productivity and enable new XR capabilities: the Android XR Engine Hub and the Android XR Interaction Framework.
The Android XR Engine Hub is currently available for Windows and is your mission control for development. It unifies your workflow across Unity, Unreal Engine, and Godot by serving as a high-speed bridge that streams device-created perception data straight from your device into the engine of your choice.
The Hub bridges the gap between desktop power and mobile sensor data. Instead of requiring a full build to see how your app reacts to the world, the Hub streams OpenXR extensions from the physical Android XR device directly to your Windows machine.
This means you can iterate on complex interactions in "Play Mode" while receiving live, high-fidelity data from the headset’s sensors. Without this streaming capability, testing even a minor change to eye-tracking or spatial mapping would require a full APK export and installation.
The Hub enables low-latency testing for the following streamed extensions:
Core & Interaction Support
Android XR Vendor Extensions
.png)
XR_ANDROID): Stream expressive avatar data to your editor to refine social presence without building.By virtualizing the device's hardware capabilities and streaming them over a low-latency desktop bridge, the Android XR Engine Hub allows for game engine developers to quickly iterate.
Download the Hub:
Get the Android XR Engine Hub for Windows
Learn more about Direct Preview
Through our commitments to OpenXR standards, we are ensuring that whether you are a veteran studio or an indie developer, you have best-in-class tools to help bring your creative vision to life.
Unreal Engine support is now available in developer preview, targeting version 5.6.1. This integration is built directly on using OpenXR with the support for AndroidXR vendor specific API using the Android XR vendor plugin for Unreal, you can access platform-specific extensions for advanced hand tracking, face tracking, and scene understanding (like plane detection and depth) whilst making use of Unreal blueprints or C++ support.
Get Started with Unreal:
In partnership with the Godot Foundation and W4 Games, we are bringing official Godot support to Android XR for Godot 4.6.2 and higher.
We are already seeing incredible momentum from W4 as they have ported experiences like MoAT and Expedition to Blobotopia that are already live on Google Play, proving that Godot is ready for production-grade spatial experiences today.
To unlock the full potential of the platform, use the Godot OpenXR Vendors plugin 5.1, which provides the necessary Android XR vendor extensions for features like scene meshing, dynamic resolution, light estimation and much more. We're collaborating with Godot to optimize the OpenXR implementation for the Android XR power profile and input standards.
Get Started with Godot:
The Unity OpenXR: Android XR 1.13 package is now available for Unity 6.5 Beta. Unity has expanded Application SpaceWarp support to include both uGUI and TextMeshPro. Keep an eye out for the general release of Unity 6.5 and more platform enhancements arriving this summer.
Android XR Extensions v1.3.1 for Unity
Everything else you need for comprehensive platform integration is available in our latest Android XR Extensions release:
android.software.xr.api.SPATIAL manifest tag directly through XRSessionFeature settings, making it easier than ever to define your app's Spatial API requirements and target levels.TryGetFineEyePoses extension method.Note: Android XR (Extensions): Hand Mesh has been removed; you should now use the unified Hand Mesh Data within the extensions package.
The Android XR Interaction Framework (AXRIF) is now available in developer preview. AXRIF is an unstyled, opinionated input toolkit that abstracts the complex logic required to build interfaces that are consistent with Android XR system interactions.
Instead of focusing on UI visuals, AXRIF prioritizes the underlying mechanics of the Android XR user experience. At its core is the same Transition Manager that powers the system's rich multimodal inputs, enabling state switching between 6DoF controllers, 3D mouse, hand tracking, and eye gaze. By leveraging this framework, developers can significantly reduce the implementation burden required to bring Android XR's full complement of robust interactions to their apps.
At launch, the framework provides three core capabilities:
By adopting AXRIF, your app inherits the platform's native interaction model, ensuring your app feels consistent with the rest of the OS.
Explore the Toolkit:
Interaction Framework Documentation
Download the Unity Package
There has never been a better time to dive into Android XR development. With support across Unity, Unreal, and Godot, the platform is ready for your creative vision, no matter which engine you call home. Explore our official engine partners to get started:
By Simon Cooke, Developer Relations Engineer (X) and Mayank Jain, Product Manager (X)
Android Performance Analyzer (APA) is Android’s new profiler and performance analysis tool for the Android mobile ecosystem.
APA is intended as a profiling tool for any developer building for Android who needs to make their app or game run better and faster. It is helpful for all performance-minded engineers, especially those using Vulkan in their game engines who want to squeeze every bit of performance out of their code.
APA aims to be the tool that helps you optimize apps and games for all modern Android devices and simplifies your most common workflows, with a simple interface that anyone on your team can quickly learn and be productive.
Available today in open beta is APA’s new System Profiler that you can use to analyze the CPU, GPU, Memory, and power usage of your app or game - and see how it interacts with system behavior.
Developed in collaboration with Samsung Austin Research Center (SARC) and LunarG, APA relies on Perfetto for system tracing and its upcoming frame profiling/debugging features (stay tuned!) are powered by LunarG’s GFXReconstruct technology for graphics capture and replay.
Devices running Android 12+ will provide the best experience for capturing system-wide performance and GPU counters and render stages.
We’re also working across the Android ecosystem with our esteemed industry partners to bring more profiling & optimization related data into APA.
APA ships in two different forms, and you can download whichever one suits your needs best
The standalone desktop app is intended to be used without an Android Studio project or Gradle build - and provides deep customization of recording configuration, built-in Vulkan layers for graphics analysis, deep inspection of GPU counters and much more.
APA is also cross-platform: works natively on Windows, MacOS, and Linux.
Capturing your profile data
You don’t always want to take a capture immediately at application or game launch. APA allows you to choose, and capture traces from your device at launch or triggered manually. The user interface allows you to select which GPU counters and other data is captured in a trace - and if you have more complex needs, you can provide your own custom Perfetto configuration.
Deep-Dive System Analysis
With APA, you can analyze the entire system’s behavior in one view. For example, you can easily examine CPU cores - both their frequencies and the work scheduled on them or inspect processes & their thread activity.
For graphics-heavy apps, APA provides GPU performance counter data across hardware from Qualcomm, Arm, Imagination, and Samsung. You can even track battery and power consumption to see the impact of your code on power consumption.
To understand exactly where frames are spending time, SurfaceFlinger events provide deep visibility into the rendering and display composition pipeline, from initial code acquisition to final display. And with the new screenshots feature, you can visually scrub through to easily find the exact areas where you want to focus your attention.
You can open existing Perfetto traces, zoom through the timeline for precise detail, and use rulers to measure the duration of work and events. APA also lets you bookmark and annotate interesting findings, and you can pin critical tracks to the top of your screen to keep your focus exactly where it needs to be as you optimize.
Tabbed interface and split windows: You can open multiple traces in side-by-side tabs or split a single trace into two windows to compare different regions of the same trace simultaneously.
Tabbed interface showing two traces side-by-side.
Project-based workflow: APA uses a project model that allows you to keep track of multiple traces from the project sidebar. This is especially useful for gathering the results of A/B testing and longitudinal tests, and keeping all of your results together for comparison & quick access purposes.
The new project window helps you manage multiple traces.
Navigate visually using screenshots: APA lets you capture screenshots during a trace (without any noticeable performance overhead) to home in on areas where you saw something affect performance by scrubbing through the timeline. Or even just to get your bearings.
Scrubbing the timeline using screenshots for navigation (trace taken from NetMarble’s Seven Deadly Sins: Origin).
Persistent view customizations: When you pin or vertically resize tracks, we save those customizations so that they persist the next time you open the trace.
Vulkan debug trace markers for render passes: We support Vulkan debug annotations for render passes - which allow you to view Render Pass names you set from your codebase directly in the tracks and slices shown in APA.
This immensely helps you to make logical connections between the workloads you see in the profiler to where they are originating from in your codebase.
Vulkan Debug Markers allow you to keep track of what kind of work is being performed in your trace.
Use AI to build SQL queries for custom analysis work: APA supports trace analysis via SQL queries and ships with a new Perfetto SQL skill for use with your favorite AI agents. This makes it easier to build queries without needing to remember Perfetto SQL schemas or the SQL syntax.
Ask Gemini to analyze traces for you: We’ve also added another Perfetto Analysis skill to answer high-level questions for you - like “Why is my app startup slow?” - helping you to find starting points when analyzing complex traces, using your favorite AI agent to pinpoint the answers.
Agentic trace analysis in Android Performance Analyzer
FPS and Frame Duration times : You can review the FPS and Frame duration time at a glance in the tracks to correlate it with other activity happening in your trace.
Speed and robustness improvements: Rendering a trace is now typically 6x to 26x faster than Android GPU Inspector, and APA is significantly more stable when working with large traces.
We’ve worked with our early access partners to create detailed case studies showcasing how APA could be used to improve performance for Vulkan apps & games.
The Forge used Android Performance Analyzer to identify the need to batch calls to vkCmdBindDescriptorSets, which reduced CPU setup costs by ~50%. This, in turn, slowed heat production on their device by 2-3x, leading to longer session times. They also used APA to identify opportunities to move font and UI rendering work over to the GPU, improving scalability.
You can read the full case study from The Forge here.
Note: This case study demonstrates how to use custom SQL queries in the profiler to generate a total rendering cost metric.
The Forge case study showing frames presented consistently at a stable 30 FPS using APA
Netmarble used Android Performance Analyzer to fine-tune their game Seven Deadly Sins: Origin, focusing particularly on improving performance by making changes to the precision of their shaders, and exploring the impact of upscaling on the performance of their renderer.
This allowed them to reduce the GPU cost of rendering some scenes by up to 90%.
Read the full NetMarble case study here.
Netmarble validating pre- and post-optimization performance changes using APA for their game: Seven Deadly Sins: Origin
Google has been improving the Filament glTF Viewer, our physically-based rendering engine.
We spent some time digging into the viewer with a variety of scenes, and showed how to use Android Performance Analyzer to identify scenes that are too complex for the GPU, and how to trim them down to hit a target 60FPS, by improving texture compression and optimizing geometry. Memory consumption was also reduced in this process.
You can read our exploration of Filament here.
Screenshot showing GPU wait time was reduced from 25ms to 20ms by introducing dynamic resolution and measuring it through APA
The Android Performance Analyzer is available for you to try out and use today:
This is beta software, which means that you might run into an occasional bug – please report it to us if you find any (Help Menu > Submit a bug report).
We’re excited to see how you use the new Android Performance Analyzer, and how it will help your project’s performance and reliability.
Explore this announcement and all Google I/O 2026 updates on io.google.
This year at Google I/O we are going beyond iterative changes, towards a fundamental shift in how apps are built. Our newest tools are built for the agentic era with features that boost productivity for you as an Android developer AND supercharge the AI agents you deploy in your codebase. So, whether you are building exclusively with AI or you prefer being the architect of every line of code, our tools will keep you ahead of the curve.
As we move from "AI-assisted" to "Agentic" development, we’re making it easier than ever to turn a spark of an idea into a high-quality production app with significantly less developer effort.
So what’s new with Android developer tools? We will cover 3 main areas in this blog:
Let your agent handle it: Whatever development task you are working on, the Android Studio agent can help: from planning the app architecture and design, to writing code, to unit testing and bug fixing.
Any AI provider, anywhere you build: In Android Studio, you can use any model and we even help guide you to the best performing ones. Choose any of the top remote models from Google, Anthropic, OpenAI, or if you need to run locally - Gemma 4 is our most capable and efficient local model! And with Android CLI, you can build Android apps faster and easier using the agents and developer environments of your choice.
As always, performance and quality remain top priorities: We continue to invest in the Android developer tools you love: from the Emulator, to Profilers, performance analyzers, and more!
Android Studio now supports Agent Skills, modular instruction sets that ground LLMs in specialized workflows and domain-specific knowledge. By adding skills to your project, you can teach the agent to follow specific best practices, architecture patterns, or library workflows. This enables more accurate, context-aware code generation and automated skill activation for an appropriate task, ensuring the agent acts as an expert. We’ve bundled many of the top Android and Firebase agent skills in the latest Android Studio Canary build, so you can skip straight to building!
Skills in Agent ModeYou can create your own skill, or use Android CLI to install our official skills - a repository that covers some of the most common workflows that some Android developers and LLMs may struggle with. They help models better understand and execute specific patterns that follow our best practices and guidance on Android development, such as XML to Compose migration, Edge-to-edge, Navigation 3, and more. You can even build for Android XR, starting with a beautiful Display Glasses app with Jetpack Compose Glimmer. Official Android skills are automatically bundled with the latest Android Studio so the Agent is ready to build!
Firebase services like Auth and Firestore databases can now be enabled directly within Agent Mode in Android Studio using the Agent Skills for Firebase. Your agent will be able to complete Firebase integration and configure backend services. This integration empowers you to build robust, full-stack Android applications without ever leaving your IDE!
You can now run multiple conversations with Agent Mode in parallel. In one conversation, run tests and while you are waiting, you can kick off planning mode for a new feature in your app while using a third conversation thread to write documentation for your app. These improvements will save you time and improve your productivity.
Android Studio's New Project Agent has evolved into a powerful full-stack development tool, utilizing a multi-step execution plan and an autonomous "generation loop" that self-corrects build errors and configures dependencies across multiple files. This advanced capability is significantly amplified by its new integration with Firebase Agent Skills, allowing developers to seamlessly build, debug, and deploy complete full-stack applications directly from a single prompt to final production.
Additionally, it now offers support for large screens. You can scaffold your project with layouts, navigation, and components optimized for tablets, foldables, and laptop devices from the get-go. It has additional logic to test your app on large-screen emulators if you have one enabled. Simply configure the required device in the Android Emulator and the Agent can test it out!
Google AI Studio now features full Android app development capabilities. Users can generate new applications, preview them instantly via an embedded Android Emulator, and deploy them directly to physical devices using ADB over USB. Additionally, developers can publish straight to Google Play; AI Studio handles the app record creation, bundles the package, and uploads it to an internal testing track. For advanced development and production readiness, projects can be exported as a ZIP file and opened seamlessly in Android Studio. To get started, visit Google AI Studio today and start building!
Google AI Studio build mode with Android frameworkAndroid CLI enables you to build apps using any agent, LLM, and tool of your choice. Android CLI is designed to help AI agents build faster, and use less tokens when compared to only using generic LLM tools. By grounding agents with Android Knowledge Base and Android skills, you can now have your agent of choice follow the latest best practices across any coding environment.
Additionally, when using the latest Canary version of Android Studio Quail, Android CLI enables your agent to leverage powerful capabilities of the IDE, such as analyzing files for issues or finding symbol declarations. Google Antigravity 2.0 now offers official support for Android development with Android CLI.
ADB Wi-Fi 2.0 offers significantly more reliable wireless debugging. With the latest ADB command line tool from Android Platform Tools v37 and an Android 17 device, you can now change networks, shut down your machine, and go about your typical day and your devices will stay connected. Additionally, devices with wireless debugging enabled will automatically show in Android Studio’s Device Manager, streaming the pairing process and making it easier than ever to connect Android phones, watches, and more.
Upload App Bundle to Google Play
Android Performance Analyzer (APA) is the next generation of performance profiler for Android and provides a cohesive analysis of CPU, GPU, memory, and power usage for your apps and games running on Android 12+ devices. APA is engineered for reliability and performance with trace rendering speeds which are up to 26x faster from previous tooling.
APA integrates natively with AI agents and offers two new skills: Perfetto SQL skill and the Perfetto Analysis skill, which helps with questions like "Why is my app startup slow?"
Explore this announcement and all Google I/O 2026 updates on io.google.
Today we're excited to launch Developer Preview 4 of the Android XR SDK, continuing our focus on unifying cross-device development for headsets, wired XR glasses, and intelligent eyewear. To keep our platform intuitive, we are adopting more descriptive naming for our form factors, where AI glasses are now audio glasses and display AI glasses are now display glasses, with these changes appearing in our documentation starting today.
This release is packed with updates that help you build incredible experiences for XR devices, enable deeper immersive experiences on XR headsets, and streamline the path for creating augmented experiences on audio and display glasses. Also, our core libraries—including XR Runtime, Jetpack SceneCore, and ARCore for Jetpack XR— will be officially moving to Beta soon!
To give you early access to hardware and resources for building immersive and augmented experiences on upcoming devices—like display and audio glasses and XREAL’s Project Aura — we’re announcing the Android XR Developer Catalyst Program. Learn more and start your application today.
Starting out with our libraries for augmented experiences, Developer Preview 4 introduces new APIs that help you create and test your apps.
Jetpack Projected: Device Availability and ProjectedTestRule APIsThe Jetpack Projected library helps bridge app experiences from the phone to the user's field of view. We've added the Device Availability API, which consolidates wear state and connectivity signals into standard Android Lifecycle.State values. This lets you adjust your applications behavior based on whether the device is worn.
val xrDevice = XrDevice.getCurrentDevice(projectedContext)
// Observe the device lifecycle flow
xrDevice.getLifecycle().currentStateFlow
.collect { state ->
when (state) {
Lifecycle.State.STARTED -> { /* Device is available (worn) */ }
Lifecycle.State.CREATED -> { /* Device is unavailable (not worn) */ }
Lifecycle.State.DESTROYED -> { /* Device is DISCONNECTED */ }
}
}
To simplify testing, the new ProjectedTestRule API in the projected-testing artifact automates the setup of projected test environments. This helps you write clean, reliable unit tests without the boilerplate code.
// from the 'androidx.xr.projected:projected-testing:1.0.0-alpha07' artifact
@get:Rule
val projectedTestRule = ProjectedTestRule()
@Test
fun testProjectedContextInitialization() {
// by default, ProjectedTestRule automatically creates and connects
// a projected device before each test
val projectedContext = ProjectedContext.createProjectedDeviceContext(context)
// assert the projected context is successfully initialized
assertThat(projectedContext).isNotNull()
}
Jetpack Compose Glimmer: Google Sans Flex and new components
Our UI library for display glasses, Jetpack Compose Glimmer, now includes Google Sans Flex for improved legibility on optical see-through displays. We’ve also added several interactive components:
If you're looking to build fully immersive experiences for XR Headsets and wired XR Glasses, we have several big updates.
Beta Transition & Modern ArchitectureXR Runtime, Jetpack SceneCore, and the ARCore for Jetpack XR perception features (Depth Maps, Eye/Hand Tracking, Hit Testing, and Spatial Anchors) will soon move to Beta, so we’ve streamlined the Jetpack XR APIs. We've removed legacy Guava and RxJava3 packages in favor of a modern, Kotlin-first architecture.
Jetpack SceneCore: glTF and Custom MeshesWe're expanding 3D model capabilities by adding the ability to fine tune 3D models and access specific nodes with a 3D model. Using GltfModelNode, you can modify properties like pose, materials, and textures, and even run animations for specific nodes.
// Create a new PBR material
pbrMaterial = KhronosPbrMaterial.create(
session = xrSession,
alphaMode = AlphaMode.OPAQUE
)
// Load a texture.
val texture = Texture.create(
session = xrSession,
path = Path("textures/texture_name.png")
)
// Apply the texture and configure occlusion
pbrMaterial.setOcclusionTexture(
texture = texture,
strength = 0.5f
)
// Access the hierarchy of nodes
val entityNodes = entity.nodes
// Find the specific node
val myEntityNode = entityNodes.find { it.name == "node_name" }
// Apply the PBR material override
myEntityNode?.setMaterialOverride(
material = newMaterial
)
// Create the meshval roadMesh =
CustomMesh.BuilderFromMeshData(session, roadVertexLayout)
.addVertexData(ByteBufferRegion(roadDataBuffer, 0, vertexDataSize))
.setIndexData(ByteBufferRegion(roadDataBuffer, vertexDataSize, indexDataSize))
.setTopology(MeshSubsetTopology.TRIANGLES)
.build()
// Define the material
val roadMaterial = KhronosPbrMaterial.create(session, AlphaMode.OPAQUE)
// Instantiate the entity using the custom mesh and material
val roadEntity =
MeshEntity.create(
session,
roadMesh,
listOf(roadMaterial),
pose = roadPose,
)
We now have native glTF support directly in Compose for XR with SpatialGltfModel. Use this along with SpatialGltfModelState to access nodes and animations in the glTF model, or use them to add textures and materials to your 3D models.
val myGltfModelState = rememberSpatialGltfModelState(
source = SpatialGltfModelSource.fromPath(
Paths.get("models/my_animated_model.glb")
)
)
val myGltfAnimation =
myGltfModelState.animations.find { it.name == "animation_name" }
DisposableEffect(myGltfAnimation) {
myGltfAnimation?.loop()
onDispose {
myGltfAnimation?.stop()
}
}
SpatialGltfModel(state = myGltfModelState, modifier = modifier)
We’re also providing an early preview of the Geospatial API for wired XR Glasses in ARCore for Jetpack XR. This update enables high-precision anchoring of digital content tied to real-world locations in over 87 countries.
By combining ARCore’s Visual Positioning System (VPS) with the reasoning and audio capabilities of the Gemini Live API, you can create contextually aware experiences that understand both the location and position of your user. Imagine building an immersive, AI-guided walking tour that provides real-time audio descriptions of nearby places, seamlessly blending digital information with the physical environment.
It's an amazing time to develop for Android XR. With the Jetpack XR SDK moving to Beta soon and a robust set of new tools at your fingertips, explore each of the following areas to get your app's experiences ready for XR!
Read the documentation, explore the samples, and check out the XR experimentsHead to the official Android Developer site for full technical guides, API reference, and instructions on setting up the new emulator. Get inspired with our samples and experiments. See how we've used these APIs to build immersive spatial layouts, load 3D models, explore spatial audio, and more!
We've added official support for Unreal Engine and Godot, and we've launched two new tools to accelerate development for Android XR with Unity and the Android XR Interaction Framework. And, based on your feedback, we are introducing the Android XR Engine Hub to allow you to run your experiences directly from your preferred engine,
Don’t miss your chance to build for the latest Android XR hardware. Apply today for the opportunity to gain access to pre-release hardware, including our audio and display glasses prototype and XREAL’s Project Aura.
We look forward to seeing the amazing XR experiences you build as we move toward the launch of more Android XR devices later this year!
Explore this announcement and all Google I/O 2026 updates on io.google.