This is where Kotlin Multiplatform (KMP) enters the picture. Kotlin has been the native language used for Android development for half a decade and is the standard among Android developers.
In recent years, JetBrains, the makers of Kotlin, expanded the scope of the language piece by piece and added support for more target platforms. Next to Android, Kotlin/Native allows Kotlin code to be compiled to native code for iOS, macOS, Linux and Windows. Kotlin/JS and Kotlin/WASM convert Kotlin to be usable on the web.
This immense set of capabilities is tied together with Koltin Multiplatform (KMP): it allows a shared codebase to be used on different target platforms. The shared code can be imported as a dependency into the native projects for iOS and Android (and other target platforms like web) and can include parts or all the invisible parts of the app: network communication, caching, business logic and more can be easily shared between your apps. All that is left to do is to add a native UI for your apps, which thanks to the modern native UI frameworks Jetpack Compose and SwiftUI is less effort than ever. In fact, even UI elements can soon be shared with Compose Multiplatform.
In our experience, based on many successfully launched apps for multiple of our customers, all code that is not related to the UI displayed to the user can be shared without losing any of the benefits of native app development. The performance of KMP is of course at native level, because Kotlin is compiled into native code. Everything the user sees and touches is 100% native, resulting in the perfect native app experience – but with all the benefits of cross-platform solutions for our development process and client.
There is a wide range of KMP libraries that can be used to accelerate development and the number of community-created libraries is constantly growing. KMP can still make use of native features with ease: Kotlin code can call all native functions provided by the operating system.
In summary, KMP offers all benefits of native app development while also reducing the associated effort due to most of the code base being shared between the platforms. With the UI still being natively developed, a KMP app will look and feel like a fully native app to the end-user. While we mostly focus on Android and iOS in this article, Kotlin Multiplatform also allows native macOS apps, Java based Windows programs and web applications to be developed.
Changing the past
A unique ability of KMP is to transform existing native apps into cross-platform projects long after they started. A well-maintained Android codebase can form the base for a shared KMP project as native Android functionality can be extracted to create a shared code base. We were able to migrate our biggest app project from two native apps into a KMP app with a large, shared code base. We removed over 40% of code from the iOS projects while gaining additional acceleration for future developments. Many new features or changes now come to iOS “for free” as only the KMP dependency needs to be updated. As native teams already have the skillset needed to write KMP code, this can be a gradual process over multiple months without disrupting the active development work.
Sharing your UI with Kotlin Multiplatform
But what if we want to tear down the last wall between the platforms and share (parts) of our UI? This is the promise of Compose Multiplatform, once it is available for all platforms. Like Flutter, you can write one shared UI for all platforms based on what Android developers are familiar with. The APIs offered in Compose Multiplatform are almost identical with Android’s native UI framework Jetpack Compose.
While you will lose the benefits of a native UI on iOS when making use of Compose Multiplatform, Android users will see no difference. But sharing your UI is not a black or white decision. Many elements in the UI are identical between platforms: for example, cells or list items often are supposed to look identical. Instead of sharing the entire UI, you can also share smaller elements in the UI and embed them into the native UI of your app. When done right, no difference is visible to the user, but you expanded the reach of your shared codebase even further.
Compose Multiplatform is still in beta for iOS and in alpha for web, but you can already make use of it in your Android and desktop apps.
)
)
)
)
)
)
)
)
)
)
)
)
)
)
)
)
)