Kotlin Multiplatform (KMP) Reaches Critical Mass in Enterprise Adoption: A 2026 Retrospective

Host: Hey everyone, welcome back to Allur, the show where we dive deep into the tech stacks that are actually shaping the industry. I’m your host, Alex Chan. Today, we’re doing something a little bit different. We’re standing here in the middle of 2026, and looking back, the landscape of mobile development has shifted so fundamentally that it’s almost hard to remember how we used to struggle just three or four years ago. Host: I am so excited to be joined today by Marcus Thorne. Marcus is the Principal Mobile Architect at FinStream—one of the largest fintech platforms that successfully moved their entire mobile infrastructure over to KMP back in late 2024. Marcus, you’ve seen the "before and after" of this enterprise shift firsthand. Welcome to Allur! Guest: Thanks, Alex! It’s great to be here. Honestly, it feels a bit surreal to talk about this as a "retrospective," because I still have the scars from the early migration days, but looking at where we are now in 2026? Yeah, the world looks very different for mobile devs. Host: It really does. I remember back in 2023, every time I mentioned KMP to an enterprise CTO, they’d say, "Well, the business logic sharing is cool, but what about the UI?" They were so scared of that "non-native" feel. Looking back, was the stabilization of Compose Multiplatform for iOS the actual turning point? Guest: Oh, absolutely. Without a doubt. Before that, KMP was a "logic-only" story. You’d share your networking and your database, which was great, don’t get me wrong! But you still had to build the UI twice—SwiftUI for iOS and Jetpack Compose for Android. When Compose Multiplatform for iOS finally hit that "production-ready" status and stabilized, it changed the math. Actually, at FinStream, that was the moment our stakeholders stopped seeing it as a "developer experiment" and started seeing it as a "business strategy." Host: I think that’s an important distinction. It’s about the confidence. I’ve heard people say that the UI in 2026 is indistinguishable from native. Is that actually true in practice, or is there still some "jank" hidden in there? Guest: Honestly, Alex? It’s indistinguishable. And that’s coming from someone who used to be a native iOS purist! The way it compiles directly to native views—it’s not a web view, it’s not a wrapper. It’s leveraging the same hardware acceleration. In our 2026 builds, the scrolling physics, the accessibility support... it’s all there. The "aha moment" for my team was when we realized we could define a complex dashboard once in Kotlin and it just... worked. And if we *did* need something hyper-specific to Apple, like some deep integration with the latest Live Activities or whatever, we just used the `expect/actual` pattern. Host: Right! I wanted to ask you about that. For anyone listening who’s maybe a bit newer to the KMP world, can you explain why `expect/actual` is such a game-changer compared to, say, the "bridges" we used to build in React Native? Guest: Yeah, so, in the old hybrid days, you’d have to pass data over this "bridge" which was slow and, honestly, a nightmare to debug. With KMP, it’s much more elegant. You basically say, "I expect this class to exist," and then you provide the actual implementation for each platform. Like, for our biometric login at FinStream, we have an `expect class BiometricAuthenticator` in our common code. Then in the `androidMain` folder, we write the actual code using the Android BiometricPrompt API, and in the `iosMain` folder, we write it using Apple’s LocalAuthentication. The common logic just calls `authenticate()` and doesn't care how it happens. It’s native performance with a shared interface. Host: That sounds so much cleaner. But it couldn't have been all sunshine and roses, right? What was the biggest struggle you faced during that 2025 period when everyone was rushing to adopt this? Guest: (Laughs) Oh, the "talent war" was real. In 2025, finding developers who understood the KMP lifecycle was tough. We had a lot of Android devs who knew Kotlin but didn't understand the iOS memory model or how to optimize for LLVM. And our iOS devs were initially... let's say "skeptical." They felt like their platform was being "Kotlin-ified." We had to show them that KMP actually freed them up from doing the boring stuff—like rewriting JSON parsers for the tenth time—so they could focus on the really cool, platform-specific features that make an iPhone feel like an iPhone. Host: That's such a common friction point—the culture clash. But now, in 2026, we’re seeing a strategic shift away from Flutter and React Native. Why do you think KMP is winning that "enterprise standard" title? Guest: I think it comes down to longevity and performance. Enterprises are tired of "re-platforming" every four years. KMP feels more sustainable because it’s not an "all-or-nothing" framework. You’re writing native code. If, for some crazy reason, you wanted to stop using KMP tomorrow, you’d still have native binaries. Plus, the talent pool. Kotlin has become so ubiquitous—not just for mobile, but for backend too. Seeing KMP logic used in backend services now? That’s where the real ROI is. Host: Wait, that’s a great point. Are you guys actually sharing logic between the mobile app and the server? Guest: We are! We share our validation logic and our data models. If a product price format changes, we update it in one Kotlin module and it propagates to the Android app, the iOS app, and the microservices. It’s this "single source of truth" that managers have been dreaming about since the 90s. Host: That is wild. It’s like the "Write Once, Run Anywhere" dream actually came true, but without the Java Applet nightmares. Guest: Exactly! Just with much better syntax. Host: So, looking ahead—since we’re already in 2026—where do we go from here? Does KMP just keep expanding? Guest: I think so. We’re already seeing it move into desktop and even embedded systems. But the big thing will be the ecosystem maturity. We’re seeing more "KMP-first" libraries now. It’s no longer about "Is there a library for this?", it’s "Which KMP library is the best for this?" That’s a huge shift in the developer experience. Host: It’s been an incredible journey to watch. Marcus, before I let you go, for a dev who’s still stuck in a legacy native or hybrid codebase and wants to start moving toward this 2026 reality... what’s your one piece of advice? Guest: Don’t do a "Big Bang" rewrite. That’s where companies fail. Start with one module. Maybe it’s your analytics logic or your auth flow. Move that to KMP, get it working on both platforms, and let the results speak for themselves. Once the stakeholders see that 50% reduction in bug reports for that module, they’ll give you the green light for the rest. Host: That is such solid advice. Start small, prove the value, and then scale. Marcus, thank you so much for joining me today on Allur and taking this trip down memory lane... even if it's a "future" memory lane! Guest: (Laughs) Thanks for having me, Alex! It was a blast. Host: And thank you all for tuning in. The KMP story is a perfect example of how patience and technical excellence eventually win out in the enterprise. If you want to see some of the code examples Marcus mentioned, specifically that `expect/actual` pattern for biometrics, check out the show notes at Allur.tech. We’ll also have links to some of the top KMP libraries that are dominating the scene here in 2026.