React Native

This content was generated with the assistance of AI and should be verified against the official documentation before being relied on in production; see the section bibliography for the reference material consulted while preparing these pages.

Welcome to the React Native reference. React Native builds Android and iOS apps from one codebase using React: the same components, props, state and Hooks you already write for the web, rendered not to the DOM but to the platform’s own native views. A View becomes a UIView on iOS and an android.view.ViewGroup on Android; the result is a real native app, not a web page in a wrapper.

This section documents React Native 0.87 with React 19.2, written in TypeScript throughout. That baseline matters, because the platform changed substantially between 2024 and 2026: every page here assumes the New Architecture (it is the only architecture since 0.82), Hermes V1 as the JavaScript engine (the default since 0.84), and the Strict TypeScript API (the default since 0.87). Examples run in an Expo SDK 57 project created with npx create-expo-app@latest — the framework the official documentation recommends — and the pages that need bare native code use a @react-native-community/cli project instead.

If you already know React, you know most of this section’s programming model. What differs is everything around it: there is no DOM, styling is JavaScript objects rather than CSS files, layout is Flexbox with a different default, and the app runs across two threads with native modules underneath. This section documents those differences and does not re-explain React itself — for JSX, Hooks, Context, effects, Suspense and the Rules of React, see the React Reference.

How React Native got here

Release What changed

0.76 (2024)

The New Architecture became the default, and React Native DevTools replaced Flipper and the remote Chrome debugger.

0.82 (2025)

The New Architecture became the only architecture — the legacy bridge can no longer be re-enabled. Added DOM-like node APIs on refs and the web Performance APIs.

0.84 (2026)

Hermes V1 became the default engine, iOS ships precompiled binaries, legacy architecture code was removed, and React 19.2 landed.

0.85 (2026)

A new animation backend shared by Animated and Reanimated made useNativeDriver work with layout props; the Jest preset moved to @react-native/jest-preset.

0.86 (2026)

Edge-to-edge display became mandatory on Android 15 and later.

0.87 (2026)

The Strict TypeScript API became the default (deep imports are now type errors), Metro 0.87, experimental Swift Package Manager support, and AGP 9.

Anything the two consulted books describe that predates this timeline — the bridge, class components, Flow, Reanimated 2, CodePush, Flipper — is documented here as history, with the current approach given in its place.

New here? Read in this order

Getting Started with React Native → Core Components and React Fundamentals → Styling and Flexbox Layout → Lists and Scrolling and Text Input and Forms → Navigation → State Management and Networking and Data Fetching → Storage and Offline and Security → Debugging and DevTools, Testing and Performance → Native Modules and Components → Building and Publishing and CI/CD and Over-the-Air Updates.

Every code example across these pages builds one running app — Places, a travel-notes app with a list of places, a details screen, an "add place" form, favourites, a REST backend, offline persistence, OAuth sign-in and one native module — so the pages compose into a single coherent codebase rather than a set of unrelated snippets.

What’s covered

Foundations

  • Getting Started with React Native — what React Native is and is not, how it compares to native, Flutter and the mobile web, Expo vs. the Community CLI, and running the app on a simulator, an emulator and a device.

  • React Native Architecture Under the Hood — the threads, JSI, Fabric’s render pipeline, Turbo Native Modules and Codegen, bridgeless mode, and the legacy bridge they replaced.

  • Core Components and React Fundamentals — Core Components vs. Native Components vs. community components, and what carries over from React unchanged versus what has no DOM equivalent.

  • TypeScript in React Native — the default template, the Strict TypeScript API’s root-exports-only surface, and typing props, refs and events.

  • The JavaScript Runtime and Hermes — what Metro and Babel transform, which globals actually exist, and why Hermes exists and what Hermes V1 changed.

