https://github.com/ggielly/strat9-os
Strat9-OS is a modular microkernel written in Rust. Run native binary (WASM, ELF...) with small footprint directly on the kernel. Looking for contributors and help !
https://github.com/ggielly/strat9-os
kernel microkernel operating-system plan9 rust
Last synced: 7 days ago
JSON representation
Strat9-OS is a modular microkernel written in Rust. Run native binary (WASM, ELF...) with small footprint directly on the kernel. Looking for contributors and help !
- Host: GitHub
- URL: https://github.com/ggielly/strat9-os
- Owner: ggielly
- License: gpl-3.0
- Created: 2026-02-18T16:43:08.000Z (25 days ago)
- Default Branch: main
- Last Pushed: 2026-03-05T22:30:53.000Z (10 days ago)
- Last Synced: 2026-03-06T02:05:53.912Z (10 days ago)
- Topics: kernel, microkernel, operating-system, plan9, rust
- Language: Rust
- Homepage:
- Size: 3.5 MB
- Stars: 0
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Strat9-OS
Strat9-OS is an Operating System based on a modular microkernel written in Rust. The kernel provides scheduling, IPC, memory primitives, and interrupt routing. Everything else (filesystems, networking, drivers...) runs as isolated userspace components called Silos, also written in Rust.
The goal is to run various native binaries (ELF, JS, WASM..) inside the silo environment => IPC => kernel. And give features to silos like network stack, filesystem, etc. with Strates.
The Chevron shell can manage silos and strates with a bunch of commands.
Architecture concept summary: Bedrock is the microkernel, Silos are isolated Ring-3 execution units, Strates are functional layers hosted inside Silos and they can discuss together. Silos are isolated eachother.
## Architecture
- Kernel (Bedrock) in Ring 0 : minimal, `#![no_std]`.
- Silos are in Ring 3 : isolated components communicate via IPC.
- Strate are in Silo : network stack, filesystem, etc.
- Capabilities gate access to resources.
- Plan 9 style scheme model for resources.
## Status, some highlights
This project is in active development and not production-ready. The ABI is still not stabilized: the [ABI documentation is here|https://ggielly.github.io/strat9-os-docs/index.html].
### Screenshots from QEMU : bootsequence and Chevron shell
*Chevron and boot*
*2D framebuffered process monitor like (top command)*
*ls and uptime*
*Networking*
*strate screen management*
*Memory and CPU information*
*Graphics subsystem test*
#### Kernel
- SMP boot with per-CPU data, TSS/GDT, GSBase-based SYSCALL, per-CPU caches and per-CPU scheduler
- Two-stage allocator: buddy allocator for early boot and a dedicated kernel allocator (CoW support, heap/kmalloc/slab)
- Virtual memory: 4-level paging, HHDM, CR3 switching, page-fault handling (COW, mmap), user/kernel mappings
- Preemptive multitasking with APIC/x2APIC and per-CPU timers
- Limine boot path and bootable ISO
- Scheduler with priority/round-robin and CPU hotplug support
- IPC: synchronous ports, shared-memory rings (zero-copy), capability manager and VFS scheme router
- ELF loader and Ring-3 execution (userspace silos)
- POSIX interval timers and signal infrastructure
- Interrupts & exceptions: IDT, IRQ handling, exception dumps and backtraces
- Device model: PCI discovery, VirtIO and legacy drivers (block, net), console drivers
- Debugging & tooling: early serial/VGA output, configurable log levels, QEMU run targets and ISO tooling
- ACPI support and power management
- Optional Linux ABI compatibility shim for ELF binaries
#### Userspace components
- EXT4 filesystem
- RamFS filesystem
- XFS filesystem (WiP and disabled)
- VirtIO block and net drivers (kernel-side)
- libc (relibc from the Redox-OS project)
- IPv4 network stack with UDP/TCP/ICMP support, dhcp client, telnet server
- e1000/e1000e and virtio NIC drivers
- WASM native execution strate
- Remote access via SSHd or grapical with VNC
- CLI for managing silo and strate : memory management, start, stop, delete...
- Basic commands : cat, ls, uptime, reboot, shutdown, cd, top
- VFS with /proc /sys ...
```mermaid
graph TD
subgraph Ring 3 [Userspace / Silos]
direction TB
App[Application]:::app
Drivers[Drivers & Services]:::sys
subgraph Silo_JS [JIT JS Silo]
JS_Runtime[JIT JS Runtime]:::app -->|IPC| Net[Net Stack]:::sys
JS_Runtime -->|IPC| FS[Filesystem]:::sys
end
subgraph Silo_Native [Native Silo]
ELF[ELF Binary]:::app -->|IPC| Console[Console Driver]:::sys
end
end
subgraph Ring 0 [Kernel SpacSee `LICENSE`.e / Bedrock]
Kernel[Bedrock Kernel]:::kernel
Sched[Scheduler]:::kernel
IPC[IPC System]:::kernel
MM[Memory Manager]:::kernel
Kernel --- Sched
Kernel --- IPC
Kernel --- MM
end
JS_Runtime -.->|Syscall/IPC| Kernel
Net -.->|Syscall/IPC| Kernel
FS -.->|Syscall/IPC| Kernel
ELF -.->|Syscall/IPC| Kernel
Console -.->|Syscall/IPC| Kernel
classDef kernel fill:#f96,stroke:#333,stroke-width:2px;
classDef sys fill:#8cf,stroke:#333,stroke-width:1px;
classDef app fill:#8f9,stroke:#333,stroke-width:1px;
```
## Build
### Prerequisites
- Rust nightly with `rust-src` and `llvm-tools-preview`.
- QEMU.
### Commands
#### Install the Rust toolchain
```bash
rustup install nightly
rustup component add rust-src llvm-tools-preview
rustup target add x86_64-unknown-none
```
#### Compile the kernel and run it
```bash
cargo make kernel
cargo make limine-image
cargo make run-gui-smp or cargo make run-gui (for single CPU test)
```
or
```bash
cargo make
```
## Device list where Strat9-OS is booting
- QEMU
- Lenovo Thinkpad X13
## Repository way of life
- `workspace/kernel/` : the strat9-os kernel : Bedrock
- `workspace/components/` : userspace components
- `workspace/bootloader/` : limine-based bootloader
- `doc/` : specifications and design docs
- `tools/` : build and helper scripts
### Related specifications
todo...
## License
All the code is under GPLv3. See THIRD_PARTY_LICENCES.txt for more informations about librairies and software shared. Many thanks to the authors !