2013 – 2026

React Versions

Every public release of React — from the 0.x line that began in 2013 through React 19 — with ship dates and the headline changes each one introduced. React’s version numbers jumped straight from 0.14 to 15, and much of its most-searched history lands in minor releases: Hooks shipped in 16.8, not a major. Below: the per-version table, where React 1–14 went, the 0.x lineage, and the prose history from Jordan Walke’s Facebook prototype through Concurrent React and Server Components.

Where React 1–14 went — the 0.14 → 15 jump

There was never a React 1 through 14. React spent its first three years on a 0.x version line (0.3 through 0.14), then jumped straight from 0.14 to 15.0 in April 2016. The jump was deliberate: it signalled that React was production-mature, and it unified the version numbers of the react and react-dom packages, which had been split apart in 0.14. So the sequence reads 0.14 → 15.0 → 16 → 17 → 18 → 19, with no 1–14 in between. See the new-versioning-scheme announcement and the React v15 release post. The 0.x lineage is kept at the bottom of the table below.

Scope

React is a library for building user interfaces, not a full framework — routing, data fetching, and build tooling come from the surrounding ecosystem (Next.js, Remix, Vite). This page tracks React core (the react / react-dom packages). React Native is a separate project on its own 0.x versioning track and is not covered here. Feature-bearing minor releases (16.3, 16.6, 16.8) get their own rows, because the answer to “which version added Hooks?” is a minor. Each row carries its ship date inline; the current line is verified against the official versions list and the GitHub Releases feed on each refresh.

React version table

Version
React 19.2
Oct 1, 2025
The current line. <Activity> for hiding and restoring UI state, useEffectEvent, cacheSignal for Server Components, partial pre-rendering, and Performance Tracks in DevTools.
  • <Activity> — render part of the tree in a hidden mode that preserves its state and DOM for later, the building block for pre-rendering and instant back/forward navigation.
  • useEffectEvent — extract non-reactive logic out of an Effect so it reads the latest props/state without re-firing the Effect.
  • cacheSignal (Server Components) signals when a cache() lifetime ends; plus partial pre-rendering and React Performance Tracks in Chrome DevTools.
  • The current stable line; the latest patch is 19.2.1 (Dec 11, 2025). See the React 19.2 announcement and the changelog.
Version
React 19.1
Mar 28, 2025
Owner Stacks for clearer component traces in development; new Server Components prerender APIs and bundler packages (including Parcel).
  • Owner Stacks — a development-only API that reconstructs the chain of components that rendered a given element, sharpening error and warning traces.
  • Experimental prerender / resume APIs for React Server Components and a new react-server-dom-parcel package for Parcel.
  • A minor on the 19 line. See the v19.1.0 release notes.
Version
React 19.0
Dec 5, 2024
The Actions / Server Components release. Actions and the form hooks, the use API, stable Server Components, ref as a prop, and document-metadata hoisting.
  • Actions — async transitions for form submission and data mutation, with the new hooks useActionState, useFormStatus, and useOptimistic.
  • The use API — read a Promise or context during render, unlocking cleaner data-fetching and conditional context reads.
  • React Server Components and Server Actions reach stable — render-on-the-server components shipped as a supported feature for frameworks built on React.
  • ref as a regular prop (retiring most forwardRef boilerplate); <Context> usable directly as a provider; automatic hoisting of <title> / <meta> / stylesheets; clearer hydration-mismatch errors. Paired with the React Compiler (then in beta) that auto-memoizes components. See the React v19 post.
Version
React 18.0
Mar 29, 2022
Concurrent React. createRoot, automatic batching, transitions (useTransition / startTransition), streaming SSR with Suspense, and new hooks.
  • Concurrent rendering — the opt-in foundation that lets React interrupt, pause, and resume rendering so urgent updates aren’t blocked by slow ones. Most apps adopt it implicitly through the new APIs rather than turning on a flag.
  • createRoot replaces ReactDOM.render; state updates are automatically batched everywhere (not just in event handlers).
  • Transitions — startTransition / useTransition mark non-urgent updates so typing and clicks stay responsive.
  • Streaming server rendering with Suspense; new hooks useId, useDeferredValue, useSyncExternalStore, useInsertionEffect. See the React v18 post.
Version
React 17.0
Oct 20, 2020
The “No New Features” release — on purpose. Its job was gradual upgrades (two React versions on one page), plus the new JSX transform and an event-delegation change.
  • Deliberately no new user-facing features. React 17 was a stepping-stone release whose purpose was to make future upgrades incremental — letting one part of an app run React 18 while another stays on 17, so teams migrate page-by-page instead of all at once.
  • New JSX transform — the compiler no longer requires import React from 'react' in every JSX file, and produces slightly smaller bundles.
  • Event delegation moved from document to the React root container, so multiple React versions and non-React code can coexist on a page. See the React v17 post.
