How to Install NVIDIA RTX 50 Series Drivers on Ubuntu

Say you just dropped a small fortune on an NVIDIA RTX 5080 or 5090, booted into Ubuntu, and you’re ready to get to work or hit 240 FPS in Cyberpunk via Proton. Whether you’re rendering in Blender, generating images with Stable Diffusion, or just seeing how hard your GPU can flex, you need working NVIDIA drivers. Not partial support. Not “coming soon” from a repo. You need them right now.

So you try the obvious:

nvidia-smi

Ubuntu responds with:

Command 'nvidia-smi' not found, but can be installed with:
  sudo apt install nvidia-utils-525
  ...
  sudo apt install nvidia-utils-570-server

At first glance, it looks like help is just an install away. But those drivers won’t do the job. Most of them are outdated and do not include support for the RTX 50 series (which requires version 570 at a minimum). Some, like the 570-server package, are designed for datacenter GPUs. They are stable and long-lived, but built with a different set of hardware targets in mind. These server drivers often leave out support for consumer desktop cards entirely. Even if they install, you will likely end up with no display output, no hardware acceleration, and no access to CUDA or Vulkan.

And the version you actually need — 570.144 — is not available in any Ubuntu repository at the time of writing.

This guide walks you through a method that does work. It is not the official way, it’s not the polished one-click install, and it definitely is not recommended for new users. But it will get your RTX 50 series working on Ubuntu today. You will be building kernel modules from source, installing drivers manually, and managing your system outside of the package manager. If that sounds like your kind of challenge, you’re in the right place.

The Plan

• Remove any existing NVIDIA drivers and configuration files.
• Build the open-source NVIDIA kernel modules from source.
• Install the official NVIDIA driver from their website using the .run installer.
• Reboot, run nvidia-smi, and confirm that everything is working.

This method gives you full driver support for the latest hardware before Ubuntu or NVIDIA officially delivers it through the repos. Let’s get into it.

Step 1: Remove existing NVIDIA drivers.

Before doing anything else, wipe your system clean of old or partial NVIDIA installs. Conflicts between packages are the number one reason manual installs fail.

sudo apt-get remove --purge '^nvidia-.*'
sudo apt-get remove --purge nvidia*
sudo apt-get autoremove --purge
sudo apt-get autoclean

This removes installed driver packages, dependencies, and cleans up orphaned packages and cached installs.

Check your work:

dpkg -l | grep nvidia
lsmod | grep nvidia

If you see output, you probably missed something.

Step 2: Clear out old configs.

Drivers leave behind configs in places like /etc and CUDA installs in /usr/local. These can silently interfere with fresh installs if left behind.

sudo find /etc -name '*nvidia*' -exec rm -rf {} +
sudo rm -rf /usr/local/cuda*

Step 3: Reboot into a clean state.

sudo reboot

After rebooting, verify no NVIDIA modules are loaded:

lsmod | grep nvidia

You want an empty result here. If you see anything NVIDIA-related, back up and remove it.

Step 4: Clone and build the open GPU kernel modules.

NVIDIA now publishes open-source kernel modules for Linux. This is what we’ll use to support RTX 50 cards — but we need to build it ourselves.

git clone https://github.com/NVIDIA/open-gpu-kernel-modules.git
cd open-gpu-kernel-modules
make modules -j$(nproc)
sudo make modules_install -j$(nproc)

This compiles and installs the kernel-level glue that allows the user-space driver to interact with your hardware.

Step 5: Update your initramfs.

To make sure the new modules load on boot:

sudo update-initramfs -u

This step is often skipped and then forgotten, until rebooting into a broken system.

Step 6: Install required dependencies.

You don’t need a huge stack of packages. Install only what’s needed to support OpenGL and 32-bit apps (for Steam, etc.).

sudo apt install libegl1 libglvnd-dev libgl1:i386

Avoid mesa-glx and similar packages — they can conflict with NVIDIA’s OpenGL stack.

Step 7: Download the official driver.

Go to NVIDIA’s driver page:

https://www.nvidia.com/en-us/drivers/

