SOFTrobots OS
Technical datasheet · Operating system for desktop and robots on 64-bit ARM
Version0.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 of14 November 2026
ArchitectureAArch64 (ARMv8-A and newer), 64-bit only, UEFI + ACPI
LanguageEmbedded 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)
PurposeDesktop 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.
ManufacturerSOFTrobots GbR · info@softrobots.de · www.softrobots.de
0.62 sPower-on to “Hello from the kernel.” (required ≤ 1.0 s), of which kernel ≈ 90 ms
42.0 nsInterrupt latency, mean (worst 666 ns)
0.3 µsContext switch (target < 2 µs)
0.5 µsReal-time wake-up at 1 ms, mean, 0 missed periods
1.2–1.7 µsMessage round trip between two programs (different cores); on the same core 6–8 µs
4,257 MB/sDisk encryption AES-256-GCM, seal (processor instructions)
37.6 µsSOFTrobotsDB: one row by id, from a program
2.4 M/sReadings into the capture ring, without a system call, 0 dropped
35 formatsFile formats and codecs the system reads or writes – all with its own code (section 9)
975 + 954Declarations of App API 1 and of the libraries (docs/api/app-api-1.txt, libraries.txt; plus 136 for system programs only), counted 14 Nov 2026
581 + 31Host test functions (@Test) and device test targets in tools/test-all.sh, counted 14 Nov 2026
18.6 words/sQwen2.5-Coder 7B in the device, own inference, no cloud (SOFTrobotsVM, 4 CPUs, 8 GiB, 15 Nov 2026; section 15)
31.3 words/sQwen3-4B in the device (4 CPUs, 8 GiB, 15 Nov 2026), already with 4 GiB of memory (12 Nov 2026)
44 msObject detection per camera frame, int8 on 3 cores, bit-exact to the reference
110–218 MB/sThe system's own network path: 100 MB over HTTP from a server on the Mac, no internet, no TLS, 11 Nov 2026
35–59 MB/sHTTPS download of 100 MB from the internet (OVH), 11 Nov 2026
8.9 msVP9 video 1080p: decoding one frame in SOFTrobotsVM, 3 threads, 10 Nov 2026
60 of 60Frames per second for 360p video at 60 frames/s, 10 Nov 2026

Where 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

Start animation
Boot. The kernel's start animation: a small robot, below it the measured boot layers (2.3 s).
Desktop
Desktop. Window system as an EL0 service: menu bar, dock, cards, emergency stop button always visible.
Develop
Programming. Develop with the Reflex language: checking on every key press, simulation, provable real time.
Video
Video. On-device object detection (own int8 inference, models as ONNX without a signature), results as a ring for robot programs.

2Status and limits

Most important limit today: SOFTrobots OS runs only in virtual machines – in SOFTrobotsVM (our own macOS app on Apple Silicon using Virtualization.framework, the main environment) and in QEMU (-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), plus make 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

Layers of SOFTrobots OS (EL0 = user mode, EL1 = kernel mode) EL0 · PROGRAMS (signed, each with its own address space and folder) FilesFiles WebReading browser DevelopReflex VideoDetection ServerGate 443/80 DatabaseSOFTrobotsDB Benchmark80 measurements Robot-AppsReal time EL0 · SERVICES (isolated drivers and system services) displayWindow system usbinputXHCI, USB-HID actuatorsSafety limits canbusCAN FD timesyncNTS time watchdogLog rules System API: 13 basic calls (0–12) + shape call 13 (24 modules, every request checked against capabilities) EL1 · KERNEL (hybrid, Embedded Swift, no heap: -no-allocations) SchedulerEDF · prio · fair Memory16 KiB · W^X IPCRings · channels ProcessesAppCache SOFTrobotsFS+ SOFTrobotsDB NetworkIPv6/IPv4 · TCP CryptoTLS 1.3 · AES Emergency stopSafety DRIVERS IN THE KERNEL NVMeQueue per core virtiogpu · net · fs · rng GICv3Interrupts PCIeACPI MCFG PL011serial FramebufferGOP BOOT UEFI firmwareApple / edk2 EFI loader (C)Boot record A/B BootInfo128 bytes entry.SEL2→EL1, MMU on kernelMainSwift

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.

LanguageLinesShareWhere
Swift (Embedded Swift and Swift for the Mac)173,78591.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,2671.2 %shapes/ 2,171 (23 files) · program shapes in apps/ 96
Python (tools only)3,2171.7 %model converter, training, test data, datasheet; never runs in the system
Shell (tools only)3,2631.7 %test scripts, QEMU helpers, preview package, VM measurement
Assembly (AArch64)3,2041.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,3740.7 %boot/loader.c 573 · JavaScript cage 801 (userland/jscage)
C headers (own)9350.5 %BootInfo, EFI, arch.h, userland/include
JavaScript1,4580.8 %apps/web/prelude.js: page mirror for scripts in the cage
Reflex (.reflex)7560.4 %templates, guide and programs for Develop
Total own code190,259100 %
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.
Lines per language (own code) Lines Swift 173,785 Shape language 2,267 Python 3,217 Shell 3,263 Assembly 3,204 C 1,374 C headers 935 JavaScript 1,458 Reflex 756

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)

