Raze Linux is an experimental, performance-focused Linux distribution built around lightweight system services, reproducible package management, and a Rust-first development philosophy: its own init system (r6), its own Wayland compositor (Rift) and desktop shell, on a reproducible Nix base.
ISO · SHA256SUMS · Release notes · Install guide · Source
Real screenshots of the 1.1.0 release in QEMU/KVM (no 3D acceleration). More: live session with the installer · launcher · installer dialog
Raze Linux is a NixOS-derived distribution built with Nix: the whole system is declared in Nix, built reproducibly from a pinned nixpkgs revision, and installed as atomic generations you can roll back from the boot menu. On that foundation Raze runs its own Rust components: r6 as PID 1 and service manager, the Rift Wayland compositor with Rift Shell, and the Rix package tool.
Why it exists: to see how far a desktop Linux system can be pushed toward low overhead and fast startup when every default is measured, and to build Rust-first core components (init, supervision, compositor, package tooling) with real tests and real benchmarks instead of claims.
| Version | 1.1.0 (2026-11-06) |
| Architecture | x86_64 |
| Kernel | Linux 7.3.1; installer default profile: performance |
| Base | nixpkgs 1d060086d60c (nixos-unstable, pinned) |
| PID 1 / service manager | r6 — live ISO, installed systems, every desktop except GNOME (systemd only inside the initramfs) |
| Default desktop | Rift (Raze's own Smithay compositor) + Rift Shell |
| Package management | Rix (Rust) on top of Nix |
| Privilege escalation | sudo-rs |
| Installer | Calamares with a Raze install module, GRUB on BIOS and EFI, dual boot |
Upgrading from 1.0: docs/installation/upgrade.md. What is not done yet: known limitations.
- r6 everywhere — Rust PID 1 and supervisor for the whole system and, with
r6-user, for each desktop session (D-Bus, PipeWire, Rift Shell, clipboard history). systemd's roles are covered by r6, eudev, elogind, dbus-daemon, ntpd-rs,r6-tmpfilesandr6-syslogd;nixos-rebuild switchworks through r6's own switch-to-configuration. Socket activation, sd_notify readiness and timers; the NixOS services you enable are imported from their systemd units automatically. - Rift — scrollable-tiling Wayland compositor written on Smithay: columns that never resize each other, dynamic workspaces per monitor, animations, GLES on GPUs and a pixman renderer when there is no 3D acceleration, screencopy for screenshots, recording and screen sharing (xdg-desktop-portal-wlr), touchscreen and touchpad swipes, XWayland, JSON IPC.
- Rift Shell — panel, launcher (apps, calculator, commands), control centre (Wi-Fi, Bluetooth, audio, brightness, power profiles, night light, Do Not Disturb), notification daemon with history, lock screen, power menu, screenshots, screen recording, clipboard history, OSD, polkit agent, themes, plugins, multi-monitor.
- Rix — Rust package-management CLI with native, Nix-compatible NAR hashing, store verification, generations and atomic rollback, instant search; evaluation, builds and installs are delegated to Nix (and printed as such).
- sudo-rs is the only sudo. fastfetch knows Raze (
neofetchruns it too). - Reproducible and atomic — pinned flake, system generations, rollbacks.
- Desktop choice at install — Rift (default), niri, Hyprland, dwl, Xfce, LXQt, KDE Plasma, GNOME, dwm; all on r6 except GNOME, which needs systemd.
- Dual boot — install alongside Windows or another Linux, reuse the existing EFI partition; other systems appear in the GRUB menu.
flowchart LR
subgraph Build["Nix flake (pinned)"]
r6[r6] & rix[rix] & rift[Rift] & shell[Rift Shell] --> ov[overlay] --> mods[Raze modules]
end
mods --> iso[Live ISO + Calamares]
iso -->|nixos-install --flake| sys
subgraph sys["Installed system"]
k[Linux 7.3.1] --> ini[initramfs<br/>NixOS stage 1] -->|switch-root| r6i[r6-init<br/>PID 1]
r6i --> r6s[r6-supervise] --> gd[greetd] --> rs[raze-session]
r6s --> nm[NetworkManager] & db[dbus] & el[elogind] & ud[eudev] & nd[nix-daemon]
rs --> ru[r6-user] --> pw[PipeWire] & sh[Rift Shell]
rs --> rf[Rift]
end
Details: docs/architecture/overview.md · r6 · Rift · Rift Shell · Rix
| Binary | Role |
|---|---|
r6-init |
PID 1: mounts, reaping, supervisor respawn, emergency shell, ordered shutdown |
r6-supervise |
One event loop supervising every service (s6 uses one process per service) |
r6-user |
The same supervisor for a user session |
r6-tmpfiles, r6-syslogd |
tmpfiles.d and /dev/log |
r6-activate, r6-config |
Service-graph validation (build time), inspection |
r6 |
status, start, stop, restart, enable, disable, list, logs, reload, check, info, reboot, poweroff, suspend |
Services are declared in Nix and rendered to TOML:
raze.r6.services.ntpd-rs = {
command = [ "${pkgs.ntpd-rs}/bin/ntp-daemon" "-c" "/etc/ntpd-rs.toml" ];
user = "ntpd-rs";
capabilities = [ "CAP_SYS_TIME" "CAP_NET_BIND_SERVICE" ];
restart = "always";
};r6 status # every service, state, uptime
r6 logs NetworkManager # rotated per-service logs
r6 --user status # the session's servicesrift msg workspaces # IPC (JSON)
rift msg action workspace 2
rift-shell screenshot region # ~/Pictures/Screenshots + clipboard
rift-shell record toggle # ~/Videos/RecordingsDefault keys: Super+Return terminal · Super+D launcher · Super+N control centre ·
Super+V clipboard · Super+Escape power menu · Super+Alt+L lock · Print screenshot ·
Super+←/→ focus column · Super+Ctrl+←/→ move column · Super+R width preset ·
Super+F maximize · Super+1…5 workspace · Super+Shift+E log out. Configuration:
~/.config/rift/config.toml (defaults: rift/default-config.toml),
~/.config/rift-shell/settings.json.
rix search firefox # native index search
rix install firefox # → nix profile add nixpkgs#firefox
rix generations # native
rix rollback # native, atomic
sudo rix system switch # → nixos-rebuild switch --flake /etc/nixos#raze (works under r6)
rix hash path ./dir # native NAR hash, identical to `nix hash path`Rix is a front-end, not a Nix reimplementation; what is native and what is delegated is listed in docs/architecture/rix.md.
Every desktop logs in through greetd; with r6 its session services (D-Bus,
PipeWire, WirePlumber) run under r6-user. Each row is a VM test
(nix build .#checks.x86_64-linux.desktop-<name>) that boots the desktop as
installed and checks its processes and services.
| Desktop | Init | Status in 1.1 |
|---|---|---|
| Rift + Rift Shell (default) | r6 | Shipped on the ISO; VM tests with and without 3D, under r6 and systemd (screen sharing, polkit, lock, notifications, recording) |
| niri + waybar | r6 | VM test (software fallback session), benchmark VM with 3D |
| Hyprland + waybar | r6 | VM test (software fallback session), Hyprland with virgl 3D (see release notes) |
| dwl + waybar | r6 | VM test |
| KDE Plasma (Wayland) | r6 | VM test: Plasma starts without systemd, panel and desktop |
| Xfce, LXQt, dwm | r6 | VM tests: rootless X server, window manager, panel |
| GNOME | systemd | VM test (GNOME requires systemd; the installer selects it) |
niri and Hyprland need a GPU with 3D acceleration; without one, Raze starts its software-rendered sway session instead. Desktops other than Rift are downloaded during installation.
- Download the ISO and SHA256SUMS, then
sha256sum -c SHA256SUMS. - Write it to a USB stick:
sudo dd if=raze-linux-v1.1.0-x86_64.iso of=/dev/sdX bs=4M status=progress oflag=sync. - Boot it. The installer opens automatically: language → keyboard → disk → desktop → profile → user → install.
- Reboot into Raze. A network connection is required during installation.
Full guide: docs/installation/graphical.md · upgrade from 1.0: docs/installation/upgrade.md · manual install: docs/installation/manual.md · recovery: docs/installation/recovery.md
| Minimum | Recommended | |
|---|---|---|
| CPU | x86_64 | 2+ cores |
| RAM | 2 GB | 4 GB |
| Disk | 12 GB | 30 GB+ |
| Firmware | UEFI or BIOS (BIOS untested) | UEFI |
| GPU | any (Rift renders with pixman without 3D) | OpenGL ES 3 capable |
Tested: QEMU/KVM with OVMF (UEFI), virtio disk/network, with and without 3D acceleration. Real hardware has not been tested for 1.1.
All numbers are real measurements; method and environment in docs/performance.
| Metric | Raze 1.1 | Compared with |
|---|---|---|
| Desktop boot: kernel start → login screen | 5.08 s (r6) | systemd, same system: 6.41 s |
| Desktop memory used at the login screen | 355 MB (r6) | systemd: 379 MB |
| Userspace memory at the login screen (PSS) | 93.5 MB (r6) | systemd: 73.0 MB (socket-activated nix-daemon) |
| PID 1 memory (RSS) | 2.6 MB (r6-init) | systemd: 15.0 MB |
| r6: PID 1 → 20 services started (Raze Core) | 32.9 ms | s6: 31.6 ms (equal within noise) |
| r6: init + supervision processes | 2 | s6: 27 |
| Compositor CPU at idle, per minute | 0.00 s (Rift) | niri: 0.05 s |
| Compositor CPU, terminal updating 20×/s, per 10 s | 0.48 s (Rift) | niri: 0.50 s |
| Desktop session memory (PSS), one terminal open | 217 MB (Rift + Rift Shell) | niri + waybar session: 244 MB |
rix search firefox (113 419 packages) |
63.7 ms | nix search warm: 1734 ms |
| ISO size | 2.09 GB (1.95 GiB) | 1.0.0: 2.11 GB |
QEMU/KVM on an AMD Ryzen 5 7235HS host; desktop boots: 4 vCPU / 3 GiB, no 3D, 5 interleaved boots; compositors: virgl GPU, 3 interleaved runs; Raze Core: 2 vCPU / 256 MiB, 10 boots. Where Raze loses (systemd's lower userspace PSS, s6's lower PSS), the table says so.
Full tables and raw data: docs/performance/benchmarks.md.
git clone https://github.com/SwashX-dev/Raze-Linux && cd Raze-Linux
nix build .#iso # → result/iso/raze-linux-v1.1.0-x86_64.iso
nix build .#checks.x86_64-linux.desktop .#checks.x86_64-linux.core-boot
nix develop -c cargo test --workspace
nix develop -c cargo test --manifest-path rift/Cargo.tomlRequires Nix with flakes, ~40 GB free disk for the ISO, KVM for VM tests. → docs/development/building.md
Issues and pull requests are welcome — see CONTRIBUTING.md. Performance claims need measurements; delegated functionality must be labelled.
- systemd runs inside the initramfs (NixOS stage 1); PID 1 is r6 from
switch-root on. Some nixpkgs libraries still link
libsystemd. - r6 does not sandbox services (systemd's
Protect*=/Private*=directives of imported units are not applied); a few unit types are not imported (listed in/etc/r6/import-report). GNOME needs systemd. - Rift: single GPU, shm-only screencopy (no wl-screenrec; screen sharing uses CPU copies), no pinch gestures or tablet input.
- Rix delegates evaluation, builds, substitution and installs to Nix.
- Installation and upgrades need a network connection; upgrading from 1.0 compiles Raze's own packages locally (2–4 minutes in a 4-vCPU VM).
- Not tested on real hardware; BIOS installs and manual partitioning are not tested in a VM either.
- The ISO is not signed (SHA-256 checksums only).
Full list: docs/troubleshooting/known-issues.md
- Rift: multi-GPU, dmabuf screencopy, pinch gestures, tablet input.
- r6: replace the systemd-based initramfs with an r6 stage 1.
- Rix: native substitution (narinfo + parallel NAR downloads), then evaluation.
- Hardware validation matrix (real machines, BIOS), signed releases; r6 service sandboxing (namespaces, seccomp).
- Desktop memory and boot-time reductions, measured per change.
Raze Linux's own code is MIT licensed (LICENSE). The ISO contains third-party software (Linux, nixpkgs packages, Calamares, Quickshell, sudo-rs, …) under their own licenses.
Built on the work of the NixOS/nixpkgs community, the Linux kernel, niri, Smithay (Rift is built on it), Quickshell and Noctalia (Rift Shell's runtime and inspiration), sway/wlroots, Calamares, sudo-rs (Trifecta Tech Foundation), s6 (the inspiration for r6), eudev, elogind, ntpd-rs, fastfetch, waybar, fuzzel, foot, mako and busybox.