WorksComputer Science
safeL4: Rethinking Safe-Language-Based Single Address Space Microkernels
Abstract
Microkernels provide good features such as high security, safety, and flexibility, but their reliance on hardware-based isolation leads to heavy performance overhead, limiting their widespread adoption. Although constructing single-address-space microkernels based on safe language-based isolation is a promising approach to addressing the performance issue, this approach still faces challenges in maintaining the principle of minimality and enforcing capability-based, fine-grained access control over system resources. We propose safeL4, an approach to constructing microkernels based on safe languages. It guarantees minimality through low-level abstractions for unsafe operations, and implements a capability system based on the safe language's object capabilities to achieve fine-grained access control over all operations on system resources. We implement a prototype system in Rust, and our evaluation results show that the primitives provided by safeL4 are, on average, 1.9 faster than those of seL4.
This work is licensed under a Creative Commons Attribution 4.0 International License.
ASPLOS ’27, Heraklion, Greece
© 2027 Copyright held by the owner/author(s).
ACM ISBN 979-8-4007-3012-2/2027/04
https://doi.org/10.1145/3845814.3850085
CCS Concepts: • Software and its engineering → Operating systems.
Keywords: Microkernel, Safe Language, Capability System
ACM Reference Format: Zheyuan Xu, Xiaobei Zhang, Zihan Li, Zekai Nie, Guangtao Zhu, Zhuang Lu, Qianying Zhang, Shijun Zhao, Haibo Chen, and Rui Hou. 2027. safeL4: Rethinking Safe-Language-Based Single Address Space Microkernels. In Proceedings of the 32nd ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 1 (ASPLOS ’27), April 11–15, 2027, Heraklion, Greece. ACM, New York, NY, USA, 18 pages. https://doi.org/10.1145/3845814.3850085
Introduction
Despite performance concerns, microkernels have long been regarded as offering significant advantages over monolithic kernels [35, 51], primarily in security, safety, and flexibility. First, microkernels adhere to the principle of minimality [50], ensuring that the trusted computing base (TCB) is as small as possible. Second, microkernels utilize capability systems [5, 44, 71] to implement fine-grained access control over system resources, thereby enforcing the principle of least privilege (PoLP) [39, 65]. The minimality principle and capability-based access control enable formal verification of the kernel [22], leading to the world’s first formally verified operating system (OS) kernel, seL4 [42, 59, 70]. Finally, by partitioning OS services into domains that can be updated or replaced independently, microkernels achieve high flexibility. In the remainder of this paper, we refer to the domains protected by the microkernel as protection domains [45].
Microkernels, due to their advantages, were once envisioned as the basis for all types of operating systems [51]. However, since the first generation of microkernels [1], they have been used mainly in embedded and safety-critical environments (i.e., essentially static systems). In contrast, monolithic kernels remain the most prevalent and widely adopted kernel architecture. Emerging scenarios, such as smart vehicles, smartphones, trusted execution environments, containers, and confidential virtual machines, have strict security and safety requirements and therefore favor microkernels [15, 54, 55, 72, 83]. These scenarios are no longer limited to embedded systems and involve running general-purpose applications that demand a broad range of OS functionality. Nevertheless, the hardware-based isolation used by microkernels imposes significant performance overhead in these scenarios, including context switches caused by inter-process communication (IPC), cross-address-space data transfers [20], and increased IPC frequency [15]. Although various measures have been proposed to mitigate the performance issues of microkernels, none has fundamentally solved the problem. For example, some OS designs [12, 15] place the most critical servers and drivers in the kernel, which conflicts with the principle of minimality; moreover, some measures duplicate kernel state across multiple servers [15], introducing extra overhead for state synchronization.
In fact, there is another technical approach that aims to design microkernels that do not rely on hardware-based isolation to eliminate the performance overhead, namely, the use of type-safe languages. These languages use type systems to define clear contracts for components (such as modules, structures, and functions), ensuring that each component interacts with others only through well-defined interfaces and preventing unauthorized access [13, 49]. Safe language-based microkernels and applications run in the same address space and the same CPU mode, i.e., a single-address-space OS (SASOS), but they still follow the common concept of a kernel, namely, “the part of the operating system that is mandatory and common to all other software” [50]. Such a language-based approach significantly reduces the performance overhead introduced by hardware isolation: cross-domain communication is simplified to function calls, and cross-domain data transfer is achieved via zero-copy object ownership transfer. Typical representatives of safe language-based microkernels include SPIN [3, 4], Singularity [24, 37, 38], and RedLeaf [60]. There are also some kernels that, although not explicitly claiming to be microkernels, have adopted certain microkernel features in their design, such as minimizing the TCB (Asterinas [62]) and fault isolation (Tock [47, 66], Theseus [7]).
However, current safe language-based kernels face two main issues in meeting microkernel requirements. First, these kernels lack a capability system for fine-grained access control over all system resources. A capability system is the principal mechanism microkernels use to restrict the system resources available to a protection domain (e.g., to eliminate ambient authority [58] and the confused deputy problem [31]), thereby enforcing PoLP and serving as a prerequisite for formal verification to achieve high trustworthiness. Consequently, modern microkernels such as seL4 [34], L4Re [41], and HongMeng [15] all adopt capability systems as a core mechanism. Unfortunately, conventional microkernel capability systems rely on hardware-based isolation to guarantee capability unforgeability, which incurs significant performance overhead when accessing capability-protected resources. Accessing a capability-protected kernel object in seL4 consumes 379 CPU cycles (Table 1), and this overhead primarily consists of CPU mode switching, capability lookup within the capability container (CNode), capability decoding (necessitated by the semantic gap between the user-space application and the kernel regarding capability metadata), and authority check.
| Mode switch | Cap lookup | Cap decode & authority check | Others2 | Total |
| 139 | 58 | 66 | 116 | 379 |
Table 1. Profile of the access of a kernel object in seL4 on the Raspberry Pi 3B+ board (in CPU cycles).
The second issue is that the TCB of such kernels tends to become large. First, beyond the kernel code, the TCB includes toolchain libraries and third-party dependencies linked
into the kernel image. Second, these kernels typically require all unsafe code to be encapsulated within the kernel, as allowing unsafe operations in protection domains would compromise the safe language-based isolation guarantees. We use the linked code size (LCS) metric [62] to count the total lines of code (LoC) linked into the kernel image. As detailed in Table 2, our evaluation of the functionality and LCS of several popular Rust-based kernels reveals that they do not follow the minimality principle, resulting in relatively large TCBs. Although Tock exhibits a smaller LCS, this is because it is a lightweight OS for low-power microcontrollers.
| OS | Minimality | LCS in the TCB: core + alloc | LCS in the TCB: Others2 |
| SPIN [4] | ✗ (memory mgr, thread mgr) | - | - |
| Singularity [38] | ✗ (memory mgr, process mgr, IO mgr, scheduler) | - | - |
| Tock [47, 66] | ✗ (process mgr, scheduler) | 1 911 | 2 903 |
| RedLeaf [60] | ✗ (memory mgr, scheduler) | 4 357 | 17 240 |
| Theseus [7] | ✗ (memory mgr, scheduler) | 8 720 | 40 459 |
| Asterinas [62] | ✗ (phy mem mgr) | 9 442 | 11 |
Table 2. Comparison of safe language-based kernels in terms of minimality principle adherence and TCB size.
To address the above issues, we propose safeL4, a Rust-based single-address-space microkernel. The core idea of safeL4 is to construct capabilities that do not rely on hardware isolation, treating them as a first-class abstraction to uniformly provide protection domains with system resource abstractions that satisfy the microkernel minimality principle and fine-grained access control requirements. First, based on Rust’s object capabilities (i.e., object references or pointers [9, 19, 29]), safeL4 constructs a capability system that does not require address space isolation for protection. It enforces fine-grained access control over system resources within a single address space (SAS), thereby reducing the performance overhead caused by crossing address spaces in traditional capability systems. Second, it adopts a microkernel approach to provide low-level abstractions for hardware resources and the communication functionality, and safely encapsulates only the essential unsafe operations, thereby reducing the TCB. Third, by utilizing a capability derivation tree and Rust’s visibility control, it solves the problem that Rust’s native object capabilities can neither record capability derivation relationships nor be revoked. This equips the capability system with interfaces of sufficiently rich semantics to support the kernel’s management of system resources.
The contributions of this paper are summarized as follows.
We propose an approach to constructing a capability system for system resources based on Rust’s features, which avoids the heavy overhead of hardware isolation-based capability systems and satisfies microkernels’ minimality principle as well as the requirements for capability-based fine-grained access control.
We address the issue that Rust’s native object capabilities fail to meet the management requirements of microkernels for system resources.
We build a prototype of safeL4 in Rust and implement core OS services. We support applications written in unsafe languages to run in user space. Evaluation results show that safeL4’s safe abstraction achieves 1.91× the performance of seL4 on average, with IDC performance improving by 7.8× to 22.3×.
Background
seL4 Capability System
The seL4 capability system governs access control for all kernel objects. Any call on a kernel object must be made through a capability for that object, which encapsulates a reference to the object and a specific set of access rights that dictate the operations an application is authorized to perform. By controlling the dissemination of these capabilities, the system enforces access control to kernel resources. The seL4 kernel uses a variant of the take-grant model [10, 21] to manage the propagation of authority via capabilities. In seL4, capabilities are stored in the kernel to prevent tampering by user-level programs. The collection of capabilities owned by an application constitutes its capability address space (CSpace). Each capability is assigned a unique address (index) that the application uses to reference it.
Object-Capability System
An object-capability system [57, 74, 75] is a security model that combines the principles of object-oriented programming with capability-based access control [48] to manage and restrict access to resources within a software approach. In this model, objects are treated as resources, object methods serve as interfaces to access those resources, and object references act as capabilities. In Rust, for instance, references and smart pointers can fulfill this role. Several memory-safe languages support object-capability models, including Java [53, 84], E [56], Encore [11], Pony [17], and Rust [36].
The unforgability of capabilities is fundamental to preventing unauthorized access. Consequently, an object-capability system must guarantee that object references cannot be forged. This requirement explains why, when using Rust, only its safe subset can enforce an object-capability model: unsafe Rust allows raw pointer manipulation that could trivially bypass reference unforgeability. For this reason, safeL4 mandates that all code executing within its isolated domains be written exclusively in safe Rust.
Related Work and Motivation
Safe Language-Based OSes
Hardware-based isolation leverages the MMU to place each domain requiring isolation into a separate address space. In contrast, safe language-based isolation does not require a separate address space for each domain; instead, it runs all domains within a single address space, and domains can only communicate through their exposed interfaces.
Language-based isolation enables OSes to achieve better performance. It avoids the privilege-level switches and address-space switches introduced by hardware isolation, converting cross-domain communication into function calls. However, this approach changes the trust boundaries of OSes and the assumptions upon which their safety guarantees rely. Hardware-based isolation relies on the CPU’s MMU mechanism; therefore, OSes utilizing this type of isolation must assume the security of the CPU hardware. Conversely, the isolation provided by safe languages relies on the language’s type system. Consequently, all components responsible for enforcing the type system must be included in the assumptions, including the compiler, standard libraries, and, for some languages, the runtime. As a result, the safe language-based isolation approach significantly increases the OS’s TCB. We list the TCBs of representative safe language-based OSes and the safety guarantees they provide in Table 3.
| OS / language | Trusted Computing Base | Safety guarantees |
| Earlier safe language-based OSes (1990s - 2000s) | ||
| SPIN<br>Modula-3 | Modula-3 compiler and linker; Modula-3 runtime, including its garbage collector, and standard libraries; SPIN core OS services; DMA-capable devices and their drivers. | Isolation between protection domains (named safe extensions); capability protection on system resources. |
| Singularity<br>Sing# | Bartok compiler and MSIL type-safety verifier; per-SIP runtime support, including its GC; Singularity microkernel code; DMA-capable devices and their drivers. | Isolation between protection domains (named SIPs); single ownership guarantee for exchanged objects; capability protection for system resources; contract-based communication between domains. |
| House<br>Haskell | GHC compiler and linker; modified GHC runtime, including its GC, and Haskell libraries; H monad (a hardware access interface layer), including its C and assembly code; DMA-capable devices and their drivers. | Formally defined hardware access interfaces (excluding DMA devices) that enforce memory safety and support building OSes in functional languages (Haskell). |
| J-Kernel<br>Java | JVM bytecode verifier; JVM execution engine, GC, and Java system classes; J-Kernel library, including its class loader; host OS and devices. | Isolation between protection domains; capability protection for exchanged objects. |
| Rust-based OSes (2015 - ) | ||
| Tock<br>Rust | Rust compiler and linker; Rust core library; kernel code and its dependencies; DMA-capable devices and their drivers. | Hardware-based isolation between processes; isolation between protection domains (named capsules). |
| Redleaf<br>Rust | Rust compiler, linker and RedLeaf IDL compiler; Rust core/alloc, allocator; kernel code base and its dependencies; DMA-capable devices and their drivers. | Isolation between protection domains; single ownership guarantee for exchanged objects. |
| Theseus<br>Rust | Rust compiler and linker; Rust core/alloc, allocator; kernel code base and its dependencies; DMA-capable devices and their drivers. | Isolation between protection domains (named cells); minimizing cross-domain state spill. |
| Asterinas<br>Rust | Rust compiler and linker; Rust core/alloc, allocator; OSTD and its dependencies; IOMMU and devices outside its protection. | Minimizing unsafe code and guaranteeing OS services are implemented in safe code and free of undefined behaviors. |
| Atmosphere<br>Rust | Verus frontend, Z3, Rust compiler and linker; Rust core, its formal specifications, and trusted axioms; proof helpers and low-level system code; IOMMU and devices outside its protection. | Machine-checked proofs establish functional correctness, memory safety, and leak freedom for the verified microkernel. |
Table 3. TCBs and safety guarantees of representative safe language-based operating systems.
Constructing kernels in safe languages has a long research history that can be divided into two phases. The first phase, spanning the 1990s and 2000s, explored using garbage-collected safe languages to build OS protection domains [2, 3, 4, 24, 27, 30, 37, 38, 82]. Representative microkernels in this phase include SPIN [3, 4], based on the Modula-3 language [14], and Singularity [24, 37, 38], based on Sing#. Beyond providing protection domains, SPIN and Singularity also use the object capabilities of safe languages to design unforgeable tokens for system resources, serving as proofs of authority for resource access. In addition, Singularity provides fault isolation for protection domains by enforcing that any memory shared between domains can only belong to one domain at a time (single ownership), preventing a crashing domain from affecting the rest of the system.
Contemporaneous with Singularity, there were also several OSes based on the Java language. J-Kernel [82] leverages Java’s type safety to establish boundaries between domains and designs a revocable capability for objects shared across domains, ensuring that any access from other domains to a crashed domain’s shared objects triggers an exception. KaffeOS [2] implements a process abstraction within a Java virtual machine (JVM) and provides isolated processes with mechanisms to manage resources such as CPU and memory. JX [27] implements a microkernel for managing hardware resources and uses the JVM as the unit of protection domains, running applications and services in different domains to achieve separation of privilege. However, because these safe languages rely on garbage collection, which can introduce unpredictable latencies, they conflict with the real-time requirements of some OS services [23, 46].
The second phase began with Rust, which uses ownership, borrowing, and lifetimes to provide memory safety without garbage collection. This advantage introduces new development costs. Rust compiler’s conservative borrow checker may reject safe programming patterns or require complex shared data structures to be reorganized, increasing development effort. Moreover, avoiding a garbage collector does not eliminate unsafe code: Rust’s unsafe mechanism enables operations beyond compiler checking, but makes programmers responsible for preserving Rust’s safety invariants. Consequently, Rust-based OSes [7, 16, 47, 60, 61, 62, 66] must carefully manage the distribution of unsafe code, because all such code lies within the TCB. The first version of Tock [47] aimed to provide isolation for low-end embedded applications, and now it provides capabilities to restrict access to privileged APIs [66]. RedLeaf [60] captures inter-domain faults to achieve fault isolation. Theseus [7] eliminates state dependencies [8] across domains. Asterinas [61, 62] introduces a framework that encapsulates the unsafe Rust required for kernel development, thereby minimizing the TCB.
Heavy Overhead of Current Microkernel Capability Systems
Conventional microkernel capability systems rely on hardware isolation to ensure capability unforgeability, which imposes a significant performance overhead on microkernels. First, capability operations must be delegated to the kernel for execution via system calls, thereby introducing mode-switching overhead. Second, in the multi-server scenarios of microkernels, if a capability operation involves multiple protection domains, it also entails the cost of address-space switching. To avoid these overheads, current safe language-based kernels do not adopt the traditional microkernel’s explicit, capability-centric authority model. Although this approach reduces the performance overhead associated with capabilities, it weakens the capability system’s advantages in areas such as PoLP.
Safe language-based single-address-space microkernels provide a new opportunity to re-examine the tradeoff between performance and security. First, object capabilities in safe languages no longer rely on hardware isolation to guarantee their unforgeability [9, 19, 29], which establishes the prerequisite for constructing a capability system within a single address space. Second, the SAS design eliminates the costly
Entries of the Trusted Computing Base column follow the same order: language or verification toolchain; language-specific runtime and libraries; trusted system code; and the IOMMU (or all devices when no IOMMU is used). All systems additionally assume correct CPU, memory, firmware, and boot behavior.
CPU mode and context switches involved in resource access. Furthermore, since protection domains and the kernel reside in the same address space, capabilities are invoked through typed interfaces, eliminating the overhead of decoding raw bytes to determine the capability type and the method being called. Therefore, safe language-based microkernels can achieve the security benefits of a capability system without incurring a high overhead.
must not only retain minimal hardware resource abstractions, but also design these abstractions as safe abstractions with sufficiently rich semantics. This enables protection domains residing in the same address space, particularly OS services such as file systems and device drivers, to be implemented entirely in safe Rust.
Fortunately, this presents a natural opportunity. The hardware resources that a microkernel must manage are precisely where unsafe code is most concentrated in a Rust OS. Therefore, these two requirements can be unified by encapsulating hardware resources as microkernel-style kernel objects, centralizing them within a minimal kernel that contains the unsafe code, and providing them to protection domains via safe interfaces. Furthermore, modern microkernels, such as seL4, demonstrate that high expressiveness can coexist with strict minimality, enabling the construction of many practical OSes based on a small TCB (on the order of 10k LoC) [25, 26, 43, 64, 67, 68, 76, 81].
Asterinas has already begun exploring the separation of safe and unsafe code within the intra-kernel address space. By encapsulating unsafe hardware operations within a privileged framework, it constructs the kernel’s memory-safety
New Minimality Requirement for Safe Language-Based OSes
Minimality is the core principle of microkernels. In safe language-based microkernels, however, minimality entails another requirement besides minimizing kernel functionality: unsafe code usage must be minimized. This is because the prerequisite for the isolation provided by a safe language is that the code within a protection domain must be implemented using only safe code. Otherwise, the type-safe guarantees of the language could be compromised. Consequently, any component containing unsafe code inherently becomes the system’s TCB. Therefore, safe language-based microkernels TCB in a principled manner. Asterinas aims to guarantee the memory-safety property of the entire kernel in a minimal way, thereby answering which unsafe operations must remain within the trusted framework. However, it still retains certain OS functionalities within the TCB, such as the physical memory manager, and it does not use capabilities for the unified granting, derivation, and revocation of authority over all system resources. Consequently, its privileged framework resembles an expressive safe OS development kit more than a microkernel constrained by principles such as minimality and PoLP.
Design
Overview
safeL4 is a safe language-based microkernel (see the right side of Figure 1). The safeL4 microkernel abstracts system resources as kernel objects and encapsulates them with capabilities. A protection domain uses a Rust crate (a Rust compilation unit) as an isolation boundary. All protection domains run in the same address space and at the same privilege level (kernel mode) as the microkernel. safeL4 requires that protection domains be implemented only in safe Rust, and that their use of hardware resources and IDC through the capabilities. safeL4 supports two types of applications: safe tasks and user-level tasks. Safe tasks are OS services or applications that are written in safe Rust and run within protection domains. User-level tasks run in user space and are isolated by hardware, supporting legacy applications written in unsafe languages that invoke OS services within protection domains via POSIX system calls.

