How to Install XanMod Kernel on Linux Mint (22, 21)

Desktop workloads that need lower input latency, faster I/O behavior, or better frame pacing often outgrow the stock Mint kernel. To install XanMod kernel on Linux Mint, set up the official repository, choose the CPU-matched package, and keep a clean rollback path so you can test performance gains safely.

The instructions support Linux Mint 22.x (Ubuntu 24.04 base) and Linux Mint 21.x (Ubuntu 22.04 base). Repository setup uses different Ubuntu codenames per Mint series, while the install, verification, update, troubleshooting, and removal workflow stays the same across both releases.

Install XanMod Kernel on Linux Mint

Before adding the repository, compare the common Mint kernel choices so you can decide whether XanMod fits your workload and stability expectations.

Kernel Option	Primary Focus	Best For	Trade-offs
Default Mint Kernel	Stability and broad hardware support	Production systems, servers, users prioritizing reliability	Conservative updates, may lag behind latest hardware support
XanMod Kernel	Performance optimization and low latency	Gaming, multimedia production, high-performance workstations	Aggressive optimizations sacrifice exhaustive testing, potential edge-case instability
Liquorix Kernel	Desktop responsiveness and multimedia	Content creators, audio production, desktop users wanting smooth UI performance	Similar trade-offs to XanMod, less CPU-specific optimization

The default Mint kernel prioritizes broad hardware support and conservative updates. XanMod emphasizes low latency and CPU-targeted optimizations for desktop responsiveness, while Liquorix focuses on interactive desktop and multimedia behavior with fewer architecture-specific variants. For production systems where predictability matters more than peak responsiveness, keep the default kernel. For gaming or media workloads, XanMod is usually the stronger choice.

XanMod supports only x86_64 architecture (64-bit Intel/AMD processors) and does not support Secure Boot. Disable Secure Boot in firmware before continuing, then confirm architecture support with uname -m. If the output is x86_64, your CPU architecture is compatible.

Verify Secure Boot Status for XanMod

XanMod kernels are not signed with Microsoft’s UEFI keys, so Secure Boot firmware blocks them from loading. Before installing XanMod, check whether Secure Boot is currently enabled on your system:

mokutil --sb-state

Typical output looks like one of these examples:

SecureBoot enabled
SecureBoot disabled
EFI variables are not supported on this system

If the output shows SecureBoot enabled, disable Secure Boot in your BIOS/UEFI settings before proceeding. On many systems you can enter firmware setup during reboot with F2, F10, Del, or Esc, then switch Secure Boot to disabled and save changes.

If your VM reports EFI variables are not supported on this system, Secure Boot state cannot be queried from the guest. On physical hardware, rerun mokutil --sb-state after changing firmware settings and continue only when it reports SecureBoot disabled.

Import XanMod APT Repository

Update Linux Mint Before XanMod Installation

Before proceeding, update your system to ensure all packages are current and minimize potential conflicts during installation. First, refresh the package index:

sudo apt update

This tutorial uses sudo for commands that require root privileges. If your account is not configured for sudo access, follow the Linux Mint sudoers guide first.

Next, upgrade any outdated packages:

sudo apt upgrade

Install XanMod Prerequisites

Install the packages needed for secure repository management and kernel driver support. The gpg package handles GPG key verification, lsb-release detects your system codename, and dkms (Dynamic Kernel Module Support) automatically rebuilds external drivers like NVIDIA when your kernel updates:

sudo apt install gpg lsb-release ca-certificates dkms -y

Add XanMod GPG Key

Download and install the XanMod GPG key so APT can verify package signatures from the official repository:

curl -fsSL https://dl.xanmod.org/archive.key | sudo gpg --dearmor -o /usr/share/keyrings/xanmod-archive-keyring.gpg

This command downloads the ASCII-armored key and converts it to a binary keyring file that the repository definition references through Signed-By.

Add XanMod APT Repository

Add the XanMod repository using the modern DEB822 format. Since Linux Mint is based on Ubuntu, the XanMod repository uses Ubuntu codenames to identify which packages to provide. Use the appropriate command block below based on your Mint version.

Linux Mint 22.x (based on Ubuntu 24.04 Noble):

cat <<EOF | sudo tee /etc/apt/sources.list.d/xanmod.sources
Types: deb
URIs: https://deb.xanmod.org
Suites: noble
Components: main
Signed-By: /usr/share/keyrings/xanmod-archive-keyring.gpg
EOF

