ProgaTech
Contact us

Modern React Native: New Architecture & Expo

React Native no longer uses the Bridge, and Expo is now the recommended way to start a project. Here is how React Native works today, what JSI, Fabric, TurboModules and Codegen changed, and why Expo became the default.

5 min read

·

Nov 9, 2026

Modern React Native: New Architecture & Expo

Modern React Native: New Architecture & Expo

Cover
image.png
Date
Nov 9, 2026
Read Time
5
Short Description
React Native no longer uses the Bridge, and Expo is now the recommended way to start a project. Here is how React Native works today, what JSI, Fabric, TurboModules and Codegen changed, and why Expo became the default.
Slug
modern-react-native-new-architecture-expo
Is Published
Is Published
Title
Modern React Native: New Architecture & Expo
Author Avatar
T0362F2JMFU-U09FM9UTCM7-825bbc44949d-512.png
Author Name
Myroslav
Author Position
Software Engineer
Banner Subtitle
From the Bridge to JSI, Fabric and TurboModules, and why Expo is now the default
Banner Title
Modern React Native: The New Architecture and Expo
Category
Mobile Development
Meta Description
How React Native works today: the New Architecture with JSI, Fabric, TurboModules and Codegen, and why Expo is now the recommended way to start a project.
Meta Title
Modern React Native: New Architecture and Expo Explained
OG Image
image.png
Top Image
image.png
React Native has changed a lot in recent years. The Bridge is gone, a new renderer draws every screen, and Expo has become the recommended way to start a project. This blog post covers three topics: how React Native works, the old architecture versus the new one, and Expo.

You write React, users see native views

React Native is not a WebView and not a hybrid. JavaScript only describes what to show. Real UIViews on iOS and ViewGroups on Android do the drawing.
export function Greeting({ name }) { return ( <View style={styles.card}> <Text>Hello, {name}!</Text> <Image source={avatar} /> </View> ); }
React Native
iOS
Android
<View>
UIView
ViewGroup
<Text>
TextKit view
TextView
<TextInput>
UITextField
EditText
<ScrollView>
UIScrollView
ScrollView
<Image>
UIImageView
ImageView

From .tsx to .apk and .ipa

  1. Your code: TypeScript, JSX, hooks.
  1. Babel: turns JSX and TS into plain JS.
  1. Metro: bundles everything into one JS bundle.
  1. Hermes: compiles the bundle to .hbc bytecode.
In debug builds, Metro serves the bundle over the network, and Fast Refresh updates the screen in a second without losing state. In release builds, the bytecode is baked into the app, so no Metro is needed and the app works offline. On the native side, Gradle and Xcode build Kotlin, Swift, Objective-C and C++ like any other app.
Both outputs share the same structure: a native shell, the React Native core, Hermes, and your code as Hermes bytecode. Because the code is compiled ahead of time, startup is faster.
app-release.apk ├─ classes.dex ← Kotlin / Java ├─ lib/arm64-v8a/ │ ├─ libreactnative.so ← RN core │ └─ libhermesvm.so ← JS engine └─ assets/ └─ index.android.bundle MyApp.ipa └─ Payload/MyApp.app/ ├─ MyApp ← Swift / ObjC + RN core ├─ Frameworks/ │ └─ hermesvm.framework ← JS engine ├─ Info.plist └─ main.jsbundle

The old architecture: everything through the Bridge

The JS thread ran React, business logic and state. The Shadow thread used Yoga to compute layout. The UI thread handled native views and gestures, while native modules ran on their own background threads:
{"module": "UIManager", "method": "createView", "args": [42, "RCTView", …]}
Over time the Bridge became a bottleneck:
  • Async only. You can't measure a view or read a native value synchronously, only via a callback or Promise
  • JSON serialization. Every call and event is encoded to JSON and back. Large payloads are expensive
  • One queue for everything. Scrolling, gestures, animations and network responses compete, which leads to dropped frames and blank list cells
  • Everything at startup. All native modules initialize at launch, even unused ones, and there is no type safety between JS and native

The New Architecture: four pillars

  • JSI: a direct JS to C++ link with no JSON, and synchronous calls
  • Fabric: a new C++ renderer with synchronous layout and Concurrent React
  • TurboModules: native modules load lazily, only when needed
  • Codegen: generates typed native code from TypeScript specs
Since React Native 0.74 the Bridge can be removed entirely, and since 0.82 the old architecture is no longer supported.

JSI: JS calls C++ directly

The engine calls a C++ function like a regular JS function, and a C++ object (a Host Object) appears in JS as a regular object.
// Before: Bridge NativeModules.Storage .getItem('token') .then(v => setToken(v)); // Now: JSI const token = NativeStorage.getItem('token');
This enabled a new generation of libraries: Reanimated, MMKV, VisionCamera and Skia.

Fabric: rendering in three phases

  1. Render: React creates elements, and C++ builds the Shadow Tree shared by both platforms.
  1. Commit: Yoga computes layout, and the tree becomes immutable and ready to show.
  1. Mount: only the diff is applied to native views on the UI thread.
The result is synchronous layout (useLayoutEffect measures views without UI jumps), Concurrent React (Suspense, transitions and automatic batching, just like the web), and one C++ core with the same behavior on iOS and Android.

TurboModules and Codegen

