Cross-platform vs. native: choosing the right path for mobile app development in 2025

Do you build two separate, perfectly optimised apps, or do you opt for a single, unified codebase to rule them all? 

Traditionally, there have been many cross-platform solutions to choose from. While there are more niche options, such as .NET MAUI (formerly known as Xamarin), NativeScript and Ionic, this article will focus on the currently predominant alternatives: React Native, Flutter, and the increasingly popular Kotlin Multiplatform (KMP) to Native Android & iOS development.

The gold standard: native mobile development

Native development implies building an application specifically for a single platform, utilising the platform's native programming language, tools and APIs. For iOS, that's Swift or Objective-C with Xcode. For Android, it's Kotlin or Java with Android Studio.

Native applications are compiled into native code, giving them direct access to the device's hardware and APIs. This results in the best possible performance, responsiveness, and battery life. 

Native applications are able to take advantage of the platform’s latest features and new functionalities as soon as they are made available, ensuring that your app feels fresh to end users. Also, native applications can more easily adhere to the platform's design guidelines, offering a user experience that feels familiar and intuitive to the user.

Also, native applications offer a distinct advantage in security-critical applications. They can provide a more secure environment for sensitive data by directly accessing platform-specific security features, such as biometric authentication or secure storage for encryption keys.

The downside of native development is the higher cost and time to develop the application as you need two codebases - one for iOS and one for Android - for the same application. This also means that any new feature or bug fix must be implemented for both platforms separately. 

The other advantage that React Native and Flutter specifically have over native development, to some extent, is that they provide the possibility to push updates to the application without going through the official Google Play Store or Apple App Store publish and review process. 

The challenger: cross-platform development

Cross-platform development allows you to write your code once and deploy it on both iOS and Android. This has long been the dream for many developers and business people alike, and today's frameworks have made it a reality for a vast number of use cases.

Kotlin Multiplatform (KMP): the best of both worlds?

Kotlin Multiplatform (KMP) is the new kid on the block that's rapidly gaining traction. Developed by JetBrains, the creators of Kotlin, KMP takes a unique approach. Instead of dictating the UI, it focuses on sharing the business logic, networking, and data layers of your app across platforms, while allowing you to build a fully native UI for each. 

This approach gives you the best of both worlds. You can share business logic that remains consistent across platforms while building native UIs that deliver an optimal user experience and authentic platform feel.

Both the shared business logic and the native UI code are compiled down to native platform code, ensuring high performance and the feel of a native application. Teams can share up to 90% of the business logic code, significantly reducing development time and the likelihood of bugs.

With Google's backing and a growing ecosystem, KMP can be confidently adopted today. For existing applications, you can begin by integrating a small shared module and gradually expand its use.

A consideration for KMP is its relatively small, though growing, community compared to React Native or Flutter. This can make it harder to find solutions and libraries. Additionally, iOS developers familiar with Swift will need to learn Kotlin.

React Native: The JavaScript powerhouse

Backed by Meta, React Native has been a dominant force in the cross-platform world for years. It allows web developers to leverage their existing JavaScript, TypeScript and React knowledge to build native mobile apps.

The abundance of frontend and React developers makes it easier to find talent. With access to the entire npm library, they can find a package for almost anything they need.

Something that makes native mobile developers jealous is features like “Fast Refresh,” which allow for near-instant feedback during development, thereby speeding up the development process. React Native offers a unique feature: over-the-air updates for applications, bypassing the native app store review process. While powerful, this capability technically violates Apple App Store guidelines. Thus, at least for now, React Native applications must simply rely on Apple overlooking this particular violation of the app store review process.

While the new React Native architecture has improved performance, React Native can still struggle with complex animations and graphically intensive tasks compared to native or Flutter. 

Additionally, applications heavily relying on platform-specific APIs (e.g., location, Bluetooth, or payment) will require native bridge code. This code enables JavaScript or TypeScript to access these APIs, but it can negatively impact performance and complicate debugging. 

While React Native benefits from the npm ecosystem, this also presents a challenge: updating React Native can be incredibly difficult due to the complexities of managing all dependencies. Additionally, the abundance of npm libraries is a blessing; however, even the simplest React Native application often requires tens, if not hundreds, of third-party libraries. These can all potentially pose a security risk, as demonstrated by recent npm supply chain attacks.

The Expo framework streamlines the React Native app development by offering pre-built libraries with stable JavaScript and TypeScript APIs, thereby simplifying access to features such as the camera, GPS, and push notifications. Additionally, Expo CLI tools facilitate easy management of the development environment, as well as application building and publishing.

Furthermore, the React Native development environment extends beyond the integrated tools of Android Studio or Xcode. The React Native toolchain is complex, relying on tools installed via Homebrew, Node.js and Ruby version managers, as well as the Expo CLI tools. This fragmented environment can be challenging to maintain and is prone to instability if any of the tools require updates.

Flutter: Performant custom UIs

Developed by Google, Flutter has taken the mobile development world by storm with its focus on beautiful, high-performance user interfaces. It uses the Dart programming language and its own rendering engine (Skia/Impeller) to draw the UI from scratch.

Flutter gives developers complete control over every pixel on the screen, allowing for some beautiful, custom UIs that look and feel the same on both iOS and Android. Flutter applications are compiled to native code, offering near-native performance, especially for UI-heavy applications. 

Flutter also benefits from the “Hot Reload” feature, similar to React Native’s “Fast Refresh,” which allows for rapid iteration and development.

Flutter is king for custom UIs, but it struggles with providing a familiar platform-specific look and feel. When the platform introduces a new UI style, the Flutter community must build that new UI style themselves.

While Dart is a modern and well-designed language, it’s not as widely known as the other languages presented above. This can have a negative impact when the team needs to grow. 

Also, Flutter apps tend to have a larger file size compared to native or KMP apps.

Conclusion 

The appropriate approach for the development model for the application is largely determined by its intended use.

For an optimal user experience and robust long-term development support, native development remains the top choice. Alternatively, Kotlin Multiplatform (KMP) offers many similar advantages to native development for those who are not afraid to try a newer alternative and adopt the Kotlin language. React Native is ideal when you have existing web frontend developers proficient in React, and if user experience isn't the primary concern, and you are not afraid to dive deep into the good and bad of the npm ecosystem. Flutter shines when building applications with custom UIs that don't require a native platform feel, provided you're comfortable with a less common programming language.