DashOS
Modern inside, Amiga outside.
DashOS is a new operating system for ARM computers: the Raspberry Pi 4 and Pi 5 first, the Pi 3 too, and later other ARM computers that boot via UEFI. The kernel is a microkernel in Rust that only shares out the CPU, memory, messages and interrupts. Everything else is a process that talks to the others through channels and can only do what its keys allow.
It implements the AmigaOS 3.1 API natively on ARM. Amiga 68k programs run in a box: a process with the Emu68 JIT, which translates their code to ARM as it runs, while their system calls go to native libraries, without emulating a whole Amiga. Other programs have a Linux box: Arch Linux ARM in a virtual machine, with its windows on the desktop.
- In development. Everything done so far has been tested in the QEMU emulator; nothing on a real board yet.
- There is a desktop, an Amiga box and a Linux box, but no release you can download or install yet.
- Status as of 13 November 2026.
Key features
What it has and what it will have. "Done" works and is tested in the QEMU emulator; "in progress" is being built; "designed" is decided in its design but does not exist yet.
Amiga box
- DoneAmigaOS 3.x 68k programs with the Emu68 JIT and native libraries in Rust, without emulating a whole Amiga
- DoneNative exec, dos, utility, timer, intuition, gadtools and keymap; graphics and layers, partly
- DoneGadTools, BOOPSI and ReAction, with two looks: classic 3.x or DashOS style
- DoneDisk libraries and the user's own AmigaOS as a read-only layer (DashOS ships no ROM or Workbench)
- DoneNo fake Amiga disks: dos.library uses the DashOS file system, with its volumes and assigns
- DoneVirus guard: read-only SYS:, a trash can, boot block warnings and questions before touching watched files
- DoneThe box runs isolated in its own process, alongside the desktop, the Linux box and the rest of the system
- DoneInside, 68k tasks take turns as on an Amiga: Forbid() only stops the box, not the system
- In progressMUI 5 inside the box
- DesignedOne box per program, each on its own core: they share files, and a bridge carries ARexx, the clipboard and ports
- DesignedNetworking for Amiga programs (bsdsocket.library) and imitated chips for games and demos
Linux box
- DoneArch Linux ARM in its own virtual machine, with several cores
- DoneIts Wayland programs on the DashOS desktop: terminal, GTK 4 and Firefox, with clipboard
- Done2D graphics through virtio-gpu
- DoneNetworking with a firewall: Internet yes, the home network no, and the mail port closed
- Designed3D graphics and Vulkan
Desktop
- DoneIts own Wayland compositor, with several monitors
- DoneBar with workspaces, launcher and on-screen notices
- DoneQuick panel and control centre: settings, permissions, security, disks and appearance
- DoneFile manager with a sidebar, tabs, trash and drag and drop
- DoneMaterial 3 with colours taken from the wallpaper
- DesignedBuilt-in resource monitor
Stability and security
- DoneMicrokernel in Rust: it only shares out the CPU, memory, messages and interrupts
- DoneCapabilities (keys): a new program can do nothing except what it is given
- DoneDrivers and services outside the kernel, as isolated processes
- DoneFour hardening phases, each with an independent audit and hostile tests
- DoneIf an Amiga program crashes, its box goes down, not the system
Users
- DoneLogin and lock screen with a passphrase
- In progressFast user switching
- DoneAn encrypted volume for each user
- DonePer-program permissions, asked the first time, and a security log
- DoneAdministrator with no superuser, and memory quotas
Files, network and sound
- DoneDashFS, based on RedoxFS: case-insensitive names, Amiga comment and protection bits
- DoneDisk snapshots and a tool that checks and repairs the disk
- DoneIts own TCP/IP stack: DHCP and outgoing TCP connections
- In progressDNS for programs, UDP, servers and IPv6
- DoneSound service with mixing; native audio.device for the Amiga box
Hardware and boot
- DoneUEFI boot with a device tree or ACPI, on QEMU
- DoneUSB keyboard, mouse and tablet, NVMe disk and MSI-X interrupts
- In progressImages for the Raspberry Pi 4 and Pi 5, not yet tested on a real board
- DesignedOther ARM computers that boot via UEFI: boards and laptops
Programming and open
- DoneDash programs compiled for 68k run in the Amiga box
- DoneDash for AArch64 builds native DashOS programs; no GUI yet
- DoneIts own UI engine for native programs, with MUI's model and drawn in Material 3
- DesignedIts MUI, ReAction and GadTools faces, to write native programs with those APIs
- DoneOpen source under the MPL-2.0 licence, with its design and audits published
What the boxes are
DashOS has its own programs, native to ARM. Programs from other systems live in boxes. A box is an isolated DashOS process that acts as a home for those programs: it gives them what they expect to find on their own system and, underneath, translates it into DashOS services.
The Amiga box runs AmigaOS 3.x 68k programs. The Emu68 JIT translates their code to ARM as it runs, and their system calls (exec, dos, intuition, gadtools...) go to native DashOS libraries written in Rust. No whole Amiga is emulated: their windows are desktop windows.
The Linux box is a virtual machine with Arch Linux ARM. Its programs, such as Firefox or GTK apps, appear on the DashOS desktop like any other, with clipboard, and its network goes through a firewall.
Living in a box has two advantages. If a program from another system crashes, its box goes down, not DashOS. And the box can only do what its keys allow: see its user's files, open windows, use the network. Every window carries a badge with its box, 68K or LINUX, so you know where it comes from. Later there will also be a PowerPC box for WarpOS, MorphOS and AmigaOS 4 programs.
Amiga programs and CPU cores
Amiga programs were written for a computer with a single CPU. They share memory without locks and assume that, while they have their turn or have called Forbid(), nobody else touches anything. If two ran at once on two cores, they would trample each other's data.
So inside the Amiga box, 68k tasks take turns as on a real Amiga. But the box is just another DashOS process: it runs isolated and at the same time as the desktop, the Linux box, the file system, sound and networking, which run on the other cores. Its Forbid() only stops the box, not the system.
The next step, already designed, is one box per program, each on its own core, so that, for example, LightWave and Tachyon really run at the same time and, if one hangs, the other carries on. They do not share memory, but they do share files: the box has no fake Amiga disks, its dos.library uses the DashOS file system, with the same volumes and assigns for everyone. A bridge service will carry ARexx, the clipboard and named ports between them.
Today there is a single Amiga box. Several boxes and their bridge are designed, not built yet.
Screenshots
In the QEMU emulator, on 13 November 2026. Click one to see it full size.
The system at work
Pick a situation and watch how the information travels. Every message between processes goes through the kernel: that is why the blue routes go down to "Keys and channels" and back up. Parts with a dotted border are designed but do not exist yet.
Step 1 of 6The key arrives as an interrupt from the USB controller.
- Message on a channel (goes through the kernel)
- Interrupt
- DMA: the device reads or writes memory, without the CPU
- Call inside the same process
- Refused
The layers and their progress
Status as of 13 November 2026. Each part, in its layer and coloured by how much of it is done. Click one to see what it is, how far along it is and what it still needs.
49%average across all components
22components done
33in progress
15designed, not started
- Done (80% or more)
- In progress
- Designed, not started
- GPL zone (separate process)
ProgramsNative, in Rust, C and Dash
channels with badged keys: Wayland, files, sound
BoxesPrograms from other systems
the libraries in each box talk to the services
ServicesProcesses in EL0, one per job
kernel calls (numbered up to 51): channels, memory, processes, threads, time, power off
KernelMicrokernel in Rust (EL1)
registers, DMA and interrupts, through device keys
HardwarePi 3, Pi 4, Pi 5 and QEMU
Click a part to see what it is, how far along it is and what it still needs.
Progress by component
The percentage is what is done and tested against what is planned in its design and its work log. The "How it is counted" column says where each figure comes from; "judgement" marks the ones without counted steps.
| Component | Done | How it is counted | What is missing |
|---|---|---|---|
| Programs | |||
| Kit: engine and Material 3 The interface engine with the MUI model, drawn in Material 3, in Rust | 100% | 7 of 7 steps (KIT_LOOP) | nothing in the engine; the three faces below and the five agreed themes are missing (today, light and dark) |
| Kit: MUI face The MUI API for native programs, the main one: Dash's 110 MUI builtins and .dashui files. It looks Material 3 like everything else (S11) | 0% | no steps written (S11) | everything |
| Kit: ReAction face The ReAction API (window.class, layout.gadget...) on the same engine, for native programs. The Amiga box already has its own ReAction for 68k ones (S11) | 0% | no steps written (S11) | everything |
| Kit: GadTools face The GadTools API on the same engine, for native programs. The Amiga box already has its own GadTools for 68k ones (S11) | 0% | no steps written (S11) | everything |
| Dash for AArch64 The Dash compiler builds native DashOS programs | 100% | 8 of 8 phases (Dash's AARCH64_LOOP) | coverage on ARM: about 104 of 315 tests, the rest need AmigaOS; no graphical interface until the kit's MUI face |
| Dash 68k-to-native bridges Box libraries written in Dash | 0% | no work yet (PLAN.md) | everything |
| Desktop Workbench, bar, launcher, notifications, workspaces, tiling and multiple monitors (S10) | 62% | judgement: 7.5 of 12 sections of S10 (workspaces, Workbench, bar, launcher, notifications, multiple monitors, Material look and half of customisation) | tiling and per-screen layout, Commodities, ARexx, themes |
| DMS-style desktop Floating bar with pills, workspaces, centred launcher, control centre and volume OSD, with ideas from DMS (S27) | 29% | 2 of 7 waves (S27) | tabbed notifications and calendar, niri columns, full launcher, lock screen and dock, animations |
| Control centre Settings with a sidebar, quick panel with a power menu and appearance with the wallpaper colours (S10c) | 50% | 3 of 6 phases (C1 to C3 of S10c) | sound, displays and input (C4); network, Bluetooth and power (C5); add-ons (C6) |
| File manager Like Nautilus: sidebar, breadcrumbs, grid and list, tabs, bin, copy, move and drag | 80% | judgement: done and tested in QEMU; what is missing are extras listed in its log | open with another program, viewers, dragging to other programs, the new icons, the Linux box in the sidebar |
| System monitor The native Trasfondo: panel on the wallpaper, indicators on the bar and a process monitor in the control centre | 0% | judgement: under way since 13 November, nothing merged yet | everything not merged yet: the panel, the indicators, the monitor and the kernel call with per-process CPU use |
| Third-party desktops Bars and panels as Wayland clients with extra powers (S10b) | 30% | 3 of 10 phases (E1 and E2; half of E6 and half of E8) | E3, E3b (tiling and floating), E4, E5, E7, E9 and the rest of E6 and E8 |
| Boxes | |||
| Emu68 JIT Translates 68k code to ARM on the fly | 80% | judgement: 4 of 5 (native call, little-endian mode, inside a DashOS process and outside the 68k's 4 GB) | the bug that brings the box down when MUI 5 loads |
| exec Amiga tasks, signals, ports, owned memory, semaphores and devices, native | 75% | judgement: programs from m68k-amigaos-gcc and from Dash run, with the same output as in FS-UAE | several 68k tasks at once, Supervisor() and the Enforcer that warns and carries on |
| dos.library Amiga files and processes on top of the files service | 70% | judgement: reads and writes, read-only SYS:, assigns, LoadSeg, GetDeviceProc and the file guard | handler processes, CreateNewProc (texteditor.gadget needs it), Ctrl-C from a console |
| intuition and GadTools Amiga windows as compositor windows; the 12 GadTools gadgets, menus and EasyRequest, with the original look or the DashOS one | 80% | judgement: the test programs and the Dash ones open, draw and get clicks; windows at 2x and 3x | asl.library, the zoom gadget, menus outside the window, the AOS4, MOS and Magic WB themes |
| graphics and layers Amiga drawing and layers, native | 40% | judgement: graphics half done; native layers with locks and regions, without creating or moving layers | clipping to the layer's region, creating and moving layers, the hooks MUI uses |
| utility, timer and keymap Small Amiga libraries, native: utilities, timer.device and the keymap | 90% | judgement: done and tested | keymap only has the US layout; FindNamedObject and AllocNamedObjectA from utility |
| BOOPSI and ReAction Intuition's object classes and the ReAction classes of 3.2, native, with both looks | 75% | judgement: its test passes all 43 checks, the same as in FS-UAE with 3.2; Dash's ReAction examples run | the chooser menu, listbrowser columns, getfile (no asl), pages, Tab focus |
| Native MUI classes They replace the 68k ones in the box, so those programs also come out in Material 3 (S11) | 0% | no steps written (S11, "later on") | everything |
| 68k MUI The user's own MUI 5, in the JIT; it looks as on the Amiga, with an MUI configuration close to Material 3 (S11) | 20% | judgement: muimaster loads, but its start-up brings the box down because of a JIT bug | fixing the JIT (in progress), the layers hooks and 68k memory sized per program (decided: a cap in Settings, 256 MB by default; 4 MB today) |
| Disk libraries and the user's AmigaOS ramlib loads from LIBS: and Classes: whatever is not native; the user's AmigaOS sits as a layer, behind the native code | 75% | 3 of 4 steps (Amiga box log); from an AmigaOS 3.2, 8 of 16 libraries open, the hardware ones fail cleanly | step 4 (Tachyon 68k, which needs MUI and 30-40 MB); mounting an HDF (only a folder today); native icon, workbench and asl; mathieeesingbas and mathffp |
| audio.device (Paula) Paula's 4 channels as streams of the sound service | 50% | 1 of 2 (P1 done, also on virt) | hooking it up to 68k programs (P3), now possible with the box, and comparing it with FS-UAE |
| AHI The sound API of modern Amigas, native | 50% | 1 of 2 (P2, on the PC only) | P3; testing it on virt |
| Amiga chips Copper, Blitter, Denise and Paula imitated for games and demos (S18) | 0% | 0 of 7 phases | everything |
| bsdsocket.library Networking for Amiga programs: the AmiTCP and Roadshow interface on top of the DashOS network service | 0% | no code: it comes after the disk libraries (the user's decision) | everything; DNS, UDP and listening in the DashOS network come first |
| Amiga screens Workbench, public, custom and cloned screens as DashOS screens (S23) | 14% | 1 of 7 phases (P1: Workbench windows are compositor windows) | public, custom and cloned screens, dragging them and menus on the bar (P2 to P7) |
| Amiga virus guard Signature-free layers against Amiga malware: read-only SYS:, guarded files that ask first, a bin, clean memory and the box out of the 68k's reach (S28) | 85% | judgement: 6 of 7 layers in S28; seven lab viruses achieve nothing | snapshot and quota for the box's drawer, an always-on watchdog, several tasks |
| PowerPC box AmigaOS 4 and MorphOS programs (S17) | 17% | 1 of 6 phases (by size, 8 %) | F2 to F5; from F1, fres, frsqrte and FPU exceptions |
| Linux box Its own virtual machine with Arch Linux ARM and several vCPUs; its Wayland programs show up on the desktop (S7) | 60% | judgement: 9 of 15 items in S7 (hypervisor, disk, network, console, vsock, 2D display, windows, clipboard and Arch); foot, GTK 4 and Firefox open | virtio-fs and a shared Home:, XWayland, its programs in the launcher, memory balloon, starting as a service; testing it on the Pi |
| Linux box GPU virtio-gpu 2D now; for 3D and Vulkan, the Pi 4's V3D brokered by DashOS (S25) | 50% | 2 of 4 steps (S25: virtio-gpu 2D and the shadow table, tested on the PC) | the real V3D on a Pi 4, with 3D and Vulkan; then, the native context |
| Linux drivers (LKL) Linux as a library for Wi-Fi and the odd hardware (S12b) | 17% | 1 of 6 phases (L0: threads are done) | L1 to L5: LKL, virtio network, the Pi's Wi-Fi, Bluetooth and amissl |
| Services | |||
| inicio Starts the services and hands out their keys | 60% | judgement: keys, groups and channels; it watches and restarts services (R12); people's programs are now launched by sesiones | real identity cards (provisional today), telling clients their service is back, declarative services (S14) |
| Console The system log over the serial port | 100% | 1 of 1 task | an interactive shell is not planned yet |
| Files (DashFS) DashFS, derived from RedoxFS: case-insensitive folders, Amiga bits and comment, snapshots and checking; encrypted volumes | 91% | 10 of 11 tasks (ARCHIVOS_LOOP) | FS11: looking after the SD card (TRIM and the partition table are done) |
| Files: performance The improvements from the report: fewer round trips, no copies, lent cache, several commands at once | 91% | 15.5 of 17 items (A1 to A16; A14 without the SD card) | A17 (minor items) and the SD card driver from A14 |
| Files: permissions Owner, group and mode, roots per program, handing over files, administration | 90% | judgement: tested by the hostile client on virt; handing over, with the file picker | extra groups |
| Encrypted volumes One volume per user, with their password; it opens at login | 100% | 5 of 5 steps (ARCHIVOS_LOOP) | deciding whether there is a recovery key by default; measuring it on the Pi |
| ADF and HDF images Amiga floppies and hard disks mounted as volumes (S20) | 14% | 1 of 7 phases (read-only ADF, in its own process) | writing ADF, HDF, RAD:, SFS and PFS3 |
| NVMe disk NVMe driver and disk service with a ring | 80% | 4 of 5 steps | multiple queues |
| SD card The Pi's EMMC2 driver | 20% | judgement: only reads two sectors, no DMA | writing, DMA, disk service, real board |
| USB DWC2 The Pi's USB: keyboard and mouse through a hub | 67% | judgement: 2 of 3 | USB disk; testing it on the board |
| USB xHCI USB over PCIe: QEMU, laptops, the Pi 4's VL805 and the Pi 5's RP1. Boot keyboards and mice, and tablets (absolute pointer, as in virtual machines) | 78% | 7 of 9 steps | hot plugging, USB 3, isochronous transfers; the Pi 5's two xHCIs, written but untested on a board |
| Network: service and TCP/IP stack smoltcp in its own process: IPv4, IPv6, DHCP and mDNS (S13) | 43% | judgement: 3 of 7 (IPv4, DHCP and outgoing TCP) | IPv6, mDNS, UDP, listening; restarting it without losing the card; SACK if measuring shows it is needed (S12b) |
| Network: native and POSIX sockets The DashOS network API and the usual sockets through relibc (S7, S13) | 30% | judgement: the native API already works for outgoing TCP | UDP, listening and POSIX sockets through relibc |
| Network: TLS rustls for everyone: ChaCha20 on the Pi 3 and 4, AES on the Pi 5 (S13, S21) | 0% | no code | everything |
| Network: names (DNS) Name service with a cache and optional encrypted DNS (S13) | 0% | no code (DHCP already gives the name server) | everything |
| Network: firewall and permissions Closed to incoming traffic; going out and listening are per-app permissions (S6b, S13) | 35% | judgement: the Linux box firewall (Internet yes, local network no, port 25 closed) and the read-only network status | per-app permissions from sesiones, red-local and red-escuchar, Prefs/Red |
| Network: wired drivers virtio-net (QEMU), GENET (Pi 4), the RP1 one (Pi 5) and the Pi 3's USB one (S12) | 25% | 1 of 4 (virtio-net, on QEMU) | GENET (Pi 4), RP1 (Pi 5) and the Pi 3's USB one |
| Network: Wi-Fi Through LKL, with a service that keeps networks and passwords (S12b, S13) | 0% | no code | everything; LKL comes first (threads are done) |
| Sound Mixing service in the deadline class (S19) | 24% | 1.7 of 7 phases | PWM, HDMI, USB Audio, microphone |
| Studio sound Graph, MIDI, chips as instruments, CLAP and a JACK-compatible API (S19b) | 0% | 0 of 11 phases | everything |
| Wayland compositor Puts the windows together; speaks Wayland over channels. It handles native windows, Amiga box windows and Linux box windows | 94% | 15 of 16 steps (W1 to W8 and G0 to G6) | G7: HVS planes, on the Pi |
| GPU, HVS and HDMI Hardware graphics (S9, S21) | 33% | 1 of 3 phases (the firmware framebuffer) | HVS and V3D written but untested; HDMI and Mesa missing |
| Mailbox and firmware framebuffer Talks to the VideoCore; the Pi's framebuffer and the UEFI one | 100% | 4 of 4 tasks | testing it on a real Pi |
| Users and permissions Accounts, sessions, login and lock screen, per-app permissions, administrator, security log and fast user switching (S6b) | 93% | 6.5 of 7 phases (U0 to U5; of U6, everything but half of fast user switching) | steps 3 and 4 of fast user switching, permissions declared in the package (S8), account Prefs |
| Packages Paq, signatures, A/B updates (S8) | 0% | no code | everything |
| Boot and declarative services Service manager, watchdog, power off and restart, A/B (S14) | 15% | judgement: the in-memory log, watching and restarting (in inicio) and power off and restart | the declarative manager, the servicio command, A/B and tryboot |
| Suspend and hibernate Sleeping and waking without failures: drivers are restarted on wake-up (S22) | 0% | 0 of 5 phases (Z1 to Z5) | everything; it depends on the watchdog, K7 and guardian |
| Kernel | |||
| Boot and MMU Boots on QEMU raspi4b, raspi3b and virt through UEFI | 90% | 18 of 20 steps | KASLR; optional USB and NVMe from U6 |
| Scheduler Fair class, deadline class, four cores | 73% | 9.5 of 13 steps (MULTITAREA_LOOP) | direct handoff, time lending, focus weights |
| Memory Address spaces with ASIDs, W^X, shared objects, DMA | 64% | judgement: 9 of 14 items in S3 (counting views of another's memory, call 50) | copy-on-write, demand paging, large objects |
| Keys and channels Capabilities with rights and badges, messages carrying keys | 80% | 4 of 5 tasks (K7, death notice and read timeout, done) | call and reply with direct handoff (K6), waiting for measurements on the Pi |
| Groups and quotas Memory budget per process group | 95% | judgement: C42, the root quota and the real cost of each process (R11) | charging the group for the floating-point state of each Linux box vCPU |
| Interrupts and timers GIC v2 and v3, MSI-X, fine-grained timers | 90% | judgement: almost all done | moving the GIC out of the peripheral window; testing on a board |
| Secure kernel No panics, everything charged, audits (S16) | 67% | 4 of 6 phases | fuzzing, Kani, Miri, Spectre; RNG200, KASLR |
| User threads Several threads per process, with futex-style waiting (calls 40 to 44) | 85% | judgement: done and tested on raspi4b and virt, with its hostile test | per-thread priority and affinity; threads in the Amiga box and in Dash; measuring on the Pi |
| Review R1 to R19 Speed, security and stability fixes from the report | 95% | 18 of 19 steps (17 done; R18 and R19 halfway) | from R18, all of K1 and K5; from R19, the rest of fast user switching; from R10, RNG200 and testing on a board |
| Hardware | |||
| Booting on a real board A real Pi 4, Pi 5 or Pi 3 | 0% | no boot on a board recorded yet | everything: the Pi 4 image and the Pi 5 card are built, but untested; tryboot, PCIe, network, HVS and HDMI |
| Other ARM computers CM5, Snapdragon laptops and Macs (S24) | 20% | 1 of 5 steps in S24 (booting with ACPI, on QEMU) | everything on real machines; U7, the JIT without big-endian, works in the test bench but not in the box yet |
Notes
- Nothing has been tested on a real board yet. The Pi 4 and Pi 5 images are built, but the HVS, V3D, PCIe, EMMC2, on-board USB and power-off code is written code, not working code.
- The roadmap towards DashOS 0.1 (S15) is at about 65 %, by judgement: H1 to H4 done; H5 at 60 % (MUI is missing); H7 at 70 % (the kit faces are missing); H6 and H8 at zero. Outside 0.1, the Linux box (H9) already opens Firefox.
- Figures marked "judgement" have no counted steps in their design. The Dash figure comes from its work log, without running its tests again.
- The Amiga box loads disk libraries and uses the AmigaOS the user provides as a layer (DashOS ships no ROM or Workbench). MUI 5 still brings the box down because of a JIT bug, being worked on.
- Count made on 13 November 2026 from the project's work logs (docs/*_LOOP.md and docs/bitacoras/) and its designs, on the revision branch.
Dash, for DashOS too
Programs written in Dash, FreeMEM's language for the Amiga, already run in the DashOS Amiga box, and Dash already builds native ARM programs, without a GUI yet. The idea is that the same Dash program works on AmigaOS 3.x (68k) and on DashOS.
Meet Dash