Multikernel Operating Systems: A Scholarly Survey of Recent Research

Introduction

Traditional OSes such as Windows and Linux were originally built for single‑processor machines. As core counts grew, the monolithic design faced scalability limits, especially due to lock‑protected shared kernel data. Multikernel operating systems treat a machine as a network of independent cores, eliminating implicit state sharing and using explicit message passing for coordination, thereby reducing cache‑coherency traffic and lock contention.

Barrelfish (ETH Zurich / Microsoft Research)

Barrelfish, first released in 2009, is one of the earliest multikernel OS prototypes. Each core runs an independent kernel instance; kernel data structures such as scheduler queues and page tables are replicated rather than shared. Cores communicate via asynchronous messages over a network‑like interconnect. The designers state three principles: (1) make all inter‑core communication explicit, (2) keep the OS structure independent of CPU architecture, and (3) treat OS state as replicated, not globally shared. Experiments on Intel’s 48‑core SCC and heterogeneous Xeon + Xeon Phi platforms show competitive performance and better scalability as core counts increase. The project remained a research platform (last release 2020) and has not been deployed in production.

fos – Decomposed OS (MIT CSAIL)

Developed around the same time, fos decomposes the OS into fine‑grained services (memory allocation, scheduling, file system, etc.) that run as server processes distributed across cores. Each core may host a server instance for a given service, improving locality by handling requests on the local core. The design mirrors cloud‑style distributed services, allowing the system to scale to over 1 000 cores. fos builds on a tiny microkernel that provides basic messaging and protection, while most OS functionality runs in user‑space servers. This architecture isolates OS services on separate cores, reducing competition with application threads and showing scalability advantages.

Popcorn Linux (Virginia Tech)

Popcorn, introduced in the mid‑2010s, implements a “replicated kernel” approach on top of Linux. Multiple Linux kernel instances are launched—typically one per core or core group—and coordinated as a single system via message passing. The runtime and compiler infrastructure enable transparent execution of applications across heterogeneous ISAs (e.g., x86 Xeon + Xeon Phi). In experiments, Popcorn achieved up to 52 % performance improvement over native Linux on heterogeneous cores by better load balancing and eliminating slow offload paths. Popcorn also demonstrates OS‑level support for cross‑core thread migration using Linux’s kexec mechanism.

Twin‑Linux (LinSysSoft Technologies)

Twin‑Linux, released in 2010, is an early multikernel prototype for Intel Core 2 Duo platforms. It runs independent Linux kernel instances on each core, using a modified GRUB bootloader to create SMP‑compatible boot sequences. By partitioning hardware resources (memory, PCI devices, network adapters) and assigning each kernel its own slice, Twin‑Linux isolates workloads, improves cache efficiency, and separates network I/O from storage I/O across cores.

HPC Multikernel Designs (IHK/McKernel)

In high‑performance computing, hybrid multikernel designs run a lightweight kernel (LWK) on a subset of cores for compute‑intensive threads while Linux handles I/O and system services on the remaining cores. RIKEN’s IHK/McKernel for the Fugaku supercomputer exemplifies this approach: McKernel reduces OS jitter and overhead, delivering modest but significant speedups (average 4 % over tuned Linux, up to 25 % in some cases) on Intel Xeon Phi‑based systems.

mOS (Intel)

Intel’s 2014 mOS architecture runs a full‑weight kernel (FWK, typically Linux) alongside an LWK on the same node. A hierarchical system‑call routing mechanism directs performance‑critical calls to the LWK, latency‑sensitive calls to Linux, and high‑latency calls to a remote OS node. Resource partitioning (memory via mem=, CPU via maxcpus=, device specialization) ensures isolation. The design minimizes changes to Linux, facilitating upstream integration, and uses explicit inter‑core communication and layered handling to avoid SMP bottlenecks.

RainForest (Chinese Academy of Sciences)

RainForest, presented in 2016, introduces a horizontal OS model that separates a supervisor (resource provider) from multiple sub‑OS instances (resource users). Each sub‑OS runs as an independent OS instance with its own physical resources, created, destroyed, and resized quickly. The system enforces strict resource partitioning (memory via E820, CPU via ACPI MADT, device specialization) and limits shared state. In a search‑service benchmark, RainForest improves throughput by 25.0 %–42.8 % and CPU utilization by 16.6 %–25.1 % compared with Linux, LXC, and Xen under a 200 ms tail‑latency constraint; Spark workloads see up to 2.60× speedup.

Other Related Research

K2 (2014) targets heterogeneous coherence domains on mobile SoCs (e.g., ARM big.LITTLE) by running independent Linux kernels per domain and using a “shared‑most” model to keep most services synchronized, improving energy efficiency while preserving the Android programming model. Security‑focused work such as the Composite OS demonstrates that isolated kernels on different cores can provide strong isolation.

Conclusion

Over the past decade, multikernel research has progressed from feasibility studies (Barrelfish, fos) to heterogeneous extensions (Popcorn, Twin‑Linux), HPC‑oriented hybrids (IHK/McKernel, mOS), and horizontally decomposed designs (RainForest). While industrial adoption remains limited, the body of work shows consistent performance, scalability, and reliability benefits, encouraging further collaboration between academia and industry.