Distributed computing
A narrated orientation and three complete sessions follow a native x86-64 coordinator, two x86-64 workers and one AArch64 worker. Use the dashboard, inspect tile identities, lose a worker and restart a partly completed render.
Hew guest demonstrations
Watch native Hew applications assign work across SlOS guests, recover accepted results and explain a service that stayed disabled after reboot. The recordings show actual guest execution; this website does not run SlOS in the browser.
Durable causal debugger
Two continuous native x86-64 recordings connect accepted work to its receipts and inspect a worker disabled across reboot. See how the browser distinguishes checked facts, candidate explanations and missing or historical evidence.
Build an application in the guest
The C/Hew workbench guide covers source editing, diagnostics, last-good builds and saved-project recovery. Its expense-ledger and persistent actor-queue sections are worked application examples, not newly recorded video sessions.
Earlier i386 transcript demonstrations
The following step-through transcripts retain their 25 October 2026 compiler versions and i386 scope. They reveal recorded host and guest output rather than contacting a live service. Every step remains readable without JavaScript.
Persistent prime-report jobs
Submit an integer limit, run the accepted job, and fetch its prime count, sum, and largest prime. Completion records are immutable. On startup, the service replays accepted inputs that lack a completed result. The arithmetic is in compiled Hew, not a host proxy or a kernel shell command.
Accept a durable request, then explicitly run it
Acceptance writes the queued input before HTTP 202. Work starts only with POST /run or startup recovery; this is not an autonomous scheduling daemon.
> POST /jobs/1/100
< 202 Accepted
job=1 status=accepted limit=100
> POST /run/1
< 200 OK
job=1 status=completed limit=100 primes=25 sum=1060 largest=97A checked worker crash leaves the job retryable
A fresh worker retries the accepted input. A scoped fork runs the computation while a separate sibling actor advances a timer; the listener survives.
> POST /jobs/2/1000
< 202 Accepted
job=2 status=accepted limit=1000
> POST /crash/2
< 500 Internal Server Error
job=2 status=accepted worker=restarted
> POST /run/2
< 200 OK
job=2 status=completed limit=1000 primes=168 sum=76127 largest=997Leave accepted work on disk
Job 3 is accepted but not explicitly run before graceful shutdown.
> POST /jobs/3/10000
< 202 Accepted
job=3 status=accepted limit=10000
> GET /stop
< 200 OK
stoppingRestart the process in the same guest
Startup recovers job 3; completed job 1 remains unchanged. Job 4 is then accepted and left pending for the reboot.
=== process restart, same guest: Hew listener ready ===
> GET /jobs/1
< 200 OK
job=1 status=completed limit=100 primes=25 sum=1060 largest=97
> GET /jobs/3
< 200 OK
job=3 status=completed limit=10000 primes=1229 sum=5736396 largest=9973
> POST /jobs/4/2
< 202 Accepted
job=4 status=accepted limit=2
> GET /stop
< 200 OK
stoppingBoot the guest again with the same job disk
The new guest process recovers job 4 and returns earlier completed results unchanged. Direct guest disk reads and actual zero exit statuses are checked separately by the harness.
=== guest reboot, same job disk: Hew listener ready ===
> GET /jobs/3
< 200 OK
job=3 status=completed limit=10000 primes=1229 sum=5736396 largest=9973
> GET /jobs/4
< 200 OK
job=4 status=completed limit=2 primes=1 sum=2 largest=2
> GET /stop
< 200 OK
stoppingKeep the workload bounded
Only IDs 1–8 and prime limits 2–10000 are admitted. IDs cannot be replaced; the download includes the complete host transcript, including malformed and oversized headers.
> POST /jobs/1/101
< 409 Conflict
job id already exists
> POST /jobs/9/100
< 400 Bad Request
job id must be 1..8
> POST /jobs/4/10001
< 400 Bad Request
prime limit must be 2..10000The queue accepts eight immutable IDs with limits 2–10000. The service is serial and unauthenticated, with no idle-client deadline; its diagnostic crash/stop endpoints belong behind host-loopback forwarding.
Recovery was checked after ordinary process restart and guest reboot. Staged writes and rename do not provide a power-loss atomicity or exactly-once execution guarantee. Replay is safe for this deterministic calculation because it has no external side effects.
Download the complete host transcript.
Recording source, protocol limits, and session IDs
The replay selects original O2 method/status/body lines. Bounds examples are grouped at the end; they occurred during the first invocation. HTTP accepts ASCII headers up to 2048 bytes, with no body parsing, TLS, or queue eviction.
O2 session a7eb2720d64e4f62a197b2d072b3bb03; O0 43c72680dd8c49e19dda15e1e8874fa7. Hew 95340fc71a, SDK/kernel baseline 04fcefa, consumer aa2091a on 2602e68, integrated as 31dc865. Serial processes.log and reboot.log accompany host.log beneath build/io{,-o2}/jobs-sessions/SESSION/.
Run the jobs demonstration locally
Build command, prerequisites, and check workflow
The sources are private; these commands require an existing consumer checkout, matching compiler, and prepared SlOS SDK. Platform setup describes the dependencies and ABI.
# Existing private checkouts and prepared compiler + SDK required
env -u HEW_STD make -j2 jobs-demo HEW=/path/to/hew SLOS=/path/to/slos
# Optional: repeat the complete exercise with optimized Hew code
env -u HEW_STD make -j2 jobs-check-release HEW=/path/to/hew SLOS=/path/to/slosjobs-demo builds the program, boots a disposable guest, drives host HTTP requests, fails a worker, restarts the process, reboots the guest, checks disk records, and exits. It owns its QEMU lock, removes only its own image, and retains transcripts. It does not leave a server running for later curl requests. Keep HEW_STD unset unless deliberately selecting the compiler's matching standard library.
Supervised HTTP service
A one-for-one supervisor reconstructs a failed worker while a sibling retains its state. Before sending the first HTTP request, the host waits for that sibling's timer to signal over a separate TCP connection, checking progress while the service is parked in a read.
A timer runs while the connection is idle
The host connects but sends no request bytes until a separate sibling actor signals its 50 ms timer over another TCP connection.
notification b'ready\n'
notification b'timer sibling=101\n'
response 200 OK: 'worker=1 sibling=101\n'The worker keeps state
A second GET / increments the worker counter. The sibling remains at 101.
response 200 OK: 'worker=2 sibling=101\n'Checked failure, then fresh worker state
GET /crash deliberately changes worker state and triggers a checked assertion. One-for-one supervision reconstructs that worker; the next GET / sees 1, not the old state. The sibling survives.
response 500 Internal Server Error: 'worker restarted\n'
response 200 OK: 'worker=1 sibling=101\n'Reject oversized headers and stop cleanly
The host submits headers beyond the 4096-byte limit, then GET /stop. The harness compares complete HTTP responses, not only these summaries.
response 400 Bad Request: 'bounded ASCII headers required\n'
response 200 OK: 'stopping\n'A second invocation honours its request budget
The harness launches the service again with a one-request budget. These are the remaining original host.log lines.
notification b'ready\n'
notification b'timer sibling=101\n'
response 200 OK: 'worker=1 sibling=101\n'Guest serial evidence
Selected lines from the separate guest serial log, in their original order. Both invocations exit with the expected zero status after cleanup.
supervised service listening :19080
supervised service stopped after 6 requests
status: PASS expected=0 actual=0
supervised service listening :19080
supervised service stopped after 1 requests
status: PASS expected=0 actual=0This diagnostic handles one connection at a time, with ASCII headers up to 4096 bytes and no authentication or idle timeout. It demonstrates an in-process actor restart, not durable job recovery or full std.net.http. Hardware faults still terminate the process.
Download the host and guest transcript.
Recording source and local check commands
O2 consumer 2602e68, Hew 95340fc, SDK/kernel 04fcefa. Session d7dd47b7ed274de899b20ac34c319bc5 under build/integration-o2/io/service-sessions/; logs host.log and service.log, aggregate build/integration-final-o2.log. Host summaries are verbatim; serial excerpts omit boot text and terminal echo.
# In the local Hew-on-SlOS consumer checkout, with a prepared SlOS SDK
make -j2 service-check HEW=/path/to/hew SLOS=/path/to/slos
make -j2 service-check-release HEW=/path/to/hew SLOS=/path/to/slosUsing the same private checkout prerequisites as the jobs check, these targets create a disposable image, compare exact HTTP responses and exit status, retain logs, and remove their own image.
DNS and socket failures
Separate checks exercise hostname resolution, a silent accepted client, a slow reader, a stalled write, and a reset peer. The read and write deadlines are explicitly enabled for these tests; the jobs and HTTP examples above do not opt in.
Contain an accepted client that sends nothing
An explicitly configured 150 ms read deadline faults an isolated checked actor. The host observed closure in 0.198 seconds in this O2 session; it is a measurement, not a latency guarantee.
HOST
accepted idle client: guest timed out and closed in 0.198s
GUEST
Hew accepted idle read bounded: PASSDistinguish a slow reader, a stalled send, and a reset
All 2 MiB arrive after the slow reader resumes. A separate non-reader causes a 150 ms write timeout with a partial count accepted into OS buffers—not proof of delivery. Reset is classified Closed.
HOST
slow reader: all 2097152 patterned bytes after pause
non-reader: guest advanced after partial write deadline
reset peer: sent TCP RST
GUEST
Hew slow reader all bytes: PASS
Hew write timeout committed=229376: PASS
Hew reset classified closed: PASS
Hew real network resilience: PASS
status: PASS expected=0 actual=0Resolve a hostname through the native OS resolver
A separate guest check runs ordinary Hew hostname connect/echo, A/CNAME lookup, and bounded negative/malformed/silent DNS cases against a local UDP fixture over QEMU Ethernet, without public DNS.
GUEST / separate DNS session
Hew DNS hostname and bounded failures: PASS
status: PASS expected=0 actual=0Receive failure is contained in a checked actor. Failed or cancelled sends abort the connection; the partial count records bytes accepted by OS buffers, not delivery. Native IPv4 DNS can occupy Hew's cooperative worker for up to three seconds, and connect's socket deadline starts after resolution.
Download the network transcript. The platform notes describe the API and resolver limits.
Recording source and local network checks
OS/SDK addition e954004, consumer 70e08fb, Hew 95340fc71a, with clean post-commit provenance. O2 socket session cfa33b938a99410888d9965e1e4676b9; DNS 0ca31564064044c9a7d75d954fed7348. The download also records O0 and later consuming-vector proofs.
# In the prepared consumer checkout
env -u HEW_STD make -j2 io-dns-check io-resilience-check \
HEW=/path/to/hew SLOS=/path/to/slos
env -u HEW_STD make -j2 io-dns-check-release io-resilience-check-release \
HEW=/path/to/hew SLOS=/path/to/slosPlatform reference
The older transcripts above describe their original i386 programs and limits. The native platform guide and Hew runtime guide describe today's application boundary without relabelling those recordings.