Is Kotlin Multiplatform Right for Your App in 2025?

After around 8 years working on 25+ iOS apps, I finally got to play with Android a bit, thanks to Kotlin Multiplatform (KMP). Before that, I tried out other cross-platform tools like Flutter and React Native, so I got a pretty good sense of what works, what doesn’t, and when it actually makes sense to go cross-platform.

Now in 2025, a lot of teams are looking for ways to build apps for both iOS and Android without doubling the work. So, in this post, I want to give you a clear, honest look at Kotlin Multiplatform: how it compares, when it’s worth it, and when maybe you should stick to native.

My experience with Flutter and React native programming

When I first tried Flutter, I went through Angela Yu’s full course, and I’d recommend it to anyone starting from scratch. I built a bunch of small Flutter apps during that course, and I quickly noticed that UI building felt a lot like SwiftUI or Compose. That part was easy for me to pick up.

But then came Dart, the language behind Flutter. For some reason, I just didn’t feel like diving deep into it. I had a sense that better options would come along, and that’s where my Flutter journey paused. If you’re curious about a deeper comparison, check out my post on KMP vs Flutter.

React Native, on the other hand, I only touched when helping transition a couple of apps from React Native to Kotlin. First, getting the projects to run with all the scripts and Expo was kind of a pain. Second, most of the code was in JavaScript, not TypeScript, and honestly, it felt messy. Overall, it didn't feel right to use it for long-term projects across multiple target platforms.

For a more detailed look, see my KMP vs React Native blog.

Then I stumbled across Kotlin Multiplatform, and it immediately made sense. Unlike Flutter, with KMP you can:

Share only the business logic, or the pieces you choose

Build UI natively on iOS and Android, so performance is truly native

That was enough to grab my attention. Fast forward six months from that time, and my team and I manage Kotlin Multiplatform projects for three different clients. It’s been a solid foundation for us as a trusted cross-platform mobile app development company.

The cool part? Kotlin Multiplatform isn’t limited to iOS and Android. It works across macOS, Windows, Linux, watchOS, and more. Its main use case is simple: share code between platforms without compromising native performance.

‍

Big companies are adopting Kotlin Multiplatform

McDonald’s, Netflix, 9gag, and now H&M: these are just some of the big names already using Kotlin Multiplatform (KMP) for their Android and iOS apps.

You heard that right! When I first saw this, I was curious how our approach to KMP compares to how these companies are implementing it in real projects.

‍

McDonald’s

At McDonald’s, the main motivation was reducing the total amount of code they need to maintain. One of the biggest advantages of KMP is having business logic isolated and fully unit-tested in one place. They’re taking a careful, step-by-step approach, migrating shared functionality piece by piece to Kotlin Multiplatform.

Netflix

Netflix has been using KMP in their app Prodicle, built from scratch to innovate in the physical production of TV shows and movies. A key focus for them is keeping communication with the database and offline support in one shared module, which makes their codebase cleaner and easier to maintain.

9gag

9gag has an interesting journey. They migrated the whole app to React Native in 2016, but performance issues pushed them back to native. When Flutter started gaining traction in 2020, they experimented with it, but lack of ad and Firebase support held them back. Finally, they gave Kotlin Multiplatform a shot.

Their approach was gradual: starting with sharing constants, then writing shared utils in KMP, and eventually moving the entire business logic to the shared module. Now, they’re using KMP for network calls, offline mode, shared resources (via moko-resources), and encryption/decryption.

H&M

Recently, H&M implemented a shared layer for feature flags handling using Kotlin Multiplatform, and they reported it as a success. They plan to continue expanding their KMP adoption across other features, which is another strong signal that Kotlin Multiplatform is gaining traction in large-scale enterprise apps.

A couple of weeks ago, Google also announced they are using KMP for the Google Docs iOS and Android app.

Deciding what pieces of logic to share in the KMP shared module

As I mentioned earlier, one of the coolest things about Kotlin Multiplatform is that you get to decide which parts of your business logic to put in the shared module, so the same code can run on both iOS and Android.

When it comes to sharing code in KMP, there are generally two approaches:

1. Data layer only – Share models, repositories, networking, and other backend logic.
2. Data layer + view models – Everything from above, plus sharing view models between iOS and Android.

Our team went with the second approach because we wanted to take full advantage of Kotlin Multiplatform. We read all the available articles about sharing view models and dove in. Spoiler: it was way trickier than we expected.

Here were the main challenges we faced:

• Compatibility issues – You need to figure out which Kotlin and Java versions play nicely with the latest Swift version.
• Third-party library dependencies – Sharing view models relies heavily on moko-mvvm, which had compatibility problems with Swift 5.9. The fix? We downloaded some files from the library and added them manually to our iOS project.
• Lack of proper documentation – Every time we hit an issue and searched online, we kept finding the same three articles over and over.

By carefully managing run configurations by our experienced developers for both iOS and Android, and adjusting settings for each target platform, we overcame these challenges.

Kotlin Multiplatform for shared module

Things we shared between the apps:

1. Models
2. ViewModels (business logic)
3. All API and communication with the database logic
4. Resources (images and strings)
5. Compose for building UI in Android
6. SwiftUI for building UI in iOS
7. Firebase Firestore as a database

Over time, we refined our approach using tools like mokko-mvvm and kmm-viewmodel. Google’s support for Android native ViewModels in KMP further simplified things. Proper run configurations and testing on each target platform were essential to make everything work smoothly.

• mokko-mvvm (https://github.com/icerockdev/moko-mvvm) - we had a difficult time making it work properly with SwiftUI. Eventually, we ended up creating the new view models on the iOS side which had the reference to the shared view model
• kmm-viewmodel (https://github.com/rickclephas/KMM-ViewModel) - I immediately saw it works much better with SwiftUI than mokko-mvvm, and we decided to give it a shot in our second KMP project. Ended up working well for us, without the need for local view model wrappers
• Android native ViewModel - so as Google introduced the support for the Android ViewModels in the KMP, all you need now is to conform the one you want to share to ViewModel, and you will be able to access it in your iOS codebase. No third-party library is needed anymore. How good is that? We are still at the initial stage of adopting this approach and I’ll let you know how it goes.

We will keep exploring and pushing boundaries side by side with KMP!

Conclusion

Kotlin Multiplatform is no longer just an experiment, it’s a solid, reliable choice for cross-platform mobile app development. I’m glad it’s now a core part of our services.

The great thing is, all you really need is an Android developer who knows how to migrate existing projects and set up shared code so both your iOS and Android apps benefit from it. With KMP, you get native performance on each platform plus shared business logic that makes maintenance and updates way easier.

If you want to see how Kotlin Multiplatform can work for your app, or explore other ways we help teams build, scale, and maintain mobile apps, check out the rest of our website. You’ll find case studies, tech insights, and tools that make building cross-platform apps smarter and faster.