Linux Mint 21.x (based on Ubuntu 22.04 Jammy):

cat <<EOF | sudo tee /etc/apt/sources.list.d/xanmod.sources
Types: deb
URIs: https://deb.xanmod.org
Suites: jammy
Components: main
Signed-By: /usr/share/keyrings/xanmod-archive-keyring.gpg
EOF

The following table shows the relationship between Linux Mint versions and the Ubuntu codename to use:

Linux Mint Version	Mint Codenames	Ubuntu Base	Repository Codename
Linux Mint 22.x	Wilma, Xia, Zara, Zena	Ubuntu 24.04 LTS	noble
Linux Mint 21.x	Vanessa, Vera, Victoria, Virginia	Ubuntu 22.04 LTS	jammy

Afterward, verify the repository was added successfully:

cat /etc/apt/sources.list.d/xanmod.sources

The output displays the DEB822 repository configuration (shown here for Mint 22.x):

Types: deb
URIs: https://deb.xanmod.org
Suites: noble
Components: main
Signed-By: /usr/share/keyrings/xanmod-archive-keyring.gpg

Refresh APT Cache After XanMod Import

Afterward, refresh the APT package index to include the XanMod repository:

sudo apt update

You should see APT fetch metadata from deb.xanmod.org:

Get:1 https://deb.xanmod.org noble InRelease [4,908 B]
Get:2 https://deb.xanmod.org noble/main i386 Packages [3,183 B]
Get:3 https://deb.xanmod.org noble/main amd64 Packages [37.7 kB]
Reading package lists... Done

If you see a 404 error, verify you used the correct codename for your Mint version from the table above.

Select and Install XanMod Kernel

Download XanMod CPU Detection Script

First, download the XanMod CPU detection script to identify the correct kernel version for your processor:

curl -fsSLO https://dl.xanmod.org/check_x86-64_psabi.sh
chmod +x check_x86-64_psabi.sh

XanMod provides different kernel builds optimized for specific CPU generations through x86-64 microarchitecture levels. The x86-64-v2 level adds SSE3, SSSE3, and SSE4 instructions found in CPUs from approximately 2009-2015, while x86-64-v3 includes AVX and AVX2 vector extensions found in CPUs from 2015 onward like Intel Haswell and AMD Zen. The script detects your processor’s supported instruction sets to recommend the optimal build that delivers maximum performance without compatibility issues.

Then, execute the script to determine the suitable version:

./check_x86-64_psabi.sh

Afterward, the output indicates the supported x86-64 version:

CPU supports x86-64-v3

Your output may show x86-64-v2, x86-64-v3, or x86-64-v4 depending on your processor generation. Modern CPUs from approximately 2015 onward (Intel Haswell, AMD Zen, and newer) usually support v3, while older CPUs from 2009-2015 typically support v2. If your system reports v4, install the v3 package, because XanMod currently publishes v2 and v3 metapackages for this repository.

Once you have determined your CPU version, clean up the detection script:

rm check_x86-64_psabi.sh

Install XanMod Kernel via APT

Install the XanMod kernel matching your CPU version. For x86-64-v3 processors (Intel Haswell/AMD Zen and newer):

sudo apt install linux-xanmod-x64v3

Older CPUs that support only x86-64-v2 should use this package instead:

sudo apt install linux-xanmod-x64v2

The MAIN branch provides v2 and v3 builds with the latest stable kernel (currently 6.19.x). For long-term stability, install linux-xanmod-lts-x64v2 or linux-xanmod-lts-x64v3 instead, which tracks the 6.18 LTS kernel series.

Detailed compatibility information is available on the XanMod website. The project source code is available on GitLab.

XanMod Branch Overview

XanMod offers multiple kernel branches targeting different use cases. Each branch provides builds optimized for v2 and v3 CPU microarchitectures.

XanMod enables Google’s BBRv3 TCP congestion control by default, which can improve latency and throughput on modern network paths.

MAIN Branch

• linux-xanmod-x64v2: Compatible with CPUs from 2009-2015, including AMD Family 10h through 15h (Barcelona, Bulldozer, Piledriver) and Intel Core 2 through 3rd Gen Core (Sandy Bridge, Ivy Bridge). Supports SSE3, SSSE3, SSE4.1, and SSE4.2 instruction sets.
• linux-xanmod-x64v3: Optimized for modern CPUs from 2015 onward, including AMD Family 17h and 19h (Zen through Zen 4) and Intel 4th Gen Core and newer (Haswell, Skylake, Coffee Lake, and beyond). Adds AVX, AVX2, BMI1, BMI2, and FMA3 instruction sets for significantly better performance in multimedia and computational workloads.

