hmofet/unodos: UnoDOS — lively growth (the ahead, contract-driven line; grasp carries the pc64 x86-64/UEFI globe). Frozen legacy (archived): hmofet/unodos-3-legacy. · GitHub

One supply tree, one design, twenty-two machines, from an IBM PC/XT with an
8088 to the fashionable laptop computer in your desk.

UnoDOS is a household of graphical working programs. It started as a GUI-first,
16-bit real-mode OS written fully in x86 meeting, becoming a kernel, a
window supervisor, two filesystems, cooperative multitasking and a full
utility set on a single 1.44 MB floppy. It has since grown right into a
contract-driven household of ports spanning house computer systems, consoles, handhelds,
single-board computer systems and a cellphone, and its flagship is now pc64: UnoDOS
working bare-metal on any fashionable 64-bit PC, by itself drivers, with its personal
community stack, browser, workplace suite, compiler and hypervisor.

Prebuilt photos for each platform are on the
releases page: a hybrid ISO and
USB disk picture for contemporary PCs, cartridge ROMs for the consoles and handhelds,
disk photos for the house computer systems, and SD-card payloads for the boards. Most
of them run in an emulator inside a minute; the
user manual walks by booting actual
{hardware}, together with one-click USB flasher apps for Windows and macOS.

What has really been verified is a separate query from what builds, and
PLATFORMS.md is the ledger that solutions it: per platform, what
has booted on actual {hardware} (and on which bodily machine), what’s
emulator-verified solely, and each recognized hole.

pc64 boots bare-metal on basically any x86-64 PC made since ~2007.
UEFI performs the position the BIOS performs for the basic OS: the firmware arms over
a framebuffer, a keyboard and the boot quantity, after which, on most machines,
UnoDOS calls ExitBootServices and the firmware leaves. From that time
the OS runs fully by itself drivers. A hybrid disk picture boots the identical OS
on legacy-BIOS machines too.

The shell is constructed on unoui, the household’s cross-platform widget toolkit: a
windowed desktop with a taskbar, digital desktops, window snapping, an
animated Alt-Tab switcher, desktop icons and a packages menu. Ten themes are
live-switchable, from Aurora (the fashionable flat default, in mild and darkish)
to trustworthy retro appears (Mac OS 7, 1-bit Mac Plus, Windows 3.1, Amiga
Workbench, C64, Apple II, NeXTSTEP). Text is kerned, anti-aliased TrueType
with bundled open fonts, and each management is reachable by pointer or
keyboard.

• UnoWord, UnoCalc, UnoShow: an Office 97-class suite that reads and
  writes the actual Microsoft binary codecs (.doc, .xls, .ppt) by
  the in-tree unodoc library.
• Browser: HTML, Markdown and CSS rendering with cookies, cache, discover and
  save, HTTP and CA-validated TLS 1.2 HTTPS, and two switchable JavaScript
  engines: the in-tree unojs bytecode VM and vendored quickjs-ng,
  with a libcss-based structure engine possibility behind the identical seam.
• Studio: an IDE that runs on the OS itself, with syntax highlighting, a
  build-and-run loop, an AI assistant, and UnoC, a built-in C compiler
  that compiles native UnoDOS apps on UnoDOS.
• Python: MicroPython as a first-class runtime (PYRT.UNO) with a uno
  API into the shell, filesystem and community.
• Music, UnoAmp, Photos: from-scratch WAV, MIDI, MP3 and AAC-LC decoders
  (unomedia); UnoAmp is a Winamp 2 clone that masses basic
  skins; Photos views the frequent picture codecs.
• SSH: a local SSH consumer (ed25519, in-tree crypto).
• Plus Files, Editor, Paint, Tracker, Clock, Control Panel, System, a log
  viewer, the video games (Dostris, Pac-Man, OutLast) and Runner3D, the showcase
  for the uno3d 3D library.

