Two call paths compared: the old bridge serialising each call to JSON, queueing it and answering a frame later, and JSI holding a direct reference so the call returns immediately, with TurboModules, Fabric and Codegen built on top.

The bridge is gone, and the round trip was always the real cost

Modern mobile applications are expected to deliver fast, responsive, and seamless user experiences

For about ten years, the two halves of a React Native app could not call each other. They could only leave messages.

Your JavaScript ran in its own engine on its own thread. The native side - the real UIView and android.view.View objects, the camera, the filesystem - ran on others. Between them sat a queue. Every interaction was serialised into JSON, put on that queue, batched up, and delivered to the other side on its next pass. The answer came back the same way.

That queue was called the bridge, and nearly everything people complained about in React Native was a consequence of it.

What it actually cost

Three things followed from the design, and none of them was "JavaScript is slow".

Everything was asynchronous, including things that had no business being. Asking for the screen width meant posting a message and waiting for a reply, even though the native side had the number in memory the whole time. You wrote await to read a constant.

// The old way. A value that already exists, a frame away.
const width = await NativeModules.ScreenInfo.getWidth();

Everything had to be JSON. That is the part that shaped the architecture most. You could not pass a function across, or an object reference, or an image buffer. Anything that moved had to be flattened into text and rebuilt on the other side. For a list of twenty rows, fine. For a 60-frames-a-second animation, where every frame means serialising the new position, sending it, and waiting - not fine. This is exactly why the framework grew a useNativeDriver: true flag: it was an escape hatch that let a small, fixed set of properties be handed over once and then animated entirely natively, because the per-frame round trip was unaffordable. The flag's limitations - transforms and opacity only, never layout - were the limitations of what could be described in one JSON payload up front.

Nothing was checked. The bridge had no notion of types. A native module declaring it returned a number and actually returning a string produced a crash on a user's phone, not an error on your machine.

And then the subtler cost, the one that showed up as a number product managers cared about: startup time grew with every dependency you added. The old module system initialised every registered native module when the app launched, whether the app used it or not. Install a library for a feature on the fifth screen and you paid for it at launch, on every launch, forever.

JSI: a reference instead of a queue

The JavaScript Interface is a thin C++ layer, and the idea is small enough to say in a sentence: let JavaScript hold a direct reference to a native object and call its methods.

Not a message describing a call. The call.

Once that exists, the queue has nothing to do. There is no serialisation, because there is nothing to serialise - both sides are looking at the same memory. There is no waiting for the next batch, because there is no batch. A function can be passed across and invoked later. A buffer can be shared rather than copied.

// With JSI, the same read is a read.
const width = DeviceInfo.getScreenWidth();   // returns, now

JSI is also engine-agnostic, which is why React Native could move from JavaScriptCore to Hermes without rewriting everything above it. The interface is to a JavaScript engine, not to a specific one.

Everything else in the New Architecture is built on this.

TurboModules, and the startup problem

A TurboModule is a native module over JSI. It is faster, because the call is a call. But the change that users actually notice is lazy loading.

A TurboModule is not created until the first time something uses it. Install a barcode scanner for a feature buried three screens deep and your app's launch no longer knows it exists. For an app with forty native dependencies - which is an ordinary number - this is the difference between a cold start that feels instant and one that does not.

The second change is Codegen. You describe the module's interface in TypeScript, and the build generates the C++ on both sides from that description:

export interface Spec extends TurboModule {
  getDeviceName(): string;              // synchronous, and typed
  readSetting(key: string): Promise<string | null>;
}

A mismatch between what JavaScript expects and what the native code provides is now a compile error. The whole class of "it works until the one device that takes the other code path" has moved from runtime to build time.

Fabric, and why it needed JSI first

Fabric is the rewritten renderer, and the reason it could not have been built before is that rendering needs to ask questions synchronously. How tall is this text? What is this view's measured size? Under the old bridge, every such question was a round trip, so layout had to happen in one place, on one thread, in one pass.

With JSI, the renderer can read layout directly. From that, a few things fall out. The shadow tree - React Native's internal description of what should be on screen - is C++, shared and immutable, so it can be created on a background thread and committed on the main one. React's concurrent features, including Suspense and interruptible rendering, work properly, because interrupting a render is only safe if the renderer can discard half-finished work without having already posted it across a queue. And view flattening removes redundant container views, so a tree of nested View components does not become a tree of nested native views.

You can check which renderer you are on in one line:

console.log(global.nativeFabricUIManager ? 'Fabric' : 'legacy');

One frame, traced

The abstraction gets clearer if you follow a single dragged finger.

A reader puts a thumb on a card and moves it. On the old architecture, here is what had to happen before the card moved one pixel:

  1. The native touch system registers the move and creates a touch event.
  2. The event is serialised to JSON and placed on the queue.
  3. On its next pass, the bridge delivers the batch to the JavaScript thread.
  4. Your handler runs, computes a new position, and calls setState or writes to an Animated.Value.
  5. The new position is serialised and queued back.
  6. The bridge delivers it to the native side on another pass.
  7. The view is finally moved.

