GemOS

Project site

Desktop OS, built from the boot sector up.

GemOS is a from-scratch 32-bit desktop operating system for x86, written in C and assembly, with its own boot chain, kernel, scheduler, filesystem, GUI stack and a real Ring 3 transition already running isolated userland apps.

The project is not trying to look futuristic. It is trying to be coherent, stable and technically honest about what is finished, what is transitional and what is intentionally still simple.

Launch browser preview Open repository

What GemOS is

A real desktop-style OS project, not a boot demo.

GemOS owns the full path from the first boot sector to the desktop shell. The stack is intentionally integrated: boot loader, protected-mode bring-up, paging, scheduler, graphics, font rendering, window manager, filesystem and userland application model all live in the same project and evolve together.

The current architecture is deliberately transitional. The desktop shell stays kernel-hosted while Ring 3 userland grows through small, explicit interfaces. That keeps the system stable while still turning isolation into something practical.

  • System, not showcase
  • Architecture before features
  • Small transitions over rewrites
  • Thin interfaces over abstraction sprawl
  • Classic desktop OS feel

Screenshots

Current system state

GemOS desktop overview

The desktop stays in kernel space on purpose while userland applications mature through a smaller and safer interface layer.

Current state

What works now

Boot chain

Stage 1 + Stage 2, A20, protected mode and kernel entry.

Kernel core

IDT, ISR/IRQ, PIC, PIT, RTC, heap, paging, scheduler and serial logging.

Graphics and input

VBE linear framebuffer, page-flipped render path, PS/2 keyboard/mouse and TrueType text.

Desktop shell

Window manager, topbar, dock, menus, focus routing and decorations.

Storage

ATA PIO, GemFS, seeded userland binaries and basic userland file read/write.

Isolation

Ring 3, separate CR3 per process, TSS/esp0 switching and contained user faults.

Hosted app model

Userland owns state and render logic; the kernel hosts windows and text surfaces.

Apps

UTERM and About are stable userland apps. TextEdit is in active bring-up.

Architecture snapshot

Transition by layers

Userland apps: UTERM.ELF, ABOUT.ELF, UTEXTEDIT.ELF
Hosted window/surface services and thin syscalls
Scheduler, processes, ELF loading, fault handling
Paging, heap, interrupts, timer and serial path
VBE, PS/2, ATA, GemFS and font rendering
Own stage 1 + stage 2 boot chain

Why it looks like this

Userland without a desktop rewrite

  • Desktop shell, WM, topbar and dock remain in kernel space.
  • Userland apps run isolated and communicate through a small ABI.
  • The syscall surface stays narrow until multiple real apps prove it needs to grow.
  • The system grows outward from a stable desktop instead of replacing it all at once.

Applications

Current userland

UTERM screenshot

UTERM.ELF

Usable

Terminal logic in Ring 3 with hosted windows, input handling, command loop and predictable lifecycle.

About screenshot

ABOUT.ELF

Stable

Small informational app that shows the hosted app pattern is useful for polished UI, not only debugging tools.

UTEXTEDIT screenshot

UTEXTEDIT.ELF

Bring-up

The next larger app: document state, multiline rendering, caret movement and future file-oriented workflows.

Browser preview

Run GemOS in your browser

The preview uses the real GemOS floppy and data images through `v86`. It is an emulator, not a streamed desktop and not a mockup. Expect slower boot and lower frame pacing than local QEMU.

  • Static-site friendly, no backend required
  • Uses a real build output from this repository
  • Best suited for previewing the desktop and userland path, not benchmarking

Preview package

v86 + GemOS images

Boot the system directly from the site, inspect the desktop and try the current userland applications in a browser-hosted x86 VM.

Open browser preview

Build and debug

Local workflow

GemOS is built with a freestanding x86 cross-toolchain, NASM and QEMU. The same repo also produces the static demo assets used by the browser preview on this site.

  • Build target: `build/gemos.img` + `build/data.img`
  • Runtime: `qemu-system-i386`
  • Debug path: serial output and GDB remote attach
  • Site preview source: static copies of the same boot/data images

Roadmap

Near-term direction

  • Finish UTEXTEDIT file open/save flow and unsaved-close behavior
  • Keep hardening hosted app lifecycle and cleanup
  • Migrate more practical apps only when the app pattern is mature
  • Expand APIs only when real userland needs prove them out

Out of scope

What GemOS is not chasing right now

  • POSIX compatibility and `fork/exec`
  • Large userspace GUI toolkit
  • USB, TCP/IP and audio stack bring-up
  • High-half kernel rewrite
  • Moving the whole desktop shell to userspace in one jump