More than 10 years ago, I ventured into the world of mobile development. The transition from BlackBerry to Android was a game-changer, and seeing a touchscreen capable of detecting multiple fingers at once blew my mind. It was love at first sight. Or was it my first codependent relationship with technology?

From that moment on, I became obsessed with creating apps—programs designed to be touched. But there was a problem: developing an app meant choosing a side. Android or iOS. Java or Objective-C. Open-source or a closed ecosystem. As a 21-year-old enthusiast, I dived headfirst into Android.

Back then, there were no free courses, YouTube tutorials, or AI to write code for you. Just forums, documentation, and endless trial and error. That’s how I discovered my first hybrid solution: Apache Cordova. What a revolution! Now I could write code once and run it on any platform. My first app was simple yet meaningful—a button that, when pressed, told my girlfriend how much I loved her. I’m a romantic, I know.

From Hybrid Disappointment to Native Love

Like any relationship with high expectations, the illusion quickly shattered. Cordova was just a web page wrapped inside an app icon. Slow, clunky, and disappointing. It felt like that girlfriend who seemed perfect at first but turned out to be completely different in reality.

The solution? Learning native development. Nothing beats native. I realized that quickly and stayed loyal to it. Although Ionic, React Native, and even Flutter (which, to be honest, was the sexiest of them all) tried to seduce me, I never abandoned pure Android.

Then, Kotlin arrived and changed our lives. We moved from a verbose language like Java to something more expressive, clean, and powerful. There were some bumps along the way, but it was a change for the better. And just when I thought nothing could surprise me, Kotlin Multiplatform (KMP) appeared.

Kotlin Multiplatform: The Promise of Unification

KMP wasn’t just another empty promise of “write once, run everywhere.” No, this time it made sense. It didn’t try to force the UI across all devices with a single codebase; instead, it focused on sharing what truly matters: business logic.

For those unfamiliar, KMP allows you to share code across platforms without sacrificing native performance. It doesn’t enforce a generic UI but lets each platform handle its interface natively. Think of it as a multiplatform library that encapsulates data models, API connections, and business rules, ensuring consistency and reducing code duplication.

The result?

• Less duplicated code. A single source of truth for business logic.
• Better-aligned teams. Android, iOS, and Web developers working on the same logical foundation.
• Native performance. No unnecessary rendering engines or bloated dependencies.

And most importantly, you’re still coding in Kotlin, a language we already mastered and one that’s very similar to Swift. A win-win for both Android and iOS developers.

How to Get Started with Kotlin Multiplatform?

If all this sounds interesting and you want to try it, JetBrains makes the process easy with KMP Wizard.

KMP Wizard: The Easiest Way to Set Up a KMP Project

JetBrains has developed a tool called KMP Wizard, which helps configure a KMP project from scratch based on your needs. You can choose whether to share only business logic or also use Compose Multiplatform (Kotlin’s UI library for cross-platform interfaces).

Steps to Create Your First KMP Project

1. Go to KMP Wizard at https://kmp.jetbrains.com/.
2. Select the features you want in your project.
3. Download the .zip file containing the pre-configured project structure.

This file includes the necessary folder structure and dependencies to get started.

Now, where do you open this project?

• Android Studio is the best option, but it doesn’t support everything out of the box.
• Install the Kotlin Multiplatform plugin from JetBrains Marketplace.

Two Tips to Ensure a Smooth Start

1. Download the Kotlin Multiplatform Project Viewer plugin for better project visualization.
2. Use KDoctor on macOS to verify that you have all the necessary components. Install it with:

brew install kdoctor

1. Then run

kdoctor

1. If everything checks out, you’re ready to start using KMP in Android Studio.

And that’s it! You can now start experimenting with Kotlin Multiplatform. 🚀

Companies That Have Already Adopted KMP

If all this sounds like an overpromise, it’s actually already happening in practice. Companies like Google, Netflix, McDonald’s, and 9GAG have started adopting KMP in their products.

Even Google is migrating many of its libraries to KMP—something it never did with any other multiplatform solution. This isn’t just a passing trend; it’s a paradigm shift.

JetBrains is also making a strong commitment. Fleet, their experimental IDE, dropped KMP support because they now have something even more ambitious in mind: a much more robust development environment based on IntelliJ and Android Studio.

Flutter vs. KMP? Key Differences

If you’ve worked with Flutter, you’re probably wondering what the difference is.

Architecture

• Flutter: UI and business logic are tightly coupled within its own Dart-based ecosystem.
• KMP: Separates business logic from UI, allowing for 100% native interfaces.

Performance

• Flutter: Uses its own rendering engine (SKIA/Impeller), which adds weight and may affect performance.
• KMP: Doesn’t need a rendering engine because it works with native UI.

App Size

• Flutter: Apps include the rendering engine, making them heavier.
• KMP: Doesn’t add unnecessary dependencies, keeping the size optimized.

Kotlin Full Stack: The Next Big Trend?

Kotlin is not only leading Android and KMP but also growing in backend development with Ktor, allowing for efficient and scalable API and microservice development.

With KMP and Ktor working together, a single language can handle both backend and mobile frontend. Are we entering the Kotlin Full Stack era? I think so.

So, Revolution or Disappointment?

If you’ve made it this far, you have enough information to decide for yourself.

KMP is fast, efficient, and native. It’s not a framework trying to impose its own ecosystem; it’s a realistic and flexible solution for the multiplatform world.

I wouldn’t call it a revolution, but it’s definitely not a disappointment. It’s a smart and strategic step in the evolution of mobile development.

Now, the question is: Are you jumping on board, or are you waiting for the next big thing? 🚀