PicoSuite
Markdown

Technical whitepaper / 2026

PicoSuite

From bare metal to browser and local AI.

A closer look at the architecture, engineering choices and next steps behind a bounded, capability-oriented platform.

Review date20 Nov 2026
Kernel targetsPi 5 + QEMU
Evidence37 source groups
Platform layers01 — 04
  1. 01
    ExperienceBrowser + applicationsBareMetalJsTools / PicoDesk / DaveAI
  2. 02
    Authority + policyServices + runtimePicoSTS / PicoScript / model service
  3. 03
    Reusable machineryNative librariesPicoWAL / PicoWeb / search / crypto
  4. 04
    ExecutionOS + hardwarePIOS / ARM / storage / accelerators
Responsibility map, not an integration claim

Start here / 01

The whole system,
in focus.

Choose a lens for the short version, then follow the evidence into the full report.

01 / The design

A platform built around ownership.

The OS owns devices and transport; bounded services expose capabilities to policy, applications and the browser. Native-host implementations remain distinct from the kernel.

Explore the architecture

02 / The evidence

Strong foundations. Uneven integration.

Recorded hardware operation, host fixtures and bounded GPU proofs are meaningful progress. They are not yet a production appliance or repeatable GPU model service.

See the maturity assessment

03 / The path

Prove the seams, then expand.

Reproducible builds, shared identity, one real application slice and repeatable CPU inference come before broader GPU and cluster graduation.

Open the roadmap

The complete report / 02

Read the evidence.

Explore the full technical whitepaper, with links back to the repository.

Executive summary

PicoSuite is an integrated platform, not an application name. It brings together a bare-metal operating system, reusable native libraries, a bounded scripting runtime, identity services, a dependency-free browser toolkit, local productivity applications, and an emerging hardware-backed AI execution stack.

Its central proposition is to make resource ownership and execution costs explicit across the whole system. The OS owns devices, transport and memory authority. Applications express policy through PicoScript and consume capability-gated services. PicoWAL provides compact durable state. PicoWeb supplies native web-serving and application-route components. BareMetalJsTools supplies browser interfaces without a framework runtime. DaveAI is a demanding consumer of those foundations, not a special privilege inside the kernel.

The approach is different from assembling a conventional Linux/container/web-framework stack, but it does not eliminate the engineering responsibilities that stack normally absorbs. PicoSuite takes direct responsibility for scheduling, interrupt continuation, storage recovery, protocol interoperability, cryptography integration, accelerator visibility, and safe cancellation.

Current assessment: substantial foundations and component-level proofs exist. The Pi 5 kernel has recorded hardware operation; the browser toolkit and several native libraries have extensive implementation; application and model-service contracts are present. However, a fully integrated, authenticated, recoverable PicoSuite appliance with productive app capsules, replicated cluster services and repeatable GPU model serving has not yet met its end-to-end acceptance gates. It is best described as an advanced engineering platform with uneven component maturity, not a completed production suite.

The shortest credible path forward is to close ownership and reproducibility gaps, prove one authenticated application/storage vertical slice, establish repeatable CPU model execution, and then graduate guarded GPU operations into a safe resident-model service. Cluster automation and the wider application catalogue should build on those proven seams.


1. Scope and evidence

This paper examines the local WillEastbury/SmoofOS monorepo. The repository name is historical; the platform name is PicoSuite. Its bare-metal component is the PicoSuite OS Kernel, retained under components/pios. SmoofSuite-derived applications are currently represented by PicoDesk under components/picodesk, plus the separate target application capsules under apps. There is no components/smoofsuite directory in the inspected checkout, despite older manifest and overview references. 123

The initial review began at commit b1c97e3ce852f16120960a97c9c3ddbec2288700, with uncommitted kernel/storage/test changes, an updated DaveAI text-API document, and a new model uploader in the working tree. Those changes were subsequently committed as bf729cf7843638f37fe158cc29d0337b7f10fc6b, the baseline for the follow-up searches. This is a research snapshot, not certification of an immutable release. Repository source, current contracts, dated execution records, hardware gates and current GitHub issue status were inspected. No new kernel or component build, platform benchmark, deployment or hardware experiment was performed for this paper.

Evidence is distinguished throughout:

Evidence levelWhat it establishesWhat it does not establish
Source or contract presentAn implementation or defined interface existsSuccessful execution or integration
Host fixture/referenceChecked behavior with host execution, often simulated devicesPhysical interrupts, DMA, storage durability or deployment
QEMU integrationGuest boot and the particular exercised guest pathPi 5 peripheral behavior or discrete GPU execution
Physical bounded proofThe recorded operation worked on that image/deviceGeneral workload support, safe reuse or recovery
Release acceptanceReproducible regression and all applicable hardware gates passImplied by none of the levels above

The active kernel support targets are Raspberry Pi 5 and QEMU AArch64 virt. Other Pi boards, Hyper-V and native x86 kernel ports remain historical, out-of-scope experiments. This policy does not remove the Windows/Linux portability of individual libraries, nor the Linux implementation of PicoCluster. 4

