Frequently Asked Questions

General Questions

What is VeridianOS?

VeridianOS is a next-generation microkernel operating system written entirely in Rust. It emphasizes security, modularity, and performance through a capability-based security model and modern OS design principles.

Why another operating system?

VeridianOS addresses several limitations in existing systems:

Security: Capability-based security from the ground up
Safety: Rust's memory safety eliminates entire classes of bugs
Modularity: True microkernel design with isolated services
Performance: Modern algorithms and zero-copy IPC
Simplicity: Clean codebase without decades of legacy

What makes VeridianOS different?

Key differentiators:

Written entirely in Rust (no C/C++ in kernel)
Capability-based security model throughout
Designed for modern hardware (64-bit only)
Native support for virtualization and containers
Post-quantum cryptography ready
Formal verification of critical components

What's the project status?

VeridianOS has completed Phase 0 (Foundation) as of v0.1.0 (June 2025) and is now starting Phase 1 (Microkernel Core). All foundation infrastructure is in place and development is proceeding to kernel implementation.

When will it be ready for daily use?

Our timeline targets:

2025: Core kernel functionality (Phase 1)
2026: Basic usability with drivers and userspace (Phase 2-3)
2027: Production readiness for specific use cases (Phase 4-5)
2028: Desktop and general use (Phase 6)

Technical Questions

What architectures are supported?

Current support:

x86_64: Full support, primary platform
AArch64: Full support, including Apple Silicon
RISC-V (RV64GC): Experimental support

All architectures require:

64-bit CPUs with MMU
4KB page size support
Atomic operations

What's a microkernel?

A microkernel runs minimal code in privileged mode:

Memory management
CPU scheduling
Inter-process communication (IPC)
Capability management

Everything else runs in user space:

Device drivers
File systems
Network stack
System services

Benefits include better security, reliability, and modularity.

What are capabilities?

Capabilities are unforgeable tokens that grant specific permissions:

Not "who you are": No user IDs or access control lists
But "what you can do": Hold a capability = have permission
Composable: Combine capabilities for complex permissions
Revocable: Invalidate capabilities to revoke access

Example:

#![allow(unused)]
fn main() {
// A capability to read from a file
let read_cap: Capability<FileRead> = file.get_read_capability()?;

// Use the capability
let data = read_cap.read(buffer)?;

// Delegate to another process
other_process.send_capability(read_cap)?;
}