# Rust Projects at AI Tinkerers

> Canonical HTML: https://aitinkerers.org/technologies/rust
> Markdown URL: https://aitinkerers.org/technologies/rust.md
> Technology record last updated: 2026-09-18T15:13:50Z
> Generated: 2026-09-20T14:47:18Z

Rust is a high-performance systems programming language that guarantees memory and thread safety via its compile-time ownership model.

Rust is a statically-typed systems language engineered for performance and reliability, directly challenging C/C++ in speed. Its core innovation is the ownership model and 'borrow checker,' which enforces strict memory and thread safety at compile-time, eliminating data races and null pointer dereferences without a conventional garbage collector. Rust achieves near-native speed through 'zero-cost abstractions,' allowing high-level features to compile into highly optimized code. Major industry players, including Microsoft and Cloudflare, leverage Rust for critical infrastructure, and it is now officially supported for development in the Linux kernel.

- Official technology site: https://www.rust-lang.org/
- Public AI Tinkerers demos and talks: 55
- Result page: 1 of 3

## Recent Public Talks and Demos

### [Local AI on anything with NobodyWho](https://copenhagen.aitinkerers.org/talks/rsvp_eeot-Z52CbQ)

An open-source library for running local LLMs on any hardware: custom inference engine in Rust with bindings to 6 languages, builds for 7 operating systems, and hardware accelerating on anything.

- Event context: September Demo Night — 2026-09-16 — Copenhagen
- Public talk page: https://copenhagen.aitinkerers.org/talks/rsvp_eeot-Z52CbQ

### [Learn Anything by Doing: An Agent That Teaches, a Grader That Can't Flatter You](https://hong-kong.aitinkerers.org/talks/rsvp_9jqGP6qJZHg)

Carpenter is a tool for learning by doing: you tell your AI agent what you want to master, it drafts a course outline for your approval, renders Jupyter notebooks with practice stubs and quizzes — and the second you hit Run, you get an instant, honest per-case PASS/FAIL. The agent teaches; carpenter grades. The key trust move: grading is locked to an answer key the agent can't see at grade time (lesson verify against an authored reference solution), and the grading helper is structurally verification-only — it can never print expected. A pass is a real pass, not the AI being nice to you. Live demo, two beats. Beat 1 (the main event): from "I want to learn X" to a graded notebook in minutes — agent drafts the plan, I approve it, a rendered notebook appears (SQLite is the source of truth; notebooks are just views), I fill in a practice stub, Run, instant feedback, then progress summary showing exactly what's done and where I'm stuck. Beat 2 (the twist, short): this tool is itself built by the same kind of loop — I'll add a command via an agent and show the build refusing to compile until the docs and tests exist. The learning tool dogfoods its own philosophy.

- Event context: AI Tinkerers Hong Kong: August Meetup with OAX Foundation and GMAsia — 2026-08-31 — Hong Kong
- Public talk page: https://hong-kong.aitinkerers.org/talks/rsvp_9jqGP6qJZHg

### [Prairie Engine and the Frontier of Simulation](https://atlanta.aitinkerers.org/talks/rsvp_OG4-D-AvZ7g)

I built a general simulation engine. Once a user puts in an API key, they can type something in and the engine will generate a full simulation complete with metrics, visuals, and a cohesive storyline. The central mechanism is having an LLM rewrite an entire .html page to render each "turn," as opposed to static text-only replies.

- Event context: AI Tinkerers Atlanta: 2-Year Anniversary & Best Demos of the Year — 2026-07-30 — Atlanta
- Public talk page: https://atlanta.aitinkerers.org/talks/rsvp_OG4-D-AvZ7g

### [better code search for agents](https://seattle.aitinkerers.org/talks/rsvp_xeiKfEt_v-U)

It's a new programming language for agents, but today we'll focus on how easy it is for the agents to search through the codebase.

- Event context: AI Dev Tools Track - Seattle - July 13 — 2026-07-14 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_xeiKfEt_v-U

### [Nika - Intent as code](https://paris.aitinkerers.org/talks/rsvp_6XBmEC8IoVA)

