React Fiber Explained: How React’s Engine Actually Works

React Fiber is the internal engine that powers React’s rendering and reconciliation.

It’s what makes React’s updates smooth, interruptible, and concurrent.

🧩 What is React Fiber?

React Fiber is React’s reconciliation engine — the system that decides what needs to be rendered and when.

Before React 16, React updates were synchronous and blocking. Once rendering started, React couldn’t pause or reprioritize work — large trees could freeze the UI.

Fiber was a complete rewrite that made React’s rendering:

• ⏸ Interruptible
• ⏱ Prioritized
• 🔁 Incremental (chunked)
• 💾 Recoverable (resumable)

In short: Fiber = React’s virtual call stack for async rendering.

🕰️ The Old Model (Before Fiber)

Before Fiber, React used a recursive rendering approach — like this:

function renderTree(node) { node.render(); node.children.forEach(renderTree); } 

• Large trees blocked the main thread.
• The browser couldn’t respond to user input until React finished.
• No way to pause, abort, or prioritize rendering.

⚡ Fiber: The New Architecture

React Fiber breaks the rendering work into small units of work, called fiber nodes.

This lets React:

• Pause between chunks of work.
• Resume later if the browser is busy.
• Assign different priorities to updates.
• Reuse previous work if nothing changed.

So React no longer blocks the main thread — it cooperatively yields to the browser.

🧱 The Fiber Node Structure

Each React component is represented by a Fiber node — a JavaScript object with pointers and metadata.

📘 Think of it as two trees:

• Current tree → what’s on screen.
• Work-in-progress tree → what React is preparing.

When ready, React commits the new tree and swaps references.

🔁 The Two Phases of Rendering

1️⃣ Render Phase (Reconciliation)

• React builds a new Fiber tree (work-in-progress).
• Diffs elements vs previous render.
• Calculates what to change.
• Can be paused, aborted, or restarted.

2️⃣ Commit Phase

• React applies all DOM mutations.
• Runs effects (useEffect, componentDidMount, etc.).
• This phase is synchronous — React cannot pause it.

🧠 Render phase = “thinking”

⚡ Commit phase = “doing”

🧠 Scheduling and Priority

Fiber works with React’s scheduler, which assigns priority to updates:

React checks between chunks:

“Browser, do you have time? If not, I’ll yield and resume later.”

This is what enables Concurrent Rendering.

⚙️ Concurrent React (Fiber + Scheduler)

With Concurrent Mode (React 18+), Fiber can prepare multiple UI versions in parallel.

React can:

• Prepare new UI while showing the old one.
• Cancel or pause updates mid-render.
• Prioritize urgent updates (like typing).

Example:

const [isPending, startTransition] = useTransition(); function handleInput(e) { const value = e.target.value; startTransition(() => setFilter(value)); // low priority render } 

React keeps input responsive because it renders background updates at a lower priority.

🧬 Visualization

 [Root Fiber] │ ┌─────┴─────┐ [App] [Modal] │ │ [Header] [Button] 

Each node is a Fiber linked by child, sibling, and return.

React walks this structure instead of the JS call stack — so it can pause or resume at any point.

💡 Key Benefits of Fiber

✅ Interruptible, non-blocking rendering

✅ Priority scheduling for updates

✅ Recoverable rendering (pause/resume)

✅ Enables Suspense, useTransition, and concurrent features

✅ Better error isolation and performance profiling

🧠 Why It Matters (Even if You Don’t Use It Directly)

You don’t write Fiber code yourself, but understanding it helps you reason about:

• Why React sometimes delays updates.
• Why “render” can happen multiple times before commit.
• How useTransition and Suspense work.
• Why strict mode double-invokes renders (simulates concurrency).

✅ Summary

✨ React Fiber turned React from a recursive renderer into an asynchronous virtual machine for UI.

It’s the reason React 18 feels fast, smooth, and intelligent.

Originally published on Bitlyst.