SectionBytesSizeContents
.text840,244821 KiBMachine code (R X, BTI-protected)
.rodata244,696239 KiBConstants, font masks of the start animation, embedded data (R)
.data184,161180 KiBinitialised variables (R W, never X)
Loaded image (file part)1,269,1011.21 MiBwhat the loader reads from disk
.bss31,745,58430.27 MiBfixed 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 / .stack2,293,7602.19 MiBPage table pool 2 MiB, early tables 64 KiB, boot stack 128 KiB
Debug information (.debug_*)6,102,9985.82 MiBfor 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).

FolderLines≈ CodeContents
kernel/core15,517≈ 319 KiBKernel logic: scheduler, memory, processes, system calls, shapes, channels, file dialog, preview, microphone, sound, emergency stop
kernel/fs (SOFTrobotsFS + DB)6,997≈ 144 KiBFile system, database, joins, series, snapshots, sealing
kernel/crypto5,106≈ 105 KiBSHA-2, HMAC/HKDF, AES-GCM, ChaCha20-Poly1305, X25519, Ed25519, ECDSA, RSA, X.509, TLS 1.3, DoH, NTS, Argon2id
kernel/arch/aarch643,442≈ 71 KiBMMU, exceptions, interrupts, SMP, timer; Swift 2,068 + assembly 1,374
kernel/lib3,558≈ 73 KiBhardware-independent, tested on the Mac (file types, manifest, page tables …)
drivers/2,700≈ 56 KiBNVMe, virtio (gpu, console, net, fs, sound, rng …), GICv3, PCIe, PL011, Framebuffer
kernel/net2,567≈ 53 KiBIPv6/IPv4, TCP (with 4 large receive rings), UDP, DHCP with renewal, DNS, mDNS
Total kernel + drivers39,887821 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.

ProgramKindCodeDataBSS (RAM)ELF file
webSystem1,225 KiB4,283 KiB2,036 KiB6,150 KiB
filesSystem834 KiB3,668 KiB1,575 KiB4,974 KiB
developSystem1,525 KiB1,966 KiB1,554 KiB4,314 KiB
imageSystem579 KiB3,036 KiB1,524 KiB4,005 KiB
reflexrunSystem416 KiB920 KiB1,548 KiB3,817 KiB
benchmarkSystem1,170 KiB1,895 KiB2,668 KiB3,746 KiB
readerSystem398 KiB2,970 KiB1,523 KiB3,691 KiB
displayService655 KiB1,732 KiB1,634 KiB2,829 KiB
cameraSystem508 KiB1,545 KiB1,527 KiB2,324 KiB
reflexrtSystem8 KiB1 KiB0 KiB2,117 KiB
aboutSystem114 KiB1,598 KiB1,524 KiB1,906 KiB
serverSystem363 KiB1,101 KiB3,991 KiB1,753 KiB
videoSystem533 KiB900 KiB1,527 KiB1,720 KiB
askSystem328 KiB911 KiB1,525 KiB1,541 KiB
settingsSystem213 KiB902 KiB1,524 KiB1,343 KiB
aiSystem367 KiB696 KiB1,256 KiB1,270 KiB
soundSystem190 KiB850 KiB1,525 KiB1,237 KiB
databaseSystem175 KiB855 KiB2,552 KiB1,209 KiB
devclaudeSystem152 KiB842 KiB1,765 KiB1,204 KiB
activitySystem151 KiB856 KiB1,524 KiB1,203 KiB
consoleSystem128 KiB849 KiB1,702 KiB1,132 KiB
chooserSystem93 KiB845 KiB1,521 KiB1,104 KiB
webjsSystem771 KiB109 KiB1,255 KiB1,097 KiB
monitorSystem79 KiB838 KiB1,565 KiB1,058 KiB
textSystem57 KiB845 KiB1,522 KiB1,056 KiB
modelgetSystem139 KiB182 KiB1,765 KiB522 KiB
timesyncService102 KiB146 KiB1,769 KiB394 KiB
watchdogSystem56 KiB64 KiB1,257 KiB266 KiB
usbinputService26 KiB30 KiB0 KiB159 KiB
actuatorsService24 KiB3 KiB1,255 KiB77 KiB
canbusService9 KiB0 KiB0 KiB54 KiB
Programs: code and data in the ELF file KiB, linear Code constants and data (including fonts) web 5.4 MiB files 4.4 MiB develop 3.4 MiB image 3.5 MiB reflexrun 1.3 MiB benchmark 3.0 MiB reader 3.3 MiB display 2.3 MiB camera 2.0 MiB about 1.7 MiB server 1.4 MiB video 1.4 MiB ask 1.2 MiB settings 1.1 MiB ai 1.0 MiB sound 1.0 MiB database 1.0 MiB devclaude 1.0 MiB activity 1.0 MiB console 1.0 MiB chooser 0.9 MiB webjs 0.9 MiB monitor 0.9 MiB text 0.9 MiB modelget 0.3 MiB timesync 0.2 MiB watchdog 0.1 MiB usbinput 0.1 MiB actuators 0.0 MiB canbus 0.0 MiB

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-vm fails 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 preview builds the product image without test programs, without development keys and without API keys, using mkimage --expires (default 25 Feb 2027, file /expires on 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-preview checks 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-number counts 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:

ClassMethodProperties
RealtimeEDF with a budget per period and admission controlPeriod 100 µs … 1 s; utilisation per core at most 900 ‰; if a contract does not fit, the program does not start at all
Interactivefixed prioritiesDesktop, services, ordinary programs; priority inheritance in the volume lock and IPC
BackgroundFair share by weightsWeights 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, restart or stop-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

ProtectionImplementation
Signed programs onlyEvery 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.
Capabilities32 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 folderWith 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 identityEvery 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 protectionArgon2id (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 protectionW^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 driversUSB 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>.local in 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.info reports features.aes, in the App API SystemStatus.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)MeasuredRemark
Own path: HTTP from the Mac, no internet, no TLS110–218 MB/saround 190–200 MB/s on an idle Mac; the range follows the Mac's load
HTTPS from OVH35–59 MB/salmost no packet loss; the next limit is not known yet
HTTPS from Hetzner9–58 MB/svaries from run to run – open, under investigation
curl on the Mac, same servers (comparison)80–96 MB/sshows 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)

