rust
Makepad is a creative software development platform for Rust that compiles to wasm/webGL, osx/metal, windows/dx11 linux/opengl.
Makepad is an AI-accelerated application and game development environment for Rust. It combines a high-performance UI runtime, a live-editable design language, and a fast iteration loop so you can build native and web apps with a tight feedback cycle.
Rust LSP that doesn't eat memory for breakfast.
Rust Glancer is a memory efficient LSP for Rust. It uses a different approach compared to rust-analyzer: instead of storing everything in memory and recomputing dynamically, it uses frozen workspaces that can be offloaded to the filesystem. As a result, the LSP gets some performance penalty, but is able to achieve extreme memory efficiency and instant restarts.
A fast, simple, and embedded key-value store for Rust.
TurboKV is an async embedded key-value database with atomic batches, ordered range scans, configurable durability, compression, and background compaction.
PDF structure, built for speed. fast, open-source PDF to Markdown.
A Rust-powered, open-source parser that classifies PDFs and turns native text into clean, position-aware Markdown. Use it from Node.js or the bundled CLI, with packages also available from PyPI and crates.io.
Magical Rust patterns laid out and simplified.
The best way to learn Rust is by looking at simplified examples and building from there. Well, maybe not the best way, but this is the content of this blog repository.
Redis-compatible distributed cache.
A low-latency, high-throughput, distributed cache. Drop-in replacement for Redis — up to 1.9x faster with p99 latency under 1.3ms.
"putzen" is German and means cleaning. It helps keeping your disk clean of build and dependency artifacts safely.
Topcoat is a modular, batteries-included Rust framework for building fullstack apps. It prioritizes simplicity and productivity.
postgres, rewritten in rust.
Postgres rewritten in Rust, now passing 100% of the Postgres regression tests.
Related contents:
Guard rail for your commit messages for sustainable development.
A Positively Charged JavaScript Runtime. A JavaScript Runtime for Rust.
Ion is a JavaScript runtime for integrating a JavaScript engine within a Rust program. This is useful for cases like building out a JavaScript powered plug-in system - but it can also be used directly from a stand alone executable.
A refreshingly simple data-driven game engine built in Rust Free and Open Source Forever!
Pick the guide that matches your background.
Beginner, advanced, expert level Rust training material.
Git, rewritten by agents, in Rust, as a library.
Grit is an agent-driven, library-oriented reimplementation of Git in Rust, aiming to pass Git's own test suite.
Related contents:
A vector index built on TurboQuant, written in Rust with Python bindings.
A 10 million document corpus takes 31 GB of RAM as float32. turbovec fits it in 4 GB - and searches it faster than FAISS.
turbovec is a Rust vector index with Python bindings, built on Google Research's TurboQuant algorithm — a data-oblivious quantizer that matches the Shannon lower bound on distortion, with no codebook training and no separate train phase.
Declarative GUI for Rust, C++, JavaScript & Python.
Slint is an open-source declarative GUI toolkit to build native user interfaces for Rust, C++, JavaScript, or Python apps. Write your UI once in .slint, a simple markup language. Connect it to business logic written in Rust, C++, JavaScript, or Python.
Related contents:
15-stage Windows malware development & analysis course in Rust. Red team builds it, blue team detects it. All 15 binaries achieved 0/76 on VirusTotal.
A ground-up reimplementation of Kubernetes in Rust.
Rūsternetes includes a built-in web console with real-time cluster topology visualization, live metrics, pod log streaming, and full resource management. It deploys automatically — embedded in the API server, no separate installation.
🪇 Minimal terminal spinners for Rust.
Rattles is a minimal, dependency-free terminal spinner library for Rust. It makes no assumptions about how the output will be used.
youki is an implementation of the OCI runtime-spec in Rust, similar to runc.
An experimental Rust architecture for reactive UI.
Xilem and Masonry provide an experimental high-level architecture for writing GUI apps in Rust.
Masonry is a foundational crate for building natively compiled GUIs in Rust. It provides a retained widget tree and runs event handling and update passes on it.
Xilem a high-level reactive framework inspired by React, SwiftUI and Elm. It lets users create a lightweight view tree, and changes the rendered app based on changes to the tree. It has a web backend and a Masonry backend.
Rewrite of Claude Code
The fastest repo in history to surpass 50K stars ⭐, reaching the milestone in just 2 hours after publication. Better Harness Tools that make real things done. Now writing in Rust using oh-my-codex.
Related contents:
noq, a QUIC implementation in Rust.
General purpose implementation of the QUIC transport protocol in pure Rust. Noq is built as an async-friendly API in the noq crate on top of a sans-io protocol library in noq-proto.
Noq started out as a fork of the excellent Quinn project. The main focus of development has been towards adding support for more QUIC (draft) extensions.
Related contents:
Hegel is a universal property-based testing protocol and family of libraries, built on Hypothesis.
Related contents:
The open protocol for machine-to-machine payments. Charge for API requests, tool calls, or content—agents and apps pay per request in the same HTTP call.
Exploring memory safety that's easier to use.
A programming language that is higher level than Rust but lower level than Go. Someday, anyways.
Related contents:
Oxyde ORM is a type-safe, Pydantic-centric asynchronous ORM with a high-performance Rust core designed for clarity, speed, and reliability.
Inspired by the elegance of Django’s ORM, Oxyde focuses on explicitness over magic, providing a modern developer-friendly workflow with predictable behavior and strong typing throughout.
Wrappers is a Rust framework for developing PostgreSQL Foreign Data Wrappers.
Related contents:
The Monster Terminal UI Kernel for Rust.
Minimal, high-performance terminal UI kernel with diff-based rendering, inline mode, and RAII terminal cleanup.
S3-native event streaming. One binary, zero ops.
StreamHouse is an Apache Kafka alternative that stores events directly in S3. No broker fleet, no disk management, no replication — just S3's 99.999999999% durability out of the box.
S3-native streaming platform. A Kafka alternative with infinite scalability, 10x lower cost, and Kafka-compatible APIs. Written in Rust.
The vector database that gets smarter the more you use it — and now ships as a cognitive container.
RuVector is a High Performance, Real-Time, Self-Learning, Vector Graph Neural Network, and Database built in Rust.
Most vector databases are static — they store embeddings and search them. That's it. RuVector is different: it learns from every query, runs LLMs locally, scales horizontally, boots as a Linux microservice from a single file, and costs nothing to operate.
pre-commit is a framework to run hooks written in many languages, and it manages the language toolchain and dependencies for running the hooks.
prek is a reimagined version of pre-commit, built in Rust. It is designed to be a faster, dependency-free and drop-in alternative for it, while also providing some additional long-requested features.
MiniJinja is a powerful but minimal dependency template engine which is based on the syntax and behavior of the Jinja2 template engine for Python.
Related contents:
fast, encrypted, and deduplicated backups.
rustic is a backup tool that provides fast, encrypted, deduplicated backups. It reads and writes the restic repo format described in the design document and can be used as a restic replacement in most cases.
🔱 A dynamic SQL query builder for MySQL, Postgres and SQLite.
SeaQuery is a query builder to help you construct dynamic SQL queries in Rust. You can construct expressions, queries and schema as abstract syntax trees using an ergonomic API. We support MySQL, Postgres and SQLite behind a common interface that aligns their behaviour where appropriate. MS SQL Server Support is available under SeaORM X.
The JavaScript Oxidation Compiler.
A collection of JavaScript tools written in Rust.
Related contents:
Kanidm is a modern and simple identity management platform written in rust.
Kanidm is a simple and secure identity management platform, allowing other applications and services to offload the challenge of authenticating and storing identities to Kanidm.
High-performance embedded SQL database in Rust. A Modern Embedded SQL Database in Pure Rust.
Full ACID transactions with MVCC, cost-based query optimizer, multiple index types (B-tree, Hash, Bitmap), parallel execution, and minimal unsafe code.
High-Performance Distributed Storage System Built with Rust.
🚀2.3x faster than MinIO for 4KB object payloads. RustFS is an open-source, S3-compatible high-performance object storage system supporting migration and coexistence with other S3-compatible platforms such as MinIO and Ceph.
RustFS is a high-performance, distributed object storage system built in Rust—one of the most loved programming languages worldwide. RustFS combines the simplicity of MinIO with the memory safety and raw performance of Rust. It offers full S3 compatibility, is completely open-source, and is optimized for data lakes, AI, and big data workloads.
Related contents:
What happens when you take an XKCD joke too literally.
CLI tool that renders package dependencies as physical tower structures. Supports PyPI, npm, and crates.io with optimal crossing minimization.
🦭 High Performance kafka alternative written in rust.
Walrus is a distributed message streaming platform built on a high-performance log storage engine. It provides fault-tolerant streaming with automatic leadership rotation, segment-based partitioning, and Raft consensus for metadata coordination.
dragonfire:
- reads all the static libraries in one pass
- deduplicates the object files inside them based on their size and naming (Rust has its own, unique naming convention for object files -- pretty useful!)
- copies the duplicate objects into a new static library (usually called gstrsworkspace as its primary use is for the GStreamer ecosystem)
- removes the duplicates from the rest of the libraries
- updates the symbol table in each of the libraries with the bundled LLVM tools.
Related contents:
Modern embedded framework, using Rust and async. The next-generation framework for embedded applications
Write safe, correct and energy-efficient embedded code faster, using the Rust programming language, its async facilities, and the Embassy libraries.
Related contents:
An executable file that runs a harmless program most of the time, but will run a different, hidden code if deployed on a specific target host.
Related contents:
A lightweight, high-performance Rust email archiver with WebUI.
Bichon is a minimal, high-performance, standalone Rust email archiver with a built-in WebUI. Its name is inspired by the puppy my daughter adopted last month. It runs as a single binary, requires no external dependencies, and provides fast, efficient email archiving, management, and search.
Related contents:
Async-friendly QUIC implementation in Rust.
Quinn is a pure-Rust, async-compatible implementation of the IETF QUIC transport protocol. The project was founded by Dirkjan Ochtman and Benjamin Saunders as a side project in 2018, and has seen more than 30 releases since then. If you're using Quinn in a commercial setting, please consider sponsoring the project.
Related contents:
New JavaScript engine written in Rust.
Brimstone is a JavaScript engine written from scratch in Rust, aiming to have full support for the JavaScript language.
Brimstone is a work in progress but already supports almost all of the JavaScript language (>97% of the ECMAScript language in test262). Not ready for use in production.
Boa is an embeddable Javascript engine written in Rust.
Boa is an experimental JavaScript lexer, parser and interpreter written in Rust 🦀, it has support for more than 90% of the latest ECMAScript specification. We continuously improve the conformance to keep up with the ever-evolving standard.
A modern static site generator by the creators of Material for MkDocsh
Zensical is a fresh take on what we envision a modern Open Source toolchain to build static sites should look like. Brought to you by the creators of Material for MkDocs – a tool trusted by more than 70,000 projects worldwide – we're building Zensical from first principles to achieve faster iteration, better authoring experience, and a modern architecture that scales with your needs.
Related contents:
Non-intrusive GUI framework for Rust.
Non-intrusively build apps. A declarative, purely composed GUI library for building cross-platform applications. It's lightweight and powerful.
🔍 Tiny, full-text search engine for static websites built with Rust and Wasm.
Related contents:
Rust implementation of the H3 geospatial indexing system.
Related contents:
Version control for your data. Automerge is a local-first sync engine for multiplayer apps that works offline, prevents conflicts, and runs fast.
Related contents:
A Nix library for building cargo projects. Never build twice thanks to incremental artifact caching.
A fast, productive UI framework for Rust from the creators of Zed.
GPUI is a hybrid immediate and retained mode, GPU accelerated, UI framework for Rust, designed to support a wide variety of applications.
Rust GUI components for building fantastic cross-platform desktop application by using GPUI.
Catch Broken Links in Seconds.
⚡ Fast, async, stream-based link checker written in Rust. Finds broken URLs and mail addresses inside Markdown, HTML, reStructuredText, websites and more!
Related contents:
A code spell-checker, written in rust. This project aims to be a cleaner and faster replacement for cspell.
Flowistry is an IDE plugin for Rust that helps you focus on relevant code.
Flowistry is a tool that analyzes the information flow of Rust programs. Flowistry understands whether it's possible for one piece of code to affect another. Flowistry integrates into the IDE to provide a "focus mode" which helps you focus on the code that's related to your current task.
RustPython is a Python interpreter written in Rust. RustPython can be embedded into Rust programs to use Python as a scripting language for your application, or it can be compiled to WebAssembly in order to run Python in the browser. RustPython is free and open-source under the MIT license.