Skip to main content

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.

CLI​

  • 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.
  • clap-rs - Full featured, fast Command Line Argument Parser. (Reddit) (step towards 4.0) (Reddit)
  • 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).
  • Argh - Opinionated Derive-based argument parser optimized for code size.
  • tui-rs - Build terminal user interfaces and dashboards using Rust.
  • 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.
  • Lexopt - Minimalist pedantic command line parser.
  • 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.
  • bpaf - Parse command line arguments by composing a parser from the components optimized for flexibility and compilation time. (Reddit)
  • 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.

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)
  • Rouille - Rust web micro-framework.
  • hyper - Fast and correct HTTP implementation for Rust. (Web) (Hyper's Vision)
  • 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)
  • 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)
  • 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-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)
  • Tide - Modular web framework.
  • 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.
  • 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)
  • 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.
  • axum-live-view - Real-time user experiences with server-rendered HTML.
  • 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.

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)
  • 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.

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)
  • 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)
  • 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.

DB​

  • SQLx - Rust SQL Toolkit.
  • 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.

Video​

  • rust-ac-ffmpeg - Rust wrapper for FFmpeg libraries.
  • Nightfall - Easy to use lib for creating on-demand transcoding sessions for efficient media playback.

Graphics​

  • 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.

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.

GraphQL​

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.
  • 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.

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.

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​

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.

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.

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.

ML​

  • 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.

macOS​

  • mach - Rust interface to the Mach 3.0 kernel that underlies macOS.
  • Cacao - Rust bindings for AppKit (macOS) and UIKit (iOS/tvOS).
  • 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.

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.

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.

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)
  • 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.
  • 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-rs - Provide as direct as possible access to the system's functionality for sockets as possible.
  • 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.
  • 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)
  • 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 - Rust embedded async tools.
  • 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)
  • 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.
  • 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.
  • 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.
  • fs2 - 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.

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)
  • 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.
  • 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.
  • 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.

Notes​