React Native's New Architecture: what Fabric and TurboModules actually change

The New Architecture has been "coming" for years, and as of the recent releases it's the default for new apps rather than an experimental opt-in. So it's worth cutting through the marketing terms and asking the only question an app developer cares about: what actually changes for me?

Short version: the headline win is the death of the bridge, and most of your app code doesn't change - but your native dependencies very much have to be ready.

The old problem: the bridge#

The original architecture had your JavaScript and the native side talking over a "bridge." Every interaction - calling a native module, rendering a native view - was serialized to JSON, sent across asynchronously, and deserialized on the other side. That works, but it has real costs: everything is async, the serialization is overhead, and you can't do anything synchronously across the boundary. For chatty interactions or animations driven from JS, the bridge was the bottleneck. (This is the whole reason Reanimated exists - to get around it.)

The new foundation: the JSI#

The New Architecture replaces the bridge with the JSI (JavaScript Interface), a thin C++ layer that lets JavaScript hold references to native objects and call them directly - synchronously when needed, no JSON serialization. Everything else is built on this. You won't write JSI by hand; it's the plumbing that makes the rest possible.

On top of the JSI sit the two pieces with the buzzword names:

• TurboModules - the new way native modules work. They load lazily (only when first used, instead of all at startup, which helps cold start) and can call across to native synchronously through the JSI.
• Fabric - the new rendering system. It's the renderer rebuilt on the JSI, with a shared C++ core. The practical upshots are better interop with native views, support for concurrent React features, and less overhead getting your views onto the screen.

There's also codegen, which generates the type-safe native interface code from JS spec files, so the JS and native sides can't drift out of sync.

What changes for your app code#

Here's the reassuring part: if you're writing normal app code - components, hooks, business logic - most of it doesn't change at all. Your screens are still screens. The New Architecture is mostly underneath you.

What changes is at the edges:

• Custom native modules need to become TurboModules (with codegen spec files). The old bridge-style modules run through an interop layer for now, but the real path forward is converting them.
• Custom native components move to the Fabric way of doing things.
• Your native dependencies must support it. This is the actual gating factor. A library that hasn't been updated for the New Architecture is your blocker, not your own code.

Before you flip it on#

The migration advice that actually matters:

1. Audit your dependencies first. Go through your native libraries and confirm each supports the New Architecture. There are community-maintained lists tracking this. The single most likely reason your migration stalls is one unmaintained library.
2. Update React Native and your libraries to current versions. New Architecture support landed and stabilized progressively; old library versions won't have it.
3. Convert your own native modules to TurboModules with codegen specs.
4. Test on real devices, both platforms, thoroughly. Rendering changes mean visual and behavioral edge cases. This isn't a JS-only change you can eyeball in the simulator.

Should you rush?#

If you're starting a new app, you're on it by default now - good, that's where the ecosystem is going. If you have an existing app, the calculus is dependency readiness: when your critical native libraries all support it, migrating is worth it for the performance foundation and to stay current. If one essential library isn't ready, that's your timeline, and forcing it early just buys you pain.

The thing to internalize is that the New Architecture isn't a rewrite of how you build apps. It's a replacement of the engine under the hood - faster, synchronous where it needs to be, no bridge. Your job is mostly to get your native layer ready for it, not to relearn React Native.