CipherMeasuredfor reference: the same computation in Swift
ChaCha20 (NEON)1,657–1,735 MB/s373–376 MB/s
ChaCha20-Poly1305 (seal)703–719 MB/s287 MB/s
AES-256-GCM (AES/PMULL)4,594–4,896 MB/s46–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 srcset candidate for the screen (density or width descriptors) and enlarges bilinearly when needed. Boxes with overflow: auto or scroll keep the height of their content, because Web cannot scroll inside a box; overflow: hidden really 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.play gets 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: .shape files 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 frameSOFTrobotsVMMac (host test)
decode, 1 thread10.5 ms6.9 ms
decode, 3 threads8.9 ms3.3 ms
YUV → RGB conversion (SIMD)1.4 ms1.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.
Finding on strict alignment (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

MeasurementValueWhere / how measured
NVMe: one 16 KiB command read / write38.6 µs / 80.3 µsKernel at start, Benchmark 14 Nov 2026 (median of 4 runs)
NVMe sequential (256 KiB, 16 commands at the same time) read / write1,500 MB/s / 554 MB/sKernel at start; the VM disk is a file on the Mac
Commit of a new file3.3 msBoot log 8 Nov; almost entirely the flush of the VM disk
Commit of 280 new files in one go4.2 ms13 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 msonly superblocks and map blocks read (Hb. 3.58, 1 Nov 2026)
Check of all nodes after “Hello” (403 blocks)7.1 ms0 damage, 0 missing map bits (Hb. 3.58); runs in the diagnostics thread, does not slow down the boot
Node cache at start: hits / reads1,087 / 12 · 289 / 1System volume · DATA, boot log 8 Nov
Program: write / read a 4 MiB file126 MB/s / 99 MB/sBenchmark, via the system calls (16 KiB per call)
Create and delete a small file8.0 msBenchmark
List a folder entry374 µsBenchmark
Disk encryption AES-256-GCM seal / open4,257 MB/s / 3,995 MB/sKernel at start, bit-identical to the software reference, tampering detected
Why LZ4 compression was dropped (decision of 29 Oct 2026, measured on one core): our own codec packs at about 200 MB/s and unpacks at 600–1,200 MB/s – a fast SSD alone is 3 to 10 times faster than unpacking. Only code and text shrink (about 2×); photos, video, archives and anything encrypted do not (1.0–1.1), and that is most of the data. Compressed extents of variable size would have complicated the simple block mapping, checksums, copy-on-write and encryption (the compressed size reveals something about the contents).

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).

Path of a transaction: one system call, one root switch Program (EL0)Write package in its own memory Kernel: checkRules, reserve space apply in the cacheall or nothing CommitNodes, flush, superblock FUA No log that writes data a second time · no server process · no second cache · snapshots and the time slider see database and files of the same generation. Real-time programs write measurements into a ring without a system call; the recorder thread empties it into a series every 20 ms.

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 disk20.8 ms
1,000 rows “soon” (durable within 10 ms)9.8 ms
One row by id37.6 µs
Range over an index (100 rows)4.0 ms
Top 100 of 1,000 sorted without an index20.4 ms
Counting in groups (1,000 rows)2.6 ms
Translate an SQL statement0.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

