Definition and History

Definition and History Interview with follow-up questions

1. What is React Native and who developed it?

React Native is an open-source framework for building native mobile apps for iOS and Android (plus other targets) using JavaScript/TypeScript and React. It was created by Meta (Facebook) and open-sourced in 2015.

The detail interviewers want: React Native is not a webview wrapper. Your React components render to real native views (a `becomes aUIView/ViewGroup, not a

`). You write UI as React components and style with JS objects, and the framework drives the actual platform UI.

Be ready for the obvious follow-up — "is it still relevant in 2026?" Yes: it's actively maintained (RN 0.85 as of April 2026), runs on the New Architecture (Fabric + JSI), and Expo is now Meta's officially recommended way to start a new app.

↑ Back to top

Follow-up 1

What are some of the main features of React Native?

Some of the main features of React Native are:

  • Cross-platform development: React Native allows developers to build mobile applications for both iOS and Android platforms using a single codebase.
  • Native performance: React Native uses native components, which allows it to deliver high performance and a native look and feel.
  • Hot Reloading: With React Native, developers can see the changes they make in the code instantly, without the need to rebuild the entire application.
  • Third-party library support: React Native has a large and active community, which has developed a wide range of third-party libraries and plugins that can be easily integrated into React Native projects.

Follow-up 2

Why is React Native popular among developers?

React Native is popular among developers for several reasons:

  • Code reusability: With React Native, developers can write code once and use it for both iOS and Android platforms, saving time and effort.
  • Faster development: React Native allows developers to use their existing JavaScript skills to build mobile applications, which reduces the learning curve and speeds up the development process.
  • Native performance: React Native uses native components, which allows it to deliver high performance and a native look and feel.
  • Large community and ecosystem: React Native has a large and active community, which provides support, resources, and a wide range of third-party libraries and plugins.
  • Hot Reloading: React Native's hot reloading feature allows developers to see the changes they make in the code instantly, making the development process more efficient.

Follow-up 3

Can you name some popular apps built with React Native?

Some popular apps built with React Native are:

  • Facebook: The Facebook app itself is built using React Native.
  • Instagram: Instagram's mobile app uses React Native for its development.
  • Walmart: Walmart's mobile app is built with React Native.
  • UberEats: The UberEats app is built using React Native.
  • Skype: Skype's mobile app uses React Native for its development.

These are just a few examples, and there are many more apps that have been built with React Native.

2. Can you explain the history of React Native?

React Native was created by Meta (Facebook) and open-sourced in 2015. It grew out of an internal hackathon project: the goal was to bring React's declarative, component-based model to mobile while still rendering real native UI (not a webview), so teams could share skills and much of their logic across iOS and Android instead of maintaining two separate native codebases.

The part interviewers actually care about is the architecture evolution, since it explains most performance gotchas:

  • Original (legacy) architecture: JS and native communicated over an asynchronous "bridge" that serialized messages as JSON. Flexible, but the serialization and async hops were a performance bottleneck.
  • New Architecture: Introduced gradually, made the default in 0.76 (2024), the only option from 0.82 (2025), and the legacy bridge code was fully removed in 0.85 (2026). It replaces the bridge with JSI (direct, synchronous JS↔C++/native calls), the Fabric renderer, and TurboModules (lazy-loaded native modules). Hermes is the default JS engine.

So the modern one-liner: "Started in 2015 as React-for-mobile over an async bridge; today it's a bridgeless, JSI-based framework, with Expo as the recommended way to start."

↑ Back to top

Follow-up 1

What problem does React Native solve?

React Native solves the problem of having to build separate native apps for iOS and Android platforms. Traditionally, developers had to write code in different programming languages (Objective-C or Swift for iOS, Java or Kotlin for Android) and use different development tools and frameworks for each platform. This meant that building and maintaining two separate codebases was time-consuming and costly. React Native allows developers to write code once in JavaScript and deploy it as a native app on both iOS and Android platforms. This significantly reduces development time and effort, as well as the cost of maintaining two separate codebases.

Follow-up 2

How has React Native evolved over the years?

React Native has evolved significantly since its initial release. In the early years, React Native focused on improving performance, stability, and adding new features. The React Native community grew rapidly, and many developers started contributing to the framework, resulting in a vibrant ecosystem of libraries, tools, and resources. Facebook, the primary maintainer of React Native, also invested heavily in improving the framework and addressing community feedback. Over the years, React Native has become more mature, stable, and feature-rich, making it a popular choice for building mobile apps.

