Migrate Kotlin Project to Kotlin Multiplatform: Why and How

Being here probably means you already have an Android project in Kotlin and are considering migrating it, or you simply want to better understand how the process works. We did our best to provide you with the information you’re looking for.

By the end of this text, you will learn about the benefits of using Kotlin Multiplatform for your mobile app project, how to convert your Android project to KMP, and who to ask for help if you get stuck.

But first, let's give a couple of words about Kotlin.

About Kotlin

Kotlin is an object-oriented programming language and the main language used in Android app development. It was developed by JetBrains in 2010, and after 7 years, Google officially announced its support. Compared to the previous official languages, Java, Kotlin allows the developers to write 20% less code, provides Null safety, and gives you additional Lambada expressions, companion objects, data classes, coroutines, and more (source).

What is Kotlin Multiplatform?

To make the process of development easier and faster, in the 1.2 version of Kotlin, JetBeen introduced Kotlin Multiplatform (KMP) solutions to build apps with one codebase not only for smartphones but for smart TV, Web, Desktop, and server-side applications.

This technology allows the sharing of logic code across multiple platforms while keeping UI native. It should not be confused with Compose Multiplatform, which enables you to share the UI as well.

Many big companies are already using Kotlin Multiplatform for their mobile apps because they realize the advantage KMP provides. The most popular are Netflix, Forbes, McDonald's, and 9GAG.

Benefits of using Kotlin Multiplatform for your app

Using Kotlin Multiplatform can provide certain benefits for you and your projects, and some of them are:

Shorter development time

Writing only one business logic code for both platforms is something that definitely will shorten your development time.

Compatibility with existing projects

Unlike React Native or Flutter, which often require rebuilding your app from scratch, Kotlin Multiplatform allows you to build upon your existing Kotlin-based Android app.

Decreasing the development cost

Kotlin Multiplatform (KMP) allows sharing of code between iOS and Android applications, which drastically reduces development time. Less development time means a smaller budget and reduced costs.

Better performance of your mobile apps

Using other solutions that allow you to shorten your development time and write apps with one code for both platforms can slow your apps, which will give a bad experience for your users. Especially for bigger projects.

Native look

Kotlin Multiplatform helps you maintain the native look and feel of both iOS and Android apps, giving users a smooth experience that fits each platform’s design.

If you are still not sure if Kotlin Multiplatform is for your project, read more about it in our blog: Kotlin Multiplatform: Is It Really the Right Choice for Your App?

Now, that you are familiar with all the advantages KMP offers, let's see how to migrate your project into KMP.

How to convert Kotlin to Kotlin Multiplatform?

Here are the steps to guide you toward a successful migration. But, before you begin, make sure you fully understand each step and how it fits into the overall process to avoid potential challenges along the way.

Let's start:

• Make sure your repositories are ready: Make sure your common logic for both Android and iOS platforms has access to the repository. If you have both Android and iOS app, you probably have two separate repositories. We recommend you merge them into one mono repo.
• Modularize your shared code: A module can be defined as a collection of source files and build settings that let you divide your project into discrete units of functionality. Modularization is important in Kotlin Multiplatform (KMP) because it improves code organization, maintainability, scalability, and reusability.
• Change your code to become Swift-friendly: When Kotlin code is compiled, it transforms into native code for each platform. For iOS, Kotlin is converted into Objective-C. This can be problematic because Kotlin has some functionality that Objective-C doesn't recognize and some functionality can be lost. In Kotlin-Swift interopedia you can learn more about how Kotlin interacts with Objective-C.
• Adjust Dependency Injection: ID is part of any larger project because it increases flexibility and allows you to write more efficient code. A library that the developer used the most for ID in the Android project are Dager and Hilt. Unfortunately, these libraries are based in Java and not supported by the iOS platform and KMP. But there is Hilt, a compatible library.
• Migrate your project’s model classes: Model classes represent objects like User or Product that hold data and business logic. All you need to do is adjust some of them with a library that is not supported by the iOS platform.
• Make Data Source migration:
  REST: Many Android projects use the Retrofit library because it simplifies the process of making API requests and handling responses. But it is a Java-based library, and it is not compatible with KMP, so instead of Retrofit, we encourage you to use Ktor.
  
  Jetpack DataStore: If you’re already using this solution, there’s no additional work required. However, if you want to ensure everything is set up correctly, simply review this guide.
  
  Firebase: Until this article is written, there isn't an official solution for the implementation of Firebase in your KMP project. The reason for that is the Firebase Android SDK is based on Java, and Google doesn't develop an SDK based on Kotlin. However, there is an open-source solution, Firebase Kotlin SDK, that can get the job done.
• Migrate APIs and SDKs: For KMP, platform-specific code is needed for interaction with system APIs and third-party SDKs. To manage this, you need to write an abstract interface in the shared code to define the required functionalities across all platforms. After that, you need to write platform-specific code for Android and iOS. In more complex scenarios, the interface can be written directly in the native applications. This way, the shared module only exposes the interface and allows the native app to provide its own implementation.
• Business logic migration: Because all the necessary components, such as APIs, SDKs, and data sources, have already been migrated, this process is going to be straightforward. All you need to do is move code from the Android app to the commonMain source in the shared module
• Migrate presentation logic:
  To complete this final step, you need to adapt ViewModels for both Android and iOS platforms. On Android, the ViewModel class, which is typically inherited from Jetpack ViewModel, can be directly used in KMP after code migration to the shared module. For iOS, if you’re using SwiftUI and the UIHostingController, the solution is to create a small wrapper class that implements the ViewModelStoreOwner interface.
  
  In terms of data flow, Android ViewModels expose data streams to the UI via Kotlin Flows. In a Compose UI, this data can be collected using functions like collectAsState. On iOS, Kotlin Flow is converted into a Swift AsyncSequence using the SKIE plugin, which doesn’t have a built-in method for observing AsyncSequence. To address this, you can create a custom ViewModifier that binds the Flow from the ViewModel to a specific @State property in SwiftUI.
  
  When migrating the presentation layer, handling Parcelable data can be a challenge because it works on Android but not in KMP's shared code. The solution for you is to use the expect/actual mechanism. In the shared commonMain code, define expected versions of the Parcelable interface and Parcelize annotation. In the androidMain code, implement the Android-specific Parcelable and Parcelize to retain the same behavior as before.

‍

If you need a more detailed explanation about how to migrate your Kotlin application to Kotlin Multiplatform, step by step, you can find it in our free e-book

Conclusion

In the mobile app industry, change is always happening, and sticking to outdated solutions can leave you behind your competitors. Cross-platform development is one of the trends for 2025. By allowing a single codebase for business logic while maintaining a native look and performance, KMP enables faster development without compromising quality compared to other cross-platform solutions.

Migrating an existing Kotlin project to KMP offers numerous benefits, including shorter development time, reduced costs, and improved performance. The process involves preparation, research, and planning but is achievable with the right approach.

Aetherius Solutions has extensive experience developing mobile app projects for startups and large enterprises, many of which use KMP technology. If you are considering migrating your project or building a new one from scratch and need professional help, feel free to contact us.