| Version | 0.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 |
| Stand | 14. November 2026 |
| Architektur | AArch64 (ARMv8-A und neuer), nur 64 Bit, UEFI + ACPI |
| Sprache | Embedded 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) |
| Zweck | Desktop-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. |
| Hersteller | SOFTrobots GbR · info@softrobots.de · www.softrobots.de |
docs/api/app-api-1.txt, libraries.txt; dazu 136 nur für Systemprogramme), gezählt 14.11.2026@Test) und Gerätetest-Ziele in tools/test-all.sh, gezählt 14.11.2026Wo 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
2Stand und Grenzen
-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), dazumake 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
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.
| Sprache | Zeilen | Anteil | Wo |
|---|---|---|---|
| Swift (Embedded Swift und Swift für den Mac) | 173 785 | 91,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 267 | 1,2 % | shapes/ 2 171 (23 Dateien) · Programmformen in apps/ 96 |
| Python (nur Werkzeuge) | 3 217 | 1,7 % | Modellkonverter, Training, Testdaten, Datenblatt; läuft nie im System |
| Shell (nur Werkzeuge) | 3 263 | 1,7 % | Testskripte, QEMU-Helfer, Vorschau-Paket, VM-Messung |
| Assembler (AArch64) | 3 204 | 1,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 374 | 0,7 % | boot/loader.c 573 · Käfig für JavaScript 801 (userland/jscage) |
| C-Header (eigene) | 935 | 0,5 % | BootInfo, EFI, arch.h, userland/include |
| JavaScript | 1 458 | 0,8 % | apps/web/prelude.js: Seitenabbild für Skripte im Käfig |
| Reflex (.reflex) | 756 | 0,4 % | Vorlagen, Anleitung und Programme für Develop |
| Summe eigener Code | 190 259 | 100 % | |
| 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. |
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)
| Abschnitt | Bytes | Größe | Inhalt |
|---|---|---|---|
| .text | 840 244 | 821 KiB | Maschinencode (R X, BTI-geschützt) |
| .rodata | 244 696 | 239 KiB | Konstanten, Schriftmasken der Start-Animation, eingebettete Daten (R) |
| .data | 184 161 | 180 KiB | vorbelegte Variablen (R W, nie X) |
| Geladenes Abbild (Datei-Anteil) | 1 269 101 | 1,21 MiB | was der Loader von der Platte liest |
| .bss | 31 745 584 | 30,27 MiB | feste 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 / .stack | 2 293 760 | 2,19 MiB | Seitentabellen-Vorrat 2 MiB, frühe Tabellen 64 KiB, Boot-Stack 128 KiB |
| Debug-Informationen (.debug_*) | 6 102 998 | 5,82 MiB | nur 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).
| Ordner | Zeilen | ≈ Code | Inhalt |
|---|---|---|---|
kernel/core | 15 517 | ≈ 319 KiB | Kernel-Logik: Scheduler, Speicher, Prozesse, Systemaufrufe, Formen, Kanäle, Datei-Dialog, Vorschau, Mikrofon, Ton, Not-Halt |
kernel/fs (SOFTrobotsFS + DB) | 6 997 | ≈ 144 KiB | Dateisystem, Datenbank, Joins, Serien, Snapshots, Versiegelung |
kernel/crypto | 5 106 | ≈ 105 KiB | SHA-2, HMAC/HKDF, AES-GCM, ChaCha20-Poly1305, X25519, Ed25519, ECDSA, RSA, X.509, TLS 1.3, DoH, NTS, Argon2id |
kernel/arch/aarch64 | 3 442 | ≈ 71 KiB | MMU, Exceptions, Interrupts, SMP, Timer; Swift 2 068 + Assembler 1 374 |
kernel/lib | 3 558 | ≈ 73 KiB | hardwareunabhängig, auf dem Mac getestet (Dateitypen, Manifest, Seitentabellen …) |
drivers/ | 2 700 | ≈ 56 KiB | NVMe, virtio (gpu, console, net, fs, sound, rng …), GICv3, PCIe, PL011, Framebuffer |
kernel/net | 2 567 | ≈ 53 KiB | IPv6/IPv4, TCP (mit 4 großen Empfangsringen), UDP, DHCP mit Erneuerung, DNS, mDNS |
| Summe Kernel + Treiber | 39 887 | 821 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.
| Programm | Art | Code | Daten | BSS (RAM) | ELF-Datei |
|---|---|---|---|---|---|
| web | System | 1 225 KiB | 4 283 KiB | 2 036 KiB | 6 150 KiB |
| files | System | 834 KiB | 3 668 KiB | 1 575 KiB | 4 974 KiB |
| develop | System | 1 525 KiB | 1 966 KiB | 1 554 KiB | 4 314 KiB |
| image | System | 579 KiB | 3 036 KiB | 1 524 KiB | 4 005 KiB |
| reflexrun | System | 416 KiB | 920 KiB | 1 548 KiB | 3 817 KiB |
| benchmark | System | 1 170 KiB | 1 895 KiB | 2 668 KiB | 3 746 KiB |
| reader | System | 398 KiB | 2 970 KiB | 1 523 KiB | 3 691 KiB |
| display | Dienst | 655 KiB | 1 732 KiB | 1 634 KiB | 2 829 KiB |
| camera | System | 508 KiB | 1 545 KiB | 1 527 KiB | 2 324 KiB |
| reflexrt | System | 8 KiB | 1 KiB | 0 KiB | 2 117 KiB |
| about | System | 114 KiB | 1 598 KiB | 1 524 KiB | 1 906 KiB |
| server | System | 363 KiB | 1 101 KiB | 3 991 KiB | 1 753 KiB |
| video | System | 533 KiB | 900 KiB | 1 527 KiB | 1 720 KiB |
| ask | System | 328 KiB | 911 KiB | 1 525 KiB | 1 541 KiB |
| settings | System | 213 KiB | 902 KiB | 1 524 KiB | 1 343 KiB |
| ai | System | 367 KiB | 696 KiB | 1 256 KiB | 1 270 KiB |
| sound | System | 190 KiB | 850 KiB | 1 525 KiB | 1 237 KiB |
| database | System | 175 KiB | 855 KiB | 2 552 KiB | 1 209 KiB |
| devclaude | System | 152 KiB | 842 KiB | 1 765 KiB | 1 204 KiB |
| activity | System | 151 KiB | 856 KiB | 1 524 KiB | 1 203 KiB |
| console | System | 128 KiB | 849 KiB | 1 702 KiB | 1 132 KiB |
| chooser | System | 93 KiB | 845 KiB | 1 521 KiB | 1 104 KiB |
| webjs | System | 771 KiB | 109 KiB | 1 255 KiB | 1 097 KiB |
| monitor | System | 79 KiB | 838 KiB | 1 565 KiB | 1 058 KiB |
| text | System | 57 KiB | 845 KiB | 1 522 KiB | 1 056 KiB |
| modelget | System | 139 KiB | 182 KiB | 1 765 KiB | 522 KiB |
| timesync | Dienst | 102 KiB | 146 KiB | 1 769 KiB | 394 KiB |
| watchdog | System | 56 KiB | 64 KiB | 1 257 KiB | 266 KiB |
| usbinput | Dienst | 26 KiB | 30 KiB | 0 KiB | 159 KiB |
| actuators | Dienst | 24 KiB | 3 KiB | 1 255 KiB | 77 KiB |
| canbus | Dienst | 9 KiB | 0 KiB | 0 KiB | 54 KiB |
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-vmscheitert, 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 previewbaut das Produktabbild ohne Testprogramme, ohne Entwicklungsschlüssel und ohne API-Schlüssel, mitmkimage --expires(Vorgabe 25.02.2027, Datei/expiresauf 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-previewprü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-numberzä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:
| Klasse | Verfahren | Eigenschaften |
|---|---|---|
| Realtime | EDF mit Budget je Periode und Zulassungsprüfung | Periode 100 µs … 1 s; Auslastung je Kern höchstens 900 ‰; passt ein Vertrag nicht, startet das Programm gar nicht |
| Interactive | feste Prioritäten | Desktop, Dienste, normale Programme; Prioritätsvererbung in Volume-Sperre und IPC |
| Background | Fair Share nach Gewichten | Gewichte 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,restartoderstop-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
| Schutz | Umsetzung |
|---|---|
| Nur signierte Programme | Jedes 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. |
| Capabilities | 32 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 Ordner | Mit 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ät | Jedes 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äteschutz | Argon2id (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-Schutz | W^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 Treiber | USB 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>.localim 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.infomeldetfeatures.aes, in der App-APISystemStatus.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) | Gemessen | Bemerkung |
|---|---|---|
| Eigener Weg: HTTP vom Mac, ohne Internet und TLS | 110–218 MB/s | um 190–200 MB/s bei ruhigem Mac; der Bereich folgt der Last des Mac |
| HTTPS von OVH | 35–59 MB/s | fast ohne Paketverlust; die nächste Grenze ist noch nicht bekannt |
| HTTPS von Hetzner | 9–58 MB/s | schwankt von Lauf zu Lauf – offen, wird untersucht |
| curl auf dem Mac, dieselben Server (Vergleich) | 80–96 MB/s | zeigt, 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)
| Verfahren | Gemessen | zum Vergleich: dieselbe Rechnung in Swift |
|---|---|---|
| ChaCha20 (NEON) | 1657–1735 MB/s | 373–376 MB/s |
| ChaCha20-Poly1305 (versiegeln) | 703–719 MB/s | 287 MB/s |
| AES-256-GCM (AES/PMULL) | 4594–4896 MB/s | 46–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
srcsetdie Version für den Bildschirm (Dichte- oder Breitenangaben) und vergrößert bei Bedarf bilinear. Boxen mitoverflow: autooderscrollbehalten die Höhe ihres Inhalts, weil Web in einer Box nicht scrollt;overflow: hiddenschneidet 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.playbekommt 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 mszä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 Bild | SOFTrobotsVM | Mac (Host-Test) |
|---|---|---|
| dekodieren, 1 Thread | 10,5 ms | 6,9 ms |
| dekodieren, 3 Threads | 8,9 ms | 3,3 ms |
| YUV → RGB umrechnen (SIMD) | 1,4 ms | 1,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.
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
| Messung | Wert | Wo / wie gemessen |
|---|---|---|
| NVMe: ein 16-KiB-Befehl lesen / schreiben | 38,6 µs / 80,3 µs | Kernel beim Start, Benchmark 14.11.2026 (Median aus 4 Läufen) |
| NVMe sequentiell (256 KiB, 16 Befehle gleichzeitig) lesen / schreiben | 1500 MB/s / 554 MB/s | Kernel beim Start; die VM-Platte ist eine Datei auf dem Mac |
| Commit einer neuen Datei | 3,3 ms | Boot-Log 08.11.; fast ganz der Flush der VM-Platte |
| Commit von 280 neuen Dateien in einem Zug | 4,2 ms | 13 Knoten gemeinsam an die NVMe, ohne Umkopieren („0 bounced since the boot“), Boot-Log 08.11. |
| DATA einbinden (versiegelt, über die Freiplatz-Karte) | 11 ms | nur Superblöcke und Kartenblöcke gelesen (Hb. 3.58, 01.11.2026) |
| Prüfung aller Knoten nach „Hello“ (403 Blöcke) | 7,1 ms | 0 Schäden, 0 fehlende Kartenbits (Hb. 3.58); läuft im Diagnose-Thread, bremst den Boot nicht |
| Knoten-Cache beim Start: Treffer / Lesezugriffe | 1087 / 12 · 289 / 1 | Systemvolume · DATA, Boot-Log 08.11. |
| Programm: 4-MiB-Datei schreiben / lesen | 126 MB/s / 99 MB/s | Benchmark, über die Systemaufrufe (16 KiB je Aufruf) |
| Kleine Datei anlegen und löschen | 8,0 ms | Benchmark |
| Ordnereintrag auflisten | 374 µs | Benchmark |
| Plattenverschlüsselung AES-256-GCM versiegeln / öffnen | 4257 MB/s / 3995 MB/s | Kernel beim Start, bitgleich zur Software-Referenz, Manipulation erkannt |
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).
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 gewartet | 20,8 ms |
| 1000 Zeilen „soon“ (dauerhaft binnen 10 ms) | 9,8 ms |
| Eine Zeile nach Id | 37,6 µs |
| Bereich über einen Index (100 Zeilen) | 4,0 ms |
| Top 100 von 1000 ohne Index sortiert | 20,4 ms |
| Zählen in Gruppen (1000 Zeilen) | 2,6 ms |
| SQL-Anweisung übersetzen | 0,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
| Grenze | Wert | Grenze | Wert |
|---|---|---|---|
| Datensatz (alle Felder) | ≤ 4096 Bytes – große Daten als Datei (8.5) | Tabellen / Felder | 64 je Datenbank / 64 je Tabelle |
| Schlüssel | 1–255 Bytes | Schreibpaket (Transaktion) | ≤ 4 MiB, vorher vollständig geprüft |
| Baumtiefe | 8 Ebenen – bei 100-Byte-Zeilen weit über 10 Milliarden Zeilen | Zeilen je Abfrage-Aufruf | 256 (Ausgabe ≤ 256 KiB), weiter per Cursor |
| Sortieren ohne Index | Top-N ≤ 1000 | Gruppen | 256, Gruppenwert ≤ 32 Bytes |
| Offene Datenbanken | 4 je Programm, 32 im System | Serien-Datensatz | 8–1024 Bytes, Ring 1–600 s, ≤ 32 MiB |
8.4 Warum die Datenbank schnell ist – und um wie viel
| Grund | Was es bewirkt | Vorteil |
|---|---|---|
| Eine Schicht statt zwei | Kein 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 Transaktion | Das 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 Daten | Filter, 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 alles | Der 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 Messwerte | Ein 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-Write | Ein 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.
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 == .fileundisBelow(…, fileFieldRoot); den Ordner setztDatabaseAccess.swiftbeim Ö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-Felds | Stand | Wo / Bemerkung |
|---|---|---|
Feldtyp file im Kernel: 8-Byte-Objektkennung, Prüfung „existiert, ist Datei, im Ordner des Programms“ | gebaut | Stufe 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 Datei | gebaut | Schema.swift; Snapshots enthalten jede Datenbank (Hb. 3.59) |
Formsprache data.shape (Programme beschreiben ihre Tabellen seit 05.11.2026 als gespeicherte Formen) | noch nicht | docs/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 öffnen | geplant | Konzept 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 Console | geplant | Konzept 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).
.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 | Lesen | Schreiben | Varianten: unterstützt und nicht | Grenzen und Tempo |
|---|---|---|---|---|
| Bilder | ||||
| PNG Image, Files, Web, SVG | ja | ja | 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 | ja | ja | 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 | ja | ja | 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 | ja | ja | 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, PSD | nein | nein | 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/EPS | nein | nein | Nicht unterstützt: kein Dokumenttyp im Kernel. Quelle: kernel/lib/FileTypes.swift | |
| Video | ||||
| Matroska (.mkv) Video, Files | ja | ja | 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 | ja | nein | 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 | ja | ja | 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, AVI | nein | nein | 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 | ja | ja | 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 | ja | ja | 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 | ja | ja | 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, ALAC | nein | nein | 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 | ja | ja | 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 | ja | ja | 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, Zstandard | nein | nein | 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 | ja | ja | 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 | ja | ja | 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 | ja | ja | 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 | ja | ja | 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 | ja | ja | 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 | ja | ja | 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 | ja | ja | 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 | ja | ja | 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 | ja | ja | 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 | ja | Mac | 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,duration2,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
| Schicht fertig | Sekunden nach dem Einschalten |
|---|---|
| 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 (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) | Gemessen | Ziel | Urteil |
|---|---|---|---|
| IRQ-Latenz (Deadline → Handler), Mittel | 42,0 ns | < 10 µs | erfüllt |
| IRQ-Latenz, schlechteste | 666 ns | < 10 µs | erfüllt |
| Kontextwechsel | 0,3 µs | < 2 µs | erfüllt |
| Nachricht hin und zurück (IPC) | 1,2–1,7 µs | < 1 µs | nicht erfüllt: 1,2–1,7 µs auf verschiedenen Kernen, 6–8 µs auf demselben (F184) |
| Echtzeit-Aufwachen 1 ms, Mittel | 0,5 µs | < 20 µs | erfüllt |
| Echtzeit-Aufwachen 1 ms, schlechteste | 7,6 µs | < 20 µs | erfüllt (die drei Läufe: 7,6 / 3,0 / 3,0 µs) |
| Echtzeit-Programm 1 kHz: Startverzögerung Mittel / schlechteste | 0,13 µs / 0,5–16 µs (im Boot 26–77 µs) | < 20 µs | erfüllt nach dem Start |
| Verpasste Perioden in 10 s | 0 | 0 | erfüllt |
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.
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).
| Messung | M3 Pro | M4 | M4 gegenüber M3 Pro |
|---|---|---|---|
| Einschalten bis „Hello from the kernel.“ | 618 ms | 566 ms | 8 % kürzer |
| Interrupt-Latenz, Mittel | 42,0 ns | 28,0 ns | 33 % kürzer |
| Kontextwechsel | 290 ns | 252 ns | 13 % kürzer |
| An den Scheduler abgeben | 986 ns | 537 ns | 46 % kürzer |
| Nachrichten durch einen Kanal | 2,55 Mio./s | 3,58 Mio./s | 40 % mehr |
| Systemaufruf (Zeit) | 526 ns | 427 ns | 19 % kürzer |
| CRC-32 über 16 MiB | 493 MB/s | 614 MB/s | 25 % mehr |
| Speicher kopieren (32 MiB) | 49,3 GB/s | 43,0 GB/s | 13 % weniger |
| NVMe: 16 KiB lesen, ein Befehl | 38,6 µs | 9,27 µs | 76 % kürzer |
| NVMe: sequentiell lesen | 1,50 GB/s | 3,78 GB/s | 152 % mehr |
| NVMe: 16 KiB schreiben, ein Befehl | 80,3 µs | 82,0 µs | 2 % länger |
| NVMe: sequentiell schreiben | 554 MB/s | 575 MB/s | 4 % mehr |
| Programm: 4-MiB-Datei lesen | 99,0 MB/s | 344 MB/s | 247 % mehr |
| Programm: 4-MiB-Datei schreiben | 126 MB/s | 185 MB/s | 47 % mehr |
| Datenbank: 1000 Zeilen einfügen (auf der Platte) | 20,8 ms | 20,8 ms | gleich* |
| Messwerte in den Aufnahme-Ring | 2,36 Mio./s | 2,72 Mio./s | 15 % mehr |
| JPEG 1024 × 1024 öffnen | 9,45 ms | 8,55 ms | 10 % kürzer |
| Plattenverschlüsselung AES-256-GCM versiegeln | 4,26 GB/s | 5,08 GB/s | 19 % mehr |
| SHA-256 | 193 MB/s | 281 MB/s | 46 % mehr |
| TLS-1.3-Handshake im Speicher (eigener Server und Client) | 2,43 ms | 2,23 ms | 8 % kürzer |
| Reflex: Beispielprogramm übersetzen | 30,3 µs | 25,2 µs | 17 % 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. | Messung | Wert | Bemerkung |
|---|---|---|---|
| 40 | CRC-32 over 16 MiB | 493 MB/s | Benchmark-Lauf |
| 41 | Floating point (matrix 128 x 128) | 3709 Mio./s | Benchmark-Lauf |
| 42 | Memory copy (32 MiB) | 49253 MB/s | Benchmark-Lauf |
| 43 | Memory fill (32 MiB) | 32255 MB/s | Benchmark-Lauf |
| 44 | Heap: allocate and free an object | 67 ns | Benchmark-Lauf |
Alle Messungen
| Nr. | Messung | Wert | Bemerkung |
|---|---|---|---|
| Start · Start | |||
| 1 | Power on to "Hello from the kernel." | 0,62 s | Firmware + Loader + Kernel bis „Hello“ |
| Scheduler, Echtzeit · Scheduler, realtime | |||
| 10 | Interrupt latency, average | 42,0 ns | Kernel-Messung beim Start |
| 11 | Interrupt latency, worst | 666 ns | Kernel-Messung beim Start |
| 12 | Context switch | 0,3 µs | Benchmark-Lauf |
| 13 | Scheduling decision | 0,2 µs | Kernel-Messung beim Start |
| 14 | Realtime wake-up (1 ms), average | 0,5 µs | beim Start auf dem Echtzeit-Kern (ab Build 236; davor auf einem Programm-Kern, F185) |
| 15 | Realtime wake-up (1 ms), worst | 7,6 µs | die 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 |
| 16 | Realtime periods missed at boot | 0 | Kernel-Messung beim Start |
| 17 | Sleep 1 ms: late by, average | 260 µs | Zeitgeber-Auflösung für Programme |
| 18 | Yield to the scheduler | 1,0 µs | Benchmark-Lauf |
| Nachrichten (IPC) · Messages (IPC) | |||
| 20 | Message sent and received | 1,2–1,7 µs | Programme auf verschiedenen Kernen (6 Läufe am 15.11.2026); auf demselben Kern 6–8 µs (F184) |
| 21 | Wake the other end (notify) | 6,7 ns | nur noch, wenn die Gegenseite schläft (F143) |
| 22 | Messages through a channel | 2,5 Mio./s | Benchmark-Lauf |
| Programme · Programs | |||
| 30 | Start and end a program | 1,3 ms | nur im Testabbild: Läufe vom 15.11.2026 (Build 233, 4 CPUs, 8 GB) |
| 31 | Start from the app cache | 81 µs | nur im Testabbild: Läufe vom 15.11.2026 (Build 233, 4 CPUs, 8 GB) |
| 32 | System call (time) | 526 ns | Benchmark-Lauf |
| 33 | System information read (system.info) | 3,1 µs | Benchmark-Lauf |
| 34 | Installed programs listed (all, with id and version) | 660 µs | Benchmark-Lauf |
| Prozessor, Speicher · Processor, memory | |||
| 40 | CRC-32 over 16 MiB | 493 MB/s | Benchmark-Lauf |
| 41 | Floating point (matrix 128 x 128) | 3709 Mio./s | Benchmark-Lauf |
| 42 | Memory copy (32 MiB) | 49253 MB/s | Benchmark-Lauf |
| 43 | Memory fill (32 MiB) | 32255 MB/s | Benchmark-Lauf |
| 44 | Heap: allocate and free an object | 67 ns | Benchmark-Lauf |
| Platte (NVMe) · Disk (NVMe) | |||
| 50 | Read 16 KiB, one command | 38,6 µs | Kernel-Messung beim Start |
| 51 | Write 16 KiB, one command | 80,3 µs | Kernel-Messung beim Start |
| 52 | Sequential read (16 commands at once) | 1500 MB/s | Kernel-Messung beim Start |
| 53 | Sequential write (16 commands at once) | 554 MB/s | Kernel-Messung beim Start |
| Dateisystem · File system | |||
| 60 | Kernel: 4 MiB written and committed | 255 MB/s | Kernel-Messung beim Start |
| 61 | Kernel: 4 MiB read and checked | 779 MB/s | Kernel-Messung beim Start |
| 62 | App: 4 MiB file written | 126 MB/s | Benchmark-Lauf |
| 63 | App: 4 MiB file read | 99 MB/s | Benchmark-Lauf |
| 64 | Small file created and removed | 8,0 ms | Benchmark-Lauf |
| 65 | Folder entry listed | 374 µs | Benchmark-Lauf |
| Datenbank · Database | |||
| 70 | 1000 rows inserted (on disk) | 20,8 ms | Benchmark-Lauf |
| 71 | 1000 rows inserted (soon) | 9,8 ms | Benchmark-Lauf |
| 72 | Row by id | 37,6 µs | Benchmark-Lauf |
| 73 | Range through an index (100 rows) | 4,0 ms | Benchmark-Lauf |
| 74 | Sorted without an index (top 100 of 1000) | 20,4 ms | Benchmark-Lauf |
| 75 | Count in groups (1000 rows) | 2,6 ms | Benchmark-Lauf |
| 76 | SQL statement translated | 0,8 µs | Benchmark-Lauf |
| Serien, Aufzeichnung · Series, recording | |||
| 80 | Records pushed into the ring | 2,4 Mio./s | Benchmark-Lauf |
| 81 | Records dropped (10 000 pushed) | 0 | Benchmark-Lauf |
| 82 | Time range read back (1000 records) | 15,4 ms | Benchmark-Lauf |
| Bilder, ZIP · Pictures, ZIP | |||
| 90 | PNG 1024 x 1024 saved | 67,7 ms | Benchmark-Lauf |
| 91 | PNG 1024 x 1024 opened | 17,9 ms | Benchmark-Lauf |
| 92 | JPEG 1024 x 1024 saved | 12,7 ms | Benchmark-Lauf |
| 93 | JPEG 1024 x 1024 opened | 9,4 ms | Benchmark-Lauf |
| 94 | Deflate (ZIP) 4 MiB | 240 MB/s | Benchmark-Lauf |
| 95 | GIF 512 x 512 opened | 2,2 ms | Benchmark-Lauf |
| 96 | TIFF 1024 x 1024 saved | 79 ms | Benchmark-Lauf |
| 97 | TIFF 1024 x 1024 opened | 28,9 ms | Benchmark-Lauf |
| 98 | SVG drawing read and drawn (512 x 512) | 7,0 ms | Benchmark-Lauf |
| Anzeige · Display | |||
| 100 | Whole picture 1280 x 800 filled | 3858/s | Benchmark-Lauf |
| 101 | Characters drawn | 6,3 Mio./s | Benchmark-Lauf |
| 102 | Window drawn and shown | braucht Fenster | braucht ein offenes Fenster; der Lauf ohne Fenster lässt sie aus |
| 103 | Key mapped (German layout, umlauts) | 4,3 ns | Benchmark-Lauf |
| 104 | Key typed into a text field | 10,1 ns | Benchmark-Lauf |
| 105 | Text field drawn | 17,2 µs | Benchmark-Lauf |
| Verschlüsselung · Encryption | |||
| 110 | Disk: AES-256-GCM seal (hardware) | 4257 MB/s | Kernel-Messung beim Start |
| 111 | Disk: AES-256-GCM open (hardware) | 3995 MB/s | Kernel-Messung beim Start |
| 112 | SHA-256 | 193 MB/s | Benchmark-Lauf |
| 113 | AES-256-GCM in an app | 57,5 MB/s | Benchmark-Lauf, Software-Fassung; TLS in Programmen seit 11.11. mit AES/PMULL (Abschnitt 6.6) |
| 114 | ChaCha20-Poly1305 in an app | 304,6 MB/s | Benchmark-Lauf, Software-Fassung; TLS in Programmen seit 11.11. mit NEON (Abschnitt 6.6) |
| 115 | Ed25519 signature checked | 195 µs | Benchmark-Lauf |
| 116 | Password check (Argon2id, 64 MiB) | 182 ms | Kernel-Messung beim Start |
| 117 | ECDSA P-256 signature made | 1,0 ms | Benchmark-Lauf |
| 118 | ECDSA P-256 signature checked | 0,7 ms | Benchmark-Lauf |
| Netzwerk · Network | |||
| 120 | Name resolved (DNS over HTTPS) | 70 ms | Benchmark-Lauf |
| 121 | TLS 1.3 handshake | 66,4 ms | Benchmark-Lauf |
| 122 | HTTPS page fetched (example.com) | 113 ms | Benchmark-Lauf |
| Server, Zertifikate · Server, certificates | |||
| 130 | Robot's root certificate made | 4,0 ms | Benchmark-Lauf |
| 131 | Server certificate issued by the root | 3,0 ms | Benchmark-Lauf |
| 132 | TLS 1.3 handshake, own server and client in memory | 2,4 ms | Benchmark-Lauf |
| 133 | TLS 1.3 data, server to client in memory | 56,1 MB/s | Benchmark-Lauf |
| 134 | HTTP request head read (browser request) | 3,4 µs | Benchmark-Lauf |
| 135 | QR code made (version 4) | 100 µs | Benchmark-Lauf |
| 136 | QR code made (version 10) | 0,4 ms | Benchmark-Lauf |
| Develop (Reflex) · Develop (Reflex) | |||
| 140 | Reflex: system shapes read (catalog) | 1,6 ms | Benchmark-Lauf |
| 141 | Reflex: example program compiled | 30,3 µs | Benchmark-Lauf |
| 142 | Reflex: periodic handler run (interpreter) | 0,3 µs | Benchmark-Lauf |
Weitere Messwerte aus Boot-Log und Handbuch
| Messung | Wert | Wo / wie gemessen |
|---|---|---|
| System und Programme | ||
| Programm aus dem App-Cache starten | 53–56 µs | SOFTrobotsVM, Phase 14 (erster Start ca. 2 ms); Code und Konstanten geteilt |
| Programm starten und beenden (Lebenszyklus) | 0,77–0,80 ms | SOFTrobotsVM, Handbuch Kapitel 6 |
| Signaturprüfung je Programm beim Start / Hashen aller Programme | 430 µs / 3,3 ms | Boot-Log 08.11.2026: 6 MiB, SHA-256 mit Prozessorbefehlen |
| Fair Share mit Gewichten 2 : 1 | 2,0 | Boot-Log 08.11.: 66 ms : 33 ms |
| Krypto im Kernel (Boot-Log 08.11.2026) | ||
| SHA-256 mit Prozessorbefehlen | 2149 MB/s | in einem Programm ohne diese Befehle: 193 MB/s (Benchmark) |
| X25519-Schlüsseltausch | 10 322 /s | Handbuch Kapitel 6 |
| ChaCha20-Poly1305 | 76 MB/s | Software, 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 NEON | 1657–1735 MB/s | SOFTrobotsVM, make vm-net-bench, zwei Läufe |
| ChaCha20-Poly1305 versiegeln | 703–719 MB/s | dasselbe |
| AES-256-GCM mit AES/PMULL | 4594–4896 MB/s | dasselbe; beim ersten Verbinden gegen die Swift-Fassung geprüft |
| Argon2id je Passwortprüfung (64 MiB, 3 Durchläufe) | 182 ms | absichtlich teuer: bremst Raten |
| Netz und Caches (Hb. 3.93, je drei Läufe in SOFTrobotsVM) | ||
| 8 neue Namen über DNS über HTTPS | 455 ms | die Verbindung bleibt offen, 64 Namen im Cache |
| 8 Abrufe vom selben Webserver | 448 ms | Keep-Alive |
| Hashen aller Programme beim Start (SHA-256 in Hardware) | 3,4 ms | Hb. 3.93 |
| Medien | ||
| Objekterkennung je Kamerabild (int8, 3 Kerne) | 44 ms | SOFTrobotsVM; bei ruhigem Bild entfallen 75 % der Läufe (Hb. 3.93) |
| JPEG 640 × 480 dekodieren (Kamerabild) | 4 ms | SOFTrobotsVM, Camera |
| ZIP mit Passwort entpacken / 6 Dateien (10,3 MiB) packen | 61 / 655 ms | SOFTrobotsVM, AES in Software |
| PDF-Seite zeichnen (eine Seite des Datenblatts) | ≈ 0,06 s | Mac, 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 Thread | 8,9 / 10,5 ms | SOFTrobotsVM, make vm-vp9-bench, 600 Bilder (Abschnitt 6.12) |
| YUV → RGB umrechnen, 1080p je Bild | 1,4 ms | SOFTrobotsVM; in einen gehaltenen Puffer 1,1 ms |
| 360p-Video mit 60 Bildern/s: gezeigt je Sekunde | 60 von 60 | SOFTrobotsVM, 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 TLS | 110–218 MB/s | SOFTrobotsVM auf dem M3 Pro; um 190–200 MB/s bei ruhigem Mac (Abschnitt 6.6) |
| HTTPS von OVH | 35–59 MB/s | Mac per Kabel am Netz, Leitung 934 Mbit/s (≈ 117 MB/s) |
| HTTPS von Hetzner | 9–58 MB/s | schwankt 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.
| Baustein | Was wir anders machen | Beleg (gemessen) | Einordnung |
|---|---|---|---|
| Start | Kleiner 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 gemessen | Der größte Teil der Zeit liegt in Firmware und Loader, nicht im Kernel. |
| Interrupts und Echtzeit | Reservierter 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 verpasst | Ziele < 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. |
| Kontextwechsel | Heiße Scheduler-Methoden ohne Struct-Kopien, Per-CPU-Zustand nie in Optional; Lazy FP/SIMD. | 0,3 µs; Entscheidung allein 0,2 µs | Ziel < 2 µs erfüllt. |
| Kommunikation zwischen Programmen | Kanä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 ns | Bauart 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üsselung | AES-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/s | Die 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 Signaturen | CRC-32C und SHA-256 mit Prozessorbefehlen; geprüfte Programme merkt sich der App-Cache. | SHA-256 2149 MB/s; Signatur je Programm 430 µs | Ein geprüftes Programm wird nicht erneut gehasht (App-Cache). |
| Dateisystem | Kein 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 ms | Bauart jede Änderung wird einmal geschrieben, nicht zweimal; ein Flush + FUA je Commit. Mit anderen Dateisystemen verglichen ist das nicht gemessen. |
| Datenbank | Commit 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./s | Bauart 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. |
| Speicher | 16-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 ns | Bauart 16 KiB statt 4 KiB: ein TLB-Eintrag deckt die vierfache Fläche ab. Die Wirkung allein ist nicht gemessen. |
| Netz | Eigener 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 Programmen | AES-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). |
| Video | Vordekodieren 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 Bildern | Zusammen ≈ 10 ms von 16,7 ms je Bild bei 60 Bildern/s (VM, 10.11.). |
| Erkennung im Gerät | Eigene 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 gespart | Mit der Mac-Kamera etwa 10 Erkennungen je Sekunde, bit-genau zur Referenz (Hb. 3.93). |
| Was wir weggelassen haben | Keine 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.
| Grenze | Wert |
|---|---|
| Prozessor | |
| Architektur | AArch64, 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 Block | 16 KiB / 32 MiB |
| Heap je Programm | Vorgabe 256 MiB, memory = 16 … 2048 MiB; Heap aus höchstens 512 Stücken zu ≤ 32 MiB (≤ 16 GiB) |
| Systemreserve / Spitzen-Polster | 256 MiB / ≈ 3 % des RAM (64 MiB … 1 GiB) |
| Eigener Auslagerungsbereich | 2 × Zusage, höchstens 4 GiB |
| App-Stack | 64 KiB Vorgabe, stack = 64 … 8192 KiB |
| Platte | |
| Partitionen | EFI 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 / Pfad | 80 Bytes UTF-8 / 255 Bytes, 32 Teile |
| Offene Dateien | 64 im System, 16 je Programm; 16 KiB je Lese-/Schreibaufruf |
| Block-Cache | DATA 32 MiB, Systemvolume 512 KiB |
| Snapshots | alle 15 min, 24 h / 7 d / 30 d, höchstens 400 |
| Programme | |
| Gleichzeitig laufend | 127 (128 Prozessplätze, Platz 0 = Kernel) |
| Programmdatei | ≤ 32 MiB ELF, ≤ 8 Segmente; Programm-Cache 32 Einträge |
| Worker-Threads | 7 je Programm (+ Hauptthread) |
| Fenster (Zeichenflächen) | 3 je Programm, 16 im System |
| Menüs | 6 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-Vertrag | Periode 100 µs … 1 s, Auslastung ≤ 900 ‰ je Kern |
| Capabilities | 35 von 64 Bits belegt |
| Datei-Dialog | ≤ 16 Freigaben je Programm (solange es läuft), ≤ 3 Dialoge gleichzeitig, eine offene Frage je Programm |
| IPC | |
| Kanäle | 64 im System |
| Systemaufrufe | 14 Nummern (0–13), Obergrenze 100 |
| Veröffentlichungen | 16 im System, 1 je Programm, ≤ 2 Abos |
| Netzwerk | |
| TCP-Verbindungen | 64 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 |
| Lauscher | 8; Warteschlange 16, 16 halb offene je Lauscher |
| UDP-Sockets | 4 im System, 1472 Bytes je Datagramm |
| TLS-Verbindungen | 4 je Programm (+ 1 für DNS über HTTPS) |
| DNS-Cache | 64 Namen je Programm |
| Datenbank | |
| Tabellen / Felder | 64 je Datenbank / 64 je Tabelle |
| Datensatz | ≤ 4096 Bytes (alle Felder); große Daten als Datei |
| Transaktion | ≤ 4 MiB |
| Zeilen je Abfrage-Aufruf | 256 (Ausgabe ≤ 256 KiB, danach Cursor) |
| Sortieren ohne Index | Top-N ≤ 1000 |
| Offene Datenbanken | 4 je Programm, 32 im System |
| Joins | 2 für WHERE/ORDER BY, 4 zum Anzeigen; Sortieren nach verknüpftem Feld mit LIMIT ≤ 1000 |
| Aufnahme-Ringe | 16 im System, 1 … 600 s, ≤ 32 MiB |
| Geräte | |
| USB-Klassen | Erlaubnisliste HID, CDC-ACM, UVC, signierte Herstellertreiber; gebaut: HID |
| Kameras | 4 gleichzeitig |
| Grafik | |
| Bildschirm | ≤ 8192 × 8192 (virtio-gpu); VM 1280 × 800 |
| Bilder | ≤ 2048 × 2048 Pixel, ≤ 16 MiB je Datei |
| Datei ≤ 256 MiB, Strom ≤ 64 MiB entpackt, Verschachtelung ≤ 32; Vorschau in Files bis 32 MiB | |
| Camera / Video | Aufnahme (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ächtnis | bis 32 768 Positionen (höchstens die Grenze des Modells), 16 Bit; über 4096 nur, solange ein Viertel dieses Platzes frei bleibt |
| Sprachmodell: Größe | Ganz 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 |
| Ask | Frage ≤ 512 Zeichen; die letzten 30 Gespräche werden aufbewahrt, einzeln löschbar |
| Mikrofon | Ring ≈ 1,4 s je Mikrofon, 48 kHz, 16 Bit; Pegel alle 10 ms |
| Sicherheit | |
| Passwort | 8 … 64 Zeichen; Argon2id 64 MiB, 3 Durchläufe |
| Bildschirmsperre | 1 … 1440 min oder aus (Vorgabe 5) |
| System | |
| Boot bis „Hello“ | ≤ 1,0 s in SOFTrobotsVM (Testpflicht); QEMU ≤ 10 s |
| Absturzberichte / Logs | 20 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:
ailädt das Modell einmal; Programme mit dem Rechtai.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-Befehlensdotundsmmla(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-checkvergleichen 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:
qwen3VLAnswerMatchesLlamaCppvergleicht mitllama-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.
| Modell | Datei | 4 GiB | 8 GiB | 16 GiB | erstes Wort |
|---|---|---|---|---|---|
| Qwen3-1.7B Q8_0 | 1749 MiB | 56,5 / 57,1 / 70,0 | gleich | – | 0,17 s |
| Qwen3-4B-Instruct-2507 Q4_K_M | 2381 MiB | 42,3 / 40,1 / 79,8 | 42,3 / 39,4 / 79,3 | 42,0 / 40,1 / 79,6 | 0,33 s |
| Qwen2.5-Coder-7B-Instruct Q4_K_M (14.11.) | 4466 MiB | passt nicht | 24,8 / 24,7 / 48,9 | 23,3 / 23,1 / 47,0 | 0,57 s |
| Qwen3-8B Q4_K_M | 4794 MiB | passt nicht | 23,8 / 22,5 / 26,3 | 23,7 / 22,5 / 26,3 | 0,74 s |
| Qwen3-14B Q4_K_M | 8584 MiB | passt nicht | passt nicht | 12,3 / 12,1 / 12,0 | 1,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)
| Modell | llama.cpp Antwort | SOFTrobots Antwort | llama.cpp Prompt | SOFTrobots Prompt |
|---|---|---|---|---|
| Qwen2.5-0.5B Q8_0 | 164 | 163–173 | 1046 Tokens/s | ≈ 410 Tokens/s |
| Qwen2.5-1.5B Q4_K_M | 62 | 93–105 (5 Kerne) | 117 Tokens/s | ≈ 210 Tokens/s |
| Qwen3-8B Q4_K_M | 14,3 | 22–25 | 24 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.
| Messung | Wert | Einstellung |
|---|---|---|
| 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 GiB | 1,0–1,1 Wörter/s | Experten-Cache 8,7 GB |
| Kolibri-1, VM mit 8 GiB | 0,4 Wörter/s | |
| Erste Frage nach dem Start (56 Wörter), 18 GiB | 124 s | Cache nach dem Start leer |
| Warten auf die Platte je Wort | 0,83 von 0,86 s | nachgebildete Platte der VM ≈ 200 MB/s; Rechnen 25 ms |
Prüfungen des KI-Dienstes (aicheck), 18 GiB | alle 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 GB | 1,37 Wörter/s | Experte schon im Cache: 79 % |
| Kolibri-1, Cache 4 GB | 2,22 Wörter/s | |
| Kolibri-1, Cache 8 GB | 3,59 Wörter/s | |
| Kolibri-1, Cache 16 GB | 5,68 Wörter/s | Experte schon im Cache: 97,8 %; drei deutsche Prüffragen richtig (Widerspruch, Brief zusammenfassen, Rechnen) |
| Kolibri-1, Cache 24 GB | 6,18 Wörter/s | |
| Llama 4 Scout (65,4 GB, ein Experte 81 MB), Cache 16–24 GB | 0,3–0,7 Wörter/s | antwortet 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/detectiondirekt 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
aiund Ask haben kein Netzrecht (Manifest ohnenetwork.outgoing): Fragen, Antworten, Bilder und gespeicherte Gespräche bleiben im Gerät. - Modelle kommen nur über das Systemprogramm
modelget(Rechtmodels.install: Netz hinaus und/modelsschreiben, 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.