Choose your RTX 5080/5090, select Linux 64-bit, and download the .run file. You’ll need version 570.144.

Make it executable:

chmod +x NVIDIA-Linux-x86_64-570.144.run

Step 8: Shut down your graphical session.

You can’t install NVIDIA drivers while the display manager is running. Switch to a TTY with Ctrl+Alt+F3 or SSH in, then stop the display manager.

sudo systemctl isolate multi-user.target
sudo systemctl stop gdm

Replace gdm with lightdm or whatever you use if needed.

Step 9: Run the installer.

Now install the user-space components of the driver — but skip its kernel modules, since we already installed our own.

sudo ./NVIDIA-Linux-x86_64-570.144.run --no-kernel-modules

What to do when prompted:

• Select MIT/GPL open-source kernel modules
• Say yes to 32-bit support if you plan on using apps like Steam or Wine
• Allow it to write X configs if you use X11

Step 10: Reboot again.

sudo reboot

Step 11: Fire up nvidia-smi and bask in your success.

This is the moment of truth. You’ve rebooted, the system is up, and now it’s time to see if your GPU is finally awake.

Open your terminal and run:

nvidia-smi

If everything went smoothly, you’ll be greeted by the classic NVIDIA stats table. This is your GPU reporting for duty — complete with driver version, temperature, memory usage, power draw, and more.

It should look something like this:

+-----------------------------------------------------------------------------+
| NVIDIA-SMI 570.144       Driver Version: 570.144       CUDA Version: 12.8   |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  NVIDIA GeForce RTX 5080  Off  | 00000000:01:00.0 On | N/A              |
|  0%   34C    P8    23W / 360W |    560MiB / 16303MiB  |     0%      Default |
+-----------------------------------------------------------------------------+

If you see your GPU listed, congratulations. You’ve just installed the NVIDIA driver manually, built your own kernel module, and made an RTX 50 card work on Linux before most people even knew it was possible. You now have full control over your GPU, your system, and your performance.

So, go run some benchmarks. Launch a game. Load a 4K texture pack. You’ve earned it.

If you don’t see your GPU, something earlier in the process probably needs a second look. Check the kernel module build, make sure you used the correct driver version, and confirm that the display manager was stopped during installation.

Final Notes

This isn’t the install process NVIDIA or Ubuntu wants you to go through, but right now, it’s the only way to get an RTX 50 series working properly on Ubuntu. While we Arch users already have nvidia-open-dkms sitting in the extra repo, Ubuntu users still need to take the manual route to get everything working correctly.

By building the open GPU kernel modules yourself and combining them with the matching user-space driver from NVIDIA’s official .run file, you’ve bypassed the limitations of Ubuntu’s outdated packages and forced your GPU into action.

Here’s why this works:

• You avoided broken or incomplete drivers from Ubuntu’s repo
• You compiled and installed kernel modules that actually support your card
• You installed a matching user-space stack directly from NVIDIA
• You selected the MIT/GPL open kernel module, giving you better integration and transparency
• You kept your system clean, free from conflicting packages or bad configs

Here’s what you give up in return:

• No DKMS — kernel updates will require you to manually rebuild and reinstall the module
• No package manager support — everything is maintained manually, including future upgrades
• Slight fragility — future Ubuntu kernel updates might break things unless you rebuild in sync

But what you gain is worth it:

• You get full RTX 50 support today. No guessing. No waiting.
• You understand how the driver stack works, which helps when things break or need tuning
• You have more flexibility for custom setups, dual GPUs, custom kernels, or bleeding-edge configs

If you’re the kind of person who likes control over your hardware and isn’t afraid of a terminal, this method is for you. You’re now part of the small but mighty group of users running the latest GPU hardware on Ubuntu before the support is mainstream.

Should you check the Ubuntu package repositories in a month or two to see if official support has landed? Yes. Should you expect to repeat this after every kernel update? Also yes, unless you build out DKMS support yourself, which is a topic for another post.

Until then, fire up your favorite game, launch Blender, or just enjoy seeing that sweet nvidia-smi output. Your GPU is finally doing what it was built for.