DEV Community: kavin.dev

Understanding React Rendering Flow

kavin.dev — Wed, 27 May 2026 03:20:07 +0000

⚛️

If you're learning React, one of the most important concepts is understanding what happens internally when a component renders.

At first, React can feel magical.

You write JSX… and somehow the UI updates automatically.

But behind the scenes, React follows a very systematic rendering flow.

Let’s break it down step-by-step 👇

React Rendering Flow

Developer Writes Components
        ↓
Components Return JSX
        ↓
JSX Converts into React Elements
        ↓
React Creates Virtual DOM
        ↓
React Compares Old & New Virtual DOM
        ↓
Updates Only Changed Parts in Real DOM
        ↓
Browser Displays Updated UI

1 Developer Creates Components

In React, UI is built using components.

A component is simply a JavaScript function that returns UI.

Example:

function Welcome() {
  return <h1>Hello Captain</h1>;
}

Components make applications:

Reusable
Organized
Scalable
Easier to maintain

2 Components Return JSX

Inside components, we usually return JSX.

Example:

return <h1>Hello</h1>;

JSX looks like HTML, but it’s actually JavaScript syntax.

Browsers cannot understand JSX directly.

So React transforms it internally before rendering.

3 JSX Converts into React Elements

React converts JSX into plain JavaScript objects called React Elements.

Example:

<h1>Hello</h1>

becomes something like:

{
  type: "h1",
  props: {
    children: "Hello"
  }
}

These objects describe what the UI should look like.

React Element Structure

A React Element mainly contains:

Property	Purpose
`type`	HTML tag or component
`props`	Properties/data
`children`	Nested content
`key`	Unique ID for lists

4 React Creates the Virtual DOM

Using React Elements, React builds a Virtual DOM.

What is Virtual DOM?

A lightweight JavaScript representation of the Real DOM stored in memory.

Virtual DOM = Fast in-memory copy of UI

Instead of directly manipulating the browser DOM every time something changes, React first updates the Virtual DOM.

This makes rendering much faster and more efficient.

5 React Performs Diffing (Reconciliation)

Whenever state or props change:

React creates a new Virtual DOM.

Then React compares:

Old Virtual DOM
vs
New Virtual DOM

This comparison process is called:

Diffing / Reconciliation

React tries to identify:

"What exactly changed?"

instead of rebuilding the entire page.

6 React Updates the Real DOM

After finding the differences:

React updates only the changed parts in the Real DOM.

This selective updating is why React apps feel fast and responsive.

Benefits:

Better performance
Efficient updates
Smooth UI interactions

7 Browser Paints the Updated UI

Finally, the browser renders the updated UI on the screen.

Important point:

React manages updates,
but the browser actually displays the UI.

Why React Is Fast

React improves performance because it:

Uses Virtual DOM
Updates only changed elements
Avoids unnecessary DOM operations
Efficiently re-renders components

Final Thoughts

Understanding React’s rendering flow helps you:

Write better components
Optimize performance
Debug rendering issues
Understand hooks and state updates more deeply

Once you understand this internal workflow, React becomes much easier to reason about.

What helped you understand React rendering for the first time?

Drop your thoughts below

How to Install NVIDIA Drivers on Fedora 44

kavin.dev — Thu, 07 May 2026 03:53:34 +0000

This guide covers the RPM Fusion method — the recommended and most maintainable way to install NVIDIA proprietary drivers on Fedora. No manual .run installers, no broken dnf states.

Prerequisites

Before you start, make sure your system is fully up to date

sudo dnf upgrade --refresh

Reboot if there were kernel updates:

sudo reboot

Step 1 — Enable RPM Fusion Repositories

Fedora doesn't ship proprietary drivers by default. RPM Fusion fills that gap. You need both the free and nonfree repos:

sudo dnf install \
  https://mirrors.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm \
  https://mirrors.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm

## Step 2 — Install the NVIDIA Driver

Install the akmod-nvidia package. The akmod (automatic kernel module) system automatically rebuilds the driver whenever your kernel updates — saving you from the classic "driver broke after update" headache.

sudo dnf install akmod-nvidia

*Optional *

If you need CUDA support (for ML, video encoding, etc.), add this too:

sudo dnf install xorg-x11-drv-nvidia-cuda

Step 3 — Wait for the Kernel Module to Build

This is the step most guides skip over — and it's important.

After installation, the kernel module needs to compile. Do not reboot immediately. Wait for the build to complete:

sudo akmods --force
sudo dracut --force

You can verify the module is built by running:

modinfo -F version nvidia

You should see a version number like 570.xx.xx in the output. If you see an error instead, do not reboot yet — something went wrong.

Step 4 — Reboot

Once the module is confirmed built:

sudo reboot

After rebooting, verify the driver is active:

nvidia-smi

You should see your GPU listed with the driver version and memory usage.

Wrapping Up

The RPM Fusion + akmod-nvidia approach is the most reliable way to run NVIDIA drivers on Fedora. It survives kernel updates, works across Fedora versions, and doesn't require babysitting .run scripts.

Got questions or a specific GPU edge case? Drop them in the comments below. 🐧

How To Install ROG Control Center on Fedora 44,43 Based Distros (asusctl Guide)

kavin.dev — Fri, 01 May 2026 15:08:43 +0000

If you're running an Asus ROG/TUF laptop on Fedora 42,43,44, you've probably noticed there's no official Armoury Crate for Linux. But don't worry, the open source asusctl. suite has you covered with fan control, performance profiles, GPU switching, and RGB lighting.

Step 1: Enable the COPR Repository

sudo dnf copr enable lukenukem/asus-linux
sudo dnf update --refresh

Step 2: Install asusctl and supergfxctl

sudo dnf install asusctl supergfxctl rog-control-center
sudo dnf update --refresh

Step 3: Enable Services

sudo systemctl daemon-reload
sudo systemctl enable --now asusd.service
sudo systemctl enable supergfxd.service

step 4: Verify Kernel Modules

lsmod | grep asusYou should see modules like asus_nb_wmi, asus_armoury, asus_wmi, and hid_asus listed. ## Step 5: Launch ROG Control Centerrog-control-center`

Or find it in your application menu.

Troubleshooting

asusd.service fails to start?

Run it manually to see the raw error:
sudo asusd

"Asus kernel isn't loaded" warning?

Ignore it — it's safe and cosmetic.

Profile switching not working?

asusctl profile --list
asusctl profile -P Balanced

What You Can Control

Fan Curves
Performance Profiles (silent, Balanced, Turbo)
GPU switching (Integrated / Hybrid / Dedicated)
Keyboard RGB lighting

Conclusion

No Windows VM needed anymore! The asusctl project is actively
maintained and gets better with every update.

Useful Links: