vasilito
5897eefc3a
The local/sources/kernel fork at 1be659b adds the
hardware-agnostic S3 resume trampoline (Phase II.X):
* Saves the CPU state (general-purpose registers,
segment registers, RFLAGS, RSP, RIP, CR3) to a static
S3State struct in `enter_s3()`.
* Adds a 64-bit `naked_asm!` trampoline
(`s3_resume::s3_trampoline`) that the platform
firmware jumps to on S3 wake. The trampoline:
- Verifies the magic value (0x123456789abcdef0) in
S3_STATE.saved_magic (a la Linux's
`arch/x86/kernel/acpi/wakeup_64.S`)
- Restores ds/es/fs/gs/ss to __KERNEL_DS
- Restores CR3 (page table base)
- Restores RSP, RFLAGS
- Restores 13 general-purpose registers
- Sets the RESUMING_FROM_S3 flag
- Pushes saved RIP onto the stack and uses `ret`
* Exposes `s3_resume_address()` that acpid writes
to FACS.waking_vector.
* Exposes `s3_state_valid()` that the kernel checks
during boot to determine if this is a cold boot
or a resume from S3.
Hardware-agnostic: works on any x86_64 system with
standard ACPI S3 support (Dell, HP, Lenovo, LG Gram 14).
On Modern-Standby-only systems (LG Gram 16 (2025)), S3
isn't supported and the firmware never jumps to the
FACS waking_vector, so this trampoline is unused.
Build: redbear-mini.iso (512 MB) builds successfully.
The S3 resume path is verified to compile and be
present in the ISO. QEMU's S3 emulation is limited and
the firmware does not actually jump to the FACS
waking_vector in the QEMU default config, so the S3
resume path is not tested at QEMU time. The acpid <-> kernel
wiring via FACS.waking_vector is the next step (separate
Phase II.X.W commit).
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
Our Git Server
Red Bear OS lives on a self-hosted Gitea instance at https://gitea.redbearos.org. This is the canonical home for the fork — there is no GitHub / GitLab / Codeberg mirror that is authoritative.
| Field | Value |
|---|---|
| Host | https://gitea.redbearos.org |
| User | vasilito |
| Token | (session-only — never stored in repo) |
| Web UI | https://gitea.redbearos.org/vasilito |
| Main repo | https://gitea.redbearos.org/vasilito/RedBear-OS |
Token policy. The
vasilitotoken is a per-session credential and must never be committed to any tracked file. Usegit credential.helper(store / cache / libsecret),~/.netrc, or$REDBEAR_GITEA_TOKENenv var. Seelocal/AGENTS.md§ Our Git Server for the full operator runbook, mirror list, API reference, and recovery procedure.
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 (one-off) — supply token via env var, not literal here
git clone https://vasilito:${REDBEAR_GITEA_TOKEN}@gitea.redbearos.org/vasilito/RedBear-OS.git
# Recommended: use the Red Bear wrapper
./local/scripts/build-redbear.sh redbear-mini # Text-only target
./local/scripts/build-redbear.sh redbear-full # Desktop-capable target
# Boot in QEMU with the resulting image
make qemu
Build script:
local/scripts/build-redbear.shis the canonical entry point. Baremake allworks but bypasses the.configchecking andREDBEAR_ALLOW_PROTECTED_FETCH=1gates thatbuild-redbear.shenforces. SeeAGENTS.md§ Build Commands for full details.
Public Scripts
| Script | Purpose |
|---|---|
local/scripts/build-redbear.sh |
Canonical build wrapper for redbear-mini/full/grub |
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/
├── patches/ # Durable changes to upstream source trees
├── 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.