↓ Skip to main content

Ubuntu's linux-firmware Split: What Dual-Kernel Users Need to Know

Ubuntu’s linux-firmware Split: What Dual-Kernel Users Need to Know

Linux hardware support depends on more than the kernel itself. Graphics cards, wireless adapters, audio controllers, and other devices often require separate firmware blobs loaded by their kernel drivers.

On Ubuntu, these files have traditionally been distributed through a shared linux-firmware package, with firmware for a wide range of devices installed under /lib/firmware.

That arrangement is becoming increasingly difficult to maintain as Ubuntu’s Long-Term Support (LTS) releases support two kernel tracks: General Availability (GA) and Hardware Enablement (HWE).

Canonical is working on a separate linux-firmware-hwe package to reduce regressions caused by backporting newer firmware for HWE kernels. The proposal addresses a real compatibility problem, but it also leaves an important gap: systems that keep both GA and HWE kernels installed will still use whichever firmware package set is currently installed.

This is particularly relevant to desktop users who keep an older kernel in GRUB as a recovery option.

📋 Where Does the Packaging Change Stand?
#

The proposal originated with Juerg Haefliger, Canonical’s linux-firmware maintainer.

On September 11, 2026, Haefliger opened a discussion on the ubuntu-devel mailing list titled “Entertaining the idea of linux-firmware-hwe”. He explained that firmware backports for HWE kernels had repeatedly caused problems for users running the older GA kernel.

His proposal was to introduce linux-firmware-hwe, along with HWE variants of the existing firmware subpackages. HWE kernels would use the newer firmware set, while GA kernels would retain the firmware set associated with their release.

The original proposal is available in the Ubuntu development mailing-list discussion.

By September 22, Haefliger had clarified the intended maintenance model in response to concerns about firmware updates and security fixes. The GA and HWE firmware collections would each receive targeted updates for reported problems rather than repeatedly importing large batches of firmware from newer releases.

The November 6 progress update described packages for Tenacious (Ubuntu 27.04) already built in a personal PPA, awaiting sponsorship and inclusion in the official packageset.

There was also a release-management complication: because the 26.10 archive was already open, the change for Stonking (Ubuntu 26.10) needed to follow the Stable Release Update (SRU) process.

As of November 19, 2026, linux-firmware-hwe is not listed in the official Ubuntu package search results. The archive does list the existing firmware metapackages and vendor-specific packages, but that is not the same as the proposed GA/HWE split.

You can check the current archive through Ubuntu’s linux-firmware package search.

In other words, this is an active packaging effort, not a change users can simply install today.

🧩 Why One Firmware Package Causes Problems for Two Kernel Tracks
#

Ubuntu LTS releases can provide two different kernel tracks.

Track Purpose Ubuntu 24.04 Example Ubuntu 26.04 Example
GA (General Availability) Original kernel track maintained throughout the release lifecycle Kernel 6.8 Kernel 7.0
HWE (Hardware Enablement) Newer kernel stack brought in from subsequent Ubuntu releases Kernel 6.17 / 7.0, depending on point release Kernel 7.3, planned

GA prioritizes continuity with the kernel shipped when the LTS release launched. HWE brings newer kernel support to existing installations, helping users with recently released hardware.

The problem is that newer kernels frequently need newer firmware.

Firmware Updates Are Not Always Backward-Compatible
#

Consider an Ubuntu 24.04 installation running the original GA kernel alongside a newer HWE kernel.

To support newly released hardware, Canonical may need to import firmware updates from a later Ubuntu release. Those updates can include files for:

  • AMD graphics processors.
  • Intel wireless adapters.
  • MediaTek network controllers.
  • Cirrus audio devices.
  • Other devices supported by Linux kernel drivers.

The difficulty is that these firmware files are shared through the same filesystem location.

The older GA kernel can therefore load firmware that was introduced primarily to support the newer HWE kernel.

That combination is not necessarily tested by the hardware vendor. A firmware image designed for a newer driver may behave differently when loaded by an older driver.

This is the compatibility problem Haefliger described in the September mailing-list discussion.

A Real Example: Ubuntu 24.04 Firmware Backports
#

Haefliger pointed to a firmware update for Ubuntu 24.04 that included the changelog entry:

Update firmware for linux-hwe-7.0

The update, identified as 20240318.git3b128b60-0ubuntu2.29, contained changes across several hardware families.

The AMD graphics section included both firmware reverts and re-applies. Other changes covered Cirrus audio, MediaTek networking, and Intel wireless devices.

According to Haefliger, the backport introduced at least two AMD regressions for users running kernel 6.9.

The important point is not that every firmware update breaks older kernels. It is that importing a large firmware batch for a newer kernel can unintentionally change the behavior of hardware on an older kernel.

That makes firmware backporting difficult to validate: one update can affect devices and kernel versions far beyond the immediate reason for the change.

Why Firmware Failures Are Particularly Difficult to Diagnose
#

A conventional software regression often produces an error message, failed service, or application crash.

Firmware failures can look more like hardware failures.

