How to Build and Compile Linux Kernel From Scratch

Try this guide with our instant dedicated server for as low as 40 Euros

compile Linux kernel

Imagine building a home exactly to your specifications, with every nook and corner customized and tuned to your needs. 

If you want this level of control over your system’s OS, you should consider Linux. More specifically, you should consider how to build and compile the Linux kernel from scratch. 

The Linux kernel contains crucial kernel modules. As such, it is the core of a Linux system that acts as a bridge between the software programs (packages and apps) and hardware devices (CPU, RAM, network interfaces, and storage) of the system. 

On the flip side, building and compiling a Linux kernel from scratch isn’t for everyone. You need extensive code writing and hardware programming knowledge for the process of creating a custom kernel tailored to the user’s exact needs. You also need to include (or write your own) drivers and specific hardware and software interaction components. 

In this tutorial, we will discuss how to build and compile the Linux kernel. We will discuss the seven steps involved in the process. However, before that, let us take a quick look at the prerequisites. 

Table Of Contents

  1. The Prerequisites
  2. How to Build and Configure Linux Kernel
    1. Step #1: Download the Source Code
    2. Step #2: Extract the Source Code
    3. Step #3: Install the Required Packages
    4. Step #4: Initial Kernel Configuration
    5. Step #5: Build the Kernel
    6. Step #6: Update the Bootloader (Optional)
    7. Step #7: Reboot and Confirm Kernel Version
  3. Conclusion
  4. FAQs

The Prerequisites

Before moving in, ensure you have the following: 

  • A Linux system with a minimum of 12GB of free space on the hard drive.
  • Access to the terminal/command line.
  • A user account with sudo or administrative privilege.

How to Build and Configure Linux Kernel

Building and compiling the Linux kernel from scratch offers ultimate control and customization, the latest features, and significantly enhanced performance. More importantly, the process deepens your understanding of how the operating system works at its core. 

Note: Building the kernel can take a significant amount of time depending on your system’s resources. Be patient and avoid interrupting the process.

Also, if the kernel version mentioned here differs from the latest available, replace the version number in the commands with the current version.

Step #1: Download the Source Code

Navigate to the official kernel website and download the newest kernel version. You will receive a compressed file with the source code for the new kernel.

linux kernel archives

Next, open the terminal and run the following wget command to download the Linux kernel’s source code.

# wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.8.9.tar.xz


Step #2: Extract the Source Code

Next, extract the downloaded source code with the following tar command:

# tar -xvf linux-6.0.7.tar.xz

Once the tar command finishes, the kernel source code will be ready for you to configure and compile.



Step #3: Install the Required Packages

Before building the new kernel, you need to install several essential packages. Execute the following command to install these packages:

# sudo apt-get install git fakeroot build-essential ncurses-dev xz-utils libssl-dev bc flex libelf-dev bison

The following table summarizes the source packages installed by executing the command. 

source packages

sudo apt get install

Step #4: Initial Kernel Configuration

Once you have the necessary packages installed, you can now configure the Linux kernel to fit your requirements.

Start by navigating to the kernel source directory (usually named linux-6.0.7) with the cd command:

# cd linux-6.8.9

Next, use the cp command to copy the current Linux default configuration file.

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

cd linux

Next, modify the original configuration with the make menuconfig command.

# make menuconfig

This command opens a menu-driven interface for configuring the kernel settings. 

Navigate to the current configuration tool menu through options like firmware, file system, network, and memory settings. 

Use the arrow keys to select options and if required, select Help for more information.

make menuconfig 

Once you make the necessary changes, save and exit the menu.

save exit menu

Step #5: Build the Kernel

Once the kernel is configured, you can now proceed to build the kernel based on these configurations. 

Start building the kernel by executing the following command:

# make

Note: Building and compiling the Linux kernel takes a while. Ensure you do not interrupt the process. 

The terminal lists all Linux kernel components like memory management, device drivers, and network functionalities.