// specs/NativeBattery.ts import type { TurboModule } from 'react-native'; import { TurboModuleRegistry } from 'react-native'; export interface Spec extends TurboModule { getLevel(): number; isCharging(): Promise<boolean>; } export default TurboModuleRegistry .getEnforcing<Spec>('NativeBattery');
From this spec, Codegen generates a C++ / ObjC++ interface for iOS and an abstract Java class that you implement in Kotlin for Android. A type mismatch is caught at build time, so the app won't compile. The module initializes on first use, not at startup.

Old vs New at a glance

Aspect
Old: Bridge
New: JSI
Communication
Async JSON messages
Direct calls via C++
Synchronous calls
No
Yes
Native modules
All initialized at startup
Lazy TurboModules
Renderer
Paper, separate per OS
Fabric, shared C++ core
Type safety
None, errors at runtime
Codegen from specs
Concurrent React
Not supported
Suspense, transitions

A decade to the New Architecture

Year
Milestone
2025
0.82: New Architecture only. The legacy architecture can no longer be enabled.
2024
0.76: New Architecture by default.
2022
0.68: New Architecture as opt-in. 0.70: Hermes by default.
2019
Hermes, a JS engine built for mobile.
2018
Facebook announces a major architecture rewrite.
2015
Open-sourced: iOS in March, Android in September.
The migration took about six years. The library ecosystem needed time to catch up, so an interop layer kept legacy modules working.

Expo: from "Exponent" to the standard

Year
Milestone
2024-2025
SDK 52: New Architecture by default. Then Expo UI.
2024
React Native docs recommend starting with a framework, that is, Expo.
2023
Expo Router: file-based routing, like Next.js.
2022
Expo Modules API: native modules in Swift and Kotlin.
2021
EAS Build, config plugins, dev builds: any native code.
2019
Bare workflow: step outside the "managed" mode.
2017
Becomes Expo. The client app (now Expo Go) runs a project from a QR code.
2015
Exponent, by Charlie Cheever (Quora co-founder) and James Ide.

Expo is a framework, not a library

  • Expo SDK: camera, files, notifications, location, SecureStore and more, with one API for iOS, Android and web.
  • Expo Router: file-based navigation, typed routes, deep links out of the box.
  • Expo CLI: prebuild, dev builds, DevTools. npx expo install picks compatible versions.
  • EAS (optional): cloud Build, store Submit, over-the-air Update, Workflows for CI/CD.

CNG: android/ and ios/ are build artifacts

With Continuous Native Generation, the native folders are generated from config and plugins by running npx expo prebuild.
// app.config.ts export default { name: 'MyApp', plugins: [ 'expo-router', ['expo-camera', { cameraPermission: 'Scan QR codes', }], ], };
  • SDK upgrades: bump the version and regenerate. No manual diffing of native files.
  • Native config as code: permissions, Info.plist and Gradle settings go through config plugins, not by hand.
  • Clean git: no more project.pbxproj conflicts.

What makes Expo a joy to use

  • Expo Router: the file app/user/[id].tsx is both a screen and a deep link.
  • EAS Update: ship JS fixes over the air, with no new store release.
  • Expo Modules API: your own native module in Swift or Kotlin in a few dozen lines.
  • "use dom": embed a React DOM web component right inside a native screen.
  • Expo UI: real SwiftUI and Jetpack Compose components from JSX.
  • Expo Go and a QR code: from create-expo-app to an app on your phone in a minute.

Myth: "Expo is for prototypes"

Myth
Reality
"You can't add native code"
Dev builds and config plugins make any native library work. Custom modules go through the Expo Modules API.
"Locked into Expo's cloud"
EAS is optional. npx expo run:ios builds locally, and prebuild gives standard native projects.
"It bloats your app"
Only the modules you install get bundled, same as bare React Native.
"It lags behind React Native"
Each SDK targets a recent React Native release, usually within weeks of it. New Architecture by default since SDK 52.

Conclusion: the Bridge is gone

In 2015, React Native made a bold promise: write React, ship real native apps. It kept that promise, but under the hood every tap, scroll and layout update had to squeeze through the Bridge, one asynchronous JSON message at a time. For years, that was the price of “learn once, write anywhere.”
Then the team rebuilt the engine without stopping the car. It took about six years, an interop layer, and a lot of patience from the whole library ecosystem. The result is a React Native that barely resembles the old one on the inside. JSI lets JavaScript talk to C++ directly. Fabric renders through one shared core on iOS and Android, with synchronous layout and Concurrent React. TurboModules load only when you need them, and Codegen catches type mismatches before the app even compiles. Alongside it, Hermes compiles your code to bytecode ahead of time, so the app starts faster.
Expo grew up alongside it. It began as Exponent, a small app that ran a project from a QR code, and for a long time people dismissed it as a toy for prototypes. Today it is the framework the React Native docs tell you to start with. You get native code through config plugins and the Expo Modules API, file-based routing, over-the-air updates, and android/ and ios/ folders you no longer have to babysit.
So if your picture of React Native is still “a JS thread shouting JSON across a bridge,” it’s time to update it. The Bridge is gone, and the fastest way to see what replaced it is one command: npx create-expo-app.

Modern React Native: The New Architecture and Expo

From the Bridge to JSI, Fabric and TurboModules, and why Expo is now the default

Contact us

Check out other posts

Marketplace payments with Stripe Connect
Payments

8 min read

Oct 21, 2026

Marketplace payments with Stripe Connect