6 Major Updates to Kotlin Multiplatform Project Structure You Must Know

JetBrains has overhauled the default project layout for Kotlin Multiplatform (KMP) to streamline development and align with modern build tools. This new structure separates shared code from platform-specific entry points, making responsibilities clearer and easing migration to Android Gradle Plugin 9.0. Here are the six essential changes you need to understand.

1. A Dedicated Shared Module Replaces the Monolithic composeApp

Previously, the composeApp module served double duty: it hosted your shared Kotlin Multiplatform library and acted as the application container for multiple platforms. Now, a new shared module takes over all shared code responsibilities. This module is a pure KMP library, free from platform packaging details. As a result, you can instantly identify what belongs to the shared logic versus what configures a runnable app. This separation reduces configuration clutter and makes your project easier to navigate, whether you’re using Compose Multiplatform or not.

2. Platform Application Modules Are Now Fully Separate

Each platform that builds a runnable application now gets its own dedicated module: androidApp, desktopApp, webApp, and similar. These modules contain only the entry points and platform-specific setup, such as the Android manifest or desktop launcher code. In the Project view, you’ll see the shared folder alongside folders for each app module. This change makes it trivial to add or remove platforms without touching the shared library, and it mirrors conventions used in other build systems like Gradle and Maven.

3. Clearer Responsibilities Reduce Configuration Complexity

The old composeApp module bundled library configuration with application packaging for every target. Developers often struggled to distinguish between KMP library settings (like source sets) and platform-specific packaging (like applicationId or desktop distribution). With the new structure, the shared module deals only with library concerns, while each app module handles its own packaging. This clarity cuts down on accidental misconfiguration and makes it easier to onboard new team members who are familiar with standard modular project layouts.

4. iOS Apps Benefit from a Consistent Approach

In the old setup, iOS applications already lived in a separate iosApp folder (because they require an Xcode project), creating an asymmetry—other platforms were all crammed into composeApp. The new structure removes this inconsistency: now every platform has its own application module (including iosApp). This makes the project layout uniform across all targets and simplifies CI/CD pipelines, as each app module can be built independently. It also paves the way for easier multi-platform testing and deployment.

5. Android Gradle Plugin 9.0 Compatibility Is Ensured

AGP 9.0 no longer allows applying the Android application plugin in a multiplatform module. The old composeApp module, being both library and application, would break under this restriction. By moving the Android entry point to a separate androidApp module, the new structure fully supports AGP 9.0 out of the box. To leverage this in IntelliJ IDEA, update to version 2026.1.2 or newer and install the latest Android plugin. This change future‑proofs your projects against upcoming Gradle and plugin versions.

6. Migration Is Straightforward with Tooling and Samples

The new project structure is already live in the KMP wizard—both in IntelliJ IDEA (with the Kotlin Multiplatform plugin) and at kmp.jetbrains.com. For existing projects, you can manually reorganize your modules following the pattern above. JetBrains is updating sample projects and learning materials; you can check out kotlinconf-app, KMP-App-Template, or RSS Reader for reference. The migration involves moving shared code into a new shared module and creating separate app modules for each target. Expect more detailed migration guides soon.

Embracing this new default structure will make your Kotlin Multiplatform projects cleaner, more maintainable, and ready for the next generation of Android tooling. Whether you’re starting fresh or planning a migration, these six changes represent a significant step forward in the KMP ecosystem.