Skip to content
Manticore is a research operating system, written in Rust.
Branch: master
Clone or download
penberg Merge 'Build support for Arch Linux and Antergos' from Henrik
"Using the OS ID's antergos and arch as discriminators for installing dependencies with pacman."
Latest commit 17c524d May 22, 2019
Type Name Latest commit message Commit time
Failed to load latest commit information.
arch x86/apic: Periodic timer support May 11, 2019
drivers Remove the use of "alloc" feature flag May 11, 2019
include/kernel kernel: console_print() system call May 11, 2019
kernel kernel: console_print() system call May 11, 2019
lib libc: Add strlcpy() Aug 16, 2017
mm mm/kmem: Use snprintf() and fix format specifiers Mar 16, 2018
scripts build: force install of xargo May 22, 2019
tests tests/tst-page-alloc: Fix printf() format specifiers Mar 16, 2018
usr liblinux: Relax CMake version requirement May 16, 2019
.clang-format clang-format: Increase line length to 120 characters Nov 16, 2017
.gitignore build: Linker script preprocessing Apr 14, 2017
Cargo.lock Remove the use of "alloc" feature flag May 11, 2019
Cargo.toml drivers/virtio: Network device driver Sep 28, 2018 Update project description May 11, 2019
LICENSE-APACHE Update project description May 11, 2019
LICENSE-MIT Update project description May 11, 2019
Makefile build: support for Antergos and Arch Linux May 22, 2019 Add a badge for May 17, 2019
Xargo.toml build: Fix aarch64 build breakage Aug 17, 2017
aarch64-unknown-none.json Upgrade to latest Rust nightly Sep 29, 2018 Update project description May 11, 2019 Upgrade to latest Rust nightly Sep 29, 2018
rustfmt.toml Add configuration for rustfmt Jan 4, 2018
x86_64-unknown-none.json Upgrade to latest Rust nightly Sep 29, 2018

Manticore Operating System

Build Status MIT/Apache 2.0 License Gitter

A research operating system to explore parakernels.

Table of Contents


Manticore is a research operating system, written in Rust, with the aim of exploring the parakernel OS architecture.

The OS is increasingly a bottleneck for server applications that want to take maximum advantage of the hardware. Many traditional kernel interfaces (such as in POSIX) were designed when I/O was significantly slower than the CPU. However, today I/O is getting faster, but single-threaded CPU performance has stagnated. For example, a 40 GbE NIC can receive a cache-line sized packet faster than the CPU can access its last-level cache (LLC), which makes it tricky for an OS to keep up with packets arriving from the network. Similarly, non-volatile memory (NVM) access speed is getting closer to DRAM speeds, which challenges OS abstractions for storage.

To address this OS bottleneck, server applications are increasingly adopting kernel-bypass techniques. For example, the Seastar framework is an OS implemented in userspace, which implements its own CPU and I/O scheduler, and bypasses the Linux kernel as much as it can. Parakernel is an OS architecture that eliminates many OS abstractions (similar to exokernels) and partitions hardware resources (similar to multikernels) to facilitate high-performance server application with increased application-level parallelism and predictable tail latency.


  • Process scheduling (no kernel threads)
  • Hardware resource partitioning
  • Virtual memory (no demand paging)
  • Kernel-bypass by default
  • Non-blocking OS system calls
  • ELF executable support

Getting Started

Building from Sources

First, install the toolchain, which includes rustup, Rust, and other dependencies:


Now that you have the toolchain installed, you can build Manticore with:


The build system generates a kernel.iso image, which you can launch under QEMU with:

$ ./scripts/run kernel.iso

For more information, see Manticore Hacker's Guide.

Running Example Applications

Once kernel.elf is built, you can build an user space echo server with:

$ make -C usr/echod

and launch it under QEMU with:

$ ./scripts/run usr/echod/echod.iso

Supported Hardware

  • Legacy-free PC with a 64-bit x86 processor
    • xAPIC2 interrupt controller
    • MSI-X interrupt delivery
    • PCIe 3.0 bus
  • VirtIO network device

Code Structure

Manticore's code is structured into different directories as follows:

  • arch: machine architecture specific code
  • drivers: device drivers
    • virtio: VirtIO device drivers
    • pci: PCIe device drivers
  • kernel: kernel services (e.g., process scheduling and system calls)
  • lib: support libraries
  • mm: memory management (e.g., virtual memory manager and kernel dynamic memory allocator)
  • usr: user space libraries and example applications




Bug reports and pull requests are welcome!

Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms. See Code of Coduct for details.


See also the list of contributors who contributed to this project.


Licensed under either of these:

Unless you explicitly state otherwise, any contribution you intentionally submit for inclusion in the work, as defined in the Apache-2.0 license, shall be dual-licensed as above, without any additional terms or conditions.

You can’t perform that action at this time.