React Native's New Architecture: What It Changes in Your App
React Native's new architecture (Fabric, TurboModules, JSI) rewires communication, rendering, and startup. Here’s what changes in your app — and which libraries still hold you back.

What is React Native new architecture? It’s the most fundamental reboot of the framework’s internals since its inception – a shift from an asynchronous bridge model to a direct, synchronous, multi‑threaded engine built on JSI, TurboModules, Fabric, and Codegen. For technical decision makers, it rewrites the performance story: startup time, list rendering, native module interop, and the third‑party library choices that can still drag you back. Here’s exactly what changes in your app and how to make the most of it.
What is React Native’s new architecture?
The new architecture is the result of a redesign that began in 2018, aiming to replace the classic “bridge” with three interconnected pillars React Native team’s official overview:
- JSI (JavaScript Interface) – a C++ layer that lets JavaScript hold direct references to native objects and call native methods synchronously, without JSON serialization.
- TurboModules – a modern module system that loads native modules lazily on demand, using JSI for instant calls, instead of the old batched bridge messages.
- Fabric – the new rendering system that runs layout, commit, and paint on separate threads, leveraging a synchronous C++‑driven renderer (Yoga) that can interrupt lower‑priority work to keep the UI at a steady 60 fps.
- Codegen – static type‑checking that automatically generates the C++ glue needed for TurboModules and Fabric components, reducing manual boilerplate.
From React Native 0.76 onward, the new architecture ships enabled by default for new projects React Native Journal on 2025 default, so the question is no longer if you should adopt it but how it reshapes your app’s behaviour.
How Fabric improves rendering and list performance
Fabric decouples rendering from JavaScript’s main thread, making scroll performance and view updates nearly indistinguishable from fully native apps.
Instead of serialising UI instructions into JSON and flushing them across the bridge, Fabric’s C++ core talks directly to the platform’s UI layer. It splits updates into three phases:
- Render phase – React creates a lightweight, immutable tree of elements on a background thread.
- Commit phase – Fabric mounts changes onto the “shadow tree” (the C++ representation of the view hierarchy), also off the main JS thread.
- Mount phase – Only the final native operations (create, insert, delete) happen on the main (UI) thread, batched together for efficiency.
This pipeline means a heavy FlatList with hundreds of cells can measure, layout, and recycle rows on a worker thread, while the JavaScript event loop stays free. The synchronous nature of JSI ensures that onScroll callbacks or gestures never queue up behind a sluggish bridge deep-dive into Fabric and Yoga.
Practical takeaway: if you’ve experienced janky lists, Fabric often fixes that without a single line of code – provided your UI library supports the new renderer. Which leads to…
TurboModules and faster startup: How direct native calls change boot time
TurboModules shave seconds off launch by lazily loading native modules only when JavaScript actually asks for them, and calling them without JSON serialization.
In the old architecture, every native module was eagerly initialised at app start for registration, and every call was encoded to JSON, sent over the bridge, decoded, executed, and sent back Metadesign Solutions on JSI bindings. With TurboModules:
- The JSI exposes a native function to JS as a simple property (
deviceInfo.getBatteryLevel()), skipping JSON completely. - Only the module that’s actually called gets loaded – a navigation library might sit untouched until the user opens a particular screen.
- And because the C++ bindings are generated by Codegen, the runtime memory overhead drops.
For a typical app with 30‑40 native modules, this means the time‑to‑interactive (TTI) can be cut by 200‑500 ms or more, depending on how many heavy modules you’ve been loading upfront.
// android/gradle.properties
newArchEnabled=trueEnable the new architecture in an existing project, and you’ll immediately see the difference: the NativeModules call no longer blocks the JS thread while a chunky Bluetooth or biometrics module initialises. For a full migration guide, our mobile development services team can audit your native surface and handle the lift.
Native interop without the bridge: writing native modules the new way
You can keep your existing native modules while you transition, but the real power comes when you wrap them in TurboModule specs and Fabric components.
Here’s a minimal TurboModule spec for a hypothetical logger:
// LoggerNativeModule.ts
import { TurboModule, TurboModuleRegistry } from 'react-native';
export interface Spec extends TurboModule {
logEvent(eventName: string, properties: Object): void;
}
export default TurboModuleRegistry.get<Spec>('Logger');On the native side, a corresponding Java/Kotlin or Obj‑C/Swift class implements the generated interface. Codegen then creates the JSI binding, so Logger.logEvent('screen_view', { page: 'home' }) hits the native module in microseconds.
For UI components, Fabric expects a C++ “shadow node” that can participate in the synchronous layout engine. While this adds some upfront boilerplate, it means your custom map or chart view will render in‑sync with the React tree, with no flickers or delayed mount events.
The third‑party library bottleneck: Which libraries still hold you back?
Your biggest performance blocker isn’t the framework – it’s the ecosystem. Many popular native modules haven’t adopted Fabric or TurboModules, falling back to the old bridge.
As of early 2025, libraries in categories like camera, advanced video/audio processing, maps, and push notifications often still rely on the legacy NativeModules path. When that happens:
- They load eagerly at startup, erasing the TurboModule advantage.
- Every call between JS and native still goes through batched JSON messages, even if your own code doesn’t.
- Fabric’s multi‑threaded rendering can’t touch those views – they remain stuck on the main thread.
Before enabling newArchEnabled, run a dependency audit. Look for libraries that already ship a TurboModule spec or a Fabric‑compatible view. Many UI kit libraries have already updated – for instance, our comparison of the best React Native UI libraries highlights the ones that work seamlessly with Fabric.
If a critical library hasn’t moved, you have two options: fork and add the new architecture support, or keep it as‑is (it will still function) and accept that those specific screens won’t enjoy the performance uplift. Either way, the bridge isn’t disappearing overnight, but it is becoming a drag.
Migrating your existing project to the new architecture
Start with a canary build where you flip newArchEnabled=true and fix what breaks – usually far less than you fear.
- Enable the flag in
android/gradle.propertiesandios/Podfile. - Update React Native to a version ≥0.76 (where the new architecture is default‑on).
- Run the app and watch for red boxes – they usually point to libraries that aren’t ready. Temporarily wrap those native calls with a
try/catchand fallback to the bridge version. - Convert your own native modules using the helper scripts and Codegen specs provided by the React Native core team; the official upgrade helper generates a spec skeleton.
- Test list performance with a heavy screen – you should see a dramatic drop in frame drops and JS thread occupancy.
If your app’s binary size suddenly jumps, it’s often because of duplicated C++ headers. Our lab guide on why React Native app size balloons – and how to shrink it walks through the clean‑up steps.
For teams that don’t have bandwidth for an in‑house migration, techpotions’ mobile practice offers a targeted upgrade engagement that benchmarks your app before and after.
FAQ
How do I know if my app is using the new architecture?
Check android/gradle.properties for newArchEnabled=true and your Podfile for RCT_NEW_ARCH_ENABLED=1. At runtime, evaluate global.__turboModuleProxy != null – if it returns a function, TurboModules are active.
Does the new architecture reduce app size?
It can, by enabling lazy loading of native modules and eliminating duplicated C++ symbols, but the initial codegen output may temporarily inflate the binary. After cleaning up duplicate headers and unused libraries, many teams see a net decrease. Refer to our deep‑dive on React Native app size for the step‑by‑step.
Will my custom native modules break when I enable the new architecture?
No. Your existing modules will continue to work through the legacy bridge. To get the performance benefits you must wrap them with TurboModule specs (for methods) and Fabric adapters (for views). The backward‑compatible bridge stays until React Native eventually removes it.