VibeOS: The Revolutionary ARM64 OS Built with AI

Building an operating system from scratch has always been the Mount Everest of programming challenges. Developers spend years mastering bootloaders, memory management, process scheduling, and device drivers before seeing a single pixel appear on screen. But what if you could vibecode an entire OS in just 64 sessions with AI assistance? Enter VibeOS—the hobby operating system that proves artificial intelligence can democratize systems programming.

This isn't another Linux distribution or a minimal kernel tutorial. VibeOS is a fully functional ARM64 operating system with a modern GUI, TCP/IP networking, a web browser, and yes—it runs DOOM. Created by developer kaansenol5 through collaborative sessions with Claude Code, it targets real hardware (Raspberry Pi Zero 2W) and virtual machines alike. The project represents a paradigm shift in how we approach complex system-level development.

In this deep dive, you'll discover how VibeOS challenges traditional OS development timelines, explore its impressive feature set, and learn how to build and run it yourself. We'll examine real code examples, compare it against established hobby OS projects, and reveal why developers are calling it the future of rapid systems prototyping. Whether you're an embedded systems engineer, a curious programmer, or an AI enthusiast, VibeOS offers something revolutionary.

What is VibeOS?

VibeOS is a completely vibecoded operating system targeting the ARM64 (aarch64) architecture, built from the ground up through 64 documented sessions with Claude Code. The term "vibecoding" refers to the AI-assisted development methodology where a human developer guides an AI pair programmer through iterative refinement, rapidly translating high-level ideas into working code.

Created by kaansenol5, this hobby OS demonstrates what's possible when modern AI meets systems programming. Unlike traditional OS projects that evolve over years of weekend hacking, VibeOS achieved a bootable GUI system with networking and applications in a fraction of the time. The entire development journey is transparently documented in six session log files, providing unprecedented insight into AI-assisted kernel development.

The OS runs on QEMU for easy testing and Raspberry Pi Zero 2W for real hardware deployment. It features a custom kernel with cooperative multitasking backed by preemptive scheduling, a FAT32 filesystem with long filename support, and a modern desktop environment inspired by macOS aesthetics. What makes VibeOS particularly compelling is its rapid development cycle—each session with Claude produced functional components that integrated seamlessly into the growing system.

VibeOS is trending because it challenges the notion that OS development requires decades of expertise. It proves that with the right AI collaboration, developers can tackle complex systems programming tasks previously reserved for elite kernel hackers. The project has captured attention across developer communities as both a technical achievement and a glimpse into the future of software creation.

Key Features That Make VibeOS Stand Out

VibeOS packs an astonishing array of features for a hobby OS. Let's break down what makes this system technically impressive:

Core Kernel Architecture

The heart of VibeOS is its custom kernel featuring cooperative multitasking with preemptive backup scheduling. This hybrid approach allows processes to yield control voluntarily while ensuring the kernel can interrupt runaway tasks. The memory allocator and process scheduler work in tandem with sophisticated interrupt handling that supports both GIC-400 (for QEMU virtualization) and BCM2836/BCM2835 interrupt controllers found in Raspberry Pi hardware.

The FAT32 filesystem implementation includes full long filename support, enabling modern file operations on SD cards. The configurable boot system lets developers choose between a splash screen animation or direct boot to desktop or shell environment.

Modern GUI Desktop Environment

VibeOS delivers a complete desktop experience with draggable windows, a menu bar, dock, and full window management (minimize/maximize/close). The GUI renders at 1920x1080 resolution using a direct framebuffer approach, achieving smooth performance even on modest hardware. The macOS-inspired aesthetic provides familiar UX patterns that make the system immediately usable.

Input handling supports both USB mouse and keyboard through the DWC2 driver, enabling precise cursor control and text input. The windowing system manages overlapping surfaces, focus switching, and event propagation—all essential features for a modern computing experience.

Full TCP/IP Networking Stack

Perhaps most impressively, VibeOS includes a complete TCP/IP implementation supporting Ethernet, ARP, IP, ICMP, UDP, and TCP protocols. The networking subsystem features a DNS resolver, HTTP client, and TLS 1.2 with HTTPS support through the TLSe library. This enables real internet connectivity for web browsing and secure communications.

The stack handles packet fragmentation, reassembly, and connection state management—sophisticated functionality rarely seen in hobby operating systems. Developers can write network applications using standard socket-like APIs.

