If you want to install ReactJS on Fedora 44 and get a proper development environment running without fighting broken Node versions or permission errors, you are in the right place. Fedora 44, released on April 28, 2026, ships with the Linux 6.14 kernel and GNOME 50, making it one of the most capable Fedora releases for modern web development. This guide walks you through every step from a clean Fedora 44 system to a working React application in your browser. You will understand not just what to type, but exactly why each command matters.

One thing I want to address before we start: if you have seen other tutorials telling you to run npx create-react-app, stop. The React team officially deprecated Create React App (CRA) on February 14, 2025. It breaks with React 19, it has no active maintainers, and it will waste your time. This guide uses Vite, which is the modern, officially recommended way to scaffold React projects.

I have been managing Linux servers and setting up development environments for over a decade. The workflow in this guide is what I actually use when provisioning a fresh Fedora machine for React development.

Prerequisites

Before you start, confirm you have the following in place:

• Fedora 44 installed (Workstation, Server, or KDE Spin all work)
• A non-root user account with sudo privileges — running npm as root is how you create system-wide permission nightmares
• An active internet connection — NVM and Node.js download from external servers
• Access to a terminal (GNOME Terminal, Konsole, or SSH session)
• At least 1.5 GB of free disk space — Node.js plus a React project’s node_modules folder easily exceeds 400 MB
• Basic comfort with the command line — copy and paste will get you through everything here

Confirm you are actually running Fedora 44 before proceeding:

cat /etc/fedora-release

Expected output:

Fedora release 44 (Rawhide)

Step 1: Update Your Fedora 44 System Before Installing Anything

The very first step is a full system update. Many developers skip this and then spend an hour debugging a problem that a package update would have fixed in 30 seconds.

Fedora uses DNF as its package manager. Run both update and upgrade together. The upgrade flag removes obsolete packages alongside updating existing ones, which is the cleaner choice on a fresh install:

sudo dnf update -y && sudo dnf upgrade -y

Why this matters: React projects often pull in native C++ addons through npm. If your system libraries like glibc, openssl, or libstdc++ are stale, those native addon compilations will fail with cryptic errors. An upfront update eliminates that entire class of problem.

After the update finishes, check whether a new kernel was installed:

rpm -q kernel | tail -1

If the kernel version changed, reboot before continuing. Running a mismatched kernel and userspace can cause subtle issues with build tools:

sudo reboot

After rebooting, confirm your system is current:

sudo dnf check-update

If that returns Last metadata expiration check with no package list below it, you are ready to move forward.

Step 2: Install curl and Essential Build Tools

Next, install the tools that the rest of this process depends on. These are not optional, and several tutorials skip them entirely, which causes confusing failures two or three steps later.

sudo dnf install -y curl gcc-c++ make git

Here is what each package does and why you need it:

• curl — The NVM installer script downloads directly from GitHub using curl. Without it, the install command simply will not work
• gcc-c++ — Some npm packages include native C++ code that must compile on your machine during npm install. Without a C++ compiler, those packages fail silently or throw gyp errors
• make — Works alongside gcc as the build coordinator for native addons. It reads Makefile instructions during compilation
• git — Vite and several React-related tools use git internally for template resolution and scaffolding. Some npm install operations also fetch packages directly from git repositories

Verify that curl installed correctly:

curl --version

You should see output like:

curl 8.x.x (x86_64-redhat-linux-gnu) ...

Step 3: Install Node.js on Fedora 44 Using NVM

This is the most important step in the entire guide, and it is the one where most people go wrong.

You have two obvious choices on Fedora: sudo dnf install nodejs or NVM. The dnf route is fast, but it installs Node.js system-wide as root, which means every npm install -g command will require sudo. That creates file permission conflicts, and it locks you to whatever Node.js version Fedora packages. When a project needs a different version, you are stuck.

NVM (Node Version Manager) solves all of that. It installs Node.js per user, not system-wide. You can run multiple Node.js versions side by side and switch between them per project. The official npm documentation explicitly recommends NVM for Linux users to avoid permission issues.

Install NVM

Run the official install script:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.4/install.sh | bash

Why this exact URL: This pulls directly from the official nvm-sh/nvm GitHub repository, version 0.40.4. Always use the official source. Do not use unofficial mirrors or install NVM through npm — that method is outdated and unreliable.

