Customization from the package level.

Name: LevitateOS
Author: LevitateOS

Make your own package repository. While other Linux distributions rely on centralized repositories, here we take the slow route. You write your own packages named "recipes": declaring how to acquire, build and install each piece of software.

Atomic A/B updates by default. Build the next system in slot B, boot it once, then commit. Roll back by rebooting.

Too slow? No worries. This is designed with a locally running LLM (SmolLM3) that generates, customizes and maintains your recipes and handles dependencies.

Immutable by default. Full control. AI-assisted packaging.

See How It Works GitHub

Scroll

Three Variants. One Recipe System.

Desktops and appliances built from the same pipeline. A/B immutable by default. Mutable mode is optional.

LevitateOS

glibc / systemd / GNU

Maximum software compatibility. If it runs on Linux, it runs here. Systemd handles services, timers, and boot.

Broadest package compatibility
Comprehensive service management
Rocky 10 RPMs for dependencies
Familiar to most Linux users

ISO builder made by Claude Opus 4.5

RalphOS

Ralph4Days Sandbox

Agent-only appliance OS. Ships as a preinstalled QCOW2 disk image to host ralphd and isolated automation sandboxes.

Atomic slot updates + rollback
QCOW2-only disk image
Provision-and-go (SSH key)
Immutable-only by design

Agent appliance variant (QCOW2-only)

AcornOS

musl / OpenRC / busybox

A mirror build of LevitateOS with a different toolchain. Smaller binaries, faster boot, simpler init. For those who prefer knowing exactly what's running on their system.

Leaner compiled binaries
Straightforward init scripts
Alpine Linux PKGs for dependencies
Less complexity under the hood

ISO builder built by experimental coding Agents

Recipes, Not Repositories

Instead of apt or dnf, LevitateOS uses recipe.

A recipe is an elaborate .rhai script that describes how to acquire, build, and install a package. Rhai is a safe, sandboxed scripting language embedded in Rust — readable in seconds, impossible to hide malicious code in.

On immutable systems, recipe changes are applied to the inactive slot (B) first. You trial-boot, then commit. Mutable mode exists, but it is explicitly unsafe.

Pin exact versions — your system stays reproducible

Read the build logic in seconds — it's just Rhai script

Add patches directly — your recipes, your rules

Full audit trail of what's installed and how

Command

rust

// recipes/ripgrep.rhai
let ctx = #{
    name: "ripgrep",
    version: "14.1.0",
    repo: "BurntSushi/ripgrep",
};

fn is_acquired(ctx) {
    is_file(join_path(BUILD_DIR, "rg/Cargo.toml"))
}

fn acquire(ctx) {
    let tarball = github_download_release(
        ctx.repo, ctx.version, "*.tar.gz"
    );
    extract(tarball, BUILD_DIR);
}

fn build(ctx) {
    shell_in(BUILD_DIR + "/rg",
        "cargo build --release");
}

fn install(ctx) {
    let bin = BUILD_DIR + "/rg/target/release/rg";
    shell("install -Dm755 " + bin + " $OUT/usr/bin/rg");
}

Everything a package does, in one readable file.

Command

bash

$ recipe llm "create a recipe for htop"

Drafting recipe for htop...

// recipes/htop.rhai
let ctx = #{
    name: "htop",
    version: "3.3.0",
    repo: "htop-dev/htop",
};

fn is_acquired(ctx) {
    is_file(join_path(BUILD_DIR, "htop/configure.ac"))
}

fn acquire(ctx) {
    let tarball = github_download_release(
        ctx.repo, ctx.version, "*.tar.xz"
    );
    extract(tarball, BUILD_DIR);
}

fn build(ctx) {
    let src = BUILD_DIR + "/htop";
    shell_in(src, "./autogen.sh && ./configure && make");
}

fn install(ctx) {
    shell_in(BUILD_DIR + "/htop", "make install DESTDIR=$OUT");
}

Recipe saved. Review and run: recipe install htop

Local Recipe Assistant

Writing recipes is straightforward, but you shouldn't have to do it from scratch.

The recipe assistant is a local LLM that drafts recipes by reading upstream documentation. It runs on your machine — no cloud, no telemetry. You review the output, make adjustments, and run it.

Drafts .rhai recipes from upstream documentation

Reads build logs and suggests fixes

Runs entirely local — your machine, your data

You review and execute — AI handles the boilerplate