React Native vs Flutter: 2022 State of Play

I've been shipping mobile apps in both React Native and Flutter for four years. Early on, the choice was stark: React Native if you had JavaScript developers, Flutter if you could learn a new ecosystem. But that calculus has shifted.

June 2022, after Flutter 3.0 shipped in May and React Native's new architecture is in beta, the choice is more nuanced. Both frameworks work. Both have rough edges. The question isn't "which is better?" It's "which tradeoffs do you want?"

Flutter 3.0: The Maturity Signal

Flutter 3.0 landing in May felt like the framework crossing a threshold. Not because of any single feature—web support in Flutter has been coming for a while—but because it signals that Flutter is now a platform play, not just a mobile framework.

You can build web apps in Flutter. You can ship macOS apps. The same codebase spans mobile, web, and desktop. That's a different value proposition than cross-platform mobile.

I've tested it on a few projects. Building for web works, but—and this is important—the web version looks and feels like a Flutter app running in a browser, not like a native web application. The performance is fine. The UX is fine. But there's a semantic weirdness to it.

React on the web is the default. Flutter on the web is interesting but still feels like a secondary target.

That matters if you care about web UX. If you're okay with Flutter's approach to web (which is basically "viewport that happens to be a browser"), then Flutter's unified codebase is genuinely powerful.

React Native New Architecture: The Perpetual Beta

React Native's new architecture has been in progress for years. The promise is better performance, simpler internals, better interop with native code. In June 2022, it's still not shipped, but it's getting closer.

Teams I know are cautiously experimenting with it. The promise is real, but the risk is also real. You're opting into chasing a moving target while the rest of the ecosystem is on the stable version.

The gap between "new architecture works great on this one phone" and "new architecture works reliably at scale" is still substantial.

That said, React Native's base has gotten noticeably better in the past year. The debugging experience improved. The error messages are clearer. Library compatibility got better. If you're starting a new React Native project today, the baseline experience is better than it was in 2021.

The Ecosystem Divergence

Here's where things get interesting: both frameworks now have solid third-party ecosystems, but they're pulling in opposite directions.

React Native benefits from everything the web developer community builds. Every JavaScript library is potentially available. You get bundlers, state management, styling systems, testing frameworks all from the web ecosystem. The cross-pollination is constant.

But that also means React Native is inheriting web complexity. Your React Native app can use Next.js-style patterns. That's powerful and also confusing. You end up with web developers using web patterns that don't quite fit mobile constraints.

Flutter has a more bounded ecosystem. The Dart package landscape is smaller. You have fewer third-party options. But the tradeoff is coherence. Flutter packages tend to follow Flutter conventions. The ecosystem pulls in one direction.

For our mobile projects, we're noticing that React Native feels more flexible but requires more decisions. Flutter feels more opinionated but requires fewer calls.

Performance and Device Support

Flutter's compiled approach gives it a performance advantage on low-end devices. The resulting binaries are more efficient with system resources. On a $50 phone, this difference is measurable.

React Native's performance is good enough for most use cases, but React-based interpretation adds overhead. On high-end devices, imperceptible. On low-end hardware, noticeable.

If you're targeting emerging markets—which we talk about a lot—Flutter's performance advantage matters.

That said, React Native's JavaScript bridge is getting faster. The delta is narrowing.

The Real Tradeoff

Here's what I'm telling teams in June 2022:

If you have strong JavaScript expertise and want to maximize code reuse with web platforms, React Native. The ecosystem is richer, tooling is more mature, and you're leveraging team skills.

If you want maximum performance, unified codebase across mobile/web/desktop, and you're building a new team, Flutter. The framework is younger but more cohesive. You're not fighting ecosystem expectations from web development.

If you're targeting emerging markets with low-end devices, Flutter's performance edge is real enough to swing the decision.

If you already have native apps and want to progressively add cross-platform code, React Native's interop story is still better.

If you need web UX parity with native UX, React Native is safer. Flutter web works, but it's a different paradigm.

What's Coming

The new React Native architecture is going to ship this year or next. When it does, React Native will feel less like "a JavaScript layer running on native bindings" and more like "first-class native support using JavaScript." That's going to matter.

Flutter is going to continue pushing the unified platform story. We'll see improvements to web, better desktop support, and growing tooling. The gap between "Flutter is for mobile" and "Flutter is a cross-platform framework" is going to close.

Where We're At

Both frameworks work. Both have communities. Both are improving. The choice is less about correctness and more about fit.

June 2022, we're in a good place. You can't go wrong. You can go right or less-right depending on your constraints, your team, and your targets. But the days of "flutter is better" or "react native is better" are over.

You pick the one that fits your problem. Then you ship. Then you don't regret the choice because both choices actually work now.

That's progress.