rust
🪇 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.
One command. 25 languages. Universal multi-language runner and smart REPL written in Rust.
A universal code runner and stateful REPL written in Rust. Execute Python, JavaScript, TypeScript, Go, Rust, C, C++, Java, Kotlin, Swift, and 15 more languages with a single command.
Diesel is a Safe, Extensible ORM and Query Builder for Rust.
Diesel is the most productive way to interact with databases in Rust because of its safe and composable abstractions over queries.
Hybrid Cache in Rust. Seamlessly integrates both in-memory and disk cache for optimal performance and flexibility.
foyer aims to be an efficient and user-friendly hybrid cache lib in Rust. foyer draws inspiration from Facebook/CacheLib, a highly-regarded hybrid cache library written in C++, and ben-manes/caffeine, a popular Java caching library, among other projects.
Related contents:
The Privacy-First Alternative to Ollama.
⚡ Python-free Rust inference server — OpenAI-API compatible. GGUF + SafeTensors, hot model swap, auto-discovery, single binary. FREE now, FREE forever.
Shimmy is a 5.1MB single-binary that provides 100% OpenAI-compatible endpoints for GGUF models. Point your existing AI tools to Shimmy and they just work — locally, privately, and free.
Paralegal is a static analyzer for Rust code that enforces privacy and security policies on programs.
Related contents:
A simple, blazingly fast, selfhosted URL shortener with no unnecessary features; written in Rust.
Up to 100x faster strings for C, C++, CUDA, Python, Rust, Swift, JS, & Go, leveraging NEON, AVX2, AVX-512, SVE, GPGPU, & SWAR to accelerate search, hashing, sorting, edit distances, sketches, and memory ops 🦖
Related contents:
Dotter is a dotfile manager and templater written in rust 🦀 .
Dotfiles are configuration files that usually live in the home directory and start with a dot. Often times, it is desirable to have a backup of all the configurations on your system, which is why a lot of users have their dotfiles saved in a git repository, then symlinking them to their target locations using ln -s.
A bot that integrates with GitHub and your favorite continuous integration service.
Homu listens to the pull request comments, waiting for an approval comment from one of the configured reviewers. When the pull request is approved, Homu tests it using your favorite continuous integration service, and only when it passes all the tests, it is merged into master.
Related contents:
AI-assisted SAST, SCA and Secrets Detection. Lightweight static analysis for many languages. Find bug variants with patterns that look like source code.
Semgrep is a fast, open-source, static analysis tool that searches code, finds bugs, and enforces secure guardrails and coding standards. Semgrep supports 30+ languages and can run in an IDE, as a pre-commit check, and as part of CI/CD workflows.
Related contents:
Build Rust program to support Windows XP, Vista and more.
Use Thunk to build your Rust program to support old Windows platforms. It uses VC-LTL5 and YY-Thunks to build programs that support even Windows XP.
Related contents:
the Ruby swiss army knife. 💎💨 Next-gen very fast Ruby tooling.
new Ruby version manager with high ambitions.
Related contents:
High-performance React Server Components framework powered by a Rust runtime, delivering 4x faster performance than Next.js with zero-config setup and universal NPM support.
Related contents:
This open-source curriculum introduces the fundamentals of Model Context Protocol (MCP) through real-world, cross-language examples in .NET, Java, TypeScript, JavaScript, Rust and Python. Designed for developers, it focuses on practical techniques for building modular, scalable, and secure AI workflows from session setup to service orchestration.
A Rust based DNS client, server, and resolver, built to be safe and secure from the ground up.
Your Next(Gen) OS.
Redox is a Unix-like general-purpose microkernel-based operating system written in Rust, aiming to bring the innovations of Rust to a modern microkernel, a full set of programs and be a complete alternative to Linux and BSD.
Related contents:
Make ship happen. Turborepo is the build system for JavaScript and TypeScript codebases.
Build system optimized for JavaScript and TypeScript, written in Rust.
Related contents:
Unlock the Future of Identity. Modern IAM written in Rust.
A blazing-fast IAM, powered by Rust. Open, secure, ready for your cloud journey.
FerrisKey is an open-source IAM solution designed for modern cloud-native environments. With its high-performance API written in Rust and its intuitive web interface developed in Typescript/React, FerrisKey offers a robust and flexible alternative to traditional IAM solutions.