Rust kit ecosystem for production services: built to one gate matrix: build --locked, clippy -D warnings, cargo-deny, cargo-audit, llvm-cov thresholds, cargo-semver-checks, loom and miri where applicable, cargo-vet, release provenance. The estate composes as a system: estate-integration is the cross-crate proof.

The products and most crates run in production for my own businesses; estate-integration is the CI proof that the crates they are built from compose and pass the same gates daily.

The index below is complete. Every public repository appears exactly once under exactly one heading; every entry links to its repository, and each description is that repository's own metadata. Private repositories are listed by name only. Counts per heading are stated so completeness is checkable at a glance.

• ferro: Self-hosted file storage platform: WebDAV (Class 1/2/3), CalDAV/CardDAV, OIDC auth, S3-compatible backends, full-text search, WASM processing workers. Single binary, docker compose up.
• clawdius: Remote agentic coding with a WASM sandbox and OS-level bubblewrap isolation: agents can read what they need and cannot write to the system.
• aileron: Keyboard-driven web environment for developers: native tiling, Lua configuration, zero-extension ad blocking, and a built-in MCP server so LLMs can see the web. Powered by Servo.
• chisel-doc: Industrial-hardening fork of PdfCraft: a PDF reader and editor written from scratch in pure Rust, built to a defined gate matrix.
• aperture-vault: Photo and video vault: single binary, content-addressed storage, Immich-compatible API, faster ingest with less overhead.
• CivitForge: Federated software forge built for petabyte scale: Actions running on Kubernetes pods.

• axum-stack (crate): Axum server utilities: shutdown, CORS, request ID, health routes, middleware stack.
• axum-server: Axum server utilities: shutdown, CORS, request ID, health routes, middleware stack.
• json-envelope (crate): Standard API response envelope for Rust services.
• http-error: Derive macro for mapping error enums to HTTP status codes.
• app-error: Common application error variants with recovery classification.
• errcode: Structured error handling for Rust: derive macros for error codes, HTTP status mapping, and RFC 7807 Problem Details.
• api-types (crate): Standard API response types for Rust: Success, Error, and List wrappers with OpenAPI derives and RFC 7807 Problem Details.
• validkit (crate): Unified input validation: typed newtypes for email, URL, phone, cron, tenant, locale with proptest.
• paginate: Pagination types for Rust APIs: offset-based and cursor-based pagination with OpenAPI support.
• envstack (crate): Layered configuration for Rust: environment variables, TOML files, and CLI args with type-safe extraction and validation.
• config-kit (crate): Layered typed configuration for Rust: file → env → overrides with unknown-field denial, secret redaction, and hot reload.
• fetch-kit (crate): Resilient HTTP client for Rust: retry, circuit breaker, connection pooling, and typed JSON helpers built on reqwest, with a native middleware stack that mirrors the reqwest-middleware shape.
• ratelimit: Rate limiting for Rust: GCRA (Generic Cell Rate Algorithm) with pluggable.
• idempotency-kit (crate): Idempotency keys for Rust: scoped BLAKE3 key derivation, TTL claims with response replay, pluggable memory/redis stores.
• outbox-kit (crate): Transactional outbox for Rust: durable event envelopes, at-least-once dispatch with breaker-aware backoff, replay after restart.
• webhookkit (crate): Verify webhook signatures in Rust: with a nostd-compatible core.
• ws-kit (crate): Generic authenticated typed WebSocket: BroadcastHub, RoomManager, heartbeat.
• uds-kit (crate): Timeout-aware Unix domain socket connect/read/write helpers for Tokio: transport-only, protocol-agnostic.
• eventbus: Async event bus for Rust: typed pub/sub with optional persistence, replay, and wildcard subscriptions.
• worker-kit (crate): Periodic job scheduling for Rust services: jittered intervals, graceful drain, breaker-aware failure budgets, optional leader election.
• healthkit (crate): Health check endpoints for Rust: liveness, readiness, and startup probes with dependency checking for Kubernetes and Docker.
• geo-kit (crate): Typed newtypes for validated geo primitives: postcodes, country codes, coordinates, addresses.
• Private: deploy-webhook-rs, eventbusd.

