Operating system for desktop and robots · 64-bit ARM · version 0.15.3 · Build 629

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 – even models larger than its memory.

Real time 1000 periods/s, proved Emergency stop in the kernel AI every model, no 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 models on the device

Every model runs.
With an explanation.

A small model fits into memory and answers smoothly. A large one doesn't – and runs anyway: SOFTrobots OS fetches from the disk only the parts it needs for the next word. That makes it slower, but it works. All on the device, no cloud.

31words/s
Qwen3 4B – a small model, entirely in memory
47.5GB
is the size of Kolibri-1 – more than the VM's memory (18 GiB)
1.0–1.1words/s
is what Kolibri-1 still writes, its experts coming from the disk
6of 384
experts per layer are all Kolibri-1 needs for one word

SOFTrobotsVM on a Mac with Apple M3 Pro (36 GB). Qwen3 4B: 4 cores, 8 GB, median of three runs on 15 Nov 2026. Kolibri-1 (Q4_K_M): 8 CPUs, 18 GiB, disk image on an external SSD over USB, 18 Nov 2026.

What is a model?

A file full of numbers

A language model is a large file holding billions of numbers, learned from an enormous amount of text. Qwen3 4B is 2.4 GB, Kolibri-1 47.5 GB.

One word at a time

From your question the model works out the next word, appends it and works again. For every word it has to read the numbers it needs. Strictly speaking these are pieces of words; we simply call them “words”.

Why memory matters

When the numbers sit in main memory, reading them is fast. When they first have to come from the disk, the model waits for the disk. So the speed depends on how much has to come from the disk for each word.

Small is fast. Large works too.

SOFTrobots OS doesn't turn away a model that is too big for memory – it loads it anyway.

Small: fits entirely

The whole model sits in memory. Every word is read from memory alone.

Memory · 8 GBQwen3 4B
Model 2.4 GBfree for programs
31 words/ssmooth enough to read along

Large: the experts come from the disk

A fixed part stays in memory. The rest is a cache for experts; whatever is missing, the system reads from the disk.

DiskKolibri-1 · 47.5 GB
all experts live here
↓ for each word, only the experts it needs
Memory · 18 GiBCache 8.7 GB
fixedexpert cachefree
1.0–1.1 words/sslower, but the same kind of answer

Bars not to scale. Values: SOFTrobotsVM on the Mac with Apple M3 Pro; Qwen3 4B with 4 cores and 8 GB (15 Nov 2026), Kolibri-1 with 8 CPUs and 18 GiB (18 Nov 2026); the expert cache held 8.7 GB.

What are experts?

Many new large models are split into small sub-networks called experts (“mixture of experts”, MoE for short). For each word a router picks only the ones that fit; the rest stay idle. Kolibri-1 has 384 experts in every layer and uses 6 of them. So for each word it reads only about a twentieth of the file – and that is what lets a model larger than memory run at all.

One layer of Kolibri-1, one word · 384 experts
needed, already in the cache needed, read from the disk in the cache on the disk only

An illustration, not a measurement: which experts sit in the cache changes with every conversation.

The fixed part stays in memory.

Whatever every word needs – attention, vectors, the output head and the shared expert – is always ready.

The router chooses.

In every layer it picks the 6 best-fitting of 384 experts for the word. One Kolibri-1 expert is only 2.6 MB.

The cache keeps the popular ones.

Experts that are needed often stay in memory. Only what is missing comes from the disk.

More memory, more speed.

The larger the cache, the more often an expert is already there. Nothing in the system needs to be reconfigured for that.

How fast? Measured with Kolibri-1.

The same AI engine, once inside SOFTrobotsVM and once as a test tool running directly on the Mac. The numbers show what more memory for the cache achieves.

In SOFTrobotsVM · memory of the VM
8 GiB0.4
18 GiB1.0–1.1
Engine directly on the Mac · cache size
2 GB1.37
4 GB2.22
8 GB3.59
16 GB5.68
24 GB6.18

Words per second. Mac with Apple M3 Pro, 36 GB, on 18 Nov 2026; Kolibri-1 Q4_K_M (47.5 GB) on an external SSD over USB (10 Gb/s), 32 words per run. VM: 8 CPUs.

