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
- Your code: TypeScript, JSX, hooks.
- Babel: turns JSX and TS into plain JS.
- Metro: bundles everything into one JS bundle.
- Hermes: compiles the bundle to
.hbcbytecode.
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
- Render: React creates elements, and C++ builds the Shadow Tree shared by both platforms.
- Commit: Yoga computes layout, and the tree becomes immutable and ready to show.
- 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 installpicks 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.pbxprojconflicts.
What makes Expo a joy to use
- Expo Router: the file
app/user/[id].tsxis 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-appto 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.





