Linux Multikernel Project Reaches ARM64, Bringing Independent Kernels to the Same Physical Machine

Linux Multikernel Project Reaches ARM64, Bringing Independent Kernels to the Same Physical Machine

The Multikernel Linux project has reached an important milestone with the release of mklinux 7.0-mk5, introducing native ARM64 support and expanding its experimental architecture beyond traditional x86-64 systems. Announced by developer Cong Wang on November 17, 2026, the release allows multiple independent Linux kernels to operate simultaneously on a single physical machine without relying on a conventional hypervisor. Each kernel receives its own allocation of processor cores, memory, and hardware devices, allowing it to execute directly on the underlying system.

The new release builds on Linux kernel 7.0 and introduces 114 additional patches compared with the previous mklinux 7.0-mk4 version. The complete development tree now contains approximately 330 patches beyond the upstream kernel. Although ARM64 compatibility is the most significant addition, the update also improves PCI device isolation, DMA protection, interrupt management, communication between kernel instances, and mechanisms for transferring control of a machine from one kernel to another.

Multikernel Linux remains an experimental project rather than a feature available in standard Linux distributions. However, its continued development demonstrates an alternative approach to operating-system architecture, particularly for environments where fault isolation, predictable performance, and recovery from kernel failures are important.

Understanding the Multikernel Linux Architecture

Most Linux systems operate under a single kernel responsible for managing every processor, memory region, hardware device, and running application. Even when a server executes hundreds of containers, those workloads generally share the same kernel and depend on its ability to coordinate resources safely. Virtual machines provide stronger separation by running individual guest kernels, but they require virtualization infrastructure to manage the relationship between the guest operating systems and the physical hardware.

Multikernel Linux approaches this problem differently. Instead of placing several operating systems inside virtual machines, it divides the physical machine into independent resource domains and assigns each domain to a separate Linux kernel. A host kernel initially controls the system, reserves a collection of processors and memory, and launches another kernel using those resources. Once started, the additional kernel operates directly on its assigned hardware, maintaining its own scheduler, memory management, and device drivers.

This arrangement allows different kernels to serve different purposes without sharing every internal kernel subsystem. A general-purpose Linux instance could handle ordinary server workloads while another instance runs a real-time application on dedicated CPU cores. Because the kernels operate independently, a problem affecting one instance does not necessarily require stopping every other instance, although the degree of isolation depends on correct hardware and resource management.

The architecture also creates opportunities for replacing a running kernel or recovering from certain failures without performing a conventional system reboot. These capabilities remain experimental, but they are central to the project's long-term objectives.

ARM64 Support Opens the Door to More Hardware Platforms

Until this release, Multikernel Linux was limited to x86-64 systems. The addition of ARM64, also known as AArch64, expands the project to an architecture increasingly used in cloud servers, enterprise computing, embedded devices, and specialized hardware platforms. Supporting ARM64 required significant development because its processor startup procedures, interrupt controllers, firmware interfaces, and hardware descriptions differ from those used by conventional x86 systems.

The new implementation relies on the Power State Coordination Interface (PSCI) to start, stop, and release processors assigned to different kernel instances. PSCI provides standardized firmware operations for managing processor power states, allowing the host kernel to bring selected CPU cores online for a spawned kernel and confirm that those processors have stopped before transferring ownership again.

The release also introduces architecture-specific boot handling through kexec_file_load(). When launching another kernel, the host prepares an ARM64 kernel image and constructs a device tree describing the hardware resources assigned to that instance. The device tree includes information about memory, processors, and available devices, allowing the new kernel to initialize without assuming it controls the entire physical machine.

This approach is particularly important on ARM systems, where hardware configurations can differ substantially between manufacturers. Rather than depending on a universal PC-style hardware layout, Multikernel can provide each spawned kernel with a description of the resources it is permitted to use.

Running Independent Kernels Without a Hypervisor

The central distinction between Multikernel Linux and traditional virtualization is that its kernel instances execute directly on physical processor cores. In a conventional KVM environment, a hypervisor manages virtual CPUs and coordinates guest access to hardware resources. Modern hardware virtualization makes this process efficient, but it still introduces additional execution and management layers.