The installer appends export lines to your shell configuration file. To activate NVM in your current terminal session without restarting it, source your profile:

source ~/.bashrc

If you use Zsh:

source ~/.zshrc

Why this source command: Your shell only reads the profile file on startup. Sourcing it manually tells the current session to load the new NVM configuration immediately. Without this, you will see nvm: command not found even though NVM installed successfully.

Verify NVM is working:

nvm --version

Expected output: 0.40.4

Install Node.js LTS

Install the latest Long Term Support release:

nvm install --lts

Why LTS over the latest: Node.js releases alternate between LTS and current versions. LTS versions receive security and bug fixes for 30 months. Current releases are short-lived. For React development, you want stability, so LTS is the right choice every time.

Set it as your default so every new terminal session uses it automatically:

nvm use --lts
nvm alias default 'lts/*'

Verify both Node.js and npm installed correctly:

node -v
npm -v

You should see something like:

v22.15.0
10.9.2

If both version numbers appear, your Node.js environment is solid. Now move on to React.

Step 4: Why You Should Not Use Create React App in 2026

Before scaffolding a project, this context will save you from wasting time with outdated tooling.

If you search for React installation tutorials right now, most of them still reference npx create-react-app my-app. Do not follow those guides. The React team formally deprecated Create React App on February 14, 2025, citing no active maintenance and fundamental incompatibility with React 19. Running it today produces a deprecation warning, and the generated project uses outdated configurations.

The React team’s current official recommendation is:

• Vite for standalone Single Page Applications (SPA)
• Next.js for full-stack apps with server-side rendering
• React Router as a framework layer on top of Vite for more complex SPA routing

This guide uses Vite because it is lightweight, actively maintained, and produces a clean React 19 project with zero legacy baggage. Its dev server cold-start time is under 300ms, compared to webpack-based CRA which could take 10 to 30 seconds on the same machine.

Step 5: Create Your First React App on Fedora 44 Using Vite

Now that Node.js is installed and you understand why Vite is the right tool, build the project.

Scaffold the React Project

npm create vite@latest my-react-app -- --template react

Breaking this command down:

• npm create vite@latest — pulls the latest Vite project creator from npm. The @latest tag ensures you are not running a cached older version
• my-react-app — the name of your project folder. Replace this with whatever name your project needs
• -- --template react — the double dash separates npm arguments from Vite arguments. --template react tells Vite to scaffold a JavaScript React project with JSX support already configured

If you prefer TypeScript, use --template react-ts instead. TypeScript adds compile-time type checking, which catches bugs before runtime and is worth it for any project that will grow beyond a few components.

Expected output:

Scaffolding project in /home/youruser/my-react-app...

Done. Now run:

  cd my-react-app
  npm install
  npm run dev

Install Project Dependencies

Navigate into the project folder and install dependencies:

cd my-react-app
npm install

Why a separate install step: Vite only creates the configuration files and source code structure during scaffolding. It does not download dependencies automatically. Running npm install reads package.json and fetches every listed library from the npm registry into the node_modules/ folder. Without this step, npm run dev will fail immediately with a module-not-found error.

This typically takes 30 to 60 seconds on a standard connection. You will see a progress bar, then a summary like:

added 154 packages, and audited 155 packages in 45s

Start the Development Server

npm run dev

Why npm run dev and not npm start: Vite maps its dev server command to the dev script in package.json. The npm start convention belongs to CRA. Using npm start in a Vite project throws an error because no start script is defined.

Expected output:

  VITE v6.x.x  ready in 312 ms

  ➜  Local:   http://localhost:5173/
  ➜  Network: use --host to expose

Open your browser and go to http://localhost:5173. You should see the Vite and React welcome page with a spinning React logo. Your React development environment on Fedora 44 is now running.

Note on port 5173: Vite uses port 5173 by default, not port 3000 like CRA. If something else is already using port 5173, you will see an error. Jump to the troubleshooting section to fix it.

Step 6: Verify the Installation and Confirm Hot Reload Works

A working dev server is not enough to confirm everything is set up correctly. Verify that Hot Module Replacement (HMR) is working, because this is a core part of the development workflow.

Check that the process is bound to the correct port:

ss -tulnp | grep 5173

Why ss instead of netstat: The netstat command is deprecated on modern Linux systems. ss is its replacement, included in Fedora’s iproute package, and it is faster and more accurate. Get in the habit of using it.

