Skip to content
All posts

React Native vs Flutter: How to Actually Choose

Both frameworks can ship a great app. The real question isn't which one is better. It's which one fits your team, your product, and the code you already have.

Harshil Moradia

5 min read

Every few months someone asks me which one they should pick, React Native or Flutter. They usually expect a winner. The honest answer is that both are mature, both are used in production by large companies, and both can ship an app your users will be happy with. The choice depends far less on benchmarks than on who's building the app and what it needs to do.

Here's how I think about it.

How they work, in one paragraph each

React Native lets you write your app in JavaScript or TypeScript with React, and renders real native UI components. A <View> becomes a UIView on iOS and an android.view.View on Android. With the New Architecture (now the default), JavaScript talks to native code directly through JSI instead of the old async bridge, which removed most of the performance complaints people remember from a few years ago.

Flutter lets you write your app in Dart and draws every pixel itself using its own rendering engine (Impeller). It doesn't use the platform's buttons or text fields. It paints its own versions of them. That's why a Flutter app looks the same on every device, and also why it sometimes doesn't feel quite like the platform it's running on.

That single difference, native components versus a custom renderer, explains most of the trade-offs below.

Where React Native wins

  • Your team already knows React. This is the biggest factor by far. A web team can be productive in React Native within days. The mental model, the state management libraries, and a lot of the tooling carry over.
  • You want to share code with a web app. Business logic, API clients, validation, types, and sometimes components can live in a shared package. With Flutter, your web and mobile code are usually separate worlds.
  • The app should feel native. Because you're using real platform components, things like text selection, accessibility, scrolling physics, and keyboard behavior match what users expect on each OS for free.
  • Over-the-air updates. Shipping JavaScript fixes without going through app store review (within the stores' rules) is a real advantage when you need to move fast.
  • Expo. Expo has turned React Native from "set up Xcode and Gradle and pray" into a smooth experience: managed builds, a large set of native modules, and file-based routing. Most new React Native projects should start there.

Where Flutter wins

  • Pixel-perfect, custom UI. If your design is heavily branded, full of custom animations, or needs to look identical on iOS and Android, Flutter is excellent. You control every pixel.
  • Consistency. Since Flutter doesn't depend on platform widgets, there are fewer "works on iOS, looks broken on Android" surprises.
  • Batteries included. Flutter ships with a large, well-designed widget library, its own testing tools, and solid DevTools. You make fewer decisions about third-party libraries at the start.
  • Predictable performance. Dart compiles ahead of time to native code, and the rendering pipeline is under Flutter's control. Complex animations and graphics-heavy screens tend to stay smooth without much tuning.
  • Beyond mobile. Flutter's desktop and embedded support is further along than React Native's, which matters if you're targeting kiosks, cars, or desktop from the same codebase.

The trade-offs nobody puts on the landing page

React Native:

  • Upgrades between versions can still be painful, especially if you depend on many community native modules that lag behind.
  • You'll sometimes need to drop into Swift or Kotlin for a missing native feature. Expo modules make this easier, but it's still a skill your team needs.
  • The ecosystem is huge but uneven. For any problem there are five libraries, and two of them are abandoned.

Flutter:

  • Dart is a nice language, but it's one your team probably doesn't know yet, and it's rarely used outside Flutter. That affects hiring.
  • When iOS or Android ship new UI conventions, Flutter has to reimplement them. There's always some lag, and Cupertino-style widgets never feel 100% like the real thing.
  • App size starts larger, since the engine ships with your app.
  • Integrating with existing native screens or platform views works, but it's more friction than in React Native.

Performance: mostly a non-issue now

For the typical app (lists, forms, API calls, navigation), users won't be able to tell the difference. Both frameworks hit 60fps (or 120fps) comfortably when written reasonably. If your app is slow, it's almost always because of how it's built: unnecessary re-renders, huge unvirtualized lists, heavy work on the main thread. Not because of the framework.

Flutter has an edge for animation-heavy or graphics-heavy UIs. React Native has an edge for startup integration with native code and memory use in simpler apps. Neither edge should decide your choice unless your app lives at those extremes.

A simple way to decide

Ask these questions in order and stop at the first clear answer:

  1. Does your team already write React? Pick React Native. The productivity gain beats anything else on this list.
  2. Do you need to share code with an existing web app? Pick React Native.
  3. Is the UI heavily custom, branded, or animation-driven? Pick Flutter.
  4. Are you targeting desktop or embedded alongside mobile? Lean Flutter.
  5. Must the app feel exactly like a native iOS/Android app? Lean React Native.
  6. Starting from zero with no strong preference? Build the same small screen in both over a weekend. The one your team enjoys working in is the right answer.

What I'd tell a friend

Stop looking for the objectively better framework, because there isn't one. Look at the people who will maintain the app for the next three years and pick the tool that makes them fast and confident. A team that knows its framework well will ship a better app in either one than a team fighting a tool it chose because of a benchmark chart.

Thanks for reading. If this was useful, the newsletter below is the best way to catch the next one.

Keep reading

More essays