**Sutra** is a typed, purely functional programming language whose compiled forward pass is a PyTorch neural network. The compiler beta-reduces the whole program — primitives, control flow, string I/O — to a single substrate-pure tensor-op dataflow graph over a frozen embedding substrate (every operation is a tensor op; the language has no scalar-readout escape hatch).
We report a previously undocumented defect in how the Ollama runtime serves mxbai-embed-large, one of the most widely used open-source text embedding models: on every release from **v0.14.
We verify **Sutra** — a typed, purely functional language — as a fixed **execution environment**: an instruction-set architecture whose *non-learned* trusted base (kernel roles and named critical programs, behaviour fixed at compile time) runs on a substrate that is, on its second compile target, genuinely **probabilistic** — a sampler that *settles into* the answer rather than computing it deterministically. The claim is narrow and per-contract; we do not claim to verify a learned component or a whole running system.
Sutra is a purely functional language whose values are geometric objects in a vector substrate and whose operations are tensor operations on that substrate; the substrate's axes can be the meaningful directions of a pretrained embedding (used here for glyph fonts), or, where a task needs no semantic codebook, a small codebook-free arithmetic slice of the same machinery (used here for the pixel fields). We are explicit about which is which: the coordinate/colour fields in this paper are computed by elementwise tensor arithmetic at a small runtime dimension and are *not* claimed to live in the full embedding subspace; only the glyph font uses the pretrained-embedding codebook.
A transformer with **analytically computed (untrained) weights** can execute arbitrary WebAssembly programs — Percepta's `transformer-vm`. We study this artifact as a **handcrafted, constructed-weight neural network that edits RAM to process WebAssembly**: attention is used as exact, content/location-addressed memory access, the feed-forward layers are the per-step compute, and the append-only token sequence together with a memory region is the machine's state.
Conventional operating systems treat the CPU as the brain and the GPU as an accelerator, and treat AI as something bolted on through serialization layers (text, JSON, tool-call schemas). For workloads where both **predictable latency under load** and **first-class local AI** matter — defense, aerospace, industrial control, medical devices, autonomous systems — neither inversion is paid for, but both costs are felt: GPU-resident models thrash against CPU-resident schedulers, and every round trip through the OS/AI boundary costs an embed/decode pair that drops information and adds jitter.
**Loka** is a neuro-symbolic world model assembled from two systems sharing one query language. The first is an RDF-star triplestore — explicit memory, exact answers.
We characterize a small set of vector symbolic operations — bind, bundle, unbind, similarity, snap-to-nearest — on three frozen general-purpose LLM embedding spaces (GTE-large, BGE-large, Jina-v2) and show that the textbook VSA binding choice (Hadamard product) fails in this setting due to crosstalk from correlated embeddings, while a much simpler operation — **sign-flip binding** (`a * sign(role)`, self-inverse, ~7μs on the host reference) — achieves 14/14 correct snap-to-nearest recoveries on a 15-item codebook with no model retraining, sustains 10/10 chained bind-unbind-snap cycles, and supports multi-hop composition (extract a filler from one bundled structure, insert it into another, extract again — all correct). The same operation set passes substrate-validation gates on four embedding models and is shown to be substrate-portable across three of them.
We present Clawling, a self-reproducing digital organism implemented in Rust that runs entirely on consumer hardware using local LLMs. Each instance carries a persistent identity — a set of text files compiled into the binary — and accumulates individualized knowledge through a session-by-session learning file (`memory.