Version
React 16.8
Feb 6, 2019
Hooks. State and lifecycle in function components — useState, useEffect, and the rest — shipped in a minor, not a major.
  • Hooks — useState, useEffect, useContext, useReducer, useMemo, useCallback, useRef, and custom hooks. Function components gained state and lifecycle, and classes stopped being necessary for most components.
  • The single most-searched fact in React versioning: Hooks shipped in 16.8, a minor release (February 6, 2019) — not in a major. The preceding 16.7 was even titled “No, this is not the one with Hooks.”
  • See the “React v16.8: The One With Hooks” post and the Hooks history below.
Version
React 16.6
Oct 23, 2018
React.lazy + Suspense for code-splitting, React.memo, and contextType.
  • React.lazy and <Suspense> — first-class component-level code splitting with a declarative loading fallback.
  • React.memo — the function-component equivalent of PureComponent, memoizing render output by props.
  • static contextType for consuming context in class components, and getDerivedStateFromError for error boundaries. See the v16.6 post.
Version
React 16.3
Mar 29, 2018
The modern Context API, createRef / forwardRef, StrictMode, and the new lifecycle methods.
  • New Context API (React.createContext) — the supported replacement for the long-experimental legacy context, and the basis for most state-sharing patterns until Hooks.
  • createRef and forwardRef; <StrictMode> for surfacing unsafe patterns in development.
  • New lifecycle methods getDerivedStateFromProps and getSnapshotBeforeUpdate, deprecating the componentWill* lifecycles ahead of async rendering. See the v16.3 post.
Version
React 16.0
Sep 26, 2017
The Fiber rewrite. Error boundaries, returning arrays/strings from render, portals, and a rewritten server renderer — and the move to the MIT license.
  • Fiber — React’s reconciler rebuilt from scratch as an incremental rendering engine. Fiber is invisible to most app code but is the foundation that Concurrent React (18) and everything after is built on. (See the Fiber history below.)
  • Error boundaries (componentDidCatch), returning arrays and strings from render, portals (ReactDOM.createPortal), and a faster, rewritten server-side renderer.
  • React 16 shipped under the MIT license, ending the BSD-plus-patents-clause controversy that had pushed some organizations away from React. See the v16.0 post.
Version
React 15.0
Apr 7, 2016
The version jumped here straight from 0.14 (see the callout above). Per-node document.createElement, full SVG attribute support, and dropped IE 8.
  • React’s version line jumped from 0.14 to 15.0 to signal maturity and align the react and react-dom package numbers — the page’s signature reference fact, detailed in the callout above.
  • Rendering moved to per-node document.createElement (away from the old data-reactid markup), full SVG attribute support, and improved warnings.
  • Dropped Internet Explorer 8 support over the 15.x line. See the React v15 post.
Below this line: the 0.x line (2013–2015) — React’s pre-15 lineage, from the May 2013 open-sourcing through 0.14. Kept here for historical completeness and to answer “what came before React 15.”
Version
React 0.x
2013 – 2015
The pre-15 lineage: 0.3 (the first public release) through 0.14 (the react / react-dom split). The line predates the maturity-signaling jump to 15.
  • 0.14 (Oct 7, 2015) — React split into two packages: react (the renderer-agnostic core) and react-dom (the browser renderer), the split that React 15 then re-unified under one version number. Stateless functional components arrived here.
  • 0.13 (Mar 10, 2015) — support for defining components as ES6 classes, alongside the older React.createClass.
  • 0.12 (Oct 2014) — the React elements model (React.createElement), separating elements from components.
  • 0.3.0 (May 29, 2013) — the first public release, when React was open-sourced at JSConf US. (See the origin history below.)
  • The full 0.x archive lives in the official versions list; this row carries the milestones, not every point release.

Each row anchors as #react-MAJOR-MINOR (e.g. #react-19-0, #react-16-8); the 0.x lineage anchors as #react-0x. The current line is re-verified against the GitHub Releases feed and react.dev/versions — this table is refreshed when a new stable release lands.

Jordan Walke, FaxJS, and the 2013 open-sourcing

React began at Facebook around 2011 as an internal prototype by engineer Jordan Walke, originally called FaxJS. It grew out of a homegrown PHP UI library (XHP) and the problem of keeping Facebook’s increasingly interactive News Feed in sync with its data. The core idea was to re-render a component’s whole UI on every state change and let a fast diffing layer — the virtual DOM — apply only the minimal real changes. React shipped inside Facebook’s News Feed in 2011 and was adopted by Instagram after Facebook acquired it in 2012.

