Exploring Cross-Platform Development with Kotlin Multiplatform

Programmers endure numerous challenges while writing and maintaining code for different platforms—Android, iOS, macOS, Windows, Linux, and the web. Kotlin Multiplatform (KMP) emerges as a robust technology to address these challenges, enabling developers to create applications using a single codebase.

In this blog, we'll uncover the essentials of Kotlin Multiplatform, its advantages, and how it aids in cross-platform development.

Understanding Kotlin Multiplatform (KMP)

Kotlin Multiplatform is an experimental technology that allows developers to share business logic code across multiple platforms while keeping UI code (User Interface) platform-specific.

What does this mean?

You will write platform-specific code for the different look and feel each platform demands, but the underlying logic, the real 'meat' of the software, is shared across all platforms.

The most significant advantage of Kotlin Multiplatform is that it significantly reduces development time by eliminating the need to write and debug the same code on different platforms. Here's a glimpse of what a multiplatform project structure in Kotlin looks like:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
kotlin {
    android()
    ios()
    jvm("backend")

    sourceSets {
        commonMain {
            dependencies {
                implementation kotlin('stdlib-common')
            }
        }
        backendMain {
            dependencies {
                implementation kotlin('stdlib')
            }
        }
    }
}

This snippet includes Android, iOS, and Backend as target platforms while commonMain contains the 'common code' shared across platforms.

Deep Dive into Kotlin Multiplatform Mobile (KMM)

Kotlin Multiplatform Mobile (KMM) has breathed new life into cross-platform development, facilitating the sharing of business logic in Android and iOS applications. KMM is played out perfectly as it allows you to 'share code' on UI as well as 'business logic' across mobile platforms, enhancing code reusability and maintainability.

One of the invaluable aspects of KMM is that it seamlessly works with existing native apps. You don't need to halt your current development or discard what you've already created. KMM can be gradually integrated into existing native apps. Here's an illustration of how Kotlin Multiplatform Mobile infuses the shared logic into Android and iOS apps:

Copy
1
2
3
4
5
commonMain {
    dependencies {
        implementation("io.github.kotlinx:kotlinx-coroutines-core:$coroutines_version")
    }
}

This module holds all the code (Kotlin code) you want to share between Android and iOS. All platform-specific APIs and components can be described using the expected/actual mechanism of Kotlin Multiplatform. It's used to declare an API without providing implementation and lets you write platform-specific interfaces and interact with platform-specific code using a shared interface.

Kotlin Multiplatform vs. Kotlin Multiplatform Mobile

While the terms Kotlin Multiplatform and Kotlin Multiplatform Mobile are often interchanged, they stand for different aspects of the multiplatform project. Kotlin Multiplatform (KMP) refers to the core technology that enables code sharing across various platforms. The Kotlin Multiplatform technology supports platforms besides mobile, including desktop environments (Windows, Linux, macOS), web, Android, iOS, and even embedded systems.

On the other hand, Kotlin Multiplatform Mobile (KMM) specifically concerns mobile development for Android and iOS. It provides tools (like the KMM plugin for Android Studio) and libraries specialized for mobile development projects.

In simpler terms, all KMM projects are Kotlin Multiplatform projects, but not all Kotlin Multiplatform projects are KMM.

Is Kotlin Cross Platform?

Yes, Kotlin is a cross-platform language. This means that you can create applications for different operating systems while maintaining a shared code base. Kotlin facilitates cross-platform development by enabling developers to decouple the business logic from platform-specific code, thereby promoting optimal 'code sharing'.

How Kotlin Cross-Platform Works?

Kotlin Multiplatform works by compartmentalizing your code into two segments—shared code, and platform-specific code.

The shared code part contains the 'common code' related to your business logic that can effectively run on different platforms. On the other hand, platform-specific code consists of portions required to interact with platform-specific APIs, native libraries, etc., and tailored UI components catering to a unique user experience on individual platforms.

Here's a basic description of this working model in a Kotlin Multiplatform Project:

Copy
1
2
3
4
5
6
7
expect class Sample() {
    fun checkMe(): Int
}

actual class Sample actual constructor() {
    actual fun checkMe() = 42
}

In this Kotlin code, "expect" is a way of saying that the actual implementation of this code is platform-dependent and will be provided in the platform-specific code.

Kotlin Multiplatform: Maximizing Code Sharing

Utilizing the same code across multiple instances is one of the prominent features of Kotlin Multiplatform. It allows developers to share code across platforms and run it uniformly on different operating systems. Consequently, this leads to shorter development cycles and efficient code maintenance, making Kotlin an ideal choice for cross-platform projects.

Incorporating shared code into your project functions through creating an intertwined multiplatform project - define common code independent of the platform, and then write platform-specific code for each platform independently:

Copy
1
2
3
4
fun main() {
    println(Sample().checkMe())
    println(Platform.name)
}

This snippet calls the platform-independent logic written in the Kotlin code by calling Sample().checkMe(). However, calling Platform.name retrieves the platform-dependent implementation of a name.

Creating Cross-Platform Projects with Kotlin

Creating Cross-platform projects with Kotlin is simple and effective. With Kotlin, you can build projects that run on multiple platforms including Android, iOS, Linux, macOS, Windows, and the web using a single project setup. The essence of Kotlin Multiplatform is allowing code sharing across platforms and efficient interaction with platform-specific dependencies.

To begin with, select a compatible IDE such as Android Studio. Kotlin supports seamless integration with Android Studio, which can facilitate building a robust Kotlin Multiplatform project.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
plugins {
    kotlin("multiplatform") version "1.5.0"
}

kotlin {
    js(IR) {
        browser {
            webpackTask
        }
    }
    jvm()
    ios()

    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.3")
            }
        }
        val commonTest by getting {
            dependencies {
                implementation(kotlin("test-common"))
                implementation(kotlin("test-annotations-common"))
            }
        }
    }
}

This code snippet outlines how a Kotlin Multiplatform project is set up for JS, JVM, and iOS.

Kotlin Multiplatform and Native Programming

Kotlin Multiplatform is designed to augment native programming, not replace it. Kotlin upholds the benefits of native programming such as direct access to native technologies and can interop smoothly with native code on multiple platforms.

For instance, developers can write a correlation with platform-specific components and services— UI widgets, device APIs, etc. In contrast, other cross-platform development solutions like React Native follow a different ethos—write once, run everywhere, which often results in compromised performance and a lack of native feel in the resultant apps.

Kotlin's approach unlocks the full potential of native programming whilst ensuring maximum code sharing. This unique aspect of running Kotlin Multiplatform projects on existing codebases sets it apart from other technologies and tech stacks for cross-platform development.

Real-World Examples of Kotlin Multiplatform in Mobile Platforms

Kotlin Multiplatform offers the tools to build stable, scalable, and effective applications across different operating systems. Established brands such as Quizlet, Autodesk, Netflix, and VMWare have successfully adopted it for building impressive multiplatform applications.

Quizlet, an online study application, switched to Kotlin Multiplatform. This resulted in significantly reducing their development time as they were able to share code between iOS and Android.

Conclusion

Kotlin Multiplatform has heralded a new era in cross-platform development. By exploiting the core potential of native programming, embracing code sharing, and enabling development across various platforms, Kotlin serves as a practical and efficient solution to cross-platform dilemmas. Whether you're an Android developer, an iOS developer, or a web developer, the advantages of Kotlin Multiplatform open up new paradigms for future development endeavors.

References

Official Kotlin Multiplatform Documentation