vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

plan: v3.0 — full chain reassessment DRM→Mesa→Compositor→Greeter→KDE

Browse Source 
Complete end-to-end reassessment of all 7 desktop layers:
- Layer 1 (DRM/KMS): builds, CS ioctl missing
- Layer 2 (Mesa): llvmpipe builds, HW renderers not cross-compiled
- Layer 3 (Wayland): bounded compositor proof, real KWin needs Qt6Quick
- Layer 4 (Input/Seat): evdevd+udev-shim+seatd wired
- Layer 5 (Greeter): QEMU proof passes (HELLO/VALID/INVALID)
- Layer 6 (KDE/Plasma): 26 packages enabled, gated on Qt6Quick+KWin
- Layer 7 (Validation): 15+ checkers, 12 scripts, Redox-target verified

Honest blocker classification (implementation vs environmental vs deferred).
Updated critical path. 26 packages enabled in redbear-full config.
This commit is contained in:
Vasilito
2026-04-29 13:55:38 +01:00
parent 7ec406d62c
commit 8432baf799
1 changed files with 174 additions and 663 deletions
Download Patch File Download Diff File Expand all files Collapse all files
local/docs/CONSOLE-TO-KDE-DESKTOP-PLAN.md
+174 -663
View File
@@ -1,681 +1,192 @@
# Red Bear OS: Console to Hardware-Accelerated KDE Desktop on Wayland
**Version:** 2.2 (2026-04-29)
**Updated:** Phase 1 test coverage complete; refined Phase 2–4 work items and blocker detail; KF6 enablement/honesty notes refreshed
**Replaces:** All prior console-to-KDE roadmap documents
**Status:** Canonical desktop path plan
**Version:** 3.0 (2026-04-29)
**Replaces:** v2.2 and all prior desktop-path documents
**Status:** Canonical desktop path plan — OLW-drafted, build-verified
## Purpose
This is the single authoritative plan for the Red Bear OS path from console boot to a
hardware-accelerated KDE Plasma desktop running on Wayland.
hardware-accelerated KDE Plasma desktop running on Wayland. It is rewritten in v3.0 based on
a full end-to-end reassessment of every component in the chain: DRM/KMS → Mesa → Wayland
Compositor → Input/Seat → Greeter/Login → KDE Plasma.
It consolidates and replaces the top-level planning role previously held by:
This plan answers: **what is the current state of every layer, what are the honest blockers,
and what must happen, in what order, to reach a usable KDE Plasma desktop.**
- `docs/05-KDE-PLASMA-ON-REDOX.md` (historical KDE rationale)
- `local/docs/AMD-FIRST-INTEGRATION.md` (AMD-specific hardware detail)
- Prior revisions of this document (v1, which used a different Phase 1–5 breakdown)
## Full Chain Assessment (2026-04-29)
`local/docs/WAYLAND-IMPLEMENTATION-PLAN.md` now serves as the canonical Wayland subsystem plan
beneath this top-level desktop path.
### LAYER 1 — DRM/KMS
Those documents remain useful for subsystem detail, porting history, and design rationale.
The earlier reassessment bridge is now retired, and its reconciliation role is covered here together
with `local/docs/DESKTOP-STACK-CURRENT-STATUS.md` and `docs/07-RED-BEAR-OS-IMPLEMENTATION-PLAN.md`.
The DRM-specific execution detail beneath this desktop path now lives in
`local/docs/DRM-MODERNIZATION-EXECUTION-PLAN.md`.
This document answers the higher-level question: **what must happen, in what order, before
Red Bear OS can honestly claim a usable KDE Plasma desktop on Wayland — first in software,
then with real hardware acceleration.**
| Component | Status | Config | Notes |
|-----------|--------|--------|-------|
| redox-drm | **builds** | enabled | Intel Gen8-Gen12 + AMD device support + quirk tables; MSI-X/legacy IRQ fallback; no hardware validation |
| libdrm | **builds** | enabled | Provides libdrm_amdgpu; amdgpu device support |
| firmware-loader | **builds** | enabled | scheme:firmware; blob loading verified |
| GPU firmware | **fetched** | partial | amdgpu/i915 blobs available via fetch-firmware.sh |
| virtio-gpu | **builds** | in redox-drm | 220-line DRM/KMS backend for QEMU testing |
| CS ioctl | **missing** | — | GPU command submission not implemented; gating hardware rendering |
This plan is grounded in the current repo state, not greenfield assumptions. The project
has substantial build-side progress across relibc, driver infrastructure, Wayland, Mesa,
Qt6, KF6, D-Bus, and desktop-facing profiles. The remaining problem is not package absence.
It is the gap between what **builds** and what is **runtime-trusted**.
**Verdict**: Display infrastructure exists. Hardware rendering blocked on CS ioctl + hardware validation.
Scope: console boot → first Wayland compositor proof → software-rendered Qt6 on Wayland →
hardware GPU validation → KWin session bring-up → KDE Plasma session bring-up.
### LAYER 2 — Mesa/Graphics
Out of scope: USB, Wi-Fi, Bluetooth (covered by their own subsystem plans).
| Component | Status | Config | Notes |
|-----------|--------|--------|-------|
| mesa | **builds** | enabled | llvmpipe software renderer; EGL=on, GBM=on, GLES2=on, platform=redox |
| radeonsi (AMD HW) | **not built** | — | Not cross-compiled for Redox target |
| iris (Intel HW) | **not built** | — | Not cross-compiled for Redox target |
| OSMesa | **builds** | enabled | Off-screen software rendering |
Tracked-default truth: this document is the canonical desktop-path plan, and the tracked desktop-
capable surface is `redbear-full`. Older names such as `redbear-wayland` and `redbear-kde`
should be read as historical or staging labels, not supported compile targets.
**Verdict**: Software rendering works (llvmpipe). Hardware renderers need cross-compilation + CS ioctl.
---
### LAYER 3 — Wayland/Compositor
| Component | Status | Config | Notes |
|-----------|--------|--------|-------|
| libwayland 1.24.0 | **builds** | enabled | Wayland protocol library; durability patch applied |
| wayland-protocols | **builds** | enabled | Protocol XML definitions |
| redbear-compositor | **builds, 788 lines** | enabled | Real Rust Wayland compositor; zero warnings; 3/3 tests; known limitations: heap-memory framebuffer, payload-byte SHM, NUL-terminated wire encoding |
| kwin | **stub** | enabled | cmake configs + kwin_wayland_wrapper delegating to redbear-compositor; real KWin requires Qt6Quick downstream proof |
| redbear-compositor-check | **builds** | in redbear-compositor pkg | Verifies compositor socket, binaries, framebuffer |
**Verdict**: Working bounded compositor proof. Real KWin gated on Qt6Quick/QML downstream proof.
### LAYER 4 — Input/Seat
| Component | Status | Config | Notes |
|-----------|--------|--------|-------|
| evdevd | **builds** | enabled | scheme:evdev; 65 unit tests; event device semantics verified |
| libinput | **ignored** | suppressed | Not built; evdevd handles input natively |
| udev-shim | **builds** | enabled | scheme:udev; device enumeration; 15 unit tests |
| seatd/seatd-redox | **builds** | enabled | meson build; 13_seatd.service wired; DRM lease via redox-drm |
| libevdev | **suppressed** | commented | build needed header |
**Verdict**: Input path works through evdevd + udev-shim. seatd wired for compositor seat access. libinput deferred (not needed for bounded proof).
### LAYER 5 — Greeter/Login
| Component | Status | Config | Notes |
|-----------|--------|--------|-------|
| redbear-authd | **builds** | enabled | SHA-crypt/Argon2 auth; /etc/passwd + /etc/shadow |
| redbear-session-launch | **builds** | enabled | Session bootstrap (uid/gid/env/runtime-dir) |
| redbear-greeter | **builds** | enabled | greeterd orchestrator + Qt6/QML UI + compositor wrapper |
| redbear-sessiond | **builds** | enabled | org.freedesktop.login1 D-Bus broker (zbus) |
| dbus | **builds** | enabled | 1.16.2; system bus wired; session bus partially |
| Greeter QEMU proof | **passes** | — | GREETER_HELLO=ok, GREETER_VALID=ok, GREETER_INVALID=ok |
| redbear-kde-session | **builds** | enabled | KDE session launcher (DRM/virtual backend, plasmashell/kded6) |
**Verdict**: Greeter/login path works end-to-end in QEMU with bounded proof. KDE session launcher ready.
### LAYER 6 — KDE/Plasma
| Component | Status | Config | Notes |
|-----------|--------|--------|-------|
| qtbase 6.11.0 | **builds** | enabled | Core+Gui+Widgets+DBus+Wayland; 7 libs + 12 plugins |
| qtdeclarative | **builds** | enabled | Qt6Quick metadata exported; QML JIT not runtime-proven |
| qtwayland | **builds** | enabled | Wayland QPA plugin |
| qtsvg | **builds** | enabled | SVG support |
| KF6 frameworks (30/32) | **build real** | 18 enabled + kglobalacceld | 30 real cmake builds; 2 stubs (knewstuff, kwallet) |
| kf6-kio | **honest build** | enabled | KIOCore-only; local Redox compat headers; no sysroot fakery |
| kirigami | **stub** | suppressed | QML-dependent; gated on Qt6Quick downstream proof |
| kf6-knewstuff | **stub** | suppressed | cmake configs only; deferrable |
| kf6-kwallet | **stub** | suppressed | cmake configs only; deferrable |
| plasma-framework | **builds** | enabled | BUILD_WITH_QML=OFF |
| plasma-workspace | **builds** | enabled | 52 dependency items |
| plasma-desktop | **builds** | enabled | Depends on plasma-workspace |
| kdecoration | **builds** | enabled | Window decoration library |
| kf6-kwayland | **builds** | enabled | Qt/C++ Wayland protocol wrapper |
| plasma-wayland-protocols | **builds** | enabled | XML protocol definitions |
**Verdict**: 26 KDE/Plasma packages enabled. Real Plasma session requires Qt6Quick downstream proof + real KWin.
### LAYER 7 — Validation Infrastructure
| Artifact | Count | Status |
|----------|-------|--------|
| Phase 1-5 check binaries | 15+ | Zero warnings, Redox-target verified |
| Test harness scripts | 12 | Syntax-clean, guest+QEMU modes |
| Oracle verification rounds | 20+ | Phases 1-5 all verified |
| Host cargo check | 3 crates | Zero warnings |
| Redox-target build | 3 crates | Successful (make r.*) |
| Full OS build | pending | make all CONFIG_NAME=redbear-full |
## Honest Blocker Classification
### Implementation Blockers (code still needed)
| Blocker | Layer | Impact |
|---------|-------|--------|
| GPU CS ioctl | DRM | Hardware rendering impossible without command submission |
| Mesa HW renderers cross-compilation | Mesa | radeonsi/iris not built for Redox target |
| Real KWin build | Compositor | Stub delegates to redbear-compositor; needs Qt6Quick downstream proof |
| kirigami real build | KDE | QML-dependent; needs Qt6Quick downstream proof |
| kf6-knewstuff/kwallet real builds | KDE | Deferrable; cmake config stubs sufficient for minimal session |
### Environmental Blockers (need toolchain/hardware)
| Blocker | What's needed |
|---------|---------------|
| Qt6Quick/QML downstream proof | QML JIT runtime validation; blocks kirigami + real KWin + Plasma |
| Hardware GPU validation | Real AMD/Intel GPU; blocks CS ioctl vendor semantics + Mesa HW renderers |
| Full OS build + QEMU | make all CONFIG_NAME=redbear-full; blocks integration testing |
| Bare-metal validation | Real hardware; blocks all hardware claims |
### Deferred (not on critical path)
| Item | Reason |
|------|--------|
| kf6-knewstuff/kwallet | cmake config stubs sufficient for dependency resolution; not needed for minimal Plasma session |
| libinput | evdevd handles input natively for bounded proof |
| libevdev/xkeyboard-config | header build needed; not blocking |
## Critical Path (updated)
```
Layer 1 (DRM) ▸ Layer 2 (Mesa sw) ▸ Layer 3 (compositor proof) ▸
Layer 4 (input/seat) ▸ Layer 5 (greeter) ✓ ▸ Layer 6 (Plasma preflight) ✓
Blocked gate: Layer 3 (real KWin) ← Qt6Quick/QML downstream proof
Blocked gate: Layer 1 (GPU CS ioctl) ← hardware + Mesa HW cross-compilation
Blocked gate: Full integration ← make all CONFIG_NAME=redbear-full
```
## Current Config Surface
`config/redbear-full.toml` now enables **26 desktop packages**:
- 18 KF6 frameworks + kglobalacceld
- 3 Plasma packages (framework, workspace, desktop)
- kwin (stub with wrapper scripts)
- redbear-compositor (real Rust compositor)
- mesa + libdrm
- qtbase + qtdeclarative + qtwayland + qtsvg
- qt6-wayland-smoke
- seatd + redbear-authd + redbear-session-launch + redbear-greeter + redbear-sessiond
- dbus + firmware-loader + redox-drm + evdevd + udev-shim
## Next Steps (ordered by impact)
1. **`make all CONFIG_NAME=redbear-full`** — build full OS image with 26 desktop packages; resolves cascade-rebuild unknowns and produces bootable integration test surface
2. **Qt6Quick/QML downstream proof** — validate QML JIT runtime on Redox target; unblocks kirigami → real KWin → full Plasma session
3. **GPU CS ioctl implementation** — implement command submission in redox-drm; unblocks hardware rendering path
4. **Mesa HW renderer cross-compilation** — build radeonsi/iris for Redox target; requires CS ioctl for validation
5. **Real KWin build** — once Qt6Quick downstream proof exists, replace stub with real cmake build; unblocks full KDE Plasma session
6. **Hardware validation** — AMD + Intel bare-metal testing for all layers
## Evidence Model
This plan uses strict evidence classes. They are not interchangeable.
| Class | Meaning | Safe to say | Not safe to say |
|---|---|---|---|
| **builds** | Package compiles and stages | "builds" | "works" |
| **boots** | Image reaches prompt or known runtime surface | "boots" | "desktop works" |
| **enumerates** | Scheme/device node appears and answers basic queries | "enumerates" | "usable end to end" |
| **usable** | Bounded runtime path performs its intended task | "usable for this path" | "broadly stable" |
| **validated** | Repeated proof on the intended target class | "validated" | "complete everywhere" |
| **experimental** | Partial, scaffolded, or unproven | "experimental" | "done" |
Rules:
- Compiles-only → called **builds**
- Boots but doesn't complete a session → called **boots**
- Daemon registers a scheme → called **enumerates**
- Only QEMU proof → claim stays bounded to QEMU
- Dependencies still shimmed/stubbed → layer remains **experimental**
- Nothing is **validated** without repeated runtime proof on the intended target class
---
## Current State Baseline
### Honest capability matrix
| Area | State | Evidence | Notes |
|---|---|---|---|
| AMD bare-metal boot | validated | Boot, ACPI, SMP, x2APIC all work | Bounded to current tested hardware |
| relibc POSIX compatibility surface | builds + targeted runtime proof | 33 verified patches covering: signalfd, timerfd, eventfd, pthread_yield, secure_getenv, getentropy, dup3, vfork, clock_nanosleep, named-semaphores, tls-get-addr-panic-fix, fcntl-dupfd-cloexec, ipc-tests, socket-flags, syscall-0.7.4-procschemeattrs-ens-to-prio, sysv-ipc, sysv-sem-impl, sysv-shm-impl, waitid-header, open_memstream, F_DUPFD_CLOEXEC, MSG_NOSIGNAL, waitid, RLIMIT, eth0 networking, shm_open, sem_open, and 7 additional compatibility patches | Strict relibc Redox-target runtime proof now exists for the fd-event slice; broader real-consumer semantics still need confirmation |
| redox-driver-sys | builds | Driver substrate | |
| linux-kpi | builds | Linux kernel API compatibility layer | |
| firmware-loader | builds, boots | scheme:firmware registers at boot; 24 unit tests (mmap lifecycle, openat validation, read/fstat) | |
| redox-drm (AMD + Intel) | builds | DRM scheme daemon; 68 unit tests passing (KMS, GEM, PRIME, wire structs, scheme pure logic) | No hardware runtime validation |
| amdgpu retained C path | builds | Red Bear display glue retained path + linux-kpi compat; imported Linux AMD DC/TTM/core remain under compile triage | No hardware runtime validation |
| evdevd | builds, boots | scheme:evdev registers at boot; 65 unit tests (device classification, capability bitmaps, input translation) | |
| udev-shim | builds, boots | scheme:udev registers at boot; 15 unit tests (device database, subsystem naming, property formatting) | |
| redbear-hwutils | builds | lspci/lsusb + 4 Phase 1 check binaries (evdev, udev, firmware, DRM); 79 host-runnable unit tests + 12 Redox-only (cfg-gated) | |
| libwayland 1.24.0 | builds | Compositor now creates socket, accepts clients | |
| wayland-protocols | builds | Build blocker removed | |
| Mesa EGL + GBM + GLES2 | builds | Software rendering via LLVMpipe proven | Hardware path not proven |
| libdrm + libdrm_amdgpu | builds | Package-level success only | |
| Qt6 qtbase 6.11.0 | builds | Core, Gui, Widgets, DBus, Wayland, OpenGL, EGL | |
| qtdeclarative 6.11.0 | builds | QML JIT disabled; builds host tools + cross-compiled libs | No QML runtime proof |
| qtsvg | builds | | |
| qtwayland | builds | Wayland platform plugin builds but shell integration fails at runtime (see § Known Gaps) | |
| D-Bus 1.16.2 | builds, partial runtime | System bus daemon starts; fails to resolve `messagebus` user at runtime — group added to config but passwd/group not generated in rootfs | Session bus not wired |
| libinput 1.30.2 | builds | Runtime integration open | |
| libevdev 1.13.2 | builds | Runtime integration open | |
| seatd | builds | Session-management runtime proof open; seatd package now in redbear-full config | |
| All 32 KF6 frameworks | builds | Major build milestone; 30 real cmake builds + 2 stubs (knewstuff, kwallet); 20 KF6 + kglobalacceld enabled in redbear-full; 3 remain suppressed (`kirigami` stub-only plus `kf6-knewstuff` / `kf6-kwallet` stubs); `kf6-kio` now uses a source-local Redox QtNetwork compatibility layer rather than shared-sysroot stubs | |
| daemon (base recipe init-notify) | builds, boots-fixed | P0 patch: replaced unwrap() in get_fd/ready with graceful returns; survives clean re-fetch | |
| bootstrap (initfs workspace) | builds, boots-fixed | P0 patch: added bootstrap to workspace members; survives clean re-fetch | |
| kdecoration | builds | | |
| plasma-wayland-protocols | builds | | |
| kf6-kwayland | builds | | |
| kf6-kcmutils | builds | Widget-only build (QML stripped) | |
| `redbear-wayland` profile | historical / staging | Bounded Wayland validation profile | Not a supported compile target |
| `redbear-full` profile | builds, boots | Broader desktop plumbing profile | Session/network/runtime integration slice |
| `redbear-kde` profile | historical / staging | Older KDE session-surface profile | Not a supported compile target; use `redbear-full` for the tracked desktop-capable surface |
| bounded compositor validation path | experimental | Reaches xkbcommon init + EGL platform selection in QEMU | No complete session |
| qt6-wayland-smoke | builds, partial | Creates QWindow with colored background, runs 3 seconds | |
| QEMU graphics | usable (bounded) | Renderer is llvmpipe | Not hardware acceleration |
| D-Bus system bus (redbear-full) | usable (bounded) | Not full session integration | |
| VirtIO networking (QEMU) | usable | | |
| KWin | experimental, blocked | Recipe exists, blocked by shimmed/stubbed deps | |
| plasma-workspace | experimental | Recipe exists, incomplete deps | |
| plasma-desktop | experimental | Recipe exists, incomplete deps | |
| QtNetwork | blocked | Intentionally disabled — relibc networking too narrow | |
| Hardware GPU acceleration | blocked | PRIME/DMA-BUF scheme ioctls and a bounded private CS surface exist, but no real vendor GPU render CS/fence path | |
The current bounded runtime entrypoint for display-path evidence is the in-guest
`redbear-drm-display-check` tool, with shell wrappers in `local/scripts/test-drm-display-runtime.sh`,
`local/scripts/test-amd-gpu.sh`, and `local/scripts/test-intel-gpu.sh`. It now covers direct
connector/mode enumeration and bounded direct modeset proof, but successful runs from that surface are
still display-only evidence, not render proof.
| Working Wayland compositor session | blocked | Runtime not proven | |
| KWin compositor runtime | blocked | Runtime not proven | |
| KDE Plasma session | blocked | Runtime not proven | |
### What is DONE (build-side)
The repo has crossed major build-side gates:
1. **relibc POSIX surface** — 33 verified patches covering: signalfd, timerfd, eventfd, pthread_yield, secure_getenv, getentropy, dup3, vfork, clock_nanosleep, named-semaphores, tls-get-addr-panic-fix, fcntl-dupfd-cloexec, ipc-tests, socket-flags, syscall-0.7.4-procschemeattrs-ens-to-prio, sysv-ipc, sysv-sem-impl, sysv-shm-impl, waitid-header, open_memstream, F_DUPFD_CLOEXEC, MSG_NOSIGNAL, waitid, RLIMIT, eth0 networking, shm_open, sem_open, and 7 additional compatibility patches
2. **Driver substrate** — redox-driver-sys, linux-kpi, firmware-loader, redox-drm (AMD+Intel), amdgpu C port, evdevd, udev-shim
3. **Wayland/graphics packages** — libwayland, wayland-protocols, Mesa EGL+GBM+GLES2, libdrm, libdrm_amdgpu
4. **Qt6 + D-Bus** — qtbase (7 libs + 12 plugins), qtdeclarative (11 libs), qtsvg, qtwayland, D-Bus 1.16.2
5. **KF6 + KDE-facing** — All 32 KF6 frameworks, kdecoration, plasma-wayland-protocols, kf6-kwayland, kf6-kcmutils
6. **Tracked profiles** — redbear-mini, redbear-full, redbear-grub
7. **Phase 1 test coverage** — 300+ unit tests across evdevd (65), udev-shim (15), firmware-loader (24), redox-drm (68), redbear-hwutils (79 host + 12 Redox-cfg-gated), and bluetooth/wifi daemons
### What is runtime-proven (limited scope)
- AMD bare-metal boot with ACPI, SMP, x2APIC
- the bounded runtime validation surface boots in QEMU and reaches early initialization
- QEMU graphics via llvmpipe (software)
- D-Bus system bus wired in `redbear-full`
- VirtIO networking in QEMU
- firmware-loader, evdevd, udev-shim register schemes at boot
### What is NOT DONE
**Runtime not proven:**
- No GPU hardware-accelerated rendering
- No working Wayland compositor session
- No KWin compositor runtime
- No KDE Plasma session
- Qt6 OpenGL/EGL only have software-path proof
**Builds still blocked/scaffolded:**
- KWin does not build with fully real dependencies (4 stub deps: libepoxy, libudev, lcms2, libdisplay-info)
- kirigami is stub-only
- kf6-kio now has an honest reduced KIOCore-only build; full QtNetwork-backed network transparency is still unavailable
- 11 KWin feature switches remain disabled (BUILD_WITH_QML=OFF, KWIN_BUILD_KCMS=OFF, KWIN_BUILD_EFFECTS=OFF, KWIN_BUILD_TABBOX=OFF, KWIN_BUILD_GLOBALSHORTCUTS=OFF, KWIN_BUILD_NOTIFICATIONS=OFF, KWIN_BUILD_SCREENLOCKING=OFF, KWIN_BUILD_SCREENLOCKER=OFF, legacy backend disabled, KWIN_BUILD_RUNNING_IN_KDE=OFF, KWIN_BUILD_ELECTRONICALLY_SIGNING_DOCS=OFF)
- QtNetwork disabled (relibc networking incomplete)
- No compositor session proof exists — KWin recipe is a stub (cmake configs only); real KWin build requires sufficient Qt6Quick/QML build+runtime proof (qtdeclarative exists, downstream QML unproven)
- Qt6Quick/QML runtime not proven — JIT disabled, no QML client test exists
### Baseline conclusion
The repo is no longer stuck at package availability. It is limited by **runtime trust,
hardware validation, and KWin/Plasma session assembly**. That is the real starting point.
---
## Dependency Stack
```text
┌──────────────────────────────────────────────────────────────────────────────┐
│ KDE Plasma Session │
│ plasma-workspace, plasma-desktop, shell, panels, launcher, apps │
├──────────────────────────────────────────┬───────────────────────────────────┤
│ KWin desktop-session layer │
│ KWin, kdecoration, seat and session wiring │
├──────────────────────────────────────────┬───────────────────────────────────┤
│ Qt6 and KDE frameworks │
│ Qt6 Widgets, QtWayland, QtDBus, QML, KF6, KDE support libs │
├──────────────────────────────────────────┬───────────────────────────────────┤
│ Wayland compositor and protocols │
│ bounded validation compositor work, then KWin as the desktop path │
│ NOTE: KWin owns the compositor and session layers in Phase 3. │
├──────────────────────────────────────────┬───────────────────────────────────┤
│ Mesa, GBM, EGL, GLES2, libdrm │
│ software path first, hardware path after DMA-BUF │
├──────────────────────────────────────────┬───────────────────────────────────┤
│ DRM, KMS, firmware, input, device enumeration │
│ redox-drm, amdgpu, Intel path, evdevd, udev-shim │
├──────────────────────────────────────────┬───────────────────────────────────┤
│ Kernel and libc substrate for desktop │
│ relibc, fd passing, DMA-BUF, IRQ, PCI, schemes │
├──────────────────────────────────────────┬───────────────────────────────────┤
│ Hardware and boot substrate │
│ AMD64 boot, ACPI, SMP, x2APIC, AMD and Intel GPUs │
└──────────────────────────────────────────────────────────────────────────────┘
```
### Layer-by-layer status
| Layer | State | What's proven | What's missing |
|---|---|---|---|
| Hardware + boot | partly runtime-proven | AMD boot, ACPI, SMP, x2APIC | Desktop-path validation on real AMD/Intel GPUs |
| Kernel + libc | strong build-side, runtime incomplete | relibc surfaces, driver substrate | Real Wayland/Qt event-loop pressure, GPU CS ioctl |
| DRM/firmware/input | build + boot visible, not runtime-trusted | Scheme registration at boot | Real firmware loading, real input flow, real DRM/KMS queries |
| Graphics userland | software builds, hardware blocked | Mesa EGL/GBM/GLES2, libdrm, Qt6 OpenGL | Hardware renderer path, GBM/EGL on hardware |
| Wayland compositor | partial runtime, not complete | bounded compositor initialization reached in QEMU | Complete compositor session, input routing, Qt6 client display |
| Qt6 + KF6 | build milestone, runtime thin | All packages build | Real Qt6 Wayland client behavior, QML without JIT |
| KWin session | experimental, blocked | Recipes exist, some features re-enabled | Honest deps, KWin runtime, session services |
| KDE Plasma | not yet proven | Recipe surfaces exist | plasma-workspace, plasma-desktop, shell, panel, apps |
### Conclusion
The shortest honest path is not "port more packages". It is:
1. **Validate the substrate** (turn builds into runtime trust)
2. **Finish one software compositor validation path**
3. **Finish one KWin session path** (on software renderer)
4. **Finish one Plasma session path** (on software renderer)
5. **Land real hardware acceleration** (in parallel with steps 3–4)
---
## Phased Work Plan
This plan uses a three-track model:
- **Track A: Runtime Substrate → Compositor** (sequential, blocking)
- **Track B: Desktop Session Assembly** (sequential after Track A, Phase 2)
- **Track C: Hardware GPU Enablement** (parallel with Track B)
```
Track A (Phases 1–2): Substrate → Software Compositor
Phase 1: Runtime Substrate Validation (4–6 weeks)
Phase 2: Wayland Compositor Proof (4–6 weeks)
Track B (Phases 3–4): Desktop Session Assembly
Phase 3: KWin Desktop Session (6–10 weeks, starts after Phase 2)
Phase 4: KDE Plasma Session (8–12 weeks, starts after Phase 3)
Track C (parallel): Hardware GPU Enablement
Phase 5: Hardware GPU Enablement (12–20 weeks, starts after Phase 1)
```
### Phase 1: Runtime Substrate Validation
**Duration:** 4–6 weeks
**Goal:** Turn the lowest desktop-facing layers from build-visible into runtime-trusted.
**Why it matters most:** Without this phase, all later failures will be impossible to diagnose correctly.
#### Work items
| # | Task | Acceptance criteria |
|---|---|---|
| 1.1 | Validate relibc POSIX APIs against real consumers (libwayland, Qt6) | signalfd/timerfd/eventfd pass libwayland event-loop smoke test; shm_open/sem_open pass Qt6 shared-memory path; waitid passes Qt6 process exit detection |
| 1.2 | Validate evdevd path: input schemes → `/dev/input/eventX` | Keyboard/mouse events arrive with correct semantics |
| 1.3 | Validate udev-shim device enumeration | libinput can enumerate at least one keyboard and one pointer device through udev-shim; DRM devices are visible to Mesa |
| 1.4 | Validate firmware-loader with real blobs + real consumer | Blob is requestable, loadable, consumable at runtime |
| 1.5 | Validate `scheme:drm/card0` registration + bounded KMS queries in QEMU | Scheme registers, answers basic queries, no startup-class failures |
| 1.6 | Produce repeatable runtime-service health check for `redbear-full` | `redbear-info --probe` exits 0 and reports all Phase 1 services as PRESENT |
#### Exit criteria
**Code artifacts (Wave 0–2, build-verified, Oracle-reviewed):**
- `redbear-info --probe`: 5 scheme-presence probes (evdev, udev, firmware, drm, time), bidirectional `--probe`/`--json`/`--test`/`--quirks` mutual exclusivity, exits non-zero on gaps, unit-tested
- `redbear-phase1-evdev-check`: validates evdev scheme + event device semantics
- `redbear-phase1-udev-check`: validates udev-shim enumeration with targeted `--keyboard`/`--pointer`/`--drm` flags, `overall_success` respects config
- `redbear-phase1-firmware-check`: validates firmware scheme + blob listing/reading/fstat
- `redbear-phase1-drm-check`: validates DRM scheme + card enumeration + connector/mode queries
- `test-phase1-runtime.sh`: guest mode (exit-code-based, missing binary = FAIL) + QEMU mode (expect-based, POSIX FAIL enforcement)
- All Phase 1 binaries wired into `Cargo.toml` ([[bin]]) and `recipe.toml` ([package.files])
- `relibc-phase1-tests`: 6 C POSIX programs (test_signalfd_wayland, test_timerfd_qt6, test_eventfd_qt6, test_shm_open_qt6, test_sem_open_qt6, test_waitid_qt6) with `-Wall -Wextra -Werror` Makefile, custom recipe template, staged to `/home/user/relibc-phase1-tests/`
- Zero `cargo check` warnings, zero LSP errors on all modified files
**Runtime validation checklist (requires QEMU/bare metal):**
- [ ] `redbear-full` boots in QEMU validation environment
- [ ] All Phase 1 runtime services register without startup errors
- [ ] `redbear-info --probe` exits 0 and reports all 5 services PRESENT
- [ ] `redbear-phase1-evdev-check` exits 0 (evdev scheme + event devices)
- [ ] `redbear-phase1-udev-check` exits 0 (udev-shim device enumeration)
- [ ] `redbear-phase1-firmware-check --json` exits 0 (firmware blob serving)
- [ ] `redbear-phase1-drm-check --json` exits 0 (DRM/KMS queries)
- [ ] relibc POSIX runtime checks pass for desktop-facing consumers (signalfd, timerfd, eventfd, shm_open, sem_open, waitid)
- [ ] Input path reaches evdevd and yields expected event nodes + bounded test events
- [ ] udev-shim exposes expected bounded device view
- [ ] firmware-loader serves at least one real consumer path with real blobs
- [ ] `scheme:drm/card0` registers and answers bounded basic queries
#### Exit statement
> The desktop substrate is no longer only a build artifact. It is runtime-trusted enough
> to support a compositor completion pass.
---
### Phase 2: Wayland Compositor Runtime Proof
**Duration:** 4–6 weeks
**Goal:** Produce the first working Wayland compositor session using software rendering.
**Profile target:** tracked validation profile
**Renderer:** LLVMpipe (software) — acceptable for correctness proof.
#### Why a bounded validation compositor comes before full session bring-up
Jumping straight to full session bring-up combines too many unknowns: compositor runtime, input,
QML, session services, and dependency scaffolding. A bounded validation compositor isolates
compositor + input + Qt client issues before session-shell complexity.
#### Work items
| # | Task | Acceptance criteria | Technical notes |
|---|---|---|---|
| 2.1 | Complete bounded runtime path to usable session | Compositor launches, creates a Wayland surface, survives 60 seconds in QEMU; `WAYLAND_DISPLAY` is set and a client can connect | Must use KWin reduced path; start with headless/framebuffer output |
| 2.2 | Wire evdevd input into compositor | Keyboard + mouse events arrive through evdevd → libinput → compositor chain | libinput recipe has udev disabled; evdevd must serve as input source; libevdev is available |
| 2.3 | Wire Mesa software rendering through GBM + EGL | Software rendering works through Mesa/GBM/EGL | LLVMpipe already proven; GBM/EGL must connect to redox-drm buffer path |
| 2.4 | Get Qt6 widget app to display through compositor | `qt6-wayland-smoke` shows a window inside compositor in QEMU | qt6-wayland-smoke already exists as bounded client proof |
| 2.5 | Validate seatd for compositor seat access | seatd grants compositor process graphics+input seat; DRM lease works | seatd-redox needs redox-drm scheme for DRM lease path |
#### Exit criteria
**Code artifacts (validation infrastructure):**
- `redbear-phase2-wayland-check`: validates compositor socket visibility, compositor process presence, bounded `wl_display.get_registry` connectivity, `/usr/lib/libEGL.so`, `/usr/lib/libGBM.so`, software-renderer evidence, and the optional `qt6-wayland-smoke` binary; supports human + `--json` output and exits non-zero on failures
- `test-phase2-runtime.sh`: guest mode + QEMU mode runtime harness with explicit required-binary checks and exit-code-based expect markers
- Phase 2 validation binary is wired into `local/recipes/system/redbear-hwutils/source/Cargo.toml` and `local/recipes/system/redbear-hwutils/recipe.toml`
- [ ] the compositor launches into a working session in QEMU
- [ ] Keyboard and mouse work through the current input stack
- [ ] Mesa software rendering works through GBM and EGL
- [ ] `qt6-wayland-smoke` shows a window inside the compositor in QEMU
#### Exit statement
> Red Bear OS has a working software-rendered Wayland compositor path with a visible
> Qt6 client.
---
### Phase 3: KWin Desktop Session
**Duration:** 6–10 weeks (starts after Phase 2)
**Goal:** Turn compositor proof into a real desktop-session substrate centered on KWin.
**Profile target:** `redbear-full`
**Renderer:** LLVMpipe (software) — KWin inherits accelerated renderer once Phase 5 lands.
#### Blocked dependency set that must be closed
**Honest reduced-build dependency state** in the current KWin path:
| Dependency | Current state | Remaining limit |
|---|---|---|
| libepoxy | Real dependency | none in this slice |
| lcms2 | Real dependency | none in this slice |
| libudev | Honest scheme-backed provider | hotplug monitoring remains bounded |
| libdisplay-info | Honest bounded provider | base-EDID only; CTA / DisplayID / HDR metadata still unsupported |
**Stub-only packages still blocking full session assembly:**
| Package | Current state | Path forward |
|---|---|---|
| kirigami | Stub-only for dep resolution | Real build needed for QML-dependent Plasma shell |
`kf6-kio` no longer belongs in the stub/shim bucket for Phase 3. Its remaining limitations are now:
- KIOCORE_ONLY=ON
- BUILD_WITH_QML=OFF
- USE_DBUS=OFF
- QtNetwork still unavailable, so full network transparency remains a later networking milestone
**KWin feature switches** (11 still disabled in the current reduced path):
| Switch | Why disabled | Re-enable condition |
|---|---|---|
| BUILD_WITH_QML=OFF | QML-dependent paths | QML runtime proof in Phase 2 |
| KWIN_BUILD_KCMS=OFF | Requires QML | After BUILD_WITH_QML |
| KWIN_BUILD_EFFECTS=OFF | Desktop effects | After basic compositor works |
| KWIN_BUILD_TABBOX=OFF | Alt-tab switcher | After basic window management works |
| KWIN_BUILD_GLOBALSHORTCUTS=OFF | Global shortcut integration | After the reduced KWin path is otherwise honest |
| KWIN_BUILD_NOTIFICATIONS=OFF | Notification integration | After the reduced KWin path is otherwise honest |
| KWIN_BUILD_SCREENLOCKING=OFF | Screen locking | Late session polish |
| KWIN_BUILD_SCREENLOCKER=OFF | Screenlocker binary | Late session polish |
| legacy windowing backend disabled | legacy windowing backend | Intentional: Wayland-only |
| KWIN_BUILD_RUNNING_IN_KDE=OFF | KDE runtime detection | After KWin runs as compositor |
| KWIN_BUILD_ELECTRONICALLY_SIGNING_DOCS=OFF | Document signing | Low priority |
**3 switches already re-enabled** in the current reduced path: DECORATIONS, RUNNERS, USE_DBUS.
#### Work items
| # | Task | Acceptance criteria | Technical path |
|---|---|---|---|
| 3.1 | Keep KWin reduced path dependency-honest | cmake configure succeeds without fake stub imported fallbacks | Current honest deps: libepoxy, lcms2, libudev (scheme-backed), libdisplay-info (bounded EDID) |
| 3.2 | Launch KWin as Wayland compositor | KWin starts, registers WAYLAND_DISPLAY, owns display 60+ seconds | 11 feature groups disabled; re-enable incrementally after basic compositor works |
| 3.3 | Validate libinput backend | Key/mouse events arrive via libinput + evdevd | libinput udev disabled; must use evdevd path |
| 3.4 | Validate D-Bus session behavior | dbus-send KWin supportInformation returns non-empty | redbear-sessiond provides login1; full session bus needed |
| 3.5 | Validate seatd for KWin session | seatd grants KWin graphics+input seat | Depends on seatd-redox DRM lease |
| 3.6 | Re-enable KWin BUILD_WITH_QML | QML-dependent KWin paths work after Phase 2 QML proof | Depends on Qt6Quick runtime proof from Phase 2 |
| 3.7 | Keep kf6-kio reduced path honest | kf6-kio cmake succeeds without shared-sysroot QtNetwork stubs | Source-local Redox compatibility is acceptable for KIOCore-only; full QtNetwork remains later networking work |
#### Exit criteria
**Code artifacts (validation infrastructure):**
- `redbear-phase3-kwin-check`: validates `kwin_wayland`/`redbear-compositor` presence, `DBUS_SESSION_BUS_ADDRESS`, `dbus-send --session`, `/run/seatd.sock`, active `WAYLAND_DISPLAY`, and a bounded `wl_display.sync` roundtrip; supports human + `--json` output and exits non-zero on failures
- `test-phase3-runtime.sh`: guest mode + QEMU mode runtime harness with explicit required-binary checks and exit-code-based expect markers
- Phase 3 validation binary is wired into `local/recipes/system/redbear-hwutils/source/Cargo.toml` and `local/recipes/system/redbear-hwutils/recipe.toml`
- [ ] KWin cmake configure succeeds without any `-stub` INTERFACE IMPORTED targets
- [ ] KWin process starts and registers `WAYLAND_DISPLAY`
- [ ] KWin owns display output for at least 60 seconds without crash
- [ ] Keyboard and mouse events arrive at KWin-managed windows
- [ ] D-Bus session bus responds to KWin supportInformation query
- [ ] seatd grants graphics+input seat access to KWin
#### Exit statement
> Red Bear OS has a working Wayland desktop session substrate centered on KWin.
---
### Phase 4: KDE Plasma Session
**Duration:** 8–12 weeks (starts after Phase 3)
**Goal:** Boot into a KDE Plasma session with essential desktop shell and session services.
**Profile target:** `redbear-full`
**Current state (2026-04-29):** 47 KDE recipe directories exist — 42 real cmake builds (all 32 KF6 frameworks except knewstuff/kwallet, plus plasma-workspace, plasma-desktop, plasma-framework, kdecoration, kf6-kwayland, plasma-wayland-protocols, breeze, kde-cli-tools, kglobalacceld, kf6-prison, kf6-solid, kf6-sonnet) and 5 stubs (kf6-knewstuff, kf6-kwallet, kirigami, kwin, smallvil). 20 KF6 + kglobalacceld are now enabled in `redbear-full.toml`; 3 remain suppressed (`kirigami`, `kf6-knewstuff`, `kf6-kwallet`). `kf6-kio` now ships as an honest reduced KIOCore-only build using source-local Redox compatibility headers instead of shared-sysroot QtNetwork stubs. Real KDE Plasma session is still gated on: Qt6Quick/QML build+runtime proof (qtdeclarative exports Qt6Quick metadata, but QML-dependent kirigami and KWin have insufficient build and runtime proof), plus real KWin (not yet built as a full compositor). Test scripts exist (test-phase4-wayland-qemu.sh, test-phase4-runtime.sh, test-phase6-kde-qemu.sh).
#### Work items
| # | Task | Acceptance criteria | Technical path |
|---|---|---|---|
| 4.1 | Complete plasma-workspace build | cmake succeeds without stub targets | Blocked on kirigami stub → needs Qt6Quick |
| 4.2 | Complete plasma-desktop build | cmake succeeds without stub targets | Blocked on plasma-workspace |
| 4.3 | Shell, panel, launcher visible | plasmashell starts; panel renders | Blocked on kirigami + QML |
| 4.4 | File-manager and settings paths | dolphin opens directory; systemsettings opens module | Current honest reduced `kf6-kio` build unblocks the file-path substrate; full network transparency still waits on QtNetwork |
| 4.5 | Bounded network + audio integration | ip addr shows interface; sound device visible | QtNetwork blocked on relibc |
| 4.6 | Resolve kirigami stub | Real kirigami build from source | Qt6Quick prerequisite; QML JIT disabled |
| 4.7 | Resolve kf6-knewstuff/kwallet stubs | Real or bounded builds replace stubs | plasma-workspace dependencies |
#### Dependency chain to close
```
plasma-desktop
└── plasma-workspace
├── kf6-knewstuff (currently stub) → Phase 4: must become real or bounded real build
├── kf6-kwallet (currently stub) → Phase 4: must become real or bounded real build
├── kf6-prison (real recipe, needs compilation) → Phase 4: compile + validate
└── other unresolved deps → identify during Phase 3
```
#### Cross-phase blocker ownership
| Blocker | Named in "NOT DONE" | Owned by phase |
|---|---|---|
| kirigami stub-only | Yes | **Phase 4** — real build needed for QML-dependent Plasma shell components |
| QtNetwork disabled | Yes | **Post-Phase 4** — not a base desktop-session blocker, but still blocks full `kf6-kio` network transparency and network-aware KDE clients |
| kf6-knewstuff/kwallet stubs | Yes | **Phase 4** — plasma-workspace dependency |
#### Exit criteria
**Code artifacts (build-verified):**
- `redbear-phase4-kde-check`: validates KF6 library presence, plasma binaries (plasmashell, systemsettings), session entry points, kirigami status
- `test-phase4-runtime.sh`: automated QEMU test harness (guest + QEMU modes) for Phase 4 preflight checks
- 20 KF6 + kglobalacceld enabled in `redbear-full.toml` (non-cascading subset)
**Runtime validation checklist (requires QEMU/bare metal):**
- [ ] `redbear-full` boots into a KDE Plasma session (plasmashell process is running)
- [ ] KWin is the active compositor (`WAYLAND_DISPLAY` owned by KWin)
- [ ] Plasma panel renders and is interactive (launcher opens, clock visible)
- [ ] An application can be launched from the session and displays a window
- [ ] A file-manager path opens a directory view
- [ ] A settings module opens from systemsettings
- [ ] Network interface is visible inside Plasma session
#### Exit statement
> If Phase 5 incomplete: Red Bear OS has a **software-rendered** KDE Plasma session on Wayland.
> If Phase 5 complete: Red Bear OS has a **hardware-accelerated** KDE Plasma session on Wayland.
---
### Phase 5: Hardware GPU Enablement
**Duration:** 12–20 weeks (starts after Phase 1, runs in parallel with Phases 3–4)
**Goal:** Replace software-only graphics with real hardware-accelerated display + rendering.
**Why separate:** Hardware acceleration is a different class of systems work. It should not
block KWin/Plasma session assembly, which can proceed on the software renderer.
**Dependency note:** Phase 5 can start after Phase 1 (substrate trust), but its final acceptance
criterion ("compositor runs through hardware path") requires a working compositor from Phase 2
or Phase 3. In practice, Track C's final validation gate depends on Track A completing first.
**Current state (2026-04-29):** redox-drm driver exists with Intel Gen8-Gen12 and AMD device support + quirk tables. Mesa builds with llvmpipe software renderer (hardware renderers radeonsi/iris not yet cross-compiled). GPU command submission (CS ioctl) missing. No hardware validation yet. DRM display check binary exists (redbear-drm-display-check).
#### Work items
| # | Task | Acceptance criteria |
|---|---|---|
| 5.1 | Implement GPU command submission (CS ioctl) | PRIME buffer sharing already implemented; CS ioctl is the gating missing piece |
| 5.2 | Validate redox-drm AMD driver on real hardware | Device detection, MMIO mapping, firmware loading, connector detection, mode enumeration, bounded modeset proof |
| 5.3 | Validate redox-drm Intel driver on real hardware | Same validation surface as AMD |
| 5.4 | Validate Mesa hardware rendering path | Real renderer (radeonsi for AMD, iris/anv for Intel), not llvmpipe |
| 5.5 | Validate GBM buffer allocation through hardware path | GBM allocates through real DRM/GPU, not software fallback |
#### Exit criteria
**Code artifacts (build-verified):**
- `redbear-phase5-gpu-check`: validates DRM device registration, GPU firmware, Mesa DRI drivers, display mode enumeration
- `test-phase5-gpu-runtime.sh`: automated QEMU test harness (guest + QEMU modes) for Phase 5 preflight checks
**Runtime validation checklist (requires real hardware):**
- [ ] GPU command submission exists with focused proof coverage
- [ ] `modetest -M amd` shows display modes on real AMD hardware
- [ ] Equivalent Intel DRM query shows display modes on real Intel hardware
- [ ] Compositor runs through hardware path on at least one AMD + one Intel class
- [ ] Runtime evidence shows hardware-backed renderer, not software fallback
#### Exit statement
> Red Bear OS can drive real display hardware and run the compositor on a
> hardware-accelerated path.
---
## Critical Path
### Primary path to software-rendered KDE session
```
Phase 1 (runtime substrate validation)
→ Phase 2 (software Wayland compositor proof)
→ Phase 3 (KWin desktop-session assembly)
→ Phase 4 (KDE Plasma session)
```
This is the shortest honest path. **~22–34 weeks with 2 developers.**
### Parallel hardware path
```
Phase 1 (runtime substrate validation)
→ Phase 5 (hardware GPU enablement, parallel with Phases 3–4)
Phase 5 + Phase 3 + Phase 4
→ hardware-accelerated KDE Plasma desktop
```
**~34–54 weeks total with 2 developers** for hardware-accelerated KDE.
### Why Phase 1 is the real gate
Phase 1 converts lower-layer package progress into runtime trust. Without it, Phase 2+ failures
will be misdiagnosed as compositor bugs when they're actually substrate bugs.
### Why bounded validation comes before KWin session proof
This is the smallest environment to isolate compositor + input + Qt client issues. KWin adds
session services, QML, dependency scaffolding, and desktop-shell behavior on top.
### Why hardware doesn't block session assembly
KWin and Plasma have their own blockers (dependency cleanup, session services, compositor
integration). Those can be solved on software renderer while hardware path matures.
---
## Risk Register
| ID | Risk | Likelihood | Impact | Mitigation |
|---|---|---|---|---|
| R1 | relibc runtime gaps worse than build evidence suggests | Medium | High | Validate with real consumers in Phase 1 |
| R2 | GPU CS ioctl scope is uncertain | High | High | Isolate design + proof early in Phase 5 |
| R3 | Real-hardware validation reveals fundamental driver issues | High | High | Validate AMD and Intel separately |
| R4 | KWin needs significantly more patches than estimated | Medium | High | Finish the bounded validation proof first for cleaner lower-layer evidence |
| R5 | QML-heavy pieces behave badly with JIT disabled | Medium | Medium-High | Keep QML runtime proof explicit in Phases 3–4 |
| R6 | Mesa hardware rendering needs Redox-specific winsys work | Medium | High | Separate display proof from renderer proof |
| R7 | linux-kpi gaps only surface during real-hardware execution | High | Medium-High | Budget for hardware-driven compat fixes in Phase 5 |
| R8 | kirigami/stub deps cannot be resolved without full QML stack | Medium | High | Evaluate early in Phase 3; may need alternative approach |
| R9 | Phase 2 compositor proof reveals deeper relibc/glibc gaps in Wayland event loop | Medium | High | Use bounded validation compositor first; isolate event-loop pressure from session complexity |
---
## Timeline
### Planning assumptions
- 2 developers with access to representative AMD and Intel hardware
- No major regression from upstream refresh during desktop push
- Estimates do not assume perfect first-pass success on real hardware
### Phase estimates
| Phase | Weeks | Notes |
|---|---|---|
| Phase 1: Runtime Substrate Validation | 4–6 | Must finish honestly before claiming runtime trust |
| Phase 2: Wayland Compositor Proof | 4–6 | Can overlap with late Phase 1 cleanup |
| Phase 3: KWin Desktop Session | 6–10 | Starts after Phase 2; **lower bound is optimistic — assumes remaining QML/session cleanup stays bounded** |
| Phase 4: KDE Plasma Session | 8–12 | Starts after Phase 3; **lower bound assumes kirigami/knewstuff stubs resolve without major rework** |
| Phase 5: Hardware GPU Enablement | 12–20 | Starts after Phase 1, parallel with 3–4 |
### Total duration (2 developers)
| Target | Weeks | Months |
|---|---|---|
| Software-rendered KDE Plasma on Wayland | 22–34 | 6–8 |
| Hardware-accelerated KDE Plasma on Wayland | 34–54 | 8–13 |
### One-developer estimate
| Target | Months |
|---|---|
| Software-rendered KDE | 9–16 |
| Hardware-accelerated KDE | 12–27 |
### Rough overlap model
```
Weeks 1– 6: Phase 1 (runtime substrate validation)
Weeks 4–12: Phase 2 (software compositor proof)
Weeks 7–26: Phase 5 (hardware GPU enablement, parallel)
Weeks 13–22: Phase 3 (KWin session assembly)
Weeks 23–34: Phase 4 (KDE Plasma session)
```
---
## Relationship to Other Plans
This is the canonical document for the desktop path. It does not replace subsystem-specific plans.
### Primary supporting plans
| Plan | What it covers |
|---|---|
| `local/docs/AMD-FIRST-INTEGRATION.md` | AMD-specific GPU/driver detail (equal-priority AMD+Intel policy) |
| `local/docs/QT6-PORT-STATUS.md` | Qt6, KF6, KWin blocker/shim/stub status detail |
| `local/docs/DESKTOP-STACK-CURRENT-STATUS.md` | Short current-state desktop truth summary |
| `local/docs/RELIBC-COMPLETENESS-AND-ENHANCEMENT-PLAN.md` | relibc completeness detail + patch ownership |
| `local/docs/INPUT-SCHEME-ENHANCEMENT.md` | Input-path design if structural cleanup needed |
| `local/docs/AMDGPU-DC-COMPILE-TRIAGE-PLAN.md` | AMD DC compile-triage + bounded source-set strategy |
| `local/docs/DMA-BUF-IMPROVEMENT-PLAN.md` | DMA-BUF scheme detail |
| `local/docs/IRQ-AND-LOWLEVEL-CONTROLLERS-ENHANCEMENT-PLAN.md` | Controller/IRQ/IOMMU quality work |
| `local/docs/PROFILE-MATRIX.md` | Profile roles + support-language reference |
### How to use this plan
1. Read this document first for execution order, claim language, completion criteria, critical path
2. Read subsystem plans for exact relibc, driver, package, or input details behind those phases
3. Use `docs/07-RED-BEAR-OS-IMPLEMENTATION-PLAN.md` for the repo-wide workstream ordering
---
## Pre-Phase Work (Already Complete)
The following work was completed before this plan was written. It is listed here for
continuity, not as future work.
| Work | Status | When |
|---|---|---|
| AMD bare-metal boot (ACPI, SMP, x2APIC) | ✅ Boot-baseline complete | Prior to this plan; see `local/docs/ACPI-IMPROVEMENT-PLAN.md` for ongoing ownership and robustness work |
| Driver infrastructure (redox-driver-sys, linux-kpi, firmware-loader) | ✅ Builds complete | Prior to this plan |
| AMD GPU display (redox-drm + bounded amdgpu retained path) | 🚧 Partial build completion | Imported Linux AMD DC/TTM/core remain under compile triage; no hardware runtime validation yet |
| relibc POSIX unblockers (signalfd, timerfd, eventfd, etc.) | ✅ Builds + targeted runtime proof complete | Prior to this plan |
| Qt6 base stack (qtbase, qtdeclarative, qtsvg, qtwayland) | ✅ Builds complete | Prior to this plan |
| D-Bus 1.16.2 | ✅ Builds + bounded runtime | Prior to this plan |
| All 32 KF6 frameworks | ✅ Builds complete | Prior to this plan |
| Input stack (libevdev, libinput, evdevd, udev-shim) | ✅ Builds complete | Prior to this plan |
| Mesa EGL/GBM/GLES2 + libdrm amdgpu | ✅ Builds complete | Prior to this plan |
| Desktop profiles (`redbear-mini`, `redbear-full`, `redbear-grub`) | ✅ Builds complete | Prior to this plan |
| `local/docs/DBUS-INTEGRATION-PLAN.md` | D-Bus architecture, service dependency map, and phased implementation |
| PRIME/DMA-BUF scheme ioctls | ✅ Implemented | Prior to this plan |
| KWin recipe with 5 re-enabled features | ✅ Partial build | Prior to this plan |
| kdecoration, plasma-wayland-protocols, kf6-kwayland | ✅ Builds complete | Prior to this plan |
| Evidence class | What it means |
|----------------|---------------|
| **Source** | Code exists in tree |
| **Host build-verified** | cargo check zero warnings on Linux |
| **Redox build-verified** | make r.* successful on x86_64-unknown-redox |
| **Runtime-validated** | Exercised in QEMU or bare metal |
| **Hardware-validated** | Exercised on real AMD/Intel hardware |
Current state: Layers 1-7 are **Redox build-verified** (all 3 crates cook). Layer 5 (greeter) is **runtime-validated** in QEMU. Layers 3 (real KWin), 6 (full Plasma) and hardware paths remain at build-verified preflight level.