Install required tools using sudo apt install build-essential libncurses-dev bison flex libssl-dev libelf-dev. 2. Download kernel source from kernel.org or via git clone. 3. Copy current config with cp /boot/config-$(uname -r) .config and run make olddefconfig. 4. Optionally customize with make menuconfig. 5. Compile with make -j$(nproc). 6. Install modules with sudo make modules_install. 7. Install kernel with sudo make install, which updates the bootloader. 8. Reboot and verify with uname -r. Always keep the old kernel for fallback, use LOCALVERSION to customize version string, clean builds with make clean or make mrproper, and backup .config for future use. The process is time-consuming but straightforward when following these steps carefully, and it ends with a successfully booted custom kernel.

Compiling the Linux kernel from source might sound intimidating, but it's a manageable process once you know the steps. Whether you're doing it to enable specific features, improve performance for your hardware, or just to learn how the kernel works, this guide walks you through the entire process on a typical Ubuntu-based system. While distro-specific details may vary slightly, the core steps are the same across most Linux distributions.

1. Install Required Tools and Dependencies

Before you start, make sure your system has the necessary tools to compile the kernel. You’ll need compilers, development libraries, and other build utilities.

On Ubuntu or Debian-based systems, run:

sudo apt update
sudo apt install build-essential libncurses-dev bison flex libssl-dev libelf-dev

These packages provide:

• build-essential: GCC compiler and related tools
• libncurses-dev: Needed for menuconfig (text-based configuration interface)
• bison and flex: Parser and lexical analyzer generators
• libssl-dev: Required for signing modules (if enabled)
• libelf-dev: Used for ELF object file support

2. Download the Kernel Source Code

You can get the latest stable kernel from kernel.org.

Go to your home directory (or a dedicated folder) and download the latest source:

cd ~
wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.6.1.tar.xz
tar -xf linux-6.6.1.tar.xz
cd linux-6.6.1

? Tip: Replace the version number with the latest stable release available at the time.

Alternatively, use git to clone the official repository (if you want more control or plan to contribute):

git clone https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git

3. Configure the Kernel

This is one of the most important steps. You need to decide which features, drivers, and options to include in your custom kernel.

Start with Your Current Configuration

The easiest way is to base your new kernel config on your current running one:

cp /boot/config-$(uname -r) .config

Then update it for any new options in the newer kernel:

make olddefconfig

olddefconfig uses default values for new options instead of prompting you — useful for automation.

Customize Using Menuconfig (Optional)

If you want to tweak settings (e.g., disable unused drivers or enable experimental features), use:

make menuconfig

This opens an interactive menu where you can navigate and modify kernel options. Save and exit when done.

?? Common changes: Enable BPF, disable unused filesystems, optimize for your CPU type under "Processor type and features".

4. Compile the Kernel

Now it’s time to build the kernel and modules. This step can take 20 minutes to over an hour, depending on your CPU and number of cores.

To speed things up, use multiple threads (-j$(nproc) uses all available cores):

make -j$(nproc)

This compiles:

• The kernel image (e.g., arch/x86/boot/bzImage)
• Loadable kernel modules

?? If you get errors, double-check that all dependencies are installed and your .config is valid.

5. Install the Kernel Modules

Once compilation finishes, install the modules (drivers, filesystems, etc.) into /lib/modules:

sudo make modules_install

This copies compiled modules to /lib/modules/<kernel-version>/.

6. Install the Kernel Image

Next, install the actual kernel image so the bootloader can find it:

sudo make install

This command:

• Copies bzImage to /boot/vmlinuz-<version>
• Creates an initramfs using dracut or mkinitramfs
• Updates the bootloader configuration (on Debian/Ubuntu, via update-grub)

? On Ubuntu/Debian, make install automatically runs update-initramfs and grub-mkconfig.

If you're on another distro or the boot entry isn't added, you may need to manually update GRUB:

sudo update-grub

7. Reboot into Your New Kernel

Reboot your system and select the new kernel from the GRUB menu (if multiple entries exist).

After booting, verify the kernel version:

uname -r

You should see the version number of the kernel you just compiled.

Tips and Best Practices

• Keep your old kernel: Don’t remove old kernel entries until you confirm the new one works. This ensures you can boot into a working system if something goes wrong.

• Version naming: To avoid confusion with distribution kernels, consider customizing the kernel version string. Edit the LOCALVERSION in .config or run:

  make LOCALVERSION=-mykernel -j$(nproc)

• Clean up builds: Use make clean (removes generated files but keeps config) or make mrproper (full cleanup) when starting fresh.

• Backup your config: Save your .config file somewhere safe for future use:

  cp .config ~/kernel-config-6.6.1-custom

  ---

  Compiling the Linux kernel isn’t something most users need to do daily, but it’s a powerful skill for developers, system administrators, or enthusiasts. Once you’ve done it once, the process becomes straightforward. Just remember to test thoroughly before relying on it in production.

  Basically, it's a bit time-consuming, but not complicated — especially when you stick to small, safe changes at first.

  The above is the detailed content of A Step-by-Step Guide to Compiling the Linux Kernel from Source. For more information, please follow other related articles on the PHP Chinese website!