Why we love multiplatform with Kotlin and Compose

If you’ve been following what’s happening in the Android and Kotlin world lately, you might have noticed that Kotlin Multiplatform (KMP) and Compose Multiplatform (CMP) are quietly, but powerfully, changing how we build apps. Created by JetBrains and backed by Google, Kotlin Multiplatform is gaining strong momentum and long‑term support.

At Q42, we have been putting both technologies to work in real projects, like our McDonald’s app, used by millions of users every day. Real users. Real scale. Real Kotlin Multiplatform.

So why do we like it so much?

The duplication dilemma

When you build for iOS and Android, things often get unnecessarily complicated:

• two separate codebases
• two separate teams
• two different implementations of the same logic
• twice the chance for bugs to sneak in

Every new feature, backend change, or tweak needs to be built and tested twice.

This is why Kotlin Multiplatform is so appealing.

Kotlin Multiplatform: one logic to rule them all

Kotlin Multiplatform lets you share code across platforms such as Android, iOS, web or even backend servers. You write your business and data logic (networking, data models, authentication, caching) and presentation logic once, and then reuse it everywhere.

Using Kotlin Multiplatform on Android, your app just calls the shared Kotlin library. On iOS, the same Kotlin code compiles to native binaries that Swift can use directly. As a result, both apps are native while a lot of logic is shared.

Pure native experience. No compromises.

At Q42, we use this setup on the McDonald's app, where all the non-UI logic lives inside the shared KMP module. That means:

• We implement the hard stuff only once.
• We write most of our test code only once.
• Android and iOS both use the same code, up to and including the presentation layer.
• The UI is native, so the app feels native. Because SwiftUI and Compose are used to create the user interfaces, users won’t see or sense that Kotlin Multiplatform is powering it.
• Trade-off: less code to write and maintain, but a bit more complexity to manage. The handoff between KMP and native needs careful design to provide an intuitive API on the native side.

The result: consistent behavior across platforms, easier maintenance, and faster development.

We use this approach either as a shared library inside existing native apps for HeartEye, an app that reads, filters and displays ECG data from a hardware device. Or, as in the case of McDonald’s, as the core for a full-scale app.

Compose Multiplatform: design once, deploy everywhere

In addition to KMP, there is also Compose Multiplatform (CMP). While Kotlin Multiplatform focuses on sharing business logic across platforms, Compose Multiplatform extends this by enabling shared user interfaces.

Compose Multiplatform builds on Kotlin Multiplatform in combination with Jetpack Compose, which Android developers already know and love. It extends the same declarative UI system to desktop, web and iOS. You can design flexible, modern interfaces once and have them run on multiple platforms. On Android, the UI is native. On iOS, the interface is still evolving toward a truly native experience and currently feels somewhat similar to React Native or Flutter implementations. But with JetBrains and Google actively improving this technology, we expect rapid and steady enhancements.

We have used this technique in Q42’s Hack The Planet app, that we use to manage poacher camera traps. Featuring shared logic, presentation, and UI layers. In other words: almost everything is shared.

This setup stays flexible. If we need a custom iOS view, we can still use SwiftUI. If a screen calls for something platform-specific, like a Google Map, we can use that.

At Q42, we’re working on an internal CMP project template that helps teams get started instantly. It includes:

• a pre-configured multiplatform setup
• shared design system components
• sample implementations for navigation and data flow
• a place to share knowledge and reusable code

With this template, we can spin up a Compose Multiplatform project and start coding in minutes.

How it compares to React Native

React Native is often brought up when discussing multiplatform frameworks. It’s worth clarifying how it differs from Kotlin Multiplatform and Compose Multiplatform.

React Native uses JavaScript or TypeScript to build shared UI components and executes them through, using New Architecture, a C++ based JSI layer that calls native APIs at runtime. It uses legacy views, no Compose nor SwiftUI. Kotlin Multiplatform shares business logic written in Kotlin code, compiled natively, resulting in a native app. In that sense, Kotlin Multiplatform is something very different from React Native. Compose Multiplatform however, is closer to React Native. It lets you share UI code too. However, it achieves this entirely in Kotlin, bridgeless.

• No runtime translation layer.
• Better native performance.
• Stronger type safety and the advantages of the modern Kotlin programming language.
• Simpler maintenance and upgrade paths.
• Familiar JetBrains and Android Studio tooling.
• No legacy Views that require maintaining or fixing bugs in both the native View layer and the React Native bridge code.

So while React Native or Flutter works well for many use cases, KMP and CMP give us tighter integration with native systems and better long-term maintainability.

Why we love KMP and CMP

We love KMP and CMP, because these technologies make teams faster, collaboration smoother, and products more consistent.

• Consistency – Shared logic means fewer platform differences.
• Happier developers – One language, fewer repetitive tasks.
• Speed – Build and ship features faster.
• Future ready – Kotlin keeps evolving, backed by JetBrains and Google.

Because our developers genuinely love working with these techniques, many of them build their own apps and games with KMP and CMP in their free time. But this isn’t just an experiment. The McDonald’s app, used by millions of people in more than 60 countries, relies on Kotlin Multiplatform for its core logic. It’s a tested and proven technology that continues to grow more powerful with every release.

What’s next

We’re investing more time and energy into improving our Compose Multiplatform template and building a reliable shared foundation across the Eidra network of studios where Q42 is part of.

The goal is simple: deliver better digital experiences without doubling our work. Because Kotlin Multiplatform development has matured from a buzzword into a real, production-proven approach.

Want to learn more? We love talking about Kotlin, multiplatform development and efficient ways to build digital products. Feel free to reach out, we’ll happily talk to you once, for every platform.

🇳🇱 👋 Hey Dutchies!
Voordat je gaat... we zoeken nieuwe Q'ers!