BlogProduct engineering

Flutter vs React Native: choosing a cross-platform framework

Both are good enough for almost any business app, so choose on team and product, not on benchmarks. Pick React Native if you have React and TypeScript developers or a React web app to share code with; pick Flutter if you want one custom interface that looks identical on phones, desktops and embedded screens. Go fully native when the app lives on platform features.

How the two differ underneath

Flutter and React Native answer the same question, one codebase for iOS and Android, in opposite ways.

Flutter brings its own everything. You write Dart, which is compiled ahead of time to machine code. The framework does not use the platform’s buttons and lists. It has its own implementation of each control and paints every pixel itself through its rendering engine, Impeller. As of Flutter 3.50, released in November 2026, Impeller is the only renderer on iOS, the default on Android 10 and later, and since version 3.47 the default on Windows, macOS and Linux as well. Think of it as a game engine specialised for app interfaces.

React Native drives the platform’s own interface. You write React components in TypeScript. They run in a JavaScript engine called Hermes, and what appears on screen are real native views created on your behalf. For years the JavaScript and native sides talked over an asynchronous bridge, which was the source of most performance complaints. That is gone. The New Architecture, which lets JavaScript call native code directly, has been the only architecture since version 0.82 in October 2025, and Hermes V1 has been the default engine since 0.84. The current release is 0.88.

The React Native documentation itself recommends starting with a framework such as Expo, which adds routing, native API libraries and build tooling. In this article, React Native means React Native with Expo, currently SDK 58.

How do they perform in practice?

For a booking app, a banking app, a field-service tool or a shop, both are fast enough that users cannot tell which was used. Older comparisons that put Flutter clearly ahead were largely measuring that bridge.

Differences still show at the edges. Flutter’s renderer compiles its shaders when the engine is built, not while the app runs, so animation is very consistent, which suits custom-drawn interfaces with heavy motion. React Native still runs your application logic on a single JavaScript thread. Parse a large payload or recompute a big list there and the interface stutters, however quick the engine underneath.

What we see go wrong is rarely the framework. In React Native it is long lists rendered without virtualisation and state updates that redraw half the screen. In Flutter it is large widget trees rebuilt on every frame, oversized images, and embedded native views such as maps and web views. A Flutter app also carries its engine with it, so the smallest possible download is larger than the native equivalent.

The way to find out is to build the heaviest screen first and profile a release build on a low-cost Android phone. Measure cold start, scrolling on the longest list and the most complex animation. Leave the flagship devices in the drawer: they hide everything.

UI fidelity and platform feel

Flutter gives you the same pixels everywhere. If the brand has a distinctive design system and you want it identical on an iPhone, a Samsung tablet and a Windows kiosk, that is a real advantage, and designers can be exact.

The price is that platform conventions are imitated, not inherited. When Apple changes its design language, as it did with Liquid Glass in iOS 26, a Flutter app does not change until the widget library does. Flutter is loosening that coupling: in 3.50 the Material and Cupertino libraries bundled with the SDK are deprecated in favour of standalone material_ui and cupertino_ui packages that can update on their own schedule. It is a sensible move, and a migration to plan for.

React Native uses the platform’s components, so text fields, scrolling, accessibility and system gestures behave the way each platform’s users expect, and apps built on native navigation tend to pick up much of an OS redesign with an SDK upgrade. The price runs the other way. iOS and Android differ, and you will write some platform-specific styling to make one design sit well on both.

Native modules, platform features and on-device AI

Neither framework removes native code from your life. Push notifications, payments, Bluetooth, background location, health data: each goes through platform APIs, and sooner or later a library is missing or out of date.

Flutter’s current guidance for new bindings is generated, type-safe interop: Pigeon for message passing, FFIgen and JNIgen for calling native libraries directly, with the older platform channels kept for existing code. React Native has Turbo Modules, and Expo’s module API lets you write a native module in Swift and Kotlin and configure the native projects through plugins instead of editing them by hand.

Some things stay native in both. Home-screen widgets, watch apps and similar extensions are separate targets written with the platform’s own tools. Whichever framework you pick, budget for at least part-time access to someone who knows Swift and Kotlin.

Upgrades are a real cost. React Native ships a release roughly every two months and is still numbered 0.x. Flutter ships a stable release each quarter. Both are manageable if you take every upgrade as it comes, and painful if you skip a year.

On-device AI

Both mobile platforms now expose system language models to apps. On Android, Gemini Nano runs in the AICore system service and is reached through ML Kit’s GenAI APIs. On Apple devices, the Foundation Models framework offers the on-device model through a Swift API. Neither is available on every phone.

These are Kotlin and Swift APIs, so in either framework you reach them through a plugin or a native module of your own. React Native has an edge for open models: React Native ExecuTorch runs language models, Whisper speech-to-text and vision models locally from React hooks. Flutter’s official AI documentation leans towards cloud models through Firebase AI Logic and Genkit, with on-device support coming mostly from community packages.

Our view is that on-device models should not decide the framework. The hard parts are the same in both: which devices can run the model, how much memory it needs, and what happens on phones that cannot. We cover those in small language models on device.

Web, desktop and sharing code with a web app

