How to Boot Older Kernel From GRUB Menu 2026?

You updated your Linux system, rebooted, and now your Wi-Fi adapter is gone, your audio only shows “Dummy Output,” or your screen flickers with graphical artifacts. Sound familiar? A new kernel update breaking hardware is one of the most frustrating experiences for Linux users, but the fix is surprisingly simple if you know how to boot into an older kernel from the GRUB menu.

Our team has helped hundreds of users recover from broken kernel updates across Ubuntu, Fedora, Debian, and Arch. The good news is that Linux keeps your previous kernels installed by default, so rolling back rarely requires a fresh install or a Live USB.

In this guide, I will walk you through every method to boot into an older kernel when a new one breaks hardware. You will learn the quick GRUB menu method, how to make that kernel the permanent default, how to diagnose kernel panics, and how to prevent the problem from happening again on future updates.

Why New Kernels Sometimes Break Hardware?

Kernel updates are supposed to improve performance, patch security holes, and add hardware support. But each new kernel version also changes how the system interacts with hardware drivers, kernel modules, and firmware. When something in that chain changes, hardware that worked perfectly yesterday can stop working today.

The most common culprits are proprietary graphics drivers (especially NVIDIA), Wi-Fi adapters that rely on out-of-tree modules, and audio subsystems tied to specific kernel module versions. A kernel ABI change or a removed deprecated feature can break these drivers without warning.

Here is the critical thing to understand: Linux distributions keep multiple kernel versions installed simultaneously. When you install a kernel update, the old kernel is not removed. It stays on your system alongside the new one, and GRUB keeps an entry for it in the boot menu. That design is your safety net.

So when a new kernel breaks your hardware, you do not need to reinstall your system. You just need to tell GRUB to load the previous kernel version instead.

How to Boot Into an Older Kernel From the GRUB Menu?

This is the fastest method and works on virtually every Linux distribution. The entire process takes under two minutes once you know which keys to press.

Step 1: Reboot Your Computer

Save your work and reboot normally. If your system is stuck on a black screen after the broken kernel loads, force a restart by holding the power button for 5-10 seconds.

Step 2: Access the GRUB Menu

As soon as the BIOS/UEFI POST screen disappears, press and hold the correct key for your system:

For BIOS (Legacy) systems: Press and hold the Shift key immediately after the manufacturer logo appears.

For UEFI systems: Tap the Esc key repeatedly, about once per second, starting right after the manufacturer logo.

This is the most common stumbling block. If GRUB does not appear, you pressed the key too early (before POST finished), too late (GRUB already timed out), or used the wrong key for your firmware type. Forum users on r/Ubuntu and AskUbuntu report that timing is the number one issue. Try rebooting again and adjust your timing slightly.

On some distributions like Pop!_OS, GRUB may not be installed at all. Pop!_OS uses systemd-boot instead. In that case, press Space during boot to bring up the boot menu, then select the older kernel.

Step 3: Navigate to Advanced Options

Once the GRUB menu appears, use your arrow keys to highlight “Advanced options for [Your Distro Name]” and press Enter. This expands a submenu showing all installed kernel versions.

You will see entries like “Ubuntu, with Linux 6.8.0-45-generic” and below it “Ubuntu, with Linux 6.8.0-45-generic (recovery mode).” Each installed kernel version gets its own pair of entries (normal boot and recovery mode).

Step 4: Select the Older Kernel

Use the arrow keys to highlight the previous kernel version. Look for a version number lower than the one that caused your problem. For example, if kernel 6.8.0-45 broke your system, select 6.8.0-44 or whichever earlier version is listed.

Press Enter to boot into that kernel.

Step 5: Verify You Are Running the Older Kernel

Once your system boots and you log in, open a terminal and run:

uname -r

The output should show the older kernel version you just selected, not the problematic one. If you see the old version, congratulations. Your hardware should be working again.

This temporary fix reverts every time you reboot, because GRUB still defaults to the newest kernel. The next section shows you how to make this change permanent.

How to Change Default Boot Kernel in GRUB Permanently

Selecting an older kernel from the GRUB menu works for one boot. To make that kernel load automatically on every restart, you need to modify the GRUB configuration.

The Correct File to Edit

Never edit /boot/grub/grub.cfg directly. That file is auto-generated and will be overwritten the next time you run update-grub or install a kernel update. Instead, edit the source configuration file:

sudo nano /etc/default/grub

Setting GRUB_DEFAULT for Submenu Entries

Find the line that reads GRUB_DEFAULT=0. On Ubuntu and Debian, older kernels live inside the “Advanced options” submenu, so you need to reference them using submenu path notation.

Change the line to:

GRUB_DEFAULT="Advanced options for Ubuntu>Ubuntu, with Linux 6.8.0-44-generic"

