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!

Wear OS 7 Canary

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.

Explore new Wear OS features

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.

Live Updates

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.

Connect your app to the intelligence system

AppFunctions

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.

Task automation

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 Workout Tracker

We know that building a full-featured, high-quality fitness tracking experience on Wear OS from scratch is resource-intensive, so we built the all new Wear Workout Tracker experience for exercise apps. It will be included in Wear OS later in the year. 

The workout tracker provides a rich standardized workout tracking experience which includes heart rate monitoring, media control, and a collection of other useful features to help you reduce development investment while guaranteeing a high-quality experience for your users.

We’ve been working closely with ASICS Runkeeper to bring it to their users, check it out!

Enhanced System Media Controls in Wear OS 7

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.

UI Library updates

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!

Compose for Wear OS 1.6

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.

@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)
            }
        }
    }
}

Protolayout & Tiles updates

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:

• Inlined Image Resources: 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: Tiles can be implemented as a 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.
• Dynamic Service Switching: On Wear 7, multiple 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.

WFF 5

Watch Face Format version 5 (WFF5) is now available with a host of new features to make it easier to build watch faces, including:

• Enhanced Alignment Options: Text elements like TextCircular have additional alignment options, including verticalAlign on the same baseline for multiple text elements.
• Auto-Size Enhancements: 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.
• Blend Modes: Group and ComplicationSlot elements now support blend mode, in addition to existing support on Part* elements.
• Stroke Joins: Stroke and WeightedStroke elements now include a join attribute.
• Hierarchical settings: User Styles can now be structured as a hierarchy, where some settings are visible only when other settings have specific values. User Styles can now enable or disable complication slots as well. These can be configured using the childSettingIds and complicationSlotIds on User Style Options.

Check out our new developer guidance to learn more about WFF 5.

Start building for Wear OS 7 now

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:

• Learn about designing and developing for Wear OS
• Check out Wear OS samples on Github
• Get started with the latest Wear OS 7 emulator

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.

Posted by Nick Butcher, Product Manager

In the almost-5-years since Jetpack Compose launched, we've invested in bringing you all the features, performance and tools that you need to build amazing UIs across the variety of Android devices. Compose helps you to build beautiful, adaptive UIs that meet the demands of modern UI design.

• Rich feature set: With a powerful library of layouts, input, graphics, animation APIs, and the latest Material Design components, Compose empowers you to build anything.
• Highly performant: Out of the box, Compose offers native performance, delivering a delightful experience to your users.
• Adaptive: Compose offers the easiest way to build adaptive apps that work across the range of Android form factors.
• Productive: With powerful tools like Previews and Live Edit and the full expressiveness of Kotlin, teams tell us that they move much faster when building with Jetpack Compose, reducing the time to market.

Compose has matured into the standard for Android UI development—we believe that all Android UI should be built with Compose; we call this going Compose First. From today, we'll provide all APIs, libraries, tools and guidance in Compose. We now consider the View components that Compose replaces (components in the android.widget package) to be in maintenance mode. We have no plans to deprecate or remove View components and will continue to support them with critical bug fixes, but they will receive no new features.

View-based Jetpack Libraries
The same goes for View based libraries like Fragments, RecyclerView or Viewpager — we consider them complete and will only publish critical bugfixes. For a complete list of libraries now in maintenance mode, see here.


Tools
Any new Android Studio UI tools will be built for Jetpack Compose only. Existing view-based tools (such as the Navigation Editor and Layout Editor) are now in maintenance mode and will not receive new features.


Guidance
Documentation, codelabs, and samples will focus on building UI with Jetpack Compose. You can still find Views-specific documentation linked from pages that contain generic and Compose information, where relevant.

Happy Composing

By Simon Cooke, Developer Relations Engineer (X) and Mayank Jain, Product Manager (X)

What is Android Performance Analyzer?

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. 

How to get Android Performance Analyzer

APA ships in two different forms, and you can download whichever one suits your needs best

• As a lightweight standalone desktop app.
• And also integrated directly into Android Studio as the updated System Trace viewer (available in Panda 4 canary builds and later).

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.

Features in this release

Basic profiling functionality

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.

Workflow features

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.

Analysis tools & new skills for AI agents

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 & robustness improvements

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.

Case studies

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 Interactive

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 – Seven Deadly Sins: Origin

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

Profiling model complexity in Google’s Filament engine

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

Try out the Android Performance Analyzer Beta today!

The Android Performance Analyzer is available for you to try out and use today:

• Standalone profiler: https://developer.android.com/android-performance-analyzer
• Android Studio Canary Build (Panda 4 canary builds and later): https://developer.android.com/studio/preview

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.