| Version | 0.15.0 (phase 15) with a build number: images carry “0.15.0+N”, About and the desktop show “0.15.0 · Build N” – SYSTEM_VERSION from kernel/core/Version.swift, build number from tools/build-number |
| As of | 14 November 2026 |
| Architecture | AArch64 (ARMv8-A and newer), 64-bit only, UEFI + ACPI |
| Language | Embedded Swift (kernel, drivers, programs); C in the EFI loader and in the JavaScript cage; assembly only where necessary; the only third-party code: QuickJS-ng (JavaScript, only in the cage) |
| Purpose | Desktop system with its own programs (approx. 70 %) and robots as a strong part (approx. 30 %), direction since 13 Nov 2026. Guidelines: real time, security and speed without compromise, modern hardware only, no legacy code. |
| Manufacturer | SOFTrobots GbR · info@softrobots.de · www.softrobots.de |
docs/api/app-api-1.txt, libraries.txt; plus 136 for system programs only), counted 14 Nov 2026@Test) and device test targets in tools/test-all.sh, counted 14 Nov 2026Where measured: Unless noted otherwise, all measurements come from SOFTrobotsVM (our own macOS app using Virtualization.framework, 4 virtual CPUs, 8 GB RAM – our fixed standard for measurements since 15 Nov 2026)
on the host Apple M3 Pro (Mac15,7), 36 GB, macOS 27.0.1, version 0.15.0 (build 234), the image of the downloadable preview, Mac on power and on wired Ethernet, no other VM.
The Benchmark values are the median of three runs on 15 Nov 2026, each after a fresh start (docs/benchmarks/2026-11-15-m3pro-preview-4cpu-8gb-run1…3.csv); for “worst” the worst value of all runs is given. The same preview on a Mac mini M4 is in section 12.1. Values from other runs name their handbook section (e.g. “Hb. 3.93”); the measurements of 10 Nov 2026 on video are in
docs/benchmarks/video-playback.md, those of 11 Nov 2026 on network and encryption (downloads of 100 MB with make vm-net-bench, the Mac on wired Ethernet) in docs/benchmarks/network-download.md. QEMU times are emulation values and are not listed here; Mac values are marked as such.
Highlighted numbers are measurements. Design marks a statement that follows from how the system is built and is not measured; we have not measured comparisons with other systems and therefore give no factors – the only exception are the language models, measured next to llama.cpp (section 15.2).
1Pictures
2Status and limits
-M virt, for debugging and automated tests). There is no real hardware yet,
so no real motor drivers, USB cameras (UVC), SMMU, MTE or TPM either. All times are VM times on a Mac; on a robot compute module they may
turn out differently. Real hardware is phase 16; the robot API with ROS 2 semantics and Zenoh is phase 17.What works today (phases 0–15 complete, as of 14 Nov 2026)
- Own EFI loader, system copies A/B with updates and automatic fallback; downloadable preview with expiry date (10 Nov); 512 MiB system sides in new images and a build number (11 Nov)
- Kernel with SMP, tickless scheduler per core, EDF real time with admission control, reserved real-time core; interruptible system calls (F143)
- 16 KiB pages, W^X, PAN/PAC/BTI, stack canaries, guard pages
- Programs at EL0, signed only (Ed25519), 35 rights from the signed manifest
- Zero-copy IPC over shared rings, 14 numbered system calls (shape call 13 carries 24 modules)
- SOFTrobotsFS (copy-on-write, B+ trees, CRC-32C, AES-256-GCM per block, snapshots, time slider)
- SOFTrobotsDB in the file system: tables, indexes, queries, joins in WHERE and ORDER BY (9 Nov), SQL, series, flight recorder
- Device protection: Argon2id password, recovery key, screen lock
- Own network stack: IPv6 (SLAAC), IPv4 (DHCP with renewal), TCP with SACK (64 held ranges), CUBIC and 4 MiB receive rings for downloads (11 Nov), UDP, mDNS
- Own crypto library, TLS 1.3 as client and server (with KeyUpdate, 9 Nov; AES-256-GCM with SHA-384, AES/PMULL and NEON instructions in programs, 11 Nov), DNS over HTTPS, NTS time
- 2D desktop with windows, menus, dock, light/dark, scale 2; since 10 Nov: one open/save dialog for all programs, progress for all programs, memory window, window buttons and tabs in the dock
- Programs: Files, Web (with JavaScript in a cage, 13 Nov), Image (with an inspector for EXIF, GPS and colour profile, 14 Nov), Reader (PDF), Text, Console, Database, Benchmark, Activity, Monitor, Settings, Camera (detect, learn, record), Video (playback; Camera and Video split on 14 Nov), Sound, Ask (speech bubbles, images, saved conversations, 14 Nov), Develop, Server, file dialog
- 35 file formats and codecs with own code, including PDF with encryption and scans, VP9 (1080p on 3 cores), Opus, FLAC (section 9)
- Sound: output with a mixer in the kernel, microphone with an always-visible indicator (9 Nov)
- Crashes: the kernel writes reports, Monitor › Report steps through all kept reports (Older/Newer); the watchdog service (Buddy) reports every crash, also those before it started (11 Nov)
- Robots: emergency stop in the kernel, actuator service with safety limits, CAN FD service, simulated 6-axis arm
- Develop with its own language Reflex: projects as folders, checking on every key press, Run with preview, forms and stored lists, real-time proof in advance, “Save as Program” creates a signed ARM64 program (also for the real-time core)
- AI in the device: own inference for language models (Qwen2.5, Qwen3, Qwen3-VL with images, DeepSeek-R1-Distill, Qwen2.5-Coder 7B since 14 Nov) and for object detection, one AI service for all programs (section 15)
- Tests: 581 host test functions (Swift Testing) and 31 automated device test targets in QEMU/SOFTrobotsVM (
tools/test-all.sh), plusmake test-preview
Deliberately not included
POSIX or Linux compatibility, 32-bit, BIOS, SATA/IDE, Bluetooth, USB classes outside the allow list, multiple users, 3D graphics, UI languages other than English. Still open or later: kernel signature check in the loader, batched TRIM, QUIC/HTTP/2/HTTP/3, SMMU (DMA isolation of the driver services), MTE, TPM binding, GROUP BY over joined fields, file fields in the App API (section 8.5), AV1 (with hardware), Opus and MP3 recording.
Known open items (as of 14 Nov 2026)
- Downloads from Hetzner vary between 9 and 58 MB/s, also in runs with almost no packet loss, while curl on the Mac gets 80–96 MB/s from the same server. Cause not found yet; a packet trace on the Mac side is still to be done. For OVH (35–59 MB/s, almost no loss) the next limit is not known yet either.
- Network lost after about 50 minutes (F149): once, Web could no longer resolve names after about 50 minutes. DHCP renewal, new log lines and Buddy's rule 13 are built. A 75-minute soak test (11 Nov) passed 74 of 74 rounds; not seen again since. The cause is not proven.
- An update failed once (F155, “no room for the new copy”) and could not be reproduced. The message stood for three different failures; each now logs its own reason. In five more runs the failure did not come back.
- Memory copy 48.7 GB/s (Benchmark 14 Nov): measured, but not explained – the value is far above what earlier runs showed, and no change to copying is known. Read it with care until this is cleared up.
3Architecture overview
Hybrid kernel: Everything that has to be fast and trustworthy – scheduler, memory, IPC, file system, NVMe, network and crypto – runs in the kernel (EL1).
Risky parts such as USB and graphics run as isolated services at EL0. Programs talk to the kernel only through the system API; there is deliberately no POSIX or Linux layer.
The kernel is linked for the higher half (0xFFFFFFFF80000000) and loaded at 0x8000_0000; every section starts on a 16 KiB boundary and is mapped W^X.
4Programming languages
Counted with wc -l over the source tree (without build/, package caches and docs/), as of 14 Nov 2026. Lines including comments; third-party code is listed separately.
| Language | Lines | Share | Where |
|---|---|---|---|
| Swift (Embedded Swift and Swift for the Mac) | 173,785 | 91.3 % | kernel 35,813 · drivers 2,700 · runtime userland/ 56,556 · programs apps/ 54,617 · Mac tools 7,950 · host tests 16,075 |
| Shape language (.shape) | 2,267 | 1.2 % | shapes/ 2,171 (23 files) · program shapes in apps/ 96 |
| Python (tools only) | 3,217 | 1.7 % | model converter, training, test data, datasheet; never runs in the system |
| Shell (tools only) | 3,263 | 1.7 % | test scripts, QEMU helpers, preview package, VM measurement |
| Assembly (AArch64) | 3,204 | 1.7 % | kernel 1,374: entry.S 343, sysreg.S 383, crypto.S 283, context.S 261, vectors.S 104 · programs 1,830: infer/asm/kernels.S 1,198 (sdot, smmla for AI), tls/asm 439 (AES-GCM, ChaCha20), crt0.S 193 |
| C (own code) | 1,374 | 0.7 % | boot/loader.c 573 · JavaScript cage 801 (userland/jscage) |
| C headers (own) | 935 | 0.5 % | BootInfo, EFI, arch.h, userland/include |
| JavaScript | 1,458 | 0.8 % | apps/web/prelude.js: page mirror for scripts in the cage |
| Reflex (.reflex) | 756 | 0.4 % | templates, guide and programs for Develop |
| Total own code | 190,259 | 100 % | |
| Third-party code: QuickJS-ng (MIT) | 82,889 | – | third_party/quickjs-ng, 72,243 lines of C and 10,646 header lines; Web's JavaScript engine, runs only in the cage (six system calls). Not in the total. |
Embedded Swift
Kernel, drivers, services and programs. Toolchain swift.org 6.4.1 (via swiftly), target aarch64-none-none-elf.
In the kernel: no classes on hot paths (no ARC), no heap (-no-allocations), no async/await, -Osize.
Unsafe pointer and register access only in kernel/arch/ and drivers/. Hardware-independent code in kernel/lib/ also runs as ordinary Swift on the Mac (host tests).
Assembly – only where necessary
entry.S (entry, EL2→EL1, early page tables), vectors.S (exception vectors), context.S (context switch),
sysreg.S (system registers, Swift has no inline assembler) and crypto.S (AES/PMULL for the disk, SHA-256 with processor instructions – pure speed).
In programs: crt0.S, the sdot/smmla kernels for detection and language models, and AES-GCM/ChaCha20 for TLS.
C – documented exceptions
The EFI loader (boot/loader.c, PE/COFF), the cage around the JavaScript engine QuickJS-ng (userland/jscage; QuickJS-ng itself is third-party C code, MIT licence, decision of 13 Nov 2026) and headers that describe hardware and ABI structures (bootinfo.h, arch.h). The BootInfo structure is checked in C with _Static_assert and in Swift with a host test.
Own languages
.shape: one definition for API, kernel checking code, database tables, rings and network (tool shapec). Reflex: the scripting language of Develop, compiled in the system itself.
5Sizes
Kernel (build/kernel/kernel.elf, build of 14 Nov 2026, 20:56)
| Section | Bytes | Size | Contents |
|---|---|---|---|
| .text | 840,244 | 821 KiB | Machine code (R X, BTI-protected) |
| .rodata | 244,696 | 239 KiB | Constants, font masks of the start animation, embedded data (R) |
| .data | 184,161 | 180 KiB | initialised variables (R W, never X) |
| Loaded image (file part) | 1,269,101 | 1.21 MiB | what the loader reads from disk |
| .bss | 31,745,584 | 30.27 MiB | fixed tables in RAM (128 process slots, 256 threads, buffers, 4 TCP receive rings of 4 MiB each); takes no space in the file |
| .page_table_pool / .boot_tables / .stack | 2,293,760 | 2.19 MiB | Page table pool 2 MiB, early tables 64 KiB, boot stack 128 KiB |
| Debug information (.debug_*) | 6,102,998 | 5.82 MiB | for symbolication only; ELF file total 7,829,424 bytes |
EFI loader (build/boot/BOOTAA64.EFI, build of 12 Nov 2026): 17,408 bytes; 573 lines of C.
Disk image: 8 GiB (sparse); new images since 11 Nov 2026: EFI 64 MiB · SYSTEM_A 512 MiB · SYSTEM_B 512 MiB · DATA rest (in an 8 GB image 6.9 GiB; the system uses 54 MiB). Older images keep 2 GiB system sides (section 6.1). Measured with llvm-size.
Kernel building blocks
Lines counted (14 Nov 2026, Swift and assembly); the code share is an approximation (.text distributed in proportion to source lines, computed, not measured from the link map).
| Folder | Lines | ≈ Code | Contents |
|---|---|---|---|
kernel/core | 15,517 | ≈ 319 KiB | Kernel logic: scheduler, memory, processes, system calls, shapes, channels, file dialog, preview, microphone, sound, emergency stop |
kernel/fs (SOFTrobotsFS + DB) | 6,997 | ≈ 144 KiB | File system, database, joins, series, snapshots, sealing |
kernel/crypto | 5,106 | ≈ 105 KiB | SHA-2, HMAC/HKDF, AES-GCM, ChaCha20-Poly1305, X25519, Ed25519, ECDSA, RSA, X.509, TLS 1.3, DoH, NTS, Argon2id |
kernel/arch/aarch64 | 3,442 | ≈ 71 KiB | MMU, exceptions, interrupts, SMP, timer; Swift 2,068 + assembly 1,374 |
kernel/lib | 3,558 | ≈ 73 KiB | hardware-independent, tested on the Mac (file types, manifest, page tables …) |
drivers/ | 2,700 | ≈ 56 KiB | NVMe, virtio (gpu, console, net, fs, sound, rng …), GICv3, PCIe, PL011, Framebuffer |
kernel/net | 2,567 | ≈ 53 KiB | IPv6/IPv4, TCP (with 4 large receive rings), UDP, DHCP with renewal, DNS, mDNS |
| Total kernel + drivers | 39,887 | 821 KiB |
Programs and services (build/apps/*.elf, build of 14 Nov 2026)
Measured with llvm-size. “Code” is .text; “data” is constants and initialised variables, mostly the embedded UI fonts (around 0.85 MiB per program with a user interface). reflexrun and reflexrt are the templates for “Save as Program”; their ELF files contain empty code and data areas that Develop fills when building and cuts to the real size.
Program code is shared by all launches; only the writable data is copied per launch.
| Program | Kind | Code | Data | BSS (RAM) | ELF file |
|---|---|---|---|---|---|
| web | System | 1,225 KiB | 4,283 KiB | 2,036 KiB | 6,150 KiB |
| files | System | 834 KiB | 3,668 KiB | 1,575 KiB | 4,974 KiB |
| develop | System | 1,525 KiB | 1,966 KiB | 1,554 KiB | 4,314 KiB |
| image | System | 579 KiB | 3,036 KiB | 1,524 KiB | 4,005 KiB |
| reflexrun | System | 416 KiB | 920 KiB | 1,548 KiB | 3,817 KiB |
| benchmark | System | 1,170 KiB | 1,895 KiB | 2,668 KiB | 3,746 KiB |
| reader | System | 398 KiB | 2,970 KiB | 1,523 KiB | 3,691 KiB |
| display | Service | 655 KiB | 1,732 KiB | 1,634 KiB | 2,829 KiB |
| camera | System | 508 KiB | 1,545 KiB | 1,527 KiB | 2,324 KiB |
| reflexrt | System | 8 KiB | 1 KiB | 0 KiB | 2,117 KiB |
| about | System | 114 KiB | 1,598 KiB | 1,524 KiB | 1,906 KiB |
| server | System | 363 KiB | 1,101 KiB | 3,991 KiB | 1,753 KiB |
| video | System | 533 KiB | 900 KiB | 1,527 KiB | 1,720 KiB |
| ask | System | 328 KiB | 911 KiB | 1,525 KiB | 1,541 KiB |
| settings | System | 213 KiB | 902 KiB | 1,524 KiB | 1,343 KiB |
| ai | System | 367 KiB | 696 KiB | 1,256 KiB | 1,270 KiB |
| sound | System | 190 KiB | 850 KiB | 1,525 KiB | 1,237 KiB |
| database | System | 175 KiB | 855 KiB | 2,552 KiB | 1,209 KiB |
| devclaude | System | 152 KiB | 842 KiB | 1,765 KiB | 1,204 KiB |
| activity | System | 151 KiB | 856 KiB | 1,524 KiB | 1,203 KiB |
| console | System | 128 KiB | 849 KiB | 1,702 KiB | 1,132 KiB |
| chooser | System | 93 KiB | 845 KiB | 1,521 KiB | 1,104 KiB |
| webjs | System | 771 KiB | 109 KiB | 1,255 KiB | 1,097 KiB |
| monitor | System | 79 KiB | 838 KiB | 1,565 KiB | 1,058 KiB |
| text | System | 57 KiB | 845 KiB | 1,522 KiB | 1,056 KiB |
| modelget | System | 139 KiB | 182 KiB | 1,765 KiB | 522 KiB |
| timesync | Service | 102 KiB | 146 KiB | 1,769 KiB | 394 KiB |
| watchdog | System | 56 KiB | 64 KiB | 1,257 KiB | 266 KiB |
| usbinput | Service | 26 KiB | 30 KiB | 0 KiB | 159 KiB |
| actuators | Service | 24 KiB | 3 KiB | 1,255 KiB | 77 KiB |
| canbus | Service | 9 KiB | 0 KiB | 0 KiB | 54 KiB |
6Core components
6.1 Boot, EFI loader, updates A/B and fallback
How it works: The UEFI firmware starts \EFI\BOOT\BOOTAA64.EFI. The loader reads the boot record (512 bytes, two copies with sequence number and CRC-32C in the reserved FAT32 sectors 16/17),
chooses system copy A or B, loads KERNEL_A.ELF or KERNEL_B.ELF to its fixed physical address, collects the memory map, ACPI RSDP and GOP framebuffer in the BootInfo (128 bytes) and, after
ExitBootServices, jumps into the kernel. entry.S switches from EL2 to EL1 if necessary, builds early 16 KiB page tables, turns on the MMU and calls kernelMain.
- Fast: Measurements and self-tests run only after “Hello”; nothing on the boot path waits for the network.
make test-vmfails if “Hello” comes later than 1.0 s. - Updates: A signed package (
.srupdate, Ed25519, kernel + system volume) is written to the inactive copy and tried at the next start; if that start reaches “Hello”, the copy stays. - Fallback: If the new copy fails to reach “Hello” three times, the loader goes back to the old one on its own. A rolled-back start shows lines of text instead of the animation.
- Security: System volume read-only; packages with a wrong signature are rejected (
make test-update). Checking the kernel signature in the loader is prepared (loader and kernel are separate files) but not yet built. - Preview with expiry date (10 Nov 2026,
docs/decisions.md):make previewbuilds the product image without test programs, without development keys and without API keys, usingmkimage --expires(default 25 Feb 2027, file/expireson the read-only system volume). Every start writes the remaining days to the log; from the expiry day on no program starts, and the screen says where the new preview is (kernel/core/Preview.swift). The 8 GiB image is shipped compressed and unpacked sparsely at the first start (123 MB on disk after the first start). It is inside the app and is unpacked to~/Library/Application Support/SOFTrobots OS Preview/, so the app starts from anywhere (macOS starts downloaded apps from a random copy, F182). Signed with the Developer ID and notarised by Apple (build 234, 15 Nov 2026).make test-previewchecks both cases in QEMU. - Version and build number (11 Nov 2026, Hb. 3.141): the version stays the phase until 1.0 (0.15.0 = phase 15).
tools/build-numbercounts up by one in every build in which the kernel or a program changed, and is never reset. Images carry “0.15.0+N” (fits the boot record's 16 bytes); About and the desktop's SYSTEM card show “0.15.0 · Build N” (SystemStatus.versionShown). - Disk in new images (11 Nov 2026, Hb. 3.140): EFI 64 MiB · SYSTEM_A 512 MiB · SYSTEM_B 512 MiB · DATA the rest (the system uses 54 MiB). In an 8 GB image DATA has 6.9 GiB. Existing images keep their layout; an update's 512 MiB system volume fits both.
6.2 Scheduler
How it works: One scheduler per core (up to 8 CPUs, 64 kernel threads), tickless (ARM Generic Timer in one-shot mode) and fully preemptive. Three classes:
| Class | Method | Properties |
|---|---|---|
| Realtime | EDF with a budget per period and admission control | Period 100 µs … 1 s; utilisation per core at most 900 ‰; if a contract does not fit, the program does not start at all |
| Interactive | fixed priorities | Desktop, services, ordinary programs; priority inheritance in the volume lock and IPC |
| Background | Fair share by weights | Weights 2:1 give exactly 2.0 when measured |
- Load balancing: A busy core hands at most one waiting thread to an idle core every 10 ms (never the running one, never real-time threads, never the real-time core). The old core pushes, because only it can save the program's floating-point registers (lazy FP/SIMD).
- Real-time core: The last CPU takes real-time threads; other threads avoid it. With admitted real-time work it does not sleep (no
wfi), because waking a virtual CPU cost around 170 µs. - Watchdog: Checks the real-time programs every 50 ms and applies the reaction from the manifest:
log,stop,restartorstop-actuators. - Interrupts: GICv3 with priorities, short top halves, work in threads; MSI/MSI-X via the ITS.
6.3 Memory
- 16 KiB pages (the kernel requires the 16 KiB granule), 32 MiB blocks for large buffers, buddy allocator for physical pages, up to 16 GiB of managed RAM, 48-bit addresses.
- W^X everywhere: no executable data, no writable code – in the kernel and in every program. Direct map for the kernel, devices only via
MMU.map. - One address space per program (EL0): code from
0x1000_0000, heap above it, stack with guard page, channel pages, device and DMA windows only for driver services. - No kernel heap (
-no-allocations); programs in the real-time profile have no heap at all. - Commitments instead of swap:
memory =in the manifest (16–2048 MiB, default 256 MiB) is a commitment that is admitted at start and never taken away. Above it there is lending from free RAM. 256 MiB of system reserve (emergency stop, real time, services) are never lent. - Peak cushion: approx. 3 % of RAM (64 MiB … 1 GiB), available immediately on request for peaks, at most half of it per program, visible in Activity and on the desktop.
- Own paging area (stage 2): reclaimed lent pages go only into the area of that program (2 × commitment, at most 4 GiB), AES-GCM per page with a key for this run only. A program above its commitment gets slower – no other program does. Real-time programs are never paged out.
6.4 IPC – communication between programs
- Channel = one shared page with two message rings (single producer/single consumer, messages up to 256 bytes) between exactly two programs, found by name. The kernel never copies a message – it maps the page and wakes the other side.
- 64 channels in the system. In addition publications/subscriptions (16 slots), capture rings for series and the detection ring from Camera.
- System calls: 13 basic calls (0–12: exit, yield, sleep, wait, periodWait, memoryGrow, workerWake, workerExit, channelNotify, channelWait, deviceWait, surfaceNotify, inputReceive) that only wait, wake or end and should cost around 100 ns.
Everything that works with an object goes through shape call 13 (24 modules, 141 calls, 224 shapes and 30 enumerations in 23 files
shapes/*.shape, counted on 14 Nov 2026). Upper limit: 100 system calls. - Measured: message round trip between two programs on different cores 1.2–1.7 µs, on the same core 6–8 µs: then the processor switches programs twice for every message and sleeps through the timer. Which case happens is decided today by where the partner is placed when it starts (measured in six runs on 15 Nov 2026, failure log F184). If the other side is actively waiting, the wake-up call is skipped entirely (flag in the ring, F143). Target < 1 µs: reached in the median, missed in 2 of 4 runs (1.07 and 1.24 µs).
6.5 Security model
| Protection | Implementation |
|---|---|
| Signed programs only | Every program and its manifest are signed with Ed25519; the kernel does not start unsigned or modified programs (test programs unsigned, tampered). Updates are signed too. AI models are not programs: they stay in their standard formats (GGUF, ONNX) and are not signed; the reader checks every size against the file. |
| Capabilities | 32 rights (bits 0–31 of 64; new on 10 Nov: files.dialog, for chooser only) from the signed manifest, e.g. network.outgoing, network.incoming, files.own, safety.stop, device.can, device.microphone. Every call is checked. Without network.incoming no incoming connections; only Server may listen, and only on the ports in its manifest. |
| Own folder | With files.own, only /data/<name> exists for a program; . and .. do not exist. Real-time programs have no file access. |
| File dialog: choosing is allowing (10 Nov 2026) | A program asks with Dialog.open or Dialog.save; the dialog is shown by the system program chooser, not by the asking program. The kernel checks location, type and contents of the choice and grants access to exactly this file – without a file right in the manifest, up to 16 per program, as long as it runs; there is no “Recently used”.
Locations: the program's own folder, the shared folder /documents and, in SOFTrobotsVM, the Mac folder; never other programs' folders, the system or logs. Every request has a number and belongs to one program; up to 3 dialogs at the same time. Checked with make test-dialog (PASS after 8 s, Hb. 3.135). |
| Program identity | Every program has an identifier (id =, reverse domain) and a version in the signed manifest; the folder is bound to the identifier. Programs built in Develop are signed with this robot's key and run only here. |
| Device protection | Argon2id (64 MiB, 3 passes) on the password decrypts the random volume key; DATA is sealed with AES-256-GCM per block. The password is never stored. One-time recovery key (128 bits), screen lock, failed attempts cause a delay of 2–60 s. |
| Processor protection | W^X, PAN (the kernel does not read program memory by accident), PAC (return addresses signed), BTI (branch targets marked), stack canaries, guard pages – checked by make test-fault (6 cases). |
| Isolated drivers | USB and graphics run as EL0 services. Limit: Without an SMMU (Virtualization.framework has none), a driver service is isolated only on the CPU side; its device could access foreign memory via DMA. |
6.6 Network
- Own stack in Swift in the kernel: IPv6 first (SLAAC), IPv4 (DHCP), TCP with SACK, CUBIC and window scaling, UDP, DNS, mDNS (
<name>.localin the home network). Interrupts instead of polling; 64 TCP connections in the system. - TLS 1.3 only (X25519; AES-128-GCM, AES-256-GCM with SHA-384 since 11 Nov 2026, ChaCha20-Poly1305), as client and as server. Name resolution only via DNS over HTTPS, time via NTS (authenticated NTP).
- TLS in programs (11 Nov 2026): AES-128-GCM and AES-256-GCM are decrypted with the ARMv8 AES and PMULL instructions, checked against the software version at the first connection and offered first when the CPU has them (
system.inforeportsfeatures.aes, in the App APISystemStatus.hasAES). ChaCha20 runs four blocks at a time with NEON (userland/tls/asm). The kernel keeps the portable versions, since it uses no vector registers. - Server – the only gate in: only door 443 (everything behind the login) and door 80 (redirect), no public web server. The robot's own root authority (ECDSA P-256), access by invitation with a code and pairing of the device; 5 wrong passwords within 10 minutes block the address for 15 minutes. From outside via the home router's VPN.
- No configurable firewall needed: a port without a listener does not answer at all.
- Measured: TLS 1.3 handshake 66.4 ms, name resolution via DoH 70 ms (Benchmark 14 Nov); ping to the gateway 0.1 ms (boot log 8 Nov); downloads see below (11 Nov 2026).
- Downloads: a simulated sender in the host tests sends arbitrary valid pieces, 2 MB arrive exactly; loss, duplication and reordering are survived. Web resumes broken-off downloads with a range request (at most three times).
- Network diagnostics (F149, Hb. 3.136): DHCP renews the IPv4 address at half of the lease time; DNS queries without an answer are logged together with the router's state; Buddy barks when the internet cannot be reached (rule 13). A one-time network loss after about 50 minutes has not happened again; the cause is not proven (section 2).
Downloads measured (11 Nov 2026, docs/benchmarks/network-download.md, Hb. 3.140)
make vm-net-bench (program netbench): SOFTrobotsVM on the Apple M3 Pro downloads 100 MB over HTTP from a server on the Mac (no internet, no TLS – only virtio-net, TCP and the system calls) and over HTTPS from two speed-test servers on the internet; curl on the Mac fetches the same files just before. The Mac is on wired Ethernet; the internet line at the test bench has 934 Mbit/s (≈ 117 MB/s).
| Path (100 MB) | Measured | Remark |
|---|---|---|
| Own path: HTTP from the Mac, no internet, no TLS | 110–218 MB/s | around 190–200 MB/s on an idle Mac; the range follows the Mac's load |
| HTTPS from OVH | 35–59 MB/s | almost no packet loss; the next limit is not known yet |
| HTTPS from Hetzner | 9–58 MB/s | varies from run to run – open, under investigation |
| curl on the Mac, same servers (comparison) | 80–96 MB/s | shows what the line and the servers gave in the same minute |
- virtio-net driver: 256 receive buffers, one device notification per batch, frames copied as blocks.
- TCP: acknowledges every segment that arrives in order; a window update on reading goes out only when the peer last heard of less than half the ring; ring copies as blocks.
- Download receive rings 4 MiB (window scale 7): after 1 MiB received a connection gets one of the 4 large rings, otherwise 128 KiB.
- 64 held out-of-order ranges with SACK; SACK names the newest range first.
- Programs read up to 8 KiB per system call (
Network.Connection.receive(area:)); TLS keeps the decrypted record in place. - Log: when a download (over 4 MB) closes, the kernel writes “TCP: download of N MB: … segments, … beyond a gap, … again, … into a full ring”. From the Mac 0 segments came beyond a gap, from OVH 0–15, from Hetzner 26–1,547.
Encryption in a program (11 Nov 2026, netbench, 8 MiB each, two runs)
| Cipher | Measured | for reference: the same computation in Swift |
|---|---|---|
| ChaCha20 (NEON) | 1,657–1,735 MB/s | 373–376 MB/s |
| ChaCha20-Poly1305 (seal) | 703–719 MB/s | 287 MB/s |
| AES-256-GCM (AES/PMULL) | 4,594–4,896 MB/s | 46–49 MB/s |
The kernel keeps the portable versions: ChaCha20-Poly1305 76 MB/s in its self-test (no vector registers). All three are far above the line at the test bench (117 MB/s).
6.7 Graphics and display
- 2D only: GOP framebuffer or virtio-gpu 2D, drawing on the CPU. No 3D graphics, no full-screen effects (no dimming, no shadows).
- Window system as an EL0 service (
display): programs draw only into their own drawing surface; the service composites, redraws only changed areas, double-buffered. A frame counter per window prevents half-drawn frames. - 16 drawing surfaces in the system, 3 per program; titles come from the signed manifest so that no program can pose as another.
- Light and dark, scale 2 from 2400 × 1500. All decoders and encoders for pictures, documents, video and sound run in the program runtime (never in the kernel) – the complete list is in section 9.
- Window buttons (10 Nov 2026, Hb. 3.137): on the right of the title [Put away] and [×], always visible; the capsules for progress and memory sit next to them without a gap. The × turns red in three steps. No animation.
- Tabs in the dock: A put-away window sticks out of its program's tile as a small amber window (at most 3 stacked); if no window of the program is visible, the dot under the tile becomes a ring. New in the manifest:
dock = no– the program never appears in the dock (used by chooser). - Progress for all programs (Hb. 3.136): one call
surface.progress(…)(userland/ui/Progress.swift); the system draws a capsule in the window title (bar, percent, time left) and a thin bar on the dock tile. Cancelling only if the program offers it – as a bit in the window's ring page, which even a program in a loop sees. Buddy reports a task of at least 3 s that ends while its window is not in front. First user: Web. - Memory window (Hb. 3.136): A click on the memory display in the title shows the history of the last 10 minutes (one point every 2 s, always recorded for every program), heap peak, guarantee, use of the cushion and a suggestion for
memory =(apps/display/MemoryCard.swift). - Pictures in Web (11 Nov 2026, Hb. 3.141): Web draws pictures at the screen's full resolution (scale 2 on Retina), picks the
srcsetcandidate for the screen (density or width descriptors) and enlarges bilinearly when needed. Boxes withoverflow: autoorscrollkeep the height of their content, because Web cannot scroll inside a box;overflow: hiddenreally clips. - Uniform File menu (Hb. 3.135): programs with files get it from the system (
surface.addFileMenu): New ⌘N, Open… ⌘O, Save ⌘S, Save As… ⇧⌘S, Export… ⌘E, Show in Files; menu bar “Program · File · Edit · …”.
6.8 USB with an allow list
XHCI driver as the EL0 service usbinput. Concept: allowed are HID, CDC-ACM (serial), UVC (cameras) and vendor-specific interfaces only with a signed driver service.
Any other interface causes the whole device to be rejected. Built today: HID (keyboard, pointer) with interrupts; CDC-ACM and UVC follow with real devices.
6.9 Safety on the robot: emergency stop
- Emergency stop in the kernel (
Safety): stops all actuators immediately, even during the start animation (⌘+Esc), via the always-visible button in the menu bar or the status page of Server. Release only at the robot. - Programs never get direct access to a motor or bus: the actuator service limits every movement (in the code today: −90…+90°, 30°/s) before a command goes onto the CAN FD bus.
- Measured: emergency stop to sent stop frame 10–12 µs (SOFTrobotsVM, handbook chapter 6). On an emergency stop or crash, the flight recorder saves the last seconds of the recording.
6.10 Sound and microphone
- Output: virtio-sound, 48 kHz, 16 bits, stereo, periods of 10 ms. Mixer in the kernel: every program with
sound.playgets a ring of about 341 ms; the device starts with the first sound and stops after one second of silence (Hb. 3.100). - Microphone (9 Nov 2026, Hb. 3.134): virtio-sound input, runs only while a program is listening. One ring per microphone (48 kHz, 16 bits, ≈ 1.4 s), mapped read-only into every listening program, with level (peak and RMS) every 10 ms. Right
device.microphone. - Always visible: red pill “MIC · program” in the menu bar, cannot be hidden; “Stop the microphone” stops all listeners. Settings › Privacy shows who sees the camera and who hears the microphone.
- Sound (10 Nov 2026): menus “Sound, File, Edit”; Open… and Save As… (FLAC or WAV) via the system dialog.
6.11 Shapes, Reflex and Develop
- Everything is a shape:
.shapefiles describe once what the API, kernel checking code (integers only, no heap), database tables, rings and network use. Stable layouts: published fields keep their place. - Reflex: own language with lexer, parser, one-pass compiler to bytecode and a machine; every line names its module, and the script's rights follow from that.
- Develop: projects as folders, checks on every key press (compile and tests), Run runs the program with a preview, forms and stored lists (
stored as table). “Save as Program” compiles to ARM64 machine code and creates a signed program, without source text and compiler, never with writable code; a script made only of real-time handlers becomes a program for the real-time core. - Provable real time: For
realtime every 1 ms, the compiler counts the worst-case cycles of every statement (every memory access as a cache miss, at only 1 GHz) and starts only if at most 80 % of the period is needed.
6.12 Video playback (measured 10 Nov 2026)
Video writes one line per playback to /data/video/measurements.csv and one log line every second
(shown, late, skipped, decode, convert and draw time; apps/video/PlayStats.swift). Mac values come from the host test vp9FileSpeed, VM values from make vm-vp9-bench (600 frames of Big Buck Bunny 1080p). Source of all numbers: docs/benchmarks/video-playback.md.
| 1080p, per frame | SOFTrobotsVM | Mac (host test) |
|---|---|---|
| decode, 1 thread | 10.5 ms | 6.9 ms |
| decode, 3 threads | 8.9 ms | 3.3 ms |
| YUV → RGB conversion (SIMD) | 1.4 ms | 1.1 ms |
- How Video plays: up to 4 frames decoded and converted ahead; when behind, it catches up in order (at most 4 frames in a row), the sound keeps running and jumps to the picture time after a stall; loop filter on 3 cores (bit-identical to one thread); YUV→RGB with SIMD (byte-identical).
- Result: 360p at 60 frames/s: 60 of 60 shown, 0 skipped; 720p 60 of 60, also in a VM with 2 cores and 2 GB (14 Nov 2026, on the owner's machine, 0 late frames). 1080p: decoding and converting take about 10 ms of the 16.7 ms a frame may have at 60 frames/s.
- Measured and not taken: loop filter with SIMD (Mac, 1 thread 12–15 % slower) and motion compensation with SIMD (no difference).
- Open: three threads bring 16–20 % in the VM, 50 % on the Mac; the reason has not been found.
docs/decisions.md, 10 Nov 2026): A pure arithmetic loop takes the same time in the VM and on the Mac (249 / 248 ms) – the VM's cores are not slower.
Cause: all programs were built with -Xcc -mno-unaligned-access (inherited from the kernel, which initially runs without an MMU); with that, Swift split every unaligned 8-byte access into single bytes (in the disassembly of rgba: ldrb/orr, strb).
Therefore only programs without a heap keep the setting (they may map device registers: usbinput, canbus); programs with a heap see only normal memory, where unaligned accesses are allowed. Programs with uses-video are built with -O like uses-infer.7File system SOFTrobotsFS
Structure
- Copy-on-write: a valid block is never overwritten; a commit writes new nodes and then switches a single root pointer in the double superblock. No journal.
- B+ trees for objects and extents; keys (object, type, offset) keep everything belonging to an object together; up to 8 levels.
- 16 KiB blocks = page size = tree node: cache frames go to the NVMe without copying.
- CRC-32C (processor instruction) on all data and metadata.
- AES-256-GCM per block (sealed volume): header as additional data, tag and nonce in the header; parents store the generation of every child – an old block cannot be played back unnoticed.
- Snapshots every 15 minutes, retention 24 h / 7 days / 30 days, at most 400; the time slider in Files and Database shows old states.
- Small files up to 2 KiB directly in the tree (no separate data block), folder totals immediately, no atime.
- Free-space map on disk (volume up to ≈ 1.99 TiB), 32 MiB hash cache, batched commit with FUA, up to 32 write commands at the same time.
- Planned: batched TRIM (not yet built).
Why it is fast
- No journal: every change is written once, not twice.
- Block = page = node: no conversion, DMA directly from the cache.
- Checksum and encryption in hardware: AES-256-GCM 4,257 MB/s seal, 3,995 MB/s open.
- No atime: reading causes no writes; small files cost no extra block.
- In the kernel, without POSIX layers in between.
Advantages
- Power failure: always exactly the old or the new state, never anything in between (host tests with shuffled write order on every write).
- Every silent corruption is detected; a sealed volume is unreadable without the password and tamper-proof.
- Snapshots cost almost nothing – they are a consequence of copy-on-write.
Measured (kernel, 4 MiB)
Write + commit 255 MB/s · read + CRC check 779 MB/s
The value varies with the Mac's file cache (1 Nov: 166 / 389 MB/s, Hb. 3.58).
File system measurements in detail
| Measurement | Value | Where / how measured |
|---|---|---|
| NVMe: one 16 KiB command read / write | 38.6 µs / 80.3 µs | Kernel at start, Benchmark 14 Nov 2026 (median of 4 runs) |
| NVMe sequential (256 KiB, 16 commands at the same time) read / write | 1,500 MB/s / 554 MB/s | Kernel at start; the VM disk is a file on the Mac |
| Commit of a new file | 3.3 ms | Boot log 8 Nov; almost entirely the flush of the VM disk |
| Commit of 280 new files in one go | 4.2 ms | 13 nodes together to the NVMe, without copying (“0 bounced since the boot”), boot log 8 Nov |
| Mount DATA (sealed, via the free-space map) | 11 ms | only superblocks and map blocks read (Hb. 3.58, 1 Nov 2026) |
| Check of all nodes after “Hello” (403 blocks) | 7.1 ms | 0 damage, 0 missing map bits (Hb. 3.58); runs in the diagnostics thread, does not slow down the boot |
| Node cache at start: hits / reads | 1,087 / 12 · 289 / 1 | System volume · DATA, boot log 8 Nov |
| Program: write / read a 4 MiB file | 126 MB/s / 99 MB/s | Benchmark, via the system calls (16 KiB per call) |
| Create and delete a small file | 8.0 ms | Benchmark |
| List a folder entry | 374 µs | Benchmark |
| Disk encryption AES-256-GCM seal / open | 4,257 MB/s / 3,995 MB/s | Kernel at start, bit-identical to the software reference, tampering detected |
8Database SOFTrobotsDB
A database is not a file with its own pages but an object of its own in the file system (kind “database” next to file and folder) with its own copy-on-write B+ tree – made of the same 16 KiB nodes, with the same block management,
the same checksum or encryption and the same commit. The file system's commit is the database's commit; there is no write-ahead log and no second copy layer
(docs/database-concept.md, section 1; code in kernel/fs/softrobotsfs/Database.swift, Tables.swift, Query.swift, Schema.swift).
8.1 Functions
- Tables as stored shapes: types bool, int8–64, uint8–64, float32/64, text(n), bytes(n), time, enum, id, ref, file; rules optional, unique, default, range.
- The kernel checks every row (required fields, size, valid UTF-8, ranges also for floating point, NaN rejected, unique, ref, file) – a faulty app cannot store nonsense.
- Indexes (16 per table, 8 fields per index) in the same write package as the row; queries with filters (64 nodes), sorting over up to 4 fields, top N, groups, sum/average (128 bits internally), cursors; “explain” names the plan.
- Joins over ref fields (9 Nov 2026, Hb. 3.128): up to two joins for WHERE and ORDER BY, up to four for display; the kernel reads the joined row itself (one point query per row and join). Not yet: GROUP BY over joined fields, index over joined fields.
- SQL (read-only) in Console and Database; translation into the fixed plan runs in the program, the kernel understands no text language.
- Changing the schema (add, remove, rename a field, extend an enum): immediately, without rewriting a single row.
- Series, capture rings and flight recorder (the last seconds, saved on emergency stop or crash).
8.2 Measured (Benchmark 14 Nov 2026, median of 4 runs, via the system calls from a program)
| Insert 1,000 rows, waiting for the disk | 20.8 ms |
| 1,000 rows “soon” (durable within 10 ms) | 9.8 ms |
| One row by id | 37.6 µs |
| Range over an index (100 rows) | 4.0 ms |
| Top 100 of 1,000 sorted without an index | 20.4 ms |
| Counting in groups (1,000 rows) | 2.6 ms |
| Translate an SQL statement | 0.8 µs |
| Readings into the ring (real-time path) | 2.4 M/s |
| of which dropped (10,000 written) | 0 |
| Read back a time range (1,000 records) | 15.4 ms |
Per row: 22.2 µs durable, 10.3 µs with “soon”. First measurement in stage 4 (1 Nov 2026, test program dbcheck, with a unique field, two indexes, checking of all rules and undo log): 17 ms and 5.9 ms for 1,000 rows. A small durable write cost 3.6 ms, almost entirely the flush of the VM disk (Hb. 3.62, 1 Nov 2026). The first measurement was 17 times slower (291 ms for 1,000 rows, F80) – found only because a real app measured in the real VM.
8.3 Limits
| Limit | Value | Limit | Value |
|---|---|---|---|
| Record (all fields) | ≤ 4,096 bytes – large data as a file (8.5) | Tables / fields | 64 per database / 64 per table |
| Key | 1–255 bytes | Write package (transaction) | ≤ 4 MiB, fully checked beforehand |
| Tree depth | 8 levels – with 100-byte rows far more than 10 billion rows | Rows per query call | 256 (output ≤ 256 KiB), more via cursor |
| Sorting without an index | Top N ≤ 1,000 | Groups | 256, group value ≤ 32 bytes |
| Open databases | 4 per program, 32 in the system | Series record | 8–1,024 bytes, ring 1–600 s, ≤ 32 MiB |
8.4 Why the database is fast – and by how much
| Reason | What it does | Advantage |
|---|---|---|
| One layer instead of two | No write-ahead log, no journal, no database file inside a file system. A changed node is written once; the root switch in the superblock makes everything valid at once. | Design a small durable commit needs one flush + FUA superblock instead of a log flush plus the file system's journal (concept, sections 5.2 and 9). On consumer NVMe the flush is the expensive part. |
| Batched commit (group commit) | Writes from many programs that arrive during a commit share the next flush; all dirty nodes go to the NVMe together (up to 32 at the same time). | Design commits under load are gathered instead of each waiting for its own flush (concept 5.3). How many per second has not been measured under load. |
| One system call per transaction | The write package is checked without a server process and applied in one go; the result goes directly into the program's memory. | measured: 9.8 ms for 1,000 rows in one call |
| Queries in the kernel close to the data | Filters, sorting, groups and joins run where the nodes sit in the cache; only the result travels through the system call window. | measured: counting in groups over 1,000 rows 2.6 ms |
| One cache for everything | The kernel's block cache (32 MiB, 2,048 slots, hash lookup) holds files and databases; its 16 KiB frames are pages and DMA buffers at the same time – no copying, no second cache in the program. | inner nodes stay in the cache: an uncached access costs exactly one disk access (concept 4) |
| Rings for measurements | A real-time thread writes without a system call and never waits; if the ring is full, the value is dropped and counted. | measured: 2.4 M/s, 0 dropped. Qualitatively: from a real-time thread this is not possible at all with a usual database. |
| Snapshots from copy-on-write | A snapshot of the database is a snapshot of the file system. | costs no copy – instead of a full backup |
To be honest: For single point queries SOFTrobotsDB is not many times faster – on every side they are limited by memory and device (concept, section 9). The lead lies in durable commits, many writers, measurements from real-time code and large data (8.5).
8.5 Files as a field: why the database is not limited for large data
A record is at most 4 KiB in size (decision in concept 15.5 point 9). Pictures, recordings, models or measurement files therefore do not belong in the row but in the file system –
the row refers to them with the field type file (concept 15.6 of 1 Nov 2026). Because the database and the files live in the same file system, this is not a loose path reference as with a database file next to other files, but a reference within the same copy-on-write tree.
How it works (from the code)
- A
filefield stores the file's object identifier in SOFTrobotsFS (8 bytes,Schema.swift: fixed size 8), not a path. Identifiers come from a counter in the superblock and are never reused. - On writing, the kernel checks every row: the object exists, is a file and lies in the program's folder (
Tables.swift:info(of:)?.kind == .fileandisBelow(…, fileFieldRoot); the folder is set byDatabaseAccess.swifton opening). Otherwise the row is rejected with “not a file in the app's folder”. - Renaming and moving the file do not change the identifier – the reference stays valid. A deleted file is not blocked; the field then reads as “missing” and can never point to a newer, different file.
- The file itself is an entirely normal file: extents up to 16 blocks = 256 KiB (sealed 4 = 64 KiB), every block with its own checksum or its own GCM tag, parents store the generation of every child.
Why this is faster – and why
- Large data is written exactly once – into the file's extents. No overflow page chain in the database, no log containing the same bytes a second time. Design a large value is written once, not first into a log and later again; compared with other databases this is not measured.
- Rows stay small: queries, indexes, sorting and joins never touch the file. One row by id costs 37.6 µs – regardless of whether the file is 1 KB or 1 GB. Design scans over tables read no attachment bytes, because attachments are files of their own (not measured).
- Reading in one piece: extents are contiguous (up to 256 KiB); cache frames are DMA buffers at the same time, and the NVMe reads without an intermediate buffer (“0 bounced”). Measured: kernel read 4 MiB + CRC 779 MB/s, from a program 99 MB/s (16 KiB per call, so one copy into the program – no zero-copy all the way into the app).
- Encryption costs almost nothing: AES-256-GCM opens at 3,995 MB/s, almost three times as fast as the VM disk reads sequentially (1,500 MB/s) – both values measured in the same start.
- Copy and backup for free: a snapshot of a table with a thousand large files copies not a single file (copy-on-write).
| Part of the file field | As of | Where / remark |
|---|---|---|
Field type file in the kernel: 8-byte object identifier, check “exists, is a file, in the program's folder” | built | Stage 2 (1 Nov 2026) and 4; kernel/fs/softrobotsfs/Tables.swift, kernel/core/DatabaseAccess.swift |
Kernel schema text (photo file optional), snapshots and time slider across database and file | built | Schema.swift; snapshots contain every database (Hb. 3.59) |
Shape language data.shape (programs have described their tables as stored shapes since 5 Nov 2026) | not yet | docs/decisions.md, 5 Nov 2026: “Not yet: … file fields” – shapec cannot express a file field yet |
| App API: get the identifier of a file and open a file by its identifier | planned | Concept 15.6: opening by identifier is a tree lookup; the folder rules still apply, an identifier never bypasses them. Today files.info returns no identifier. |
| Path for display in Files and Console | planned | Concept 15.6: the path is computed only for display |
Valid within one volume. For programs, the file field is therefore fully secured in the kernel today, but usable only once the shape language and the App API offer it.
9File formats: what the system reads and writes
Every row has been checked against the code (kernel/lib/FileTypes.swift, userland/image, svg, video, opus, sound, archive, web, sql, the programs' manifests, docs/api/app-api-1.txt; read on 10 Nov 2026).
All formats are our own Swift code – no third-party library, no C dependency (for the WebP reader the algorithm is ported from libwebp, licence in the file header). Decoders never run in the kernel but in the program's address space without extra rights:
a malicious file can at most hit that program. Since 10 Nov 2026, opening and saving go through one system dialog for all programs (section 6.5, Hb. 3.135).
.reflex). A program gets a document only if it names the extension in its signed manifest and the start of the file matches the type
(PNG signature, FF D8 FF, %PDF-, EBML header, “fLaC”, valid UTF-8 …). A renamed file thus cannot pose as another type.| Format Program | Read | Write | Variants: supported and not | Limits and speed |
|---|---|---|---|---|
| Pictures | ||||
| PNG Image, Files, Web, SVG | yes | yes | Read: all colour types (grey, RGB, palette, each with alpha), bit depths 1–16, Adam7 interlace, tRNS transparency, all five row filters, every CRC checked; own inflate (RFC 1950/1951). Result always 8-bit RGBA (16 bits are reduced). Skipped: gamma, colour profiles, text chunks. Not: APNG animation (the default image appears); an unknown critical chunk rejects the file. Write: 8-bit RGB (opaque) or RGBA, without interlace, filter per row, one IDAT, own deflate. |
Read and write ≤ 2048 × 2048 pixels, file ≤ 16 MiB; preview in Files ≤ 4 MiB. Measured: open 1024² 25.3 ms, save 73.0 ms; open 1400 × 1400 in 64 ms (Hb. 3.34). Source: userland/image/PNG.swift, PNGEncoder.swift, Picture.swift (maxPixels, maxFile), apps/files/Thumbnail.swift |
| JPEG Image, Files, Web, Video, Reader | yes | yes | Read: baseline, extended sequential (8 bits), progressive; Huffman; grey, YCbCr, RGB; subsampling with factors up to 4 (4:4:4, 4:2:2, 4:2:0, 4:1:1 …), restart intervals, EXIF orientation. At most 2 levels of deviation from libjpeg-turbo (bit-identical with 16-bit tables). Not: arithmetic coding, 12 bits, lossless, CMYK. Write: baseline, YCbCr 4:2:0, quality 1–100 (tables from the standard, scaled like IJG), standard Huffman tables, JFIF header; alpha is dropped. |
File ≤ 16 MiB. Baseline with one scan (cameras) is decoded line by line; larger than 2048 × 2048 → reduced to 1/2, 1/4 or 1/8, so originals up to 16,384 × 16,384. Progressive and multiple scans: ≤ 12 million coefficients (arithmetically ≈ 8 megapixels at 4:2:0). Write ≤ 2048 × 2048. Measured: 36 MP photo in 537 ms (SOFTrobotsVM). Source: userland/image/JPEG.swift, JPEGEncoder.swift, Picture.swift |
| GIF Image, Files, Web | yes | – | GIF87a and GIF89a; LZW up to 12 bits, global and local colour tables, interlace, transparency; animation with a delay per frame, repeat count and all three disposal methods. Delays under 20 ms count as 100 ms (as in browsers). Web animates only what is visible. | Canvas ≤ 2048 × 2048, ≤ 10,000 frames per file, file ≤ 16 MiB. Only one canvas and one copy are kept in memory, never all frames. Damaged LZW data ends only that frame. Measured: open 512 × 512 in 3.3 ms. Source: userland/image/GIF.swift (maxFrames) |
| WebP Image, Files, Web | yes | – | VP8 (lossy), VP8L (lossless), VP8X with ALPH (raw or VP8L-compressed, with filter), animation (ANIM/ANMF) is played in Image and Web; ICCP, EXIF, XMP are skipped. Pixels exactly as libwebp 1.6.0 dwebp (algorithm ported from libwebp). |
Canvas and picture ≤ 2048 × 2048, file ≤ 16 MiB; VP8L Huffman tables ≤ 222 entries. Damaged data gives an error, never a crash. Source: userland/image/WebP.swift, WebPLossless.swift, WebPAnimation.swift |
| SVG Image, Files, Web | yes | – | Own XML reader (entities, CDATA, DOCTYPE skipped). Shapes, paths, nested <svg>, viewBox, gradients, patterns, clip-path, masks, group opacity, markers, use/symbol, CSS, embedded PNG/JPEG, text with tspan and textPath, filters (including blur, turbulence, lighting – checked against Chrome). Not: scripts, foreignObject, animation, external references (nothing is loaded afterwards); for text no vertical text, no bidi text, no ligatures. | ≤ 100,000 nodes, depth ≤ 256, use nesting ≤ 32, ≤ 250,000 drawn elements, canvas ≤ 4096 × 4096; Image reads ≤ 16 MiB, preview in Files ≤ 4 MiB. Measured: read and draw 512 × 512 in 39.2 ms. Source: userland/svg/SVGDocument.swift, SVGRender.swift (maxSide, maxDrawn), SVGText.swift |
| BMP Image, Files | yes | yes | Read: 1, 4, 8, 16, 24, 32 bits, palette, bit fields (also alpha mask), RLE4/RLE8, top-down or bottom-up. Write: 24 bits (opaque) or 32 bits with alpha (BITMAPV4 header). |
≤ 2048 × 2048 pixels, file ≤ 16 MiB, read and write. Source: userland/image/BMP.swift, Picture.swift |
| TIFF Image, Files | yes | yes | Read: the first image in the file, Intel/Motorola, strips or tiles, 1/2/4/8/16 bits per channel, grey, RGB, RGBA, palette; uncompressed, PackBits, LZW, Deflate, horizontal predictor. Not: CMYK, YCbCr, Lab, JPEG in TIFF, floating point, separate planes, BigTIFF, further images in the file. Write: RGB/RGBA 8 bits, Deflate, one strip. |
≤ 2048 × 2048 pixels, file ≤ 16 MiB. Measured: open 1024² in 41.1 ms, save in 114 ms. Source: userland/image/TIFF.swift, Picture.swift |
| HEIC/HEIF, AVIF, JPEG 2000, JPEG XL, camera RAW, ICO, PSD | no | no | Not supported: no document type in the kernel; no program opens such files. JPEG 2000 in PDFs: grey area. Source: kernel/lib/FileTypes.swift, userland/svg/PDFRender.swift | |
| Documents and fonts | ||||
| PDF read Reader, Files (preview) | yes | – | Every version (header “%PDF-” in the first 1 KiB; the version number is not evaluated). Cross-reference tables and streams (PDF 1.5), /Prev, repair of broken tables, object streams. Filters Flate and LZW (each with predictor), ASCIIHex, ASCII85, RunLength, DCT (JPEG); scans with CCITT G3/G4 and JBIG2 (generic, MMR, symbols, text, refinement). Colours grey, RGB, CMYK, Lab, ICC, indexed, Separation/DeviceN; shadings type 2 and 3. Encryption RC4 40/128, AES-128, AES-256 (revision 2–6), with user or owner password. Search, highlight, copy, links. Not: JPEG 2000 (grey area), Huffman JBIG2 and halftone regions (empty), JavaScript and actions (never executed); mesh and function shadings only as the average colour. | File ≤ 256 MiB, one stream ≤ 64 MiB unpacked, nesting ≤ 32, ≤ 4 million objects, ≤ 4 million operators per page, form XObjects ≤ 12 deep, JBIG2 page ≤ 228 pixels; preview in Files ≤ 32 MiB (encrypted ones only without a password). 1,500 randomly damaged PDFs open without a crash (host test). Source: userland/image/PDFReader.swift (maximumFile, maximumStream), PDFCrypto.swift, userland/svg/PDFRender.swift, PDFScan.swift, PDFJBIG2.swift |
| PDF write Image (export), App API PDFDocument | – | yes | PDF 1.7, encrypted PDF 2.0. Free page size (default A4); text, lines, rectangles, pictures (JPEG embedded unchanged, otherwise Deflate with alpha mask). Fonts Helvetica, Helvetica-Bold, Courier (standard fonts, not embedded); characters Latin-1 via WinAnsi (ä, ö, ü, ß, €), others become “?”. Encryption AES-256 (revision 6) – macOS opens it with the password. Not: embedded fonts, forms. Since 10 Nov, Image exports via the system dialog (Export… with PNG, JPEG, BMP, TIFF or PDF). | No fixed limit in the code; the file is created entirely in memory (no limit except memory). Pictures ≤ 2048 × 2048 (picture limit). Source: userland/image/PDF.swift; Hb. 3.135 |
| Fonts Reader (in PDFs) | only in PDF | – | Embedded font programs in PDFs: TrueType (cmap 0, 4, 6, 12; composite glyphs up to 8 deep), OpenType with TrueType or CFF outlines, CFF (Type1C, CIDFontType0C), Type 1, Type 3. If a program cannot be read, Reader draws with its own font in the PDF's widths. The system fonts (Inter, Source Serif 4, Roboto Condensed, JetBrains Mono) are converted on the Mac at build time (tools/fontgen), without hinting. |
Every offset in the font program is checked against its length. Not: font files as documents (.ttf, .otf, .woff – no document type), web fonts (@font-face is skipped). Source: userland/svg/PDFFontProgram.swift, PDFFontCFF.swift, PDFFontType1.swift, userland/web/CSSParser.swift, OutlineFont.swift |
| Word (DOC/DOCX), ODT, RTF, EPUB, PostScript/EPS | no | no | Not supported: no document type in the kernel. Source: kernel/lib/FileTypes.swift | |
| Video | ||||
| Matroska (.mkv) Video, Files | yes | yes | Own EBML code (RFC 8794/9559). Read: DocType matroska or webm, Info, Tracks, Cluster, SimpleBlock and BlockGroup, lacing Xiph/EBML/fixed – only via the element headers, the file is never loaded completely. Video plays the tracks V_MJPEG and V_VP9, sound A_OPUS and A_PCM/INT/LIT, detections S_SOFTROBOTS/DETECTIONS; any other codec: message “codec is not supported”. Writing in one pass (append only): the camera's MJPEG frames unchanged with ms timestamps, one cluster per second, cues at the end; detections as a track of their own, sound as a PCM track. Checked against ffprobe/ffmpeg. | Read: nesting ≤ 16, ≤ 4 million frames per file, every element size checked against the parent element; file size without a fixed limit. Recording: a new part begins at 2 GB, stops when less than 2 GB of space is free; no time limit. Source: userland/image/Matroska.swift, apps/video/Recording.swift (partLimit, freeLimit) |
| WebM (.webm) Video, Web (download) | yes | – | Picture VP9, sound Opus; a seek decodes from the keyframe before it; sound only at speed 1× (otherwise muted). After a stall the sound jumps to the picture time instead of drifting (10 Nov). Not: VP8, AV1, playing while loading; writing WebM (recordings are .mkv). | Like Matroska. From Web: download ≤ 64 MiB and ≤ 10 min, playable only afterwards. Download speed: section 6.6 (11 Nov 2026: HTTPS from the internet 35–59 MB/s). Source: userland/image/Matroska.swift, apps/video/Codecs.swift, userland/web/HTTPMessage.swift (limit), apps/web/Fetch.swift, docs/benchmarks/network-download.md |
| VP9 (Codec) Video | yes | – | Profile 0 (8 bits, 4:2:0) with all tools: key, inter, intra-only and hidden frames, superframes, compound prediction, all transforms, lossless (WHT), segmentation, loop filter, tiles, references of a different size. Bit-exact against all 258 test vectors of libvpx. Up to 4 frames decoded ahead, loop filter on 3 cores (bit-identical to one thread), YUV→RGB with SIMD (byte-identical). Not: profiles 1–3 (4:2:2, 4:4:4, 10/12 bits) – Video shows a notice instead of a picture. | ≤ 8192 × 8192 samples per frame. Measured in SOFTrobotsVM (10 Nov 2026): decoding 1080p 8.9 ms per frame with 3 threads (1 thread 10.5 ms), converting 1.4 ms; 360p at 60 frames/s: 60 of 60 shown (section 6.12). Mac (M3 Pro, release build): 1080p 3.3 ms with 3 threads. Source: userland/video/VP9.swift (maxSize), VP9Loop.swift, docs/benchmarks/video-playback.md |
| Opus (Codec) Video | yes | no | Own decoder according to RFC 6716, 7845, 8251: SILK, hybrid, CELT, channel mapping family 0, 1 and 255, output gain, simple loss concealment; output 48 kHz. SILK bit-exact, CELT ≈ 85 dB distance from the reference. Not: error correction from LBRR frames, SILK comfort noise. Opus encoding (recording): not yet. | Every packet length checked; no length limit. Only in WebM/Matroska – .opus files (Ogg) have no document type. Source: userland/opus/Opus.swift, kernel/lib/FileTypes.swift |
| MJPEG (Codec) Video | yes | yes | JPEG frames in Matroska (V_MJPEG); recording takes over the camera's frames without re-encoding. | Per frame the JPEG limits (above). Source: userland/image/Matroska.swift, apps/video/Recording.swift |
| MP4/MOV, H.264/AVC, H.265/HEVC, MPEG-1/2, AV1, VP8, AVI | no | no | Not supported: no container except Matroska/WebM, no codec except MJPEG and VP9. VP8 deliberately not (superseded by VP9), AV1 later with hardware decoding. Source: kernel/lib/FileTypes.swift (only mkv, webm), apps/video/Codecs.swift, Hb. 3.131/3.132 | |
| Sound | ||||
| WAV Sound, Files | yes | yes | Read: RIFF/WAVE, PCM 8/16/24/32-bit integer and 32-bit floating point (also WAVE_FORMAT_EXTENSIBLE), mono/stereo (more channels: the first two), any sample rate; playback interpolated to 48 kHz, Sound computes internally with 16 bits. Not: compressed WAV (ADPCM, µ-law, A-law), 64-bit floating point, RF64. Write: 16-bit PCM, 48 / 44.1 / 16 kHz, mono/stereo (recording, export). Since 10 Nov, Open… and Save As… via the system dialog. |
Sound loads the whole file, ≤ 512 MiB (≈ 46 min stereo, 48 kHz, 16 bits). Recording: no time limit in the code, saved to DATA every 0.5 s (survives a crash). Source: userland/sound/WAV.swift, apps/sound/Library.swift, apps/sound/SoundFile.swift |
| FLAC Sound (default for recording), Files | yes | yes | Own encoder and decoder according to RFC 9639: native .flac (a preceding ID3v2 header is skipped), 4–24 bits, 1–8 channels, rates up to 1,048,575 Hz, STREAMINFO, SEEKTABLE, MD5. Encoder: blocks of 4096, per block L/R, L/S, S/R or M/S, LPC up to order 12, seek table every 10 s; the file is playable even during recording. Bit-exact against ffmpeg in both directions, files about as small as ffmpeg level 5. Sound records with 16 bits (48 / 44.1 / 16 kHz, mono/stereo) and converts to 16 bits and 2 channels on opening. | The decoder reads block by block via a read function: no limit except memory. Sound loads ≤ 512 MiB. Recording without a time limit. Source: userland/sound/FLAC.swift, FLACDecoder.swift, FLACEncoder.swift, apps/sound/Library.swift, SoundFile.swift |
| PCM in Matroska Video | yes | yes | Sound track A_PCM/INT/LIT, 16-bit little-endian, next to the picture; Video records 48 kHz mono and plays back mono or stereo. Checked against ffmpeg. | Like Matroska. Source: apps/video/Codecs.swift, apps/video/RecordSound.swift |
| MP3, AAC/M4A, Ogg Vorbis, .opus, AIFF, ALAC | no | no | Not supported: neither read nor write. MP3 and Opus recording are being planned; since 10 Nov 2026 programs no longer show anything as “later” (apps/sound/Look.swift).Source: kernel/lib/FileTypes.swift (only wav, wave, flac), Hb. 3.134 | |
| Archives and compression | ||||
| ZIP Files | yes | yes | Read: stored and Deflate, ZIP64, WinZip AES (AE-1/AE-2), ZipCrypto (read only); safe names (no “..”, no absolute paths, no control characters), links and hidden names (.DS_Store, __MACOSX) skipped. Other methods (e.g. bzip2, LZMA, Deflate64) are skipped. Write: Deflate as a stream, UTF-8 names, Unix permissions and time; password only WinZip AES-256 (AE-2, PBKDF2-HMAC-SHA1 with 1,000 rounds). |
Read: file size without a fixed limit, every entry runs through ≈ 130 KiB of memory; the central directory must lie in the last 1 MiB of the file. Write: ≤ 4 GiB per file and archive, ≤ 65,535 entries (no ZIP64 when writing). Preview in Files ≤ 64 MiB. Measured: Deflate 4 MiB 166 MB/s; 3,000,000 mixed bytes → 605,816 bytes (Mac test, Hb. ch. 6). Source: userland/archive/ZipReader.swift (tailLimit), ZipWriter.swift, ZipCipher.swift, StreamInflate.swift, apps/files/Archives.swift |
| Deflate / zlib / gzip PNG, ZIP, PDF, TIFF, Web | yes | yes | One inflate (RFC 1950/1951) for all formats, also as a stream in pieces up to 64 KiB; gzip only as HTTP content encoding in Web. Deflate: hash chains over 32 KiB, ≤ 32 candidates, one step of lazy matching; every block (≤ 16,384 symbols or 64 KiB) dynamic, fixed or stored – whichever is smaller. | Output always with an upper limit: PNG the computed picture size, PDF 64 MiB per stream, gzip in Web 64 MiB; in the stream (ZIP) without a limit. Source: userland/image/Inflate.swift, userland/archive/StreamInflate.swift, Deflate.swift, apps/web/Fetch.swift |
| tar, .gz as a file, 7z, RAR, bzip2, xz, Zstandard | no | no | Not supported: no document type in the kernel. Source: kernel/lib/FileTypes.swift | |
| Web | ||||
| HTML and CSS Web | yes | – | Reading browser without JavaScript: tolerant HTML reader (implicit end tags, <script> skipped, <noscript> shown), CSS selectors and values, @media (width, height, screen, light colour scheme), @supports, @layer, @import. Pictures in all the picture formats above (also data: addresses), <video> as a card “Play in Video”. HTTP/1.1 (GET, chunked, gzip) over TLS 1.3, without cookies and referrer. Own outline fonts with kerning. Since 10 Nov: File › Open… opens an .html file, Save Page As… saves the page shown unchanged. Not: JavaScript, cookies, @font-face, @keyframes, nested CSS rules. | ≤ 100,000 nodes, depth ≤ 256; one style sheet ≤ 4 MiB, ≤ 16 external ones with together < 4 MiB; response ≤ 64 MiB; ≤ 600 pictures per page and ≤ 160 MiB of decoded picture pixels; SVG pictures ≤ 4096 × 4096. A page has 20 s, a download up to 10 min. Source: userland/web/HTML.swift, CSSParser.swift, HTTPMessage.swift, apps/web/Images.swift, apps/web/main.swift, apps/web/Fetch.swift |
| Data and tables | ||||
| SOFTrobotsDB (.db) Programs (App API); Database, Console | yes | yes | An object of its own in the file system (section 8). Database and Console read every database but write only in their own folder. | Record ≤ 4,096 bytes, 64 tables per database, 64 fields per table, transaction ≤ 4 MiB, ≤ 256 rows per query call (then cursor); large data as a file field (8.5). Source: sections 8 and 14, docs/handbuch/grenzen.html |
| Series (.series), flight recorder Real-time programs; Database, Console | yes | yes | Fixed-size records with a timestamp in 16 KiB blocks, time index in the database tree. | Record 8–1,024 bytes; capture ring 1–600 s, ≤ 32 MiB, 16 rings in the system. Source: sections 8 and 14 |
| SQL Console, Database | yes | – | Read-only: SELECT with WHERE, GROUP BY, ORDER BY, LIMIT, COUNT/SUM/MIN/MAX/AVG, BETWEEN, LIKE (starts with / contains), IS NULL, LEFT/INNER JOIN over ref fields. Translated in the program into the kernel's fixed plan. Not: INSERT, UPDATE, DELETE, subqueries. | ≤ 4 joins (2 of them for WHERE/ORDER BY); sorting without an index top N ≤ 1,000; ≤ 256 groups. Source: userland/sql/SQL.swift, section 14 |
| CSV Export: Database, Console, Benchmark; Text | yes | yes | Export: all rows of the query (not just the 1,000 drawn ones), texts in full, quotation marks doubled; since 10 Nov, Database asks via the system dialog where to save. Text reads and edits CSV as text. | Export: no row limit. Text holds ≤ 4 MiB in memory. Source: apps/database/Export.swift, apps/text/main.swift (textLimit) |
| JSON Export: Database, Console, Benchmark; Text | yes | yes | Export like CSV, texts escaped. Text reads and edits JSON as text. | Like CSV. Source: apps/database/Export.swift, apps/text/main.swift |
| Text | ||||
| Text, Markdown, log, settings Text, Files | yes | yes | Extensions txt, text, md, markdown, log, csv, json, conf and the file config; valid UTF-8 without NUL bytes is required (the kernel checks it). ⌘S saves; since 10 Nov New, Open… and Save As… via the system dialog – with that, Text creates new files for the first time. |
Text holds ≤ 4 MiB in memory. Source: kernel/lib/FileTypes.swift, apps/text/main.swift; Hb. 3.135 |
| Crash reports (.crash) Kernel writes, Monitor shows | yes | yes | Text in DATA /state/crashes; since Hb. 3.89 with pictures of the screen and camera. Since 11 Nov 2026 Monitor › Report steps through all kept reports (Older/Newer). | 20 files, each ≤ 1 MiB. Source: section 14, docs/handbuch/grenzen.html |
| AI models (standard formats, not signed) | ||||
| GGUF (language models) the AI service ai reads from /models/language | yes | – | The open format of llama.cpp (MIT licence), read directly. Formats Q8_0, Q4_K, Q6_K; architectures qwen2, qwen3, qwen3moe, llama, llama4, qwen3vl, kolibri1. No signature: the reader checks every size against the file (host test GGUFFuzzTests: small kolibri1 and llama4 files deliberately damaged 20,000 times each); a broken file does not bring down the service. |
Larger than memory: runs with a fixed part and an expert cache from the disk (section 15.3). Source: userland/llm, tests/HostTests/GGUFFuzzTests.swift |
| ONNX (detection models) Camera reads from /models/detection | yes | – | An open standard of the Linux Foundation, read directly – no converting on the Mac and no third-party runtime. The weights are turned into 8 bits while loading (in memory only). No signature. | Camera loads models ≤ 64 MiB. Unknown building blocks: the model is refused with a clear message. Source: apps/camera/Models.swift, userland/infer/ONNX.swift |
| Signed system formats | ||||
| Programs (ELF + manifest) Kernel loads; Develop, Mac tool srapp | yes | yes | AArch64 ELF, Ed25519-signed; the manifest carries rights, real-time contract and memory commitment (since 10 Nov also dock = no). |
≤ 32 MiB, ≤ 8 segments. Source: kernel/lib/AppImage.swift (largestFile, maxSegments), kernel/lib/AppManifest.swift |
| .srshare (Reflex script) Develop | yes | yes | Shared Reflex script (“SOFTrobots share 1”), signed; Develop shows it on a review card before it is taken over. Share… asks where the package should go; Import… via the system dialog. | No size limit of its own found in the code (not checked). Source: apps/develop/Share.swift, kernel/lib/FileTypes.swift; Hb. 3.135 |
| .reflex Develop, Files | yes | yes | Source text of the Reflex language; compiled to bytecode or ARM64. Since 10 Nov 2026 a document type of its own, “Reflex script”, in the kernel (valid UTF-8 required); a double-click in Files takes the script over into Develop; Import… and Export… ⌘E via the system dialog. | Editor ≤ 1 MiB of source text. Source: apps/develop/Editor.swift (limit), kernel/lib/FileTypes.swift (reflex = 24); Hb. 3.135 |
| .srupdate Kernel reads; Mac tool sign | yes | Mac | Signed update package (Ed25519): kernel and used blocks of the system volume; a wrong signature is rejected (make test-update). |
≤ 4,064 system blocks of 16 KiB (≈ 63.5 MiB) plus kernel. Source: kernel/lib/UpdatePackage.swift (maxBlocks) |
| QR code Server (invitation) | – | yes | Byte mode (UTF-8 text as bytes), all four error correction levels, all eight masks evaluated; cross-read with Apple's Vision (host test). | Versions 1–10 (21 × 21 to 57 × 57 modules), ≤ 271 bytes (level L) or 213 (M). Measured: version 4 in 410 µs, version 10 in 1.3 ms. Source: userland/qr/QRCode.swift |
35 formats and codecs are read or written; the grey “no” rows name what is explicitly missing. Limits are constants from the named source code (read on 10 Nov 2026), speed values from SOFTrobotsVM unless marked as a Mac value. Evidence such as “bit-exact” and “pixel-identical” comes from the host tests (handbook 3.34–3.37, 3.70–3.76, 3.102, 3.121, 3.129–3.137). A format without its own row is not supported: the kernel gives a program only files of the 24 known document types.
10Boot graphics and boot times
The start animation is drawn by the kernel itself – with integer arithmetic, because the kernel does not use floating point: rounded rectangles, ellipses, rings, capsules and pre-rendered text masks, edges smoothed with 4 × 4 samples. A low-priority thread draws about 30 frames per second.
- Sequence (2.3 s): The small robot with a screen face is there from the first frame: the head rises, the face lights up, it opens its eyes, smiles and waves;
the lettering “SOFTrobots OS” and the birthday line (“born 28 October 2026 · N days old”) appear, then the desktop is there (
kernel/core/BootScreen.swift,duration2.3 s). The time until the desktop is ready has not been measured with the 2.3 s version. - Start sound: a triad 0.3 s after the start (variant b), servo whirring while waving – from the kernel's mixer, without floating point; without a sound device it stays silent. If the sound device starts later, it plays the whole chord as soon as it can.
- The layer line is real: at the bottom, firmware, kernel, devices, storage, network, programs and ready appear one after another, each with the measured time at which that layer was finished in the kernel.
- The system does not wait for the animation: services, real-time loops and programs run behind it as if it were not there. Only the desktop asks (system info) whether it is still running. Any key or click skips it; ⌘+Esc triggers the emergency stop even while it runs.
- Without flicker: with virtio-gpu every frame is created in guest memory and shown by a flush; only with GOP (real hardware without a graphics driver) in an intermediate buffer that is copied over when finished.
- Lines of text instead of the animation: key V at power-on, file
\SOFTROBOTS\VERBOSE(test images), a rolled-back update, a panic or the setting “Start screen: Text” (in the boot record, so that the loader can read it before unlocking).
Boot times
| Layer finished | Seconds after power-on |
|---|---|
| Firmware | 0.52 s |
| Kernel | 0.53 s |
| Devices | 0.55 s |
| Storage | 0.58 s |
| Network | 0.58 s |
| Programs | 0.63 s |
| Ready (Hello) | 0.64 s |
| IPv4 address via DHCP (background) | 1.18 s |
Source of the layer times: the line below the boot animation in the picture above (SOFTrobotsVM, product image 0.15.0, 8 Nov 2026). “Hello” in the measurement run of the same day: 0.62 s. Firmware and loader take about 0.5 s of that; the kernel itself around 90 ms. In QEMU it takes about 6 s until “Hello” – almost all of it emulated firmware.
11Real-time processor
A robot arm is controlled by a control loop that reads sensors and adjusts motors every millisecond. “Fast on average” is not enough – the cycle must be guaranteed to be on time. For this, SOFTrobots OS reserves the last processor core as the real-time core.
Contract in the signed manifest
realtime = 1000 100 stop means: period 1000 µs (1 kHz, the end of the period is the deadline), budget 100 µs of CPU time per period, reaction to a missed deadline
log, stop, restart or stop-actuators. The program ends every period with the basic call periodWait.
Admission: if the sum of the budgets no longer fits on the real-time core (≤ 900 ‰), the program is not started at all – instead of failing unpredictably later.
What the real-time core guarantees
- No other threads, no load balancing onto or off it, no
wfisleep. - No heap and no file access for real-time programs; never paged out.
- Asynchronous kernel log: writers never wait for the console or GPU.
- Watchdog every 50 ms; counters for periods, missed deadlines, mean and worst lateness (desktop card ROBOT & REALTIME).
| Measurement (SOFTrobotsVM) | Measured | Target | Verdict |
|---|---|---|---|
| IRQ latency (deadline → handler), mean | 42.0 ns | < 10 µs | met |
| IRQ latency, worst | 666 ns | < 10 µs | met |
| Context switch | 0.3 µs | < 2 µs | met |
| Message round trip (IPC) | 1.2–1.7 µs | < 1 µs | not met: 1.2–1.7 µs on different cores, 6–8 µs on the same one (F184) |
| Real-time wake-up at 1 ms, mean | 0.5 µs | < 20 µs | met |
| Real-time wake-up at 1 ms, worst | 7.6 µs | < 20 µs | met (the three runs: 7.6 / 3.0 / 3.0 µs) |
| Real-time program at 1 kHz: start delay mean / worst | 0.13 µs / 0.5–16 µs (during boot 26–77 µs) | < 20 µs | met after the start |
| Missed periods in 10 s | 0 | 0 | met |
Sources: Benchmark in SOFTrobotsVM on 15 Nov 2026, three runs with 4 CPUs and 8 GB, the preview image (docs/benchmarks/2026-11-15-m3pro-preview-4cpu-8gb-run1…3.csv). Real-time wake-up, worst value per run: 7.6 / 3.0 / 3.0 µs. Message round trip: 1.2–1.7 µs on different cores, 6–8 µs on the same one (six more runs, F184).
Test program control with a 1 kHz contract (phase 9, handbook chapter 6, 10 s without a missed period). Since F143 (8 Nov 2026), system calls are interruptible: if a large program starts on the same core,
a cycle comes at most 6–7 µs late instead of up to 0.9 ms (docs/decisions.md). Develop even proves real time in advance: for “Wrist hold”, 39.4 µs of 1 ms (3.9 %) are computed as the worst case (14 Nov 2026).
Real hardware has not been measured yet.
12Speed in numbers (the Benchmark program)
The Benchmark program measures every building block individually: 80 measurements in 15 areas. Every measurement has a fixed number whose meaning never changes, so that runs of all versions are comparable.
Every run is stored in /data/benchmark/runs.db (a SOFTrobotsDB database); after an update Benchmark measures on its own. Kernel values (start, scheduler, NVMe, file system, disk encryption, program start, password check) are measured at boot and taken over.
apps/benchmark/Metrics.swift.12.1 Two Macs, the same system
The same preview (build 234, 4 CPUs, 8 GB), three runs each after a fresh start, median. M3 Pro: MacBook Pro, Apple M3 Pro, 36 GB, wired network. M4: Mac mini M4, 16 GB, Wi-Fi – so the network values are not compared here. Of 75 shared measurements the M4 is faster by more than 5 % in 59, the same in 7, slower in 9 (all values: docs/benchmarks/2026-11-15-m3pro-vs-m4.md). The message round trip is left out: on both Macs it depends on whether the partner lands on the same core (F184).
| Measurement | M3 Pro | M4 | M4 against M3 Pro |
|---|---|---|---|
| Power on to “Hello from the kernel.” | 618 ms | 566 ms | 8 % shorter |
| Interrupt latency, mean | 42.0 ns | 28.0 ns | 33 % shorter |
| Context switch | 290 ns | 252 ns | 13 % shorter |
| Yield to the scheduler | 986 ns | 537 ns | 46 % shorter |
| Messages through a channel | 2.55 M/s | 3.58 M/s | 40 % more |
| System call (time) | 526 ns | 427 ns | 19 % shorter |
| CRC-32 over 16 MiB | 493 MB/s | 614 MB/s | 25 % more |
| Memory copy (32 MiB) | 49.3 GB/s | 43.0 GB/s | 13 % less |
| NVMe: read 16 KiB, one command | 38.6 µs | 9.27 µs | 76 % shorter |
| NVMe: sequential read | 1.50 GB/s | 3.78 GB/s | 152 % more |
| NVMe: write 16 KiB, one command | 80.3 µs | 82.0 µs | 2 % longer |
| NVMe: sequential write | 554 MB/s | 575 MB/s | 4 % more |
| App: 4 MiB file read | 99.0 MB/s | 344 MB/s | 247 % more |
| App: 4 MiB file written | 126 MB/s | 185 MB/s | 47 % more |
| Database: 1000 rows inserted (on disk) | 20.8 ms | 20.8 ms | same* |
| Records pushed into the ring | 2.36 M/s | 2.72 M/s | 15 % more |
| JPEG 1024 × 1024 opened | 9.45 ms | 8.55 ms | 10 % shorter |
| Disk encryption AES-256-GCM seal | 4.26 GB/s | 5.08 GB/s | 19 % more |
| SHA-256 | 193 MB/s | 281 MB/s | 46 % more |
| TLS 1.3 handshake in memory (own server and client) | 2.43 ms | 2.23 ms | 8 % shorter |
| Reflex: example program compiled | 30.3 µs | 25.2 µs | 17 % shorter |
* Same median; the single runs lie at 18.8–20.8 ms (M3 Pro) and 19.9–22.9 ms (M4). About half of the time is the commit, which writes to the disk – and writing is as fast on both Macs (see the two write rows).
Processor speed tests (area “Processor, memory”)
| No. | Measurement | Value | Remark |
|---|---|---|---|
| 40 | CRC-32 over 16 MiB | 493 MB/s | Benchmark run |
| 41 | Floating point (matrix 128 x 128) | 3,709 M/s | Benchmark run |
| 42 | Memory copy (32 MiB) | 49,253 MB/s | Benchmark run |
| 43 | Memory fill (32 MiB) | 32,255 MB/s | Benchmark run |
| 44 | Heap: allocate and free an object | 67 ns | Benchmark run |
All measurements
| No. | Measurement | Value | Remark |
|---|---|---|---|
| Start · Start | |||
| 1 | Power on to "Hello from the kernel." | 0.62 s | Firmware + loader + kernel until “Hello” |
| Scheduler, real time · Scheduler, realtime | |||
| 10 | Interrupt latency, average | 42.0 ns | Kernel measurement at start |
| 11 | Interrupt latency, worst | 666 ns | Kernel measurement at start |
| 12 | Context switch | 0.3 µs | Benchmark run |
| 13 | Scheduling decision | 0.2 µs | Kernel measurement at start |
| 14 | Realtime wake-up (1 ms), average | 0.5 µs | at boot on the real-time core (from build 236; before on a program core, F185) |
| 15 | Realtime wake-up (1 ms), worst | 7.6 µs | the other two runs: 3.0 and 3.0 µs; up to build 235 measured on a program core, hence one M4 run with 210 µs (F185); on the real-time core 6.8–9.0 µs in 6 starts |
| 16 | Realtime periods missed at boot | 0 | Kernel measurement at start |
| 17 | Sleep 1 ms: late by, average | 260 µs | Timer resolution for programs |
| 18 | Yield to the scheduler | 1.0 µs | Benchmark run |
| Messages (IPC) · Messages (IPC) | |||
| 20 | Message sent and received | 1.2–1.7 µs | programs on different cores (6 runs on 15 Nov 2026); on the same core 6–8 µs (F184) |
| 21 | Wake the other end (notify) | 6.7 ns | only when the other side is asleep (F143) |
| 22 | Messages through a channel | 2.5 M/s | Benchmark run |
| Programs · Programs | |||
| 30 | Start and end a program | 1.3 ms | only in the test image: runs of 15 Nov 2026 (build 233, 4 CPUs, 8 GB) |
| 31 | Start from the app cache | 81 µs | only in the test image: runs of 15 Nov 2026 (build 233, 4 CPUs, 8 GB) |
| 32 | System call (time) | 526 ns | Benchmark run |
| 33 | System information read (system.info) | 3.1 µs | Benchmark run |
| 34 | Installed programs listed (all, with id and version) | 660 µs | Benchmark run |
| Processor, memory · Processor, memory | |||
| 40 | CRC-32 over 16 MiB | 493 MB/s | Benchmark run |
| 41 | Floating point (matrix 128 x 128) | 3,709 M/s | Benchmark run |
| 42 | Memory copy (32 MiB) | 49,253 MB/s | Benchmark run |
| 43 | Memory fill (32 MiB) | 32,255 MB/s | Benchmark run |
| 44 | Heap: allocate and free an object | 67 ns | Benchmark run |
| Disk (NVMe) · Disk (NVMe) | |||
| 50 | Read 16 KiB, one command | 38.6 µs | Kernel measurement at start |
| 51 | Write 16 KiB, one command | 80.3 µs | Kernel measurement at start |
| 52 | Sequential read (16 commands at once) | 1,500 MB/s | Kernel measurement at start |
| 53 | Sequential write (16 commands at once) | 554 MB/s | Kernel measurement at start |
| File system · File system | |||
| 60 | Kernel: 4 MiB written and committed | 255 MB/s | Kernel measurement at start |
| 61 | Kernel: 4 MiB read and checked | 779 MB/s | Kernel measurement at start |
| 62 | App: 4 MiB file written | 126 MB/s | Benchmark run |
| 63 | App: 4 MiB file read | 99 MB/s | Benchmark run |
| 64 | Small file created and removed | 8.0 ms | Benchmark run |
| 65 | Folder entry listed | 374 µs | Benchmark run |
| Database · Database | |||
| 70 | 1000 rows inserted (on disk) | 20.8 ms | Benchmark run |
| 71 | 1000 rows inserted (soon) | 9.8 ms | Benchmark run |
| 72 | Row by id | 37.6 µs | Benchmark run |
| 73 | Range through an index (100 rows) | 4.0 ms | Benchmark run |
| 74 | Sorted without an index (top 100 of 1000) | 20.4 ms | Benchmark run |
| 75 | Count in groups (1000 rows) | 2.6 ms | Benchmark run |
| 76 | SQL statement translated | 0.8 µs | Benchmark run |
| Series, recording · Series, recording | |||
| 80 | Records pushed into the ring | 2.4 M/s | Benchmark run |
| 81 | Records dropped (10 000 pushed) | 0 | Benchmark run |
| 82 | Time range read back (1000 records) | 15.4 ms | Benchmark run |
| Pictures, ZIP · Pictures, ZIP | |||
| 90 | PNG 1024 x 1024 saved | 67.7 ms | Benchmark run |
| 91 | PNG 1024 x 1024 opened | 17.9 ms | Benchmark run |
| 92 | JPEG 1024 x 1024 saved | 12.7 ms | Benchmark run |
| 93 | JPEG 1024 x 1024 opened | 9.4 ms | Benchmark run |
| 94 | Deflate (ZIP) 4 MiB | 240 MB/s | Benchmark run |
| 95 | GIF 512 x 512 opened | 2.2 ms | Benchmark run |
| 96 | TIFF 1024 x 1024 saved | 79 ms | Benchmark run |
| 97 | TIFF 1024 x 1024 opened | 28.9 ms | Benchmark run |
| 98 | SVG drawing read and drawn (512 x 512) | 7.0 ms | Benchmark run |
| Display · Display | |||
| 100 | Whole picture 1280 x 800 filled | 3,858/s | Benchmark run |
| 101 | Characters drawn | 6.3 M/s | Benchmark run |
| 102 | Window drawn and shown | needs window | needs an open window; the run without a window skips it |
| 103 | Key mapped (German layout, umlauts) | 4.3 ns | Benchmark run |
| 104 | Key typed into a text field | 10.1 ns | Benchmark run |
| 105 | Text field drawn | 17.2 µs | Benchmark run |
| Encryption · Encryption | |||
| 110 | Disk: AES-256-GCM seal (hardware) | 4,257 MB/s | Kernel measurement at start |
| 111 | Disk: AES-256-GCM open (hardware) | 3,995 MB/s | Kernel measurement at start |
| 112 | SHA-256 | 193 MB/s | Benchmark run |
| 113 | AES-256-GCM in an app | 57.5 MB/s | Benchmark run, software version; TLS in programs uses AES/PMULL since 11 Nov (section 6.6) |
| 114 | ChaCha20-Poly1305 in an app | 304.6 MB/s | Benchmark run, software version; TLS in programs uses NEON since 11 Nov (section 6.6) |
| 115 | Ed25519 signature checked | 195 µs | Benchmark run |
| 116 | Password check (Argon2id, 64 MiB) | 182 ms | Kernel measurement at start |
| 117 | ECDSA P-256 signature made | 1.0 ms | Benchmark run |
| 118 | ECDSA P-256 signature checked | 0.7 ms | Benchmark run |
| Network · Network | |||
| 120 | Name resolved (DNS over HTTPS) | 70 ms | Benchmark run |
| 121 | TLS 1.3 handshake | 66.4 ms | Benchmark run |
| 122 | HTTPS page fetched (example.com) | 113 ms | Benchmark run |
| Server, certificates · Server, certificates | |||
| 130 | Robot's root certificate made | 4.0 ms | Benchmark run |
| 131 | Server certificate issued by the root | 3.0 ms | Benchmark run |
| 132 | TLS 1.3 handshake, own server and client in memory | 2.4 ms | Benchmark run |
| 133 | TLS 1.3 data, server to client in memory | 56.1 MB/s | Benchmark run |
| 134 | HTTP request head read (browser request) | 3.4 µs | Benchmark run |
| 135 | QR code made (version 4) | 100 µs | Benchmark run |
| 136 | QR code made (version 10) | 0.4 ms | Benchmark run |
| Develop (Reflex) · Develop (Reflex) | |||
| 140 | Reflex: system shapes read (catalog) | 1.6 ms | Benchmark run |
| 141 | Reflex: example program compiled | 30.3 µs | Benchmark run |
| 142 | Reflex: periodic handler run (interpreter) | 0.3 µs | Benchmark run |
Further measurements from the boot log and handbook
| Measurement | Value | Where / how measured |
|---|---|---|
| System and programs | ||
| Start a program from the app cache | 53–56 µs | SOFTrobotsVM, phase 14 (first start approx. 2 ms); code and constants shared |
| Start and end a program (life cycle) | 0.77–0.80 ms | SOFTrobotsVM, handbook chapter 6 |
| Signature check per program at start / hashing all programs | 430 µs / 3.3 ms | Boot log 8 Nov 2026: 6 MiB, SHA-256 with processor instructions |
| Fair share with weights 2 : 1 | 2.0 | Boot log 8 Nov: 66 ms : 33 ms |
| Crypto in the kernel (boot log 8 Nov 2026) | ||
| SHA-256 with processor instructions | 2,149 MB/s | in a program without these instructions: 193 MB/s (Benchmark) |
| X25519 key exchange | 10,322 /s | handbook chapter 6 |
| ChaCha20-Poly1305 | 76 MB/s | Software, the kernel's self-test on 11 Nov 2026 (network-download.md; boot log 8 Nov: 57.8 MB/s) |
| Encryption in a program (11 Nov 2026, netbench, 8 MiB each) | ||
| ChaCha20 with NEON | 1,657–1,735 MB/s | SOFTrobotsVM, make vm-net-bench, two runs |
| ChaCha20-Poly1305 seal | 703–719 MB/s | same |
| AES-256-GCM with AES/PMULL | 4,594–4,896 MB/s | same; checked against the Swift version at the first connection |
| Argon2id per password check (64 MiB, 3 passes) | 182 ms | deliberately expensive: slows down guessing |
| Network and caches (Hb. 3.93, three runs each in SOFTrobotsVM) | ||
| 8 new names via DNS over HTTPS | 455 ms | the connection stays open, 64 names in the cache |
| 8 fetches from the same web server | 448 ms | Keep-alive |
| Hashing all programs at start (SHA-256 in hardware) | 3.4 ms | Hb. 3.93 |
| Media | ||
| Object detection per camera frame (int8, 3 cores) | 44 ms | SOFTrobotsVM; with a still picture 75 % of the runs are skipped (Hb. 3.93) |
| Decode JPEG 640 × 480 (camera frame) | 4 ms | SOFTrobotsVM, Camera |
| Unpack a password-protected ZIP / pack 6 files (10.3 MiB) | 61 / 655 ms | SOFTrobotsVM, AES in software |
| Draw a PDF page (one page of the datasheet) | ≈ 0.06 s | Mac, host test (Hb. 3.130) – not a VM value |
Video (10 Nov 2026, docs/benchmarks/video-playback.md) | ||
| Decode VP9 1080p per frame, 3 threads / 1 thread | 8.9 / 10.5 ms | SOFTrobotsVM, make vm-vp9-bench, 600 frames (section 6.12) |
| YUV → RGB conversion, 1080p per frame | 1.4 ms | SOFTrobotsVM; into a kept buffer 1.1 ms |
| 360p video at 60 frames/s: shown per second | 60 of 60 | SOFTrobotsVM, Big Buck Bunny |
Downloads (11 Nov 2026, make vm-net-bench, 100 MB, docs/benchmarks/network-download.md) | ||
| Own path: HTTP from a server on the Mac, no internet, no TLS | 110–218 MB/s | SOFTrobotsVM on the M3 Pro; around 190–200 MB/s on an idle Mac (section 6.6) |
| HTTPS from OVH | 35–59 MB/s | Mac on wired Ethernet, line 934 Mbit/s (≈ 117 MB/s) |
| HTTPS from Hetzner | 9–58 MB/s | varies a lot, open; curl on the Mac 80–96 MB/s from the same servers |
13Why it is fast – reasons and evidence
This section describes what makes SOFTrobots OS faster and how it is measured. We have not run comparison measurements against other systems; what is not measured but follows from the design is marked Design – without estimated factors.
| Building block | What we do differently | Evidence (measured) | Assessment |
|---|---|---|---|
| Start | Small kernel (1.21 MiB loaded), no probing for legacy devices, measurements and self-tests only after “Hello”, nothing on the boot path waits for the network. | 0.62 s until “Hello”, of which kernel ≈ 90 ms, the rest firmware and loader; boot animation 2.3 s; the time until the desktop is ready has not been measured with this animation | Most of the time is spent in firmware and loader, not in the kernel. |
| Interrupts and real time | Reserved real-time core without wfi, tickless timer in one-shot mode, short top halves, interruptible system calls, asynchronous log. |
IRQ 42.0 ns Ø, wake-up 0.5 µs Ø, 0 missed | Targets < 10 µs and < 20 µs met, also in the worst value of all runs (958 ns, 6.5 µs). Real time is a contract with admission, not a setting. |
| Context switch | Hot scheduler methods without struct copies, per-CPU state never in an Optional; lazy FP/SIMD. | 0.3 µs; the decision alone 0.2 µs | Target < 2 µs met. |
| Communication between programs | Channels are shared pages with two rings; the kernel never copies a message. If the other side is waiting, the wake-up call is skipped entirely. | 1.2–1.7 µs round trip (different cores; same core 6–8 µs); 2.5 M/s messages; notify 6.7 ns | Design no serialisation and no copy in the kernel. Target 1 µs: narrowly met in the median (0.9 µs), missed in 2 of 4 runs (1.07 and 1.24 µs). |
| Disk encryption | AES-256-GCM with the ARM crypto instructions in our own assembly (crypto.S), per block, with protection against played-back blocks. |
4,257 MB/s / 3,995 MB/s; software AES in a program 57.5 MB/s | Encryption is faster than the VM disk reads (reading from a program 149–154 MB/s): it is not the bottleneck. |
| Checksums and signatures | CRC-32C and SHA-256 with processor instructions; the app cache remembers checked programs. | SHA-256 2,149 MB/s; signature per program 430 µs | A checked program is not hashed again (app cache). |
| File system | No journal; block = page = tree node = DMA buffer; batched commit with FUA; no atime; small files in the tree; free-space map on disk. | 4 MiB 255 MB/s write, 779 MB/s read; 280 files in one commit 4.2 ms; mounting 11 ms | Design every change is written once, not twice; one flush + FUA per commit. Compared with other file systems this is not measured. |
| Database | File system commit = database commit; one system call per transaction; queries in the kernel; rings for measurements; large data as a file (8.4, 8.5). | Row by id 37.6 µs; 1,000 rows 9.8 ms; ring 2.4 M/s | Design one flush per small durable commit, no log of its own; large values are written once; measurements from real-time code without a system call. Compared with other databases this is not measured. |
| Memory | 16 KiB pages and 32 MiB blocks (fewer TLB misses), commitments instead of overcommitment, paging only into the program's own area; real time never paged out. | Memory copy 49,253 MB/s, fill 32,255 MB/s; heap object 67 ns | Design 16 KiB instead of 4 KiB: one TLB entry covers four times the area. The effect alone is not measured. |
| Network | Own stack in the kernel with interrupts instead of polling, window scaling, open connections for DoH and Web, Back from memory; 256 receive buffers in the driver, one device notification per batch, block copies, 8 KiB per read call, 4 MiB rings and 64 held ranges for downloads. | Ping 0.1 ms; 8 web fetches 448 ms; own path 110–218 MB/s, HTTPS from OVH 35–59 MB/s (100 MB, 11 Nov) | Internet downloads stay below what curl on the Mac gets from the same server (80–96 MB/s); the limit has not been found yet (section 2). |
| TLS in programs | AES-GCM with the AES/PMULL instructions, ChaCha20 with NEON in our own assembler (userland/tls/asm), checked against the Swift version at the first connection; the state is no longer copied onto the stack. |
AES-256-GCM 4,594–4,896 MB/s; ChaCha20-Poly1305 703–719 MB/s (11 Nov) | Both are far above the line at the test bench (117 MB/s). |
| Video | Decoding ahead and catching up in order, loop filter on 3 cores, colour conversion with SIMD, programs with a heap without strict alignment, Video built with -O. | Decode 1080p 8.9 ms, convert 1.4 ms per frame; 360p and 720p 60 of 60 frames | Together ≈ 10 ms of 16.7 ms per frame at 60 frames/s (VM, 10 Nov). |
| On-device detection | Own int8 inference with sdot assembly, spread over 3 cores; unchanged frames are not detected again. | 44 ms per frame; 75 % of the runs saved for a still picture | With the Mac camera about 10 detections per second, bit-exact to the reference (Hb. 3.93). |
| What we left out | No POSIX layer, no compatibility code, no compression in the file system (LZ4 measured and dropped), no 3D effects; in the VP9 decoder, SIMD loop filter and SIMD motion compensation measured and removed again (10 Nov). | LZ4: unpacking 600–1,200 MB/s (own codec, one core); SIMD loop filter 12–15 % slower, SIMD motion compensation without difference (Mac) | A fast SSD reads faster than LZ4 can unpack; that is why there is no compression in the file system. |
Statements marked “Design” describe how it is built (number of writes, flushes, copies) after docs/database-concept.md sections 5 and 9 and docs/decisions.md; none of it is measured against other systems.
14Limits
Fixed limits from the code (checked again on 14 Nov 2026 for threads, process slots, workers, heap, channels, capabilities and AI; the others on 8–11 Nov 2026) and from the handbook's overview of limits (as of 5 Nov 2026). Most of them are constants and can be raised if a use case requires it.
| Limit | Value |
|---|---|
| Processor | |
| Architecture | AArch64, 64-bit only; 16 KiB granule required |
| Cores | ≤ 8 CPUs; last core = real-time core |
| Threads | ≤ 256 in the system, 64 per CPU run queue |
| Main memory | |
| Managed RAM | ≤ 16 GiB (VM default 4 GiB) |
| Page / largest block | 16 KiB / 32 MiB |
| Heap per program | Default 256 MiB, memory = 16 … 2048 MiB; heap made of at most 512 pieces of ≤ 32 MiB each (≤ 16 GiB) |
| System reserve / peak cushion | 256 MiB / ≈ 3 % of RAM (64 MiB … 1 GiB) |
| Own paging area | 2 × commitment, at most 4 GiB |
| App stack | 64 KiB default, stack = 64 … 8192 KiB |
| Disk | |
| Partitions | EFI 64 MiB · SYSTEM_A 512 MiB · SYSTEM_B 512 MiB · DATA rest (GPT, 1 MiB alignment; new images since 11 Nov 2026, older ones with 2 GiB system sides) |
| Largest DATA volume | ≈ 1.99 TiB (1,024 map blocks × 130,560 blocks) |
| Name / path | 80 bytes UTF-8 / 255 bytes, 32 parts |
| Open files | 64 in the system, 16 per program; 16 KiB per read/write call |
| Block cache | DATA 32 MiB, system volume 512 KiB |
| Snapshots | every 15 min, 24 h / 7 d / 30 d, at most 400 |
| Programs | |
| Running at the same time | 127 (128 process slots, slot 0 = kernel) |
| Program file | ≤ 32 MiB ELF, ≤ 8 segments; program cache 32 entries |
| Worker threads | 7 per program (+ main thread) |
| Windows (drawing surfaces) | 3 per program, 16 in the system |
| Menus | 6 menu titles and 64 items per window; dock: 6 pinned |
| Document types (opens =) | 16 extensions per program (opens = and takes =); the kernel knows 24 types |
| Real-time contract | Period 100 µs … 1 s, utilisation ≤ 900 ‰ per core |
| Capabilities | 35 of 64 bits used |
| File dialog | ≤ 16 grants per program (as long as it runs), ≤ 3 dialogs at the same time, one open request per program |
| IPC | |
| Channels | 64 in the system |
| System calls | 14 numbers (0–13), upper limit 100 |
| Publications | 16 in the system, 1 per program, ≤ 2 subscriptions |
| Network | |
| TCP connections | 64 in the system (half of them for incoming); receive ring 128 KiB per connection, from 1 MiB received one of 4 rings of 4 MiB each (window scale 7); 64 held out-of-order ranges |
| Network reads | ≤ 8 KiB per system call (receive(area:); receive(into:) 1 KiB); virtio-net 256 receive buffers |
| Listeners | 8; backlog 16, 16 half-open per listener |
| UDP sockets | 4 in the system, 1,472 bytes per datagram |
| TLS connections | 4 per program (+ 1 for DNS over HTTPS) |
| DNS cache | 64 names per program |
| Database | |
| Tables / fields | 64 per database / 64 per table |
| Record | ≤ 4,096 bytes (all fields); large data as a file |
| Transaction | ≤ 4 MiB |
| Rows per query call | 256 (output ≤ 256 KiB, then cursor) |
| Sorting without an index | Top N ≤ 1,000 |
| Open databases | 4 per program, 32 in the system |
| Joins | 2 for WHERE/ORDER BY, 4 for display; sorting by a joined field with LIMIT ≤ 1,000 |
| Capture rings | 16 in the system, 1 … 600 s, ≤ 32 MiB |
| Devices | |
| USB classes | Allow list HID, CDC-ACM, UVC, signed vendor drivers; built: HID |
| Cameras | 4 at the same time |
| Graphics | |
| Screen | ≤ 8192 × 8192 (virtio-gpu); VM 1280 × 800 |
| Pictures | ≤ 2048 × 2048 pixels, ≤ 16 MiB per file |
| File ≤ 256 MiB, stream ≤ 64 MiB unpacked, nesting ≤ 32; preview in Files up to 32 MiB | |
| Camera / Video | Recording (Camera) in parts of 2 GB, stops when less than 2 GB of space is free; ≤ 4 million frames per file; VP9 ≤ 8192 × 8192; download from Web ≤ 64 MiB, ≤ 10 min |
| Language model: conversation memory | up to 32,768 positions (at most the model's limit), 16 bits; above 4,096 only as long as a quarter of this space stays free |
| Language model: size | Entirely in memory when file + memory + working memory + 64 MiB fit into the space (¾ of memory, at most what is free), with at least 1,024 positions. A larger model runs anyway: the fixed part stays in memory and the experts come from the disk through an expert cache (Settings › AI: “runs slower”); models without experts then read the whole file for every word. Formats Q8_0, Q4_K, Q6_K |
| Ask | question ≤ 512 characters; the last 30 conversations are kept, each can be deleted |
| Microphone | Ring ≈ 1.4 s per microphone, 48 kHz, 16 bits; level every 10 ms |
| Security | |
| Password | 8 … 64 characters; Argon2id 64 MiB, 3 passes |
| Screen lock | 1 … 1440 min or off (default 5) |
| System | |
| Boot until “Hello” | ≤ 1.0 s in SOFTrobotsVM (required by tests); QEMU ≤ 10 s |
| Crash reports / logs | 20 files / the last 10 starts, 1 MiB each |
15AI right in the device, no detours
Language models and object detection run in the system itself: own code from the model file to the answer, no cloud, no third-party AI program, no Python, no library such as llama.cpp in the device. A program asks a question through the App API and gets the answer from the memory of the same computer.
The path of a question
- One service for all:
ailoads the model once; programs with the rightai.use(in the signed manifest) talk to it over their own channel (AI.Session). No program loads a model of its own. - Own inference (
userland/llm, 2,265 lines of Swift): reading GGUF, tokenizer, transformer (architectures qwen2, qwen3, qwen3moe, llama, llama4, qwen3vl, kolibri1), formats Q8_0, Q4_K, Q6_K. The matrix products run in our own assembly with the ARM instructionssdotandsmmla(userland/infer/asm/kernels.S, 1,198 lines), spread over all cores for programs. - Images: Qwen3-VL with its own image encoder (
Vision.swift); Ask sends along an image from a file, dragged from Files or from the camera. - Memory follows the RAM: up to 32,768 positions, in 16 bits; the service says in advance whether a model fits entirely into memory or runs more slowly from the disk (sections 14 and 15.3).
Checked against the reference
- Host tests and
make vm-llm-checkcompare tokens and the greedy answer exactly with llama.cpp (Homebrew, CPU). - Perplexity (8 × 128 tokens): Qwen3-8B Q4_K_M 32.56, llama.cpp 32.50; Qwen2.5-1.5B Q4_K_M 39.18, llama.cpp 39.31 / 39.03 (12 Nov 2026).
- Images:
qwen3VLAnswerMatchesLlamaCppcompares withllama-mtmd-cli. - Object detection: the engine's 8-bit arithmetic is bit-exact to a NumPy reference (
make infer-check).
15.1 Measured: words per second in the device
With the measuring standard (SOFTrobotsVM, 4 CPUs, 3 of them for programs, 8 GiB, Mac on power, three runs on 15 Nov 2026, median; first answer / follow-up / quote): Qwen3-4B-Instruct-2507 31.3 / 29.7 / 46.3, first word after 0.54 s, 8,192 positions; Qwen2.5-Coder-7B 18.6 / 18.1 / 28.2, first word after 0.99 s, 4,096 positions. The table below is still from the runs with 7 CPUs (6 for programs) of 12 and 14 Nov; with more cores the same model writes faster.
SOFTrobotsVM with 7 CPUs (6 for programs), Mac on power; aicheck with four questions of at most 160 tokens each; values: first answer / follow-up question / quote. A “word” here is a token. All files checked with SHA-256 against Hugging Face. Source: docs/benchmarks/local-ai.md.
| Model | File | 4 GiB | 8 GiB | 16 GiB | first word |
|---|---|---|---|---|---|
| Qwen3-1.7B Q8_0 | 1,749 MiB | 56.5 / 57.1 / 70.0 | same | – | 0.17 s |
| Qwen3-4B-Instruct-2507 Q4_K_M | 2,381 MiB | 42.3 / 40.1 / 79.8 | 42.3 / 39.4 / 79.3 | 42.0 / 40.1 / 79.6 | 0.33 s |
| Qwen2.5-Coder-7B-Instruct Q4_K_M (14 Nov) | 4,466 MiB | does not fit | 24.8 / 24.7 / 48.9 | 23.3 / 23.1 / 47.0 | 0.57 s |
| Qwen3-8B Q4_K_M | 4,794 MiB | does not fit | 23.8 / 22.5 / 26.3 | 23.7 / 22.5 / 26.3 | 0.74 s |
| Qwen3-14B Q4_K_M | 8,584 MiB | does not fit | does not fit | 12.3 / 12.1 / 12.0 | 1.1 s |
Measured on 12 Nov 2026, Qwen2.5-Coder on 14 Nov 2026 (8 GiB with 4,096 positions, 16 GiB with 32,768). The speed depends on the model (memory bandwidth), not on the VM's memory size. For reference, a person reads about 5 words per second.
15.2 Measured next to llama.cpp (12 Nov 2026, 6 cores each)
| Model | llama.cpp answer | SOFTrobots answer | llama.cpp prompt | SOFTrobots prompt |
|---|---|---|---|---|
| Qwen2.5-0.5B Q8_0 | 164 | 163–173 | 1,046 tokens/s | ≈ 410 tokens/s |
| Qwen2.5-1.5B Q4_K_M | 62 | 93–105 (5 cores) | 117 tokens/s | ≈ 210 tokens/s |
| Qwen3-8B Q4_K_M | 14.3 | 22–25 | 24 tokens/s | ≈ 54 tokens/s |
Answer in words per second, prompt with 35 tokens. llama.cpp ran natively on the Mac (llama-bench -t 6 -ngl 0, CPU only), SOFTrobots in SOFTrobotsVM on the same Mac. For the small 8-bit model llama.cpp is faster on the prompt, for the 4-bit models SOFTrobots. llama.cpp with the graphics card (Metal) has not been compared.
15.3 Larger than memory: models with experts
Many large models are built from experts (mixture of experts): for each word a router picks only a few of them in every layer. When such a model does not fit into memory, the fixed part (attention, vectors, output head, shared expert) stays in memory; the rest is an expert cache, and whatever is missing the service reads from the disk. Kolibri-1 (Q4_K_M, 47.5 GB, 78 billion parameters, 3.46 billion of them active) uses 6 of 384 experts in every layer; one expert is 2.6 MB, and per word it reads about a twentieth of the file.
| Measurement | Value | Setting |
|---|---|---|
| In SOFTrobotsVM (Mac with Apple M3 Pro, 36 GB; 8 CPUs; model on an external SSD over USB; 18 Nov 2026) | ||
| Kolibri-1, VM with 18 GiB | 1.0–1.1 words/s | expert cache 8.7 GB |
| Kolibri-1, VM with 8 GiB | 0.4 words/s | |
| First question after a start (56 words), 18 GiB | 124 s | cache empty after the start |
| Waiting for the disk per word | 0.83 of 0.86 s | the VM's emulated disk ≈ 200 MB/s; computing 25 ms |
Checks of the AI service (aicheck), 18 GiB | all passed | |
| Engine as a tool directly on the Mac (Apple M3 Pro, 36 GB; SSD over USB, 10 Gb/s; read depth 4, LFU; 32 words per run; 18 Nov 2026) | ||
| Kolibri-1, cache 2 GB | 1.37 words/s | expert already in the cache: 79 % |
| Kolibri-1, cache 4 GB | 2.22 words/s | |
| Kolibri-1, cache 8 GB | 3.59 words/s | |
| Kolibri-1, cache 16 GB | 5.68 words/s | expert already in the cache: 97.8 %; three German test questions answered correctly (contradiction, summarising a letter, arithmetic) |
| Kolibri-1, cache 24 GB | 6.18 words/s | |
| Llama 4 Scout (65.4 GB, one expert 81 MB), cache 16–24 GB | 0.3–0.7 words/s | answers correctly |
All models 4-bit (Q4_K_M). A model without experts (a “dense” model) that is larger than memory runs too, but reads the whole file for every word. The system shows no estimated time; Settings › AI shows “runs slower: larger than the memory, read from the disk”, Ask shows “slower, from the disk” in its title and the real speed while answering. Source: handbook 3.166, docs/design/ki-ohne-grenzen.html.
15.4 Object detection and learning
- Camera is the eye: only Camera loads a detection model (built in: our own softrobots-base with 97 things, NanoDet design, trained on Open Images photos, CC BY 2.0; own int8 inference with
sdot, 3 cores): 44 ms per frame in SOFTrobotsVM, with the Mac camera about 10 detections per second; with a still picture 75 % of the runs are skipped. - No copy to other programs: the results are in a ring (
camera.detections) that the kernel maps read-only into other programs – Develop scripts, Server and real-time programs read the same pages. - Models in the standard format: Camera reads an ONNX model from
/models/detectiondirectly and turns it into 8 bits while loading. Models are not signed; if the engine doesn't know a building block, it refuses the model with a clear message. - Learning: Camera's learning window takes photos with boxes; training happens on the Mac (SOFTrobots Trainer, PyTorch on the Mac GPU), and the model comes back into the device as a plain ONNX file. There is no training in the device itself.
15.5 What leaves the device
- The AI service
aiand Ask have no network right (manifest withoutnetwork.outgoing): questions, answers, images and saved conversations stay in the device. - Models come only through the system program
modelget(rightmodels.install: network out and writing/models, nothing else), every file checked with SHA-256 against the catalogue. - Exception, named openly: Develop's assistant (Explain, Ask Develop) asks a service on the internet, through a helper of its own and only with a key set; the preview has none.