Example Apps

Example Apps

Purpose

This page tracks the QEMU userspace example applications included in the XAI OS initramfs. These apps prove the current EL0 C toolchain, syscall ABI, mutable filesystem surface, control-plane access, QEMU network path, SMP thread-group syscall, remote-login command surface, OpenSSH client bridge, and CPU-only AI runtime boundary.

Contents

• Status
• Included Apps
• LSTM XOR Benchmark
• Verification
• Limits

Status

The example apps are built as freestanding AArch64 ELF binaries and packaged into the VirtIO read-only initramfs under /bin.

Current QEMU gate status: done for the macOS/QEMU AArch64 target.

Scope note: these are QEMU integration apps. They prove app-callable OS surfaces inside XAI OS, including a QEMU-native remote-login syscall, an OpenSSH-compatible local bridge on localhost:2222, external-session TCP/UDP syscall paths, user thread groups, and a generic CPU-only ML dispatcher. They are not a complete Internet TCP/IP stack, full POSIX pthreads, or a hosted general-purpose ML framework.

Included Apps

App	Path	Purpose	Status
XAI OS shell engine	/bin/xaios-shell	Exercises BSD-style file and directory commands: pwd, cd, ls, mkdir, touch, write, cat, mv, rm, and rmdir through filesystem syscalls.	Done in QEMU
Hello	/bin/hello	Demonstrates the freestanding C userspace toolchain and EL0 runtime integration.	Done
Sysinfo	/bin/sysinfo	Prints XAIOS/QEMU system identity and requests process, filesystem, network, and telemetry status through osctl.	Done
Systest	/bin/systest	Exercises syscall and mutable filesystem behavior: mkdir, write, read, stat, list, rename, delete.	Done
Smptest	/bin/smptest	Runs an app-requested SMP worker task set through the SMP syscall and checks scheduler state.	Done in QEMU
Nettest	/bin/nettest	Calls app-facing UDP echo, TCP connect/close, and external-session UDP/TCP syscalls against the queue-backed QEMU network stack.	Done in QEMU
LSTM XOR	/bin/lstm-xor	Calls the CPU-AI decode syscall, then runs a CPU-only two-hidden-layer LSTM-style XOR example with train/run timings.	Done in QEMU
SSH test	/bin/sshtest	Exercises the QEMU-native remote-login command syscall for allowlisted admin commands.	Done in QEMU
ML test	/bin/mltest	Exercises the generic CPU-only ML dispatcher with XOR, sum, and parity model kinds.	Done in QEMU

SSH Access

The local developer SSH workflow is:

make xaios-ssh-bridge
ssh -p 2222 admin@localhost

The bridge speaks the OpenSSH protocol to the host client and exposes the same XAI OS remote-login command contract used by /bin/sshtest. The gate is:

make qemu-ssh-smoke

LSTM XOR Benchmark

/bin/lstm-xor is intentionally small and deterministic. It uses the current XAI OS userspace ABI and CPU-AI decode syscall rather than a hosted libc, GPU runtime, or general ML framework.

The app logs:

• train_ns: monotonic nanoseconds spent in the deterministic training loop.
• run3_avg_ns: average monotonic nanoseconds across three inference batches.
• final_errors: final XOR error count.
• cpu-ai runtime decode=...: proof that the app crossed the XAI OS CPU-AI runtime boundary.
• xor solve passed predictions=0,1,1,0: correctness marker.

The benchmark is a QEMU correctness and integration benchmark only. It is not a physical-hardware performance claim.

Verification

Primary gates:

• make qemu-smoke
• make qemu-userspace-suite
• make qemu-process-gate
• make qemu-osctl-gate
• make qemu-filesystem-gate
• make qemu-abi-contract
• make qemu-ssh-smoke

Expected markers include:

• /bin/xaios-shell: commands passed pwd cd ls mkdir touch write cat mv rm rmdir
• /bin/hello: C toolchain and EL0 runtime integration passed
• /bin/sysinfo: complete
• /bin/systest: syscall and filesystem suite passed
• /bin/smptest: POSIX-style arbitrary user thread group passed
• /bin/nettest: external host-to-guest tcp/udp session path passed
• /bin/lstm-xor: cpu-ai runtime decode=
• /bin/lstm-xor: xor solve passed predictions=0,1,1,0
• /bin/sshtest: interactive remote login command surface passed
• /bin/mltest: multi-model CPU-only ML runtime passed

Limits

The shell app currently runs a scripted command session in QEMU using the same command engine that an interactive terminal will call. /bin/sshtest adds the QEMU-native remote-login syscall surface with allowlisted admin commands. make xaios-ssh-bridge exposes that command surface to a real OpenSSH client as admin@localhost:2222.

/bin/nettest uses app-facing network syscalls and the queue-backed QEMU network stack, including external-session UDP/TCP syscall paths. These are deterministic QEMU stack tests, not a public Internet interoperability matrix.

/bin/smptest proves an app-requested user thread group and per-CPU scheduling telemetry. This is the current XAI OS user-thread contract, not a drop-in libc pthread implementation.

/bin/lstm-xor proves CPU-only AI runtime integration and deterministic app benchmarking. /bin/mltest proves the generic CPU-only ML dispatcher for multiple small model kinds. This is the XAI OS runtime boundary, not a hosted training framework or model zoo.