Older documents are not uniformly current. Examples include the libraries overview calling PicoLog/PicoPXE unimplemented and the model-cli README calling the port a scaffold. Where these conflict with inspected source, later execution notes or current issue status, the more specific evidence takes precedence. 52332

2. What is different

2.1 A common engineering discipline across layers

The differentiator is not one novel queue, database or UI widget. It is the attempt to preserve a common set of rules from device execution to application delivery:

  • Bounded memory, work, queues and parsing.

  • Explicit owner, generation and lifetime for reusable resources.

  • Immutable publication across ownership boundaries.

  • Capability checks before protected work is decoded or materialized.

  • Backpressure instead of overwriting outstanding work.

  • Observable failure rather than a successful-looking fallback.

  • Separation of application policy from OS and device authority.

These mechanisms already appear in the service FIFO, portable storage engine, route table, tensor descriptor broker and DaveAI stream prototype. Their existence does not mean every active legacy path has converged on them. Convergence is an explicit remaining engineering task. 68918253235

2.2 Owning the OS rather than merely tuning a host

PIOS runs without Linux or a POSIX environment in the kernel. Core 0 is reserved for kernel I/O and management; cores 1-3 run preemptively scheduled user processes. Hardware-specific drivers sit behind common contracts.

This gives the project direct control over its data path and recovery behavior. The tradeoff is direct ownership of work normally supplied by a mature OS: device bring-up, page attributes, interrupt routing, protocol correctness, filesystem recovery and debugging tools. "Deterministic" should be understood here as a design objective enforced through bounds and ownership, not a demonstrated whole-system hard-real-time guarantee. 467

2.3 Pay predictable costs early

PicoWeb's Linux static-serving path reads or maps assets, builds response variants and constructs lookup tables at startup. Its hot path is lookup plus resumable send rather than repeated allocation, formatting and file assembly.

The same reasoning appears in fixed queue capacity, caller-owned library buffers, compiled PicoScript policy and resident AI weights. Predictability is gained by moving work to initialization or explicit preparation, at the cost of capacity planning and update/rebuild mechanics. Static-serving claims do not extend to every dynamic application, TLS or storage path. 8

2.4 Small, independently usable components

PicoSuite libraries and BareMetalJsTools can be used without adopting the bare-metal OS. The browser toolkit is plain JavaScript and CSS; the portable database and search libraries accept caller-owned memory; PicoCluster deliberately uses small native Linux processes rather than an OCI container ecosystem.

This makes adoption incremental. It also means "PicoSuite runs without dependencies" is too broad: browser modules have no runtime package dependencies, the kernel is freestanding, Linux services use libc and OS facilities, and optional media workers may still require Python/Torch/Diffusers. 58101123

2.5 AI as an OS service, not browser or kernel branding

The intended model interface lets a capsule open an authorized logical model and request execution without naming a GPU, DMA pointer or physical address. Native providers own arithmetic and execution. PicoScript supplies control policy. DaveAI handles the user-facing conversation and application orchestration.

The separation allows independent UI and inference deployment and, eventually, provider selection based on compatible operation contracts. It does not yet establish runtime-interchangeable Falcon CPU/QPU/B50 execution or a heterogeneous production scheduler. 18232627

These are architectural differentiators, not claims of uniqueness, formally proven isolation, lower total cost, or superiority to established products. Those claims would require comparative measurements and independent assurance.

3. System architecture

3.1 Platform layers

 Browser clients
   BareMetalJsTools: UI, documents, workflows, storage, transport
          |
 Application tier
   PicoDesk / app capsules             DaveAI frontend and orchestration
          |                                      |
          |                         Versioned inference API (remote seam)
          |                                      |
 Service and runtime contracts
   PicoSTS/PicoLogin | PicoScript | PicoWeb routes | Model service
   Storage, discovery, deployment and cluster service contracts
          |
 Reusable native libraries
   PicoWAL | search | compression | crypto | Parquet | small domain APIs
          |
+--------------------------+-----------------------------------------+
| PIOS implementation      | Native-host implementations             |
| EL0 capsules             | Linux PicoWeb/PicoCluster               |
| OS-owned FIFO/span IPC   | Windows/Linux library and DaveAI hosts  |
| Core-0 I/O + drivers     | OS sockets/files/process adapters       |
+--------------------------+-----------------------------------------+
          |
 Pi 5: ARM/NEON, VideoCore, SD, Ethernet, PCIe/NVMe/experimental Arc
 QEMU: virtual ARM CPU, virtio network/block devices, framebuffer

This is a responsibility map, not a claim that every box is wired into one running system. In particular, the Linux supervisor is not a bare-metal component, and remote inference HTTP is not the local FIFO ABI. 1101226

3.2 Kernel execution and the fail-safe path

On Pi 5, hardware IRQ top halves acknowledge or quiesce the device and publish bounded work. Protocol processing follows scheduled IRQ -> FIFO -> AIRQ -> subsequent FIFO stage handoffs, not timer-driven protocol polling.

