RavenLinux

A developer-focused Linux distribution built from scratch with custom tooling.

  _____                         _      _
 |  __ \                       | |    (_)
 | |__) |__ ___   _____ _ __   | |     _ _ __  _   ___  __
 |  _  // _` \ \ / / _ \ '_ \  | |    | | '_ \| | | \ \/ /
 | | \ \ (_| |\ V /  __/ | | | | |____| | | | | |_| |>  <
 |_|  \_\__,_| \_/ \___|_| |_| |______|_|_| |_|\__,_/_/\_\

Overview

RavenLinux is an independent Linux distribution designed for developers and application development. It features:

Custom Package Manager (rvn) - Fast, Rust-based package management with developer workspaces
Custom Bootloader (RavenBoot) - Multi-boot UEFI bootloader with Linux EFI stub support
Native Tools Integration - First-class support for Vem editor, Carrion language, and Ivaldi VCS
Minimal Base - Built with musl libc for a clean, lightweight system
Rolling Release - Always up-to-date packages

Downloads

Download the latest release from GitHub Releases:

File	Description
`ravenlinux-vX.X.X.iso`	Bootable ISO image
`raven-usb-vX.X.X-linux-x86_64`	USB flasher tool
`ravenlinux-vX.X.X-source.tar.gz`	Complete source code
`ravenlinux-tools-vX.X.X-linux-x86_64.tar.gz`	All tools bundled

Quick Install

# Download the ISO and raven-usb tool, then flash to USB
chmod +x raven-usb-*-linux-x86_64
sudo ./raven-usb-*-linux-x86_64 ravenlinux-*.iso /dev/sdX

# Boot from USB and follow the installer

Technology Stack

Component	Language	Description
Kernel	C	Linux kernel with EFI stub
Bootloader	Rust	UEFI multi-boot loader (RavenBoot)
Init System	Rust	Custom init and service manager
Package Manager	Rust	System package management (rvn)
Text Editor	Go	Vem - Modal editor with syntax highlighting
Version Control	Go	Ivaldi - Distributed VCS
Programming Language	Go	Carrion - Custom programming language
WiFi Manager	Go	TUI/GUI tools to connect to WiFi networks
Installer	Go	GUI system installer
USB Flasher	Go	Tool to create bootable USB drives

Native Tools

RavenLinux includes these custom development tools:

Vem (Text Editor)

Modal text editor with syntax highlighting and modern editing features.

vem myfile.txt

Carrion (Programming Language)

Custom programming language designed for system scripting and application development.

carrion run script.crl

OxigenLang (Programming Language)

TBD - Still in Alpha

oxigen example.oxi

Ivaldi (Version Control) Currently GO *will transition to Rust Version

Distributed version control system with a focus on simplicity.

ivaldi forge
ivaldi seal "Example message"
ivaldi upload

Networking

WiFi Setup

Connecting to WiFi is simple. Just run:

sudo wifi

This opens an interactive terminal interface where you can:

See all available networks with signal strength
Use arrow keys to select a network
Enter password when prompted
Connection is automatically saved for next time

That's it! No complicated commands to remember.

Note: RavenLinux ships rtw89 firmware and sets options rtw89_pci disable_aspm=1 by default to ensure RTL8852BE cards reliably create a wlan* interface at boot.

Alternative: GUI WiFi Manager

If you prefer a graphical interface:

raven-wifi

Advanced: Manual WiFi (CLI)

For power users who prefer raw commands:

# Using iwd
iwctl station wlan0 scan
iwctl station wlan0 get-networks
iwctl station wlan0 connect "NetworkName"

# Using wpa_supplicant (fallback)
wpa_passphrase "NetworkName" "password" > /etc/wpa_supplicant.conf
wpa_supplicant -B -i wlan0 -c /etc/wpa_supplicant.conf
dhcpcd wlan0

Building from Source

Requirements

Linux system (tested on Arch Linux)
20GB+ disk space
8GB+ RAM recommended
Rust toolchain
Go toolchain (1.23+)
Build tools: gcc, make, cmake, meson

Build Steps

# Clone the repository
git clone https://github.com/javanhut/RavenLinux.git
cd RavenLinux

# Build everything and generate ISO
./scripts/build.sh all

# Or build individual stages:
./scripts/build.sh stage1    # Download toolchain and build base
./scripts/build.sh stage2    # Build native sysroot
./scripts/build.sh stage3    # Build packages
./scripts/build.sh stage4    # Generate ISO

Building with Docker / Podman (macOS, Windows, or Linux)

RavenLinux is a Linux-From-Scratch style distro — the build uses chroot, overlayfs mounts and a musl cross-toolchain, so it cannot run natively on macOS or Windows. The included Dockerfile provides a ready-to-use Linux build host that works with both Docker and Podman.

The easiest way is the Makefile — it builds the toolchain image and runs the containerized build for you, on any host OS:

make image      # build just the Docker/Podman toolchain image
make build      # build everything and produce the ISO (-> repo root)
make iso        # generate the ISO from existing build output
make minimal    # headless build: base system + CLI ISO, no GUI
make rootfs     # package the built rootfs as a runnable image (ravenlinux:latest)
make shell      # interactive shell inside the build environment
make help       # list every target

# Overrides
make build JOBS=8            # parallel compile jobs
make build ARCH=x86_64       # target architecture
make build ENGINE=podman     # force Podman instead of Docker
make rebuild                 # clean rebuild from scratch

Under the hood the Makefile calls scripts/docker-build.sh, which you can also use directly:

# Build everything inside a container; the ISO lands in ./build/
./scripts/docker-build.sh all

# Or target a single stage
./scripts/docker-build.sh image           # build the toolchain image only
./scripts/docker-build.sh stage0          # cross toolchain only
./scripts/docker-build.sh -j 8 stage1     # stage1 with 8 jobs
./scripts/docker-build.sh --clean all     # clean rebuild

# Drop into an interactive shell in the build environment
./scripts/docker-build.sh shell

The helper auto-detects Docker or Podman, builds the image (cached after the first run), and runs the container --privileged with the repo bind-mounted at /raven so all artifacts appear in ./build/ on your host.

See docs/docker-build.md for the full guide (options, environment variables, Apple Silicon notes, and troubleshooting).

macOS / Apple Silicon note: the build is x86_64, so on Apple Silicon it runs under emulation. Use Docker or colima with Rosetta — Rosetta translates the amd64 toolchain reliably, whereas Podman's default qemu-user emulation crashes the Rust compiler. With colima:
colima start --vm-type vz --vz-rosetta --memory 12 --cpu 8
RAVEN_ENGINE=docker make build
Give the VM several GB of RAM — the kernel link is memory-hungry and a small VM gets OOM-killed. The build's working tree is kept on a Docker volume on macOS (the bind mount's virtiofs mishandles the symlinks an LFS build unpacks); the ISO still lands in the repo root. To boot/test the ISO, use QEMU (brew install qemu).