React was open-sourced at JSConf US in May 2013 (the initial public commit is dated May 29, 2013). The reception was initially skeptical: JSX — React’s syntax for writing markup inside JavaScript — struck many developers as a violation of the “separation of concerns” principle that had kept HTML, CSS, and JS in separate files. React’s counter-argument, that components co-locate the markup and the logic that actually change together, gradually won out, and JSX became one of the most widely copied ideas in front-end tooling.

For the language JSX compiles into, and the TypeScript dialect most React apps are written in today, see the JavaScript Versions and TypeScript Versions pages.

Fiber, and the BSD-patents-to-MIT relicensing (2017)

By 2016 React’s original reconciler — the part that decides what to update — had reached its limits. The team rebuilt it as Fiber, an incremental engine that can split rendering work into units, pause and resume them, and prioritize urgent updates. Fiber shipped in React 16.0 (September 2017) with no change to the public API, and it is the substrate that made Concurrent React (18) and Suspense possible years later.

React 16 also resolved a licensing fight. React had shipped under a BSD license plus an additional patents grant that revoked the patent license if you sued Facebook for patent infringement. In 2017 the Apache Software Foundation classified that clause as incompatible with its projects, and the controversy peaked when WordPress announced it would move away from React. In September 2017 Facebook relicensed React under the standard MIT license, and React 16 was the first release to carry it — removing the legal cloud that had kept some organizations off React.

React is maintained by Meta (formerly Facebook) together with a large open-source community, and remains a library rather than a framework — a distinction the team continues to make explicit.

Hooks — the 16.8 watershed

For React’s first five years, state and lifecycle methods lived in class components, while function components were limited to stateless presentation. Sharing stateful logic between components meant awkward patterns (higher-order components, render props) that wrapped the component tree in extra layers. Hooks, previewed at React Conf in October 2018 and shipped in React 16.8 on February 6, 2019, let function components hold state (useState), run side effects (useEffect), and read context (useContext) directly, and let stateful logic be packaged as reusable custom hooks.

The detail that trips people up is that this landmark change shipped in a minor version, not a major — which is why “which version of React added Hooks?” is one of the most common React-versioning questions, and why this page lists feature-bearing minors as their own rows. Hooks became the default way to write React; classes still work but are rarely written in new code.

Concurrent React, Server Components, and react.dev

React 18 (March 2022) turned Fiber’s capabilities into public APIs under the banner of Concurrent React: transitions, automatic batching, streaming server rendering with Suspense, and createRoot. Rather than a single “concurrent mode” switch, the concurrency showed up gradually through individual features — the foundation for what came next.

React 19 (December 2024) shipped Server Components and Actions as stable features, alongside the use API, form hooks, and document-metadata support — a shift toward rendering work on the server and treating data mutations as first-class. It arrived with the React Compiler, which automatically memoizes components so developers write less useMemo / useCallback by hand; the compiler reached its 1.0 in October 2025.

Alongside the code, React’s documentation moved from reactjs.org to react.dev in March 2023, reframing the recommended path around production frameworks (such as Next.js) rather than the older create-an-app workflow. That pivot was made concrete in February 2025 when the team sunset Create React App, pointing new projects at frameworks or build tools like Vite instead. React itself stays a view library; the framework layer lives in the ecosystem around it.

Find your React version

React is a project dependency, so the version lives in your package.json and lockfile — and, unlike most build-time tools, React also exposes its version at runtime. Run one of these in the project directory, or read React.version from inside the app.

What version is installed?

npm ls react prints the exact resolved version in the project; npm view react version prints the latest published to npm.

$ npm ls react            # exact version installed in this project
$ npm view react version    # latest version published to npm
$ yarn why react          # yarn / pnpm: who depends on which react
$ pnpm why react

Read it from the project files

The range you allow lives in package.json; the exact resolved version lives in package-lock.json (or yarn.lock / pnpm-lock.yaml).

// package.json
"dependencies": {
  "react":     "^19.2.0",
  "react-dom": "^19.2.0"
}

At runtime, from inside the app

React publishes its own version string — useful in a console or a debug overlay to confirm what actually shipped to the browser.

// in app code or the browser console
import { version } from 'react';
console.log(version);   // e.g. "19.2.0"

// or, without an import:
React.version;

Sources: github.com/facebook/react releases; React CHANGELOG; react.dev/blog; react.dev/versions; legacy.reactjs.org blog archive. Cross-reference: JavaScript Versions, TypeScript Versions, Angular Versions. Last updated June 2026.

Mungomash LLC · More software pages

Shipped 2026-06-23 by Tethys — initial build; React 19.2 current (latest patch 19.2.1, Dec 2025), verified against react.dev/versions and the GitHub Releases feed.