Follow-up 3

What are some of the major updates in recent versions of React Native?

React Native has seen several major updates in recent versions. Some of the notable updates include:

  1. React Native 0.60: This version introduced the auto-linking feature, which simplified the process of linking native dependencies. It also included improvements to the Android build system and introduced the new React Native CLI.

  2. React Native 0.61: This version introduced the new Hermes JavaScript engine, which improved app startup time and reduced memory usage. It also included updates to the AndroidX support and introduced the new Fast Refresh feature for faster development iterations.

  3. React Native 0.62: This version introduced the new Flipper debugging tool, which provides advanced debugging capabilities for React Native apps. It also included updates to the CocoaPods integration and introduced the new Hermes bytecode serializer for improved performance.

These are just a few examples of the major updates in recent versions of React Native. The framework continues to evolve with regular updates and improvements.

3. What is the relationship between React and React Native?

React (React.js) and React Native both come from Meta and share the same React core: components, props/state, the reconciliation/diffing algorithm, and hooks. You write the same kind of declarative component tree in both.

The difference is the renderer, not React itself:

  • React is a UI library that is renderer-agnostic. With React DOM it renders to the browser's DOM (<div>, <span>, CSS).
  • React Native ships its own renderer (Fabric) that turns your components into real native views — → `UIView`/`ViewGroup`, → native text. There is no HTML, CSS, or DOM; styling is JS objects via StyleSheet and layout is Flexbox (via the Yoga engine).

A clean way to say it: "React is the engine; React DOM and React Native are two different rendering targets bolted onto it." That's why your React knowledge transfers, but DOM/CSS specifics and react-dom-only APIs do not.

↑ Back to top

Follow-up 1

How does React Native leverage React's features?

React Native leverages React's features by allowing developers to use React's component-based architecture and declarative syntax to build native mobile applications. React Native uses the same concepts of components, props, and state as React, making it easy for developers familiar with React to transition to mobile development using React Native.

Follow-up 2

Can you explain how React Native extends React's component-based architecture to mobile development?

React Native extends React's component-based architecture to mobile development by providing a set of pre-built components that map directly to native UI components. These components are written in JavaScript and are rendered as native components on the device. This allows developers to build mobile applications using familiar React syntax and concepts, while still having access to the performance and capabilities of native mobile development.

4. What is the architecture of React Native?

A React Native app runs your JS/React code and renders it as real native views — it's not a hybrid/webview. Frame the answer around the New Architecture, which has been the default since 0.76 and the only architecture since 0.82 (the legacy "bridge" was fully removed in 0.85):

  • JS thread: runs your React code on the Hermes engine. Reconciliation produces a tree of native view descriptions.
  • JSI (JavaScript Interface): a thin C++ layer that lets JS hold references to native objects and call them directly and synchronously, replacing the old asynchronous JSON bridge.
  • Fabric: the native renderer. It builds a C++ shadow tree, runs layout with Yoga (Flexbox), and mounts/updates actual platform views. It supports concurrent React features and synchronous layout reads.
  • TurboModules: native modules exposed over JSI; they load lazily and use Codegen to generate type-safe bindings at build time.

So the modern soundbite: "A JSI-based, bridgeless architecture — Fabric renders real native views and TurboModules expose native APIs, with no async JSON bridge." Don't describe the old async bridge/message-queue as current; that's legacy.

↑ Back to top

Follow-up 1

How does React Native use the JavaScript thread and the Native thread?

React Native uses two threads: the JavaScript thread and the Native thread. The JavaScript thread is responsible for executing the JavaScript code and handling the application logic. It runs on a separate thread from the UI thread, which ensures that the UI remains responsive even when the JavaScript thread is busy. The Native thread, on the other hand, is responsible for rendering the UI components and handling the native APIs. It communicates with the JavaScript thread through a bridge.

Follow-up 2

Can you explain the role of the bridge in React Native architecture?

The bridge is a key component in the React Native architecture. It acts as a communication channel between the JavaScript thread and the Native thread. When a React Native application is launched, the bridge is initialized and establishes a connection between the two threads. It allows the JavaScript thread to invoke native methods and access native APIs, and vice versa. The bridge also handles the serialization and deserialization of data between the two threads, ensuring that the communication is efficient and reliable.

