Red Bear OS Icon

Red Bear OS

Microkernel operating system in Rust — based on Redox OS.
Custom drivers, GPU support, and KDE Plasma desktop integration.

Get Started Downloads
0
Thousand Lines of Rust
0
Package Recipes
0
Recipe Categories
0
Thousand Source Files

What is Red Bear OS?

A modern microkernel operating system with serious hardware ambitions.

Red Bear OS is a full fork of Redox OS, based on frozen release snapshots (currently the 0.1.0 baseline). It extends upstream Redox with custom drivers, GPU support, filesystems, and desktop integration that Redox alone doesn't ship.

Built entirely in Rust, Red Bear OS runs a microkernel architecture where drivers are userspace daemons communicating via a scheme system. This design provides fault isolation, security, and a clean separation of concerns that monolithic kernels can't match.

Red Bear's custom work lives in local/ — patches, recipes, drivers, and documentation that survive upstream updates and form the durable Red Bear identity.

🦀Written in Rust
Microkernel architecture
🖥️KDE Plasma desktop target
🎮AMD & Intel GPU drivers
🔧Custom driver infrastructure
📦226 package recipes

Current Status

Red Bear OS is under active development. Here's where things stand.

ACPI Boot

Boot baseline
🎮

AMD GPU Driver

Partial
🖥️

Intel GPU Driver

Compiles
💾

ext4 Filesystem

Read/Write
🌐

Wired Networking

Native
🖼️

Qt6 + KF6 (32/32)

Built
🔗

D-Bus 1.16.2

Built
🪟

Wayland Compositor

In progress
🖥️

KDE Plasma

In progress
📡

Wi-Fi

Bounded path
🔵

Bluetooth

Bounded BLE
🔌

USB

In progress
🎨

Mesa / GBM

Partial
⚙️

PCI / IRQ Quality

In progress
🔋

ACPI Power / Shutdown

In progress
⌨️

Input Stack (libinput)

Built

Architecture

Microkernel design with userspace drivers and a scheme-based I/O system.

Userspace
Shell / UI Qt6 / KDE Wayland POSIX Apps
relibc (C library in Rust)
amdgpu i915 xhcid e1000 ps2d pcid
Schemes
Scheme System
scheme:display scheme:irq scheme:pci scheme:memory scheme:firmware
Kernel (Microkernel)
Scheduler IPC Memory Mgmt Scheme Registry
Hardware
AMD64 CPU PCIe GPU NVMe USB Network

🟢 redbear-mini

Text-only console and recovery target. Minimal footprint, boots fast. Ideal for headless systems and recovery workflows.

🔴 redbear-full

Desktop and graphics target. Includes Wayland, Qt6, KDE Frameworks, Mesa, DRM drivers, D-Bus, and firmware loading.

🟠 redbear-grub

Text-only with GNU GRUB boot manager. Multi-boot compatible with Linux systems on the same disk.

Development Timeline

The path from bare-metal boot to a hardware-accelerated KDE Plasma desktop.

Phase 1 — Complete
Runtime Substrate Validation
ACPI boot baseline, x2APIC/SMP, PCI enumeration, ACPI shutdown/reboot. Bounded QEMU/runtime proof with IOMMU, MSI-X, and xHCI IRQ validation surfaces.
4–6 weeks
Phase 2 — Complete
Driver Infrastructure
redox-driver-sys, linux-kpi, firmware-loader, redox-drm scheme daemon. MSI-X support. Quirk-aware IRQ fallback for AMD and Intel GPUs.
8–12 weeks
Phase 3 — In Progress
Wayland Compositor Proof
libwayland + wayland-protocols built. Mesa EGL+GBM+GLES2 built. Bounded greeter/compositor-backed login proof passes in QEMU/UEFI. Broader compositor/runtime stability still incomplete.
4–6 weeks
Phase 4 — In Progress
KWin Desktop Session
Qt6 (Core+Gui+Widgets+DBus+Wayland) built. KF6 Frameworks 32/32 built. D-Bus 1.16.2 with session broker. KWin building, runtime validation incomplete.
6–10 weeks
Phase 5 — Upcoming
KDE Plasma Session
Plasma Shell, KDE applications, session management. Full desktop environment running on software-rendered Wayland compositor.
8–12 weeks

Redox vs Red Bear OS

Red Bear OS is a full fork of Redox OS, based on frozen release snapshots. Custom drivers, GPU support, and desktop integration are maintained in a durable local/ directory that survives upstream updates.

