Runtime Layers

Hermes is React Native's default JavaScript engine. In release builds its compiler, hermesc, turns the Metro bundle into bytecode on the build machine, so at launch the device runs ready bytecode instead of parsing and compiling JavaScript source.

The JavaScript thread runs your bundle: React rendering, state updates, event handlers, timers and fetch callbacks. The UI (main) thread is the only one that creates and mutates native views, and it handles raw touches, native scrolling and native animations.

The legacy bridge sent serialized, batched messages asynchronously, so native calls normally answered through callbacks or promises. JSI lets JavaScript call C++ host functions synchronously and hold references to C++ host objects, with no serialization step.

No. The New Architecture is the only architecture since React Native 0.82: newArchEnabled=false on Android and RCT_NEW_ARCH_ENABLED=0 on iOS are ignored with a warning, and the app still runs on it, with old libraries loaded through interop layers.

JSON.parse runs synchronously on the single JavaScript thread, so no setInterval callback, state update or re-render can run until it returns. Scrolling is performed natively on the UI thread, so it keeps working while JS-driven updates stall.

No. React Native 0.87 runs bridgeless: JavaScript calls Turbo Native Modules and drives the Fabric renderer through JSI, with no serialized message queue. Libraries still written for the bridge work through interop layers.

Render clones the changed host components' shadow nodes into a new immutable tree. Commit runs Yoga layout and promotes it as the next tree. Mount diffs it against the tree on screen and applies only the resulting mutations to native views.

Check the HermesInternal global, which only Hermes defines. It proves the engine, not the input: debug builds run development source from Metro, and non-standard bundle loading can skip the precompiled bytecode, so measure a release build that ships the .hbc.

Interop layers adapt old-architecture code: legacy native modules are served through NativeModules and legacy view managers are hosted in a Fabric wrapper. They cannot provide custom shadow nodes, concurrent features, synchronous typed calls or codegen type safety.

Measure the anchor's host View ref inside useLayoutEffect with getBoundingClientRect or measureInWindow, then set the tooltip's placement there. Fabric answers synchronously from the committed shadow tree, so the corrected position commits before the first frame.

JavaScriptCore is no longer in core since 0.81: an app must add @react-native-community/javascriptcore and select it in the build. Most teams move to Hermes V1 instead, which core ships, tests and precompiles to bytecode for faster startup.

Scans stop being serialized, queued bridge events: JavaScript holds a C++ host object and reads its state synchronously. The rule: jsi::Runtime must not be used concurrently, so the camera thread schedules work onto the JS thread instead of touching the runtime.

Legacy dependence shows as Android compile errors on classes removed in 0.84 or 0.85, iOS build failures now that legacy code is compiled out, 'not available in the new architecture' errors, nil-returning bridge-proxy calls and Unimplemented component placeholders.

Drop pure-JavaScript libraries, check each native one's New Architecture status in React Native Directory, its codegenConfig and release notes, then run every flow on the New Architecture and sort libraries into supported, interop-only, broken or replace.

Normally render and commit (including Yoga layout) run on the JavaScript thread and mount runs on the UI thread. For a high-priority discrete event originating on the UI thread, Fabric can run render, commit and mount synchronously on the UI thread.

Weigh the feature's importance, a maintained alternative, the native surface and whether the team can own it: replace when a good alternative exists, fork or port when none does and you can maintain it, and treat interop as borrowed time.

View flattening lets Fabric skip creating native views for layout-only Views, folding their layout into their children during diffing. Set collapsable={false} when native code needs that View to exist as a real platform view.

MessageQueue recorded each call as a module id, method id and arguments, and handed the batch to native code on the next native-to-JS return or after 5 ms. Arguments crossed as JSON-compatible data, so functions, NaN and native objects could not.

Hermes's Hades collector does most old-generation marking and sweeping on a background thread, so the JS thread pauses only briefly, at some throughput cost. React Native also requests a collection on severe Android onTrimMemory levels and, since 0.81, on iOS memory warnings.