Multikernel instead assigns dedicated processors to individual kernels. Once a kernel has been launched, its scheduler operates on those cores without requiring the host to schedule its execution as a virtual machine. Memory is similarly partitioned, with the host removing assigned regions from its own active management structures before transferring them to another instance.

This design can be attractive for workloads requiring predictable processor behavior, particularly when administrators want to minimize interference from unrelated tasks. However, direct hardware ownership introduces its own challenges. Devices, interrupts, memory mappings, and communication channels must be coordinated carefully to prevent one kernel from interfering with another.

The architecture should therefore not be considered a universal replacement for KVM or containers. Each technology provides a different balance between isolation, flexibility, resource utilization, and operational complexity. Multikernel is primarily exploring what becomes possible when independent operating-system kernels share a physical machine without using the traditional virtualization model.

ARM64 Interrupt Handling Uses GICv3

Interrupt management represents one of the most technically demanding parts of the ARM64 implementation. Hardware interrupts notify processors when devices require attention, and the operating system must coordinate their delivery to the appropriate CPU. On modern ARM64 platforms, this responsibility is commonly handled by the Generic Interrupt Controller version 3, or GICv3.

In a normal Linux installation, one kernel manages the interrupt controller for the entire system. Multikernel cannot allow every independent kernel to modify the same global interrupt configuration because conflicting changes could disrupt devices or processors belonging to other instances. The new implementation therefore establishes a division of responsibility between the host and spawned kernels.

The host retains control of the global GICv3 distributor and Locality-specific Peripheral Interrupt configuration. Spawned kernels initialize only the redistributors and CPU interfaces associated with their assigned processors. This allows each instance to handle interrupts on its own cores while leaving shared interrupt infrastructure under centralized management.

For PCI devices, Message Signaled Interrupts are routed through the appropriate host-managed Interrupt Translation Service. This provides a way for assigned hardware to communicate with the correct kernel without granting unrestricted control over the system's interrupt configuration.

The implementation currently limits ARM64 spawned kernels to PCI devices rather than arbitrary platform devices. This restriction reflects the complexity of sharing integrated ARM peripherals that depend on globally managed interrupt resources.

PCI Device Leasing Improves Hardware Isolation

mklinux 7.0-mk5 introduces several improvements to PCI device assignment through a leasing mechanism designed to maintain clear ownership boundaries. When the host assigns a PCI function to another kernel, it binds that function to a stub driver and records the associated resources in a device lease. The approach resembles techniques used by vfio-pci and Xen's PCI backend infrastructure, where a device is reserved so that ordinary host drivers cannot simultaneously control it.

This arrangement prevents two kernels from independently configuring the same hardware device. Without a reliable ownership mechanism, conflicting driver operations could corrupt device state, interrupt active transfers, or cause failures that affect other workloads. The leasing model establishes a controlled process for assigning devices and returning them when they are no longer required.

The release also improves device cleanup when a lease ends. Before ownership is returned, the PCI function is reset while its memory access remains restricted. This helps prevent the device from continuing operations initiated by the previous kernel after control has changed.

These changes are especially relevant for systems that dynamically allocate hardware resources. A machine might assign a network adapter or storage controller to a specialized kernel for a particular workload, then reclaim the device when that workload finishes. Reliable device leasing makes such transitions more practical while reducing the risk of interference between kernel instances.

DMA Confinement Strengthens Memory Protection

Direct Memory Access, commonly called DMA, allows hardware devices to read and write system memory without requiring the CPU to handle every transfer. It is essential for high-performance networking, storage, and accelerator hardware, but it also creates an important isolation problem. A device assigned to one kernel must not be able to modify memory belonging to another kernel.

The new Multikernel release strengthens DMA confinement through hardware I/O memory management. On ARM64 systems, the implementation uses SMMUv3, while supported Intel systems rely on VT-d. These technologies allow the operating system to restrict which physical memory regions a device can access, creating a boundary between the device and memory belonging to unrelated workloads.