airq separates software priorities and producer/target lanes. adrv provides admitted, deadline-bounded asynchronous driver steps. Queue saturation must retain a continuation until credit returns. A doorbell may coalesce; correctness rests on published work and retained sequence-backed continuation, not on equal interrupt and message counts.

Core 0 is especially important: it owns the network, disk and operator path, and answers requests on which other cores may be waiting. Blocking it can make a live board unreachable and stall the application cores simultaneously. The architecture protects that path, but remaining SD/NVMe/TLS polling migrations show that the objective is not yet universally achieved. 6732

User processes execute at EL0 with mandatory preemption and private kernel exception stacks. Scheduling supports eligible cores, optional pinning and owner claims. Shared control records are cache-line isolated. A physical page must retain compatible memory attributes across kernel, user and other aliases; ordering barriers cannot repair contradictory cacheability. 6

3.3 Local service IPC

The current service FIFO header defines ABI 2 with 64-byte descriptors, generation and owner metadata, bounded lengths, and release/acquire publication. Producer and consumer indices reside on separate owned pages. Requests and completions are distinct channels; model traffic has an additional independent lane.

The broad pattern is:

Authorized caller -> immutable descriptor -> OS-owned bounded queue
     -> service/provider -> correlated completion -> owner-routed wake

No sender-local pointer becomes receiver authority. Borrowed spans and leases remain owned until the relevant consumer, cancellation acknowledgement or safe retirement boundary permits reuse.

Several bridge implementations and specialized model paths coexist. The generic ModelFifo VM registry still lacks its complete production stop/retire/reuse protocol; this must not be confused with the separately implemented capsule model-service FIFO path. Existing local VM queues are likewise not automatically cross-process OS queues. 9181932

3.4 Boot, storage and updates

A small stage0 loader selects the real OS from redundant raw A/B slots, with checked FAT recovery packaging and controlled override behavior. WALFS supplies the kernel's append/recovery-oriented storage. The exFAT Transfer volume is a separate interchange surface, used for files such as model weights.

These are related, but not interchangeable:

  • PicoWAL is the database/component family.

  • WALFS is the PIOS filesystem/storage implementation.

  • Transfer/exFAT provides host-interchange files.

  • PicoDrive CAS is a proposed immutable-object and revision API above WALFS.

Transfer HTTP uploads are asynchronous: HTTP 202 means queued, not durably committed. Clients must inspect completion status. Exclusive writer leases prevent model readers or competing mutations from observing an incomplete upload. Recent storage work is specifically hardening this path. 13202829

Pi and QEMU have different raw-slot capacities and memory layouts. A QEMU image or successful direct-boot smoke cannot certify Pi boot-media compatibility or a changed physical stage0 trampoline. 1329

4. Component technical approach

4.1 PicoSTS and PicoLogin: identity with explicit hosting boundaries

Two relevant implementations must be distinguished.

Native PicoSTS, under components/picosts, provides OIDC discovery/JWKS, authorization-code and refresh flows, password storage, RS256 JWT support, PKCE, TOTP and bounded directory/token stores. It consumes PicoSuite crypto and the portable PicoWAL adapter. Its PicoWeb route plugin uses caller-owned route/response storage; RSA signing requires a configured DER key and fails closed without one. Administrative import remains explicitly unavailable. 14

PIOS PicoLogin, under services/picologin, is a PicoScript service using native kernel STS/FIFO bindings. Its documented native signing path is HS256, with Interactive, Background and System identities and resource permissions. Internal identity comes from the bound FIFO source rather than a second HTTP password exchange. 15

PicoDesk also retains a local development STS prototype. These are not evidence of one fully reconciled production identity deployment. The remaining work is to establish durable provider ownership, verified identity propagation, consistent resource grants and tested revocation across all active paths. Browser RBAC is a UI aid, never the enforcement authority. Current STS/cluster enforcement work remains open. 31532

4.2 PicoWeb: native serving plus an embeddable application seam

The Linux server uses per-worker connection pools, epoll, SO_REUSEPORT, immutable asset arenas, host/path hashing, prebuilt headers and partial-send state machines. Media can use read-only mappings and Range requests. The portable route table offers exact method/path dispatch independently of that Linux listener.

The adjacent userspace network tree contains real crypto/TLS/TCP implementation and separate QUIC/HTTP-3 primitives. Its own status document distinguishes compiled/tested code from live protocol integration; the running server must not be advertised as HTTP/3-ready merely because those sources exist.

PIOS uses its own network/TLS stack and EL0 capsule adapters. Linux sendmsg performance or host TLS features are not inherited automatically by that implementation. 7816

4.3 PicoWAL: compact state with explicit durability

PicoWAL uses packs/cards as a compact data model across embedded and hosted implementations. The portable C11 engine is independently usable: positional storage callbacks, caller-owned primary/index tables, append records, CRC recovery and derived index rebuilds.

Recovery follows the valid append chain and stops at torn or invalid records. The adapter's sync callback is the durability boundary. An exhausted derived index is marked incomplete, leaving primary data intact; callers must fall back to a primary scan rather than return incomplete answers as complete.