Seven steps, two queue traversals and two JSON conversions - for one frame. At 60 frames a second you have 16.7 milliseconds for the whole loop, and if the JavaScript thread happens to be parsing an API response when the batch arrives, step 4 waits. The finger keeps moving; the card does not. That lag is the thing people meant when they said React Native "felt" non-native, and it was not a feeling - it was a measurable number of dropped frames with a specific cause.

Now the same drag with react-native-gesture-handler and Reanimated on JSI. The gesture is recognised natively. The handler is a worklet, running on the UI thread. It writes to a shared value, which is memory the UI thread already owns. The animated style reads it and the view moves. JavaScript is not involved in any of it, and can be entirely blocked throughout without the card hesitating.

The code barely changed. The number of threads the frame has to visit went from three to one.

How it shipped without breaking everything

A rewrite of this size usually means a hard break, and this one did not, which is worth a note.

The New Architecture landed behind a flag and became the default in React Native 0.76. Alongside it came an interop layer: a compatibility shim that lets old-style native modules and old-style view managers keep working under the new renderer. So a library that had not been updated did not immediately stop working - it ran through the shim, lost the benefits, and kept the app building.

That is why most teams upgraded without touching their own code, and also why the ecosystem's transition has been gradual rather than a cliff. It has a cost: an app can be on the New Architecture while half its dependencies are still crossing a compatibility boundary, which means the startup and performance wins arrive piecemeal as each library is updated. If an upgrade did not feel faster, an unmigrated dependency in a hot path is the first thing to check.

What this does not fix

It is worth being precise about the limits, because "the bridge is gone" gets repeated as though it made React Native fast in general. It did not. It removed one specific cost.

Your JavaScript still runs on one thread. A heavy synchronous computation blocks it, and the interface stops responding, exactly as before. JSI makes crossing cheap; it does not make your code parallel.

A badly built list still drops frames. Rendering a thousand rows at once is slow because of the rendering, not the boundary. Everything in Module 3 of our React Native course about FlatList, stable keys and memoised rows is as true as it ever was.

Re-renders still cost what they cost. A context provider handing out a fresh object every render re-renders every consumer, and no amount of C++ underneath changes that.

What JSI fixes is the boundary. If your performance problem was the boundary - a per-frame animation, a chatty native module, a cold start bloated by eager initialisation - it is fixed. If it was your own code, it is still your own code.

Does any of this change what you write?

Mostly, no, and that is the point of a good migration. Your components are the same. Your hooks are the same. View, Text, FlatList all behave as before. The New Architecture has been the default since React Native 0.76, and most apps upgraded without changing a line.

Three places where it does show up:

Animations. Reanimated's worklets and shared values are built on JSI, which is what allows an animation loop to run entirely on the UI thread while JavaScript is blocked. You could not have built that cleanly on the old bridge, and useNativeDriver's restrictions were the shape of what was possible instead.

Writing a native module. The spec-first workflow - declare the TypeScript interface, let Codegen produce the bindings - is genuinely different from the old hand-written bridging, and better. Synchronous functions are available where they make sense, which they never were before.

Old libraries. A package that has not been updated for the New Architecture may rely on the interop layer, or may not work at all. "Does it support the New Architecture" has become a real question to ask before adding a dependency, alongside the last commit date.

The pattern underneath

There is a general lesson here that outlives React Native.

For a decade, a very large number of people believed the framework's ceiling was JavaScript. The reasoning was intuitive: it is an interpreted language, the native side is compiled, so the gap must be the language. Considerable effort went into that theory - moving work off JavaScript, writing more native code, choosing other frameworks on the strength of it.

The ceiling was the boundary. Not the language on either side of it, but the fact that crossing meant copying your data into text, putting it in a queue, and waiting for a turn. Replace the crossing and the same JavaScript, in the same engine, on the same thread, gets dramatically faster at the things that were slow.

The expensive part of a system is frequently not the work. It is the handover.

It is worth noticing how long the wrong explanation survived. It was plausible, it was repeated by people with real experience, and it was never quite tested - because testing it would have meant building the alternative, and the alternative was a multi-year rewrite of the framework's foundations. The theory was cheap and the experiment was expensive, so the theory stood.

The same shape turns up in a lot of places: a serialisation boundary between two services, an ORM that makes one query per row, a build step that copies a directory it could have linked. The work looks like the cost because the work is what you wrote. The handover is in the gaps between what you wrote, which is exactly where nobody looks.


The New Architecture, TurboModules and writing your own native module in Swift and Kotlin are Module 7 of React Native Development, free to read in full.

react native jsi turbomodules fabric performance mobile development