Why Rolling Release?​

The project vision is clear: erase the mystique of the Linux distribution. A "distro" is just base OS × desktop × kernel × drivers — assembled by a build factory. If that's true, it shouldn't matter whether the base is RHEL-compatible, Fedora, Ubuntu, Arch, or CachyOS. The same factory should produce them all.

🐟 Marlin — Arch Linux on bootc​

Arch Linux with the stability guarantees of bootc: atomic updates, rollback, immutable base.

• Base: archlinux/archlinux:latest
• Kernel: stock linux (latest stable)
• Package manager: pacman
• bootc: built from source (Arch doesn't package it yet)
• Desktops: gnome, kde, cosmic, niri, xfce

How It Works​

Containerfile.arch bootcifies a stock Arch container:

1. Builds bootc from source (~2 min Rust compile)
2. Moves /var → /usr/lib/sysimage for pacman+ostree compatibility
3. Installs kernel, dracut, ostree, filesystem tools
4. Builds initramfs with bootc dracut modules
5. Sets up composefs + ostree rootfs layout

Desktop packages come from the same manifest system — the pacman: section in each manifests/desktops/*.yaml.

🐟 Wahoo — CachyOS on bootc​

The performance variant. CachyOS ships:

• BORE scheduler — better desktop interactivity under load
• LTO-compiled packages — 5-15% faster binaries
• x86-64-v3 targeting — uses modern CPU instructions (AVX2, BMI2, etc.)
• Performance-tuned sysctl — optimized for desktop workloads

Same Containerfile.arch — it auto-detects CachyOS repos in pacman.conf and installs linux-cachyos instead of stock linux.

The Matrix​

              │ gnome │ kde  │ niri │ cosmic │ xfce │
──────────────┼───────┼──────┼──────┼────────┼──────┤
EL10          │  ✅   │  ✅  │  ✅  │   ✅   │  ✅  │
Fedora        │  ✅   │  ✅  │  ✅  │   ✅   │  ✅  │
Ubuntu        │  ✅   │  ✅  │  ✅  │   —    │  ✅  │
Arch          │  ✅   │  ✅  │  ✅  │   ✅   │  ✅  │  ← NEW
CachyOS       │  ✅   │  ✅  │  ✅  │   ✅   │  ✅  │  ← NEW

Try It​

# Build locally
just build marlin gnome
just build wahoo kde

# Or switch a running system
sudo bootc switch ghcr.io/tuna-os/marlin:gnome
sudo bootc switch ghcr.io/tuna-os/wahoo:kde

Both variants are marked experimental — expect rough edges. ISOs coming once the builds stabilize.

Credits​

This work stands on the shoulders of:

• bootcrew — the reference implementation for Arch Linux on bootc. Their arch-bootc project proved the composefs-native backend works on Arch and pioneered the /var → /usr/lib/sysimage pacman migration. Our Containerfile.arch is directly based on their work.
• jumpvi / bootc-shindig — the bootc-deb apt packages that make bootc work on Ubuntu/Debian. Without their work packaging bootc for apt-based systems, our Grouper (Ubuntu) variant wouldn't exist. The entire deb-based bootc ecosystem traces back to their packaging effort.
• CachyOS — for maintaining performance-optimized Arch repos (BORE scheduler, LTO, x86-64-v3) and publishing Docker images we can build on.
• Universal Blue and Project Bluefin — for proving that bootc-based desktop images work at scale and inspiring this entire approach.

The Mystique​

For decades, "making a Linux distro" meant: fork a package set, maintain an installer, hand-tune configs, ship ISOs on a 6-month cadence, and pray nothing breaks between your packages and upstream. The result: hundreds of distros that are 95% the same packages with 5% different defaults.

The mystique is that this is hard. That it takes a team of package maintainers and release engineers. That choosing Arch vs Fedora vs Debian is a permanent, load-bearing decision.

We reject this.

The Factory​

TunaOS is not a distribution. It's an image factory. The inputs are:

base OS  ×  desktop  ×  kernel  ×  drivers  =  bootable image

The output is an OCI container image you can bootc switch to — atomically, with rollback. Changing your "distro" is a one-line command. The factory stamps out every combination automatically.

The Fishes​

Every TunaOS variant is named after a fish. Today there are 10:

Each fish gets 6 desktops: GNOME, GNOME 50, KDE Plasma, COSMIC, Niri, and XFCE. Each desktop can optionally layer an HWE kernel or NVIDIA drivers on top.

How We Got Here​

A week ago, adding a new base OS meant writing hundreds of lines of new shell scripts. Today it means:

1. A Containerfile that bootcifies the stock container image (~150 lines, mostly the ostree filesystem layout)
2. A pacman: or apt: section in each desktop manifest (the packages that make up GNOME/KDE/etc. on that OS)
3. An entry in build-config.yml (the variant name, base image, platforms)

That's it. The generic installer reads the YAML, installs the right packages for the detected OS, and produces a working image. No per-distro bash scripts. No per-DE-per-distro combinatorial explosion.

What This Means For Users​

You're not locked in. Want to try Arch after running AlmaLinux for a year? sudo bootc switch ghcr.io/tuna-os/marlin:kde. Want the CachyOS performance kernel on your KDE desktop? sudo bootc switch ghcr.io/tuna-os/wahoo:kde. Don't like GNOME 50? Switch to GNOME 49: sudo bootc switch ghcr.io/tuna-os/yellowfin:gnome.

The matrix is your menu. Every cell is a valid, tested, bootable system.

What's Next​

• Build validation — getting CI green for all 10 variants across all platforms
• ISOs — tacklebox-generated live ISOs for every variant×desktop combination
• NVIDIA on Arch/CachyOS — pacman -S nvidia-open as a manifest entry (no akmods needed)
• More desktops — Hyprland, Sway, Budgie are each one YAML file away
• Community manifests — let anyone contribute a desktop definition without touching build scripts

Credits​

This wouldn't be possible without:

• bootcrew — reference bootc implementations for Arch and Debian
• jumpvi / bootc-shindig — bootc-deb packages for Ubuntu/Debian
• CachyOS — performance-optimized Arch repos and Docker images
• Universal Blue & Project Bluefin — proving bootc desktop works at scale
• bootc — the engine that makes all of this possible

The mystique is dead. A distro is just data in, image out. Pick your fish.

The Problem​

The old build system had a 150-line bash script per desktop (gnome.sh, kde.sh, cosmic.sh, niri.sh, xfce.sh). Each one was an imperative mess of if fedora; dnf install X; elif el10; dnf group install Y; fi. Adding GNOME 50 meant duplicating gnome.sh. Adding Ubuntu support meant adding elif apt; pkg_install Z to every single script.

The Justfile's _build recipe was 150 lines of positional-argument spaghetti. Understanding what arg 7 meant required reading the recipe signature.

The Solution​

Desktop Manifests​

Each desktop is now a YAML file in manifests/desktops/:

# manifests/desktops/kde.yaml
display_manager: sddm
packages:
  fedora:
    groups: [kde-desktop]
    packages: [sddm, dolphin, konsole, kate, ...]
  el10:
    groups: ["KDE Plasma Workspaces", ...]
    optional: [kdeconnect, nvtop, ...]
  pacman:
    - plasma-desktop
    - sddm
    - dolphin
    - konsole
  apt:
    - kde-plasma-desktop
    - sddm
versionlock: [plasma-desktop, "qt6-*"]

A single generic installer (install-desktop.sh) reads the manifest and handles everything: groups, packages, COPRs, version locks, display manager enablement.

Build Engine Extraction​

The Justfile _build monolith became scripts/build-image-inner.sh — 198 lines, env-var driven (not 11 positional args). The Justfile is now a 25-line export wrapper.

Flavor Resolution​

scripts/resolve-flavor.sh maps any flavor to its build parameters. 18 BATS tests cover every path. The old 50-line if/elif/case block in the Justfile is gone.

The Numbers​

What's Next​

The manifest system now supports 4 package managers (dnf, apt, pacman, zypper) and we've added Arch Linux (marlin) and CachyOS (wahoo) variants. The matrix grows:

9 base variants × 6 desktops × 3 hardware layers = image factory

Adding a new distro = write a Containerfile that bootcifies it + add pacman/apt/dnf sections to the manifests. The build system handles the rest.