Developers today are often confused when trying to pick the best framework for building apps. Native Android and iOS were the most sought-after ones until recently. Today, though, businesses and developers are looking for a technology that lets them share code across platforms while also ensuring that there aren’t any performance hiccups.

At the turn of this decade, mobile application developers do have a wide variety of frameworks and technologies to choose from. Facebook’s React Native is still the preferred framework for building cross-platform apps. Despite this, Google’s Flutter, a relatively new kid on the block, has gained steam and is breathing down React Native’s neck. At the same time, the Xamarin and Ionic frameworks are beginning to see a decline in their popularity.

Yet, despite the abundance of cross-platform technologies, rarely would you come across a hybrid app that feels and performs as well as a native one. Reasons for the drastic difference in performances could be attributed to the fact that most of these frameworks essentially contain wrapper UI views; only Flutter boasts a framework that runs a low-level drawing API natively.

Still, Flutter has its own pitfalls, which we’ll discuss more later. Moreover, coming from Google, one can never be too sure about its future, given that the tech giant is known to kill products, services and technologies that are still widely used and beloved.

The shortcomings of all other frameworks bring Kotlin Multiplatforms, the better alternative, into the picture. For those who’re unfamiliar, Kotlin Multiplatforms is JetBrains promising project that lets developers run Kotlin code natively across Android, iOS, Windows, Linux, macOS and other embedded devices. The fact that Kotlin Multiplatforms provides an opportunity to build cross-platform apps with the exact same experience as native ones ensures that the framework has a promising future.

It isn’t an overstatement to say that JetBrains latest project will overshadow other cross-platform frameworks, especially given that the Kotlin language is widely adopted by Android developers.


Kotlin Multiplatform Beats the Rivals, Hands Down

Despite the advantages of a mature ecosystem, React Native didn’t really deliver on its promise of a single code that works across both Android and iOS. Ironically, React Native didn’t stay true to the word “native.”

Looking beyond the single design language React Native provided for writing user interface code, a developer would always be forced to branch their codebase based on the platform-specific APIs for Android and iOS. This problem only led to scalability issues with a lot of bridged code between JavaScript and native platforms. Worse, the animations on React Native were far from native and caused performance limitations.

By contrast, Flutter solved a lot of these issues for cross-platform developers. First, it has its own rendering engine, which allows for both the building and running of high-performance apps. Flutter’s much-talked-about hot reload feature also makes debugging on both Android and iOS a lot easier. By having its own native components, Flutter ensured that there’s not much bridged communication with the native APIs. Even better, the Flutter framework actually addressed the downsides of most cross-platform tools by providing resources to build complex animations. The Flutter community happily proclaims how much easier it made creating custom UI views compared to native Android.

Yet, Flutter suffers primarily due to its newer ecosystem, lack of support for platforms such as watchOS and tvOS apps and a language that isn’t used by many people. Dart, Google’s language for building applications in Flutter, is minuscule when compared to Kotlin, which has a huge base of developers. Worse, it also falls short in its features. The lack of access modifiers, data classes and type safety actually makes Dart feel more like Java than a modern language.

If Flutter were to use Kotlin instead of Dart, things might have been perfect. And this is why Kotlin Multiplatform looks more promising than Flutter.

Kotlin/Native (a part of the Kotlin Multiplatforms framework) lets you run compiling Kotlin code directly to native binaries and also run without a virtual machine. This means one can directly share business logic across platforms. Although this may not seem like a huge deal at first, it’s a massive advantage. Now an Android developer with Kotlin experience can reuse her code in iOS without the need for a third-party framework or language. This makes using Kotlin Multiplatforms a no-brainer since it significantly reduces the development cost and time for building mobile applications. Unfortunately, there is a downside: Kotlin Multiplatforms doesn’t support the sharing of UI logic at the moment. Hence, the developer would have to write the entire user interface code in iOS using Apple’s frameworks (SwiftUI/UIKit).

On the bright side, though, JetPack Compose, Android’s declarative UI framework, is written entirely in Kotlin APIs. So, don’t be surprised if Google makes its UI framework entirely platform-independent in the future, thereby letting developers design native apps powered by Kotlin code across Android and iOS.


Solving the Woes of Google and Android Developers

Google has been worried about Android’s future due to its decade-old battle with Oracle. The use of certain licensed Java APIs and JVM-powered Android devices puts Google at a risk of sharing its business with Oracle.

Perhaps that’s why Flutter was introduced. The fact that Dart doesn’t rely on JVM and is compiled directly to native code helps Google steer clear from Oracle. Also, Flutter supports Fuschia, Google’s secret, non-Linux based operating system that’s likely to be Android’s successor. But Google’s relentless backing of Flutter has actually scared Android developers about Kotlin’s future. Though Google is unlikely to kill native Android in favor of its own cross-platform framework, given the tricky situation it finds itself in, it might actually do so.

Kotlin Multiplatform, despite being backed by JetBrains, is a win-win for Google as well as Android developers. Kotlins ability to support multiple runtime targets much like Dart does ensures that the JetBrains language will continue to be an important part of Android and Google’s future operating systems. More importantly, Kotlin’s native support across different platform architectures pretty much guarantees that native Android developers won’t be forced to switch to Flutter. This has become a moment for them to rejoice as Kotlin makes the transition to iOS development seamless and efficient.


The Big Takeaway

Many platforms over the years have promised the ability to “build once, run everywhere.” All cross-platform frameworks have tried their best but suffered due to the disparity performance differences between native and hybrid apps. Kotlin Multiplatforms Ecosystem is all set to change that by offering developers the ability to use Android’s preferred development language for building apps on other platforms. If nothing else, Netflix’s recent move to switch over to Kotlin Multiplatform is a good signal that JetBrains project has a promising future in app development.

Check Out More From Anupam ChughPython Is About to Get the Squeeze

Expert Contributors

Built In’s expert contributor network publishes thoughtful, solutions-oriented stories written by innovative tech professionals. It is the tech industry’s definitive destination for sharing compelling, first-person accounts of problem-solving on the road to innovation.

Learn More

Great Companies Need Great People. That's Where We Come In.

Recruit With Us