What is React?

What is React?

React is an open-source JavaScript library for building user interfaces, created by Jordan Walke at Facebook (now Meta) and open-sourced in May 2013. It introduced a component-based architecture and a virtual DOM diffing algorithm that made declarative UI development practical at scale. As of April 2026, React 19 is the current stable release, shipping React Server Components and the use hook as first-class features. React doesn't prescribe routing, data fetching, or build tooling — it's a rendering library, not a framework. That distinction matters because full-stack frameworks like Next.js, Remix, and Astro build on top of React to handle everything else. React powers the interfaces of Facebook, Instagram, Airbnb, and countless production apps. We've shipped React on 50+ client projects, and it remains the default UI layer in our Next.js stack for interactive web applications.

How it works

React's core loop is straightforward: you describe what the UI should look like for a given state, and React figures out the minimum DOM mutations needed to get there.

1. Components — Functions (or classes, though nobody writes those anymore) that accept props and return JSX, a syntax extension that compiles to React.createElement calls.
2. State and hooks — useState, useEffect, useRef, and others let you manage local state and side effects inside function components. React 19 added use() for reading promises and context inline.
3. Reconciliation — When state changes, React builds a new virtual DOM tree, diffs it against the previous one (the "fiber" reconciler, rewritten in React 16), and batches the minimal set of real DOM updates.
4. Server Components (RSC) — Introduced experimentally in React 18 and stabilized in React 19, RSCs run on the server, send serialized UI to the client, and never ship their JavaScript to the browser. Big shift from React's original client-only model.

A minimal component:

import { useState } from 'react';

export function Counter() {
  const [count, setCount] = useState(0);
  return (
    <button onClick={() => setCount(c => c + 1)}>
      Clicked {count} times
    </button>
  );
}

React doesn't handle routing or data fetching on its own. That's why most production apps pair it with a meta-framework like Next.js (our go-to) or Remix.

When to use it

React's the right choice more often than not for interactive web UIs. But it's not always the right choice.

Use React when:

• You're building a single-page app or a complex interactive interface (dashboards, SaaS products, content editors)
• Your team already knows it — React's hiring pool is the largest in frontend
• You need a rich ecosystem of third-party components (headless UI, Radix, React Aria)
• You're using Next.js or Remix, which require React as the rendering layer

Skip React when:

• You're building a content-heavy, mostly-static site with minimal interactivity — Astro with zero JS or vanilla HTML will score better on Core Web Vitals
• You need sub-50KB total bundle weight and every kilobyte counts — Preact (3KB) or Svelte (compiler, no runtime) are leaner
• You're building a simple marketing page — React adds complexity you won't need

React vs alternatives

React's biggest advantage isn't technical — it's ecosystem gravity. More libraries. More hiring candidates. More battle-tested patterns. Vue and Svelte are excellent, but when clients ask us to pick, React + Next.js wins on long-term maintainability for teams that will grow.

Real-world example

We recently rebuilt a B2B SaaS dashboard for a client processing 2M+ monthly sessions. The previous jQuery-based UI had an Interaction to Next Paint (INP) of 800ms+ on median devices. We rewrote it in React 19 with Next.js 15 App Router, using Server Components for the data-heavy table views and client components only for interactive filters and modals. Post-launch INP dropped to 180ms (well under the 200ms "good" threshold), and the JS bundle shipped to the browser shrank by 62% because the heaviest data-formatting logic stayed on the server via RSC. The dev team went from 2 engineers to 5 without onboarding friction because everyone already knew React.