v0.3.0 Rust x86_64

OpenOS

A microkernel operating system written in Rust, designed for x86_64 bare metal.

Channel/Handle IPC, user-space services, and memory safety. Built for the future of systems programming.

openos@qemu:~

╔═══════════════════════════════════════════════════════════════╗
║                    OpenOS Interactive Terminal                ║
║                   Type "help" for available commands          ║
╚═══════════════════════════════════════════════════════════════╝
$_

Syscalls

Allocated

<100KB

Kernel Size

Ring 3

User Services

FEATURES

Why OpenOS?

Built for the modern era with cutting-edge technology

Blazing Fast

Optimized Rust-based kernel with zero-cost abstractions and minimal overhead.

Secure by Design

Memory safety guaranteed at compile time. No buffer overflows, no data races.

Modern Architecture

Microkernel design with message-passing IPC and modular driver framework.

Developer Friendly

Comprehensive tooling, excellent documentation, and a welcoming community.

Cross Platform

Run on x86_64, ARM64, and RISC-V architectures with consistent behavior.

Open Source

MIT licensed. Contribute, fork, and build upon OpenOS freely.

Architecture

A clean, modular design that scales

User Applications

Your applications run in isolated sandboxes

System Services

File system, networking, and device management

Kernel Core

Memory management, scheduling, and IPC

Hardware Abstraction

Unified interface for diverse hardware

OpenOS uses a microkernel architecture that separates core services into isolated modules, providing better security, reliability, and maintainability.

4Layers

ZeroCopy IPC

100%Memory Safe

Simple & Powerful

Write system code with confidence

rust
use openos::prelude::*;

fn main() {
    println!("Hello from OpenOS!");

    // Access system services safely
    let fs = FileSystem::mount("/dev/sda1")?;
    let contents = fs.read_to_string("/etc/hostname")?;
    println!("Hostname: {}", contents);
}
rust
use openos::process::{Process, Priority};

fn spawn_workers() -> Result<()> {
    // Spawn processes with isolated memory
    let worker = Process::new("worker")?
        .priority(Priority::High)
        .memory_limit(256 * 1024 * 1024)
        .spawn()?;

    // Communicate via message passing
    worker.send(Message::Data(payload))?;
    let response = worker.recv()?;

    Ok(())
}

OpenOS provides clean, safe APIs that make systems programming accessible without sacrificing performance.

Ready to explore?

Start building with OpenOS today

Read the Docs View on GitHub