Nika is an open source workflow language + Rust engine where AI pipelibe is a siNGle YAML file woth 4 verb

- Event context: Offstage w/ Docker feat ClickHouse — 2026-07-07 — Paris
- Public talk page: https://paris.aitinkerers.org/talks/rsvp_6XBmEC8IoVA

### [ArgosBrain pushed Opus 4.7 from 87.6% to 95% on SWE-bench Verified](https://paris.aitinkerers.org/talks/rsvp_xM-68JzVhpc)

ArgosBrain — structural engine for AI coding agents. Opus 4.7 leads the GA SWE-bench Verified leaderboard at 87.6%. We're aiming for ~95% — by amplifying (not replacing) grep and Read with ArgosBrain. Argos delivers structural facts — every symbol, every caller, every type — in under 50ms at $0 per query. Grep and Read get faster and sharper because they know exactly where to search. We're publishing the full head-to-head: Opus 4.7 vanilla vs Opus 4.7 + ArgosBrain on SWE-bench Verified. AI agents like Claude Code and Cursor re-read your codebase every session, burning 73% of their tokens on redundant file reads. ArgosBrain is a local Rust engine that indexes your code into a unified graph (SCIP + LSP + tree-sitter) and serves it to agents via MCP — sub-50ms symbol lookups, $0 per query, zero hallucinated symbols. Live tested on Kubernetes (~2M LOC), VS Code, and OpenClaw. Per-task cost drops from $0.40 to $0.04 in our benchmarks.

- Event context: AI Tinkerers Paris feat Scalingo: Conversational DevOps & AI Infrastructure — 2026-05-21 — Paris
- Public talk page: https://paris.aitinkerers.org/talks/rsvp_xM-68JzVhpc

### [UI on the Fly](https://nyc.aitinkerers.org/talks/rsvp_95YAuinv7Hk)

A system that lets AI agents change app UI on the fly. The demo will show components being swapped live across existing app frameworks.

- Event context: Demo Day: Adaptive Software with Sky Valley and Veris — 2026-05-13 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_95YAuinv7Hk

### [VLMs for Electronics Design](https://raleigh.aitinkerers.org/talks/rsvp_PDqUleDH6rI)

An electronics design tool (think KiCAD or Altium) that leverages VLMs to turn vendor datasheet PDFs into live component models extracted directly from manufacturer reference documentation. The AI Tinkerers demo shows how I built the extraction pipeline using small open weight VLMs deployed on Modal, and a UI built on top of Zed's GPUI framework. The code and benchmark results discussed during the talk are now available on Github as the Parselab project.

- Event context: AI Tinkerers Raleigh Meetup — May 6, 2026 — 2026-05-06 — Raleigh
- Public talk page: https://raleigh.aitinkerers.org/talks/rsvp_PDqUleDH6rI

### [An Open-Source Harness for Long-Running Autonomous Agentic Development in Production](https://lausanne.aitinkerers.org/talks/rsvp_2noswA3klrA)

I built an open-source agentic coding CLI plugin that packages three requirements for reliable autonomous coding into one system: persistent semantic memory, mechanical feedback loops, and navigable task structure. It runs multi-session agentic work in dependency order, each task through a full cycle of specification, planning, test-driven implementation, multi-model review, and lesson extraction, with no shared context between sessions. I'll demo it through its benchmark: a fully functional browser-based DAW (subtractive synth, drum machine, piano roll, mixer, effects chain) built in 20 hours of unattended autonomous work. This is the same challenge Anthropic ran internally with their unpublished harness (https://www.anthropic.com/engineering/harness-design-long-running-apps, March 24 2026). The harness is open-source, and I'm deploying features and apps in production at my tech company.

- Event context: AI Tinkerers Lausanne April 2026 Meetup — 2026-04-30 — Lausanne
- Public talk page: https://lausanne.aitinkerers.org/talks/rsvp_2noswA3klrA

### [When You Log Off, Your Agents Clock In](https://atlanta.aitinkerers.org/talks/rsvp_3CWSeM9TLh4)

TaskFast, a TaskRabbit-style marketplace for agents, is a platform where both people and AI agents can post tasks for agents to complete.