The portable engine's current transaction unit is one put/delete record. It is not a general multi-record transaction system. Other PicoWAL and WALFS variants have different formats and limits; the appliance's 508-byte card limit and application conventions around 4 KiB must not be generalized to every adapter. 1720

4.4 PicoScript: bounded policy, native capabilities

The shipped C VM has a compact 16-opcode base instruction set, verification and execution budgets, with host capability classes for protected bindings. The browser compiler/editor and VM assets connect authoring, bytecode, control-flow views and execution tracing.

The useful division is portable policy above native services: request handling, routing and orchestration in scripts; networking, secrets, crypto primitives, memory grants and device execution in trusted providers. Generic network hooks exist, but the target app-capsule model uses Req/Resp and capability services, not independent application-owned sockets.

A hook name, capability bit or generated reference entry does not prove a live PIOS provider exists. Some collection hooks remain local or deferred; device/stream documents include design-only surfaces; newer timer, resident lifecycle, context and telemetry work is still tracked separately.

The canonical compiler/runtime source is not fully represented as one self-contained authoritative tree in this monorepo. Vendored C, generated browser assets, external compiler inputs and local host extensions therefore require exact versioning and differential tests. Typed ownership and retained workflow frontend parity are remaining work, not completed language guarantees. 21221932

4.5 Other PicoSuite tools

FamilyTechnical approach and existing scopeBoundary/readiness qualification
PicoCompressCodec-neutral shell/registry; native micro codec; one descriptor ABI for static and dynamic registration; streaming conversionPreserve v3 bitstream and cross-language identity; codec modules, not the host, own format behavior
PicoZstdCaller-owned C11 streaming Zstandard decoder; raw/RLE/compressed blocks and entropy decodingDecoder-only, dictionary-free v0.1; not a full Zstandard feature implementation
PicoParquetRead-only, selective column reader; bounded metadata/page/dictionary storage; callback input and codec seamExplicit unsupported encodings/features; not a writer or general analytics engine
PicoCryptoShared SHA/HMAC/PBKDF2/RSA and constant-time/zeroization helpersNot a certificate host, key generator or proof of cryptographic assurance
SearchGeneric PicoWAL inverted/vector substrates; lexical, fuzzy and hybrid assembliesCaller supplies storage and vectors; no embedding model or automatic Unicode normalization
Small domain APIsPicoJSON, PicoHTTP, PicoCatalog, PicoEvents, PicoRecommend, PicoCart and PicoOrderBounded building blocks, not complete JSON/HTTP servers, payments or persisted commerce systems
PicoBlobNative content-addressed PUT/GET/HAS/DEL TCP implementationNot SMB, replicated storage or the completed PicoDrive API
PicoLogNative append/read/tail service integrated with PicoWeb and external STS validationNative host implementation differs from the PIOS service integration
PicoDNS/DHCP/PXENative DNS/registration/anti-entropy, lease and DHCP handling, read-only TFTP boot-file servingSource and tests exceed older scaffold descriptions; PIOS hosting/netboot remains separate
PicoCluster/PicoPod/PicoReplicateDesired state, placement, replication, process/rootfs isolation and authenticated log exchangePrimarily Linux implementations; cluster safety and production deployment need their own evidence
PicoWatch/PicoAI service capsulesPIOS-target metadata routes for watch targets/status and AI models/jobsNot an implemented health-reconciliation loop or OpenAI-compatible inference endpoint

The unifying value is reusable, narrow machinery rather than a promise to reproduce every large upstream ecosystem. For example, PicoJSON's extraction helper is explicitly not a validating general parser, and vector similarity is not semantic understanding without a supplied embedding pipeline. 510113031

The inspected PicoWatch, PicoAI and PicoSearch service scripts illustrate the difference between intent and implementation: they expose health/readiness and pack metadata operations, but do not execute automatic service reconciliation, model inference or ranked search. Their readiness check establishes storage availability, not readiness of those engines. 36

4.6 BareMetalJsTools: the browser half of the platform

The inspected src directory contains 113 non-minified BareMetal.*.js modules. This is an inventory count, not a statement that every module is equally mature or loaded by every app.

The toolkit covers reactive binding and controls; schemas and binary transport; charts, grids and documents; workflow/report designers; browser storage and offline outboxes; authentication/session helpers; accessibility; media, audio and terminal interfaces.

Modules attach to the shared BareMetal namespace as plain script-loaded IIFEs. Consumers choose what to load and observe dependency order. UI source does not need a framework compilation step, although generating PicoScript assets, minified distributions and integrity manifests still involves tooling.

The browser does substantial UI and local/offline work, keeping the server surface compact. It does not acquire server-side trust through client token decoding, infer model execution from an AI widget, or turn an offline queue into a distributed transaction guarantee. 24

4.7 SmoofSuite-derived tools: PicoDesk today, app capsules tomorrow

