Crates.io

Parser for Rust source code

A macro to generate structures which behave like bitflags.

Random number generators and other randomness functionality.

Core random number generation traits and tools for implementation.

Raw FFI bindings to platform libraries like libc.

A substitute implementation of the compiler's `proc_macro` API to decouple token-based libraries from the procedural macro use case.

Quasi-quoting macro quote!(...)

encodes and decodes base64 as bytes or utf8

A hash table with consistent order and fast iteration.

Extra iterator adaptors, iterator methods, free functions, and macros.

A regular expression parser.

Rust for Windows

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.

A generic serialization/deserialization framework

derive(Error)

ChaCha random number generator

Provides extremely fast (uses SIMD on x86_64, aarch64 and wasm32) routines for 1, 2 or 3 byte search and single substring search.

Macros 1.1 implementation of #[derive(Serialize, Deserialize)]

Automatic cfg for Rust compiler features

A JSON serialization file format

Single assignment cells and lazy values.

A lightweight logging facade for Rust

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.

An implementation of regular expressions for Rust. This implementation uses finite automata and guarantees linear time matching on all inputs.

A simple to use, efficient, and full-featured Command Line Argument Parser

Fast multiple substring searching.

Safe Rust bindings to POSIX/Unix/Linux/Winsock-like syscalls

Implementations of string similarity metrics. Includes Hamming, Levenshtein, OSA, Damerau-Levenshtein, Jaro, Jaro-Winkler, and Sørensen-Dice.

More compact and efficient implementations of the standard synchronization primitives.

Traits for cryptographic hash functions and message authentication codes

Types and traits for working with bytes

A macro for declaring lazily evaluated statics in Rust.

Parser and evaluator for Cargo's flavor of Semantic Versioning

The enum `Either` with variants `Left` and `Right` is a general purpose sum type with two cases.

Tiny crate to check the version of the installed/running rustc.

A set of types for representing HTTP requests and responses.

Buffer types for block processing of data

An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications.

Flexible concrete Error type built on std::error::Error

Rustls is a modern TLS library written in Rust.

Date and time library. Fully interoperable with the standard library. Mostly compatible with #![no_std].

A protective and efficient HTTP library for all.

Pure Rust implementation of the SHA-2 hash function family including SHA-224, SHA-256, SHA-384, and SHA-512.

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 library for Rust, based on the WHATWG URL Standard

Common utilities and extension traits for the futures-rs library.

Generic types implementing functionality of arrays

Lightweight runtime CPU feature detection for aarch64, loongarch64, and x86/x86_64 targets, with no_std support and support for mobile targets including Android and iOS

Minimal, flexible command line parser

Application-level tracing for Rust.