Start with a problem. Choose the smallest useful building block.

The cornerstone every other Magogi library stands on: typed exceptions, one central configuration object, structured logging with redaction, and tracing.

The engineering standard itself as an installable package: the rule corpus, the federation contract, and the generated library registry this site is built from.

A budget-aware, crash-survivable supervisor that drives pytest from the outside, so a hung or crashed test is recorded as an outcome instead of vanishing.

An async-aware Alembic helper for database schema migrations: one call configures the migration environment that otherwise takes a page of boilerplate.

REST API verification: typed probes that describe a request and its expected response, pluggable checks that emit structured findings, and suites that report.

Authentication verifier seams for federation services: a session verifier and a webhook verifier, a Clerk adapter, typed 401 errors and in-process test doubles.

Coaches a human through a timed physical procedure the software cannot perform itself, such as holding a button for a set time, one cue at a time.

The Qt presentation of a coaching run: a dialog rendering the cue stream through screen, sound and the accessibility bus for an operator whose hands are busy.

Django adapters for federation services: one app entry and two middlewares bring request ids, request context and JSON logging to an unchanged Django project.

FastAPI adapters for federation services: request ids, exception translation, lifespan wiring, webhook verification, IP allow-lists and a test-app helper.

A typed asynchronous HTTP client for the federation's Python services, with retries, timeouts, header redaction and tracing-aware logging.

A realtime push pipeline for services: server-sent event streaming, a pluggable pub/sub broker seam with a Redis adapter, and per-key connection caps.

Typed async SQLAlchemy plumbing for services: engine and pool defaults, session factories, Postgres row-level tenant scoping and cursor pagination.

VManager — end-to-end KVM/QEMU virtual-machine management for Linux: a typed core with a command-line tool and a desktop GUI over the same library.

The pure VM-domain core behind VManager: a state machine, an engine-neutral VM specification, the backend contracts, provided fakes and a conformance suite.

The Firecracker microVM adapter for VManager: a second hypervisor backend, planned to prove the engine-neutral contracts against a different engine.

VM forensics for VManager: packet-capture analyzers, case management and top-talker, DNS and TLS server-name extraction, kept apart from the VM engine core.

OVA and OVF interchange for VManager: it parses a portable appliance into the engine-neutral VM specification and exports one back to a portable archive.

The libvirt adapter for VManager: it implements the core hypervisor and storage contracts against libvirt, KVM and QEMU — wrapping libvirt, not marrying it.

The VManager client SDK: one client interface over an in-process transport for a single host, with a gRPC transport for a fleet to follow.

The VManager per-host agent: the component on each hypervisor host that brokers hardware to the control plane, starting with the device-passthrough seam.

The single source of truth for the VManager system: its architecture, component contracts, decision register and roadmap, end to end.

The desktop instrument for the hardware resource broker: device tree, leases, doctor checks, and an embedded command line in one PySide6 window.

The hardware resource broker: userspace arbitration of PCIe, USB, GPU and CPU resources — a Zig broker and a Python SDK talking over a Unix socket with no FFI.

The identity-continuity comparator: after a device re-enumerates and every handle to it changes, it estimates whether this is still the same physical device.

The shared Zig commons, and the home of the federation's Zig coding standard.

The capability engine: unforgeable rights whose attenuation can only ever shrink authority, with direct register access treated as its own distinct right.

The abstract kernel seam: nine operations with no Linux-specific nouns, plus a fake backend and a conformance suite that decides when a new backend is correct.

The broker's vocabulary as a leaf module on the Zig standard library alone: resource families, the resource-name type and matcher, claim modes and errors.

The runtime primitives behind the broker's reliability guarantees: a lock-free single-producer ring, file-descriptor passing and connection-liveness heartbeats.

The vendor-neutral telematics seam: a device-session contract, codec-agnostic record types, typed errors and a scripted mock that vendor packages build on.

The first vendor package on the telematics seam: a decoder for Teltonika Codec 8 and 8 Extended and a device-session provider for its FMB, FMC and FMM trackers.

The federation's cloud-resource interface: virtual machines, storage and networking on Infomaniak Public Cloud, driven from a CLI or a local web console.

Declarative, idempotent provisioning of the federation's self-hosted services, such as the package index and the CI host: plan, apply and destroy over a spec.

The cloud console: a local, single-user web front-end for viewing and managing cloud resources through the cloud-resource interface — not a hosted service.

A daily cloud-cost estimate with teeth: a scheduled job prices live cloud resources at published rates and fails when the monthly run-rate breaches a threshold.

The estate's runnable proof repository: an all-integer numerical core that digests identically across processor architectures, with its accuracy gaps on record.

The federation orchestrator: it runs the recurring cross-repo work — gates, releases in dependency-wave order, status and drift checks — across the whole fleet.

The federation dashboard: a read-mostly console over the fleet's recorded state. It reads state; it never authors it.

The federation-resources spine: the shared convention, schemas, manifest and sync engine that both consoles read state from.

Centralised log forwarding: a fail-open handler that sends canonical log records to a collector, so a logging outage never takes an application down with it.

The credential plane: a registry that declares every credential and stores no values, plus a read-only doctor proving declared, deployed and consumed agree.

Observable-behaviour UI testing for the desktop applications — the tier that exists because a broken button once shipped past a green suite.

Browser-level UI testing for the internal consoles, driving a real browser with an accessibility pass in the loop.

ProofWarden — the testing and CI authority console, where a per-project warden is the sole test executor and a test cannot run twice at once by construction.

The Foundation's knowledge base and brand: the canonical facts about Magogi, the business and legal procedures, and the brand identity from logo to palette.

The brand kit for Qt desktops: locked tokens, a generated stylesheet, self-hosted fonts, the icon set, marks, patterns and brand widgets in one package.

The brand-web kit as an installable package: tokenised CSS, components, self-hosted fonts, logo marks and patterns, so every web surface shares one source.

The Foundation's media library: provenance-bearing records of films, scores, renders and posters; git holds the record, object storage will hold the payload.

This site. It is in the registry like everything else, and it is built from the registry.

A cookiecutter template for Magogi marketing and showcase websites: a static site with the brand system on by default and a contact-form handler.

A platform for real-time conversation and structured debate — claims, citations and resolution states rather than a comment thread.

A design study for an IP-camera streaming and recording platform: the design suite and contract skeletons exist; the implementation does not.

A multi-tenant fleet-operations platform built on the vendor-neutral telematics seam.

The family's flagship consumer project: a verifiable weather node whose firmware provenance is re-derived rather than trusted.

The family's identity layer: the canonical reference for what sooth is, and its visual system.

The family's engineering standard: its rules, its philosophy, and the tooling that enforces them.

The kernel: deterministic and compliance-first, designed around explicit states, refusal, and provenance.

The GUI toolkit: a user interface as one readable text file with a mandatory semantic twin — no pixel is painted whose meaning has not been published.

Applied verifiable AI: a self-hosted, local-first, all-integer inference core that runs byte-identically twice.

The forge: it turns a kernel build into a provenance-bearing artifact for a board — provenance you re-derive rather than trust.

The language: a trust-first systems language whose compiler lowers to a pinned toolchain.

The provenance-bearing debugger: a separately built instrument for recording, replaying, and examining kernel decisions.

The trust-first mesh: networking work with explicit routing, trust, and provenance decisions.