Compelling reasons to try Kotlin Multiplatform

We create various digital solutions for our customers, but in the mobile context, we are particularly interested in Kotlin Multiplatform (KMP). Our customers expect the highest quality from us, delivered in a reasonable timeframe. KMP is designed to empower developers with the best possible tooling, enabling them to create optimal, platform-specific solutions as smoothly as possible. For these reasons, we believe that KMP brings value to both Nitor and our customers.

Kotlin Multiplatform gives the following compelling promises:

• Avoid code duplication: Minimise redundant code across platforms.

• A loved and trusted language: Leverage the power of a modern and widely adopted programming language.

• Extensive platform support: Write code that targets a broad range of platforms.

I will now explore each of these points in greater detail below.

Avoid code duplication

The primary benefit and strongest selling point of KMP is its cross-platform capability. This feature directly addresses the major pain points in mobile development: the high cost of maintaining two separate codebases (Android and iOS) and the platform-specific bugs that arise from inconsistent functionality.

By using KMP, developers can share code for components that lack platform-specific requirements. These areas, which are also common sources of errors, include:

• Common data models

• Data verification logic

• The network stack

A loved and trusted language

Kotlin is a modern, pragmatic language designed to enhance developer experience and satisfaction. It embraces both object-oriented and functional programming paradigms, offering features like a strong type system, higher-order functions and built-in null-safety for improved safety and correctness, leading to fewer bugs and crashes.

The language's design focuses on the following core principles:

• Readability is prioritised over extreme concision.

• The ability to reuse code is valued over mere expressiveness.

• Interoperability with existing systems is considered more important than pure originality.

• Focus on safety and strong tooling takes precedence over theoretical soundness.

Beyond Android, where it is already used in 99% of the top 1,000 Google Play apps, Kotlin is also widely adopted for server-side development, with first-class support from popular frameworks like Spring.

Extensive platform support

KMP allows developers to write code once and share it across various platforms, notably Android and iOS. This is achieved by compiling the shared code specifically for each target. For instance, the compiled code is DEX bytecode on Android but arm64 machine code on iOS. In effect, it's as if the code were natively written for each platform, but utilises Kotlin instead of platform-specific languages, like Swift for iOS.

Beyond mobile, KMP supports a wide array of target platforms, including:

• Mobile: Android, iOS

• Desktop: macOS, Windows, Linux

• Server: JVM

• Web: JavaScript, WASM

How to adopt Kotlin Multiplatform 

Introducing new technology in a project inherently carries risk, but this risk should be managed flexibly, starting small to minimise potential issues.

KMP naturally supports this gradual adoption. The shared code begins as a new module or dependency consumed by existing code. An initial value can be achieved immediately by sharing minimal but critical functions, such as data verification (e.g., an email validation function).

From this starting point, more code can be progressively migrated to the shared codebase, including common data objects, network and caching logic, and eventually, entire view models that encapsulate a view’s business logic. Sharing business logic should be the ultimate goal of any cross-platform project. This unification eliminates platform-specific bugs, allowing fixes to be applied simultaneously across all platforms.

With the business logic shared, a platform-specific UI can be built on top, using Jetpack Compose for Android and SwiftUI for iOS. This approach ensures no compromise on the UI layer, allowing for a native, platform-specific feel and maximising performance.

Shared UI 

Kotlin Multiplatform also offers the option for true cross-platform user interface (UI) sharing through Compose Multiplatform, allowing the same UI code to target all platforms. Compose Multiplatform is a cross-platform adaptation of the Jetpack Compose UI framework, created by Google, but initially targeting only Android devices. Compose Multiplatform is built on top of the technology from Jetpack Compose and allows to write Compose UI code that will run on all platforms. 

This is particularly advantageous when a project prioritises brand requirements over strict adherence to platform-specific UI conventions, which is often the case in real-world scenarios.

Conclusion

Cross-platform solutions have been a recurring theme, dating back to Java's initial promise of "write once, run everywhere." Since then, frameworks like Qt and Xamarin have offered cross-platform support, particularly for mobile development. However, these attempts often felt like a compromise, sacrificing platform-specific advantages to meet a minimal common denominator. While modern options like React Native and Flutter have achieved high adoption rates for valid reasons, they still necessitate trade-offs in certain areas.

Kotlin Multiplatform (KMP) presents a different approach. It finally allows developers to share the common, platform-agnostic business logic while easily integrating platform-specific functionality when required. By building a native, platform-specific UI on top of this shared code, KMP offers a compelling solution, complete with excellent developer and tooling support.