React

React is Meta’s JavaScript library for building user interfaces out of small, composable components. Instead of manually mutating the DOM, you describe what the UI should look like for a given state and React efficiently computes and applies the minimal set of updates, using a fiber-based reconciler and a cooperative scheduler so rendering work can be prioritized and interrupted without blocking the browser.

Because the core react package only defines the component and hooks model, the same code can target very different renderers: react-dom for the browser, react-native-renderer for native apps, and custom renderers built on react-reconciler. This split, plus first-class support for concurrent features, Suspense, and (with the newer React Compiler) automatic memoization, is what has kept React the default choice for teams building anything from a single interactive widget to a full application shell.

What You Get

• The core react package (createElement, hooks like useState/useEffect/useTransition, Suspense, act) that defines components independent of any renderer.
• Official renderers — react-dom for the web and react-native-renderer for native — plus react-reconciler for building custom renderers.
• The scheduler package’s cooperative, priority-based work loop that powers concurrent rendering and keeps the main thread responsive.
• An experimental React Compiler (in compiler/) that auto-memoizes components at build time, reducing the need for manual useMemo/useCallback.

Common Use Cases

• Building interactive single-page or multi-page web UIs, typically paired with a bundler or meta-framework like Next.js.
• Powering cross-platform mobile apps via React Native using the same component model.
• Rendering server-driven UI (React Server Components / streaming SSR) through react-server and the various react-server-dom-* packages.
• Authoring custom, non-DOM renderers (canvas, terminal, PDF, etc.) on top of react-reconciler.

Under The Hood

Architecture The monorepo separates the public API package (packages/react — ReactHooks.js, ReactBaseClasses.js, ReactChildren.js, ReactContext.js, jsx-runtime.js) that exposes createElement/hooks and delegates all stateful work to a global “current dispatcher” (ReactSharedInternals) so it stays agnostic of render target; the actual fiber-tree reconciliation and work scheduling lives in packages/react-reconciler, which is instantiated per host by packages/react-dom, react-native-renderer, and react-test-renderer via a “host config” interface, while packages/scheduler provides a cooperative, priority-based work loop (built on MessageChannel/timers) that the reconciler yields to for concurrent rendering; cross-cutting primitives (symbols, ReactTypes, feature flags) sit in packages/shared and are imported by every other package.

Tech Stack The repo is a Yarn workspaces monorepo (workspaces: ["packages/*"], yarn.lock) whose root package.json is private and pulls in a Babel toolchain (@babel/core, numerous plugin-transform-*) plus Rollup plugins (@rollup/plugin-babel, -commonjs, -node-resolve, -replace, -typescript) for bundling; source is still primarily Flow-typed (@flow pragmas, flow-typed.config.json) with an active migration toward TypeScript, and Jest drives testing across two separate CI workflows (runtime_build_and_test.yml, compiler_typescript.yml). A newer compiler/ directory houses the React Compiler, whose implementation is roughly a quarter Rust by byte count alongside the JS/TS runtime.

Code Quality Tests are extensive and colocated — packages/react/src/__tests__ alone holds 25 files, with thousands more across the other 40 packages — and internal invariants are enforced with __DEV__-gated console.error calls that link straight to react.dev documentation (see resolveDispatcher in ReactHooks.js) rather than throwing in hot paths. Naming is consistent (ReactXxx.js), and inline comments frequently explain non-obvious tradeoffs (e.g. why an error is logged instead of thrown, to keep a function inlinable).

API Design The public surface is deliberately small — a handful of top-level exports (createElement, useState, useEffect, etc.) plus dedicated subpath entry points (react/jsx-runtime, react/jsx-dev-runtime, react/compiler-runtime) so bundlers only pull in what’s used. Hooks read as plain function calls with no required boilerplate, dev-mode invariant violations produce actionable, documentation-linked error messages, and the canonical getting-started snippet is a single createRoot(...).render(<X/>) call shown directly in the README.