- Event context: AI Tinkerers Atlanta: Community Demos & Technical Deep Dives — 2026-04-21 — Atlanta
- Public talk page: https://atlanta.aitinkerers.org/talks/rsvp_3CWSeM9TLh4

### [GitKB – A distributed knowledge base protocol for agentic engineering at global scale](https://austin.aitinkerers.org/talks/rsvp_midMkpylNrs)

GitKB is a git-like distributed knowledge graph protocol with sparse sync and checkout semantics, enabling agents and their humans to work on all the world's knowledge — a few documents at a time. If you know git commit, git checkout, and git push, you already know the mental model — but GitKB’s protocol is purpose-built for knowledge, not source code. There are no branches — knowledge is never forgotten, it just fades out of context as new learning continues. A KB is a single linear stream where each document maintains its own commit chain. These design choices unlock GitKB’s core capability: truly sparse sync. Agents and humans pull only the documents they need for the task at hand. No need to clone an entire repo. But GitKB is just just a sync protocol. It's a lightning fast knowledge graph that installs in seconds, requires no external servers, operates completely locally, for free, and operates on standard markdown files. No vendor lock in. Individuals and teams onboard in minutes. Skills train your agents for immediate use. Every new document you create generates new relationships. Every new session benefits from the last.

- Event context: AI Tinkerers Austin: April 2026 Demo Night — 2026-04-16 — Austin
- Public talk page: https://austin.aitinkerers.org/talks/rsvp_midMkpylNrs

### [Backpressure helping Claude code to learn from mistakes](https://cologne.aitinkerers.org/talks/rsvp_X_VoB3MUovI)

keel is a pure Rust CLI tool that builds a fast, incrementally-updated structural graph of your codebase and enforces architectural contracts at generation time — not at review time, not at build time. When an LLM coding agent modifies your code, keel immediately validates that the change doesn't break callers, violate type contracts, or introduce structural drift. Think of it as a structural linter purpose-built for the age of AI-generated code.

- Event context: AI Tinkerers Cologne 4: Live Technical Demos — 2026-04-16 — Cologne
- Public talk page: https://cologne.aitinkerers.org/talks/rsvp_X_VoB3MUovI

### [Virtual model endpoints: fast mode, long context, & unlimited context](https://seattle.aitinkerers.org/talks/rsvp_jFDQjMA0UtY)

We optimize GPU compute for inference. We've stood up several clusters of capacity serving common/popular models. This has pushed us to providing unique variants that solve common context/memory issues and we've provided these in a way that's a simple as changing to another OpenAI compliant model. For development or agentic scenarios, these can enable multi-million context as well as unlimited model context all behind a simple model endpoint.

- Event context: AI Dev Tool Track — Seattle Meetup - April 13th, 2026 — 2026-04-14 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_jFDQjMA0UtY

### [Parallel Coding Agents Without Merge Hell](https://columbus.aitinkerers.org/talks/rsvp_79je3WEumVU)

Multiple coding agents in parallel against the same codebase by treating version control changes as the fundamental unit of agent work. For the demo, I'll show agents working simultaneously on distinct tasks across a shared repo, with their work composed cleanly

- Event context: AI Tinkerers - Columbus April Meetup — 2026-04-06 — Columbus
- Public talk page: https://columbus.aitinkerers.org/talks/rsvp_79je3WEumVU

### [OpenSymphony: Orquestación de Trabajo para Ingeniería Agencial](https://manizales.aitinkerers.org/talks/rsvp_g9MD2ZfMbBk)

Se implementó el diseño de OpenAI Symphony, hecho en Rust y usando OpenHands agent-server. Se compartirán recursos de aprendizaje, enlaces de referencia, y se mostrará la herramienta en acción.

- Event context: 🚀 ¡14vo Encuentro de AI Tinkerers Manizales! 🤖 — 2026-03-25 — Manizales
- Public talk page: https://manizales.aitinkerers.org/talks/rsvp_g9MD2ZfMbBk

### [Building Bob's Cabins Across Three Agent Tools Without Losing My Mind](https://nashville.aitinkerers.org/talks/rsvp_iAJZ16pa6m0)