When a PCI function is assigned to a spawned kernel, its DMA mappings are limited to the memory owned by that instance. If the kernel's memory allocation changes, the corresponding mappings are updated to reflect the new boundaries. This ensures that hardware access restrictions remain aligned with resource ownership throughout the instance's lifetime.

The distinction is important because processor-level memory separation alone cannot provide complete isolation. A device capable of unrestricted DMA could potentially write into another kernel's memory even when the processors themselves respect their assigned regions. By combining memory partitioning with IOMMU protection, Multikernel establishes a stronger foundation for running independent kernels on shared hardware.

Intel VT-d Integration Receives Additional Improvements

Although ARM64 support receives most of the attention, mklinux 7.0-mk5 also introduces important changes for x86-64 systems using Intel VT-d. The update improves how IOMMU units and interrupt-remapping resources are assigned between kernels, particularly when one instance needs to assume control of hardware previously managed by another.

The host can now allocate blocks of interrupt-remapping entries to spawned kernels while validating changes made to those entries. This allows individual instances to configure interrupts for their assigned devices without gaining unrestricted access to interrupt resources used elsewhere in the machine.

The release also improves IOMMU ownership during kernel takeover. When a successor kernel assumes control after its predecessor has been stopped, it can claim the relevant IOMMU units without disabling address translation. Maintaining translation during the transition helps preserve DMA protection while hardware ownership changes.

These improvements are important because kernel replacement involves more than transferring CPU cores and memory. Devices may still have pending operations, and interrupt or DMA configuration must remain consistent while control moves between instances. The updated VT-d handling reduces the risk of exposing memory or interrupt resources during these transitions.

Chained Kernel Takeovers Expand Recovery Capabilities

One of Multikernel Linux's most ambitious features is the ability for a spawned kernel to take control of the physical machine from its host. This mechanism provides a foundation for kernel replacement and recovery from certain failures without performing a conventional reboot.

Earlier implementations already supported transferring control from an original host to a successor. The new release expands this capability through chained takeovers, allowing a kernel that has assumed control to become instance zero and prepare another successor. The process can be repeated, creating the possibility of multiple kernel transitions during a system's operational lifetime.

When a successor takes control, it can bring adopted memory online as kernel memory and acquire resources previously managed by its predecessor. The architecture is intended to support scenarios where a replacement kernel is prepared in advance and activated when the current kernel needs to be retired or has stopped responding.

This does not automatically guarantee uninterrupted application execution. A kernel takeover must still account for application state, device configuration, storage consistency, and service recovery. Nevertheless, the ability to transfer hardware ownership between independent kernels provides a different foundation for high-availability systems than traditional reboot-based recovery.

CPU Parking Changes Simplify Repeated Takeovers

The release also changes how parked processors are managed on x86-64 systems. During a takeover, processors associated with the previous kernel must be stopped before they can safely be assigned to another instance. Earlier implementations used parking structures associated with individual kernels, creating complications when a successor needed to locate processors stopped by another instance.

mklinux 7.0-mk5 introduces a machine-wide CPU parking table containing an entry for each processor. This allows a successor kernel to identify and wake parked CPUs without depending on a structure owned exclusively by its predecessor.

The new design supports chained takeovers because processor management no longer depends on a single original host remaining available. Once a kernel assumes control, it can coordinate processor ownership and prepare another transition using the same shared mechanism.

On ARM64, similar responsibilities are handled through PSCI, which provides standardized operations for starting and stopping processors. Although the underlying implementation differs between architectures, the objective is the same: ensure that processor ownership can be transferred safely between independent kernel instances.

ARM64 Kernel Shutdown Uses SDEI and Stop Interrupts

Safely stopping a kernel is another important part of the ARM64 implementation. A processor may be executing with ordinary interrupts masked, which can prevent conventional interrupt-based shutdown requests from reaching it. Multikernel therefore uses the Software Delegated Exception Interface, or SDEI, when supported by the system firmware.

SDEI provides a mechanism for delivering certain events even when normal exception handling is restricted. The project uses SDEI event zero to request that an instance stop, allowing the host to reclaim processors that might otherwise be difficult to interrupt.