PicoDesk is a local office/developer desk using BareMetalJsTools, PicoScript and chunked PicoWAL-style state. Its implemented surfaces include:

  • PicoSheet: grid, formulas, drawings, filtering and graph/pivot views.

  • PicoWrite: a small document editor.

  • PicoShow/PicoBase: slides and form-led records.

  • PicoMail/PicoChat: local mail tooling and rooms with browser WebRTC signalling.

  • PicoDrive: file catalogue/chunk operations.

  • Developer/orchestra seat: board, agents, tasks and file-oriented coding tools.

These are intentionally small local tools, not Office/LibreOffice/Google compatibility products or a public mail/cloud-storage gateway. Native/background Drive sync, Tune playback, Vault autofill and the broader capsule composition are roadmap items.

The distinction is important: the developer desk is implemented, while the apps target servers for Sheet, Doc, Chart, Chat, Mail, Forge, Drive, Tune, List and Vault are currently boundary stubs. They provide health, require host-validated authentication for other requests, and then return 501. PicoDrive's CAS/revision API is documented but absent from its stub.

A completed-looking browser screen is therefore not evidence that its production capsule API, durable storage and cross-app identity work on PIOS. 2328

5. DaveAI and the hardware execution stack

5.1 Application, protocol and engine are separate responsibilities

DaveAI combines a browser workspace, PicoScript API admission policy, native host capabilities, DeveloperCLI/model-cli inference, and optional media/tool workers. Parts of the broader application still use Python orchestration; the native architecture direction is not a claim that migration is finished.

A versioned inference API defines model discovery, job submission, bounded NDJSON output, owner/conversation scope, cancellation, restart behavior and measured telemetry. A reference service and tests establish that seam without requiring working PIOS inference.

The QEMU portal prototype demonstrated actual EL0 asset streaming and real C-VM policy execution. Its dated record reports five API checks and 50 portal/stream checks, including byte identity, slow readers and disconnect recovery. However, it used an isolated kernel overlay; trusted sign-in, production storage, incremental TLS output and real inference were not established by that run. 23252627

5.2 The native model work is beyond a scaffold

The model-cli port contains tokenizer, GGUF, Qwen and several backend sources, compatibility/memory adapters and independent reference tooling. Later port notes supersede the old "no code ported" README.

The Falcon3-1B-Instruct-1.58bit lane has more concrete integration: authenticated model definitions and chunk hashes, Transfer readers, tokenizer worker protocol, CPU forward execution, compiled capsule calls and real FIFO/broker host fixtures. Host tests have produced exact checkpoint-backed responses through the broker encoder with simulated SD and scheduler events.

A historical incrementally linked QEMU CPU image returned Hello! How can; the run asserted a shorter prefix and the full response was manually compared. Clean-image repeatability and overlapping-request runs remained unresolved in later notes. This is limited software execution evidence, not a repeatable deployed service or a physical inference pass. 182329

5.3 Hardware layers and what has actually been proved

Hardware layerRoleRecorded evidence and current limit
Pi 5 ARM CPU/NEONKernel, native arithmetic and reference executionKernel hardware operation and NEON primitive checks exist; complete physical checkpoint/API acceptance remains open
VideoCore VII/QPUSelected tensor/media offloadsGuarded operations and representative batch profiles exist; generic model execution and Falcon provider interchange are not established
PCIe1 and switch fabricAttach discrete storage/computeEnumeration/recovery observations exist; discovering an endpoint is not execution authority
Intel Arc B50GuC/CCS/PPGTT native compute and emerging resident Falcon providerGuarded stores and a fixed tensor passed; current retirement, physical resident upload and full model gates remain open
Intel Arc B60Heterogeneous future compute targetEnumeration/capability observations are not a validated B60 model backend
NVMeHigher-capacity/faster storageA dated namespace block read/write and ring-wrap proof passed; filesystem integration and broader async/recovery acceptance remain distinct
SD/exFAT TransferCheckpoint interchange and verified source readsAsync source/upload implementation and fixtures exist; interoperability, power-cut and live throughput gates remain

On 10 November, a guarded B50 PPGTT tensor job matched all 16 outputs, guards and independent completion markers and published its result. The device remained quarantined because retirement/DMA safety was not established. Later runtime lease/fence changes have host tests but need their own physical validation. Earlier failed PPGTT attempts must not erase the later bounded pass; equally, that pass must not be promoted into full inference readiness. 29

The newer resident Falcon software path wires authenticated Transfer chunks to a generation-owned COPY_U32 uploader, resident projections, GPU KV state, attention and output-head dispatch. A complete forward-state mock covers all 18 layers and 1,366 head tiles. It proves orchestration wiring, not actual shader execution or generated answers on B50. 18

The recorded 18 November preflight found no B50 on the selected node and insufficient Transfer capacity: the three-file model bundle was approximately 1.377 GB, exceeding the approximately 1.333 GB partition by 44.7 MB before filesystem overhead. This is a dated deployment blocker, not a fresh claim about today's board. 29

5.4 Why accelerator completion is not enough

At least four facts must be proved separately:

  1. The right operation was admitted for the right owner/model/device generation.

  2. The device actually executed correct arithmetic and wrote visible output.

  3. The reported completion belongs to that operation, with guards intact.

  4. The device can no longer access resources before they are reused.

