Linux Mint inherits Ubuntu’s stable kernel tracks, which is usually what you want on a daily desktop. When newer hardware, upstream regression testing, or Incus-focused workloads need a mainline kernel sooner, the Zabbly kernel project packages current stable mainline Linux kernels for the Ubuntu bases used by Linux Mint.
To install a mainline kernel on Linux Mint with Zabbly, add the Zabbly APT repository with the correct Ubuntu-base codename, install the linux-zabbly metapackage, reboot, and keep Mint’s generic kernel available in GRUB as your rollback path. The workflow targets Linux Mint 22.x and 21.x, which map to Ubuntu 24.04 noble and Ubuntu 22.04 jammy.
Install Mainline Kernel on Linux Mint
Zabbly is a third-party kernel source, so do not remove your Linux Mint generic kernel. The fallback kernel is what lets you return through GRUB if the mainline kernel does not work with your firmware, storage controller, graphics driver, Secure Boot policy, or DKMS modules.
Check Your Mint Release, Kernel, and Architecture
Start by confirming the Mint release, Ubuntu base codename, package architecture, and currently running kernel. The Ubuntu codename is the value the Zabbly repository needs; the Mint codename, such as zena or virginia, is not valid for this repository.
. /etc/os-release
printf 'Linux Mint: %s\n' "$PRETTY_NAME"
printf 'Ubuntu base: %s\n' "$UBUNTU_CODENAME"
printf 'APT architecture: %s\n' "$(dpkg --print-architecture)"
uname -rExample output from Linux Mint 22.3 on the current HWE track looks like this:
Linux Mint: Linux Mint 22.3 Ubuntu base: noble APT architecture: amd64 6.17.0-29-generic
Linux Mint 21.x reports jammy instead and may still be running the 5.15 generic kernel before you install any alternate kernel.
Compare Zabbly With Other Mint Kernel Options
Use Zabbly when you specifically want a stable upstream mainline kernel with minimal distribution patching. If your goal is simply newer hardware support while staying closer to Mint’s normal support path, try the HWE kernel first.
| Kernel Option | Source | Best Fit | Trade-off |
|---|---|---|---|
| Linux Mint HWE kernel | Linux Mint and Ubuntu base repositories | Newer laptops, WiFi, storage, graphics, and virtualization support while staying on Mint’s normal package sources | Newer than GA, but still conservative compared with third-party mainline builds |
| Zabbly mainline kernel | Zabbly APT repository | Newest stable mainline kernel testing, early hardware support, and Incus-heavy systems | Less Mint and Ubuntu integration testing, Secure Boot caveats, and possible DKMS driver issues |
| XanMod kernel on Linux Mint | XanMod APT repository | Gaming, performance testing, and CPU-targeted desktop kernels | Custom patches and branch choices create a different compatibility profile than mainline |
| Liquorix kernel on Linux Mint | Launchpad PPA | Desktop responsiveness, audio production, and interactive workloads | Desktop-oriented tuning is not a general server stability target |
For Linux Mint, the relevant Zabbly stable suites are Ubuntu 24.04 LTS (
noble) and Ubuntu 22.04 LTS (jammy), which are the Ubuntu bases for Linux Mint 22.x and 21.x. The commands here target standardamd64Mint desktop installs. Zabbly also notes that these kernels are not signed by a trusted distribution key, so Secure Boot systems may need Secure Boot disabled or a separately managed signing workflow.
Update Linux Mint and Install Repository Tools
Refresh APT metadata first, then install the small toolset used to fetch and inspect the repository signing key.
sudo apt update
sudo apt install ca-certificates curl gpgThese commands use
sudobecause kernel installation changes system packages and boot entries. If your account cannot run administrative commands yet, follow the Linux Mint sudoers instructions before continuing.
If APT lists normal Mint package upgrades during the refresh, review and apply them before changing kernels. Kernel work is safer when the current package state is already clean.
Add and Verify the Zabbly Signing Key
Download the Zabbly key as an unprivileged file, install it into APT’s keyring directory, then display the fingerprint from the installed key. Compare it with the fingerprint in the official Zabbly repository instructions before adding the source.
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSLo zabbly.asc https://pkgs.zabbly.com/key.asc
sudo install -m 0644 zabbly.asc /etc/apt/keyrings/zabbly.asc
rm -f zabbly.asc
gpg --quiet --show-keys --with-fingerprint /etc/apt/keyrings/zabbly.ascThe curl -fsSLo flags make the download fail on HTTP errors, keep normal progress output quiet while still showing errors, follow redirects, and write the key to a named local file. The curl command guide covers those flags in more depth.
pub rsa3072 2023-08-23 [SC] [expires: 2030-08-17]
4EFC 5906 96CB 15B8 7C73 A3AD 82CC 8797 C838 DCFD
uid Zabbly Kernel Builds <info@zabbly.com>
sub rsa3072 2023-08-23 [E] [expires: 2030-08-17]
Continue only when the fingerprint matches 4EFC 5906 96CB 15B8 7C73 A3AD 82CC 8797 C838 DCFD. If it does not match, remove /etc/apt/keyrings/zabbly.asc and stop before writing the repository file.
Add the Zabbly APT Repository
Linux Mint reports its own codename from some tools, but vendor repositories normally need the Ubuntu base codename. The Linux Mint release table lists the Ubuntu base for each Mint series; the table here shows the mapping used by the source-writing command.
| Linux Mint Series | Mint Codenames | Ubuntu Base | Zabbly Suite |
|---|---|---|---|
| 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 |
Create the DEB822 source file from UBUNTU_CODENAME and the installed APT architecture. The guard accepts standard amd64 Mint 22.x and 21.x systems and prints a message instead of writing a broken source file if the Mint series or architecture does not match.
. /etc/os-release
ubuntu_codename="${UBUNTU_CODENAME:-}"
arch="$(dpkg --print-architecture)"
case "${ubuntu_codename}:${arch}" in
noble:amd64 | jammy:amd64)
printf '%s\n' \
'Enabled: yes' \
'Types: deb' \
'URIs: https://pkgs.zabbly.com/kernel/stable' \
"Suites: ${ubuntu_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
;;
*)
printf 'This workflow targets amd64 Linux Mint 22.x/noble and 21.x/jammy systems. No source file was written.\n' >&2
false
;;
esacThe sudo tee form writes the source file as root. A normal > redirect would still run from your unprivileged shell and fail against /etc/apt/sources.list.d/.
Check the generated source file before refreshing APT. Linux Mint 22.x should show Suites: noble, while Linux Mint 21.x should show Suites: jammy.
cat /etc/apt/sources.list.d/zabbly-kernel-stable.sourcesEnabled: yes Types: deb URIs: https://pkgs.zabbly.com/kernel/stable Suites: noble Components: main Architectures: amd64 Signed-By: /etc/apt/keyrings/zabbly.asc
Confirm the Zabbly Package Candidate
Refresh APT again, then confirm that the linux-zabbly candidate comes from the Zabbly repository.
sudo apt update
apt-cache policy linux-zabblyOn Linux Mint 22.x, relevant lines include a noble/main source from pkgs.zabbly.com:
linux-zabbly:
Installed: (none)
Candidate: 202605192323~amd64~ubuntu24.04
Version table:
202605192323~amd64~ubuntu24.04 500
500 https://pkgs.zabbly.com/kernel/stable noble/main amd64 Packages
Linux Mint 21.x shows the same repository path with jammy/main and an Ubuntu 22.04 package suffix:
linux-zabbly:
Installed: (none)
Candidate: 202605192322~amd64~ubuntu22.04
Version table:
202605192322~amd64~ubuntu22.04 500
500 https://pkgs.zabbly.com/kernel/stable jammy/main amd64 Packages
The build stamp changes as Zabbly publishes newer kernels, so focus on the repository suite, package source, and non-empty candidate rather than copying an exact version string.
Install the Zabbly Kernel Package
Install the Zabbly metapackage. It pulls in the current Zabbly kernel image and matching headers, which is the package pair DKMS-managed drivers need after the reboot.
sudo apt install linux-zabblyReview the transaction before confirming. On Linux Mint 22.x, the install can also upgrade linux-libc-dev from the Zabbly repository, while Linux Mint 21.x may install only the Zabbly image, headers, and metapackage.
The following additional packages will be installed: linux-headers-7.0.9-zabbly+ linux-image-7.0.9-zabbly+ linux-libc-dev The following NEW packages will be installed: linux-headers-7.0.9-zabbly+ linux-image-7.0.9-zabbly+ linux-zabbly The following packages will be upgraded: linux-libc-dev
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 versioned package names move as Zabbly publishes newer stable builds. The stable part is the metapackage name linux-zabbly, the -zabbly+ suffix on the installed image and headers, and the rollback path that removes those packages later.
Reboot Into the Zabbly Kernel
Reboot so GRUB can start the newly installed kernel.
sudo rebootKeep console or recovery access available for important machines. If the system cannot boot the Zabbly kernel, select a generic Mint kernel from GRUB’s advanced options and remove the Zabbly packages from that working session.
Verify the Running Zabbly Kernel
After the reboot, confirm that the active kernel has the Zabbly suffix and that the matching header tree exists for the live kernel string.
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'Zabbly kernel is running Matching headers are installed
Run uname -r separately when you need the full kernel version string. A current Zabbly boot returns a suffix like this:
uname -r7.0.9-zabbly+
If uname -r still ends in -generic, the package installed but GRUB did not start it. Select the Zabbly entry from GRUB’s advanced options once, or stay on the generic kernel and remove Zabbly if the alternate kernel does not fit your system.
Manage Zabbly Kernel Updates on Linux Mint
Zabbly kernel updates arrive through the same APT source you added during installation. Refresh metadata and review the Zabbly-related packages before you accept a kernel update.
sudo apt update
apt list --upgradable | grep -E 'linux-(zabbly|image-.*zabbly|headers-.*zabbly|libc-dev)' || trueWhen a newer Zabbly build appears, run the install command again so APT can pull in the next image and header pair. Keep the command interactive so you can review whether linux-libc-dev changes at the same time.
sudo apt install linux-zabbly
sudo rebootAfter the reboot, rerun the Zabbly suffix and header checks. Kernel updates are only complete after the system boots the new image.
Remove Zabbly Kernel from Linux Mint
Remove Zabbly only after booting a Mint generic kernel. Purging the kernel you are currently running can trigger package-manager warnings and leaves newer users with an avoidable recovery problem.
Boot a Generic Mint Kernel First
Reboot, open GRUB’s advanced options for Linux Mint, and choose a kernel entry that does not contain zabbly. After the system starts again, confirm that the active kernel is generic.
uname -r6.17.0-29-generic
On Linux Mint 21.x, the generic kernel may show a 5.15-family version instead. If the GRUB menu is hidden or too fast to select reliably, the Grub Customizer guide for Linux Mint can help with menu visibility and default-entry checks.
List the Installed Zabbly Packages
Check the package names before removing anything. The metapackage tracks the versioned image and header packages underneath it.
dpkg-query -W -f='${binary:Package}\t${db:Status-Abbrev}\t${Version}\n' 'linux-zabbly' 'linux-image-*-zabbly*' 'linux-headers-*-zabbly*' 2>/dev/null | sortlinux-headers-7.0.9-zabbly+ ii 7.0.9-amd64-202605182147-ubuntu24.04 linux-image-7.0.9-zabbly+ ii 7.0.9-amd64-202605182147-ubuntu24.04 linux-zabbly ii 202605192323~amd64~ubuntu24.04
Purge the Zabbly Kernel Packages
This command reads installed Zabbly package names from dpkg and passes only those names to APT. It avoids relying on shell globs for package names that contain moving kernel versions and a trailing plus sign.
dpkg-query -W -f='${binary:Package}\n' 'linux-zabbly' 'linux-image-*-zabbly*' 'linux-headers-*-zabbly*' 2>/dev/null | xargs -r sudo apt purgeRelevant removal lines include the Zabbly metapackage, image, and headers. Older generic kernels listed as autoremovable are separate from the Zabbly removal and do not need to be removed as part of this rollback.
The following packages will be REMOVED: linux-headers-7.0.9-zabbly+* linux-image-7.0.9-zabbly+* linux-zabbly*
Remove the Zabbly Repository and Key
Delete the source file and key, including older paths that some previous Zabbly instructions used, 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 updateAPT should stop finding the metapackage once the repository is gone. The exact wording can differ by Mint base release.
apt-cache show linux-zabblyE: No packages found
Restore Mint’s linux-libc-dev Package When Needed
If the install transaction upgraded linux-libc-dev from the Zabbly repository, downgrade it back to the package from Mint’s Ubuntu base after the Zabbly source has been removed. A plain reinstall can keep the higher local Zabbly version, so name the Ubuntu-base version explicitly.
if dpkg-query -W linux-libc-dev >/dev/null 2>&1; then
tmp_linux_libc_versions=$(mktemp)
apt-cache madison linux-libc-dev >"$tmp_linux_libc_versions"
ubuntu_linux_libc_version=$(awk '$0 !~ /pkgs.zabbly.com/ {print $3; exit}' "$tmp_linux_libc_versions")
rm -f "$tmp_linux_libc_versions"
if [ -n "$ubuntu_linux_libc_version" ]; then
sudo apt install --allow-downgrades "linux-libc-dev=${ubuntu_linux_libc_version}"
else
echo 'No Ubuntu-base linux-libc-dev candidate found; check your APT sources.'
fi
fiOn Mint 22.x, APT may show a downgrade after the Zabbly source is removed:
The following packages will be DOWNGRADED: linux-libc-dev
On Mint 21.x, the package may already be on the Ubuntu-base version and APT can report that it is already the newest version.
Reinstall the Mint Generic Kernel Metapackage
Reinstall the generic kernel metapackage that already belongs to your system. This keeps future Mint and Ubuntu-base kernel updates attached to the normal package track.
if dpkg-query -W linux-generic-hwe-24.04 >/dev/null 2>&1; then
sudo apt install --reinstall linux-generic-hwe-24.04
elif dpkg-query -W linux-generic-hwe-22.04 >/dev/null 2>&1; then
sudo apt install --reinstall linux-generic-hwe-22.04
elif dpkg-query -W linux-generic >/dev/null 2>&1; then
sudo apt install --reinstall linux-generic
else
. /etc/os-release
case "${UBUNTU_CODENAME:-}" in
noble) sudo apt install linux-generic-hwe-24.04 ;;
jammy) sudo apt install linux-generic ;;
*) echo 'No supported Mint generic kernel metapackage detected.' ;;
esac
fi
sudo update-grubAfter cleanup, confirm that the running kernel no longer uses the Zabbly suffix and that no installed Zabbly packages remain.
case "$(uname -r)" in
*-zabbly+) echo 'Zabbly kernel is still running' ;;
*) echo 'Linux Mint generic 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'Linux Mint generic kernel is running No installed Zabbly kernel packages found
Troubleshoot Zabbly Kernel on Linux Mint
APT Cannot Find linux-zabbly
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-zabblyThe Suites: value must be noble on Linux Mint 22.x or jammy on Linux Mint 21.x. If it contains a Mint codename such as zena, xia, or virginia, remove the source file and recreate it with UBUNTU_CODENAME.
Secure Boot Blocks the Zabbly Kernel
If firmware rejects the Zabbly kernel before Linux starts, return to a Mint generic kernel from GRUB’s advanced options. Zabbly states that these kernels are not signed by a trusted distribution key, so Secure Boot systems usually need Secure Boot disabled unless you maintain your own signing path.
Check the firmware state from Linux when mokutil can read EFI variables.
mokutil --sb-statePossible output includes enabled, disabled, or an EFI-variable limitation on systems where Linux cannot query firmware state directly.
SecureBoot enabled SecureBoot disabled EFI variables are not supported on this system
DKMS Modules Fail After the Zabbly Boot
Out-of-tree modules such as NVIDIA, VirtualBox, and some storage drivers rely on DKMS to rebuild against the active kernel headers. If graphics, virtualization, or hardware modules stop working after the reboot, check DKMS status first.
dkms statusIf an entry for the active Zabbly kernel is stuck at built instead of installed, trigger the rebuild again and retest the status.
sudo dkms autoinstall
dkms statusThe target state is an installed entry for the active uname -r kernel. NVIDIA users should also confirm that the driver branch supports the running kernel; the NVIDIA driver guide for Linux Mint covers the packaged driver path.
GRUB Does Not List the Zabbly Kernel
If the Zabbly image installed but does not appear in the boot menu, confirm the image exists under /boot, then regenerate the GRUB configuration.
ls /boot/vmlinuz-*zabbly*
sudo update-grubReboot after updating GRUB and check the advanced options menu again. Keep a generic Mint kernel installed before changing boot defaults.
Inspect Kernel Logs After a Zabbly Boot
When the system boots but hardware or drivers still misbehave, filter the current boot log for obvious warnings and failures before changing packages.
journalctl -k -b | grep -iE 'error|fail|warn' | head -n 20ACPI warnings can be firmware noise, repeated storage or USB errors can point to a regression, and module signature lines usually point back to Secure Boot or DKMS. If the same hardware works again under the generic kernel, keep the generic kernel as your default and remove Zabbly until the issue is fixed upstream.
Conclusion
Linux Mint can now boot a Zabbly mainline kernel from APT while keeping the generic Mint kernel available as a GRUB fallback. For a safer first stop on new hardware, use the HWE kernel on Linux Mint; for desktop tuning rather than upstream mainline behavior, compare the Mint guides for XanMod and Liquorix.
Formatting tips for your comment
You can use basic HTML to format your comment. Useful tags currently allowed in published comments:
<code>command</code>command<strong>bold</strong><em>italic</em><blockquote>quote</blockquote>