What is React Native?

What is React Native?

React Native is a cross-platform mobile framework that lets developers build iOS and Android apps using JavaScript and React. The output is genuine native binaries — not web views inside a wrapper. UI components map to platform-specific native widgets (UIKit on iOS, Android Views on Android), and your JavaScript runs on a separate thread that communicates with the native UI via a bridge or, in newer versions, the more efficient JSI (JavaScript Interface).

Created by Facebook (now Meta) in 2015 from a hackathon project, React Native solved a real pain: the same product team having to ship and maintain two completely separate codebases for iOS (Swift/Objective-C) and Android (Kotlin/Java). With React Native, ~85-95% of code is shared. Big production users include Meta's own apps, Microsoft Office mobile, Discord (originally), Shopify, Coinbase, and Walmart's app — alongside thousands of smaller apps.

How React Native works (the architecture)

The mental model:

• JavaScript thread. Your React Native code runs here. Standard React rendering rules apply — component tree, state, effects.
• Native UI thread. Renders the actual platform widgets (UIView on iOS, View on Android). The JS thread doesn't directly touch this; it sends instructions.
• Bridge / JSI. The communication layer between the two threads. The original "bridge" (until ~2022) serialized messages as JSON — slow for animations and interactive elements. The new JSI architecture (default in modern React Native) gives JavaScript direct synchronous access to native modules, dramatically faster.
• Native modules. Platform-specific code (Swift, Kotlin) accessible from JavaScript. Use these for things React Native doesn't expose by default — Bluetooth, native camera APIs, biometric auth.

The result: UI looks and feels native (because it IS native), animations can hit 60fps on modern hardware, and most application logic stays in the shared JavaScript codebase.

What React Native is good at

• Cross-platform UI development. One JavaScript codebase, real native UIs on both platforms. The shared-code ratio is genuinely high (typically 85-95%).
• Hot reload and fast iteration. Code changes show up in the running app within seconds. Native development with full Xcode/Android Studio rebuilds takes minutes per iteration.
• Existing React expertise. Web teams using React can ship mobile without learning Swift or Kotlin from scratch. The React mental model carries over directly.
• Over-the-air updates. Tools like Expo's EAS Update (or CodePush, deprecated 2024 but still used) let you push JS-only updates without going through App Store / Play Store review. Critical bug fixes in hours, not weeks.
• Most app categories. CRUD apps, social apps, e-commerce, content apps, productivity tools — all good fits.

Where React Native struggles

• Performance-intensive apps. AR/VR, advanced graphics, complex real-time data visualization, heavy game logic — these often need native code. The JS bridge (or even JSI) adds overhead that matters at the edge.
• Native UI features that lag platform. When iOS or Android ships new APIs (e.g. Vision Pro, new Material 3 components), React Native often takes months to expose them. Native developers ship them on day one.
• Larger app size. Bundling the JavaScript runtime adds 5-15 MB to your binary. Matters for emerging-market users with strict storage / data plans.
• Debugging across the bridge. When something crashes, the stack trace may span JS, native bridge code, and platform code. Tooling has improved (Flipper, React DevTools) but it's harder than pure native.
• Library ecosystem decay. Many React Native libraries are abandoned or unmaintained. Anything not officially supported by Expo or the Meta core team has elevated risk.

React Native vs Flutter vs Native

The three main mobile development paths in 2026:

• React Native: JavaScript + React, real native widgets. Best for teams with existing React expertise. Mature, but the architecture has evolved through pain.
• Flutter: Dart language + custom rendering engine (no native widgets, draws everything itself). Pixel-perfect across platforms but slightly less "native feel." Growing fast since Google's strong investment.
• Native (Swift/Kotlin): Two codebases. Highest performance, latest platform features on day one. Best for resource-rich teams shipping platform-specific UX or performance-critical apps.

The 80/20 rule: most product apps don't need native performance. React Native or Flutter saves enough engineering time to justify the (small) compromises.

React Native and Expo

Expo is a managed framework on top of React Native that handles the most painful parts: build infrastructure, OTA updates, native modules, push notifications, splash screens. Modern best practice is "start with Expo unless you have a specific reason not to" — even Meta-led projects increasingly use Expo's tooling. The trade-off: Expo bundles a fixed set of native modules, so if you need something they don't ship, you eject to bare React Native.

Common React Native gotchas

• iOS and Android UI subtle differences. The same React component renders slightly differently on each platform — text rendering, scroll behavior, default colors. Test on both; don't assume parity.
• Permission handling differs. iOS asks for permissions on first use; Android often pre-requests in manifest. The React Native API smooths this but doesn't fully unify behavior.
• Navigation is a separate library. React Native ships no opinion. React Navigation is the de facto standard, but the API is large and has breaking changes between major versions.
• iOS deployment requires a Mac. No way around it — building iOS bundles for the App Store requires Xcode, which only runs on macOS. Linux/Windows teams use cloud build services (EAS Build, Bitrise) for iOS.
• Crash logs need symbol upload. React Native crashes can be hard to read without uploading source maps to your crash reporter (Sentry, Crashlytics). Easy to forget; expensive to debug without.

FAQ: React Native

Is React Native still relevant in 2026?

Yes. The architecture rewrite (Fabric renderer + JSI) shipped in 2023-2024 addressed long-standing performance issues. Major apps (Meta, Microsoft, Shopify) actively maintain React Native investments. Expo's tooling has made onboarding much smoother. Cross-platform mobile is a steady-state market and React Native is one of two leaders alongside Flutter.

What's the difference between React Native and React (web)?

Same React core (components, state, hooks), different rendering targets. React for web renders to DOM elements (<div>, <span>). React Native renders to native UI primitives (<View>, <Text>). You share component logic and state management; UI components themselves don't directly share between web and mobile (use React Native Web if you want to share UI, with caveats).

Can I share code between web (React) and mobile (React Native)?

Business logic, hooks, and state management: yes, easily. UI components: only with React Native Web (renders RN components on the web). Many teams take a 60-70% sharing approach — share logic, write platform-specific UI for each target.

Is React Native good for performance-sensitive apps?

Increasingly, yes. The new architecture (Fabric + JSI, default since RN 0.74) significantly reduced bridge overhead. For AR/VR, complex animations at 120fps, or 3D rendering, native still wins. For most product apps, React Native is fast enough that performance isn't the limiter.

How long does a React Native app take to build?

Initial setup (Expo): 1-2 days to running app with auth and a few screens. Pure native equivalent: 1-2 weeks. The cross-platform speed-up compounds — what takes 4 months in pure native takes 2-3 in React Native for typical product apps.

Can I migrate an existing native app to React Native?

Incremental migration is possible — React Native supports embedding inside an existing native app ("brownfield" integration). Many large apps (Microsoft Office, Walmart) used this approach. It's hard but doable; budget months, not weeks.

How LoadFocus tests React Native apps

React Native apps that talk to backends (95%+ of them) need API monitoring and load testing. LoadFocus API monitoring validates the backend that your mobile clients hit — slow APIs make even the best React Native UI feel sluggish. Load testing validates that your backend holds up when your app launches and goes viral. UI testing of the React Native app itself uses different tools (Detox, Maestro) — but the network layer absolutely benefits from synthetic monitoring.