Figure 1. Comparison between hardware isolation-based microkernels and safeL4 (EP: Endpoint; Dev. Mem.: DeviceMemory; PT: PageTable; IRQ: Interrupt; UT: Untyped; FRM: Frame; NTFN: Notification).
safeL4 builds a capability system based on Rust smart pointers, enforcing fine-grained access control over all system resources. safeL4 adheres to the minimality principle of microkernels by adopting a microkernel-like approach that provides low-level safe abstractions of hardware resources and by providing safe abstractions for non-privileged instructions and the basic data structures that must be implemented with unsafe Rust. These abstractions ensure that protection domains can implement their logic entirely in safe Rust. Furthermore, safeL4 confines a domain’s failures within itself through fault isolation.
Trusted Computing Base and Safety Guarantees
The safety of a safeL4-based OS relies on a trusted computing base and a set of execution assumptions. Under these assumptions, safeL4 provides protection domains with two safety guarantees: language-level memory and type safety, and capability safety.
Trusted components and assumptions (TCB). (1) We trust the Rust compiler to enforce the language-safety guarantees of safe Rust, and the linker to correctly produce the final binary. (2) We trust Rust’s core/alloc libraries, the global heap allocator, and the safeL4 microkernel and its dependencies to correctly implement their safe interfaces. (3) We assume that every protection domain and all of its third-party dependencies are implemented in safe Rust. The only trusted dependencies permitted to contain unsafe code are Rust’s core/alloc libraries and the safeL4 microkernel and its dependencies. (4) We trust the boot firmware, loader, and safeL4’s initialization code to establish a well-formed initial state. (5) We assume that the processor, memory, platform hardware, and peripheral devices behave according to their specifications. Because unrestricted DMA can bypass Rust’s language safety, safeL4 trusts DMA-capable devices, their drivers, and DMA configurations to confine DMA to authorized buffers, consistent with safeL4’s memory-access and DMA assumptions. The current safeL4 does not support IOMMU-based DMA isolation. A future extension of safeL4 to isolate devices via a correctly configured IOMMU would remove DMA-capable devices and their drivers from the TCB.
About four safe notions related to this paper. ❶ General safety refers broadly to safety properties such as functional correctness and crash freedom. ❷ Safe Rust refers to Rust code that itself does not contain unsafe code and benefits from the safety guarantees provided by the Rust language, such as memory safety, type safety, and data-race freedom. ❸ Safe Rust interfaces (e.g., Asterinas’s OST interfaces and safe abstractions presented in this paper) have safe function signatures, but their implementations may contain unsafe code. Nevertheless, their implementations must semantically satisfy Rust’s safety requirements [40]. ❹ Safe Rust over device interfaces refers to safe Rust code that controls devices through safe Rust interfaces. Although the code itself is written in safe Rust, hardware-induced changes to device state may undermine Rust’s safety guarantees (e.g., the MMIO access use case in 6.6).
Safety guarantees. safeL4 provides the following two safety guarantees to protection domains.
Language-level memory and type safety. safeL4 encapsulates its unsafe code behind safe abstractions (safe notion ❸), allowing protection domains to be written in safe code and thereby retain Rust language’s safety (safe notion ❷). For safe Rust over MMIO devices, safeL4 provides the safe abstraction DeviceMemory, but it does not guarantee that drivers program devices correctly and such non-guarantees are discussed below.
Capability safety. Capability safety mainly includes two aspects. (1) Capability-protected resource access. Capabilities act as tokens to kernel objects that abstract hardware and communication resources. Rather than exposing raw pointers or hardware directly to a protection domain, a capability authorizes method invocations on its corresponding object, strictly governed by its associated rights. (2) Safety properties of the capability system. As detailed in § 5.1.1, safeL4 enforces capability unforgability and non-bypassability, tracks capability provenance, preserves rights monotonicity, and ensures revocation correctness. These properties govern all invocations on capability-protected kernel objects.
Non-guarantees. safeL4 does not guarantee general safety (safe notion ❶) for protection domains, such as functional correctness. It also does not guarantee that driver code written in safe Rust (safe notion ❹) programs devices correctly: such code may use the DeviceMemory provided by the safeL4 microkernel to corrupt memory or compromise the system, for example through DMA misuse or violations of device protocols. We note that higher-level device-safety guarantees, such as preventing device-protocol violations, could be layered on top of our DeviceMemory API, for example via typestate checks as in Abacus [63].
Capability System
The capability system encapsulates safe abstractions of system resources and serves as the interface that safeL4 exposes to protection domains.
Capability System Design
In Rust, the combination of Arc and Weak smart pointers is a common pattern for shared ownership. Its semantics fit the basic sharing requirements of capabilities, and many Rust-based operating systems use this native mechanism to implement capabilities for shared resources. However, for a strict capability system, such as one that supports the take-grant model [32, 52], directly using Arc and Weak as capabilities introduces the following two issues.
Issue 1: Arc/Weak cannot support revocation semantics. In a capability system, subjects must be able to revoke resources they have shared. However, the semantics of Arc prevent such revocation. Once subject A duplicates an Arc and passes it to subject B, A cannot perform a revocation as long as B still holds that Arc. Additionally, the fact that Arc/Weak cannot represent multi-level capability derivation hierarchies prevents revocation. For example, suppose domain A owns a kernel object through an Arc and shares it with domain B as a Weak, and domain B then shares it with domain C. Arc/Weak cannot track the derivation relationship between domains B and C. As a result, in the sharing chain “A→B→C”, domain B cannot revoke domain C’s access to the kernel object.
Issue 2: Weak::upgrade prevents revocation. When a domain calls Weak::upgrade(), it obtains an Arc and can hold the corresponding kernel object indefinitely. While this behavior is acceptable in common Rust programs, it is problematic in a capability system: if a protection domain can hold the upgraded Arc indefinitely, the original resource owner cannot revoke it.
To address the two issues, we combine Rust’s Arc/Weak with a capability derivation tree (CDTree) and propose the capability system as follows (Listing 1). ❶ Each kernel object is wrapped in an Arc<RwLock<KObj>>, called RawCap, which ensures synchronized concurrent access to the object. ❷ The capability system does not expose RawCap directly to protection domains. Instead, it provides a wrapper called Cap. Cap is a public struct visible to protection domains, but its internal fields are marked pub(crate), restricting their visibility only to the microkernel. ❸ The microkernel maintains the CDTree, a private global tree composed of CdtNode, to record derivation relationships among capabilities. For all capability operations (e.g., derive, mint, revoke), the capability system maintains the following invariant: each node (CdtNode) in the CDTree has a 1:1:1 correspondence with a RawCap and its associated Cap. ❹ The microkernel exposes a procedural macro that allows protection domains to invoke methods of the kernel object by a capability. ❺ Each Cap contains a private field rights that specifies its authorities.
For Issue 1, our solution is to enforce revocation semantics by maintaining the derivation relationships when resources are shared via Arc/Weak. We bind CDTree maintenance to the Cap operations built on Arc/Weak, ensure the CDTree retains ownership of the RawCap, and restrict domains to holding only a Weak to the RawCap through the Cap. Figure 2 shows the changes in the CDTree when performing capability derivation and revocation operations.

