Overview

React is a free, open-source JavaScript library for building user interfaces out of small, reusable pieces called components. A component is a function that receives data as props and returns a description of what should be on screen — written as JSX, a syntax that looks like HTML but compiles to ordinary function calls. When state changes, React compares the new description with the previous one and applies the smallest set of DOM operations that brings the page into line, so you describe the result you want rather than the sequence of steps that gets there.

The library started at Meta in 2013 as an internal answer to a specific problem: keeping a large, constantly updating feed interface consistent with its data. It was open-sourced that May (the repository was created on 24 May 2013) and grew into the base layer under a large share of the modern web. Ownership changed in 2026 — React, React Native and JSX are now held by the React Foundation, an independent body hosted by the Linux Foundation, with Amazon, Callstack, Expo, Huawei, Meta, Microsoft, Software Mansion and Vercel as founding members and Seth Webster as executive director. The code is MIT licensed and the repository at github.com/react/react carries roughly 252,000 stars. The current line is 19.3, with 19.3.1 published on 14 October 2026.

Key Features

• Component model — a component is an ordinary JavaScript function; compose Thumbnail, LikeButton and Video into a page, and reuse or nest them freely.
• Declarative rendering — you return the markup for a given state and React reconciles it against the DOM; there is no manual element creation, insertion or cleanup.
• Hooks — useState for local state, useEffect for synchronising with systems outside React, useMemo and useCallback for stable computed values, useRef for values that should not trigger renders.
• JSX — markup and logic in the same expression, with the full power of JavaScript inside it: conditionals with if, lists with map(), composition with plain function calls.
• Actions and form handling — async transitions, useActionState, useOptimistic and useFormStatus cover submitting, pending states, optimistic updates and errors without hand-written flags.
• Server Components — components that render only on the server and stream to the client, so data access stays off the bundle; a shared React runtime handles both sides.
• Suspense and transitions — loading states, streaming with useDeferredValue and startTransition, and in 19.2 <Activity> for pre-rendering hidden screens without blocking the visible one.
• View Transitions — <ViewTransition> and addTransitionType, stable since 19.3, animate enter, exit, move and resize changes using the browser’s View Transition API.
• React Compiler — a build-time optimiser that memoises components automatically; its 1.0 release arrived on 7 October 2025, so most codebases no longer hand-wrap everything in useMemo.
• One runtime, many targets — react-dom for the browser, React Native for iOS and Android, and rendering to strings or streams for servers and static sites.

Why Use React?

The practical argument is the size of the ecosystem and the number of problems already solved. Routing, data fetching, forms, tables, charts, maps, accessibility primitives and design systems all exist as mature React libraries, and a question about any of them has been answered publicly many times over. That makes hiring, onboarding and debugging cheaper than with a smaller runtime, and it makes the choice of React the least risky decision in a stack review.

The second argument is that the mental model survives growth. A component tree that starts as one file still reads the same way at a thousand components: data flows down through props, events flow up through callbacks, and state lives in the smallest component that needs it. When that stops being enough, the same primitives extend into server rendering, streaming, code splitting and native apps without a rewrite. React is deliberately a library rather than a framework: it renders, and leaves routing, data and build tooling to the surrounding choices.

Use Cases

• Single-page applications — dashboards, admin panels and internal tools where the interface changes constantly and a full page reload would be wasteful.
• Server-rendered sites — content and commerce sites built with Next.js, React Router or TanStack Start, where React Components render on the server and hydrate in the browser.
• Design systems — a shared component library consumed by several applications, with Storybook for documentation and visual testing.
• Mobile apps — React Native compiles the same component model to native iOS and Android interfaces.
• Embedded widgets — a React tree mounted into one element of an existing page, which is how many legacy applications adopt it incrementally.
• Interactive documentation and demos — live examples, playgrounds and visualisation tools where markup has to respond to input.

Getting Started

The React team’s own advice for a new application is to start from a framework — Next.js for a full-stack site, React Router for a client-heavy one, Expo for a mobile app — because routing, data fetching and bundling are already wired. To learn React itself, or for a single-page tool with no server, a build tool is the shorter path: npm create vite@latest my-app -- --template react produces a project with JSX, hot module replacement and a production build in place, and npm run dev serves it locally.

From scratch the requirements are small: Node.js for the toolchain, a package manager, and React plus React DOM as dependencies. A minimal application is a component, a createRoot call against a container element, and the JSX inside. Teaching material lives at react.dev, which pairs every concept with an editable example, and the reference documentation is the same site’s API section.

What Changed in React 19.x

React 19, stable since December 2024, made Actions a first-class concept: a form or button can hand an async function to React and get pending, error and optimistic states handled for it, with useActionState, useOptimistic, useFormStatus and the use API alongside. It also allowed ref as a plain prop on function components, hoisted document metadata into the tree, and stabilised Server Components.

19.2, in October 2025, added <Activity> for keeping hidden parts of an app mounted but deprioritised, useEffectEvent for extracting non-reactive logic out of effects, cacheSignal, React Performance Tracks in Chrome DevTools, and partial pre-rendering for static shells with dynamic holes. 19.3, released 9 September 2026, stabilised <ViewTransition> and fragment refs, added Trusted Types support to React DOM, and let <Context> be rendered directly in a Server Component. Patch releases including 19.3.1 have concentrated on hardening the Server Components transport protocol.

How It Compares

Vue offers a comparable component model with single-file components and a gentler template syntax; it is an excellent default for teams that prefer templates to JavaScript expressions in markup. Svelte moves the work to build time and ships no runtime, which suits small, fast sites. Angular is the most complete framework of the group, with dependency injection and opinionated structure that pays off in very large enterprises. Solid and Preact trade ecosystem size for a smaller footprint — Preact is often used to shrink bundles on already-large sites.

React’s distinguishing bet is on being a library plus a huge ecosystem rather than a framework, and on Server Components as the bridge between server-rendered HTML and a client app. Where Vue or Svelte give you one blessed way to build a site, React gives you Next.js, React Router, Expo or a plain Vite app — more choice, and more decisions to make.

Learn and Get Help

react.dev is the canonical documentation: the Learn section teaches by building, and the Reference section documents every hook, component and API with caveats. The React Foundation’s site, react.foundation, covers governance and the wider ecosystem; the blog at react.dev/blog carries each release’s notes and upgrade guidance. Source, issues and RFCs live at github.com/react/react. For the surrounding tooling, Vite’s documentation covers the build side, and Next.js, React Router and Expo each carry their own guides for the framework layer.