← CESARops on Lemonade

CESARops on Lemonade: technical README

What each piece is, how it works inside, and how it connects to Lemonade. For a quick read, start with the table.

CESARops is a free search-and-rescue toolkit built by Thom Hadfield, a teacher. It runs on second-hand servers and local models. Lemonade is the layer that lets the same apps run on AMD, NVIDIA, Intel or plain CPU hardware.

Short version: most of this is not a wrapper around shell commands. It includes: - a ternary inference engine with hand-written AVX2/AVX-512 kernels; - a USB host for a neural-network stick that its vendor dropped, written from the protocol up; - about 2,000 lines of C++ in a Lemonade Nexus fork that change how Tier 1 servers prove their identity; - a native backend generator for Lemonade; - a GPU-federation control plane; - a coding pool that re-runs every test itself.

The few thin pieces (L-con, the Stand's install steps) are thin on purpose, and they are labelled as such below.

Sizes are lines of source code that we wrote (Rust, C++, Python, JS/TS; vendored code excluded), counted 2026-10-31. For the three forks, only our diff against upstream is counted.

              apps: Wayfinder · NautiK9 phone · L-con · Ori · the forge
                                    │  OpenAI-style HTTP
                                    ▼
   ┌──────────────────────── Lemonade (or Iced Lemon Cake) ────────────────────────┐
   │ built-in engines (llama.cpp ROCm/Vulkan/CUDA, Kokoro TTS …)                    │
   │ + engines from the Stand: lemonade-burn, ternlight, Ternary Bonsai, Strata     │
   │ + native backends from lemonade-engine-adapters                                │
   └───────────────┬───────────────────────────────────────────┬────────────────────┘
                   │ Tier 3 node                                │ adapter reports
                   ▼                                            ▼
        Lemonade Nexus mesh (between sites)         nauti-fabric / nauti-nodes (inside a site)
        operator-trust Tier 1 on Intel boxes        leases, capabilities, job routing

Where to look first (10 minutes)

1. lemonade-burn crates/ternary-kernels: the AVX-512 VNNI ternary GEMV, plus the correctness table against Hugging Face in docs/BENCHMARKS.md.
2. Nexus fork docs/Operator-Trust-Bootstrap.md, then the F4 evidence: 5 founders reached epoch 1 on ordinary Intel servers.
3. movidius-rust docs/USING_THE_STICK.md: SqueezeNet top-5 identical to Caffe fp32 on the CPU, about 34 ms per image.
4. The forge README "Principles": how it refuses to trust a model's own "tests passed".
5. The evidence table in the entry page: every number links to the raw run.

lemonade-burn (Nauti Ternary)

festeraeb/lemonade-burn · MIT OR Apache-2.0

Runs Microsoft's BitNet b1.58 2B4T, whose weights are all -1, 0 or +1, on an ordinary x86 CPU in about 2 GB of RAM.

Inside: - ternary-kernels: packed 2-bit ternary × int8 GEMV/GEMM, with a scalar reference and AVX2, AVX-512BW and AVX-512 VNNI versions. The reference keeps each SIMD path honest. - lb-ternary: weight packing, int8 activation quantisation and per-socket (NUMA) thread pools. - lb-model: the decoder, built on the Burn ML framework. - An OpenAI-compatible server.

Measured: - Correctness: top-1 agrees with Hugging Face float64 on 142 of 146 teacher-forced positions. HF's own float32 run agrees on 140. - Speed: on a 4-core Xeon E3 (AVX2), about 40–48 tok/s prefill and 7.7 tok/s decode.

With Lemonade: the Stand installs it in one click (tested through Playwright on Linux and Windows 11). A native backend is generated from engines/lemonade-burn.json; it builds but has not been run live.

movidius-rust (Bitter Lemons)

festeraeb/movidius-rust (v0.3.0; branch fix/0.3.1) · Apache-2.0

A pure-Rust host for the Intel Movidius Neural Compute Stick 1. OpenVINO dropped this stick; this keeps the hardware useful.

Inside: - USB boot: firmware upload; the stick re-enumerates from 03e7:2150 to 03e7:f63b. - The v1 command protocol, with every status reply checked against known states. - A graph-file builder and fp16 tensor I/O. - A daemon that resets the stick before each graph load, because loading on top of an old graph hangs it. - Uses no OpenVINO and no Intel host library. Only Intel's device firmware runs on the stick.

Measured: SqueezeNet v1.1 top-5 is identical to Caffe fp32 on the CPU (max difference 0.0032), at about 34 ms per image. The stick sets that speed.

Branch fix/0.3.1: gemm now runs on the stick. Weights are aligned to 64 bytes, because SPARC traps on a misaligned word load. Results match the CPU fp16 reference at three sizes.

With Lemonade: serve speaks Lemonade's API shape: - GET /v1/models lists a vision_graph; - chat answers 501; - the work is POST /v1/infer.

Lemonade Nexus fork: operator trust

festeraeb/lemonade-nexus, branch cesarops/operator-trust · MIT (upstream's licence)

Nexus Tier 1 servers must prove themselves with AMD SEV-SNP. Ordinary Intel servers without SEV-SNP, TDX or TPM can never form a Nexus network. Many schools and rescue teams are in that position.

Inside (about 2,000 lines of C++ against upstream): - A build option, off by default. - With it on, the operator creates a root key and signs each server in. A server answers the Tier 1 challenge with that signature instead of a hardware report. - The rest of the protocol (founders, quorum, epochs, gossip) is unchanged. - Tests: 18 pass in the default build and 20 with the option on.

Measured: an anchor plus 5 founders on 4 Intel machines gave 5 PASSED verdicts, and all 5 reached epoch 1 (evidence F4). With one founder offline, commits continue (F2).

Stated plainly: with this option, Tier 1 is exactly as trustworthy as the operator's key and the machines the operator chose. Nothing is measured, and it is not hardware security.

Iced Lemon Cake (our Lemonade fork)

festeraeb/lemonade-iced-lemcake, branch iced-lemcake/nexus-tier3-2026-10-30 · Apache-2.0

Lemonade 2026.43.x, plus about 2,500 lines on the Tier 3 branch.

Inside: - lemond loads the Nexus SDK at run time and joins the mesh as a Tier 3 inference node. It pins the Genesis key and retries as an enrolled peer. - The mesh port 127.0.0.1:13306 looks like a single Lemonade to a client. If the chosen device does not answer, the request is re-sent once to the next device serving that model. - Backends for lemonade-burn and for Cake. Cake is never bundled: it is fetched only if the user picks it and accepts its own licence. - Branch iced-lemcake/movidius-rea-2026-10-29 adds movidius and rea backends.

Measured, failover: a backend was stopped and restarted mid-run, and 47 of 47 requests were answered, with one automatic re-send. Before the fix, 7 of 20 were answered.

lemonade-engine-adapters

festeraeb/lemonade-engine-adapters · Apache-2.0

The Rust tool make-adapter turns one JSON spec per engine into a native Lemonade backend. It writes the C++ backend source and adds the LEMON_BACKENDS line to the fork's CMake.

What the generated backend does: - Finds the engine binary; if it is missing, that is an error, never faked. - Starts the engine from a templated command line ({model}, {port}, {device}). - Waits for the ready route and an optional JSON readiness value. - Checks owned_by in /v1/models, and stops the engine if it doesn't match.

Verified: FreeToken on an RTX 2060 through the fork's lemond: pull, pinned load, chat at 44–47 tok/s decode, and an unload that frees the card. The Rust tool's output is byte-identical to the original Python generator's.

nauti-nodes

festeraeb/nauti-nodes, branch feat/nexus-peer-identity · AGPL-3.0

A control plane that lets mixed GPU machines (RTX 2060, GTX 1070, P100, M2200 and others) federate.

Inside: - An Axum coordinator with worker registration, heartbeats, quotas, job routing and cancellation. - OpenAI-compatible streamed inference back to the client. - A Lemonade probe that reads the server version from /api/v1/health. - A self-endpoint loop guard.

New: a worker's identity comes from its Nexus mesh peer, not from anything it writes in the request. - An attributed join returns 200. - Forged headers or body return 403 (evidence B1, B2).

Nauti-Virtualizer / nauti-fabric

festeraeb/Nauti-Virtualizer · Apache-2.0

The resource fabric inside one site.

Inside: - A resource registry and host inventory. - Capability filtering and exclusive leases. - Authorised adapter attachment and structured events. - A rust-vmm guest-memory allocation boundary. - An Iroh/QUIC agent (cesarops-nauti-agent), running on three of our servers. - A Lemonade adapter that reports which models each node is actually serving. It asks Lemonade rather than reading a config file, and works on any GPU brand.

The plan is fabric inside a site and Nexus between sites.

NautiBurn

festeraeb/NautiBurn · Apache-2.0

What it does: NautiBurn records which experts a Mixture-of-Experts model picks at each layer for each token. It does this inside the engines we run, with a scraper built into each one, and stores histograms. Predictors (nautiburn-shadow) then name the experts likely needed at the next layer, before the model's own router picks them, and score themselves against the scrape.

Why it matters: this is groundwork for placing hot experts on small GPUs and the rest on the CPU.

Status: it only measures and predicts. It does not yet move weights.

Wayfinder

festeraeb/Wayfinder, branch wayfinder/s2-bundle-2026-10-29 · Apache-2.0

A file organiser for students and developers with ADHD.

Inside: - Semantic search over a local index (Lemonade embeddings). - A git helper. - The save-prompter crate: Mr. Clippy is sarcastic about the file, never the person. The L-con slider caps how sharp he gets, and he softens as you save well. Git Clippy has four moods: chill, nudge, warning, panic.

With Lemonade: - All chat and embeddings go through Lemonade. - Check Lemonade names the step that fails. - The end-to-end suite passed 12 of 12 through the Nexus mesh.

The forge

festeraeb/cesarops-forge · Apache-2.0

A multi-lane AI coding pool.

How a job runs: - Each job starts from a seeded failing test, proven first with a reference implementation. - The next free lane (a coder plus a reviewer) takes the job. - The pool re-runs the tests itself on the final branch, in a throwaway worktree. A lane's own "tests passed" is never trusted. - A lane that edits a file outside its task fails, even if the tests then pass. - A failed job rotates to lanes it hasn't tried, and each retry is shown the real error from the last attempt.

With Lemonade: Lemonade is the default backend (seats are Lemonade model ids), and Paddler is an optional fallback. It wrote L-con's API-key feature against seeded tests: 71 of 71 passed after the reviewer's polish.

lemonade-ori-harness

festeraeb/lemonade-ori-harness · Apache-2.0

What it is: a Rust agent harness with a tool loop, an embedded web UI and an MCP server (stdio and HTTP), so editors and desktop agents can call it. A --bench mode prints a throughput scorecard from the local Lemonade.

New: a pool of up to 5 NIM endpoints, and a spawn_subagents tool that fans out up to 20 subtasks with a harness-wide cap of 1 to 5 at once (tested live: 4 tasks, 2 at a time, 1.7 s).

Limits: the action tier is Linux-only, because it uses setpriv to drop privileges.

Nauti-Monitor

festeraeb/Nauti-Monitor, branch fix/lemonade-stats-2026-10-21 · Apache-2.0

What it is: a telemetry daemon with an MCP surface (JSON-RPC 2.0 over stdio and HTTP) and a Dioxus WASM HUD.

Inside: - Multi-vendor GPU stats through all-smi, with a sysfs fallback for AMD Polaris cards. - Network rates from physical NICs only.

With Lemonade: it reads Lemonade's models, health and stats live, and never invents a number when Lemonade is unreachable.

NautiK9

festeraeb/nautik9, branch android-app-2026-10-28 · Apache-2.0

What it is: a notes vault (SQLite, with [[links]] and #tags) and an assistant server with a phone-friendly UI. Its design is rewritten from Jade Vault (MIT).

Inside: - An ordered chain of model providers. - Token-gated APIs. - SMS reply drafts. The phone's own composer sends them only after you approve; NautiK9 never sends by itself.

With Lemonade: the default first provider is the local Lemonade.

ternlight-server

festeraeb/ternlight-server · Apache-2.0 (vendored engine and model are MIT)

What it is: an OpenAI-compatible embeddings server for the ternlight ternary sentence-embedding model (384 dimensions), running on CPU with the model built into the program.

How it handles long text: it cuts the text into 400-character windows (at most 16), embeds them, averages and normalises. The engine is vendored; the server, the windowing and the release builds are ours.

With Lemonade: register it with lemonade cloud install ternlight --base-url ….

NautiK9 Lemonade Stand (lemonade-engines)

festeraeb/lemonade-engines · MIT OR Apache-2.0

What it is: a local page that adds engines to the Lemonade you already run. Set up downloads the engine, checks its sha256, starts it, registers it with Lemonade and asks it one test question, showing each step. Lemonade itself is not modified.

Thin on purpose: it orchestrates; the engines do the work. Getting there took: - portable builds (glibc 2.30) for 4 platforms; - licence-acceptance records for engines that need them; - stopping an engine's whole process tree on Windows; - zip unpacking with size checks.

Tested: driven through Playwright on Linux and Windows 11.

L-con (cognitive contract)

festeraeb/lemonade-cognitive-contract-l-con, branch claude/lcon-lc123-2026-10-25 · MIT

A zero-dependency Node proxy in front of Lemonade.

What it does: - Four sliders and a notes box become a session policy of about 170 tokens: tone, ADHD scaffolding, and how to read self-deprecating jokes. - That policy is added to every chat, so any OpenAI-style app gets it without changes. - A model-side profile picks steering text by model name.

Thin on purpose: it adds 3–5 ms per request, which is why it stayed in Node and was not ported to Rust. 71 tests pass, including a new upstream API-key feature: the key never appears in its API, state file or logs.

PolyStrata

festeraeb/PolyStrata, branch compat/pascal-sm60-cublas-avx · MIT

Upstream's part: a fork of an upstream MoE engine that keeps hot experts on the GPU and the rest on the CPU.

Our part (small): it now builds and runs on a Tesla P100 (sm_60, cuBLAS) and on AVX-only CPUs. We also wrote docs/LEMONADE.md on registering it as a Lemonade provider. This entry cites no PolyStrata speed of its own.

Honest limits (short)

• Each repo's default branch carries the work described here (2026-10-31); the branch names above are where it was developed.
• The operator-trust mode ran for about a day, on one LAN. It is not upstream and not hardware security.
• The Movidius stick runs classic compiled CNNs; there is no detector network for it yet.
• The full list is in the entry page under "Honest limits".

Written with Claude from Thom Hadfield's direction; Thom is dyslexic. Counts and claims were checked against the repos and the evidence folders on 2026-10-31.