Operating system for desktop and robots · 64-bit ARM · version 0.15.2 · Build 260

A robot needs a system that is never late.

SOFTrobots OS is built entirely on its own – from the loader to the database, in Embedded Swift, without Linux. With Develop you write a program while the system checks it at every key; for the real-time part it proves that every period is long enough. And the AI runs right on the device.

Real time 1000 periods/s, proved Emergency stop in the kernel AI without a cloud Signed every program

Develop and real time, recorded in SOFTrobotsVM on 14 Nov 2026 – every time is real (2:24 min, with sound).

0.62s
from power-on to “Hello from the kernel.”
39.4µs
proved worst case of a 1 ms real-time period
0.2–1.3ms
for Develop to check a whole program – at every key
31words/s
written by a local AI model (Qwen3 4B), no cloud at all

Measured in SOFTrobotsVM on a Mac with Apple M3 Pro. Start: median of three runs on 15 Nov 2026, 4 cores, 8 GB (on a Mac mini M4: 0.57 s); Develop and the real-time proof: 14 Nov 2026; AI: 15 Nov 2026, 4 cores, 8 GB. Real robot hardware has not been measured yet.

Experimental. Never put important data into it. Everything can change – formats, API and data can be lost with an update. Never use it for real robots, machines or vehicles.

Develop

A few lines.
A finished window.

Develop is the workshop inside the system. You write in Reflex, a language that reads like a recipe – on the right the window appears, with buttons, slider and chart. Develop checks at every key and suggests the fix right away when something is wrong.

  counter · main.reflex ✓ 0 problems · test 1/1
1count = 0
2step = 1
3
4page "Counter"
5    value count label "count"
6    button "Add"
7    slider step from 1 to 10
8    chart count
9
10when "Add" is pressed
11    count += step
Window · Counter live
Counter
COUNT
12
STEP
3
Add
step

A shortened version of the template “Counter” (the template also has a heading, a text, Reset and a test). The window on the right is drawn after it; the real one is in the picture further down.

0.2–1.3 ms
for Develop to check the whole program at every key – problems with a suggested fix
0.58 ms
to compile it for ⌘R: the preview runs, a click on it is a real event
13.5 µs
for “Save as Program” to make ARM64 machine code – 1.4 KiB, signed with the robot's key

Measured in SOFTrobotsVM (7 cores, 8 GB) on 14 Nov 2026 while filming the Develop film, with the templates “Counter” and “Wrist hold”; Develop shows these times itself, anew at every check.

Forms and lists

A text field, a button and a list that is still there after a restart – an excerpt of the template “Notes”. The list is a table in the program's own folder.

notes = stored list of text: text at: time page "Notes" field newNote placeholder "Write a note" button "Add" list notes showing text, at removable when "Add" is pressed notes.add text: newNote, at: clock.now

Charts in one line

chart draws a value over time – the counter, a measurement or the angle of a joint.

page "Counter" value count chart count

12 templates to start

Empty, Notes, Counter, Stopwatch, Tea timer, Shopping list, Quiz, Arm buttons, Arm move, Camera watch, Clap to stop, Melody – ⌘N, pick one, Enter.

Develop: the counter's code on the left, the running window with numbers, buttons, slider and chart on the right
The counter running: two clicks on “Add” in the preview – the number is 2, the chart shows it.
Develop: New project with twelve templates
New project: twelve templates, from notes to moving the arm.

Real time

Not hoped for.
Proved.

An arm that reacts late is dangerous. So for every real-time part Develop works out how long one period takes in the worst case – instruction by instruction. Only what fits safely into 80 % of the period may go onto the real-time core.

  wrist hold · main.reflex ✓ proved
1target = 40°
2periods = 0
3
4realtime every 1 ms
5    joint = robot.state(joint: 5)
6    if periods % 10 == 0
7        arm.move joint 5 to (joint.angle
8            + clampStep(error: target - joint.angle)) in 10 ms
9    periods += 1
Realtime · proof✓ PROVED
039.4 µs80 % = 800 µs1 ms
Period1 ms · 1000 per second
Worst case, computed39.4 µs
Used of the period3.9 %
Corea core of its own, only for real time
Memory of the real-time partfixed, no heap

If the time cannot be proved, Develop shows it at once not proved – and “Save as Program” does not put such a script onto the real-time core.

