Back to repositories
Repository Reference Table
Every public repository, what it does, its category, and the commercial software it was designed to replace or compete with.
| Repository | Description | Category | Replaces / Competitors |
|---|---|---|---|
| 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. | Applications | LiteLLM Proxy, OpenRouter, direct API usage in Cline/Claude Code | |
| Guide to the TPT Solutions open-source ecosystem: 300+ Rust repos grouped by layer, how the foundation crates fit together, and live todo.md progress. | — | ||
| 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. | — | ||
| Ultra-fast, zero/low-allocation Rust parsers for niche data formats (JSONL, GeoJSON, logfmt, cron, MIME). | — | ||
| 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. | — | ||
| 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. | — | ||
| Offline-first, app-store-free PWA framework — Svelte/TS frontend with an optional native companion (Go + Rust) for true background processing, persistent storage, and hardware access. | — | ||
| Local-first AI coding assistant. Features a Rust daemon, Tree-sitter + BM25/vector indexing, GGUF inference, and VS Code/JetBrains extensions. | — | ||
| 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. | — | ||
| 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. | — | ||
| Privacy-first, open-source NZ Road User Charges (RUC) tracking: shared Rust core, ESP32 GPS reference node, offline PWA and self-hostable backend. Not an NZTA Section 43 approved distance recorder. | — | ||
| 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. | — | ||
| A memory-safe, composable Rust media processing platform designed to become a modern alternative to FFmpeg. | — | ||
| Portable, zero-cost SIMD abstractions for Rust DSP and codec development: complex math, fixed-point, butterflies, transpose, saturation and more. 22 focused no_std crates over x86_64, ARM64 and RISC-V. Design phase. | — | ||
| Executable orchestration layer for the TPT ecosystem. Wires tpt-norma policy evaluation, tpt-writ execution permits, and tpt-concord audit logging into one fail-closed endpoint (HTTP and MCP) for AI agents and domain applications. Dual-licensed MIT OR Apache-2.0. | — | ||
| 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. | — | ||
| Pure-Rust conformance, fuzzing, and benchmarking harness for the TPT AV Stack — golden-master testing, real-time safety checks, and mock hardware, MIT/Apache-2.0 licensed. | — | ||
| A high-performance, zero-cost Rust toolkit for local AI. Features HuggingFace model caching, LoRA weight merging, safetensors I/O, and pure-Rust tokenization. | — | ||
| 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. | — | ||
| Durable execution / BPM engine — orchestrates long-running, stateful workflows across your microservices with crash-safe replay, sandboxed WASM workers, and gRPC task dispatch. | — | ||
| Proof-gated capability guard for MCP tool calls — derive minimal tool scopes from verified proofs, enforce fail-closed. | — | ||
| 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. | — | ||
| 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) | — | ||
| 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. | — | ||
| 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. | — | ||
| First-principles, multi-scale computational platform for whole-body human physiology — unifying multi-omics, clinical, and sensor data into mathematically rigorous digital twins. | — | ||
| Find Cargo target/ folders, see how big they are and how long since they were built, and safely archive the ones you don't need. CLI and native GUI, written in Rust. | — | ||
| Pure-Rust, no_std-capable domain modeling, schema registry, and type-safe schema evolution engine for the TPT ecosystem. | — | ||
| Optimisation analysis for Rust projects. Combines static analysis, runtime profiling and benchmarks to rank what's worth optimising next, with impact, confidence and effort estimates. Dual-licensed MIT OR Apache-2.0. | — | ||
| Experimental Rust research workspace testing whether a compact, typed task notation for LLM prompts can preserve meaning, constraints and permissions while cutting total cost per successful task. No efficiency claims until measured. | — | ||
| Cognitive process and thought-representation engine in Rust: the explicit loop from observation to decision, action, learning and sleep, independent of any model or backend. MIT OR 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. | — | ||
| 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. | — | ||
| Session-typed channels and compile-time reactive signals for Rust — statically verified protocol and dataflow correctness via tpt-telos. | — | ||
| 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. | — | ||
| 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. | Infrastructure | NVIDIA CUDA, AMD ROCm, Apple Metal, OpenCL, Triton | |
| A webview app shell for Rust: licence-clean, secure by default, and built for kiosks, regulated work and AI agents. Talks to WebView2, WKWebView and WebKitGTK directly, with no wry/tao/Tauri. | — | ||
| 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. | — | ||
| Modular Rust workspace for domain-aware, high-performance compression: tensor-aware ML model archives, indexed log archives, and zero-copy game asset packs, built as reusable library crates with a unified CLI. | — | ||
| 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. | — | ||
| Runtime-agnostic async I/O stack for Rust — no_std-compatible traits, executor, timer wheel, TLS, HTTP, and WebSocket across 9 focused crates. | — | ||
| 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. | Infrastructure | Auth0, Keycloak, Okta, Ory Hydra/Kratos | |
| Peripheral nervous system for the TPT robotics ecosystem. A hardware-agnostic Rust SDK, embedded edge firmware (ESP32/STM32) and protocol layer that connects tpt-cerebrum, tpt-soma and tpt-chrysalis to self-healing, morphing end-effectors, with a formally verified, signed power handshake. MIT OR 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. | — | ||
| 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. | — | ||
| Modular Rust research platform for building, simulating and validating biologically grounded neural circuit emulations, scaling progressively toward whole-brain emulation. Reuses TPT Solutions foundations. Dual-licensed MIT OR Apache-2.0. | — | ||
| 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. | — | ||
| Shared wire layer for the TPT ecosystem: CRC-checked frame format, UDP/serial/CAN transports, sequencing, heartbeat and reconnect with backoff. no_std-friendly core. | — | ||
| Pure-Rust, no_std, deterministic operation & command modeling engine: validate, apply, invert (undo/redo), serialize, and replay state mutations. CRDT-ready. | — | ||
| 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. | — | ||
| Applied engineering primitives (fluid/gas properties, sensor timeseries alignment, infrastructure topology, control systems) for the tpt-solutions physical-systems verticals | — | ||
| Rust workspace for indexing and understanding codebases — parses source into symbol records (structs, enums, traits, impls, functions) and builds a cross-file symbol graph (modules, crates, dependencies, references, callers/callees) for downstream tooling. | — | ||
| Pure-Rust, no_std content-addressable version control for structured data: Merkle DAG, structural diff, and 3-way merge for tpt-model entities. | — | ||
| Integration harness that closes the loop between tpt-telos (verified codegen) and tpt-archon (capability kernel) | — | ||
| Pure-Rust, no_std, offline-first P2P sync and CRDT merge engine: hybrid logical clocks, replicated op logs, delta sync, and transport-agnostic peer messaging. | — | ||
| High-performance, local-first Rust CLI that audits dependency trees for CVEs, license violations, and bloat — no telemetry, fully air-gapped after update. | — | ||
| 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. | — | ||
| Pure-Rust, no_std 2D vector graphics API. Write drawing code once and render it to PDF, SVG, a pixel buffer, WebGPU, or HTML Canvas2D, with deterministic output. | — | ||
| Pure-Rust, no_std, SIMD-accelerated 2D rasterizer and image compositor: analytic anti-aliasing, Porter-Duff blending, filters, and byte-identical output across x86_64, ARM64, and WASM. | — | ||
| 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. | — | ||
| 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. | — | ||
| 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. | — | ||
| 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 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. | — | ||
| 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. | — | ||
| 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. | — | ||
| Shared canonical primitives (identity, capability, intent, computation, execution, evidence, claim) underpinning the Fabric, Repro and Concord ecosystem — dual-licensed MIT/Apache-2.0. | — | ||
| Sync-native storage for offline-first apps. A pure-Rust, no_std append-only key-value store whose write log doubles as the replication feed, plus a CRDT sync engine (tpt-rift). No SQLite, no triggers, no C FFI. MIT OR Apache-2.0. | — | ||
| Pure-Rust, no_std, exact symbolic math engine: canonical ASTs, rewrite-based simplification, differentiation, integration, and equation solving. | — | ||
| 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. | — | ||
| Pure-Rust, no_std embedded declarative query engine for structured entity graphs: filtering, projection, graph traversal and aggregation with no database required. | — | ||
| A patent-free, clean-room media codec suite in Rust. Three purpose-built tiers each for audio and video (real-time, high-fidelity/archival, and edge/IoT), a custom lightweight .tpt container format, a CLI, a WASM browser player, and C FFI bindings. 100% public-domain DSP — no CABAC, no fractional-pixel interpolation, no SBR. | — | ||
| Pure-Rust, zero-FFI text shaping, bidi, line breaking, paragraph layout and hit-testing. no_std + alloc, with deterministic fixed-point output. | — | ||
| Pure-Rust, deterministic, no_std box and page layout engine: Flexbox, Grid, absolute positioning, inline flow and page breaks for PDFs, web UIs and CAD title blocks. | — | ||
| Pure-Rust, no_std colour management: colour spaces, alpha compositing, ICC v2/v4 profiles, and gamut mapping, with no C-FFI. | — | ||
| 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. | — | ||
| Unified golden-file, benchmarking, fuzzing, and property-testing infrastructure for the TPT Rust ecosystem. | — | ||
| Pure-Rust, AI-native computational acoustics library — geometric room acoustics, wave acoustics (BEM/FEM Helmholtz), aeroacoustics, vibroacoustics & psychoacoustics. No C/C++ FFI. Dual-licensed MIT/Apache-2.0. | — | ||
| Decentralized ambient compute fabric: unifies idle edge devices (cars, robots, phones) and datacenter spot capacity into a self-verifying P2P network using dynamic quorum consensus and heterogeneous hardware redundancy. Written in Rust. | — | ||
| Pure-Rust, memory-safe speech processing engine — transcription, voice isolation, speaker diarization, and text-based editing. Zero C/C++ bindings, dual MIT/Apache-2.0 licensed. | — | ||
| Pure-Rust, formally verified 3D spatial library suite with two-layer (QF_LRA ideal + bounded f64 realization) soundness. | — | ||
| Breach-tolerant data security for Rust without payload encryption: field-level fragmentation across isolated vaults, RAM-only reassembly, short-lived capability tokens, canary decoys and anonymized analytics. Built on tpt-keystone-db and tpt-strata. MIT OR Apache-2.0. | — | ||
| Pure-Rust, AI-native control systems library — state-space modeling, classical/optimal control, state estimation, and MPC, with zero C/C++ FFI and zero external solver dependencies. MIT OR Apache-2.0. | — | ||
| 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 | — | ||
| Memory-safe, GPU-accelerated video processing engine — real-time compositing, color science, and effects for the TPT AV stack. Rust · wgpu · MIT OR Apache-2.0 | — | ||
| Arbitrary-precision, proof-aware numerical engine in Rust: bigints, rationals, floats, modular arithmetic, polynomials, number theory and certificate generation. Part of the TPT Solutions math ecosystem. | — | ||
| Ultra-lean, self-hosted home server platform in a single Rust binary. Axum + SQLite + Leptos, with macro-driven blueprints and WASM plugins. MIT OR Apache-2.0. | — | ||
| 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. | — | ||
| 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, AI-native FEA/DEM/CFD physics simulation framework — data-oriented, unit-safe, zero C/C++ FFI. Dual-licensed MIT/Apache-2.0. | — | ||
| Formal-verification and design-by-contract foundation for Rust — typestate, ghost state, proof ASTs, deterministic simulation, and fault-tolerance harnesses. | — | ||
| Pure-Rust, AI-native computational chemistry and molecular simulation library — molecular dynamics, quantum chemistry (Hartree-Fock/DFT), reaction kinetics, and crystallography, with zero C/C++ FFI or external solver dependencies. | — | ||
| Pure-Rust, AI-native applied fluid mechanics library — 1D hydraulic networks, marine hydrodynamics, and tribology in one feature-gated workspace, with no C/C++ FFI or external solver dependencies. MIT OR Apache-2.0. | — | ||
| Pure-Rust, AI-native computational optics & photonics library — geometric/wave optics, polarization, photonic device modeling, and optical design optimization with zero C/C++ FFI. Dual-licensed MIT OR Apache-2.0. | — | ||
| Pure-Rust, formally-verified WebRTC stack — AV1-first, zero libwebrtc, MIT OR Apache-2.0. | — | ||
| Pure-Rust, AI-native discrete event simulation library — event calendars, queuing theory, Petri nets, Markov chains, and resource contention modeling with zero external solver dependencies. | — | ||
| Pure-Rust, AI-native aerodynamics and flight mechanics library — VLM, panel methods, and BEMT solvers, atmospheric modeling, and stability derivative extraction, with no C/C++ FFI or external solver dependencies. MIT/Apache-2.0 dual-licensed. | — | ||
| Unified workload runtime for Windows and heterogeneous compute — a common substrate for native, Linux, OCI, WASM, and AI workloads with capability-based security. Not a WSL clone. | — | ||
| Fully open-source, pure-Rust computational biomechanics and medical device simulation engine, compiling to WASM for zero-cloud, browser-based surgical planning. | — | ||
| Pure-Rust, zero-dependency audio codec suite (WAV, AIFF, FLAC, AAC, Opus, MP3, Vorbis). Memory-safe, real-time capable, dual-licensed MIT/Apache-2.0. Part of the TPT AV Stack by TPT Solutions. | — | ||
| Pure-Rust, AI-native 3D spatial perception and sensor fusion library — point cloud processing, SLAM, multi-sensor fusion, and spatial registration with zero C/C++ FFI or external dependencies. | — | ||
| 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. | — | ||
| Modular, memory-safe, no_std-first Rust ecosystem for RISC-V: arch, HAL, async, SBI/boot, NPU and embedded Linux tooling. MIT OR Apache-2.0. | — | ||
| No description | — | ||
| 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. | — | ||
| Auditable, reproducible actuarial modeling in Rust: mortality, loss triangles, stochastic reserving, IFRS 17 / Solvency II cash flows, credibility and pricing. A fast, deterministic alternative to R and proprietary actuarial software. MIT OR Apache-2.0. | — | ||
| Rust toolchain for compiling AI models onto edge hardware. Ingests ONNX, GGUF, PyTorch, Keras and TFLite models, then quantizes, partitions and pre-flights them for ESP32 swarms (alloy), FPGA overlays (fusion) and PCB/netlist simulation (element). Includes a CLI, a web observer with a swarm topology map, and CI. | Infrastructure | Apache TVM, MLIR/LLVM, Xilinx Vitis AI, Intel OpenVINO | |
| Rust sensory and perception foundation for cognitive, robotic and autonomous systems. Turns measurements from any sensor, real or simulated, into observations with uncertainty and provenance. no_std-friendly. MIT OR Apache-2.0. | — | ||
| 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. | — | ||
| 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. | — | ||
| 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, CRDT-based real-time collaboration engine for media timelines — multi-user editing, playhead sync, and conflict-free state replication for audio/video. Part of the TPT AV Stack. Dual-licensed MIT OR Apache-2.0. | — | ||
| Pure-Rust, real-time safe studio protocol suite — OSC, MIDI 2.0 (UMP), DMX/Art-Net/sACN, and hardware control surface integration. Dual-licensed MIT/Apache-2.0. | — | ||
| A pure-Rust, background media asset management engine — proxy generation, waveform peak caching, thumbnail indexing, and filesystem monitoring. The performance backbone of the TPT AV stack. Dual-licensed MIT/Apache-2.0. | — | ||
| Test & assembly operational software for silicon manufacturing — SECS/GEM equipment comms, STDF V4, wafer bin-sort, and pluggable wire-bond/flip-chip/chiplet assembly, built for OSATs and fabs handling test/assembly in-house. | — | ||
| 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. | — | ||
| 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. | — | ||
| Rust-native structured intelligence primitive: typed, deterministic decisions (classify, rank, score, predict, compare) without natural-language generation or vendor lock-in. | — | ||
| 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. | — | ||
| 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 Rust middleware for autonomous farming machinery — RTK/IMU nav, ISOBUS, teleop handover, and lock-free real-time control for tractors, combines, and sprayers. | — | ||
| Modern file search & launcher (Everything/PowerToys Run alternative) — Rust engine (USN Journal / inotify) + Tauri UI, with an optional local semantic search layer via Ollama. Windows, Linux, and Archon. | — | ||
| 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. | — | ||
| 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. | — | ||
| 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. | — | ||
| Fully open-source, pure-Rust computational engine for energy systems, power grids, and renewable integration. MIT OR Apache-2.0. | — | ||
| 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. | — | ||
| A pure-Rust, MIT/Apache-2.0 multiphysics simulation engine for electronic systems (thermal, Joule heating, SPICE, signal integrity, RF, power, EMC, battery). Parses Gerber/KiCad/ODB++, runs coupled electro-thermal FEM, and compiles to WASM — fully open source with a strict MIT license chain | — | ||
| Unified notification & focus center for Windows and Linux — a Rust core engine with rule-based batching and context-aware muting (e.g. mute Slack when your IDE is fullscreen), a searchable history, and a native tray/popup GUI. Dual-licensed MIT/Apache-2.0. | — | ||
| Blazing-fast dual-pane file explorer built with Tauri and TypeScript — persistent tabs, command palette, built-in archiving, and live directory watching. | — | ||
| 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. | — | ||
| Unprivileged-caller-to-privileged-daemon primitive for host control operations — typed command envelope, per-command policy checks, tamper-evident audit log, and capability-dropping. Shared plumbing for TPT Solutions control-system repos. | — | ||
| Rust-native, memory-safe OPNsense-equivalent firewall/router. Structured filter/NAT/traffic-shaping rule model with graph-based verification, built to compose with separate dataplane, privileged-execution, HA, and DPI components. Dual-licensed MIT/Apache-2.0. | — | ||
| Backend-independent Rust API for Linux dataplane control (filter/NAT/rate-limit) over nftables and eBPF/XDP. | — | ||
| 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. | — | ||
| 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. | — | ||
| 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). | — | ||
| 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. | — | ||
| 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. | — | ||
| Simple, modern audio router and virtual mixer for Windows, Linux, and Archon — a drag-and-drop routing matrix with zero-latency, low-CPU, per-app volume control. | — | ||
| 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. | — | ||
| 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. | — | ||
| Pure-Rust, GPU-accelerated media UI components — waveform renderers, timeline scrubbers, node graphs, and meters for building audio/video editors. Dual-licensed MIT/Apache-2.0. | — | ||
| An ultra-lightweight, event-driven sync client and virtual file system for OneDrive & SharePoint, built with Tauri, Rust, and rclone. Zero polling, low resource usage, first-class Enterprise/SharePoint support. | — | ||
| Zero-allocation barcode generation and scanning for Rust — no_std compatible, perspective-corrected QR scanning, pure MIT/Apache dependency chain. | — | ||
| Rust toolkit for fab equipment integration (SECS/GEM) and process simulation, with pluggable lithography backends and privacy-preserving outcome aggregation. | — | ||
| 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. | — | ||
| A keyboard-driven, Rust-native window tiling and workspace manager for Windows, Linux, and Archon. A fast, scriptable FancyZones/DisplayFusion alternative with a TypeScript visual zone editor. Dual-licensed MIT/Apache-2.0. | — | ||
| Persistent virtual-desktop & workspace manager for Windows and Linux — remembers app-to-desktop assignments, restores window geometry, and pauses background apps on inactive workspaces. Dual-licensed MIT OR Apache-2.0. | — | ||
| A hardware-accelerated, instant-loading image viewer & batch converter for Windows and Linux — a modern IrfanView/XnView alternative built in Rust (wgpu) + Tauri. MIT OR Apache-2.0. | — | ||
| Local-first encrypted vault and secure markdown notes editor — a friendlier VeraCrypt alternative with Windows Hello / Linux biometric unlock. Windows, Linux & Archon. | — | ||
| Open-source, versioned backup & sync utility for local drives, SMB, WebDAV, S3, and major cloud providers — a FreeFileSync/GoodSync alternative with no paywalled scheduling or destination limits. Go core + Rust (BLAKE3) checksumming, Tauri tray/GUI, Windows & Linux (Archon-ready). Dual-licensed MIT OR Apache-2.0. | — | ||
| Smart Startup & Background Service Manager — a unified dashboard that finds every startup item on Windows and Linux (registry runners, scheduled tasks, systemd units, cron, autostart entries), sorts them into Safe/Recommended/Critical, and explains each in plain English. Rust + Tauri. Dual-licensed MIT OR Apache-2.0. | — | ||
| Open-source GlassWire alternative: real-time per-app bandwidth monitoring, historical usage, and one-click firewall blocking. Rust core (WFP/ETW on Windows, nftables/eBPF on Linux) + Tauri UI. Windows & Linux for v1; Archon support planned. | — | ||
| A beautiful, customizable system resource monitor for Windows, Linux, and Archon — the modern Process Hacker / System Informer alternative, with a widget-based dashboard, desktop overlays, and smart process suggestions. | — | ||
| Lightweight, offline UI macro & workflow recorder for Windows and Linux — Rust core with native GUIs, no Wayland/X11 hacks required. | — | ||
| Modern, cross-platform font manager for designers & devs — session-scoped temporary font activation, duplicate detection, and variable font previewing. Rust core + Tauri UI, targeting Windows and Linux. | — | ||
| Open-source bulk software uninstaller for Windows, Linux & Archon — deep leftover cleanup and real-time install snapshotting | — | ||
| 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). | — | ||
| Open-source, pure-Rust micro-scale materials physics engine (crystal plasticity, phase-field, diffusion, micro-mechanics, degradation). MIT OR Apache-2.0. Micro-scale physics, macro-scale impact. | — | ||
| 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. | — | ||
| 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 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. | — | ||
| 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. | — | ||
| 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. | — | ||
| 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. | — | ||
| 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. | — | ||
| 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). | — | ||
| 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. | — | ||
| 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. | — | ||
| 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. | — | ||
| 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. | — | ||
| 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. | — | ||
| Pure-Rust computational electromagnetics: MNA circuit simulation, device models, quasi-static Maxwell FEM, transmission lines, S-parameters, and power systems. | — | ||
| 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. | — | ||
| 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. | ApplicationsInfrastructure | Stripe, PayPal, Square, Adyen | |
| 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, 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. | — | ||
| An AI-native language and agentic compiler that turns declared intent, invariants, and constraints into formally verified Rust and Go code. | — | ||
| 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. | — | ||
| 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. | — | ||
| A Rust mathematical reasoning lab: a small trusted proof kernel plus automation, counterexample search, and conjecture generation to prove, disprove, repair, and audit mathematics. | — | ||
| 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, planetary-scale GIS engine — a zero-FFI replacement for GDAL/PROJ/GEOS with no_std support for edge/embedded and cloud-native COG streaming. Dual-licensed MIT/Apache-2.0. | — | ||
| 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. | Infrastructure | NASA GMAT, AGI STK, Orekit, Basilisk | |
| 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. | — | ||
| 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. | — | ||
| 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. | — | ||
| Rust workspace for modeling, simulating, optimizing, and controlling thermal energy systems — local-first and simulation-first. | — | ||
| Embodied-AI / bio-hybrid android platform — neuromorphic computation, formally-verified physical safety, and simulation-first robotics for the tpt ecosystem. | — | ||
| 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. | — | ||
| 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. | — | ||
| 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. | — | ||
| 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. | — | ||
| 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). | — | ||
| 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. | — | ||
| 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. | — | ||
| 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. | Applications | LM Studio, Jan.ai, Ollama (desktop UI), GPT4All | |
| 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. | — | ||
| 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. | ApplicationsNew Zealand | Orion Health, Medtech Evolution, Jade System One, Epic (NZ pilots) | |
| 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. | — | ||
| 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. | Applications | Microsoft 365, Google Workspace, LibreOffice, OnlyOffice | |
| 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. | — | ||
| 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. | — | ||
| 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. | Applications | AIMS (airport software), Jeppesen FliteDeck, NAVBLUE, Sabre AirVision | |
| 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. | Applications | ESO Suite (offline mode), Spillman Flex, Tyler New World CAD | |
| Open-source merchant payment management dashboard — transaction processing, refunds, invoicing, revenue analytics, multi-gateway support & subscription billing. Built with TypeScript. MIT licensed. | Applications | Stripe Dashboard, Square Dashboard, PayPal Business Hub | |
| 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. | Applications | GitHub Desktop, GitKraken, Sourcetree, Fork | |
| Bioprinting/food-printing CAD and slicer with an integrated rheology solver. It models shear-thinning and yield-stress inks to predict extrusion pressure and slumping. It generates G-code for Klipper, Marlin and RepRap, supports 5-axis toolpaths, and exports 3MF. Rust + Tauri desktop app. | — | ||
| 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. | — | ||
| 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). | Applications | — | |
| 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. | Applications | — | |
| 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." | Infrastructure | — | |
| 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. | Applications | SAP Business One, Odoo, ERPNext, Dolibarr | |
| 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. | Infrastructure | Microsoft Exchange, Google Workspace, Postfix, Mailcow | |
| Encrypted peer-to-peer mesh communication platform built in Rust + Tauri. QUIC transport, Noise XX handshake, LAN discovery, relay fallback, and MCP/bot API. | Infrastructure | Signal, Matrix/Element, Briar, Session | |
| 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. | Infrastructure | Ghidra, IDA Pro, manual kernel driver development | |
| 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. | Infrastructure | ThingsBoard, InfluxDB + Telegraf, Particle.io, AWS IoT Core | |
| 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. | Applications | Koha, Evergreen ILS, Ex Libris Alma, Destiny (Follett) | |
| 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. | Infrastructure | Apple AirTag / FindMy, Tile, Samsung SmartTag, Chipolo | |
| 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. | Applications | axe DevTools, Deque WorldSpace, Lighthouse, WAVE by WebAIM | |
| 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. | Applications | YouTube, Vimeo, PeerTube, Wistia, Bunny Stream | |
| 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. | Applications | Mambu, Temenos Transact, Thought Machine Vault, Finxact | |
| 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. | Infrastructure | — | |
| 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. | Applications | Autodesk Civil 3D, Bentley OpenRoads Designer, ESRI ArcGIS | |
| 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. | Applications | — | |
| 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. | Applications | — | |
| 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. | InfrastructureApplications | CrowdStrike Falcon, Malwarebytes, Windows Defender, ClamAV | |
| 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. | InfrastructureNew Zealand | OpenFisca, Blawx, Catala, Rules as Code (NZ DIA initiatives) | |
| 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. | ApplicationsNew Zealand | Public Trust NZ, Safewill, LegalZoom, Perpetual Guardian | |
| 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). | Applications | — | |
| Open-source water utility management platform — real-time consumption monitoring, smart meter integration, billing, leak detection, maintenance scheduling & compliance reporting. TypeScript. MIT licensed. | Applications | Veolia Aquadvance, Itron Total Water Management, Oracle Utilities Water | |
| 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. | ApplicationsNew Zealand | Auckland Council eServices, Objective ECM, local council RMA portals | |
| 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. | ApplicationsNew Zealand | Trade Me, Facebook Marketplace, Craigslist, Gumtree NZ | |
| 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. | ApplicationsNew Zealand | Public Trust NZ, paper-based POA systems, Perpetual Guardian | |
| 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. | Applications | Axon Records, Tyler Technologies, MarkLogic Law Enforcement, Motorola CommandCentral | |
| 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. | ApplicationsNew Zealand | NZQA portal, MySkills NZ, LinkedIn Certificates, Credly | |
| 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. | ApplicationsNew Zealand | GETS (govt.nz existing system), Tenderlink, Tenders.net | |
| 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. | Applications | Tyler Technologies Odyssey, Thomson Reuters eCourt, Justice Systems, Catalis | |
| 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. | InfrastructureNew Zealand | AWS NZ regions, Azure New Zealand North, Datacom Cloud, Catalyst Cloud | |
| 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. | Infrastructure | Gmail / Google Workspace, Proton Mail, standard SMTP (Postfix/Exim) | |
| Open-source security assessment and compliance audit platform. Scan, audit, and report for SOC 2, ISO 27001 & HIPAA — CLI + web UI. | ApplicationsInfrastructure | Qualys VMDR, Rapid7 InsightVM, Tenable Nessus, Drata | |
| 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. | Applications | KAMAR (NZ), Edge Learning, Schoology, PowerSchool, Compass | |
| 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. | Applications | Microsoft Azure Smart City, IBM Maximo, Siemens City Performance Tool, Cisco Kinetic | |
| 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. | Applications | Medtech Evolution (NZ), Genie Solutions (AU), Epic, Cerner, Cliniko | |
| 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. | Applications | Autodesk Revit, ArchiCAD, SketchUp Pro, Vectorworks | |
| 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. | Applications | ESO Suite, ImageTrend Elite, FirstWatch, Motorola PremierOne | |
| 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. | Applications | ServiceNow Government, Salesforce Government Cloud, Pega | |
| 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. | Applications | Oracle Utilities, SAP IS-U, Itron GridStream, Landis+Gyr | |
| 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. | Infrastructure | Box2D, Bullet Physics, NVIDIA PhysX, Rapier | |
| 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. | Applications | Mathematica, SageMath, MATLAB, Maple | |
| 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. | InfrastructureApplications | Unity, Godot, Phaser, Three.js, Babylon.js | |
| 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. | Applications | Mastodon, Bluesky, Nostr clients, Diaspora | |
| 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. | Applications | Trapeze Group, Cubic Transportation, Transdev HASTUS, OpenTripPlanner |
352 repositories · Competitor data is indicative — these projects are alternatives, not direct replacements.