# Multikernel arrives on ARM64 and now runs on mklinux 7.0-mk5

> Multiple independent kernels on the same machine are no longer an x86-only affair and are being tested on Linux 7.0. What is gained and why it remains outside the tree.
> By José Maldonado · Technology · 2026-11-19

Several kernels coexist on the same machine, each with its own cores, its own drivers and its own user space. The Multikernel patches have been trying this on x86\_64 for more than a decade and have just crossed the border they were missing: version mklinux 7.0-mk5, announced on November 18, 2026, also works on ARM64, [as reported by Phoronix](https://www.phoronix.com/news/Multi-Kernel-mklinux-7.0-mk5). That is 114 patches on top of the previous release, and they remain outside the main tree.

If you administer Linux servers, there is nothing for you to do this week: Multikernel is not in your distribution and will not be any time soon. Nor is it an option you can enable in the kernel you already have: you have to boot one of its own.

It should be read for what it is: an engineering experiment published in numbered versions on top of the upstream kernel. What matters is not the release but the architecture: ARM64 is where computing has grown in recent years, between hyperscale servers and systems on chip, and a mechanism that exists only on x86 has an obvious ceiling. Hardware designers think twice before depending on a feature their architecture does not support, which is why this announcement reads differently from a performance patch.

## What Multikernel is and what problem it solves

A driver with a memory bug can take down an entire server. It only has to share the privilege space: in a monolithic kernel there is no wall between a module and the scheduler. Microkernels and virtual machines attack the problem along known paths; Multikernel proposes a third: several copies of the kernel isolated from one another, each with its share of the machine.

Each instance starts its own scheduler, its own drivers and its own user space. What on a normal server would be an operational absurdity becomes interesting when the goal is not performance but separation.

The most cited case is that of a real-time kernel on some cores and a general-purpose kernel on the rest. An industrial system needs predictable latencies on a subset of the machine, and building a complete real-time operating system for that is expensive. With Multikernel, that part keeps its cores and the rest carries on as a normal Linux.

Another case is recovery. With Kmorph, the project showed that a successor kernel can take over the cores, memory and devices of the one that fails, without rebooting: [the Kmorph handover](https://github.com/multikernel/kmorph) takes about a second from when Kmorph detects the silence until the successor is running, and the failed kernel's memory is left for later analysis.

Isolation is the third case. If an instance is dedicated to a specific workload, its drivers and its attack surface are separated from the rest. It is not the cage of a virtual machine, but it reduces the chance that a failure drags down the entire system. The [OpenAI test with 948 Linux flaws that allow administrator privileges to be obtained](https://observatorioblockchain.com/en/ai/openai-detecta-948-fallos-linux-tomar-control/) measures that surface.

## What version 7.0-mk5 brings

The base is kernel 7.0 from the main tree, with the project's patch set on top. The [release log](https://github.com/multikernel/linux/releases/tag/v7.0-mk5) counts 114 patches on top of the previous iteration and a changelog that describes the work behind it.

*   **ARM64 and AArch64**, the main novelty: each instance boots via PSCI, ARM's standard boot interface, and shares the GICv3 with the host as a tenant.
*   **Device loss**, with improvements in how an instance reacts when another takes a device down with it.
*   **DMA confinement**, so that a device handed to an instance does not write to memory belonging to others.
*   **VT-d integration and chained handovers**, the least showy part and the hardest to maintain.

DMA confinement decides whether this is useful outside the lab. When several instances share a bus and devices, a card's engine can write to any physical address if there is no input-output management unit to limit it. That class of bug turns an elegant experiment into data loss.

There is also an ABI change for anyone who has automated booting: the KEXEC\_FILE\_MULTIKERNEL flags moved to the upper half of the flags, so a loader compiled against the previous version has to be rebuilt. It is plumbing, and it silently breaks an integration.

The release also debuts precompiled packages for arm64, so testing it no longer requires compiling the kernel by hand. That detail separates a demonstration from something someone can install on a Friday.

## Why ARM64 changes the map

ARM64 support is not just another checkbox. The architecture reached servers through performance per watt and today underpins much of new computing, with boards that integrate CPU, GPU and accelerators in the same package. Splitting hardware between kernels requires understanding that topology, and on ARM device discovery does not work as it does on a PC.

The project explains it with an example: [it splits a 128-core arm64 server](https://multikernel.io/platforms/arm.html) into four domains of different sizes, each with its own kernel. These are the project's own figures, not an auditor's, and they should be read with that label attached: in embedded systems with heterogeneous cores the idea fits better than on a general-purpose server.

The missing part is still the same as on x86: full virtualization support, interrupt isolation and a boot model that does not depend on the firmware doing half the work. ARM64 opens the door, it does not solve the corridor.

## Why it remains outside the main tree

A change of this depth touches boot, memory management, interrupt distribution and the driver lifecycle, and none of those pieces can be changed without affecting every user of the main tree. The maintainers have said it in various ways: the design is interesting, the maintenance cost is not.

That is why the project lives in its own repository and publishes numbered versions that follow upstream. Each version forces the patches to be redone, and with a release every nine or ten weeks that is permanent work: the [release schedule published by kernel.org](https://www.kernel.org/category/releases.html) negotiates with no one.

For anyone administering systems, the consequence is simple: none of this enters their update cycle. And the other end of the problem can be seen in [CVE-2026-98432 in MPTCP, still unpatched in RHEL](https://observatorioblockchain.com/en/cybersecurity/cve-2026-98432-mptcp-linux-sin-parche/): being in the tree does not solve the calendar.

## The three use cases that justify the work

All three share a common trait: they are money problems. Reserving a few cores for a real-time kernel avoids buying a separate machine for deadline-bound tasks. Restoring service without rebooting avoids lost minutes. And separating workloads of different trust levels prevents third-party software from sharing a plane with the rest.

None of the three is a problem the home user has, which is why the project survives with few developers. The interest is not massive: it is persistent, and what is persistent tends to last longer.

The calculation is done in the same spreadsheet that decides server purchases. Those with fixed deadlines do not change architecture for fashion, and those who lose an hour of service to a broken driver pay for it every month the incident lasts. Multikernel does not compete for the best benchmark number, but for the worst case.

## An experiment that says a lot about the kernel

The history of Multikernel is also the history of how Linux changes: ideas that seemed impossible are tested outside, mature slowly and leave traces in smaller mechanisms. ARM64 does not turn it into a product, but it keeps it alive when more hardware is designed outside x86.

Two calendars are enough to keep track of it. One is the tree's, where [Linux 7.4 rc2 and its FAT32 patch](https://observatorioblockchain.com/en/technology/linux-7-4-rc2-fat32-162x-torvalds-ia/) set the pace; the other is the project's, which redoes its patches with each of those milestones.

The next version will tell whether arm64 is an architecture the project maintains or a box ticked once. If the 7.0-mk6 patches touch the ARM part again, the experiment will have two real architectures.
