10 Key Updates in Compose Multiplatform 1.11.0

Compose Multiplatform 1.11.0 has arrived, bringing a host of enhancements that refine the developer and user experience across iOS, web, and testing. From a more native feel on Apple devices to faster scrolling in browsers, this release is packed with improvements. Below, we break down the ten most important changes you should know about. Whether you're a seasoned Compose developer or just getting started, these updates will help you build better apps more efficiently.

1. New Release Overview

Compose Multiplatform 1.11.0 continues the mission of delivering a consistent UI framework across Android, iOS, desktop, and web. This version focuses on narrowing the gap between native and cross-platform experiences. Key highlights include an experimental native text input for iOS, default concurrent rendering, revamped UI testing APIs, and significantly improved scrolling performance on web targets. The entire release aims to make your apps feel more at home on each platform while maintaining a single Kotlin codebase. For a complete list of changes, the official What’s New document provides exhaustive details.

2. Native Text Input on iOS

One of the most requested features for Compose on iOS has been text fields that behave like native UITextFields. In version 1.11.0, an experimental implementation built on top of UIView is now available. This brings precise caret movement, native gesture handling, and context menus that include Autofill, Translate, and Search. While the existing cross-platform text input remains stable and is the default, developers who want the most authentic iOS feel can opt into this new mode. It's a significant step toward eliminating the subtle differences that can make Compose iOS apps feel less native.

3. Opting Into Native Text Fields

To enable the native text input on iOS, you need to set an experimental flag in your Compose configuration. This opt-in mechanism ensures that while the feature is still under development, you can test it and provide feedback. The stable text input remains the default for production apps. To switch, add the appropriate compiler option or use a property in your build.gradle.kts. Once activated, all TextField and BasicTextField components will use the UIView-backed implementation. Be aware that some custom text behaviors might not yet be supported; check the migration notes for details.

4. Concurrent Rendering Now Default

Introduced as an opt-in in version 1.8.0, concurrent rendering is now enabled by default. This offloads rendering tasks to a dedicated render thread, improving frame rates and reducing jank — especially on complex UIs. The best part? You don't need any extra configuration. If you previously opted out or used the old single-threaded model, you may notice smoother animations and better overall responsiveness. This change aligns Compose Multiplatform with modern rendering architectures seen in native frameworks.

5. Compose UI Testing Version 2

Testing on non-Android targets gets a significant upgrade with the introduction of v2 ComposeUiTest APIs. The default dispatcher is now StandardTestDispatcher, which makes coroutines run in the order they are queued. This leads to more predictable tests that mirror production behavior. The v2 APIs also accept an effectContext parameter, allowing you to inject a custom coroutine context — useful for overriding motion duration scales or supplying custom dispatchers. The new signature looks like this:

@OptIn(ExperimentalTestApi::class)
@Test
fun myTest() = runComposeUiTest(
    effectContext = motionDurationScale + StandardTestDispatcher()
) {
    setContent { MyComposable() }
    // assertions
}

6. Deprecated Testing APIs

With the arrival of v2 testing APIs, several older functions are now deprecated. These include runComposeUiTest, runSkikoComposeUiTest, and runDesktopComposeUiTest. The new APIs consolidate the experience and provide a unified interface across platforms. Developers are encouraged to migrate their tests to the v2 equivalents to take advantage of the improved predictability and additional features. Deprecation warnings will appear in your code, making it easy to identify what needs updating. The migration is straightforward, typically involving a simple rename.

7. Smoother Scrolling on Web

Web scrolling has historically been a pain point for Compose Multiplatform. With 1.11.0, touch processing has been reworked substantially. The result is scrolling that feels much closer to native platforms — smoother, more responsive, and with less lag. The fixes address both mouse and touch interactions, making the web version of your apps more pleasant to use. This change is part of ongoing efforts to bring web performance up to par with desktop and mobile. For a deep dive into the technical improvements, see issue CMP-9727.

8. See It in Action: KotlinConf App

The latest web version of the KotlinConf App demonstrates the improved scrolling experience. This open-source project is a great way to see how Compose Multiplatform performs in a real-world application. You can explore the codebase and see how the team optimized scrolling for the web target. The app is available on the KotlinConf website, and the source code is on GitHub. It serves as both a showcase and a reference for best practices when building cross-platform UIs with Compose.

9. Upgrade Your Projects

To take advantage of these new features, update your dependencies to version 1.11.0. The process is simple: modify your build.gradle.kts files to reference the new version. For those using the JetBrains Compose Multiplatform plugin, update the plugin version as well. After upgrading, try out the native text input on iOS, run your tests with the v2 API, and observe the improved web scrolling. Remember to check for any breaking changes between versions — the official migration guide has you covered.

10. Full Release Notes

This list covers the most notable updates, but there is much more in the 1.11.0 release. For a comprehensive overview, consult the What’s New page and the full release notes. They include detailed changelogs, bug fixes, and performance enhancements not mentioned here. Staying informed ensures you can leverage every improvement to build better multi-platform apps. Compose Multiplatform continues to evolve rapidly, and this release is a big step forward.

With these ten updates, Compose Multiplatform 1.11.0 solidifies its position as a robust framework for cross-platform development. The focus on native feel, performance, and developer tooling shows JetBrains’ commitment to quality. Update your projects, experiment with the new features, and share your feedback with the community. The future of Compose Multiplatform looks bright — and it's only getting better.