LimitValueLimitValue
Record (all fields)≤ 4,096 bytes – large data as a file (8.5)Tables / fields64 per database / 64 per table
Key1–255 bytesWrite package (transaction)≤ 4 MiB, fully checked beforehand
Tree depth8 levels – with 100-byte rows far more than 10 billion rowsRows per query call256 (output ≤ 256 KiB), more via cursor
Sorting without an indexTop N ≤ 1,000Groups256, group value ≤ 32 bytes
Open databases4 per program, 32 in the systemSeries record8–1,024 bytes, ring 1–600 s, ≤ 32 MiB

8.4 Why the database is fast – and by how much

ReasonWhat it doesAdvantage
One layer instead of twoNo 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 transactionThe 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 dataFilters, 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 everythingThe 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 measurementsA 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-writeA 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.

A file field: 8 bytes in the row, the data in the file's extents ROW IN THE TABLE (≤ 4 KiB) id 7 name angle photoobject 4711 Indexes, filters, sorting and joins read only the row. The size of the file does not matter for that. Object 4711 (file) Identifier from a counter, never reused; renaming and moving change only folder entries EXTENTS (each up to 256 KiB) … 16 KiB blocks, each with CRC-32C or AES-256-GCM tag One superblock, one root switch: database tree and file extents hang off the same volume tree. A snapshot captures row and file of the same generation – the time slider always shows both matching each other. Largest file: the size is a 64-bit value, in practice limited by the volume (≈ 1.99 TiB). The row keeps 8 bytes for the field.

How it works (from the code)

  • A file field 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 == .file and isBelow(…, fileFieldRoot); the folder is set by DatabaseAccess.swift on 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 fieldAs ofWhere / remark
Field type file in the kernel: 8-byte object identifier, check “exists, is a file, in the program's folder”builtStage 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 filebuiltSchema.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 yetdocs/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 identifierplannedConcept 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 ConsoleplannedConcept 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).

The kernel checks the contents, not just the name: it knows 24 document types (since 10 Nov 2026 also “Reflex script”, .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
ReadWriteVariants: supported and notLimits and speed
Pictures
PNG
Image, Files, Web, SVG
yesyes 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
yesyes 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
yesyes 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
yesyes 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, PSDnono 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/EPSnono Not supported: no document type in the kernel.
Source: kernel/lib/FileTypes.swift
Video
Matroska (.mkv)
Video, Files
yesyes 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
yesno 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
yesyes 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, AVInono 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
yesyes 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
yesyes 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
yesyes 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, ALACnono 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
yesyes 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
yesyes 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, Zstandardnono 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
yesyes 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
yesyes 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
yesyes 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
yesyes 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
yesyes 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
yesyes 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
yesyes 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
yesyes 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
yesyes 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
yesMac 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, duration 2.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

Boot timeline in SOFTrobotsVM (seconds after power-on) 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0 1.1 1.2 Seconds UEFI firmware + EFI loader 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 ≈ 1.18 s (in the background, the boot does not wait)
Layer finishedSeconds after power-on
Firmware0.52 s
Kernel0.53 s
Devices0.55 s
Storage0.58 s
Network0.58 s
Programs0.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 wfi sleep.
  • 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)MeasuredTargetVerdict
IRQ latency (deadline → handler), mean42.0 ns< 10 µsmet
IRQ latency, worst666 ns< 10 µsmet
Context switch0.3 µs< 2 µsmet
Message round trip (IPC)1.2–1.7 µs< 1 µsnot met: 1.2–1.7 µs on different cores, 6–8 µs on the same one (F184)
Real-time wake-up at 1 ms, mean0.5 µs< 20 µsmet
Real-time wake-up at 1 ms, worst7.6 µs< 20 µsmet (the three runs: 7.6 / 3.0 / 3.0 µs)
Real-time program at 1 kHz: start delay mean / worst0.13 µs / 0.5–16 µs (during boot 26–77 µs)< 20 µsmet after the start
Missed periods in 10 s00met
Measured against our own target (target = red line) IRQ latency, average 0.4 % IRQ latency, worst (3 runs) 6.7 % Context switch 14.5 % Message there and back 120–170 % – above the target (different cores; same core 600–800 %) Real-time wake-up 1 ms, average 2.4 % Real-time wake-up, worst (3 runs) 37.9 % Three runs on 15 Nov 2026 in SOFTrobotsVM (4 CPUs, 8 GB, preview image, build 234), median; “worst” = the worst value of all runs.

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.

Measured in SOFTrobotsVM on Apple Silicon, host: Apple M3 Pro (Mac15,7), 36 GB, macOS 27.0.1. All numbers are the median of three runs on 15 Nov 2026 (version 0.15.0, build 234, the preview image, 4 CPUs, 8 GB, each run after a fresh start, Mac on power, wired network): 77 measurements (the others exist only in the test image); for “worst” the worst value of all runs. The kernel values come from the same starts. The message round trip (20) depends on whether the partner program lands on the same core: 1.2–1.7 µs on different cores, 6–8 µs on the same one (F184; the three runs here: 4.2 / 1.1 / 8.0 µs). Reading (61, 63) varies with the Mac's file cache. The “Measurement” column shows the English name from 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).

