Google Launches Room 3.0: Kotlin-First Multiplatform DB

Google has officially released Room 3.0, a major overhaul of its popular Android persistence library that goes fully Kotlin-first, embraces asynchronous programming by default, and — most significantly — adds complete Kotlin Multiplatform (KMP) support. The release marks the biggest architectural shift for Room since its initial launch in 2017, signaling Google's deepening commitment to the Kotlin Multiplatform ecosystem.

Room 3.0 enables developers to share database logic across Android, iOS, desktop, and other platforms using a single Kotlin codebase, eliminating the need for platform-specific persistence implementations. This is a strategic move that positions Room as the go-to persistence solution for the rapidly growing KMP developer community.

Key Takeaways at a Glance

• Kotlin Multiplatform support: Room now works across Android, iOS, JVM desktop, and native targets
• Async-first APIs: Blocking DAO methods are deprecated in favor of coroutines and Flow
• Kotlin-first design: Java support enters maintenance mode with no new features planned
• New KSP-only processing: KAPT annotation processing is no longer supported
• SQLite driver abstraction: A new driver layer enables platform-specific SQLite implementations
• Breaking migration required: Room 2.x projects need code changes to upgrade

Room Goes Fully Kotlin-First, Deprecates Java APIs

Room 3.0 represents a decisive pivot away from Java. While existing Java APIs will continue to function, Google has made clear that all future development, new features, and optimizations will target Kotlin exclusively. This aligns with Google's broader strategy since declaring Kotlin the preferred language for Android development in 2019.

The practical impact is substantial. DAO interfaces now leverage Kotlin coroutines as the primary async mechanism, replacing the older RxJava and LiveData return types. Developers writing new Room code will define their queries using suspend functions and Flow return types by default.

For teams still maintaining Java codebases, Google recommends a gradual migration path. Java-based DAOs will continue to compile and run, but they won't benefit from performance improvements or new capabilities introduced in 3.x releases. This is a clear signal that mixed-language Android projects should prioritize Kotlin adoption for their data layer.

Async-First Architecture Replaces Blocking Calls

One of the most impactful changes in Room 3.0 is the shift to async-first database operations. In previous versions, developers could define blocking DAO methods that executed queries on the calling thread — a pattern that frequently led to UI freezes and ANR (Application Not Responding) errors in production apps.

Room 3.0 deprecates all synchronous DAO methods. Every database operation is now expected to run within a coroutine scope or return a reactive stream. This architectural decision enforces best practices that many experienced Android developers already followed, but now makes them the default behavior.

The change affects 3 core operation types:

• Read queries: Must return Flow<T> for observable queries or use suspend functions for one-shot reads
• Write operations: Insert, update, and delete methods must be suspend functions
• Transactions: The @Transaction annotation now works exclusively with suspend blocks
• Migration callbacks: Database migration and creation callbacks support coroutine-based execution

This async-first approach also unlocks better performance on multiplatform targets where threading models differ significantly from Android. On iOS, for example, Kotlin/Native's memory model requires careful handling of concurrent database access — something Room 3.0's architecture handles transparently.

Kotlin Multiplatform Support Changes the Game

The headline feature of Room 3.0 is undoubtedly its Kotlin Multiplatform compatibility. Previously, Room was an Android-only library, forcing KMP projects to use alternatives like SQLDelight for cross-platform database needs. With this release, Google enters direct competition with SQLDelight on its home turf.

Room 3.0 introduces a new SQLite driver abstraction layer that decouples the library from Android's built-in SQLite implementation. This driver architecture supports multiple backends:

• Android: Uses the bundled Android SQLite or the AndroidX SQLite library
• iOS/macOS: Leverages the native SQLite included in Apple platforms
• JVM Desktop: Connects through JDBC-based SQLite drivers
• Linux/Windows: Uses native SQLite bindings via Kotlin/Native

For teams already using Room on Android, the multiplatform migration path is relatively smooth. Existing @Entity, @Dao, and @Database definitions can be moved to a shared KMP module with minimal changes. Platform-specific code is primarily limited to database driver configuration and file path resolution.

Compared to SQLDelight, which uses SQL-first schema definitions, Room maintains its annotation-based Kotlin-first approach. This means developers define their schema using Kotlin data classes rather than raw SQL files — a design philosophy that many Android developers find more intuitive and type-safe.

KSP-Only Processing Drops KAPT Support