Revari: A Memory Dataplane for Heterogenous Agent Environments Every multi-agent workflow hits the same wall: switch tools and start over. Context vanishes between Claude, Codex, Cursor, or whatever your stack is. You end up re-explaining architecture decisions, copy-pasting summaries, manually bridging what one agent learned to the next. It's a tax on every tool switch, and it compounds. Revari eliminates that tax. It's a sovereign memory dataplane that sits below your agents, not inside any one of them. Persistent, hybrid retrieval (BM25 + vector + graph fused via RRF) running entirely on local hardware. Any agent reads and writes to the same shared memory. Swap agents mid-workflow and nothing is lost. Decisions, context, and intent carry forward automatically. That's the developer problem. Here's where the architecture goes further. Revari is built for DDIL (denied, degraded, intermittent, limited) environments and connectivity. Agents on edge devices persist memories locally via and reconcile when connectivity returns, over any network. The same memory layer that keeps your coding agents in sync also keeps autonomous systems coherent across factory floors, field hospitals, and forward-deployed environments. The open protocol underneath is post-quantum encrypted by default, with a novel gradient memory system that adapts to available bandwidth. Full context over Ethernet, compressed facts over WiFi, tags over LoRa. Starts with your dev workflow. Scales to infrastructure for agents that operate in the real world. Seeking development partners and seed funding.

- Event context: AI Tinkerers Nashville – Software Development in the Age of AI — 2026-03-25 — Nashville
- Public talk page: https://nashville.aitinkerers.org/talks/rsvp_iAJZ16pa6m0

### [Simulating the unsimulable](https://montreal.aitinkerers.org/talks/rsvp_d9kca3RKDrA)

I’m building Kobayashi, an optimization and simulation engine for Star Trek Fleet Command. It models the game’s combat mathematically, then searches huge decision spaces like ships, officers, and upgrades to tell you what actually maximizes win rate. AI helped me reverse engineer complex game files, rapidly build an MVP, and iteratively improve the engine.

- Event context: AI Tinkerers Montreal - March Demo Night — 2026-03-24 — Montreal
- Public talk page: https://montreal.aitinkerers.org/talks/rsvp_d9kca3RKDrA

### [OmniNode Protocol: Pipeline-Parallel LLM Inference Across Consumer Devices via Rust, QUIC, and Native GGUF-to-MLX](https://la.aitinkerers.org/talks/rsvp_NiC_L_N1e5A)

A live, two-machine demo of OmniNode Protocol: an open-source Rust/Python system that splits a large language model across multiple consumer devices and runs real autoregressive inference over a LAN. We built four layers from scratch: 1. P2P Transport (omni-net): mDNS peer discovery + encrypted QUIC streams via libp2p 0.55. All tensor routing uses a custom /omni/tensor-xfer/1 request-response protocol, no centralized broker. 2. GGUF Model Sharding (omni-store): A zero-copy GGUF v2/v3 parser (memmap2) that classifies tensors by name (token_embd.*, blk.{N}.*, output.*), chunks them by transformer block, and content-addresses each shard with BLAKE3 → CIDv1. No iroh dependency, we built the 64 MiB sliding-window transfer protocol directly on libp2p request-response. 3. PyO3 FFI Bridge (omni-bridge): A Rust-to-Python zero-copy bridge using the Python Buffer Protocol. PyShardView implements __getbuffer__ over memmap2::Mmap, exposing raw shard bytes to NumPy and MLX with zero memory copies on Apple Silicon unified memory. 4. Pipeline-Parallel Inference + Native GGUF Bridge: Each node loads only its assigned layer slice from the .gguf file using Apple's mx.load() API directly, no HuggingFace Hub, no config.json, no mlx_lm.load(). Architecture (hidden_dim, layer count, rope_theta, etc.) is inferred entirely from GGUF metadata at runtime. After slicing, the full model is explicitly dropped (del model + gc.collect() + mx.metal.clear_cache()) so each node holds only its 50% of weights in Apple Silicon VRAM. Hidden states are routed over QUIC using hidden_dim as a wire-level type discriminator: hidden_dim == model_size means float16 activations; hidden_dim == 1 means a 4-byte token ID. Next step: Phase 5 (omni-zkml): wrap each pipeline stage in a zk proof (ezkl/Halo2 SNARK or RISC Zero STARK) to cryptographically prove correct inference, enabling a trustless staking/slashing economy on SUM Chain.

