SOFTrobots OS
Technisches Datenblatt · Betriebssystem für Desktop und Roboter auf 64-Bit-ARM
Version0.15.0 (Phase 15) mit Build-Nummer: Images tragen „0.15.0+N“, About und Desktop zeigen „0.15.0 · Build N“ – SYSTEM_VERSION aus kernel/core/Version.swift, Build-Nummer aus tools/build-number
Stand14. November 2026
ArchitekturAArch64 (ARMv8-A und neuer), nur 64 Bit, UEFI + ACPI
SpracheEmbedded Swift (Kernel, Treiber, Programme); C im EFI-Loader und im Käfig für JavaScript; Assembler nur wo nötig; einziger fremder Code: QuickJS-ng (JavaScript, nur im Käfig)
ZweckDesktop-System mit eigenen Programmen (ca. 70 %) und Roboter als starker Teil (ca. 30 %), Ausrichtung seit 13.11.2026.
Leitlinien: Echtzeit, Sicherheit und Geschwindigkeit ohne Kompromiss, nur moderne Hardware, kein Altlasten-Code.
HerstellerSOFTrobots GbR · info@softrobots.de · www.softrobots.de
0,62 sEinschalten bis „Hello from the kernel.“ (Pflicht ≤ 1,0 s), davon Kernel ≈ 90 ms
42,0 nsInterrupt-Latenz im Mittel (schlechteste 666 ns)
0,3 µsKontextwechsel (Ziel < 2 µs)
0,5 µsEchtzeit-Aufwachen 1 ms, Mittel, 0 verpasste Perioden
1,2–1,7 µsNachricht hin und zurück zwischen zwei Programmen (verschiedene Kerne); auf demselben Kern 6–8 µs
4257 MB/sPlattenverschlüsselung AES-256-GCM, versiegeln (Prozessorbefehle)
37,6 µsSOFTrobotsDB: eine Zeile nach Id, aus einem Programm
2,4 Mio./sMesswerte in den Aufnahme-Ring, ohne Systemaufruf, 0 verworfen
35 FormateDateiformate und Codecs, die das System liest oder schreibt – alle mit eigenem Code (Abschnitt 9)
975 + 954Deklarationen der App-API 1 und der Bibliotheken (docs/api/app-api-1.txt, libraries.txt; dazu 136 nur für Systemprogramme), gezählt 14.11.2026
581 + 31Host-Testfunktionen (@Test) und Gerätetest-Ziele in tools/test-all.sh, gezählt 14.11.2026
18,6 Wörter/sQwen2.5-Coder 7B im Gerät, eigene Inferenz, ohne Cloud (SOFTrobotsVM, 4 CPUs, 8 GiB, 15.11.2026; Abschnitt 15)
31,3 Wörter/sQwen3-4B im Gerät (4 CPUs, 8 GiB, 15.11.2026), schon mit 4 GiB Speicher (12.11.2026)
44 msObjekterkennung je Kamerabild, int8 auf 3 Kernen, bit-genau zur Referenz
110–218 MB/sEigener Netzweg des Systems: 100 MB per HTTP von einem Server auf dem Mac, ohne Internet und TLS, 11.11.2026
35–59 MB/sHTTPS-Download 100 MB aus dem Internet (OVH), 11.11.2026
8,9 msVP9-Video 1080p: ein Bild dekodieren in SOFTrobotsVM, 3 Threads, 10.11.2026
60 von 60Bilder je Sekunde bei 360p-Video mit 60 Bildern/s, 10.11.2026

Wo gemessen: Wenn nicht anders vermerkt, stammen alle Messwerte aus SOFTrobotsVM (eigene macOS-App mit Virtualization.framework, 4 virtuelle CPUs, 8 GB RAM – unser fester Standard für Messungen seit 15.11.2026) auf dem Host Apple M3 Pro (Mac15,7), 36 GB, macOS 27.0.1, Version 0.15.0 (Build 234), das Abbild der Vorschau zum Herunterladen, Mac am Netzteil und per Kabel am Netz, ohne andere VM. Die Benchmark-Werte sind der Median aus drei Läufen am 15.11.2026, jeder nach einem frischen Start (docs/benchmarks/2026-11-15-m3pro-preview-4cpu-8gb-run1…3.csv); bei „schlechteste“ steht der schlechteste Wert aller Läufe. Dieselbe Vorschau auf einem Mac mini M4 steht in Abschnitt 12.1. Werte aus anderen Läufen nennen ihren Handbuch-Abschnitt (z. B. „Hb. 3.93“); die Messungen vom 10.11.2026 zu Video stehen in docs/benchmarks/video-playback.md, die vom 11.11.2026 zu Netz und Verschlüsselung (Downloads von 100 MB mit make vm-net-bench, Mac per Kabel am Netz) in docs/benchmarks/network-download.md. QEMU-Zeiten sind Emulationswerte und hier nicht aufgeführt; Mac-Werte sind als solche gekennzeichnet. Hervorgehobene Zahlen sind Messwerte. Bauart markiert eine Angabe, die aus dem Aufbau folgt und nicht gemessen ist; Vergleiche mit anderen Systemen haben wir nicht gemessen und nennen darum keine Faktoren – einzige Ausnahme sind die Sprachmodelle, die neben llama.cpp gemessen sind (Abschnitt 15.2).

1Bilder

Start-Animation
Boot. Die Start-Animation des Kernels: ein kleiner Roboter, unten die gemessenen Boot-Schichten (2,3 s).
Desktop
Desktop. Fenstersystem als EL0-Dienst: Menüleiste, Dock, Karten, Not-Halt-Knopf immer sichtbar.
Develop
Programmierung. Develop mit der Sprache Reflex: Prüfung bei jeder Taste, Simulation, beweisbare Echtzeit.
Video
Video. Objekterkennung im Gerät (eigene int8-Inferenz, Modelle als ONNX ohne Signatur), Ergebnisse als Ring für Roboterprogramme.

2Stand und Grenzen

Wichtigste Grenze heute: SOFTrobots OS läuft nur in virtuellen Maschinen – in SOFTrobotsVM (eigene macOS-App auf Apple Silicon mit Virtualization.framework, Hauptumgebung) und in QEMU (-M virt, für Fehlersuche und automatische Tests). Es gibt noch keine echte Hardware, also auch keine echten Motortreiber, Kameras über USB (UVC), SMMU, MTE oder TPM. Alle Zeiten sind VM-Zeiten auf einem Mac; auf einem Roboter-Rechenmodul können sie anders ausfallen. Echte Hardware ist Phase 16, die Roboter-API mit ROS-2-Bedeutung und Zenoh Phase 17.

Was heute funktioniert (Phasen 0–15 abgeschlossen, Stand 14.11.2026)

  • Eigener EFI-Loader, Systemkopien A/B mit Updates und automatischem Rückfall; Vorschau zum Herunterladen mit Ablaufdatum (10.11.); Systemseiten 512 MiB in neuen Images und Build-Nummer (11.11.)
  • Kernel mit SMP, tickless Scheduler pro Kern, EDF-Echtzeit mit Zulassungsprüfung, reservierter Echtzeitkern; Systemaufrufe unterbrechbar (F143)
  • 16-KiB-Seiten, W^X, PAN/PAC/BTI, Stack-Canaries, Guard Pages
  • Programme auf EL0, nur signiert (Ed25519), 35 Rechte aus dem signierten Manifest
  • Zero-Copy-IPC über gemeinsame Ringe, 14 nummerierte Systemaufrufe (Formaufruf 13 trägt 24 Module)
  • SOFTrobotsFS (Copy-on-Write, B+-Bäume, CRC-32C, AES-256-GCM je Block, Snapshots, Zeitregler)
  • SOFTrobotsDB im Dateisystem: Tabellen, Indexe, Abfragen, Joins in WHERE und ORDER BY (09.11.), SQL, Serien, Flugschreiber
  • Geräteschutz: Argon2id-Passwort, Wiederherstellungsschlüssel, Bildschirmsperre
  • Eigener Netzwerk-Stack: IPv6 (SLAAC), IPv4 (DHCP mit Erneuerung), TCP mit SACK (64 gemerkte Bereiche), CUBIC und 4-MiB-Empfangsringen für Downloads (11.11.), UDP, mDNS
  • Eigene Kryptobibliothek, TLS 1.3 als Client und Server (mit KeyUpdate, 09.11.; AES-256-GCM mit SHA-384, in Programmen AES/PMULL- und NEON-Befehle, 11.11.), DNS über HTTPS, NTS-Zeit
  • 2D-Desktop mit Fenstern, Menüs, Dock, Hell/Dunkel, Maßstab 2; seit 10.11.: ein Öffnen-/Sichern-Dialog für alle Programme, Fortschritt für alle Programme, Speicherfenster, Fensterknöpfe und Laschen im Dock
  • Programme: Files, Web (mit JavaScript in einem Käfig, 13.11.), Image (mit Inspektor für EXIF, GPS und Farbprofil, 14.11.), Reader (PDF), Text, Console, Database, Benchmark, Activity, Monitor, Settings, Camera (Erkennen, Lernen, Aufnehmen), Video (Abspielen; Camera und Video getrennt am 14.11.), Sound, Ask (Sprechblasen, Bilder, gespeicherte Gespräche, 14.11.), Develop, Server, Datei-Dialog
  • 35 Dateiformate und Codecs mit eigenem Code, u. a. PDF mit Verschlüsselung und Scans, VP9 (1080p auf 3 Kernen), Opus, FLAC (Abschnitt 9)
  • Ton: Ausgabe mit Mischer im Kernel, Mikrofon mit immer sichtbarer Anzeige (09.11.)
  • Abstürze: Der Kernel schreibt Berichte, Monitor › Report blättert durch alle aufbewahrten (Older/Newer); der Watchdog-Dienst (Buddy) meldet jeden Absturz, auch die vor seinem Start (11.11.)
  • Roboter: Not-Halt im Kernel, Aktor-Dienst mit Sicherheitsgrenzen, CAN-FD-Dienst, simulierter 6-Achs-Arm
  • Develop mit der eigenen Sprache Reflex: Projekte als Ordner, Prüfung bei jeder Taste, Run mit Vorschau, Formulare und gespeicherte Listen, Echtzeit-Beweis vorab, „Save as Program“ erzeugt ein signiertes ARM64-Programm (auch für den Echtzeitkern)
  • KI im Gerät: eigene Inferenz für Sprachmodelle (Qwen2.5, Qwen3, Qwen3-VL mit Bildern, DeepSeek-R1-Distill, Qwen2.5-Coder 7B seit 14.11.) und für Objekterkennung, ein KI-Dienst für alle Programme (Abschnitt 15)
  • Tests: 581 Host-Testfunktionen (Swift Testing) und 31 automatische Gerätetest-Ziele in QEMU/SOFTrobotsVM (tools/test-all.sh), dazu make test-preview

Bewusst nicht enthalten

POSIX- oder Linux-Kompatibilität, 32 Bit, BIOS, SATA/IDE, Bluetooth, USB-Klassen außerhalb der Erlaubnisliste, mehrere Benutzer, 3D-Grafik, andere UI-Sprachen als Englisch. Noch offen oder später: Signaturprüfung des Kernels im Loader, gebündeltes TRIM, QUIC/HTTP/2/HTTP/3, SMMU (DMA-Isolation der Treiberdienste), MTE, TPM-Bindung, GROUP BY über verknüpfte Felder, Datei-Felder in der App-API (Abschnitt 8.5), AV1 (mit Hardware), Opus- und MP3-Aufnahme.

Bekannte offene Punkte (Stand 14.11.2026)

  • Downloads von Hetzner schwanken zwischen 9 und 58 MB/s, auch in Läufen fast ohne Paketverlust, während curl auf dem Mac vom selben Server 80–96 MB/s holt. Ursache noch nicht gefunden; ein Paketmitschnitt auf der Mac-Seite steht aus. Auch bei OVH (35–59 MB/s, fast ohne Verlust) ist die nächste Grenze noch nicht bekannt.
  • Netz weg nach etwa 50 Minuten (F149): Einmal fand Web nach rund 50 Minuten keine Namen mehr. DHCP-Erneuerung, neue Log-Zeilen und Buddys Regel 13 sind gebaut. Ein Dauertest über 75 Minuten (11.11.) kam in 74 von 74 Runden durch; seitdem nicht wieder gesehen. Die Ursache ist nicht bewiesen.
  • Ein Update schlug einmal fehl (F155, „no room for the new copy“) und ließ sich nicht wiederholen. Die Meldung stand für drei verschiedene Fehler; jeder schreibt jetzt seinen eigenen Grund ins Log. In fünf weiteren Läufen kam der Fehler nicht wieder.
  • Speicher kopieren 48,7 GB/s (Benchmark 14.11.): gemessen, aber nicht erklärt – der Wert liegt weit über dem, was frühere Läufe zeigten, ohne dass eine Änderung am Kopieren bekannt ist. Bis zur Klärung mit Vorsicht lesen.

3Architektur-Überblick

Schichten von SOFTrobots OS (EL0 = Benutzer-Modus, EL1 = Kernel-Modus) EL0 · PROGRAMME (signiert, je eigener Adressraum und Ordner) FilesDateien WebLese-Browser DevelopReflex VideoErkennung ServerTor 443/80 DatabaseSOFTrobotsDB Benchmark80 Messungen Robot-AppsEchtzeit EL0 · DIENSTE (isolierte Treiber und Systemdienste) displayFenstersystem usbinputXHCI, USB-HID actuatorsSicherheitsgrenzen canbusCAN FD timesyncNTS-Zeit watchdogLog-Regeln System-API: 13 Grundbefehle (0–12) + Formaufruf 13 (24 Module, jede Anfrage gegen Capabilities geprüft) EL1 · KERNEL (hybrid, Embedded Swift, kein Heap: -no-allocations) SchedulerEDF · Prio · Fair Speicher16 KiB · W^X IPCRinge · Kanäle ProzesseAppCache SOFTrobotsFS+ SOFTrobotsDB NetzwerkIPv6/IPv4 · TCP KryptoTLS 1.3 · AES Not-HaltSafety TREIBER IM KERNEL NVMeQueue je Kern virtiogpu · net · fs · rng GICv3Interrupts PCIeACPI MCFG PL011seriell FramebufferGOP START UEFI-FirmwareApple / edk2 EFI-Loader (C)Boot-Record A/B BootInfo128 Bytes entry.SEL2→EL1, MMU an kernelMainSwift

Hybrid-Kernel: Alles, was schnell und vertrauenswürdig sein muss – Scheduler, Speicher, IPC, Dateisystem, NVMe, Netzwerk und Krypto – läuft im Kernel (EL1). Riskante Teile wie USB und Grafik laufen als isolierte Dienste auf EL0. Programme sprechen nur über die System-API mit dem Kernel; eine POSIX- oder Linux-Schicht gibt es bewusst nicht. Der Kernel ist für die Higher Half (0xFFFFFFFF80000000) gelinkt und an 0x8000_0000 geladen; jeder Abschnitt beginnt auf einer 16-KiB-Grenze und ist W^X abgebildet.

4Programmiersprachen

Gezählt mit wc -l über den Quellbaum (ohne build/, Paket-Caches und docs/), Stand 14.11.2026. Zeilen einschließlich Kommentaren; fremder Code steht getrennt.

SpracheZeilenAnteilWo
Swift (Embedded Swift und Swift für den Mac)173 78591,3 %Kernel 35 813 · Treiber 2 700 · Laufzeit userland/ 56 556 · Programme apps/ 54 617 · Mac-Werkzeuge 7 950 · Host-Tests 16 075
Formsprache (.shape)2 2671,2 %shapes/ 2 171 (23 Dateien) · Programmformen in apps/ 96
Python (nur Werkzeuge)3 2171,7 %Modellkonverter, Training, Testdaten, Datenblatt; läuft nie im System
Shell (nur Werkzeuge)3 2631,7 %Testskripte, QEMU-Helfer, Vorschau-Paket, VM-Messung
Assembler (AArch64)3 2041,7 %Kernel 1 374: entry.S 343, sysreg.S 383, crypto.S 283, context.S 261, vectors.S 104 · Programme 1 830: infer/asm/kernels.S 1 198 (sdot, smmla für KI), tls/asm 439 (AES-GCM, ChaCha20), crt0.S 193
C (eigener Code)1 3740,7 %boot/loader.c 573 · Käfig für JavaScript 801 (userland/jscage)
C-Header (eigene)9350,5 %BootInfo, EFI, arch.h, userland/include
JavaScript1 4580,8 %apps/web/prelude.js: Seitenabbild für Skripte im Käfig
Reflex (.reflex)7560,4 %Vorlagen, Anleitung und Programme für Develop
Summe eigener Code190 259100 %
Fremder Code: QuickJS-ng (MIT)82 889–third_party/quickjs-ng, 72 243 Zeilen C und 10 646 Header; die JavaScript-Maschine von Web, läuft nur im Käfig (sechs Systemaufrufe). Nicht in der Summe.
Zeilen je Sprache (eigener Code) Zeilen Swift 173 785 Formsprache 2 267 Python 3 217 Shell 3 263 Assembler 3 204 C 1 374 C-Header 935 JavaScript 1 458 Reflex 756

Embedded Swift

Kernel, Treiber, Dienste und Programme. Toolchain swift.org 6.4.1 (über swiftly), Ziel aarch64-none-none-elf. Im Kernel: keine Klassen auf heißen Pfaden (kein ARC), kein Heap (-no-allocations), kein async/await, -Osize. Unsicherer Zeiger- und Registerzugriff nur in kernel/arch/ und drivers/. Hardwareunabhängiger Code in kernel/lib/ läuft auch als normales Swift auf dem Mac (Host-Tests).

Assembler – nur wo nötig

entry.S (Einstieg, EL2→EL1, frühe Seitentabellen), vectors.S (Exception-Vektoren), context.S (Kontextwechsel), sysreg.S (Systemregister, Swift hat keinen Inline-Assembler) und crypto.S (AES/PMULL für die Platte, SHA-256 mit Prozessorbefehlen – reine Geschwindigkeit). In Programmen: crt0.S, die sdot/smmla-Kerne für Erkennung und Sprachmodelle und AES-GCM/ChaCha20 für TLS.

C – dokumentierte Ausnahmen

Der EFI-Loader (boot/loader.c, PE/COFF), der Käfig um die JavaScript-Maschine QuickJS-ng (userland/jscage; QuickJS-ng selbst ist fremder C-Code, MIT-Lizenz, Entscheidung vom 13.11.2026) und Header, die Hardware- und ABI-Strukturen beschreiben (bootinfo.h, arch.h). Die BootInfo-Struktur wird in C per _Static_assert und in Swift per Host-Test geprüft.

Eigene Sprachen

.shape: eine Definition für API, Kernel-Prüfcode, Datenbanktabellen, Ringe und Netz (Werkzeug shapec). Reflex: die Skriptsprache von Develop, im System selbst übersetzt.

