Distributed computing with SlOS and Hew

This is an orientation tour of real SlOS recordings. The views are simultaneous, but this tour cuts between labeled excerpts at normal speed. The other three videos preserve each complete, uninterrupted session.

The large left pane is Chrome displaying a page served by the Hew coordinator inside SlOS. Here you submit jobs, pause admission, watch accepted tiles, select their evidence, and download the actual bitmap.

Top right is the coordinator's real serial console. Assignment and commit messages come from its native guest. This is not a host scheduler pretending to be the operating system.

Middle right is the AArch64 worker's serial console. The other two workers are separate x86-64 guests; their full logs are retained. The render calculation runs inside each Hew user program.

Bottom right is the host operator's transcript. It labels real user actions, power cuts and verification results. It is not SlOS's causal graph. The visible delay here is an actual outstanding lease.

Select a green tile. Its assignment ID is the actual work message identity, whose parent is the worker's pull. Done names that assignment as its exact parent. The inspector connects an accepted result to a specific worker and attempt, not merely a nearby timestamp.

After coordinator power loss, these checked tiles recover on the same volume with unchanged assignment and completion identities. Upload is only staging. The Hew coordinator publishes a checked immutable tile before reporting application processed. A mailbox receipt alone is not durable completion.

The useful distinction is explainable retry and acceptance: which attempt ran, which expired, and which result survived. SlOS supplies shared global identities and preserved causal parents through its SDK. The application still owns leases, result validation, persistence and reconciliation.

Hew supplies the user space policy: the coordinator actor, worker computation and the receiving actors. It compiles on the host into native user ELFs. These link a freestanding runtime subset, not the normal full Hew runtime. No compiler runs inside the guest.

Why an entire OS? This renderer does not require one. A mature operating system and tracing libraries could implement the same contract. SlOS is a controlled experiment in making causal context and explicit resource outcomes common facilities below applications, rather than conventions reinvented by each service.

The demonstration proves a working integration, not automatic root cause analysis or exactly once execution. Causal IDs do not make a dishonest worker correct. These are four QEMU guests on a trusted LAN, not physical hardware or a CPU scaling benchmark.

This is the actual SlOS compute dashboard, beside simultaneous live guest consoles. A Hew coordinator and three native workers are running in separate virtual machines. Everything you see plays at real time.

I pause two workers through the dashboard. Pause stops new assignments; it does not cancel a tile already in progress. The remaining worker can still accept work.

I enter the image settings and submit a job. The browser only requests and displays it. The Hew programs inside SlOS calculate the pixels.

The first green tiles were accepted from worker one. Blue means an outstanding lease, not a finished result. Notice the live assignment and commit messages in the coordinator console.

Now I resume the other two workers. One of them is AArch64. They pull their own assignments from the same coordinator, and the image fills progressively.

Selecting a completed tile exposes its worker, attempt count, actual assignment identity, completion event, and durable causal audit. These are the records for this tile, not a reconstructed example.

I download the real bitmap. The raw pixel result has also matched an independent reference, byte for byte. All three native workers contributed accepted tiles.

Finally, I explicitly forget the completed job. Its card disappears because the guest has removed that completed job. This is a deliberate user action, not automatic cleanup.

This session demonstrates a real worker failure. I pause the two x86 workers so that the AArch64 virtual machine receives the next assignment.

I have cut power to the AArch64 worker while its tile is still uncommitted. Its console stops. The coordinator keeps the outstanding lease rather than immediately trusting another result.

I resume worker one. Recovery waits for the bounded lease to expire. This waiting is shown at real time; there is no cut or speed increase hiding the delay.

The expired assignment was retried and worker one committed the replacement tile. The orange border and the audit expose the second attempt. The pixels still match the independent reference.

Now I reboot the AArch64 worker using its original volume and start the same Hew worker again. Its stable application identity is preserved.

With the other workers paused, the rejoined AArch64 worker has completed a new job. These are new verified commits after a real power loss, not merely a reconnected status indicator.

Here the coordinator itself will lose power during a partly completed render. I pause one worker first, so that its admission setting must also survive the reboot.

I have powered off the coordinator virtual machine. The browser loses its connection, while the worker machines remain running. Only results already published to the coordinator volume are durable.

I reboot the coordinator on that same volume. The native SlOS boot is visible in the console. Network discovery and recovery happen at their actual speed.

The dashboard is connected again. The checked tiles are marked recovered, with their original assignment and completion identities unchanged. The worker that was paused is still paused.

After I resume admission, unfinished work completes and the entire image matches the independent reference. This is a trusted LAN, one user compute core per worker, QEMU demonstration; it is not a physical Pi or CPU scaling benchmark.