-
serde
A generic serialization/deserialization framework
-
thiserror
derive(Error)
-
serde_json
A JSON serialization file format
-
rand
Random number generators and other randomness functionality
-
clap
efficient, and full-featured Command Line Argument Parser
-
tokio
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
syn
Parser for Rust source code
-
log
A lightweight logging facade for Rust
-
anyhow
Flexible concrete Error type built on std::error::Error
-
regex
regular expressions for Rust. This implementation uses finite automata and guarantees linear time matching on all inputs.
-
quote
Quasi-quoting macro quote!(...)
-
chrono
Date and time library for Rust
-
base64
encodes and decodes base64 as bytes or utf8
-
proc-macro2
A substitute implementation of the compiler’s
proc_macroAPI to decouple token-based libraries from the procedural macro use case -
tracing
Application-level tracing for Rust
-
libc
Raw FFI bindings to platform libraries like libc
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
reqwest
higher level HTTP client library
-
tempfile
managing temporary files and directories
-
futures
streams featuring zero allocations, composability, and iterator-like interfaces
-
once_cell
Single assignment cells and lazy values
-
bytes
Types and traits for working with bytes
-
toml
A native Rust encoder and decoder of TOML-formatted files and streams. Provides implementations of the standard Serialize/Deserialize traits for TOML data to facilitate deserializing and serializing Rust structures.
-
url
based on the WHATWG URL Standard
-
uuid
generate and parse UUIDs
-
bitflags
A macro to generate structures which behave like bitflags
-
indexmap
A hash table with consistent order and fast iteration
-
tracing-subscriber
implementing and composing
tracingsubscribers -
sha2
Pure Rust implementation of the SHA-2 hash function family including SHA-224, SHA-256, SHA-384, and SHA-512
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
async-trait
Type erasure for async trait methods
-
getrandom
A small cross-platform library for retrieving random data from system source
-
num-traits
Numeric traits for generic mathematics
-
futures-util
Common utilities and extension traits for the futures-rs library
-
hashbrown
port of Google's SwissTable hash map
-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
env_logger
A logging implementation for
logwhich is configured via an environment variable -
http
A set of types for representing HTTP requests and responses
-
hex
Encoding and decoding data into/from hexadecimal representation
-
cc
A build-time dependency for Cargo build scripts to assist in invoking the native C compiler to compile native C code into a static archive to be linked into Rust code
-
cfg-if
A macro to ergonomically define an item depending on a large number of #[cfg] parameters. Structured like an if-else chain, the first matching branch is the item that gets emitted.
-
tokio-util
Additional utilities for working with Tokio
-
criterion
Statistics-driven micro-benchmarking library
-
strum
macros for working with enums and strings
-
rayon
work-stealing parallelism for Rust
-
flate2
DEFLATE compression and decompression exposed as Read/BufRead/Write streams. Supports miniz_oxide and multiple zlib implementations. Supports zlib, gzip, and raw deflate streams.
-
smallvec
'Small vector' optimization: store up to a small number of items on the stack
-
hyper
A protective and efficient HTTP library for all
-
nix
Rust friendly bindings to *nix APIs
-
semver
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
rustls
modern TLS library written in Rust
-
windows-sys
Windows
-
rand_core
Core random number generation traits and tools for implementation
-
axum
Web framework that focuses on ergonomics and modularity
-
rand_chacha
ChaCha random number generator
-
glob
Support for matching file paths against Unix shell style patterns
-
heck
case conversion library
-
tower
modular and reusable components for building robust clients and servers
-
wasm-bindgen
Easy support for interacting between JS and Rust
-
dirs
tiny low-level library that provides platform-specific standard locations of directories for config, cache and other data on Linux, Windows, macOS and Redox by leveraging the mechanisms…
-
paste
Macros for all your token pasting needs
-
strum_macros
macros for working with enums and strings
-
tokio-stream
work with
Streamandtokio -
prost
A Protocol Buffers implementation for the Rust Language
-
indicatif
A progress bar and cli reporting library for Rust
-
bincode
A binary serialization / deserialization strategy for transforming structs into bytes and vice versa!
-
rustc-hash
A speedy, non-cryptographic hashing algorithm used by rustc
-
zeroize
Securely clear secrets from memory with a simple trait built on stable Rust primitives which guarantee memory is zeroed using an operation will not be 'optimized away' by the compiler…
-
derive_more
Adds #[derive(x)] macros for more traits
-
percent-encoding
Percent encoding and decoding
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
unicode-width
Determine displayed width of
charandstrtypes according to Unicode Standard Annex #11 rules -
nom
A byte-oriented, zero-copy, parser combinators library
-
walkdir
Recursively walk a directory
-
socket2
handling networking sockets with a maximal amount of configuration possible intended
-
schemars
Generate JSON Schemas from Rust code
-
colored
The most simple way to add colors in your terminal
-
crossterm
A crossplatform terminal library for manipulating terminals
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
ahash
A non-cryptographic hash function using AES-NI for high performance
-
tokio-rustls
Asynchronous TLS/SSL streams for Tokio using Rustls
-
byteorder
reading/writing numbers in big-endian and little-endian
-
dashmap
Blazing fast concurrent HashMap for Rust
-
futures-core
The core traits and types in for the
futureslibrary -
http-body-util
Combinators and adapters for HTTP request or response bodies
-
tower-http
Tower middleware and utilities for HTTP clients and servers
-
serde_with
Custom de/serialization functions for Rust's serde
-
hyper-util
hyper utilities
-
bindgen
Automatically generates Rust FFI bindings to C and C++ libraries
-
crossbeam-channel
Multi-producer multi-consumer channels for message passing
-
js-sys
Bindings for all JS global objects and functions in all JS environments like Node.js and browsers, built on
#[wasm_bindgen]using thewasm-bindgencrate -
memchr
extremely fast (uses SIMD on x86_64, aarch64 and wasm32) routines for 1, 2 or 3 byte search and single substring search
-
hmac
Generic implementation of Hash-based Message Authentication Code (HMAC)
-
num-bigint
Big integer implementation for Rust
-
toml_edit
format-preserving TOML parser
-
fastrand
fast random number generator
-
ring
An experiment
-
darling
A proc-macro library for reading attributes into structs when implementing custom derives
-
console
A terminal and console abstraction for Rust
-
digest
Traits for cryptographic hash functions and message authentication codes
-
bytemuck
mucking around with piles of bytes
-
convert_case
Convert strings into any case
-
pretty_assertions
Overwrite
assert_eq!andassert_ne!with drop-in replacements, adding colorful diffs -
itoa
Fast integer primitive to string conversion
-
pkg-config
run the pkg-config system tool at build time in order to be used in Cargo build scripts
-
rustls-pemfile
Basic .pem file parser for keys and certificates
-
sha1
SHA-1 hash function
-
pin-project
safe and ergonomic pin-projection
-
quick-xml
High performance xml reader and writer
-
zerocopy
makes zero-cost memory manipulation effortless. We write "unsafe" so you don't have to.
-
webpki-roots
Mozilla's CA root certificates for use with webpki
-
web-sys
Bindings for all Web APIs, a procedurally generated crate from WebIDL
-
which
equivalent of Unix command "which". Locate installed executable in cross platforms.
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
tonic
A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility
-
zip
support the reading and writing of zip files
-
static_assertions
Compile-time assertions to ensure that invariants are met
-
unicode-segmentation
Grapheme Cluster, Word and Sentence boundaries according to Unicode Standard Annex #29 rules
-
zstd
Binding for the zstd compression library
-
image
Imaging library. Provides basic image processing and encoders/decoders for common image formats.
-
http-body
Trait representing an asynchronous, streaming, HTTP request or response body
-
rustversion
Conditional compilation according to rustc compiler version
-
urlencoding
doing URL percentage encoding
-
subtle
Pure-Rust traits and utilities for constant-time cryptographic implementations
-
proptest
Hypothesis-like property-based testing and shrinking
-
predicates
boolean-valued predicate functions
-
indoc
Indented document literals
-
windows
Rust for Windows
-
mime
Strongly Typed Mimes
-
prost-types
Prost definitions of Protocol Buffers well known types
-
tokio-tungstenite
Tokio binding for Tungstenite, the Lightweight stream-based WebSocket implementation
-
ordered-float
Wrappers for total ordering on floats
-
memmap2
Cross-platform Rust API for memory-mapped file IO
-
prettyplease
A minimal
synsyntax tree pretty-printer -
crc32fast
Fast, SIMD-accelerated CRC32 (IEEE) checksum computation
-
phf
Runtime support for perfect hash function data structures
-
async-stream
Asynchronous streams using async & await notation
-
fnv
Fowler–Noll–Vo hash function
-
tar
file reader and writer. This library does not currently handle compression, but it is abstract over all I/O readers and writers. Additionally, great lengths are taken to ensure that the entire…
-
futures-channel
Channels for asynchronous communication using futures-rs
-
pyo3
Bindings to Python interpreter
-
libloading
Bindings around the platform's dynamic library loading primitives with greatly improved memory safety
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
serde_urlencoded
x-www-form-urlencodedmeets Serde -
slab
Pre-allocated storage for a uniform data type
-
encoding_rs
A Gecko-oriented implementation of the Encoding Standard
-
wasm-bindgen-futures
Bridging the gap between Rust Futures and JavaScript Promises
-
humantime
A parser and formatter for std::time::{Duration, SystemTime}
-
winapi
Raw FFI bindings for all of Windows API
-
home
Shared definitions of home directories
-
sysinfo
get system information such as processes, CPUs, disks, components and networks
-
lru
cache implementation
-
rustc_version
querying the version of a installed rustc compiler
-
backtrace
acquire a stack trace (backtrace) at runtime in a Rust program
-
serial_test
Allows for the creation of serialised Rust tests
-
num-integer
Integer traits and functions
-
sqlx
🧰 The Rust SQL Toolkit. An async, pure Rust SQL crate featuring compile-time checked queries without a DSL. Supports PostgreSQL, MySQL, and SQLite.
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
rstest
Rust fixture based test framework. It use procedural macro to implement fixtures and table based tests.
-
serde_repr
Derive Serialize and Deserialize that delegates to the underlying repr of a C-like enum
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
tokio-test
Testing utilities for Tokio- and futures-based code
-
dotenvy
A well-maintained fork of the dotenv crate
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
tower-service
Trait representing an asynchronous, request / response based, client or server
-
libm
libm in pure Rust
-
assert_cmd
Test CLI Applications
-
ureq
safe HTTP client
-
prost-build
Generate Prost annotated Rust types from Protocol Buffers files
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
opentelemetry
API for Rust
-
aes
Pure Rust implementation of the Advanced Encryption Standard (a.k.a. Rijndael)
-
cargo_metadata
structured access to the output of
cargo metadata -
blake3
hash function
-
pest
The Elegant Parser
-
cmake
A build dependency for running
cmaketo build a native library -
csv
Fast CSV parsing with support for serde
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
textwrap
word wrapping, indenting, and dedenting strings. Has optional support for Unicode and emojis as well as machine hyphenation.
-
async-channel
Async multi-producer multi-consumer channel
-
notify
Cross-platform filesystem notification library
-
mime_guess
detection of a file's MIME type by its extension
-
clap_complete
Generate shell completion scripts for your clap::Command
-
pest_derive
pest's derive macro
-
jsonwebtoken
Create and decode JWTs in a strongly typed way
-
insta
A snapshot testing library for Rust
-
bitvec
Addresses memory by bits, for packed collections and bitfields
-
data-encoding
Efficient and customizable data-encoding functions like base64, base32, and hex
-
fs_extra
Expanding std::fs and std::io. Recursively copy folders with information about process and much more.
-
futures-lite
Futures, streams, and async I/O combinators
-
approx
Approximate floating point equality comparisons and assertions
-
rand_distr
Sampling from random number distributions
-
arc-swap
Atomically swappable Arc
-
num-complex
Complex numbers implementation for Rust
-
ed25519-dalek
Fast and efficient ed25519 EdDSA key generations, signing, and verification in pure Rust
-
rust_decimal
Decimal number implementation written in pure Rust suitable for financial and fixed-precision calculations
-
serde_bytes
Optimized handling of
&[u8]andVec<u8>for Serde -
git2
Bindings to libgit2 for interoperating with git repositories. This library is both threadsafe and memory safe and allows both reading and writing git repositories.
-
dyn-clone
Clone trait that is dyn-compatible
-
mockall
A powerful mock object library for Rust
-
dunce
Normalize Windows paths to the most compatible format, avoiding UNC where possible
-
opentelemetry_sdk
The SDK for the OpenTelemetry metrics collection and distributed tracing framework
-
native-tls
A wrapper over a platform's native TLS implementation
-
ctrlc
Easy Ctrl-C handler for Rust projects
-
signal-hook
Unix signal handling
-
flume
A blazingly fast multi-producer channel
-
sha3
Pure Rust implementation of SHA-3, a family of Keccak-based hash functions including the SHAKE family of eXtendable-Output Functions (XOFs), as well as the accelerated variant TurboSHAKE
-
owo-colors
Zero-allocation terminal colors that'll make people go owo
-
num-derive
Numeric syntax extensions
-
ratatui
that's all about cooking up terminal user interfaces
-
web-time
Drop-in replacement for std::time for Wasm in browsers
-
dialoguer
A command line prompting library
-
rsa
Pure Rust RSA implementation
-
tonic-build
Codegen module of
tonicgRPC implementation -
arbitrary
The trait for generating structured data from unstructured data
-
rmp-serde
Serde support for MessagePack
-
tracing-opentelemetry
OpenTelemetry integration for tracing
-
aes-gcm
Pure Rust implementation of the AES-GCM (Galois/Counter Mode) Authenticated Encryption with Associated Data (AEAD) Cipher with optional architecture-specific hardware acceleration
-
aws-config
AWS SDK config and credential provider implementations
-
config
Layered configuration system for Rust applications
-
crossbeam
Tools for concurrent programming
-
ignore
A fast library for efficiently matching ignore files such as
.gitignoreagainst file paths -
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
pathdiff
diffing paths to obtain relative paths
-
directories
tiny mid-level library that provides platform-specific standard locations of directories for config, cache and other data on Linux, Windows and macOS by leveraging the mechanisms defined…
-
terminal_size
Gets the size of your Linux or Windows terminal
-
termcolor
cross platform library for writing colored text to a terminal
-
rusqlite
Ergonomic wrapper for SQLite
-
similar
A diff library for Rust
-
trybuild
Test harness for ui tests of compiler diagnostics
-
secrecy
Wrapper types and traits for secret management which help ensure they aren't accidentally copied, logged, or otherwise exposed (as much as possible), and also ensure secrets are securely wiped from memory when dropped
-
hostname
Cross-platform system's host name functions
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
ctor
__attribute__((constructor)) for Rust
-
nalgebra
General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices
-
dotenv
A
dotenvimplementation for Rust -
glam
fast 3D math library for games and graphics
-
opentelemetry-otlp
Exporter for the OpenTelemetry Collector
-
pulldown-cmark
A pull parser for CommonMark
-
p256
Pure Rust implementation of the NIST P-256 (a.k.a. secp256r1, prime256v1) elliptic curve as defined in SP 800-186, with support for ECDH, ECDSA signing/verification, and general purpose curve arithmetic
-
actix-web
Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust
-
chrono-tz
TimeZone implementations for chrono from the IANA database
-
const_format
Compile-time string formatting
-
prometheus
instrumentation library for Rust applications
-
rcgen
Rust X.509 certificate generator
-
metrics
A lightweight metrics facade
-
async-std
Deprecated in favor of
smol- Async version of the Rust standard library -
heapless
staticfriendly data structures that don’t require dynamic memory allocation -
blake2
hash functions
-
globset
Cross platform single glob and glob set matching. Glob set matching is the process of matching one or more glob patterns against a single candidate path simultaneously, and returning all of the globs that matched.