5Größen

Kernel (build/kernel/kernel.elf, Build vom 14.11.2026, 20:56 Uhr)

AbschnittBytesGrößeInhalt
.text840 244821 KiBMaschinencode (R X, BTI-geschützt)
.rodata244 696239 KiBKonstanten, Schriftmasken der Start-Animation, eingebettete Daten (R)
.data184 161180 KiBvorbelegte Variablen (R W, nie X)
Geladenes Abbild (Datei-Anteil)1 269 1011,21 MiBwas der Loader von der Platte liest
.bss31 745 58430,27 MiBfeste Tabellen im RAM (128 Prozessplätze, 256 Threads, Puffer, 4 TCP-Empfangsringe zu 4 MiB); belegt keinen Platz in der Datei
.page_table_pool / .boot_tables / .stack2 293 7602,19 MiBSeitentabellen-Vorrat 2 MiB, frühe Tabellen 64 KiB, Boot-Stack 128 KiB
Debug-Informationen (.debug_*)6 102 9985,82 MiBnur zum Symbolisieren; ELF-Datei gesamt 7 829 424 Bytes

EFI-Loader (build/boot/BOOTAA64.EFI, Build vom 12.11.2026): 17 408 Bytes; 573 Zeilen C. Disk-Image: 8 GiB (sparse); neue Images seit 11.11.2026: EFI 64 MiB · SYSTEM_A 512 MiB · SYSTEM_B 512 MiB · DATA Rest (im 8-GB-Image 6,9 GiB; das System belegt 54 MiB). Ältere Images behalten Systemseiten zu 2 GiB (Abschnitt 6.1). Gemessen mit llvm-size.

Kernel-Bausteine

Zeilen gezählt (14.11.2026, Swift und Assembler); der Code-Anteil ist eine Näherung (.text anteilig nach Quellzeilen verteilt, berechnet, nicht aus der Link-Map gemessen).

OrdnerZeilen≈ CodeInhalt
kernel/core15 517≈ 319 KiBKernel-Logik: Scheduler, Speicher, Prozesse, Systemaufrufe, Formen, Kanäle, Datei-Dialog, Vorschau, Mikrofon, Ton, Not-Halt
kernel/fs (SOFTrobotsFS + DB)6 997≈ 144 KiBDateisystem, Datenbank, Joins, Serien, Snapshots, Versiegelung
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 + Assembler 1 374
kernel/lib3 558≈ 73 KiBhardwareunabhängig, auf dem Mac getestet (Dateitypen, Manifest, Seitentabellen …)
drivers/2 700≈ 56 KiBNVMe, virtio (gpu, console, net, fs, sound, rng …), GICv3, PCIe, PL011, Framebuffer
kernel/net2 567≈ 53 KiBIPv6/IPv4, TCP (mit 4 großen Empfangsringen), UDP, DHCP mit Erneuerung, DNS, mDNS
Summe Kernel + Treiber39 887821 KiB