When SDEI is unavailable, the implementation falls back to a stop interprocessor interrupt. To support this mechanism, ARM64 spawned kernels must boot with pseudo-NMI functionality enabled through the following kernel parameter:

irqchip.gicv3_pseudo_nmi=1

This setting is a requirement of the experimental Multikernel ARM64 implementation rather than a general recommendation for all ARM Linux systems. Its purpose is to ensure that the host can stop a spawned kernel when firmware-assisted shutdown is unavailable.

Together, these mechanisms help establish a reliable process for reclaiming CPUs before transferring them to another kernel. Without such coordination, a processor could continue executing instructions associated with an instance that no longer owns the corresponding hardware resources.

Shared-Memory Communication Connects Kernel Instances

Although Multikernel instances operate independently, they still require communication channels for certain operations. A spawned kernel may need console access, PCI configuration information, or a way to exchange messages with its host. The project provides these capabilities through shared-memory message rings and interprocessor interrupts.

Shared-memory rings allow kernels to exchange structured information through designated memory regions, while interprocessor interrupts notify the receiving instance when new messages are available. The transport supports console communication, PCI configuration-space operations, and AF_VSOCK connections.

The use of AF_VSOCK is particularly interesting because the interface is commonly associated with communication between virtual machines and their hosts. Multikernel adapts the same general communication model to independent kernels running directly on physical hardware.

The new release gives each parent-child relationship its own communication rings. This improves fault containment because a kernel that fails during a message transfer can disrupt its own communication link without necessarily corrupting the channels used by unrelated kernel instances.

This separation is consistent with the project's broader architecture. Independent kernels should not share more internal state than necessary, particularly when the objective includes recovering from failures that affect only part of the machine.

ARM64 Gains Framebuffer Console Support

mklinux 7.0-mk5 also improves console access by allowing a spawned kernel to receive the host's display through a simple-framebuffer interface. This is especially useful for servers managed remotely through a Baseboard Management Controller, or BMC.

Enterprise servers often provide remote keyboard, video, and mouse functionality through their management controllers. Administrators can use these interfaces to access the machine even when ordinary network services are unavailable or the operating system is not fully operational.

Without suitable framebuffer support, a spawned kernel might start successfully but provide limited diagnostic information through the server's existing remote display. The new implementation allows the host to transfer access to a basic framebuffer, making kernel console output available to the spawned instance.

This feature is primarily intended for debugging and system administration rather than graphical desktop use. It does not introduce a complete display server or desktop environment, but it can make early boot failures and kernel initialization problems easier to investigate.

Memory Hot-Remove Becomes More Reliable on ARM64

Memory reassignment is fundamental to the Multikernel architecture because the host must remove physical memory from its own management structures before assigning that memory to another kernel. Linux already provides memory hotplug infrastructure for adding and removing memory while a system is running, but applying those mechanisms to independent kernels introduces additional requirements.

The ARM64 implementation now handles partial memory removal more carefully when the requested region intersects a large linear-map entry. Depending on the mapping structure, the kernel can split the relevant entry or reject an operation that cannot be completed safely.

The release also improves cleanup of page tables and vmemmap structures when memory regions are removed. These structures describe how the kernel maps and tracks physical memory, so failing to release them correctly can leave unnecessary allocations or inconsistent mappings.

These improvements strengthen the process of transferring memory between kernel instances. When the host gives memory to another kernel, it must not continue treating that region as ordinary host-owned memory. Correct hot-remove behavior helps maintain that separation while supporting changes to the amount of memory assigned to each instance.

Userspace Tools Must Be Updated for the New ABI

The release introduces an Application Binary Interface change affecting the flags passed to kexec_file_load(). Multikernel-specific flags have been moved into the upper portion of the flags field to avoid conflicts with existing kernel definitions.

The new values are:

#define KEXEC_FILE_MULTIKERNEL 0x80000000
#define KEXEC_FILE_MK_ID_MASK  0x7fff0000

The previous definitions conflicted with flags used for contiguous memory allocation and device-tree handling. Moving the Multikernel values resolves these collisions and creates a clearer distinction between standard kexec functionality and the project's additional features.

