x86-64 · AArch64 · Raspberry Pi 4 & 5 · GPL-3.0
SIEOS is a small, fast operating system in C. It has its own file system, its own C compiler, a desktop laid out as BeOS's was, its own network stack with TLS 1.3, and an AI assistant that runs a language model on the machine. All the code is new.
Work in progress. This is the new SIEOS, rebuilt as a microkernel. It is not stable yet.
How it works
The kernel only manages memory, threads on every CPU, time, and messages between programs. It delivers hardware interrupts as messages too. The disk driver, the file system, the console, the network and the desktop are ordinary programs: servers.
programs sh fetch sia svc hello bench ... │ messages, stamped with the sender's identity servers init con vblk fs auth login atlas netd vnet siad gpiod │ kernel memory, threads, scheduler, messages, quotas + one architecture: x86-64 or AArch64 │ hardware CPUs, RAM, disk, screen, keyboard, network card, serial port
initthe supervisor: starts and restarts every serverconthe console: serial port, keyboard, mousevblkthe disk driver: virtio, or the Pi's SD cardfsthe file server (SieFS); it checks permissionslogin auththe login; the accounts server, on demandatlasthe desktopvnet netdthe network card's driver; TCP/IP, DHCP, DNS, on demandsiadthe assistant, on demandgpiodthe Pi's GPIO pins (simulated elsewhere), on demandThe desktop
Windows with title tabs, the Deskbar, four workspaces and the sia strip, in a day or a night palette. It is one process, and it draws nothing when nothing happens.
A tab as wide as the title, with the app's icon. Drag it to move, double-click to minimize; zoom, resize by any edge. Only the focused window's tab is amber, and it casts the deepest shadow. A window opened or minimized flies to its row on the Deskbar as a ghost of light.
The menu, sia's state, the clock, and the apps, each with its pixel icon: Terminal, sia, Files, Text editor, Pins, Settings. A lit dot marks a running one.
Four of them, each cell a small map of its windows. Ctrl+1 to 4 switch; Send to workspace moves a window.
Ctrl+Space opens a command palette: the apps at once, then the files that match what you type, or a question for sia.
The look is frosted glass: a navy desk lit by soft blue glows, and glass for the Deskbar, the sia strip, menus and windows that shows what is behind it, blurred. One amber accent. By day the panes are light; at night the frost is smoke-tinted and the desk darker, by hand or on its own from 19:00 to 7:00. Titles, menus and buttons are in DejaVu Sans, terminals and code in its mono. Settings, a sidebar of sections with a card for each, draws everything from 50% to 400%, sharp at every size, with native fonts at 100%. It also sets the screen size (it goes back by itself after 15 s unless you keep it), the mouse, the sound, the network and sia's model. Super+L locks the screen; the session goes on behind it.
The same desktop runs on Linux too: atlas_wm is a Wayland compositor with the tabs, the Deskbar, the workspaces and the glass, for your Wayland and X11 apps. Read about Atlas on Linux, or get it from GitHub.
The assistant
Type sia QUESTION, or just sia for a conversation, or press
Ctrl+Space then Tab on the desktop. sia runs a language model on the machine with SIEOS's
own engine, or uses any OpenAI-compatible service.
sdot on AArch64.sia remember "...".alice@sieos:/home/alice$ sia list 1 6 turns ~1.2k tokens how do I make a project? 2 2 turns ~0.4k tokens what is SieFS? alice@sieos:/home/alice$ sia resume 2 alice@sieos:/home/alice$ sia memory 1 my name is Alice 2 I prefer short answers alice@sieos:/home/alice$ su root root@sieos:/home/alice# sia config backend=remote root@sieos:/home/alice# sia config url=https://api.example.com/v1 root@sieos:/home/alice# sia config api_key=YOUR_KEY kept in a root-only file root@sieos:/home/alice#
The Raspberry Pi's pins
One server, gpiod, gives every program the pins of the Pi's 40-pin header.
Use it from the shell with gpio, from C with gpio.h, or from the
desktop's Pins window. On a PC it simulates 28 pins, so programs and tests
run the same everywhere.
busy and is refused.alice@sieos:/home/alice$ gpio out 17 1 # BCM 17, header pin 11: high alice@sieos:/home/alice$ gpio get 17 1 alice@sieos:/home/alice$ gpio in 27 up # an input with a pull-up alice@sieos:/home/alice$ gpio blink 17 250 # every 250 ms, played by the server alice@sieos:/home/alice$ gpio stop alice@sieos:/home/alice$ gpio out 14 1 pin 14 is busy: the serial console uses it alice@sieos:/home/alice$ cc blink.c -o blink # the C below, built on SIEOS alice@sieos:/home/alice$ ./blink alice@sieos:/home/alice$
From C
#include "mk.h"
#include "gpio.h"
int main(void)
{
gpio_mode(17, GPIO_OUT, GPIO_PULL_NONE); /* an LED */
gpio_mode(27, GPIO_IN, GPIO_PULL_UP); /* a button */
while (gpio_read(27)) { /* until pressed */
gpio_write(17, 1); sleep_ms(200);
gpio_write(17, 0); sleep_ms(200);
}
/* two short blinks, a pause: 100 ms a step, looping */
uint32_t steps[] = { 1u << 17, 0, 1u << 17, 0, 0, 0 };
gpio_play(1u << 17, steps, 6, 100000, 1);
return 0;
}
The tracks are kept in ~/.pins. Up to 8 tracks and 64 steps, from 1 ms to 1 s a step. Every call returns -EBUSY, -EINVAL or -EPERM when it cannot be done. Tested in QEMU with simulated pins; not yet tried on a real board.
What is inside
A copy-on-write B+tree with two superblocks and a checksum in every pointer. A crash leaves the old state or the new one, never a mix. Small files live inside the tree, and attributes are indexed: find key=value.
Tested with 2,151 simulated power cuts.
One program that preprocesses, compiles, assembles and links C11 for x86-64 and AArch64, with its own optimizer, assemblers and linker. It builds all of SIEOS, compiles itself into byte-identical stages, and keeps NEON vectors in registers.
About 15 times faster than gcc at building SIEOS.
TCP/IP, DHCP, DNS, HTTP and TLS 1.3 with certificate checking, written for SIEOS. Drivers for virtio-net, the Pi 4's GENET and the Pi 5's RP1 Ethernet. fetch URL downloads a page.
Crypto checked against official test vectors.
Argon2id passwords, groups, and permissions enforced by the file server with the identity the kernel stamps on every message. passwd, su, useradd, userdel.
The first start creates root and your account.
Reads GGUF models and runs them on the CPU, with hand-written AVX2, AVX-VNNI and NEON kernels. It works on SIEOS and, for testing, on the development machine.
37 tokens/s for a 1.7B model on 4 CPUs.
sicc also runs inside SIEOS as /bin/cc, on x86-64 and on the Pis, with SIEOS's headers and library in /lib/sicc. As a user, in any folder: cc hello.c -o hello, then ./hello.
Its own small C library, on the file server.
More than 20 automatic test suites boot SIEOS in QEMU on both architectures. They cover the first start, logins, permissions, crash recovery, the network and the assistant, and they drive the desktop through QEMU's monitor: windows, Files, the editor, Settings and Pins.
Plus host tests for SieFS, sicc, the crypto and the engine.
SIEOS's own UEFI loader (11 KB) starts it from a USB key, and SIEOS uses the key as its disk: what you write stays on it. A USB stack with xHCI, hubs, disks, keyboards and mice.
Nothing on the PC's own disks is touched.
No serial cable? With a Pimoroni GFX HAT on a Pi 4, its small screen shows the console's log from the very start of the boot, and its touch buttons scroll back through it. The kernel keeps the last 32 KiB of the log.
An amber backlight, like the desktop's accent.
About 57,000 lines of C: kernel 5,500 · servers and programs 20,100 · sicc 19,200 · SieFS 2,300 · engine 2,400.
Where it runs
The same kernel, servers and programs on two architectures. Everything for AArch64 is built by sicc alone.
| x86-64 QEMU, KVM | AArch64 QEMU virt | Raspberry Pi 4 | Raspberry Pi 5 | |
|---|---|---|---|---|
| Kernel: SMP, tickless, threads, quotas | yes | yes | yes (QEMU) | card image, untested |
| SieFS disk | virtio | virtio | SD card | SD card, untested |
| Users, login, permissions | yes | yes | yes | untested |
| Desktop | yes | yes | yes (USB keyboard, mouse: written, untested) | untested |
| Network, TLS | yes | yes | written, untested | written, untested |
| GPIO | simulated | simulated | real pins (untested) | simulated |
| Assistant, local model | AVX2 / VNNI | NEON | NEON | NEON + sdot |
Compiler on SIEOS (cc) | yes | yes | yes | untested |
Try it
make to desktop.You need gcc, make, python3 and QEMU. KVM is used when /dev/kvm is writable.
A PC with UEFI, or QEMU. Write it to a USB key and start from it, with Secure Boot off.
DownloadWrite it to a USB key
sudo dd if=sieos-usb.img of=/dev/sdX bs=4M conv=fsync status=progress
Run it in QEMU
qemu-system-x86_64 -smp 4 -m 4G -accel kvm -cpu host -no-reboot \ -bios /usr/share/ovmf/OVMF.fd \ -drive if=none,id=k,file=sieos-usb.img,format=raw \ -device qemu-xhci -device usb-storage,drive=k,bootindex=0 -device usb-tablet \ -netdev user,id=n0 -device virtio-net-pci,netdev=n0,disable-modern=on,addr=5 \ -display gtk,zoom-to-fit=on -chardev stdio,id=s0,signal=off -serial chardev:s0
A Raspberry Pi 4. Write it to an SD card and start the Pi from it.
DownloadWrite it to an SD card
sudo dd if=sieos-pi4.img of=/dev/sdX bs=4M conv=fsync status=progress
Run it in QEMU
cp --sparse=always build-arm64/sieos-pi4.img build-arm64/pi4-run.img truncate -s 4G build-arm64/pi4-run.img qemu-system-aarch64 -M raspi4b -kernel build-arm64/kernel.bin \ -dtb .hosttools/rpi/bcm2711-rpi-4-b.dtb -initrd build-arm64/modules.img -no-reboot \ -drive file=build-arm64/pi4-run.img,if=sd,format=raw \ -display gtk,zoom-to-fit=on -chardev stdio,id=s0,signal=off -serial chardev:s0
Run it from a SIEOS build (make ARCH=arm64): QEMU also needs the kernel, the modules and the Pi's device tree, which the download does not include.
A Raspberry Pi 5. Not yet tried on a real board.
DownloadWrite it to an SD card
sudo dd if=sieos-pi5.img of=/dev/sdX bs=4M conv=fsync status=progress
Run it in QEMU
Not possible yet: QEMU does not emulate the Raspberry Pi 5 for now.
Writing an image erases the key or card: replace /dev/sdX with its device, and check it with lsblk first. Or build them yourself:
git clone https://github.com/omoulin/sieos cd sieos make make run # a window and this terminal make run SMP=8 MEM=8G # 8 CPUs, 8 GiB make run-nox # this terminal only
On a new disk, the welcome screen asks for root's password and creates your account.
make ARCH=arm64 run # QEMU virt make ARCH=arm64 run-pi4 # QEMU's Pi 4 make ARCH=arm64 PI=4 sdcard FIRMWARE=dir make ARCH=arm64 PI=5 sdcard FIRMWARE=dir # add SDMODEL=1 to put the 360M model on the card
The processor is emulated on a PC, so it is several times slower.
make usb # build/sieos-usb.img make run-usb # try it in QEMU first make usb-test # the automatic test
Write the image to a USB key (it erases the key) and start a UEFI PC from it, with Secure Boot off.
make model # copy the model to the disk make run sia hello
To leave, log in as root and type poweroff: it writes everything to the disk first.
No warranty
SIEOS is free software, provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and non-infringement. You use it entirely at your own risk. See the GNU General Public License v3, sections 15 and 16, for details.
Roadmap
gpio module, then CPython.make for SIEOS, now that cc runs there.Limits today
All the code is new: the kernel, the servers, the file system, the compiler, the network and the assistant's engine.
Enjoying SIEOS? Support its development.