The New Architecture: Fabric, TurboModules and JSI

For years, every interaction in a React Native app — a scroll event reaching JavaScript, a state update reaching a native view, a native module call returning a result — traveled across a single mechanism called the bridge: an asynchronous queue that serialized every payload to JSON, batched it, and shipped it across to the other side, where it had to be deserialized before anything could act on it. That serialization tax is invisible for a button tap, but it becomes very visible the moment an app needs to synchronously measure a native view's layout before deciding what JavaScript should render next, or needs to stream a large volume of data — a camera frame, a big list's scroll offset — many times a second.

An architecture where JavaScript and native can only ever talk to each other by writing a JSON message onto a queue and waiting for the other side to eventually process it cannot support synchronous native calls, cannot easily share memory, and forces every native module and every custom native view component to route through the same serialized bottleneck regardless of how much data is actually moving. The New Architecture — Fabric, TurboModules, and the JavaScript Interface underneath both — exists to replace that queue with something JavaScript and native can call into directly, synchronously when needed, without paying a JSON tax on every single interaction.

Analogy🏏Cricket

🏏 Think of it like cricket: For decades, a team's analysts sitting in the dressing room and the coaching staff on the boundary line could only exchange tactical notes by physically writing them on paper and having a twelfth man carry the note out during a drinks break — a genuinely asynchronous channel, batched to specific stoppages in play, where a note written the moment a bowler's pace visibly dropped wouldn't reach the captain until the next natural break, by which point the over was already bowled. Modern setups instead give the analyst a live radio link directly to an earpiece the support staff can relay from, so an observation — "this batter is struggling against the short ball, bowl a bouncer now" — reaches a decision-maker inside seconds, during the same over, not queued for the next drinks break. The paper-note system did not fail because the analysts were bad at their jobs; it failed because the channel itself imposed a delay no amount of skill on either end could work around. Just as a radio link lets an observation reach a decision-maker immediately instead of waiting for a batched delivery window, TurboModules and Fabric let JavaScript and native code call each other directly instead of waiting for a batched, serialized bridge message. Just as the paper-note delay was a property of the channel, not the people using it, the old bridge's latency was a property of always serializing to JSON and queuing, not a limitation of what JavaScript or native code could individually do fast. The insight is that some problems are not solved by making the people on either end better — they are solved by replacing the channel connecting them with one that doesn't impose a structural delay in the first place.