• tokenkit (crate): Type-safe JWT encode/decode for Rust with configurable validation, secret rotation, key rotation, and revocation support.
• oauth-toolkit (crate): Shared OAuth2/OIDC primitives: crypto, PKCE, scopes, CSRF, social login, OIDC, JWKS validation.
• webauthn-kit (crate): Standalone WebAuthn/FIDO2 passkey verification kit for Rust: CTAP2 parsing, COSE ES256/RS256 via ring, replay/freshness protection, sign-count clone detection. No storage, no framework.
• scim-kit (crate): Self-contained SCIM 2.0 (RFC 7644) provisioning types, stores, and optional axum router.
• accessctl (crate): Role-based access control for Rust: Cedar policy engine integration with typed roles and Axum middleware.
• auditlog: Tamper-evident audit logging for Rust: SHA-256 chain, immutable entries, and queryable audit trail.
• policy-kit (crate): Fail-closed Rego policy evaluation for Rust: bundle loading, dialect auto-detect, typed verdicts.
• salting (crate): Opinionated Argon2id password hashing for Rust with OWASP-recommended defaults.
• cryptkit (crate): Cryptographic primitives for Rust: HMAC-SHA256, AES-GCM, constant-time comparison, and secure random with zeroize.
• typed-id: Type-safe ID newtypes via derive macro.
• Private: authbox.

• blobkit (crate): Typed object storage: BlobStore trait with S3/Local/Memory backends, audit, presigned URLs.
• cas-kit (crate): Content-addressed blob store: BLAKE3 addressing, 2-hex bucketing, optional Zstd, packfiles, verify-on-read. Extracted from Suture.
• delta-kit (crate): Binary delta codec: Rabin rolling-hash copy/insert opcodes, prefix/suffix fast-path, binary-safe. Extracted from Suture.
• crawlkit: Site crawl kit.
• crawlkit-testbed: Ground-truth conformance testbed for crawlkit: a site with planted, documented defects, and a scorer that measures precision and recall against them.
• tantivy-ext: Full-text search for Rust: Tantivy wrapper with autocomplete, highlighting, and typed queries.
• crdts-kit (crate): CRDT toolkit: RGA replicated string with tombstones, participant presence, serde + wasm support.
• shared-state (crate): Concurrent state utilities: readiness gates, TTL caches, shared counters, type aliases.
• poolkit (crate): Database connection pooling for Rust: SQLx wrapper with health checks, lazy connections, test containers, and metrics.
• slab-pool (crate): Lock-free slab object pool: tagged-pointer ABA protection, RAII guards, loom+miri verified.
• shm-rings (crate): Lock-free shared-memory SPMC ring: power-of-two masked, cache-line aligned, zero SeqCst, loom+miri verified.
• cachekit: Unified caching for Rust: in-memory (moka) and Redis backends with TTL, stale-while-revalidate, and eviction listeners.
• crdt-demo: Live multi-user CRDT demo: crdts-kit + ws-kit, single binary, open two tabs and watch edits converge.
• signalkit (crate): Snapshot, store, and score any counter: subjects/observations engine + engagement-integrity signals.

