How to Install Zabbly Kernel on Ubuntu 26.04, 24.04 and 22.04

New hardware sometimes needs a kernel newer than the one Ubuntu ships for its LTS release. The Zabbly kernel fills that gap by packaging current stable mainline Linux kernels for Ubuntu while keeping an Ubuntu-style configuration, which makes it useful for hardware enablement, kernel testing, and Incus-focused systems that need upstream kernel behavior sooner.

You can install the Zabbly kernel on Ubuntu 26.04, 24.04, and 22.04 through Zabbly’s APT repository. The repository currently publishes packages for amd64 and arm64, tracks stable mainline releases after their early bugfix cycle, and receives updates through APT like other enabled package sources.

Install Zabbly Kernel on Ubuntu

Zabbly is a third-party kernel source, so keep at least one Ubuntu generic kernel installed before you start. That fallback gives you a known boot path if the newer mainline kernel does not work with your firmware, graphics stack, storage controller, or out-of-tree modules.

Decide Whether Zabbly Fits Your Ubuntu System

Use Zabbly when you specifically need a newer upstream stable kernel than Ubuntu currently provides. For production systems that value Canonical’s kernel testing, the default generic or HWE kernel remains the safer baseline.

Kernel Option	Source	Best Fit	Trade-off
Ubuntu HWE kernel	Ubuntu repositories	Recent hardware on supported LTS releases with Ubuntu-managed updates	Newer than GA, but still conservative compared with third-party mainline builds
Zabbly kernel	Zabbly APT repository	Newest stable mainline kernel testing, early hardware support, Incus-heavy systems	Less Ubuntu integration testing and possible Secure Boot or driver-module issues
XanMod kernel	XanMod APT repository	Desktop performance, gaming, and scheduler-focused tuning	Custom patches can create a different compatibility profile than mainline
Liquorix kernel	Liquorix PPA	Desktop responsiveness and low-latency workloads	Desktop-oriented tuning is not a general server stability target

Zabbly publishes kernel packages for Ubuntu 26.04 LTS (resolute), 24.04 LTS (noble), and 22.04 LTS (jammy) in the stable repository. The project also notes that Secure Boot may need to be disabled unless you manage your own trusted signing path for the kernel image.

Update Ubuntu and Install Repository Tools

Refresh APT metadata first, then install the tools needed to download the repository key and detect your Ubuntu release codename:

sudo apt update
sudo apt install ca-certificates curl gpg lsb-release

If APT lists upgrades during the refresh, review and apply them before changing kernels. Kernel work is safer when the current release state is already clean.

Verify the Zabbly Signing Key

Zabbly publishes an ASCII-armored signing key. Display the fingerprint before saving it so you can compare it with the fingerprint listed in the official Zabbly installation instructions:

curl -fsSL https://pkgs.zabbly.com/key.asc | gpg --show-keys --fingerprint

The primary fingerprint should match this value:

4EFC 5906 96CB 15B8 7C73  A3AD 82CC 8797 C838 DCFD

After confirming the fingerprint, save the key where APT can use it for this repository:

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://pkgs.zabbly.com/key.asc | sudo tee /etc/apt/keyrings/zabbly.asc > /dev/null

The tee command writes the key as root; a normal shell redirect would still run as your user and fail against the root-owned keyrings directory.

Add the Zabbly APT Repository

Create the DEB822 source file with your Ubuntu codename and system architecture. The guard stops unsupported codenames before it writes a source file, which prevents broken APT entries on releases outside Zabbly’s published matrix:

codename=$(lsb_release -sc)

if printf '%s\n' resolute noble jammy | grep -qx "$codename"; then
  arch=$(dpkg --print-architecture)

  printf '%s\n' \
  'Enabled: yes' \
  'Types: deb' \
  'URIs: https://pkgs.zabbly.com/kernel/stable' \
  "Suites: $codename" \
  'Components: main' \
  "Architectures: $arch" \
  'Signed-By: /etc/apt/keyrings/zabbly.asc' \
  | sudo tee /etc/apt/sources.list.d/zabbly-kernel-stable.sources > /dev/null
else
  printf 'Zabbly stable kernels are published for Ubuntu 26.04, 24.04, and 22.04 only.\n'
fi

Zabbly’s repository metadata currently advertises amd64 and arm64. The architecture line uses dpkg --print-architecture so the source matches the installed Ubuntu architecture instead of assuming every system is amd64.