However, the change means that userspace loaders compiled against mklinux 7.0-mk4 or earlier must be rebuilt. The project has released kerf 0.5.0, an updated version of its userspace management tool that supports the revised interface.

This compatibility requirement is particularly important for developers maintaining scripts or automated testing environments. Updating the kernel without updating the corresponding userspace tools could prevent instances from launching correctly.

Because Multikernel remains an out-of-tree project, changes to its internal interfaces are still possible as the architecture evolves. Users testing new releases should therefore treat the kernel and its management tools as closely related components.

Building and Testing mklinux 7.0-mk5

The Multikernel project provides source code and prebuilt Debian and RPM packages for both x86-64 and ARM64 systems. The packages use a configuration based on Ubuntu 26.04 with the Multikernel feature enabled, making it easier for developers to experiment without preparing every kernel configuration option manually.

Users who want to examine the source can clone the project's repository and select the release tag:

git clone https://github.com/multikernel/linux.git
cd linux
git checkout v7.0-mk5

The kernel configuration option responsible for enabling Multikernel support is:

CONFIG_MULTIKERNEL=y

Developers building a custom kernel must ensure that the appropriate architecture-specific dependencies and configuration options are available. A conventional kernel build may involve commands such as make olddefconfig and make -j"$(nproc)", although the complete procedure depends on the target hardware and development environment.

The project includes additional documentation under Documentation/multikernel/, covering architecture-specific behavior and the management of kernel instances.

Because Multikernel modifies fundamental kernel operations involving processors, memory, interrupts, and device ownership, it should be tested on dedicated development hardware rather than production machines. Administrators should also maintain a known-working kernel installation so they can recover if the experimental configuration fails to boot.

Current Limitations and Hardware Requirements

Despite the progress in mklinux 7.0-mk5, several limitations remain. On ARM64, spawned kernels currently receive PCI devices but not arbitrary platform devices. This is an important restriction because many ARM systems rely heavily on integrated peripherals that are not exposed through PCI.

The limitation is related to interrupt management. Platform devices may depend on shared interrupt infrastructure controlled by the host, making independent assignment more complicated than transferring a PCI function with appropriately managed interrupts.

The prebuilt kernel packages also lack debugging information and BPF Type Format metadata. This may restrict certain tracing and debugging workflows, particularly those that depend on detailed kernel type information. Developers requiring those capabilities may need to compile their own kernels with additional debugging options.

Another consideration is Secure Boot. The distributed packages are not signed for Secure Boot, so systems enforcing signature verification may reject them unless administrators configure an appropriate trust mechanism.

These limitations reinforce the experimental status of the project. Although the release demonstrates working ARM64 support, compatibility will depend on the platform's firmware, interrupt controller, IOMMU capabilities, and hardware configuration.

Multikernel Linux Compared With KVM and Containers

Multikernel Linux provides an alternative to existing isolation technologies, but it does not replace their established use cases. Containers isolate applications while sharing the same kernel, making them efficient for deploying services that do not require independent operating-system kernels. KVM virtual machines provide separate guest kernels through hardware-assisted virtualization, offering mature isolation and management capabilities.

Multikernel takes a different approach by assigning physical hardware directly to independent kernel instances. This removes the need for a traditional hypervisor during normal execution, but it also requires dedicated resources and introduces more complicated hardware ownership requirements.

For example, a container platform can distribute workloads dynamically across available processor cores, while a virtual machine can use virtual CPUs that share physical processors with other guests. A Multikernel instance instead operates on the cores assigned to it, potentially improving predictability but reducing flexibility when workloads need to share unused processing capacity.

The distinction becomes particularly relevant for specialized computing environments. A real-time workload might benefit from dedicated processor ownership, while an ordinary web application may be better served by containers or conventional virtualization.

The appropriate architecture therefore depends on operational requirements rather than a simple comparison of performance or isolation.

Potential Applications in Real-Time Computing

One of the most promising applications for Multikernel Linux involves real-time systems. These environments require operations to complete within predictable timing constraints, making interference from unrelated workloads a significant concern.

