cloudparts

React

The JavaScript library for building interfaces from components: functions that return JSX, re-rendered when their state changes, with the same model on the web, on the server and, through React Native, on phones.

React Foundation project
What it is
UI libraries (headless libraries)
Type
Open source
Made by
React Foundation
Foundation
React Foundation, joined February 2026. Contributed by Meta, which still employs a full-time React team. Part of the Linux Foundation
License
MIT
Facts checked
28 October 2026
Website Source code

What it is

A React component is a JavaScript function that takes props and returns a description of the UI, usually written in JSX, HTML-like syntax that a compiler turns into function calls. State lives in hooks such as useState; when it changes, React calls the component again, compares the new tree of elements with the previous one and applies only the differences through a renderer: react-dom updates the browser DOM, React Native creates native views. The reconciler behind this, rewritten as Fiber for React 16, can split rendering into small units of work, which React 18 (March 2022) used for concurrent rendering: an update wrapped in startTransition can be interrupted by a more urgent one, such as a keystroke, and <Suspense> shows a fallback while part of the tree waits for code or data.

React 19 (December 2024) made Server Components and Server Functions stable: components that run only on the server, or at build time, and send their rendered result to the browser, plus functions the client calls on the server. Using them needs a bundler and router that support them, so the React docs recommend starting new apps with a framework (Next.js, React Router or, for native apps, Expo) or, for a single-page app built by hand, a build tool such as Vite, Parcel or Rsbuild; Create React App was deprecated in February 2025. React Compiler 1.0 (October 2025) memoizes components and values automatically at build time, so most code no longer needs useMemo and useCallback by hand. React 19.3 (September 2026) made <ViewTransition> and Fragment refs stable, and 19.3.1 followed in October. Meta built React and contributed it to the React Foundation on February 24, 2026; it is MIT-licensed.

Why teams pick it

  • The largest ecosystem of any UI library: component kits such as MUI, headless libraries such as TanStack, frameworks and developers; 85 percent of developers in the 2025 State of JavaScript survey had used it
  • One component model across targets: the browser, the server, static builds and, with React Native, Android, iOS and other platforms
  • UI as a function of state: you describe what the screen should show and React works out the DOM changes, which keeps complex interfaces predictable
  • Long-lived APIs and a gradual upgrade path: function components and hooks from 2019 still work unchanged in React 19

Watch out for

  • Only the view layer: routing, data loading, bundling and server rendering come from a framework or other libraries, and the React docs steer new projects towards one
  • Server Components add a server and a serialization protocol to the app; in December 2025 a flaw in how React decoded requests to Server Function endpoints allowed unauthenticated remote code execution (CVE-2025-55182, CVSS 10.0)
  • Re-rendering is the default: a state change re-runs the component and its children, so large trees need memoization, which React Compiler now adds automatically if you use it
  • Hooks follow strict rules (call them at the top level, in the same order every render) and effects run twice in development Strict Mode, which surprises newcomers

Alternatives

What all headless libraries have in common →Compare side by side →
TanStackOpen sourceA family of open-source TypeScript libraries (Query, Table, Form, Router, Start and more), each a framework-agnostic core with thin adapters, that handle state and logic while you keep the markup.

How it fits with other technologies

State, rendering and a transition that a keystroke can interrupt · ts

// npm install react react-dom
import { useState, useTransition } from 'react'
import { createRoot } from 'react-dom/client'

function Search({ items }: { items: string[] }) {
  const [query, setQuery] = useState('')
  const [shown, setShown] = useState(items)
  const [isPending, startTransition] = useTransition()

  function onChange(text: string) {
    setQuery(text)                       // urgent: the input updates at once
    startTransition(() => {              // can be interrupted by the next keystroke
      setShown(items.filter(i => i.includes(text)))
    })
  }

  return (
    <>
      <input value={query} onChange={e => onChange(e.target.value)} />
      <ul style={{ opacity: isPending ? 0.5 : 1 }}>
        {shown.map(i => <li key={i}>{i}</li>)}
      </ul>
    </>
  )
}

createRoot(document.getElementById('root')!).render(<Search items={['apple', 'apricot', 'banana']} />)

See it in a real stack

No architecture uses React yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2011–2026

Jordan Walke, a software engineer at Facebook, built a prototype called FaxJS that became React. Facebook first used it in News Feed in 2011 and in Instagram in 2012, and open-sourced it at JSConf US in May 2013. Its idea was to re-render the whole view on every change and let the library work out the DOM updates. React Native brought the same model to mobile in 2015.

React was first released under a BSD licence with an extra patent grant whose terms worried some users; in September 2017 Facebook relicensed it under MIT, and React 16, the first release on the Fiber reconciler, shipped under MIT that month. Hooks arrived in React 16.8 in February 2019 and replaced class components for most code. React 18 (March 2022) added concurrent rendering, and React 19 (December 2024) made Server Components, Actions and the use API stable.

On October 7, 2025, Meta announced it would move React, React Native and JSX to a new React Foundation under the Linux Foundation, and released React Compiler 1.0 the same day. The foundation launched on February 24, 2026, and the repository moved from facebook/react to react/react in June. React 19.3 followed in September 2026.

Why it’s built this way

Re-render and compare instead of updating the DOM by hand
Describing the whole UI for the current state, and letting React apply the difference, removes a class of bugs where the screen and the data drift apart; the cost is extra rendering work that memoization has to trim.
Markup in JavaScript with JSX
Keeping a component’s logic and markup in one place, using ordinary JavaScript for loops and conditions instead of a template language, made components easy to compose and type-check.
Interruptible rendering
The Fiber rewrite split rendering into units React can pause and resume, so urgent updates such as typing aren’t blocked by large, slow ones; transitions and Suspense are built on it.
Leave routing and data fetching to frameworks
Server Components and Server Functions need cooperation from the bundler and router, so the React team now points new projects at frameworks rather than shipping its own app starter.

Timeline

  1. 2011

    First used in Facebook’s News Feed

  2. 2013

    Open-sourced at JSConf US in May

  3. 2017

    Relicensed under MIT; React 16 ships on the Fiber reconciler

  4. 2019

    Hooks arrive in React 16.8

  5. 2022

    React 18 adds concurrent rendering

  6. 2024

    React 19 makes Server Components and Actions stable

  7. 2025

    React Compiler 1.0; React Foundation announced; Create React App deprecated

  8. 2026

    Moves to the React Foundation on February 24; React 19.3 in September

Sources14 · facts checked 28 October 2026

Improve this page on GitHub