Before React 18, complex rendering during user interactions such as typing or clicking often caused performance issues. Because React’s rendering was synchronous and blocking, heavy updates could freeze the UI, making input laggy and clicks feel unresponsive.

With React 18, Concurrent React introduces a new rendering model where updates are interruptible, prioritized, and non-blocking.

Rendering is broken down into small units of work that React can pause, resume, or cancel if something more urgent happens, like user input.

**Key features:**

- **Interruptible rendering**: React 18 can pause ongoing work to quickly respond to user actions such as clicks or typing.
- **Cancelable and restartable rendering**: If new data arrives while React is rendering, it can discard the current work and restart with the latest updates.
- **Prioritization**: Urgent updates (like typing or clicking) are prioritized over less critical ones (like data fetching).


**How It Works Under the Hood**

React still uses the Virtual DOM, diffing, and reconciliation, but:
- rendering is split into chunks
- these chunks can be paused or interrupted
- only after rendering is complete, React commits the changes to the DOM (this is still synchronous)

**APIs and Hooks for Enabling Concurrent Features**

**1.Concurrent Rendering Root API**
The **createRoot()** method enables concurrent rendering in React by allowing React to batch state updates more efficiently and prepare the app for concurrent behavior. However, it doesn’t activate any specific concurrent features on its own. To actually take advantage of concurrent capabilities, you need to use additional APIs like the **Suspense** component, **useTransition**, or **useDeferredValue** hooks.

```jsx
import { createRoot } from 'react-dom/client';

const root = createRoot(document.getElementById('root'));
root.render(<App />);

```

**2.Suspense**
Lets you **pause rendering** while waiting for async data or lazy-loaded components. It shows a fallback UI during the wait.

```jsx
<Suspense fallback={<Loading />}>
  <LazyComponent />
</Suspense>
```


**3.useTransition()**

**useTransition** lets you mark some state updates as “low priority” or “non-urgent”  to defer heavy UI tasks, keeping the interface responsive for urgent actions like typing or clicking.

```jsx
const [isPending, startTransition] = useTransition();

const handleChange = (newValue) => {
  startTransition(() => {
    setSearchQuery(newValue); // This update is low priority
  });
};
```

**4.useDeferredValue()**
Allows you to defer a value until the UI has finished more urgent updates. Ideal for delaying expensive computations or rendering based on changing input.

```jsx
 const deferredQuery = useDeferredValue(query);
```

How Concurrent React Improves UI Responsiveness

Concurrent React introduces a new, interruptible rendering model that makes UIs more responsive