TermuOS
Download
x86_64 · written in C, C++ & assembly

An operating system, built from ring 0 up.

TermuOS is a lightweight, open-source kernel project for learning how computers actually work — its own memory manager, virtual filesystem, scheduler, drivers, and shell, booted fresh in QEMU.

Get the source Read the docs
MIT licensed Limine boot protocol Runs in QEMU
qemu-system-x86_64 — termuos.iso
Physical & virtual memory management Preemptive multitasking Custom filesystem (TFS) Luna GUI toolkit
What's inside

A kernel with its own everything.

No borrowed userland, no wrapped Linux syscalls — every layer below the shell prompt is written for TermuOS itself.

[mm]

Memory management

A physical page frame allocator paired with a virtual memory manager and kernel heap, built to hand out memory the way a real kernel has to.

[sched]

Preemptive scheduler

A thread scheduler with context switching in hand-written assembly, so threads and ps show real, running work.

[fs]

Virtual filesystem

A VFS layer in front of TFS, TermuOS's own on-disk filesystem, plus a ramfs — mounted, read, and written from the shell.

[drv]

Driver stack

ATA storage, PS/2 keyboard and mouse, real-time clock, serial console, framebuffer video, and a virtio network driver over PCI.

[shell]

Terminal & shell

A built-in shell with file, process, network, and system commands — the primary way you drive the machine.

[luna]

Luna GUI toolkit

An early windowing system with a compositor, taskbar, start menu, and widgets — buttons, labels, and text fields — running on the kernel.

[net]

Networking

A virtio-net driver with ARP and a basic IP stack, reachable from the shell through ifconfig, ping, and arp.

[proc]

Processes & objects

A process layer with an ELF launcher, plus an object manager (ob) for tracking kernel resources by handle.

[boot]

Limine boot protocol

Boots on BIOS or UEFI, x86_64 first, with Limine binaries for RISC-V, LoongArch, and IA-32 already vendored in.

Quickstart

Booted in about a minute.

Everything you need is one make away — the build script pulls Limine, assembles the kernel, and stitches together a bootable ISO.

1

Install the toolchain

clang, nasm, make, xorriso, and QEMU.

2

Clone the repository

Grab the source straight from GitHub.

3

Build and run

make produces termuos.iso; make run boots it in QEMU.

Full build instructions →
shell 
# dependencies (Debian/Ubuntu)
sudo apt install clang nasm make xorriso qemu-system-x86

# clone
git clone https://github.com/TermuOS-Project/TermuOS.git
cd TermuOS

# build the ISO
make

# boot it in QEMU
make run
Architecture

From bootloader to desktop, in five layers.

Each layer only talks to the one below it — the shell doesn't know about ATA, and drivers don't know about the scheduler.

limine/
Boots the machine (BIOS or UEFI) and hands off a memory map and framebuffer to the kernel.
kernel/mm, sched
Physical & virtual memory management, the kernel heap, and the preemptive thread scheduler.
kernel/drivers, fs, net
Hardware drivers, the VFS + TFS filesystem, and the virtio networking stack.
kernel/proc, ob, shell
Process & object management, the ELF launcher, and the interactive shell you land in at boot.
kernel/luna
The windowing system — compositor, taskbar, start menu, and widgets — layered on top of everything else.
Roadmap

What's running, what's next.

Landed

  • x86_64 kernel & boot
  • Preemptive multitasking
  • Virtual filesystem + TFS
  • Driver stack (ATA, input, RTC, net)
  • Shell with 25+ commands
  • Early Luna GUI toolkit

In progress

  • User-mode programs
  • ELF executable loader
  • Improved networking
  • Better filesystem support
  • SMP support
  • Audio & package manager

Read the kernel. Break the kernel. Fix the kernel.

TermuOS is MIT licensed and built in the open — clone it, boot it in QEMU, and start reading from kernel/.

Download / build Star on GitHub