language · language
Filter in Explore Rust
42 production projects and 5 rule sets built with Rust.
Production projects
- Developer Work Log & Promotion Coach Hybrid Upleveler Upleveler keeps every log, note and goal as plain local files and routes all AI work through a local Ollama model in small map-reduce prompts, so one Rust binary can serve the CLI, a Ratatui app and a 127.0.0.1 Axum dashboard without an account or cloud.
- S3-Compatible Object Storage Classic RustFS RustFS splits a MinIO-style object store into dozens of single-purpose Rust crates behind one binary, keeps extra protocols behind cargo features, and moves inter-node traffic to gRPC, so storage, healing and IAM evolve separately.
- Distributed Blob & File Storage Classic SeaweedFS Decoupling directory metadata from physical volume storage eliminates central metadata bottlenecks, enabling massive horizontal scaling for small and large files alike.
- Rust Web Framework Classic Axum Axum skips a custom middleware system and treats every route and layer as a Tower service, so it inherits timeouts, tracing, compression and auth from tower-http and shares middleware with Hyper and tonic code.
- Full-Stack Rust Web Framework Classic Leptos Leptos separates its reactive graph, renderer and server-function RPC into independent crates and keeps the core server-agnostic, so the same components run as SSR HTML or WebAssembly, and Axum or Actix Web plug in through thin integration crates.
- Cross-Platform Rust App Framework Classic Dioxus Dioxus keeps one virtual DOM and component model and swaps renderers per platform (WebAssembly, WebView, SSR, LiveView, native), while its own dx CLI handles hot-patching, asset bundling and packaging for every target.
- Federated Link Aggregator & Forum Classic Lemmy Lemmy splits its Rust backend into many small crates (per database view, API, ActivityPub, email) over one PostgreSQL schema with heavy migrations, so federation, the local API and queries evolve separately while a single binary serves an instance.
- Shell History Sync Classic Atuin Atuin keeps history local in SQLite and encrypts it before sync, so the Axum sync server stays a thin store; a gRPC daemon and capability crates (CLI, server, AI, dotfiles) let each part evolve behind feature flags.
- Identity Management Platform Classic Kanidm Kanidm ships every identity protocol from one Rust server with bundled SQLite and built-in replication, renders its UI with Axum, Askama and htmx, and maintains its own WebAuthn, JWT and LDAP crates to keep security-critical code under its control.
- Rust Web Framework Classic Actix Web Actix Web owns its HTTP stack in actix-http and keeps router, codegen, files, multipart, test utilities and the awc client in one workspace, so the whole request path, TLS options and public API are versioned and semver-checked together.
- Rails-Style Rust Web Framework Classic Loco Loco assembles proven crates (Axum, SeaORM, Tera, Lettre, OpenDAL) behind Rails-style conventions and generators, uses feature flags to keep infrastructure optional, and ships an AGENTS.md, an agent skill and evals so agents can build on it.
- Package Registry Classic crates.io crates.io runs one pinned-dependency Rust binary as migrate, web and worker processes, splits domains into small internal crates, and generates its TypeScript client from OpenAPI types so the SvelteKit frontend and Axum API share one contract.
- Open-Source Payments Orchestration Classic Hyperswitch Hyperswitch runs a panic-averse Rust router on Actix Web with Redis absorbing hot writes and a drainer persisting them to PostgreSQL, while a routing DSL that also compiles to WebAssembly keeps processor selection consistent between server and browser.
- Browser Automation Bridge for AI Agents Classic BrowserSkill The agent keeps the browser's real login state and the user can watch and take over, because the design pairs a small native Rust daemon (callable from any agent's shell) with a WXT extension, instead of running a separate headless browser. A shared protocol crate keeps both sides in sync.
- Local LLM Inference Engine & Hardware Profiler Hybrid Magnitude Performance-critical inference sits in a Rust workspace around vendored llama.cpp, while the app, CLI, agent and model management live in a Bun + Effect TypeScript monorepo. The native engine can be pinned and benchmarked on its own while the product layer changes quickly.
- Lightweight Self-Hosted Password Vault Classic Vaultwarden Vaultwarden replaces the heavy, multi-container official Bitwarden stack with a single fast Rust executable consuming minimal RAM.
- Columnar Real-Time Analytical Database (OLAP) Classic ClickHouse A single CMake super-project that vendors ~150 native dependencies (Arrow, gRPC, AWS/Azure/GCS SDKs, NuRaft, Delta Lake kernel) under contrib/ lets ClickHouse ship a largely self-contained, dependency-free binary and Docker image.
- High-Throughput LLM Inference & Serving Engine AI-agent vLLM vLLM solves GPU memory fragmentation in large language model serving, delivering state-of-the-art throughput on commodity and enterprise hardware.
- Instant GraphQL Engine & Unified Data Access Classic Hasura Hasura runs two independently evolving query engines from one repository — a Haskell V2 server and a Rust V3 engine — and extends database support through an out-of-process Data Connector protocol, so a new database backend plugs in as a separate agent instead of new code inside either engine.
- Secure JavaScript & TypeScript Runtime Classic Deno A single Cargo workspace embeds V8 directly in Rust so the CLI, its Web API extensions, and npm compatibility ship as one statically-linked binary instead of relying on a separate Node.js toolchain.
- All-in-One JavaScript Runtime & Toolchain Classic Bun Implementing the runtime, bundler, installer and test runner as one Cargo workspace around a single embedded JS engine keeps startup and cross-tool integration fast, while a dedicated *_jsc crate layer isolates the JavaScriptCore bridge from the rest of the Rust codebase.
- Utility-First CSS Engine & Framework Classic Tailwind CSS Tailwind CSS re-architected its compilation engine with Rust Oxide and Lightning CSS for near-instant builds and zero-config CSS integration.
- Fullstack React Framework Hybrid Next.js Performance-critical compilation and bundling are implemented as Rust crates (Turbopack, SWC transforms) compiled to native addons, while the framework surface stays in TypeScript, letting Next.js run its full test matrix across three interchangeable bundlers without forking the codebase.
- Local-First Privacy Workspace Hybrid AppFlowy Flutter delivers five platforms from one codebase while a Rust core owns storage, CRDT documents, search and AI behind a protobuf FFI boundary, keeping data local by default and sync optional.
Often used with Rust
AGENTS.md rules and agent skills with Rust
rust-axum-htmx-askama/AGENTS.mdRust + Axum + htmx + Askama (Server-Rendered Web App)Server-rendered Rust web app rules: Axum 0.8, compile-time Askama templates, htmx partials, sqlx 0.9 + PostgreSQL, and a cargo check loop for AI agents. intermediaterust-axum-postgres/AGENTS.mdRust + Axum + PostgreSQL API (sqlx & Tokio)Rust API and backend rules: Axum 0.8 on Tokio, compile-time SQL checks with sqlx 0.9, Tower middleware, typed errors and a cargo check loop for AI agents. advancedrust-leptos-fullstack/AGENTS.mdLeptos Full-Stack Rust (SSR + Hydration on Axum)Full-stack Rust web app rules: Leptos 0.8 SSR with hydration, server functions on Axum, sqlx + PostgreSQL, cargo-leptos and Tailwind, written for AI agents. advancedrust-loco-saas/AGENTS.mdLoco + SeaORM + PostgreSQL (Rails-Style Rust SaaS)Rails-style Rust SaaS rules for Loco: generators, SeaORM models and migrations, Tera views or htmx scaffolds, JWT auth, background workers and mailers. intermediatetauri-react-desktop/AGENTS.mdTauri 2 + React + Vite (Rust Desktop App)Desktop app rules for Tauri 2: React + Vite + TypeScript UI, typed Rust commands, least-privilege capabilities, SQLite in Rust, updater and signed CI builds. intermediate
Questions about Rust
How many production projects use Rust?
42 verified production projects in the STACK IT FAST directory use Rust, each with a full architecture breakdown.
What is Rust most often used with?
Across projects in the directory, Rust is most commonly paired with Docker, Tokio, TypeScript.
Is there an AGENTS.md rule or Claude Code skill for Rust?
Yes — Rust + Axum + htmx + Askama (Server-Rendered Web App), Rust + Axum + PostgreSQL API (sqlx & Tokio), Leptos Full-Stack Rust (SSR + Hydration on Axum), Loco + SeaORM + PostgreSQL (Rails-Style Rust SaaS), Tauri 2 + React + Vite (Rust Desktop App) each include a full AGENTS.md, CLAUDE.md, Cursor .mdc rule set and an installable SKILL.md covering Rust.