React 19.2, released in October 2025, is the third major release following React 19.0 and 19.1. This update focuses on performance enhancements, new hooks that improve developer experience, and Server-Side Rendering (SSR) optimizations. In this article, we'll explore the most important features of React 19.2 and how to integrate them into your applications.
Quick Summary: Core Features of React 19.2
The most notable features introduced in React 19.2 include:
- Activity Component: Configure specific sections of your app to run in the foreground or background
- useEffectEvent Hook: Separate event logic from useEffect and prevent unnecessary work
- cacheSignal: Manage cache lifecycle with React Server Components
- Performance Tracks: New performance analysis tools in Chrome DevTools
- Partial Pre-rendering (PPR): Pre-render static shell and stream dynamic content later
- SSR Improvements: Enhance streaming performance with Web Streams and Node Streams support
Activity Component: Intelligently Manage Your UI Sections
React's new <Activity /> component allows you to segment your application into logical "activities" and control when and how each section operates.
Two Core Modes of Activity
The Activity component can work in two different modes:
visible: The component and all its children are rendered, effects run, and state updates are processed normally.
hidden: The component renders but its children are not shown, effects are unmounted, and any state updates are deferred to the background.
Activity Component in Practice
In this setup, when ProductPane is hidden, the effects of its children are unmounted, preventing unnecessary API calls. When you return to the page, instant transitions are achieved using cached data.
Benefits of Using Activity
- Instant Transitions: State is preserved when switching between tabs, no restart
- Background Preparation: Hidden components can perform necessary work in the background
- Performance: Unnecessary renders and effects are prevented
useEffectEvent: Keep Your Event Logic Pure
The useEffectEvent hook allows you to separate your event-based logic from useEffect. This helps you always access the latest prop or state values while keeping your dependency array under control.
Why useEffectEvent Matters
When using traditional useEffect, changes to prop or state dependencies can re-run your effect. Sometimes, you only want code to run in response to specific events.
In this example, when theme changes, the connection isn't re-established, only the notification displays with the new theme.
Key Rules for useEffectEvent
- Event functions can access reactive values from their closure
- Don't include effect events in your effect dependencies (your linter will enforce this)
- Event functions can be called from within components or used by effects
cacheSignal: Managing Cache with RSC
When using React Server Components, the cacheSignal function gives you control over cache lifecycle. It allows the server to indicate when cached work is no longer needed.
This feature is particularly valuable in CDN and streaming hydration scenarios. You can abort network requests or clean up custom async tasks.
Performance Tracks: Detailed Performance Analysis
The new "Performance Tracks" feature in Chrome DevTools helps you visualize how React works internally:
React Scheduler Track
- Task priority levels ("blocking", "transition")
- When and why render work began
- Which React component triggered which work
React Components Track
- When components mount/unmount
- When effects run
- Where state updates originated
These tools are an excellent starting point for discovering why your app feels slow.
Partial Pre-rendering (PPR): Take SSR to the Next Level
React DOM introduces new primitives to pre-render a static shell and resume it later — perfect for CDNs + streaming hydration.
Pre-render
Pre-render captures the static shell of your application and saves the postponed state for later resumption.
Resume to SSR stream (Web Streams)
Retrieve the saved postponed state and resume streaming the application as a Web Stream to the client.
Resume + Produce Static HTML (SSG)
Generate static HTML from the resumed render and upload it to a CDN for optimal performance.
APIs to Look Up
For Web Streams:
react-dom/server: resume(Web Streams),resumeToPipeableStream(Node Streams)
For Static Generation:
react-dom/static: resumeAndPrerender(Web Streams),resumeAndPrerendererToNodeStream(Node Streams)
Important Note: The prerender APIs now return a postpone state you'll pass to the resume APIs.
Notable Changes
1. Suspense Boundary Batching (SSR)
In streaming SSR, reveals are slightly delayed so that content reveals happen together, aligning client and SSR behavior.
2. Web Streams (Node.js)
APIs like renderToReadableStream, prerender, and resumeAndPrerender are now available in Node.js. This provides compatibility with Deno and other runtimes.
Node Preferences:
renderToNodeStreamrenderToPipeableStreamresumeAndPrerender
3. eslint-plugin-react-hooks v6
- Flat config support
- React Compiler-powered recommendations
- Use
plugin:react-hooks/recommended-legacyfor legacy behavior
4. useId Prefix Change
The prefix changed from _ in React 19.0 to _r_ in React 19.1. This ensures compatibility with View Transition CSS selectors and XML 1.0 naming conventions.
React 19.2 Migration Checklist
Follow this checklist for a successful migration to React 19.2:
For Applications
- Adopt Activity Component: Pre-render tabs, side panels, or upcoming pages
- Refactor to useEffectEvent: Identify where event logic causes effect churning
- Cache Your RSC: Manage network requests with
cacheSignal - Profile with Performance Tracks: Check which work is "blocking" in Chrome DevTools
- Configure Your SSR Pipeline: Decide between Web Streams vs Node Streams
For Tooling
- Update ESLint Rules: Install
eslint-plugin-react-hooks@6.1or later and choose eitherrecommendedorrecommended-legacypreset - Verify useId CSS Selectors: Ensure prefixes are in the
_r_format
Conclusion
React 19.2 represents significant progress in performance and developer experience. The Activity component enables intelligent UI segmentation, useEffectEvent keeps event logic pure, and Partial Pre-rendering optimizes SSR, making React applications faster and smoother.
By gradually integrating these new features into your applications, you'll meet the performance and user experience expectations of modern web applications. With React 19.2, the future of web applications promises even better performance, lower bandwidth usage, and seamless user interactions.