Prefer to run the engine directly:

docker build -t ravenlinux-build .
docker run --rm -it --privileged -v "$PWD:/raven" -w /raven \
    ravenlinux-build ./scripts/build.sh all

Headless / minimal build (no GUI)

For a lean, command-line-only RavenLinux — base system, kernel and a CLI ISO with none of the graphical stack — use the minimal build. It skips the compositor, file manager, desktop and GUI apps, so it needs none of the GUI build dependencies and builds from a much smaller toolchain image (Dockerfile.minimal):

make minimal-image   # slim headless toolchain image (one-time)
make minimal         # base system + kernel + CLI ISO -> raven-*-minimal.iso

The resulting ISO (raven-<ver>-<arch>-minimal.iso in the repo root) boots straight to an autologin root shell on tty1 (and the serial console). The minimal build uses its own image tag, build volume and ISO name, so it never touches the full build's output.

Running RavenLinux in a container (test your tools)

The build produces an ISO for booting on hardware or in a VM. To run RavenLinux itself and test terminal tools quickly, package the built root filesystem (build/sysroot) as a container image. This is RavenLinux — not the Arch builder:

make build           # (or `make minimal`) build RavenLinux into the sysroot
make rootfs          # package build/sysroot as image `ravenlinux:latest`

# Run it — a Raven Linux shell with your tools (rvn, carrion, ivaldi, poxy, ...)
docker run --rm -it --platform linux/amd64 ravenlinux:latest

make minimal-rootfs does the same from the headless build. Under the hood, scripts/export-rootfs.sh tars the sysroot and docker imports it as a flat image (drop --platform linux/amd64 on a native x86_64 host).

To iterate on a tool without rebuilding, mount the binary into the running image:

docker run --rm -it --platform linux/amd64 \
    -v "$PWD/mytool/target/release/mytool:/usr/local/bin/mytool" \
    ravenlinux:latest
# now run `mytool` inside real RavenLinux

To bake a tool in permanently, add it to scripts/lib/repos.sh REPO_REGISTRY (or copy the binary into build/sysroot/bin/) and re-run make rootfs. Build Go tools with CGO_ENABLED=0 for a static binary that runs regardless of libc.

Development Environment

# Set up development environment
./scripts/dev-env.sh setup

# Mount overlay filesystem for editing
./scripts/dev-env.sh mount

# Enter chroot to test
./scripts/dev-env.sh chroot

