EuroOS on real hardware: the "Metal" phase.

The decision: class standards, not a driver zoo

The reason operating systems carry tens of thousands of device drivers is history. Thirty years of unique hardware, each needing its own code. It is also, for a sovereign OS, thirty years of code you did not write and cannot fully audit.

We took the opposite bet, and it is only possible because the hardware market made it possible. Since roughly 2015 the industry consolidated onto a handful of class standards: NVMe for storage, xHCI for USB, AHCI for SATA, HID for input, HDA for audio, ACPI for platform control, UEFI for boot, TPM 2.0 for trust, PCIe/ECAM for the bus. Write one clean driver per standard and you cover almost every machine built in the last decade. A small, auditable driver base is not a compromise here. It is the sovereignty story: no thirty-year blob inheritance, just code we can read.

What we built

It boots and installs on a modern machine

A modern laptop is NVMe-only, so "usable on a laptop" starts with booting from NVMe. EuroOS now speaks PCIe ECAM (the memory-mapped config space modern firmware exposes), has from-scratch NVMe and AHCI/SATA class drivers, and, crucially, can install itself onto a blank NVMe or SATA disk and then boot standalone from it, with its root filesystem on that disk. The installer writes a real GPT, an EFI System Partition, and the EuroFS root; UEFI boots it back; the kernel mounts its root on the disk. Installing to a disk is also where you least want a bug: the code that picks a target disk will only ever write to a genuinely blank one, so the disk you booted from is structurally safe.

Networking on real NICs

Virtual machines get a virtual NIC; real machines get an Intel or Realtek chip. We wrote a driver for the Intel e1000/e1000e gigabit family (the NIC most desktops and many laptops carry), behind a small dispatch layer so the entire network stack, DHCP, DNS, TLS, the signed update channel, runs on it unchanged. For machines with no wired port, EuroOS also does USB ethernet (CDC-ECM), which is exactly what a USB-C dongle or phone tethering speaks. WiFi radios are the honest exception, and we will come back to them.

USB grown up, including audio

The first USB support handled a keyboard plugged straight into a port. Real machines and docks have hubs, and real keyboards and touchpads describe their own data format in a HID report descriptor instead of assuming a fixed layout. EuroOS now enumerates devices through hubs and parses those descriptors, so an arbitrary pointing device works, not just the ones we hardcoded. And it gained USB audio: streaming sound over USB uses isochronous transfers, a mode the USB controller handles differently from everything else, and the driver now does it, with the audio mixer routing a real stream to a USB DAC.

Power, and trust

Pressing a laptop's power button should be a clean shutdown, not a hard cut. EuroOS now handles the ACPI power-button event and performs an orderly power-off, and reads battery and AC-adapter status where the firmware exposes it. For the hardware root of trust, the TPM 2.0 driver now speaks both the discrete-chip interface (TIS) and the CRB interface that firmware TPMs use, Intel PTT and AMD fTPM, which is what most modern laptops actually present. The disk-encryption key is sealed to the measured boot state on either.

Printers and scanners: a protocol, not a driver

This is the part we are proudest of, because it is the future done right. When Microsoft removed third-party printer drivers, it was recognising that modern printers are network devices that speak an open protocol over HTTP. EuroOS takes that all the way: it prints over IPP Everywhere and scans over eSCL/AirScan, discovering the device with mDNS and talking to it over HTTP, with no printer or scanner driver at all. A protocol you can inspect, over a network you control, instead of a vendor binary in your kernel. If your printer or scanner supports the driverless standard, and almost everything sold since 2017 does, it just works.

How we keep it working: the hardware matrix

A driver that worked once is worthless; a driver that keeps working is a platform. So every one of these lives under a hardware matrix: the same release image is booted against seventeen different QEMU machine configurations, each mirroring a piece of real hardware, and each one has to reach the desktop and print the markers that prove its subsystem actually ran.

All seventeen pass. On top of that, 987 host tests cover the parsing and protocol logic, and a fuzzer throws hundreds of thousands of malformed inputs at every parser that touches an untrusted device. It earned its keep immediately: it found an integer overflow in the USB HID descriptor parser, a crafted device could have crashed the machine, and we fixed it before it could ever reach hardware.