Apps are loadable .UNO modules carrying their very own descriptors: drop one
into APPS and the shell discovers it. No rebuild, no reboot.

Everything beneath the firmware line is native, written for this tree:

• Storage: AHCI, NVMe, SDHCI/eMMC and USB mass storage below a standard
  block layer, a local FAT16/FAT32 driver, GPT/ESP authoring.
• USB: a polled xHCI host stack with hubs, HID keyboards and mice, mass
  storage, and USB Ethernet (ASIX AX88179, Realtek RTL8152).
• Networking: wired NICs (Intel e1000/e1000e/igb, Realtek r8169) and
  Wi-Fi (Intel, Realtek, Marvell drivers) with WPA2, over a from-scratch
  TCP/IP stack: ARP, IPv4, ICMP, UDP, TCP, DHCP, DNS, TLS (BearSSL), sockets
  and syslog in each instructions.
• Input: PS/2, I2C-HID (native laptop computer trackpads) and USB HID.
• Audio: Intel HDA with AC’97 fallback right into a 48 kHz DMA ring.
• ACPI: an in-tree AML interpreter (unoacpi).

unovirt enters VMX operation on Intel {hardware} and runs
visitors behind EPT with virtio gadgets: an actual Ubuntu kernel boots below
UnoDOS, reaches userspace, solutions at its shell, and mounts an ext4 disk
served from a file on a UnoDOS quantity. The Appliances app and VM supervisor
entrance it; an AMD/SVM backend is written and awaiting {hardware} proof.

• Installer: non-destructive set up onto an present disk’s ESP, or a
  whole-disk clone; a working machine can be reinstalled over the
  community.
• unosecure: native accounts, RBAC and an audit path.
• URC: a remote-control channel (fail-closed verb gate, one-time console
  arming) that drives actual machines headlessly: deploying builds, working
  assessments, streaming the display screen. It is how the {hardware} fleet is validated
  and not using a human on the keyboard.
• Debug builds: a behavioral spec (pc64/SPEC.md) executed
  as an on-metal conformance take a look at, plus watchdogs, fault telemetry and a
  stress harness.

Validated on a Lenovo ThinkPad X1 Carbon Gen 8 (native trackpad, Wi-Fi, stay
theme and backbone switching), on an always-on ZimaBlade take a look at field (boots
from USB, detaches from the firmware, runs totally native), and on QEMU+OVMF
harnesses that boot the actual picture on each change. The design notes in
pc64/README.md report the firmware traps solely actual {hardware}
exposes; they’re half the worth of the port.

sudo apt set up gcc-mingw-w64-x86-64 qemu-system-x86 ovmf python3 python3-pil
cd pc64
./construct.sh            # -> construct/esp/EFI/BOOT/BOOTX64.EFI
./construct.sh run        # boot it in QEMU+OVMF

The complete port builds with inventory packages, no EDK2. See
pc64/DEVELOPMENT.md for Linux and Windows setting
setup and pc64/README.md for the total structure tour.

UnoDOS 3.1 is contract-driven: a single machine-readable Contract
(unodef/) defines display screen geometry, the window and occasion structure and
the shared enums, and each globe is generated from it or checked in opposition to it.
The meeting ports and the x86 reference devour it byte-identically, and
eleven ports had been constructed contemporary on the three.1 structure relatively than
migrated, proving {that a} new goal prices a small generated floor. See
docs/UNODOS-3.1-MIGRATION.md and
docs/CONTRACT-ARCH.md.

Every port boots a UnoDOS desktop with the shared app set: Files, Notepad,
Music, Theme, Tracker, Paint and the video games (Dostris, OutLast, Pac-Man),
scaled to what the machine can maintain, all the way down to a launcher profile on 2 KB of
RAM. A feature-by-feature comparability lives in
docs/FEATURE-MATRIX.md.

Home computer systems

Consoles and handhelds

Boards and cellular