The exact text between the angle brackets must match the submenu title in your GRUB menu. The part after the > must match the kernel entry name exactly, including spaces and capitalization.

An alternative approach is using index-based notation. If your GRUB menu counts from 0, the “Advanced options” entry is typically at index 1 (or 2 depending on your setup). The submenu entries are also zero-indexed. So GRUB_DEFAULT="1>2" means “second top-level entry, third submenu entry.” This method is less readable but avoids name-matching issues.

Apply the Changes

After saving the file, regenerate the GRUB configuration:

sudo update-grub

On RHEL, Fedora, and CentOS, the command is different:

sudo grub2-mkconfig -o /boot/grub2/grub.cfg

For UEFI systems on RHEL/Fedora, the output path may be /boot/efi/EFI/fedora/grub.cfg or /boot/grub2/grub.cfg depending on your version. Check your distribution documentation if unsure.

Reboot your system. GRUB should now automatically select your specified older kernel without any manual intervention.

Using grubby to Set the Default Kernel on RHEL, Fedora, and CentOS

If you are on Red Hat Enterprise Linux, Fedora, CentOS, AlmaLinux, or Rocky Linux, the grubby tool offers a cleaner way to manage default kernels. It works directly with Boot Loader Specification (BLS) entries used by modern Red Hat-based distributions.

List All Installed Kernels

First, see what kernels are available:

grubby --info=ALL | grep -E "index|kernel|title"

This command displays each kernel entry with its index number, kernel path, and display title. Note the index number of the kernel you want to set as default.

Set the Default Kernel by Index

Use the index number from the previous command:

sudo grubby --set-default-index=1

You can also set the default by specifying the kernel path directly:

sudo grubby --set-default=/boot/vmlinuz-5.14.0-284.el9.x86_64

Verify the Default Was Set

Confirm the change took effect:

grubby --default-kernel

The output should show the path to the kernel you just selected. Reboot to confirm GRUB loads the correct one automatically.

One important note about BLS: Modern Fedora and RHEL use BLS snippets in /boot/loader/entries/ rather than a monolithic grub.cfg for kernel entries. The grubby tool handles these entries correctly, but manually editing grub.cfg in these distributions may not work as expected. Always prefer grubby on Red Hat-based systems.

Reverting to an Old Kernel Using Package Managers

Boot selection handles the immediate problem, but you may want to install a specific older kernel package or remove the broken one entirely. Package manager methods differ by distribution.

Debian and Ubuntu (apt)

To install a specific kernel version:

sudo apt install linux-image-6.8.0-44-generic linux-headers-6.8.0-44-generic

To remove the broken kernel:

sudo apt remove linux-image-6.8.0-45-generic linux-headers-6.8.0-45-generic

To prevent a specific kernel from being updated automatically:

sudo apt-mark hold linux-image-6.8.0-44-generic

Release the hold later with:

sudo apt-mark unhold linux-image-6.8.0-44-generic

Fedora, RHEL, CentOS (dnf)

Downgrade the kernel package:

sudo dnf downgrade kernel

Install a specific version:

sudo dnf install kernel-5.14.0-284.el9

Lock the kernel version to prevent updates:

sudo dnf install python3-dnf-plugin-versionlock
sudo dnf versionlock add kernel

Arch Linux (pacman)

Arch does not keep old kernels by default, but you can use the Arch Linux Archive to downgrade:

sudo pacman -U https://archive.archlinux.org/packages/l/linux/linux-6.8.9-arch1-1-x86_64.pkg.tar.zst

You can also install the downgrade tool from the AUR for an interactive downgrade experience.

Kernel Panic Diagnostics After a Bad Kernel Update

Sometimes a bad kernel update does not just break a Wi-Fi adapter. It causes a full kernel panic, leaving you staring at a screen of scrolling text or a frozen boot. No competitor we reviewed covers this scenario in depth, so here is how to diagnose it.

What a Kernel Panic Looks Like

A kernel panic typically shows a stack trace on screen with messages like “Kernel panic – not syncing: VFS: Unable to mount root fs” or a panic related to a missing module. The system halts and requires a manual reboot.

Boot the Previous Kernel and Investigate

Follow the GRUB menu steps above to boot into the older working kernel. Once logged in, examine why the new kernel failed:

journalctl --boot=-1 -k

This shows kernel messages from the previous boot attempt. If you want to look at the failed boot specifically, you may need to find the right boot number:

journalctl --list-boots

Then specify the boot number that corresponds to the failed kernel attempt:

journalctl -b -3 -k

Look for error messages about missing modules, firmware issues, or hardware initialization failures. Common causes include missing initramfs images (the kernel cannot find its root filesystem) or removed kernel modules that a driver depends on.

Boot Into Recovery Mode