Linux already supports real-time computing through scheduling policies and the PREEMPT_RT infrastructure. However, even carefully configured real-time workloads may share certain kernel resources with ordinary applications running on the same system.

Multikernel offers the possibility of assigning a dedicated kernel to a specific group of processor cores while allowing another kernel to manage general-purpose workloads. This could help separate time-sensitive processing from background activities such as logging, package management, networking, or administrative services.

ARM64 support makes this approach particularly interesting because ARM processors are widely used in embedded computing, telecommunications, robotics, and industrial systems.

Nevertheless, independent kernel execution does not automatically guarantee real-time performance. Interrupt routing, memory access, device drivers, and application scheduling must still be evaluated carefully. Any system requiring strict timing guarantees would need extensive testing before adopting an experimental Multikernel configuration.

Kernel Recovery Without a Conventional Reboot

Another important area of research is recovery from kernel failures. In a conventional Linux system, a serious kernel panic can interrupt every workload running on the machine, often requiring a reboot before services can resume.

Multikernel explores a different recovery model by allowing another kernel to remain available as a potential successor. If the original kernel becomes unresponsive, a recovery mechanism can attempt to stop the failed instance, reclaim its hardware resources, and transfer control to the replacement.

The project's related Kmorph work has demonstrated how this architecture can support recovery without a conventional reboot. The new chained takeover mechanism extends that concept by allowing successive kernels to prepare additional replacements.

This could eventually be valuable for systems where availability is critical and restarting the entire machine introduces unacceptable delays.

However, recovering the kernel is not the same as restoring every application to its previous state. Services may still require restarting, storage operations must remain consistent, and device configuration must be recovered correctly. Multikernel provides an architectural foundation for these capabilities rather than a complete, production-ready recovery solution.

Why ARM64 Support Matters for Linux Development

The introduction of ARM64 compatibility demonstrates that Multikernel's architecture can extend beyond the processor family on which it was originally developed. Supporting a second major architecture requires developers to separate general Multikernel concepts from hardware-specific implementation details, making the overall design more adaptable.

The release also provides a broader environment for evaluating kernel isolation, device assignment, interrupt management, and recovery mechanisms. ARM64 systems differ substantially from x86-64 machines in their firmware interfaces and hardware organization, so successful support helps identify which parts of the architecture are portable and which require specialized handling.

At the same time, the approximately 330-patch development tree illustrates the complexity of the project. Maintaining changes across kernel releases requires ongoing work, particularly when those changes affect foundational subsystems such as memory management, processor initialization, and hardware interrupts.

There is currently no guarantee that the complete Multikernel architecture will be merged into the upstream Linux kernel. Its long-term development will depend on continued testing, technical review, hardware compatibility improvements, and the ability to maintain the project as Linux evolves.

Even without immediate upstream adoption, the work contributes to research into alternative kernel architectures and may influence future approaches to fault isolation and system recovery.

Conclusion

mklinux 7.0-mk5 represents a major step forward for Multikernel Linux by extending its experimental architecture to ARM64 systems. Released on November 17, 2026, the update allows independent Linux kernels to operate directly on separate portions of the same physical machine, expanding a design previously limited to x86-64 hardware.

The new ARM64 implementation introduces PSCI-based processor management, GICv3 interrupt coordination, device-tree-based hardware allocation, and support for assigning PCI devices to spawned kernels. Additional improvements strengthen DMA confinement, device leasing, Intel VT-d integration, shared-memory communication, and repeated kernel takeovers.

These capabilities create interesting possibilities for real-time computing, hardware isolation, and recovery from kernel failures without conventional reboots. However, the project remains experimental, with important limitations involving ARM platform devices, Secure Boot, debugging support, and hardware compatibility.

For Linux developers, the release demonstrates how operating-system resources can be divided between multiple independent kernels without relying on traditional virtualization. With ARM64 now supported alongside x86-64, Multikernel Linux has established a broader foundation for exploring new approaches to workload isolation, resource management, and system resilience.

George Whittaker is the editor of Linux Journal, and also a regular contributor. George has been writing about technology for two decades, and has been a Linux user for over 15 years. In his free time he enjoys programming, reading, and gaming.

Load Disqus comments