For example:

  • A wireless adapter disappears from the network manager.
  • An external monitor remains black.
  • Audio output falls back to a dummy device.
  • A graphics device fails to initialize.
  • A laptop stops resuming correctly from suspend.

The kernel log may contain messages indicating that a firmware file failed to load or that device initialization failed, but the visible symptom can be far removed from the actual cause.

This is why testing a new kernel with its corresponding firmware is not enough. The older supported kernel configurations must also be considered.

📦 The Proposed Solution: Separate GA and HWE Firmware Packages
#

Canonical’s proposal is to separate the firmware collections at the package level rather than maintain two copies of individual firmware files selected by the running kernel.

The intended relationship looks like this:

GA kernel  → linux-firmware
HWE kernel → linux-firmware-hwe

The HWE package is intended to contain the complete firmware collection corresponding to the newer kernel generation.

For example, Ubuntu 26.04’s HWE firmware set would be based on the firmware collection from Ubuntu 26.10, rather than importing individual firmware updates into the existing 26.04 collection.

This gives Canonical a clearer compatibility boundary.

Why the Packages Are Mutually Exclusive
#

The proposed package relationship uses Debian package metadata such as Provides and Breaks.

The intention is to prevent the regular and HWE firmware collections from being installed simultaneously as competing versions of the same firmware package set.

In practical terms:

Package Intended Role
linux-firmware Firmware collection for the GA kernel track
linux-firmware-hwe Firmware collection for the HWE kernel track
linux-firmware-hwe-amd-graphics HWE firmware for AMD graphics
Other HWE subpackages HWE-specific firmware for individual hardware families

The vendor-specific subpackages are important because Ubuntu has already been moving toward a more granular firmware package structure.

For example, Ubuntu 24.04 and later releases have firmware packages separated by hardware category, including AMD graphics, Intel graphics, wireless adapters, and other device families.

This makes it possible to organize the HWE variants around the existing package structure rather than invent an entirely different firmware distribution system.

Why Not Put Both Firmware Sets in Separate Directories?
#

A more flexible alternative was discussed on the mailing list.

Instead of making the packages mutually exclusive, Ubuntu could install different firmware collections into separate directories:

/lib/firmware/
├── hwe/
├── oem/
└── ...

The kernel could then resolve firmware requests through a version-specific path or a symbolic link.

Conceptually:

HWE kernel → /lib/firmware/<kernel-version> → /lib/firmware/hwe
OEM kernel → /lib/firmware/<kernel-version> → /lib/firmware/oem

This would allow multiple firmware collections to coexist, giving each kernel track access to its intended files.

The proposal was raised by AMD’s Mario Limonciello in the mailing-list discussion.

However, changing the firmware search layout is not a trivial filesystem operation. The conventional /lib/firmware path is assumed by many components and tools, including:

  • dracut
  • initramfs-tools
  • Kernel Snap build scripts
  • flash-kernel
  • Other firmware packaging and image-generation workflows

Each of these would need to be reviewed to ensure that firmware is found in the correct location.

Haefliger considered the approach technically possible but too complicated for the initial implementation.

The mutually exclusive package model is less flexible, but it avoids changing a path that a large part of the Linux boot and packaging ecosystem already expects.

An Empty Metapackage Is Not the Full Firmware Migration
#

One detail worth understanding is the staged rollout.

The initial linux-firmware-hwe package is expected to be an empty metapackage that depends on the existing firmware package. It does not initially introduce a second complete set of firmware files.

The actual firmware-bearing HWE packages are intended to arrive before the first HWE kernel for the relevant LTS release.

This means that the first appearance of linux-firmware-hwe in an archive does not necessarily mean that the firmware collections have already been separated in practice.

The package dependencies and contents must be inspected together.

⚠️ The Remaining Problem: Dual-Kernel Systems
#

The package split addresses one important scenario: a system running only the GA kernel.

It does not fully solve the problem for a system that keeps both GA and HWE kernels installed.

This limitation was explicitly acknowledged in Haefliger’s original proposal.

APT Selects the Firmware Package, Not GRUB
#

Consider a machine with two installed kernels:

Ubuntu 26.04
├── GA kernel 7.0
└── HWE kernel 7.3

Suppose the user installs linux-firmware-hwe.

The system now has the newer firmware collection installed under the standard firmware directory.

If the user boots kernel 7.3, the HWE kernel loads the HWE firmware as intended.

But if the user selects kernel 7.0 from GRUB, that older kernel still sees the same installed firmware files.

The firmware selection is controlled by the package installation and filesystem layout, not automatically by the kernel selected at boot.

The result looks like this:

                  Installed firmware
                         |
                  linux-firmware-hwe
                         |
                 /lib/firmware/
                    /       \
                   /         \
              GA 7.0       HWE 7.3
                 |             |
          Loads HWE firmware  Loads HWE firmware

The older kernel has not regained access to the firmware collection it originally used.

Why This Matters to Desktop Users
#

Keeping an older kernel is a common recovery strategy.

When a new kernel causes problems with graphics, wireless networking, suspend, or another device, users often return to an earlier kernel through GRUB.