A timeout, cancellation, completion marker, clear AER status, or disabled bus-master bit is not by itself a resource-reclamation fence. This is the central challenge in converting bounded diagnostic GPU execution into a reusable multi-tenant model service. 181929

6. Engineering challenges and tradeoffs

Protecting progress under backpressure

Full FIFOs, lost re-arms, slow SD operations or a blocked core-0 callback can stall the entire chain. Tests need to exhaust real pools, retain work, return credit and prove progress without an unrelated timer or packet accidentally waking the system. Current transport convergence and polling-removal issues are directly relevant. 732

Keeping lifetime, cancellation and recovery consistent

HTTP disconnects, capsule exit, worker loss, device generations and storage leases must agree about who still owns memory. "Failed" is an application result; "safe to free" is a separate lifecycle fact. A recoverable appliance needs both graceful cancellation and conservative quarantine when proof is unavailable. 18192529

Making durability a checked result

CRC recovery detects torn records; durable callbacks make commits stable; consensus establishes replicated authority. None substitutes for another. Application revision changes, auth persistence and model-source mutation exclusion need to propagate the real commit/failure outcome rather than return success on an intermediate queue receipt. 17202632

Replacing infrastructure without inheriting its assurance

From-scratch TLS, authentication, SMB and storage implementations must interoperate with independent clients and survive malformed input. Known-answer crypto tests are more meaningful than self-round-trips; real SMB client mapping is more meaningful than a packet fixture. Current signing/identity and STS/cluster enforcement gaps prevent blanket security-readiness claims. This paper identifies acceptance boundaries, not a vulnerability audit. 7142932

Preserving one contract across multiple runtimes

C and browser PicoScript runtimes, generated assets, vendored crypto/replication copies and native/model adapters can drift. Exact upstream pins, local-delta records, numerical contracts and differential execution are essential. Blank licence fields and obsolete paths in the component manifest are release-engineering gaps, even when individual components build. 12132

Scaling beyond narrow memory and storage budgets

The kernel raw image, process arenas, tokenizer memory, model workspace, DMA windows and GPU local memory are different budgets. Optional packed application images help fit the boot slot, but do not solve runtime reservations. Some feature builds have approached the Pi raw-slot limit closely. Recent high-memory probing is useful but not exhaustive stress or proof that all DMA can reach that RAM. 1829

Selecting performance paths by workload, not label

Dispatch, data copies, synchronization, weight access and tiny workloads can erase GPU benefits. Fused batches and resident weights are the right direction, but must preserve the actual quantization and numerical contract. Generic INT4 support does not imply GGUF Q4_K compatibility; a supported header format does not imply a supported model architecture. 182335

Measurement discipline: PicoWeb's published Linux request-rate figures are not Pi 5 capsule measurements. The 19 November small HTTP-response baseline is not a bulk-transfer benchmark. Historical QPU profiles show workload-specific crossover, not general AI throughput. No current PicoSuite-wide latency, tokens/second, energy or cost claim is defensible from those measurements alone. 782935

7. Common features, searches, patterns and learnings

These focused searches were run against the follow-up baseline above. The examples below use rg from the repository root in PowerShell; they are starting points for inspection, not proof that all instances or all implementations have been found.

rg -n 'generation|capacity|producer|consumer' components\pios\include\service_fifo.h
rg -n -g '*.{h,c,md}' 'sync|incomplete|CRC|recover' components\picosuite\picowal\portable
rg -ni 'backpressure|continuation|FIFO|AIRQ' components\pios\docs\network_stack.md
rg -n -g '*.pc' 'ValidateToken|Principal|auth_bound|need_auth' services\picologin services\picoai services\picosearch
rg -n 'RESP_END|Resp\.End' components\pios\src\picovm.c
rg -n 'renderSafe|createIndex|aria-selected|disclosure|skipNav' components\baremetaljstools\src\BareMetal.Markdown.js components\baremetaljstools\src\BareMetal.Search.js components\baremetaljstools\src\BareMetal.Tabs.js components\baremetaljstools\src\BareMetal.Controls.js components\baremetaljstools\src\BareMetal.A11y.js
rg -ni 'host_tests|qemu|build_bootstrap' .github\workflows\ci.yml
FeatureObserved pattern and reusable learningBoundary or exception
Ownership and IPCFIFO descriptors carry owner, generation, length and capacity; producer and consumer indices occupy separately owned pages. Make authority, lifetime and publication rules explicit at the boundary. 9A descriptor contract does not prove that every bridge or cancellation path has converged on it.
Backpressure and progressThe documented network pipeline retains upstream work when downstream capacity is exhausted and records stall/resume diagnostics. Design for credit returning, not just the first successful enqueue. 7The cited host tests and documented path do not replace repeated physical acceptance or prove all legacy polling has disappeared.
Storage and recoveryPortable PicoWAL checks append records, exposes a sync durability boundary and marks exhausted derived indexes incomplete. Separate commit, recovery and query-completeness guarantees. 17The portable transaction unit is one put/delete; adapter correctness and physical persistence still need independent validation.
Identity and control flowPicoLogin explicitly returns after a failed token check. PicoAI and PicoSearch call a void need_auth() and then continue to their handlers; the inspected C VM's Resp.End hook itself returns without terminating the handler. Check the actual failure path and its side effects, not merely the presence of a validation call. 152236This is a source-level observation, not an end-to-end vulnerability test; other hosting paths may behave differently. Fail-closed route tests remain important.
Browser toolingThe toolkit exposes a safe Markdown renderer, an indexed search API, keyboard-aware tabs, disclosures and skip navigation. Compose small, accessible capabilities rather than assuming a framework is required. 37Accessibility, safe input handling and correct load order still depend on the consuming page. Client-side checks are not server authority.
Validation and releaseRoot CI explicitly runs kernel host tests and documents the missing Windows-hosted QEMU job. State exactly which stage each test covers and keep missing gates visible. 33Host-suite status cannot certify Pi builds, QEMU integration or physical-device behavior.