Template “Wrist hold”, proof in Develop on 14 Nov 2026; the proof counts for a 1 GHz core, with a safety margin.

Write and prove.

Develop checks at every key – the real-time part too. The proof is a card beside the code.

Save as Program.

Develop compiles to ARM64 machine code, signs it with this robot's key and puts it onto the real-time core – with fixed memory, without a heap.

The kernel takes only what fits.

Period and budget are in the signed manifest. If the contract does not fit the core, the program does not start.

The emergency stop comes first.

A click on E-STOP or ⌘+Esc: the stop goes over CAN to the motor – in the VM 10–12 µs from the emergency stop in the kernel to the stop frame sent. The flight recorder keeps the last seconds.

The real-time program runs on the real-time core and is in the dock with an RT badge
The proof on the right in Develop, “steady” with its RT badge in the dock, 1 kHz on the desktop card.

AI on the device

AI right inside the robot.
No detours.

No cloud, no Python, no borrowed runtime: SOFTrobots OS has an AI engine of its own, written in Swift, with its own compute kernels for the ARM processor's vector instructions (sdot, smmla). It reads the models straight from the file; its answers are checked against the reference program llama.cpp.

Modela GGUF file in /models – Qwen3, Qwen2.5 Coder, Qwen3 VL; with a button in Settings, its checksum checked
One AI service for allloads the model once for every program; it reads only /models, has no network and writes nothing
Programs askAsk or your own programs – through the API, with the right ai.use in the manifest
Answer word by wordwith speed, memory and model – shown in Ask's inspector
✓ no word leaves the robot✓ no picture leaves the robot✓ works without the internet

This holds for the AI service and Ask. The exception: Develop's assistant (Explain, Ask Develop) asks Claude over the internet – only with a key of your own; the preview has none.

Measured

Model (4-bit, Q4_K_M)Words per second
Qwen3 4B Instruct31
Qwen2.5 Coder 7B19
Qwen3 14B (needs 16 GB; 7 cores, 12 Nov)12
First word after0.5 s (4B)
1.0 s (Coder 7B)
Memory of a conversation8,192 (4B), 4,096 (Coder 7B)
with 8 GB; up to 32,768 with 16 GB

SOFTrobotsVM on a Mac with Apple M3 Pro, 4 cores (3 for programs), 8 GB, three runs on 15 Nov 2026, median. The speed depends on the model and on the number of cores, not on the size of the memory.

Seeing, detecting, learning

Object detection with an inference engine of our own and signed models – the kernel does not open an unsigned model.

Straight into the real-time period: a real-time program reads the camera's findings from a shared ring – no copy, no system call, no waiting.

Show instead of draw: Camera remembers the empty place, finds what is new by itself and takes the learning photos with their boxes; SOFTrobots Trainer on the Mac turns them into a model of your own, signed.

Ask: question and answer as speech bubbles, the inspector with model, memory, speed and memory use on the right
Ask with the small test model (QEMU, hence slow): the conversation as speech bubbles, the inspector on the right – model, memory, speed, memory use.

The system

All our own.
From the loader to the database.

Kernel, drivers, file system, database, network, desktop and programs – in Embedded Swift. C only in the EFI loader and in the JavaScript cage, assembly only where nothing else works. The only third-party code: the JavaScript engine QuickJS-ng, locked in a cage with six system calls.

Web, Image, Camera and Video – recorded in SOFTrobotsVM on 15 Nov 2026, every time is real (1:58 min, with sound). Web shows this website; photos CC0 from Wikimedia Commons.

Rights from the manifest

Every program is signed, runs in its own address space and gets only the rights in its manifest. A program sees a file only when it is given to it.

SOFTrobotsFS and the database

Copy-on-write, checksums on everything, AES-256-GCM per block. After a power cut the old or the new state holds – never anything in between. The database lives in the file system.

Buddy, the watchdog

Reads the logs, barks at faults and bites programs that take more memory than they announced.

Network only encrypted

IPv6 first, only TLS 1.3, names only over DNS over HTTPS, time over NTS. A port without a listener does not answer at all.

Programs

Develop, Ask, Camera, Video, Image, Files with a time slider, Web (JavaScript in a cage), Reader, Sound, Database, Benchmark, Activity, Server, Console, Settings.

Small