If even the older kernel has issues, try the recovery mode option from the GRUB Advanced options submenu. This boots into a minimal environment with a root shell. On systemd-based distributions, you can also append systemd.unit=rescue.target or systemd.unit=emergency.target to the kernel command line by pressing e in GRUB and editing the boot entry.

Rescue target mounts the filesystem read-write with minimal services. Emergency target mounts it read-only with even fewer services. Use emergency mode when rescue mode also fails.

Rebuild the Initramfs

If the new kernel panics because of a missing or corrupted initramfs, rebuild it:

On Debian/Ubuntu: sudo update-initramfs -u -k all

On RHEL/Fedora: sudo dracut --force

On Arch: sudo mkinitcpio -P

Live USB Recovery When the System Will Not Boot at All

In the worst case, GRUB itself may be broken, or no kernel on the system can boot successfully. This is where a Live USB becomes essential.

Step 1: Create a Bootable Live USB

On another computer, download your distribution ISO and flash it to a USB drive using a tool like Rufus (Windows), balenaEtcher (cross-platform), or the dd command on Linux:

sudo dd if=ubuntu.iso of=/dev/sdX bs=4M status=progress

Replace /dev/sdX with your USB drive device. Be careful to select the correct device.

Step 2: Boot From the USB and Mount Your Root Partition

Boot from the USB and open a terminal. Identify your root partition:

sudo fdisk -l

Look for your Linux root partition (usually the largest ext4 partition). Mount it:

sudo mount /dev/sdXN /mnt

If you have a separate boot partition, mount that too:

sudo mount /dev/sdXM /mnt/boot

Step 3: Chroot and Fix the Problem

Enter the mounted system:

sudo arch-chroot /mnt

On Debian/Ubuntu, use:

sudo mount --bind /dev /mnt/dev
sudo mount --bind /proc /mnt/proc
sudo mount --bind /sys /mnt/sys
sudo chroot /mnt

From inside the chroot, you can reinstall a working kernel, remove the broken one, or regenerate the GRUB configuration:

apt install --reinstall linux-image-6.8.0-44-generic
update-grub

Exit the chroot with exit, unmount everything, and reboot.

Preventing Kernel Updates From Breaking Your System Again

Once you have recovered, take steps to prevent the same issue on the next update cycle.

Hold Your Working Kernel Version

On Debian/Ubuntu: sudo apt-mark hold linux-image-generic

On Fedora/RHEL: sudo dnf versionlock add kernel kernel-core

This prevents the package manager from upgrading the kernel until you explicitly release the hold.

Configure How Many Kernels Are Kept

Ubuntu and Debian keep a limited number of old kernels. You can adjust this in /etc/apt/apt.conf.d/01autoremove-kernels or by configuring unattended-upgrades. RHEL systems can control this through the installonly_limit setting in /etc/dnf/dnf.conf:

installonly_limit=5

Keeping at least 3-5 kernel versions gives you rollback options.

Use System Snapshots as a Safety Net

Tools like Timeshift (Ubuntu/Mint), snapper (openSUSE/SUSE), or btrfs snapshots let you roll back the entire filesystem to a pre-update state. If a kernel update breaks everything, restoring a snapshot takes seconds instead of the manual recovery process described above.

Common Mistakes to Avoid When Rolling Back a Kernel

Based on forum reports from r/Ubuntu, AskUbuntu, and r/linuxquestions, here are the errors that cause the most headaches:

Editing grub.cfg directly. This file is auto-generated. Always edit /etc/default/grub and run update-grub afterward. Changes to grub.cfg vanish on the next kernel update.

Deleting all installed kernels. Never remove every kernel except the one you want. If that kernel develops an issue, you have no fallback. Always keep at least two working kernel versions.

Forgetting to run update-grub. After editing /etc/default/grub, the changes do not take effect until you regenerate the configuration. This is the most frequently missed step on AskUbuntu.

Not verifying with uname -r. Always confirm which kernel actually loaded. Assuming the rollback worked without checking leads to confusion when the problem persists.

Ignoring the root cause. If a kernel update broke your hardware, file a bug report or check the distribution bug tracker. The maintainers need this feedback to fix the issue in future releases.

Frequently Asked Questions

Conclusion

A new kernel breaking your hardware is stressful, but knowing how to boot into an older kernel from the GRUB menu turns a potential disaster into a two-minute fix. The process is the same across most distributions: access GRUB with Shift or Esc, open Advanced options, and select the previous working kernel.

For a permanent solution, modify /etc/default/grub on Debian-based systems or use grubby on Red Hat-based ones. Always verify with uname -r that the correct kernel loaded, and keep multiple kernel versions installed so you always have a fallback.

Going forward, consider holding your kernel version, maintaining 3-5 installed kernels, and setting up system snapshots. A few minutes of preparation now will save you from hours of recovery work on the next problematic update.