- Event context: AI Tinkerers LA: March Builder Meetup & Live Demos — 2026-03-20 — Los Angeles
- Public talk page: https://la.aitinkerers.org/talks/rsvp_NiC_L_N1e5A

### [Writing our own JavaScript for "Code Mode" MCP](https://nyc.aitinkerers.org/talks/rsvp__yv2FaDF35s)

How we built two javascript runtimes in Rust using the "Deno" crate. - How we embedded typescript instant type checking of LLM generated code - How we embedded a Rust MCP client - How we lean on Deno configurations for sandboxing rules

- Event context: March Demo Day, hosted by Flowglad — 2026-03-18 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp__yv2FaDF35s

### [An RTS-Style Interface for AI Agents and Codebases](https://berlin.aitinkerers.org/talks/rsvp_n4kJ2vGsbwA)

A desktop app that renders your codebase as a 3D city -- files become buildings, directories become districts. It picks up Claude Code, Codex and Opencode telemetries locally and animates agents flying through the scene as they read, write, and edit files. All local-first -- no data leaves your machine.

- Event context: AI Tinkerers Berlin Meetup - March 11, 2026 — 2026-03-11 — Berlin
- Public talk page: https://berlin.aitinkerers.org/talks/rsvp_n4kJ2vGsbwA

### [Building a Terminal Orchestrator for AI Coding Agents in Rust](https://houston.aitinkerers.org/talks/rsvp_AD3Q9uzasnc)

**Context Foundry** is an autonomous build loop written in Rust. Give it a task list in markdown, and it works through every task using AI agents -- scouting the codebase, planning, building, and verifying with an independent reviewer in a fresh context. Passing tasks get committed. When the list runs out, a discovery agent scans for new work and keeps going. ``` SCOUT ──▶─ PLAN ──▶─ IMPLEMENT ──▶─ DOUBT ``` **The core insight:** every agent starts with a clean context window and receives only curated artifacts from the previous stage -- not a bloated conversation history full of noise. The scout writes a structured report. The planner reads that report and writes a plan. The builder reads that plan and writes code. The verifier reads the code with zero knowledge of why it was written that way. No shared context windows, no accumulated reasoning, no inherited blind spots. Each stage gets signal, not noise. This is how foundry prevents the compounding error problem where task 3 builds on task 2's mistakes. On top of this, **pattern learning** extracts reusable lessons after each task and injects them into future runs across all projects. ``` - [x] T1.1: Set up scaffolding [SPID] ● feat - [x] T1.2: Implement auth [SPID!] ✗ WIP - [ ] T1.3: Write tests [....] ``` You can also race two models against each other -- Claude and Codex each get their own worktree and run the full pipeline independently, so you compare finished solutions, not just raw outputs. Simple tasks skip the planner and reviewer and commit in about 30 seconds. There are three run modes: Auto keeps going forever, Sprint stops when the list is done, Review creates a PR after each task and waits for approval. Foundry has completed 141 tasks on its own codebase across 33 discovery rounds. Most of the features described here were built by the loop itself.

- Event context: AI Tinkerers Houston Meetup (March 10, 2026) — 2026-03-10 — Houston
- Public talk page: https://houston.aitinkerers.org/talks/rsvp_AD3Q9uzasnc

### [Speech to Music with Story Jam](https://portland.aitinkerers.org/talks/rsvp_sxCV-CokrdM)

I developes music generation systems empowered by Elevenlaps Speech transcription I have a demo for audience to try live to create chord stories from their words

- Event context: AI Tinkerers Portland: Building Voice Agents & Conversational AI Stacks — 2026-03-06 — Portland
- Public talk page: https://portland.aitinkerers.org/talks/rsvp_sxCV-CokrdM

### [UnaMentis: A mobile, AI, voice first learning platform](https://portland.aitinkerers.org/talks/rsvp_L4vjfVilvoQ)