MeasurementM3 ProM4M4 against M3 Pro
Power on to “Hello from the kernel.”618 ms566 ms8 % shorter
Interrupt latency, mean42.0 ns28.0 ns33 % shorter
Context switch290 ns252 ns13 % shorter
Yield to the scheduler986 ns537 ns46 % shorter
Messages through a channel2.55 M/s3.58 M/s40 % more
System call (time)526 ns427 ns19 % shorter
CRC-32 over 16 MiB493 MB/s614 MB/s25 % more
Memory copy (32 MiB)49.3 GB/s43.0 GB/s13 % less
NVMe: read 16 KiB, one command38.6 µs9.27 µs76 % shorter
NVMe: sequential read1.50 GB/s3.78 GB/s152 % more
NVMe: write 16 KiB, one command80.3 µs82.0 µs2 % longer
NVMe: sequential write554 MB/s575 MB/s4 % more
App: 4 MiB file read99.0 MB/s344 MB/s247 % more
App: 4 MiB file written126 MB/s185 MB/s47 % more
Database: 1000 rows inserted (on disk)20.8 ms20.8 mssame*
Records pushed into the ring2.36 M/s2.72 M/s15 % more
JPEG 1024 × 1024 opened9.45 ms8.55 ms10 % shorter
Disk encryption AES-256-GCM seal4.26 GB/s5.08 GB/s19 % more
SHA-256193 MB/s281 MB/s46 % more
TLS 1.3 handshake in memory (own server and client)2.43 ms2.23 ms8 % shorter
Reflex: example program compiled30.3 µs25.2 µs17 % 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.MeasurementValueRemark
40CRC-32 over 16 MiB493 MB/sBenchmark run
41Floating point (matrix 128 x 128)3,709 M/sBenchmark run
42Memory copy (32 MiB)49,253 MB/sBenchmark run
43Memory fill (32 MiB)32,255 MB/sBenchmark run
44Heap: allocate and free an object67 nsBenchmark run
Processor and memory: throughput (higher is better) MB/s CRC-32 over 16 MiB 493 MB/s Memory copy 32 MiB 49,253 MB/s Memory fill 32 MiB 32,255 MB/s Encryption and checksums: throughput (higher is better) MB/s, linear AES-256-GCM seal (disk) 4,257 MB/s AES-256-GCM open (disk) 3,995 MB/s SHA-256 (processor instructions) 193 MB/s ChaCha20-Poly1305 304.6 MB/s AES-256-GCM in a program 57.5 MB/s

All measurements