UI & layout

  • Styling — StyleSheet.create, style arrays, the style-prop families, density-independent points, PlatformColor, dark mode, custom fonts, and the styling-library landscape.

  • Flexbox Layout — Yoga, flexDirection’s `column default and every other layout prop, safe areas and Android edge-to-edge, and a catalogue of common layouts.

  • Images and Icons — image sources, resizeMode, the ImageBackground migration, expo-image, lazy loading, SVG, and icon sets.

  • Lists and Scrolling — ScrollView vs. FlatList vs. SectionList, filtering, pagination, pull-to-refresh, tuning props, and FlashList.

  • Text Input and Forms — controlled TextInput, focus management, pickers, keyboard avoidance, and form validation with React Hook Form and Zod.

  • Touches and Gestures — Pressable, the legacy Touchables, the gesture responder system and PanResponder, and React Native Gesture Handler.

  • Animations — the Animated API and useNativeDriver, LayoutAnimation, Reanimated’s shared values and worklets, and Lottie.

  • Modals, Alerts, and Progress — alerts, modals and bottom sheets, toasts, and progress indicators.

  • Accessibility — the accessibility props, AccessibilityInfo, font scaling, and testing with VoiceOver and TalkBack.

Navigation, platform & device

  • Navigation — React Navigation 7’s static configuration API, Expo Router’s file-based routing, deep links, and the Android back button.

  • Platform-Specific Code and Device APIs — Platform.select, platform file extensions, and the device/app-state API roster.

  • Device Capabilities — permissions, geolocation, maps, camera and media, push notifications, and vetting a community module.

Data & state

  • State Management — local vs. global vs. server state, Context and useReducer, Zustand, Redux Toolkit and MobX, and mobile-specific concerns.

  • Networking and Data Fetching — fetch, WebSockets, App Transport Security and cleartext, and TanStack Query.

  • Storage and Offline — AsyncStorage, MMKV, SQLite and sync databases compared, NetInfo, and offline-first write queues and conflict resolution.

  • Security — secrets outside the bundle, secure storage, deep-link hijacking and universal links, OAuth with PKCE, and certificate pinning.

Quality: debugging, testing & performance

  • Debugging and DevTools — the Dev Menu, LogBox, React Native DevTools, native and release-build debugging, and crash reporting.

  • Testing — the mobile test pyramid, Jest and React Native Testing Library, and end-to-end tests with Detox, Maestro and Appium.

  • Performance — the two-thread frame budget, list and startup optimization, and profiling with DevTools, Perfetto and Instruments.

Native, tooling & delivery

  • Native Modules and Components — the Turbo Native Module workflow from spec through Codegen to Kotlin and Swift, Fabric Native Components, and the Expo Modules API.

  • Brownfield Integration — embedding React Native in an existing Android or iOS app, native-to-JS communication, Headless JS, and app extensions.

  • Tooling, Metro, and Project Structure — Metro, autolinking, linting, project layout for large teams, monorepos, universal apps, and upgrading.

  • Building and Publishing — app identity, Android and iOS release builds and signing, the stores, and EAS Build and Submit.

  • CI/CD and Over-the-Air Updates — a GitHub Actions pipeline, EAS Workflows and Fastlane, and shipping JavaScript updates without a store release.

Reference

Related sections

React Native sits on top of material documented elsewhere on this site, and these pages link to it rather than repeat it. The React Reference covers React 19 itself — JSX, components, Hooks, effects, Context and the Rules of React — which this section assumes throughout. The JavaScript Development and TypeScript Reference sections cover the languages; this section documents only what is React-Native-specific about them. Native modules are written in the languages of the Kotlin, Swift and Objective-C references, and Android documents the native alternative to building cross-platform on Google’s platform — including Recommended App Architecture (UI, Domain and Data Layers) and Building, Signing and Preparing a Release, the native counterparts to this section’s own architecture and release-build pages — and Apple Platforms the native alternative on iOS, iPadOS, macOS, watchOS and visionOS. Kotlin Multiplatform is the Kotlin-based cross-platform alternative, sharing logic (or, with Compose Multiplatform, the UI) between Android, iOS, desktop and the web. OAuth for Native & Mobile Apps is the protocol reference behind Security, Couchbase Lite is one of the sync options in Storage and Offline, and E2E Testing in Real Browsers is the browser-side counterpart to this section’s mobile end-to-end testing.

Bibliography

Official React Native documentation (primary source for every page and every code example)

Expo documentation (primary source for the framework, Expo Router, Expo Modules and EAS)

Ecosystem documentation (primary source for the library code each page shows)

Language references

  • react.dev — React itself, which this section assumes rather than documents.

  • TypeScript — the language every example is written in.

  • MDN Web Docs — for the web-standard globals React Native implements (fetch, WebSocket, URL, timers, the Performance APIs).

Consulted reference books

These were consulted for the concept narrative and the practitioner’s perspective, never as the source of any code example. Both are copyrighted works and are not reproduced here; their publisher pages are linked instead.

  • Kuttig, Alexander Benedikt. Professional React Native: Expert techniques and solutions for building high-quality, cross-platform, production-ready apps. Packt Publishing, October 2022. ISBN 978-1-80056-368-1 — see the publisher’s book page and packtpub.com, with the official code bundle at PacktPublishing/Professional-React-Native. The narrative source for the storage, state-management, animation-library, tooling, project-structure, CI/CD, testing and over-the-air-update material. Its examples target React Native 0.68 on the legacy bridge, with Reanimated 2, CodePush, NativeBase and Flow — all superseded by this section’s baseline and documented here only as history.

  • Sakhniuk, Mikhail & Boduch, Adam. React and React Native: Build cross-platform JavaScript and TypeScript apps for the web, desktop, and mobile, 5th ed. Packt Publishing, April 2024. ISBN 978-1-80512-730-7 (print), 978-1-80512-687-4 (ebook) — see the publisher’s book page and packtpub.com, with the official code bundle at PacktPublishing/React-and-React-Native-5E. Part II ("React Native", chapters 15—​28) is the narrative source for the layout, lists, input, gestures, progress and modals, images, maps and offline material; its Part I is already the basis of the React Reference.

On any discrepancy between these books and the current documentation, reactnative.dev, docs.expo.dev and each library’s own documentation are authoritative — every code example on these pages is written against React Native 0.87 and Expo SDK 57 and verified against those sources, not transcribed from either book.