The React Native New Architecture
The React Native New Architecture is a rewrite of the systems that underpin React Native: how components are rendered, how JavaScript communicates with native code, and how work is scheduled across threads. It replaces the asynchronous bridge with the JavaScript Interface (JSI) and adds full support for modern React features such as Suspense, Transitions, automatic batching and useLayoutEffect. Since React Native 0.82 it is the only architecture. This guide is current as of React Native 0.88 (reviewed November 2026).
What it is
The official overview names four main parts: a new Native Module system, a new renderer, a well-defined event loop, and the removal of the bridge. The release posts use the names below.
Fabric is the new renderer, introduced as the Fabric Renderer. It is written in C++ and shared across platforms, so the same rendering code runs on iOS, Android and other platforms. It stores the view hierarchy in an immutable tree, which lets it work on several in-progress trees at once: React can render a low-priority update in the background, interrupt it for an urgent one such as user input, and read layout synchronously when needed. This is what makes Suspense, Transitions and useLayoutEffect work properly in React Native. View Flattening, once an Android-only optimisation, now also applies on iOS.
TurboModules (also called Turbo Native Modules) are the new native modules. The new Native Module system is written in C++ and talks to JavaScript through JSI, so JavaScript can call a native function synchronously and get a value back, instead of passing a callback and receiving only serializable values. Modules are lazily loaded: they load only when they are needed, not at startup. A module written in C++ works across Android, iOS, Windows and macOS.
Codegen lets your modules define a strongly typed contract between the JavaScript layer and the native layer, and generates the boilerplate code. The official post calls cross-boundary type errors one of the most common sources of crashes in cross-platform apps. Since 0.70, Codegen specs for iOS and Android can be defined in a single codegenConfig entry in package.json.
JSI (JavaScript Interface) is the interface that replaces the bridge. It lets JavaScript hold a reference to a C++ object and vice versa, so methods are invoked directly, without serialization costs. The official example is VisionCamera, which processes camera frames of about 30 MB each in real time. React Native 0.86 added new JSI APIs, including the IRuntime interface and first-class TypedArray/Uint8Array support.
Bridgeless mode disables creation of the bridge entirely. In the old architecture, every render and native call was serialized and queued on an asynchronous bridge. Without the bridge, startup is faster because there is no bridge to initialize, error reporting improves, and crashes from undefined behavior are reduced. Bridgeless Mode arrived as an experiment in 0.73 and became the default for New Architecture apps in 0.74. Interop layers let modules and components written for the old architecture work in Bridgeless Mode.
How it arrived
- 0.68: first release with opt-in support for the New Architecture, the Fabric Renderer and the TurboModule system. Android uses a
newArchEnabledproperty; on iOS the flag is named RCT_NEW_ARCH_ENABLED. - 0.69: React 18 support. Concurrent features require the New Architecture.
- 0.70: one
codegenConfigentry for both platforms, and Android autolinking for New Architecture libraries. - 0.71: enabling the New Architecture no longer requires C++ code in your app. On iOS, setup is encapsulated in
RCTAppDelegate. - 0.73: experimental Bridgeless Mode.
- 0.74: Bridgeless Mode is the default when the New Architecture is enabled, and the New Renderer Interop layer is enabled by default without listing components.
- 0.75: stabilization, including stable APIs for thread-safe
jsi::Runtimeaccess from Turbo Native Modules. - 0.76: the New Architecture is enabled by default and declared ready for production.
- 0.80: the Legacy Architecture is frozen. React Native DevTools warns about APIs that won't work on the New Architecture.
- 0.81: with Expo SDK 54, the last version that allows the Legacy Architecture.
- 0.82: the first release that runs entirely on the New Architecture. The opt-outs are ignored.
- 0.83: experimental iOS build option
RCT_REMOVE_LEGACY_ARCH=1, which compiles out the Legacy Architecture to reduce build time and app size. - 0.84: Legacy Architecture code is removed by default on iOS.
- 0.85: Legacy Architecture cleanup continues on Android; for example,
CatalystInstanceImplis removed.
What it means for your app
On React Native 0.82 and later, every app runs on the New Architecture. There is no opt-out: newArchEnabled=false on Android and RCT_NEW_ARCH_ENABLED=0 on iOS are ignored, and iOS shows a warning if RCT_NEW_ARCH_ENABLED is set to 0.
Because of that, every app can use the features that need the New Architecture, such as the style props boxShadow and filter (0.76) and display: contents, boxSizing and mixBlendMode (0.77). Concurrent React features such as Suspense and Transitions also depend on it, but they need migrated Native Components and code that follows the Rules of React (see below).
What to check:
- Libraries. The most popular libraries already support the New Architecture. At the 0.76 launch, more than 850 libraries were compatible, including all libraries with over 200K weekly downloads. You can check a library on the reactnative.directory website. Libraries that offer backward compatibility with both architectures keep working on 0.82.
- Interop layers. Modules and components written for the old architecture run through automatic interop layers. The 0.82 announcement says they stay in the codebase for the foreseeable future. They have known limitations: they do not support accessing custom Shadow Nodes or concurrent features.
- DevTools warnings. Since 0.80, React Native DevTools warns about APIs that won't work on the New Architecture, and iOS also warns about modules and components loaded through the interop layer. Review these warnings and plan the migration of what they name.
- Your own native code. Custom Native Modules and Native Components keep working through the interop layer. Without migrating your Native Modules to the new API, you will not get shared C++, synchronous method calls or type-safety from Codegen. Without migrating your Native Components, you will not be able to use concurrent features.
- Performance expectations. Enabling the New Architecture may not immediately improve performance. Your code may need refactoring to use synchronous layout effects or concurrent features, and data serialization may not have been your app's bottleneck.
Migrating an older app
The 0.82 announcement gives the path for an app that still uses the Legacy Architecture:
- Upgrade to React Native 0.81 or Expo SDK 54. These are the last versions that allow the Legacy Architecture, and they contain warnings and performance improvements meant to help the migration.
- Enable the New Architecture in 0.81 and verify that your app works.
- Upgrade to 0.82, which no longer allows enabling the Legacy Architecture.
If an incompatible third-party dependency blocks you, contact its maintainers. If a bug in React Native core blocks you, report it on the React Native issue tracker. Use the React Native Upgrade Helper to see the code changes between versions.
Apps on 0.76 to 0.81. The New Architecture is on by default. An app that opted out did it in one of these ways:
- Android:
newArchEnabled=falseinandroid/gradle.properties. - iOS:
ENV['RCT_NEW_ARCH_ENABLED'] = '0'in the main scope ofios/Podfile, or installing pods withRCT_NEW_ARCH_ENABLED=0 bundle exec pod install.
From 0.82 these opt-outs are ignored.
Apps on 0.75 or older. From 0.68 to 0.75 the New Architecture was opt-in, through the newArchEnabled property on Android and the RCT_NEW_ARCH_ENABLED flag on iOS. The recommended path is the same: upgrade to 0.81 first. From 0.76, the New Architecture and React 18 are enabled by default; the official post expects most apps to upgrade to 0.76 with the same level of effort as any other release, and asks you to follow the React 18 Upgrade guide as well.
Along the way:
- Check each dependency on reactnative.directory. If one is not compatible, open an issue asking the author to migrate, or consider an alternative library if it is not maintained.
- Migrate custom Native Modules and Native Components to the new Native Module and Native Component APIs. The October 2024 post recommends doing this as soon as possible.
- To use concurrent features, update your code to support Concurrent React by following the Rules of React.
- On the New Architecture, state updates in onLayout callbacks are batched (since 0.74). Code relying on un-batched updates must be refactored to use updater functions or equivalent.
If you maintain a library, first test that it works with the interop layer; if it does not, open an issue on the New Architecture Working Group. Then migrate it to the new Native Module and Native Component APIs so its users can take full advantage of the New Architecture.
Common questions
Is the New Architecture on by default?
Yes, since React Native 0.76. Since 0.82 it is the only architecture: apps always run on it.
How do I enable it?
On 0.82 or later there is nothing to enable: apps always run on it. On 0.76 to 0.81 it is on by default, unless your app opted out. If your app opted out or is on an older version, follow the upgrade path above: upgrade to 0.81, enable the New Architecture there and verify your app, then move to 0.82.
Can I still use the old architecture?
Not on 0.82 or later. React Native 0.81 and Expo SDK 54 are the last versions that allow the Legacy Architecture. It has been frozen since 0.80: no new fixes or features, and it is no longer tested during releases.
What happened to the bridge?
The New Architecture replaces the asynchronous bridge with direct communication between JavaScript and native code through JSI. Bridgeless Mode, the default for New Architecture apps since 0.74, disables creation of the bridge entirely. Modules written for the old architecture keep working through the interop layers.
Will the New Architecture make my app faster?
Not necessarily right away. It enables synchronous layout and concurrent rendering, but your code may need refactoring to use them, and data serialization may not have been your app's bottleneck.
Do libraries written for the old architecture still work?
Usually, yes. They run through the interop layers, which stay for the foreseeable future, and libraries that support both architectures keep working on 0.82. Check reactnative.directory for a library's status.
Sources
- About the New Architecture
- New Architecture is here
- React Native 0.76 - New Architecture by default, React Native DevTools, and more
- React Native 0.82 - A New Era
Release posts
- React Native v0.86 released
- React Native v0.85 released
- React Native v0.84 released
- React Native v0.83 released
- React Native v0.82 released
- React Native v0.81 released
- React Native v0.80 released
- React Native v0.77 released
- React Native v0.76 released
- React Native v0.75 released
- React Native v0.74 released
- React Native v0.73 released
- React Native v0.72 released
- React Native v0.71 released
- React Native v0.70 released
- React Native v0.69 released
- React Native v0.68 released
- React Native v0.64.x released