Why is the VM slower? The VM's emulated disk reads about 200 MB/s. For each word Kolibri-1 spends 0.83 of 0.86 seconds there waiting for the disk; the computing itself takes 25 ms. On the Mac the same engine reads straight from the SSD.
How often is an expert already there? On the Mac with a 16 GB cache in 97.8 % of cases, with 2 GB in 79 %.
Is the answer right? Kolibri-1 answered our three German test questions correctly: spotting a contradiction, summarising a letter, doing arithmetic. In the VM with 18 GiB it passed every check of the AI service.
The first question takes a while. After a start the cache is empty: in the VM with 18 GiB the first question (56 words) took 124 seconds.

Which model for what?

Honestly measured. Green means smooth enough to read along; amber means worth it when the answer can wait.

KindExampleSpeedGood for
Small, fits into memoryQwen3 4B Instruct, 2.4 GB31 words/sVM, 4 cores, 8 GBeveryday Ask, short questions, explanations
For code, fits into memoryQwen2.5 Coder 7B19 words/sVM, 4 cores, 8 GBquestions about programs
Medium, fits with 16 GBQwen3 14B, 9.0 GB12 words/sVM, 7 cores, 16 GBlonger, more precise answers
Large with experts, bigger than memoryKolibri-1, 47.5 GB, 6 of 384 experts1.0–1.1 words/sVM, 8 CPUs, 18 GiB · 5.68 directly on the Mac with a 16 GB cachegood German, answers that can wait
Large with large expertsLlama 4 Scout, 65.4 GB, one expert 81 MB0.3–0.7 words/sdirectly on the Mac, 16–24 GB cacheruns and answers correctly; every missing expert means a lot of reading

Qwen values: SOFTrobotsVM on the Mac with Apple M3 Pro, median of three runs on 15 Nov 2026 (Qwen3 14B on 12 Nov 2026). Kolibri-1 and Llama 4 Scout: 18 Nov 2026, models on an external SSD over USB. All models 4-bit (Q4_K_M). Models without experts (“dense” models) also run when they are bigger than memory – but they read the whole file for every word and therefore stay slow. With little memory, a model with experts is the right choice.

The system tells you

Settings › AI shows for every model whether it fits. Ask puts it in the window title and shows the real speed while it answers. The system deliberately shows no estimated time – it would only be a guess.

Settings › AI with three language models: Qwen3 4B in use, Qwen3 14B and Kolibri-1 marked 'runs slower: larger than the memory, read from the disk', each with its checked SHA-256
Settings › AI in QEMU on the Mac with Apple M3 Pro, 8 GB memory for the robot, 19 Nov 2026. Qwen3 14B (9 GB) and Kolibri-1 (47.5 GB) are larger than that memory.
Askredrawn
Kolibri-1 · slower, from the diskAsk's title when the model doesn't fit into memory

This line is the real text from Ask.

Private and open

The AI service reads only the /models folder, has no network and writes nothing. Models come in the formats you can get them in anywhere – swap them without any extra tools.

✓ no word leaves the robot✓ no picture leaves the robot✓ works without the internet

Language: GGUF

GGUFRQ8_0Q4_KQ6_K

One file into /models/language. Today the engine knows the architectures Qwen2, Qwen3, Qwen3 with experts, Qwen3 VL (images), Llama, Llama 4 and Kolibri-1.

Detection: ONNX

ONNXR

A detection model goes into /models/detection. Camera reads it directly and turns it into 8 bits while loading – no converting on the Mac. If the engine doesn't know a building block, it says so plainly.

Not signed, but checked

Models are not programs, so they are not signed. The reader checks every size against the file; to prove it, small models were deliberately damaged and read in 20,000 times. A broken file does not bring down the AI service.

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

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.

At the desk

Calculate, plan, print.
All on the device.

SOFTrobots OS is also a desktop for every day: spreadsheets, letters, contacts and appointments in open formats, printing over the home network, folders on your Mac and 3D models to look at. No account, no cloud – the files stay on the device.

Calc and Write

.odsR W.xlsxR W.odtR W