Expected output:

tcp   LISTEN  0  511  127.0.0.1:5173  0.0.0.0:*  users:(("node",pid=XXXXX,...))

Now test HMR. Open src/App.jsx in any text editor:

nano src/App.jsx

Find the text Vite + React and change it to My React App. Save the file. Switch back to your browser. The text should update instantly without a full page reload.

Why HMR matters: Without HMR, every code change forces a complete browser refresh and you lose your component state. With HMR working, Vite patches only the changed module in under 50ms. This keeps your development loop tight and significantly reduces iteration time on complex UI work.

Step 7: Understand Your Project Structure

Knowing what each file does saves you from confusion when something breaks. Here is the layout Vite created:

my-react-app/
├── index.html
├── package.json
├── package-lock.json
├── vite.config.js
├── public/
│   └── vite.svg
└── src/
    ├── App.css
    ├── App.jsx
    ├── assets/
    ├── index.css
    └── main.jsx

Key files explained:

• index.html — The entry point that Vite serves directly. Unlike CRA which buried this file in public/, Vite keeps it at the root. This is intentional because Vite uses it as the module graph entry point
• src/main.jsx — The JavaScript entry that mounts your React root component into the DOM. Everything starts here
• src/App.jsx — Your default root component. This is where your top-level application layout lives
• vite.config.js — Where you configure the dev server port, API proxies, plugins, and build options. You will spend time here as your project grows
• package.json — The project manifest. Lists all dependencies and scripts. Running npm install regenerates node_modules from this file alone
• node_modules/ — Never commit this directory to git. It is auto-generated by npm install and typically contains thousands of files. Your .gitignore already excludes it

Troubleshooting Common Errors When You Configure ReactJS on Fedora 44

Even with a clean setup, things can go wrong. Here are the five most common errors and exactly how to fix them.

Error 1: nvm: command not found after installation

This is the most common issue. NVM installed successfully, but the shell has not loaded it yet.

Fix:

source ~/.bashrc

If that does not work, check whether NVM added its lines to the right file:

grep 'nvm' ~/.bashrc

If nothing shows up, re-run the NVM install script and then source again.

Error 2: EACCES: permission denied during npm install

This means Node.js was installed system-wide via sudo dnf install nodejs instead of NVM. The npm directories are owned by root.

Fix: Switch to NVM entirely. Remove the system Node.js first:

sudo dnf remove nodejs npm -y

Then go back to Step 3 and install via NVM. Permission issues disappear because NVM scopes everything to your home directory.

Error 3: npm ERR! code ENOENT — could not find package.json

You ran npm install from the wrong directory.

Fix:

cd my-react-app
npm install

Always confirm your working directory before running npm commands:

pwd
ls

You need to see package.json in the output of ls before running any npm command.

Error 4: Port 5173 is already in use

You have another Vite process running, or another application occupies that port.

Fix option A — use a different port:

npm run dev -- --port 3000

Fix option B — kill whatever is using port 5173:

fuser -k 5173/tcp
npm run dev

Error 5: make: command not found or gyp ERR! during npm install

A package in your project has native C++ code that needs to compile, but your build tools are missing.

Fix:

sudo dnf install -y gcc-c++ make python3
npm install

Why Python 3 here: node-gyp, the tool that compiles native addons, requires Python 3 to run its build scripts. Fedora 44 usually has Python 3 pre-installed, but it is worth adding to the install command if gyp errors appear.

Optional: Set Up a Custom npm Global Path

If you plan to install global npm tools like ESLint, Prettier, or the Vite CLI globally, confirm that npm’s global prefix points to a user-writable location. With NVM, this is already handled automatically.

Verify your current global prefix:

npm config get prefix

With NVM, this should output something like /home/youruser/.nvm/versions/node/v22.x.x. If it shows /usr or /usr/local, you are still using the system Node.js and need to switch to the NVM-managed version.

To permanently set a user-scoped global path without NVM:

mkdir -p ~/.npm-global
npm config set prefix '~/.npm-global'
echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

[su_box title=”VPS Manage Service Offer” style=”bubbles” box_color=”#000000″ radius=”10″]If you don’t have time to do all of this stuff, or if this is not your area of expertise, we offer a service to do “VPS Manage Service Offer”, starting from $10 (Paypal payment). Please contact us to get the best deal![/su_box]