The Cross-Platform Development Promise and Its Evolution
The promise of cross-platform mobile development — write the code once, deploy everywhere — has been a goal of the mobile development industry since the smartphone era began. The early approaches (HTML5-based apps wrapped in a native container, pioneered by PhoneGap/Cordova) achieved the write-once goal at significant performance cost. The next generation (React Native, Xamarin) used a bridge between JavaScript or C# code and native UI components, achieving better performance but introducing complexity at the bridge that caused performance problems in animation-heavy or data-intensive applications. The current generation (Flutter, and React Native’s new architecture) uses more direct compilation and rendering approaches that have significantly reduced the performance gap with native development.
The cross-platform development market share that most reflects current practitioner preferences: Flutter has achieved the highest adoption among the current cross-platform frameworks, with a large and active developer community, strong Google investment, and a consistent developer experience that has produced capable apps across mobile, web, and desktop from a single codebase. React Native maintains significant adoption, particularly in organisations with existing JavaScript/React expertise, and its new architecture (with the JSI bridge replacement and the Fabric renderer) has addressed many of the performance limitations of the original architecture. The choice between these frameworks is often determined more by the team’s existing expertise than by technical capability differences.
Flutter: Dart, Custom Rendering, and Developer Experience
Flutter’s architecture — using the Dart programming language and a custom rendering engine (Skia, transitioning to Impeller) to draw every pixel of the UI rather than delegating to native UI components — produces the most visually consistent cross-platform experience available: a Flutter app looks and behaves identically on iOS, Android, web, and desktop because the UI is drawn by Flutter’s own rendering engine rather than by each platform’s native UI toolkit. This consistency is Flutter’s primary visual advantage and its primary visual disadvantage — Flutter apps that look exactly the same on iOS and Android may feel slightly off to users who are accustomed to the subtle UI differences between platforms.
The Flutter development experience characteristics that most affect team productivity: the hot reload feature that applies code changes to a running app in milliseconds without restarting (significantly accelerating the development iteration cycle), the comprehensive widget library that provides both Material Design (Google’s design language) and Cupertino (Apple’s iOS design language) widget sets out of the box, and the growing ecosystem of packages available through pub.dev that extends Flutter’s capabilities for specific use cases. The Dart language learning curve for developers from JavaScript or Swift backgrounds is typically measured in weeks rather than months, and most developers find Dart’s syntax comfortable after the initial adjustment.
React Native: JavaScript, Native Components, and Ecosystem
React Native’s architecture — using JavaScript and the React component model to specify the UI, which is then rendered using the platform’s native UI components — produces apps that use iOS and Android’s actual native UI elements, giving them the platform-specific look and behaviour that Flutter’s custom renderer does not provide by default. The navigation patterns, input controls, and interaction behaviours that iOS and Android users expect are provided natively rather than simulated, which can produce a more authentic platform experience at the cost of the cross-platform consistency that Flutter provides.
The React Native new architecture that has most improved the framework’s performance and reliability: the replacement of the JavaScript Bridge (which serialised all communication between JavaScript and native code as JSON passed across a single thread, creating bottlenecks and asynchronous coordination challenges) with the JavaScript Interface (JSI), which allows JavaScript to call native functions synchronously without serialisation overhead. The Fabric renderer that uses JSI to provide synchronous UI updates and the TurboModules system that provides lazy loading of native modules together address the performance limitations that made React Native unsuitable for the most demanding UI animation and interaction patterns in its original architecture.
When Cross-Platform Is and Is Not the Right Choice
The application characteristics that most favour cross-platform development: the majority of the app’s functionality is business logic, data display, and standard UI patterns rather than platform-specific capabilities or demanding animation and graphics (which are the areas where native development retains the strongest advantage), the development team has JavaScript or Dart expertise that transfers to the chosen cross-platform framework without a steep learning curve, and the business requires simultaneous iOS and Android presence without the budget or timeline for two separate native development efforts.
The application characteristics that most favour native development despite its higher cost: the app that requires deep integration with platform-specific hardware or software capabilities (AR frameworks, always-on sensors, background processing modes) that cross-platform abstractions have not yet fully exposed, the app where animation and graphics performance at 60 or 120 frames per second is a core requirement of the user experience, and the app whose entire value proposition depends on providing the most authentic possible iOS or Android experience (which native UI components provide and cross-platform custom rendering does not). The performance gap between native and cross-platform has narrowed significantly but has not closed — for the specific application types where that gap matters, native development remains the right choice.
The Web and Desktop Dimension
The cross-platform development evolution that extends beyond mobile to web and desktop: Flutter’s web target and desktop targets (macOS, Windows, Linux) allow a single codebase to deploy across all major platforms simultaneously, though the web deployment produces different performance characteristics than the mobile deployment and the desktop deployment requires adaptation for the keyboard, mouse, and window management interaction patterns that desktop platforms use. React Native’s web support through React Native for Web follows a similar pattern — enabling code sharing between mobile and web at the cost of platform-specific adaptation work that pure web or native development would not require.
The cross-platform strategy that most organisations find most pragmatic for the full platform matrix: using a cross-platform framework for the mobile experience (where iOS and Android share enough design language and interaction patterns to benefit most from code sharing) while using a separate web framework optimised for the web (where the interaction patterns, performance requirements, and distribution mechanisms differ enough from mobile that a mobile-first codebase produces a suboptimal web experience). The code that benefits most from sharing across mobile platforms — business logic, data models, API communication — can be extracted into a shared layer regardless of the UI framework used.