Calc works out sheets with formulas and templates such as the household book; a formula can also be described in a sentence. An .xlsx stays an .xlsx – nothing is converted silently. Write writes letters as .odt and PDF.

Contacts and Calendar

vCardR W.icsW

People and firms with birthdays, groups and attached files; vCard 2.1 to 4.0. Appointments are typed in one line ("Dentist Fri 14:30"), and Buddy reminds you.

Printing

⌘P in Write, Calc, Reader and Image: the system shows the print dialog with a preview and only what the printer can do. Network printers over IPP, as PDF. Programs never see your printers; the printer sees only "SOFTrobots document".

Folders on your Mac

Files opens folders of your Mac over SSH/SFTP – always encrypted, with post-quantum key exchange too. You compare the Mac's fingerprint once; if it changes, Buddy barks. The robot only connects outwards; nothing new listens on it.

Parts: 3D models

STLR3MFROBJRPLYR

Parts shows 3D models to turn, measure and cut, with sizes, volume and whether the model is watertight. Files shows a preview. The file is read by a service of its own with no network and no file rights.

Files

Your favourite places on the left, folders you cannot write with a lock, cut and paste, dragging between two windows, ZIP with a password and the time slider that brings back older versions.

Calc with the household book; in front the print window: Printed on a Lexmark CS310dn
Calc with the household book template, printed on a real Lexmark printer in the home network.
Parts shows an angle bracket from above at an angle; on the right size, triangles, surface, volume and watertight: yes
Parts: an angle bracket as STL, on the right size, surface, volume and whether it is watertight.
Calendar showing November, at the bottom Buddy's reminder of an appointment
Calendar: an appointment in one line, the reminder at the bottom.
Contacts with a card: address, birthday, groups, notes and an attached picture
Contacts: a card with birthday, groups and an attached file (test data).

Security

Secrets in a safe.
Visible, but sealed.

A key you cannot see is hard to understand. So SOFTrobots OS hides nothing: secret files stand in Files as rows of steel – only no program can open, copy or restore them.

The safe

The robot's own key, API keys, the server's keys and guest list, passwords for network folders and Web's cookies are sealed. Only the program a secret belongs to and the kernel read it – not even Console or the time slider.

Locks that explain themselves

Every locked place says who may change things there and why, with a button that goes straight there. Places that are only read are shown as red glass by the system – no program can take that off.

Checked models

Only Settings › AI and the model download change AI models. Every model file gets a SHA-256 check; a changed file is refused. Models are not signed – they stay files in standard formats.

Rights for the system only

Important rights – all files, offering AI, installing models – go to system programs only. Programs you install yourself stay in their own folder.

Encrypted from the start

The data lies on the disk with AES-256-GCM per block. The key comes from your password (Argon2id); the password itself is never stored.

Signed

Every program is signed and runs in its own address space; updates are signed packages. An update that does not start is taken back by itself after three tries.

The safe card of the robot key: what it is, who uses it, when it was made and its fingerprint
The safe card of the robot key: what it is, who uses it, the fingerprint – the content stays sealed.
Files in the models folder as red glass, at the bottom the bar: Only Settings › AI can add or remove models, with the button Open Settings › AI
Red glass: the folder of the AI models is locked; the bar says why and leads to Settings › AI.

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, Write, Calc, Contacts, Calendar, Parts, Web (JavaScript in a cage), Reader, Sound, Database, Benchmark, Activity, Server, Console, Settings – and games such as chess.

Small

The whole system: a download of 53 MB, 181 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.odt / .odsR W.xlsxR W

PDF is ISO 32000 and free to implement. Text and Markdown are plain UTF-8 text. OpenDocument is an open ISO standard (ISO/IEC 26300), and so is .xlsx (Office Open XML, ISO/IEC 29500).

Contacts, appointments, 3D

vCardR WiCalendar (.ics)WSTLR3MFROBJRPLYR

vCard (RFC 6350) and iCalendar (RFC 5545) are open IETF standards. STL, OBJ and PLY are simple, openly described formats; 3MF is an open specification of the 3MF Consortium.

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.

AI models

GGUFRONNXR

GGUF is the open format of llama.cpp (MIT licence), ONNX an open standard of the Linux Foundation. We read both directly – no converting, no third-party runtime.

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.