No.MeasurementValueRemark
Start · Start
1Power on to "Hello from the kernel."0.62 sFirmware + loader + kernel until “Hello”
Scheduler, real time · Scheduler, realtime
10Interrupt latency, average42.0 nsKernel measurement at start
11Interrupt latency, worst666 nsKernel measurement at start
12Context switch0.3 µsBenchmark run
13Scheduling decision0.2 µsKernel measurement at start
14Realtime wake-up (1 ms), average0.5 µsat boot on the real-time core (from build 236; before on a program core, F185)
15Realtime wake-up (1 ms), worst7.6 µsthe 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
16Realtime periods missed at boot0Kernel measurement at start
17Sleep 1 ms: late by, average260 µsTimer resolution for programs
18Yield to the scheduler1.0 µsBenchmark run
Messages (IPC) · Messages (IPC)
20Message sent and received1.2–1.7 µsprograms on different cores (6 runs on 15 Nov 2026); on the same core 6–8 µs (F184)
21Wake the other end (notify)6.7 nsonly when the other side is asleep (F143)
22Messages through a channel2.5 M/sBenchmark run
Programs · Programs
30Start and end a program1.3 msonly in the test image: runs of 15 Nov 2026 (build 233, 4 CPUs, 8 GB)
31Start from the app cache81 µsonly in the test image: runs of 15 Nov 2026 (build 233, 4 CPUs, 8 GB)
32System call (time)526 nsBenchmark run
33System information read (system.info)3.1 µsBenchmark run
34Installed programs listed (all, with id and version)660 µsBenchmark run
Processor, memory · Processor, memory
40CRC-32 over 16 MiB493 MB/sBenchmark run
41Floating point (matrix 128 x 128)3,709 M/sBenchmark run
42Memory copy (32 MiB)49,253 MB/sBenchmark run
43Memory fill (32 MiB)32,255 MB/sBenchmark run
44Heap: allocate and free an object67 nsBenchmark run
Disk (NVMe) · Disk (NVMe)
50Read 16 KiB, one command38.6 µsKernel measurement at start
51Write 16 KiB, one command80.3 µsKernel measurement at start
52Sequential read (16 commands at once)1,500 MB/sKernel measurement at start
53Sequential write (16 commands at once)554 MB/sKernel measurement at start
File system · File system
60Kernel: 4 MiB written and committed255 MB/sKernel measurement at start
61Kernel: 4 MiB read and checked779 MB/sKernel measurement at start
62App: 4 MiB file written126 MB/sBenchmark run
63App: 4 MiB file read99 MB/sBenchmark run
64Small file created and removed8.0 msBenchmark run
65Folder entry listed374 µsBenchmark run
Database · Database
701000 rows inserted (on disk)20.8 msBenchmark run
711000 rows inserted (soon)9.8 msBenchmark run
72Row by id37.6 µsBenchmark run
73Range through an index (100 rows)4.0 msBenchmark run
74Sorted without an index (top 100 of 1000)20.4 msBenchmark run
75Count in groups (1000 rows)2.6 msBenchmark run
76SQL statement translated0.8 µsBenchmark run
Series, recording · Series, recording
80Records pushed into the ring2.4 M/sBenchmark run
81Records dropped (10 000 pushed)0Benchmark run
82Time range read back (1000 records)15.4 msBenchmark run
Pictures, ZIP · Pictures, ZIP
90PNG 1024 x 1024 saved67.7 msBenchmark run
91PNG 1024 x 1024 opened17.9 msBenchmark run
92JPEG 1024 x 1024 saved12.7 msBenchmark run
93JPEG 1024 x 1024 opened9.4 msBenchmark run
94Deflate (ZIP) 4 MiB240 MB/sBenchmark run
95GIF 512 x 512 opened2.2 msBenchmark run
96TIFF 1024 x 1024 saved79 msBenchmark run
97TIFF 1024 x 1024 opened28.9 msBenchmark run
98SVG drawing read and drawn (512 x 512)7.0 msBenchmark run
Display · Display
100Whole picture 1280 x 800 filled3,858/sBenchmark run
101Characters drawn6.3 M/sBenchmark run
102Window drawn and shownneeds windowneeds an open window; the run without a window skips it
103Key mapped (German layout, umlauts)4.3 nsBenchmark run
104Key typed into a text field10.1 nsBenchmark run
105Text field drawn17.2 µsBenchmark run
Encryption · Encryption
110Disk: AES-256-GCM seal (hardware)4,257 MB/sKernel measurement at start
111Disk: AES-256-GCM open (hardware)3,995 MB/sKernel measurement at start
112SHA-256193 MB/sBenchmark run
113AES-256-GCM in an app57.5 MB/sBenchmark run, software version; TLS in programs uses AES/PMULL since 11 Nov (section 6.6)
114ChaCha20-Poly1305 in an app304.6 MB/sBenchmark run, software version; TLS in programs uses NEON since 11 Nov (section 6.6)
115Ed25519 signature checked195 µsBenchmark run
116Password check (Argon2id, 64 MiB)182 msKernel measurement at start
117ECDSA P-256 signature made1.0 msBenchmark run
118ECDSA P-256 signature checked0.7 msBenchmark run
Network · Network
120Name resolved (DNS over HTTPS)70 msBenchmark run
121TLS 1.3 handshake66.4 msBenchmark run
122HTTPS page fetched (example.com)113 msBenchmark run
Server, certificates · Server, certificates
130Robot's root certificate made4.0 msBenchmark run
131Server certificate issued by the root3.0 msBenchmark run
132TLS 1.3 handshake, own server and client in memory2.4 msBenchmark run
133TLS 1.3 data, server to client in memory56.1 MB/sBenchmark run
134HTTP request head read (browser request)3.4 µsBenchmark run
135QR code made (version 4)100 µsBenchmark run
136QR code made (version 10)0.4 msBenchmark run
Develop (Reflex) · Develop (Reflex)
140Reflex: system shapes read (catalog)1.6 msBenchmark run
141Reflex: example program compiled30.3 µsBenchmark run
142Reflex: periodic handler run (interpreter)0.3 µsBenchmark run
Disk and file system: throughput (higher is better) MB/s, linear NVMe sequential read 1,500 MB/s NVMe sequential write 554 MB/s FS: write 4 MiB + commit 255 MB/s FS: read 4 MiB + check 779 MB/s App: write 4 MiB file 126 MB/s App: read 4 MiB file 99 MB/s NVMe reads come from the Mac's page cache (image file), not from the SSD. Short paths: times (shorter is better) Microseconds, linear Context switch 0.3 µs Real-time wake-up, mean 0.5 µs IPC round trip 1.2–1.7 µs NVMe read 16 KiB 38.6 µs DB: row by id 37.6 µs Start from the app cache 69–82 µs NVMe write 16 KiB 80.3 µs Database: times (shorter is better) Milliseconds, linear Insert 1,000 rows (disk) 20.8 ms Insert 1,000 rows (soon) 9.8 ms Range over an index 4.0 ms Top 100 without an index 20.4 ms Counting in groups 2.6 ms Translate SQL 0.8 µs