EDGE Branch

• linux-xanmod-edge-x64v2: Bleeding-edge kernel for older CPUs (2009-2015 generation). Includes experimental patches and latest upstream features before they stabilize in MAIN.
• linux-xanmod-edge-x64v3: Bleeding-edge kernel for modern CPUs (2015+ generation). Delivers cutting-edge performance optimizations and new features at the cost of potential instability.

LTS Branch

• linux-xanmod-lts-x64v1: Long-term stable kernel for legacy CPUs from 2003-2009, including AMD K8/K10 families, Intel Pentium 4, Core 2, and early Core i-series. Use this only if your CPU predates SSE4.2 support.
• linux-xanmod-lts-x64v2: Long-term stable kernel for CPUs from 2009-2015 generation. Provides conservative updates with security patches while maintaining proven stability for production systems.
• linux-xanmod-lts-x64v3: Long-term stable kernel for modern CPUs from 2015 onward. Balances performance optimizations with extended support lifecycle, ideal for production workstations requiring stability guarantees.

RT Branch

• linux-xanmod-rt-x64v2: Real-time kernel for CPUs from 2009-2015 generation. Provides deterministic latency and preemption guarantees for audio production, industrial control systems, and robotics applications requiring hard real-time performance.
• linux-xanmod-rt-x64v3: Real-time kernel for modern CPUs from 2015 onward. Combines PREEMPT_RT patches with AVX2 optimizations for low-latency multimedia workloads and time-critical applications where consistent sub-millisecond response times matter more than maximum throughput.

Selecting the correct version for your CPU architecture is crucial for achieving the best results with the XanMod Kernel. When unsure, the v2 version provides a safe fallback that works on nearly all 64-bit systems.

Reboot System After XanMod Installation

Reboot to activate the newly installed kernel:

sudo reboot

After rebooting, your system loads the XanMod kernel with CPU-specific optimizations active. GRUB automatically selects the newest kernel by default, so XanMod should load without manual intervention.

Verify XanMod Kernel Installation

Check XanMod Kernel Version

Verify the active kernel version to confirm XanMod is running:

uname -r

The output shows the XanMod kernel version and CPU architecture variant:

6.19.6-x64v3-xanmod1

The version format breaks down as: kernel version (for example, 6.19.6), CPU optimization level (x64v3), and XanMod release number (xanmod1). This confirms your system boots the performance-optimized kernel built specifically for your processor’s instruction set capabilities.

Display System Information with hostnamectl

You can use the built-in hostnamectl command (part of systemd on every modern Linux Mint release) to print kernel, hardware, and operating system details without installing extra utilities:

hostnamectl

Example output:

 Static hostname: mint-workstation
       Icon name: computer-desktop
Operating System: Linux Mint 22.3
          Kernel: Linux 6.19.6-x64v3-xanmod1
    Architecture: x86-64

For more detailed output, you can also check the full kernel version string:

cat /proc/version

Install Intel or AMD Microcode for XanMod

Microcode updates address CPU bugs, security vulnerabilities, and performance issues at the processor firmware level. These updates are especially important when running custom kernels like XanMod, as they ensure your CPU operates with the latest fixes. Linux Mint enables easy microcode updates through its package management system.

Install Intel Microcode

Intel processor users should install microcode updates with the following command:

sudo apt install intel-microcode iucode-tool

This command installs intel-microcode, containing the latest microcode binaries from Intel, and iucode-tool, a utility for handling microcode updates. After installation, reboot to apply the microcode.

Install AMD Microcode

AMD processor users should install microcode updates with the following command:

sudo apt install amd64-microcode

This command installs amd64-microcode, the package containing the latest microcode updates for AMD CPUs. After installation, reboot to apply the microcode.

Manage XanMod Kernel

Update XanMod Kernel

XanMod updates are delivered through APT. First, identify which XanMod metapackage is installed on your system:

dpkg --list | grep '^ii  linux-xanmod'

Example output:

ii  linux-xanmod-x64v3  6.19.6-xanmod1-0  amd64  Complete XanMod Linux kernel and headers [6.19] [x86-64-v3]

Refresh package metadata, then upgrade only the installed XanMod metapackage (replace the package name if you use LTS, EDGE, RT, or v2):

