Course contentsShow
← React
Lesson 415 of 2,39612. Rendering and BatchingFree lesson

Why Renders Are Usually Fast

Modern React is optimized for frequent renders—most components render in microseconds unless doing expensive work.

Why Renders Are Usually Fast

You'll learn: Why React can afford to re-render frequently without performance problems in most applications.

The Speed of Modern React

When you first learn that changing state triggers a re-render, it's natural to worry: "Won't my app get slow if components keep re-rendering?"

The answer is usually no—because React's rendering process is incredibly fast.

What Makes Renders Fast?

1. Render Just Means Running JavaScript

Remember from previous lessons that the render phase is just React calling your component function and comparing the result. No DOM updates happen yet. Modern JavaScript engines can execute thousands of function calls per second.

function Counter({ count }) {
  return <div>{count}</div>; // Just creating a JS object
}

This function runs in microseconds—faster than you can blink.

2. Virtual DOM Comparison is Lightweight

React compares old and new virtual DOM trees using optimized diffing algorithms (Fiber). Comparing JavaScript objects is much faster than touching the real DOM.

3. The Commit Phase is Selective

Even if 100 components render, React only updates the actual DOM nodes that changed. If nothing changed, the commit phase does almost no work.

4. Most Components Are Simple

The average component just reads some props, maybe does a simple calculation, and returns JSX. No expensive operations.

When Renders Do Get Slow

Renders only become a problem when you do expensive work:

  • Heavy calculations inside the component
  • Rendering thousands of list items
  • Deep object comparisons

For normal apps with dozens or hundreds of components? React handles it effortlessly.

Key Takeaway: Modern React is optimized for frequent renders—most components execute in microseconds, so you can re-render liberally without worrying about performance until you actually measure a problem.