Rich Application Ecosystem

VibeOS ships with 60+ userspace programs including:

• Web browser with HTML/CSS rendering capabilities
• Terminal emulator featuring a readline-style shell
• Text editor (vim clone) with syntax highlighting
• File manager supporting drag-and-drop operations
• Music player handling MP3 and WAV formats
• System monitor, calculator, and VibeCode IDE
• DOOM running natively at 2x scale on Raspberry Pi

Onboard Development Tools

The OS transforms into a self-hosting development platform with TCC (Tiny C Compiler) for compiling C programs directly on VibeOS. The MicroPython interpreter includes full kernel API bindings, allowing Python scripts to interact with system calls and hardware. This dual-language support makes VibeOS both a runtime environment and a development target.

Real-World Use Cases for VibeOS

1. Accelerated OS Development Education

VibeOS serves as a living textbook for understanding operating system internals. Computer science students can examine a complete, modern OS codebase that includes everything from bootloaders to GUI applications. The session logs provide a unique narrative showing how each component evolved, making abstract concepts concrete. Instead of studying Minix or xv6, learners can explore a system built with contemporary tools and AI collaboration patterns.

2. Rapid ARM64 Prototyping Platform

Embedded developers targeting ARM64 devices can use VibeOS as a rapid prototyping framework. The system's modular design allows quick integration of new drivers and applications. Need to test a custom USB device? The DWC2 driver implementation provides a clear template. Building an IoT gateway? The TCP/IP stack and networking APIs offer a foundation that can be extended for specific use cases.

3. AI-Assisted Development Laboratory

The project demonstrates vibecoding methodologies that can be applied to other complex systems. Developers can study the 64-session pattern to understand how to effectively collaborate with AI on large-scale projects. The CLAUDE.md file contains technical references and architecture decisions that reveal the thought process behind AI-human pair programming at the systems level.

4. Retro Gaming and Demoscene Platform

Running DOOM on bare metal at 1920x1080 with USB controller support makes VibeOS an attractive platform for retro gaming enthusiasts. The system's lightweight nature and direct hardware access provide the performance characteristics that demoscene creators crave. The included minimp3 library and audio subsystem enable multimedia applications that push hardware limits.

5. Minimalist Edge Computing Node

For edge computing scenarios requiring minimal overhead, VibeOS offers a compelling alternative to bloated Linux distributions. The entire system can be understood and audited by a single developer, making it ideal for security-sensitive deployments where simplicity equals reliability. The TCP/IP stack and TLS support enable secure cloud connectivity without the complexity of mainstream OSes.

Step-by-Step Installation & Setup Guide

Getting VibeOS running takes minutes on macOS or Linux. Follow these precise steps to build and boot the system.

Prerequisites Installation

First, install the cross-compiler and emulator. On macOS, use Homebrew:

brew install aarch64-elf-gcc qemu

Linux users should install equivalent packages through their distribution's package manager. The aarch64-elf-gcc toolchain is essential for compiling ARM64 code on x86 hosts, while qemu-system-aarch64 provides the virtualization environment.

Initial Build Process

Clone the repository and resolve the TLSe dependency:

git clone https://github.com/kaansenol5/VibeOS.git
cd VibeOS
cd vendor/
git clone https://github.com/kaansenol5/tlse
cd ..

The TLSe library provides TLS 1.2 support for HTTPS functionality. Without this dependency, compilation will fail when linking networking components.

Creating the Disk Image

Build the initial filesystem image:

make disk

This command creates a FAT32-formatted disk image containing the directory structure, configuration files, and placeholder directories for applications and games.

Building and Running in QEMU

Compile the kernel, all userspace programs, and launch the virtual machine:

make run

This single command orchestrates the entire build process: cross-compiling the kernel, building 60+ applications, syncing files to the disk image, and launching QEMU with the correct machine configuration (virt board) and CPU settings for ARM64 emulation.

Running on Raspberry Pi Zero 2W

For real hardware deployment, build the Pi-specific version:

make TARGET=pi

This configures the kernel for BCM2835/BCM2836 peripherals and includes the USB DWC2 driver for keyboard and mouse support.

Installing to SD Card

Identify your SD card device:

# macOS
diskutil list

# Linux
lsblk

Install the bootloader, kernel, and filesystem:

make install DISK=/dev/disk4  # Replace with your actual device

WARNING: This command partitions the SD card and overwrites all data. Triple-check the device path before executing.

