AnotherOS

What it actually does

Every line below is something that runs, not something planned.

AnotherOS is a hobby operating system for the homelab, written in C. What it shares with Linux is an interface, not an implementation: it exposes the Linux syscall ABI faithfully enough that unmodified musl, BusyBox, bash, GTK3, Qt6 and WebKitGTK run on it. Everything below that line is original.

It boots from a USB stick, installs to a disk, dual-boots beside macOS on a Mac, compiles its own software on the machine, and runs Firefox — and native Windows executables — on the desktop it draws itself.

The kernel

  • x86_64. Long mode, four-level paging, SMP, and a MuQSS scheduler with LAPIC preemption.
  • Memory. Demand paging, copy-on-write fork, an OOM killer, real madvise purging, and a page cache that took a warm 4 MB SquashFS read from 2.51 s to 0.34 s.
  • Filesystems. ext2/3/4, SquashFS, OverlayFS, NFSv3, ISO 9660 and FAT behind a real VFS — plus an in-kernel SMB2 client, so a Windows or Samba share mounts with no userspace daemon at all.
  • Networking. A from-scratch TCP/IP stack with genuine congestion control — throughput went from 12 KB/s to 8157 KB/s once it was right — plus a soft-MAC 802.11 implementation with the WPA2-PSK four-way handshake and CCMP.
  • USB. UHCI, OHCI, EHCI and xHCI. All four, because machines routinely put internal devices behind the older controllers.
  • Graphics. i915, radeon and bochs DRM drivers loaded as modules through a LinuxKPI compatibility layer, with Mesa on top — including GPU buffer sharing over dma-buf and hardware video decode on the chips that support it.
  • ACPI with a real interpreter. Batteries, the AC adapter, the lid, the power button and screen brightness all come from firmware methods actually being run, not from tables being read.
  • UEFI runtime services. An installed disk can be made the firmware's own default boot, including on a Mac.
  • Timekeeping from the processor's own clock, so a machine whose firmware silently disables the legacy timer still boots.
  • Debugging. A kernel debugger speaking the GDB remote serial protocol over UDP, so a panic on real hardware is inspectable from another machine.
  • Crash reporting. A process that dies from a fault is symbolised and backtraced by a supervised reporter, system-wide.

Fasadas, the desktop

Fasadas is a compositor and window server written for this system. Clients and the compositor exchange buffers over a local socket protocol, passing memory handles directly — zero-copy, with no X server in the middle.

  • Kvarcas is the 2D engine underneath, a Core-Graphics-shaped API over Cairo.
  • Grafika is the unified graphics API: one Metal-shaped C interface with a complete software backend and a GPU backend, which every 2D and 3D path goes through.
  • Plintusas is the dock: a glass shelf with magnification, reflections and a launch bounce.
  • Vanduo is the theme. Every widget draws through one set of primitives, so a checkbox in one application cannot drift from a checkbox in another.
  • XFasadas is a rootless X11 server for software that still wants X.

What the desktop does now:

  • GPU compositing. The compositor can draw the scene on the GPU through Mesa, keeping it there only when the renderer is real hardware and staying on the CPU when it is not — because on a software rasteriser the CPU is genuinely faster.
  • Notifications: banners, alerts with action buttons that reach the application that posted them, grouping, Do Not Disturb with a schedule, and a Notification Centre with history, calendar and system metrics.
  • HiDPI, with the backing scale carried through the protocol, so text and edges are rasterised at device resolution rather than upscaled.
  • Trackpad gestures and scroll phases.
  • Desktop effects — genie and scale minimise, open and close animations, menu-bar vibrancy, and a wobbly-windows spring lattice — each with its cost shown live in the settings pane, because two of the controls give frame time back rather than spending it.
  • A typed pasteboard, system-wide, with lazy promises and file transfers, shared with GTK, Qt, Firefox and Win32 programs.
  • The level bezel for brightness, keyboard light and volume keys.
  • A VNC server built into the compositor, on by default, so a headless machine is reachable without installing anything.

The bundled applications are native: a file manager (Rastinis), a terminal, a text editor, a bitmap editor, a media player, System Preferences with twenty panels, Activity Monitor, System Profiler, a Launchpad-style launcher, a 3D benchmark, and the graphical installer.

Sound

Garsas is the sound stack: a kernel multiplexer that owns the hardware, and a sound server that owns policy — application identity, per-application volume and mute remembered across runs, routing, and capture consent.

Its client library keeps working when the server is not running, and on a machine with no sound card at all: that is a reported state rather than an error, so an application never has to care.

Running Windows programs

Native 32-bit Windows executables run as first-class, crash-isolated desktop applications. Not an emulator, and not Wine — a native subsystem modelled on Windows NT's own, using the CPU's compatibility mode with a 64-bit host in the same process.

A .exe is executable: ./program.exe works, with no loader on the command line, and the process appears under its own name. Direct3D 7 through 11 and DirectDraw run through Wine's translation layer onto OpenGL and Mesa, with DirectInput built in. On supported Intel hardware that is real GPU acceleration.

Networking and services

Tinklas owns all network configuration — a daemon that is the sole owner of the Wi-Fi control plane, so the link comes back after an access point drops it even on a headless machine with no desktop running.

Wi-Fi, DHCP with proper lease renewal, DNS that follows the lease, SSH, and SMB and NFS shares mounted from the file manager or the shell.

apkg, the package manager

apkg is statically linked and depends on nothing but syscalls — it is the one program that has to work when nothing else does. It carries its own SHA-256, SHA-512 and ed25519 verification, its own ustar reader and its own HTTP client.

Packages install into a versioned tree and are activated by flipping a symlink farm. Installation is atomic and reversible: dependencies resolve completely, the archive is verified, it unpacks to staging on the same filesystem, and only then does a rename put it in place. The previous version stays on disk, so a rollback is flipping the farm back.

A kernel can be installed as a package and booted once without becoming the default, so trying a new kernel is not betting the machine on it.

The toolchain, and self-hosting

A real x86_64-anotheros-musl triplet — binutils, GCC and musl — not a cross-compiler pretending to target Linux. Ports identify the system through a genuine predefine rather than faking one.

The machine builds its own software. A freshly installed disk carries a native GCC, g++, binutils and a complete sysroot, so cc hello.c -o hello works with no cross host. C++ has POSIX threads, which is what made WebKit possible.

How it boots

Limine via Multiboot2, with GRUB2 as a drop-in fallback, on both BIOS and UEFI — and BSDP for Macs, which speak a protocol no other machine uses.

The ISO is the whole system: a compressed SquashFS root is demand-read off the disc and unioned with a RAM filesystem, so the root is read-only, writes go to memory, and the entire userland — desktop, GTK/Qt/WebKit stacks, toolchain — is present with no second disk required.

On a Mac it installs alongside macOS and appears in the firmware's own boot picker, leaving macOS untouched.

Where to go next

The documentation covers each of these in detail, including the API surfaces for writing native applications.