The whole system: a download of 27 MB, 123 MB on disk after the first start (an 8 GB image with holes) – with the desktop, all programs and Develop's compiler.

Image with its inspector: format, pixels, profile, EXIF and the note about the place a photo was taken
Image: the inspector on the right – with a clear note when a photo carries the place it was taken (test picture).
The desktop with the simulated arm and the cards on the right
The desktop: the simulated 6-axis arm, on the right live memory, processors, real time and the emergency stop.

Architecture

How the system is built.
Swift from bottom to top.

Five layers, one main language: kernel, services and programs are Embedded Swift. C only in the EFI loader and in the JavaScript cage, assembly only where Swift cannot reach – at start, for exceptions, for the thread switch, at the system registers and for fast crypto.

How SOFTrobots OS is built, in five layersFrom bottom to top: hardware (AArch64, UEFI, ACPI; today SOFTrobotsVM/QEMU). EFI loader in C, boot/loader.c, 573 lines. Kernel at EL1 in Embedded Swift with scheduler, memory, IPC rings, SOFTrobotsFS and SOFTrobotsDB, network with TLS 1.3 and drivers; assembly only in entry.S, vectors.S, context.S, sysreg.S and crypto.S, 1,374 lines in all. Services and system programs at EL0: display, AI service, USB input, actuators/CAN. Programs at EL0, each in its own address space, signed, with rights from the manifest; assembly in kernels.S, tls/asm and crt0.S; JavaScript only in a cage with QuickJS-ng. On top: Reflex scripts from Develop, compiled to ARM64 machine code. Reflex scripts from Develop compiled to ARM64 machine code Programs EL0 · Embedded Swift Develop Web Ask Camera Video Image Files … each in its own address space · signed · rights from the manifest Assembly in programs kernels.SAI: sdot, smmla tls/asmAES-GCM, ChaCha20 crt0.Sprogram start JavaScript in a cage QuickJS-ng (MIT), third-party only six system calls for scripts of web pages Services and system programs EL0 · Embedded Swift Window system “display” AI service USB input Actuators/CAN ↑ System calls ↓ Kernel EL1 · Embedded Swift Schedulerper core, real time (EDF) on its own core Memory16 KiB pages, W^X IPCrings between the address spaces FilesSOFTrobotsFS and SOFTrobotsDB Networkown network stack, TLS 1.3 DriversNVMe, virtio, GICv3 Assembly – only where Swift cannot1,374 lines entry.Sstart vectors.Sexceptions context.Sthread switch sysreg.Ssystem registers crypto.SAES/PMULL, SHA-256 for the disk EFI loader C · boot/loader.c · 573 lines Hardware AArch64 · UEFI · ACPI today: SOFTrobotsVM / QEMU How SOFTrobots OS is built, in five layersFrom bottom to top: hardware (AArch64, UEFI, ACPI; today SOFTrobotsVM/QEMU). EFI loader in C, boot/loader.c, 573 lines. Kernel at EL1 in Embedded Swift with scheduler, memory, IPC rings, SOFTrobotsFS and SOFTrobotsDB, network with TLS 1.3 and drivers; assembly only in entry.S, vectors.S, context.S, sysreg.S and crypto.S, 1,374 lines in all. Services and system programs at EL0: display, AI service, USB input, actuators/CAN. Programs at EL0, each in its own address space, signed, with rights from the manifest; assembly in kernels.S, tls/asm and crt0.S; JavaScript only in a cage with QuickJS-ng. On top: Reflex scripts from Develop, compiled to ARM64 machine code. Reflex scripts from Develop compiled to ARM64 machine code EL0 · EMBEDDED SWIFT Programs Develop Web Ask Camera Video Image Files … own address space, signed, rights from the manifest Assembly in programs kernels.SAI: sdot, smmla tls/asmAES-GCM, ChaCha20 crt0.Sprogram start JavaScript in a cage QuickJS-ng (MIT), third-party only six system calls for scripts of web pages EL0 · EMBEDDED SWIFT Services and system programs Window system “display” AI service USB input Actuators/CAN ↑ System calls ↓ EL1 · EMBEDDED SWIFT Kernel Schedulerper core; real time(EDF) on its own core Memory16 KiB pagesW^X IPCrings betweenthe address spaces FilesSOFTrobotsFSSOFTrobotsDB Networkown network stackTLS 1.3 DriversNVMe, virtioGICv3 Assembly – only where Swift cannot entry.Sstart vectors.Sexceptions context.Sthread switch sysreg.Ssystem registers crypto.SAES/PMULL, SHA-256 for the disk 1,374 lines C EFI loader boot/loader.c · 573 lines HARDWARE AArch64 · UEFI · ACPI today: SOFTrobotsVM / QEMU

