Learning Artix Linux - Kernel & Firmware

#Introduction

Every system runs on a kernel, and Artix gives you full freedom to choose it. Episode 11 covers the official kernel choices — linux, linux-lts, and linux-zen — how to build a custom kernel, the role of the mkinitcpio hooks at boot, the linux-firmware package for hardware, and the microcode of intel-ucode and amd-ucode.

Ordinary users rarely tinker with the kernel, but understanding how it works saves you when boot fails or hardware isn't detected. Let's break down the components.

#Official Kernel Choices

#linux: The Balanced Default

The linux package is a vanilla kernel with upstream patches, tracking the latest releases. It's the right default for most users:

sudo pacman -S linux linux-headers

linux-headers is needed to compile external kernel modules, including the NVIDIA driver. Check the running kernel version with uname -r.

#linux-lts: Long-Term Stability

linux-lts is a kernel with long-term support — the best choice for servers or machines that don't want frequent reboots from kernel updates:

sudo pacman -S linux-lts linux-lts-headers

With two kernels installed, GRUB shows both at boot. Choose LTS if stability matters more than the newest features.

#linux-zen: Interactive Performance

linux-zen is tuned for a responsive desktop and gaming experience. Try it with:

sudo pacman -S linux-zen linux-zen-headers

After installing a new kernel, verify that GRUB recognizes it and regenerate the initramfs:

sudo mkinitcpio -P
sudo grub-mkconfig -o /boot/grub/grub.cfg

grub-mkconfig scans /boot and adds the new kernel to the boot menu. Without this step, the new kernel won't appear on reboot.

#Custom Kernels

#Assembling from a PKGBUILD

Artix inherits Arch's PKGBUILD system, so a custom kernel can be built from ABS with makepkg. This is for those who need specific patches or configuration. The basic flow:

mkdir -p ~/abs/linux
cd ~/abs/linux
asp update linux
asp checkout linux

The asp tool fetches the kernel sources along with the official PKGBUILD. You can modify the configuration in the build folder, then run makepkg.

#Building with makepkg

Building a kernel takes a long time, so mind your resources:

makepkg -s -c

makepkg -s -c pulls dependencies and cleans the build directory. When finished, install the resulting .pkg.tar.zst package with pacman -U.

#mkinitcpio and Hooks

#What the Initramfs Does

At boot, the kernel can't read the root filesystem directly — too many drivers are needed. The initramfs is a temporary filesystem containing the drivers and tools to find and mount root. Its contents are determined by the hooks in /etc/mkinitcpio.conf.

View the current hook configuration:

cat /etc/mkinitcpio.conf | grep HOOKS

cat /etc/mkinitcpio.conf | grep HOOKS shows the hook order that runs. The block hook loads disk drivers, encrypt is for LUKS, filesystems for filesystem formats, and fsck for boot-time checking.

#Adding a Hook

For needs like encryption (episode 10) or LVM, hooks must be ordered correctly. After editing the file, always regenerate with mkinitcpio -P.

#Firmware and Microcode

#linux-firmware

Kernel drivers need binary firmware for many devices — Wi-Fi, GPUs, and more. The linux-firmware package covers almost all of them:

sudo pacman -S linux-firmware

Without firmware, Wi-Fi or GPU devices often go undetected. Install this package right after your first kernel.

#Microcode: CPU Updates

Microcode is a CPU patch loaded by the kernel at boot. Install per your processor vendor:

sudo pacman -S intel-ucode
sudo pacman -S amd-ucode

Install only the one matching your CPU. After installing, update GRUB so the microcode loads:

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

grub-mkconfig adds the microcode image to the kernel boot line. With this, important CPU security updates are active right after reboot.

#Kernel Troubleshooting

#Boot Fails After an Update

If the system won't boot after a kernel update, enter the GRUB menu and pick another kernel that still exists — for example linux-lts. Then fix things from there. If there's no other kernel, boot from the ISO and chroot (episode 3) to reinstall the kernel.

#Keeping Multiple Kernels

A recommended habit: always keep two kernels on different lines — for example linux and linux-lts. When one kernel has problems, the other is the lifesaver:

pacman -Qs '^linux' | grep '^local'

The output of pacman -Qs '^linux' | grep '^local' shows all installed kernel packages. Two different kernel lines means your system has a boot fallback.

#Conclusion

Episode 11 equipped you with kernel and firmware understanding: the linux, linux-lts, and linux-zen choices, custom kernels from PKGBUILD, the role of the mkinitcpio hooks, the linux-firmware package, and the intel-ucode and amd-ucode microcode.

Key takeaways:

• linux is the default, linux-lts is stable, linux-zen is for interactive performance.
• After installing a new kernel, run mkinitcpio -P and grub-mkconfig.
• The initramfs is built from hooks in /etc/mkinitcpio.conf.
• linux-firmware is required for hardware detection.
• Microcode is loaded via GRUB; install per your CPU.
• Keep two kernels as a fallback when one fails to boot.

In the next episode, episode 12, we'll cover web servers and the LEMP stack — nginx and Apache, PHP-FPM, MariaDB and PostgreSQL, and enabling services via your chosen init.