Covering our entire project is very much out of scope, but I will be giving a quick background on who we are and what we are building. The primary topic though is our very aggressive use of on de vice voice models to provide both the lowest latency and the highest quality in a detached client we can. This includes porting a TTS model that was a perfect fit for our use to IOS with rust/candle.

- Event context: AI Tinkerers Portland: Building Voice Agents & Conversational AI Stacks — 2026-03-06 — Portland
- Public talk page: https://portland.aitinkerers.org/talks/rsvp_L4vjfVilvoQ

### [Un Agente AI que si puede tocar tu terminal](https://bogota.aitinkerers.org/talks/rsvp_qIkbtvBBLeI)

Un proyecto open Source, que combina análisis estático de Código (tree-sitter) visualización 3D interactiva (three.js) y un sistema de agentes AI tool- use real, que te ayuda a explorar las decisiones de arquitectura.

- Event context: AI Tinkerers Bogotá: El Primer Meetup de 2026 — 2026-02-26 — Bogotá
- Public talk page: https://bogota.aitinkerers.org/talks/rsvp_qIkbtvBBLeI

## Related Technologies

- [Python](https://aitinkerers.org/technologies/python) ([Markdown](https://aitinkerers.org/technologies/python.md)) — 662 public demos
- [TypeScript](https://aitinkerers.org/technologies/typescript) ([Markdown](https://aitinkerers.org/technologies/typescript.md)) — 205 public demos
- [Claude Code](https://aitinkerers.org/technologies/claude-code) ([Markdown](https://aitinkerers.org/technologies/claude-code.md)) — 214 public demos
- [OpenAI API](https://aitinkerers.org/technologies/openai-api) ([Markdown](https://aitinkerers.org/technologies/openai-api.md)) — 520 public demos
- [Tauri](https://aitinkerers.org/technologies/tauri) ([Markdown](https://aitinkerers.org/technologies/tauri.md)) — 8 public demos
- [Docker](https://aitinkerers.org/technologies/docker) ([Markdown](https://aitinkerers.org/technologies/docker.md)) — 147 public demos
- [Gemini](https://aitinkerers.org/technologies/gemini) ([Markdown](https://aitinkerers.org/technologies/gemini.md)) — 188 public demos
- [WebAssembly](https://aitinkerers.org/technologies/webassembly) ([Markdown](https://aitinkerers.org/technologies/webassembly.md)) — 11 public demos
- [GPT-3](https://aitinkerers.org/technologies/gpt-3) ([Markdown](https://aitinkerers.org/technologies/gpt-3.md)) — 191 public demos
- [GPT-4](https://aitinkerers.org/technologies/gpt-4) ([Markdown](https://aitinkerers.org/technologies/gpt-4.md)) — 529 public demos
- [Kubernetes](https://aitinkerers.org/technologies/kubernetes) ([Markdown](https://aitinkerers.org/technologies/kubernetes.md)) — 35 public demos
- [LLM](https://aitinkerers.org/technologies/llm) ([Markdown](https://aitinkerers.org/technologies/llm.md)) — 123 public demos
- [React](https://aitinkerers.org/technologies/react) ([Markdown](https://aitinkerers.org/technologies/react.md)) — 219 public demos
- [Tokio](https://aitinkerers.org/technologies/tokio) ([Markdown](https://aitinkerers.org/technologies/tokio.md)) — 3 public demos
- [Anthropic API](https://aitinkerers.org/technologies/anthropic-api) ([Markdown](https://aitinkerers.org/technologies/anthropic-api.md)) — 66 public demos
- [BERT](https://aitinkerers.org/technologies/bert) ([Markdown](https://aitinkerers.org/technologies/bert.md)) — 179 public demos
- [BLOOM](https://aitinkerers.org/technologies/bloom) ([Markdown](https://aitinkerers.org/technologies/bloom.md)) — 115 public demos
- [Candle](https://aitinkerers.org/technologies/candle) ([Markdown](https://aitinkerers.org/technologies/candle.md)) — 2 public demos

## More Results

- Next: https://aitinkerers.org/technologies/rust.md?page=2