{
  "id": "sel4",
  "title": "seL4",
  "lang": "en",
  "source_lang": "en",
  "summary": "seL4 is a capability-based microkernel whose formal verification establishes functional correctness and selected security properties for specified implementations and configurations.",
  "category": "computer-science",
  "subcategory": "software",
  "type": "product",
  "aliases": [
    "seL4 microkernel"
  ],
  "generated_at": "2026-11-05",
  "model": "pro/gpt-6.1-sol",
  "url": "https://aiwiki.page/en/sel4/",
  "translations": {
    "zh-Hans": {
      "url": "https://aiwiki.page/zh/sel4/",
      "json": "https://aiwiki.page/zh/sel4.json"
    }
  },
  "sections": [
    {
      "heading": "",
      "text": "seL4 is an open-source, capability-based microkernel designed to provide a small, strongly isolated foundation for secure and dependable computer systems. It supplies essential mechanisms for managing execution, memory, communication, and authority, while leaving most operating-system services outside the kernel. Its distinguishing feature is machine-checked formal verification: for supported configurations, mathematical proofs connect the kernel implementation to a formal specification and establish additional security properties. These guarantees apply to precisely defined software, hardware models, and assumptions, rather than automatically extending to every system built using seL4."
    },
    {
      "heading": "Origins and development",
      "text": "seL4 belongs to the L4 family of microkernels, which emphasizes minimal kernel functionality and efficient communication between isolated components. Development began at Australia's National ICT Australia, or NICTA, with close involvement from researchers at the University of New South Wales.\n\nIn 2009, the project reported a machine-checked functional-correctness proof for an operating-system kernel of practical scope. The result connected an abstract specification to the kernel's implementation in the C programming language, subject to explicit assumptions about such matters as hardware behavior and low-level code outside the proof.\n\nSubsequent work extended the verification effort to security properties, executable code, and additional architectures and configurations. The kernel and its proofs were released as open source in 2014. The seL4 Foundation was established in 2020 under the Linux Foundation to support the project's community and ecosystem.\n\nVerification coverage has evolved alongside the implementation. A result established for one architecture, kernel configuration, or release should not be assumed to hold unchanged for another."
    },
    {
      "heading": "Microkernel architecture",
      "text": "A conventional operating system often places device management, networking, storage, and other services inside a privileged kernel. seL4 instead keeps a relatively small set of mechanisms in privileged execution:\n\n- Creation and management of kernel objects.\n- Control of address spaces and memory mappings.\n- Thread execution and scheduling.\n- Communication and synchronization between components.\n- Controlled delivery of hardware interrupts.\n- Enforcement of capability-based authority.\n\nServices such as file systems, network stacks, and most device drivers run as user-level components. These components interact through explicit interfaces rather than sharing unrestricted access to kernel memory.\n\nThis organization can reduce the amount of software that must be trusted for a particular security property. A faulty driver, for example, need not have authority over unrelated application memory. The effectiveness of that separation nevertheless depends on the capabilities, mappings, and hardware access actually granted to the driver.\n\nseL4 is not a complete desktop or server operating system. A usable system requires additional components for bootstrapping, resource management, applications, and any required services."
    },
    {
      "heading": "Capabilities and resource management",
      "text": "Authority represented by capabilities\n\nA capability is a kernel-protected reference to an object together with authority to perform specified operations on that object. Objects include threads, communication endpoints, memory-related objects, and capability-storage structures called CNodes.\n\nA component cannot legitimately invoke an arbitrary kernel object merely by knowing its address or choosing an identifier. It must possess an appropriate capability. Depending on the object and operation, capabilities can be copied, transferred, restricted, or revoked under kernel-enforced rules.\n\nThis supports least privilege: a component can receive only the resources and operations needed for its task. It also makes the system's authority structure explicit. However, capability enforcement does not decide which components should be trusted; the system designer must still establish an appropriate access-control policy and initial distribution of authority.\n\nExplicit memory allocation\n\nseL4 makes allocation of memory for kernel objects largely explicit. Available physical memory is represented through untyped memory capabilities. A holder with sufficient authority can retype such memory into particular kernel objects.\n\nThis design makes resource ownership and allocation more visible than in systems where kernel operations routinely allocate memory from a shared internal heap. It assists resource accounting and reasoning about isolation, although it does not by itself prevent exhaustion of every resource in a complete system.\n\nAddress spaces and communication\n\nseL4 controls virtual memory mappings and the execution state of threads. Its interprocess communication mechanisms include endpoints for message exchange and notifications for signaling events. Components can also communicate through shared memory when appropriately authorized.\n\nA typical design uses separate address spaces for mutually distrusting components, endpoints for controlled requests, and shared memory for bulk data transfer. Shared-memory access and application-level protocols still require careful coordination: kernel isolation alone does not eliminate race conditions or errors in those protocols."
    },
    {
      "heading": "Formal verification",
      "text": "Functional correctness\n\nThe central functional-correctness result is a refinement proof. In simplified terms, it establishes that the behaviors of the verified implementation are permitted by its abstract specification, under the proof's assumptions.\n\nThe verification uses proof-assistant technology, notably Isabelle/HOL. Proof checking provides assurance beyond testing alone because the argument covers the states and executions described by the formal model rather than only selected test cases.\n\nFor the verified code and configuration, refinement supports conclusions about the absence of many implementation faults, such as invalid memory accesses and undefined behavior covered by the formal semantics. However, correctness is always relative to the specification. An accurately implemented specification may still omit a requirement that a particular application needs.\n\nSecurity properties\n\nSeparate proofs address security properties, including forms of:\n\n- Integrity: a component cannot modify protected state without the required authority.\n- Confidentiality: information does not flow between security domains in ways forbidden by the formal policy.\n- Authority confinement: the system's capability rules constrain how authority can be exercised and propagated.\n\nThese are distinct from functional correctness. A proof that code implements a specification does not, by itself, establish that the specification enforces every desired security policy.\n\nInformation-flow results also depend on the modeled observations and assumptions. They should not be interpreted as blanket protection against every side-channel attack, including all effects involving caches, speculation, or physical hardware behavior.\n\nVerification of executable code\n\nA proof about C source code leaves a potential gap between that source and the executable produced by a compiler. The seL4 verification effort has included binary-level verification for selected configurations, checking a relationship between compiled machine code and the verified source-level behavior.\n\nSuch results reduce dependence on compiler correctness for the covered artifact. They do not imply that every compiler version, optimization setting, architecture, or kernel build is verified automatically.\n\nTrusted assumptions\n\nThe trusted computing base for a claim includes whatever components and assumptions must be correct for that claim to hold. Depending on the particular verification result, these may include:\n\n- The hardware and its formal model.\n- Boot and initialization behavior.\n- Low-level assembly code not covered by the relevant proof.\n- The proof checker's logical foundation and implementation.\n- Compiler behavior where no applicable binary-level result closes that gap.\n\nThe boundary is claim-specific. An application protecting a secret may additionally depend on its own code, selected services, and the correctness of the system's security configuration."
    },
    {
      "heading": "Scheduling and real-time behavior",
      "text": "seL4 supports priority-based scheduling. Its mixed-criticality scheduling configuration introduces scheduling contexts that associate execution with budgets and replenishment periods. This provides mechanisms for controlling processor-time consumption and limiting interference between components.\n\nSuch mechanisms are useful in real-time systems, where meeting deadlines matters alongside producing correct results. Nevertheless, scheduling support is not an end-to-end deadline guarantee. Establishing one requires analysis of application execution, interrupt handling, communication, blocking, and relevant hardware behavior.\n\nFunctional correctness, information-flow security, and timing guarantees are different claims. Each requires suitable models and evidence. Verification coverage for a scheduling configuration must also be checked independently rather than inferred from another configuration's proofs."
    },
    {
      "heading": "System construction and applications",
      "text": "seL4 is used as a foundation for systems that require strong separation between components of different trust levels. Relevant application areas include embedded control, security gateways, defense systems, and mixed-criticality computing.\n\nOne construction approach uses CAmkES, a component framework that describes components, interfaces, and connections and generates supporting integration code. This can make system structure explicit, but using a framework does not automatically prove the correctness of the entire assembled system.\n\nseL4 can also underpin virtualization systems. A user-level virtual-machine monitor can manage guest virtual machines, including guests running Linux, while the microkernel enforces boundaries between the monitor, guests, and other components. This allows existing software to coexist with smaller, more isolated services.\n\nThe resulting assurance remains property-dependent. Isolating a guest does not prove that the guest is free of vulnerabilities, and a virtual-machine monitor may remain security-critical for the resources under its control."
    },
    {
      "heading": "Limitations and engineering trade-offs",
      "text": "A small verified kernel does not make the surrounding software automatically correct. Applications can still contain authorization mistakes, insecure protocols, memory errors, or incorrect handling of secrets. Excessive initial authority can also defeat an intended isolation policy even when the kernel enforces every capability operation correctly.\n\nHardware behavior requires particular attention. Direct memory access by devices must be constrained appropriately, and attacks exploiting microarchitectural state may fall outside a given proof. Relevant guarantees must therefore be interpreted against an explicit threat model.\n\nMicrokernel construction also creates engineering costs. Moving services into separate components introduces interfaces, communication paths, resource-allocation decisions, and deployment configuration. These can improve fault containment while complicating integration and performance analysis.\n\nFormal verification has maintenance costs as well. Changes to code, architecture support, scheduling, or specifications can require substantial proof work. Consequently, the availability of a feature and the availability of a proof covering that feature are separate questions.\n\nFinally, seL4's kernel proofs do not generally establish application termination, freedom from all system-level deadlocks, or resistance to every denial-of-service attack. Those properties depend on resource policies, component behavior, and additional system-level arguments."
    }
  ],
  "links": [
    "open-source-software",
    "capability-based-security",
    "microkernel",
    "formal-verification",
    "c-programming-language",
    "operating-system",
    "kernel-operating-system",
    "file-system",
    "device-driver",
    "least-privilege",
    "access-control",
    "virtual-memory",
    "thread-computing",
    "interprocess-communication",
    "shared-memory",
    "race-condition",
    "proof-assistant",
    "side-channel-attack",
    "compiler",
    "machine-code",
    "real-time-operating-system",
    "virtualization",
    "virtual-machine",
    "linux",
    "deadlock",
    "denial-of-service-attack"
  ],
  "sources": [],
  "license": "https://creativecommons.org/licenses/by/4.0/"
}