Programme und Dienste (build/apps/*.elf, Build vom 14.11.2026)

Gemessen mit llvm-size. „Code“ ist .text; „Daten“ sind Konstanten und vorbelegte Variablen, vor allem die eingebetteten UI-Schriften (rund 0,85 MiB je Programm mit Oberfläche). reflexrun und reflexrt sind die Vorlagen für „Save as Program“; ihre ELF-Dateien enthalten leere Code- und Datenbereiche, die Develop beim Bauen füllt und auf die echte Größe kürzt. Programmcode wird von allen Starts geteilt, nur die schreibbaren Daten werden je Start kopiert.

ProgrammArtCodeDatenBSS (RAM)ELF-Datei
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
displayDienst655 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
timesyncDienst102 KiB146 KiB1 769 KiB394 KiB
watchdogSystem56 KiB64 KiB1 257 KiB266 KiB
usbinputDienst26 KiB30 KiB0 KiB159 KiB
actuatorsDienst24 KiB3 KiB1 255 KiB77 KiB
canbusDienst9 KiB0 KiB0 KiB54 KiB
Programme: Code und Daten in der ELF-Datei KiB, linear Code Konstanten und Daten (u. a. Schriften) 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

6Kernkomponenten

6.1 Boot, EFI-Loader, Updates A/B und Rückfall

Wie es funktioniert: Die UEFI-Firmware startet \EFI\BOOT\BOOTAA64.EFI. Der Loader liest den Boot-Record (512 Bytes, zwei Kopien mit Folgenummer und CRC-32C in den reservierten FAT32-Sektoren 16/17), wählt Systemkopie A oder B, lädt KERNEL_A.ELF bzw. KERNEL_B.ELF an seine feste physische Adresse, sammelt Speicherkarte, ACPI-RSDP und GOP-Framebuffer in der BootInfo (128 Bytes) und springt nach ExitBootServices in den Kernel. entry.S wechselt falls nötig von EL2 nach EL1, baut frühe 16-KiB-Seitentabellen, schaltet die MMU ein und ruft kernelMain.

  • Schnell: Messungen und Selbsttests laufen erst nach „Hello“; nichts auf dem Boot-Weg wartet auf das Netz. make test-vm scheitert, wenn „Hello“ später als 1,0 s kommt.
  • Updates: Ein signiertes Paket (.srupdate, Ed25519, Kernel + Systemvolume) wird in die inaktive Kopie geschrieben und beim nächsten Start ausprobiert; erreicht dieser „Hello“, bleibt sie.
  • Rückfall: Startet die neue Kopie dreimal nicht bis „Hello“, nimmt der Loader von selbst wieder die alte. Ein zurückgerollter Start zeigt Textzeilen statt Animation.
  • Sicherheit: Systemvolume nur lesbar; Pakete mit falscher Signatur werden abgelehnt (make test-update). Die Prüfung der Kernel-Signatur im Loader ist vorbereitet (Loader und Kernel sind getrennte Dateien), aber noch nicht gebaut.
  • Vorschau mit Ablaufdatum (10.11.2026, docs/decisions.md): make preview baut das Produktabbild ohne Testprogramme, ohne Entwicklungsschlüssel und ohne API-Schlüssel, mit mkimage --expires (Vorgabe 25.02.2027, Datei /expires auf dem schreibgeschützten Systemvolume). Jeder Start schreibt die verbleibenden Tage ins Log; ab dem Ablauftag startet kein Programm, und der Bildschirm sagt, wo die neue Vorschau liegt (kernel/core/Preview.swift). Das 8-GiB-Abbild wird komprimiert ausgeliefert und beim ersten Start mit Löchern entpackt (123 MB auf der Platte nach dem ersten Start). Es steckt in der App und wird nach ~/Library/Application Support/SOFTrobots OS Preview/ entpackt, damit die App überall startet (macOS startet heruntergeladene Apps aus einer zufälligen Kopie, F182). Signiert mit der Developer ID und von Apple notarisiert (Build 234, 15.11.2026). make test-preview prüft beide Fälle in QEMU.
  • Version und Build-Nummer (11.11.2026, Hb. 3.141): Die Version bleibt bis 1.0 die Phase (0.15.0 = Phase 15). tools/build-number zählt bei jedem Build, in dem sich der Kernel oder ein Programm geändert hat, um eins weiter und wird nie zurückgesetzt. Images tragen „0.15.0+N“ (passt in die 16 Bytes des Boot-Records); About und die SYSTEM-Karte des Desktops zeigen „0.15.0 · Build N“ (SystemStatus.versionShown).
  • Platte in neuen Images (11.11.2026, Hb. 3.140): EFI 64 MiB · SYSTEM_A 512 MiB · SYSTEM_B 512 MiB · DATA der Rest (das System belegt 54 MiB). Im 8-GB-Image hat DATA 6,9 GiB. Bestehende Images behalten ihre Aufteilung; das 512-MiB-Systemvolume eines Updates passt in beide.

6.2 Scheduler

Wie es funktioniert: Ein Scheduler je Kern (bis 8 CPUs, 64 Kernel-Threads), tickless (ARM Generic Timer im One-Shot-Betrieb) und voll präemptiv. Drei Klassen:

KlasseVerfahrenEigenschaften
RealtimeEDF mit Budget je Periode und ZulassungsprüfungPeriode 100 µs … 1 s; Auslastung je Kern höchstens 900 ‰; passt ein Vertrag nicht, startet das Programm gar nicht
Interactivefeste PrioritätenDesktop, Dienste, normale Programme; Prioritätsvererbung in Volume-Sperre und IPC
BackgroundFair Share nach GewichtenGewichte 2:1 ergeben gemessen genau 2,0
  • Lastverteilung: Ein voller Kern gibt höchstens alle 10 ms einen wartenden Thread an einen leeren Kern ab (nie den laufenden, nie Echtzeit-Threads, nie den Echtzeitkern). Der alte Kern schiebt, weil nur er die Gleitkomma-Register des Programms sichern kann (Lazy FP/SIMD).
  • Echtzeitkern: Die letzte CPU nimmt Echtzeit-Threads auf, andere Threads meiden sie. Mit zugelassener Echtzeit-Arbeit schläft sie nicht (kein wfi), weil das Wecken einer virtuellen CPU rund 170 µs kostete.
  • Watchdog: Prüft alle 50 ms die Echtzeit-Programme und wendet die Reaktion aus dem Manifest an: log, stop, restart oder stop-actuators.
  • Interrupts: GICv3 mit Prioritäten, kurze obere Hälften, Arbeit in Threads; MSI/MSI-X über das ITS.

6.3 Speicher

  • 16-KiB-Seiten (der Kernel verlangt das 16-KiB-Granule), 32-MiB-Blöcke für große Puffer, Buddy-Allokator für physische Seiten, bis 16 GiB verwalteter RAM, 48-Bit-Adressen.
  • W^X überall: kein ausführbarer Datenbereich, kein schreibbarer Code – im Kernel und in jedem Programm. Direct Map für den Kernel, Geräte nur über MMU.map.
  • Ein Adressraum je Programm (EL0): Code ab 0x1000_0000, Heap darüber, Stack mit Guard Page, Kanalseiten, Geräte- und DMA-Fenster nur für Treiberdienste.
  • Kein Kernel-Heap (-no-allocations); Programme im Echtzeitprofil haben gar keinen Heap.
  • Zusagen statt Swap: memory = im Manifest (16–2048 MiB, Vorgabe 256 MiB) ist eine Zusage, die beim Start zugelassen und nie weggenommen wird. Darüber gibt es Leihe aus freiem RAM. 256 MiB Systemreserve (Not-Halt, Echtzeit, Dienste) werden nie verliehen.
  • Spitzen-Polster: ca. 3 % des RAM (64 MiB … 1 GiB), sofort auf Anfrage für Spitzen, höchstens die Hälfte je Programm, sichtbar in Activity und auf dem Desktop.
  • Eigener Auslagerungsbereich (Stufe 2): zurückgeforderte Leihseiten gehen nur in den Bereich dieses Programms (2 × Zusage, höchstens 4 GiB), AES-GCM je Seite mit einem Schlüssel nur für diesen Lauf. Ein Programm über seiner Zusage wird langsamer – kein anderes. Echtzeit-Programme werden nie ausgelagert.

6.4 IPC – Kommunikation zwischen Programmen

  • Kanal = eine gemeinsame Seite mit zwei Nachrichtenringen (Single-Producer/Single-Consumer, Nachrichten bis 256 Bytes) zwischen genau zwei Programmen, gefunden über den Namen. Der Kernel kopiert nie eine Nachricht – er bildet die Seite ab und weckt die Gegenseite.
  • 64 Kanäle im System. Dazu Veröffentlichungen/Abos (16 Plätze), Aufnahme-Ringe für Serien und der Erkennungs-Ring von Camera.
  • Systemaufrufe: 13 Grundbefehle (0–12: exit, yield, sleep, wait, periodWait, memoryGrow, workerWake, workerExit, channelNotify, channelWait, deviceWait, surfaceNotify, inputReceive), die nur warten, wecken oder enden und rund 100 ns kosten sollen. Alles, was mit einem Objekt arbeitet, geht über den Formaufruf 13 (24 Module, 141 Aufrufe, 224 Formen und 30 Aufzählungen in 23 Dateien shapes/*.shape, gezählt am 14.11.2026). Obergrenze: 100 Systemaufrufe.
  • Gemessen: Nachricht hin und zurück zwischen zwei Programmen auf verschiedenen Kernen 1,2–1,7 µs, auf demselben Kern 6–8 µs: Dann wechselt der Prozessor für jede Nachricht zweimal das Programm und schläft über den Zeitgeber. Welcher Fall eintritt, entscheidet heute die Kernverteilung beim Start des Partners (gemessen in sechs Läufen am 15.11.2026, Fehlerprotokoll F184). Wartet die Gegenseite gerade aktiv, entfällt der Weck-Aufruf ganz (Merkzeichen im Ring, F143). Ziel < 1 µs: im Median erreicht, in 2 von 4 Läufen verfehlt (1,07 und 1,24 µs).

6.5 Sicherheitsmodell

SchutzUmsetzung
Nur signierte ProgrammeJedes Programm und sein Manifest sind mit Ed25519 signiert; unsignierte oder veränderte Programme startet der Kernel nicht (Testprogramme unsigned, tampered). Auch Updates sind signiert. KI-Modelle sind keine Programme: Sie bleiben in ihren Standardformaten (GGUF, ONNX) und werden nicht signiert; der Leser prüft jede Größe gegen die Datei.
Capabilities32 Rechte (Bits 0–31 von 64; neu am 10.11. files.dialog, nur für chooser) aus dem signierten Manifest, z. B. network.outgoing, network.incoming, files.own, safety.stop, device.can, device.microphone. Jeder Aufruf wird geprüft. Ohne network.incoming keine eingehenden Verbindungen; lauschen darf nur Server auf den Ports seines Manifests.
Eigener OrdnerMit files.own existiert für ein Programm nur /data/<name>; . und .. gibt es nicht. Echtzeit-Programme haben keinen Dateizugriff.
Datei-Dialog: Wählen ist Erlauben (10.11.2026)Ein Programm fragt mit Dialog.open oder Dialog.save; den Dialog zeigt das System-Programm chooser, nicht das fragende Programm. Der Kernel prüft Ort, Typ und Inhalt der Wahl und gibt eine Freigabe für genau diese Datei – ohne Dateirecht im Manifest, bis 16 je Programm, solange es läuft; ein „Zuletzt benutzt“ gibt es nicht. Orte: der eigene Ordner, der gemeinsame Ordner /documents und in SOFTrobotsVM der Mac-Ordner; fremde Programmordner, System und Logs nie. Jede Frage hat eine Nummer und gehört einem Programm; bis 3 Dialoge gleichzeitig. Geprüft mit make test-dialog (PASS nach 8 s, Hb. 3.135).
Programm-IdentitätJedes Programm hat eine Kennung (id =, Reverse-Domain) und Version im signierten Manifest; der Ordner ist an die Kennung gebunden. In Develop gebaute Programme werden mit dem Schlüssel dieses Roboters signiert und laufen nur hier.
GeräteschutzArgon2id (64 MiB, 3 Durchläufe) aus dem Passwort entschlüsselt den zufälligen Volume-Schlüssel; DATA ist mit AES-256-GCM je Block versiegelt. Das Passwort wird nie gespeichert. Einmaliger Wiederherstellungsschlüssel (128 Bit), Bildschirmsperre, Fehlversuche verzögern 2–60 s.
Prozessor-SchutzW^X, PAN (Kernel liest Programmspeicher nicht aus Versehen), PAC (Rücksprungadressen signiert), BTI (Sprungziele markiert), Stack-Canaries, Guard Pages – geprüft durch make test-fault (6 Fälle).
Isolierte TreiberUSB und Grafik laufen als EL0-Dienste. Grenze: Ohne SMMU (Virtualization.framework hat keine) ist ein Treiberdienst nur von der CPU-Seite isoliert; sein Gerät könnte per DMA auf fremden Speicher zugreifen.

6.6 Netzwerk

  • Eigener Stack in Swift im Kernel: IPv6 zuerst (SLAAC), IPv4 (DHCP), TCP mit SACK, CUBIC und Window Scaling, UDP, DNS, mDNS (<name>.local im Heimnetz). Interrupts statt Polling; 64 TCP-Verbindungen im System.
  • Nur TLS 1.3 (X25519; AES-128-GCM, AES-256-GCM mit SHA-384 seit 11.11.2026, ChaCha20-Poly1305), als Client und als Server. Namensauflösung nur über DNS über HTTPS, Uhrzeit über NTS (authentifiziertes NTP).
  • TLS in Programmen (11.11.2026): AES-128- und AES-256-GCM werden mit den ARMv8-Befehlen AES und PMULL entschlüsselt, beim ersten Verbinden gegen die Software-Fassung geprüft und zuerst angeboten, wenn der Prozessor sie hat (system.info meldet features.aes, in der App-API SystemStatus.hasAES). ChaCha20 rechnet mit NEON vier Blöcke gleichzeitig (userland/tls/asm). Der Kernel behält die portablen Fassungen, weil er keine Vektorregister benutzt.
  • Server – das einzige Tor nach drinnen: nur Tür 443 (alles hinter dem Login) und Tür 80 (Umleitung), kein öffentlicher Webserver. Eigene Stammstelle des Roboters (ECDSA P-256), Zugang per Einladung mit Code und Koppeln des Geräts, 5 falsche Passwörter in 10 Minuten sperren die Adresse 15 Minuten. Von unterwegs über das VPN des Heimrouters.
  • Keine konfigurierbare Firewall nötig: Ein Port ohne Lauscher antwortet gar nicht.
  • Gemessen: TLS-1.3-Handshake 66,4 ms, Namensauflösung über DoH 70 ms (Benchmark 14.11.); Ping zum Gateway 0,1 ms (Boot-Log 08.11.); Downloads siehe unten (11.11.2026).
  • Downloads: Ein nachgebauter Sender in den Host-Tests schickt beliebige gültige Stücke, 2 MB kommen exakt an; Verlust, Verdopplung und Vertauschung werden überstanden. Web setzt abgebrochene Downloads mit einem Range-Request fort (höchstens dreimal).
  • Netz-Diagnose (F149, Hb. 3.136): DHCP erneuert die IPv4-Adresse bei der Hälfte der Laufzeit; DNS-Fragen ohne Antwort stehen mit dem Zustand des Routers im Log; Buddy bellt, wenn das Internet nicht erreichbar ist (Regel 13). Ein einmaliger Netzverlust nach etwa 50 Minuten ist nicht wieder aufgetreten; die Ursache ist nicht bewiesen (Abschnitt 2).

Downloads gemessen (11.11.2026, docs/benchmarks/network-download.md, Hb. 3.140)

make vm-net-bench (Programm netbench): SOFTrobotsVM auf dem Apple M3 Pro lädt 100 MB per HTTP von einem Server auf dem Mac (kein Internet, kein TLS – nur virtio-net, TCP und die Systemaufrufe) und per HTTPS von zwei Speedtest-Servern im Internet; curl auf dem Mac holt dieselben Dateien direkt davor. Der Mac hängt per Kabel am Netz; die Internetleitung am Messplatz hat 934 Mbit/s (≈ 117 MB/s).

Weg (100 MB)GemessenBemerkung
Eigener Weg: HTTP vom Mac, ohne Internet und TLS110–218 MB/sum 190–200 MB/s bei ruhigem Mac; der Bereich folgt der Last des Mac
HTTPS von OVH35–59 MB/sfast ohne Paketverlust; die nächste Grenze ist noch nicht bekannt
HTTPS von Hetzner9–58 MB/sschwankt von Lauf zu Lauf – offen, wird untersucht
curl auf dem Mac, dieselben Server (Vergleich)80–96 MB/szeigt, was Leitung und Server in derselben Minute hergaben
  • Treiber virtio-net: 256 Empfangspuffer, eine Gerätemeldung pro Bündel, Rahmen werden in Blöcken kopiert.
  • TCP: bestätigt jedes Segment, das in der Reihe ankommt eine Fenstermeldung beim Lesen geht nur noch hinaus, wenn die Gegenseite zuletzt von weniger als einem halben Ring wusste; Ringkopien in Blöcken.
  • Empfangsringe für Downloads 4 MiB (Fensterskalierung 7): Eine Verbindung bekommt nach 1 MiB Empfang einen der 4 großen Ringe, sonst 128 KiB.
  • 64 gemerkte Bereiche außer der Reihe mit SACK; SACK nennt den neuesten Bereich zuerst.
  • Programme lesen bis 8 KiB pro Systemaufruf (Network.Connection.receive(area:)); TLS lässt den entschlüsselten Record an seinem Platz.
  • Log: Schließt ein Download (über 4 MB), schreibt der Kernel „TCP: download of N MB: … segments, … beyond a gap, … again, … into a full ring“. Vom Mac kamen 0 Segmente hinter einer Lücke, von OVH 0–15, von Hetzner 26–1547.

Verschlüsselung in einem Programm (11.11.2026, netbench, je 8 MiB, zwei Läufe)

VerfahrenGemessenzum Vergleich: dieselbe Rechnung in Swift
ChaCha20 (NEON)1657–1735 MB/s373–376 MB/s
ChaCha20-Poly1305 (versiegeln)703–719 MB/s287 MB/s
AES-256-GCM (AES/PMULL)4594–4896 MB/s46–49 MB/s

Der Kernel behält die portablen Fassungen: ChaCha20-Poly1305 76 MB/s in seinem Selbsttest (ohne Vektorregister). Alle drei liegen weit über der Leitung am Messplatz (117 MB/s).

6.7 Grafik und Anzeige

  • Nur 2D: GOP-Framebuffer oder virtio-gpu 2D, Zeichnen auf der CPU. Keine 3D-Grafik, keine Vollbild-Effekte (kein Abdunkeln, keine Schatten).
  • Fenstersystem als EL0-Dienst (display): Programme zeichnen nur in ihre eigene Zeichenfläche; der Dienst setzt zusammen, zeichnet nur geänderte Bereiche, doppelt gepuffert. Ein Bildzähler je Fenster verhindert halb gezeichnete Bilder.
  • 16 Zeichenflächen im System, 3 je Programm; Titel kommen aus dem signierten Manifest, damit sich kein Programm als ein anderes ausgeben kann.
  • Hell und Dunkel, Maßstab 2 ab 2400 × 1500. Alle Decoder und Encoder für Bilder, Dokumente, Video und Ton laufen in der Programm-Laufzeit (nie im Kernel) – die vollständige Liste steht in Abschnitt 9.
  • Fensterknöpfe (10.11.2026, Hb. 3.137): rechts im Titel [Ablegen] und [×], immer sichtbar; die Kapseln für Fortschritt und Speicher stehen ohne Lücke daneben. Das × wird in drei Schritten rot. Keine Animation.
  • Laschen im Dock: Ein abgelegtes Fenster ragt als kleines bernsteinfarbenes Fenster aus der Kachel seines Programms (höchstens 3 gestapelt); ist kein Fenster des Programms sichtbar, wird der Punkt unter der Kachel zum Ring. Neu im Manifest: dock = no – das Programm erscheint nie im Dock (genutzt von chooser).
  • Fortschritt für alle Programme (Hb. 3.136): ein Aufruf surface.progress(…) (userland/ui/Progress.swift); das System zeichnet eine Kapsel im Fenstertitel (Balken, Prozent, Restzeit) und einen dünnen Balken auf der Dock-Kachel. Abbrechen nur, wenn das Programm es anbietet – als Bit in der Ringseite des Fensters, das auch ein Programm in einer Schleife sieht. Buddy meldet eine Aufgabe von mindestens 3 s, die endet, während ihr Fenster nicht vorne ist. Erster Nutzer: Web.
  • Speicherfenster (Hb. 3.136): Ein Klick auf die Speicheranzeige im Titel zeigt den Verlauf der letzten 10 Minuten (ein Punkt alle 2 s, für jedes Programm immer aufgezeichnet), Heap-Spitze, Garantie, Nutzung des Polsters und einen Vorschlag für memory = (apps/display/MemoryCard.swift).
  • Bilder in Web (11.11.2026, Hb. 3.141): Web zeichnet Bilder in der vollen Auflösung des Bildschirms (Maßstab 2 auf Retina), nimmt aus srcset die Version für den Bildschirm (Dichte- oder Breitenangaben) und vergrößert bei Bedarf bilinear. Boxen mit overflow: auto oder scroll behalten die Höhe ihres Inhalts, weil Web in einer Box nicht scrollt; overflow: hidden schneidet wirklich ab.
  • Einheitliches File-Menü (Hb. 3.135): Programme mit Dateien bekommen es vom System (surface.addFileMenu): New ⌘N, Open… ⌘O, Save ⌘S, Save As… ⇧⌘S, Export… ⌘E, Show in Files; Menüleiste „Programm · File · Edit · …“.

6.8 USB mit Erlaubnisliste

XHCI-Treiber als EL0-Dienst usbinput. Konzept: Erlaubt sind HID, CDC-ACM (seriell), UVC (Kameras) und herstellerspezifische Schnittstellen nur mit signiertem Treiberdienst. Jede andere Schnittstelle führt dazu, dass das ganze Gerät abgelehnt wird. Heute gebaut: HID (Tastatur, Zeiger) mit Interrupts; CDC-ACM und UVC folgen mit echten Geräten.

6.9 Sicherheit am Roboter: Not-Halt

  • Not-Halt im Kernel (Safety): stoppt alle Aktoren sofort, auch während der Start-Animation (⌘+Esc), über den immer sichtbaren Knopf in der Menüleiste oder die Statusseite von Server. Lösen nur am Roboter.
  • Programme kommen nie direkt an Motor oder Bus: Der Aktor-Dienst begrenzt jede Bewegung (heute im Code: −90…+90°, 30°/s) bevor ein Befehl auf den CAN-FD-Bus geht.
  • Gemessen: Not-Halt bis gesendeter Stopp-Rahmen 10–12 µs (SOFTrobotsVM, Handbuch Kapitel 6). Der Flugschreiber sichert bei Not-Halt oder Absturz die letzten Sekunden der Aufzeichnung.

6.10 Ton und Mikrofon

  • Ausgabe: virtio-sound, 48 kHz, 16 Bit, Stereo, Abschnitte von 10 ms. Mischer im Kernel: jedes Programm mit sound.play bekommt einen Ring von etwa 341 ms; das Gerät startet mit dem ersten Ton und stoppt nach einer Sekunde Stille (Hb. 3.100).
  • Mikrofon (09.11.2026, Hb. 3.134): virtio-sound-Eingang, läuft nur, solange ein Programm zuhört. Ein Ring je Mikrofon (48 kHz, 16 Bit, ≈ 1,4 s), schreibgeschützt in jedes zuhörende Programm eingeblendet, mit Pegel (Spitze und RMS) alle 10 ms. Recht device.microphone.
  • Immer sichtbar: rote Pille „MIC · Programm“ in der Menüleiste, nicht versteckbar; „Stop the microphone“ stoppt alle Zuhörer. Settings › Privacy zeigt, wer die Kamera sieht und wer das Mikrofon hört.
  • Sound (10.11.2026): Menüs „Sound, File, Edit“; Open… und Save As… (FLAC oder WAV) über den System-Dialog.

6.11 Formen, Reflex und Develop

  • Alles ist eine Form: .shape-Dateien beschreiben einmal, was API, Kernel-Prüfcode (nur Ganzzahlen, kein Heap), Datenbanktabellen, Ringe und Netz verwenden. Stabile Layouts: veröffentlichte Felder behalten ihren Platz.
  • Reflex: eigene Sprache mit Lexer, Parser, Ein-Pass-Compiler zu Bytecode und einer Maschine; jede Zeile nennt ihr Modul, daraus ergeben sich die Rechte des Skripts.
  • Develop: Projekte als Ordner, prüft bei jeder Taste (übersetzen und Tests), Run führt das Programm mit Vorschau aus, Formulare und gespeicherte Listen (stored as table). „Save as Program“ übersetzt zu ARM64-Maschinencode und legt ein signiertes Programm an, ohne Quelltext und Compiler, nie mit schreibbarem Code; ein Skript nur aus Echtzeit-Handlern wird ein Programm für den Echtzeitkern.
  • Beweisbare Echtzeit: Für realtime every 1 ms zählt der Compiler die schlechtesten Takte jeder Anweisung (jeder Speicherzugriff als Cache-Fehlgriff, bei nur 1 GHz) und startet nur, wenn höchstens 80 % der Periode gebraucht werden.

6.12 Video-Wiedergabe (gemessen 10.11.2026)

Video schreibt je Wiedergabe eine Zeile in /data/video/measurements.csv und jede Sekunde eine Logzeile (gezeigt, verspätet, übersprungen, Dekodier-, Umrechen- und Zeichenzeit; apps/video/PlayStats.swift). Mac-Werte kommen aus dem Host-Test vp9FileSpeed, VM-Werte aus make vm-vp9-bench (600 Bilder Big Buck Bunny 1080p). Quelle aller Zahlen: docs/benchmarks/video-playback.md.

1080p, je BildSOFTrobotsVMMac (Host-Test)
dekodieren, 1 Thread10,5 ms6,9 ms
dekodieren, 3 Threads8,9 ms3,3 ms
YUV → RGB umrechnen (SIMD)1,4 ms1,1 ms
  • Wie Video abspielt: bis 4 Bilder voraus dekodiert und umgerechnet; bei Rückstand der Reihe nach aufgeholt (höchstens 4 Bilder am Stück), der Ton läuft weiter und springt nach einem Hänger zur Bildzeit; Schleifenfilter auf 3 Kernen (bitgleich mit einem Thread); YUV→RGB mit SIMD (bytegleich).
  • Ergebnis: 360p mit 60 Bildern/s: 60 von 60 gezeigt, 0 übersprungen; 720p 60 von 60, auch in einer VM mit 2 Kernen und 2 GB (14.11.2026, beim Owner, 0 verspätete Bilder). 1080p: Dekodieren und Umrechnen brauchen etwa 10 ms der 16,7 ms, die ein Bild bei 60 Bildern/s haben darf.
  • Gemessen und nicht genommen: Schleifenfilter mit SIMD (Mac, 1 Thread 12–15 % langsamer) und Bewegungsausgleich mit SIMD (kein Unterschied).
  • Offen: Drei Threads bringen in der VM 16–20 %, auf dem Mac 50 %; der Grund ist nicht gefunden.
Befund Strict Alignment (docs/decisions.md, 10.11.2026): Eine reine Rechenschleife braucht in VM und auf dem Mac gleich lang (249 / 248 ms) – die Kerne der VM sind nicht langsamer. Ursache: Alle Programme wurden mit -Xcc -mno-unaligned-access gebaut (vom Kernel geerbt, der anfangs ohne MMU läuft); Swift zerlegte damit jeden nicht ausgerichteten 8-Byte-Zugriff in Einzelbytes (in der Disassemblierung von rgba: ldrb/orr, strb). Darum behalten nur Programme ohne Heap die Einstellung (sie dürfen Geräteregister einblenden: usbinput, canbus); Programme mit Heap sehen nur normalen Speicher, wo nicht ausgerichtete Zugriffe erlaubt sind. Programme mit uses-video werden wie uses-infer mit -O gebaut.

7Dateisystem SOFTrobotsFS

Aufbau

  • Copy-on-Write: nie wird ein gültiger Block überschrieben; ein Commit schreibt neue Knoten und schaltet dann einen einzigen Wurzelzeiger im doppelten Superblock um. Kein Journal.
  • B+-Bäume für Objekte und Extents; Schlüssel (Objekt, Typ, Offset) halten alles eines Objekts beisammen; bis 8 Ebenen.
  • 16-KiB-Blöcke = Seitengröße = Baumknoten: Cache-Rahmen gehen ohne Umkopieren an die NVMe.
  • CRC-32C (Prozessorbefehl) auf allen Daten und Metadaten.
  • AES-256-GCM je Block (versiegeltes Volume): Kopf als zusätzliche Daten, Tag und Nonce im Kopf; Eltern speichern die Generation jedes Kindes – ein alter Block kann nicht unbemerkt zurückgespielt werden.
  • Snapshots alle 15 Minuten, Aufbewahrung 24 h / 7 Tage / 30 Tage, höchstens 400; der Zeitregler in Files und Database zeigt alte Stände.
  • Kleine Dateien bis 2 KiB direkt im Baum (kein eigener Datenblock), Ordnersummen sofort, kein atime.
  • Freiplatz-Karte auf der Platte (Volume bis ≈ 1,99 TiB), 32-MiB-Hash-Cache, gebündelter Commit mit FUA, bis 32 Schreibbefehle gleichzeitig.
  • Geplant: gebündeltes TRIM (noch nicht gebaut).

Warum es schnell ist

  • Kein Journal: jede Änderung wird einmal geschrieben, nicht zweimal.
  • Block = Seite = Knoten: kein Umrechnen, DMA direkt aus dem Cache.
  • Prüfsumme und Verschlüsselung in Hardware: AES-256-GCM 4257 MB/s versiegeln, 3995 MB/s öffnen.
  • Kein atime: Lesen erzeugt keine Schreibzugriffe; kleine Dateien kosten keinen Extra-Block.
  • Im Kernel, ohne POSIX-Schichten dazwischen.

Vorteile

  • Stromausfall: immer genau der alte oder der neue Stand, nie etwas dazwischen (Host-Tests mit vertauschter Schreibreihenfolge bei jedem Schreibvorgang).
  • Jede stille Beschädigung wird erkannt; ein versiegeltes Volume ist ohne Passwort unlesbar und manipulationssicher.
  • Snapshots kosten fast nichts – sie sind eine Folge von Copy-on-Write.

Gemessen (Kernel, 4 MiB)

Schreiben + Commit 255 MB/s · Lesen + CRC-Prüfung 779 MB/s

Der Wert schwankt mit dem Datei-Cache des Macs (01.11.: 166 / 389 MB/s, Hb. 3.58).

Messwerte des Dateisystems im Einzelnen

MessungWertWo / wie gemessen
NVMe: ein 16-KiB-Befehl lesen / schreiben38,6 µs / 80,3 µsKernel beim Start, Benchmark 14.11.2026 (Median aus 4 Läufen)
NVMe sequentiell (256 KiB, 16 Befehle gleichzeitig) lesen / schreiben1500 MB/s / 554 MB/sKernel beim Start; die VM-Platte ist eine Datei auf dem Mac
Commit einer neuen Datei3,3 msBoot-Log 08.11.; fast ganz der Flush der VM-Platte
Commit von 280 neuen Dateien in einem Zug4,2 ms13 Knoten gemeinsam an die NVMe, ohne Umkopieren („0 bounced since the boot“), Boot-Log 08.11.
DATA einbinden (versiegelt, über die Freiplatz-Karte)11 msnur Superblöcke und Kartenblöcke gelesen (Hb. 3.58, 01.11.2026)
Prüfung aller Knoten nach „Hello“ (403 Blöcke)7,1 ms0 Schäden, 0 fehlende Kartenbits (Hb. 3.58); läuft im Diagnose-Thread, bremst den Boot nicht
Knoten-Cache beim Start: Treffer / Lesezugriffe1087 / 12 · 289 / 1Systemvolume · DATA, Boot-Log 08.11.
Programm: 4-MiB-Datei schreiben / lesen126 MB/s / 99 MB/sBenchmark, über die Systemaufrufe (16 KiB je Aufruf)
Kleine Datei anlegen und löschen8,0 msBenchmark
Ordnereintrag auflisten374 µsBenchmark
Plattenverschlüsselung AES-256-GCM versiegeln / öffnen4257 MB/s / 3995 MB/sKernel beim Start, bitgleich zur Software-Referenz, Manipulation erkannt
Warum LZ4-Kompression gestrichen wurde (Entscheidung 29.10.2026, gemessen auf einem Kern): der eigene Codec packt mit etwa 200 MB/s und entpackt mit 600–1200 MB/s – eine schnelle SSD allein ist 3- bis 10-mal schneller als das Entpacken. Nur Code und Text schrumpfen (etwa 2×); Fotos, Video, Archive und alles Verschlüsselte nicht (1,0–1,1), und das ist der größte Teil der Daten. Komprimierte Extents variabler Größe hätten die einfache Blockabbildung, Prüfsummen, Copy-on-Write und die Verschlüsselung verkompliziert (die komprimierte Größe verrät etwas über den Inhalt).

8Datenbank SOFTrobotsDB

Eine Datenbank ist keine Datei mit eigenen Seiten, sondern ein eigenes Objekt im Dateisystem (Art „database“ neben Datei und Ordner) mit einem eigenen Copy-on-Write-B+-Baum – aus denselben 16-KiB-Knoten, mit derselben Blockverwaltung, derselben Prüfsumme bzw. Verschlüsselung und demselben Commit. Der Commit des Dateisystems ist der Commit der Datenbank; es gibt kein Write-Ahead-Log und keine zweite Kopierschicht (docs/database-concept.md, Abschnitt 1; Code in kernel/fs/softrobotsfs/Database.swift, Tables.swift, Query.swift, Schema.swift).

Weg einer Transaktion: ein Systemaufruf, ein Wurzelwechsel Programm (EL0)Schreibpaket im eigenen Speicher Kernel: prüfenRegeln, Platz reservieren im Cache anwendenganz oder gar nicht CommitKnoten, Flush, Superblock FUA Kein Log, das Daten ein zweites Mal schreibt · kein Server-Prozess · kein zweiter Cache · Snapshots und Zeitregler sehen Datenbank und Dateien derselben Generation. Echtzeit-Programme schreiben Messwerte ohne Systemaufruf in einen Ring; der Recorder-Thread leert ihn alle 20 ms in eine Serie.

8.1 Funktionen

  • Tabellen als gespeicherte Formen: Typen bool, int8–64, uint8–64, float32/64, text(n), bytes(n), time, enum, id, ref, file; Regeln optional, unique, default, range.
  • Der Kernel prüft jede Zeile (Pflichtfelder, Größe, gültiges UTF-8, Bereiche auch für Gleitkomma, NaN abgelehnt, unique, ref, file) – eine fehlerhafte App kann keinen Unsinn speichern.
  • Indexe (16 je Tabelle, 8 Felder je Index) im selben Schreibpaket wie die Zeile; Abfragen mit Filtern (64 Knoten), Sortierung über bis zu 4 Felder, Top-N, Gruppen, Summe/Durchschnitt (128 Bit intern), Cursor; „explain“ nennt den Plan.
  • Joins über ref-Felder (09.11.2026, Hb. 3.128): bis zu zwei Joins für WHERE und ORDER BY, bis zu vier zum Anzeigen; der Kernel liest die verknüpfte Zeile selbst (eine Punktabfrage je Zeile und Join). Noch nicht: GROUP BY über verknüpfte Felder, Index über verknüpfte Felder.
  • SQL (nur lesend) in Console und Database; die Übersetzung in den festen Bauplan läuft im Programm, der Kernel versteht keine Textsprache.
  • Schema ändern (Feld hinzufügen, entfernen, umbenennen, Enum erweitern): sofort, ohne eine Zeile umzuschreiben.
  • Serien, Aufnahme-Ringe und Flugschreiber (die letzten Sekunden, gesichert bei Not-Halt oder Absturz).

8.2 Gemessen (Benchmark 14.11.2026, Median aus 4 Läufen, über die Systemaufrufe aus einem Programm)

1000 Zeilen einfügen, auf die Platte gewartet20,8 ms
1000 Zeilen „soon“ (dauerhaft binnen 10 ms)9,8 ms
Eine Zeile nach Id37,6 µs
Bereich über einen Index (100 Zeilen)4,0 ms
Top 100 von 1000 ohne Index sortiert20,4 ms
Zählen in Gruppen (1000 Zeilen)2,6 ms
SQL-Anweisung übersetzen0,8 µs
Messwerte in den Ring (Echtzeit-Weg)2,4 Mio./s
davon verworfen (10 000 geschrieben)0
Zeitbereich zurücklesen (1000 Datensätze)15,4 ms

Je Zeile: 22,2 µs dauerhaft, 10,3 µs mit „soon“. Erste Messung in Stufe 4 (01.11.2026, Testprogramm dbcheck, mit unique-Feld, zwei Indexen, Prüfung aller Regeln und Rücknahme-Protokoll): 17 ms bzw. 5,9 ms für 1000 Zeilen. Ein kleiner dauerhafter Schreibvorgang kostete 3,6 ms, fast ganz der Flush der VM-Platte (Hb. 3.62, 01.11.2026). Die erste Messung war 17-mal langsamer (291 ms für 1000 Zeilen, F80) – gefunden nur, weil eine echte App in der echten VM maß.

8.3 Grenzen

GrenzeWertGrenzeWert
Datensatz (alle Felder)≤ 4096 Bytes – große Daten als Datei (8.5)Tabellen / Felder64 je Datenbank / 64 je Tabelle
Schlüssel1–255 BytesSchreibpaket (Transaktion)≤ 4 MiB, vorher vollständig geprüft
Baumtiefe8 Ebenen – bei 100-Byte-Zeilen weit über 10 Milliarden ZeilenZeilen je Abfrage-Aufruf256 (Ausgabe ≤ 256 KiB), weiter per Cursor
Sortieren ohne IndexTop-N ≤ 1000Gruppen256, Gruppenwert ≤ 32 Bytes
Offene Datenbanken4 je Programm, 32 im SystemSerien-Datensatz8–1024 Bytes, Ring 1–600 s, ≤ 32 MiB

8.4 Warum die Datenbank schnell ist – und um wie viel

GrundWas es bewirktVorteil
Eine Schicht statt zweiKein Write-Ahead-Log, kein Journal, keine Datenbank-Datei in einem Dateisystem. Ein geänderter Knoten wird einmal geschrieben; der Wurzelwechsel im Superblock macht alles auf einmal gültig. Bauart ein kleiner dauerhafter Commit braucht einen Flush + FUA-Superblock statt Log-Flush plus Journal des Dateisystems (Konzept, Abschnitte 5.2 und 9). Auf Verbraucher-NVMe ist der Flush der teure Teil.
Gebündelter Commit (Group Commit)Schreibvorgänge vieler Programme, die während eines Commits ankommen, teilen sich den nächsten Flush; alle schmutzigen Knoten gehen zusammen an die NVMe (bis 32 gleichzeitig). Bauart Commits unter Last werden zusammengefasst, statt jeder einzeln auf einen Flush zu warten (Konzept 5.3). Wie viele je Sekunde, ist unter Last nicht gemessen.
Ein Systemaufruf je TransaktionDas Schreibpaket wird ohne Server-Prozess geprüft und in einem Zug angewandt; das Ergebnis kommt direkt in den Speicher des Programms. gemessen: 9,8 ms für 1000 Zeilen in einem Aufruf
Abfragen im Kernel nahe an den DatenFilter, Sortierung, Gruppen und Joins laufen dort, wo die Knoten im Cache liegen; über das Systemaufruf-Fenster wandert nur das Ergebnis. gemessen: Zählen in Gruppen über 1000 Zeilen 2,6 ms
Ein Cache für allesDer Block-Cache des Kernels (32 MiB, 2048 Plätze, Hash-Suche) hält Dateien und Datenbanken; seine 16-KiB-Rahmen sind zugleich Seiten und DMA-Puffer – kein Umkopieren, kein zweiter Cache im Programm. innere Knoten bleiben im Cache: ein nicht zwischengespeicherter Zugriff kostet genau einen Plattenzugriff (Konzept 4)
Ringe für MesswerteEin Echtzeit-Thread schreibt ohne Systemaufruf und wartet nie; ist der Ring voll, wird verworfen und gezählt. gemessen: 2,4 Mio./s, 0 verworfen. Qualitativ: aus einem Echtzeit-Thread ist das mit einer üblichen Datenbank gar nicht möglich.
Snapshots aus Copy-on-WriteEin Snapshot der Datenbank ist ein Snapshot des Dateisystems.kostet keine Kopie – statt einer vollständigen Sicherung

Ehrlich: Bei einzelnen Punktabfragen ist SOFTrobotsDB nicht um ein Vielfaches schneller – die sind auf jeder Seite durch Speicher und Gerät begrenzt (Konzept, Abschnitt 9). Der Vorsprung liegt bei dauerhaften Commits, bei vielen Schreibern, bei Messwerten aus Echtzeit-Code und bei großen Daten (8.5).

8.5 Dateien als Feld: warum die Datenbank bei großen Daten nicht begrenzt ist

Ein Datensatz ist höchstens 4 KiB groß (Entscheidung im Konzept 15.5 Punkt 9). Bilder, Aufnahmen, Modelle oder Messdateien gehören deshalb nicht in die Zeile, sondern in das Dateisystem – die Zeile verweist auf sie mit dem Feldtyp file (Konzept 15.6 vom 01.11.2026). Weil Datenbank und Dateien im selben Dateisystem liegen, ist das kein loser Pfad-Verweis wie bei einer Datenbank-Datei neben anderen Dateien, sondern ein Verweis innerhalb desselben Copy-on-Write-Baums.

Ein file-Feld: 8 Bytes in der Zeile, die Daten in den Extents der Datei ZEILE IN DER TABELLE (≤ 4 KiB) id 7 name angle photoObjekt 4711 Indexe, Filter, Sortieren und Joins lesen nur die Zeile. Die Größe der Datei spielt dafür keine Rolle. Objekt 4711 (Datei) Kennung aus einem Zähler, nie wiederverwendet; Umbenennen und Verschieben ändern nur Ordnereinträge EXTENTS (je bis 256 KiB) … 16-KiB-Blöcke, je CRC-32C oder AES-256-GCM-Tag Ein Superblock, ein Wurzelwechsel: Datenbank-Baum und Datei-Extents hängen am selben Baum des Volumes. Ein Snapshot hält Zeile und Datei derselben Generation fest – der Zeitregler zeigt beide immer zueinander passend. Größte Datei: Größe ist ein 64-Bit-Wert, praktisch begrenzt durch das Volume (≈ 1,99 TiB). Die Zeile bleibt dabei 8 Bytes für das Feld.

Wie es funktioniert (aus dem Code)

  • Ein file-Feld speichert die Objektkennung der Datei in SOFTrobotsFS (8 Bytes, Schema.swift: feste Größe 8), keinen Pfad. Kennungen kommen aus einem Zähler im Superblock und werden nie wiederverwendet.
  • Beim Schreiben prüft der Kernel jede Zeile: das Objekt existiert, ist eine Datei und liegt im Ordner des Programms (Tables.swift: info(of:)?.kind == .file und isBelow(…, fileFieldRoot); den Ordner setzt DatabaseAccess.swift beim Öffnen). Sonst wird die Zeile mit „not a file in the app's folder“ abgelehnt.
  • Umbenennen und Verschieben der Datei ändern die Kennung nicht – der Verweis bleibt gültig. Eine gelöschte Datei wird nicht blockiert; das Feld liest sich dann als „fehlt“ und kann nie auf eine neuere, andere Datei zeigen.
  • Die Datei selbst ist eine ganz normale Datei: Extents bis 16 Blöcke = 256 KiB (versiegelt 4 = 64 KiB), jeder Block mit eigener Prüfsumme bzw. eigenem GCM-Tag, Eltern speichern die Generation jedes Kindes.

Warum das schneller ist – und warum

  • Große Daten werden genau einmal geschrieben – in die Extents der Datei. Keine Überlauf-Seitenkette in der Datenbank, kein Log, das dieselben Bytes ein zweites Mal enthält. Bauart ein großer Wert wird einmal geschrieben, nicht erst in ein Log und später noch einmal; mit anderen Datenbanken verglichen ist das nicht gemessen.
  • Zeilen bleiben klein: Abfragen, Indexe, Sortieren und Joins berühren die Datei nie. Eine Zeile nach Id kostet 37,6 µs – unabhängig davon, ob die Datei 1 KB oder 1 GB groß ist. Bauart Durchläufe über Tabellen lesen keine Anhang-Bytes, weil Anhänge als eigene Dateien liegen (nicht gemessen).
  • Lesen am Stück: Extents liegen zusammenhängend (bis 256 KiB); Cache-Rahmen sind zugleich DMA-Puffer, die NVMe liest ohne Zwischenpuffer („0 bounced“). Gemessen: Kernel 4 MiB lesen + CRC 779 MB/s, aus einem Programm 99 MB/s (16 KiB je Aufruf, also eine Kopie ins Programm – kein Zero-Copy bis in die App).
  • Verschlüsselung kostet fast nichts: AES-256-GCM öffnet mit 3995 MB/s, fast dreimal so schnell, wie die VM-Platte sequentiell liest (1500 MB/s) – beide Werte im selben Start gemessen.
  • Kopie und Sicherung umsonst: Ein Snapshot einer Tabelle mit tausend großen Dateien kopiert keine einzige Datei (Copy-on-Write).
Teil des Datei-FeldsStandWo / Bemerkung
Feldtyp file im Kernel: 8-Byte-Objektkennung, Prüfung „existiert, ist Datei, im Ordner des Programms“gebautStufe 2 (01.11.2026) und 4; kernel/fs/softrobotsfs/Tables.swift, kernel/core/DatabaseAccess.swift
Schema-Text des Kernels (photo file optional), Snapshots und Zeitregler über Datenbank und DateigebautSchema.swift; Snapshots enthalten jede Datenbank (Hb. 3.59)
Formsprache data.shape (Programme beschreiben ihre Tabellen seit 05.11.2026 als gespeicherte Formen)noch nichtdocs/decisions.md, 05.11.2026: „Not yet: … file fields“ – shapec kann ein Datei-Feld noch nicht ausdrücken
App-API: Kennung einer Datei erfahren und eine Datei über ihre Kennung öffnengeplantKonzept 15.6: Öffnen über die Kennung ist eine Baumsuche; die Ordnerregeln gelten weiter, eine Kennung umgeht sie nie. Heute gibt files.info keine Kennung zurück.
Pfad zur Anzeige in Files und ConsolegeplantKonzept 15.6: der Pfad wird nur zur Anzeige berechnet

Gültig innerhalb eines Volumes. Für Programme ist das Datei-Feld damit heute im Kernel vollständig abgesichert, aber erst nutzbar, wenn Formsprache und App-API es anbieten.

9Dateiformate: was das System liest und schreibt

Jede Zeile ist mit dem Code geprüft (kernel/lib/FileTypes.swift, userland/image, svg, video, opus, sound, archive, web, sql, Manifeste der Programme, docs/api/app-api-1.txt; gelesen am 10.11.2026). Alle Formate sind eigener Swift-Code – keine fremde Bibliothek, keine C-Abhängigkeit (beim WebP-Leser ist der Algorithmus aus libwebp portiert, Lizenz im Kopf der Datei). Decoder laufen nie im Kernel, sondern im Adressraum des Programms ohne zusätzliche Rechte: eine bösartige Datei kann höchstens dieses Programm treffen. Öffnen und Sichern laufen seit 10.11.2026 über einen System-Dialog für alle Programme (Abschnitt 6.5, Hb. 3.135).

Der Kernel prüft den Inhalt, nicht nur den Namen: Er kennt 24 Dokumenttypen (seit 10.11.2026 auch „Reflex script“, .reflex). Ein Programm bekommt ein Dokument nur, wenn es die Endung in seinem signierten Manifest nennt und der Anfang der Datei zum Typ passt (PNG-Signatur, FF D8 FF, %PDF-, EBML-Kopf, „fLaC“, gültiges UTF-8 …). Eine umbenannte Datei kann sich so nicht als anderer Typ ausgeben.
Format
Programm
LesenSchreibenVarianten: unterstützt und nichtGrenzen und Tempo
Bilder
PNG
Image, Files, Web, SVG
jaja Lesen: alle Farbtypen (Grau, RGB, Palette, je mit Alpha), Bittiefen 1–16, Adam7-Interlace, tRNS-Transparenz, alle fünf Zeilenfilter, jede CRC geprüft; eigenes Inflate (RFC 1950/1951). Ergebnis immer 8 Bit RGBA (16 Bit wird reduziert). Übergangen: Gamma, Farbprofile, Text-Chunks. Nicht: APNG-Animation (es erscheint das Standardbild); ein unbekannter kritischer Chunk lehnt die Datei ab.
Schreiben: 8 Bit RGB (deckend) oder RGBA, ohne Interlace, Filter je Zeile, ein IDAT, eigener Deflate.
Lesen und Schreiben ≤ 2048 × 2048 Pixel, Datei ≤ 16 MiB; Vorschau in Files ≤ 4 MiB.
Gemessen: 1024² öffnen 25,3 ms, speichern 73,0 ms; 1400 × 1400 öffnen 64 ms (Hb. 3.34).
Quelle: userland/image/PNG.swift, PNGEncoder.swift, Picture.swift (maxPixels, maxFile), apps/files/Thumbnail.swift
JPEG
Image, Files, Web, Video, Reader
jaja Lesen: Baseline, Extended sequenziell (8 Bit), Progressive; Huffman; Grau, YCbCr, RGB; Unterabtastung mit Faktoren bis 4 (4:4:4, 4:2:2, 4:2:0, 4:1:1 …), Restart-Intervalle, EXIF-Ausrichtung. Höchstens 2 Stufen Abweichung zu libjpeg-turbo (mit 16-Bit-Tabellen bitgleich). Nicht: arithmetische Kodierung, 12 Bit, Lossless, CMYK.
Schreiben: Baseline, YCbCr 4:2:0, Qualität 1–100 (Tabellen des Standards, skaliert wie IJG), Standard-Huffman-Tabellen, JFIF-Kopf; Alpha entfällt.
Datei ≤ 16 MiB. Baseline mit einem Scan (Kameras) wird zeilenweise dekodiert; größer als 2048 × 2048 → verkleinert auf 1/2, 1/4 oder 1/8, also Vorlagen bis 16 384 × 16 384. Progressive und mehrere Scans: ≤ 12 Mio. Koeffizienten (rechnerisch bei 4:2:0 ≈ 8 Megapixel). Schreiben ≤ 2048 × 2048.
Gemessen: 36-MP-Foto in 537 ms (SOFTrobotsVM).
Quelle: userland/image/JPEG.swift, JPEGEncoder.swift, Picture.swift
GIF
Image, Files, Web
ja– GIF87a und GIF89a; LZW bis 12 Bit, globale und lokale Farbtabellen, Interlace, Transparenz; Animation mit Wartezeit je Bild, Wiederholungszahl und allen drei Entsorgungsarten. Wartezeiten unter 20 ms zählen als 100 ms (wie in Browsern). Web animiert nur Sichtbares. Bildfläche ≤ 2048 × 2048, ≤ 10 000 Bilder je Datei, Datei ≤ 16 MiB. Im Speicher liegen nur eine Leinwand und eine Kopie, nie alle Bilder. Beschädigte LZW-Daten beenden nur dieses Bild.
Gemessen: 512 × 512 öffnen 3,3 ms.
Quelle: userland/image/GIF.swift (maxFrames)
WebP
Image, Files, Web
ja– VP8 (verlustbehaftet), VP8L (verlustfrei), VP8X mit ALPH (roh oder VP8L-komprimiert, mit Filter), Animation (ANIM/ANMF) wird in Image und Web abgespielt; ICCP, EXIF, XMP werden übersprungen. Pixel exakt wie libwebp 1.6.0 dwebp (Algorithmus aus libwebp portiert). Leinwand und Bild ≤ 2048 × 2048, Datei ≤ 16 MiB; VP8L-Huffman-Tabellen ≤ 222 Einträge. Beschädigte Daten geben einen Fehler, nie einen Absturz.
Quelle: userland/image/WebP.swift, WebPLossless.swift, WebPAnimation.swift
SVG
Image, Files, Web
ja– Eigener XML-Leser (Entitäten, CDATA, DOCTYPE übersprungen). Formen, Pfade, verschachteltes <svg>, viewBox, Verläufe, Muster, clip-path, Masken, Gruppen-Deckkraft, Marker, use/symbol, CSS, eingebettete PNG/JPEG, Text mit tspan und textPath, Filter (u. a. Weichzeichnen, Turbulenz, Licht – gegen Chrome geprüft). Nicht: Skripte, foreignObject, Animation, Verweise nach außen (nichts wird nachgeladen); bei Text kein vertikaler Text, keine Bidi-Texte, keine Ligaturen. ≤ 100 000 Knoten, Tiefe ≤ 256, use-Verschachtelung ≤ 32, ≤ 250 000 gezeichnete Elemente, Zeichenfläche ≤ 4096 × 4096; Image liest ≤ 16 MiB, Vorschau in Files ≤ 4 MiB.
Gemessen: 512 × 512 lesen und zeichnen 39,2 ms.
Quelle: userland/svg/SVGDocument.swift, SVGRender.swift (maxSide, maxDrawn), SVGText.swift
BMP
Image, Files
jaja Lesen: 1, 4, 8, 16, 24, 32 Bit, Palette, Bitfelder (auch Alpha-Maske), RLE4/RLE8, oben- oder untenbeginnend.
Schreiben: 24 Bit (deckend) oder 32 Bit mit Alpha (BITMAPV4-Kopf).
≤ 2048 × 2048 Pixel, Datei ≤ 16 MiB, lesen und schreiben.
Quelle: userland/image/BMP.swift, Picture.swift
TIFF
Image, Files
jaja Lesen: das erste Bild der Datei, Intel/Motorola, Streifen oder Kacheln, 1/2/4/8/16 Bit je Kanal, Grau, RGB, RGBA, Palette; unkomprimiert, PackBits, LZW, Deflate, horizontaler Prädiktor. Nicht: CMYK, YCbCr, Lab, JPEG in TIFF, Gleitkomma, getrennte Ebenen, BigTIFF, weitere Bilder der Datei.
Schreiben: RGB/RGBA 8 Bit, Deflate, ein Streifen.
≤ 2048 × 2048 Pixel, Datei ≤ 16 MiB.
Gemessen: 1024² öffnen 41,1 ms, speichern 114 ms.
Quelle: userland/image/TIFF.swift, Picture.swift
HEIC/HEIF, AVIF, JPEG 2000, JPEG XL, Kamera-RAW, ICO, PSDneinnein Nicht unterstützt: kein Dokumenttyp im Kernel; solche Dateien öffnet kein Programm. JPEG 2000 in PDFs: graue Fläche.
Quelle: kernel/lib/FileTypes.swift, userland/svg/PDFRender.swift
Dokumente und Schriften
PDF lesen
Reader, Files (Vorschau)
ja– Jede Version (Kopf „%PDF-“ in den ersten 1 KiB; die Versionsnummer wird nicht ausgewertet). Querverweis-Tabellen und -Ströme (PDF 1.5), /Prev, Reparatur kaputter Tabellen, Objektströme. Filter Flate und LZW (je mit Prädiktor), ASCIIHex, ASCII85, RunLength, DCT (JPEG); Scans mit CCITT G3/G4 und JBIG2 (generisch, MMR, Symbole, Text, Verfeinerung). Farben Grau, RGB, CMYK, Lab, ICC, Index, Separation/DeviceN; Verläufe Typ 2 und 3. Verschlüsselung RC4 40/128, AES-128, AES-256 (Revision 2–6), mit Benutzer- oder Besitzerpasswort. Suchen, Markieren, Kopieren, Links. Nicht: JPEG 2000 (graue Fläche), Huffman-JBIG2 und Halbton-Bereiche (leer), JavaScript und Aktionen (nie ausgeführt); Gitter- und Funktionsverläufe nur als Mittelfarbe. Datei ≤ 256 MiB, ein Strom ≤ 64 MiB entpackt, Verschachtelung ≤ 32, ≤ 4 Mio. Objekte, ≤ 4 Mio. Operatoren je Seite, Form-XObjects ≤ 12 tief, JBIG2-Seite ≤ 228 Pixel; Vorschau in Files ≤ 32 MiB (verschlüsselte nur ohne Passwort). 1500 zufällig beschädigte PDFs öffnen ohne Absturz (Host-Test).
Quelle: userland/image/PDFReader.swift (maximumFile, maximumStream), PDFCrypto.swift, userland/svg/PDFRender.swift, PDFScan.swift, PDFJBIG2.swift
PDF schreiben
Image (Export), App-API PDFDocument
–ja PDF 1.7, verschlüsselt PDF 2.0. Seitengröße frei (Vorgabe A4); Text, Linien, Rechtecke, Bilder (JPEG unverändert eingebettet, sonst Deflate mit Alpha-Maske). Schriften Helvetica, Helvetica-Bold, Courier (Standardschriften, nicht eingebettet); Zeichen Latin-1 über WinAnsi (ä, ö, ü, ß, €), andere werden „?“. Verschlüsselung AES-256 (Revision 6) – macOS öffnet sie mit dem Passwort. Nicht: eingebettete Schriften, Formulare. Image exportiert seit 10.11. über den System-Dialog (Export… mit PNG, JPEG, BMP, TIFF oder PDF). Keine feste Grenze im Code; die Datei entsteht ganz im Speicher (keine Grenze außer Speicher). Bilder ≤ 2048 × 2048 (Bildgrenze).
Quelle: userland/image/PDF.swift; Hb. 3.135
Schriften
Reader (in PDFs)
nur in PDF– Eingebettete Schriftprogramme in PDFs: TrueType (cmap 0, 4, 6, 12; zusammengesetzte Glyphen bis 8 tief), OpenType mit TrueType- oder CFF-Umrissen, CFF (Type1C, CIDFontType0C), Type 1, Type 3. Ist ein Programm nicht lesbar, zeichnet Reader mit eigener Schrift in den Breiten des PDFs. Die Systemschriften (Inter, Source Serif 4, Roboto Condensed, JetBrains Mono) werden beim Bauen auf dem Mac umgewandelt (tools/fontgen), ohne Hinting. Jeder Versatz im Schriftprogramm wird gegen dessen Länge geprüft. Nicht: Schriftdateien als Dokument (.ttf, .otf, .woff – kein Dokumenttyp), Web-Schriften (@font-face wird übersprungen).
Quelle: userland/svg/PDFFontProgram.swift, PDFFontCFF.swift, PDFFontType1.swift, userland/web/CSSParser.swift, OutlineFont.swift
Word (DOC/DOCX), ODT, RTF, EPUB, PostScript/EPSneinnein Nicht unterstützt: kein Dokumenttyp im Kernel.
Quelle: kernel/lib/FileTypes.swift
Video
Matroska (.mkv)
Video, Files
jaja Eigener EBML-Code (RFC 8794/9559). Lesen: DocType matroska oder webm, Info, Tracks, Cluster, SimpleBlock und BlockGroup, Lacing Xiph/EBML/fest – nur über die Element-Köpfe, die Datei wird nie ganz geladen. Video spielt die Spuren V_MJPEG und V_VP9, Ton A_OPUS und A_PCM/INT/LIT, Erkennungen S_SOFTROBOTS/DETECTIONS; jeder andere Codec: Meldung „codec is not supported“. Schreiben in einem Durchgang (nur Anhängen): MJPEG-Bilder der Kamera unverändert mit ms-Zeitstempeln, ein Cluster je Sekunde, Cues am Ende; Erkennungen als eigene Spur, Ton als PCM-Spur. Geprüft gegen ffprobe/ffmpeg. Lesen: Verschachtelung ≤ 16, ≤ 4 Mio. Bilder je Datei, jede Elementgröße gegen das Elternelement geprüft; Dateigröße ohne feste Grenze. Aufnahme: bei 2 GB beginnt ein neuer Teil, Ende bei weniger als 2 GB freiem Platz; keine Zeitgrenze.
Quelle: userland/image/Matroska.swift, apps/video/Recording.swift (partLimit, freeLimit)
WebM (.webm)
Video, Web (Download)
ja– Bild VP9, Ton Opus; ein Sprung dekodiert ab dem Schlüsselbild davor; Ton nur bei Tempo 1× (sonst stumm). Nach einem Hänger springt der Ton zur Bildzeit, statt sich zu verschieben (10.11.). Nicht: VP8, AV1, Abspielen während des Ladens; WebM schreiben (Aufnahmen sind .mkv). Wie Matroska. Aus Web: Download ≤ 64 MiB und ≤ 10 min, dann erst abspielbar. Download-Tempo: Abschnitt 6.6 (11.11.2026: HTTPS aus dem Internet 35–59 MB/s).
Quelle: 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
ja– Profil 0 (8 Bit, 4:2:0) mit allen Werkzeugen: Schlüssel-, Inter-, Intra-only- und versteckte Bilder, Superframes, Compound-Prädiktion, alle Transformationen, Lossless (WHT), Segmentierung, Schleifenfilter, Kacheln, Referenzen anderer Größe. Bitgenau gegen alle 258 Testvektoren von libvpx. Bis 4 Bilder voraus dekodiert, Schleifenfilter auf 3 Kernen (bitgleich mit einem Thread), YUV→RGB mit SIMD (bytegleich). Nicht: Profile 1–3 (4:2:2, 4:4:4, 10/12 Bit) – Video zeigt einen Hinweis statt Bild. ≤ 8192 × 8192 Abtastwerte je Bild. Gemessen in SOFTrobotsVM (10.11.2026): 1080p dekodieren 8,9 ms je Bild mit 3 Threads (1 Thread 10,5 ms), umrechnen 1,4 ms; 360p mit 60 Bildern/s: 60 von 60 gezeigt (Abschnitt 6.12). Mac (M3 Pro, Release-Build): 1080p 3,3 ms mit 3 Threads.
Quelle: userland/video/VP9.swift (maxSize), VP9Loop.swift, docs/benchmarks/video-playback.md
Opus (Codec)
Video
janein Eigener Decoder nach RFC 6716, 7845, 8251: SILK, Hybrid, CELT, Kanalzuordnung Familie 0, 1 und 255, Ausgangsverstärkung, einfache Verlust-Verdeckung; Ausgabe 48 kHz. SILK bitgenau, CELT ≈ 85 dB Abstand zur Referenz. Nicht: Fehlerkorrektur aus LBRR-Rahmen, SILK-Komfortrauschen. Opus kodieren (Aufnahme): noch nicht. Jede Paketlänge geprüft; keine Längengrenze. Nur in WebM/Matroska – .opus-Dateien (Ogg) haben keinen Dokumenttyp.
Quelle: userland/opus/Opus.swift, kernel/lib/FileTypes.swift
MJPEG (Codec)
Video
jaja JPEG-Einzelbilder in Matroska (V_MJPEG); die Aufnahme übernimmt die Bilder der Kamera ohne Neukodieren. Je Bild die JPEG-Grenzen (oben).
Quelle: userland/image/Matroska.swift, apps/video/Recording.swift
MP4/MOV, H.264/AVC, H.265/HEVC, MPEG-1/2, AV1, VP8, AVIneinnein Nicht unterstützt: kein Container außer Matroska/WebM, kein Codec außer MJPEG und VP9. VP8 bewusst nicht (von VP9 abgelöst), AV1 später mit Hardware-Dekodierung.
Quelle: kernel/lib/FileTypes.swift (nur mkv, webm), apps/video/Codecs.swift, Hb. 3.131/3.132
Ton
WAV
Sound, Files
jaja Lesen: RIFF/WAVE, PCM 8/16/24/32 Bit Ganzzahl und 32 Bit Gleitkomma (auch WAVE_FORMAT_EXTENSIBLE), mono/stereo (mehr Kanäle: die ersten zwei), jede Abtastrate; Wiedergabe auf 48 kHz interpoliert, Sound rechnet intern mit 16 Bit. Nicht: komprimierte WAV (ADPCM, µ-law, A-law), 64-Bit-Gleitkomma, RF64.
Schreiben: 16 Bit PCM, 48 / 44,1 / 16 kHz, mono/stereo (Aufnahme, Export). Seit 10.11. Open… und Save As… über den System-Dialog.
Sound lädt die Datei ganz, ≤ 512 MiB (≈ 46 min Stereo, 48 kHz, 16 Bit). Aufnahme: keine Zeitgrenze im Code, alle 0,5 s auf DATA gesichert (übersteht einen Absturz).
Quelle: userland/sound/WAV.swift, apps/sound/Library.swift, apps/sound/SoundFile.swift
FLAC
Sound (Standard der Aufnahme), Files
jaja Eigener Encoder und Decoder nach RFC 9639: native .flac (ID3v2-Kopf davor wird übersprungen), 4–24 Bit, 1–8 Kanäle, Raten bis 1 048 575 Hz, STREAMINFO, SEEKTABLE, MD5. Encoder: Blöcke zu 4096, je Block L/R, L/S, S/R oder M/S, LPC bis Ordnung 12, Sprungtabelle alle 10 s; die Datei ist schon während der Aufnahme abspielbar. Bitgenau gegen ffmpeg in beide Richtungen, Dateien etwa so klein wie ffmpeg Stufe 5. Sound nimmt mit 16 Bit auf (48 / 44,1 / 16 kHz, mono/stereo) und rechnet beim Öffnen auf 16 Bit und 2 Kanäle um. Decoder liest blockweise über eine Lesefunktion: keine Grenze außer Speicher. Sound lädt ≤ 512 MiB. Aufnahme ohne Zeitgrenze.
Quelle: userland/sound/FLAC.swift, FLACDecoder.swift, FLACEncoder.swift, apps/sound/Library.swift, SoundFile.swift
PCM in Matroska
Video
jaja Tonspur A_PCM/INT/LIT, 16 Bit little-endian, neben dem Bild; Video nimmt 48 kHz mono auf und spielt mono oder stereo ab. Gegen ffmpeg geprüft. Wie Matroska.
Quelle: apps/video/Codecs.swift, apps/video/RecordSound.swift
MP3, AAC/M4A, Ogg Vorbis, .opus, AIFF, ALACneinnein Nicht unterstützt: weder lesen noch schreiben. MP3- und Opus-Aufnahme stehen in der Planung; Programme zeigen seit 10.11.2026 nichts „später“ mehr (apps/sound/Look.swift).
Quelle: kernel/lib/FileTypes.swift (nur wav, wave, flac), Hb. 3.134
Archive und Kompression
ZIP
Files
jaja Lesen: gespeichert und Deflate, ZIP64, WinZip AES (AE-1/AE-2), ZipCrypto (nur lesen); sichere Namen (kein „..“, keine absoluten Pfade, keine Steuerzeichen), Links und versteckte Namen (.DS_Store, __MACOSX) übersprungen. Andere Verfahren (z. B. bzip2, LZMA, Deflate64) werden übersprungen.
Schreiben: Deflate als Strom, UTF-8-Namen, Unix-Rechte und Zeit; Passwort nur WinZip AES-256 (AE-2, PBKDF2-HMAC-SHA1 mit 1000 Runden).
Lesen: Dateigröße ohne feste Grenze, jeder Eintrag läuft durch ≈ 130 KiB Speicher; das zentrale Verzeichnis muss im letzten 1 MiB der Datei liegen. Schreiben: ≤ 4 GiB je Datei und Archiv, ≤ 65 535 Einträge (kein ZIP64 beim Schreiben). Vorschau in Files ≤ 64 MiB.
Gemessen: Deflate 4 MiB 166 MB/s; 3 000 000 gemischte Bytes → 605 816 Bytes (Mac-Test, Hb. Kap. 6).
Quelle: userland/archive/ZipReader.swift (tailLimit), ZipWriter.swift, ZipCipher.swift, StreamInflate.swift, apps/files/Archives.swift
Deflate / zlib / gzip
PNG, ZIP, PDF, TIFF, Web
jaja Ein Inflate (RFC 1950/1951) für alle Formate, auch als Strom in Stücken bis 64 KiB; gzip nur als HTTP-Content-Encoding in Web. Deflate: Hash-Ketten über 32 KiB, ≤ 32 Kandidaten, ein Schritt Lazy Matching; jeder Block (≤ 16 384 Symbole oder 64 KiB) dynamisch, fest oder gespeichert – je nachdem, was kleiner ist. Ausgabe immer mit Obergrenze: PNG die berechnete Bildgröße, PDF 64 MiB je Strom, gzip in Web 64 MiB; im Strom (ZIP) ohne Grenze.
Quelle: userland/image/Inflate.swift, userland/archive/StreamInflate.swift, Deflate.swift, apps/web/Fetch.swift
tar, .gz als Datei, 7z, RAR, bzip2, xz, Zstandardneinnein Nicht unterstützt: kein Dokumenttyp im Kernel.
Quelle: kernel/lib/FileTypes.swift
Web
HTML und CSS
Web
ja– Lesebrowser ohne JavaScript: toleranter HTML-Leser (implizite End-Tags, <script> übersprungen, <noscript> gezeigt), CSS-Selektoren und -Werte, @media (Breite, Höhe, screen, helles Farbschema), @supports, @layer, @import. Bilder aller obigen Bildformate (auch data:-Adressen), <video> als Karte „Play in Video“. HTTP/1.1 (GET, chunked, gzip) über TLS 1.3, ohne Cookies und Referrer. Eigene Umrissschriften mit Kerning. Seit 10.11.: File › Open… öffnet eine .html-Datei, Save Page As… sichert die gezeigte Seite unverändert. Nicht: JavaScript, Cookies, @font-face, @keyframes, verschachtelte CSS-Regeln. ≤ 100 000 Knoten, Tiefe ≤ 256; ein Stylesheet ≤ 4 MiB, ≤ 16 externe mit zusammen < 4 MiB; Antwort ≤ 64 MiB; ≤ 600 Bilder je Seite und ≤ 160 MiB dekodierte Bildpixel; SVG-Bilder ≤ 4096 × 4096. Eine Seite hat 20 s, ein Download bis 10 min.
Quelle: userland/web/HTML.swift, CSSParser.swift, HTTPMessage.swift, apps/web/Images.swift, apps/web/main.swift, apps/web/Fetch.swift
Daten und Tabellen
SOFTrobotsDB (.db)
Programme (App-API); Database, Console
jaja Eigenes Objekt im Dateisystem (Abschnitt 8). Database und Console lesen jede Datenbank, schreiben nur im eigenen Ordner. Datensatz ≤ 4096 Bytes, 64 Tabellen je Datenbank, 64 Felder je Tabelle, Transaktion ≤ 4 MiB, ≤ 256 Zeilen je Abfrage-Aufruf (dann Cursor); große Daten als Datei-Feld (8.5).
Quelle: Abschnitte 8 und 14, docs/handbuch/grenzen.html
Serien (.series), Flugschreiber
Echtzeit-Programme; Database, Console
jaja Datensätze fester Größe mit Zeitstempel in 16-KiB-Blöcken, Zeitindex im Datenbank-Baum. Datensatz 8–1024 Bytes; Aufnahme-Ring 1–600 s, ≤ 32 MiB, 16 Ringe im System.
Quelle: Abschnitte 8 und 14
SQL
Console, Database
ja– Nur lesend: SELECT mit WHERE, GROUP BY, ORDER BY, LIMIT, COUNT/SUM/MIN/MAX/AVG, BETWEEN, LIKE (beginnt mit / enthält), IS NULL, LEFT/INNER JOIN über ref-Felder. Im Programm in den festen Bauplan des Kernels übersetzt. Nicht: INSERT, UPDATE, DELETE, Unterabfragen. ≤ 4 Joins (2 davon für WHERE/ORDER BY); Sortieren ohne Index Top-N ≤ 1000; ≤ 256 Gruppen.
Quelle: userland/sql/SQL.swift, Abschnitt 14
CSV
Export: Database, Console, Benchmark; Text
jaja Export: alle Zeilen der Abfrage (nicht nur die 1000 gezeichneten), Texte ganz, Anführungszeichen verdoppelt; Database fragt seit 10.11. über den System-Dialog, wohin. Text liest und bearbeitet CSV als Text. Export: keine Zeilengrenze. Text hält ≤ 4 MiB im Speicher.
Quelle: apps/database/Export.swift, apps/text/main.swift (textLimit)
JSON
Export: Database, Console, Benchmark; Text
jaja Export wie CSV, Texte maskiert. Text liest und bearbeitet JSON als Text. Wie CSV.
Quelle: apps/database/Export.swift, apps/text/main.swift
Text
Text, Markdown, Log, Einstellungen
Text, Files
jaja Endungen txt, text, md, markdown, log, csv, json, conf und die Datei config; gültiges UTF-8 ohne NUL-Bytes ist Pflicht (der Kernel prüft es). ⌘S speichert; seit 10.11. New, Open… und Save As… über den System-Dialog – Text legt damit erstmals neue Dateien an. Text hält ≤ 4 MiB im Speicher.
Quelle: kernel/lib/FileTypes.swift, apps/text/main.swift; Hb. 3.135
Absturzberichte (.crash)
Kernel schreibt, Monitor zeigt
jaja Text in DATA /state/crashes; seit Hb. 3.89 mit Bildern von Bildschirm und Kamera. Monitor › Report blättert seit 11.11.2026 durch alle aufbewahrten Berichte (Older/Newer). 20 Dateien, je ≤ 1 MiB.
Quelle: Abschnitt 14, docs/handbuch/grenzen.html
KI-Modelle (Standardformate, nicht signiert)
GGUF (Sprachmodelle)
KI-Dienst ai liest aus /models/language
ja– Das offene Format von llama.cpp (MIT-Lizenz), direkt gelesen. Formate Q8_0, Q4_K, Q6_K; Bauarten qwen2, qwen3, qwen3moe, llama, llama4, qwen3vl, kolibri1. Keine Signatur: Der Leser prüft jede Größe gegen die Datei (Host-Test GGUFFuzzTests: kleine kolibri1- und llama4-Dateien je 20 000-mal absichtlich beschädigt); eine kaputte Datei beendet den Dienst nicht. Größer als der Speicher: läuft mit festem Teil und Experten-Cache von der Platte (Abschnitt 15.3).
Quelle: userland/llm, tests/HostTests/GGUFFuzzTests.swift
ONNX (Erkennungsmodelle)
Camera liest aus /models/detection
ja– Offener Standard der Linux Foundation, direkt gelesen – ohne Umwandeln am Mac und ohne fremde Laufzeit. Die Gewichte werden beim Laden in 8 Bit umgerechnet (nur im Speicher). Keine Signatur. Camera lädt Modelle ≤ 64 MiB. Unbekannte Bausteine: Das Modell wird mit klarer Meldung abgelehnt.
Quelle: apps/camera/Models.swift, userland/infer/ONNX.swift
Signierte Systemformate
Programme (ELF + Manifest)
Kernel lädt; Develop, Mac-Werkzeug srapp
jaja AArch64-ELF, Ed25519-signiert; das Manifest trägt Rechte, Echtzeit-Vertrag und Speicherzusage (seit 10.11. auch dock = no). ≤ 32 MiB, ≤ 8 Segmente.
Quelle: kernel/lib/AppImage.swift (largestFile, maxSegments), kernel/lib/AppManifest.swift
.srshare (Reflex-Skript)
Develop
jaja Geteiltes Reflex-Skript („SOFTrobots share 1“), signiert; Develop zeigt es auf einer Prüfkarte, bevor es übernommen wird. Share… fragt, wohin das Paket soll; Import… über den System-Dialog. Keine eigene Größengrenze im Code gefunden (nicht geprüft).
Quelle: apps/develop/Share.swift, kernel/lib/FileTypes.swift; Hb. 3.135
.reflex
Develop, Files
jaja Quelltext der Sprache Reflex; übersetzt zu Bytecode oder ARM64. Seit 10.11.2026 eigener Dokumenttyp „Reflex script“ im Kernel (gültiges UTF-8 Pflicht); ein Doppelklick in Files übernimmt das Skript in Develop; Import… und Export… ⌘E über den System-Dialog. Editor ≤ 1 MiB Quelltext.
Quelle: apps/develop/Editor.swift (limit), kernel/lib/FileTypes.swift (reflex = 24); Hb. 3.135
.srupdate
Kernel liest; Mac-Werkzeug sign
jaMac Signiertes Update-Paket (Ed25519): Kernel und belegte Blöcke des Systemvolumes; falsche Signatur wird abgelehnt (make test-update). ≤ 4064 Systemblöcke zu 16 KiB (≈ 63,5 MiB) plus Kernel.
Quelle: kernel/lib/UpdatePackage.swift (maxBlocks)
QR-Code
Server (Einladung)
–ja Byte-Modus (UTF-8-Text als Bytes), alle vier Fehlerkorrektur-Stufen, alle acht Masken bewertet; mit Apples Vision gegengelesen (Host-Test). Versionen 1–10 (21 × 21 bis 57 × 57 Module), ≤ 271 Bytes (Stufe L) bzw. 213 (M).
Gemessen: Version 4 in 410 µs, Version 10 in 1,3 ms.
Quelle: userland/qr/QRCode.swift

35 Formate und Codecs werden gelesen oder geschrieben; die grauen Zeilen „nein“ nennen, was ausdrücklich fehlt. Grenzen sind Konstanten aus dem genannten Quelltext (gelesen am 10.11.2026), Tempo-Werte aus SOFTrobotsVM, sofern nicht als Mac-Wert vermerkt. Nachweise wie „bitgenau“ und „pixelgleich“ stammen aus den Host-Tests (Handbuch 3.34–3.37, 3.70–3.76, 3.102, 3.121, 3.129–3.137). Ein Format ohne eigene Zeile wird nicht unterstützt: der Kernel gibt einem Programm nur Dateien der 24 bekannten Dokumenttypen.

10Boot-Grafik und Boot-Zeiten

Die Start-Animation zeichnet der Kernel selbst – mit Ganzzahl-Arithmetik, weil der Kernel kein Gleitkomma benutzt: abgerundete Rechtecke, Ellipsen, Ringe, Kapseln und vorgerenderte Textmasken, Kanten mit 4 × 4 Abtastungen geglättet. Ein Thread niedriger Priorität zeichnet etwa 30 Bilder pro Sekunde.

  • Ablauf (2,3 s): Der kleine Roboter mit Bildschirmgesicht ist ab dem ersten Bild da: Der Kopf hebt sich, das Gesicht geht an, er öffnet die Augen, lächelt und winkt; Schriftzug „SOFTrobots OS“ und Geburtstagszeile („born 28 October 2026 · N days old“) erscheinen, dann ist der Desktop da. (kernel/core/BootScreen.swift, duration 2,3 s). Die Zeit bis zum fertigen Desktop ist mit der 2,3-s-Fassung nicht gemessen.
  • Startton: ein Dreiklang 0,3 s nach dem Start (Variante b), Servo-Surren beim Winken – aus dem Mischer des Kernels, ohne Gleitkomma; ohne Tongerät bleibt es still. Startet das Tongerät später, spielt es den ganzen Akkord, sobald es kann.
  • Die Schichtenzeile ist echt: Unten erscheinen nacheinander Firmware, Kernel, Devices, Storage, Network, Programs und Ready, jede mit der gemessenen Zeit, zu der diese Schicht im Kern fertig war.
  • Das System wartet nicht auf die Animation: Dienste, Echtzeitschleifen und Programme laufen dahinter wie ohne sie. Nur der Desktop fragt (Systeminfo), ob sie noch läuft. Jede Taste oder jeder Klick überspringt sie; ⌘+Esc löst auch währenddessen den Not-Halt aus.
  • Ohne Flackern: mit virtio-gpu entsteht jedes Bild im Gastspeicher und wird per Flush gezeigt; nur mit GOP (echte Hardware ohne Grafiktreiber) in einem Zwischenpuffer, der fertig hinüberkopiert wird.
  • Textzeilen statt Animation: Taste V beim Einschalten, Datei \SOFTROBOTS\VERBOSE (Testabbilder), ein zurückgerolltes Update, ein Panic oder die Einstellung „Start screen: Text“ (im Boot-Record, damit der Loader sie vor dem Entsperren lesen kann).

Boot-Zeiten

Boot-Zeitachse in SOFTrobotsVM (Sekunden nach dem Einschalten) 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 Sekunden 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-Adresse per DHCP ≈ 1,18 s (im Hintergrund, der Boot wartet nicht)
Schicht fertigSekunden nach dem Einschalten
Firmware0,52 s
Kernel0,53 s
Devices0,55 s
Storage0,58 s
Network0,58 s
Programs0,63 s
Ready (Hello)0,64 s
IPv4-Adresse per DHCP (Hintergrund)1,18 s

Quelle der Schichtzeiten: die Zeile unter der Boot-Animation im Bild oben (SOFTrobotsVM, Produktabbild 0.15.0, 08.11.2026). „Hello“ im Messlauf desselben Tages: 0,62 s. Firmware und Loader brauchen davon etwa 0,5 s; der Kernel selbst rund 90 ms. In QEMU dauert es bis „Hello“ etwa 6 s – fast nur emulierte Firmware.

11Echtzeit-Prozessor

Ein Roboterarm wird von einem Regelkreis gesteuert, der jede Millisekunde Sensoren liest und Motoren nachstellt. „Schnell im Durchschnitt“ reicht nicht – der Takt muss garantiert pünktlich sein. Dafür reserviert SOFTrobots OS den letzten Prozessorkern als Echtzeitkern.

Vertrag im signierten Manifest

realtime = 1000 100 stop heißt: Periode 1000 µs (1 kHz, das Periodenende ist die Frist), Budget 100 µs CPU-Zeit je Periode, Reaktion bei verpasster Frist log, stop, restart oder stop-actuators. Das Programm beendet jede Periode mit dem Grundbefehl periodWait.

Zulassung: Passt die Summe der Budgets nicht mehr auf den Echtzeitkern (≤ 900 ‰), wird das Programm gar nicht erst gestartet – statt später unberechenbar zu scheitern.

Was der Echtzeitkern garantiert

  • Keine anderen Threads, keine Lastverteilung auf oder von ihm, kein wfi-Schlaf.
  • Kein Heap und kein Dateizugriff für Echtzeit-Programme; nie ausgelagert.
  • Asynchrones Kernel-Log: Schreiber warten nie auf Konsole oder GPU.
  • Watchdog alle 50 ms; Zähler für Perioden, verpasste Fristen, mittlere und schlechteste Verspätung (Desktop-Karte ROBOT & REALTIME).
Messung (SOFTrobotsVM)GemessenZielUrteil
IRQ-Latenz (Deadline → Handler), Mittel42,0 ns< 10 µserfüllt
IRQ-Latenz, schlechteste666 ns< 10 µserfüllt
Kontextwechsel0,3 µs< 2 µserfüllt
Nachricht hin und zurück (IPC)1,2–1,7 µs< 1 µsnicht erfüllt: 1,2–1,7 µs auf verschiedenen Kernen, 6–8 µs auf demselben (F184)
Echtzeit-Aufwachen 1 ms, Mittel0,5 µs< 20 µserfüllt
Echtzeit-Aufwachen 1 ms, schlechteste7,6 µs< 20 µserfüllt (die drei Läufe: 7,6 / 3,0 / 3,0 µs)
Echtzeit-Programm 1 kHz: Startverzögerung Mittel / schlechteste0,13 µs / 0,5–16 µs (im Boot 26–77 µs)< 20 µserfüllt nach dem Start
Verpasste Perioden in 10 s00erfüllt
Gemessen im Verhältnis zum eigenen Ziel (Ziel = rote Linie) IRQ-Latenz, Mittel 0,4 % IRQ-Latenz, schlechteste (3 Läufe) 6,7 % Kontextwechsel 14,5 % Nachricht hin und zurück 120–170 % – über dem Ziel (verschiedene Kerne; derselbe Kern 600–800 %) Echtzeit-Aufwachen 1 ms, Mittel 2,4 % Echtzeit-Aufwachen, schlechteste (3 Läufe) 37,9 % Drei Messläufe am 15.11.2026 in SOFTrobotsVM (4 CPUs, 8 GB, Abbild der Vorschau, Build 234), Median; „schlechteste“ = der schlechteste Wert aller Läufe.

Quellen: Benchmark in SOFTrobotsVM am 15.11.2026, drei Läufe mit 4 CPUs und 8 GB, Abbild der Vorschau (docs/benchmarks/2026-11-15-m3pro-preview-4cpu-8gb-run1…3.csv). Echtzeit-Aufwachen, schlechtester Wert je Lauf: 7,6 / 3,0 / 3,0 µs. Nachricht hin und zurück: 1,2–1,7 µs auf verschiedenen Kernen, 6–8 µs auf demselben (sechs weitere Läufe, F184). Testprogramm control mit 1-kHz-Vertrag (Phase 9, Handbuch Kapitel 6, 10 s ohne verpasste Periode). Seit F143 (08.11.2026) sind Systemaufrufe unterbrechbar: Startet auf demselben Kern ein großes Programm, kommt ein Takt höchstens 6–7 µs zu spät statt bis 0,9 ms (docs/decisions.md). Develop beweist Echtzeit sogar vorab: Für „Wrist hold“ werden 39,4 µs von 1 ms (3,9 %) als schlechtester Fall berechnet (14.11.2026). Echte Hardware ist noch nicht gemessen.

12Geschwindigkeit in Zahlen (Programm Benchmark)

Das Programm Benchmark misst jeden Baustein einzeln: 80 Messungen in 15 Bereichen. Jede Messung hat eine feste Nummer, die ihre Bedeutung nie ändert, damit Läufe aller Versionen vergleichbar sind. Jeder Lauf wird in /data/benchmark/runs.db (einer SOFTrobotsDB-Datenbank) gespeichert; nach einem Update misst Benchmark von selbst. Werte des Kernels (Start, Scheduler, NVMe, Dateisystem, Plattenverschlüsselung, Programmstart, Passwortprüfung) werden beim Boot gemessen und übernommen.

Gemessen in SOFTrobotsVM auf Apple Silicon, Host: Apple M3 Pro (Mac15,7), 36 GB, macOS 27.0.1. Alle Zahlen sind der Median aus drei Läufen am 15.11.2026 (Version 0.15.0, Build 234, Abbild der Vorschau, 4 CPUs, 8 GB, jeder Lauf nach frischem Start, Mac am Netzteil, Netz per Kabel): 77 Messungen (die übrigen gibt es nur im Testabbild); bei „schlechteste“ der schlechteste Wert aller Läufe. Die Kernel-Werte stammen aus denselben Starts. Die Nachricht hin und zurück (20) hängt davon ab, ob das Partnerprogramm auf demselben Kern landet: 1,2–1,7 µs auf verschiedenen Kernen, 6–8 µs auf demselben (F184; die drei Läufe hier: 4,2 / 1,1 / 8,0 µs). Lesen (61, 63) schwankt mit dem Datei-Cache des Macs. Die Spalte „Messung“ zeigt den englischen Namen aus apps/benchmark/Metrics.swift.

12.1 Zwei Macs, dasselbe System

Dieselbe Vorschau (Build 234, 4 CPUs, 8 GB), je drei Läufe mit frischem Start, Median. M3 Pro: MacBook Pro, Apple M3 Pro, 36 GB, Netz per Kabel. M4: Mac mini M4, 16 GB, Netz per WLAN – darum sind die Netzwerk-Werte hier nicht verglichen. Von 75 gemeinsamen Messungen ist der M4 in 59 um mehr als 5 % schneller, in 7 gleich, in 9 langsamer (alle Werte: docs/benchmarks/2026-11-15-m3pro-vs-m4.md). Die Nachricht hin und zurück fehlt hier: Sie hängt auf beiden Macs davon ab, ob der Partner auf demselben Kern landet (F184).

MessungM3 ProM4M4 gegenüber M3 Pro
Einschalten bis „Hello from the kernel.“618 ms566 ms8 % kürzer
Interrupt-Latenz, Mittel42,0 ns28,0 ns33 % kürzer
Kontextwechsel290 ns252 ns13 % kürzer
An den Scheduler abgeben986 ns537 ns46 % kürzer
Nachrichten durch einen Kanal2,55 Mio./s3,58 Mio./s40 % mehr
Systemaufruf (Zeit)526 ns427 ns19 % kürzer
CRC-32 über 16 MiB493 MB/s614 MB/s25 % mehr
Speicher kopieren (32 MiB)49,3 GB/s43,0 GB/s13 % weniger
NVMe: 16 KiB lesen, ein Befehl38,6 µs9,27 µs76 % kürzer
NVMe: sequentiell lesen1,50 GB/s3,78 GB/s152 % mehr
NVMe: 16 KiB schreiben, ein Befehl80,3 µs82,0 µs2 % länger
NVMe: sequentiell schreiben554 MB/s575 MB/s4 % mehr
Programm: 4-MiB-Datei lesen99,0 MB/s344 MB/s247 % mehr
Programm: 4-MiB-Datei schreiben126 MB/s185 MB/s47 % mehr
Datenbank: 1000 Zeilen einfügen (auf der Platte)20,8 ms20,8 msgleich*
Messwerte in den Aufnahme-Ring2,36 Mio./s2,72 Mio./s15 % mehr
JPEG 1024 × 1024 öffnen9,45 ms8,55 ms10 % kürzer
Plattenverschlüsselung AES-256-GCM versiegeln4,26 GB/s5,08 GB/s19 % mehr
SHA-256193 MB/s281 MB/s46 % mehr
TLS-1.3-Handshake im Speicher (eigener Server und Client)2,43 ms2,23 ms8 % kürzer
Reflex: Beispielprogramm übersetzen30,3 µs25,2 µs17 % kürzer

* Gleicher Median, die einzelnen Läufe liegen bei 18,8–20,8 ms (M3 Pro) und 19,9–22,9 ms (M4). Etwa die Hälfte der Zeit ist das Festschreiben, also Schreiben auf die Platte – und Schreiben ist auf beiden Macs gleich schnell (siehe die zwei Schreib-Zeilen).

Prozessor-Speedtests (Bereich „Processor, memory“)

Nr.MessungWertBemerkung
40CRC-32 over 16 MiB493 MB/sBenchmark-Lauf
41Floating point (matrix 128 x 128)3709 Mio./sBenchmark-Lauf
42Memory copy (32 MiB)49253 MB/sBenchmark-Lauf
43Memory fill (32 MiB)32255 MB/sBenchmark-Lauf
44Heap: allocate and free an object67 nsBenchmark-Lauf
Prozessor und Speicher: Durchsatz (höher ist besser) MB/s CRC-32 über 16 MiB 493 MB/s Speicher kopieren 32 MiB 49253 MB/s Speicher füllen 32 MiB 32255 MB/s Verschlüsselung und Prüfsummen: Durchsatz (höher ist besser) MB/s, linear AES-256-GCM versiegeln (Platte) 4257 MB/s AES-256-GCM öffnen (Platte) 3995 MB/s SHA-256 (Prozessorbefehle) 193 MB/s ChaCha20-Poly1305 304,6 MB/s AES-256-GCM in einem Programm 57,5 MB/s

Alle Messungen

Nr.MessungWertBemerkung
Start · Start
1Power on to "Hello from the kernel."0,62 sFirmware + Loader + Kernel bis „Hello“
Scheduler, Echtzeit · Scheduler, realtime
10Interrupt latency, average42,0 nsKernel-Messung beim Start
11Interrupt latency, worst666 nsKernel-Messung beim Start
12Context switch0,3 µsBenchmark-Lauf
13Scheduling decision0,2 µsKernel-Messung beim Start
14Realtime wake-up (1 ms), average0,5 µsbeim Start auf dem Echtzeit-Kern (ab Build 236; davor auf einem Programm-Kern, F185)
15Realtime wake-up (1 ms), worst7,6 µsdie anderen zwei Läufe: 3,0 und 3,0 µs; bis Build 235 auf einem Programm-Kern gemessen, darum ein M4-Lauf mit 210 µs (F185); auf dem Echtzeit-Kern 6,8–9,0 µs in 6 Starts
16Realtime periods missed at boot0Kernel-Messung beim Start
17Sleep 1 ms: late by, average260 µsZeitgeber-Auflösung für Programme
18Yield to the scheduler1,0 µsBenchmark-Lauf
Nachrichten (IPC) · Messages (IPC)
20Message sent and received1,2–1,7 µsProgramme auf verschiedenen Kernen (6 Läufe am 15.11.2026); auf demselben Kern 6–8 µs (F184)
21Wake the other end (notify)6,7 nsnur noch, wenn die Gegenseite schläft (F143)
22Messages through a channel2,5 Mio./sBenchmark-Lauf
Programme · Programs
30Start and end a program1,3 msnur im Testabbild: Läufe vom 15.11.2026 (Build 233, 4 CPUs, 8 GB)
31Start from the app cache81 µsnur im Testabbild: Läufe vom 15.11.2026 (Build 233, 4 CPUs, 8 GB)
32System call (time)526 nsBenchmark-Lauf
33System information read (system.info)3,1 µsBenchmark-Lauf
34Installed programs listed (all, with id and version)660 µsBenchmark-Lauf
Prozessor, Speicher · Processor, memory
40CRC-32 over 16 MiB493 MB/sBenchmark-Lauf
41Floating point (matrix 128 x 128)3709 Mio./sBenchmark-Lauf
42Memory copy (32 MiB)49253 MB/sBenchmark-Lauf
43Memory fill (32 MiB)32255 MB/sBenchmark-Lauf
44Heap: allocate and free an object67 nsBenchmark-Lauf
Platte (NVMe) · Disk (NVMe)
50Read 16 KiB, one command38,6 µsKernel-Messung beim Start
51Write 16 KiB, one command80,3 µsKernel-Messung beim Start
52Sequential read (16 commands at once)1500 MB/sKernel-Messung beim Start
53Sequential write (16 commands at once)554 MB/sKernel-Messung beim Start
Dateisystem · File system
60Kernel: 4 MiB written and committed255 MB/sKernel-Messung beim Start
61Kernel: 4 MiB read and checked779 MB/sKernel-Messung beim Start
62App: 4 MiB file written126 MB/sBenchmark-Lauf
63App: 4 MiB file read99 MB/sBenchmark-Lauf
64Small file created and removed8,0 msBenchmark-Lauf
65Folder entry listed374 µsBenchmark-Lauf
Datenbank · Database
701000 rows inserted (on disk)20,8 msBenchmark-Lauf
711000 rows inserted (soon)9,8 msBenchmark-Lauf
72Row by id37,6 µsBenchmark-Lauf
73Range through an index (100 rows)4,0 msBenchmark-Lauf
74Sorted without an index (top 100 of 1000)20,4 msBenchmark-Lauf
75Count in groups (1000 rows)2,6 msBenchmark-Lauf
76SQL statement translated0,8 µsBenchmark-Lauf
Serien, Aufzeichnung · Series, recording
80Records pushed into the ring2,4 Mio./sBenchmark-Lauf
81Records dropped (10 000 pushed)0Benchmark-Lauf
82Time range read back (1000 records)15,4 msBenchmark-Lauf
Bilder, ZIP · Pictures, ZIP
90PNG 1024 x 1024 saved67,7 msBenchmark-Lauf
91PNG 1024 x 1024 opened17,9 msBenchmark-Lauf
92JPEG 1024 x 1024 saved12,7 msBenchmark-Lauf
93JPEG 1024 x 1024 opened9,4 msBenchmark-Lauf
94Deflate (ZIP) 4 MiB240 MB/sBenchmark-Lauf
95GIF 512 x 512 opened2,2 msBenchmark-Lauf
96TIFF 1024 x 1024 saved79 msBenchmark-Lauf
97TIFF 1024 x 1024 opened28,9 msBenchmark-Lauf
98SVG drawing read and drawn (512 x 512)7,0 msBenchmark-Lauf
Anzeige · Display
100Whole picture 1280 x 800 filled3858/sBenchmark-Lauf
101Characters drawn6,3 Mio./sBenchmark-Lauf
102Window drawn and shownbraucht Fensterbraucht ein offenes Fenster; der Lauf ohne Fenster lässt sie aus
103Key mapped (German layout, umlauts)4,3 nsBenchmark-Lauf
104Key typed into a text field10,1 nsBenchmark-Lauf
105Text field drawn17,2 µsBenchmark-Lauf
Verschlüsselung · Encryption
110Disk: AES-256-GCM seal (hardware)4257 MB/sKernel-Messung beim Start
111Disk: AES-256-GCM open (hardware)3995 MB/sKernel-Messung beim Start
112SHA-256193 MB/sBenchmark-Lauf
113AES-256-GCM in an app57,5 MB/sBenchmark-Lauf, Software-Fassung; TLS in Programmen seit 11.11. mit AES/PMULL (Abschnitt 6.6)
114ChaCha20-Poly1305 in an app304,6 MB/sBenchmark-Lauf, Software-Fassung; TLS in Programmen seit 11.11. mit NEON (Abschnitt 6.6)
115Ed25519 signature checked195 µsBenchmark-Lauf
116Password check (Argon2id, 64 MiB)182 msKernel-Messung beim Start
117ECDSA P-256 signature made1,0 msBenchmark-Lauf
118ECDSA P-256 signature checked0,7 msBenchmark-Lauf
Netzwerk · Network
120Name resolved (DNS over HTTPS)70 msBenchmark-Lauf
121TLS 1.3 handshake66,4 msBenchmark-Lauf
122HTTPS page fetched (example.com)113 msBenchmark-Lauf
Server, Zertifikate · Server, certificates
130Robot's root certificate made4,0 msBenchmark-Lauf
131Server certificate issued by the root3,0 msBenchmark-Lauf
132TLS 1.3 handshake, own server and client in memory2,4 msBenchmark-Lauf
133TLS 1.3 data, server to client in memory56,1 MB/sBenchmark-Lauf
134HTTP request head read (browser request)3,4 µsBenchmark-Lauf
135QR code made (version 4)100 µsBenchmark-Lauf
136QR code made (version 10)0,4 msBenchmark-Lauf
Develop (Reflex) · Develop (Reflex)
140Reflex: system shapes read (catalog)1,6 msBenchmark-Lauf
141Reflex: example program compiled30,3 µsBenchmark-Lauf
142Reflex: periodic handler run (interpreter)0,3 µsBenchmark-Lauf
Platte und Dateisystem: Durchsatz (höher ist besser) MB/s, linear NVMe sequentiell lesen 1500 MB/s NVMe sequentiell schreiben 554 MB/s FS: 4 MiB schreiben + Commit 255 MB/s FS: 4 MiB lesen + Prüfung 779 MB/s App: 4 MiB Datei schreiben 126 MB/s App: 4 MiB Datei lesen 99 MB/s NVMe-Lesen kommt aus dem Page-Cache des Mac (Image-Datei), nicht von der SSD. Kurze Wege: Zeiten (kürzer ist besser) Mikrosekunden, linear Kontextwechsel 0,3 µs Echtzeit-Aufwachen, Mittel 0,5 µs IPC-Runde 1,2–1,7 µs NVMe 16 KiB lesen 38,6 µs DB: Zeile nach Id 37,6 µs Start aus dem App-Cache 69–82 µs NVMe 16 KiB schreiben 80,3 µs Datenbank: Zeiten (kürzer ist besser) Millisekunden, linear 1000 Zeilen einfügen (Platte) 20,8 ms 1000 Zeilen einfügen (soon) 9,8 ms Bereich über einen Index 4,0 ms Top 100 ohne Index 20,4 ms Zählen in Gruppen 2,6 ms SQL übersetzen 0,8 µs

Weitere Messwerte aus Boot-Log und Handbuch

MessungWertWo / wie gemessen
System und Programme
Programm aus dem App-Cache starten53–56 µsSOFTrobotsVM, Phase 14 (erster Start ca. 2 ms); Code und Konstanten geteilt
Programm starten und beenden (Lebenszyklus)0,77–0,80 msSOFTrobotsVM, Handbuch Kapitel 6
Signaturprüfung je Programm beim Start / Hashen aller Programme430 µs / 3,3 msBoot-Log 08.11.2026: 6 MiB, SHA-256 mit Prozessorbefehlen
Fair Share mit Gewichten 2 : 12,0Boot-Log 08.11.: 66 ms : 33 ms
Krypto im Kernel (Boot-Log 08.11.2026)
SHA-256 mit Prozessorbefehlen2149 MB/sin einem Programm ohne diese Befehle: 193 MB/s (Benchmark)
X25519-Schlüsseltausch10 322 /sHandbuch Kapitel 6
ChaCha20-Poly130576 MB/sSoftware, Selbsttest des Kernels am 11.11.2026 (network-download.md; Boot-Log 08.11.: 57,8 MB/s)
Verschlüsselung in einem Programm (11.11.2026, netbench, je 8 MiB)
ChaCha20 mit NEON1657–1735 MB/sSOFTrobotsVM, make vm-net-bench, zwei Läufe
ChaCha20-Poly1305 versiegeln703–719 MB/sdasselbe
AES-256-GCM mit AES/PMULL4594–4896 MB/sdasselbe; beim ersten Verbinden gegen die Swift-Fassung geprüft
Argon2id je Passwortprüfung (64 MiB, 3 Durchläufe)182 msabsichtlich teuer: bremst Raten
Netz und Caches (Hb. 3.93, je drei Läufe in SOFTrobotsVM)
8 neue Namen über DNS über HTTPS455 msdie Verbindung bleibt offen, 64 Namen im Cache
8 Abrufe vom selben Webserver448 msKeep-Alive
Hashen aller Programme beim Start (SHA-256 in Hardware)3,4 msHb. 3.93
Medien
Objekterkennung je Kamerabild (int8, 3 Kerne)44 msSOFTrobotsVM; bei ruhigem Bild entfallen 75 % der Läufe (Hb. 3.93)
JPEG 640 × 480 dekodieren (Kamerabild)4 msSOFTrobotsVM, Camera
ZIP mit Passwort entpacken / 6 Dateien (10,3 MiB) packen61 / 655 msSOFTrobotsVM, AES in Software
PDF-Seite zeichnen (eine Seite des Datenblatts)≈ 0,06 sMac, Host-Test (Hb. 3.130) – kein VM-Wert
Video (10.11.2026, docs/benchmarks/video-playback.md)
VP9 1080p dekodieren je Bild, 3 Threads / 1 Thread8,9 / 10,5 msSOFTrobotsVM, make vm-vp9-bench, 600 Bilder (Abschnitt 6.12)
YUV → RGB umrechnen, 1080p je Bild1,4 msSOFTrobotsVM; in einen gehaltenen Puffer 1,1 ms
360p-Video mit 60 Bildern/s: gezeigt je Sekunde60 von 60SOFTrobotsVM, Big Buck Bunny
Downloads (11.11.2026, make vm-net-bench, 100 MB, docs/benchmarks/network-download.md)
Eigener Weg: HTTP von einem Server auf dem Mac, ohne Internet und TLS110–218 MB/sSOFTrobotsVM auf dem M3 Pro; um 190–200 MB/s bei ruhigem Mac (Abschnitt 6.6)
HTTPS von OVH35–59 MB/sMac per Kabel am Netz, Leitung 934 Mbit/s (≈ 117 MB/s)
HTTPS von Hetzner9–58 MB/sschwankt stark, offen; curl auf dem Mac 80–96 MB/s von denselben Servern

13Warum es schnell ist – Gründe und Belege

Hier steht, was SOFTrobots OS schneller macht und woran man es misst. Vergleichsmessungen mit anderen Systemen haben wir nicht gemacht; was nicht gemessen ist, sondern aus der Bauart folgt, ist mit Bauart markiert – ohne geschätzte Faktoren.

BausteinWas wir anders machenBeleg (gemessen)Einordnung
StartKleiner Kernel (1,21 MiB geladen), keine Suche nach Altgeräten, Messungen und Selbsttests erst nach „Hello“, nichts auf dem Boot-Weg wartet auf das Netz. 0,62 s bis „Hello“, davon Kernel ≈ 90 ms, Rest Firmware und Loader; Boot-Animation 2,3 s; die Zeit bis zum fertigen Desktop ist mit dieser Animation nicht gemessenDer größte Teil der Zeit liegt in Firmware und Loader, nicht im Kernel.
Interrupts und EchtzeitReservierter Echtzeitkern ohne wfi, tickloser Zeitgeber im One-Shot-Betrieb, kurze obere Hälften, unterbrechbare Systemaufrufe, asynchrones Log. IRQ 42,0 ns Ø, Aufwachen 0,5 µs Ø, 0 verpasstZiele < 10 µs und < 20 µs erfüllt, auch im schlechtesten Wert aller Läufe (958 ns, 6,5 µs). Echtzeit ist ein Vertrag mit Zulassung, keine Einstellung.
KontextwechselHeiße Scheduler-Methoden ohne Struct-Kopien, Per-CPU-Zustand nie in Optional; Lazy FP/SIMD. 0,3 µs; Entscheidung allein 0,2 µsZiel < 2 µs erfüllt.
Kommunikation zwischen ProgrammenKanäle sind gemeinsame Seiten mit zwei Ringen; der Kernel kopiert nie eine Nachricht. Wartet die Gegenseite, entfällt der Weck-Aufruf ganz. 1,2–1,7 µs hin und zurück (verschiedene Kerne; derselbe Kern 6–8 µs); 2,5 Mio./s Nachrichten; notify 6,7 nsBauart keine Serialisierung und keine Kopie im Kernel. Ziel 1 µs: im Median knapp erreicht (0,9 µs), in 2 von 4 Läufen verfehlt (1,07 und 1,24 µs).
PlattenverschlüsselungAES-256-GCM mit den ARM-Krypto-Befehlen in eigenem Assembler (crypto.S), je Block, mit Schutz gegen zurückgespielte Blöcke. 4257 MB/s / 3995 MB/s; Software-AES im Programm 57,5 MB/sDie Verschlüsselung ist schneller, als die VM-Platte liest (Lesen aus einem Programm 149–154 MB/s): sie ist nicht der Engpass.
Prüfsummen und SignaturenCRC-32C und SHA-256 mit Prozessorbefehlen; geprüfte Programme merkt sich der App-Cache. SHA-256 2149 MB/s; Signatur je Programm 430 µsEin geprüftes Programm wird nicht erneut gehasht (App-Cache).
DateisystemKein Journal; Block = Seite = Baumknoten = DMA-Puffer; gebündelter Commit mit FUA; kein atime; kleine Dateien im Baum; Freiplatz-Karte auf der Platte. 4 MiB 255 MB/s schreiben, 779 MB/s lesen; 280 Dateien in einem Commit 4,2 ms; Einbinden 11 msBauart jede Änderung wird einmal geschrieben, nicht zweimal; ein Flush + FUA je Commit. Mit anderen Dateisystemen verglichen ist das nicht gemessen.
DatenbankCommit des Dateisystems = Commit der Datenbank; ein Systemaufruf je Transaktion; Abfragen im Kernel; Ringe für Messwerte; große Daten als Datei (8.4, 8.5). Zeile nach Id 37,6 µs; 1000 Zeilen 9,8 ms; Ring 2,4 Mio./sBauart ein Flush je kleinem dauerhaftem Commit, kein eigenes Log; große Werte werden einmal geschrieben; Messwerte aus Echtzeit-Code ohne Systemaufruf. Mit anderen Datenbanken verglichen ist das nicht gemessen.
Speicher16-KiB-Seiten und 32-MiB-Blöcke (weniger TLB-Fehlgriffe), Zusagen statt Überbuchung, Auslagerung nur in den eigenen Bereich des Programms; Echtzeit nie ausgelagert. Speicher kopieren 49253 MB/s, füllen 32255 MB/s; Heap-Objekt 67 nsBauart 16 KiB statt 4 KiB: ein TLB-Eintrag deckt die vierfache Fläche ab. Die Wirkung allein ist nicht gemessen.
NetzEigener Stack im Kernel mit Interrupts statt Polling, Window Scaling, offene Verbindungen für DoH und Web, Zurück aus dem Speicher; 256 Empfangspuffer im Treiber, eine Gerätemeldung pro Bündel, Kopien in Blöcken, 8 KiB je Lese-Aufruf, 4-MiB-Ringe und 64 gemerkte Bereiche für Downloads. Ping 0,1 ms; 8 Web-Abrufe 448 ms; eigener Weg 110–218 MB/s, HTTPS von OVH 35–59 MB/s (100 MB, 11.11.)Internet-Downloads liegen unter dem, was curl auf dem Mac vom selben Server holt (80–96 MB/s); die Grenze ist noch nicht gefunden (Abschnitt 2).
TLS in ProgrammenAES-GCM mit den AES/PMULL-Befehlen, ChaCha20 mit NEON in eigenem Assembler (userland/tls/asm), beim ersten Verbinden gegen die Swift-Fassung geprüft; kein Zustand mehr auf dem Stack kopiert. AES-256-GCM 4594–4896 MB/s; ChaCha20-Poly1305 703–719 MB/s (11.11.)Beide liegen weit über der Leitung am Messplatz (117 MB/s).
VideoVordekodieren und Aufholen der Reihe nach, Schleifenfilter auf 3 Kernen, Farbumrechnung mit SIMD, Programme mit Heap ohne Strict Alignment, Video mit -O gebaut. 1080p dekodieren 8,9 ms, umrechnen 1,4 ms je Bild; 360p und 720p 60 von 60 BildernZusammen ≈ 10 ms von 16,7 ms je Bild bei 60 Bildern/s (VM, 10.11.).
Erkennung im GerätEigene int8-Inferenz mit sdot-Assembler, auf 3 Kerne verteilt; unveränderte Bilder werden nicht neu erkannt. 44 ms je Bild; 75 % der Läufe bei ruhigem Bild gespartMit der Mac-Kamera etwa 10 Erkennungen je Sekunde, bit-genau zur Referenz (Hb. 3.93).
Was wir weggelassen habenKeine POSIX-Schicht, kein Kompatibilitätscode, keine Kompression im Dateisystem (LZ4 gemessen und gestrichen), keine 3D-Effekte; im VP9-Decoder SIMD-Schleifenfilter und SIMD-Bewegungsausgleich gemessen und wieder entfernt (10.11.). LZ4: entpacken 600–1200 MB/s (eigener Codec, ein Kern); SIMD-Schleifenfilter 12–15 % langsamer, SIMD-Bewegungsausgleich ohne Unterschied (Mac)Eine schnelle SSD liest schneller, als LZ4 entpacken kann; darum gibt es keine Kompression im Dateisystem.

Angaben „Bauart“ beschreiben den Aufbau (Zahl der Schreibvorgänge, Flushes, Kopien) nach docs/database-concept.md Abschnitte 5 und 9 und docs/decisions.md; gegen andere Systeme gemessen ist nichts davon.

14Grenzwerte

Feste Grenzen aus dem Code (am 14.11.2026 nachgeprüft für Threads, Prozessplätze, Worker, Heap, Kanäle, Capabilities und KI; die übrigen am 08.–11.11.2026) und aus der Grenzen-Übersicht des Handbuchs (Stand 05.11.2026). Die meisten sind Konstanten und lassen sich anheben, wenn ein Anwendungsfall es verlangt.

GrenzeWert
Prozessor
ArchitekturAArch64, nur 64 Bit; 16-KiB-Granule Pflicht
Kerne≤ 8 CPUs; letzter Kern = Echtzeitkern
Threads≤ 256 im System, 64 je CPU-Warteschlange
Arbeitsspeicher
Verwalteter RAM≤ 16 GiB (VM-Vorgabe 4 GiB)
Seite / größter Block16 KiB / 32 MiB
Heap je ProgrammVorgabe 256 MiB, memory = 16 … 2048 MiB; Heap aus höchstens 512 Stücken zu ≤ 32 MiB (≤ 16 GiB)
Systemreserve / Spitzen-Polster256 MiB / ≈ 3 % des RAM (64 MiB … 1 GiB)
Eigener Auslagerungsbereich2 × Zusage, höchstens 4 GiB
App-Stack64 KiB Vorgabe, stack = 64 … 8192 KiB
Platte
PartitionenEFI 64 MiB · SYSTEM_A 512 MiB · SYSTEM_B 512 MiB · DATA Rest (GPT, 1-MiB-Ausrichtung; neue Images seit 11.11.2026, ältere mit Systemseiten zu 2 GiB)
Größtes DATA-Volume≈ 1,99 TiB (1024 Kartenblöcke × 130 560 Blöcke)
Name / Pfad80 Bytes UTF-8 / 255 Bytes, 32 Teile
Offene Dateien64 im System, 16 je Programm; 16 KiB je Lese-/Schreibaufruf
Block-CacheDATA 32 MiB, Systemvolume 512 KiB
Snapshotsalle 15 min, 24 h / 7 d / 30 d, höchstens 400
Programme
Gleichzeitig laufend127 (128 Prozessplätze, Platz 0 = Kernel)
Programmdatei≤ 32 MiB ELF, ≤ 8 Segmente; Programm-Cache 32 Einträge
Worker-Threads7 je Programm (+ Hauptthread)
Fenster (Zeichenflächen)3 je Programm, 16 im System
Menüs6 Menütitel und 64 Einträge je Fenster; Dock: 6 angeheftet
Dokumenttypen (opens =)16 Endungen je Programm (opens = und takes =); der Kernel kennt 24 Typen
Echtzeit-VertragPeriode 100 µs … 1 s, Auslastung ≤ 900 ‰ je Kern
Capabilities35 von 64 Bits belegt
Datei-Dialog≤ 16 Freigaben je Programm (solange es läuft), ≤ 3 Dialoge gleichzeitig, eine offene Frage je Programm
IPC
Kanäle64 im System
Systemaufrufe14 Nummern (0–13), Obergrenze 100
Veröffentlichungen16 im System, 1 je Programm, ≤ 2 Abos
Netzwerk
TCP-Verbindungen64 im System (Hälfte davon für eingehende); Empfangsring 128 KiB je Verbindung, ab 1 MiB Empfang einer von 4 Ringen zu 4 MiB (Fensterskalierung 7); 64 gemerkte Bereiche außer der Reihe
Netz lesen≤ 8 KiB je Systemaufruf (receive(area:); receive(into:) 1 KiB); virtio-net 256 Empfangspuffer
Lauscher8; Warteschlange 16, 16 halb offene je Lauscher
UDP-Sockets4 im System, 1472 Bytes je Datagramm
TLS-Verbindungen4 je Programm (+ 1 für DNS über HTTPS)
DNS-Cache64 Namen je Programm
Datenbank
Tabellen / Felder64 je Datenbank / 64 je Tabelle
Datensatz≤ 4096 Bytes (alle Felder); große Daten als Datei
Transaktion≤ 4 MiB
Zeilen je Abfrage-Aufruf256 (Ausgabe ≤ 256 KiB, danach Cursor)
Sortieren ohne IndexTop-N ≤ 1000
Offene Datenbanken4 je Programm, 32 im System
Joins2 für WHERE/ORDER BY, 4 zum Anzeigen; Sortieren nach verknüpftem Feld mit LIMIT ≤ 1000
Aufnahme-Ringe16 im System, 1 … 600 s, ≤ 32 MiB
Geräte
USB-KlassenErlaubnisliste HID, CDC-ACM, UVC, signierte Herstellertreiber; gebaut: HID
Kameras4 gleichzeitig
Grafik
Bildschirm≤ 8192 × 8192 (virtio-gpu); VM 1280 × 800
Bilder≤ 2048 × 2048 Pixel, ≤ 16 MiB je Datei
PDFDatei ≤ 256 MiB, Strom ≤ 64 MiB entpackt, Verschachtelung ≤ 32; Vorschau in Files bis 32 MiB
Camera / VideoAufnahme (Camera) in Teilen zu 2 GB, Ende bei weniger als 2 GB freiem Platz; ≤ 4 Mio. Bilder je Datei; VP9 ≤ 8192 × 8192; Download aus Web ≤ 64 MiB, ≤ 10 min
Sprachmodell: Gesprächsgedächtnisbis 32 768 Positionen (höchstens die Grenze des Modells), 16 Bit; über 4096 nur, solange ein Viertel dieses Platzes frei bleibt
Sprachmodell: GrößeGanz im Speicher, wenn Datei + Gedächtnis + Arbeitsspeicher + 64 MiB in den Platz passen (¾ des Speichers, höchstens was frei ist), mit mindestens 1024 Positionen. Ein größeres Modell läuft trotzdem: Der feste Teil bleibt im Speicher, die Experten kommen über einen Experten-Cache von der Platte (Settings › AI: „runs slower“); Modelle ohne Experten lesen dann für jedes Wort die ganze Datei. Formate Q8_0, Q4_K, Q6_K
AskFrage ≤ 512 Zeichen; die letzten 30 Gespräche werden aufbewahrt, einzeln löschbar
MikrofonRing ≈ 1,4 s je Mikrofon, 48 kHz, 16 Bit; Pegel alle 10 ms
Sicherheit
Passwort8 … 64 Zeichen; Argon2id 64 MiB, 3 Durchläufe
Bildschirmsperre1 … 1440 min oder aus (Vorgabe 5)
System
Boot bis „Hello“≤ 1,0 s in SOFTrobotsVM (Testpflicht); QEMU ≤ 10 s
Absturzberichte / Logs20 Dateien / die letzten 10 Starts, je 1 MiB

15KI direkt im Gerät, ohne Umwege

Sprachmodelle und Objekterkennung laufen im System selbst: eigener Code von der Modelldatei bis zur Antwort, keine Cloud, kein fremdes KI-Programm, kein Python, keine Bibliothek wie llama.cpp im Gerät. Ein Programm stellt eine Frage über die App-API und bekommt die Antwort aus dem Speicher desselben Rechners.

Der Weg einer Frage

  • Ein Dienst für alle: ai lädt das Modell einmal; Programme mit dem Recht ai.use (im signierten Manifest) sprechen über einen eigenen Kanal mit ihm (AI.Session). Kein Programm lädt ein eigenes Modell.
  • Eigene Inferenz (userland/llm, 2265 Zeilen Swift): GGUF lesen, Tokenizer, Transformer (Architekturen qwen2, qwen3, qwen3moe, llama, llama4, qwen3vl, kolibri1), Formate Q8_0, Q4_K, Q6_K. Die Matrixprodukte laufen in eigenem Assembler mit den ARM-Befehlen sdot und smmla (userland/infer/asm/kernels.S, 1198 Zeilen), verteilt auf alle Kerne für Programme.
  • Bilder: Qwen3-VL mit eigenem Bild-Encoder (Vision.swift); Ask schickt ein Bild aus einer Datei, aus Files gezogen oder von der Kamera mit.
  • Gedächtnis folgt dem Speicher: bis 32 768 Positionen, in 16 Bit; der Dienst sagt vorher, ob ein Modell ganz in den Speicher passt oder langsamer von der Platte läuft (Abschnitte 14 und 15.3).

Geprüft gegen die Referenz

  • Host-Tests und make vm-llm-check vergleichen Tokens und die gierige Antwort exakt mit llama.cpp (Homebrew, CPU).
  • Perplexität (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.11.2026).
  • Bilder: qwen3VLAnswerMatchesLlamaCpp vergleicht mit llama-mtmd-cli.
  • Objekterkennung: die 8-Bit-Rechnung der Engine bit-genau zu einer NumPy-Referenz (make infer-check).

15.1 Gemessen: Wörter je Sekunde im Gerät

Mit dem Mess-Standard (SOFTrobotsVM, 4 CPUs, davon 3 für Programme, 8 GiB, Mac am Netzteil, drei Läufe am 15.11.2026, Median; erste Antwort / Folgefrage / Zitat): Qwen3-4B-Instruct-2507 31,3 / 29,7 / 46,3, erstes Wort nach 0,54 s, 8192 Positionen; Qwen2.5-Coder-7B 18,6 / 18,1 / 28,2, erstes Wort nach 0,99 s, 4096 Positionen. Die Tabelle darunter stammt noch aus den Läufen mit 7 CPUs (6 für Programme) vom 12. und 14.11.; mit mehr Kernen schreibt dasselbe Modell schneller.

SOFTrobotsVM mit 7 CPUs (6 für Programme), Mac am Netzteil; aicheck mit vier Fragen zu je höchstens 160 Tokens; Werte: erste Antwort / Folgefrage / Zitat. Ein „Wort“ ist hier ein Token. Alle Dateien per SHA-256 gegen Hugging Face geprüft. Quelle: docs/benchmarks/local-ai.md.

ModellDatei4 GiB8 GiB16 GiBerstes Wort
Qwen3-1.7B Q8_01749 MiB56,5 / 57,1 / 70,0gleich–0,17 s
Qwen3-4B-Instruct-2507 Q4_K_M2381 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.11.)4466 MiBpasst nicht24,8 / 24,7 / 48,923,3 / 23,1 / 47,00,57 s
Qwen3-8B Q4_K_M4794 MiBpasst nicht23,8 / 22,5 / 26,323,7 / 22,5 / 26,30,74 s
Qwen3-14B Q4_K_M8584 MiBpasst nichtpasst nicht12,3 / 12,1 / 12,01,1 s

Gemessen am 12.11.2026, Qwen2.5-Coder am 14.11.2026 (8 GiB mit 4096 Positionen, 16 GiB mit 32 768). Die Geschwindigkeit hängt vom Modell ab (Speicherbandbreite), nicht von der Speichergröße der VM. Zum Vergleich liest ein Mensch etwa 5 Wörter je Sekunde.

15.2 Neben llama.cpp gemessen (12.11.2026, je 6 Kerne)

Modellllama.cpp AntwortSOFTrobots Antwortllama.cpp PromptSOFTrobots Prompt
Qwen2.5-0.5B Q8_0164163–1731046 Tokens/s≈ 410 Tokens/s
Qwen2.5-1.5B Q4_K_M6293–105 (5 Kerne)117 Tokens/s≈ 210 Tokens/s
Qwen3-8B Q4_K_M14,322–2524 Tokens/s≈ 54 Tokens/s

Antwort in Wörtern je Sekunde, Prompt mit 35 Tokens. llama.cpp lief nativ auf dem Mac (llama-bench -t 6 -ngl 0, nur CPU), SOFTrobots in SOFTrobotsVM auf demselben Mac. Beim kleinen 8-Bit-Modell ist llama.cpp beim Prompt schneller, bei den 4-Bit-Modellen SOFTrobots. Mit Grafikkarte (Metal) ist llama.cpp nicht verglichen.

15.3 Größer als der Speicher: Modelle mit Experten

Viele große Modelle bestehen aus Experten (Mixture of Experts): Für jedes Wort wählt eine Weiche in jeder Schicht nur wenige aus. Passt ein solches Modell nicht in den Speicher, bleibt der feste Teil (Aufmerksamkeit, Vektoren, Kopf, gemeinsamer Experte) im Speicher; der Rest ist ein Experten-Cache, und was fehlt, liest der Dienst von der Platte. Kolibri-1 (Q4_K_M, 47,5 GB, 78 Mrd. Parameter, davon 3,46 Mrd. aktiv) nimmt in jeder Schicht 6 von 384 Experten; ein Experte ist 2,6 MB groß, pro Wort liest es etwa ein Zwanzigstel der Datei.

MessungWertEinstellung
In SOFTrobotsVM (Mac mit Apple M3 Pro, 36 GB; 8 CPUs; Modell auf einer externen SSD über USB; 18.11.2026)
Kolibri-1, VM mit 18 GiB1,0–1,1 Wörter/sExperten-Cache 8,7 GB
Kolibri-1, VM mit 8 GiB0,4 Wörter/s
Erste Frage nach dem Start (56 Wörter), 18 GiB124 sCache nach dem Start leer
Warten auf die Platte je Wort0,83 von 0,86 snachgebildete Platte der VM ≈ 200 MB/s; Rechnen 25 ms
Prüfungen des KI-Dienstes (aicheck), 18 GiBalle bestanden
Engine als Werkzeug direkt auf dem Mac (Apple M3 Pro, 36 GB; SSD über USB, 10 Gb/s; Lesetiefe 4, LFU; 32 Wörter je Lauf; 18.11.2026)
Kolibri-1, Cache 2 GB1,37 Wörter/sExperte schon im Cache: 79 %
Kolibri-1, Cache 4 GB2,22 Wörter/s
Kolibri-1, Cache 8 GB3,59 Wörter/s
Kolibri-1, Cache 16 GB5,68 Wörter/sExperte schon im Cache: 97,8 %; drei deutsche Prüffragen richtig (Widerspruch, Brief zusammenfassen, Rechnen)
Kolibri-1, Cache 24 GB6,18 Wörter/s
Llama 4 Scout (65,4 GB, ein Experte 81 MB), Cache 16–24 GB0,3–0,7 Wörter/santwortet richtig

Alle Modelle 4-Bit (Q4_K_M). Ein Modell ohne Experten („dichtes“ Modell), das größer ist als der Speicher, läuft auch, liest aber für jedes Wort die ganze Datei. Eine geschätzte Zeit zeigt das System nicht; Settings › AI zeigt „runs slower: larger than the memory, read from the disk“, Ask im Titel „slower, from the disk“ und beim Antworten das echte Tempo. Quelle: Handbuch 3.166, docs/design/ki-ohne-grenzen.html.

15.4 Objekterkennung und Lernen

  • Camera ist das Auge: Nur Camera lädt ein Erkennungsmodell (eingebaut: unser eigenes softrobots-base mit 97 Dingen, NanoDet-Bauart, trainiert mit Fotos von Open Images, CC BY 2.0; eigene int8-Inferenz mit sdot, 3 Kerne): 44 ms je Bild in SOFTrobotsVM, mit der Mac-Kamera etwa 10 Erkennungen je Sekunde; bei ruhigem Bild entfallen 75 % der Läufe.
  • Ohne Kopie zu anderen Programmen: Die Ergebnisse stehen in einem Ring (camera.detections), den der Kernel anderen Programmen nur lesbar einblendet – Develop-Skripte, Server und Echtzeit-Programme lesen dieselben Seiten.
  • Modelle im Standardformat: Camera liest ein ONNX-Modell aus /models/detection direkt und rechnet es beim Laden in 8 Bit um. Modelle werden nicht signiert; kennt die Engine einen Baustein nicht, lehnt sie das Modell mit klarer Meldung ab.
  • Lernen: Das Lernfenster von Camera macht Fotos mit Rahmen; trainiert wird auf dem Mac (SOFTrobots Trainer, PyTorch auf der Mac-GPU), das Modell kommt als einfache ONNX-Datei zurück ins Gerät. Training im Gerät selbst gibt es nicht.

15.5 Was das Gerät verlässt

  • Der KI-Dienst ai und Ask haben kein Netzrecht (Manifest ohne network.outgoing): Fragen, Antworten, Bilder und gespeicherte Gespräche bleiben im Gerät.
  • Modelle kommen nur über das Systemprogramm modelget (Recht models.install: Netz hinaus und /models schreiben, sonst nichts), jede Datei mit SHA-256 gegen den Katalog geprüft.
  • Ausnahme, offen benannt: Develops Assistent (Explain, Ask Develop) fragt einen Dienst im Internet, über einen eigenen Helfer und nur mit einem gesetzten Schlüssel; die Vorschau hat keinen.