Open Source Projects

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.

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.

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

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 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.

Maths. Rust + Lean 4 engine that discovers, verifies, minimizes, and publishes novel theorems — symbolic search by default, AI-assisted when you want it.

An AI-native language and agentic compiler that turns declared intent, invariants, and constraints into formally verified Rust and Go code.

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.

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.

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.

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.

Durable execution / BPM engine — orchestrates long-running, stateful workflows across your microservices with crash-safe replay, sandboxed WASM workers, and gRPC task dispatch.

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.

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.

Formally verified, sub-second settlement protocol for autonomous AI agent payments — nano-denominated value transfer under cryptographically enforced human-delegated mandates.

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.

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 memory-safe, lock-free media processing engine in Rust. The modern, hyper-concurrent successor to FFmpeg for production pipelines.

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.

Local-first AI coding assistant. Features a Rust daemon, Tree-sitter + BM25/vector indexing, GGUF inference, and VS Code/JetBrains extensions.

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.

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.

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 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.

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.

A unified, cross-platform, zero-cost async I/O framework for Rust, abstracting io_uring, IOCP, and kqueue behind a single memory-safe API.

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.

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.

Ultra-fast, zero/low-allocation Rust parsers for niche data formats (JSONL, GeoJSON, logfmt, cron, MIME).

A high-performance, zero-cost Rust toolkit for local AI. Features HuggingFace model caching, LoRA weight merging, safetensors I/O, and pure-Rust tokenization.

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.

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).

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.

A Rust dev-tooling workspace featuring isolated env mocking, zero-dep snapshot testing, realistic fake data, ephemeral FS fixtures, and a TUI cargo scrubber.

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.

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.

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-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.

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).

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.

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.

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.

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.

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.

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 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."

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.

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.

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.