sudo apt update
sudo apt install --only-upgrade linux-xanmod-x64v3

After a kernel update, reboot to activate the new version. You can verify the active kernel version with uname -r after rebooting.

Troubleshoot XanMod Kernel Issues

Secure Boot Prevents XanMod Kernel From Booting

If your system shows “Validation failed: Security Policy Violation” or fails to boot after installing XanMod, Secure Boot is still enabled. XanMod kernels are not signed with Microsoft’s UEFI keys, so Secure Boot firmware blocks them. Check your current Secure Boot status:

mokutil --sb-state

Common output examples:

SecureBoot enabled
SecureBoot disabled
EFI variables are not supported on this system

If it reports SecureBoot enabled, disable Secure Boot in firmware and rerun the command. If it reports EFI variables are not supported on this system, this VM cannot query firmware state from the guest.

System Still Boots Default Kernel

If uname -r shows a generic Linux Mint kernel instead of XanMod after installation, boot order settings may still point at an older entry. If needed, use GRUB Customizer on Linux Mint to review saved boot preferences, then list all installed kernels:

dpkg --list | grep linux-image

You should see both XanMod and generic kernels installed:

ii  linux-image-6.19.6-x64v3-xanmod1  6.19.6-x64v3-xanmod1-0~20260304.ge0b3726  amd64  Linux kernel, version 6.19.6-x64v3-xanmod1
ii  linux-image-6.17.0-14-generic     6.17.0-14.14~24.04.1                       amd64  Signed kernel image generic
ii  linux-image-6.14.0-37-generic     6.14.0-37.37~24.04.1                       amd64  Signed kernel image generic

Then verify GRUB’s default boot entry:

grep GRUB_DEFAULT /etc/default/grub

Expected output:

GRUB_DEFAULT=0

If set to anything other than GRUB_DEFAULT=0, GRUB may skip the newest kernel. Update GRUB to rebuild the boot menu with the XanMod kernel first:

sudo update-grub

Look for output confirming XanMod entries were detected:

Found linux image: /boot/vmlinuz-6.19.6-x64v3-xanmod1
Found initrd image: /boot/initrd.img-6.19.6-x64v3-xanmod1
Found linux image: /boot/vmlinuz-6.17.0-14-generic
done

Afterward, reboot and verify XanMod loads. At the GRUB menu, you can manually select “Advanced options for Linux Mint” and choose the XanMod kernel entry if automatic selection fails.

Repository Returns 404 Error

If sudo apt update shows a 404 error for the XanMod repository, you may have used an incorrect codename. The XanMod repository uses Ubuntu codenames: noble for Mint 22.x and jammy for Mint 21.x.

Check the codename in your repository configuration:

cat /etc/apt/sources.list.d/xanmod.sources

Example of an incorrect file on Mint 22.x:

Types: deb
URIs: https://deb.xanmod.org
Suites: jammy
Components: main
Signed-By: /usr/share/keyrings/xanmod-archive-keyring.gpg

If the Suites: line shows an incorrect codename, delete the file and recreate it using the correct Ubuntu codename (noble for Mint 22.x or jammy for Mint 21.x) as shown in the installation section above.

CPU Detection Script Shows Wrong Version

If the XanMod detection script reports a version that seems incorrect for your CPU, verify instruction set support manually. Check for AVX2 support (required for x64v3):

grep -o 'avx2' /proc/cpuinfo | head -n1

Expected output when AVX2 is present:

avx2

If the output shows “avx2,” your CPU supports x64v3. If empty, your CPU only supports x64v2. You can also check SSE4.2 support (required for x64v2):

grep -o 'sse4_2' /proc/cpuinfo | head -n1

Expected output when SSE4.2 is present:

sse4_2

When uncertain, install the x64v2 version as the safe fallback. Modern CPUs from 2015 onward almost universally support x64v3, while CPUs from 2009-2015 support x64v2. If the detection script reports x86-64-v4, use the x64v3 package for now because no dedicated x64v4 metapackage is published in this repository.

DKMS Module Build Failures

If you see DKMS errors during kernel installation, external drivers (NVIDIA, VirtualBox, etc.) failed to build against the new kernel. Check DKMS module status:

sudo dkms status

Example output:

nvidia/575.64.05, 6.19.6-x64v3-xanmod1, x86_64: installed
v4l2loopback/0.15.0, 6.19.6-x64v3-xanmod1, x86_64: installed