That fallback is useful because it allows the machine to boot with an older driver stack.

But the recovery mechanism is less effective if the firmware files have already been replaced by a newer collection.

In other words, the kernel version changes, but the firmware environment does not.

This does not mean that every older kernel will fail with the newer firmware. Many firmware blobs remain compatible across multiple kernel generations.

The problem is that the package split cannot guarantee the older kernel receives the firmware set that was tested alongside it.

OEM Firmware Is a Separate Consideration
#

The mailing-list discussion also touched on OEM kernel support.

A possible directory-based design included a separate location for OEM firmware:

/lib/firmware/oem

The idea is to let OEM kernels use firmware collections selected for vendor-certified hardware configurations.

That is a separate compatibility problem from the GA/HWE split.

The current proposal focuses on separating the GA and HWE firmware collections. It should not be interpreted as a complete solution for every OEM kernel or vendor-specific firmware arrangement.

🔧 What Ubuntu Users Should Do Now
#

There is no reason to install unofficial firmware packages or change kernel configurations simply because the proposal has been announced.

As of November 19, 2026, the proposed linux-firmware-hwe package is not listed in the official Ubuntu package search results.

For now, the most useful step is to record your current kernel and firmware package state.

Run:

uname -r

This shows the kernel currently running.

Next, inspect installed firmware packages:

dpkg -l 'linux-firmware*'

Finally, list installed kernel images:

apt list --installed 'linux-image*'

Keep the output somewhere accessible. If a firmware-related regression appears after a future update, these records will help establish which kernel and firmware packages were installed before the problem occurred.

If You Use Only the GA Kernel
#

The proposed split should provide a clearer separation between the firmware collection maintained for your release and the newer collection intended for HWE users.

There is little to do until the official package transition arrives.

Continue using the normal Ubuntu update channels and avoid installing experimental packages unnecessarily.

If You Use HWE but Keep a GA Fallback
#

This is the configuration that deserves the most attention.

The HWE kernel may receive its intended firmware collection, but the older GA kernel will still use that same collection if the packages are mutually exclusive.

Do not remove your fallback kernel just to avoid a hypothetical compatibility problem. An older kernel may still be useful, and the new firmware may work perfectly well with it.

If a regression occurs, test the available kernel versions and inspect the kernel log:

journalctl -k -b

You can also look specifically for firmware-loading messages:

dmesg | grep -i firmware

These commands can help identify missing firmware files, failed loading attempts, and device initialization errors.

Be Careful With Firmware Downgrades
#

Downgrading the firmware package may restore an earlier firmware collection, but it is not always straightforward.

For example:

apt install linux-firmware=<old-version>

This works only if the requested version remains available through a configured repository, package cache, or snapshot source.

Before attempting a downgrade, inspect the package versions available to APT:

apt-cache policy linux-firmware

Also remember that a package downgrade affects the installed firmware collection globally. It does not selectively restore firmware for only the GA kernel.

Avoid personal PPAs and unofficial builds unless you understand their package dependencies and are prepared to recover from an inconsistent firmware installation.

🔍 What to Watch for During the Rollout
#

There are several milestones worth checking as Canonical moves from the proposal to actual archive packages.

Milestone What to Verify
Stonking SRU Whether the initial package transition reaches the official 26.10 archive
Resolute backport Whether Ubuntu 26.04 receives the corresponding package changes
HWE firmware deployment Whether the complete HWE firmware subpackages arrive before the first HWE kernel
Package dependencies Whether Provides and Breaks enforce the intended package relationship
Dual-kernel behavior Whether a GA kernel still loads the HWE firmware collection
OEM handling Whether OEM firmware remains separate or receives additional changes

The most important test is not simply whether linux-firmware-hwe appears in APT.

It is whether a system with both GA and HWE kernels can boot each kernel with the firmware collection intended for that kernel.

That is the difference between separating firmware packages and achieving kernel-specific firmware selection.

🧠 The Bigger Picture: Firmware Is Part of the Kernel Compatibility Stack
#

Linux firmware is often treated as a collection of static files that can be updated independently of the kernel.

In practice, the relationship is more complicated.

A kernel driver communicates with hardware using a particular firmware interface. A newer firmware image may introduce changes, fixes, or assumptions that are not suitable for an older driver.

This is why a large firmware update can cause regressions even when the kernel itself has not changed.

Canonical’s proposal recognizes that problem and attempts to make firmware maintenance follow the same release boundaries as kernel maintenance.

That is a sensible improvement over repeatedly importing large firmware batches into an LTS release.

However, package-level separation is not the same as runtime isolation. As long as GA and HWE kernels share the same /lib/firmware tree, only one installed firmware collection is available to both.

The unresolved dual-kernel case is therefore not a minor packaging detail. It is the main limitation that users who rely on older kernels as recovery options should keep in mind.

For more background on how Linux and UEFI divide responsibility during system startup, see UEFI BIOS Architecture and Boot Flow.

The real measure of success will be whether Ubuntu can eventually preserve a known-compatible firmware environment for each supported kernel track—not merely whether it can publish another package name.

Related