These are engineering observations, not a comprehensive security review. They illustrate how the same bounded-ownership discipline appears in multiple layers, while also showing why a common-looking helper or a passing fixture is not sufficient evidence of end-to-end behavior.

8. How far through is PicoSuite?

One percentage would obscure the actual risk: components can be locally complete while a cross-layer ownership or identity seam is unfinished.

AreaEvidence-based stageWhat is still needed
BareMetalJsToolsBroad implemented browser toolkitReproducible vendored-tree validation, release packaging and actual app journeys
Portable PicoWAL/search/codec/parser librariesImplemented bounded components with focused testsScope-specific interoperability, fuzzing, adapter durability and consuming-app integration
Linux PicoWebImplemented native server; historical deployment/performance reportsCurrent reproducible deployment evidence; distinguish optional protocol paths
Native PicoSTSImplemented auth/store/route componentComplete deployment, persistence failure, grant/revocation and provider integration evidence
PIOS kernelOperating hardware-backed development platformRemaining async/lifecycle work, clean reproducible release gates and current hardware regression
PIOS identity/cluster servicesContracts, source and test slicesProduction capability hosting, enrollment, mTLS, quorum storage and failover
PicoDeskImplemented local developer/productivity deskProduction single-origin auth/storage/capsule migration
Target apps serversAuthentication/health boundary stubsActual app routes and data, permissions, transactions and deployment
Native model engine/serviceExtensive port/provider/host integration; limited historical QEMU outputRepeatable clean CPU execution, concurrency, lifecycle and physical proof
Arc GPU model executionBounded physical tensor proof plus resident-model software wiringUpload, full numerical/semantic inference, retirement, device-loss recovery
Integrated PicoSuite applianceIntegration and acceptance stageAll required vertical slices, operations and release gates

Root CI currently runs the kernel host suite on Ubuntu. It does not supply root Pi/QEMU builds or QEMU smoke. The five latest returned workflow runs were failures dated 18 November; the inspected latest run failed at the host-test step. Those runs are not the reviewed HEAD, so they neither certify nor disprove this working tree. They do show that a current green, end-to-end automated release baseline cannot be assumed. 3233

The repository permits software completion and merges before batch hardware acceptance. Production release requires the full regression and outstanding hardware gates to pass. Hardware limits are therefore a validation queue, not permission to call an unverified feature complete. 129

9. Path to go: an acceptance-driven roadmap

The sequence below is a research recommendation within existing architectural direction, not a new commitment, architecture decision or calendar estimate. Independent component work can continue in parallel; dependency-sensitive features should graduate only after the named seam works.

MilestoneDeliverableExit evidenceRelevant current work
A. Reproducible platform baselineExact source/provenance/build map; current host gates; Pi/QEMU builds and genuine QEMU smokeClean snapshot builds, correct size/memory gates, real failing gates, preserved diagnostics#43, #255, #256
B. Shared authority and service lifecycleDurable identity, scoped grants, verified caller context, canonical service handoffs and safe retirementNegative grant/replay tests; revoke/exit/disconnect/full-queue tests; no unsafe reuse or success-before-sync#178, #258, #194, #260, #192
C. One productive application sliceSign in once, open two distinct capsules, save/reopen data through real storageActual Sheet/Doc/List API operations; permission separation; checked durable save; restart recovery; shared service mapExisting app/package plan; #170, #168
D. Repeatable CPU model serviceOne pinned checkpoint and tokenizer through the compiled capsule, FIFO broker and native providerIndependent exact output/intermediate comparison on a clean build; bounded cancellation, worker loss and overlapping requests#45, #167, #172
E. Resident B50 inferenceAuthenticated upload and a reusable resident model on one device generationFull file/component verification; all-layer/head coverage; exact reference answer; correlated markers/guards; safe retirement and loss handling#39, #191, #192, #195, #167, #41
F. DaveAI end-to-end integrationReal application tier consumes the proven inference service without sharing its failure domainVerified identity scope; real streamed output; cancellation/slow-client/restart journeys; measured queue/prefill/decode#14 and inference API contract
G. Cluster service graduationExplicit provisioning, enrollment, tenant discovery, three durable replicas and service routingFresh-node boot; mTLS; 2/3 durable commit; quorum-loss refusal; stale-writer fencing; replay and failover#44, #178, cluster hardware gates
H. Product and release expansionRemaining app APIs, selected native helpers and operational packagingReal app acceptance, full regression, all required physical gates, reviewed licence/provenance and recovery documentationApp plan and hardware gate ledger