The output lists all DKMS modules and their build status for each kernel. Look for “Error” entries. If a module shows errors, rebuild it manually:

sudo dkms autoinstall -k $(uname -r)

If the rebuild succeeds, you will see a completion message similar to:

* dkms: running auto installation service for kernel 6.19.6-x64v3-xanmod1
* dkms: autoinstall for kernel 6.19.6-x64v3-xanmod1
...done.

For NVIDIA driver issues specifically, ensure you have the latest driver version that supports your kernel. See the NVIDIA driver installation guide for Linux Mint for recommended driver installation methods. If the rebuild fails, check the build logs:

sudo cat /var/lib/dkms/*/build/make.log

Repository GPG Key Errors

If apt update shows “GPG error: The following signatures couldn’t be verified,” the XanMod GPG key is missing or corrupted. Re-import the key:

curl -fsSL https://dl.xanmod.org/archive.key | sudo gpg --dearmor -o /usr/share/keyrings/xanmod-archive-keyring.gpg

Next, verify the keyring file exists and has correct permissions:

ls -lh /usr/share/keyrings/xanmod-archive-keyring.gpg

Expected output:

-rw-r--r-- 1 root root 1.9K Mar  5 14:30 /usr/share/keyrings/xanmod-archive-keyring.gpg

The keyring file should be readable by all users. If permissions are wrong, fix them:

sudo chmod 644 /usr/share/keyrings/xanmod-archive-keyring.gpg

Finally, run sudo apt update again to verify the error resolves.

System Fails to Boot After Kernel Install

If your system fails to boot after installing XanMod, boot the previous working kernel from GRUB. When the system starts, hold Shift (BIOS) or Esc (UEFI) to show the GRUB menu. Select “Advanced options for Linux Mint,” then choose your previous kernel (the generic Mint kernel listed below XanMod). Once booted, remove the problematic XanMod kernel and investigate the issue before trying again.

Check system logs for boot failures:

sudo journalctl -xb -1

Typical failures include module load errors, Secure Boot policy blocks, or early kernel panics. Example excerpt:

kernel: Lockdown: modprobe: unsigned module loading is restricted; see man kernel_lockdown.7
kernel: Kernel panic - not syncing: Attempted to kill init!

This shows logs from the previous boot attempt. Look for kernel panics, driver failures, or hardware initialization errors that prevented the XanMod kernel from completing startup.

Remove XanMod Kernel

To remove XanMod and restore the default Linux Mint kernel, follow the steps below. The default kernel remains installed alongside XanMod, so your system will boot normally after removing XanMod packages.

First, remove the XanMod repository configuration:

sudo rm -f /etc/apt/sources.list.d/xanmod.sources

Then, remove the GPG key:

sudo rm -f /usr/share/keyrings/xanmod-archive-keyring.gpg

Refresh the package cache to remove the XanMod repository from your system’s sources:

sudo apt update

Identify the installed XanMod packages to ensure complete removal:

dpkg --list | grep xanmod

The output lists XanMod kernel images and headers. For example:

ii  linux-headers-6.19.6-x64v3-xanmod1    6.19.6-xanmod1-0    amd64   Linux kernel headers
ii  linux-image-6.19.6-x64v3-xanmod1      6.19.6-xanmod1-0    amd64   Linux kernel image
ii  linux-xanmod-x64v3                    6.19.6-xanmod1-0    amd64   XanMod Linux kernel metapackage

Remove all XanMod kernel packages:

sudo apt remove --purge $(dpkg --list | awk '/^ii  linux-(headers|image)-.*xanmod|^ii  linux-xanmod/{print $2}')
sudo apt autoremove

This removes the currently installed XanMod image, matching headers, and metapackage without relying on broad wildcard package arguments. The follow-up sudo apt autoremove command cleans up orphaned dependencies.

After removal, reboot to load the default Linux Mint kernel:

sudo reboot

Upon restarting, verify that your system has reverted to the standard kernel:

uname -r

The output should show a default Linux Mint kernel version without the xanmod suffix:

6.17.0-14-generic

Frequently Asked Questions

Conclusion

XanMod kernel is now installed on Linux Mint with a verified workflow for updates, driver rebuilds, and rollback to the default kernel. If you want tighter control over boot entry behavior, follow the GRUB Customizer on Linux Mint guide. For driver compatibility after kernel changes, use the NVIDIA drivers on Linux Mint guide.