Kotlin Multiplatform in 2025 — How Android Developers Can Build for iOS Too

4 min readApr 21, 2025

✨ Introduction

As an Android developer in 2025, you might be wondering: “Do I really have to learn Swift or Flutter just to build an iOS app?” The answer is: not anymore.

With Kotlin Multiplatform (KMP) evolving rapidly and gaining official support from JetBrains and Google, Android developers now have a powerful tool to share business logic across platforms — without sacrificing performance or native feel.

Whether you’re building a startup MVP, scaling a production-grade app, or just exploring cross-platform development, KMP lets you use your Kotlin skills to ship apps for Android, iOS, desktop, and web — all from a single codebase (well, mostly 😉).

In this article, we’ll walk through:

What Kotlin Multiplatform really is
How it works under the hood
Setting up a real KMP project in Android Studio
Sharing code between Android and iOS
Pros, cons, and best practices in 2025

Let’s dive in and see how you can go from Android-only to truly cross-platform — with the tools you already know and love.

🚀 What Is Kotlin Multiplatform and Why Should You Care?

Kotlin Multiplatform (often shortened as KMP) is a technology developed by JetBrains that enables developers to share code across multiple platforms — including Android, iOS, desktop, web, and even backend services.

But unlike other cross-platform frameworks like Flutter or React Native, KMP doesn’t aim to replace the UI layer. Instead, it focuses on sharing business logic, networking, caching, data models, and other core components — while still giving you the freedom to build native UIs for each platform.

🧩 How It Works

KMP uses Kotlin’s multiplatform project structure to separate code into two major parts:

commonMain — Shared logic written in Kotlin
androidMain / iosMain — Platform-specific implementations

When you compile the project:

For Android, it compiles to JVM bytecode.
For iOS, it compiles to native binaries using Kotlin/Native.

This means you can write your logic once and reuse it while still delivering fully native apps.

🛠️ Setting Up a Kotlin Multiplatform Project in Android Studio (2025 Edition)

Android Studio now offers built-in templates for KMP projects (since Giraffe and beyond). Here’s a step-by-step to get started:

✅ Step 1: Create a New Multiplatform Project

Open Android Studio
Select “New Project” > “Kotlin Multiplatform App”
Choose targets (e.g., Android + iOS)
Select UI frameworks (Jetpack Compose for Android, SwiftUI/UIKit for iOS)

Studio generates a folder structure like this:

shared/
 ┣ src/
 ┃ ┣ commonMain/
 ┃ ┣ androidMain/
 ┃ ┣ iosMain/
androidApp/
iosApp/

✅ Step 2: Add Dependencies

In shared/build.gradle.kts:

kotlin {
    android()
    iosX64()
    iosArm64()
    iosSimulatorArm64()

    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation("io.ktor:ktor-client-core:2.3.0")
                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.0")
                implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")
            }
        }
    }
}

🔗 Sharing Code Between Android and iOS

Let’s say you want to fetch a list of users from an API and display them in both Android and iOS.

Step 1: Create a shared UserRepository

// shared/src/commonMain/kotlin/repository/UserRepository.kt
class UserRepository(private val api: UserApi) {
    suspend fun getUsers(): List<User> = api.fetchUsers()
}

Step 2: Implement UserApidifferently per platform

// androidMain
actual class UserApi {
    actual suspend fun fetchUsers(): List<User> {
        // Use Ktor or Retrofit for Android
    }
}

// iosMain
actual class UserApi {
    actual suspend fun fetchUsers(): List<User> {
        // Use Ktor or native iOS networking
    }
}

✅ Both platforms can now use UserRepository, while customizing how networking is handled behind the scenes.

🧪 Testing and Debugging Shared Code

You can write unit tests for shared logic in commonTest. These tests run on the JVM and help catch bugs early without needing to launch full Android or iOS apps.

class UserRepositoryTest {
    @Test
    fun testUserFetchingReturnsData() {
        val repo = UserRepository(FakeApi())
        runBlocking {
            val users = repo.getUsers()
            assert(users.isNotEmpty())
        }
    }
}

📱 Accessing Shared Code from iOS (Swift)

Once you build the iOS framework, Xcode can access your shared Kotlin code:

import shared

let repository = UserRepository(api: UserApi())
repository.getUsers { users in
    print(users)
}

You get full Swift interop with Kotlin types, including generics and suspending functions!

⚖️ Pros and Cons of Kotlin Multiplatform in 2025

✅ Pros

Share up to 70–80% of business logic
No compromise on native UI
One codebase, fewer bugs
Seamless Swift/Obj-C interoperability
Great IDE support with Android Studio and AppCode

❌ Cons

Requires iOS build tools (Xcode, macOS)
Larger learning curve than Flutter
Not ideal for complex UI sharing
Limited third-party library support (though improving rapidly)

🚀 Real-World Use Cases

CashApp: Core business logic shared between Android and iOS
[Netflix]: Uses KMP for internal tooling and logic reuse
[VMware]: Backend and frontend shared logic

🧠 Conclusion

Kotlin Multiplatform is no longer “experimental.” In 2025, it’s a production-ready tool that empowers Android developers to ship features faster, test smarter, and support more platforms — with less code.

If you already know Kotlin and want to reach iOS without learning Swift from scratch, KMP is your best entry point into the world of cross-platform development.

Buy a coffee for me ☕️

buy me a coffee ☕️

Connect with me👇🏻

LinkedIn — Github —

Listen to Our Podcast 🎧

Spotify

Bootcamp