Confirm the Zabbly Package Candidate

Refresh APT, then confirm that the linux-zabbly candidate comes from the Zabbly repository:

sudo apt update
apt-cache policy linux-zabbly

The package version changes as Zabbly publishes new builds, so focus on the source line for your codename. Ubuntu 26.04 shows a resolute/main source line; Ubuntu 24.04 and 22.04 show noble/main and jammy/main instead:

        500 https://pkgs.zabbly.com/kernel/stable resolute/main amd64 Packages

Install the Zabbly Kernel Package

Install the Zabbly metapackage. It pulls in the current Zabbly kernel image and matching headers:

sudo apt install linux-zabbly

After APT finishes, confirm that the metapackage is installed and that a Zabbly kernel image exists under /boot:

dpkg-query -W -f='${db:Status-Abbrev} ${binary:Package}\n' linux-zabbly
ls /boot/vmlinuz-*zabbly* >/dev/null 2>&1 && echo 'Zabbly kernel image is installed'

ii  linux-zabbly
Zabbly kernel image is installed

The exact kernel image and header package names change as Zabbly publishes newer stable builds. On Ubuntu 24.04 and 26.04, APT may also upgrade linux-libc-dev from the Zabbly repository; the restore workflow includes the matching downgrade step for systems that need to return fully to Ubuntu archive packages.

Reboot into the Zabbly Kernel

Reboot so GRUB can start the newly installed kernel:

sudo reboot

Keep console or recovery access available for production machines. If the system cannot boot the Zabbly kernel, select an older Ubuntu generic kernel from GRUB’s advanced options and follow the restore workflow to remove the Zabbly packages.

Verify the Running Zabbly Kernel

After the reboot, confirm that the active kernel has the Zabbly suffix and that the matching header tree exists:

case "$(uname -r)" in
  *-zabbly+) echo 'Zabbly kernel is running' ;;
  *) echo 'Zabbly kernel is not running' ;;
esac

test -d "/usr/src/linux-headers-$(uname -r)" && echo 'Matching headers are installed'

A successful Zabbly boot returns these checks. Run uname -r separately when you need the full kernel version string:

Zabbly kernel is running
Matching headers are installed

If uname -r still ends in -generic, the package installed but your system did not boot into it. Use the GRUB advanced menu to select the Zabbly entry once, or stay on the Ubuntu kernel and remove Zabbly if the alternate kernel does not fit your system.

Manage Zabbly Kernel Updates on Ubuntu

Zabbly kernel updates arrive through the same APT source you added during installation. Refresh metadata and review pending upgrades when you want to pick up a newer Zabbly build:

sudo apt update
apt list --upgradable | grep -E 'linux-(zabbly|image-.*zabbly|headers-.*zabbly|libc-dev)' || true

If APT lists a newer Zabbly kernel, apply normal package upgrades and reboot afterward:

sudo apt upgrade
sudo reboot

After the reboot, rerun the Zabbly suffix and header checks you used after installation. Kernel updates are only complete after the system boots the new image.

Troubleshoot Zabbly Kernel on Ubuntu

APT Cannot Find the Zabbly Package

If apt-cache policy linux-zabbly shows no candidate, inspect the source file and rerun the metadata refresh before trying the install again:

cat /etc/apt/sources.list.d/zabbly-kernel-stable.sources
sudo apt update
apt-cache policy linux-zabbly

The Suites: value must match a supported codename, such as resolute, noble, or jammy. If it contains another Ubuntu codename, remove the source file and stay with Ubuntu’s generic kernel until Zabbly publishes packages for that release.

Secure Boot Blocks the Zabbly Kernel

If firmware rejects the Zabbly kernel during boot, return to an Ubuntu generic kernel from the GRUB advanced menu. Zabbly notes that these kernels are not signed by a trusted distribution key, so Secure Boot environments may need either Secure Boot disabled in firmware or a locally managed Machine Owner Key workflow.

After booting a working kernel, check for signature-related messages:

sudo dmesg | grep -i 'signature'

Ubuntu Shows a Kernel Panic After Reboot

A kernel panic after installing a mainline kernel usually points to a driver, storage, firmware, or bootloader compatibility problem. Boot a previous Ubuntu generic kernel from the GRUB advanced options menu, then remove the Zabbly kernel packages from that working session.

If the GRUB menu is hidden, hold Shift during BIOS boot or press Esc during UEFI boot to reveal it. Systems with fast boot may need several attempts or firmware boot-menu access.

