vasilito
a24cfe64c4
R1-R10 audit Gap 10: evdevd had zero HID quirk consumption. The lookup_hid_quirks entry point in redox-driver-sys was populated by R10 with 191 compiled-in entries + TOML support, but no consumer read it. Every InputDevice entering the evdev scheme flew past the HID quirk table. This change: - Adds a redox-driver-sys path dependency to source/Cargo.toml. Path mirrors the depth used by pcid/usbhidd (4 ../ levels to reach local/, then recipes/drivers/redox-driver-sys/source). - Adds source/src/quirks.rs with one public function, log_hid_quirks(vendor, product, kind), that calls lookup_hid_quirks and emits an info-level line on a non-empty result, debug-level on empty. - Wires the call into EvdevScheme::add_device() at the moment the InputDevice is created, before it is pushed onto the device list. - Adds 'mod quirks' to main.rs module declarations. Caveat (carried forward from the audit, 2026-06-07): evdevd currently constructs InputDevice with vendor=0 because the upstream usbhidd produces orbclient::Event streams without forwarding the real USB vendor/product IDs. The lookup therefore returns empty flags in practice. Once the orbclient event pipe is extended to carry the device IDs, the wiring below will start logging the matched flag sets without any further code change. This is documented in the module-level docstring of quirks.rs. 4 unit tests cover the wiring: - synthetic zero-vendor returns empty - synthetic product IDs 0..32 return empty (these are the IDs evdevd currently assigns) - a real Linux HID table entry (0x06d6:0x0025 → BADPAD) returns the expected flag - the log helper does not panic on any input Note on pre-existing test errors: cargo test fails to compile the test binary because of unrelated errors in src/translate.rs:517,534 and src/gesture.rs:1 (a 'translate_gesture' function that no longer exists). These pre-date this change and are out of scope for Gap 10. cargo check is clean (zero new warnings from this change); the failing tests are in the existing scheme.rs and device.rs test modules that have nothing to do with the new quirks module.
Red Bear OS
A microkernel operating system written in Rust, derived from Redox OS
What is Red Bear OS?
Red Bear OS is a general-purpose, Unix-like operating system with a microkernel architecture, written in Rust. It is a full fork of Redox OS, frozen at release 0.1.0, with added hardware support, filesystem drivers, and a KDE Plasma desktop path.
Goals:
- AMD & Intel parity — first-class support for both platforms on bare metal
- KDE Plasma desktop — Wayland-based desktop environment via the KWin compositor
- Hardware GPU acceleration — AMD GPU (amdgpu) and Intel GPU drivers via
redox-drm - Modern subsystems — USB, Wi‑Fi, Bluetooth, ext4, GRUB, D-Bus
- Offline-first builds — reproducible from archived, BLAKE3-verified sources
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
git clone https://gitea.redbearos.org/vasilito/RedBear-OS.git
cd RedBear-OS
# Build and run the desktop target in QEMU
./scripts/run.sh --build
# Build a live ISO for bare metal
./scripts/build-iso.sh redbear-full
# Build the text-only recovery target
./scripts/run.sh --build --config redbear-mini
Repository Hosting
The canonical Red Bear OS Git server is Gitea at
https://gitea.redbearos.org/vasilito/RedBear-OS.git. GitHub is not a Red Bear OS source of
truth and must not be used for pushes, issues, releases, or project coordination.
Public Scripts
| Script | Purpose |
|---|---|
scripts/run.sh |
Build and run in QEMU (-b to build, -c <config> for target) |
scripts/build-iso.sh |
Build a live ISO for bare-metal boot |
scripts/build-all-isos.sh |
Build all live ISO targets |
scripts/network-boot.sh |
PXE network boot helper |
scripts/dual-boot.sh |
Dual-boot installation helper |
Config Targets
| Target | Type | Description |
|---|---|---|
redbear-full |
Desktop | Wayland + KDE + GPU drivers + D-Bus services |
redbear-mini |
Console | Text-only recovery / install target |
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 filesystem support (RedoxFS, ext4, FAT).
| Area | Status |
|---|---|
| Boot (ACPI/x2APIC/SMP) | ✅ Bare-metal proven |
| Userspace drivers (PCI, storage, net) | ✅ Working in QEMU |
| D-Bus system bus + services | ✅ Working (login1, PolicyKit, UDisks, UPower) |
| ext4 / FAT filesystems | ✅ Compiles, installer-wired |
| POSIX gaps (relibc) | 🚧 Bounded Wayland-facing support |
| DRM/KMS display drivers | 🚧 AMD + Intel compile; HW validation pending |
| Wayland compositor | 🚧 Bounded proof; Qt6/KF6 clients crash at init |
| KDE Plasma desktop | 🔄 In progress (Qt6/KF6 compile; KWin/QML blocked) |
| Wi‑Fi / Bluetooth | 📋 Planned (architected, implementation pending) |
How It Works
Red Bear OS uses a userspace driver model — all drivers run as unprivileged daemons:
Kernel (microkernel)
└── schemes: memory, irq, event, pipe, debug
└── Driver daemons (userspace)
├── pcid → PCI enumeration
├── e1000d → Intel ethernet
├── xhcid → USB controller
└── vesad → Display framebuffer
The kernel provides minimal services (memory, interrupts, IPC). Everything else — filesystems, networking, graphics, input — runs in userspace.
Documentation
- Implementation Plan — roadmap and execution model
- Desktop Path Plan — kernel → DRM → Mesa → Wayland → KDE
- D-Bus Integration — session bus architecture
- USB Plan — USB stack design
- Wi‑Fi Plan — wireless architecture
- Bluetooth Plan — BT stack design
- Documentation Index — full doc map
Contributing
Red Bear OS uses a full fork model. Upstream Redox sources are frozen and archived. All custom work lives in local/:
local/
├── sources/ # Red Bear source forks (git repos, directly editable)
├── recipes/ # Custom packages (drivers, GPU, system)
├── docs/ # Integration and planning docs
└── scripts/ # Build, test, and release tooling
We welcome contributions made with or without AI assistance — we care about quality, not how the code was produced.
License
MIT — same as upstream Redox OS.