React 18 vs React 19 comes down to this: React 18 (March 2022) added the concurrent renderer. React 19 (December 2024) builds on it with Actions, stable Server Components and the removal of old APIs.
BOSC Tech Labs has built and maintained web products for clients since 2019, so this comparison follows the questions product teams ask us before they change the React version in production.
This guide is for teams still running React 18 in production. You get the React 18 features that still matter, what React 19 changed, and a step-by-step plan to move safely.
If you need hands-on help along the way, our team also offers full-stack development for React products.
Key takeaways:
- React 18 shipped on 29 March 2022 and introduced the concurrent renderer.
- React 19 went stable on 5 December 2024; the current release is 19.3 (September 2026).
- Most React 18 code runs on React 19 without changes.
- Move to React 18.3 first: it warns about every API that React 19 removes.
React 18 features explained: what changed in 2022
React 18 introduced concurrent rendering, which lets React pause and resume rendering work, plus automatic batching, transitions, streaming server rendering with Suspense and the createRoot API.
Before React 18, once React started rendering an update it could not stop until the result reached the screen. The concurrent renderer lets urgent work, such as typing, interrupt slower work.
Transitions with startTransition and useTransition
A transition marks a state update as non-urgent. Clicks and keystrokes render first, and React can interrupt a transition if a more urgent update arrives.
React 18 offers two ways to start one: startTransition, a plain function, and useTransition, a hook that also returns an isPending flag so you can show a loading state.
const [isPending, startTransition] = useTransition();
function handleChange(e) {
setQuery(e.target.value); // urgent: update the input
startTransition(() => setFilter(e.target.value)); // non-urgent: filter the list
}
Batched state updates everywhere
React 17 grouped several state updates into one re-render only inside React event handlers. React 18 does the same inside timeouts, promises and native event handlers.
The result is fewer re-renders with no code changes, as long as the app uses the new root API. If one update must render immediately, flushSync lets you opt out.
Streaming server rendering with Suspense
React 18 can stream HTML from the server and hydrate parts of the page as they arrive. renderToPipeableStream (Node) and renderToReadableStream (web streams) replaced the older renderToNodeStream.
A Suspense boundary shows a fallback while its content loads, so a slow part of the page no longer blocks the rest. It also powers lazy loading components in React.
The new root API
createRoot replaced ReactDOM.render, and hydrateRoot replaced ReactDOM.hydrate. The new React 18 behavior, including batching and transitions, only works through these APIs.
import { createRoot } from 'react-dom/client';
const root = createRoot(document.getElementById('root'));
root.render(<App />);
React 18 also added the useId, useDeferredValue, useSyncExternalStore and useInsertionEffect hooks. Strict Mode began mounting components twice in development to surface unsafe effects.
React 18 dropped support for Internet Explorer, because it now depends on modern browser features such as Promise, Symbol and Object.assign.
What is new in React 19?
React 19 became stable on 5 December 2024 and adds Actions for async updates and forms, new hooks, ref as a normal prop, native document metadata and stable Server Components.
For most teams, the biggest practical gap in React 18 vs React 19 is boilerplate. React 19 removes much of the code you used to write for loading, error and optimistic states.
Actions and new form hooks
An Action is an async function that runs inside a transition. React tracks its pending state, errors and optimistic updates for you, so a form no longer needs three separate pieces of state.
React 19 adds useActionState to hold an Action’s result and useFormStatus to read a form’s pending state. useOptimistic gives instant feedback, and the use API reads promises and context in render.
function NameForm() {
const [error, submit, isPending] = useActionState(async (prev, formData) => {
const res = await saveName(formData.get('name'));
return res.ok ? null : 'Could not save';
}, null);
return <form action={submit}><input name="name" /><button disabled={isPending}>Save</button>{error}</form>;
}
Automatic memoization with the compiler
The React Compiler is a build-time tool that memoizes components and hooks automatically, so most manual useMemo and useCallback calls become unnecessary. It reached its stable 1.0 release in October 2025.
The compiler is optional and can be adopted one folder at a time. It also works on React 17 and 18 with extra configuration, so it is not a reason on its own to change versions.
React 19 keeps the concurrent rendering model from React 18 and lets transitions run async functions, which is what makes Actions possible.
Other React 19 additions
Function components receive ref as a regular prop, so new code no longer needs forwardRef. Components can render title and meta tags, and React places them in the document head.
React 19.1 (March 2025), 19.2 (October 2025) and 19.3 (September 2026) added more, such as the Activity component and useEffectEvent in 19.2 and View Transitions in 19.3. See the full list of React 19 changes on react.dev.
React 18 vs React 19: side-by-side comparison
React 19 keeps everything that worked in React 18 and adds tools that remove boilerplate. The main cost of moving is cleaning up APIs that React 18 had only deprecated.
The table below sums up the difference between React 18 and React 19 area by area.
| Area | React 18 | React 19 |
|---|---|---|
| Stable release | 29 March 2022 | 5 December 2024 (19.3 in September 2026) |
| Rendering | Concurrent renderer, opt-in through the new root API | Same model; transitions can be async |
| Batching | Automatic batching for all updates | Same |
| Forms and mutations | Manual loading and error state | Actions, useActionState, useFormStatus, useOptimistic |
| Memoization | Manual useMemo and useCallback | Optional compiler memoizes automatically |
| Server-rendered components | Not stable in core React | Server Components stable |
| Refs | forwardRef needed | ref passed as a normal prop |
| Document metadata | Needs a library | Native title and meta tags in components |
| Legacy APIs | ReactDOM.render deprecated | ReactDOM.render removed |
Most rows add features rather than take them away, so the move is mainly about removing old patterns.
In practice, React 18 vs React 19 is less a performance decision than a maintenance one. React 19 saves developer time, while staying on 18 keeps legacy code in place longer.
Breaking changes to check before you move
React 19 removes APIs that React 18 only deprecated, so search your codebase for them before you upgrade to React 19. Most apps use few of them, but each one stops working.
| Removed in React 19 | Replace with |
|---|---|
| ReactDOM.render | createRoot |
| ReactDOM.hydrate | hydrateRoot |
| String refs | Callback refs or useRef |
| propTypes checks | TypeScript or another type checker |
| defaultProps on function components | Default parameter values |
| findDOMNode, unmountComponentAtNode | DOM refs, root.unmount() |
| Legacy context (contextTypes) | contextType with createContext |
These removals come from the official React 19 upgrade guide, which also lists smaller changes to error handling and test utilities.
When we audit an older React codebase, we first search for legacy APIs such as ReactDOM.render, string refs and propTypes. That short list usually tells us how much work a version move will take.
React 18.3 is identical to 18.2 but logs a warning for each of these APIs, which makes it the safest stepping stone. TypeScript users also get stricter types, such as useRef now requiring an argument.
Libraries that rely on React internals can block the move, so check your UI kit, router and testing tools. For larger codebases, our legacy product modernization team runs this audit as a first step.
How to upgrade to React 19 from React 18 in 6 steps
Move in small steps: get to React 18.3, fix every warning, run the official codemods, install React 19, test, and only then adopt the new features. Each step can ship on its own.
- Upgrade to React 18.3 and fix every deprecation warning in the console.
- Check that your router, state library, UI kit and testing tools support React 19.
- Run the official codemod recipe, which rewrites ReactDOM.render, string refs and other removed APIs.
- Install react and react-dom version 19, plus the version 19 type packages if you use TypeScript.
- Run your test suite and watch the console; React 19 reports render errors differently.
- Enable the compiler gradually, one folder or component at a time, if you want it.
npx codemod@latest react/19/migration-recipe
npm install --save-exact react@^19.0.0 react-dom@^19.0.0
npm install --save-exact @types/react@^19.0.0 @types/react-dom@^19.0.0
The codemod recipe does not cover TypeScript changes. For those, the React team points to types-react-codemod with its preset-19 option.
Our team prefers to move client apps to a new React major in small steps: update the packages, fix the warnings, run the tests, and only then switch on newer tools like the React Compiler.
Also confirm that the new JSX transform is enabled. React 19 requires it, though most build tools from the last few years already use it.
React 18 vs React 19 for business apps: stay or switch?
For most business apps, React 18 vs React 19 is a question of timing, not need. A stable React 18 app keeps working, but React 19 removes old APIs, so the cleanup grows the longer you wait.
Most of our client relationships run for several years, so we schedule React version moves around each product’s release plan instead of rushing them in the middle of a busy quarter.
The React 18 features your app relies on, from batching to transitions, keep working in React 19. What changes is the legacy code around them.
Staying on React 18 for now makes sense when:
- the product is in maintenance mode with few planned changes;
- a key library does not support React 19 yet;
- the team has no capacity for testing this quarter.
Moving soon makes sense when:
- the app is in active development and new code keeps adding legacy patterns;
- you want server-rendered components or a framework that builds on them;
- the app has many forms and data updates that Actions would simplify.
Frequently asked questions
Is React 18 still supported?
React 18 apps keep working, but new features ship only in React 19, now at version 19.3. React does not publish a long-term support calendar, so plan your move rather than wait for a deadline.
Do I need to rewrite my app for React 19?
No. Most React 18 code runs on React 19 unchanged. Only code that uses removed APIs, such as ReactDOM.render or string refs, needs edits, and the official codemods automate most of them.
How long does a React 19 upgrade take?
It depends on how much legacy API usage and how many outdated libraries your app has. A short audit of the codebase, starting with React 18.3 warnings, gives a far better estimate than any rule of thumb.
Is the React Compiler required in React 19?
No. The compiler is an optional build tool. You can leave it off, or enable it gradually for one folder or component at a time, and it also works with React 17 and 18 using extra configuration.
Which is faster, React 18 or React 19?
The core renderer performs similarly. In React 18 vs 19 comparisons, gains usually come from the optional compiler cutting re-renders and from Actions reducing state code. Measure your own app with the React Profiler.
What is the latest version of React?
The latest version is React 19.3, released on 9 September 2026. It added View Transitions, Fragment Refs and other features, and the react.dev documentation now covers the 19.x line.
Next steps: plan your React version move
The React 18 vs React 19 decision starts with one task: search your codebase for the APIs React 19 removes. That list tells you how big the move is and when it fits your roadmap.
When you are ready to upgrade to React 19, follow the six steps above and keep each one small. If you want an experienced team to review an older codebase first, talk to our engineers.
Sources
- React v18.0, react.dev, 29 March 2022
- React v19, react.dev, 5 December 2024
- React 19 Upgrade Guide, react.dev
- React Compiler v1.0, react.dev, 7 October 2025
- React 19.3, react.dev, 9 September 2026



