Before we interact with GRUB, let’s understand where it fits in the big picture. The boot sequence on an x86 machine (simplified for modern UEFI + kernel 6.x systems) looks like this:

On a modern system using UEFI (which is the default on most laptops and desktops since ~2012), GRUB is stored as an EFI application in the EFI System Partition (ESP). On older BIOS-based systems, GRUB’s first-stage loader sits in the Master Boot Record (MBR). Either way, from your point of view as a developer, interacting with GRUB is the same.

When the machine starts, GRUB displays a menu listing all bootable entries. On Ubuntu 22.04 / 24.04 with kernel 6.x, a typical menu looks like this (simplified):

The entry marked with * is the default. If you have compiled a custom kernel (for example 6.8.0-mykernel), it appears at the top because it was the most recently installed. Use the arrow keys to highlight your custom entry and press Enter to boot it.

This is where things get really interesting. When you highlight a GRUB menu entry and press e, GRUB opens an editor showing the raw configuration for that boot entry.

The edit screen contains several lines of GRUB script. The most important one starts with the word linux. It tells GRUB which kernel image to load and what parameters to pass to that kernel.

After pressing e, you can change any of these values. When you are done editing, press Ctrl + X or F10 to boot with your changes. These changes are temporary — they only apply to this one boot session. The stored GRUB config on disk is not touched.

The values you see after the kernel image path on the linux line are called kernel command-line parameters (also called boot parameters or kernel boot arguments). These are passed by GRUB to the kernel at boot time, and the kernel reads them very early in its startup sequence — before any user-space program runs.

You can view the parameters that your currently running kernel was booted with at any time:

cat /proc/cmdline

On a typical Ubuntu 24.04 system with kernel 6.8.x, the output looks something like:

BOOT_IMAGE=/boot/vmlinuz-6.8.0-45-generic root=UUID=d1a2b3c4-... ro quiet splash

The full list of kernel parameters is documented in the kernel source tree under Documentation/admin-guide/kernel-parameters.txt. As of Linux 6.x, there are hundreds of parameters covering everything from CPU scheduling to memory management to device drivers.

Here is a practical skill that will save you one day: recovering from a forgotten root password without reinstalling the OS.

The trick is to boot the system into single-user mode (also called runlevel 1 or rescue mode). In this mode, the system starts up minimally and drops you into a root shell without asking for a password.

Here is how to do it step by step:

linux  /boot/vmlinuz-6.8.0-mykernel root=UUID=abc123 ro quiet splash single

passwd username

The GRUB edits you make by pressing e are one-time-only. They last only for that single boot session. To make permanent changes, you edit the GRUB configuration file.

On modern Debian/Ubuntu systems, the main GRUB configuration file that you should edit is:

/etc/default/grub

Some important options inside this file:

# Set the default boot entry (0 = first entry)
GRUB_DEFAULT=0

# How long to show the menu before auto-booting (seconds)
GRUB_TIMEOUT=5

# Command-line options passed to the kernel for normal boots
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"

# Options passed to ALL boot entries (including recovery)
GRUB_CMDLINE_LINUX=""

After editing this file, you must regenerate the actual GRUB config file that the bootloader reads:

sudo update-grub