• metrics-kit (crate): Lock-free Prometheus-exposition metrics kit: counters, gauges, histograms with cache-line padding, cardinality guards, VictoriaMetrics/Grafana-compatible output.
• telemetry-init (crate): One-call observability bootstrap for Rust services: tracing + metrics + OTLP wired with estate defaults.
• otelkit (crate): Tracing and telemetry initialization for Rust: OpenTelemetry, OTLP export, Sentry integration, and structured logging.
• otel-stack (crate): OpenTelemetry integration for Rust: unified tracing, metrics, and OTLP export with version-pinned dependencies.
• observability-assets: Central VictoriaMetrics + Grafana assets for every shipping WyattAu build: scrape configs, vmalert rules, dashboards.
• clock-kit (crate): Time-source abstraction for Rust: monotonic/wall separation, TSC calibration, PTP quality detection, deterministic test clock.
• clock: Trait-based time abstraction with mock clock for testing.
• percentile-kit (crate): Latency percentile tracking and budget gates for Rust: P50/P99 from criterion output, committed budgets, CI regression enforcement.
• hw-kit (crate): Hardware topology and control for Rust: CPU/NUMA discovery, core pinning, NUMA binding, hugepage reservation (Linux).
• uring-kit (crate): Reusable io_uring socket substrate: ring lifecycle, registered buffers, zero-copy socket ops (Linux).

