Jetpack Compose’s latest stable release ships with something that sounds unsexy but will change how you write Android UIs: real trackpad support, drastically better test coroutine handling, and experimental layout APIs that finally eliminate boilerplate for responsive design. The April 2026 release (version 1.11) isn’t a headline feature drop, but it’s where Compose moves from “nice alternative to XML” to “the only reasonable choice for building Android UIs.”
How Test Coroutines Moved from Fake to Production-Realistic
Jetpack Compose 1.11 changed the default test dispatcher from UnconfinedTestDispatcher (which executed coroutines immediately) to StandardTestDispatcher (which queues them and requires virtual clock advancement). Tests now mimic production conditions where coroutines don’t execute instantly—race conditions that hide in flaky tests suddenly become obvious. A coroutine that completes out of order in a real app but passes in tests because of immediate execution will now fail in your test suite first.
Why it matters: You’ll catch concurrency bugs before users do. Any team using Compose for state management, async operations, or anything touching coroutines gets a massive improvement in test reliability.
Consider a team using Compose with a data layer that fetches user information and populates a UI state. Previously, your tests might pass even if a race condition could occur between the fetch and the render. Now, your tests queue the coroutine, and if your code doesn’t handle the async ordering correctly, the test fails immediately. The tradeoff is migration: existing test suites need updates, but the release documentation walks through common fixes and API mappings.
Compose tests move from “we hope this reflects reality” to “we’re confident this reflects reality.”
Trackpad Support That Finally Works Like Trackpads
For years, trackpad input on Android tablets and foldables was treated as fake touchscreen fingers, which meant clicking and dragging would scroll instead of select, and gestures were interpreted incorrectly. Compose 1.11 changed how PointerType events are classified—trackpad input is now PointerType.Mouse rather than PointerType.Touch, and the framework automatically recognizes platform gestures like two-finger swipes and pinches (available on API 34+).
Why it matters: Built-in components like Modifier.scrollable and Modifier.transformable automatically adapt to trackpad behavior. Text selection, drag-and-drop, and context menus now feel native to desktop-style input. As foldables become more common and tablets increasingly ship with trackpads, users get the laptop experience they expect.
If you’re building a productivity app for Samsung Galaxy Tab S or a foldable device, you now get correct trackpad behavior out of the box. A user can click and drag to select text, double-click to select a word, and right-click for context menus—without extra code. New testing APIs like performTrackpadInput let you validate that custom gesture detectors work across touchscreens, mice, trackpads, and styluses.
New Layout APIs That Kill Boilerplate for Responsive Design
Compose 1.11 introduces three experimental layout APIs: Grid (for two-dimensional layouts with tracks, gaps, and cells), FlexBox (for high-performance adaptive layouts with wrapping and multi-axis alignment), and a refreshed MediaQuery API (for declarative UI adaptation based on device capabilities).
The MediaQuery API is the most immediately useful. Before, checking if a device was in tabletop mode required boilerplate to collect window layout info, filter for folding features, and check state. Now it’s a single condition: if (mediaQuery { windowPosture == UiMediaScope.Posture.Tabletop }). The performance benefit is baked in: derivedMediaQuery ensures recomposition only happens when the environment actually changes.
Why it matters: MediaQuery abstracts device capability queries into simple conditions. Grid and FlexBox replace the pattern of nesting Row and Column components or manually managing scroll containers. These experimental APIs handle complex screen layouts without the overhead of scrollable lists.
If you’re building a cross-platform mobile app that supports phones, tablets, and foldables, MediaQuery and Grid let you write responsive layouts that adapt to screen size, fold state, and keyboard presence without platform-specific code. Instead of conditional Row/Column nesting and manual state collection, you declare what your UI looks like in each configuration.
These APIs are experimental, which means they’ll likely change before stabilization. But the direction is clear: Compose is moving toward layout primitives that match CSS Grid and Flexbox—standards that web developers already understand.
The Performance Gamble: Style API and SlotTable Rewrites
Compose 1.11 introduces two more experimental features: the Style API (a new paradigm for customizing components without modifiers) and a new SlotTable implementation (the internal data structure tracking composition state, recompositions, and remembered values).
The Style API is designed to unlock deeper customization by exposing a standard set of styleable properties. Early testing shows promising performance benefits, and the team plans to adopt it in Material components once it stabilizes. The SlotTable rewrite improves performance around random edits—the kind of changes that happen frequently in real apps.
Why it matters: Both features are bets on long-term performance and developer ergonomics. Styles reduce the mental overhead of understanding which modifiers apply when and in what order. The SlotTable rewrite improves how Compose handles frequent edits in complex compositions.
If you’re building a complex app with lots of nested state, dynamic lists, and frequent UI updates, the SlotTable changes might eventually remove performance cliffs you’ve hit. Right now, both are experimental, so feedback from real apps matters—file bugs and use cases early.
Why This Release Matters for the Broader Ecosystem
The pattern across Compose 1.11 is consolidation, not flashiness. Test coroutines get realistic. Trackpads work correctly. Boilerplate for responsive design disappears. Layout APIs converge toward web standards. Performance improves incrementally.
This is what mature UI frameworks do. You don’t get AI-powered previews or one-click design-to-code tools. You get the work of making existing patterns reliable, making new patterns obvious, and removing friction from common tasks.
Within two releases, the experimental layout APIs will likely stabilize, becoming the idiomatic way to build Compose layouts. Teams that start adopting Grid, FlexBox, and MediaQuery now will have a head start on layouts that work correctly across the full device spectrum—phones, tablets, foldables, TVs.
FAQ
Q: Do I need to migrate my existing tests to use StandardTestDispatcher?
A: Yes. The migration is not automatic; tests written for UnconfinedTestDispatcher will behave differently in Compose 1.11. The release includes a comprehensive migration guide with API mappings and common fixes. The benefit—catching race conditions and reducing test flakiness—is worth the effort.
Q: Will the experimental layout APIs (Grid, FlexBox, MediaQuery) be stable soon?
A: The Compose team plans to stabilize these APIs, but the timeline is unclear. They’re available as @Experimental in 1.11 and marked for feedback. Start exploring them now, but don’t bet your entire architecture on them until they’re stable. The underlying concepts are stable; the API surface may change.
Q: Is SlotTable rewrite something I should enable right now?
A: Only if you’re running benchmarks or have encountered performance issues in complex compositions. It’s disabled by default in 1.11. Enable it via ComposeRuntimeFlags.isLinkBufferComposerEnabled if you want to help stress-test it, then file bugs. Don’t use it in production yet.
Key Takeaways
-
Test coroutines now queue by default instead of executing immediately, making tests more robust. This is a breaking change requiring test migration, but the reliability gain is substantial. Plan migration time into your next sprint if you’re using Compose heavily.
-
Trackpad support is finally correct on tablets and foldables. Built-in components adapt automatically; custom gesture detectors need validation via
performTrackpadInput. This is table-stakes for premium tablet experiences. -
New layout APIs (
Grid,FlexBox,MediaQuery) eliminate boilerplate for responsive design. Adopt them cautiously while experimental, but expect them to become idiomatic within two releases. Teams building for foldables and tablets should exploreMediaQueryimmediately. -
Compilation will now require compileSdk 37 and AGP 9 in Compose 1.11. Keep your toolchain updated. Compose is committing to adopting new Android SDK levels promptly to access latest features.
-
Style API and SlotTable rewrites are early performance bets for the future. File bugs and share use cases if you’re using experimental features. The ecosystem needs real-world feedback to stabilize these APIs correctly.