vasilito
9ff9b4b0e2
The Redox EGL platform was in-tree from a prior session (the
egldisplay.h enum entry, eglapi.c dispatch, egl_dri2.c case,
meson.build / meson.options / src/egl/meson.build wiring,
recipe.toml platforms list). This commit closes the remaining
gaps so the platform actually builds.
What was missing / what this fixes:
1. dri2_initialize_redox prototype was not declared in
egl_dri2.h. The function definition in platform_redox.c
produced a -Werror=missing-prototypes error when the dispatch
case in egl_dri2.c tried to call it. Added the prototype
under HAVE_REDOX_PLATFORM.
2. platform_redox.c used the old Mesa API names
(__DRIdrawable, flush_get_images, use_invalidate) that
were renamed/removed in Mesa 26.1.4. The codebase is a
2022-era RedoxOS fork updated to a 26.1.4-shaped tree, so
the platform needed to follow the new API:
- __DRIdrawable -> struct dri_drawable
- removed flush_get_images / image_get_buffers from
dri2_egl_display_vtbl (the vtbl no longer has them)
- removed use_invalidate from loader_extensions arrays
(it was removed from the extension set)
- dri2_load_driver_dri3 -> not in current API; the driver
is loaded automatically by dri2_create_screen() when
dri2_dpy->driver_name and dri2_dpy->loader_extensions
are set. Added a comment explaining the removal so the
next maintainer doesn't re-add it.
- dri2_setup_extensions -> removed in 26.1.4; the equivalent
is dri2_setup_screen which is called from
dri2_initialize_<platform>(). Removed the call.
3. image_loader_extensions[] is now declared with
__attribute__((unused)). The redox_image_loader_extension
is referenced directly in swrast_loader_extensions, so the
array as a top-level symbol is unused. Kept for future
expansion (e.g. hardware image loading) where the array
might be reused.
Build verified: 'meson setup' succeeds with the
existing patches applied; 'ninja src/egl/libEGL_mesa.so.0.0.0'
links cleanly with the redox platform included. dri2_initialize_redox
is a local symbol inside libEGL_mesa.so, called from
dri2_initialize() in egl_dri2.c via the _EGL_PLATFORM_REDOX case.
Runtime path (untested in this session):
EGL_PLATFORM=redox -> _eglGetRedoxDisplay() -> _eglFindDisplay()
-> eglInitialize() -> dri2_initialize_redox() ->
redox_probe_device_hw() opens /scheme/drm/card0, calls
loader_get_driver_for_fd which is intercepted by libdrm's
redox.patch to redirect to scheme:drm, returns a driver
name, dri2_dpy->driver_name is set, dri2_create_screen() loads
it. Falls back to swrast when no DRM device is present.
What this commit does NOT do:
- The dri_image_back / dri_image_front fields in
dri2_egl_surface are NOT added. The basic pbuffer +
front-buffer path works without them. Hardware-backed
image rendering would need them (deferred to follow-up).
- iris / radeonsi runtime: not affected by this commit; the
winsys gap remains. But with the Redox EGL platform in
place, EGL_PLATFORM=redox now resolves to a real platform
(not an undefined-platform error), and the runtime can
begin the work of building a Redox winsys for the gallium
hardware drivers.
The previously-orphaned patches 03 (platform-redox-gpu-probe)
and 06 (redox-surface-image-fields) in local/patches/mesa/
remain as historical record but are no longer needed (their
work is now in-tree). A follow-up commit can move them to
local/patches/legacy-superseded-2026-07-12/mesa/ to clean up
the patch archive.
Red Bear OS
A microkernel operating system written in Rust — derived from Redox OS, built for bare metal.
What is Red Bear OS?
Red Bear OS is a general-purpose, Unix-like operating system with a microkernel architecture,
written entirely in Rust. It is a full fork of Redox OS (baseline 0.3.1), actively developed
on branch 0.3.1 with hardware enablement, multiple filesystems, a native greeter and login
system, and a KDE Plasma desktop path.
We aim to stay close to upstream Redox — diverging only where necessary to add missing functionality, fix bugs, or support new hardware. The build system itself is under constant active development alongside the OS.
It ships with several first-in-class Rust-native tools found nowhere else in the OS world:
- cub — an AUR-inspired package manager with pacman-style CLI (
-S/-Q/-R) and a ratatui TUI that converts Arch Linux PKGBUILDs into Red Bear recipes on the fly - tlc (Twilight Commander) — a pure-Rust reimplementation of Midnight Commander; dual-panel file manager, built-in editor and viewer, 8 color themes, 1204 unit tests, zero unsafe code
- redbear-power — interactive ratatui TUI for live CPU frequency, governor, and thermal monitoring with on-the-fly P-state control
These are joined by dozens of redbear-* system utilities — redbear-netctl (network control),
redbear-info (hardware diagnostics), redbear-acmd (admin CLI), redbear-mtr,
redbear-nmap, redbear-btctl, and many more — all written in Rust, all built from source
alongside the OS.
Goals:
- AMD & Intel parity — equal-priority bare-metal support for both platforms
- KDE Plasma desktop — Wayland-based desktop environment via the KWin compositor
- Hardware GPU acceleration — AMD (amdgpu) and Intel GPU drivers via
redox-drm - cub package ecosystem — AUR → recipe.toml pipeline giving access to thousands of packages
- First-class subsystems — USB, Wi‑Fi, Bluetooth, ext4, FAT, GRUB, D-Bus (none optional)
- Power management — CPU frequency scaling, thermal monitoring, RAPL, sleep states
- Offline-first, reproducible builds — BLAKE3-verified source archives with content-hash caching
Our Git Server
Red Bear OS lives on a self-hosted Gitea instance at https://gitea.redbearos.org.
This is the canonical home — no GitHub, GitLab, or Codeberg mirror is authoritative.
There is exactly one repository: all component sources (kernel, relibc, drivers,
system utilities) live here as submodule branches or tracked trees in local/sources/.
| Field | Value |
|---|---|
| Host | https://gitea.redbearos.org |
| User | vasilito |
| Web UI | https://gitea.redbearos.org/vasilito |
| Main repo | https://gitea.redbearos.org/vasilito/RedBear-OS |
Authentication tokens are per-session credentials — never stored in the repo. See
local/AGENTS.md§ Our Git Server for the full operator runbook.
Quick Start
Prerequisites
Linux x86_64 host with Rust nightly, QEMU, nasm, and standard build tools. See the Redox Build Guide for full setup.
Build & Run
# Clone (read-only)
git clone https://gitea.redbearos.org/vasilito/RedBear-OS.git
cd RedBear-OS
# Authenticated clone — supply token via env var
git clone https://vasilito:${REDBEAR_GITEA_TOKEN}@gitea.redbearos.org/vasilito/RedBear-OS.git
# Canonical build entry point
./local/scripts/build-redbear.sh redbear-mini # Text-only target
./local/scripts/build-redbear.sh redbear-full # Desktop-capable target
# Boot in QEMU
make qemu
local/scripts/build-redbear.shis the only supported build entry point. It handles.configparsing, prefix staleness detection, protected-recipe authorization, pre-cooking critical packages, and source fingerprint tracking. Directmakeinvocations bypass these gates. SeeAGENTS.md§ Build Commands for details.
Config Targets
| Target | Type | Description |
|---|---|---|
redbear-full |
Desktop-capable | GPU drivers + Wayland compositor + Qt 6.11.1 + KF6 6.27.0 + KWin + SDDM + greeter + D-Bus |
redbear-mini |
Console | Text-only recovery / install target with tlc, cub, and redbear-* utilities |
redbear-grub |
Console | Text-only with GRUB boot manager |
Current Status
Red Bear OS boots to a login prompt in QEMU with working wired networking, D-Bus system bus,
hardware detection daemons, and three filesystem backends (RedoxFS, ext4, FAT). The ISO builds
successfully on branch 0.3.1. Graphics packages are frozen at latest upstream stable
(Qt 6.11.1, KF6 6.27.0, Plasma 6.7.2, SDDM 0.21.0, Mesa 26.1.4, wayland-protocols 1.49).
| Area | Status |
|---|---|
| Boot (ACPI, x2APIC, SMP) | ✅ Bare-metal proven — Ryzen Threadripper 128-thread verified |
| Userspace drivers (PCI, storage, net) | ✅ Working in QEMU |
| Filesystems — RedoxFS, ext4, FAT | ✅ Scheme daemons + mkfs/fsck tools |
| D-Bus system bus + services | ✅ Working — login1, PolicyKit, UDisks, UPower |
| cub package manager | 🟡 17-module Rust workspace; AUR → recipe pipeline; 70+ tests |
| tlc file manager | 🟡 113 .rs files, 46k+ lines; 1497 tests; 8 skins; VFS archives; first-paint panic fixed (2026-07-24) |
| IRQ / PCI / MSI-X / IOMMU | 🟡 QEMU-proven; shared-IRQ re-arm bug class swept across 11 drivers (2026-07-20); hardware validation open |
| POSIX gaps (relibc) | 🟡 ~85% coverage; PATCHED-VIA-PATH-FORK — relibc changes are committed directly to local/sources/relibc/; local/patches/relibc/ holds reference and archived patches only |
| DRM/KMS display drivers | 🟡 AMD + Intel + virtio-gpu compile; HW validation open |
| Mesa — llvmpipe + virgl | 🟡 Builds (virtio_gpu_dri.so, 17.4 MB); virgl EGL runtime probe open |
| 3D userland (iris / radeonsi / Vulkan) | 🔴 Not built |
| SDDM display manager + Greeter/Login | 🟡 Wired in redbear-full; graphical login blocked by Qt6 Wayland crash |
| Qt 6.11.1 (Core, Gui, DBus, Wayland) | 🟡 Builds successfully; Wayland null+8 crash blocks runtime |
| KF6 Frameworks — 40/40 | 🟡 All frameworks build; KWin cooks successfully |
| Wayland compositor | 🟡 Bounded proof; blocked by Qt6 Wayland protocol crash |
| KWin | 🟡 Builds successfully (redox-drm + Qt6 Wayland); runtime blocked by Qt6 Wayland crash in wl_proxy_add_listener |
| KDE Plasma | 🔴 Runtime blocked by Qt6 Wayland null+8 crash — depends on KWin |
| Wi‑Fi (Intel iwlwifi) | 🟡 VFIO/passthrough bounded runtime validation framework exists |
| USB / Bluetooth | 🟡 xHCI mature in QEMU: 51-flag quirks, capability gating, 36-code error recovery, Linux hub enumeration state machine, hub + hub-child enumeration proven, storage BOT proven; USB 2.0 HW LPM (L1) attach path implemented; endpoint-indexing bug class fixed across acmd/ecmd/usbaudiod/usbhidd; UAS/HID-parser expansion in flight; Bluetooth controller path planned |
Where help is most wanted: Qt6 Wayland protocol crash — the #1 blocker for graphical desktop · AMD/Intel GPU hardware validation on bare metal · USB controller maturity · Wi‑Fi native control plane · cub AUR pipeline hardening · package maintainers for the growing recipe catalog · tlc VFS remote backends and archive support
How It Works
Red Bear OS uses a userspace driver model — all drivers run as unprivileged daemons communicating through the kernel's scheme-based IPC.
┌─────────────────────────────────────────────────────────────────┐
│ KERNEL (microkernel) │
│ schemes: memory · irq · event · pipe · debug │
└──────────────────────────┬──────────────────────────────────────┘
│
┌─────────────────────┼─────────────────────────┐
▼ ▼ ▼
┌──────────┐ ┌──────────────────┐ ┌──────────────────────┐
│ pcid │ │ e1000d xhcid │ │ vesad redox-drm │
│ PCI enum │ │ Intel USB 3.0 │ │ fbdev GPU manager │
└──────────┘ └──────────────────┘ └──────────────────────┘
┌──────────┐ ┌──────────────────┐ ┌──────────────────────┐
│ ext4d │ │ ps2d evdevd │ │ thermald cpufreqd │
│ fatd │ │ KB+mouse input │ │ thermal CPU freq │
└──────────┘ └──────────────────┘ └──────────────────────┘
┌──────────┐ ┌──────────────────┐ ┌──────────────────────┐
│ iommu │ │ acpid │ │ dbus-daemon │
│ DMA map │ │ power mgmt │ │ system + session │
└──────────┘ └──────────────────┘ └──────────────────────┘
The kernel provides minimal services: memory, interrupts, and IPC. Everything else —
filesystems, networking, graphics, input, power management, D-Bus — runs in userspace.
Hardware quirks are handled by a data-driven system in redox-driver-sys with compiled-in
tables, TOML runtime configuration, and DMI matching.
Engineering Standards
Red Bear OS operates under strict discipline. Full policies: local/AGENTS.md.
| Rule | |
|---|---|
| Never delete to "fix" a build | If a package breaks, fix the root cause. Never remove, ignore, or comment out a package, service, or config to make a build pass. |
| Zero stubs | No fake headers, #ifdef no-ops, or "make it compile" shortcuts. Missing functionality must be implemented properly in the right component. |
| Single repository | All component sources live here — no per-component repos. 9 submodule/<component> branches. |
| Local fork model | Core components (kernel, relibc, base, bootloader, installer, redoxfs, userutils) are maintained as local forks in local/sources/ with immutability guarantees; syscall and libredox are wired as Cargo path dependencies via redbear-rt consumers, not via recipes/<comp>/recipe.toml path =. |
| Adapt to upstream | Red Bear adapts to upstream API/ABI changes — never pins, downgrades, or holds back a dependency. |
| Free/libre only | No proprietary, source-unavailable, or redistributability-restricted dependencies. MIT licensed. |
Documentation
- Desktop Path Plan — Canonical plan v6.0: kernel → DRM → Mesa → Wayland → KDE
- Implementation Plan — Roadmap and execution model
- cub Package Manager — AUR → recipe pipeline, CLI reference, architecture
- tlc File Manager — Pure-Rust Midnight Commander replacement
- D-Bus Integration — Session bus architecture
- IRQ & Low-Level Controllers — IRQ delivery, MSI/MSI-X, IOMMU
- Greeter & Login — Native greeter, auth daemon, session launch
- DRM Modernization — DRM/KMS display and render maturity
- USB Plan — USB stack design and implementation
- Patch Preservation Audit — orphan-patch governance, Rounds 1-6 audit results, SUPERSEDED.md log
- Collision Detection Status — runtime collision-detection current state
- Hooks — opt-in git hooks (pre-push safety net, etc.)
- Build Tools — 15-tool reference (patch-status, sync, verify, collision, release-bump, etc.)
- Fork Push Status — fork-branch push results + base deadlock (updated Round 9)
- Wi‑Fi Plan — Wireless architecture and driver plan
- Bluetooth Plan — Bluetooth stack design
- Build Cache — Content-hash (BLAKE3) build cache system
- Build System Hardening — Collision detection, init service validation
- Build System Assessment — Architecture, quality, robustness, and gap assessment (2026-07-18)
- Quirks System — Hardware quirks infrastructure
- Documentation Index — Full doc map
Contributing
Red Bear OS is a full fork of Redox OS. Upstream sources are frozen and archived; all
custom work lives in local/ and survives every build operation.
local/
├── sources/ # Local forks of core components (kernel, relibc, base, bootloader, …)
├── recipes/ # Custom packages — drivers, GPU stack, system daemons, branding
├── patches/ # Durable changes to upstream source trees
│ └── (orphan-patch governance: every patch must correspond to work
│ present in the matching fork source tree. `verify-patch-content.sh`
│ enforces this on every build preflight. See
│ `local/docs/PATCH-PRESERVATION-AUDIT-2026-07-12.md` for the audit
│ and AGENTS.md § "Orphan-Patch Supersession Decision Tree" for the
│ decision flow when an orphan is detected.)
├── docs/ # Integration and planning documentation
└── scripts/ # Build, test, validation, and release tooling
We're Looking For
| Role | What you'd work on |
|---|---|
| Package maintainers | Port and maintain AUR packages through cub's pipeline; write and test recipe.toml files for Red Bear OS; improve the PKGBUILD → recipe conversion |
| Driver developers | AMD/Intel GPU drivers, USB controller maturity, Wi‑Fi native control plane, Bluetooth |
| Graphics stack engineers | Qt6 Wayland crash fix (the #1 desktop blocker), Mesa virgl runtime, KWin Wayland compositor |
| Systems/Rust engineers | Kernel syscalls, relibc POSIX gaps, filesystem daemons, D-Bus services, hardware quirks |
| TUI/app developers | tlc feature completion, cub TUI polish, redbear-power enhancements, new redbear-* utilities |
Contributions are welcome with or without AI assistance — we care about quality, not how the code was produced. Pick an area from the status table above, check the relevant plan doc, and dive in.
License
MIT — same as upstream Redox OS.