Jetpack Compose 1.13 adds adaptive layouts and AppState

At the Android Developer Summit on November 4, 2026, Google announced significant updates to Jetpack Compose, focusing on adaptive development for a multi-device ecosystem. The release introduces new layout primitives, architectural state management tools, and enhanced input handling to support devices ranging from phones and foldables to in-car displays and the new Googlebook form factor.

What happened

The Android ecosystem now spans a wide variety of screen sizes and interaction models, making adaptive development a core requirement rather than an optional enhancement. To address this, the team presented Jetpack Compose as the unified standard for building user interfaces, moving developers away from the fragmented legacy View system. The goal is to provide a single development target that reduces the friction of maintaining separate codebases for different form factors while ensuring apps remain coherent when windows resize or screens fold.

A major part of the announcement focused on expanding Compose beyond just the visual layer into the application architecture. The team introduced Jetpack AppState, currently in alpha, which brings Compose’s snapshot-based state system into the data layer. This allows developers to share observable state across activities, background services, widgets, and App Functions. Additionally, the upcoming Compose 1.13 stable release includes built-in support for adaptive layouts through new Grid and Flexbox components, alongside visual enhancements like Progressive Blur and Formatted Text.

Navigation and input systems also received substantial upgrades to handle complex multi-device scenarios. Jetpack Navigation 3, version 1.2, now offers type-safe deep linking using Kotlin Serialization, allowing developers to map URIs directly to strongly typed navigation keys. On the input side, Compose’s layered input system now supports trackpads, mice, and physical controls, enabling seamless interactions on desktop-class devices like Googlebook. To assist with implementation, Google released updated Android skills for coding agents, helping automate the transformation of compact mobile layouts into responsive multi-pane experiences.

How it works

Jetpack AppState integrates Compose’s reactive state model into the broader app architecture. It introduces two primary components: Transform and StateStore. Transform allows developers to derive reactive state from existing State and Flow inputs using automatic read tracking and standard Kotlin control flow. This eliminates the need for complex boilerplate when combining multiple data sources. StateStore acts as a keyed container that holds observable state, making it accessible across different parts of the application, including background services and widgets. It also supports optional persistence via DataStore, ensuring state consistency even when the app is not in the foreground.

For layout adaptation, Compose 1.13 introduces native Grid and Flexbox components. These primitives allow interfaces to reflow content dynamically based on available screen space, rather than simply stretching elements. When combined with WindowManager APIs, these components enable apps to transition smoothly between single-pane mobile views and multi-pane desktop or tablet layouts. The new BasicTextField implementation uses a buffer-driven architecture and TextFieldState to manage text editing. This redesign resolves Input Method Editor (IME) race conditions and supports rich text formatting, providing a more reliable editing experience across devices with different input methods.

Key details

• Compose 1.13 stable release includes built-in Grid and Flexbox layouts, Progressive Blur, and Formatted Text support.
• Jetpack AppState (alpha) introduces Transform for reactive state derivation and StateStore for sharing state across activities and services.
• Jetpack Navigation 3 (version 1.2) adds type-safe deep linking using Kotlin Serialization and synthetic back stack generation.
• BasicTextField has been rewritten with a buffer-driven architecture to eliminate IME race conditions and support rich text.
• New Android skills for coding agents include Adaptive, Compose performance, XML to Compose migration, and Ink skills.
• Input handling now extends to trackpads, mice, and physical controls, supporting desktop-class interactions on devices like Googlebook.

Why it matters

For software engineers building Android applications, these updates reduce the complexity of supporting diverse hardware. Previously, adapting an app for foldables or tablets often required manual layout adjustments and fragile state management logic. With native Grid and Flexbox components, developers can define responsive layouts declaratively, reducing the amount of custom code needed to handle window size changes. This leads to more maintainable codebases and fewer visual bugs when users transition between devices.

The introduction of Jetpack AppState addresses a common pain point in large-scale Android development: state synchronization. By bringing Compose’s snapshot system to the architecture layer, teams can ensure that UI state remains consistent across different entry points, such as widgets or background services. This simplifies the data flow and reduces the risk of state loss during configuration changes or process death. Furthermore, the enhanced input support and type-safe navigation make it feasible to build true desktop-class experiences on emerging form factors like Googlebook without reinventing fundamental interaction patterns.

What you can do

• Update your project dependencies to prepare for the Compose 1.13 stable release and experiment with the new Grid and Flexbox layouts.
• Explore the Jetpack AppState alpha library to refactor complex state pipelines, using Transform to derive state from Flows.
• Migrate to Jetpack Navigation 3 version 1.2 to implement type-safe deep links using Kotlin Serialization for more robust navigation.
• Test your app’s input handling with trackpads and mice to ensure hover states and pointer lifecycles work correctly on larger screens.
• Use the new Android Adaptive skill in Android Studio or via the Android CLI to help refactor existing layouts into multi-pane designs.
• Watch the on-demand sessions from the Android Developer Summit, particularly those on Perfetto profiling and recomposition tracing, to optimize performance.