Next, if you’re compiling the kernel on Ubuntu, you might encounter an error message related to security certificates that halt compilation. 

No rule to make target ‘debian/canonical-certs.pem

We recommend the following two commands to resolve this issue by turning off the security certificates that cause this issue: 

# scripts/config --disable SYSTEM_TRUSTED_KEYS

# scripts/config --disable SYSTEM_REVOCATION_KEYS

Note that these commands do not return any output. 

Next, execute the make command again to build the kernel. 

Press Enter to accept the default options for creating new certificates.

Once the kernel is built, install the necessary modules.

# sudo make modules_install

Finally, install the kernel with the following command:

# sudo make install

Step #6: Update the Bootloader (Optional)

The GRUB bootloader is responsible for loading the operating system when the system starts the boot sequence. You can also use GRUB rescue commands to fix boot issues after you have installed the custom kernel on your system.

While the make install command usually updates GRUB automatically, you can update it manually if needed.

First, update the initramfs to match the kernel version you have installed.

# sudo update-initramfs -c -k 6.0.7

Next, update the GRUB bootloader with this command:

# sudo update-grub

The terminal displays the update progress and confirms when it is complete.

update grub

Step #7: Reboot and Confirm Kernel Version

Restart your system to load the new kernel.

Once the system reboots, verify the kernel version with the following command:

# uname -mrs

This command displays the current kernel version and architecture, confirming that your new kernel is successfully installed and running.


Building your own Linux kernel might seem complex at first, but it’s a rewarding process that gives you control over your system. 

By following the step-by-step instructions, you can create a customized kernel tailored to your needs. 

Whether you’re a curious enthusiast or a seasoned developer, experimenting with kernel building opens up new possibilities for understanding and optimizing your Linux experience. 

So go ahead, dive in, and enjoy the journey of building your own Linux kernel!


Q. What is a custom kernel?

A custom kernel is a version of the Linux kernel that you build yourself, tailored to your specific needs or preferences.

Q. What is a source tree in kernel development?

A source tree is the complete directory structure containing the Linux kernel’s source code. It includes all the files, directories, and subdirectories needed to build the kernel, organized hierarchically.

Q. What is a patch file in kernel development?

A patch file is a text file that contains differences between two versions of files or source code. In kernel development, patch files update the source tree by applying changes or fixing the kernel code without downloading the entire source tree again.

Q. What is a config file in kernel development?

A config file contains settings and options for building a custom kernel, allowing normal users to modify and fine-tune the kernel’s behavior.

Q. What is a kernel driver?

A kernel driver is a piece of software that allows the kernel to communicate with hardware devices, enabling them to function properly.

Q. How do I build a kernel from scratch?

Building a kernel from scratch involves downloading the kernel source code, configuring it according to your needs, compiling it, and installing it on your system.

Q. What is a kernel module?

A kernel module is a piece of code that can be dynamically loaded into the kernel to add or extend functionality without the need to recompile the entire kernel.

Q. What are kernel headers used for?

Kernel headers provide the necessary interface for compiling and linking user-space programs with the kernel.

Q. What is a kernel tree?

A kernel tree is the directory structure containing the source code for the Linux kernel, organized into various directories and files.

Q. How do I install additional packages for kernel development?

Additional packages required for kernel development can be installed using package managers like apt or yum, depending on your Linux distribution.

Q. How do I configure kernel options?

Kernel configuration options can be set using tools like make menuconfig or make xconfig, which provide graphical interfaces for customizing the kernel’s behavior.

Q. What is the difference between a 64-bit kernel and a 32-bit kernel?

A 64-bit kernel is designed to run on 64-bit processors and can handle larger amounts of RAM and more efficient processing. A 32-bit kernel is designed for 32-bit processors and has limitations on the maximum RAM it can address and overall processing power. Choosing between them depends on your hardware and performance requirements.

Try this guide with our instant dedicated server for as low as 40 Euros