GRUB Does Not List the Zabbly Kernel

If the Zabbly image installed but does not appear in the boot menu, regenerate the GRUB menu and confirm the image exists under /boot:

ls /boot/vmlinuz-*zabbly*
sudo update-grub

For recurring boot-menu work, the graphical Grub Customizer guide for Ubuntu can help with menu visibility and default-entry checks, but keep a known-good Ubuntu kernel installed before changing boot defaults.

Restore the Ubuntu Kernel

This workflow removes Zabbly and returns to Ubuntu’s kernel packages. If possible, boot an Ubuntu -generic kernel from GRUB before removing the Zabbly packages.

Remove Zabbly Kernel Packages

Build a list of installed Zabbly kernel packages, then remove only those installed packages:

zabbly_packages=$(dpkg-query -W -f='${binary:Package}\n' 'linux-*zabbly*' 2>/dev/null | grep -E '^(linux-zabbly|linux-image|linux-headers)' || true)

if [ -n "$zabbly_packages" ]; then
  sudo apt remove $zabbly_packages
else
  printf 'No installed Zabbly kernel packages found.\n'
fi

This avoids the noisy behavior that can happen when APT expands repository-wide regex matches for older Zabbly package versions that are available but not installed.

Remove the Zabbly Repository and Key

Delete the source and signing key, including the older paths used by previous versions of this article, then refresh APT:

sudo rm -f /etc/apt/sources.list.d/zabbly-kernel-stable.sources
sudo rm -f /etc/apt/sources.list.d/linux-zabbly.sources
sudo rm -f /etc/apt/keyrings/zabbly.asc /usr/share/keyrings/linux-zabbly.gpg
sudo apt update

Verify that the removed source no longer provides a live package candidate:

apt-cache policy linux-zabbly

After source cleanup, the Zabbly repository URL should no longer appear in the policy output.

Restore Ubuntu’s linux-libc-dev Package

On systems where Zabbly upgraded linux-libc-dev, reinstall the current Ubuntu archive version explicitly. A plain reinstall can keep the newer local package because its version is higher than Ubuntu’s candidate:

if dpkg-query -W linux-libc-dev >/dev/null 2>&1; then
  ubuntu_linux_libc_version=$(apt-cache madison linux-libc-dev | awk '{print $3; exit}')
  if [ -n "$ubuntu_linux_libc_version" ]; then
    sudo apt install --allow-downgrades "linux-libc-dev=${ubuntu_linux_libc_version}"
  fi
fi

APT should show a downgrade when the installed linux-libc-dev package still comes from Zabbly:

DOWNGRADING:
  linux-libc-dev

Reinstall the Ubuntu Kernel Metapackage

Reinstall your Ubuntu generic kernel metapackage so future Ubuntu kernel updates continue normally. The command keeps the current LTS HWE stack when that package is installed, otherwise it falls back to linux-generic:

ubuntu_release=$(lsb_release -rs)

if dpkg-query -W "linux-generic-hwe-${ubuntu_release}" >/dev/null 2>&1; then
  sudo apt install --reinstall "linux-generic-hwe-${ubuntu_release}"
elif dpkg-query -W linux-generic >/dev/null 2>&1; then
  sudo apt install --reinstall linux-generic
else
  sudo apt install "linux-generic-hwe-${ubuntu_release}"
fi

sudo update-grub

Reboot back into Ubuntu’s kernel:

sudo reboot

Verify the Zabbly Removal

After rebooting, confirm that the running kernel no longer uses the Zabbly suffix and that no installed Zabbly kernel packages remain:

case "$(uname -r)" in
  *-zabbly+) echo 'Zabbly kernel is still running' ;;
  *) echo 'Ubuntu kernel is running' ;;
esac

dpkg-query -W -f='${db:Status-Abbrev} ${binary:Package}\n' 'linux-*zabbly*' 2>/dev/null | grep '^ii' || echo 'No installed Zabbly kernel packages found'

Expected output after returning to Ubuntu’s kernel looks like this:

Ubuntu kernel is running
No installed Zabbly kernel packages found

Conclusion

The Zabbly kernel is now available on Ubuntu through a signed APT source, with a verified boot path, matching headers, and a tested rollback route to Ubuntu’s generic kernel. Keep the Ubuntu kernel installed as your fallback, and use the Linux kernel headers guide for Ubuntu if you also maintain DKMS drivers or build kernel-adjacent software.