LUPERIQ OS
Secure Operating System Built in Rust
A capability-based microkernel OS written entirely in Rust. No C, no Linux reuse, no proprietary blobs. Every line auditable. Every resource controlled.
Every line auditable. Every resource controlled. Every variant purpose-built.
Secure Operating System Built in Rust
LuperIQ OS is a capability-based microkernel operating system written entirely in Rust, from bootloader to desktop environment. No C, no Linux code reuse, no proprietary blobs. Around 50,000 lines of readable, auditable source code with memory safety enforced at compile time. Every resource on the system, whether a file, a network socket, or a hardware device, is accessed through unforgeable kernel handles with explicit rights. No process can do anything it was not explicitly granted permission to do.
The platform ships as 10 specialized variants, each configured for a specific domain: AI agent isolation, IoT edge devices, mobile privacy, robotics safety, medical device certification, vehicle infotainment, education, and fully open RISC-V hardware. The kernel is the same. The security model is the same. The configuration and drivers change to match the job. LuperIQ OS is early-stage, actively developed, and already booting on real hardware.
Capability-based security from the kernel up
Traditional operating systems give processes broad access and try to restrict it after the fact. LuperIQ OS inverts this model. Every process starts with nothing and receives only the specific capabilities it needs. A capability is an unforgeable kernel handle with a bitmask of explicit rights: read, write, execute, map, signal. If a process does not hold a capability for a resource, it simply cannot access it. There is no root user. There is no ambient authority. There is no way to escalate privileges by exploiting a buffer overflow because Rust prevents buffer overflows at compile time.
The cryptography stack is built from scratch in Rust: AES-128-GCM for encryption, SHA-256 for hashing, X25519 for key exchange, RSA and X.509 for certificates, and TLS 1.3 for secure communication. No OpenSSL. No hidden dependencies. Every line of crypto code is auditable.
What makes it different
Memory Safe
Zero buffer overflows, guaranteed
Written in Rust with no unsafe C code. Use-after-free, buffer overflows, null pointer dereferences, and data races are caught at compile time, not at runtime after an attacker exploits them.
Capability Handles
No ambient authority
Every resource is accessed through an unforgeable kernel handle. Processes cannot discover or manufacture handles. If you do not have the handle, you do not have access. Period.
Microkernel Design
Minimal attack surface
Drivers run in userspace, not in the kernel. A buggy driver cannot crash the system or access kernel memory. The kernel itself is minimal: scheduling, memory management, IPC, and capability enforcement.
Auditable Crypto
No hidden dependencies
TLS 1.3, AES-128-GCM, SHA-256, X25519, RSA, and X.509 are all implemented from scratch in Rust. No OpenSSL. No dynamically linked libraries. Every line is readable and auditable.
Immutable Audit Trail
Every action recorded
On Agent OS, every capability grant and revoke is logged to a SHA-256 hash chain. The log cannot be tampered with retroactively. You can prove exactly what happened and when.
Stateful Firewall
Default deny, per-app rules
Network access is capability-controlled. New applications cannot reach the network without explicit permission. Outbound connections are denied by default.
Built from scratch
LuperIQ OS is not a Linux distribution. It is not a fork of anything. The bootloader loads a custom kernel. The kernel manages memory, schedules threads, and enforces capabilities. Userspace processes communicate through IPC message channels. The network stack handles TCP/IP, DNS, HTTP, and TLS. The graphics compositor tiles windows at 30+ frames per second. The terminal emulator runs a built-in shell. Even the web browser engine is custom.
The entire stack compiles from a single Rust workspace. Three kernel crate dependencies: spin for spinlocks, bitflags for capability rights, and x86_64 for CPU structures. That is it. No sprawling dependency trees. No supply chain risk from thousands of transitive packages.
Multi-architecture
LuperIQ OS runs on x86_64 (Intel and AMD), AArch64 (ARM64, including Raspberry Pi 5), and has RISC-V support planned. The same kernel code, the same capability model, the same security guarantees across architectures.
Agent OS already boots on a Raspberry Pi 5 from an SD card image. Edge targets $35-100 ARM hardware for IoT deployments. Forge will run on fully open RISC-V boards where even the CPU instruction set is auditable. The architecture abstraction layer means adding a new platform is a driver exercise, not a rewrite.
Ten variants, one kernel
Each variant of LuperIQ OS is a focused configuration of the same kernel and security model, tuned for a specific domain. Different drivers, different default capabilities, same foundation.
Sentinel
Secure AI agent runtime
Replaces bloated agent frameworks with 3,500 lines of Rust and only 2 dependencies. Connects LLMs to messaging platforms with kernel-enforced capability isolation. What a compromised AI agent can access is controlled at the OS level, not by the agent itself.
Agent OS
Dedicated hardware for AI agents
A complete appliance: LuperIQ kernel plus Sentinel runtime on a Raspberry Pi 5. Physically separate from your corporate network. Immutable audit trail records every action. Web management UI for monitoring and configuration. An $80 box that keeps AI agents contained.
Edge
IoT, kiosks, and gateways
Capability-isolated embedded OS for ARM and RISC-V devices costing $35 to $100. Sub-configurations for retail kiosks, network gateways, and sensor hubs. Secure by default on hardware that fits in your palm.
Phone
Mobile privacy, kernel-enforced
Camera, microphone, contacts, location, and network access are each a separate capability handle. Apps request only what they need and the kernel enforces it. No background access. No silent data collection. Targeting PinePhone hardware.
Robotics
Safety-critical isolation
Capability isolation between vision, planning, and motor control systems. A compromised vision module cannot send commands to actuators. Priority-based real-time scheduling for sensor and control loops. GPIO, I2C, SPI, and UART drivers included.
Medical
Auditable OS for medical devices
Around 50,000 lines of readable Rust with zero hidden dependencies. Deterministic behavior with no background services and no auto-updates. Designed for FDA and CE certification pathways. HIPAA compliance-ready with built-in TLS 1.3.
Auto
Vehicle infotainment, safely isolated
CAN bus driver with capability isolation ensures that a compromised entertainment system cannot access vehicle control systems. OBD-II diagnostics, touchscreen UI, and browser included. Entertainment stays in its lane.
Academy
Learn OS development end to end
A complete, modern operating system in readable Rust as a teaching platform. Eight curriculum modules from boot and memory management through scheduling, security, filesystems, networking, cryptography, and graphics. Students can trace a packet from NIC to browser.
Forge
Fully open from CPU to application
RISC-V edition with no proprietary CPU, no proprietary OS, and no proprietary dependencies. The instruction set is open. The firmware is open. The OS is open. Designed for sovereignty, research, and fully auditable computing.
Desktop
General-purpose secure computing
The base LuperIQ OS experience with tiling compositor, terminal emulator, built-in shell, and browser. Every application is sandboxed by capabilities. Coming soon: widget toolkit, package manager, and user profiles.
Development status
LuperIQ OS is early-stage and actively developed. The kernel is stable and bootable on x86_64 and AArch64. It runs in QEMU and on real Raspberry Pi 5 hardware. Core systems are functional: memory management, process scheduling, capability enforcement, IPC, virtual filesystem with ext2, full TCP/IP networking with TLS 1.3, a tiling desktop compositor at 30+ fps, and a terminal with built-in shell. Sentinel has reached v0.2.0 with a complete agent runtime and 63 passing tests.
What is working today
- Capability-based microkernel with process isolation
- Round-robin thread scheduler with per-thread kernel stacks
- Virtual memory with copy-on-write and demand paging
- Virtual filesystem with ramfs, devfs, and ext2
- Block storage: ATA, AHCI, NVMe, SDHCI/SD card
- Full TCP/IP network stack with DNS and HTTP
- TLS 1.3 with from-scratch cryptography
- Tiling desktop compositor at 30+ fps
- Terminal emulator with built-in shell
- ELF binary loader for userspace programs
- Bidirectional IPC message channels
- Stateful firewall with per-app rules
- AArch64 port with Raspberry Pi 5 support
- Sentinel AI agent runtime (3,500 lines, 2 dependencies)
On the roadmap
- Userspace drivers (proving the microkernel model)
- GPU-accelerated graphics
- Widget toolkit for application development
- Package manager with signed packages
- Multi-user profiles with context adaptation
- Settings portability across devices
- RISC-V architecture support
- PinePhone and PinePhone Pro bring-up
- Real-time scheduling for robotics variant
- CAN bus driver for automotive variant
- FDA/CE certification preparation for medical variant
- End-to-end encryption for agent communications
- Live migration between hardware platforms
Sentinel: the secure AI agent runtime
Popular open-source AI agent frameworks ship as 57 megabytes of JavaScript with 1,200 npm dependencies and thousands of known vulnerabilities. Sentinel is 3,500 lines of Rust with 2 runtime dependencies. It connects large language models like Claude to messaging platforms like Telegram, Discord, and Slack with kernel-enforced capability isolation on LuperIQ OS and application-level allowlists on Linux.
On LuperIQ Agent OS, Sentinel runs on dedicated hardware, physically separate from your network. Every action the AI agent takes is logged to an immutable SHA-256 hash chain. The capability broker controls exactly which APIs, files, and network endpoints the agent can access. If an LLM tries to do something it should not, the kernel stops it before it happens.
Frequently asked questions
Is LuperIQ OS ready for production use?
Not yet. LuperIQ OS is early-stage and actively developed. The kernel is stable and boots on real hardware, but it is not ready for production deployment. Sentinel (the AI agent runtime) has reached MVP at v0.2.0 and is the closest component to production readiness.
Why Rust instead of C?
C has powered operating systems for 50 years, but it cannot prevent buffer overflows, use-after-free, null pointer dereferences, or data races at compile time. Rust can. Every memory safety bug that Rust prevents is a potential security vulnerability that never exists in LuperIQ OS.
What hardware does it run on?
x86_64 (Intel and AMD) and AArch64 (ARM64, including Raspberry Pi 5) today. RISC-V support is planned. It also runs in QEMU for development and testing.
How is this different from Linux?
Linux is a monolithic kernel where all drivers run in kernel space with full access to system memory. LuperIQ OS is a microkernel where drivers run in userspace with only the capabilities they need. Linux uses discretionary access control. LuperIQ OS uses mandatory capability-based security with no ambient authority.
What does capability-based mean?
Every resource (file, socket, device, process) is accessed through an unforgeable kernel handle. Each handle has a bitmask of specific rights. A process can only do what its handles allow. There is no root user, no sudo, no way to bypass the model.
Why build cryptography from scratch?
Using OpenSSL means trusting 700,000 lines of C code with a long history of critical vulnerabilities. LuperIQ OS implements TLS 1.3, AES-128-GCM, SHA-256, X25519, RSA, and X.509 in auditable Rust. Every line is readable and verifiable.
Can I contribute?
LuperIQ OS is developed under a contributor license agreement. Check the project repositories for CONTRIBUTING.md with development setup instructions and contribution guidelines.
What is the Forge variant?
Forge is the RISC-V edition of LuperIQ OS. RISC-V is an open instruction set architecture, meaning even the CPU design is publicly auditable. Combined with LuperIQ OS and open firmware, Forge delivers a computing stack with zero proprietary components from silicon to application.
Want to test LuperIQ OS?
We are looking for beta testers. Sign up to be among the first to try our secure Rust-built operating system.