For milestone E, the existing physical semantic target is deliberately concrete: the pinned Falcon checkpoint must answer "The capital of France is Paris." for the fixed chat-template prompt, with coverage for all 18 layers, seven projections and attention, plus all 1,366 output-head tiles per completed token on one B50 generation. Host mocks do not satisfy it. Start with a verified enumerated device and sufficient Transfer capacity, then use the build -> deploy -> live-verify loop. 1829

For milestone G, native Linux Raft/gossip source is valuable reference material, not proof of PIOS cluster implementation. The approved storage target requires one current-term writer, committed follower reads and three durable replicas with 2/3 majority. Gossip, DNS preference, VIP ownership or a local WAL write must never substitute for that authority. Authenticated replication records provide integrity/deduplication, not consensus by themselves. 101234

SMB must also graduate honestly: the current Transfer implementation advertises SMB2 2.0.2/2.1 with signing unsupported and a restricted development guest path while STS is unavailable. The target authenticated, signed SMB 3.1.1 cluster/file service is a separate future acceptance level, not the current share. Actual Windows/Linux client policy and file interoperability matter. 1229

After milestone C, wider applications can reuse the proven auth/storage seam. After D, DaveAI can exercise a truthful CPU backend while GPU work continues. Multi-GPU and heterogeneous serving should follow safe one-device retirement, not bypass it. This ordering maximizes useful integration while keeping the most dangerous resource-lifetime assumptions explicit.

10. Conclusion

PicoSuite's strongest idea is a coherent platform discipline: small reusable components, bounded execution, explicit ownership, durable state and capability-oriented services from hardware to browser.

The repository contains far more than a concept or collection of empty scaffolds. It also contains enough explicit gaps, failed experiments and partial proofs to make a blanket production claim inappropriate.

The next phase is primarily graduation of seams: from source to reproducible execution; from tested primitives to real services; from correct outputs to safe retirement; and from useful local tools to one authenticated, recoverable appliance. Completing those transitions will determine whether PicoSuite's architectural simplicity becomes operational simplicity.


Evidence index

Links resolve to the local repository documents/source unless explicitly marked as GitHub. They describe the reviewed evidence snapshot; moving documents and issue bodies may change after this date.

RefRepository evidence
[1]Platform overview, repository rules, component manifest
[2]Application capsule status, representative Sheet stub, application plan
[3]PicoDesk overview, PicoDesk ownership/instructions
[4]PIOS active platform policy, kernel overview
[5]PicoSuite libraries overview, actual CMake assembly
[6]Kernel system architecture, kernel execution contract
[7]Kernel network implementation
[8]PicoWeb implementation/route boundaries
[9]Service FIFO ABI and implementation
[10]Linux PicoCluster
[11]Linux PicoPod, PicoReplicate
[12]Approved service/cluster/identity architecture
[13]Kernel boot/storage architecture
[14]Native PicoSTS, public API, route implementation, tests
[15]PIOS PicoLogin
[16]PicoWeb userspace protocol status
[17]Portable PicoWAL, engine contract, engine tests
[18]Model-service execution and integration history
[19]Internal ModelFifo and production attachment boundary
[20]PicoWAL appliance/pack model
[21]PicoScript source-of-truth audit, shipped PIOS runtime map
[22]C VM contract, C VM implementation, host bindings, device design boundary
[23]Native DaveAI direction, native model port progress, text inference integration
[24]BareMetalJsTools, representative namespace/binding source
[25]DaveAI QEMU streamed-portal evidence and limitations
[26]Inference API v1
[27]Application/inference separation
[28]PicoDrive planned CAS API and current stub boundary
[29]Physical acceptance ledger and dated execution observations
[30]PicoCompress, PicoZstd, PicoParquet, PicoCrypto
[31]Lexical search, vector search, domain primitives, PicoJSON, PicoHTTP, PicoBlob source, PicoLog, PicoDNS, PicoDHCP, PicoPXE
[32]Current GitHub issue status: #43, #14, #45, #167, #191, #192, #194, #255, #256, #257, #258, #260, #261; inspected 20 November 2026
[33]Root CI definition, latest inspected failed host-test run
[34]Linux control-plane consensus contract, cluster ownership boundaries
[35]Tensor placement and current broker limits, canonical descriptor header, native tensor/QPU documentation, model-format inventory limitations
[36]PicoWatch service source, PicoAI service source, PicoSearch service source
[37]Markdown renderer, search index, tabs, disclosures, accessibility helpers