5. What is the difference between React Native and other mobile development frameworks?

The key distinction is how the UI is rendered, and that's where most frameworks split:

  • React Native renders to real native views and runs your logic in a JS engine (Hermes) talking to native directly via JSI. You get native look-and-feel and native API access while sharing one JS/React codebase.
  • WebView/hybrid frameworks (e.g. Ionic, Cordova) render HTML/CSS inside an embedded browser. Easier to reuse web code, but the UI isn't truly native.
  • Flutter also draws native-quality UI, but with its own rendering engine (Skia/Impeller) and Dart — it paints its own widgets rather than mounting platform views, so the language and ecosystem differ.
  • Fully native (Swift/SwiftUI, Kotlin/Compose) gives maximum performance and platform fidelity, at the cost of two separate codebases.

Interviewers usually want the trade-off framing, not a winner: React Native's selling points are a shared JavaScript/React codebase, a huge ecosystem, fast iteration (Fast Refresh), over-the-air updates, and — with the New Architecture — near-native performance via direct JSI calls. The honest cost is that heavy graphics or deep platform-specific work can still push you toward native modules or fully native code.

↑ Back to top

Follow-up 1

Why would a developer choose React Native over other frameworks?

There are several reasons why a developer might choose React Native over other frameworks:

  1. Code reusability: React Native allows developers to write code once and deploy it on both iOS and Android platforms. This can significantly reduce development time and effort.

  2. Native performance: React Native uses native components, which means that the resulting apps have a more native look and feel and can take advantage of the performance optimizations and features provided by the underlying platform.

  3. Large community and ecosystem: React Native has a large and active community of developers, which means that there are plenty of resources, libraries, and tools available to help with development.

  4. Hot reloading: React Native supports hot reloading, which allows developers to see the changes they make to the code immediately, without having to recompile the entire app.

  5. Cross-platform development: React Native allows developers to build apps for both iOS and Android platforms using a single codebase, which can save time and effort compared to developing separate apps for each platform.

Follow-up 2

Can you discuss some of the limitations of React Native?

While React Native offers many advantages, it also has some limitations:

  1. Performance limitations: Although React Native apps can achieve native-like performance, there may be some performance limitations compared to fully native apps, especially for complex animations or heavy computations.

  2. Limited access to native APIs: While React Native provides access to many native APIs, there may be some APIs that are not yet supported or require additional configuration.

  3. Platform-specific code: In some cases, developers may need to write platform-specific code to access certain features or APIs that are not available in React Native.

  4. Learning curve: React Native has a learning curve, especially for developers who are new to JavaScript or mobile app development.

  5. Third-party library compatibility: Some third-party libraries may not be fully compatible with React Native, requiring additional effort to integrate them into the app.

Despite these limitations, React Native remains a popular choice for mobile app development due to its code reusability, native performance, and large community support.

6. What is the New Architecture (Fabric, TurboModules, JSI) and how does it differ from the old Bridge?

This is the single most common React Native question in 2026, so interviewers expect more than buzzwords.

The old architecture ran on an asynchronous bridge: JS and native lived on separate threads and communicated by serializing messages to JSON and passing them over a queue. That meant no synchronous calls, batching delays, and a serialization bottleneck (janky lists, slow startup).

The New Architecture removes the bridge and is built on three pillars:

  • JSI (JavaScript Interface): a lightweight C++ layer letting JS hold references to native objects and call them directly and synchronously — no JSON serialization.
  • Fabric: the new rendering system. It builds a C++ shadow tree, runs layout with Yoga, and commits updates to native views; it supports React 18 concurrent features.
  • TurboModules: native modules loaded lazily over JSI, with Codegen producing type-safe bindings at build time.

Timeline gotcha interviewers like: New Architecture became the default in 0.76, the only architecture in 0.82, and the legacy bridge was fully removed in 0.85 (2026). Hermes is the default engine. Practical impact: faster startup, synchronous layout reads, better list/animation performance — but every library you depend on must be New-Architecture-compatible.

↑ Back to top

Live mock interview

Mock interview: Definition and History

Intermediate ~5 min Your own free AI key

Your voice and your AI key never touch our servers; the key stays in this browser and is sent only to Google. Only your round scores are saved to track progress.