vibeOS

vibeOS is a small, experimental x86_64 Linux distribution whose userspace is written from scratch in Rust. It boots Linux 7.1.5 in QEMU, starts a statically linked, libc-free Rust PID 1, provides an interactive serial shell, installs signed packages, and serves a page from persistent storage.

The project is deliberately small enough to understand end to end. It is a working bring-up system, not yet a general-purpose or production distribution.

What works

• Linux 7.1.5 built from a checked and pinned kernel.org archive
• persistent writable ext4 system root
• Rust PID 1 with service supervision
• interactive vibe-sh console
• libc-free Rust core utilities
• HTTP/1.1 GET and HEAD server
• persistent ext4 web content at /var/www
• Ed25519-verified package install, upgrade, remove, and listing
• package downloads by name over DNS and HTTP
• two-boot QEMU smoke test proving persistence

Quick start

vibeOS currently builds and runs on a Linux host.

git clone --recurse-submodules https://github.com/vibedOS/vibeOS.git
cd vibeOS
rustup toolchain install 1.94.0 --profile minimal
sudo apt-get install bc bison clang cpio curl e2fsprogs flex libelf-dev lld llvm make python3 qemu-system-x86 xz-utils
make run

The first build downloads and compiles Linux, so it takes longer than later runs. When boot completes, the same terminal becomes the serial console:

vibeOS ready
vibe-sh 0.1
vibe$

Type commands directly after vibe$. Run reboot to stop the VM cleanly, or press Ctrl-a, then x, to exit QEMU immediately.

While the VM is running, open http://127.0.0.1:18080/ or:

curl http://127.0.0.1:18080/
curl http://127.0.0.1:18080/health

If port 18080 is already in use, select another host port:

make run HTTP_PORT=18081

Shell commands

Run help in vibeOS for the current list.

Command	Purpose
help	list built-ins and installed commands
clear	clear the serial terminal
echo TEXT...	print text
cd [DIRECTORY]	change directory; defaults to /
pwd	print the current directory
ls [DIRECTORY]	list one directory
cat [FILE...]	print files or standard input
mkdir PATH...	create directories
rm PATH...	remove files
uname	print the vibeOS kernel identity
whoami	print the current user
vibefetch	show the colored system summary
pid	print the shell process ID
true / false	return success or failure
vibe-pkg	install, upgrade, remove, or list signed packages
reboot	sync storage and reboot
exit	leave the current shell; PID 1 starts another

Commands support one output redirection:

echo hello from vibeOS > /var/www/hello.txt

Pipes, quoting, variables, globbing, job control, and input redirection are not implemented yet.

Package management

vibeOS includes a signed vibe-hello package in its local cache:

vibe-pkg install /var/cache/vibe-pkg/vibe-hello.vpkg
vibe-hello
vibe-pkg list
vibe-pkg remove vibe-hello

upgrade accepts the same package name or local path as install. Packages are verified against the Ed25519 trust root in keys/vibe-packages.pub, staged with fsync, and atomically renamed into /bin.

make run also starts a local development repository. Install from it by package name:

vibe-pkg install vibe-hello

The repository URL lives at /etc/vibe-pkg/repository. Name lookup checks /etc/hosts before sending a DNS A query through /etc/resolv.conf.

Persistent storage

make run creates .build/system.ext4 as the writable root filesystem and .build/www.ext4 for separately mounted web content. Installed packages, system changes, and web files survive reboots and later runs.

Normal builds never overwrite either user volume. After pulling userspace changes, run make system-reset to boot the new base system; this deliberately removes packages and system edits made inside the previous root volume.

Reset either volume to the current source tree with:

make system-reset
make data-reset

The smoke test uses separate disposable images and never resets the user volumes.

Build targets

Target	Result
make release	build the kernel, Rust userspace, base system image, and persistent volumes
make run	build and boot vibeOS interactively in QEMU
make check	run host tests and verify the binaries are static and libc-free
make smoke	boot twice, exercise the shell and HTTP server, and prove persistence
make data-reset	recreate the persistent web volume from the seed files
make system-reset	recreate the persistent root volume from the latest build
make clean	remove all build output, including both persistent user volumes

Set JOBS to control kernel build parallelism and HTTP_PORT to change the forwarded host port.

Repositories

Every userspace component is an independent MIT-licensed Git repository, included here as a submodule.

Repository	Role
vibe-rt	no_std process entry, Linux syscalls, and shared runtime
vibe-init	PID 1, filesystem mounting, and service supervision
vibe-sh	interactive shell and command execution
vibe-coreutils	multicall Unix utilities and vibefetch
vibe-httpd	bounded HTTP/1.1 server
vibe-net	allocator-free DNS and HTTP client
vibe-pkg	signed package manager and host package builder
vibe-hello	first installable package and persistence check

The root filesystem seed lives in rootfs/, and the minimal x86_64 kernel configuration lives in kernel/x86_64.fragment.

Current limits

vibeOS currently targets QEMU x86_64, runs services as root, and relies on the kernel's boot-time DHCP support. Packages currently contain one /bin executable and do not yet support dependencies. Package downloads use plain HTTP, with Ed25519 signatures providing authenticity but not privacy. The OS also lacks an installer, TLS, and general hardware support.

License

The vibeOS integration code and every userspace repository are MIT licensed. The downloaded Linux source remains under its upstream GPL-2.0 WITH Linux-syscall-note licensing.