Further measurements from the boot log and handbook

MeasurementValueWhere / how measured
System and programs
Start a program from the app cache53–56 µsSOFTrobotsVM, phase 14 (first start approx. 2 ms); code and constants shared
Start and end a program (life cycle)0.77–0.80 msSOFTrobotsVM, handbook chapter 6
Signature check per program at start / hashing all programs430 µs / 3.3 msBoot log 8 Nov 2026: 6 MiB, SHA-256 with processor instructions
Fair share with weights 2 : 12.0Boot log 8 Nov: 66 ms : 33 ms
Crypto in the kernel (boot log 8 Nov 2026)
SHA-256 with processor instructions2,149 MB/sin a program without these instructions: 193 MB/s (Benchmark)
X25519 key exchange10,322 /shandbook chapter 6
ChaCha20-Poly130576 MB/sSoftware, 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 NEON1,657–1,735 MB/sSOFTrobotsVM, make vm-net-bench, two runs
ChaCha20-Poly1305 seal703–719 MB/ssame
AES-256-GCM with AES/PMULL4,594–4,896 MB/ssame; checked against the Swift version at the first connection
Argon2id per password check (64 MiB, 3 passes)182 msdeliberately expensive: slows down guessing
Network and caches (Hb. 3.93, three runs each in SOFTrobotsVM)
8 new names via DNS over HTTPS455 msthe connection stays open, 64 names in the cache
8 fetches from the same web server448 msKeep-alive
Hashing all programs at start (SHA-256 in hardware)3.4 msHb. 3.93
Media
Object detection per camera frame (int8, 3 cores)44 msSOFTrobotsVM; with a still picture 75 % of the runs are skipped (Hb. 3.93)
Decode JPEG 640 × 480 (camera frame)4 msSOFTrobotsVM, Camera
Unpack a password-protected ZIP / pack 6 files (10.3 MiB)61 / 655 msSOFTrobotsVM, AES in software
Draw a PDF page (one page of the datasheet)≈ 0.06 sMac, 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 thread8.9 / 10.5 msSOFTrobotsVM, make vm-vp9-bench, 600 frames (section 6.12)
YUV → RGB conversion, 1080p per frame1.4 msSOFTrobotsVM; into a kept buffer 1.1 ms
360p video at 60 frames/s: shown per second60 of 60SOFTrobotsVM, 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 TLS110–218 MB/sSOFTrobotsVM on the M3 Pro; around 190–200 MB/s on an idle Mac (section 6.6)
HTTPS from OVH35–59 MB/sMac on wired Ethernet, line 934 Mbit/s (≈ 117 MB/s)
HTTPS from Hetzner9–58 MB/svaries 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 blockWhat we do differentlyEvidence (measured)Assessment
StartSmall 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 animationMost of the time is spent in firmware and loader, not in the kernel.
Interrupts and real timeReserved 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 missedTargets < 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 switchHot scheduler methods without struct copies, per-CPU state never in an Optional; lazy FP/SIMD. 0.3 µs; the decision alone 0.2 µsTarget < 2 µs met.
Communication between programsChannels 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 nsDesign 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 encryptionAES-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/sEncryption is faster than the VM disk reads (reading from a program 149–154 MB/s): it is not the bottleneck.
Checksums and signaturesCRC-32C and SHA-256 with processor instructions; the app cache remembers checked programs. SHA-256 2,149 MB/s; signature per program 430 µsA checked program is not hashed again (app cache).
File systemNo 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 msDesign every change is written once, not twice; one flush + FUA per commit. Compared with other file systems this is not measured.
DatabaseFile 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/sDesign 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.
Memory16 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 nsDesign 16 KiB instead of 4 KiB: one TLB entry covers four times the area. The effect alone is not measured.
NetworkOwn 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 programsAES-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).
VideoDecoding 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 framesTogether ≈ 10 ms of 16.7 ms per frame at 60 frames/s (VM, 10 Nov).
On-device detectionOwn 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 pictureWith the Mac camera about 10 detections per second, bit-exact to the reference (Hb. 3.93).
What we left outNo 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.