Languages in our own code

  • Swift173,78591.3 %kernel, drivers, services, programs; plus Mac tools and tests
  • Assembly3,2041.7 %kernel 1,374 · programs 1,830
  • Shape language (.shape)2,2671.2 %one definition for API, rings, tables and network
  • JavaScript1,4580.8 %Web's page mirror for scripts in the cage
  • C1,3740.7 %EFI loader 573 · JavaScript cage 801
  • C headers9350.5 %BootInfo, EFI, ABI structures
  • Reflex7560.4 %templates and programs for Develop
  • Python and Shell6,4803.4 %Mac tools only – never run in the system
  • Total own code190,259100 %lines including comments

Third-party code, counted separately

QuickJS-ng – 82,889 lines (MIT licence), Web's JavaScript engine. Runs only in the cage, not in the total.

Counted on 14 Nov 2026 with wc -l; technical datasheet, section 4.

File formats

Open formats –
no licence fees.

Every format is our own Swift code. The decoders run in the program's address space, never in the kernel – a malicious file can hit only that one program. And we only build formats that anyone may use without paying licence or patent fees.

Pictures

PNGR WJPEGR WGIFRWebPRSVGRBMPR WTIFFR W

PNG (W3C/ISO) was built to be patent-free; for baseline JPEG the patent claims have expired, for GIF the LZW patents expired in 2003/2004. WebP comes with Google's royalty-free licence, SVG is a royalty-free W3C standard, BMP and TIFF are simple, documented formats.

Documents

PDFR WText and MarkdownR W

PDF is ISO 32000 and free to implement. Text and Markdown are plain UTF-8 text.

Video

Matroska (.mkv)R WWebMRVP9RMJPEGR W

VP9 comes with Google's royalty-free licence (BSD code, patent grant); Matroska and WebM are open containers. MJPEG is JPEG pictures – that is how Camera stores its recordings.

Sound

OpusRFLACR WWAVR WPCM in MatroskaR W

Opus is IETF RFC 6716 and royalty-free, FLAC is open and free, WAV and PCM are simple, documented formats. Opus is read in WebM and Matroska.

Archives

ZIP with AES passwordR WDeflate, zlib, gzipR W

Deflate (RFC 1951) is free to use – one own inflate for PNG, ZIP, PDF, TIFF and Web.

Data

CSVR WJSONR WSQL queriesR

CSV and JSON are open, simple text formats. SQL is read-only, in Console and Database.

Our own formats

SOFTrobotsDB (.db)R WSeries (.series)R WReflex (.reflex)R WReflex package (.srshare)R W

Our own formats – described in the technical datasheet.

R = read, W = write

Deliberately not built: H.264 and H.265/HEVC. Patent pools charge licence fees per device for them – the decision is: never H.264.

Variants, limits and speed of every format, checked against the code: technical datasheet, section 9. For the WebP reader the algorithm was ported from libwebp to Swift (BSD licence, in the file header).

How it is built

Developed with the help of AI.
Reviewed and tested by the developers.

Since its first start on 28 October 2026: one change at a time, measured before and after – what brings nothing is removed again. Every failure is written down (180 entries, F1 to F180), every decision recorded, and before a version 31 device tests and 581 tests on the Mac run.

Try the preview

SOFTrobots OS
on your Mac.

An app and the finished system, for Macs with Apple silicon. Unpack, double-click, set up the robot – and write your first program in Develop.

Download and unpack.

Put SOFTrobots OS.app anywhere, Applications for example – the system is inside it.

Double-click SOFTrobots OS.app.

Signed with the Developer ID of SOFTrobots GbR and notarised by Apple.

Set up the robot.

A name and a password – the password is never stored.

Needs: a Mac with Apple silicon (M1 or newer), macOS 15 or newer, 4 GB of free memory, about 2 GB of free space.

Contact

Curious?

Write to us: info@softrobots.de. Every number with its source and conditions is in the technical docs, the programming interface in the API.