Figure 2. Derivation and revocation of the capability system.
pub(crate) struct RawCap {
pub(crate) object: Arc<RwLock<KObj>>,
}
pub(crate) struct CdtNode {
pub(crate) cap: Arc<RawCap>,
pub(crate) child: Vec<Arc<Mutex<CdtNode>>>,
}
pub struct Cap {
pub(crate) raw_cap: Weak<RawCap>,
pub(crate) rights: Rights,
pub(crate) cdt_node: Weak<Mutex<CdtNode>>,
}
Listing 1. Struct definitions in safeL4’s capability system.
State 1 → State 2: When domain A derives a Cap for domain B, the capability system clones the RawCap and creates a new CdtNode to hold it. It then uses this CdtNode and the cloned RawCap to create a new Cap, returning this new Cap to domain A. Domain A can then share the derived Cap with domain B.
State 2 → State 3: When domain A revokes the Cap, the capability system locates the CdtNode via the Cap and drops the derived CdtNode. Consequently, the RawCap owned by the derived CdtNode is dropped as well. Thereafter, although domain B still holds the derived Cap, when it attempts to invoke the kernel object through this Cap, upgrading the Weak to the RawCap will fail.
For Issue 2, our key insight is that the capability system must limit the scope of Weak upgrades, and this enforcement must be guaranteed by the microkernel. safeL4 enforces this by making the RawCap visible only within the microkernel crate using pub(crate), preventing protection domains from directly upgrading the Weak reference inside a Cap. safeL4 provides a procedural macro interface that redirects the kernel object method invocation to a public proxy function, which upgrades a Cap’s inner Weak (see § 6.3 for details). This ensures that all Weak upgrades occur only within the proxy function; thus, the lifetime of the upgraded Arc, and consequently the duration of resource access, is strictly controlled by the microkernel.
Security Analysis of the Capability System
Capability unforgeability. In safeL4, protection domains are restricted to safe Rust, meaning they can only create capabilities through the capability system’s public APIs. While safe Rust allows creating a raw pointer and performing pointer arithmetic (e.g., using ptr::wrapping_add) to point to a capability or other sensitive data, an attacker cannot exploit these operations to break the safety enforced by safe Rust. Any attempt to dereference such a raw pointer would require unsafe code blocks, which are disallowed in protection domains. Moreover, all safe interfaces of the safeL4 microkernel do not accept raw pointers as parameters. Therefore, attackers cannot convert a forged raw pointer into a valid capability through safeL4’s safe interfaces.
Protection domains cannot bypass the capability system. The pointer to the kernel object within a capability is encapsulated as a private field, preventing direct dereferencing in protection domains. In addition, each kernel object is defined as a private structure within the microkernel, ensuring that protection domains cannot instantiate or directly access kernel objects, nor can they directly call their methods to bypass the authority check. Consequently, the procedural macro provided by the microkernel is the only interface through which protection domains can invoke operations on the kernel objects referenced by capabilities.
Provenance of a capability. Every capability is either created by the safeL4 microkernel for a resource allocated during boot, or derived at runtime from an existing capability. For capability operations such as copy and revoke, the capability system maintains a one-to-one correspondence between each capability and a node in the CDTree. Therefore, any capability can be traced along the CDTree derivation relation back to a root capability created during boot.
Monotonicity of capability rights. All capability transition operations are implemented within the microkernel. For derivation operations such as copy and mint, the microkernel ensures that the rights of a derived capability are a subset of those of its parent. Capability rights are therefore monotonically non-increasing along every derivation path in the CDTree.
The Minimality Design
In the context of safe language-based microkernels, the minimality principle requires not only that the microkernel provide the minimum functionality, but also that it provide safe abstractions for all necessary unsafe operations, thereby ensuring that protection domains can be implemented exclusively in safe Rust. To maintain minimality, safeL4 provides low-level safe abstractions for the following main categories of unsafe operations.
Low-level safe abstraction for system resources. The first design principle for maintaining kernel minimality in safeL4 is to adopt the microkernel approach to constructing low-level abstractions for system resources. Inspired by seL4, we abstract fundamental hardware resources (CPU, memory, and I/O), privileged instructions, and communication functionality into corresponding kernel objects, and expose their interfaces as object methods. safeL4 requires the method signatures of kernel objects to be strictly safe, while their implementations may use unsafe code.
For CPUs, the TCB (thread control block) object encapsulates access to and modification of CPU registers. Physical memory is abstracted as Untyped and Frame objects: Untyped objects represent allocatable physical-memory regions, while Frame objects provide methods for accessing and mapping frames. Memory-mapped I/O (MMIO) devices are represented as DeviceMemory objects that provide safe methods for volatile read and write operations on device registers. Interrupts are represented by Interrupt objects, which can be bound to Notification objects for delivering interrupt events. For privileged instructions, safeL4 follows seL4’s approach by wrapping them in the methods of kernel objects. OS services invoke these privileged instructions through these methods. We design the Endpoint object to handle synchronous communication, and use Notification objects for asynchronous communication. The low-level implementations of several of these objects use unsafe Rust because they manipulate raw memory or registers that Rust cannot validate. These safe abstractions are trusted to ensure that unsafe operations do not violate Rust’s type safety guarantees, exposing safe interfaces to protection domains.
Safe abstraction for non-privileged instructions. The Rust core library provides wrappers for a subset of non-privileged instructions. For non-privileged instructions not covered by core that are required in device driver development, such as timer read and memory barrier instructions, safeL4 encapsulates them as safe functions in a library crate for protection domains. These wrappers use unsafe Rust because inline assembly may rely on conditions that rustc cannot fully verify. They are trusted to satisfy Rust’s inline-assembly contract [80] for every call.
Safe abstraction for basic data structures. Some fundamental data structures commonly used in Rust programs rely on unsafe code in their efficient implementations, including synchronization primitives (e.g., Mutex, RwLock) and heap-allocated collections (e.g., HashMap, LinkedList). The microkernel encapsulates these basic data structures and provides safe interfaces to protection domains. Rust’s ownership rules make efficient implementations of shared mutable or pointer-linked data structures difficult using only safe Rust. Their unsafe implementations are therefore trusted to preserve the ownership, initialization, aliasing, and synchronization invariants promised by their safe interfaces.
Some unsafe code is not exposed to protection domains through safe abstractions, but is used internally to implement the safeL4 microkernel’s own functionality. Typical examples include (1) the stack unwinder used in panic handling; (2) small amounts of assembly used in trap entry and return; and (3) unsafe code in the dependency tree of safeL4’s procedural macros, which generates IDC and capability-invocation code.
Notably, safe abstractions do not eliminate unsafe code but rather confine it, providing safe interfaces to keep protection domains free of unsafe code. Therefore, any undefined behavior or arbitrary memory corruption introduced by unsafe code within them will still violate safeL4’s safety guarantees.
Fault Isolation
Because the safe language-based microkernel and its protection domains share a single address space, a panic in one domain will propagate and crash the entire OS. Therefore, safeL4 must provide a fault isolation mechanism to capture panics permitted by the safe language, such as Rust’s panics.
Inspired by some Rust-based OSes [7, 60, 62], we implement a lightweight fault isolation mechanism. When a protection domain invokes another domain via a synchronous IDC, safeL4 inserts fault isolation logic at the invocation point using a Rust procedural macro (see § 6.2 for details). If a thread panics within the callee domain, the failure is captured at the call site. safeL4 unwinds the stack frames in the callee domain and cleans up the associated resources. The caller domain then receives an error from the IDC.
Implementation
The safeL4 Microkernel
The safeL4 microkernel provides system resource operations to protection domains by implementing a set of kernel objects, including TCB, Untyped, DeviceMemory, Frame, PageTable, MPI, Notification, Interrupt, and Endpoint. All these kernel objects are accessed via capabilities. In addition, the microkernel provides safe interfaces for non-privileged instructions and basic data structures.
Inter-Domain Communication
safeL4 supports both asynchronous and synchronous IDC. The asynchronous IDC is built on the Notification object. In addition to supporting the asynchronous semantics of seL4’s Notification (e.g., signal, wait, and poll), safeL4 extends it with a message-passing mechanism based on zero-copy ownership transfer, enabling efficient asynchronous communication between domains.
We implement synchronous IDC based on the Endpoint object. The callee domain uses link-time registration to register its interface with the microkernel, and then Endpoint uses the registered interface to invoke the callee domain.
Link-Time Registration for Callee Crate
Since the microkernel crate is a dependency of all protection domains, it cannot directly reference any domain crate. Otherwise, it would lead to a circular dependency.
To resolve this, we modify the linking phase of the microkernel and protection domains. Each callee crate uses trusted_kernel_export!, a Rust attribute macro provided by the microkernel, to annotate the functions it intends to export to other domains and the microkernel (Listing 2). During linking, the linker aggregates all exported interfaces from callee crates into a designated section of the compiled image. Each interface can be identified by a unique key consisting of the callee’s crate name and its function signature (including function name, parameter types, and return type). When loading the callee image, the microkernel parses this section to obtain the interfaces of the callee and stores their function pointers for later invocation.
// in MemoryManager (callee crate)
#[trusted_kernel_export]
pub fn ut_alloc_frame() -> Result<Cap, UtError> {
UT_MANAGER.lock().do_alloc::<Frame>(
FRAME_SIZEBIT)
}
// in ProcessManager (caller crate)
fn alloc_frame_cap() -> Result<FrameCap, UtError> {
trusted_kernel_invoke!(mm::ut_alloc_frame() ->
Result<Cap, UtError>).unwrap()
}
Listing 2. Example code of registering an interface.
Runtime IDC Invocation
An Endpoint uses the procedural macro trusted_kernel_invoke! (Listing 3) to invoke the callee domain’s interface. The macro first performs a type matching to ensure that the parameters passed by the caller crate conform to the requirements of the callee interface. It then directly locates the corresponding callee interface using the compile-time generated unique key. Before transferring control to the callee domain, the invocation is wrapped in a catch_unwind block to capture and handle potential panics in the callee domain. Additionally, safeL4 uses a custom compilation target to generate a section in
// trusted_kernel_invoke! calls this function after the type-match check
pub fn invoke_proxy<T>(
api_identifier: ExportedAPIIdentifier,
arg: *const (),
ret: *mut (),
) -> Option<T> {
GLOBAL_API_RESERVOIR.read()
// find callee interface according to identifier tuple
.get(&api_identifier)
.and_then(|interface| unsafe {
// wrap callee execution
crate::catch_unwind(|| {
interface.transmute_then_invoke(arg, ret);
})
.ok()
.and_then(|_| {
let ret_place_holder = &mut *(ret as *mut
Option<MaybeUninit<T>>);
ret_place_holder.take().map(|inner| inner.
assume_init())
})
})
}
Listing 3. Simplified safeL4 microkernel workflow for resolving and calling IDC interfaces.
the OS image for storing exception-handling information. With this information, safeL4 employs the unwinding library [28] to implement a stack-unwinding mechanism.
Capability Invocation
A protection domain holds capabilities pointing to different kernel objects, and all accesses to a given kernel object must be performed by invoking the corresponding Cap. In safeL4, such capability invocation is exposed through kobj!, a procedural macro provided by the microkernel. The macro takes Cap as input and redirects the kernel object method to a public proxy function, which then performs the following steps: (1) checks authority, (2) temporarily upgrades the Weak to the corresponding RawCap, and (3) tries to obtain the RwLock guarding the KObj inside the RawCap. The proxy function then executes the target method of the kernel object. After invocation, the proxy function releases the acquired RwLock, exits the scope of the Weak::upgrade, and returns.
OS Services in Protection Domains
We implemented fundamental OS services on safeL4, including process management, memory management, a file system, and several peripheral drivers.
Process Management and Memory Management
The process management (PM) is responsible for creating, deleting, and scheduling all threads in the OS. PM uses the TCB object to implement the thread abstraction for both safe tasks and user-level tasks, and implements a scheduler. In the multicore scheduling implementation, PM obtains the hardware core ID via the capability of an MPI object.
During system startup, the safeL4 microkernel initializes the physical memory reserved for protection domains as Untyped objects and transfers the corresponding capabilities to the memory management domain. The memory management domain implements a buddy system and a slab system based on these Untyped objects, and provides interfaces for memory allocation and deallocation to other domains.
Porting RedoxFS
5.4.2 Porting RedoxFS. RedoxFS [78] is a file system inspired by ZFS [6] that runs as a user-level process on Redox OS [79]. We port RedoxFS and run it in a protection domain on safeL4, and the interfaces of RedoxFS are registered using trusted_kernel_export!.
We remove all unsafe code blocks from the original RedoxFS code by leveraging our safe abstractions. RedoxFS performs in-place serialization and deserialization of inode data structures, which requires unsafe type conversions in Rust. To address this, inspired by PODType [77], we introduce a dedicated unsafe trait named Convert within the microkernel to support controlled type conversion and make it available for protection domains. We further enforce strict semantic constraints on this trait to restrict its behavior, which provides the following three additional guarantees.
Types that implement this trait cannot contain any function or data pointers, and all fields must be owned values.
Types that implement this trait can only be converted to and from a byte array.
The trait ensures that all type conversions occur in place with bound-checking to prevent out-of-bounds memory access during conversion.
Since this trait is marked as unsafe within the microkernel, protection domains cannot implement it directly. Instead, protection domains use the #[derive(Convert)] macro to mark their data structures that require the trait, and let the Rust compiler check if the requirements are satisfied and automatically derive implementations for these structures.
Device Drivers
5.4.3 Device Drivers. The interrupt dispatch routine remains within the microkernel, while peripheral device drivers are implemented in protection domains. We have ported Redox’s SD card driver and implemented drivers for UART, timer, and DMA. All device drivers access MMIO registers through the capabilities of their DeviceMemory objects, each of which represents a specific device memory region. To support a new peripheral driver, we can create a DeviceMemory object pointing to the device’s MMIO region, pass the corresponding capability to the device driver’s protection domain during driver initialization, and bind the device’s interrupt (an Interrupt object) to the driver’s interrupt-handling IDC interface. For example, when porting Redox’s SD card driver, we replace its original unsafe operations, namely direct register access using ptr::read_volatile and ptr::write_volatile, with invocations on the capability of the DeviceMemory object (Listing 4).
// Unsafe way to access MMIO area.
unsafe { (start as *mut T).add(offset).write_volatile(val);}
// safeL4’s cap–gated access (Offset is checked)
let result = kobj!(<device_memory_cap as
DeviceMemoryCap>.write(offset, val)
.map_err(|_| DMError::DMWriteError));
Listing 4. safeL4 replaces unsafe MMIO access with invocations on the capability of the DeviceMemory object.
5.4.4 Musl Libc Support. To support user-level applications written in unsafe languages, we port musl libc to safeL4’s user layer and implement 50 system calls in OS services. A system call invoked by musl libc is transferred to the corresponding OS services.
Evaluation
We evaluate safeL4’s source code and linked code size, micro- and macrobenchmarks to achieve the following evaluation objectives, and use concrete examples from existing Rust OSes to evaluate safeL4’s safety guarantees.
Objective 1. By comparing safeL4 with seL4, evaluate the performance differences in low-level operations (such as IPC, interrupt handling, signal, and scheduling) between a safe language-based microkernel and a hardware isolation-based microkernel.
Objective 2. Evaluate the performance differences between safeL4, seL4, and Linux when handling realistic workloads.
Objective 3. Evaluate the file system-related microbenchmark performance between safeL4 and Redox, to reveal the impact of different microkernel architectures.
Experiment Setup
All experiments are conducted on a Raspberry Pi 3B+ board with four Cortex-A53 cores (1.4 GHz), 1 GB SDRAM, and a 32 GB SD card. We have set up the following OSes on this hardware platform to achieve our evaluation objectives.
seL4. seL4 is a hardware isolation-based microkernel with the fastest IPC. We evaluate the performance differences between safeL4 and seL4 in terms of their low-level abstraction of hardware resources (Objective 1) and realistic workloads (Objective 2). The most common deployment scenario for seL4 is as a library OS (LibOS), in which resources are statically allocated, and most computations do not require system calls. We run YCSB benchmarks [18] on SQLite3 [73] in the user space of safeL4 and seL4 LibOS.
Redox. Redox OS is a relatively mature microkernel-based general-purpose OS based on hardware isolation and implemented in Rust. We have ported RedoxFS and the SD card driver to safeL4’s protection domains while maintaining source code consistency. We run file system-related microbenchmarks in user space on both Redox and safeL4 to evaluate the performance difference between safe language-based isolation and hardware-based isolation (Objective 3).
Linux. Linux is a representative monolithic OS. We use Ubuntu 22.04 (Linux 6.6.12) with the ZFS file system. We run SQLite3 in the user space of safeL4 and Linux (Objective 2).
Source Code and Linked Code Size Evaluation
We evaluate both the source code size and the linked code size (LCS) included in the final image. For the latter, we adopt the LCS metric used in Asterinas [62]. However, it is important to note that the source code size and LCS do not fully represent the TCB of safeL4. A complete account must also incorporate the remaining assumptions specified in § 4.2.
The entire safeL4 OS consists of 22,018 LoC (Table 4). The microkernel contains 11,688 LoC, including 1,765 lines of unsafe code, which accounts for 15.1% of the microkernel code. We support the RISC-V64 and AArch64 architectures. Table 4 shows that the amount of unsafe code required to support a new CPU architecture is quite small, 462 LoC for AArch64 and 349 LoC for RISC-V64, respectively.
| LoC | Crate | LoC | Crate | LoC | |
| Safe code | 9 923 | Microkernel | 11 688 | DMA | 328 |
| Unsafe code: | Process management | 3 943 | UART | 261 | |
| Arch-independent | 954 | Memory management | 502 | RAM Disk | 110 |
| AArch64 | 462 | RedoxFS | 4 254 | Mailbox | 81 |
| RISC-V64 | 349 | SD card driver | 777 | Timer | 74 |
| Total (Microkernel) | 11 688 | Total | 22 018 |
Table 4. Lines of Code for safeL4.
We further evaluate safeL4’s LCS. We count all source lines referenced in the linked IR generated by the LLVM toolchain. We evaluate the LCS of both the TCB components (primarily including the Rust core and alloc libraries, the safeL4 microkernel, and its direct and indirect crate dependencies) and the non-TCB components (protection domains).
The evaluation results (Table 5) show that (1) in Rust-based OSes, the Rust core and alloc libraries account for a large fraction of the trusted linked code. (2) Compared with other Rust-based OSes, safeL4’s low-level abstraction approach yields the smallest amount of other trusted linked code for system resource abstraction (others in Table 5). Although Tock also has a small amount of such code, it is a lightweight OS aimed at low-power microcontrollers.
| OS | LCS in the TCB | LCS outside the TCB | Total | |
| core + alloc | others | |||
| Asterinas | 9 442 | 11 090 | 58 165 | 78 697 |
| Theseus | 8 720 | 40 459 | 9 595 | 58 774 |
| RedLeaf | 4 357 | 17 240 | 4 813 | 26 410 |
| Tock | 1 911 | 2 903 | 1 814 | 6 628 |
| safeL4 | 6 248 | 2 720 | 6 081 | 15 049 |
Table 5. Comparison of LCS.
Microbenchmark Comparison with seL4
We use seL4bench [69] as a microbenchmark suite to compare the performance of safeL4 and seL4. seL4bench is designed to evaluate various low-level operations of the seL4 microkernel. On safeL4, we reimplement all seL4bench benchmarks in Rust, excluding VCPU (virtualization), and execute them in protection domains.
The evaluation results (Table 6) show that safeL4 is 1.91× (geometric mean) faster on average than seL4, with IDT demonstrating the most significant performance advantage, being 7.8× to 22.3× faster than seL4. The results may help answer the question about the performance comparison between safe language-based microkernels and those that rely on hardware isolation [33]: for microkernels, the overhead introduced by Rust code (including type safety checks and fault isolation mechanisms) is lower than the overhead introduced by hardware isolation (including CPU context switching, privilege-level switching, and page table switching).
| seL4bench | Description | seL4 | safeL4 | Perf* |
| Fault | hardware fault triggering-to-handling | 589.470 ± 22.487 | 309.952 ± 5.206 | 1.902 |
| Hardware | calling into kernel and return | 149.000 ± 34.795 | 44.000 ± 0.000 | 3.386 |
| IPC/IDC | invoke a server in a different address space (seL4)/domain (safeL4) | 249.000 ± 0.000 | 32.000 ± 0.000 | 7.781 |
| a server replies to a client in a different address space (seL4)/domain (safeL4) | 268.000 ± 0.000 | 12.000 ± 0.000 | 22.330 | |
| IRQ | invoke an interrupt handler in a user-thread (seL4)/domain (safeL4) | 622.440 ± 21.835 | 413.632 ± 1.502 | 1.505 |
| Page mapping | prepare one page table | 1 354.438 ± 120.572 | 1 153.889 ± 151.577 | 1.174 |
| map one page | 390.377 ± 4.420 | 260.900 ± 12.518 | 1.496 | |
| allocate one frame capability | 538.345 ± 24.992 | 949.200 ± 14.119 | 0.567 | |
| Signal | asynchronous signal delivery | 406.050 ± 22.614 | 113.684 ± 1.243 | 3.572 |
| synchronous signal delivery | 560.830 ± 22.979 | 449.309 ± 8.072 | 1.248 | |
| Scheduler | yield a thread | 382.310 ± 19.130 | 400.056 ± 0.631 | 0.956 |
| schedule between two threads | 758.100 ± 15.400 | 584.955 ± 3.462 | 1.296 | |
| Synchronization | broadcast a signal through notification | 1 370.860 ± 26.950 | 892.400 ± 23.589 | 1.536 |
| the last waiter of a waiting chain being woken | 71 296.000 ± 14.949 | 45 868.900 ± 208.884 | 1.554 | |
| producer to consumer latency | 1 217.740 ± 140.721 | 876.600 ± 9.088 | 1.389 | |
| consumer to producer latency | 1 194.160 ± 28.889 | 860.800 ± 3.513 | 1.387 | |
| SMP | intra-core IPC round-trip | 6 888.610 ± 0.410 | 4 877.980 ± 2.460 | 1.411 |
| Geometric Mean | 1.910 |
Table 6. The seL4bench results in CPU cycles. Smaller is better.
Synchronization-related benchmarks (signal/schedule/sync) also benefit from safeL4. In safeL4, the primary overhead of a synchronization operation comes from accessing CPU contexts through capabilities, CPU context switching triggered by thread switches, and atomic operations within semaphores. They do not involve CPU mode switching or address space switching, thereby outperforming seL4.
Here, we explain why safeL4 underperforms seL4 in the frame allocation benchmark. This primarily stems from design divergences in concurrency strategies of kernel data structures. seL4 employs coarse-grained concurrency control via a big kernel lock, which ensures exclusive access, allowing kernel data structures to operate without internal synchronization checks. In contrast, safeL4 adopts a fine-grained locking design. Accessing kernel objects via capabilities in safeL4 requires acquiring a read-write lock (RwLock)
Normalized performance, use seL4/safeL4 to indicate safeL4’s performance advantage over seL4. Higher is better.
Normalized performance. For throughput, use safeL4/Redox; for latency, use Redox/safeL4. Higher is better.
to ensure correctness in concurrent environments, which inevitably introduces synchronization overhead at the granularity of kernel objects. We profile the synchronization overhead incurred by this fine-grained locking (Table 8). The results indicate that during frame allocation, the initialization of a capability with RwLock and Arc consumes an average of 656.11 CPU cycles, constituting the dominant overhead. Furthermore, a portion of the frame allocation overhead in safeL4 originates from maintaining the CDTree.
| Operation | Avg. Cycles |
| Acquire the RwLock on a capability to access Untyped kernel object | 99.28 |
| Retype a Frame kernel object from the Untyped kernel object | 165.32 |
| Create a Frame capability using the Frame kernel object | 656.11 |
| Insert the Frame capability’s CdtNode to its parent | 29.00 |
Table 8. Profile of allocation of a frame.
Macrobenchmark Comparison with seL4 and Linux
We evaluate the performance of safeL4, seL4, and Linux using the YCSB benchmark on SQLite3. SQLite3 is ported to seL4 LibOS and deployed as a user-level task on safeL4. The workload comprises six standard YCSB scenarios, covering read, write, update, and mixed operations on a table containing 1,000 records.
The results (Figure 3) show that safeL4 outperforms seL4 by 14.3% and Linux by 23.2% on average. Both safeL4 and the seL4 LibOS achieve higher performance than Linux.
Figure 3. SQLite3 YCSB benchmark, smaller is better.
To explain safeL4’s advantage over Linux, we profile system calls during the YCSB benchmark. Four system calls, fc-ntl, newfstatat, pread64, and pwrite64, account for more than 70% of the total execution time. The system calls implemented by safeL4 are simpler than Linux’s. For example, there is much less locking logic (no byte-range locking and no need for a global lock linked list), fewer system states to maintain, no access control checks, and so on.
In this benchmark, the performance improvement of safeL4 over seL4 is not as good as in seL4bench, for the following reasons. First, SQLite3 and YCSB, as implemented in an unsafe language, run in user space on safeL4, so they need to allocate resources via system calls. Second, the seL4 LibOS adopts a static allocation strategy: the memory required by applications is allocated in one shot during initialization, reducing the number of system calls during execution. Third, in the seL4 LibOS, SQLite3, the file system and drivers run in the same address space, and there is no IPC overhead between them. The second and third reasons also explain why seL4 outperforms Linux in this benchmark.
Microbenchmark Comparison with Redox
We port the RedoxFS and SD card driver from Redox OS, maintaining source and semantic consistency. In Redox OS, the file system and drivers run as user-level processes. In safeL4, they run in protection domains.
We cannot run LMbench directly on Redox because it only supports a limited set of POSIX system calls on AArch64. We implement an LMbench subset related to the file system in Rust and run it in user space on both safeL4 and Redox.
The results (Table 7) show that safeL4 outperforms Redox in all file system-related microbenchmarks, with a geometric-mean speedup of 1.47×. This experiment demonstrates that it is feasible to port existing typical OS services to safeL4 using its safe abstractions and that these OS services can benefit from safeL4’s single-address-space design.
| LMbench | Description | Unit | Redox | safeL4 | Perf* |
| memory map | map then unmap a block of memory | 27.789 ± 0.049 | 21.795 ± 0.052 | 1.275 | |
| page fault | triggers page fault for each page | 150.988 ± 0.129 | 94.336 ± 0.157 | 1.601 | |
| file access | open, read then close a file | MB/s | 8.269 ± 0.053 | 18.142 ± 0.009 | 2.194 |
| read a file | MB/s | 25.199 ± 0.139 | 55.618 ± 0.007 | 2.207 | |
| memory map | map, read, then unmap a file | MB/s | 345.429 ± 7.180 | 380.940 ± 0.000 | 1.103 |
| open, map, read, unmap, close | MB/s | 8.287 ± 0.001 | 12.082 ± 0.002 | 1.458 | |
| file create/delete | create files | files/s | 32.685 ± 1.960 | 40.894 ± 0.986 | 1.251 |
| delete files | files/s | 74.854 ± 4.370 | 82.138 ± 1.833 | 1.097 | |
| Geometric Mean | 1.470 |
Table 7. File system-related comparison with Redox.
Case Study: MMIO Abstraction and Capability-Protected Device Access
We use two concrete device-access examples from existing Rust OSes to illustrate the benefits of safeL4’s language-level memory/type safety, as well as capability safety.
MMIO access without Rust references. Theseus’s PL011 driver maps an MMIO region into a MappedPages object and borrows the mapping as a typed mutable register block.
// kernel/uart_pl011/src/lib.rs
// Pl011::new
let regs =
mapped_pages.into_borrowed_mut::<Pl011_Regs>(0)?;
// kernel/memory/src/paging/mapper.rs
// MappedPages::as_type_mut
let typed: &mut T =
unsafe { &mut *(start_vaddr as *mut T) };
Listing 5. Theseus constructs a typed mutable reference over a PL011 MMIO mapping (simplified for brevity).
This issue was previously identified in the Asterinas paper [62]: Theseus’s MappedPages API eventually constructs an &mut T over an MMIO mapping. This is unsound for externally modifiable memory because hardware may update device registers independently, whereas &mut T assumes no external modifications.
safeL4 instead represents each MMIO region as a capability-protected DeviceMemory object. Its interface exposes neither Rust references nor raw pointers into the region. Each invocation causes the microkernel to perform a bounds-checked volatile read or write. Thus, under the assumptions in § 4.2, MMIO access through this interface preserves language-level memory/type safety.
Capability-protected device access. A sound MMIO interface alone does not determine which domain may access a particular device. RedLeaf, for example, relies on a PCI domain to discover PCI devices, map their memory-mapped I/O regions, and grant drivers access to those regions. However, any driver domain with access to this service can invoke pci_register_driver, claim another device’s vendor and device identifiers, and request access to one of that device’s MMIO regions.
The PCI domain thereby acts as a confused deputy: a driver can exploit the PCI domain’s broader authority to acquire and subsequently access a device-memory region that was not assigned to it. safeL4 instead directly grants the designated driver capabilities for a DeviceMemory object and the Notification associated with the device interrupt during initialization. The capability safety guarantees that the driver can invoke methods only on authorized objects for which it holds capabilities, removing the confused deputy issue.
Guarantees and limitations. In safeL4, the safe abstraction over DeviceMemory constrains how MMIO is accessed, while the capability system constrains which objects a domain may invoke. However, these guarantees do not establish driver functional correctness: a driver may still contain logic errors and violate device-specific state-machine protocols.
// domains/sys/driver/pci/src/lib.rs
// PCI::pci_register_driver
let (vid, did) =
(pci_driver.get_vid(), pci_driver.get_did());
let devices = PCI_DEVICES.lock();
let dev = devices.iter().find(|d|
(d.vendor_id(), d.device_id()) == (vid, did)
)?;
let bar = dev.get_bar(
bar_index, pci_driver.get_driver_type());
pci_driver.probe(bar);
Listing 6. RedLeaf’s PCI domain selects a device and BAR from caller inputs (simplified for brevity).
Conclusion
This paper presents safeL4, a safe language-based microkernel built around a capability-centered design. The key idea is to combine a single-address-space design for low-overhead capability invocation with safe language-enforced capability unforgeability, and to treat the capability as a first-class kernel abstraction for uniformly exposing system resources to protection domains. Our evaluation shows that safeL4’s primitives achieve 1.91× the performance of seL4 on average, and that although the Rust toolchain accounts for a notable portion of the TCB, the kernel itself remains compact.
Acknowledgments
We would like to thank the reviewers for their comments, and our anonymous shepherd for their insightful comments and suggestions that greatly inspired us. We also thank Gernot Heiser for his insightful comments on safeL4. This work is supported by the National Natural Science Foundation of China (No.62272458 and No.62372311), and the National Natural Science Foundation of China for Distinguished Young Scholars (No.62125208).
Artifact Appendix
Abstract
This artifact provides a pre-built safeL4 image, together with the source code and pre-built images for the seL4, Redox, and Linux. It supports the reproduction of three main experiments from the paper on a Raspberry Pi 3 Model B+: the microbenchmark comparison with seL4, the SQLite3/YCSB macrobenchmark comparison with seL4 and Linux, and the file-system microbenchmark comparison with Redox. Detailed instructions for running each experiment are included in the artifact repository.
Artifact check-list
Program: safeL4 image; seL4 and seL4bench; Redox OS; Ubuntu Linux with ZFS; YCSB benchmark on SQLite3; a file-system-related subset of LMbench.
Compilation: Not required for the main evaluation; all evaluated systems are supplied as pre-built images. Source code of seL4, Redox, and Linux are included for inspection and optional rebuilding.
Run-time environment: Bare-metal Raspberry Pi 3 Model B+; a separate Linux host is used to write images and capture UART output.
Hardware: Raspberry Pi 3 Model B+, 32 GB or larger microSD card, card reader, and 3.3 V USB-to-TTL UART adapter.
Output: UART logs and parsed numerical summaries.
Experiments: Microbenchmark comparison with seL4; macrobenchmark comparison with seL4 and Linux; microbenchmark comparison with Redox.
Required disk space: Under 15 GB.
Experiment run time: 10-12 hours.
Public link: https://doi.org/10.5281/zenodo.22852236
Licenses: safeL4 image: MIT; third-party sources and binaries retain their upstream licenses.
Description
How to access
The artifact and its detailed README are available at https://doi.org/10.5281/zenodo.22852236. The artifact contains the safeL4 image; the source code and images for seL4, Redox, and Linux; checksums; and documentation for building and running the images, conducting the experiments, and extracting the results.
Hardware dependencies
The evaluation requires:
one Raspberry Pi 3 Model B+ with four Cortex-A53 cores at 1.4 GHz and 1 GB SDRAM, plus a suitable power supply;
one 32 GB or larger microSD card and a USB card reader;
one Linux host with an available USB port; and
one 3.3 V USB-to-TTL UART adapter and jumper wires for the Raspberry Pi UART pins.
Software dependencies
The Linux host described above should run a 64-bit Debian-based Linux distribution (tested with Ubuntu 22.04) and have tools for checksum verification, writing raw images to microSD cards, capturing UART output, and parsing results. The required packages and installation commands are provided in the repository.
Installation
We provide pre-built images for all evaluated operating systems, so evaluators do not need to install the corresponding build environments. Instructions for running the OS images, as well as optional build instructions, are provided in the README.
Experiment workflow
To run an experiment, follow the instructions in the README in the corresponding experiment directory. First, flash the experiment-specific Raspberry Pi 3B+ firmware and OS images to the SD card. Insert the SD card into the Raspberry Pi, connect its UART interface to a host device that captures the serial output, and power on the board. Then follow the remaining instructions in the README to execute the experiment and collect the raw numerical results. Each experiment directory also provides scripts or documentation explaining how the raw results are processed or mapped to the reported results.
Evaluation and expected results
Due to differences in hardware and execution environments, the exact results presented in the paper may differ from those reproduced on other machines. However, the relative performance trends and conclusions drawn in our evaluation should hold.
Microbenchmark Comparison with seL4
This experiment compares safeL4 with seL4 to assess the performance differences in low-level operations, including IPC, interrupt handling, signaling, and scheduling, between a safe-language-based microkernel and a hardware-isolation-based microkernel. The results correspond to Table 6 The expected result is that safeL4 achieves better geometric-mean performance than seL4 across the evaluated microbenchmarks. This advantage primarily comes from avoiding privilege-level and address-space switches.
Macrobenchmark Comparison with seL4 and Linux
This experiment compares safeL4, seL4 LibOS, and Linux under realistic workloads by running YCSB on SQLite3. The YCSB benchmark is included in each corresponding system image and can be run directly. The results correspond to Figure 3. The expected overall trend is that safeL4 outperforms both seL4 and Linux.
Microbenchmark Comparison with Redox
This experiment compares safeL4 with Redox using file-system-related microbenchmarks to assess the performance impact of their different microkernel architectures. The results correspond to Table 7. The expected overall trend is that safeL4 outperforms Redox. In safeL4, Redox’s user-space RedoxFS and SD driver are ported into protection domains running in kernel mode, reducing IPC overhead and eliminating the costs of privilege-level and address-space switches.
References
- [1]Mike Accetta, Robert Baron, William Bolosky, David Golub, Richard Rashid, Avadis Tevanian, and Michael Young. 1986. Mach: A new kernel foundation for UNIX development. In Proceedings of the 1986 USENIX Summer Conference. USENIX Association, 93–113. https://eecs582.github.io/readings/mach-usenix86.pdf
- [2]Godmar Back, Wilson C Hsieh, and Jay Lepreau. 2000. Processes in KaffeOS: Isolation, resource management, and sharing in Java. In Proceedings of the 4th Symposium on Operating Systems Design and Implementation (OSDI). USENIX Association, 333–346. https://dl.acm.org/doi/epdf/10.5555/1251229.1251252
- [3]Brian N Bershad, Craig Chambers, Susan Eggers, Chris Maeda, Dylan McNamee, Przemysław Pardyak, Stefan Savage, and Emin Gün Sirer. 1994. SPIN: An extensible microkernel for application-specific operating system services. In Proceedings of the 6th ACM SIGOPS European Workshop: Matching Operating Systems to Application Needs (EW). ACM, 48–71. doi:10.1145/504390.504408
- [4]Brian N Bershad, Stefan Savage, Przemysław Pardyak, Emin Gün Sirer, Marc E Fiuczynski, David Becker, Craig Chambers, and Susan Eggers. 1995. Extensibility, safety and performance in the SPIN operating system. In Proceedings of the 15th ACM Symposium on Operating Systems Principles (SOSP). ACM, 267–284. doi:10.1145/224056.224077DOI
- [5]Alan C Bomberger, Norman Hardy, A Peri Frantz, Charles R Landau, William S Frantz, Jonathan S Shapiro, and Ann C Hardy. 1992. The KeyKOS® nanokernel architecture. In Proceedings of the USENIX Workshop on Micro-kernels and Other Kernel Architectures. USENIX Association, 95–112. https://flint.cs.yale.edu/cs428/doc/NanoKernel.pdf
- [6]Jeff Bonwick, Matt Ahrens, Val Henson, Mark Maybee, and Mark Shellenbaum. 2003. The Zettabyte file system. Technical Report. Sun Microsystems, Inc. https://www.mit.edu/6.033/www/papers/zfs.pdf
- [7]Kevin Boos, Namitha Liyanage, Ramla Ijaz, and Lin Zhong. 2020. Theseus: An experiment in operating system structure and state management. In Proceedings of the 14th USENIX Symposium on Operating Systems Design and Implementation (OSDI). USENIX Association, 1–19. https://www.usenix.org/system/files/osdi20-boos.pdf
- [8]Kevin Boos, Emilio Del Vecchio, and Lin Zhong. 2017. A characterization of state spill in modern operating systems. In Proceedings of the 12th European Conference on Computer Systems (EuroSys). ACM, 389–404. doi:10.1145/3064176.3064205DOI
- [9](ECOOP). Springer, 2–27. doi:10.1007/3-540-45337-7_2DOI
- [10]Andrew Boyton. 2009. A verified shared capability model. In Proceedings of the 4th International Workshop on Systems Software Verification (SSV). Elsevier, 25–44. doi:10.1016/J.ENTCS.2009.058DOI
- [11]Stephan Brandeauer, Elias Castegren, Dave Clarke, Kiko Fernandez-Reyes, Einar Broch Johnsen, Ka I Pun, S Lizeth Tapia Tarifa, Tobias Wrigstad, and Albert Mingkun Yang. 2015. Parallel objects for multicore: A glimpse at the parallel language Encore. In Proceedings of the 15th International School on Formal Methods for the Design of Computer, Communication and Software Systems (SFM). Springer, 1–56. doi:10.1007/978-3-319-18941-3_1
- [12]Allan Bricker, Michel Gien, Marc Guillemont, Jim Lipkis, Douglas Orr, and Marc Rozier. 1991. A new look at microkernel-based UNIX operating systems: Lessons in performance and compatibility. In Proceedings of the EuroOpen Spring 1991 Conference. http://fqrd.fr/publications/chorus/CS-TR-91-7.pdf
- [13]Anton Burtsev, Dan Appel, David Detweiler, Tianjiao Huang, Zhaofeng Li, Vikram Narayanan, and Gerd Zellweger. 2021. Isolation in Rust: What is missing?. In Proceedings of the 11th Workshop on Programming Languages and Operating Systems (PLOS). ACM, 76–83. doi:10.1145/3477113.3487272
- [14]Luca Cardelli, James Donahue, Lucille Glassman, Mick Jordan, Bill Kalsow, and Greg Nelson. 1992. Modula-3 language definition. ACM SIGPLAN Notices 27, 8 (1992), 15–42. doi:10.1145/142137.142141DOI
- [15]Haibo Chen, Xie Miao, Ning Jia, Nan Wang, Yu Li, Nian Liu, Yutao Liu, Fei Wang, Qiang Huang, Kun Li, Hongyang Yang, Hui Wang, Jie Yin, Yu Peng, and Fengwei Xu. 2024. Microkernel goes general: Performance and compatibility in the HongMeng production microkernel. In Proceedings of the 18th USENIX Symposium on Operating Systems Design and Implementation (OSDI). USENIX Association, 465–485. https://www.usenix.org/system/files/osdi24-chen-haibo.pdf
- [16]Xiangdong Chen, Zhaofeng Li, Jerry Zhang, Vikram Narayanan, and Anton Burtsev. 2025. Atmosphere: Practical verified kernels with Rust and Verus. In Proceedings of the ACM SIGOPS 31st Symposium on Operating Systems Principles (SOSP). ACM, 752–767. doi:10.1145/3731569.3746821DOI
- [17]Sylvan Clebsch, Sophia Drossopoulou, Sebastian Blessing, and Andy McNeil. 2015. Deny capabilities for safe, fast actors. In Proceedings of the 5th International Workshop on Programming Based on Actors, Agents, and Decentralized Control (AGERE!). ACM, 1–12. doi:10.1145/2824815.2824816DOI
- [18]Brian F Cooper, Adam Silberstein, Erwin Tam, Raghu Ramakrishnan, and Russell Sears. 2010. Benchmarking cloud serving systems with YCSB. In Proceedings of the 1st ACM Symposium on Cloud Computing (SoCC). ACM, 143–154. doi:10.1145/1807128.1807152DOI
- [19]Jack B Dennis and Earl C Van Horn. 1966. Programming semantics for multiprogrammed computations. Commun. ACM 9, 3 (1966), 143–155. doi:10.1145/365230.365252
- [20]Dong Du, Zhichao Hua, Yubin Xia, Binyu Zang, and Haibo Chen. 2019. XPC: Architectural support for secure and efficient cross process call. In Proceedings of the 46th International Symposium on Computer Architecture (ISCA). ACM, 671–684. doi:10.1145/3307650.3322218DOI
- [21]Dhammika Elkaduwe, Gerwin Klein, and Kevin Elphinstone. 2008. Verified protection model of the seL4 microkernel. In Proceedings of the 2nd International Conference on Verified Software: Theories, Tools, Experiments (VSTTE). Springer, 99–114. doi:10.1007/978-3-540-87873-5_11
- [22]Kevin Elphinstone and Gernot Heiser. 2013. From L3 to seL4 what have we learnt in 20 years of L4 microkernels?. In Proceedings of the 24th ACM Symposium on Operating Systems Principles (SOSP). ACM, 133–150. doi:10.1145/2517349.2522720DOI
- [23]Paul Emmerich, Simon Ellmann, Fabian Bonk, Alex Egger, Esaú García Sánchez-Trujillo, Thomas Günzel, Sebastian Di Luzio, Alexandru Obada, Maximilian Stadlmeier, Sebastian Voit, and Georg Carle. 2019. The case for writing network drivers in high-level programming languages. In Proceedings of the 15th ACM/IEEE Symposium on Architectures for Networking and Communications Systems (ANCS). IEEE, 1–13. doi:10.1109/ANCS.2019.8901892DOI
- [24]Manuel Fähndrich, Mark Aiken, Chris Hawblitzel, Orion Hodson, Galen Hunt, James R Larus, and Steven Levi. 2006. Language support for fast and reliable message-based communication in Singularity OS. In Proceedings of the 1st ACM SIGOPS/EuroSys European Conference on Computer Systems (EuroSys). ACM, 177–190. doi:10.1145/1217935.1217953
- [25]Juliana Furgala. 2023. Magnetite: Rust-based OS services for seL4. https://sel4.systems/Foundation/Summit/2023/slides/day2-02-furgala.pdf. Presentation slides at the seL4 Summit 2023.
- [26]Gapfruit AG. 2025. Gapfruit OS: Secure and scalable OS. https://www.gapfruit.com/.
- [27]Michael Golm, Meik Felser, Christian Wawersich, and Jürgen Kleinöder. 2002. A Java operating system as the foundation of a secure network operating system. Technical Report TR-I4-02-05. Department of Computer Sciences 4 (Distributed Systems and Operating Systems), University of Erlangen-Nuremberg. https://www4.informatik.uni-erlangen.de/DE/Projects/JX/publications/jx-sec.pdf
- [28]Gary Guo. 2024. Unwinding: Unwinding library in Rust and for Rust. https://github.com/nbdd0121/unwinding.
- [29]Philipp Haller and Martin Odersky. 2010. Capabilities for uniqueness and borrowing. In Proceedings of the 24th European Conference on Object-Oriented Programming (ECOOP). Springer, 354–378. doi:10.1007/978-3-642-14107-2_17DOI
- [30]Thomas Hallgren, Mark P Jones, Rebekah Leslie, and Andrew Tolmach. 2005. A principled approach to operating system construction in Haskell. In Proceedings of the 10th ACM SIGPLAN International Conference on Functional Programming (ICFP). ACM, 116–128. doi:10.1145/1086365.1086380DOI
- [31]Norm Hardy. 1988. The confused deputy (or why capabilities might have been invented). ACM SIGOPS Operating Systems Review 22, 4 (1988), 36–38. doi:10.1145/54289.871709
- [32]Michael A Harrison, Walter L Ruzzo, and Jeffrey D Ullman. 1976. Protection in operating systems. Commun. ACM 19, 8 (1976), 461–471. doi:10.1145/360303.360333DOI
- [33]Gernot Heiser. 2008. What is the difference between a microkernel? https://microkerneldude.org/2008/03/13/q-what-is-the-difference-between-a-microkernel.
- [34]Gernot Heiser. 2025. The seL4 microkernel – An introduction. White paper. seL4 Foundation. https://sel4.systems/About/seL4-whitepaper.pdf
- [35]Jorrit N Herder. 2005. Towards a true microkernel operating system. Master’s thesis. Vrije Universiteit Amsterdam. https://minix3.org/doc/herder_thesis.pdf
- [36]Jessica Hillert. 2019. A comparison of the capability systems of Encore, Pony and Rust. Bachelor’s thesis. Uppsala University. https://uu.diva-portal.org/smash/get/diva2:1363822/FULLTEXT01.pdf
- [37]Galen Hunt, James Larus, Martin Abadi, Mark Aiken, Paul Barham, Manuel Fähndrich, Chris Hawblitzel, Orion Hodson, Steven Levi, Nick Murphy, Bjarne Steensgaard, David Tarditi, Ted Wobber, and Brian Zill. 2005. An overview of the Singularity project. Technical Report MSR-TR-2005-135. Microsoft Research. https://www.microsoft.com/en-us/research/wp-content/uploads/2005/10/tr-2005-135.pdf
- [38]Galen C Hunt and James R Larus. 2007. Singularity: Rethinking the software stack. ACM SIGOPS Operating Systems Review 41, 2 (2007), 37–49. doi:10.1145/1243418.1243424DOI
- [39]Samuel Jero, Juliana Furgala, Runyu Pan, Phani Kishore Gadepalli, Alexandra Clifford, Bite Ye, Roger Khazan, Bryan C Ward, Gabriel Parmer, and Richard Skowyra. 2021. Practical principle of least privilege for secure embedded systems. In Proceedings of the 27th IEEE Real-Time and Embedded Technology and Applications Symposium (RTAS).DOI
- [40]Ralf Jung, Jacques-Henri Jourdan, Robbert Krebbеrs, and Derek Dreyer. 2018. RustBelt: Securing the foundations of the Rust programming language. Proceedings of the ACM on Programming Languages 2, POPL (2018), 66:1–66:34. doi:10.1145/3158154DOI
- [41]Kernkonzept GmbH. 2026. The L4Re operating system framework. https://l4re.org.
- [42]Gerwin Klein, June Andronick, Kevin Elphinstone, Toby Murray, Thomas Sewell, Rafal Kolanski, and Gernot Heiser. 2014. Comprehensive formal verification of an OS microkernel. ACM Transactions on Computer Systems (TOCS) 32, 1 (2014), 2:1–2:70. doi:10.1145/2560537DOI
- [43]Kry10 Unlimited, Inc. 2024. Kry10 - Enabling innovation in high trust systems. https://www.kry10.com/.
- [44]Adam Lackorzynski and Alexander Warg. 2009. Taming subsystems: Capabilities as universal resource access control in L4. In Proceedings of the 2nd Workshop on Isolation and Integration in Embedded Systems (IIES). ACM, 25–30. doi:10.1145/1519130.1519135DOI
- [45]Butler W. Lampson. 1971. Protection. In Proceedings of the 5th Princeton Symposium on Information Sciences and Systems. 437–443. doi:10.1145/775265.775268. Reprinted in Operating Systems Review, 8(1):18–24, 1974.
- [46]Junghee Lee, Youngjae Kim, Galen M Shipman, Sarp Oral, and Jong-man Kim. 2013. Preemptible I/O scheduling of garbage collection for solid state drives. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 32, 2 (2013), 247–260. doi:10.1109/TCAD.2012.2227479DOI
- [47]Amit Levy, Bradford Campbell, Branden Ghena, Daniel B Giffin, Pat Pannuto, Prabal Dutta, and Philip Levis. 2017. Multiprogramming a 64kB computer safely and efficiently. In Proceedings of the 26th Symposium on Operating Systems Principles (SOSP). ACM, 234–251. doi:10.1145/3132747.3132786DOI
- [48]Henry M Levy. 1984. Capability-based computer systems. Digital Press. doi:10.1016/C2013-0-01290-XDOI
- [49]Zhaofeng Li, Tianjiao Huang, Vikram Narayanan, and Anton Burtsev. 2021. Understanding the overheads of hardware and language-based IPC mechanisms. In Proceedings of the 11th Workshop on Programming Languages and Operating Systems (PLOS). ACM, 53–61. doi:10.1145/3477113.3487275DOI
- [50]Jochen Liedtke. 1995. On micro-kernel construction. In Proceedings of the 15th ACM Symposium on Operating Systems Principles (SOSP). ACM, 237–250. doi:10.1145/224056.224075DOI
- [51]Jochen Liedtke. 1996. Toward real microkernels. Commun. ACM 39, 9 (1996), 70–77. doi:10.1145/234215.234473DOI
- [52]Richard J Lipton and Lawrence Snyder. 1977. A linear time algorithm for deciding subject security. J. ACM 24, 3 (1977), 455–464. doi:10.1145/322017.322025DOI
- [53]Adrian Mettler, David A Wagner, and Tyler Close. 2010. Joe-E: A security-oriented subset of Java. In Proceedings of the 17th Network and Distributed System Security Symposium (NDSS). The Internet Society, 357–374. https://www.ndss-symposium.org/wp-content/uploads/2017/09/met.pdf
- [54]Till Miemietz, Viktor Reusch, Matthias Hille, Max Kurze, Adam Lackorzynski, Michael Roitzsch, and Hermann Härtig. 2024. A perfect fit? - Towards containers on microkernels. In Proceedings of the 10th International Workshop on Container Technologies and Container Clouds (WoC). ACM, 1–6. doi:10.1145/3702637.3702957DOI
- [55]Till Miemietz, Viktor Reusch, Matthias Hille, Lars Wrenger, Jana Eisoldt, Jan Klötzke, Max Kurze, Adam Lackorzynski, Michael Roitzsch, and Hermann Härtig. 2025. MettlEagle: Costs and benefits of implementing containers on microkernels. In Proceedings of the 19th USENIX Symposium on Operating Systems Design and Implementation (OSDI). USENIX Association, 979–996. https://www.usenix.org/system/files/osdi25-miemietz.pdf Mark Samuel Miller. 2006. Robust composition: Towards a unified approach to access control and concurrency control. Ph.D. Dissertation. Johns Hopkins University. https://jscholarship.library.jhu.edu/server/api/core/bitstreams/c2c3ea50-2613-47a7-b33c-9383c706ee63/content
- [57]Mark S Miller, Chip Morningstar, and Bill Frantz. 2000. Capability-based financial instruments. In Proceedings of the 4th International Conference on Financial Cryptography (FC). Springer, 349–378. doi:10.1007/3-540-45472-1_24DOI
- [58]Mark S Miller, Ka-Ping Yee, and Jonathan Shapiro. 2003. Capability myths demolished. Technical Report SRL2003-02. Systems Research Laboratory, Johns Hopkins University. http://zesty.ca/capmyths/usenix.pdf
- [59]Toby Murray, Daniel Matichuk, Matthew Brassil, Peter Gammie, Timothy Bourke, Sean Seefried, Corey Lewis, Xin Gao, and Gerwin Klein. 2013. seL4: From general purpose to a proof of information flow enforcement. In Proceedings of the 34th IEEE Symposium on Security and Privacy (SP). IEEE, 415–429. doi:10.1109/SP.2013.35DOI
- [60]Vikram Narayanan, Tianjiao Huang, David Detweiler, Dan Appel, Zhaofeng Li, Gerd Zellweger, and Anton Burtsev. 2020. RedLeaf: Isolation and communication in a safe operating system. In Proceedings of the 14th USENIX Symposium on Operating Systems Design and Implementation (OSDI). USENIX Association, 21–39. https://www.usenix.org/system/files/osdi20-narayanan_vikram.pdf
- [61]Yuke Peng, Hongliang Tian, Jinyi Xian, Shuai Zhou, Shoumeng Yan, and Yinqian Zhang. 2024. Framkernel: A safe and efficient kernel architecture via Rust-based intra-kernel privilege separation. In Proceedings of the 15th ACM SIGOPS Asia-Pacific Workshop on Systems (APSys). ACM, 31–37. doi:10.1145/3678015.3680492DOI
- [62]Yuke Peng, Hongliang Tian, Junyang Zhang, Ruihan Li, Chengjun Chen, Jianfeng Jiang, Jinyi Xian, Xiaolin Wang, Chenren Xu, Diyu Zhou, Yingwei Luo, Shoumeng Yan, and Yinqian Zhang. 2025. Asterinas: A Linux ABI-compatible, Rust-based frameworkel OS with a small and sound TCB. In Proceedings of the 2025 USENIX Annual Technical Conference (USENIX ATC). USENIX Association, 307–323. https://www.usenix.org/system/files/atc25-peng-yuke.pdfarxiv.org/abs/2506.03876
- [63]Tyler Potyondy, Anthony Torbjørn, Leon Schuermann, Eric Mugnier, Adin Ackerman, Amit Levy, and Pat Pannuto. 2026. Rage against the state machine: Type-stated hardware peripherals for increased driver correctness. In Proceedings of the 31st ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2 (ASPLOS). ACM, 1508–1522. doi:10.1145/3779212.3790207DOI
- [64]Ning Qu. 2024. seL4 in software-defined vehicles: Vision, roadmap, and impact at NIO. https://sel4.systems/Summit/2024/slides/software-re-defined.pdf. Keynote at the seL4 Summit 2024.
- [65]Jerome H Saltzer and Michael D Schroeder. 1975. The protection of information in computer systems. Proc. IEEE 63, 9 (1975), 1278–1308. doi:10.1109/PROC.1975.9939DOI
- [66]Leon Schuermann, Brad Campbell, Branden Ghena, Philip Levis, Amit Levy, and Pat Pannuto. 2025. Tock: From research to securing 10 million computers. In Proceedings of the ACM SIGOPS 31st Symposium on Operating Systems Principles (SOSP). ACM, 36–49. doi:10.1145/3731569.3764828DOI
- [67]seL4 Foundation. 2024. The seL4 Microkit. https://docs.sel4.systems/projects/microkit/
- [68]seL4 Foundation. 2025. CamKES VMM. https://docs.sel4.systems/projects/camkes-vm/
- [69]seL4 Foundation. 2025. The sel4bench suite. https://docs.sel4.systems/projects/sel4bench.
- [70]Thomas Sewell, Simon Winwood, Peter Gammie, Toby Murray, June Andronick, and Gerwin Klein. 2011. seL4 enforces integrity. In Proceedings of the 2nd International Conference on Interactive Theorem Proving (ITP). Springer, 325–340. doi:10.1007/978-3-642-22863-6_24DOI
- [71]Jonathan S Shapiro, Jonathan M Smith, and David J Farber. 1999. EROS: A fast capability system. In Proceedings of the 17th ACM Symposium on Operating Systems Principles (SOSP). ACM, 170–185. doi:10.1145/319151.319163DOI
- [72]Jiacheng Shi, Jinyu Gu, Yubin Xia, and Haibo Chen. 2025. Serverless functions made confidential and efficient with split containers. In Proceedings of the 34th USENIX Security Symposium (USENIX Security). USENIX Association, 1091–1110. https://www.usenix.org/system/files/usenixsecurity25-shi-jiacheng.pdf
- [73]SQLite Consortium. 2025. SQLite. https://sqlite.org/index.html.
- [74]Marc Stiegler and Mark Miller. 2006. How Emily tamed the Caml. Technical Report. Hewlett-Packard Laboratories. https://shiftleft.com/mirror/www.hpl.hp.com/techreports/2006/HPL-2006-116.pdf
- [75]David Swasey, Deepak Garg, and Derek Dreyer. 2017. Robust and compositional verification of object capability patterns. Proceedings of the ACM on Programming Languages 1, OOPSLA (2017), 89:1–89:26. doi:10.1145/3133913DOI
- [76]June Tate-Gans, Sam Leffler, and Kai Yick. 2023. CantripOS: An OS for Ambient ML applications. https://sel4.systems/Foundation/Summit/2023/slides/day2-01-leffler.pdf. Keynote at the seL4 Summit 2023.
- [77]The cppreference.com contributors. 2022. C++ named requirements: PODType (deprecated in C++20). https://en.cppreference.com/w/cpp/named_req/PODType.
- [78]The Redox Developers. 2018. RedoxFS: The Redox filesystem. https://gitlab.redox-os.org/redox-os/redoxfs.
- [79]The Redox Developers. 2025. Redox OS. https://www.redox-os.org.
- [80]The Rust Project Developers. 2026. Rust rules for inline assembly. https://doc.rust-lang.org/reference/inline-assembly.html.
- [81]Trustworthy Systems Research Group, UNSW Sydney. 2024. The Lions Operating System (LionsOS). https://lionsos.org.
- [82]Thorsten von Eicken, Chih-Chao Chang, Grzegorz Czajkowski, Chris Hawblitzel, Deyu Hu, and Dan Spoonhower. 1999. J-Kernel: A capability-based operating system for Java. In Secure Internet Programming: Security Issues for Mobile Agents and Distributed Objects. Springer, 369–393. doi:10.1007/3-540-48749-2_17
- [83]Carsten Weinhold, Nils Asmussen, Diana Göhringer, and Michael Roitzsch. 2023. Towards modular trusted execution environments. In Proceedings of the 6th Workshop on System Software for Trusted Execution (SysTEX). ACM, 10–16. doi:10.1145/3578359.3593037DOI
- [84]Roland Wismüller, Damian Ludwinski, and Felix Breitweiser. 2024. Extending the object-capability model with fine-grained type-based capabilities. Journal of Object Technology 23, 1 (2024), 1–36. doi:10.5381/JOT.2024.23.1.A1DOI
