What exactly is GRUB2?

When you press the power button, your computer’s firmware (BIOS or UEFI) does some hardware checks
and then hands over control to the bootloader. On most Linux systems, that bootloader is GRUB2.

GRUB2’s main job is simple: present you a menu of kernels and let you pick one. Once you pick
(or the timeout expires and it picks automatically), GRUB2 loads that kernel image into memory,
passes some parameters to it, and steps aside. The kernel takes over from there.

GRUB2 reads its configuration from /boot/grub/grub.cfg. But here is the important rule:
you must never edit that file directly. It is auto-generated. All your changes
go into /etc/default/grub, and after saving, you run sudo update-grub
to regenerate grub.cfg from your settings.

Controlling the GRUB boot menu timeout

When GRUB2 shows its menu, it waits for a few seconds before automatically booting the default
kernel. This wait time is set by the GRUB_TIMEOUT directive inside
/etc/default/grub.

By default in Ubuntu and many Debian-based distros, the timeout is set to a short duration or even
hidden. When you are doing kernel development, you want to see the menu and be able to pick your
newly compiled kernel. So you need to make the menu visible and give yourself enough time to choose.

Step-by-step: Making the GRUB menu visible and setting the timeout

sudo nano /etc/default/grub

GRUB_TIMEOUT=5

GRUB_TIMEOUT_STYLE=menu

#GRUB_HIDDEN_TIMEOUT=1

sudo update-grub

Choosing which kernel boots by default

GRUB2 can have multiple kernels listed in its menu. Think about it — when you install a new kernel,
the old one does not disappear. Both are available. The GRUB_DEFAULT setting in
/etc/default/grub decides which one boots automatically when the timeout runs out.

Method 1 — Boot by position (simplest)

By default, GRUB_DEFAULT=0 means “boot the first entry in the menu”, which is always
the most recently installed kernel. This is usually what you want for development — install your
new kernel and it automatically becomes the first entry.

# Boot the first (newest) kernel — this is the default behaviour
GRUB_DEFAULT=0

Method 2 — Boot by exact name (precise control)

If you want to lock in a specific kernel regardless of what else gets installed, you can use its
full name. First, check what kernels are available on your system:

# List all kernel entries that GRUB knows about
grep -E "^menuentry|submenu" /boot/grub/grub.cfg | cut -d "'" -f2

You will see output similar to this (the exact kernel versions will differ on your machine):

Ubuntu
Advanced options for Ubuntu
Ubuntu, with Linux 6.8.0-60-generic
Ubuntu, with Linux 6.8.0-60-generic (recovery mode)
Ubuntu, with Linux 6.8.0-mykernel
Ubuntu, with Linux 6.8.0-mykernel (recovery mode)

If the kernel you want is inside the “Advanced options” submenu (which is common in modern Ubuntu),
you must include the submenu name using a > separator:

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

Method 3 — Remember the last boot choice (most flexible)

There is a handy option that makes GRUB2 remember whatever you booted last time and use it again
next time. This is great during development — you can pick your custom kernel once and it keeps
booting it:

GRUB_DEFAULT=saved
GRUB_SAVEDEFAULT=true

With this setup, whatever you select from the GRUB menu on one boot becomes the automatic choice
for all future boots — until you change it again from the menu.

Applying your GRUB changes

Every time you edit /etc/default/grub, you must run this command to regenerate the
actual GRUB configuration:

sudo update-grub

On Fedora and RHEL-based systems, the equivalent command is:

# Fedora / RHEL / Rocky Linux
sudo grub2-mkconfig -o /boot/grub2/grub.cfg

After running update-grub, you are ready to reboot:

sudo reboot

What the GRUB menu looks like at boot time

When your machine restarts, if the GRUB menu is configured to show, you will see a simple text menu.
Here is how to understand what you are seeing:

A few things to notice here:

• Modern Ubuntu (20.04 and later) shows the latest kernel directly on the main menu. Older kernels are inside the “Advanced options” submenu.
• Every kernel gets a matching recovery mode entry. This boots the kernel with a minimal set of services and gives you a root shell — useful when a new kernel breaks something.
• The default entry (the one GRUB will auto-boot) is marked with an asterisk * or highlighted.

Safety strategy — never delete your original kernel

When you are doing kernel development, you will compile and install multiple kernels.
A very important rule: never delete your original distribution kernel.

Think about what happens if your custom kernel has a bug and fails to boot — perhaps a driver
crashes early, or the filesystem support is not compiled in. You need a working kernel to fall
back to so you can fix the issue and try again. The distro kernel is your safety net.

A complete working /etc/default/grub for kernel development

Here is a clean example of what a good /etc/default/grub looks like when you are
actively doing kernel development on Ubuntu 22.04 / 24.04:

# /etc/default/grub — Kernel development setup

# Boot the most recently installed kernel by default
GRUB_DEFAULT=0

# Always show the GRUB menu (do not hide it)
GRUB_TIMEOUT_STYLE=menu

# Wait 5 seconds for user input before auto-booting
GRUB_TIMEOUT=5

# Distro name for GRUB display
GRUB_DISTRIBUTOR=`lsb_release -i -s 2>/dev/null || echo Debian`

# Kernel boot parameters (remove 'quiet splash' to see boot messages)
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"
GRUB_CMDLINE_LINUX=""

After saving this file, always run:

sudo update-grub