• retry-backoff: Generic async retry with exponential backoff and jitter.
• chaos-kit (crate): Deterministic fault injection for Rust tests: latency, errors, partitions, and resource starvation with seeded scheduling.
• testkit: Shared test utilities for Rust: test databases, HTTP servers, auth helpers, and assertions.
• kit-conformance: Shared conformance harness for the WyattAu Rust kit ecosystem.
• graceful: Graceful shutdown for Rust services: signal handling, connection draining, and RAII cleanup guards.
• breaker (crate): Async circuit breaker for Rust: sliding-window failure-rate tripping,.
• pid-manager (crate): PID file management with RAII cleanup and process liveness checks.
• mcp-doctor: Audit an OpenCode MCP fleet: config, backends, credential entitlement, and real MCP handshakes.
• flag-kit (crate): Feature flags: FlagSet rollout, targeting, audit, OTel.
• flaglab: Audit feature flags across repos and emit reviewable removal candidates (Piranha's missing orchestrator).
• sieve-kit (crate): Rule-based mail filtering engine: conditions, actions, bounded regex evaluation.
• actor-kit (crate): Work-stealing actor runtime: OTP supervision trees, crossbeam work-stealing, bounded backpressure.
• tui-actions (crate): Terminal action/keymap layer for Rust: chord parsing (ctrl+s, leader sequences), modal context stacks, conflict and unbound-key detection, help rows derived from the live keymap. No terminal dependency.
• Private: flagsd.

• money: Money types for Rust: CurrencyAmount with Decimal precision, multi-currency support, FX conversion, and formatting.
• ledger-kit (crate): Double-entry ledger for Rust: decimal-money postings, outbox-backed journal, idempotent posting, tamper-evident history.
• double-entry (crate): Immutable double-entry accounting core: append-only journals, balanced posting, period close, reversal by counter-entry.
• invoice-kit (crate): Accounts-receivable invoicing for an SME ledger: three orthogonal document states, Peppol/EN 16931 arithmetic, per-jurisdiction rounding policy.
• ap-kit (crate): Accounts payable: supplier bills, input VAT recoverability, and the three-way split between payable, deductible tax and expense.
• vat-rules (crate): Tax categories, exemption codes, document types and rounding regimes shared by the AR and AP sides of an accounting ledger.
• billing-kit (crate): Billing primitives: Price with tax/discount, re-exporting decimal-money CurrencyAmount.
• book-kit (crate): Lock-free limit order book: price-time priority, single-writer/multi-reader snapshots, zero-allocation hot path, loom-verified.
• hdwallet: HD wallet for Rust: BIP32/39/44 derivation with multi-chain address generation (BTC, ETH, SOL, TRON).
• recon-kit (crate): Bank statement types and a matching engine for reconciling statements against a ledger: no format parsing, no floats, no silent auto-matching.
• report-kit (crate): Trial balance and aging reports over a double-entry ledger: per-currency by construction, with the accounting equation as a runtime check.
• statement-ofx: OFX bank statement adapter producing recon-kit Statements: sign-normalising, float-free amounts, zero dependencies beyond the model.
• vat-return: VAT return boxes from AR invoices and AP bills: deductible-only input tax, per-currency, tax-point filtered.

• a2l-parse (crate): ASAP2/A2L ECU description parser: PROJECT/MODULE/CHARACTERISTIC/MEASUREMENT/RECORD_LAYOUT/COMPU_METHOD, calibration data model.
• cal-model (crate): A2L calibration data model and session layer: characteristic binding, COMPU_METHOD conversions, limit validation, curve calibration.
• dbc-parse (crate): DBC file parser: CAN message definitions, signal layout (bit-offset/length/endianness/scaling), value tables, extended multiplexing.
• can-core (crate): CAN 2.0 and CAN FD frame codec: identifier parsing, DLC handling, bit-timing calculation.
• xcp-core (crate): XCP on CAN: Universal Measurement and Calibration Protocol: commands, responses, DAQ lists.
• id3-core (crate): ID3v1/ID3v2 audio tag reader and writer for Rust: CHAP/CTOC chapters, APIC art, no_std.
• mp4-core (crate): ISO-BMFF (MP4/M4A/M4B) box reader and writer for Rust: ilst metadata, chpl chapters, no_std.
• cuesheet-core: CDRWIN cue sheet reader and writer: tracks, indices, MM:SS:FF at 75 fps, CD-TEXT, no_std.
• font-parse (crate): SFNT/OTF/TrueType/WOFF/WOFF2 binary font parser: offset tables, character maps, glyph outlines, variable fonts.
• font-model (crate): Typed owned editable font model: glyph outlines, cmap formats 4 and 12, metrics, validation, subsetting.
• font-shape (crate): Glyph rasterization and text measurement: scanline fill, stroke expansion,.
• font-conformance: Independent differential oracle for the estate text stack: font-parse vs fontations, font-shape vs the rival rasterizers, Err-not-panic over a hostile corpus.
• sheet-core (crate): Spreadsheet data model: sparse cells, dependency DAG, topological order, formula reference extraction.
• sheet-engine (crate): Spreadsheet calculation engine: dependency-driven incremental recalculation, Excel-compatible semantics, volatile function tracking.
• sheet-xlsx (crate): XLSX codec: workbook, worksheets, shared strings, styles, calc chain.
• formula-lang (crate): Spreadsheet formula language: tokenizer, Pratt parser, AST, evaluator core. Excel-compatible function semantics.
• audiobook-core (crate): Audiobook domain model for Rust: format-independent titles, parts and chapters from MP3 and M4B.
• audiobook-conformance: Conformance harness for the WyattAu audiobook stack: cross-checks mp4-core/id3-core/audiobook-core against ffmpeg and ffprobe.
• audiobook-shelf: Audiobook-first library manager: decides which files form one book, orders them by disc then track, parses the folder-name conventions a library is actually named with, and reports what is inconsistent.
• ldir: LDIR (Low-level document intermediate representation), a universal document that compiles from an IR lang.
• wire-kit (crate): Zero-copy binary wire codecs: SBE block encoding and FIX 4.4 tag=value, bounds-checked, allocation-free decode, SIMD-assisted scanning.
• sensors_rpi_pico.

• dsp-core (crate): Foundational audio DSP primitives: biquad filters, FFT, convolution, windowing, dynamics, oscillators: allocation-free process paths.
• dsp-spectral (crate): Spectral audio analysis and restoration: STFT/ISTFT, mel/MFCC features, spectral gating, HPSS source separation.
• media-kit (crate): Full image pipeline: sniff, meta, resize, encode, composite, variants with bomb-guard and async support.

• plychart (crate): High-performance WASM charting library for Rust.
• leptos-stale-indicator (crate): Data freshness indicator for Leptos: shows LIVE/DATA STALE status based on fetch timestamps.
• leptos-map-search (crate): Map search/typeahead component for Leptos: filter and select countries with keyboard navigation.
• leptos-sparkline (crate): Leptos component (see repo).
• leptos-capital-markers (crate): Capital city markers for leptos-leaflet: renders weather-aware markers on a Leaflet map.
• leptos-crypto-ws (crate): Leptos component (see repo).
• leptos-leaflet: Leptos components for Leaflet.js maps. Provides a declarative, reactive API for building interactive maps in Rust/WASM with Leptos.
• leptos-macro: Procedural macros for Leptos components: boilerplate reduction for lib.rs, feature flags, and prop defaults.
• theme-kit (crate): Typed design-token contract for the estate: DTCG 2025.10 in/out, semantic role vocabulary, build-failing WCAG contrast gate, derived CVD/high-contrast/monochrome variants, data-only emitters (CSS, VS Code, ANSI-16).
• theme-egui (crate): egui/epaint lowering for theme-kit: the adapter that makes the estate token contract real in chisel-doc, chisel-platform's future front-end, and any egui app. One file of placement, zero colour maths.
• shroom-theme: VS Code colour theme with 7 variants: dark, light, high-contrast, monochrome, and 3 dichromacy adaptations (deuteranopia, protanopia, tritanopia). 1049 tokens, alpha-composited WCAG 2.1 AA, APCA lightness separation, CVD simulation in linear RGB.
• a11y-kit (crate): Accessibility semantics layer for the estate: platform-free semantic node model (role, name, states, relations), tree audit as a CI gate, AccessKit conversion behind a feature. The layer nobody funds, owned.
• color-kit (crate): Colour science leaf for Rust: linear-sRGB core, Oklab/OkLCH, WCAG 2.1 AA contrast, perceptual lightness contrast, dichromat simulation, deterministic quantisation. no_std.
• tauri-preset: Shared Tauri v2 configuration presets for window, bundle, and security settings.
• i18n-kit: Runtime i18n for Rust: BCP 47 locales, flat catalogs with dot-notation keys, fallback chains, interpolation, simple pluralization.
• polyfont: A multi font plugin for vscode and other editors.
• tao.
• tauri.
• wry.
• input-kit (crate): Toolkit-neutral text-composition semantics for Rust: IME preedit state machine, grapheme-cluster caret mapping, and dead-key composition. Pure logic, no windowing or widget dependency.
• ui-text-edit (crate): Text-field semantics for Rust GUIs: a buffer-agnostic TextBuffer, a grapheme-correct caret/selection/edit model, and an a11y-state bridge. Composes input-kit for IME. Not a code editor.

• pediment: Shared design tokens, components, hooks, and utilities for Astro+SolidJS+Starlight+Cloudflare projects.
• starlight-sites: Wyatt's Notes new site with starlight.
• starlight-kit: Starlight plugin development kit: shared configuration, plugin factory, and boilerplate for Astro/Starlight plugins.
• starlight-progress: Starlight plugin providing a reading progress bar and collapsible TOC sidebar.
• starlight-katex: Write $E = mc^2$ in any page. Get server-rendered KaTeX, automatic dark mode, and zero client-side JavaScript.
• starlight-content-guard: Starlight plugin and CLI for comprehensive content validation at scale.
• starlight-multi-site: CLI tool and shared config factory for managing multiple Starlight documentation sites from a single monorepo.
• starlight-interactive-islands: Dont know why theres no standardized plugin.
• starlight-cross-domain-sync: Starlight plugin to synchronize the dark/light theme preference across subdomains via cookies and BroadcastChannel.
• starlight-dse-test: DSE study and test platform built with Astro Starlight.
• docs-core (crate): Rust docs pipeline core: CommonMark+GFM to static HTML with astro-island-compatible island emission, so a Rust shell hydrates the estate's existing SolidJS bundles. Consolidates Tachyon + docs-pipeline + the starlight-* stack (ADR-0004 §2.5).
• docs-pipeline (crate): Markdown rendering and tree-sitter syntax highlighting pipeline for documentation sites.
• Tachyon: JIT documentation server with internal developer portal, the build step latency inherently in traditional SSG can be eliminated by reactive file watching on the host file system, while still able to compile as SSG if needed.
• hydrated-personal-site: High-performance personal site and intelligence dashboard. Astro 5 + SolidJS 1.9 + Tailwind CSS 4 + Rust/WASM widgets, deployed to Cloudflare Pages and Workers.
• WyattsNotes: Deprecated, new repo at https://github.com/WyattAu/starlight-sites. A list of personal notes modified for public use, require a high degree of contributions to polish.
• forgeyard: Standardized repository templates with CI/CD for Rust, Astro+SolidJS, Starlight, and TypeScript projects.
• cf-worker-utils: Cloudflare Workers utilities: SWR cache, circuit breaker, rate limiter, security headers, and structured logging.
• estate-site: The WyattAu estate index: built by the estate's own docs engine.
• pele-rehype: Rehype plugin: render mermaid fences with Pele in Astro/Starlight (fast, CSS-variable themable SVG).

• model-router (crate): Cost-aware LLM routing core: per-model pricing, USD budget tracking, task-class routing with fallback chains.
• simd-tokenizer (crate): Safe SWAR-accelerated whitespace token estimator with optional exact tiktoken backend.
• latent-oracle: Searchless neural chess research engine: strictly 0-ply policy with symbolic invariants.
• latent-oracle-data: Data pipeline for latent-oracle: Lichess PGN to shards to Stockfish labels.
• ironclaw: Fork of nearai/ironclaw: WyattAu staging with validkit adoption and clippy fixes.
• morph: The specification for a agentic programming language.
• contact-miner (crate): Multi-engine web contact discovery: emails, phones, WhatsApp/Telegram/Signal handles from public pages.
• trendkit (crate): Dev-trend crawler in Rust: GitHub/HN/crates.io snapshots, velocity scoring, personal relevance, Telegram digest.
• comfyui-kit (crate): Typed Rust client for the ComfyUI HTTP API: queue workflows, track history, fetch generations.
• skillkit (crate): Tooling for the agent-skill economy: lint, package, verify, and audit SKILL.md skills.

• mailkit (crate): Email delivery for Rust: SMTP, Resend, AWS SES, SendGrid, and Postmark.
• mail-sync-kit (crate): Protocol-agnostic mail sync engines: IMAP (QRESYNC/CONDSTORE/IDLE), JMAP, SMTP submission (XOAUTH2), outbox queue.
• barbican (crate): Authentication and authorization middleware for Axum: extractors, role-based guards, and public path bypass.
• ws-barbican (crate): Barbican wrapper for ws-kit: JWT auth via header/query/cookie.
• kestrel: tui+gui email client in Rust.

• suture: Core logic of suture.
• chisel-platform: Platform side of Chisel Docs: identity, assets, and the tamper-evident document audit trail: composed from the WyattAu kit estate.
• vane: L4/L7 reverse proxy,edge gateway, micro sidecar monorepo.
• estate-integration: Cross-crate dogfooding suite proving the WyattAu crate estate composes.
• homebrew-clawdius: Homebrew tap for Clawdius.
• homebrew-suture-merge-driver: Homebrew tap for Suture: a universal semantic merge driver that resolves Git merge conflicts automatically for 17+ file formats.
• continuwuity.
• aether-core: Aether-core is the open core logic for aether and the exact logic for Aether community edition.
• warploom: A data-oriented C++ engine with deterministic simulation, Vulkan rendering, an ECS, and a time-warp editor.

• traefik-setup: Docker-compose repository for setting up traefik.
• traefik-stack: Traefik setup with a few stacks. Open Portainer.io and copy the docker-compose.yml script with the .env.
• EvergreenImageRegistry: LTS images by community efforts.
• EvergreenShims: Shims for building images with, especially those ones without a healthcheck.
• RunnerImages: A list of base images usable for CI.
• forgejo-k8s-runner: Forgejo Actions runner setup for Kubernetes.
• gitea-setup: Docker compose setup for self-hosted Gitea.
• hosting-api: Control-plane API for the WyattAu hosting platform: tenant state, backup triggers, metrics. Dogfoods telemetry-init, metrics-kit, testkit.
• hosting-dashboard: Customer dashboard for the WyattAu hosting platform: tenants, backup jobs, health. Astro + SolidJS, dogfoods pediment.
• SimpleInfrastructureStack: Simple truenas infrasturcture stack with terraform.
• cachyos_sys_dotfiles: Personal infrastructure-as-code for a multi-device Arch/CachyOS/WSL environment. Managed by chezmoi (user-space configs) and Ansible (system provisioning).
• Private: windows-dotfiles.

• OmniRust-template: Maximalist Rust monorepo template: cargo workspace, estate tier-a gates (clippy pedantic/loom/miri/llvm-cov/deny/vet), nix + dual devcontainers.
• OmniTS-template: Maximalist TypeScript monorepo template: bun workspaces, Astro shell + SolidJS islands, biome, vitest + playwright, changesets.
• OmniGo-template: Maximalist Go monorepo template: go.work anchor, golangci-lint v2, govulncheck, native fuzzing, goreleaser with homebrew tap.
• OmniPython-template: A starting point for python projects.
• OmniHaskell-template: Maximalist Haskell monorepo template: cabal multi-package, nix-owned GHC 9.8 (9.6/9.10 legs), HLS, fourmolu + hlint + weeder, tasty + hedgehog.
• OmniCPP-template: A starter template for CMake projects.
• OmniCPP-docker: Docker containing CPP and CMake tooling.
• OmniEmbedded-template: Maximalist embedded C/C++ template: RP2040/RP2350, pinned pico-sdk, CMake presets, PIO scaffold, flash/RAM budget gates, HIL smoke.
• OmniInfra-template: Maximalist OpenTofu infrastructure template: tflint, fail-closed conftest/OPA policy gates, terraform-docs, sops, human-gated apply.
• OmniDotfiles-template: Maximalist dotfiles template: chezmoi-first, shellcheck + shfmt + bats, ubuntu+arch container CI for OS parity.
• OmniDocs-template: Maximalist Starlight documentation site template: Astro + Starlight, bun, biome, Pages deploy on every merge.
• OmniLean-template: Maximalist Lean 4 template: Lake, pinned toolchain, kernel-checked theorems as gates, lean-action CI, mathlib toggle.
• OmniLaTeX-template: A LaTeX template design to provide a universal template matching formatting needs for different institutes.
• OmniLaTeX-CV: CV template derive from my OmniLaTeX-template repository, probably over engineered due to the original template mainly for academic and book writing.
• OmniLaTeX-coverletter: Cover letter usage displaying OmniLaTeX-template multi document capabilities.
• OmniLaTeX-docker: The docker image for https://github.com/WyattAu/OmniLaTeX-template.
• OmniR-template: A starter monorepo template for R projects.
• engineering-standards: Engineering standards: shared CI, policies, templates for the WyattAu kit ecosystem.
• PatentSafePermissiveLicense: Patent-Safe Permissive License is inspired by Apache-2 for better readibility and more explicit clause declarations.
• omni-copier-e2e: Maximalist Rust monorepo template: cargo workspace + estate tier-a gates.
• omni-python-e2e: E2E derived repo for OmniPython-template update channel (ADR-0001).
• conan-center-index.
• latex2e.
• luaotfload.
• OmniSkill-template: Canonical agent-skill skeleton, validated by skillkit in CI.
• Private: OmniFlutter-template.

• uofg_r_mono: An R monorepo template: multiple R packages live in one repository, sharing a single.
• Private: wyatt-cv, coa, uofg_sml_soc_docs, phys-maths-gypt-notes, FlutterSSG, homebite_docs, pediment-pro, peptide-web.

Individual projects are licensed under MIT, Apache-2.0, or AGPL-3.0 as specified in their repositories.

Generated on 2026-10-23 from the GitHub repository listing (214 public non-fork repositories via the API plus 14 private repositories named from account metadata), with per-repository descriptions taken verbatim from each repository's own metadata, em dash characters removed, and headings annotated with per-heading counts so completeness is checkable by inspection.