The first vibe-coded Linux Distribution

Customization from the package level.

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.

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

Manual install. Full control. AI-assisted packaging.

See How It Works GitHub

Two Foundations. One Philosophy.

Choose your base. Both share the same recipe system and tools.

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

AcornOS

musl / OpenRC / busybox

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

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.

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

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.

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