Skip to content
Tutorials Center
My learning

Topics

Lesson 1 of 71 ยท Getting Started

What is React Native?

Learn what React Native is, how it turns React components into real native views, how it differs from web React, Flutter and native code, and when to pick Expo.

React Native is a framework for building mobile apps for iOS and Android with JavaScript (or TypeScript) and React. You write components, state and hooks exactly as you would on the web, but the components do not produce HTML. They produce real native views: the same buttons, scroll views and text fields that a Swift or Kotlin developer would use. The result is an app that looks, scrolls and feels like any other app on the phone, built from one codebase that you can share across both platforms.

This tutorial assumes you know React. If useState, props and useEffect are new to you, read the React tutorial first. Here we focus on what changes when the target is a phone instead of a browser.

What runs on this site. A phone app needs an iOS or Android runtime, and a website cannot provide one. So every real React Native snippet in this course is shown read-only in a plain code block. Next to it you get runnable stand-ins: small React 19 examples that render View-like and Text-like components to HTML so you can see the ideas working. Each lesson says clearly which part is the real thing and which part is the stand-in.

From JavaScript to native views

On the web, React DOM turns your components into DOM elements. React Native uses the same React core, but a different renderer: it turns your components into native views.

JSX
import { View, Text, Pressable } from 'react-native';

export function Greeting({ name }) {
  return (
    <View>
      <Text>Hello, {name}!</Text>
      <Pressable onPress={() => console.log('tapped')}>
        <Text>Tap me</Text>
      </Pressable>
    </View>
  );
}

Nothing in this example is HTML. View becomes a native container (a UIView on iOS, an Android view group), Text becomes native text, and Pressable reports touches from the platform's own touch system. Your JavaScript describes the tree; React works out what changed; the native side creates, moves and updates the actual views.

Same React, new renderer

React core Components, props, state, hooks.
React DOM Renders to HTML in a browser.
React Native Renders to native iOS and Android views.

You keep your React skills. Only the building blocks change.

1 / 2

How it differs from web React

Most of your React knowledge transfers directly. These things do not:

  • No HTML tags. There is no div, span, p, img or button. You use View, Text, Image and Pressable. The next lessons cover them one by one, starting with core components.
  • Text must live inside Text. A bare string inside a View is an error.
  • No CSS files. Styles are JavaScript objects with camelCase names, and there is no cascade. Layout uses Flexbox for everything, with the column direction as the default.
  • No URL bar. Navigation means a stack of screens, handled by a library (React Navigation or Expo Router).
  • No DOM, no window, no localStorage. You get platform APIs instead: storage, camera, location and notifications, usually through packages.
  • Touch, not mouse. There is no hover, and a tap is onPress, not onClick.
One component, three targets

React Native, Flutter and fully native

Three common ways to build a mobile app, each with a different trade-off:

Approach Language How the UI is drawn Strength
Native (Swift/SwiftUI, Kotlin/Compose) Swift, Kotlin Platform widgets, directly Best platform access, two codebases
React Native JavaScript/TypeScript Platform widgets, driven from JS One codebase, React skills, huge ecosystem
Flutter Dart Its own rendering engine draws every pixel Pixel-identical UI, one codebase

React Native sits in the middle: you get the platform's real widgets (so a date picker or a text field behaves like the system one) without writing two apps. Flutter draws its own widgets, which gives you total control but means you rebuild platform behavior yourself. Fully native gives the deepest access to new OS features on day one, at the cost of two teams or two skill sets. If your team already knows React and JavaScript, React Native lets you reuse that knowledge, and often some code, from your website.

The New Architecture in one minute

Older React Native versions talked to the native side through an asynchronous bridge that serialized every message to JSON. Modern React Native replaced it, and the replacement is the default in current releases. Its main parts:

  • JSI (JavaScript Interface): lets JavaScript hold direct references to native (C++) objects and call them, without JSON.
  • Fabric: the new renderer, which can read layout and update the screen synchronously when needed (useful for gestures and measuring).
  • TurboModules: native modules that load lazily, with typed interfaces.
  • Hermes: the JavaScript engine built for mobile, which runs precompiled bytecode for faster startup.

You do not need to configure any of this to build an app. You will see how the pieces fit in How React Native runs your code.

Expo or bare React Native?

You can start a project in two ways:

  • Expo is a framework and toolset around React Native. It gives you a project template, file-based routing (Expo Router), a large set of ready-made native modules (camera, notifications, SQLite, and more), and cloud services for builds and updates (EAS). The React Native team recommends starting new apps with a framework like Expo.
  • React Native CLI (bare) gives you the ios/ and android/ native projects up front and expects you to manage them yourself. You need Xcode and Android Studio set up before the first run.

Expo is not a limited "toy" version. You can add custom native code later, and you can run everything on your own machine. This course uses Expo because it removes setup friction and matches what most new projects do.

Expo or bare? A tiny decision helper

What you will build in this course

You will start with the basics (components, styles, Flexbox), move through input, lists and navigation, then handle data, native features, animation, testing and shipping to the app stores. Along the way you will build a todo app, a weather app, a notes app, a shopping app, a chat UI and a habit tracker. Because the real runtime cannot run here, every project has runnable stand-ins for its logic, and the real code is shown for you to run on your own machine or phone.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What does React Native render your components to?

    React Native uses a renderer that creates platform views (such as UIView on iOS and Android view groups). It is not a WebView, and unlike Flutter it does not draw every pixel itself.
  2. 2. Which of these is a valid React Native building block for showing a line of text?

    Text is the component for text. HTML tags do not exist, and a bare string directly inside a View is an error.
  3. 3. Which part of the New Architecture lets JavaScript call native code without serializing messages to JSON?

    JSI (JavaScript Interface) gives JavaScript direct references to native objects. Metro bundles code, Babel transforms it and Gradle builds Android projects.
  4. 4. Why does this course use Expo?

    Expo is a framework and toolset on top of React Native. It speeds up setup and still lets you add custom native code through development builds and config plugins.

Summary

  • React Native lets you build iOS and Android apps with React; components render to real native views, not HTML.
  • Most React skills transfer, but there are no HTML tags, no CSS files and no DOM. Text must be inside Text, styles are objects and layout is Flexbox.
  • Compared with fully native code you share one codebase; compared with Flutter you use platform widgets instead of a custom rendering engine.
  • The New Architecture (JSI, Fabric, TurboModules, Hermes) is the default; you rarely have to configure it.
  • Expo is the recommended way to start; this site shows real native code read-only and uses HTML stand-ins to demonstrate the ideas.

Next, install the tools and create your first project in Setting Up with Expo.