# Boot in QEMU with graphics
./scripts/dev-env.sh qemu -g

# Boot in QEMU headless (no new window, serial console in this terminal)
# Tip: In the RavenBoot menu select "Raven Linux (Serial Console)" for best logs/debugging.
./scripts/dev-env.sh qemu

# Console access:
# - tty1: starts `/bin/raven-shell` via `agetty --skip-login` (PAM-free rescue shell)
# - tty2: starts a normal `login` prompt (use this to test PAM/password logins)

# Check status
./scripts/dev-env.sh status

Project Structure

RavenLinux/
├── bootloader/          # RavenBoot UEFI bootloader (Rust)
├── init/                # Init system and service manager (Rust)
├── tools/
│   ├── rvn/             # Package manager (Rust)
│   ├── raven-installer/ # GUI system installer (Go)
│   └── raven-usb/       # USB flasher tool (Go)
├── configs/             # System configurations
│   └── kernel/          # Kernel configs
├── scripts/             # Build and utility scripts
│   ├── build.sh         # Main build script
│   ├── dev-env.sh       # Development environment
│   ├── build-initramfs.sh
│   └── stages/          # Build stage scripts
├── etc/                 # Base system configuration
└── .github/workflows/   # CI/CD pipelines

Package Manager (rvn)

# Install packages
rvn install rust nodejs python

# Search packages
rvn search editor

# Sync repository metadata (required for fast/offline search)
rvn sync

# Generate an index.json for a repo directory (expects ./packages/*.rvn)
rvn repo index /path/to/raven_linux_v0.1.0

# Developer tools
rvn dev rust           # Set up Rust toolchain
rvn dev node 20        # Set up Node.js 20

# Workspaces (isolated dev environments)
rvn workspace create myproject --lang rust,python
rvn workspace enter myproject

# System management
rvn system snapshot    # Create system snapshot
rvn system rollback    # Rollback to snapshot
rvn system health      # Check system health

Bootloader (RavenBoot)

The custom UEFI bootloader supports:

Linux EFI stub booting with initrd support
Multi-boot with other operating systems
Auto-detection of Windows, other Linux distros
Keyboard navigation and configurable timeout
Configuration via /EFI/raven/boot.cfg (preferred) or /EFI/raven/boot.conf
Recovery mode boot option

Boot Configuration

# /EFI/raven/boot.cfg
timeout = 5
default = 0

[entry]
name = "Raven Linux"
kernel = "\EFI\raven\vmlinuz"
initrd = "\EFI\raven\initramfs.img"
cmdline = "rdinit=/init quiet"
type = linux-efi

[entry]
name = "Raven Linux (Recovery)"
kernel = "\EFI\raven\vmlinuz"
initrd = "\EFI\raven\initramfs.img"
cmdline = "rdinit=/init single"
type = linux-efi

System Requirements

Target System

x86_64 CPU with UEFI firmware
2GB RAM minimum (4GB recommended)
20GB disk space

Build Host

Linux system
20GB+ disk space
8GB+ RAM recommended
Internet connection for downloading sources

Contributing

Contributions welcome! Please open an issue or pull request on GitHub.

License

MIT License - See LICENSE file

Name		Name	Last commit message	Last commit date
Latest commit History 94 Commits
.github/workflows		.github/workflows
bootloader		bootloader
build-unpriv		build-unpriv
configs		configs
desktop		desktop
docs		docs
etc		etc
fonts		fonts
init		init
installer		installer
native-tools		native-tools
packages		packages
scripts		scripts
tools		tools
.dockerignore		.dockerignore
.gitattributes		.gitattributes
.gitignore		.gitignore
ARCHITECTURE.md		ARCHITECTURE.md
Dockerfile		Dockerfile
Dockerfile.minimal		Dockerfile.minimal
LICENSE		LICENSE
Makefile		Makefile
README.md		README.md
install-compositor.sh		install-compositor.sh

Folders and files

Latest commit

History

Repository files navigation

RavenLinux

Overview

Downloads

Quick Install

Technology Stack

Native Tools

Vem (Text Editor)

Carrion (Programming Language)

OxigenLang (Programming Language)

Ivaldi (Version Control) Currently GO *will transition to Rust Version

Networking

WiFi Setup

Alternative: GUI WiFi Manager

Advanced: Manual WiFi (CLI)

Building from Source

Requirements

Build Steps

Building with Docker / Podman (macOS, Windows, or Linux)

Headless / minimal build (no GUI)

Running RavenLinux in a container (test your tools)

Development Environment

Project Structure

Package Manager (rvn)

Bootloader (RavenBoot)

Boot Configuration

System Requirements

Target System

Build Host

Contributing

License

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages