Rust libraries

axum seems nice as a web framework (neat template). Idiomatic Rust is a nice collection. Looking to try Crane for building/caching rust compiles. Also tonic is interesting.

shuttle is nice for testing concurrent code. Burn looks nice as ML library. Typeshare is nice for type sharing between languages.

rkyv is great for serialization. Moka or Quick Cache seem nice for caching.

CXX & Safer FFI are nice for writing safe rust bindings.

self_update seems nice for updating rust binaries. Linfa seems nice for ML.

Blessed.rs has nice list of good crates. Rust API Design Learnings is nice watch. Love studying David's libraries.

Lib.rs is great collection of libraries.

CLI

clap-rs - Full featured, fast Command Line Argument Parser. (Reddit) (step towards 4.0) (Reddit) (clap-markdown)
tui-prompts - Library to build rich terminal user interfaces (TUIs) and dashboards.
getopts - Rust library for option parsing for CLI utilities.
Lexopt - Simple argument parser for Rust.
xflags - Moderately simple command line arguments parsing.
clap-verbosity-flag - Easily add a --verbose flag to CLIs using clap.
Argh - Opinionated Derive-based argument parser optimized for code size.
bpaf - Parse command line arguments by composing a parser from the components optimized for flexibility and compilation time. (Reddit)
argi - Argument parsing for the future.
slap - Painless shell argument parsing and dependency check.
Wena - Micro-framework that provides an elegant starting point for your console application.
fncmd - Opinionated command line parser frontend that wraps around clap.
dialoguer - Rust utility library for nice command line prompts and similar things.
Abscissa - Microframework for building Rust applications (either CLI tools or network/web services).
StructOpt - Parse command line arguments by defining a struct.
pico-args - Ultra simple CLI arguments parser.
termcolor - Cross platform terminal colors for Rust.
Comfy-table - Library for building beautiful terminal tables with automatic content wrapping.
owo-colors - Zero-allocation no_std-compatible zero-cost way to add color to your Rust terminal.
Console Engine - Simple terminal framework to draw things and manage user input.
console - Library for Rust that provides access to various terminal features so you can build nicer looking command line interfaces.
termimad - Library to display rich (Markdown) snippets and texts in a rust terminal application.
indicatif - Rust library for indicating progress in command line applications to users.
xshell - Provides a set of cross-platform utilities for writing ergonomic "bash" scripts.
devx - Collection of utilities for writing your own dev scripts.
RustyLine - Readline Implementation in Rust.
seahorse - Minimal CLI framework written in Rust.
conch-parser - Rust library for parsing Unix shell commands.
cli-table - Rust crate for printing tables on command line.
youchoose - Lightweight terminal menu for Rust.
Tuikit - Tool kit for writing TUI applications in Rust.
argv - Command line arguments by reference.
ansi_colours - Rust, C and C++ library for converting between 24-bit sRGB colors and ANSI terminal 8-bit palette.
Cursive - TUI (Text User Interface) library for rust.
CtrlC - Simple easy to use wrapper around Ctrl-C signal.
expectrl - Library for automating and testing interactive applications.
Rink - Build reactive terminal user interfaces using Rust and Dioxus.
Update-informer - Update informer for CLI applications written in Rust. Checks for a new version on Crates.io, GitHub, and PyPI.
argfile - Load additional CLI args from file.
textplots - Terminal plotting library for Rust.
Spinners - + Elegant terminal spinners for Rust.
Bunt - Simple macro-based terminal colors and styles.
superconsole - Component-based framework for building Rust TUIs.
terminal-keycode - Convert bytes from a terminal into keycodes.
tui-realm - Tui-rs framework to build stateful applications with a React/Elm inspired approach.
spinach - Practical spinner for Rust.
zi - Incremental, declarative library for building terminal user interfaces in Rust.
Modern Terminal - Rust library for rich text and beautiful formatting.
Canopy - Terminal UI library for Rust.
Rustea - Easy-to-use TUI crate for Rust, based off of the Elm architecture.
promptio - Toolkit for building your own interactive command-line tools in Rust.
paris - Simple way to output beautiful text in your CLI applications.
Storyteller - Library for working with multi-output multi-purpose user output.
spinoff - Simple Rust library for displaying spinners in the terminal.
step-machine - Run your CLI programs as state machines with persistence and recovery abilities.
Requestty - Easy-to-use collection of interactive cli prompts inspired by Inquirer.js.
getargs - Truly zero-cost argument parser for Rust.
Anathema - TUI library in Rust with a custom templating language and runtime.
Intuitive - Library for building declarative text-based user interfaces.
yansi - Dead simple ANSI terminal color painting library for Rust.
inquire - Rust library for building interactive prompts.
prodash - Report progress of concurrent applications and display it in various ways.
minus - Asynchronous terminal paging library.
linya - Simple concurrent progress bars.
makeup - Stylish CLIs/TUIs for Rust.
is-terminal - Test whether a given stream is a terminal.
supports-color - Detects whether a terminal supports color, and gives details about that support.
TUI-Input - TUI input library supporting multiple backends and tui-rs.
CLI Batteries - Batteries included command line interfaces.
kdam - Console progress bar library for rust.
tracing-indicatif - Tracing layer that automatically creates and manages progress bars for active spans.
vt100 - Parses a terminal byte stream and provides an in-memory representation of the rendered contents.
Cartographer - Menu maker for Rust TUIs.
Ratatui - Rust library to build rich terminal user interfaces (TUIs) and dashboards.
clap-help - More compact help renderer for clap terminal applications.
completest - Run completions for your program.
stylish-rs
tui-term - Pseudoterminal widget library for ratatui.
Argp - Rust derive-based argument parsing optimized for code size and flexibility.

Web

Axum - Ergonomic and modular web framework built with Tokio, Tower, and Hyper. (Article) (Reddit) (Lobsters) (Example Web App) (Axum and SQLx App) (RESTful API template built with Rust) (Axum Server) (Tutorial For Beginners) (Rust + Axum + Prisma template) (Axum, Tokio, Tower, Hyper, Serde template) (Axum_database_Sessions) (Minimalist Guide to Axum) (Lobsters) (David Pedersen on Axum (2022)) (axum-sessions) (axum-login) (axum-tracing-opentelemetry) (Axum Auth) (tower-cookies) (Axum Connect-Web)
h3 - Async HTTP/3 implementation.
Graphul - Express inspired web framework using a powerful extractor system. (HN)
Leptos - Full-stack, isomorphic Rust web framework leveraging fine-grained reactivity to build declarative user interfaces. (Cargo-Leptos) (Starter) (Prime interview) (Learning Leptos)
tonic-rpc - Build RPCs on top of the tonic gRPC library by defining your types in Rust instead of proto.
Rouille - Rust web micro-framework.
Viz - Fast, flexible, lightweight web framework for Rust. (Docs)
Hyper - Fast and correct HTTP implementation for Rust. (Web) (Hyper's Vision) (HN)
pavex - Source code generator for building APIs and web applications with Rust. (Tweet) (Article)
Typed HTTP Headers from hyper
attohttpc - Rust lightweight HTTP 1.1 client.
Rocket - Async web framework for Rust with a focus on usability, security, extensibility, and speed. (Web) (Article) (Review) (Rocket is dead)
Salvo - Simple Rust web framework.
ntex - Framework for composable networking services.
Sauron - Versatile web framework and library for building client-side and server-side web applications. (HN clone in Sauron)
Isahc - Practical HTTP client that is fun to use.
tide-acme - Automatic HTTPS certificates for Tide, via Let's Encrypt and ACME tls-alpn-01 challenges.
preroll - Easy boilerplate utilities for Rust http services which use async-std, Tide, Surf, and friends. (Tweet)
submillisecond - Lunatic web framework for the Rust language. (Lobsters)
Routerify - Provides a lightweight, idiomatic, composable and modular router implementation with middleware support for the Rust HTTP library hyper.rs.
H2 - Tokio aware, HTTP/2.0 client & server implementation for Rust.
Thruster - Fast, middleware based, web framework written in Rust.
actix web - Small, pragmatic, and extremely fast rust web framework (Jelly - Starter template for actix-web projects) (HN) (Reddit)
actix swagger - Swagger code generator for actix-web framework.
actix-web-flash-messages - Flash messages for actix-web.
actix-web-grants - Authorization extension for actix-web to validate user permissions.
tracing-actix-web - Structured diagnostics for actix-web applications.
actix-web-lab - Experimental extractors, middleware, and other extras for possible inclusion in Actix Web.
stdweb - Standard library for the client-side Web.
Seed - Rust framework for creating web apps. (HN) (Web) (Awesome)
Tide - Modular web framework. (Designing Tide - Yoshua Wuyts)
Tide WebSockets - Experimental websockets handler for tide based on async-tungstenite.
websocket-lite - Fast, low-overhead WebSocket client.
Gloo - Toolkit for building fast, reliable Web applications and libraries with Rust and Wasm.
reqwest - Easy and powerful Rust HTTP Client.
gotham - Flexible web framework that promotes stability, safety, security and speed.
gotham-restful - RESTful additions for the gotham web framework.
warp - Super-easy, composable, web server framework for warp speeds.
HTTP - Rust HTTP types.
httparse - Push parser for the HTTP 1.x protocol in Rust.
ureq - Minimal request library in rust.
Mendes - Rust web toolkit for impatient perfectionists.
Roa - Async web framework inspired by koajs, lightweight but powerful.
rweb - Yet another web server framework for rust.
Tower Web - Web framework for Rust with a focus on removing boilerplate.
http-types - Common types for HTTP operations.
Dropshot - General-purpose crate for exposing REST APIs from a Rust program.
localghost - Ergonomic Rust bindings to the Web platform.
hyper-rustls - Integration between the rustls TLS stack and the hyper HTTP library.
biscuit-rust - Rust implementation of the Biscuit authorization token.
OpenMLS - Rust implementation of the Messaging Layer Security (MLS) protocol.
Tower - Library of modular and reusable components for building robust networking clients and servers.
gql_client - Minimal GraphQL client for Rust.
Cynic - Bring your own types GraphQL client library for Rust. (Docs)
Hyperdrive - Declarative HTTP request routing, guarding and decoding.
tame-oidc - Small OAuth crate that follows the sans-io approach.
jsonwebtoken - JWT lib in rust.
MoonZoon - Rust Fullstack Framework. (Podcast) (HN)
tame-oauth - Small OAuth crate that follows the sans-io approach.
Trillium - Composable toolkit for building web applications with async rust. (Docs)
Sycamore - Reactive library for creating web apps in Rust and WebAssembly.
Perseus - High-level frontend development framework for Rust with full support for SSR and SSG.
Zap - Fast, cross-platform (web+native), GPU-based application framework, written in Rust.
Poem - Full-featured and easy-to-use web framework. (Poem OpenAPI) (Poem Grants)
darpi - Rust web framework with safety and speed in mind.
Vial - Micro micro-framework for rust. (Docs)
Nuts - Library that offers a simple publish-subscribe API, featuring decoupled creation of the publisher and the subscriber.
javascriptcore-rs - JavaScriptCore bindings and wrappers for Rust.
Wry - Cross-platform WebView library in Rust for Tauri.
webkit2gtk - Rust bindings and wrappers for webkit2gtk.
Catnip - Fast User-Space TCP/UDP Stack.
Capsule - Framework for network function development.
webview2 - Rust bindings for WebView2.
lol-async - Provides an awkward async interface for cloudflare/lol-html.
Reqwasm - HTTP requests library for WASM Apps.
Cookie - HTTP cookie parsing and cookie jar management for Rust.
backoff - Small crate which allows you to retry operations according to backoff policies.
rust-jwt - Very simple JWT generation lib.
Avalanche - Rust library for building performant Web apps.
Dioxus - Elegant React-like library for building user interfaces for desktop, web, mobile, SSR, liveview, and more. (Docs) (TODO App Example) (HN) (CLI) (GitHub) (0.3) (0.4 release)
webview_rust - Rust Bindings to webview.
rsass - SASS reimplemented in rust with nom.
connect-rs - Message-queue abstraction over async network streams.
Tower HTTP - HTTP specific Tower utilities.
MatchIt - Blazing fast URL router and path matcher for Rust.
async-session - Async session support with pluggable middleware.
Rust Web Audio API - Rust implementation of the Web Audio API, for use in non-browser contexts.
zeroconf - Cross-platform library that wraps underlying ZeroConf/mDNS implementations such as Bonjour or Avahi, providing an easy and idiomatic way to both register and browse services.
uds - Unix domain sockets Rust library that supports abstract addresses, fd-passing, SOCK_SEQPACKET sockets and more.
Yamux - Stream multiplexer over reliable, ordered connections such as TCP/IP.
Silkenweb - Library for writing reactive single page web apps.
reqwest-middleware - Wrapper around reqwest to allow for client middleware chains.
rust-otp - Rust library for performing the HMAC-based One-Time Password (HOTP) and Time-based One-Time Password (TOTP) algorithms.
protocol - Easy protocol definitions in Rust.
rust-socketio - Implementation of a socket.io client written in the Rust.
reqsign - Signing HTTP requests without heavy SDKs.
Spectre - Lightweight toolkit for analysing p2p network topologies.
bifrost - Pure rust building block for distributed systems.
rsocket-rust - RSocket Rust Implementation using Tokio.
Aliri - Web API access control for Rust.
ipnet - IpNet, Ipv4Net, and Ipv6Net types and methods for Rust.
utoipa - Auto generated OpenAPI documentation.
packet - Network packet handling for Rust.
tokio-cron-scheduler - Schedule tasks on Tokio using cron-like annotation.
tide-trace - Minimum overhead USDT middleware to dynamically trace tide with BPF or DTrace.
mt-dom - Generic virtual DOM implementation for rust.
udp-socket - Advanced udp socket.
Fast SOCKS5 - Fast SOCKS5 client/server implementation written in Rust async/.await (with tokio).
service-io - Build your service-server fast, easy (and without hosting).
interfaces-rs - Library to work with network interfaces in Rust.
async-net - Async networking primitives for TCP/UDP/Unix communication.
ginepro - Client-side gRPC channel implementation for tonic.
fantoccini - High-level API for programmatically interacting with web pages through WebDriver.
Okapi - OpenAPI (AKA Swagger) document generation for Rust projects.
HTTP Body - Asynchronous HTTP body trait.
FeignHTTP - Declarative HTTP client for rust.
Tokamak - Simple WebFramework for real time apps.
hyper-reverse-proxy - Simple reverse proxy for use with Hyper and Tokio.
Samael - SAML2 library for Rust.
ructe - Rust Compiled Templates with static-file handling.
backon - Retry futures in backoff without effort.
nickel.rs - Express inspired web framework for Rust.
exponential-backoff - Exponential backoff generator with jitter.
Aide - Code-first API documentation and other utility libraries for Rust.
Progenitor - OpenAPI client generator.
yerpc - JSON-RPC 2.0 server handler for Rust, with automatic generation of a TypeScript client.
Seamless - Opinionated Rust library for creating simple JSON APIs that communicate over HTTP.
TinyRoute - Small networked message passing library.
Async UI - Lifetime-Friendly, Component-Based, Retained-Mode UI Powered by Async Rust. (Article) (HN)
CustomElement - Framework-agnostic CustomElement trait to create Rust/WASM Web Components/Custom Elements easily without writing any JavaScript.
har-rs - HTTP Archive format (HAR) serialization & deserialization library, written in Rust.
Motore - Async middleware abstraction powered by GAT and TAIT.
Aggligator - Aggregates multiple links (TCP or similar) into one connection having their combined bandwidth and provides resiliency against failure of individual links.
rust-multiaddr - Composable and future-proof network addresses.
axohtml - Type checked JSX for Rust.
str0m - Sync sans I/O WebRTC implementation in Rust.
lil-http - Barebones HTTP 1.1 framework, built in Rust with no external dependencies (other than tokio).
Multipart - Backend-agnostic extension for file uploads in HTTP libraries for Rust.
minreq - Simple, minimal-dependency HTTP client.
eightfish - Framework for open web.
jittr - Binary heap based jitter buffer implementation for zero latency udp/rtp streams.
Retty - Asynchronous Rust networking framework that makes it easy to build protocols, application clients/servers.
may_minihttp - Mini HTTP server that implemented on top of may.
Nanoproxy - Combination of two protocols - HTTP request proxying and mDNS advertisements.
Zino - Full-featured web application framework for Rust.
hyperlocal - Hyper client and server bindings for Unix domain sockets.
Astra - High performance Rust web servers without async/await.
Valar - Developer Centric Async Rust Web Framework.
CachePolicy - Parses HTTP headers to correctly compute cacheability of responses.
http-cache - Caching middleware that follows HTTP caching rules.
httpz - Code once, support every Rust web server.
xitca-web - Alternative HTTP library and web framework inspired by hyper.
network-types - Rust structs representing network protocol headers (on Layer 2, 3 and 4).
rate-limits - Parse HTTP Rate-Limit headers of different vendors.
Touche - Synchronous HTTP library for Rust.
Kobold - Easy declarative web interfaces. (Intro) (HN)
Perseus - State-driven web development framework for Rust with full support for server-side rendering and static generation. (HN)
html - Type-safe HTML support for Rust.
Pingora - Library for building fast, reliable and evolvable network services.
tower-livereload - Tower middleware to automatically reload your web browser during development.
Hyperide - Library provides utilities to help develop within the hyperide stack.
Leptos Struct Table - Easily create Leptos table components from structs.
dioxus-query - Fully-typed, async, reusable state management and synchronization for Dioxus.
Rust Web Push

Auth

Rust-JWT-Simple - Secure, standard-conformant, easy to use JWT implementation for Rust.
Dacquiri - Strong, compile-time enforced authorization framework for rust applications. (Tweet)
Frank JWT - JSON Web Token implementation in Rust.
oauth1-request - OAuth 1.0 client library for Rust.
totp-rs - RFC-compliant TOTP implementation with ease of use as a goal and additionnal QoL features.
rs-ucan - Rust implementation of UCAN.
PASETOrs - Secure stateless tokens.
Authifier - Opinionated Rust authentication library.
PropelAuth - Rust crate for managing authentication and authorization with support for multi-tenant / B2B products, powered by PropelAuth.

WASM

Smithy - Framework for building WebAssembly apps in Rust.
Walrus - WebAssembly transformation library.
Yew - Modern Rust framework inspired by Elm and React for creating multi-threaded frontend apps with WebAssembly. (Write a Frontend app with Rust and Yew) (axum and yew starter) (Yew Hooks) (Awesome) (Yew OAuth2) (API Hook)
Bounce - State management library for Yew.
Percy - Modular toolkit for building isomorphic web apps with Rust + WebAssembly.
Dodrio - Fast, bump-allocated virtual DOM library for Rust and WebAssembly.
Watt - Runtime for executing Rust procedural macros compiled as WebAssembly.
Draco - Rust library to build client side web applications with Web Assembly.
ehttp - Minimal Rust HTTP client for both native and WASM.
racket-wasm - WASM tooling in Racket.
Zaplib - Open-source library for speeding up web applications using Rust and WebAssembly. (Docs) (HN)
wee_alloc - Wasm-Enabled, Elfin Allocator.
witgen - Library to generate .wit files for WebAssembly in Rust.
parquet-wasm - Rust-based WASM reader for Parquet files.
xtask-wasm - Customizable subcommands to build your WASM projects using xtask.
wasmy - Easily customize my WASM app.
WASM Timer - Abstraction over std::time::Instant and tokio_timer that works on WASM.
WABT-RS - WABT bindings for Rust.
Rust Open Policy Agent SDK - Crate to use OPA policies compiled to WASM.
cargo component - Cargo subcommand for creating WebAssembly components based on the component model proposal.
wasm-instrument - Instrument and transform wasm modules.
wasm_thread - Rust std::thread replacement for wasm32 target.
idb - Futures based crate for interacting with IndexedDB on browsers using WebAssembly.
WasmEdge WASI Socket - Rust SDK for network socket functions available in the WasmEdge Runtime.
prokio - Asynchronous runtime compatible with WebAssembly and non-WebAssembly targets.
edom - Immediate mode web frontend library written in Rust.
spidermonkey-wasm-rs - Rust bindings and generic builtins for SpiderMonkey for the wasm32-wasi target.
cargo wasi - Lightweight Cargo subcommand to build Rust code for the wasm32-wasi target.
wasm-sockets - Rust WASM-specific WebSocket library.
Wasmer Pack - Import your WebAssembly code just like any other dependency.
wasi_snapshot_preview1 - Polyfill adapter for preview1-using wasm modules to call preview2 functions.
WasmBox - Turns running Rust code into a serializable data structure.
leptos_aria - Port of the react-aria ecosystem for the leptos framework.
Scotch - Create WASM plugins easily in Rust.
Stylers - Scoped CSS for Rust web frameworks like Leptos.
Ribir - Framework for building modern native/wasm cross-platform user interface application.
silly-alloc - Collection of very basic allocators. Written with WebAssembly in mind.
wasmprof - Library that allows to profile code running inside of wasmtime.
crypto-wasm - WASM wrapper over the crypto library.
externref - Low-cost reference type shims for WASM modules.

GUI

Tauri - Electron alternative. Build smaller, faster, and more secure desktop applications with a web frontend. (Web) (HN) (HN) (HN) (GitHub) (HN) (Awesome) (Docs Code) (Tauri Plugin Store) (React Tauri)
Tao - Cross-platform application window creation library in Rust that supports all major platforms. Maintained for Tauri.
Egui - Immediate mode GUI written in Rust, made for WASM. (Example) (Eframe template)
rust-skia - Safe Skia Bindings for Rust.
skulpin - Easy option for drawing hardware-accelerated 2D by combining vulkan and skia.
Alchemy - Experimental Rust GUI Framework, backed by native widgets on each platform it supports.
vgtk - Declarative desktop UI framework for Rust built on GTK and Gtk-rs. (HN)
flutter-rs - Build beautiful desktop apps with flutter and rust.
Piet - Abstraction for 2D graphics. (Piet text layout API)
piet-gpu - Experimental GPU compute-centric 2D renderer. (Piet-GPU Progress: Clipping) (HN)
Alcro - Small library to build desktop apps using rust and modern web technologies.
gpucanvas - Antialiased 2D vector drawing library written in rust.
fltk-rs - Rust bindings for the FLTK GUI library.
Thyme - Themable Immediate Mode User Interface Toolkit in Rust.
Slint - Toolkit to efficiently develop fluid graphical user interfaces for any display: embedded devices and desktop applications. (Web) (HN) (Reddit) (HN) (0.3)
Crochet - Explorations in reactive UI patterns.
KAS GUI - ToolKit Abstraction System. General-purpose GUI toolkit in Rust.
tiny-skia - Tiny Skia subset ported to Rust.
Stretch - High performance Flexbox implementation written in rust.
RAUI - Rust implementation of Renderer Agnostic User Interface.
Spline - Implements a new spline designed and optimized for interactive design of 2D curves.
Terra - Large scale terrain rendering library written in Rust.
Ochre - Highly portable GPU-accelerated vector graphics. (Talk)
glyph-brush - Fast GPU cached text rendering.
Speedy2D - Rust library for hardware accelerated drawing of 2D shapes, images, and text, with an easy to use API.
Skui - Skia-based C++ UI framework.
nuklear-rust - Bindings to the Nuklear 2D immediate GUI library.
Tuix - Cross-platform GUI toolkit written in Rust.
Elvis - WASM UI library.
egui-gizmo - 3d transformation gizmo built on top of the egui library.
VIZIA - Declarative GUI library written in Rust.
Panoramix - Prototype implementation of reactive UI in rust.
Freya - Native GUI library for Rust powered by Dioxus and Skia.
Dioxus-STD - Platform agnostic library for supercharging your productivity with Dioxus.
Floem - Native Rust UI library with fine-grained reactivity.

DB

Rust libSQL client library
SQLx - Rust SQL Toolkit.
SQLx Error - Wrapper around sqlx::Error to provide error path and additional context.
TurboSQL - Easy local data persistence layer for Rust, backed by SQLite.
SeaORM - Async & dynamic ORM for Rust. (Rocket with SeaORM example app) (HN) (Web) (Docs Code)
Diesel - Safe, extensible ORM and Query Builder. (Reddit)
Diesel Derive Enum - Use Rust enums directly with diesel ORM.
postgres-query - Write and execute SQL queries with ease.
Rusqlite - Ergonomic bindings to SQLite for Rust.
Rusqlite Migration - Simple schema migration library for rusqlite using user_version instead of an SQL table to maintain the current schema version.
serde_rusqlite - Serialize/deserialize rusqlite rows.
Wundergraph - Provides a platform to easily expose your database through a GraphQL interface.
bolt-rs - Communicate with Bolt-compatible graph databases in Rust.
sqlparser-rs - Extensible SQL Lexer and Parser for Rust.
PickleDB - Lightweight and simple key-value store written in Rust.
TQL - Compile-time ORM, inspired by Django ORM, written in Rust.
postgrest-rs - PostgREST client-side library.
RustRocks - RocksDB binding for Rust.
Cask - Fast key-value store written in Rust.
Buzz Rust - Serverless query engine.
wickdb - Pure Rust LSM-tree based embedded storage engine.
acid-store - Library for secure, deduplicated, transactional, and verifiable data storage.
SeaQuery - Database agnostic runtime query builder for Rust.
DharmaDB - Persistent, fault tolerant key-value store written in Rust.
typed-sql - Zero-cost ORM with fast compile times. (Reddit)
merk - High-performance Merkle key/value store.
Scooby - Rust SQL query builder with a pleasant fluent API closely imitating actual SQL.
pg-embed - Run a PostgreSQL database locally on Linux, MacOS or Windows as part of another Rust application or test.
ormx - Lightweight macros for sqlx.
influxdb-rust - Rust Client for the InfluxDB Time Series Database.
clickhouse-rs - Asynchronous Yandex ClickHouse client library for Rust.
Tesseract - ROLAP engine for web applications, in Rust.
dgraph-tonic - Async/Sync gRPC client for Dgraph DB.
ScyllaDB Rust Driver - Async CQL driver for Rust, optimized for Scylla.
Quaint - SQL Query AST and Visitor for Rust.
lsm_engine - Rust implementation of a key-value store with Log-Structured Merge Trees.
hotpot-db - Easy to use database system. Uses SQLite3.
redis-serde - Serde support for redis-rs.
redis_serde_json - Derive to store and retrieve JSON values in redis encoded using serde.
tiny-lsm - Super simple in-memory blocking LSM for constant-size keys and values.
Rexie - Easy-to-use, futures based wrapper around IndexedDB that compiles to webassembly.
Fang - Background job processing library for Rust. It uses Postgres DB as a task queue.
async-redis-session - redis-backed session store for async-session.
Pot - Concise storage format, written for BonsaiDb.
pg_query.rs - Rust library to parse, deparse and normalize SQL queries using the PostgreSQL query parser.
clickhouse.rs - Typed client for ClickHouse.
FuzzyTrie - Key-value collection to make fuzzy searches.
codd - Library for evaluating typed relational expressions in a monotonically growing minimal database in memory.
redb - Embedded key-value database in pure Rust. (Reddit)
OpenDAL - Open Data Access Layer that connect the whole world together.
persistentcache-rs - Macros for persistently caching function calls using files or Redis.
ODBC-API - Rust ODBC bindings. Open standard to connect to a variety of data sources.
datom-rs - Open-source database inspired by Datomic.
diesel_async - Diesel async connection implementation.
SQLite - Provides an interface to SQLite.
Syncstorage-rs - Sync Storage server in Rust.
xql - SQL query builder for sqlx.
Oxide Crucible - Prototype storage service.
rbatis - Highly Performant,Safe,Dynamic SQL (Compile time) ORM framework written in Rust.
memo-map - Concurrent insert only hash map.
Endorphin - Key-Value based in-memory cache library which supports Custom Expiration Policies.
Nebuchadnezzar - High Performance Key-Value Store.
CannyLS - Embedded persistent key-value storage for Rust that is optimized for random-access workload and huge-capacity HDD.
rocksdb-rs - Rust version of RocksDB.
mysql - Mysql client library implemented in rust.
Lru Time Cache - LRU cache settable via size or time to live.
map-to-const - Easily convert HashMap<K, V> to constant [(K, V); N] values.
Rust Dual Interface for q/kdb+ - Dual q/kdb+ interface for API to build a shared library and an IPC client.
Performance statistic collection for rusts database connection crates
vec-map - Simple map based on a vector for small integer keys.
async-postgres - Runtime-independent asynchronus PostgreSQL client.
Coil - Futures-based background work queue built with SQLx and Postgres.
pg_parse - PostgreSQL parser for Rust that uses the actual PostgreSQL server source to parse SQL queries and return the internal PostgreSQL parse tree.
tokio-rusqlite - Asynchronous handle for rusqlite library.
InfluxDBClient-rs - Easy-use client to InfluxDB.
Cornucopia - Generate type-checked Rust from your PostgreSQL.
marble - Garbage-collecting disk-based object-store.
dilemma - SQL query builder favoring composition over compile time safety.
Catalytic - ScyllaDB and Cassandra Object-Relation Mapper.
duckdb-rs - Ergonomic bindings to duckdb for Rust.
rust-kv - Embedded key/value store for Rust built on sled.
sqlite-cache - SQLite-based on-disk cache for Rust.
PartiQL Rust - Collection of crates to provide Rust support for the PartiQL query language.
YAKV - Simple persistent-key value storage implemented in Rust using "traditional" architecture: B-Tree, buffer cache, ACID transaction, write-ahead log.
encrypted-sled - Drop in replacement / wrapper around the amazing sled embedded database.
Speculare Server - Receive, store info coming from the client into the database and handle alerts to report incidents based on criteria.
ekv - Key-value store for embedded systems, for raw NOR flash, using an LSM-Tree.
linked-hash-map - HashMap wrapper that holds key-value pairs in insertion order.
zerocopy - Safe zero-copy parsing and serialization.
leveldb-rs - Fully compatible implementation of LevelDB in Rust.
TDengine connector for Rust
Hug SQLx - Derive macro turning SQL queries into plain Rust functions.
mysql_async - Asyncronous Rust Mysql driver based on Tokio.
concurrent-map - Lock-free linearizable map.
odht - Hash tables that can be mapped from disk into memory without the need for up-front decoding.
schnellru - Fast and flexible LRU map.
Canyon-SQL - Rust ORM and query builder for multiple databases. (Reddit)
Quick Cache - Lightweight and high performance concurrent cache.
Xline - Geo-distributed KV store for metadata management.
Butane - ORM for Rust with a focus on simplicity and on writing Rust, not SQL.
OpenSrv - Async bindings for emulating database servers. Currently, support for ClickHouse and MySql/MariaDB is provided.
cdbc - Coroutine Database driver Connectivity.based on mco.
ormlite - ORM in Rust for developers that love SQL.
boh - Tiny thing that can hold many things.
Nut - Port of Bolt DB in Rust.
Remi - Robust, and simple asynchronous Rust crate to handle storage-related communications with different storage providers.
SQLx Conditional Queries - Conditional compile-time verified queries with SQLx.
indxdb - Key-value database engine abstraction layer for IndexedDB running in the browser with WASM.
Mini Moka - Fast, concurrent cache library for Rust.
serde-query - Rust library that lets you write jq-like queries for your data.
cacache - High-performance, concurrent, content-addressable disk cache, optimized for async APIs.
rsonpath - Fast Rust JSONPath query engine.
adrodb - Super simple key-value store using SQLite.
SQLite no_std - Rust bindings for SQLite that are no_std and wasm compatible.
Carbonado - Apocalypse-resistant data storage format for the truly paranoid.
Storage - Exploration of Storages.
kvm-sample-rust - Minimal KVM API sample in Rust.
Kiddo - High-performance, flexible, ergonomic k-d tree library.
BendSQL - Databend Native Client in Rust.
PlanetScale Serverless Driver for Rust
diesel_ltree - Adds support for the PostgreSQL ltree extension to Diesel.
LruMap - Set of safe Least Recently Used (LRU) map/cache types for Rust.

Video

rust-ac-ffmpeg - Rust wrapper for FFmpeg libraries.
Nightfall - Easy to use lib for creating on-demand transcoding sessions for efficient media playback.
retina - High-level RTSP multimedia streaming library, in Rust.
h264-reader - Rust reader for H264 bitsream syntax.
libv4l-rs - Safe bindings to the Video for Linux (V4L) stack.
OpenH264 Rust - Idiomatic and low-level bindings for OpenH264.

Graphics

forma - Efficient vector-graphics renderer.
Miniquad - Safe and cross-platform rendering library focused on portability and low-end platforms support.
gfx - High-performance, bindless graphics API. (Gfx-Rs: The Big Picture)
rspirv - Rust implementation of SPIR-V module processing functionalities.
cgmath-rs - Linear algebra and mathematics library for computer graphics.
aljabar - Extremely generic linear algebra library for Rust.
raqote - Pure Rust 2D Graphics Library.
Kiss3d - Keep it simple, stupid 3d graphics engine for Rust.
ncollide - 2 and 3-dimensional collision detection library in Rust.
imgui-rs - Rust bindings for dear imgui.
luminance - Type-safe, type-level and stateless Rust graphics framework.
Gate - Specialized 2D game library.
ultraviolet - Wide linear algebra crate for games and graphics.
pixels - Tiny hardware-accelerated pixel frame buffer.
kurbo - Rust library for manipulating curves.
Rust-SDL2 - SDL2 bindings for Rust.
femtovg - Antialiased 2D vector drawing library written in Rust.
glow - Set of bindings to run GL anywhere and avoid target-specific code.
Rust GPU - Making Rust a first-class language and ecosystem for GPU code. (HN) (HN 2) (Example Shaders)
Rend3 - Easy to use, customizable, efficient 3D renderer library built on wgpu.
Conrod - Easy-to-use, 2D GUI library written entirely in Rust.
Peach - Processing-esque sandboxing framework for Rust.
Rendiation - Group of crates that can be composed to impl graphics project.
Building Blocks - Voxel library for real-time applications.
Relm4 - Idiomatic GUI library inspired by Elm and based on gtk4-rs.
wgpu-pbr - Implementation of PBR using wgpu-rs.
Kludgine - 2d game engine written in rust atop of wgpu.
Blue Engine - General-purpose, easy-to-use, fast, extendable, secure, and portable graphics engine written in rust.
Flou - Flowchart description language. (Docs) (Reddit)
geom3d - Data structures and algorithms for 3D geometric modeling.
dolly - Composable camera rigs.
gpgpu - Simple GPGPU framework for Rust built on top of wgpu.
jpeg-decoder - Rust library for decoding JPEGs.
raster.rs - Raster processing library and tools written in rust.
geo-svg - Generate SVG strings from geo-types.
Limelight - WebGL2 wrapper with a focus on making high-performance WebAssembly graphics code easier to write and maintain.
Kayak UI - Declarative UI that can be used to make user interfaces in Rust primarily targeting games.
Plexus - Polygonal mesh processing.
Genmesh - Library of mesh generation utilities.
RGeometry - Computational Geometry library written in Rust.
Morphorm - UI layout engine written in Rust.
poll-promise - Rust promise for games and immediate mode GUIs.
Zeno - High performance, low level 2D path rasterization library in pure Rust.
Image - Image processing library.
fast_image_resize - Rust library for fast image resizing with using of SIMD instructions.
descent - Toy library for neural networks in Rust using Vulkan compute shaders.
spectra - Rust demoscene engine.
ocl - OpenCL for Rust.
rgx - Modern mid-level 2D graphics library.
vger-rs - 2D GPU renderer for dynamic UIs.
delaunator-rs - Fast 2D Delaunay triangulation in Rust. A port of Delaunator.
Egui Node Graph - Build your node graph applications in Rust, using egui.
Softy - Simulation tools for animating interacting soft objects.
vtkio - Visualization ToolKit (VTK) file parser and writer.
rui - Rust UI library, inspired by SwiftUI. (Reddit)
Screen 13 - Easy-to-use 2D/3D rendering engine in the spirit of QBasic.
image-gif - GIF encoding and decoding library.
cavalier_contours - 2D polyline/shape library for offsetting, combining, etc.
rust-rgb - Struct RGB for sharing pixels between crates.
wgpu_glyph - Fast text renderer for wgpu, powered by glyph_brush.
Poloto - 2D plotting library that outputs graphs to SVG that can be styled using CSS.
vek - Generic 2D-3D math swiss army knife for game engines, with SIMD support and focus on convenience.
Graphics - Library for 2D graphics, written in Rust, that works with multiple back-ends.
Planetarium - Sub-pixel precision light spot rendering library for astronomy and video tracking applications.
piet-metal - Experimental Metal-based GPU renderer for piet 2D graphics.
AkariRender - High Performance CPU/GPU Physically Based Renderer.
raylib-rs - Rust bindings for raylib.
Agui - Advanced, reactive UI library for Rust.
four - 4-dimensional renderer.
muge - Minimal, Modular, Multiplatform Graphics Engine in Rust and WebAssembly.
glyphon - Fast, simple 2D text rendering for wgpu.
NVTX - Safe Rust FFI binding for the NVIDIA Tools Extension SDK.
Softbuffer - Integrates with the raw-window-handle crate to allow writing to a window in a cross-platform way.
flo_draw - 2D rendering libraries for Rust and FlowBetween.
raw-window-handle - Common windowing interoperability library for Rust.
skeletonize - Line thinning library for binary images.
Hotline - Graphics, compute and hardware accelerated A/V decoding.
GPU Rust Playground - Experimenting with Rust for GPU driver dev.
Frui - Developer-friendly UI framework that makes building user interfaces easy and productive. It's inspired by Flutter architecture and is written in Rust.
Embedded Graphics Web Simulator
Adaptive SPH - Fluid simulation with adaptive particle sizes.
smaa-rs - Post-process antialiasing for wgpu-rs, relying on the SMAA reference implementation.
Pax - Cross-platform rendering engine & Rust framework for interactive graphics, animations, and GUIs.
xilem - Experimental Rust native UI framework.
rough-rs - Draw handy sketches from your rust applications.
Contrast Renderer - Web-gpu based 2D render engine written in Rust.
turtle - Create Animated Drawings in Rust.
Fidget - Infrastructure for complex closed-form implicit surfaces.
CoGrRs - Easy-to-use but performant library for writing renderers using compute shaders in rust.
mogwai - Minimalist, obvious, graphical, web application interface.
threerender - Simple 3D rendering engine.
naga-oil - Crate for combining and manipulating shaders.
Crux - Cross-platform app development in Rust.
Blade - Sharp and simple graphics library.
guee - GUI library for Rust.
Polyhedron Operators - Implements the Conway Polyhedron Operators and their extensions by George W. Hart and others.
NSI - High level Rust bindings for Illumination Research’s Nodal Scene Interface.
Masonry - Rust UI design toolkit. (0.1 release) (HN)
concoct - Cross-platform UI framework in rust.
scene-graph - Scene-graph implementation in Rust.
etagere - Dynamic texture atlas allocator using the shelf packing algorithm.
piet-hardware - Rust's 2D vector graphics library, using GPU primitives.
Lox - Fast polygon mesh library with different data structures and traits to abstract over those.
egui_tiles - Tiling layout engine for egui with drag-and-drop and resizing.
posh - Type-safe Graphics Programming with Functional Shaders.
line_drawing - Collection of line-drawing algorithms for use in graphics and video games.
egui_graphs - Interactive graph visualization widget for rust powered by egui and petgraph.
Mepeyew - Cross Platform, Lightweight Rust Graphics Library.

Games

Tetra - Simple 2D game framework written in Rust.
Emergent AI - Toolset for producing emergent gameplay for games written in Rust.
Renet - Collection of rust crates to create Server/Client networked games.
Collider - Rust library for continuous 2D collision detection, for use with game developement.
Benimator - Sprite animation library for rust game development.
steamworks - Rust bindings to the SteamWorks SDK.
Flax - Fully featured and easy to use ECS library for rust.
yakui - Declarative Rust UI library for games.
Polyanya - Compromise-free Pathfinding on a Navigation Mesh.
me3 - Framework for modding and instrumenting games.
Backroll - Pure Rust implementation of GGPO rollback networking library.
durian - Client-server networking library built on top of the QUIC protocol. (Reddit)
tween - Std-optional tweening library, designed for use in games and animations.
apecs - Asyncronous Parallel Entity Component System.
Game Loop - Rust crate that implements a frame-rate-independent game loop.
Bonsai - Rust implementation of behavior trees.
Micro Jam Engine
Rust for Playdate
Foundry - Entity-component-system (ecs) library written in rust.

GraphQL

Generate Rust code from GraphQL schema
rusty-gql - Schema First GraphQL library for Rust.
Seaography - GraphQL framework for SeaORM.
Juniper Relay Connections

Test

faux - Traitless Mocking Library for Rust.
Drill - HTTP load testing application written in Rust inspired by Ansible syntax.
Loom - Concurrency permutation testing tool for Rust.
Mockito - HTTP mocking for Rust.
ctest - Automated testing of FFI bindings in Rust.
Mockall - Powerful mock object library for Rust.
rstest - Uses procedural macros to help you on writing fixtures and table-based tests.
Proptest - Hypothesis-like property testing for Rust.
cargo-all-features - Cargo subcommand to build and test all feature flag combinations.
Fuzzcheck - Structure-aware, in-process, coverage-guided, evolutionary fuzzing engine for Rust functions. (Docs)
k9 - Rust Testing Library.
expect-test - Minimalistic snapshot testing for Rust.
QuickCheck - Automated property based testing for Rust (with shrinking).
httpmock - HTTP mocking library for Rust.
iai - Experimental One-shot Benchmark Framework in Rust.
Test Case - Rust procedural macro attribute for adding test cases easily.
rutenspitz - Procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation.
Pretty Assertions - Overwrite assert_eq! with a drop-in replacement, adding a colorful diff.
Shuttle - Library for testing concurrent Rust code.
build-fs-tree - Generate a filesystem tree from a macro or a YAML tree.
afl.rs - Fuzzing Rust code with AFLplusplus.
heckcheck - Heckin small test generator.
rust-counter-strings - Counter strings generator written in rust to help aid software testing.
Cucumber Rust - Cucumber testing framework for Rust. Fully native, no external test runners or dependencies.
test-fuzz - Make fuzzing Rust easy.
Grillon - Elegant and natural way to approach end-to-end HTTP API testing in Rust.
wiremock - HTTP mocking to test Rust applications.
Golden Tests - Golden file testing library for rust.
cargo-mutants - Mutation testing tool for Rust.
Nextest - Next-generation test runner for Rust. (Tweet) (Reddit) (Docs) (Example demonstrating build reuse and test partitioning with nextest)
assay - Super powered testing macro for Rust.
rusty-fork - Run Rust tests in isolated subprocesses.
propfuzz - Rust toolkit to combine property-based testing and fuzzing.
Yare - Lean parametrized testing library for Rust.
tracing-test - Access and evaluate tracing logs in async and sync tests.
cov-mark - Verify that your tests exercise the conditions you think they are exercising.
test-log - Crate that takes care of automatically initializing logging and/or tracing for Rust.
Coppers - Custom test harnass for Rust that measures the energy usage of your test suite. (HN)
libtest-mimic - Write your own test harness that looks and behaves like the built-in test harness.
arbtest - Minimalist property-based testing library.
Fazi - Drop-in replacement for libfuzzer.
serial_test - Allows for the creation of serialized Rust tests.
bolero - Fuzz and property testing front-end for Rust.
split-test - Splits tests into multiple groups based on timing data to run tests in parallel.
test-strategy - Procedural macro to easily write higher-order strategies in proptest.
unimock - Library for defining mock implementations of traits.
mock-it - Aims to make mocking reliable.
Turmoil - Add hardship to your tests. (Announcement)
testdata-rs - Macros and helper functions for file-based testing.
partial-io - Rust library that provides helpers for testing resilience of I/O operations.
stubr - Rust implementation of Wiremock.
asserhttp - Fluent HTTP response assertions.
Google Rust testing library
Mry - Simple but powerful mocking library for structs, traits, and function.
cargo-is-tested - Assure that your tests are there, and well written.
Assertables - Rust crate of assert macros for testing.
assert2 - All-purpose assert!(...) and check!(...) macros, inspired by Catch2.
speculoos - Fluent test assertions for Rust.
Test generator - Procedural macro attributes that generates multiple parametrized tests using one body with different resource input parameters.
trycmd - Snapshot testing for a herd of CLI tests.
lain - Structured fuzzing framework built in Rust.
serde-reflection - Rust libraries and tools to help with interoperability and testing of serialization formats based on Serde.
Necessist - Run tests with statements and method calls removed to help identify broken tests.
rust-skeptic - Test your Rust Markdown documentation via Cargo.
pytest-rs - Experiment with pytest-like harness for Rust.
datadriven - Tool for writing table-driven tests in Rust, with rewrite support.
datatest-stable - Simple test harness intended to write data-driven tests, where individual test cases are specified as files and not as code.
compiletest-rs - Extraction of the compiletest utility from the Rust compiler.
Fabriko - Rust library to easily write safe and flexible factories for your test fixtures.
assert_fs - Filesystem fixtures and assertions.
similar-asserts - Provides assert_eq! like macros with colorized diff output.
rvcr - Record-and-replay testing middleware for reqwest http client.

Error

eyre - Trait object based error handling type for easy idiomatic error handling and reporting in Rust applications.
derive(Error) - Provides a convenient derive macro for the standard library's std::error::Error trait.
Fehler - Library to add support for "throwing functions" to Rust through procedural macros.
failure - Designed to make it easier to manage errors in Rust.
Anyhow - Flexible concrete Error type built on std::error::Error.
SNAFU - Easily assign underlying errors into domain-specific errors while adding context.
some-error - Library for creating and using anonymous sum types as errors.
Srcerr - User friendly errors from source data.
human-panic - Panic messages for humans.
panic-persist - Writes panic messages to a section of RAM.
better-panic - Gives you pretty backtraces for panics.
thisdiagnostic - Rust library for adding rich diagnostic metadata to errors.
miette - Fancy upgrade to std::error::Error.
color-eyre - Custom hooks for colorful human oriented error reports via panics and the eyre crate.
woah - Result type that differentiates between local errors (which can be handled) and fatal errors (which can't).
Core Error - Traits for working with Error in std-less environments.
Serum Errors - Specification for human-readable, machine-managable, observable/serializable/cross-language errors and error handling.
tracked - Stringly-typed Error that includes #[track_caller] information.
fused_error - Simple library for working with composable errors.
onlyerror - Tiny error derive macro.

IO

Mio - Metal IO library.

iOS

cargo-cocoapods - Bundle Cargo crates for use with macOS/iOS in Xcode.
uikit-sys - Rust bindings to to iOS UIKit Objective-C framework.

UI

Iced - Cross-platform GUI library for Rust, inspired by Elm. (HN) (HN)
Azul - Desktop GUI Framework.
Druid - Data-first Rust-native UI design toolkit. (Some reflections on the Druid architecture) (Dynamic widget sketches)
flutter-rs - Build flutter desktop app in dart & rust.
Moxie - Lightweight platform-agnostic tools for declarative UI.
OrbTk - Rust UI-Toolkit.

Crypto

subtle - Pure-Rust traits and utilities for constant-time cryptographic implementations.
zksnark-rs - Zero knowledge succinct arguments of knowledge, written in Rust.
bellman - Crate for building zk-SNARK circuits.
bellperson - Crate for building zk-SNARK circuits. Fork of the great bellman library.
Spartan - High-speed zkSNARKs without trusted setup.
RustCrypto: hashes - Collection of cryptographic hash functions written in pure Rust.
Mundane - Rust cryptography library backed by BoringSSL that is difficult to misuse, ergonomic, and performant (in that order). (HN)
RustCrypto: Elliptic Curves
poly-commit - Rust library for polynomial commitments.
Marlin - Rust library for the Marlin preprocessing zkSNARK.
STHash - Fast, keyed, cryptographic hash function designed to process large, possibly untrusted data.
arkworks::algebra - Libraries for finite field, elliptic curve, and polynomial arithmetic.
pairing - Crate for using pairing-friendly elliptic curves.
Monotree - Optimized Sparse Merkle Tree in Rust.
Cupcake - Rust library for lattice-based additive homomorphic encryption.
orion - Usable, easy and safe pure-Rust crypto.
Curv - Rust language general purpose elliptic curve cryptography.
serde-encrypt - Encrypts all the Serialize.
PLONK - Pure Rust implementation of the PLONK proving system over BLS12-381.
Tofn - Threshold cryptography library in Rust.
RustCrypto: Utilities - Utility crates used in RustCrypto.
Verkle Trie
ed25519-dalek - Fast and efficient ed25519 signing and verification in Rust.
curve25519-dalek - Pure-Rust implementation of group operations on Ristretto and Curve25519.
dryoc - Pure-Rust, general-purpose cryptography library.
RustCrypto: block ciphers - Collection of block ciphers and block modes written in pure Rust.
Curves - Implementations of popular elliptic curves.
ark-circom - Arkworks bindings to Circom's R1CS, for Groth16 Proof and Witness generation in Rust.
r1cs - Rust library for building R1CS gadgets over prime fields, which are useful in SNARKs and other argument systems.
Cipher-crypt - Library of historic cryptographic algorithms implemented in rust.
BigInt - Cryptographic Big Integers.
gravity-rs - Rust implementation of the Gravity-post-quantum signature schemes.
MACs - Message authentication code algorithms written in pure Rust.
RustCrypto: Formats - Cryptography-related format encoders/decoders: PKCS, PKIX.
crypto-hash - Rust wrapper for OS-level cryptographic hash functions.
vodozemac - Rust reimplementation of the functionality of libolm, a cryptographic library used for end-to-end encryption in Matrix.
Blind RSA signatures - Author-blinded RSASSA-PSS RSAE signatures.
RustCrypto: Traits - Collection of traits which describe functionality of cryptographic primitives.
RustCrypto: Password Hashes - Password hashing functions / KDFs.
Cryptoxide - Crypto primitives in pure rust - wasm compatible.
rust-hpke - Implementation of the HPKE hybrid encryption standard.
minisign-verify - Small, zero-dependencies Rust crate to verify Minisign signatures.
Trussed - Modern Cryptographic Firmware.
Rust-Crypto - Rust implementation of various common cryptographic algorithms.
RustCrypto AEADs - Authenticated Encryption with Associated Data (AEAD) Algorithms.
RustCrypto: NIST P-384 - Elliptic curve (a.k.a. secp384r1) types implemented in terms of traits from the elliptic-curve crate.
rust-ed25519-compact - Small, WASM-friendly, zero-dependencies Ed25519 implementation for Rust.
blake3_merkle - Based on merkle tree, but the exposed interface cannot export merkle tree.
group - Elliptic curve group traits and utilities.
Snowstorm - Minimalistic encryption protocol for rust async streams/packets, based on noise protocol and snow.
Linear-Time Sumcheck - Rust library that implements the sumcheck protocol.
Classic McEliece - Safe pure-rust implementation of the Classic McEliece post-quantum scheme.
stream ciphers - Collection of stream cipher algorithms.
ed25519-speccheck - Test cases for EdDSA signature verification edge cases.
bls12_381 - Implementation of the BLS12-381 pairing-friendly elliptic curve group.
secrets - Library to help Rust programmers safely held cryptographic secrets in memory.
crrl - Rust library for cryptographic research.
Private-ID - Collection of algorithms to match records between two parties, while preserving the privacy of these records.
twenty-first - Cryptography implementations in Rust.
fastcrypto - Common cryptographic library used in software at Mysten Labs.
fss - Rust libraries for designing and using functional secret sharing schemes.
fhe.rs - Fully Homomorphic Encryption library in Rust.
Proof Toolbox - Cryptographic primitives and protocols that can be used to build higher level protocols and schemes.
JOSE - Pure Rust implementation of JavaScript Object Signing and Encryption (JOSE).
pairing - Optimizations for Pairing-Based Cryptography.
ore.rs - Order-revealing encryption library used by the CipherStash searchable encryption platform.
cretrit - Comparison-Revealing Encryption primitives.
sss-rs - Rust bindings for my Shamir secret sharing library.
RustCrypto: signatures - Cryptographic signature algorithms: DSA, ECDSA, Ed25519.
Multi-party ECDSA - Rust implementation of {t,n}-threshold ECDSA (elliptic curve digital signature algorithm).
Poseidon - Instantiation of the Poseidon hash for use with decaf377.
Miden Crypto - Cryptographic primitives used in Polygon Miden.
eciesrs - Elliptic Curve Integrated Encryption Scheme for secp256k1.
Sponge - Library for cryptographic sponges.
halo2curves - BN256 pairing library that implements original traits from zkcrypto.
halo2wrong - Consist of a simple PLONK gate and non native arithmetic based applications.
flo_curves - Bezier curve library for Rust.
bn254 - Aggregate signatures over the pairing-friendly elliptic curve BN254.
Dilithium - Post-quantum cryptographic signature scheme.
Kyber - Rust implementation of the Kyber post-quantum KEM.
Cryptocorrosion - Performance crypto in pure Rust.
blstrs - Implementation of BLS12-381 pairing-friendly elliptic curve construction, using the blst library as backend.
bls - Aggregatable BLS sigantures.
Rustls FFI bindings - FFI bindings for the rustls TLS library.
crypto - Rust crypto library for data privacy tools.
Plonky3 - Collection of libraries related to polynomial IOPs (PIOPs).
bcrypt - Easily hash and verify passwords using Bcrypt.
tree_hash - SSZ-compatible tree hash implementation optimised for speed and security.

Linux

Reverie - Ergonomic and safe syscall interception framework for Linux.
procfs - Rust library for reading the Linux procfs filesystem.
libkrun - Dynamic library providing KVM-based process isolation capabilities.
io-uring - Linux IO Uring.
shmem-ipc - Rust high-performance communication between untrusted processes on Linux.
perf-event - Rust interface to Linux performance monitoring.
RedBPF - Rust library for building and running BPF/eBPF modules.
iou - Rust interface to io_uring.
Aya - eBPF library for the Rust programming language, built with a focus on developer experience and operability. (Article)
sev - Implementation of AMD Secure Encrypted Virtualization (SEV) APIs.
pam - Safe Rust API to the Linux Pluggable Authentication Modules (PAM).
rust-bcc - Idiomatic Rust bindings for the BPF compiler collection.
kvm-ioctls - Provides safe wrappers over the KVM API, a set of ioctls used for creating and configuring Virtual Machines (VMs) on Linux.
reverie - Trace and intercept linux syscalls.
BlueR - Rust interface to the Linux Bluetooth protocol stack (BlueZ).
oxidebpf - Rust library for managing eBPF programs.
inotify-rs - Idiomatic inotify wrapper for Rust.
Netlink - netlink libraries for rust.
libbpf-rs - Minimal and opinionated eBPF tooling for the Rust ecosystem.
cgroups-rs - Native Rust library for managing control groups under Linux.
Rust iptables - Bindings for iptables application in Linux.
listenfd - Helper crate to work with systemd/catflap socket activation.
libseccomp-rs - Rust Language Bindings for the libseccomp Library.
libsystemd - Pure-Rust client library to work with systemd.
vHost - Pure rust library for vDPA, vhost and vhost-user.
caps - Pure-Rust library to work with Linux capabilities.
InputBot - Rust library for creating global hotkeys, and emulating inputs.
daemonize-me - Rust library to ease the task of creating daemons.
zbus - Rust API for D-Bus communication.
libbpf-sys - Rust bindings to libbpf from the Linux kernel.
Userfaultfd - Rust bindings for Linux's userfaultfd functionality.
gpio-cdev - Rust interface to the Linux GPIO Character Device API (/dev/gpiochip...).
aya-log - Logging library for eBPF programs.
nbd-rs - Asynchronous Rust client and server implementation of the Network Block Device (NBD) protocol.
rust-systemd - Rust interface to systemd c apis.
SELinux - Flexible Mandatory Access Control for Linux.
penguincrab - Unsafe wrapper for Linux Kernel Library in Rust.
sysfs_gpio - Rust Interface to the Linux sysfs GPIO interface.
Wayland rust - Rust implementation of the wayland protocol (client and server).
Penrose - Library for writing an X11 tiling window manager.
syscalls - Raw Linux system calls for Rust.
ALSA-rs - Safe wrappers for ALSA, most common API for accessing audio devices on Linux.
Rust Landlock - Rust library for the Linux Landlock sandboxing feature.
devicemapper-rs - Rust library for using Linux devicemapper.
linux-raw-sys - Generated bindings for Linux's userspace API.
rustix-uring - Low-level io_uring userspace interface for Rust ported to rustix.
A10 - Low-level library safely exposing the io_uring API.

Embedded

Drogue Device - Async framework written in Rust for safe and efficient embedded applications.
volatile-register - Volatile access to memory mapped hardware registers.
stm32f7xx-hal - Rust embedded-hal HAL for all MCUs in the STM32 F7 family.
embedded-svc - Rust APIs and abstractions for various embedded services (WiFi, Network, Httpd, Logging, etc.).
RPPAL - Rust library that provides access to the Raspberry Pi's GPIO, I2C, PWM, SPI and UART peripherals.
Infrared - Infrared remote control library for embedded Rust.
embed-c - Allows you to embed C code inside Rust code files.
stm32l4xx-hal - Hardware abstraction layer for the stm32l432xx series chips written in rust.
lm3s6965 - Minimal device crate for the LM3S6965 (Cortex-M3) microcontroller.
fugit - Provides a comprehensive library of Duration and Instant for the handling of time in embedded systems, doing all it can at compile time.
esp32-hal - Hardware abstraction layer for the esp32 written in Rust.
stm32-eth - Embedded Ethernet driver in Rust.
esp-hal - Experimental no_std HAL targeting ESP devices.
assert_no_alloc - Custom Rust allocator allowing to temporarily disable memory (de)allocations for a thread. Aborts or prints a warning if allocating although forbidden.
defmt-bbq - Highly efficient logging framework that targets resource-constrained devices, like microcontrollers.
nrf-softdevice - Rust bindings for Nordic Semiconductor nRF series SoftDevices.
Wifi on ESP32C3 (on bare-metal Rust)
nrf-usbd - Driver for the USBD peripheral in nRF microcontrollers.
alloc-cortex-m - Heap allocator for Cortex-M processors.
Verified Rust for low-level systems code
nrf-hal - HAL for the nRF51, nRF52 and nRF91 families of microcontrollers.
Embedded SD/MMC - SD/MMC library with FAT16/FAT32 support, suitable for Embedded Rust systems.
embedded-io - IO traits for embedded systems.
Embedded-TLS - Rust TLS 1.3 implementation for embedded devices.
ESPMonitor - Cargo tool for monitoring ESP32/ESP8266 execution.
microbit - Rust crate for BBC micro:bit development.
meadow - Publish/request middleware for robotics applications, with a focus on ease-of-use.
svd2rust - Generate Rust register maps (structs) from SVD files.
stm32l0xx-hal - Hardware abstraction layer (HAL) for the STM32L0 series microcontrollers written in Rust.
webusb - WebUSB API implementation in Rust (and Deno).
salty - Ed25519 signatures for microcontrollers.
esp8266-wifi-serial - Driver to work with the esp8266 module over the serial port.
embuild - Build support for embedded Rust: Cargo integration with other embedded build ecosystems & tools, like PlatformIO, CMake and kconfig.
stm32wlxx-hal - Hardware abstraction layer for the stm32wl series chips written in rust.
w5500-rs - Embedded rust support for the Wiznet W5500 SPI internet offload chip.
edge-executor - Minimal async executor suitable for embedded environments.
Rust bindings for ESP-IDF
shared-bus - Crate for sharing buses between multiple devices.
usbip - Rust library to run a USB/IP server to simulate USB devices.
buddy_system_allocator - Buddy system allocator in pure Rust.
acid_alloc - Bare-metal allocators.
acid_io - Rust I/O for no_std.
esp-idf-hal - Embedded-hal implementation for Rust on ESP32 and ESP-IDF.
rust_gpiozero - Library inspired by gpiozero written in Rust.
Birdcage - Cross-platform embeddable sandboxing library allowing restrictions to Filesystem and Network operations using native operating system APIs.
noline - IO-agnostic line editor for embedded systems.
mpu9250 - No_std driver for the MPU9250 & onboard AK8963 (accelerometer + gyroscope + magnetometer IMU).
esp-idf-svc - Type-Safe Rust Wrappers for various ESP-IDF services (WiFi, Network, Httpd, Logging, etc.)
critical-section - Pluggable critical section.
stm32-data - Produce clean machine-readable data about the STM32 microcontroller families.
bl602-hal - Hardware Abstract Layer for BL602 RISC-V WiFi SoC in embedded Rust.
USRs - Pure-rust library for working with USB devices.
esp8266-hal - Hardware abstraction layer for the esp8266 written in Rust.
pci_types - Useful types for dealing with PCI.
esp-println - Provides print! and println! implementations various Espressif devices.
async-hal - Async hardware abstraction layer for embedded devices.

ML

dfdx - Strongly Typed Auto Grad in Rust.
autograph - Machine Learning Library for Rust.
Neuronika - Tensors and dynamic neural networks in pure Rust.
Juice - Hacker's Machine Learning Engine.
linfa - Rust machine learning framework.
L2 - PyTorch-style Tensor+Autograd library written in Rust.
Fwumious Wabbit - Fast on-line machine learning toolkit written in Rust.
Mushin - Compile-time creation of neural networks.
Alumina - Deep learning library for rust.
bhtsne - Parallel Barnes-Hut t-SNE implementation written in Rust.
ONNX Runtime - Rust wrapper for Microsoft's ONNX Runtime.
HAL - Rust based Cross-GPU Machine Learning.
Cogent - Simple neural network library for classification written in Rust.
tongrams-rs - Rust port of tongrams to index and query large language models in compressed space.
Rust OpenCV bindings
video-toolbox-sys - Rust bindings to Apple's Video Toolbox framework.
Rust AutoML - Automated Machine Learning in Rust.
Orkhon - ML Inference Framework and Server Runtime.
kornia-rs - Low level implementations for computer vision in Rust.
cervo - Wrapper around tract used for ML workloads in our games.
Rust NEAT - NeuroEvolution of Augmenting Topologies.
egobox - Rust toolbox about surrogate-based adaptative optimization.
Safetensors - Simple, safe way to store and distribute tensors.
Disco Rust - Recommendations for Rust using collaborative filtering.
Burn - Deep learning framework with extreme flexibility written in Rust. (Reddit)
FFSVM-Rust - Really Fast Support Vector Machine.
rusTy - Rust bindings for the spaCy library.
RSRL - Fast, safe and easy to use reinforcement learning framework in Rust.
autograd - Tensors and differentiable operations (like TensorFlow) in Rust.
Oxen - Library, tools, and server to manage local and remote Oxen repositories.
Candle - Minimalist ML framework for Rust. (HN)
Zyx - Generic tensor library and extensions.
rustygrad - Tiny Autograd engine written in Rust.
dlpackrs - DLPack safe Rust binding.
DeepCausality - Hypergeometric computational causality library for Rust.

macOS

mach - Rust interface to the Mach 3.0 kernel that underlies macOS.
Cacao - Rust bindings for AppKit (macOS) and UIKit (iOS/tvOS). (HN)
Fruity - Rusty bindings for Apple libraries.
core-foundation-rs - Rust bindings to Core Foundation and other low level libraries on Mac OS X and iOS.
Plist - Rusty plist parser.
oslog - Rust wrapper around Apple's unified logging system.
rust-security-framework - Bindings to the macOS Security.framework.
ahv - Apple Hypervisor crate for Apple Silicon.
macho-unwind-info - Parser for Apple's Compact Unwinding Format, which is used in the __unwind_info section of mach-O binaries.
rust-icns - Rust library for encoding/decoding Apple Icon Image (.icns) files.
DmgWiz - Extract filesystem data from DMG files.
mach2 - Rust interface to the user-space API of the Mach 3.0 kernel exposed in /usr/include/mach that underlies macOS and is linked via libSystem.
hv - High level Rust bindings for Hypervisor Framework.
macos-emond - Simple library to parse macOS Emond files.
appleargs - Rust crate to read the process' apple arguments.
keychain-services.rs - Keychain Services for Rust.
xhypervisor - Rust API to the OS X Hypervisor framework for hardware-accelerated virtualization.
macos-UnifiedLogs - Simple Rust library that can help parse the macOS Unified Log files.
vmnet - Apple's vmnet.framework bindings for Rust.
apple-platform-rs - Rust crates supporting Apple platform development.
coreaudio-rs - Friendly rust interface to Apple's Core Audio API.
Applevisor - Rust bindings for the Apple Silicon Hypervisor.framework.
darwin-libproc - Rust FFI bindings for macOS libproc.
imessage-exporter - Export MacOS iMessage data + run iMessage Diagnostics. (HN)
MacBinary - MacBinary and resource fork reading in Rust.
apple-rs - Idiomatic Rust bindings for iOS and macOS system libraries and frameworks.
apple-sys - Auto-managed -sys crate for Apple platforms using bindgen directly from build environment.

Macros

Readonly - Struct fields that are made read-only accessible to other modules.
join! - One macro to rule them all.
cfg-if - If/elif-like macro for Rust #[cfg] statements.
Rust Embed - Rust Macro which loads files into the rust binary at compile time during release and loads the file from the fs during dev.
Builder Pattern Derive - Rust macro to automatically implement the builder pattern for arbitrary structs.
rabbithole-rs - Nearly well-typed, user-friendly JSON:API type system, with an easy-to-use Macro System to help you modelling the your data.
once_cell - Rust library for single assignment cells and lazy statics without macros.
lazy-static.rs - Macro for declaring lazily evaluated statics in Rust.
partial_application - Partial function application macro for Rust.
macro_railroad - Library to generate syntax diagrams for Rust macros.
genco - Whitespace-aware quasiquoter for beautiful code generation.
num-derive - Procedural macros to derive numeric traits in Rust.
Horrorshow - Macro-based html builder for rust.
pipeline.rs - Macro collection to pipe your functions calls, like in F# or Elixir.
timed - Rust crate to time your function using derive annotations.
paste - Macros for all your token pasting needs.
Darling - Rust proc-macro attribute parser.
unseemly - Macros have types. (Web)
seq-macro - Macro to repeat sequentially indexed copies of a fragment of code.
Automod - Pull in every source file in a directory as a module.
Aquamarine - Inline diagrams for rustdoc with mermade.js.
Velcro - Macros for conveniently initializing collections from Rust's std and iterators.
if_chain - Macro for writing nested if let expressions.
proc-macro-crate - Providing support for $crate in procedural macros.
typestate - Provides developers with a macro to design typestated objects.
Educe - Provides procedural macros to help you implement Rust-built-in traits quickly.
no-panic - Attribute macro to require that the compiler prove a function can't ever panic.
spez - Macro to specialize on the type of an expression.
lazy-regex - Macro for when you're tired of the regex creation boilerplate.
Arraygen - Derive macro for generating arrays from struct fields.
flamer - Compiler plugin to insert flame calls.
bitflags - Macro to generate structures which behave like bitflags.
nightly-crimes - Allow you to enable nightly features on the stable compiler.
rust-delegate - Rust method delegation with less boilerplate.
blanket - Simple Rust macro to derive blanket implementations for your traits.
rustversion - Provides macros for conditional compilation according to rustc compiler version.
plex - Parser and lexer generator as a Rust procedural macro.
momo - Rust proc_macro_attribute to outline conversions from generic functions.
fixed-map - Map implementation that relies on fixed-size storage derived by a procedural macro.
smlang - State Machine Language DSL procedural macro for Rust.
ergo-pin - Ergonomic stack pinning for Rust.
duang - Use macro to provide default parameter and named parameter in Rust.
self_cell - Safe-to-use proc-macro-free self-referential structs in stable Rust.
impls - Rust macro to determine if a type implements a logical trait expression.
rust-derive-macro-guide - Simple derive macros in Rust.
reflect - Compile-time reflection API for developing robust procedural macros.
parse-display - Procedural macro to implement Display and FromStr using common settings.
Derivative - Set of alternative derive attributes for Rust.
enum-as-inner - Macros for deriving as functions to access Enums as their inner components.
Debug Plotter - Rust crate that provides a convenient macro to quickly plot variables.
Supertype - Macro that strives to make it easier to derive a subset of a type from another type.
arrayref - Two macros for taking array references in rust.
macro-attr - Custom derivation macro for Rust.
deepsize - Trait and derive macro to recursively find the size of an object and the size of allocations that it owns.
async-recursion - Procedural macro for recursive async functions.
byteme - Proc-macro to get Vec<u8> from struct and vise versa.
Cute - Macro for Python-esque list comprehensions in Rust.
real_async_trait - Proc macro for real async traits.
Enum Variant Type - Proc macro derive to generate structs from enum variants.
sscanf - Rust crate with a sscanf (inverse of format!()) Macro based on Regex.
js-macros - Quickly prototype Rust procedural macros using JavaScript or TypeScript.
valq - Macros for querying and extracting value from structured data by JavaScript-like syntax.
num_enum - Procedural macros to make inter-operation between primitives and enums easier.
macro_rules_attribute - Use declarative macros as proc_macro attributes or derives.
throttle_my_fn - Rust attribute macro to throttle the execution of functions.
test-span - Macro and utilities to do snapshot tests on tracing spans.
Modular Bitfields - Macro to generate bitfields for structs that allow for modular use of enums.
rust-mdo - Monadic do notation for rust using macro and duck typing.
derive-into-owned - Procedural macro for deriving helper methods for types with Cow fields.
derive-where - Derive macro to simplify deriving standard and other traits with custom generic type bounds.
expander - Expands a proc-macro into a file, and uses a include! directive in place.
Sugars - Nice Rust macros for better writing.
litrs - Parsing and inspecting Rust literals (particularly useful for proc macros).
rustic-c - Macro to write C inside Rust.
bytecoding - Derive macro for encoding and decoding instructions and operands as bytecode.
Venial - Lightweight parsing for Rust proc macros.
duplicate - Macros for code duplication with substitution.
const_format_crates - Compile-time string formatting.
document-features - Extract documentation for the feature flags from comments in Cargo.toml.
postfix-macros - Postfix macros on stable Rust.
doc-comment - Write doc comments from macros.
syn-file-expand - Rust library to scan files and expand (make modules inline) multi-file crates source code as a single tree.
version - Simple macro that returns the version of the crate as a string.
assert-json-diff - Easily compare two JSON values and get great output.
cascade - Dart-like cascade expressions in Rust.
Impl-tools - Set of helper macros.
inline-proc - Inline procedural macros for Rust.
Pomelo - Procedural macro to create Lemon-like parsers.
proc-easy - Macros to make writing proc-macro crates easy.
rust-si - Rusty scanf (scan!) and inverse of print! (read!).
fault-injection - Similar to the try! macro or ? operator, but externally controllable to inject faults during testing. (Tweet)
auto-import - Expands to whatever use statements you need to make the rest of the code compile. (Tweet)
entrait - Proc macro to ease development using Inversion of Control patterns in Rust.
defaults - Better Default derive macro.
staticfilemap - Procedural macro to embed optionally compressed files during compilation.
Bassert - Better assertions for Rust.
function_name - Macro that expands to the name of the annotated function.
dry - Rust macros for idiomatic deduplication of code.
comparable - Library for comparing data structures in Rust, oriented toward testing.
Virtue - Sinless derive macro helper.
autobox - Compile time analysis for runtime sandboxing.
Inter-Struct - Automatically generated traits for operations between arbitrary structs.
structmap - Procedural macro crate for conversion between Rust structs and associative containers.
mixin - Macros that combine fields and implementations of different structs.
Rust Embed for Web - Rust Macro which embeds files into your executableFork of rust-embed with a focus on usage in web servers..
OptionalStruct - Macro copying a struct with Option fields. Useful for config initialization.
Respan - Macros to erase scope information from tokens.
lazy_format - Lazy formatting utility macro.
auto_impl - Automatically implement traits for common smart pointers.
Decurse - Rust macro to make recursive function run on the heap.
Goldberg - Rust-based obfuscation macro library.
hs-bindgen - Handy macro to generate C-FFI bindings to Rust for Haskell.
tuple_list - Rust crate for macro-free variadic tuple metaprogramming.
naked-function - Proc macro version of the #[naked] attribute.
syntactic-for - Syntactic "for" loop Rust macro.
Nutype - Newtype macros on steroids.
Subenum - Simple proc-macro to derive subsets of enums.
Deluxe - Rust procedural macro attribute parser.
transitive - Transitive derive macros for Rust.
ffi-opaque - Macro generating correct opaque types.
struct-field-names-as-array - Rust crate providing a procedural macro that generates an array of the field names of a named struct.
fromit - Macro for generating new structs with getters, setters, and From or TryFrom implementation based on the given struct.
enum-tags - Derive-Macro library that generates a companion tag-enum for any enum so that variants can be referred to without specifying fields.
include_dir - Evolution of the include_str macro for embedding a directory tree into your binary.
myn - Minimalist Rust syntax parsing for procedural macros.
sealed - Macro for sealing traits and structures.
trait-gen - Trait implementation generator macro.
confik - Macro for creating configuration/settings structures and functions to read them from files and the environment.

Math

Lair - Linear Algebra in Rust.
Friedrich - Rust implementation of Gaussian Process regression.
hnsw - Hierarchical Navigable Small World Graph for fast ANN search.
statrs - Statistical computation library for Rust.
sprs - Sparse linear algebra library for rust.
Mathbox - Collection of math tools for Rust.
geometry-predicates - Rust solution to efficient exact geometry predicates used widely for computational geometry.
meval - Math expression parser and evaluation library for Rust.
libprio-rs - Rust implementation of Prio, a system for Private, Robust, and Scalable Computation of Aggregate Statistics.
Exmex - Math parser and evaluator in Rust, capable of partial differentiation, allows the use of custom operators.
cglinalg - Low-dimensional linear algebra library for real-time computer graphics.
kmeans-colors - k-means clustering library and binary to find dominant colors in images.
roots - Library of well known algorithms for numerical root finding.
Astro-float - Arbitrary precision floating point numbers library.
wedged - Robust and generalized library for Geometric Algebra in Rust.
matrixmultiply - General matrix multiplication of f32 and f64 matrices in Rust. Supports matrices with general strides.
watermill - Fast, generic and serializable online statistics.
Cycle - Modern and safe symbolic mathematics.
num-complex - Complex numbers for Rust.
RustQuant - Rust library for quantitative finance.
primal - Puts raw power into prime numbers.
scilib - Rust crate for mathematics and science.
baby_shark - Geometry processing library in pure rust.
Rust Linear Solver Toolbox

CSS

css-inline - Inline CSS into style attributes.

Other

Serde - Serialization framework for Rust. (Docs) (HN)
serde-reflection - Rust libraries and tools to help with interoperability and testing of serialization formats based on Serde.
Miniserde - Data structure serialization library with several opposite design goals from Serde.
Microserde - Miniserde minus the dependencies.
Abomonation - Mortifying serialization library for Rust.
PyO3 - Rust bindings for the Python interpreter. (HN) (Maturin - Build and publish crates with pyo3)
Actix - Actor framework for Rust. (Examples) (User Guides) (HN)
Actix Governor - Middleware for actix-web that provides rate-limiting backed by governor.
Actix Extras - Collection of additional crates supporting the actix and actix-web frameworks.
Tokio - Runtime for writing reliable asynchronous applications with Rust. Provides I/O, networking, scheduling, timers. (Web) (Tokio Console) (HN)
Tokio Metrics - Utilities for collecting metrics from a Tokio application.
nom - Parser combinators library. (Tutorial) (Building a CEDICT parser in Rust with Nom) (Error recovery with parser combinators (using nom)) (Parsing Text with Nom) (HN)
nom-derive - Declarative parsing for Rust, using a custom derive and nom.
rpds - Rust Persistent Data Structures.
Futures await - Async/await syntax and the futures crate.
nix - Rust friendly bindings to *nix APIs.
wasmi - Wasm interpreter in Rust.
rayon - Data parallelism library for Rust. (Parallelizing graph search with Rayon) (Reddit)
libfringe - Rust library implementing safe, lightweight context switches, without relying on kernel services.
rust-url - URL parser for Rust.
Rust-Postgres - Native PostgreSQL driver for Rust.
im-rs - Assorted immutable collection datatypes for Rust.
Juniper - GraphQL server library for Rust.
juniper-eager-loading - Library for avoiding N+1 query bugs with Juniper.
Logos - Create ridiculously fast Lexers.
Librsvg - SVG rendering library.
rust-openssl - OpenSSL bindings for Rust.
rustls - Modern TLS library in Rust.
Rusoto - AWS SDK for Rust.
Rand - Rust library for random number generation.
noise-rs - Procedural noise generation library for Rust.
Rust-AV - Multimedia Toolkit written in pure rust.
cookie-rs - HTTP cookie parsing and cookie jar management for rust.
yoga-rs - Rust Wrapper of Facebook's Yoga, a Flexbox layout engine.
redux-rs - Rust implementation of Redux. (Fork)
Datafrog - Lightweight Datalog engine intended to be embedded in other Rust programs.
kubernetes-rs - Kubernetes API client library for Rust.
jemallocator - Rust allocator using jemalloc as a backend.
tikv-jemallocator - Simplified fork of jemallocator focus on server.
cargo-asm - Cargo subcommand showing the assembly or llvm-ir generated for Rust code.
Crossbeam - Tools for concurrent programming in Rust. (HN) (RFCs) (Wiki)
evmap - Lock-free, eventually consistent, concurrent multi-value map.
Headless Chrome - Puppeteer for Rust.
rust-smallvec - "Small vector" optimization for Rust: store up to a small number of items on the stack.
Ketos - Lisp dialect scripting and extension language for Rust programs.
MAY - Rust stackful coroutine library.
Ditto - CRDTs for common data structures like maps, vecs, sets, text, and JSON.
self_update - Provides updaters for updating rust executables in-place from various release distribution backends.
libc - Raw FFI bindings to platforms' system libraries.
Svgbob - Convert your ascii diagram scribbles into happy little SVG.
cbindgen - Project for generating C bindings from Rust code.
Bincode - Binary encoder / decoder implementation in Rust.
Hypercore - Secure, distributed, append-only log. (Web) (HN)
rust-rocksdb - Rust wrapper for rocksdb.
futures-rs - Zero-cost asynchronous programming in Rust.
hashbrown - Rust port of Google's high-performance SwissTable hash map, adapted to make it a drop-in replacement for Rust's standard HashMap and HashSet types.
Rust-WebSocket - Provides a framework for dealing with WebSocket connections (both clients and servers).
Ramhorns - Experimental Mustache template engine implementation in pure Rust.
rust-notifica - Small, cross-platform Rust crate for sending system notifications.
pulldown-cmark - Pull parser for CommonMark, written in Rust. It comes with a simple command-line tool, useful for rendering to HTML, and is also designed to be easy to use from as a library.
Image - Encoding and decoding images in Rust.
fern - Simple, efficient logging for Rust.
Runtime - Empowering everyone to build asynchronous software.
miri - Interpreter for Rust's mid-level intermediate representation.
Tide - Empowering everyone to build HTTP Services.
fst - Represent large sets and maps compactly with finite state transducers.
maud - Compile-time HTML templates for Rust. (HN) (Docs) (HN)
panic-never - This crate guarantees that your application is free of panicking branches.
graphql_client - Typed, correct GraphQL requests and responses in Rust.
daemonize - Library for writing system daemons.
cc-rs - Rust library for build scripts to compile C/C++ code into a Rust library.
nannou - Creative Coding Framework for Rust. (Web) (HN)
Criterion.rs - Statistics-driven benchmarking library for Rust. (Improving Criterion.rs)
Cargo-fuzz - Command-line wrapper for using libFuzzer. Easy to use, no need to recompile LLVM.
spade - Spatial Data Structures for Rust.
pg-extend-rs - Rust based Postgres extension.
Hiher - Higher kinded types and other bad ideas for Rust.
cargo-geiger - Detects usage of unsafe Rust in a Rust crate and its dependencies.
Surf - Fast and friendly HTTP client framework for async Rust.
async-std - Async version of the Rust standard library. (Article)
petgraph - Graph data structure library for Rust.
Neon - Rust bindings for writing safe and fast native Node.js modules. (Web)
Plotters - Rust Drawing Library for Plotting.
rust-GSL - Rust binding for the GSL library (the GNU Scientific Library).
combine - Parser combinator library for Rust.
Syn - Parsing library for parsing a stream of Rust tokens into a syntax tree of Rust source code.
Emu - Framework/compiler for GPU acceleration of Rust, GPU programming.
Coroutine I/O - Coroutine scheduling with work-stealing algorithm.
tempfile - Temporary file library for rust.
geo - Geospatial primitives and algorithms for Rust.
hashbrown - Rust port of Google's SwissTable hash map.
nalgebra - Linear algebra library for Rust.
envy - Deserialize env vars into typesafe structs with rust.
tiny-http - Low level HTTP server library in Rust.
Dataloader - Rust implementation of Facebook's DataLoader using futures.
Specs - Entity-Component System written in Rust.
euclid - Small library for geometric types with a focus on 2d graphics and layout.
Notify - Cross-platform filesystem notification library for Rust.
notify-rust - Send Desktop Notifications on linux and bsd.
color-backtrace - Colorful panic backtraces for Rust.
r2d2 - Generic connection pool for Rust.
Rust-PHF - Compile time static maps for Rust.
Signal-hook - Rust library allowing to register multiple handlers for the same signal.
partial-io - Rust library that provides helpers for testing resilience of IO operations.
Amadeus - Harmonious distributed data analysis in Rust.
Constellation - Distributed programming for Rust.
ndarray - N-dimensional array with array views, multidimensional slicing, and efficient operations.
Evcxr - Rust REPL and Jupyter Kernel. (HN)
Declarative Dataflow - Reactive query engine built on differential dataflow.
refinery - Powerful SQL migration toolkit for Rust.
Juggernaut - Experimental Neural Network written in Rust.
Riker - Easily build efficient, highly concurrent and resilient applications. An Actor Framework for Rust.
bitvec - Crate for managing memory bit by bit.
rust-cpython - Rust <-> Python bindings.
Vicuna - AWS Lambdas in Rust made simple.
quicksilver - Simple game framework for 2D games on desktop and web.
refpool - Efficient memory pool mechanism for Rust.
lol-html - Low output latency streaming HTML parser/rewriter with CSS selector-based API.
mitosis - Spawn processes with arbitrary closures in rust.
prettytable-rs - Rust library to print aligned and formatted tables.
unicode-width - Displayed width of Unicode characters and strings according to UAX#11 rules.
Chrono - Date and time library for Rust.
iqlusion crates - Collection of open source Rust crates from iqlusion.
bnf - Parse BNF grammar definitions.
quick-protobuf - Rust implementation of protobuf parser.
Deadpool - Dead simple pool implementation for rust with async-await.
cuneiform - Cache optimizations for Rust, revived from the slabs of Sumer.
insta - Snapshot testing library for rust. (Web)
pretty.rs - Wadler-style pretty-printing combinators in Rust.
Rusty V8 - Rust bindings for the V8 JavaScript engine.
WS-RS - Lightweight, event-driven WebSockets for Rust.
CXX - Safe interop between Rust and C++. (Docs) (HN)
cxx-async - Rust crate that extends the cxx library to provide seamless interoperability between asynchronous Rust code using async/await and C++20 coroutines using co_await. (Article) (Tweet)
Duct - Rust library for shelling out and making pipelines.
crossterm - Cross platform terminal library rust.
wgpu-rs - Rust bindings to wgpu native library. (Awesome)
rio - Pure rust io_uring library, built on libc, thread & async friendly, misuse resistant.
dashmap - Blazing fast concurrent HashMap for Rust.
Interact - Framework for friendly online introspection of the running program state in an intuitive command-line interactive way.
faster - SIMD for humans.
rust-crdt - Collection of well-tested, serializable CRDTs for Rust. (HN)
JSON-RPC - Rust implementation of JSON-RPC 2.0 Specification. Transport-agnostic core and transport servers for http, ipc, websockets and tcp.
yaml-rust - Pure rust YAML implementation.
directories - Mid-level library that provides config/cache/data paths, following the respective conventions on Linux, macOS and Windows.
Bastion - Highly-available, fault-tolerant runtime system with dynamic, dispatch-oriented, lightweight process model. (HN) (Web)
Desse - Ultra fast binary serialization and deserialization for types with a constant size (known at compile time).
HdrHistogram - Port of HdrHistogram to Rust.
ritual - Use C++ libraries from Rust.
RMP - Pure Rust MessagePack implementation.
fasteval - Fast and safe evaluation of algebraic expressions.
wasmparser - Simple event-driven library for parsing WebAssembly binary files.
RoaringBitmap - Roaring bitmap implementation for Rust. (Reddit)
Graphlib - Simple but powerful graph library for Rust.
Rowan - Library for lossless syntax trees, inspired in part by Swift's libsyntax.
Tera - Template engine for Rust based on Jinja2/Django.
LibreAuth - Collection of tools for user authentication.
BoringAuth - Collection of tools for user authentication.
log - Logging implementation for Rust.
typed-html - Type checked JSX for Rust.
enigo - Cross platform input simulation in Rust.
tracing - Application level tracing for Rust.
GraphCore - Provides primitives and traversals for working with graphs.
Async trait methods - Type erasure for async trait methods.
compiler-builtins - Porting compiler-rt intrinsics to Rust.
gtk - Rust bindings and wrappers for GLib, GDK 3, GTK+ 3 and Cairo.
tokio-beanstalkd - Asynchronous client library for interacting with the Beanstalkd work queue.
octopus - Query engine for arrays of integers.
Serde YAML - Strongly typed YAML library for Rust.
shiplift - Rust interface for maneuvering docker containers.
Adapton - General-purpose abstractions for incremental computing, in Rust.
rust-objc - Objective-C Runtime bindings and wrapper for Rust.
rust-block - Rust interface for Apple's C language extension of blocks.
rust-dispatch - Rust wrapper for Apple's Grand Central Dispatch.
indextree - Arena based tree structure by using indices instead of reference counted pointers.
markedit - Library for manipulating unstructured Markdown documents.
plotlib - Data plotting library for Rust.
Parze - Clean, efficient parser combinator.
Flume - Blazingly fast multi-producer, single-consumer channel.
juniper-from-schema - Schema first GraphQL in Rust with Juniper.
stringsext - Find multi-byte-encoded strings in binary data.
byteorder - Rust library for reading/writing numbers in big-endian and little-endian.
genawaiter - Stackless generators on stable Rust.
libpnet - Cross-platform, low level networking using the Rust programming language.
num - Collection of numeric types and traits for Rust.
hecs - Provides a high-performance, minimalist entity-component-system (ECS) world.
intrusive-collections - Intrusive collections for Rust.
froggy - Component Graph System experiment.
Legion - Aims to be a feature rich high performance ECS library for Rust game projects with minimal boilerplate.
derive_more - Some more derive(Trait) options.
async-task - Task abstraction for building executors. (Article)
lz4 bindings - LZ4 is a very fast lossless compression algorithm.
SM - Static State Machine library.
parity-common - Collection of crates used in Parity projects.
desert - Traits for {de,}serializing compact binary formats.
etcd - etcd client library for Rust.
RustGnuplot - Rust library for drawing plots, powered by Gnuplot.
handlebars-rust - Rust templating with Handlebars.
inventory - Typed distributed plugin registration.
rust-ctor - Module initialization/global constructor functions for Rust.
CFG Aliases - Tiny utility to help save you a lot of effort with long winded #[cfg()] checks in Rust.
salsa - Generic framework for on-demand, incrementalized computation.
Bytes - Utility library for working with bytes.
Internment - Interning of data in rust.
merkle-tree-stream - Stream that generates a merkle tree based on the incoming data.
async-graphql - GraphQL server library that fully supports async/await and is easy to use. (Examples)
comrak - CommonMark + GFM compatible Markdown parser and renderer.
comrak-wasm - WASM bindings for the comrak markdown renderer.
generational-arena - Safe arena allocator that allows deletion without suffering from the ABA problem by using generational indices.
printpdf - Library designed for creating printable PDF documents.
rust-prometheus - Prometheus instrumentation library for Rust applications.
llvm-ir - LLVM IR in natural Rust data structures.
tinyvec - 100% safe crate of vec-like types.
time - Simple time handling in Rust.
regex-automata - Low level regular expression library that uses deterministic finite automata.
syntect - Rust library for syntax highlighting using Sublime Text syntax definitions.
glam - Simple and fast linear algebra library for games and graphics.
rust_minifb - Cross platform window and framebuffer crate for Rust.
libloading - Better library for loading dynamic libraries.
NumToA - Efficient method of heaplessly converting numbers into their string representations, storing the representation within a reusable byte array.
OsStr Bytes - Traits for converting between byte sequences and platform-native strings.
biscuit - JOSE (JSON Web Token) Library for Rust.
Nano ID - Tiny, secure, URL-friendly, unique string ID generator for Rust.
mac-notification-sys - Simple wrapper to deliver or schedule macOS Notifications in Rust.
semval - Semantic validation for Rust.
parking_lot - Compact and efficient synchronization primitives for Rust. Also provides an API for creating custom synchronization primitives.
gimli - Lazy, zero-copy parser for the DWARF debugging format.
hamt-rs - Persistent Map Implementation based on Hash Array Mapped Tries.
rust-native-tls - Abstraction over platform-specific TLS implementations.
itertools - Extra iterator adaptors, iterator methods, free functions, and macros.
validator - Simple validation for Rust structs.
sv-parser - SystemVerilog parser library fully complient with IEEE 1800-2017.
Serde JSON - Strongly typed JSON library for Rust.
Rustbreak - Simple, fast and easy to use self-contained single file storage for Rust.
Curryrs - Bridge the gap between Haskell and Rust.
libm - Port of MUSL's libm to Rust.
smol - Small and fast async runtime for Rust.
Colorous - Color schemes for charts and maps.
Termion - Pure Rust, bindless library for low-level handling, manipulating and reading information about terminals.
object - Unified interface for reading and writing object file formats.
no-panic - Attribute macro to require that the compiler prove a function can't ever panic.
rustc-demangle - Demangling for Rust symbols, written in Rust.
Rust Typed Builder - Creates a compile-time verified builder.
Tether - Barebones Electron-ish library for Rust.
event-listener - Notify async tasks or threads.
cached - Rust cache structures and easy function memoization.
tsunami - Rust crate for running one-off cloud jobs.
proc-macro2 - Wrapper around the procedural macro API of the compiler's proc_macro crate.
Rust Quasi-Quoting - Provides the quote! macro for turning Rust syntax tree data structures into tokens of source code.
displaydoc - Derive macro for implementing the display Trait via a doc comment and string interpolation.
simple-mutex - Simple mutex, faster than std and smaller than parking_lot.
remem - Utility for reusing memory.
aho-corasick - Library for finding occurrences of many patterns at once with SIMD acceleration in some cases.
inline-python - Inline Python code directly in your Rust code.
socket2 - Advanced configuration options for sockets.
heapless - Static friendly data structures that don't require dynamic memory allocation.
Arise - Run a process "forever"; Run a process and spawn it when it dies.
easy-parallel - Run closures in parallel.
Askama - Type-safe, compiled Jinja-like templates for Rust.
libprobe - Static probes for Rust.
Multiversion - Function multiversioning framework for Rust.
Kuchiki - HTML/XML tree manipulation library for Rust.
Deku - Declarative binary reading and writing.
Session Types - Implementation of session types for Rust.
binread - Rust crate for helping parse structs from binary data using macro magic.
simdeez - Library that abstracts over SIMD instruction sets, including ones with differing widths.
SIMDNoise - Super fast SIMD noise library for Rust.
Josephine - Using JavaScript to safely manage the lifetimes of Rust data.
Colored - Coloring terminal so simple you already know how to do it.
Salva - 2 and 3-dimensional particle-based fluid simulation engine for games and animations.
hdf5 - HDF5 for Rust.
Schemars - Generate JSON Schema documents from Rust code.
rusturn - Rust Implementation of TURN server and client.
safer_ffi - Write safer FFI code in Rust without polluting it with unsafe code.
positioned-io - Read and write from offsets in Rust.
jlrs - Julia bindings for Rust.
json_typegen - Rust types from JSON samples.
pathfinding - Implements several pathfinding, flow, and graph algorithms in Rust.
bstr - String type for Rust that is not required to be valid UTF-8. (Article) (HN)
cron - Cron expression parser in Rust.
Lelet - Task executor that inspired by golang runtime.
relibc - Portable POSIX C standard library written in Rust. It is under heavy development, and currently supports Redox and Linux.
wasm-mt - Multithreading library for Rust and WebAssembly.
Simba - SIMD algebra for Rust.
render - Safe and simple template engine with the ergonomics of JSX.
memmap2 - Cross-platform Rust API for memory mapped IO.
bus - Efficient, lock-free, bounded Rust broadcast channel.
sdfu - Signed Distance Field Utilities.
webrtc-audio-processing - Wrapper around PulseAudio's repackaging of WebRTC's AudioProcessing module.
Elfkit - Rust elf parsing, manipulation and (re)linking toolkit.
owning-ref-rs - Library for creating references that carry their owner with them.
Nuclei - Proactive IO system which is runtime agnostic and can work with any runtime. (Lobsters)
Autocxx - Tool for calling C++ from Rust in a heavily automated, but safe, fashion. (Reddit)
Scipio - Cooperative Thread-per-Core crate for Rust & Linux based on io_uring. (Article) (HN)
Rust command-line library (HN)
rustcommon - Common Twitter Rust lib.
rust-dominator - Zero cost declarative DOM library using FRP signals for Rust.
maplit - Rust container / collection literal macros for HashMap, HashSet, BTreeMap, BTreeSet.
cio - Set of Rust libraries for accessing various APIs for doing CIO jobs. (Automated CIO)
ocaml-interop - OCaml<->Rust FFI with an emphasis on safety.
fs-err - Simple wrapper around filesystem operations to provide more helpful error messages.
ring-compat - Compatibility crate for using RustCrypto's traits with the cryptographic algorithm implementations from ring.
untrusted.rs - Safe, fast, zero-panic, zero-crashing, zero-allocation parsing of untrusted inputs in Rust.
rust-dangerous - Rust library for safely and explicitly parsing user-generated data.
magick-rust - Rust bindings for ImageMagick.
indoc - Indented document literals for Rust.
libgoblin - Impish, cross-platform binary parsing crate, written in Rust.
com-rs - Rust Crate for Creating and Consuming COM APIs.
Headcrab - Modern Rust debugging library. (The Soul of a New Debugger)
rust-dlopen - Rust library for opening and working with dynamic link libraries.
rust-lazysort - Iterate in a lazily achieved sorted order.
decimal - Decimal Floating Point arithmetic for rust.
declio - Declarative I/O serialization library.
rye - Minimal, x86-64-only experiment into adding fibers to Rust.
stdsimd - Rust's standard library portable SIMD API.
act-zero - Actor system for Rust.
Scones - Quick and powerful constructor/builder generation in Rust.
rustls-native-certs - Integration with OS certificate stores for rustls.
Tokio Tls - Collection of Tokio based TLS libraries.
shared-arena - Thread-safe & efficient memory pool.
random_color - Rust crate for generating random attractive colors.
flexi_logger - Flexible logger for rust programs that can write to stderr or to log files.
spin-rs - Spin-based synchronization primitives.
Tremor - Event processing system for unstructured data with rich support for structural pattern matching, filtering and transformation. (Web) (v0.9 release)
uom - Units of measurement -- type-safe zero-cost dimensional analysis.
tar-rs - Tar file reading/writing for Rust.
Rio - RDF parsers library.
mles-rs - Distributed publish-subscribe data service and Mles protocol reference implementation on Rust, Tokio and Serde.
sharded-slab - Lock-free concurrent slab. Provide pre-allocated storage for many instances of a single data type.
inline-c - Write and execute C code inside Rust.
includedir - Include a whole directory tree at compile time.
strsim-rs - Rust implementations of string similarity metrics.
uefi-rs - Rust wrapper for UEFI. (HN)
OpenTelemetry-Rust - OpenTelemetry API and SDK for Rust.
cap-std - Capability-oriented version of the Rust standard library. (Article) (Lobsters)
Fuzzy Matcher - Fuzzy Matching Library for Rust.
dirs-next - Low-level library that provides config/cache/data paths.
generator-rs - Rust stackful generator library.
image2 - Image processing library for Rust.
ZEXE - Rust library for decentralized private computation.
cargo-flash - Cargo extension for programming microcontrollers.
object - Unified interface for reading and writing object file formats.
fancy-regex - Rust library for regular expressions using "fancy" features like look-around and backreferences.
rust-base64 - base64, in rust.
scraper - HTML parsing and querying with CSS selectors.
rust-gc - Simple tracing (mark and sweep) garbage collector for Rust.
anchors - Self adjusting computations in rust.
gpu-allocator - Memory allocator written in pure Rust for GPU memory in Vulkan and in the future DirectX 12.
rspirv-reflect - Minimal SPIR-V reflection library.
rkv - Simple, humane, typed Rust interface to LMDB.
difference.rs - Rust text diffing library with built-in diffing assertion.
liquid-rust - Liquid templating for Rust.
vmap-rs - Cross-platform library for fast and safe memory-mapped IO in Rust.
metrics - Metrics ecosystem for Rust.
primordial - Low-level CPU primitives.
rkyv - Zero-copy deserialization framework for Rust.
Sparse merkle tree - Optimized sparse merkle tree.
X.509 Parser - X.509 parser written in pure Rust. Fast, zero-copy, safe.
swanky - Suite of rust libraries for secure multi-party computation.
lingua-rs - Accurate natural language detection library in the Rust ecosystem, suitable for long and short text alike. (Python)
fastrand - Simple and fast random number generator.
Kompact - Component System in Rust.
faerie - Magical ELF and Mach-o object file writer backend.
extendr - Low-level R library bindings.
bumpalo - Fast bump allocation arena for Rust.
r0 - Memory initialization code written in Rust.
Lunatic - Erlang inspired runtime for WebAssembly. (Web) (HN) (Lobsters) (HN) (HN)
Lunatic Rust Lib - Higher level Rust wrappers for low level Lunatic syscalls.
Kira - Library for expressive game audio.
rust-brotli - Brotli compressor and decompressor written in rust that optionally avoids the stdlib.
infer - Small crate to infer file and MIME type by checking the magic number signature.
pretty-env-logger - Pretty, easy-to-use logger for Rust.
grmtools - Suite of Rust libraries and binaries for parsing text, both at compile-time, and run-time.
HashRing - Minimal implementation of consistent hashing.
inherent - Make trait methods callable without the trait in scope.
nanoserde - Serialisation library with zero dependencies.
coca - Allocation-free data structures that make do with the memory they're given. (Reddit)
typed-index-collections - Typed index version of Rust slice and Vec containers.
slotmap - Slotmap data structure for Rust.
Erased Serde - Type-erased Serialize, Serializer and Deserializer traits.
hyphenation - Text hyphenation for Rust.
genovo - Execute genetic algorithm (GA) simulations in a customizable and extensible way.
dhat - Heap profiling and ad hoc profiling for Rust programs.
Polonius - Core library that models the borrow check.
Thermite SIMD - SIMD library focused on providing portable SIMD acceleration of SoA (Structure of Arrays) algorithms.
generic-array - Generic array types in Rust.
numeric-array - Wrapper around generic-array that adds efficient numeric trait implementations.
par-stream - Asynchronous Parallel Stream for Rust.
triple-buffer - Implementation of triple buffering written in Rust.
linked-list-allocator - Create a static allocator.
claim - Assertion macros toolkit for Rust.
reformation - Parsing via regular expressions using format syntax.
rust-fasthash - Suite of non-cryptographic hash functions for Rust.
GilRs - Game Input Library for Rust.
rendezvous_hash - Rust implementation of Rendezvous hashing algorithm.
quanta - Speed timing library, useful for getting the current time very quickly.
JMESPath Rust - Rust implementation of JMESPath, a query language for JSON.
stream-cancel - Rust library for interrupting asynchronous streams.
Mutation - Unleash the power of nightly Rust to write code that's generic over mutation.
evmap - Lock-free, eventually consistent, concurrent multi-value map.
RustFFT - Mixed-radix FFT library written in pure Rust.
RIPP (Rust Inner Pairing Products) - Rust library for proofs about inner pairing products, and applications built atop these.
fake-rs - Rust library for generating fake data.
Xactor - Rust actors framework based on async-std.
Failsafe - Circuit breaker implementation for rust.
rust-ascii - ASCII-only equivalents to char, str and String.
varint-simd - SIMD-accelerated varint encoder and decoder in Rust.
ndarray-linalg - Linear algebra package for rust-ndarray using LAPACK binding.
Merkle Storage - Key-value git-like storage with full history backed by RocksDB.
arcode-rs - Arithmetic coder for Rust.
heck - Case conversion library.
kApp - Pure Rust window and input library for Windows, Mac, and Web.
predicates-rs - Implementation of boolean-valued predicate functions in Rust.
assert_cmd - Assert process::Command - Easy command initialization and assertions.
toml-rs - TOML encoding/decoding library for Rust.
Real-Time Ring Buffer - Wait-free single-producer single-consumer ring buffer for Rust.
daggy - Directed acyclic graph data structure for Rust.
LibHoare - Design by contract style assertions for Rust.
crc32fast - Fast, SIMD-accelerated CRC32 (IEEE) checksum computation in Rust.
Ouroboros - Easy self-referential struct generation for Rust.
Gazebo - Rust library containing a collection of small well-tested primitives.
Arcon - Runtime for Writing Streaming Applications in Rust.
joinery - Rust library for generically joining iterables with a separator.
rpmalloc-rs - Cross-platform Rust global memory allocator using rpmalloc.
shadow-rs - Build-time information stored in your binary.
jni-rs - Rust bindings to the Java Native Interface.
Plotly - Plotting library for Rust powered by Plotly.js
Spiril - Rust library for genetic algorithms.
cstree - Library for creating and working with concrete syntax trees (CSTs).
Cocoon - Simple and relyable secure storage with strong encryption and format validation.
BitReader - Helper type to extract strings of bits from a slice of bytes.
Rust FUSE - Rust library for filesystems in userspace (FUSE).
bpfs - Rust In-Memory Filesystem.
flize - Non global, configurable and fast concurrent resource reclamation.
num-traits - Numeric traits for generic mathematics in Rust.
mlua - High level Lua bindings to Rust with async/await support..
victoria-dom - Minimalistic HTML parser with CSS selectors.
MultiQueue2 - Fast MPMC Broadcast Queue.
Linkme - Safe cross-platform linker shenanigans.
hold_my_beer - Don't let unsafe get you down.
rusty-sandbox - Sandboxing library for Rust.
etcd-client - etcd v3 API client for Rust. It provides asynchronous client backed by tokio and tonic.
alga - Abstract algebra for Rust.
Postcard - no_std + serde compatible message library for Rust.
soa-derive - Array of Struct to Struct of Array helpers in Rust.
bacon - Scientific Computing in Rust. (Article)
slab - Pre-allocated storage for a uniform data type.
Cuckoo Filter - Bloom filter replacement for approximated set-membership queries.
QuantMath - Financial maths library for risk-neutral pricing and risk. (HN)
Egg - Flexible, high-performance e-graph library. (Web) (Talk) (HN)
Codegen - Provides an builder API to assist in generating Rust code.
similar - High level diffing library for rust based on diffs.
x86_64 - Library to program x86_64 hardware.
lz4_flex - Pure Rust implementation of raw LZ4 compression/decompression.
Stakker - Lightweight low-level single-threaded actor runtime.
Vicis - Manipulate LLVM-IR in Pure Rust.
tryhard - Easily retry futures.
visualizer2 - Audio Visualization in Rust.
rtt-target - Target side implementation of the RTT (Real-Time Transfer) I/O protocol.
shuffling-allocator
governor - Library for regulating the flow of data.
flurry - Port of Java's ConcurrentHashMap to Rust.
fast-float - Super-fast decimal number parser from strings into floats.
saifish - Simple, small, and extremely fast template engine for Rust. (Docs)
async-task - Task abstraction for building executors.
Minitrace - High-performance timeline tracing library for Rust, used by TiKV.
freeverb-rs - Rust implementation of the Freeverb algorithm.
Trie - Generic implementation of the Base-16 Modified Merkle Tree ("Trie") data structure.
config-rs - Layered configuration system for Rust applications (with strong support for 12-factor applications).
countme - Library to quickly get the live/total/max counts of allocated instances.
btleplug - Rust Cross-Platform Host-Side Bluetooth LE Access Library.
sysinfo - System handler to interact with processes.
Peroxide - Rust numeric library contains linear algebra, numerical analysis, statistics and machine learning tools with R, MATLAB, Python like macros.
Embassy - Modern embedded framework, using Rust and async. (Web)
uniffi - Multi-language bindings generator for rust.
gaol - Cross-platform application sandboxing for Rust.
auto_enums - Library for to allow multiple return types by automatically generated enum.
pin-project - Crate for safe and ergonomic pin-projection.
deepspeech-rs - Rust bindings of Mozilla's DeepSpeech library.
alloca-rs - Mostly safe no_std wrapper for alloca in Rust.
CPAL - Cross-platform audio I/O library in pure Rust.
Tokenizer - Library used by Meilisearch to tokenize queries and documents.
dtoa - Fast functions for printing floating-point primitives to an io::Write.
Symphonia - Rust audio decoding and media demuxing library supporting OGG, FLAC, MP3, and WAV.
treediff-rs - Library to compare arbitrary structured data of the same type, efficiently.
replace_with - Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one.
Moka - Fast, concurrent cache library for Rust.
nonblockinghashmap - Non-blocking hash map in Rust.
thread_io - Rust crate for performing I/O in background thread.
LRU Cache - Implementation of a LRU cache in Rust.
Aper - Synchronized state machines for Rust over WebSockets.
Parry - 2D and 3D collision-detection library for Rust.rs.
meio - Async actor framework for Rust.
Decimal - Decimal Implementation written in pure Rust suitable for financial calculations.
message-io - Event-driven message library for building network applications easy and fast.
GraphQL Parser - Parser, formatter and AST for graphql query and schema definition language for rust.
multer-rs - Async parser for multipart/form-data content-type in Rust.
conch-runtime - Rust library/runtime for executing Unix shell commands.
rust-clipboard - System Clipboard interfacing library in Rust.
async-io - Async I/O and timers.
stroke-rs - Zero-allocation library providing const-generic implementations of Bézier curves, B-Spline curves.
j4rs - Java for Rust.
autocfg - Rust library for build scripts to automatically configure code based on compiler support.
Figment - Semi-hierarchical configuration library for Rust.
Arbitrary - Trait for generating structured data from arbitrary, unstructured input.
RRT - Rapidly-exploring Random Tree library in Rust.
storage-poc - Exploration of using Storage instead of Allocator to parameterize collections in Rust.
safe-transmute-rs - Safe-guarded transmute for Rust.
partialdebug - Derive Debug for types where not all fields implement Debug.
wide - Crate to help you go wide. By which I mean use SIMD stuff.
Tailcall - Safe, zero-cost tail recursion for stable Rust.
async-imap - Async IMAP implementation in Rust.
nachricht - Self-describing data interchange format.
Enumflags - Rust library for efficiently representing sets of data-less enums.
cooper - Simple in-process Actor library in Rust.
Mtrx - Type-safe matrix operations using Rust's const generics.
Rustwide - Execute your code on the Rust ecosystem.
array-init - Safe wrapper for initializing arrays.
voladdress - Crate to make volatile memory operations easy to work with.
bb8 - Full-featured connection pool, designed for asynchronous connections (using tokio).
Sophia - Rust toolkit for RDF and Linked Data.
switchyard - Real-time compute-focused async executor with job pools, thread-local data, and priorities.
tokio-uring - tokio-uring backed runtime for Rust.
rust-iterators - Basic Rust iterator usage.
uluru - Simple, fast, LRU cache implementation.
Typetag - Serde serializable and deserializable trait objects.
popol - Minimal non-blocking I/O for Rust.
escher - Self-referencial structs using async stacks.
dipa - Makes it easy to efficiently delta encode large Rust data structures.
Scribe - Text editor toolkit.
mint - Math Interoperability Types.
niffler - Simple and transparent support for compressed files.
zstd-rs - Rust binding for the zstd compression library.
markup.rs - Blazing fast, type-safe template engine for Rust.
argmin - Mathematical optimization in pure Rust.
trait-set - Trait aliases on stable Rust.
String Interner - Data structure to efficiently intern, cache and restore strings.
simdutf8 - SIMD-accelerated UTF-8 validation for Rust.
biquad - Rust library for digital second order IIR filtrers, also known as biquads.
Deltoid - Type-driven rust library that can be used to calculate deltas.
ipc-channel - Multiprocess drop-in replacement for Rust channels.
Prepona - Graph crate with simplicity in mind.
delay-timer - Time-manager of delayed tasks.
jsonschema - JSON Schema validation library.
rstar - R*-tree library for the rust ecosystem.
profiling - Provides a very thin abstraction over instrumented profiling crates like puffin, optick, tracy, and superluminal-perf.
ocaml-rs - OCaml extensions in Rust.
gumdrop - Rust option parser with custom derive support.
memchr - Optimized string search routines for Rust.
Scalable Concurrent Containers - Scalable concurrent data structures for database management systems.
lexical - Fast lexical conversion routines for both std and no_std environments.
Drop-Merge-Sort - Adaptive sorting algorithm.
Sauce - Context specific everything.
tokio-console - Diagnostics and debugging tool for asynchronous Rust programs.
jsonrpsee - Rust JSON-RPC library on top of async/await.
bytemuck - Crate for mucking around with piles of bytes.
heed - Fully typed LMDB/MDBX wrapper with minimum overhead.
FUSE-Rust - Rust library crate for easy implementation of FUSE filesystems in userspace.
micromath - Embedded Rust arithmetic, 2D/3D vector, and statistics library.
Ordered Floats - Provides several wrapper types for Ord and Eq implementations on f64.
sorbus - Generic "green" syntax tree implementation.
Pointer Utils - Collection of small utilities for working with pointer types in Rust.
Valuable - Provides object-safe value inspection. Use cases include passing structured data to trait objects and object-safe serialization.
semver - Parser and evaluator for Cargo's flavor of Semantic Versioning.
hashed-permutation - An implementation of Kensler's hashed permutation algorithm.
Array2D - Statically-sized two-dimensional array written in Rust.
Ropey - utf8 text rope for manipulating and editing large texts.
Twoway - Fast substring search for strings and byte strings, using the two-way algorithm.
serde-diff - Utility for comparing two structs and re-applying the differences to other structs.
Sluice - Asynchronous byte buffers and pipes for concurrent I/O programming.
terminusdb-store - Tokio-enabled data store for triple data.
async-attributes - Experimental language-level polyfills for Async Rust.
speedy - Fast binary serialization framework.
serde_with - Custom de/serialization functions for Rust's serde using the with-annotation.
tabled - Easy to use library for pretty print tables of Rust structs and enums.
async-stream - Asynchronous streams for Rust using async & await notation.
Concread - Concurrently Readable Data Structures for Rust.
cap - Allocator that can track and limit memory usage.
Instant Distance - Fast approximate nearest neighbor searching in Rust, based on HNSW index.
static-rc - Compile-time reference counting.
async raft - Implementation of the Raft distributed consensus protocol using the Tokio framework.
arrow-rs - Native Rust implementation of Apache Arrow.
gtmpl-rust - Go text/template for rust.
rust-x86 - Rust library to use x86 (amd64) specific functionality and registers.
granne - Graph-based Approximate Nearest Neighbor Search.
Polars - Fast multi-threaded DataFrame library in Rust and Python. (Web) (HN) (Awesome)
TransIter - Iterator suitable for navigating recursive structures and DAGs in rust.
stdx - Missing batteries of Rust.
Exocore - Distributed applications framework with private and encrypted data storage.
rodio - Rust audio playback library.
segvec - SegVec data structure for rust. Similar to Vec, but allocates memory in chunks of increasing size.
confy - Zero-boilerplate configuration management in Rust.
flatparse - Fast parsing from bytestrings.
Live Reload - Live reloading for Rust programming.
Iftree - Include many files in your Rust code for self-contained binaries.
Ariadne - Fancy error diagnostics & reporting crate.
Chumsky - Friendly parser combinator crate that makes writing LL(1) parsers with error recovery easy. (Lobsters) (HN)
async-backplane - Easy, Erlang-inspired fault-tolerance framework for Rust Futures.
Eventuals - Eventually consistent values for Rust.
cargo-profile - Profiling rust program made easy.
Arrow2 - Transmute-free Rust library to work with the Arrow format.
beef - Faster, more compact implementation of std::borrow::Cow.
uuid - Generate and parse UUIDs.
QuantLib - Idiomatic rust implementation of the QuantLib C++ quantitative finance library.
dynamic_reload - Dynamic reloading of shared libraries.
rosc - OSC library for Rust.
Y CRDT
Hora - Approximate nearest neighbor search algorithm library. (Web)
fork - Library for creating a new process detached from the controlling terminal (daemon) using the fork and setsid syscalls.
peekread - Allows you to take an arbitrary Read stream and 'peek ahead' into the stream without consuming the original stream.
Dialectic - Transport-polymorphic, asynchronous session types for Rust.
MRML - Reimplementation of the nice MJML markup language in Rust.
p2panda - Provides all tools required to write a client for the p2panda network.
log4rs - Highly configurable logging framework for Rust.
executor - Minimalistic async/await executor for Rust.
wait-timeout - Waiting on a child process with a timeout in Rust.
getrandom - Small cross-platform library to securely get random data (entropy).
stdarch - Rust's standard library SIMD components.
Gallium - Simple entity-component-system crate for rust with serialization support.
dyn-clone - Clone trait that is object-safe.
Obake - Versioned data-structures for Rust.
futures-concurrency - Concurrency extensions for Future.
Hypergraph - Data structure library to generate directed hypergraphs.
cast - Ergonomic, checked cast functions for primitive types.
Cambria - Use lenses to maintain forwards and backwards compatibility with your software.
async-wormhole - Allows you to .await async calls in non-async functions, like extern "C" or JIT generated code.
extend - Create extensions for types you don't own with extension traits but without the boilerplate.
Enterpolation - Library for creating and computing interpolations, extrapolations and smoothing of generic data points.
rust-sgx - Fortanix Rust Enclave Development Platform.
tonari-actor - Minimalist actor framework aiming for high performance and simplicity.
Strum - Set of macros and traits for working with enums and strings easier in Rust.
detour-rs - Cross-platform detour library written in Rust.
EVLRU - Eventually consistent LRU designed for lock-free concurrent reads.
io-lifetimes - Low-level I/O ownership and borrowing library.
Parity SCALE Codec - Lightweight, efficient, binary serialization and deserialization codec.
bson - Encoding and decoding support for BSON in Rust.
unsafe-io - Non-owning unsafe I/O.
system-interface - Extensions to the Rust standard library.
utf8-io - Traits and types for UTF-8 I/O.
avro-rs - Library for working with Apache Avro in Rust.
Rust Amplify - Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros.
spsc-bip-buffer - Single-producer single-consumer circular buffer that always supports writing a contiguous chunk of data.
Tree-Buf - Data-oriented, data-driven serializer built for real-world data.
AnyMap - Safe and convenient store for one value of each type.
ts-rs - Generate TypeScript bindings from Rust types.
HashiCorp-LRU - Contains three LRU based cache, LRUCache, TwoQueueCache and AdaptiveCache.
compact_str - Memory efficient immutable string type that can store up to 24* bytes on the stack.
Heph - Actor framework for Rust based on asynchronous functions.
slog-rs - Structured, contextual, extensible, composable logging for Rust.
winit - Cross-platform window creation and management in Rust.
xxhash-rust - Rust implementation of xxhash.
RFD - Rusty File Dialog.
Pollster - Minimal async executor that lets you block on a future.
packed_simd - Portable Packed SIMD Vectors for Rust standard library.
Bardecoder - Detect and decode QR Codes, written in 100% Rust.
Lagoon - Thread pool crate with an array of features.
MiniJinja - Powerful but minimal dependency template engine for Rust which is based on the syntax and behavior of the Jinja2 template engine.
moveit - Library for safe, in-place construction of Rust (and C++!) objects.
binrw - Rust crate for helping parse and rebuild binary data using macro magic.
Remain - Compile-time checks that an enum or match is written in sorted order.
good_lp - Linear Programming for Rust, with an user-friendly API.
atomic_refcell - Threadsafe RefCell for Rust.
freqfs - In-memory filesystem cache for Rust. (HN)
stack-graphs - Rust implementation of stack graphs.
debug-ignore - Newtype wrapper that causes Debug impls to skip a field.
subprocess - Execution of and interaction with external processes and pipelines.
Enarx Keep Loader - Provides the enarx-keepldr executable which loads static-pie binaries into an Enarx Keep.
ArcSwap - Support atomic operations on Arc itself.
Oddio - Game-oriented audio library.
async-process - Async interface for working with processes.
tough - Rust libraries and tools for using and generating TUF repositories.
Typical - Algebraic data types for data interchange.
Swap Queue - Queue designed for buffer swapping instead of task popping.
csv - CSV parser for Rust, with Serde support.
schemafy - Rust crate which can take a JSON schema and generate Rust types which are serializable with serde.
creativity - Creative Coding Framework based on Entity Component System (ECS) written in Rust.
tap - Generic extensions for tapping values in Rust.
sp-im - Immutable no_std collection datatypes suitable for use within Substrate.
nats.rs - Rust client for NATS, the cloud native messaging system.
hashconsing - Rust hashconsing library.
safe_index - Safe indexing in Rust.
unixstring - FFI-friendly null-terminated byte string.
spmc - Single-Producer, Multiple-Consumer channel for Rust.
Av1an - Cross-platform command-line AV1 / VP9 / HEVC / H264 encoding framework with per scene quality encoding.
Rubble - BLE stack for embedded Rust.
Stretto - High performance thread-safe memory-bound Rust cache.
Caches - Rust implementation for popular caches.
TwoX-Hash - Rust implementation of the XXHash algorithm.
atomic-rs - Generic Atomic<T> type for Rust.
Dissimilar - Diff library with semantic cleanup.
waihona - Rust library for performing basic cloud storage actions across major cloud providers e.g aws.
simple_logger - Rust logger that prints all messages with a readable output format.
rs-merkle - Most advanced Merkle tree library for Rust.
bidiff - Set of rust crates that generate and apply patches for arbitrary binary files.
FutureSDR - Async SDR Runtime for Heterogeneous Architectures.
ghost - Define your own PhantomData.
gltf - Crate for loading glTF 2.0.
Sparsey - Sparse set-based Entity Component System with lots of features and nice syntax.
rquickjs - High level bindings the QuickJS JavaScript engine.
holyhashmap - Hash map with stable indices.
async-socket - General-purpose asynchronous socket stream.
Remoc - Remote multiplexed objects and channels for Rust.
delta-rs - Native Rust library for Delta Lake, with bindings into Python and Ruby. (Diving into Delta-rs: kafka-delta-ingest (2021))
rust-lapper - Rust implementation of a fast, easy, interval tree library nim-lapper.
sigstore-rs - Rust crate for sigstore.
image-png - PNG Decoder/Encoder.
streamline - Reversible streaming state machine library for Rust.
num-bigint - Big integer types for Rust.
async-tungstenite - Asynchronous WebSockets for async-std, tokio, gio and any std Futures runtime.
FastCDC - Implements the "FastCDC" content defined chunking algorithm in pure Rust.
whorl - Single file, std only, async Rust executor.
threadpool - Thread pool for running a number of jobs on a fixed set of worker threads.
Mimalloc Rust - Rust wrapper over Microsoft's MiMalloc memory allocator.
distant - Remotely edit files and run programs.
Mononym - Type-level named values with partial dependent type support in Rust. (Article)
Lambek - Type-Level Programming in Rust.
SmolStr
ATAT - no_std crate for parsing AT commands.
Shipyard - Entity Component System focused on usability and speed.
sallyport - API for the hypervisor-microkernel boundary.
Threadfin - Thread pool for running multiple tasks on a configurable group of threads.
eventually-rs - Event Sourcing for Rust.
Foca - Gossip-based cluster membership discovery (SWIM).
CloudEvents SDK Rust
rust-cached-path - Rust utility for accessing both local and remote files through a unified interface.
gray-matter-rs - Tool for easily extracting front matter out of a string.
srt-rs - SRT implementation in Rust.
hotwatch - Rust library for conveniently watching and handling file changes.
tiny_id - Rust library for generating non-sequential, tightly-packed short IDs.
libmacchina - Library providing access to all sorts of system information.
nebari - Pure Rust database implementation using an append-only B-Tree file format.
rustix - Safe Rust bindings to POSIX-ish APIs.
abi_stable_crates - Rust-to-Rust ffi,ffi-safe equivalents of std types,and creating libraries loaded at startup.
gaffer - Prioritized, parallel job scheduler with concurrent exclusion, job merging, recurring jobs and load limiting for lower priorities.
Cadence - Extensible Statsd client for Rust.
arrayvec - Vector with a fixed capacity.
open-rs - Open a path or URL with the system-defined program.
evalexpr - Expression evaluator and tiny scripting language in Rust.
SPIR-Q - Light weight SPIR-V reflection library.
Pythonize - Serializer for Rust's serde ecosystem, which can convert Rust objects to Python values and back.
enumset - Library for compact bit sets based on enums.
pom - PEG parser combinators created using operator overloading without macros.
path-to-error - Find out path at which a deserialization error occurred.
ulid-rs - Rust implementation of the ulid project which provides Universally Unique Lexicographically Sortable Identifiers.
resize - Image resampling library in pure Rust.
backtrace-rs - Library for acquiring backtraces at runtime for Rust.
lrpeg - Left Recursive PEG for rust. (Article)
dynstack - Stack for rust trait objects that minimizes allocations.
Streamson - Memory efficient handling of large JSON data.
bytelines - Read input lines as byte slices for high efficiency.
fronma - Front Matter parser for Rust.
ta - Technical analysis library for Rust.
Wait Map - Async/await concurrency primitive implemented as a concurrent hashmap.
Encoding - Character encoding support for Rust.
Pbjson - Auto-generate serde implementations for prost types.
griddle - HashMap variant that spreads resize load across inserts.
rust-s3 - Rust library for interfacing with AWS S3 and other API compatible services.
rust-bigtable - Rust library for working with Google Bigtable Data API.
rust-goauth - Crate for authenticating Server to Server Apps for Google Cloud Engine.
rust-bloom-filter - Fast Bloom filter implementation in Rust.
Typenum - Compile time numbers in Rust.
boolinator - Provides the Boolinator trait, which lets you use Option and Result-style combinators with bools.
Ciborium - CBOR serialization and deserialization implementations for serde.
Rust Onig - Rust bindings for the Oniguruma regex library.
region-rs - Cross-platform virtual memory API.
hidapi - Rust bindings for the hidapi C library.
cascara - Implementation of TinyLFU cache.
Ustr - Fast, FFI-friendly string interning for Rust.
Inflector - Rust inflection library.
Frunk - Funktional generic type-level programming in Rust: HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid and friends.
twilio-rs - Twilio library for Rust.
annotate-snippets - Rust library for annotation of programming code slices.
iceoryx-rs - Rust wrapper for Eclipse iceoryx - true zero-copy inter-process-communication.
FLAME - Intrusive flamegraph profiling tool for rust.
async-ffi - FFI-compatible futures.
rust-sidekiq - Rust Sidekiq Client.
generic-str - One true string type in Rust.
CGlue - Rust ABI safe code generator.
cl-traits - Library that generalizes collections.
kaze - HDL embedded in Rust.
tokio-file - Asynchronous file I/O for Tokio.
Calm I/O - Calm I/O operations for Rust.
GeoZero - Zero-Copy reading and writing of geospatial data.
efg - Conditional compilation using boolean expression syntax, rather than any(), all(), not().
Monoio - Thread-per-core Rust runtime with io_uring. (HN)
btree - On-Disk B+ Tree implemented in Rust.
CoreMIDI - CoreMIDI library for Rust. (Article)
node-replication - Operation-log based approach for data replication.
scapegoat - Safe, embedded-friendly ordered set/map via a scapegoat tree. Validated against BTreeSet/BTreeMap.
hackfn - Fake implementation of std::ops::Fn for user-defined data types.
thingbuf - In-place allocation-reusing queues for Rust.
serde-aux - Auxiliary serde library.
typed-arena - Fast (but limited) allocation arena for values of a single type.
rust-coroutines - 'Native' stackful coroutine library for Rust.
nom_locate - Special input type for nom to locate tokens.
libsecp256k1 - Pure Rust Implementation of secp256k1.
daachorse - Fast implementation of the Aho-Corasick algorithm using the compact double-array data structure.
cdchunking-rs - Content-Defined Chunking for Rust.
serde_bytes - Wrapper types to enable optimized handling of &[u8] and Vec<u8>.
rsx - Advanced JSX-like templating for Rust.
simplelog - Simple Logging Facility for Rust.
unwinding - Stack unwinding library in Rust.
fpRust - Monad/MonadIO, Handler, Coroutine/doNotation, Functional Programming features for Rust.
static-assertions-rs - Ensure correct assumptions about constants, types, and more in Rust.
Type Freak - Collection of typed data structures, trait operators and aliases.
ufmt - Smaller, faster and panic-free alternative to core::fmt.
rcgen - Simple Rust library to generate X.509 certificates.
DateTime - High-Level Date and Time for Rust.
futures-batch - Adaptor that chunks up completed futures in a stream and flushes them after a timeout or when the buffer is full.
SeqLock - Reader-writer lock that provides extremely fast read access without starving writers.
nanorand - Tiny, fast, zero-dep library for random number generation.
const-concat - Const string concatenation.
eos - Simple and easy to use datetime library for Rust.
acacia - Spatial tree library written in Rust.
Carboxyl - Functional Reactive Programming library for Rust.
rust-fsm - Finite state machine framework for Rust with readable specifications.
rustracing - OpenTracing API for Rust.
thread_local - Per-object thread-local storage for Rust.
stackful - Free conversion between async and sync in Rust.
rust-tun - TUN device creation and handling.
capnproto-rust - Cap'n Proto for Rust.
staticvec - Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics.
destream - Rust library for asynchronous stream (de)serialization.
freqache - Thread-safe Rust LFU cache which supports a custom eviction policy.
freqfs - In-memory filesystem cache layer based on tokio::fs, with least-frequently-used eviction.
arrform - String formatting in Rust without memory allocator.
rust-signals - Zero-cost functional reactive Signals for Rust.
butte - Rust-native Flatbuffers.
Rumpsteak - Session types for asynchronous communication between multiple parties.
SuperStruct - Rust library for versioned data types.
Typic - Type-safe transmutations between layout-compatible types.
Uncertain - Fast and correct computations with uncertain values.
Fastmurmur3 - Fast, non-cryptographic hash function.
Castaway - Safe, zero-cost downcasting for limited compile-time specialization.
lzma-rs - LZMA decoder/encoder written in pure Rust.
sucds - Succinct data structures in Rust.
mih-rs - Rust implementation of multi-index hashing for neighbor searches on binary codes in the Hamming space.
extent - Replacement for std::ops::{Range,RangeInclusive}.
teloc - Simple, compile-time DI framework for Rust.
rxRust - Rust implementation of Reactive Extensions.
dynasm-rs - Dynamic assembler written in Rust for Rust.
rexpect - Spawn, control, and respond to expected patterns of child applications and processes, enabling the automation of interactions and testing.
OptArgs - Easy-to-use optional function arguments for Rust.
Pipette - Tiny crate mimicking Elixir's pipe operator for Rust without macros.
openraft - Advanced Raft using the Tokio framework.
arcstr - Better reference counted strings for Rust.
fmmap - Flexible and convenient high-level mmap for zero-copy file I/O.
tap-rs - Exposing tapping functionality for all types, and extended functionality for Option, Result & Future. Often useful for logging.
ezio - Easy IO for Rust.
NormPath - More reliable path manipulation.
Process Control - Methods for ergonomically running processes with timeouts.
print_bytes - Print bytes as losslessly as possible.
Quit - Exit cleanly with an exit code.
elasticlunr-rs - Partial port of elasticlunr to Rust. Intended to be used for generating compatible search indices.
STM32-HAL - Provides access to STM32 peripherals in Rust.
incrementalmerkletree - Append-only merkle tree which is always pruned, along with incremental, fast-forwarding witnesses.
atoi-rs - Parse integers directly from [u8] slices in safe code.
kolor - Color space conversion math made simple.
blaze-rs - Blaze core based on arrow-datafusion for blazing-fast execution.
genio - Type safe, low level replacement for std::io.
crc - Rust implementation of CRC (16, 32, 64) with support of various standards.
kdtree - K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup.
mobc - Generic connection pool for Rust with async/await support.
pariter - Parallel iterator processing library for Rust.
Ergex - Regular expression library that does a few things rather differently from many other libraries.
memmap - Rust library for cross-platform memory mapped IO.
eventador-rs - Lock-free Pub/Sub event-bus inspired by the LMAX Disruptor.
uAsync - Fast, forbid(unsafe_code), no dependency, async executor.
Sentry SDK for Rust
prettyplease - Minimal syn syntax tree pretty-printer.
slab_tree - vec-backed tree structure with tree-specific generational indexes.
id_tree - Library for creating and modifying Tree structures.
camino - UTF-8 encoded paths.
rust-t1ha - Rust implementation for T1HA (Fast Positive Hash).
Rust-Dpdk - Rust bindings to DPDK.
Auto Launch - Auto launch any application or executable at startup.
Thalo - Event sourcing framework for building microservices. (Reddit)
tinyjson - Simple JSON parser/generator for Rust.
turbulence - Multiplexed, optionally reliable, async, transport agnostic, reactor agnostic networking library for games.
libffi-rs - Rust bindings for libffi.
Hound - wav encoding and decoding library in Rust.
async-compression - Adaptors between compression crates and Rust's async IO types.
async-trait-static - Features like async-trait, avoid using Box and dyn.
rust-fallible-iterator - "Fallible" iterators for Rust.
Leapfrog - Lock-free concurrent and single-threaded hash map implementations using Leapfrog probing. Currently the highest performance concurrent HashMap in Rust.
Counter - Simple object to count Rust iterables.
art - Adaptive Radix Trie implementation for fixed-length keys.
futures-intrusive - Synchronization primitives for Futures and async/await based on intrusive collections.
syntree - Memory efficient syntax tree for language developers.
Open Graphic Image Writer - Generate Open Graphic Image with CSS-like API.
crash-handling - Set of utility crates for catching and handling crashes.
D-Bus - D-Bus binding for the Rust language.
Deser - Experimental serialization system for Rust. (Reddit)
rpki - Library for Validating and Creating RPKI Data.
Seize - Fast, efficient, and robust memory reclamation for concurrent data structures.
timediff - Rust library for printing human readable, relative time differences.
qcms - Firefox's library for transforming image data between ICC profiles.
rustplotlib - Pure Rust visualization library inspired by D3.js.
Subotai - Kademlia based Distributed Hash Table in Rust.
extreme - Extremely boring async function runner, written in 44 lines of 0-dependency Rust.
linked_hash_set - Rust HashSet with insertion ordering.
Elfo - Another actor system.
Triomphe - Fork of std::sync::Arc with lots of utilities useful for FFI.
Taplo - TOML toolkit written in Rust.
Pipe Trait - Make it possible to chain regular functions.
relative-path - Portable relative UTF-8 paths for Rust.
kiam - Better syntax for if/else chains.
FlagSet - Rust data types and a macro for generating enumeration-based bit flags.
eventsource-stream - Basic building block for building an Eventsource from a Stream of bytes array like objects.
bugreport - Rust library to collect system and environment information for bug reports.
QBE IR for Rust - QBE IR in natural Rust data structures. (Lobsters)
rluau - Idiomatic Luau bindings in 100% Rust.
Fluvio Future - Advanced futures library.
radium - Provides abstractions and graceful degradation for behavior that must be shared-mutable, but merely may use atomic instructions to do so.
xtra - Tiny, fast, and safe actor framework. Modelled around Actix.
Human Time - Parser and formatter for std::time::{SystemTime, Duration}.
bytecheck - Memory validation framework for Rust.
sentry-contrib-breakpad - Small library to integrate native crash dump handling with Sentry, without relying on sentry-native.
Queen - Message bus.
queen-io - I/O library for Rust.
approx - Approximate floating point equality comparisons and assertions.
knuffel - Rust KDL parser and derive implementation.
bitsvec - Bit vector with the Rust standard library's portable SIMD API.
Parquet2 - Fastest and safest Rust implementation of parquet. unsafe free. Integration-tested against pyarrow.
ELBUS - Rust-native IPC broker.
rust-cpp - Embed C++ code directly in Rust.
js-sandbox - Securely embed JavaScript code into a Rust application.
cedarwood - Efficiently-updatable double-array trie in Rust.
rustc-hash - Custom hash algorithm used by rustc (plus hashmap/set aliases): fast, deterministic, not secure.
webbrowser - Rust library to open URLs in the web browsers available on a platform.
sbahn - Pure Rust Distributed Hash Table.
string-cache - String interning for Rust.
rust-atomicwrites - Atomic file-writes.
queue-file - Lightning-fast, transactional, file-based FIFO.
zstd-rs - Feature-complete decoder for the zstd compression format.
atomic-memcpy - Byte-wise atomic memcpy.
resource - Rust macros for statically including resources in release mode, but dynamically loading them in debug mode.
Rust Statsd - StatsD client implementation of statsd in rust.
ghost-collections - Safe collections written in stable Rust, based on GhostCell and StaticRc.
crc64fast - SIMD accelerated CRC-64-ECMA computation.
trackable - Provides a way to track objects manually as an alternative to mechanisms like backtracing.
rust-alloc-no-stdlib - Interface to a generic allocator so a no_std rust library can allocate memory, with, or without stdlib being linked.
tz-rs - Pure Rust reimplementation of libc functions localtime, gmtime and mktime. (Reddit)
authenticator-rs - Rust library for interacting with CTAP1/CTAP2 Security Keys.
Oneshot - Oneshot Rust channel working both in and between sync and async environments.
smartstring - Compact inlined strings.
futures-lite - Futures, streams, and async I/O combinators.
TOM - Format-preserving TOML parser in Rust.
ibig - Big integer library in Rust with good performance.
jod-thread - std::thread which joins on drop by default.
TSZ - Crate for time series compression based upon Facebook's Gorilla whitepaper.
rust-charts - Xstate-like statechart library.
Notan - Cross-platform multimedia layer.
Interprocess - Multifunctional cross-platform interprocess communication toolkit for Rust.
Archery - Abstract over the atomicity of reference-counting pointers in rust.
async-rdma - Framework for writing RDMA applications with high-level abstraction and asynchronous APIs.
scopeguard - Rust crate for a convenient RAII scope guard.
blocking - Thread pool for isolating blocking I/O in async programs.
spdlog-rs - Fast and combinable Rust logging crate.
decimal - Rust library for fixed point number.
rubato - Audio sample rate conversion library for Rust.
Stackdump - Set of rust crates for making stack dumps and getting stack traces out of them.
corosensei - Fast and safe implementation of stackful coroutines in Rust.
Sixbit - Crate for small packed strings.
String - UTF-8 encoded string with configurable byte storage.
byte-strings-rs - Rust zero-cost byte strings manipulation, for a better and safer FFI.
ArrayString - Fixed capacity stack based generic string that works on stable.
is_executable - Is there an executable file at the given path?
autodiff - Auto differentiation library.
online - Library to check your Internet connectivity.
haphazard - Hazard pointers in Rust.
rusty-money - Handles the messy parts of dealing with money like rounding, precision, parsing and internationalization.
bkt - Subprocess caching utility, available as a command line binary and a Rust library.
swift-rs - Call Swift functions from Rust with ease.
Congee - Concurrent ART (adaptive radix tree).
CRustAL - Library for Assembling C/C++ Code from Rust.
celerity - Buttery smooth animation toolkit.
extrasafe - Make your code extra-safe by voluntarily dropping privileges.
rust-stats - Basic statistical functions on streams for Rust.
splines - Spline interpolation made easy.
akin - Rust crate for writing repetitive code easier and faster.
rust-media - Free, comprehensive, and portable video/audio streaming library for Rust.
exif-rs - Exif parsing library written in pure Rust.
rangemap - Map data structure whose keys are stored as ranges.
flexstr - Immutable, clone-efficient String replacement for Rust.
minstant - Performant time measuring in Rust.
Liquid Rust - Attempt to implement Liquid Types type checker for Rust code.
RiteLinked - HashMap-like containers that hold their key-value pairs in a user controllable order.
blurhash-rs - Pure Rust implementation of Blurhash.
Voracious sort - Voracious radix sort.
qoi-rust - Very fast encoder/decoder for QOI image format in pure and safe Rust.
Atomig - Generic and convenient std atomics.
kay - High-performance actor system framework for Rust.
podman-api - Rust interface to Podman.
Boxcar - Concurrent, append-only vector.
Calloop - Callback-based Event Loop.
rust-fnv - Fowler–Noll–Vo hash function.
LibRapid - Highly optimized derivative of the LibRapid C++ library.
Fraction - Lossless fractions and decimals; drop-in float replacement.
Tardis - Elegant, clean Rust development framework.
TrapFrame-rs - Handle Trap Frame across kernel and user space on multiple ISAs.
rust-tuf - Rust implementation of The Update Framework (TUF).
Layout - Renders graphs. Graphviz Implementation in Rust. (HN)
bigjson
GJSON - Get JSON values quickly - JSON parser for Rust.
coap-rs - Constrained Application Protocol(CoAP) library implemented in Rust.
prae - Better way to define types that require validation.
Drpc - Correct, high performance, robust, easy use Remote invocation framework.
fast_log - Log implementation for extreme speed, using Crossbeam to double the efficiency.
mco - Rust Async Coroutine Runtime that combines speed and ease to use.
operational-transform - Library for Operational Transformation.
rename-future - Can name anonymous Future from async fn without dyn or Box.
Serde Pickle - Rust library for parsing and generating Python pickle streams.
envconfig-rs - Initialize config structure from environment variables in Rust without boilerplate.
SuppaFTP - Super FTP/FTPS client library for Rust.
Lightning - Set of lock-free data structures.
Moniker - Makes it simple to track variables across nested scopes in programming language implementations.
Hydroflow - Hydro's low-level dataflow runtime.
zip-rs - Zip library for rust which supports reading and writing of simple ZIP files. (Fork)
gpx - Rust read/write support for GPS Exchange Format (GPX).
art-rs - Adaptive Radix Tree.
Zestors - Simple, fast and flexible actor framework for building robust distributed applications, heavily inspired by Erlang.
id-arena - Simple, id-based arena.
Textwrap - Library for wrapping and indenting text.
cfixed-string - Pass Rust strings to C with potentially not needing heap allocation.
Node Crunch - Allows to distribute computations across several nodes.
sendable - Wrapper around Rc safe to send to a different thread.
itoa - Fast functions for printing integer primitives to an io::Write.
rust-ftp - FTP client for Rust.
rkyv_codec - Simple async codec for rkyv. Reuses streaming buffer for maximum speed.
usync - Small, fast, synchronization primitives.
Texting Robots - Library for parsing robots.txt files.
futures_codec - Utilities for encoding and decoding frames with async/await.
Zelf - Zero-allocation ELF parser.
tendril - Compact string type for zero-copy parsing.
strength_reduce - Implements integer division and modulo via "arithmetic strength reduction".
AutoPilot - Simple, cross-platform GUI automation module for Rust.
device_query - Simple library to query mouse and keyboard inputs on demand without a window.
palette - Rust library for linear color calculations and conversion.
capstone-rs - Bindings to the capstone library disassembly framework.
Rust Atelier - Rust native library and tools for the AWS Smithy Interface Definition Language.
Rusb - Safe Rust wrapper for libusb.
volatile - Wraps a reference to any copy-able type and allows for volatile memory access to wrapped value.
voprf - Implementation of a verifiable oblivious pseudorandom function.
serde-big-array - Big array helper for serde.
Prop - Propositional logic with types in Rust.
ispc-rs - Rust library for build scripts to compile ISPC code into a Rust library.
rustscript - Use Rust as a scripting language.
ena - Implementation of union-find in Rust; extracted from (and used by) rustc.
stacker - Manual segmented stacks for Rust.
tokenizations - Robust and Fast tokenizations alignment library for Rust and Python.
systemstat - Rust library for getting system information/statistics.
Symbolic Stack Machines - Library for implementing symbolically executable stack-based virtual machines.
ZeroGc - Zero overhead tracing garbage collection for rust.
nc - Execute system call directly without std or libc.
snmalloc-rs - Rust bindings of snmalloc.
Serde Lite - General-purpose serialization/de-serialization library.
vaultrs - Asynchronous Rust client library for the Hashicorp Vault API.
VDF - Verifiable Delay Functions in Rust.
TreeFlat - Simplest way to build & traverse a pre-order Tree in Rust.
sarif-rs - Rust projects for interacting with the SARIF format.
tasky - Fluent async task spawning experiments.
libavif - Rust AVIF Decoder and Encoder crate.
arrow-odbc - Fill Apache Arrow record batches from an ODBC data source in Rust.
HashCorp Vault Rust API Client
rust-minidump - Type definitions, parsing, and analysis for the minidump file format.
jwalk - Filesystem walk performed in parallel with streamed and sorted results.
LaunchDarkly Server-Side SDK for Rust
Choir - Task Orchestration Framework.
mime_guess - MIME type guessing of file extensions for Rust.
mini-fs - Extensible virtual filesystem for the application layer.
rc-zip - Pure rust zip & zip64 reading and writing.
Chicon - File abstraction system for Rust.
bet - Build and evaluate binary expression trees.
audio-graph - Data structures and algorithms for audio graphs.
rainout - Cross-platform audio and MIDI IO.
munge - Makes it easy and safe to destructure raw pointers, MaybeUninits, Cells, and Pins.
rdev - Simple library to listen and send events to keyboard and mouse (MacOS, Windows, Linux).
unic-langid - Meta-crate contains two basic crates for Unicode Language Identifier and Locale manipulation.
fibers - Rust library to execute a number of lightweight asynchronous tasks (a.k.a, fibers) based on futures and mio.
Finny - Hierarchical Finite State Machines for Rust.
Mustache - Framework-agnostic way to render logic-free views.
segment-tree - Rust implementation of two segment trees and a fenwick tree.
IO Bluetooth - Cross-platform Bluetooth library for Rust.
mp4 - MP4 reader and writer library in Rust.
PyO3-File - Small helper library for working with python file-like objects with rust.
hifitime - High fidelity time management library in Rust.
ImplicitClone - Immutable types and ImplicitClone trait similar to Copy.
libvirt Rust - Rust bindings to the libvirt C library.
postage-rs - Feature-rich, portable async channel library.
SIMD JSON for Rust
linkmap-rs - Linkmap file parse library for rust.
dirs - Low-level library that provides config/cache/data paths.
serde-bridge - Bridge between serde types.
JSON spanned value - Track the origin of your JSON values for better error reporting.
rustrict - Sophisticated profanity filter for Rust.
packed_struct.rs - Bit-level packing and unpacking for Rust.
moro - Experiments with structured concurrency in Rust.
unicycle - Scheduler for driving a large number of futures.
fs4 - Extended utilities for working with files and filesystems in Rust.
Corundum - Persistent Memory Programming Library in Rust.
serde-this-or-that - Custom deserialization for fields that can be specified as multiple types.
linemux - Asynchronous tailing library in Rust.
JWT - JSON Web Token library for Rust.
async-channel - Async multi-producer multi-consumer channel.
fs_extra - Rust library that provides additional functionality not present in std::fs.
mtpng - Parallelized PNG encoder in Rust.
parquet-format-rs - Apache Parquet format for Rust, hosting the Thrift definition file and the generated .rs file.
Brotlic - Thin wrapper around brotli.
RefCast - Safely cast &T to &U where the struct U contains a single field of type T.
qcell - Statically-checked alternatives to RefCell and RwLock.
chitchat - Decentralized cluster membership in Rust. (Article) (HN)
numanji - Local-affinity first NUMA-aware allocator with optional fallback.
Lever - Pillars for Transactional Systems and Data Grids.
byte-slice-cast - Safely cast slices of one built-in fundamental number type to another.
clang-rs - Idiomatic Rust wrapper for libclang.
rust-psutil - Process and system monitoring library for Rust.
fast-ctc-decode - Blitzing Fast CTC Beam Search Decoder.
Nomad Rust - Rust work for nomad actors.
Shaku - Compile Time Dependency injection Library for Rust.
async_nursery - Primitive for structured concurrency.
Halfbrown HashMap - Multi backend HashMap for higher performance on different key space sizes.
ferros - Rust-based userland which also adds compile-time assurances to seL4 development.
Raml - OCaml runtime and FFI bindings directly in Rust.
drop-bin - Defer running expensive destructors until later.
completion - Utilities for writing completion-based asynchronous code.
Sphinx - Sphinx implementation in Rust.
ff - Traits and utilities for working with finite fields.
refl - Provides a refl encoding which you can use to provide a proof witness that one type is equivalent (identical) to another type.
rust-dht - Kademlia-based DHT implementation for Rust.
OpenStack SDK for Rust
Asynchronous OpenStack session and authentication
Symbolic - Stack trace symbolication library written in Rust.
TinyTemplate - Minimal Lightweight Text Templating.
ThreadBound - Make any value Sync but only available on its original thread.
Lindera - Morphological analysis library.
JobScheduler - Simple cron-like job scheduling library for Rust.
lifeguard - Object pool manager in Rust.
rtree.rs - Fast R-tree for Rust.
Chomp - Fast monadic-style parser combinator designed to work on stable Rust.
oqueue - Non-interleaving output queue.
Buildstructor - Derive a builder for your constructors in Rust.
Ruler - Framework that uses equality saturation to automatically infer small, expressive rulesets for a domain.
DLHN - Language and platform neutral binary serialization format that is inspired by JSON, CSV, MessagePack, and Protocol Buffers.
futures-async-stream - Async stream for Rust and the futures crate.
ambisonic - Compose and play 3D audio in pure Rust.
async-executor
Driveyard - Tools for data-oriented programming.
kdl-rs - Rust parser for KDL.
RustNet - Fast and reactive distributed systems toolbox.
audio - Crate for working with audio in Rust.
sharded-log - Batch-oriented multi-threaded sharded log for workloads that occasionally flush logs into some other system.
flate2 - Streaming compression/decompression library DEFLATE-based streams in Rust.
CipherCore - User-friendly secure computation engine based on secure multi-party computation.
iso8601 - Parsing ISO8601 dates using nom.
arboard - Cross-platform library for interacting with the clipboard.
midir - Cross-platform, real time MIDI processing in Rust.
os_info - Rust library to detect the operating system type.
quad-snd - High-level, light-weight, and opinionated audio library.
firec - Rust API to interact with firecracker.
async-broadcast - Async multi-producer multi-consumer broadcast channel, where each consumer gets a clone of every message sent on the channel.
miniraft - Minimal implementation of the Raft consensus protocol with a focus on readability/understandability.
Rust native JSON deserializer - Performant Rust implementation to parse JSON by reference.
Rink - Unit conversion tool and library written in rust.
regalloc.rs - Modular register allocator algorithms.
tokio-file-unix - Asynchronous support for epollable files via Tokio on Unix-like platforms.
sento - Lock-free, append-only atomic pool.
rustracing_jaeger - Jaeger tracing library for Rust.
jsonc-parser - JSONC parser for Rust.
JSON5 - Rust JSON5 serializer and deserializer which speaks Serde.
metered-rs - Fast, ergonomic metrics for Rust.
shellexpand - Library for shell-like expansions of variables in strings.
floatconv - Fast implementations of integer/floating point conversion operations.
Rust-SoapySDR - Rust bindings for SoapySDR, the vendor-neutral software defined radio hardware abstraction layer.
substrait-rs - Rust bindings for substrait.
dptree - Asynchronous event dispatch mechanism for Rust.
enum-map - Library providing enum map providing type safe enum array.
etcd-rs - etcd client for Rust backed by tokio and tonic.
SendWrapper - Implements a wrapper type called SendWrapper which allows you to move around non-Send types between threads.
num-integer - Integer trait and functions for Rust.
borsh-rs - Rust implementation of Binary Object Representation Serializer for Hashing.
faktory-rs - Rust bindings for Faktory clients and workers.
Lofty - Audio metadata library.
opt-rs - Lightweight molecular mechanics optimization code written in rust.
Malachite - Arbitrary-precision arithmetic library for Rust.
upon - Simple, powerful template engine.
Stateful - Ergonomic state machines for designing event-driven systems.
Ferrite - Session Types DSL for Rust.
Armature - Event-driven stateful actor framework for Rust.
privdrop - Simple Rust crate to drop privileges.
baseview - Low-level window system interface for audio plugin UIs.
Fragile - Utility wrapper to send non send types to other threads safely.
Moose - Framework for secure multi-party computation, written in Rust.
elsa - Append-only collections for Rust where borrows to entries can outlive insertions.
Pasts - Minimal and simpler alternative to the futures crate.
Ryū - Fast floating point to string conversion.
cache-advisor - Scan-resistant concurrent lazy LRU.
tracing-timing - Inter-event timing metrics on top of tracing.
runtime_injector - Runtime dependency injection in Rust.
sha1dir - Checksum of a directory tree.
synqueue - Experimental queue to be used in multi-threaded scenarios, like the task processors.
clap-sys - Rust bindings for the CLAP audio plugin API.
Rust I18n - Crate for loading localized text from a set of YAML mapping files.
tracing-logfmt - Logfmt formatter for tracing-subscriber.
fast-bernoulli - Efficient sampling with uniform probability.
hcl-rs - HCL serializer/deserializer for rust.
Pulsar - Rust Client library for Apache Pulsar.
downcast-rs - Rust enums are great for types where all variations are known beforehand.
faketty - Wrapper to exec a command in a pty, even if redirecting the output.
globiter - Turn glob range and set into Iterator.
loco.rs - Loco Protocol Wrapper for Rust.
Quick Pool - High Performance Async Generic Pool.
btree - Persistent B+Tree (clustered index) implementation in Rust.
command-fds - Rust library for passing arbitrary file descriptors when spawning child processes.
procspawn - Like thread::spawn but for processes.
built - Provides a crate with information from the time it was built.
noisy_float-rs - Rust library for checked floating point operations.
mayda - Fast Rust integer compression using SIMD.
dipstick - Configurable metrics toolkit for Rust applications.
async_zip - Asynchronous ZIP archive reading/writing crate.
reborrow - Emulate reborrowing for user types.
generational-lru - Generational arena based LRU Cache implementation in 100% safe rust.
keypath - Strongly typed references to arbitrarily nested fields.
Rust Radix Trie - Fast generic radix trie implemented in Rust.
KString - String optimized for map keys.
lldb - Higher level LLDB bindings for Rust built on lldb-sys.
async-lock - Async synchronization primitives.
lens-rs - Lens implemented in rust.
filetime - Accessing file timestamps in a platform-agnostic fashion in Rust.
BzTree - Concurrent B-tree implementation for Rust based on paper BzTree: A High-Performance Latch-free Range Index for Non-Volatile Memory.
tributary-rs - Streaming reactive and dataflow graphs in Rust.
Rust-HyperLogLog - HyperLogLog implementation in Rust, with bias correction.
toml-cfg - Procedural macro for configuring constant values across crates.
bitpacking - SIMD algorithms for integer compression via bitpacking. This crate is a port of a C library called simdcomp.
metaheuristics-nature - Collection of nature-inspired meta-heuristic algorithms.
AVIF-Serialize - Minimal pure Rust AVIF writer (bring your own AV1 payload).
memmapix - Cross-platform Rust API for memory mapped IO.
measureme - Support crate for rustc's self-profiling feature.
Foreign Vec - Zero-cost abstraction to store either [Vec<T>] or an immutable region aligned with T allocated by an external allocator.
etherparse - Rust library for parsing ethernet & ethernet using protocols.
bv-rs - Bit-vectors and bit-slices for Rust.
weak-table - Weak hash maps and sets for Rust.
RiteRaft - Raft framework, for regular people.
tiny-actor - Minimal actor framework for Rust.
sized-chunks - Efficient sized chunk datatypes for immutable.rs.
bnum - Arbitrary precision, fixed-size signed and unsigned integer types for Rust: BInt and BUint.
lockfree-cuckoohash - Rust implementation of lock free cuckoo hashmap.
stack_dst - Inline (aka stack-allocated) dynamically-sized types, and collections of dynamically-sized types using the same logic.
econf - Loads environment variables into your structs in one shot.
BGPKIT Parser - MRT/BGP data parser written in Rust.
jsc-rs - JavaScript core Rust safe binding.
Apalis - Simple, extensible multithreaded background job processing library for Rust.
hashbag - Unordered multiset/bag implementation backed by HashMap.
catty - Send and await a value asynchronously.
orc-format - Read Apache ORC from Rust.
webp-animation - High-level Rust wrapper for decoding and encoding WebP animations.
swagger-rs - Set of common utilities for crates generated by swagger-codegen.
creek - Real time disk streaming IO for audio.
Intertrait - Library providing direct casting among trait objects implemented by a type.
cubeb-rs - Cross-platform audio library in Rust.
fdg - Force Directed Graph Framework for Rust.
blurhash-wasm - Rust implementation of the blurhash algorithm.
serde-zod - Generate zod definitions from your JSON-serializable types in Rust.
subparse - Rust library to load, change and write common subtitle formats.
nougat - Use (lifetime-)GATs on stable rust.
EString - Simple way to parse a string using type annotations.
uuid-readable-rs - Generate easy to remember sentences that acts as human readable UUIDs.
sys_metrics - Cross-platform library to gather stats/information from the host.
fid-rs - High performance FID (Fully Indexable Dictionary) library.
Sokoban - Compact, efficient data structures in contiguous byte arrays.
recursion - Recursion schemes, in rust.
Blaze - Rustified OpenCL Experience.
flashmap - Lock-free, partially wait-free, eventually consistent, concurrent hashmap.
rust-socks - SOCKS proxy support for Rust.
Crawdad - Rust library of natural language dictionaries using character-wise double-array tries.
pcd-rs - Read PCD file format in Rust.
neli - Type safe netlink library for Rust.
owning-ref-rs - Library for creating references that carry their owner with them.
laz-rs - Rust implementation/translation of LAZ (Laszip) compression.
shapefile-rs - Rust library to read & write shapefiles.
dbase-rs - Rust library to read and write .dbf (dBase / FoxPro) files.
oom - One Or Many slice types.
hot-lib-reloader - Utility to reload libraries on change. For faster feedback cycles.
Twelf - Configuration solution for Rust including 12-Factor support.
recap - Deserialize typed structures from regex captures.
async-oneshot - Fast, small, full-featured, no-std compatible oneshot channel.
Aide-De-Camp - Durable job scheduler for rust.
Uclicious - Flexible reduced boilerplate configuration framework.
Precision - Low overhead, high precision measurement crate for Rust.
name-it - Name return types of async fn on stable Rust.
cismute - Safely transmute type to itself in generic context in Rust.
vec1 - Rust Vec<T> wrapper that gurantees to contain at least 1 element.
StackFuture - Wrapper around Rust futures that stores the future in space provided by the caller.
Fcode - Binary format for Rust / serde that supports schema evolution.
concurrent-queue - Concurrent multi-producer multi-consumer queue.
RDP - Rust implementation of the Ramer–Douglas-Peucker and Visvalingam-Whyatt line simplification algorithms.
monch - Inspired by nom, but specifically for strings.
slog-stdlog - Standard Rust log crate adapter to slog-rs.
GDAL - Rust bindings for GDAL.
PROJ - Rust bindings for the latest stable release of PROJ.
exitcode - System exit code constants as defined by sysexits.h.
Partial Function - Clean way to define function as a set of smaller functions where each has defined start and end bounds.
Particular - Simple, parallel N-body simulation library written in Rust.
Peapod - Ultra-compact storage for enums.
merge-streams - Merge multiple streams into one.
bzip2-rs - Pure Rust bzip2 decoder.
rusty-s3 - Simple pure Rust AWS S3 Client following a Sans-IO approach.
Wakey - Library for managing Wake-on-LAN packets.
glob - Support for matching file paths against Unix shell style patterns.
topological-sort-rs - Performs topological sorting.
rtp-rs - Rust reader for Real time Transport Protocol packet structure.
mpeg2ts-reader - Rust reader for MPEG2 Transport Stream data.
tokio-serial - Implementation of serialport I/O for Tokio, an async framework for rust.
Audio Filters - Collection of filters for real-time audio processing.
banzai - Pure rust bzip2 encoder.
iana-time-zone - Rust crate to get the IANA time zone for the current system.
Size Of - Crate for measuring the total memory usage of an object at runtime.
Yarte - Yet Another Rusty Template Engine.
v_escape - SIMD optimized escape code.
plmap - Parallel pipelined map over iterators.
tzdb - Static time zone information for tz-rs.
atomic-wait - Cross-platform atomic wait and wake (aka futex) functionality for Rust.
Timer - Simple implementation of a timer for Rust.
toml_edit - Format-preserving TOML parser.
Melior - Rustic MLIR bindings for Rust.
GDSL - Graph Data Structure Library.
xorfilter - Rust library implementing xor-filters.
rusty_ulid - Rust ULID (Universally Unique Lexicographically Sortable Identifier) generation and processing.
const-str - Compile-time string operations.
Rustbus - Dbus transport in pure rust.
rust-dark-light - Rust crate to detect if dark mode or light mode is enabled.
lending-iterator - Lending iterators on stable Rust.
higher-order-closure - Allow function lifetime elision and explicit for<'a> annotations on closures.
Ringbuffer - Fixed-size circular buffer written in Rust.
uriparse-rs - Implementation of RFC3986 including URIs and URI references.
rtsp-rs - RTSP 2.0 implementation in Rust.
ordered-multimap-rs - Ordered multimap.
webidl-rs - WebIDL parser written in Rust.
ics - Rust library for creating iCalendar files.
Autumn - Library for building recursive descent parsers using combinators.
Flux - Refinement Types for Rust.
parasol - Multi-threaded job scheduler in Rust.
orchestra - Partial actor pattern with a global orchestrator.
CAPTCHA - Library to generate CAPTCHAs.
OBWS - Remote control OBS with the obs-websocket plugin from Rust.
boba - Rust implementation of the Bubble Babble binary data encoding.
bit-vec - Vec of Bits.
Bluest - Cross-platform Rust crate for working with Bluetooth Low Energy devices.
Confique - Type-safe, layered configuration library.
proc-exit - Exit codes for process termination.
Nodi - Rust library for playing and abstraction of MIDI files.
Vibrato - Fast implementation of tokenization (or morphological analysis) based on the Viterbi algorithm.
audiotags - Unified IO for different types of audio metadata.
OpenXRS - Rust bindings for the OpenXR virtual/augmented reality runtime API.
whoami - Rust crate to get the current user and environment.
upversion - Notify your clients when new version release and show the latest download link.
rust-debruijn - De Bruijn graph construction & path compression libraries.
dynstack - Stack that allows users to allocate dynamically sized arrays.
binfarce - Extremely minimal parser for ELF/PE/Mach-o/ar.
ogawa-rs - Rust crate for reading ogawa alembic cache data.
datasize - Heap memory usage estimation.
Rio - Framework for scalable, distributed and stateful services based on message passing between objects.
l10n - Rust localization crate built upon fluent-bundle.
rusp - Rust USP toolkit.
page-turner - Generic abstraction of paginated APIs.
Data-encoding - Efficient and customizable data-encoding functions in Rust.
lottie-rs - Lottie file toolkit written in Rust.
Kanal - Rust library to help programmers design effective programs in CSP model via providing featureful multi-producer multi-consumer channels. (Reddit)
presser - Utilities to help make copying data around into raw, possibly-uninitialized buffers easier and safer.
ntpd-rs - NTP implementation in Rust, supported by Internet Security Research Group's Prossimo project.
copypasta - Cross-platform Rust system clipboard library.
pre - Rust library to help programmers correctly uphold preconditions for function calls.
Thirtyfour - Selenium / WebDriver library for Rust, for automated website UI testing.
syn-rsx - Syn-powered parser for JSX-like TokenStreams.
Deluge - Async stream processor. (Reddit)
Treebender - HDPSG-inspired symbolic natural language parser written in Rust.
Chrono-TZ - TimeZone implementations for rust-chrono from the IANA database.
Jomini - Low level, performance oriented parser for save and game files from EU4, CK3, HOI4, Imperator, and other PDS titles.
vsr-rs - Viewstamped Replication for Rust.
async-backtrace - Efficient, logical 'stack' traces of async functions. (Announcement)
packed-encoder - Tiny rust crate that can be used to encode data of different types into a packed byte array which can be passed over network, system calls or FFI.
hy-rs - Unified and portable interface to the hypervisor APIs provided by various platforms.
tachyonix - Asynchronous, multi-producer, single-consumer (MPSC) bounded channel that operates at tachyonic speeds.
Asynchronix - High-performance asynchronous computation framework for system simulation.
graphlib2 - Rust port of Python stdlib's graphlib.
ftlog - Asynchronous logging library for high performance.
json_plus - JSON helper functions beyond Serialization & Deserialization such as diff, merge, ....
sitemap - Sitemap library for Rust.
dot_graph - Library for generating Graphviz DOT language files.
Route Pattern - Parser and matcher for route patterns in Rust.
uchan - Small, scalable, unbounded, mpsc channel.
env_logger - Logger that can be configured via environment variables.
hex - Encoding and decoding data into/from hexadecimal representation.
unicode-segmentation - Iterators which split strings on Grapheme Cluster or Word boundaries.
Banyan
xtaskops - Goodies for working with the xtask concept in Rust.
JavaScriptCore API for Rust
ijson - Offers a replacement for serde-json's Value type, which is significantly more memory efficient.
Acto - Actor library for Rust.
Versions - Library for parsing and comparing software version numbers.
validated - Cumulative sibling of Result and Either.
Scroll - Traits for read/writing generic containers (byte buffers are currently implemented by default).
StateLock - Sync primitive that can be used to wait for a state to be ready.
usdt - Dust your Rust with USDT probes.
Parcom - Trait + closure based parser combinator library loosely following the Parsec Paper.
Versionize - Framework for version tolerant serializion/deserialization of Rust data structures.
compress-tools - Swiss Army Knife for handling compressed data in Rust.
timbre - Rust audio library designed for composing real-time effects.
zalgo codec - Crate for converting an ASCII text string or file to a single unicode character.
bigdecimal-rs - Arbitrary precision decimal crate for Rust.
diff.rs - LCS based slice and string diffing implementation.
buffer-unordered-weighted - Rust Stream::buffer_unordered where each future can have a different weight.
enve - Work with environment variables and convert it to any type using only type annotations.
archive - Safe bindings for libarchive with minimum overhead.
JS Source Scopes - Extracting and processing scope information from JavaScript source files, and resolving that scope via SourceMaps.
faer - Low level linear algebra routines in pure Rust. (Reddit)
Gifed - GIF encoding and decoding library.
envsubst - Simple Rust library for variables substitution.
nom-supreme - Collection of utilities for a superior nom experience.
arena - Compact generational arena data structure for Rust.
os_pipe.rs - Cross-platform library for opening OS pipes in Rust.
Framehop - Stack unwinding library in Rust.
Arrow generated IPC format - Generated Rust of Apache Arrow spec.
dose - Your daily dose of structs and functions.
hax - Versatile and intuitive memory hacking library.
ordered-stream - Streams that produce elements with an associated ordering.
TunTap - TUN/TAP wrapper for Rust.
Rust-ConfigParser - Simple config parsing lib for rust.
metastruct - Abstractions for iterating and mapping over struct fields.
llq - Wait-free single-producer single-consumer linked-list queue with individually reusable nodes. (Article)
Fragile - Utility wrapper to send non send types to other threads safely.
regress - REGex in Rust with EcmaScript Syntax.
bittle - Zero-cost bitsets over native Rust types.
ssh-rev-exec - Enables the remote host to run command in the local host via SSH agent socket.
JumpRope - Data structure for efficiently editing large strings, or for processing editing traces.
polling - Portable interface to epoll, kqueue, event ports, and wepoll.
tree_magic - Determines the MIME type of a file by traversing a file type tree.
state - Rust library for safe and effortless global and thread-local state management.
vm-virtio - Virtio abstractions and implementation for the virtio queue and devices.
titlecase - Tool and Rust crate for transforming text into Title Case.
addr2line - Cross-platform library for retrieving per-address debug information from files with DWARF debug information.
clang-ast - Deserialization logic for efficiently processing Clang's -ast-dump=json format from Rust.
buf-list - List of Rust buffers that implements the bytes::Buf trait.
Selfie - Lightweight self-referential struct library. Macro-free, allocation-free.
reedline - Readline replacement written in Rust.
consulrs - Asynchronous Rust client library for the Hashicorp Consul API.
unicode-normalization - Unicode character composition and decomposition utilities.
dashu - Library set of arbitrary precision numbers (aka. big numbers).
galloc - Linked list allocator, inspired by the dlmalloc algorithm.
tokio-retry - Extensible, asynchronous retry behaviors for futures/tokio.
protobuf-build - Utility functions for generating Rust code from protobuf specifications.
structre - Statically-checked regex parsing into structs.
serde_closure - Serializable closures for Rust.
Prse - Tiny string parsing utility.
mirror-mirror - Powerful reflection library for Rust.
PriorityQueue - Priority queue for Rust with efficient change function.
desim - Discrete-time events simulation framework, written in rust, using the generator experimental feature.
rend - Endian-aware primitives.
rel - Object system for Rust based on relative pointers.
nnnoiseless - Recurrent neural network for audio noise reduction.
effing-mad - Algebraic effects for Rust.
fsevent-stream - Stream-based FSEvents API bindings.
bucu1 - BOCU-1 encoder/decoder.
zip-extensions-rs - High-level functions for common ZIP tasks, such as extracting archives to a directory.
Enum Ptr - Ergonomic tagged pointer.
tracing-bunyan-formatter - Bunyan formatting for tokio-rs/tracing.
uint - Rust Uint crate using const-generics.
FeOs - Framework for Equations of State and Classical Density Functional Theory.
pitch_detection - Collection of algorithms to determine the pitch of a sound sample.
serde-partial - Serde partial serialization made easy.
serde_starlark - Serde serializer for generating Starlark build targets.
eye-rs - Cross platform camera capture in Rust.
that goes there - Library for general planning and execution of tasks on local and remote hosts.
ARPFloat - Arbitrary-Precision Floating-Point Library.
libvault_rs - Rust library for Hashicorp Vault.
busan - Actor implementation in Rust.
Akt - Actors framework for Rust and Tokio.
coredump - Crate to force coredump creation on panics.
Serde ignored - Find out about keys that are ignored when deserializing data.
OkayWAL - Write-ahead log (WAL) implementation for Rust. (Article)
bitfield-rle - Run-length-encoder that compresses bitfields.
Pyo3 Bindings to Polars
alloc-track - Track memory allocations by backtrace or originating thread.
sync_cow - Thread-safe clone-on-write container for fast concurrent writing and reading.
trie-rs - Memory efficient trie (prefix tree) library based on LOUDS.
quick-xml - High performance xml pull reader/writer.
rust-ffmpeg-sys - FFmpeg bindings for Rust.
rust-s2 - Rust port of Google S2 geometry library.
Redact - Simple library for keeping secrets out of logs.
Async IO traits
network-interface - Retrieve system's Network Interfaces/Adapters on Linux, macOS and Windows on a standarized manner.
Mini Raft - Implementation of Raft in Rust.
libproc-rs - Library for getting information about running processes for Mac OS X and Linux.
flow - Exploration of a data-flow programming paradigm.
backhand - Library and binaries for the reading, creating, and modification of SquashFS file systems.
dbg-pls - Debug-like trait for rust that outputs properly formatted code.
rust-elf - Library for parsing ELF files for Rust.
validators - Library for validating and modeling user input.
HTML Escape - Encoding/escaping special characters in HTML and decoding/unescaping HTML entities as well.
MozJPEG - Safe Rust wrapper for the MozJPEG library.
Deflect - Brings reflection to Rust using DWARF debug info.
async-compat - Compatibility adapter between tokio and futures.
with-thread-local - Micro crate that simplifies a bit the use of the std macro thread_local.
RaptorQ - Rust implementation of RaptorQ.
urlpattern - Rust implementation of the URLPattern web API.
Timely Util - Utility abstractions on top of Timely Dataflow.
OpenDP - Modular collection of statistical algorithms that adhere to the definition of differential privacy.
how-u-doin - Progress reporting abstraction for Rust.
Serde JSON Borrow - Fast JSON deserialization on borrowed data.
tracery - Rust implementation of the tracery generative grammar language.
ab-av1 - AV1 video encoding tool with fast VMAF sampling & automatic encoder crf calculation. Uses ffmpeg, svt-av1 & vmaf.
gethostname.rs - gethostname() for all systems.
rust_box2d - Library wrapping around the Box2D physics engine.
LogLog - Distributed, fault tolerant, strongly consistent, performant (event)log in Rust.
redeez-rs - Simplified general-purpose queueing system for Rust apps.
Rust LiveKit SDK
glob-match - Extremely fast glob matching library with support for wildcards, character classes, and brace expansion.
fastblur - Fast (linear time) implementation of the Gaussian Blur algorithm in Rust.
Serde Querystrings - Rust library for serialising to and deserialising from querystrings.
Scoped-Arena - Arena allocator with explicit scopes.
HIDEFIX - Concurrent HDF5 and NetCDF4 reader.
Skima - Rust structural web UI library.
Observe - Lightweight Rust observables inspired by MobX.
tiny-bench - Tiny benchmarking library.
slug - Small library for generating slugs from unicode strings.
quickraw - Pure rust library to handle camera raw files.
do-notation - Monadic do notation brought to Rust.
bicoro - Bidirectional co-routine data structures.
semaphore-key - Control concurrent thread access by key using a shared semaphore.
symbol_table - Easy-to-use SymbolTable that's fast, suitable for concurrent access.
intaglio - UTF-8 string and byte string interner and symbol table.
mitmproxy_rs - Rust bits in mitmproxy.
Easy Quick JS - Simple way to embed QuickJS into your rust project.
JustJSON - Efficient JSON Value parser.
Rust for Flipper Zero
Coerce-rs - Actor runtime and distributed systems framework for Rust.
tzfile - Rust chrono::TimeZone implementation using the system tz database.
xdg-user - Crate to give you paths to user dirs.
VPlugin - Plugin framework for Rust.
Geodesy - Platform for experiments with geodetic software, transformations, and standards.
BumpSlab - Bump allocator with reusable slots.
tokio-pipe - Asynchronous pipe library using tokio.
fd-lock - Cross-platform file locks using file descriptors.
rust-bk-tree - BK-tree implementation in Rust.
serde-hashkey - Space efficient, in-memory serde serialization which supports hashing.
rxing - Barcode library in pure rust.
mtzip - Rust library for making zip files, focused on multithreading the process.
axoasset - Load, write, and copy remote and local assets.
llvm-plugin-rs - Out-of-tree LLVM passes in Rust.
csv-async - CSV parsing in async context.
nuts-rs - No U-turn Sampler in Rust.
basic-toml - Minimal TOML library with few dependencies.
Either - Enum Either with variants Left and Right and trait implementations including Iterator, Read, Write.
Autometrics - Easily add metrics to your system -- and actually understand them using automatically customized Prometheus queries.
Twinsies - Specialized reference-counting pointer where the item is jointly owned in 2 places.
Sediment - Low-level MVCC file format for storing blobs.
bytebuffer - Easy to use API to read/write data from/to a bunch of bytes.
force-directed-graph
npm-package - Lightweight client for fetching package metadata from the npm registry.
system-deps - Run pkg-config from declarative dependencies in Cargo.toml.
vectrix - Stack-allocated, constant-size, matrix type implemented with const generics.
winnow - Parser combinators library written in Rust.
Git Testament - Library to embed a testament as to the state of a git working tree during the build of a Rust program.
sharpie - Signing and verifying digital signatures using RSA or ED25519.
h264_webcam_stream - Rust-based proof of concept for streaming from a webcam (using v4l2) in h264 over webrtc.
Config Reload - Automatically reloads given config file.
nom-greedyerror - Custom error type of nom to improve accuracy of error position.
Glidesort - Stable adaptive quicksort/mergesort hybrid sorting algorithm. (HN)
autosurgeon - Rust library for working with data in automerge documents.
Syner - Derive your Attribute Parsers.
JSON-RPC-RS - JSON-RPC 2.0 client/server library in rust.
Assets-manager - Conveniently load, cache, and reload external resources.
const_env - Configure const and static items by environment variables.
io-arrays - Random-access I/O.
Versionize - Framework for version tolerant serializion/deserialization of Rust data structures.
Handoff - Unbuffered, single-producer / single-consumer, async channel.
Memflex - Memory hacking library.
little_exif - Little library for reading and writing EXIF data in pure Rust.
Rattler - Common functionality used within the Conda ecosystem.
concache - Linked-list based, lock-free concurrent hashmap in Rust.
image-tiff - TIFF decoding and encoding library in pure Rust.
Monostate - Type that deserializes only from one specific value.
envious - Deserialize (potentially nested) environment variables into your custom structs.
Parsec Rust Interface
platform-info - Cross-platform way to get information about your machine.
fat-macho-rs - Mach-O Fat Binary Reader and Writer.
xorf - Xor filters - efficient probabilistic hashsets. Faster and smaller than bloom and cuckoo filters.
io-streams - Unbuffered and unlocked I/O streams.
socketpair - Cross-platform socketpair functionality.
Hexx - Hexagonal tools lib in rust.
cargo-index-transit - Package for common types for Cargo index interactions, and conversion between them. (From cargo to crates.io and back again)
Thunderdome - Arena type inspired by generational-arena.
Nakago - Lightweight Rust framework for elegant services.
nserde_usd - Collection of serialization libraries for the Pixar's USD format.
rust_icu - Low-level rust language bindings for the ICU library.
zune-image - Small, independent and performant image codecs that can be used for decoding and sometimes encoding images in a variety of formats.
async-iterator - Async version of iterator.
strfmt - Rust library for formatting dynamic strings.
spin-sleep - Rust accurate sleeping. Only use native sleep as far as it can be trusted, then spin.
Jotdown - Djot parser library.
Lightflus - Lightweight, Cloud-Native Stateful Distributed Dataflow Engine.
rusty_link - Rust wrapper of Ableton Link's C 11 extension.
localsearch - Rust library for local search optimization.
Lariv - Thread-safe, self-memory-managed vector with no guaranteed sequential insert.
Suffix array - Construction and searching algorithms for in-memory binary data.
Stable Structures - Collection of data structures for fearless canister upgrades. (Tutorial)
rustyrepl - Rust Read-Evaluate-Print-Loop utility crate.
ractor - Rust actor framework. (Reddit) (HN)
Native JSON - Powerful way of parsing JSON syntax into native Rust structs.
async-rx - Reactive programming in async Rust.
rust-shed - Rust crates common between other Facebook open source projects (like Mononoke or Eden).
retry - Retry some code until its return value satisfies a condition.
ferrilab - Redefining the Rust fundamental data model.
Actix Net - Collection of lower-level libraries for composable network services.
process-memory - Allows you to read/write into the memory of other processes.
geo-valid - Geometry validation for the rust geo/geo-types library.
pam-rs - Rust interface to the pluggable authentication module framework (PAM).
shared_vector - Efficient reference counted vector data structure is Rust.
Guillotiere - Dynamic texture atlas allocator with fast deallocation and rectangle coalescing.
velocity - Efficient ID system written in Rust.
robusta - Easy interop between Rust and Java.
netstat2 - Cross-platform Rust library to retrieve network sockets information.
qrcode-rust - QR code and Micro QR code encoder in Rust.
sev - Rust library exposing APIs for the AMD SEV platform.
RcLite - Small, fast, and memory-friendly reference counting for Rust. (Reddit)
crop - UTF-8 text rope.
vid2img - Allows the use of a video file as a collection of frame images.
openssh-mux-client - Rust library to communicate with openssh-mux-server.
Faiss-rs - Rust bindings to Faiss, the state-of-the-art vector search and clustering library.
yatp - Thread pool in Rust that is adaptive, responsive and generic.
futures-buffered - Single future structure: FuturesUnorderedBounded.
QWT - Rust implementation of the Quad Wavelet Tree.
Wax - Opinionated and portable globs that can be matched against paths and directory trees.
ringbuf - Lock-free SPSC FIFO ring buffer with direct access to inner data.
ruice - Runtime based Dependency Injection for Rust.
blink-alloc - Fast, concurrent, arena-based allocator with drop support.
HEVC Parser - HEVC format parser.
dap-rs - Rust implementation of the Debug Adapter Protocol.
smallbox - Small Box optimization: store small item on stack and fallback to heap for large item.
jsonb - JSONB implemented in rust.
nom-bibtex - Feature complete BibTeX parser using nom.
binary-extract - Extract a value from JSON string without parsing the whole thing.
async-openai - Async Rust library for OpenAI.
anything - Calculate everything and nothing with perfect precision.
syntree_layout - Library to visualize tree structures.
ecow - Compact, clone-on-write vector and string.
CITA-Trie - Rust implementation of the Modified Patricia Tree (aka Trie).
atomic-traits - Traits for generic atomic operations in Rust.
art-rs - Adaptive Radix Tree in Rust.
arc-atomic-ref - Smart pointer type that can be shared with many different threads of execution, while at the same time can be swapped out atomically with new data.
Freezie - Disables mutation for the contained type.
tmpdir - Useful to create temp directories and copying their contents on completion of some action.
Overlord - Consensus protocol that decouple the consensus process from the execution process.
thin-vec - Vec that stores its length and capacity inline, making it take up less space.
default-net - Cross-platform library for network interface and gateway.
rav1d - AV1 decoder in Rust.
include_bytes_zstd - Includes a file with zstd compression in Rust.
deriving_via - More convenient version of derive_more for newtype pattern.
installed - Get a list of installed software for runtime use.
Unzrip - Unzip implementation, support for parallel decompression, automatic detection encoding.
memoize - Macro for auto-memoizing Rust functions.
Tydi - Open specification for complex data structures over hardware streams.
Narrow - Implementation of Apache Arrow.
Pierce - Avoid double indirection in nested smart pointers.
constant_time_eq - Compares two equal-sized byte strings in constant time.
hnsw-rs - Rust implementation of the HNSW algorithm (Malkov-Yashunin).
Propane - Rust generators.
ndarray-csv - Easily read homogeneous CSV data into a 2D ndarray.
comemo - Incremental computation through constrained memoization.
rapl - Rank Polymorphic array library for Rust.
ort - Rust wrapper for ONNX Runtime.
Nestruct - Rust Library for Flattening and Nesting Structs.
Nipper - Rust crate for manipulating HTML with CSS selectors.
Tracing OpenTelemetry - Utilities for adding OpenTelemetry interoperability to tracing.
crunch-rs - Rectangle packer, written in Rust, for cramming lots of rectangles into a larger one.
scoped-trace - Capture scoped backtraces.
vmcircbuffer - Double Mapped Circular Buffer.
Garde - Validation library.
speedate - Fast and simple datetime, date, time and duration parsing.
imstr - Immutable strings, in Rust.
shell-words - Process command line according to parsing rules of Unix shell.
integer-encoding-rs - Encoding and decoding of integers to and from bytestring representations.
Alkahest - Fantastic serialization library.
Serde Valid - JSON Schema based validation tool using with serde.
shellflip - Graceful process restarts in Rust.
Keshvar - Collection of all sorts of useful information for every country.
vdb-rs - Rust native implementation of the VDB file format.
type_description - Machine-readable descriptions for rust types.
Valico - Rust JSON Schema validator and JSON coercer.
pulp - Safe abstraction over SIMD instructions.
memuse - Traits for inspecting memory usage of Rust types.
ArrayFire Rust - High performance library for parallel computing with an easy-to-use API.
rsmpi - MPI bindings for Rust.
condtype - Choose Rust types via boolean conditions.
static_slicing - Utilities for enhanced slicing and indexing.
Myval - Lightweight Apache Arrow data frame for Rust.
webpki - WebPKI X.509 Certificate Validation in Rust.
Sucre - Experimental Symmetric Interaction Combinator Runtime.
Struson - Streaming JSON reader and writer written in Rust.
atomic-file - Rust crate for working with ACID-safe one-shot files.
TinyAudio - Cross-platform audio output library.
lyd - Music DSP library written in Rust with a focus on performance and flexibility.
triple_accel - Rust edit distance routines accelerated using SIMD.
dotenvy - Well-maintained fork of the dotenv crate.
Railroad - Library to produce syntax diagrams as Scalable Vector Graphics.
mp4parse-rust - Parser for ISO Base Media Format aka video/mp4 written in Rust.
Inexor Reactive Graph Flow - Reactive Graph and Flow Control.
ZFlow - Rust implementation of Flow Based Programming Graph specification.
tracy_full - Safe, fully-featured bindings to the Tracy profiler.
Musli - Flexible and generic binary serialization framework.
Maths - Linear algebra library for graphics and gamedev.
Backie - Background task processing for Rust applications with Tokio, Diesel, and PostgreSQL.
Zen - Open-source Business Rules Engine for your Rust, NodeJS or Python applications.
rust-cid
cfg-expr - Parser and evaluator for Rust cfg() expressions.
flatty - Flat message buffers with direct mapping to Rust types without packing/unpacking.
lasso - Fast, concurrent string interner.
Self-Replace - Utility library that helps to implement processes that replace themselves.
bsuccinct-rs - Succinct data structures and other libraries for Rust.
tracing-panic - Make panics visible in your telemetry pipeline.
textdistance.rs - Rust library to compare strings (or any sequences). 25+ algorithms, pure Rust, common interface, Unicode support.
feattle - Feature toggles for Rust, extensible and with background synchronization and administration UI.
KAS Text - Rich text processing.
Generic B-Tree - Pure safe BTree that can be used to build your own special-purpose btree data structure.
dagga - DAG scheduler with nice constraint semantics.
stack-map - Constant-size associative container backed by a simple array.
crumsort-rs - Parallelized Rust port of crumsort.
mlir-sys - Rust bindings to the MLIR C API.
Bw-Tree
gryf - Graph data structure library aspiring to be convenient, versatile, correct and performant.
vtc-rs - SMPTE timecode library for Rust.
HexTree - Trees for fast location-to-value lookup.
bilge - Use bitsized types as if they were a feature of rust.
Flowync - Simple utility for multithreading a/synchronization.
tracing-stackdriver - Stackdriver-compatible tracing Subscriber.
value-bag - Dynamic structured values for Rust.
petgraph-wasm - Selective WASM wrapper around the fantastic petgraph library in Rust.
Disintegrate - Alternative approach to building domain objects from an event stream.
atone - VecDeque (and Vec) variant that spreads resize load across pushes.
tart - Adaptive Radix Tree implementation.
stop-token - Cooperative cancellation for async Rust.
unscanny - Painless string scanning.
sluggify-rs - Simple slug or clean url generator for Rust.
option-ext - Extends Option with additional operations.
Shiftnanigans - Library of common functionality to share between other Rust projects.
simdutf - Unicode validation and transcoding at billions of characters per second.
wildmatch - Simple string matching with questionmark- and star-wildcard operator.
AutobahnHash - Fast, safe, and portable implementation of HighwayHash for Rust.
portable-atomic - Portable atomic types including support for 128-bit atomics, atomic float, etc.
memfd_exec - Execute binaries straight from memory, without touching disk, with a friendly interface.
derive_setters - Procedural macro that automatically generates setter methods for a struct's fields.
Instant Segment - Fast English word segmentation in Rust.
OpenAI - Rust library for the OpenAI API.
async-timer - Timer facilities for Rust's async story.
msgpack-schema - Specification language for MessagePack data schema.
rust-id3 - Rust library for reading and writing ID3 metadata.
Robust Binary Search
Parallelo - Small, but powerful, parallel framework written in Rust.
IceLake - Rust implementation of Iceberg.
mmap-sync - Rust library for concurrent data access, using memory-mapped files, zero-copy deserialization, and wait-free synchronization.
fail-rs - Fail points for rust.
Netidx - Cross platform secure messaging library.
Deadqueue - Dead simple queue implementation for rust with async-await.
libninja - Generate client libraries that are featureful, human, well-documented, and async based on OpenAPI specs.
sonyflake-rs - Distributed unique ID generator inspired by Twitter's Snowflake.
tobj - Tiny OBJ Loader in Rust.
ngt-rs - Rust wrappers for NGT approximate nearest neighbor search.
derive-codegen
type-safe-id - Type-safe, K-sortable, globally unique identifier.
indexset - Pure-Rust (zero dependencies) two-level dynamic b-tree.
Trc - Biased reference-counted smart pointer.
A Rust Users Guide to Generics (2023)
blitter - Bitmap blitting library for Rust.
H26Forge - Domain-specific infrastructure for analyzing, generating, and manipulating syntactically correct but semantically spec-non-compliant video files.
Statime - Implementation of the Precision Time Protocol (PTP) in Rust.
mac_address - Cross-platform retrieval of a network interface MAC address.
Bwrap - Fast, lightweight, embedded environment-friendly library for wrapping text.
codspeed-rust - Rust helpers to create CodSpeed benchmarks.
radar-rs - Unofficial Cloudflare Radar Rust SDK.
Talc - Fast, flexible, and consistant no_std allocator.
Squeeze - Dynamic congestion-based concurrency limits for controlling backpressure.
Apache Iceberg Rust
uts2ts - Convert a unix timestamp (seconds) to a struct.
Tower Async - Library of modular and reusable components for building robust networking clients and servers.
welford - Online algorithms for mean and variance, with support for weighted samplings.
graphviz-rust - Basic functions to work with Graphviz dot lang from rust code.
uy - Typesafe, flexible, simple, and user-friendly unit system library for Rust that has good error messages.
Leptos Query - Robust asynchronous state management library for Leptos.
orx-priority-queue - Priority queue traits; binary and generalized d-ary heap implementations.
piet-tiny-skia - Piet frontend for the tiny-skia framework.
Rusty FFmpeg - Cross platform FFI bindings for FFmpeg inner libraries.
nucleo - Fast and convenient fuzzy matcher library for rust.
pca - Principal component analysis (PCA).
Slipstream - Helps writing code in a way that incentives the compiler to optimize the results better.
rSVD - Computing an approximate singular value decomposition (SVD) of a matrix using randomized algorithms.
serde_columnar - Ergonomic columnar storage encoding crate.
await-tree - Instrument await-tree for actor-based applications.
dumpster - Cycle-tracking garbage collector library for Rust.
native-dialog - Library to display file choosers and message boxes.
ISO8601 Timestamp - High-performance ISO8601 Timestamp formatting and parsing.
faststr - String library that try to avoid the cost of clone.
Rodeo - Fast dropping untyped arena for Rust.
hipstr - Another string type for Rust. (Reddit)
wherr - Enhance Rust errors with file and line details using the #[wherr] macro for clearer debugging. (HN)
UNIC - Unicode and Internationalization Crates for Rust.
piz - Parallelized zip archive reading.
allocator-api2 - Mirrot of Rust's allocator api for use on stable rust.
tokio-graceful - Graceful shutdown util for Rust projects using the Tokio Async runtime.
openai-rust - Library to interface with the OpenAI API.
OpenAI API for Rust
hashlink - Updated version of linked-hash-map and friends.
aarch64-cpu - Low level access to processors using the AArch64 execution state.
qr_code - QR code encoder and decoder in Rust.
jxl-oxide - Rust implementation of JPEG XL decoder.
konst - Const equivalents of std functions, compile-time comparison, and parsing.
typewit - Type-witness-based abstractions, used for emulating polymorphism in const fns.
tick_counter - Hardware-based tick counters for high-precision benchmarks in Rust.
byteyarn - Space-efficient byte strings.
show-image - Quickly show images for debugging in Rust.
Convert Case - Converts to and from various cases.

Cargo Plugins

shuttle - Deploy Rust apps with a single Cargo command. (Web)
cargo-instruments - Cargo plugin to generate Xcode Instruments trace files.
cargo-c - Cargo C-ABI helpers.
cargo-deny - Cargo plugin to help you manage large dependency graphs.
cargo-edit - Utility for managing cargo dependencies from the command line.
cargo-profiler - Cargo subcommand to profile binaries.
cargo-outdated - Cargo subcommand for displaying when Rust dependencies are out of date.
cargo-modules - Cargo plugin for showing a tree-like overview of a crate's modules.
cargo-tree - Cargo subcommand that visualizes a crate's dependency graph in a tree-like format.
cargo cache - Manage cargo cache (${CARGO_HOME}, ~/.cargo/), print sizes of dirs and remove dirs selectively.
stack-sizes - Tools to print stack usage information emitted by LLVM in human readable format.
cargo-spellcheck - Checks all your documentation for spelling mistakes.
cargo-lipo - Cargo subcommand to automatically create universal libraries for iOS.
cargo-expand - Subcommand to show result of macro expansion.
rust-script - Rust files and expressions as scripts without any setup or compilation step. (Web) (rust-script-ext)
cargo-limit - Cargo with less noise: warnings are skipped until errors are fixed, etc.
cargo-deadlinks - Check your cargo doc documentation for broken links.
cargo-osha - Cargo plugin to list unsafe code in a Rust project.
Cargo Wipe - Recursively finds and optionally wipes all "target" or "node_modules" folders that are found in the current path.
cargo xtask - Way to add free-form automation to a Rust project, a-la make, npm run or bespoke bash scripts.
cargo-binutils - Cargo subcommands to invoke the LLVM tools shipped with the Rust toolchain.
cargo-embed - Cargo extension for working with microcontrollers.
cargo makedocs - Cargo subcommand to build documentation for development easier.
cargo-hack - Cargo subcommand to provide some options useful for testing and continuous integration.
probe-run - Run embedded programs just like native ones.
cargo-up - Automatically upgrade breaking changes.
cargo-update - cargo subcommand for checking and applying updates to installed executables.
cargo-mobile - Rust on mobile made easy. (Fork)
Cargo-sweep - Cargo subcommand for cleaning up unused build files generated by Cargo.
cargo-supply-chain - Gather author, contributor and publisher data on crates in your dependency graph.
Cargo Wharf - Cacheable and efficient Docker images builder for Rust.
cargo-deb - Cargo subcommand that generates Debian packages from information in Cargo.toml.
Cargo Remote - Cargo subcommand to compile rust projects remotely.
cargo-breaking - Compares a crate's public API between two different branches, shows what changed, and suggests the next version according to semver.
cargo-first-page - Shows only the first page of rustc output.
Cargo Bisection - Bisects rustc, either nightlies or CI artifacts.
cargo-edit-locally - Subcommand to easily edit crate dependencies locally.
cargo-patch - Cargo Subcommand which allows patching dependencies using patch files.
cargo-llvm-cov - Cargo subcommand to easily use LLVM source-based code coverage.
Cargo rdme - Cargo command to create the readme.md from your crate's documentation.
cargo-script - Cargo subcommand designed to let people quickly and easily run Rust "scripts" which can make use of Cargo's package ecosystem.
cargo-husky - Setup Git hooks automatically for cargo projects.
rhack - Temporary edit external crates that your project depends on.
Highway-rs - Native Rust port of Google's HighwayHash. Makes use of SIMD instructions for a fast and strong hash function.
cargo-depgraph - Creates dependency graphs for cargo projects using cargo metadata and graphviz.
cargo-build-deps - Cargo subcommand to build dependencies, helps speed up docker builds by allowing dependencies to be built earlier and cached.
cargo-intraconv - Simple helper to transform Markdown links to intra-doc links in Rust projects when appropriate.
cargo-xcodebuild - Helps cargo build and run apps for iOS.
cargo-strip - Cargo subcommand that reduces the size of Rust binaries using the strip command.
cargo-valgrind - cargo subcommand, that runs valgrind and collects its output in a helpful manner.
cargo-license - Cargo subcommand to see license of dependencies.
cargo-build-tree
cargo-msrv - Find the minimum supported Rust version (MSRV) for your project.
cargo-local-install - Wraps cargo install for better local, non-conflicting installation.
cargo-zigbuild - Compile Cargo project with zig as linker. (Reddit)
cargo run-wasm - Run WASM applications and examples in the browser.
cargo-quickinstall - Pre-compiled binary packages for cargo install.
cargo-diet - Help computing 'optimal' include directives for your Cargo.toml manifest.
reloady - Simple and performant hot-reloading for Rust.
cargo-temp - CLI tool that allows you to create a new rust project in a temporary directory with already installed dependencies.
cargo-bom - Bill of Materials for Rust Crates.
cargo-feature - Cargo plugin to manage dependency features.
cargo-rx - Simple, modern fuzzy finder tool to run examples in a Cargo project.
cargo-options - Reusable common Cargo command line options.
cargo-subcommand - Library for implementing cargo subcommands.
cargo-bump - The command cargo bump which bumps the current version in your Cargo.toml.
Cargo spec - Tool to turn your code into a specification.
cargo-lambda - Cargo subcommand to help you work with AWS Lambda.
cargo-action-fmt - Converts cargo check (and clippy) JSON output to the GitHub Action error format.
rusty-hook - Git hook utility for Rust codebases that lets you run any script for any git hook.
cargo-clone - Cargo subcommand to fetch the source code of a Rust crate.
Cargo Structure - Utility for analyzing the structure of a cargo project.
cargo-trace - Flamegraphing tool for perf events.
build-info - Collects build-information of your Rust crate.
cargo-minimal-versions - Cargo subcommand for proper use of -Z minimal-versions.
cargo-vet - Supply-chain security for Rust. (Docs)
cargo-criterion - Cargo extension for running Criterion.rs benchmarks.
cargo-public-api - List and diff the public API of Rust library crates between releases and commits.
cargo-doc2readme - Cargo subcommand to create a readme file containing the rustdoc comments from your code.
cargo_metadata - Structured access to the output of cargo metadata. Usually used from within a cargo-* executable.
cargo-select - Cargo subcommand to easily run targets/examples/tests.
Cargo Commander - Simple way of running commands.
cargo-run-bin - Build, cache, and run binaries scoped in Cargo.toml rather than installing globally.
cargo-i18n - Rust Cargo sub-command and libraries to extract and build localization resources to embed in your application/library.
cargo-unused-features - Find potential unused enabled feature flags and prune them.
cargo-semver-checks - Scan your Rust crate for semver violations.
cargo-spdx - Generate an SPDX Software Bill of Materials for Rust crates.
cargo-docs - Serve rust and crate doc locally.
cargo-pgo - Cargo subcommand for optimizing binaries with PGO and BOLT.
cargo feature-set - Extract the features for every compiled crate from cargo metadata.
cargo-show-asm - Cargo subcommand that displays the Assembly, LLVM-IR and MIR generated for Rust source code.
cargo add-dynamic - Allows to wrap dependencies as dylibs.
cargo-clean-all - Custom cargo command that analyses all cargo target directories under a given parent directory and allows for cleaning them.
cargo-changelog - Changelog management tool for CLI.
cargo-careful - Execute Rust code carefully, with extra checking along the way. (Article)
cargo-docset - Generate a Zeal/Dash docset for your Rust crate or workspace.
cargo-cranky - Easy to configure wrapper for Rust's clippy.
Cargo Sort - Tool to check that your Cargo.toml dependencies are sorted alphabetically.
targo - Wraps cargo to move target directories to a central location.
cargo-deps - Cargo subcommand for building dependency graphs of Rust projects.
CycloneDX Rust (Cargo) Plugin - Creates CycloneDX Software Bill of Materials (SBOM) from Rust (Cargo) projects.
cargo-guppy - Track and query Cargo dependency graphs.
allocative - Library and proc macro to analyze memory usage of data structures in rust.
Typeshare - Ultimate tool for synchronizing your type definitions between Rust and other languages for seamless FFI. (Reddit) (Article)
ddt - Clean dead git branches & Remove outdated cargo artifacts. (Reddit)
cargo-single - Cargo subcommand for handling single-source Rust programs with dependencies.
cargo-mommy - Support you when running cargo.
cargo-fetcher - Alternative to cargo fetch for use in CI or other "clean" environments.
cargo-sandbox - Drop-in replacement for cargo, with the added benefit of isolating those commands from other parts of your system. (Lobsters)
cargo-cabal - Tool that helps you to turn in one command a Rust crate into a Haskell Cabal library.
cargo-config2 - Load and resolve Cargo configuration.
cargo-generate-rpm - Cargo helper command to generate a binary RPM package.
cargo-manifest - Fork of cargo_toml to fix some issues for cargo-chef.
wasm-server-runner - Allows you to run programs in the browser using web assembly using a simple cargo run.
cargo-dist - cargo build but For Building Final Distributable Artifacts and uploading them to an archive. (Article)
Duvet - Code quality tool to help bound correctness.
cargo-px - Cargo subcommand that extends cargo's capabilities when it comes to code generation.
cargo which-nightly - Tells you which nightly contains a particular set of features.
cargo public-api-crates - Cargo subcommand to find crates in your public API.
cargo-http-registry - Cargo registry allowing for quick publishing of crates when using crates.io is just not desired.
cargo-indicate - Run GraphQL Queries on Your Rust Dependency Tree.
Cargo Feature Tree - List your features in a expanded and tree-like format.
cargo-swift - Cargo plugin to easily build Swift packages from Rust code.

Notes

cargo udeps tries to uncover unused dependencies

Genomics

Immunology

Startups

AWS

Serverless computing

Build systems

Computer vision

Algorithms

Formal verification

Blockchain

Figma

Message queue

Remote Procedure Calls

Psychedelics

Lysergamides

Tryptamines

Renewable energy

CSS

Game development

Game engines

CPU

Nutrition

Drinks

2018

2019

2020

2021

2022

Alfred

Keyboard Maestro

Xcode

Neural networks

Linear algebra

Logic

Automated theorem proving

Mathematical optimization

Statistics

Type Theory

Diseases

Music production

GraphQL

Internet of things

Peer to peer

VPN

GitHub

Containers

Kubernetes

iOS

Linux

Nix

Electrical engineering

Quantum physics

Functional programming

Interactive computing

Software testing

Version control

C

Clojure

C++

Dart

Elixir

Elm

Go

Go libraries

Java

JavaScript

JS libraries

React

Julia

Kotlin

Lisp

Nim

Objective C

OCaml

Processing

Prolog

Python

Python libraries

R language

ReasonML