Boot Configuration

Edit /etc/boot.cfg to customize behavior:

# VibeOS Boot Configuration
splash=on       # on/off - show boot splash animation
boot=desktop    # desktop/vibesh - boot target

Setting splash=off speeds up boot time for development, while boot=vibesh drops directly to the shell for debugging.

REAL Code Examples from VibeOS

Let's examine actual code snippets from the repository, explaining each component's function and implementation details.

Example 1: macOS Development Environment Setup

brew install aarch64-elf-gcc qemu

This single line installs the complete toolchain needed for VibeOS development. The aarch64-elf-gcc package provides the cross-compiler that runs on macOS x86_64 but produces ARM64 machine code. qemu installs the system emulator with aarch64 support, specifically the qemu-system-aarch64 binary that simulates the ARM64 virtual machine environment.

Example 2: TLSe Dependency Resolution

cd vendor/
git clone https://github.com/kaansenol5/tlse

The build system expects third-party libraries in the vendor/ directory. TLSe (Tiny TLS Engine) implements TLS 1.2 cryptography required for HTTPS connections in the web browser. The custom fork at kaansenol5/tlse likely includes ARM64-specific optimizations or patches for bare-metal environments without standard C library dependencies.

Example 3: Build and Run Orchestration

make run

Behind this simple command lies a complex Makefile that:

1. Compiles the kernel (kernel/kernel.c) with architecture-specific flags
2. Builds all userspace programs in user/bin/ and user/sbin/
3. Links applications against the custom C library (libc/)
4. Generates the vibeos_root/ filesystem tree
5. Creates a disk image using dd and mkfs.vfat
6. Syncs files with rsync to maintain proper FAT32 attributes
7. Launches QEMU with: qemu-system-aarch64 -M virt -cpu cortex-a53 -m 512M -kernel kernel/kernel.bin -drive file=disk.img,format=raw

Example 4: Raspberry Pi Target Configuration

make TARGET=pi

This build target switches the kernel configuration from QEMU's virt board to Raspberry Pi's hardware. The Makefile detects TARGET=pi and:

• Defines __PI__ preprocessor macro
• Links BCM2835/BCM2836 peripheral drivers instead of QEMU's PL011 UART
• Includes the DWC2 USB host driver for keyboard/mouse input
• Configures the framebuffer for the Pi's VideoCore GPU
• Sets up interrupt handling for the ARM-local timer and GPU interrupts

Example 5: Boot Configuration Parser

# VibeOS Boot Configuration
splash=on       # on/off - show boot splash animation
boot=desktop    # desktop/vibesh - boot target

The kernel's early boot code parses this simple key-value configuration file from the FAT32 filesystem. The parser (kernel/bootcfg.c) reads /etc/boot.cfg into a buffer, tokenizes lines, and sets global flags:

• splash_on controls whether to display the animated logo during initialization
• boot_target determines whether to launch the GUI desktop or the VibeShell text interface

This configuration system allows users to modify boot behavior without recompiling, essential for rapid iteration during development.

Advanced Usage & Best Practices

Optimizing Build Times

For faster development cycles, build individual components:

make kernel      # Compile only the kernel
make user/bin/*  # Build specific applications
make sync        # Sync files without rebuilding

Debugging Kernel Panics

When the kernel crashes, QEMU provides a powerful debugging environment. Launch with:

qemu-system-aarch64 -M virt -cpu cortex-a53 -m 512M -kernel kernel/kernel.bin -drive file=disk.img,format=raw -serial mon:stdio

The -serial mon:stdio flag redirects kernel debug output to your terminal, showing panic messages and stack traces.

Writing Custom Applications

Leverage the VibeOS API by including vibe.h in your C programs:

#include <vibe.h>

int main(int argc, char **argv) {
    // Your code here
    return 0;
}

The API provides system calls for process management, filesystem operations, networking, and GUI creation. Study existing applications in user/bin/ for implementation patterns.

MicroPython Integration

Access kernel functions from Python:

import vibe

# Open a file
f = vibe.open("/etc/boot.cfg", vibe.O_RDONLY)

The MicroPython port includes bindings for most system calls, enabling rapid prototyping of applications without recompiling.

Performance Tuning on Raspberry Pi

For optimal Pi performance:

• Disable the splash screen (splash=off)
• Boot to shell for memory-constrained scenarios (boot=vibesh)
• Use 2x scaling for DOOM to maintain 30+ FPS
• Connect keyboard before mouse to avoid USB enumeration issues

Comparison with Alternative Hobby OSes

Why Choose VibeOS?

1. Rapid Prototyping: Achieve in weeks what takes years traditionally
2. ARM64 Focus: Native support for modern embedded hardware
3. AI Transparency: Complete session logs reveal development decisions
4. Modern Features: TLS, HTTPS, and a real web browser out of the box
5. Educational Value: Learn OS concepts through AI collaboration patterns

Frequently Asked Questions

What exactly is "vibecoding"?

Vibecoding is the practice of using AI pair programming (specifically Claude Code) to rapidly develop software through natural language conversation. Instead of writing every line manually, developers describe desired functionality and review AI-generated code. VibeOS demonstrates this methodology at scale—64 sessions produced a complete OS.

Can VibeOS run on Raspberry Pi models other than Zero 2W?

Currently, VibeOS is optimized for the Raspberry Pi Zero 2W and its BCM2835/BCM2836 peripherals. While the ARM64 kernel could theoretically boot on other Pi models, drivers for USB, framebuffer, and interrupts would need modification. The Pi 3B+ or Pi 4 might work with minimal changes to device tree configurations.

How stable is VibeOS for daily use?

VibeOS is a hobby project, not a production OS. While most features work reliably—including GUI, networking, and applications—some components remain untested or incomplete. It's perfect for learning, experimentation, and showcasing AI-assisted development, but not recommended for critical tasks. The codebase is MIT licensed, so you can improve stability yourself!

What programming languages can I use to develop for VibeOS?

You have three options:

1. C using TCC (Tiny C Compiler) directly on VibeOS
2. Python via the MicroPython interpreter with kernel API bindings
3. Cross-compilation using aarch64-elf-gcc on Linux/macOS

The PROGRAMMING.md file provides detailed examples for each approach.

How does the AI-assisted development process work in practice?

The developer (kaansenol5) engaged in 64 structured sessions with Claude Code, each focusing on specific components. Sessions were documented in markdown files showing the conversation flow, code generation, and architectural decisions. This creates a unique learning resource showing how to effectively prompt AI for systems programming tasks.

Can I contribute to VibeOS?

Yes! The project accepts issues and pull requests on GitHub. Areas needing contribution include:

• WiFi/Ethernet drivers for Raspberry Pi
• Audio driver implementation
• Additional applications and games
• Performance optimizations
• Documentation improvements

Why did the developer choose ARM64 over x86_64?

ARM64 offers several advantages for hobby OS development:

• Simpler boot process (UEFI not required)
• Consistent hardware platforms (Raspberry Pi)
• Modern, clean instruction set
• Growing embedded ecosystem
• QEMU's virt board provides excellent emulation

The choice enables real hardware testing on affordable Pi Zero 2W boards while maintaining full emulation support.

Conclusion: The Future of OS Development is Collaborative

VibeOS represents more than just a technical achievement—it's a proof of concept for the future of software creation. By leveraging AI assistance, developer kaansenol5 accomplished in weeks what traditionally requires years of specialized expertise. The project's transparency, with complete session logs and clear documentation, provides a roadmap for others to follow.

The combination of modern features (TLS 1.2, HTML rendering, drag-and-drop GUI) with rapid development cycles demonstrates that AI pair programming can tackle even the most complex programming challenges. While VibeOS remains a hobby project, it points toward a future where developers focus on architecture and design while AI handles implementation details.

For embedded systems engineers, VibeOS offers a lightweight ARM64 platform for edge computing. For educators, it provides a complete, modern teaching resource. For AI enthusiasts, it showcases effective vibecoding at scale. And for retro gaming fans, it delivers DOOM on bare metal—which is reason enough to try it.

Ready to experience the future of OS development?

⭐ Star the repository at https://github.com/kaansenol5/VibeOS to support the project 🖥️ Build it yourself following the steps in this guide 🤖 Study the session logs to master AI-assisted development 🎮 Play DOOM on your Raspberry Pi Zero 2W 💻 Contribute drivers, apps, or documentation

The era of solitary, decade-long OS development is ending. VibeOS shows us that with AI collaboration, creativity, and modern tools, anyone can build the operating system of their dreams. What will you vibecode next?

VibeOS is MIT licensed and actively maintained. Issues and PRs welcome. DOOM port remains GPL-2.0.