Flutter targets Windows, macOS and Linux officially, and the same code runs there with little change. Its web target is a different matter. Flutter compiles to JavaScript or WebAssembly and paints the interface onto a canvas using WebGL or WebGPU. That works for app-like tools behind a login. It is the wrong choice for pages that need to load instantly, be indexed by search engines or be read by AI crawlers. The WebAssembly build is opt-in, and by default only Chromium browsers use it.

React Native reaches the web through React Native Web and the desktop through Microsoft’s Windows and macOS projects. These work, with more rough edges than Flutter’s desktop support.

The stronger argument for React Native is code sharing. If your web product is already React, a shared TypeScript workspace lets the mobile app reuse types, API clients, validation rules and business logic, and one team can work across both. Expo’s DOM components can even run existing web React components inside the app in a web view during a migration, though Expo recommends native views wherever possible. If you are still choosing the web side, see Next.js vs Astro.

Hiring and ecosystem

React and TypeScript are among the most widely held skills in software, so React Native teams are easier to assemble and web developers can move across. They still need mobile judgement: navigation patterns, app lifecycle, offline behaviour, store review. Without someone who has shipped apps before, a web team will build a website in an app’s clothing.

Dart is a small language that most developers pick up in a week or two, and Flutter’s tooling is excellent. The pool of experienced Flutter engineers is smaller in most markets, though the people in it are usually mobile specialists. Check your own hiring market before deciding.

On libraries, React Native draws on npm and a strong community, with Expo curating the common needs. Flutter has more in the box from Google. Each is open source with one large sponsor: Google for Flutter, Meta for React Native.

Which should you choose?

Flutter vs React Native at a glance

Flutter React Native
Language Dart TypeScript with React
Interface drawn by Flutter’s own engine, Impeller The platform’s native views
Current release (November 2026) 3.50 0.88, with Expo SDK 58
Look across platforms Identical by default Native to each by default
Native access Pigeon, FFIgen, JNIgen, plugins Turbo Modules, Expo modules
Web Canvas-rendered, for app-like tools React Native Web, or shared logic with a React site
Desktop Official Windows, macOS and Linux Windows and macOS through Microsoft’s projects
Sharing with a React web app API contract only Types, logic and sometimes components
Best team fit Mobile-first or brand-new team Existing React and TypeScript team
Typical failure Fighting platform conventions; plugin gaps Skipped upgrades; overloaded JavaScript thread

A short decision guide

Take a clinic group with a React patient portal, five web developers and no mobile team. It wants a booking app with reminders and video visits. React Native with Expo is the clear choice: the team is productive at once, the booking logic and API client are shared with the portal, and the native needs (push, calendar, camera) are well-trodden ground.

Now take an equipment maker that wants the same control interface on Android tablets, Windows panel PCs and a Linux kiosk, with a custom look and animated gauges. That is Flutter: one rendering engine across all three, exact control of every pixel, and no web codebase to share with. It is the pattern we meet most often in IoT products.

For everything in between:

  1. If you have React developers or a React web app, start with React Native.
  2. If desktop or embedded screens matter as much as phones, start with Flutter.
  3. If the design is heavily custom and must match across platforms, lean towards Flutter. If it should feel native on each, lean towards React Native.
  4. If the team is new and has no stack yet, choose whichever you can hire for locally.
  5. If platform-specific features dominate the roadmap, go native.

When to go fully native instead

Cross-platform is the right default for most business apps, but not all. We recommend Swift and Kotlin when:

  • the product depends on deep platform features: widgets, watch apps, CarPlay or Android Auto, advanced camera pipelines, heavy Bluetooth or background work;
  • you are shipping on one platform only and have no plans for the other;
  • you already have strong native teams;
  • performance margins are thin, as in real-time audio, video editing or augmented reality.

Kotlin Multiplatform is a middle path: share business logic in Kotlin and keep each platform’s native interface.

How to start

In the first week, do not build the login screen. Build the riskiest screen and the riskiest native integration in the framework you are leaning towards, and put them on a cheap Android phone and an older iPhone. Two developers can do this in five days.

If both hold up, commit, and make it a rule to take every framework upgrade as it arrives. If one fails, you have lost a week and not a quarter. Choosing the stack and shipping that first version is regular work for our product engineering team.

Questions

Asked often.

Is Flutter or React Native faster?

For typical business apps, users will not notice a difference. Flutter draws its own interface with a renderer that precompiles shaders, which gives very consistent animation. React Native now runs only on its New Architecture with the Hermes V1 engine, which removed the old bridge bottleneck. Poorly built screens are slow in both, so profile on a low-cost Android phone.

Which is easier to hire for, Flutter or React Native?

React Native draws on the large pool of React and TypeScript developers, so web teams can move across with some mobile coaching. Flutter uses Dart, which fewer people know but most developers pick up quickly, and experienced Flutter engineers tend to be mobile specialists. Local markets vary, so check who is available where you hire before deciding.

Can Flutter or React Native apps use on-device AI?

Yes, both. The system models on Android and iOS are exposed through Kotlin and Swift APIs, so either framework reaches them through a plugin or a small native module. React Native also has ExecuTorch bindings for running open models locally. Device support varies widely, so design a cloud fallback for phones that cannot run the model.

Not on the list? Ask us directly

Keep reading

More notes from the build.

All blogs

Let’s build your stack.

Send a brief and we’ll reply with next steps.