A step by step guide on React upgrade process to V18

June 16, 2022
upgrade to react 18

Are you one of the React developers who are looking to upgrade your project to React 18? Or you could be the CTO of a digital products company that’s looking for a React JS upgrade guide?

If so, you are at the right place.

React is one of the most preferred front-end libraries among web and app developers these days. A React js developer often remains in excessive demand due to React’s powerful capabilities.

Since we too have to work with this interesting JavaScript technology, we decided to talk about its recently released version. Our team has created this step-by-step guide, in which we have discussed React upgrade process to the latest version 18.

We have also discussed other related things, such as:-

and answered a few more public queries. So, are you ready to get started? Here we go then.

React 18 – Is it what we expected?

Released in March 2022, React 18 is the brand new version of React JS front-end library. This release focuses on improving the performance and updating the rendering engine.

React 18 sets the foundation for concurrent rendering APIs that future React features will build on. This new version brings multiple new features to advantage your website which we will be discussing ahead in this guide.

It also brought some unique features such as useId, useTransition, useDeferredValue, useSyncExternalStore, and useInsertionEffect.

Steps to upgrade from React 17 to React 18 | React Upgrade Process

It’s crucial to start by understanding that new concurrent rendering is only enabled in React 18 applications that make use of the app’s new capabilities. In this section, we’ll walk you through upgrading to React 18.

You may gradually adopt concurrent rendering in your existing applications since it’s a breaking change that makes viewing interruptible, and the consequences are that components operate somewhat differently.

When you upgrade React 18 and shift to concurrent rendering, most of your components will still work; however, some of them may not and you’ll have to make additional changes that should be simple in any case.

Without causing any issues with the existing code, your primary upgrading strategy should be to get your application working on React 18 without breaking it. Then, at your own pace, you may begin adding concurrent features gradually.

The objective of this React upgrade process is to ensure that your code continues to operate without issue after you’ve installed React 18. It’s also essential that your application be compatible with this new version, which is the first purpose of this strategy.

After that, you may build on it at your own pace, adding new features one by one as needed. It won’t catch everything, but it does an excellent job of avoiding the most frequent blunders, which is a positive thing.

Open a new command-line interface and navigate to your React 17 project. Then, continue with these instructions:-

Updating from React 17 to 18 can be done in two simple steps:-

Step 1: Install the latest version

Step 2: Go to your root entry file (typically index.js) and change the react-dom import from

Also, replace the ReactDOM.render() method in that same file.

must be changed to:

That’s all there is to it! There are no more changes to be made in this section. You will not have to relearn anything because React 18 does not change the way you write React code.

Important things you should know when upgrading to React 18

Note for React Native developers: If you are looking for a React Native upgrade guide, you should know that React Native will soon include a future version of React Native 18. As React 18 will require an improvised Native Architecture, it must integrate the latest features we’ve discussed ahead.

1) Updates to client rendering APIs

React 18 introduces a new root API that gives improved ergonomics for managing roots. The new root API also allows you to opt into concurrent capabilities, as well as the new concurrent renderer.

The unmountComponentAtNode has also been changed to root.unmount:

They have also removed the callback from render, as it usually provides an incorrect result when utilized with Suspense:

Note: The old render callback API is not a one-to-one replacement; it is dependent on your application’s needs.

Lastly, if your app uses server-side rendering with hydration, upgrade hydrate to hydrateRoot:

2) Updates to Server Rendering APIs

In this release, creators are improving the react-dom/server APIs to fully support Suspense on the server and Streaming SSR. The old Node streaming API is being deprecated as part of these changes, which do not allow for incremental Suspense streaming on the server. It is a good solution for the modern edge runtime environments.

Using this API will now notify you with the following:-

  • renderToNodeStream: Deprecated ⛔️️

Instead, to stream Node environments, you may use:-

  • renderToPipeableStream: New ✨

Developers have also introduced a new API to support streaming SSR with Suspense for modern age runtime environments, like Cloudflare Workers and Deno:-

  • renderToReadableStream: New ✨

The following APIs will continue to work. But, with a limited support for Suspense:-

  • renderToString: Limited ⚠️
  • renderToStaticMarkup: Limited ⚠️

Also, this API will continue to work for rendering e-mails.

  • renderToStaticNodeStream

3) New APIs for libraries

In the React 18 Working Group, developers collaborated with library maintainers to establish new APIs that would be required for concurrent rendering in situations such as styles and external stores. Some libraries may need to switch to one of the following APIs in order to support React 18:

  • The new SyncExternalStore hook allows external stores to support concurrent reads by forcing updates to the store to be synchronous. This new API is suggested for any library that uses state from an external source.
  • The CSS-in-JS library InnerWorkings provides a new hook called the InsertionEffect that allows CSS-in-JS libraries to address rendering performance issues. We don’t expect you to ever use this unless you’ve already built a CSS-in-JS library. This hook will execute after the DOM has been changed, but before the new layout is read. This resolves an issue that has existed in React 17 and below, when React gives up control of the browser during concurrent rendering, allowing it to recalculate layout.

React 18 also adds new functions for concurrent rendering, including startTransition, useDeferredValue, and useId.

4) Updates to TypeScript definations

If you’re working on a React project, make sure your current @types/react and @types/react-dom dependencies are up to date. The new kinds are safer and more thorough than the old ones, identifying issues that had previously gone unnoticed by the type checker. The most apparent change is that, in order to define props, you must now include the children property. For example:-

5) Automatic Batching

By reducing the overhead of batching, React 18 improves performance out of the box. Batching is a technique in which React combines many state changes into a single re-render for improved efficiency. In React 18, developers batched only updates inside React events handlers. By default, updates in promises, setTimeout, native event handlers, or any other event were not batched in React:

All changes in React 18, regardless of where they originate from, will be batched automatically. This means that events inside of timeouts, promises, native event handlers, and other similar mechanisms are all treated similarly:

This is a breaking change, but we expect it to result in less rendering work and therefore improved performance in your apps. You may use flushSync to opt-out of automatic batching:

6) Updates to Strict Mode

In the future, the developers hope to add a functionality that allows React to modify and remove parts of the user interface while keeping track of their state. When a person leaves a screen and returns to it, for example, React should be able to show the previous screen immediately. React would unmount and remount trees using the same component state, as it did before.

This feature, on the other hand, will improve React’s performance out of the box. However, components must be resilient to the effects of being mounted and destroyed multiple times in order for this pattern to work correctly. The majority of effects are unaffected by this technique because they assume that they are only deployed or removed once.

React 18 adds a development-only check, Strict Mode, to help identify and correct any potential problems. This new check will unmount and reattach every component whenever a component is first mounted, restoring the previous state on the second mount.

React would mount the component and create the effects before this change:

React 18 will simulate unmounting and remounting the component in development mode with Strict Mode:

7) Configuring the Testing Environment

You may see the following warning in your test console if you are using createRoot for the first time:

The current testing environment is not configured to support act(…)

To resolve this, set globalThis.IS_REACT_ACT_ENVIRONMENT to true before running your test:

The purpose of the flag is to notify React that the program is being run in a test-like environment. If you forget to wrap an update with act, React will log useful warnings.

To tell React that act isn’t required, you may also set the flag to false. This may be beneficial for end-to-end tests that imitate a complete browser environment.

8) Dropping Support for Internet Explorer

React is no longer compatible with Internet Explorer after this release. The support will be dropped after June 15, 2022. Developers are making this switch now because React 18 introduces new features that aren’t feasible to polyfill in Internet Explorer.

ReactJS is an efficient JavaScript framework often used to create applications. If you are a React development agency that still prefers using Internet Explorer in their projects, we recommend you stay with React 17.

9) Other breaking changes you should know

  • New JS Environment Requirements: React now depends on modern browsers features including Promise, Symbol, and Object.assign. If you support older browsers and devices such as Internet Explorer which do not provide modern browser features natively or have non-compliant implementations, consider including a global polyfill in your bundled application.
  • Consistent useEffect timing: If the update is triggered during a discrete user input event such as a click or a key down occurrence, React now always synchronously flushes effect functions. Previously, the behavior was unpredictable and inconsistent.
  • Suspense trees are always consistent: React won’t add a component to the tree in an unfinished state or trigger its effects if it suspends before it’s completely added. Instead, React will completely remove the new tree and wait for the asynchronous operation to finish before attempting again. React will render the retry attempt in parallel with other things while keeping the browser from being blocked.
  • Stricter hydration errors: Mismatches between hydration and text content are now treated as errors rather than warnings. React will no longer try to “patch up” individual nodes by inserting or deleting a node on the client in an attempt to match the server markup. In fact, it will revert to client rendering up to the closest <Suspense> boundary in the tree. This ensures the hydrated tree is consistent and any potential privacy or security flaws caused by hydration mismatches must be avoided.
  • Layout Effects with Suspense: When a tree re-suspends and resumes falling, React will now remove layout effects before resuming them when the content within the barrier is displayed again. This solves an issue that prevented component libraries from accurately measuring layouts using Suspense.

Benefits of upgrading to React 18

React 18 introduces some notable features. These will benefit developers by making the development process much more manageable. Let’s have a look:-


This feature is intended to improve the performance. When working with dynamic and large datasets, you can use it in components with various children to boost rendering time. It also helps in scenarios when you require dynamic behavior implementation with external data or server callback.


It’s beneficial when you need to execute imperative tasks in your UI because it eliminates the requirement for a class component. React uses useCallback in its code and recommends that any additional callbacks be wrapped with the same function to avoid unnecessary re-renders.


Instead of writing memoization on your own, it includes this functionality as part of its package but with conditions that the function is only safe to use in effects and is not permitted to reference anything external (outside the component). This feature will come in handy to developers who use hooks since it can enhance performance without requiring a complete makeover.

Use createRef()

createRef is one of the most simplified and adaptable methods allowing you to pass along any value you like. You may even modify the appearance of your app by passing data from one component to another, and you don’t have to be concerned about how the information will be used because props are unrestricted


The effects hook is a way to add stateful logic using lifecycle methods that weren’t intended to be used outside of classes or higher-order components (HOCs). It does not create error boundaries, but React itself does so instead of the effect.

Answered Some Frequently Asked Questions

How could you upgrade to the latest version of React, if you are a non-technical person?

Upgrading your web application or website to React 18 framework could be a complicated process if you are unknown of its technical know-how. In such a case, it is advisable to consult with experienced Reactjs developers.

Agencies have developers who are working in and out on ReactJS. They will be able to understand your project more clearly and perform a safe upgrade process without any data, privacy, or performance loss.

How to clear textbox in react js?

To clear an input field in React JS, you need to set the value of the Value attribute to an empty string. Here’s how

You need to create the Val state with the useState hook. Then, set the Value prop of the input to the Val state. Next, set the onClick prop of the button to a function that calls setVal to an empty string.

Thereafter, when you type something and click Reset, you will see the input box empty.

Is building modern web applications with react.js a smart choice?

Yes! Web application development with ReactJS would help your developer in several ways. First of all, React JS is easy to learn if your team has some beginners. It saves development time by allowing code reusability. React.js is a single-way data flow technology that further ensures code stabilization. Besides, it promotes super-fast rendering and streamlined testing, having its Virtual DOM for faster processing.

Our Latest Updates