Open Source Projects
Tools, plugins, and libraries built by TPT Solutions — see our GitHub org. All projects are freely available on GitHub.
Applied engineering primitives (fluid/gas properties, sensor timeseries alignment, infrastructure topology, control systems) for the tpt-solutions physical-systems verticals
A memory-safe, lock-free media processing engine in Rust. The modern, hyper-concurrent successor to FFmpeg for production pipelines.
Memory-safe, zero-copy ASN.1 DER/BER/CER parser and X.509/PKI toolkit in pure Rust — a clean-room, no-C-dependency alternative to OpenSSL's x509/req tooling.
Embeddable columnar query engine for the TPT stack — native format, builder API, and SQL surface with zero trait-implementation boilerplate. Dual-licensed MIT/Apache-2.0.
The survival layer beneath intelligence — a portable Rust stack (sense, metabolism, memory, replication, defense) that lets autonomous AI agents persist, migrate, and thrive without centralized infrastructure.
Pure-Rust, real-time-safe DSP framework — zero-allocation audio/RF/control processing for desktop, WebAssembly, and no_std embedded targets. Dual-licensed MIT/Apache-2.0.
Composable, linear-time, safe-by-default pattern matching engine for Rust. DFA-compiled patterns with a typed builder API — no backtracking, no ReDoS.
MIR-native dependent type system and formal verification tool for Rust: verifies Rust's actual execution model directly via stable_mir, using e-graphs (egg) for proof automation with an SMT (z3) fallback.
Embeddable, offline-first RAG engine in pure Rust — zero Docker, zero API keys. Single library for Python, JS/WASM, and C with local ONNX embeddings and disk-backed vector search.
Local-first mission control for ESP32 & embedded IoT development — serial console, flash/OTA, BLE Wi-Fi provisioning, LittleFS browser, Matter/Thread mesh visualization, and energy monitoring. Built with Rust + Tauri + React. No cloud, no accounts.
Blazing-fast, universal data validation engine written in pure Rust. One schema, every language — Python, JavaScript, Go, C, and Rust. SIMD-optimized, streaming-capable, MIT/Apache-2.0 dual-licensed.
Ultra-lightweight, guaranteed-delivery telemetry & log router in pure Rust. < 20 MB RAM, < 2% CPU, 10x compression, zero infrastructure. Native bindings for Python, JavaScript/WASM, Go, and C. Dual-licensed MIT / Apache-2.0.
Security-first Rust XML toolkit — zero-copy reader/writer, DOM, serde, and an XPath 1.0 subset, with mandatory limits against XXE and entity-expansion attacks.
A dependency-free Rust YAML toolkit — core parser/lexer, serde support, format-preserving editing, JSON Schema validation, and a CLI — built as a family of crates from the ground up (YAML 1.1/1.2 aware).
A parametric 3D CAD platform built for the collaborative era. WebGPU-powered rendering, real-time multi-user editing via CRDTs, and Git-like version control for 3D geometry. The open, cross-platform alternative to SolidWorks/CATIA for open-source hardware. Dual-licensed MIT/Apache-2.0.
A proof-native, formally verified no_std Rust foundation for ESP32 — typestate-safe DMA/ISR, WCET-bounded telemetry, verified sleep transitions, constant-time crypto, and mesh state sync, proven with Kani.
A lightweight, hardware-agnostic, and formally verifiable Intermediate Representation (IR) for the TPT AI stack — the universal contract between TPT execution engines and the formal verification engine tpt-telos.
Zero-copy streaming ETL engine in pure Rust — processes files of any size in constant memory via chunked columnar pipelines, with native Python and JavaScript bindings.
Browser-native image processing and PDF generation in pure Rust + WebAssembly. Resize images, add watermarks, and generate PDFs entirely on the client's device — no server, no cloud costs. Dual-licensed MIT OR Apache-2.0.
High-performance WSL2 filesystem & inotify event bridge — eliminates 9P I/O latency and broken file-watching when building Linux projects from the Windows filesystem. Built in Rust over AF_VSOCK/VMBus.
Open-source, real-time collaborative spreadsheet engine built in Rust/Wasm with a strictly-typed formula language, CRDT-based sync, and a Canvas/WebGL renderer.
A modern, memory-safe build system and developer toolchain for .NET, C++, Rust, TypeScript, and more — a drop-in replacement for MSBuild and Azure DevOps build agents. Hermetic, parallelized, content-addressed caching. Reads .sln/.csproj natively. Runs fully air-gapped.
Memory-safe, federated drop-in replacement for Microsoft Exchange, Teams & SharePoint — open standards storage (EML/ICS/VCF), E2EE by default, sovereign-ready, 10K mailboxes on 4 GB RAM.
Modern, memory-safe infrastructure control plane — a drop-in replacement for Azure Resource Manager. Manages on-prem, edge, and multi-cloud with HCL + a declarative state engine. Air-gap ready. Dual-licensed MIT OR Apache-2.0.
Memory-safe Active Directory replacement in Rust — LDAP v3 · Kerberos · OIDC · SAML · one-command AD migration. Sovereign by design. MIT OR Apache-2.0.
Runtime-agnostic async I/O stack for Rust — no_std-compatible traits, executor, timer wheel, TLS, HTTP, and WebSocket across 9 focused crates.
Pure-Rust, hardware-agnostic edge AI inference runtime — compile-time tensor shape checking, AOT code generation, zero-allocation execution, and ONNX support. No CUDA, no Python, no C++ toolchains.
Pure-Rust enterprise document substrate — streaming OOXML/CSV, HL7 FHIR R5, EDIFACT/X12, PDF 1.7/2.0, PAdES/XAdES/CAdES signing, and HTML-to-PDF layout. No C-FFI. No Python. 100% MIT/Apache-2.0. NZISM · FHIR R5 · HIPC 2020 compliant.
Edge-native intelligence layer for semantic capture — decides what to record, compress, and transmit, with formally verified dispatch logic and honestly-reported (not overstated) detection accuracy.
Hyper-optimized, zero-bloat, safety-critical Rust middleware for autonomous robotaxis, sidewalk delivery bots, transit shuttles, and smart-city V2X infrastructure. MIT OR Apache-2.0.
Hyper-optimized, zero-bloat, fault-tolerant Rust middleware for extraterrestrial & orbital robotics — DTN, radiation-hardened control, and deterministic ADCS/rover autonomy. MIT OR Apache-2.0.
Rust middleware for GPS-denied maritime, underwater & offshore robotics — AUVs, ROVs, ASVs, and gliders. Zero-allocation acoustic protocol, SIMD INS/DVL/EKF fusion, and deterministic COLREGS compliance. MIT OR Apache-2.0.
Zero-bloat, MIT/Apache-2.0-licensed Rust middleware for infrastructure & industrial inspection robotics — edge AI defect detection, multi-sensor fusion, tethered drone/crawler control, and automated regulatory reporting for bridges, power lines, pipelines, wind turbines, and confined spaces.
Zero-bloat, safety-critical Rust middleware for autonomous heavy machinery and mining — excavators, haul trucks, dozers, drills, and TBMs, from open-pit surface ops to GPS-denied underground tunnels. MIT OR Apache-2.0.
Zero-bloat Rust middleware for autonomous farming machinery — RTK/IMU nav, ISOBUS, teleop handover, and lock-free real-time control for tractors, combines, and sprayers.
High-performance, local-first Rust CLI that audits dependency trees for CVEs, license violations, and bloat — no telemetry, fully air-gapped after update.
Structural, AST-aware diff and merge tool for reviewing AI-generated code changes — compares source via Tree-sitter ASTs instead of raw text lines. Rust · MIT OR Apache-2.0
A pure-Rust distributed-computing substrate built on capability-controlled, temporally valid, failure-aware execution — intents, leases, epochs, and deterministic simulation as first-class primitives, not bolted-on RPC/queue/scheduler mechanisms.
Local-first, zero-trust MCP proxy and WebAssembly tool runtime. Routes MCP JSON-RPC between AI agents and tools, enforces capability-based security policy, and runs untrusted tool logic in isolated Wasm sandboxes.
Shared canonical primitives (identity, capability, intent, computation, execution, evidence, claim) underpinning the Fabric, Repro and Concord ecosystem — dual-licensed MIT/Apache-2.0.
Pure-Rust framework turning specifications, claims, evidence, and conformance into first-class machine-readable objects, connecting formal proofs, model checking, property/fuzz/differential testing into one assurance graph. Dual-licensed MIT/Apache-2.0.
Pure-Rust, MIT/Apache-2.0-dual-licensed substrate for treating computation as a content-addressable, reproducible object — canonical identity, provenance, and cache soundness for builds, data, AI, media, WASM, and container workloads.
Safety-critical, fault-tolerant process control for lunar ISRU chemical refineries — a Rust workspace with a formally-verified no_std safety domain and a std control domain (digital twin, feed-forward control, native EtherCAT/OPC-UA).
Pure-Rust, no_std-first, constant-time-by-construction crypto substrate — ML-KEM, ML-DSA, Ed25519/X25519, BLS12-381, Bulletproofs, AEAD, hashing. 100% MIT/Apache, zero C-FFI.
Rust simulation & modeling substrate for science verticals: ODE/DAE, structured-grid PDE, multi-scale orchestration, probabilistic programming (NUTS), rigid-body physics, quantum state-vector sim, 2-D CT imaging, astrodynamics, and reaction-network DSL. Dual-licensed MIT OR Apache-2.0.
Open-source Rust multiphysics engine for air, ground, sea, and space transport: FEM, CFD, crash, fatigue, composites, propulsion, and optimization in one MIT/Apache-2.0 crate ecosystem.
Independent Rust implementation of WebAssembly — specification-first, with a minimal executable semantic core (Micro Interpreter), capability-oriented host, Lean 4 formal verification layer, and native compiler. Not a Wasmtime fork.
Local-first AI coding assistant. Features a Rust daemon, Tree-sitter + BM25/vector indexing, GGUF inference, and VS Code/JetBrains extensions.
Fully open-source, pure-Rust computational engine for energy systems, power grids, and renewable integration. MIT OR Apache-2.0.
A high-performance, zero-cost Rust toolkit for local AI. Features HuggingFace model caching, LoRA weight merging, safetensors I/O, and pure-Rust tokenization.
TPT Boxcar — a monorepo of five open-source tools for the full app lifecycle: local sandbox (OCI + Wasm), state/connection proxy, eBPF observability, automated image distiller with LLM analysis, and a Wasm-native edge service mesh & API gateway.
A high-performance, type-safe Rust framework for building domain-specific ERPs — Wasm-sandboxed customization, event-sourced ledger, and multi-tenant RLS by default. Includes reference implementations for 3PL/WMS and Manufacturing/MES.
10 deep-tech Rust libraries filling the missing plumbing of the Linux ecosystem — power management, HDR/VRR compositing, eBPF kernel testing, memory tiering, firmware parsing, pro-audio DSP, SAT-based dependency solving, and AI log diagnostics. MIT/Apache-2.0.
Pure-Rust, solver-agnostic suite of large-scale, network-aware, and discrete mathematical optimization crates — MILP, MINLP, network flow / OPF, constraint programming, metaheuristics, multi-objective, robust/stochastic, and decomposition (Benders, Dantzig-Wolfe, column generation). Bridges tpt-math and Tier 2 domain repos.
Pure-Rust computational thermodynamics workspace — multi-component mixture properties, phase equilibria, and advanced Equations of State (cubic, SAFT, activity models) from first principles, with WASM support.
Safety-critical, zero-bloat Rust middleware for telesurgery, hospital logistics, automated pharmacy, and sterilization robotics — TMR redundancy, 1kHz haptics, cryptographic FDA 21 CFR Part 11 audit trails. MIT OR Apache-2.0.
Pure-Rust, MIT/Apache-2.0-only hybrid search engine — unified scalar (inverted index), vector (HNSW), and graph (property graph) search with CRDT-based edge-to-cloud sync, built as an Elasticsearch/OpenSearch alternative for offline-first deployments.
Pure-Rust PDF processing library — layout-aware extraction, pixel-perfect rendering, and PDF generation with zero-copyleft dependencies. Dual-licensed MIT/Apache-2.0.
Pure-Rust, formally-verified WebRTC stack — AV1-first, zero libwebrtc, MIT OR Apache-2.0.
A cohesive, minimal Rust AI stack for building trustworthy AI applications — unified LLM client access (12+ providers), structured output, MCP tool sharing, runtime plugins, observability, and the auditor pattern for high-stakes domains. Dual-licensed MIT/Apache-2.0.
Open-source EDA toolchain: a Rust-based HDL (Silica) compiling to Verilog-2005, plus a full digital design suite — lint, format, synth, sim, place & route, DRC — and a Tauri desktop IDE.
Pure-Rust, from-scratch multibody dynamics workspace: Featherstone 6D spatial algebra, DH/PoE kinematics, holonomic/non-holonomic joint constraints, Craig-Bampton flexible bodies, and Hertzian contact mechanics. Deterministic, no_std-friendly, WASM-compatible — for robotics, vehicle, aerospace, and biomechanical simulation.
Schema-first contract system for distributed Rust apps — native compiler, binary wire format, codegen, reflection, RPC/streaming, and clean-room Protobuf/gRPC compatibility adapters.
Pure-Rust computational electromagnetics: MNA circuit simulation, device models, quasi-static Maxwell FEM, transmission lines, S-parameters, and power systems.
Modular Rust workspace of reusable, dual-licensed (MIT OR Apache-2.0) construction-industry libraries — BIM/IFC, estimating, scheduling, civil/earthwork, field execution, and digital twins.
Pure-Rust, feature-gated workspace for parsing, validating, and serializing industry-standard data formats (medical, construction, electronics, GIS, process engineering).
KV-cache quantization for attention inference — streaming append-time quantization, recency-tiered precision, and a GPU backend behind a stable KvBackend trait
Minimal, no_std quantization primitives for Rust — group-wise scale computation, int8/int4/int3/int2 bit-packing, dequantization, and calibration stats. Zero external dependencies.
A high-performance constraint, SAT, and SMT solver suite in pure Rust, built on a certificate architecture: an untrusted, aggressively-optimized search engine paired with a small, independently-verified checker kernel that revalidates every answer.
Rust fleet orchestrator for autonomous "Dark Factory" robotics — task allocation, CBS pathfinding, digital twin, and universal protocol bridges (VDA5050/ROS/MAVLink/PLC/Isaac).
Composable Linux sandboxing in Rust — Landlock, seccomp, namespaces, and cgroups behind one declarative API. Pure-Rust alternative to bwrap/firejail.
Async, unified Linux hardware discovery — sysfs walking, PCI/USB/block enumeration, and netlink event streaming in pure Rust. MIT OR Apache-2.0.
Zero-copy, async-first Rust toolkit for Ubuntu/Debian package management — index fetch, dependency resolution, and install. 14-crate workspace spanning .deb parsing, a DPLL SAT solver, OpenPGP verification, and sandboxed maintainer script execution.
a hyper-optimized, zero-bloat Rust middleware for robot/drone teleoperation. Lock-free SPSC IPC, zero-copy (rkyv) serialization, and no async runtime (thread-per-core + io_uring)
Open-source Stripe alternative — self-hostable payment API (TPT Pay) with double-entry ledger plus a sovereign credit blockchain (TPT Credit) issuing 12,000 credits/person/year. Built in Go. MIT licensed.
Formally verified financial invariant & ledger engine in pure Rust. Proves strict conservation of value across every state transition — no created, destroyed, or silently-rounded value.
Cross-chain execution & routing layer for the TPT ecosystem — chain-abstracted transfers with dispute-window-safe atomic rollback.
Pure-Rust, formally verified engine that mathematically bounds AI agent actions against resource, temporal, and safety policies. Conservative denial with zero false allows (QF_LRA ideal layer + sound f64 realization). Dual-licensed MIT OR Apache-2.0.
Pure-Rust, zero-copy, modular computer vision framework — a permissively licensed (MIT/Apache-2.0), memory-safe alternative to OpenCV for WASM, edge/embedded, desktop, and GPU targets.
Rust robotics math & algorithms vertical for the TPT Solutions ecosystem: kinematic chains/URDF, FK/IK, trajectory generation, sampling-based planning, and state estimation. no_std-friendly, dual-licensed MIT OR Apache-2.0.
AI-native debugging & forensic replay engine for tpt-telos-verified software — ICH trace standard, counterexample generation, and cryptographic forensic replay.
Open-source, MIT-licensed pure-Rust engine for vehicle construction: sea shipyards, orbital assembly, in-space manufacturing, and construction digital twins. Build anything, anywhere — no gravity constraints, no launch limits, no proprietary lock-in.
Pure-Rust, formally verified 3D spatial library suite with two-layer (QF_LRA ideal + bounded f64 realization) soundness.
An AI-native language and agentic compiler that turns declared intent, invariants, and constraints into formally verified Rust and Go code.
Proof-gated capability guard for MCP tool calls — derive minimal tool scopes from verified proofs, enforce fail-closed.
Hardware-agnostic AI compiler suite. Compile GGUF, ONNX, PyTorch, and SafeTensors models onto FPGAs, analog circuits, MCU swarms, photonic MZI meshes, neuromorphic chips, and CIM accelerators — not GPUs. Includes SiL emulator, real-time dashboard, federated learning, and carbon-aware compilation.
Compiler-assisted lexical memory regions for Rust — O(1) bulk deallocation and zero-fragmentation bump-pointer pools scoped to lexical blocks, for deterministic allocation in HFT, real-time audio, and embedded systems.
Compile-time capability-based security for Rust — unforgeable type-state tokens that gate filesystem, network, and process access, for sandboxing plugins and AI agents without WASM overhead.
Clean-room, pure-Rust implementation of a Protocol Buffers-compatible ecosystem — parser, compiler, codegen, wire-format runtime, reflection, JSON/text formats, and gRPC. MIT OR Apache-2.0.
Refinement types, contract-verified FFI, and fractional-permission borrows for Rust, backed by an in-house QF_LRA solver. Compile-time correctness for business logic and Rust↔C/Go boundaries.
Session-typed channels and compile-time reactive signals for Rust — statically verified protocol and dataflow correctness via tpt-telos.
Dependent tensors and heterogeneous memory topologies for Rust — compile-time shape safety and topology-tracked CPU/GPU/NPU buffers, eliminating runtime shape mismatches and silent memory-transfer costs.
Probabilistic types and native Zero-Knowledge circuit generation for Rust — Fuzzy<T>/Distribution<T> with automatic variance propagation and a #[zk_provable] macro, formally verified via tpt-telos.
Multi-crate Rust workspace of zero-cost, dependency-free primitives: deterministic virtual time, CRDT merge traits, lifetime-bound telemetry contexts, typed effects, and zero-copy schema evolution.
Modular finite-element method toolkit for Rust — quadrature, elements, mesh I/O, sparse assembly, physics, eigen/continuation solvers, a native tet-mesh generator, and a CLI.
From-scratch Rust compiler with Clotho frontend, Lachesis type/borrow checker, and Atropos SSA native codegen. Single-pass Phase-1 Rust subset, dual-licensed Apache-2.0/MIT.
Unified Computational Substrate for differentiable physical & scientific computing: a universal device-agnostic tensor, reverse-mode autograd, an ML API, a SafeTensors weight hub, a multi-tier runtime, and differentiable science (ODE/FEA/PINN) crates.
A Rust mathematical reasoning lab: a small trusted proof kernel plus automation, counterexample search, and conjecture generation to prove, disprove, repair, and audit mathematics.
A coherent, self-contained platform built together from day one: one Rust workspace + one storage engine, with two written-down exceptions (Identity in Go, and a thin wasmtime WASM sandbox).
Clean-room, dual-licensed (MIT OR Apache-2.0) Rust implementations of IETF RFC protocols — closing ecosystem gaps left by license-incompatible popular crates.
Pure Rust, AI-native FEA/DEM/CFD physics simulation framework — data-oriented, unit-safe, zero C/C++ FFI. Dual-licensed MIT/Apache-2.0.
tpt-math — the numeric substrate for tpt-science, tpt-engineering, and tpt-formal: units, exact arithmetic, linear algebra, probability, stats, autodiff, symbolic math, optimization, and signal processing.
A free, open-source, desktop-native double-entry accounting app built with Tauri.> All data stays on device, encrypted at rest. CSV/OFX import, Chart of Accounts, audit logging, optional localhost API, BYOK integrations. MIT OR Apache-2.0.
Rust workspace for water distribution network modeling, simulation, optimization, and control — pressure management, flow modeling, pump scheduling, and leakage estimation.
First-principles spacecraft navigation & control library in Rust — orbital mechanics, J2-J4 perturbations, Extended Kalman Filter, multi-object tracking, Lambert trajectory solver & autonomous flight control.
Open-source, MIT-licensed pure-Rust computational engine for chemical & process engineering — thermodynamics, fluid flow, heat transfer, separations, reaction engineering, and flowsheet simulation, with WASM support.
Fully open-source, pure-Rust computational biomechanics and medical device simulation engine, compiling to WASM for zero-cloud, browser-based surgical planning.
Open-source Rust ecosystem for a post-monetary physical logistics OS — tracks energy, compute, materials, and healthcare as physical resources instead of money, governed by capability-based AI sandboxing, formally verified ethical invariants, and a multi-tier democratic architecture.
An autonomous, closed-loop Rust epistemic engine that hypothesizes, formally verifies, fabricates, measures, and rewrites its own physics models — no LLM, no network, no human in the loop.
TPT Armature is a memory-safe, 100% Rust reverse engineering and binary analysis suite. It ingests raw executables (PE, ELF, Mach-O), disassembles machine code into a custom intermediate representation, builds control-flow and data-flow analyses, and presents results through a native GUI with scripting and sandboxed plugin extensibility.
Maths. Rust + Lean 4 engine that discovers, verifies, minimizes, and publishes novel theorems — symbolic search by default, AI-assisted when you want it.
Durable execution / BPM engine — orchestrates long-running, stateful workflows across your microservices with crash-safe replay, sandboxed WASM workers, and gRPC task dispatch.
Lightweight, pure-Rust distributed job scheduler with exactly-once execution (Raft), typed job contracts, and built-in dead-letter queues — a modern alternative to cron and heavyweight orchestrators like Airflow/Temporal.
Cloud-native remote observatory control and a crowdsourced virtual observatory network, with edge AI transient detection. Rust edge agent, Go cloud core & Relay scheduler, Next.js dashboard.
A modern, strongly-typed network management protocol and MIB compiler — replaces legacy SNMP/ASN.1 with type-safe Rust clients and Prometheus/OTLP exporters.
A unified, cross-platform, zero-cost async I/O framework for Rust, abstracting io_uring, IOCP, and kqueue behind a single memory-safe API.
Open-source, memory-safe Rust suite that unifies 19 industrial, medical, and hardware protocols (Modbus, CAN, BACnet, HL7, MAVLink, and more) into a single open envelope (TUP).
Simulation engines, dispatch optimizers, and digital twin observers for the TPT platform — turns historical and live telemetry into optimal physical setpoints.
A strongly-typed observability contract and legacy log parser for Syslog, CEF, and LEEF — turns messy security-device logs into zero-allocation, schema-driven Rust structs with native OTLP export.
Rust workspace for modeling, simulating, optimizing, and controlling thermal energy systems — local-first and simulation-first.
A vertically integrated storage/kernel/database stack in Rust — a no_std zero-allocation storage engine, capability-based microkernel with a unified page cache, and a GPU-opt-in SQL query engine, sharing a single zero-copy address space
Embodied-AI / bio-hybrid android platform — neuromorphic computation, formally-verified physical safety, and simulation-first robotics for the tpt ecosystem.
Write your UI once in Rust and render it anywhere: native/WASM canvas (egui+taffy), reactive DOM, semantic HTML, terminal UI (ratatui), JSON-LD/AI-agent schema, and an OS-webview desktop shell — served to the right client by a smart backend router.
Ultra-fast, zero/low-allocation Rust parsers for niche data formats (JSONL, GeoJSON, logfmt, cron, MIME).
A self-contained, self-teaching virtual machine and archive designed to survive 1,000+ years and be decoded by post-apocalyptic humans or non-human intelligence, using only universal physics and math as the bootstrap.
Strongly-typed directory protocol and identity schema system — replaces fragile LDAP string filters with a compiled, type-checked Rust query builder, backed by a Raft-replicated server and a transparent LDAPv3 bridge.
Formal-verification and design-by-contract foundation for Rust — typestate, ghost state, proof ASTs, deterministic simulation, and fault-tolerance harnesses.
A zero-legacy, four-layer AI runtime built from first principles for autonomous agents — replacing REST/SQL/OAuth/threads with attended memory (SSE), agent negotiation (INP), zero-knowledge identity (ZKPA), and inference-based scheduling (CK). Native MCP/A2A support. Apache 2.0.
The eternal data container. Formally verified parser, embedded WASM self-decoder, local-first AI generation receipts, and zero-knowledge compliance proofs — no centralized trust required.
AURA — Adaptive Universal Record Architecture. A polymorphic master media format with embedded semantic understanding, cryptographic provenance, and adaptive neural encoding. Rust implementation of the open AURA spec: libaura core library + aura CLI compiler.
Zero-overhead, formally verified observability platform in Rust. A DSL compiles alerting rules to provably contradiction-free, loop-free Rust — no alert storms — paired with a Linux eBPF collector. No runtime interpreter, no unverified rule logic.
Universal WASM driver ecosystem. Write hardware drivers once in Rust, run them securely on any OS via capability-based sandboxing and formal verification
A Rust dev-tooling workspace featuring isolated env mocking, zero-dep snapshot testing, realistic fake data, ephemeral FS fixtures, and a TUI cargo scrubber.
Hardware-agnostic, full-stack GPU compute platform — TPT Script AI-native language, TPTIR compiler, LLM inference engine with GGUF support, and optimized GEMM/Attention primitives. Runs on CUDA, ROCm, Metal, and native TPT ISA.
A Rust workspace for modeling, simulating, and (eventually) safely controlling power systems — PV/load models, storage, forecasting, dispatch optimization, telemetry, and control policies across composable crates.
Safety guardrails for the TUP platform — interlocks, rate limiters, and actuation gating between optimized setpoints and physical hardware.
TUP-native edge memory and routing layer: zero-loss WAL, store-and-forward buffering, and real-time materialized state for physical assets on unreliable edge hardware.
No_std runtime units, timeseries alignment, infrastructure topology, and physical property tables (water/air/fuels) for the TUP protocol stack.
Runtime building blocks for formal verification, design-by-contract, and probabilistic computing in Rust — zero external dependencies, no_std by default, panic-free.
Zero-dependency, #![no_std] Rust primitives for text, parsing, and math — the Structural Layer of the tpt-zero-* ecosystem.
Integration harness that closes the loop between tpt-telos (verified codegen) and tpt-archon (capability kernel)
Zero-dependency, zero-heap-allocation no_std Rust crates for encoding (base64/hex/varint/endian), integrity checking (CRC/checksums), hashing (FNV/SipHash/xxHash/Murmur), bit manipulation (bitset/bitfield/bloom), and identifiers (UUID/MAC/IP/CIDR).
First-principles, multi-scale computational platform for whole-body human physiology — unifying multi-omics, clinical, and sensor data into mathematically rigorous digital twins.
Production-grade observability & resilience toolkit for Rust services on Kubernetes/cloud — OTel batching/PII-redacting processors, circuit breakers, distributed locks, trace-context propagation, health checks, graceful shutdown, and feature flags.
First-principles, multi-scale computational platform for the central nervous system — unifying electrophysiology, neuroimaging, connectomics, and molecular neurobiology into a single Digital Brain environment.
A purely native, Rust-first scientific computing, math, and AI stack — leapfrogs Python instead of wrapping or replicating it.
Rust hardening suite: ZK compliance receipts, capability-based WASM sandbox, typestate hardware transitions, lock-free pools, and deterministic execution — no_std-first, zero external ZK/WASM deps.
Rust firmware SDK for the TPT ecosystem — no_std device runtime with HAL support for ESP32 and RISC-V, plus a mock layer for laptop-side testing.
Privacy-first, no_std Rust workspace for multi-modal biometric sensing — PPG, ECG, NIR vein imaging, EIT tissue mapping, and ultrasound on ESP32. Build your own Medical Tricorder.
Local-first, offline-capable operating system for self-sufficient communities — energy, water, food, fabrication, health, and repair, coordinated by local governance and a local AI (ORACLE) that never phones home.
Safe, cross-platform manager for PATH, SDKs, and environment variables — with automatic backups, validation/repair, project auto-loading, shell hooks, and native GUI + CLI for Windows and Linux.
Disk cleanup desktop app built with Tauri + React and a Rust core — scans your drives and finds temp files, Docker artifacts, and duplicates to reclaim space.
A secure, sandboxed, multi-threaded PDF and PostScript rendering engine in Rust. The Ghostscript successor: immutable graphics-state architecture enables safe concurrent multi-page rendering, powered by wgpu/raqote and a knowledge-graph-driven operator interpreter.
Formally verified, capability-secured orchestration platform for organ-on-a-chip labs and autonomous lab robotics — closing the loop between digital simulation and physical biology.
Cross-platform audio router & virtual mixer (Windows WASAPI, Linux PipeWire): route any source to any sink with a live matrix, per-route/per-app volume, shareable presets, plugins, localization, and a headless JSON CLI.
Smart, secure clipboard manager with searchable history, sensitive-data auto-expiry, and E2E-encrypted cross-device sync. Rust core + Go sync. MIT/Apache-2.0.
Proof-native, GPU-accelerated presentation, interaction, and media runtime for the TPT ecosystem — replaces the browser rendering pipeline with a wgpu render graph, zero-copy state, and eidos-verified layout.
A #![no_std], zero-allocation WebAssembly micro-runtime for TPT edge devices — sandboxed, hot-swappable .wasm applets pushed over tpt-e-link, managed from tpt-basestation.
TPT Keystone DB — a multi-engine data platform. One core engine for relational, geospatial, graph, vector/AI, time-series, document, and event-streaming workloads. Postgres wire-compatible, hand-written SQL/parser, local & S3 storage, MCP server, WASM UDFs.
Host-side verification, simulation, and analysis suite for proof-native ESP32 firmware — deterministic simulator, static stack analyzer, structured trace verifier, HIL orchestration, and cross-crate invariant checking for tpt-embedded-core.
Transport-agnostic, no_std, zero-allocation protocol crate shared between TPT host and embedded device firmware — the single source of truth for the wire format.
Formally verified, sub-second settlement protocol for autonomous AI agent payments — nano-denominated value transfer under cryptographically enforced human-delegated mandates.
A vertically integrated, proof-native compute fabric for the autonomous AI agent economy — SMT-verified contracts (tpt-telos), a dependently-typed kernel (tpt-eidos), a settlement DAG (tpt-koinon), DID/mandate identity (tpt-identity), and a GPU-rendered observation layer (tpt-chora).
A neuro-symbolic preprocessing & translation suite for LLM inference pipelines — zero-copy tokenization, a symbolic IR with fractal compression, formal verification of IR edits, and a legacy BPE translation bridge so existing pretrained models benefit without retraining.
Open-source, local-first agricultural machinery diagnostics, telemetry, and control — CAN bus, SAE J1939, and ISO 11783 (ISOBUS) in Rust, built for farmers, independent mechanics, and AgTech developers.
Proof-native, dependently typed systems language — types are theorems, programs are proofs, and the compiler won't emit code unless correctness is mathematically verified. Zero-cost proof erasure targets Rust/C for safety-critical domains like flight control.
Local LLM chat app powered by WebGPU — runs GGUF models (Llama, Mistral, Qwen, Phi, Gemma & more) fully on-device via custom WGSL compute shaders. Built with Tauri v2 + TypeScript frontend. No cloud, no API keys.
Open-source, self-hosted BI & analytics platform for TPT Keystone — a free Tableau/Looker alternative with a drag-and-drop query builder, real-time dashboards, and AI-powered natural language querying.
An open-source, Rust-based microkernel VMM unifying VMs, containers, and WebAssembly workloads with hardware-level GPU/NPU virtualization. Built for the AI era and the post-Broadcom/VMware era of infrastructure freedom.
A Rust Cargo workspace of fusion-development applications — plasma data ingestion with in-DB FFT UDFs (tpt-fluxstream), visualization, digital-twin/reactor topology, and AI disruption prediction — built on the tpt-keystone-db and tpt-appfront sibling repos.
Proof-native, verification-first building blocks for safety-critical Rust — exact arithmetic, typed proof ASTs, #[requires]/#[ensures] macros, deterministic simulation, and an SMT-LIB2 bridge.
AI-native, ECS-based real-time engine in Rust that wraps AI-generated visual media (video, images, meshes, Gaussian splats) into interactive, physics-driven, deterministic game objects.
Open-source New Zealand healthcare platform — FHIR R5 REST API, NHI/HPI/ACC/NES/PHARMAC integrations, HIPC 2020 & Privacy Act 2020 compliant. Go backend, React frontend, multi-tenant, audit-trail, consent management.
Ergonomic testing DX toolkit for Rust — async trait mocking, snapshot testing, fixture loading, testcontainers, CI helpers, property-based generators, and more. 10 focused crates, tokio + cargo-nextest friendly.
A hardware-accelerated probabilistic programming language — write variables as distributions, not values, and run built-in Bayesian inference (HMC, VI, particle filter, MH) at native speed.
Offline-first farm management software for agriculture. Track fields, crops, livestock (sheep, cattle, goats, deer, pigs, poultry, bees), orchards, and pasture — all locally on your device. Built with Tauri 2, React 19, and SQLite. No cloud required.
Open-source, AI-driven physical plant controller for hyperscale data centers — Rust edge agents, Go telemetry ingestion, and a burn-based RL thermal brain behind a common Hardware Abstraction Layer.
A memory-safe, modular hypervisor and hardware emulator in Rust — the QEMU successor. Async device emulation with strict guest/host memory isolation, AI + Knowledge Graph-assisted porting of device state machines, and a cycle-accurate test harness. Dual-licensed MIT/Apache-2.0.
Open-source productivity suite for small businesses — offline-first rich text editor, Excel-class spreadsheet, forms builder, Kanban task board, chat, calendar, email client & end-to-end encryption. Go + Svelte. Free forever.
Open-source airport flight control & management system — ATC operations, real-time ADS-B aircraft tracking, passenger booking, baggage, ground crew scheduling, and live WebSocket updates. PHP + TypeScript. MIT.
A Rust-native, deterministic OpenRAN 5G/6G baseband stack — const-generic SIMD FFT, LDPC/Polar FEC, OFDM PHY, MAC scheduling/HARQ, and eCPRI fronthaul, built for PREEMPT_RT
Dynamic-depth, symbolic-verified LLM inference in Rust — a from-scratch implementation of non-sequential transformer forward passes (arbitrary layer programs) with a lightweight router and a symbolic verifier for reasoning consistency, aimed at closing the 8B→32B quality gap without model compression.
Open-source, GPU-accelerated DICOM reconstruction engine in Rust — turns raw CT/MRI/Ultrasound/PET sensor data into 3D diagnostic models in seconds, with a plug-in ONNX AI diagnostic bridge.
Rust workspace for building LLM-powered agents: unified streaming clients for OpenAI/Anthropic/Ollama, RAG pipeline (chunking, embedding, context management), vector store traits (Qdrant/Milvus/pgvector), tool-use macros, prompt templating, tokenization, agent memory, eval harness, and a mock server.
Delay-tolerant mesh networking & edge-compute orchestration for lunar robot fleets — WebAssembly-sandboxed AI offload, gossip service discovery, and PQC-secured DTN routing, independent of Earth.
A memory-safe API gateway & service mesh in Rust, with sandboxed Wasm plugins and formally-verified, loop-free routing.
TPT Eve is a Rust cognitive architecture that augments LLM pattern recognition with symbolic reasoning, causal inference, abstraction, active learning, and meta-cognition. It runs fully locally (tpt-spark or Ollama) or against cloud APIs (Anthropic, OpenAI, OpenRouter) with no external services required for the default mock demo.
The Universal Cyber-Physical Engine. An open-source, Rust-based IaC and edge-native orchestration platform for the physical world — declaratively manage water systems, microgrids, robotics, and more like Kubernetes manages compute.
Open-source, web-based maritime navigation & ECDIS system in Rust + TypeScript. AIS integration, real-time route optimization, and GPS spoofing detection — built to replace legacy proprietary bridge software. Dual-licensed MIT/Apache-2.0.
A #![no_std], memory-safe Rust flight software bus for small satellites — zero-copy message bus, FDIR, CCSDS/CFDP, and ADCS/EPS/Thermal/Comms drivers, no heap, no alloc.
Open-source ground station control & orbital routing for satellite constellations — DTN-based data routing and on-orbit AI inference, without vendor lock-in.
A memory-safe, distributed replacement for OpenLDAP, written in Rust. LDAPv3-compatible directory server with Raft-based replication for strict ACID consistency across nodes, built for Kubernetes-native deployments. Dual-licensed MIT/Apache-2.0.
WASM-native web platform runtime written in Rust — a successor to the JS-centric browser stack. Capability-secure by design, with an HTML5 → CSS → layout → GPU rendering pipeline (html5ever, lightningcss, taffy, wgpu). Early-stage: Phase 0 (Foundation) in progress.
Ultra-lightweight, API-first Identity & Access Management (IAM) platform built in Rust — a self-hosted, open-source alternative to Auth0/Okta/Keycloak with OIDC, GraphQL admin API, and a modern React dashboard.
Zero-trust secrets vault in Rust — encryption-as-a-service, dynamic credential rotation, Shamir's Secret Sharing key management, and a cryptographically signed immutable audit ledger for HIPAA/GDPR/SOC2-grade compliance.
Open-source, memory-safe vehicle operating system written in Rust — a safe AUTOSAR replacement with unified CAN/Ethernet/LIN bus abstraction, atomic OTA updates, and a plug-and-play autonomous driving interface.
A real-time microkernel RTOS in Rust for safety-critical embedded systems, targeting Cortex-M/Cortex-A with MPU-enforced task isolation, rendezvous IPC, and a POSIX-ish syscall layer.
Constraint-driven generative design and costing engine for residential construction — Rust geometry engine, NestJS API, and React/Tauri front end that turns spatial constraints into real-time-priced floor plans and standardized RFQs.
Open-source, formally verified Distributed Control System (DCS) for nuclear, renewable, and heavy-energy plants — deterministic Rust control loops, triple-redundant safety voting, and grid-forming inverter logic on commodity hardware.
Universal code modernization engine — extracts legacy codebases (C/C++, Java/C#, PHP/Python) into a language-agnostic knowledge graph, then regenerates idiomatic, memory-safe code in modern targets (Rust, Go, TypeScript) with automated differential-execution parity testing.
Open-source, memory-safe quantum control stack in Rust — nanosecond-precision pulse sequencing, cryogenic control, and qubit calibration, built to break vendor lock-in in quantum computing.
Open-source, moving-block railway signaling & PTC system in Rust — replaces legacy track circuits with GPS/INS-based dynamic safety bubbles for safer, higher-capacity rail.
Open-source, cloud-native 5G/6G core network — Go control plane (AMF/SMF/NSSF) + Rust user plane (UPF) with zero-copy XDP/DPDK packet processing. Build your own sovereign mobile network on commodity hardware.
Autonomous lunar microgrid & thermal control system in #![no_std] Rust — TMR-voted fault tolerance, breaker routing, orbital insolation prediction, and MPC-driven radiator control, with Kani-verified safety properties and STM32/RISC-V firmware.
Open-source, memory-safe substation automation and SCADA platform written in Rust. Implements IEC 61850, DNP3, and Modbus TCP for grid protection, real-time load/frequency control, and self-healing fault response — built toward NERC CIP compliance as a low-cost alternative to proprietary systems.
Autonomous multi-agent orchestration framework in Rust. Manages agent lifecycles, decomposes goals into executable DAGs, coordinates agents over NATS/gRPC, and persists shared state/memory via Keystone DB — with MCP protocol support.
Open-source, hardware-agnostic IEC 61131-3 PLC runtime in Rust — Modbus/EtherCAT/PROFINET on any Pi or industrial PC.
Distributed spatial-coordination OS for simulated lunar swarm construction — heterogeneous robots claim voxels, resolve conflicts, and execute a dependency-ordered build graph without a central controller.
Reusable Rust crates for building terminal applications: CLI config, TOTP/QR, color extraction, spinners, and derive macros.
A collection of small, focused Rust crates for async networking: HTTP caching, graceful shutdown, retry logic, TCP connection pooling, and webhook signature verification.
Unified Data Fabric broker that natively speaks MQTT, Kafka, AMQP, and Redis (RESP) wire protocols over one shared storage and routing core — a drop-in replacement for Mosquitto, Kafka, RabbitMQ, and Redis.
Next-generation Infrastructure as Code platform built in Rust — a type-safe, high-performance, truly open (Apache-2.0/MIT) alternative to Terraform, with native multi-cloud support, built-in encrypted state management, and real-time drift detection.
Orchestrate autonomous coding agents (Claude, Cline, or local GGUF) against todo.md with real-time observability, git rollback, and pure Rust tooling.
Open-source, API-first ITSM & workflow engine — durable, Temporal-inspired execution in Go, with workflows defined as code (YAML/TypeScript) instead of locked into a proprietary UI. A fast, self-hostable alternative to ServiceNow.
Memory-safe, declarative network protocol analyzer and packet inspection engine written in Rust — a spiritual successor to Wireshark. Protocols are defined as YAML schemas and compiled into safe parsers at runtime, eliminating the C-dissector buffer overflows that plague traditional packet analyzers.
Open-source, memory-safe flight control software in Rust — from hobby drones to certified eVTOL and transport aircraft, with GPS-denied navigation, formally verified math, and redundant/dissimilar nav for safety-critical flight.
3GPP-compliant 6G mobile core in Rust — async AMF/SMF control plane over a Service-Based Architecture, with a kernel-bypass User Plane Function (UPF). Hand-written GTP-U/PFCP/NGAP codecs, Raft-backed state, round-trip-tested protocols.
Edge & fleet orchestration platform for OTA deployments, canary rollouts, and instant rollbacks — with a Rust control plane, lightweight edge agents, libp2p mesh delta-sharing, and offline-first sync for devices from cloud clusters to disconnected Raspberry Pis.
Real-time, centimeter-accurate lunar digital twin & physics engine — fuses simulated robot-swarm sensor data into a live 3D voxel mesh, runs structural/seismic physics, and streams it to Earth via delta-encoded compression for telepresence.
Open-source reference platform for a unified NZ government portal — federated department nodes, self-custodied DID/VC identity, consent-gated data sharing, and optional AI. TypeScript (Next.js/Turbo) + Rust (Axum) monorepo.
Lightweight local/edge deployment of the TPT Emergency response platform — runs completely standalone on a laptop or Raspberry Pi with zero internet dependency. Ideal for remote or field emergency operations.
Open-source merchant payment management dashboard — transaction processing, refunds, invoicing, revenue analytics, multi-gateway support & subscription billing. Built with TypeScript. MIT licensed.
Fork of GitHub Desktop — open-source Electron-based Git GUI client for Windows, macOS and Linux. Commit, branch, merge, and manage pull requests without touching the command line. TypeScript + React. MIT.
A memory architecture for AI systems where storage, connectivity, and computation are earned through use rather than fixed by schema. Bi-temporal knowledge graph + adaptive connectivity engine + policy-driven consolidation, exposed over gRPC for LLM agents. Rust core, Go consolidation daemon.
Local VS Code proxy that intercepts AI coding requests (Cline, Claude Code) to redact secrets, cache prompts, compress context, and smart-route to cheaper models — cutting LLM costs without changing your workflow.
Open-source Electron desktop app for management consulting knowledge management. Ingests documents and scrapes websites, builds a knowledge graph via LLM-based entity extraction, and generates strategic briefs through RAG-powered querying (Claude, GPT, Groq, OpenRouter).
Open-source AI-driven life-path engine — conversational onboarding generates a personalised quest with milestones, tasks & resources; adaptive check-ins evolve it based on wellbeing. Next.js 15, Prisma, PostgreSQL, OpenRouter.
Open-source middleware and AI control layer for orchestrating fleets of humanoid robots and drones — hardware-agnostic, ROS2-compatible, with federated learning and simulation-to-deployment. The "Linux of physical robotics."
Free open-source ERP system — modular finance, inventory, HR & CRM platform with RESTful API, role-based access control & comprehensive test suite. PHP + PostgreSQL. No vendor lock-in. MIT licensed.
DIY self-hosted email server for Windows — full SMTP/IMAP stack you own and run yourself, no subscriptions, no third-party access. Built with TypeScript. MIT licensed.
Encrypted peer-to-peer mesh communication platform built in Rust + Tauri. QUIC transport, Noise XX handshake, LAN discovery, relay fallback, and MCP/bot API.
Integrated suite for accelerating Linux hardware driver development through automated capture, ML-assisted firmware analysis, and community-driven knowledge sharing — making reverse engineering 10x faster and accessible beyond kernel specialists.
Federated environmental data mesh: IoT sensor nodes gossip observations over QUIC, validate against neighbours, and serve a live HTTP API. Pure-Rust embedded storage, Ed25519-signed readings, SSE streaming. Runs on a Raspberry Pi Zero. No C dependencies, no cloud required.
Open-source library management and discovery platform for public libraries. Web-first, API-first monorepo with patron catalog, staff dashboard, circulation, holds, fines, events, acquisitions, and self-hosted Docker Compose deployment.
Privacy-preserving crowd-sourced BLE tracking network. Beacons rotate their advertising ID every 5 minutes — no stable identifiers, no corporate silo. Subscribers pay per-device; receivers (ESP32 or Android) earn ERC-20 tokens on Polygon for every detection.
WCAG accessibility audit + automated remediation for React, Vue, Angular, Svelte & vanilla HTML — CLI, VS Code, browser extension, Figma & IntelliJ plugins, with confidence-tiered codemods, trend tracking, and compliance reports.
Self-hostable video platform with VOD uploads, FFmpeg/HLS transcoding, adaptive bitrate playback, RTMP live streaming, WebRTC/WHEP, live chat, moderation, and S3-compatible storage. Inspired by YouTube. Apache 2.0.
Enterprise-grade open-source banking platform: retail banking, investment banking, compliance (KYC/AML/SAR), open banking (OBIE/PSD2/FDX), treasury, prime brokerage, and wealth management. NestJS microservices · PostgreSQL · Kafka · Casbin RBAC · Basel III/IV regulatory reporting.
Give PWAs native superpowers without an app store — a statically-typed DSL + lightweight VM that lets web apps declare background tasks, hardware access, and local data ops, executed by a native companion process. Rust engine, Go daemon, Svelte frontend.
Open-source infrastructure engineering platform for civil engineers & project managers — 2D/3D drawing board, AI design generation, materials database, cost estimator, CPM scheduler & regulatory report builder.
Platform for fully automated production — 3D printing, robotics, and AI agents coordinate to fulfil orders end-to-end. Hono API, Next.js 15 apps, Prisma/Postgres, BullMQ job queue, in a pnpm/Turborepo monorepo.
A calm, non-addictive social platform for presence and conversation — persistent chat rooms, ambient co-presence, and async letters. No algorithms, no likes, no infinite scroll. Next.js 15 + TypeScript PWA with E2E encryption.
Open source endpoint security suite for Linux and Windows — firewall, file integrity monitoring, ransomware detection, DNS-over-HTTPS, cloud backup, and threat feed blocking. Written in Go.
Encode legislation as executable YAML rules. Apply law to facts via REST API and get decisions with full reasoning traces — built for AI-assisted legal judgment. New Zealand (Working for Families) included.
Open-source digital will and estate platform for New Zealand — RealMe verified identity (SAML 2.0), Wills Act 2007 compliant, built with Go + Next.js + PostgreSQL.
Concept-stage complementary currency protocol with built-in demurrage, dynamic accumulation caps, and commons redistribution — designed to counter wealth concentration and velocity collapse. Includes a whitepaper, developer docs, and an interactive economic simulator (Next.js 16 + TypeScript).
Open-source water utility management platform — real-time consumption monitoring, smart meter integration, billing, leak detection, maintenance scheduling & compliance reporting. TypeScript. MIT licensed.
Transparent resource consent register for Aotearoa New Zealand — public submissions, council workflow, RealMe identity, LINZ address verification, and iCal hearings feed. Built on the RMA 1991.
Open-source peer-to-peer marketplace for New Zealand, built with Go and Next.js. All users authenticate via RealMe (NZ Government SAML 2.0). High-value listings (vehicles, property, services) require verified identity. Full-text search, private messaging, reviews, and a seller dashboard.
Digital Power of Attorney registry for New Zealand, compliant with the Protection of Personal and Property Rights Act 1988. RealMe Verified identity, attorney acceptance workflow, institution verification API, HMAC-signed webhooks, and public QR-code verification. Built with Go + Next.js.
Open-source national law enforcement management platform — multi-tenant, 4-tier hierarchy (Nation → Province → City → Precinct). Built with Next.js, TypeScript, Prisma, and PostgreSQL. Covers dispatch, case management, evidence room, HR, ERP, body-worn cameras, and a public portal.
RealMe-verified digital credentials wallet for New Zealand professionals. Link professional licences and qualifications to your verified identity and share them via QR code. Built with Go, Next.js, SAML 2.0, and PostgreSQL.
Self-sovereign identity server for Go — OIDC provider, W3C Verifiable Credentials, SD-JWT, DID (web/key/peer/ion), DIDComm v2, guardian recovery, and consent management. Pure-Go SQLite, no CGo.
NZ Government Electronic Tenders Service (GETS) platform — browse, filter, and bid on government procurement opportunities. Go + PostgreSQL backend with RealMe SAML 2.0 auth, Next.js 14 frontend.
Open-source court case management system built with Next.js, Fastify, and Prisma. Manage cases, hearings, parties, documents, payments, and notifications — with role-based access for judges, clerks, lawyers, and public e-filing.
NZISM-compliant sovereign cloud platform for New Zealand, built on OpenStack. Three deployment tiers: General (SMBs), Government (NZ agencies), and Classified (NZDF/intelligence). Includes OPA runtime policies, first open-source OSCAL mapping of NZISM v3.9, and continuous biometric authentication.
Open-source reference gateway for Trust-First Email Protocol (TFEP) — cryptographic sender identity via Ed25519 + DID:web, spam/phishing prevention, verified webhooks, B2B document exchange, and non-repudiable legal notices. SMTP-compatible. Written in Go.
Open-source security assessment and compliance audit platform. Scan, audit, and report for SOC 2, ISO 27001 & HIPAA — CLI + web UI.
A self-hostable school management platform built with Next.js, covering student enrolment, staff & HR, timetabling, attendance, gradebook, behaviour tracking, parent portal, finance, and report card generation. Packaged with Docker and an Electron installer for Windows/Mac.
Open-source smart city management platform — real-time traffic, energy grid, water utility, public safety, environmental monitoring, 3D digital twin & AI cross-domain orchestration. Self-hostable. MIT licensed.
A HIPAA/GDPR-compliant medical practice management platform built as a TypeScript monorepo. Covers EHR, appointments, telemedicine, billing, prescriptions, lab orders, and a patient portal — with multi-country support (AU, NZ, UK, CA) and deployable to AWS, Azure, GCP, or on-premise.
A parametric high-rise building design system. Structural, cost, carbon, compliance, and construction outputs are derived mathematically from a small set of inputs. Includes a 3D viewer, IFC/DXF export, subcontractor tender workflow, IPCC climate scenario modelling, and NZ/AU/US/EU code compliance checks.
Open-source offline-first emergency response platform — modular fire, ambulance, police & disaster management, live dispatch console, Bluetooth mesh networking, unit tracking, and offline mapping. PWA. MIT.
Open-source government services platform — AI-powered document processing, multi-tenant departments, workflow automation, digital signatures, WCAG 2.1 accessibility, multi-language PWA. PHP 8.2. MIT licensed.
Open-source electricity utility management platform — grid monitoring, real-time consumption analytics, smart meter integration, outage management, billing engine & customer self-service portal. TypeScript. MIT.
High-performance physics simulation engine written in Rust — rigid body dynamics, collision detection, constraint solver, broad/narrow phase algorithms, and game-ready integration. MIT licensed.
Research-grade Python desktop app for exploring the 7 Millennium Prize Problems — Riemann Hypothesis, Navier-Stokes, P vs NP, Yang-Mills, Hodge Conjecture & more. GPU-accelerated. Exports LaTeX & PDF. MIT.
Professional open-source HTML5/WebGL game engine — PBR rendering, Entity-Component-System, physics, skeletal animation, visual scripting, multiplayer framework & built-in editor. Runs in any browser. No licence fees. MIT.
Open-source privacy-first decentralized social network — IPFS content storage, end-to-end encryption, self-sovereign identity, DID support, blockchain integration & zero data harvesting. Node.js. MIT.
Open-source public transportation platform for cities & municipalities — real-time GPS fleet tracking, multi-modal journey planning, fare management, driver & passenger PWA. PHP + PostgreSQL + PostGIS. MIT.