What’s new in React 19?

React has come a long way from its initial public release in May 2013. It still remains the choice JavaScript framework for developers.

React was built on JavaScript because it is the primary language for building dynamic web applications and is supported by modern browsers. It leverages JavaScript features such as functions and classes to create more dynamic and maintainable code.

React has gone through various changes over the years, and it keeps getting improved to make sure that developers get the best use of this library.

This article aims to discuss the new features and improvements of the latest version of React.

ReactJS is a library built to provide developers with a fast, efficient and flexible library for building dynamic website and web applications. Developers can create reusable components, while React renders these components using the Virtual DOM.

The virtual DOM (Document Object Model) is a lightweight representation or copy of the actual DOM which is represented or stored as a JavaScript Object in memory.

When the state of an application changes, React updates the Virtual DOM first instead of the real DOM, it then compares the virtual DOM with the previous one and identifies the difference.

React updates only the part of the real DOM that has changed instead of re-rendering the entire DOM. This approach ensures faster operations and quick updates to the user interface making React fast and efficient for building complex and dynamic websites.

React is currently on its 19th version which was released on April 25,2024 and became officially stable on December 5,2024.

Here are new features, and improvements highlighted in the official release of React 19 including;

React compiler is a new tool designed to simplify the React code that developers write. Without the compiler, developers have to manually apply optimizations to create performant applications. Examples include using useMemo or useCallback hooks to avoid unnecessary component re-evaluations and potential render cycles.

The compiler would address these issues and add these optimizations behind the scene to your code, which will be implemented during the build process. This feature is still in the experimental phase.

Actions are functions that you can pass around to handle data mutations which involves changing the state or property of a component. Example is using the useState hook to update the value of a previous state.

In previous versions of React, you will have several state calls to handle "error”, "isPending", however by using actions you can use asynchronous transitions that handle the pending, error state automatically.

Actions manage submitting data by handling;

Pending State: Actions provide a pending state that starts at the beginning of a request and resets automatically when the state update is committed.

Optimistic Updates: Action supports useOptimitic hook which allows you to provide users with feedback while their request is submitting. In other words, it lets you show changes right away.

Error Handling: Action handles errors by enabling you to display error boundaries when a request fails. They also revert optimistic updates automatically to their original value.

Forms: Form elements supports passing functions to the action and formAction props. By passing functions to these action props, actions are used by default, and the form automatically resets after submission.

Let’s check out the example from React documentation;

src:https://react.dev/blog/2024/12/05/react-19

In the above image we see that useState is being used to track the value of the input field. There's also a state to track errors during the process of updateName and also a state "isPending" that checks if the update of the operation is in progress - in summary, when isPending is true the "update button is disabled" .

src:https://react.dev/blog/2024/12/05/react-19

The above image is the improved version, React uses useTransition hook to handle the “isPending” state instead of you manually setting it using useState.

In React 19, when a component suspends (e.g., due to asynchronous action like fetching data), React commits the fallback UI (a loading spinner or message) of the suspense component immediately, without waiting for the whole sibling tree to render.

After committing the fallback, React schedules another renders for the suspended siblings. This allows React to “pre-warm" the lazy request or content in the rest of the tree once the data is available.

This improves user experience by making components more efficient. React shows a loading state while the data is being fetched, reducing the time users spend waiting for components to become visible.

By pre-warming or preparing other components, it ensures the app feels faster and responsive while content is being loaded.

Previously, React suspense would try to render all components sequentially, one at a time. Once all components were rendered it would check to see if any of them were waiting for asynchronous data.

If so, it would throw the component into the fallback state (show a loading message). This meant React had to process all the sub components and initiate their rendering before it could show a loading state which delayed feedback to users.

React has introduced two new APIs in react-dom/static for static site generation: prerender and prerenderToNodeStream.

The APIs improve on the existing renderToString functionby ensuring all required data is fully loaded before generating static HTML. Unlike the traditional server-side rendering APIs, which support streaming contents as it loads.

The prerender APIs will wait for all data to resolve before returning the static HTML stream. This makes static site generation more flexible, and efficient.

Server components have been improved in version 19 allowing you pre-render components on the server during build or on demand, meaning they can be rendered for each request using a web server delivering a dynamic delivery of contents.

React 19 also includes features of React Server Component included from the canary channel which is an early release branch of react that contains new features that are tested before being released. React 19 now makes these features stable and available to be used in production.

React server Actions allow client-side operations to trigger functions executed on the server. By using "use server" directive, functions are called remotely, simplifying server-side logic without requiring a lot of code.

For instance, if you define a function to fetch data from an API, you can define it on the server. When an action is performed such as clicking of a button, React sends the request to the server, retrieves the data and then update the UI. In short, you can handle server-side functions directly from the client side without manually setting up API routes.

React 19 improves error reporting for hydration errors in react-dom. Previously multiple errors in DEV are logged without any information about the mismatch.

src:https://react.dev/blog/2024/12/05/react-19

In the current version React logs a single message with a diff of the mismatch.

src:https://react.dev/blog/2024/12/05/react-19

This means that there is more information about an error, making it easier for debugging.

Instead of <Context.Provider> you can render directly for providing context values which makes your code simpler.

Src: https://react.dev/blog/2024/12/05/react-19

When using refs, you may need to clean up the reference when the component unmounts.

React now supports a clean-up function for ref call-back which simplifies the removal of ref-based elements. When the component unmounts, react will call the clean-up function returned from the ref call-back.

This clean-up function works with DOM refs, refs to class components, and useImperativeHandle.

Src:https://react.dev/blog/2024/12/05/react-19

Typically, meta tags such as