Room 3.0 exclusively uses Kotlin Symbol Processing (KSP) for annotation processing, dropping support for the older KAPT (Kotlin Annotation Processing Tool). This change delivers significant build performance improvements, as KSP processes Kotlin code directly without generating Java stubs — a bottleneck that made KAPT notoriously slow in large projects.

Developers upgrading from Room 2.x must update their build configurations to replace KAPT with KSP. The migration involves changing the Gradle plugin from kotlin-kapt to com.google.devtools.ksp and updating dependency declarations from kapt() to ksp().

Build speed improvements from this change are meaningful. Google's internal benchmarks suggest 30-40% faster annotation processing compared to KAPT-based Room builds, with even larger gains in incremental compilation scenarios. For large monorepo projects with dozens of Room-annotated modules, this translates to minutes saved per build cycle.

Migration Path and Breaking Changes

Upgrading from Room 2.x to 3.0 is not a drop-in replacement. Google has documented several breaking changes that require developer attention:

• Minimum SDK: Room 3.0 requires Kotlin 2.0+ and KSP 2.0+
• Deprecated API removal: Several APIs deprecated in Room 2.5+ are now removed entirely
• Package restructuring: Some internal classes have moved to new packages for multiplatform compatibility
• Type converter changes: Custom type converters need updates to support the new async pipeline
• Testing utilities: Room's testing library has been restructured for multiplatform test execution

Google provides an automated migration tool integrated with Android Studio that handles many of these changes. However, complex projects with custom type converters, multi-database architectures, or heavy use of RxJava bindings will likely require manual intervention.

The recommended migration strategy involves upgrading to the latest Room 2.6.x first, resolving all deprecation warnings, and then moving to 3.0. This two-step approach minimizes the number of simultaneous breaking changes developers must address.

Industry Context: Google Doubles Down on KMP

Room 3.0's multiplatform support doesn't exist in isolation. It's part of Google's broader strategy to bring core Jetpack libraries to Kotlin Multiplatform. Over the past 18 months, Google has added KMP support to Lifecycle, ViewModel, DataStore, and Navigation — libraries that form the backbone of modern Android architecture.

This systematic expansion suggests Google views KMP as a strategic platform, not just an experiment. By providing first-party multiplatform alternatives to Android-only Jetpack components, Google reduces the friction for Android teams exploring iOS code sharing. The competitive implications are significant: Flutter, Google's own cross-platform UI framework, now faces internal competition from KMP-powered solutions.

The broader industry trend toward code sharing across mobile platforms continues to accelerate. JetBrains reported a 65% increase in KMP adoption throughout 2024, with database access consistently ranking as a top developer request for multiplatform support. Room 3.0 directly addresses this demand with the credibility and polish of a Google-maintained library.

What This Means for Developers

For Android-only teams, Room 3.0 brings immediate benefits through faster builds (KSP), better runtime performance (async-first), and modern API design. The migration cost is real but manageable, and the long-term maintenance benefits justify the investment.

For KMP teams, this release is transformative. Room's mature feature set — including automatic migration support, type-safe queries, and compile-time verification — instantly becomes available across platforms. Teams previously forced to choose between Room (Android-only) and SQLDelight (multiplatform) can now use Room everywhere.

For enterprise teams evaluating cross-platform strategies, Room 3.0 strengthens the case for Kotlin Multiplatform over Flutter or React Native for data-heavy applications. Shared database logic eliminates an entire category of platform-parity bugs and reduces development effort by an estimated 20-30% for typical CRUD applications.

Looking Ahead: Room's Multiplatform Roadmap

Google has outlined several features planned for Room 3.1 and beyond, including full-text search support on all platforms, database encryption via SQLCipher multiplatform bindings, and improved Compose Multiplatform integration for reactive UI updates driven by database changes.

The release of Room 3.0 also raises questions about the future of competing solutions. SQLDelight, maintained by Cash App (Block), has been the de facto standard for KMP persistence. With Google's entry into this space, SQLDelight's team will need to differentiate on features like SQL-first schema design, multi-dialect support, and community ecosystem.

Developers interested in adopting Room 3.0 can find the stable release on Maven Central with comprehensive migration guides available on the Android Developers documentation site. Google has also published a series of codelabs and sample projects demonstrating multiplatform Room usage across Android, iOS, and desktop targets.

Room 3.0 is available now as a stable release. Google recommends starting with new modules or greenfield projects before migrating existing Room 2.x code, allowing teams to build familiarity with the new APIs in a low-risk context.