FeatureRedox OSRed Bear OS
Microkernel Standard Tracked upstream
Rust toolchain Nightly Nightly (pinned)
AMD GPU driver🚧 In progress
Intel GPU driver Compiles
ext4 filesystem Read/Write
Qt6 + KF6 32/32 built
KDE Plasma🚧 In progress
Wayland compositor🚧 Experimental🚧 In progress
D-Bus 1.16.2 built
Wi-Fi / Bluetooth🚧 Bounded paths
USB stack Basic🚧 Enhanced in progress
Firmware loading scheme:firmware

Subsystem Roadmap

First-class subsystems being built in priority order. Each unlocks the next.

Priority 1 — In Tree

Low-Level Controllers & IRQ Quality

PCI interrupt plumbing, IRQ delivery quality, MSI/MSI-X follow-up, IOMMU and interrupt remapping. Architecturally strong substrate with bounded runtime proof.

Blocks: USB, Wi-Fi validation
Priority 2 — In Progress

USB Controller & Topology

USB host controller maturity, hub topology, hotplug robustness. Unlocks Bluetooth transport and broader device support.

Blocks: Bluetooth maturity
Priority 3 — In Progress

Wi-Fi Control Plane

Native wireless control surface, bounded Intel driver path, profile management via netctl. Host-tested scan/connect/disconnect flows.

First wireless driver path
Priority 4 — Bounded

Bluetooth

Host/controller path, BLE-first experimental slice. Battery Level QEMU validation in progress. Broad desktop parity still incomplete.

Depends on USB maturity

Downloads

Live ISO images for bare-metal boot and installation. Built from the latest Red Bear OS sources.

🔴 Red Bear OS Full

Desktop/graphics live ISO with Wayland, Qt6, KDE Frameworks, Mesa, and DRM drivers. For modern AMD64 hardware.

Coming Soon

x86_64/ISO/full/

🟢 Red Bear OS Mini

Text-only console and recovery live ISO. Minimal build for headless servers and recovery tasks.

Coming Soon

x86_64/ISO/mini/

Repositories

Coming Soon — ISO builds and package repositories will be available here. For now, build from source.

Build from Source

Requires a Linux x86_64 host with Rust nightly, QEMU, and standard build tools.

Terminal — redbear-build
# Desktop / graphics target make all CONFIG_NAME=redbear-full # Text-only console / recovery target make all CONFIG_NAME=redbear-mini # Live ISO for bare metal make live CONFIG_NAME=redbear-full # Boot in QEMU make qemu

See the repository for full build prerequisites and documentation.

Contribute

Red Bear OS is open source and welcomes contributions at every level.

🦀

Write Rust

Drivers, system services, libraries — the entire OS is Rust. Dive into the kernel, relibc, or userspace daemons.

🧪

Test on Hardware

Bare-metal testing on AMD and Intel machines. Report bugs, validate drivers, confirm POSIX compatibility.

📦

Package Recipes

Port new software, write TOML recipes, fix build failures. The package ecosystem needs your expertise.

📖

Write Documentation

Architecture guides, build instructions, API docs. Help make Red Bear OS accessible to new contributors.

See the repository for contribution guidelines and open issues.

Frequently Asked Questions

Common questions about Red Bear OS and what to expect.

Can I daily-drive Red Bear OS?
Not yet. Red Bear OS is under active development. The desktop stack (KDE Plasma on Wayland) and hardware GPU drivers are still in progress. It is suitable for development, testing, and contribution — not production use.
What hardware is supported?
AMD64 bare metal with UEFI boot. AMD and Intel CPUs are both first-class targets. GPU drivers (AMD amdgpu, Intel i915) compile but hardware validation is still pending. QEMU virtualization is the primary development target.
How is this different from Redox OS?
Red Bear OS is a full fork of Redox OS, based on frozen release snapshots. It extends upstream Redox with custom drivers (AMD/Intel GPU), filesystems (ext4), desktop integration (Qt6, KDE Plasma, D-Bus), and a durable local/ directory for patches and custom recipes that survive source provisioning.
Can I run Linux applications?
Directly, no. Red Bear OS uses relibc (a Rust C library), not glibc. However, many POSIX applications can be ported. The project ships 226 package recipes including Qt6, Mesa, KDE Frameworks, and common libraries.
How do I get started contributing?
Clone the repository, build with make all CONFIG_NAME=redbear-mini, and boot in QEMU. Check the documentation in docs/ and local/docs/ for architecture guides and current workstreams.