LimitValue
Processor
ArchitectureAArch64, 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 block16 KiB / 32 MiB
Heap per programDefault 256 MiB, memory = 16 … 2048 MiB; heap made of at most 512 pieces of ≤ 32 MiB each (≤ 16 GiB)
System reserve / peak cushion256 MiB / ≈ 3 % of RAM (64 MiB … 1 GiB)
Own paging area2 × commitment, at most 4 GiB
App stack64 KiB default, stack = 64 … 8192 KiB
Disk
PartitionsEFI 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 / path80 bytes UTF-8 / 255 bytes, 32 parts
Open files64 in the system, 16 per program; 16 KiB per read/write call
Block cacheDATA 32 MiB, system volume 512 KiB
Snapshotsevery 15 min, 24 h / 7 d / 30 d, at most 400
Programs
Running at the same time127 (128 process slots, slot 0 = kernel)
Program file≤ 32 MiB ELF, ≤ 8 segments; program cache 32 entries
Worker threads7 per program (+ main thread)
Windows (drawing surfaces)3 per program, 16 in the system
Menus6 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 contractPeriod 100 µs … 1 s, utilisation ≤ 900 ‰ per core
Capabilities35 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
Channels64 in the system
System calls14 numbers (0–13), upper limit 100
Publications16 in the system, 1 per program, ≤ 2 subscriptions
Network
TCP connections64 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
Listeners8; backlog 16, 16 half-open per listener
UDP sockets4 in the system, 1,472 bytes per datagram
TLS connections4 per program (+ 1 for DNS over HTTPS)
DNS cache64 names per program
Database
Tables / fields64 per database / 64 per table
Record≤ 4,096 bytes (all fields); large data as a file
Transaction≤ 4 MiB
Rows per query call256 (output ≤ 256 KiB, then cursor)
Sorting without an indexTop N ≤ 1,000
Open databases4 per program, 32 in the system
Joins2 for WHERE/ORDER BY, 4 for display; sorting by a joined field with LIMIT ≤ 1,000
Capture rings16 in the system, 1 … 600 s, ≤ 32 MiB
Devices
USB classesAllow list HID, CDC-ACM, UVC, signed vendor drivers; built: HID
Cameras4 at the same time
Graphics
Screen≤ 8192 × 8192 (virtio-gpu); VM 1280 × 800
Pictures≤ 2048 × 2048 pixels, ≤ 16 MiB per file
PDFFile ≤ 256 MiB, stream ≤ 64 MiB unpacked, nesting ≤ 32; preview in Files up to 32 MiB
Camera / VideoRecording (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 memoryup 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: sizeEntirely 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
Askquestion ≤ 512 characters; the last 30 conversations are kept, each can be deleted
MicrophoneRing ≈ 1.4 s per microphone, 48 kHz, 16 bits; level every 10 ms
Security
Password8 … 64 characters; Argon2id 64 MiB, 3 passes
Screen lock1 … 1440 min or off (default 5)
System
Boot until “Hello”≤ 1.0 s in SOFTrobotsVM (required by tests); QEMU ≤ 10 s
Crash reports / logs20 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: ai loads the model once; programs with the right ai.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 instructions sdot and smmla (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-check compare 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: qwen3VLAnswerMatchesLlamaCpp compares with llama-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.

ModelFile4 GiB8 GiB16 GiBfirst word
Qwen3-1.7B Q8_01,749 MiB56.5 / 57.1 / 70.0same–0.17 s
Qwen3-4B-Instruct-2507 Q4_K_M2,381 MiB42.3 / 40.1 / 79.842.3 / 39.4 / 79.342.0 / 40.1 / 79.60.33 s
Qwen2.5-Coder-7B-Instruct Q4_K_M (14 Nov)4,466 MiBdoes not fit24.8 / 24.7 / 48.923.3 / 23.1 / 47.00.57 s
Qwen3-8B Q4_K_M4,794 MiBdoes not fit23.8 / 22.5 / 26.323.7 / 22.5 / 26.30.74 s
Qwen3-14B Q4_K_M8,584 MiBdoes not fitdoes not fit12.3 / 12.1 / 12.01.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)

Modelllama.cpp answerSOFTrobots answerllama.cpp promptSOFTrobots prompt
Qwen2.5-0.5B Q8_0164163–1731,046 tokens/s≈ 410 tokens/s
Qwen2.5-1.5B Q4_K_M6293–105 (5 cores)117 tokens/s≈ 210 tokens/s
Qwen3-8B Q4_K_M14.322–2524 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.

MeasurementValueSetting
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 GiB1.0–1.1 words/sexpert cache 8.7 GB
Kolibri-1, VM with 8 GiB0.4 words/s
First question after a start (56 words), 18 GiB124 scache empty after the start
Waiting for the disk per word0.83 of 0.86 sthe VM's emulated disk ≈ 200 MB/s; computing 25 ms
Checks of the AI service (aicheck), 18 GiBall 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 GB1.37 words/sexpert already in the cache: 79 %
Kolibri-1, cache 4 GB2.22 words/s
Kolibri-1, cache 8 GB3.59 words/s
Kolibri-1, cache 16 GB5.68 words/sexpert already in the cache: 97.8 %; three German test questions answered correctly (contradiction, summarising a letter, arithmetic)
Kolibri-1, cache 24 GB6.18 words/s
Llama 4 Scout (65.4 GB, one expert 81 MB), cache 16–24 GB0.3–0.7 words/sanswers 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/detection directly 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 ai and Ask have no network right (manifest without network.outgoing): questions, answers, images and saved conversations stay in the device.
  • Models come only through the system program modelget (right models.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.