Several ports are validated on actual silicon (NES, PC Engine, Genesis, Mac SE,
the x86 line, pc64’s laptop computer and SBC fleet); the remaining are verified in
emulators or on ROM-free instruction-level harnesses (Unicorn, py65, a
from-scratch 65816 core), so no proprietary ROMs are wanted to construct or take a look at
something.

The authentic UnoDOS 3: a GUI-first OS for IBM PC XT-compatibles, written
fully in real-mode x86 meeting. No DOS, no runtime, simply the BIOS and an
Intel 8088 or later.

• Boots from a 1.44 MB floppy (or laborious drive, CompactFlash, USB) straight
  right into a windowed desktop: draggable icons, mouse help, a 16-window
  z-ordered window supervisor with define drag and resize.
• A ~46 KB kernel exposing 106 system calls over INT 0x80: graphics in
  4 video modes (CGA 320×200 to VESA 640×480), a 15-widget GUI toolkit
  with file dialogs, FAT12 and FAT16 learn/write, cooperative multitasking (5
  concurrent apps plus the shell in 640 KB), a system clipboard, three bitmap
  fonts and PC-speaker audio.
• 19 functions, from a full textual content editor and file supervisor to Paint,
  Tracker, Settings, a boot-floppy creator and three video games.
• Runs at full characteristic parity on a real 8088 at 4.77 MHz, verified on a
  cycle-accurate XT (Microsoft serial mouse on COM1, XT-IDE CompactFlash
  boot) and on actual {hardware} from a 386SX to an Atom netbook. See
  docs/PORT-8088.md.

Build and run it:

sudo apt set up nasm qemu-system-x86 make python3
make floppy144        # construct/unodos-144.img, a bootable FAT12 floppy
make run144           # boot it in QEMU

make hd-image builds the 64 MB FAT16 hard-drive picture;
tools/write.ps1 writes photos to bodily media on Windows
(with system-drive exclusion and read-back confirm), and plain dd does it on
Linux.

Apps are flat NASM binaries in their very own 64 KB segments; a minimal windowed
app is about 60 strains. Start with the
app development guide, the
API reference (all 106 calls with register-level
element) and docs/ARCHITECTURE.md.

The ports keep small as a result of the heavy equipment is shared:

• grasp (this repo, hmofet/unodos):
  the ahead, contract-driven line and the house of pc64. All present
  growth occurs right here.
• hmofet/unodos-3-legacy:
  the unique shipped, real-hardware-validated OS and its ports (tag
  legacy-pre-3.1). Frozen and archived, known-good.

• User manual: set up, desktop,
  apps, networking, home equipment and the developer information, for individuals who simply
  need to run it.
• docs/: structure, API reference, port spec, characteristic matrix,
  storage and boot-chain internals, and the plan and handoff paperwork behind
  every subsystem.
• CHANGELOG.md: the total historical past, 425+ builds and
  counting. Current model: v3.34.0.
• AGENTS.md and CONTRIBUTING.md: how
  work lands on this tree.

Copyright (c) 2026 Arin Bakht

This challenge is licensed below the Mozilla Public License 2.0
(MPL 2.0).

• Use: Free, together with commercially, with no royalty
• Inspection: The full supply is right here, and all the time will probably be
• Modification: Allowed, however if you happen to distribute a modified model of a file
  from this challenge, that file’s supply should be printed below MPL 2.0. You
  can’t take UnoDOS personal.
• Larger works: You could mix UnoDOS with proprietary code of your individual and
  license the mixed work nevertheless you want. Only the UnoDOS information keep MPL.
• Attribution: Required, retain the copyright discover and the license textual content

Third-party parts hold their very own licenses and are unaffected by the above
(MIT, Apache-2.0, BSD-3-Clause, public area, and CC BY for 2 fonts). Every
certainly one of them is listed in THIRD-PARTY.md.

UnoDOS 3, as a result of generally the previous methods are the very best methods.