Extra CreditRust crates
4,945 in Packages and libraries, most used first. Page 1 of 25.
-
hashbrown A Rust port of Google's SwissTable hash map - syn Parser for Rust source code
- getrandom A small cross-platform library for retrieving random data from system source
- bitflags A macro to generate structures which behave like bitflags.
- rand_core Core random number generator traits and tools for implementation.
- rand Random number generators and other randomness functionality.
- libc Raw FFI bindings to platform libraries like libc.
- quote Quasi-quoting macro quote!(...)
- proc-macro2 A substitute implementation of the compiler's `proc_macro` API to decouple token-based libraries from the procedural macro use case.
- base64 encodes and decodes base64 as bytes or utf8
- windows-sys Rust for Windows
- indexmap A hash table with consistent order and fast iteration.
- thiserror-impl Implementation detail of the `thiserror` crate
- thiserror derive(Error)
- itertools Extra iterator adaptors, iterator methods, free functions, and macros.
- 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 matchi
- memchr Provides extremely fast (uses SIMD on x86_64, aarch64 and wasm32) routines for 1, 2 or 3 byte search and single substring search.
- regex-syntax A regular expression parser.
- serde A generic serialization/deserialization framework
- unicode-ident Determine whether characters have the XID_Start or XID_Continue properties according to Unicode Standard Annex #31
- rand_chacha ChaCha random number generator
- itoa Fast integer primitive to string conversion
- serde_derive Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
- serde_json A JSON serialization file format
- autocfg Automatic cfg for Rust compiler features
- heck heck is a case conversion library.
- log A lightweight logging facade for Rust
- once_cell Single assignment cells and lazy values.
- 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 t
- regex-automata Automata construction and matching using regular expressions.
- socket2 Utilities for handling networking sockets with a maximal amount of configuration possible intended.
- smallvec 'Small vector' optimization: store up to a small number of items on the stack
- rustix Safe Rust bindings to POSIX/Unix/Linux/Winsock-like syscalls
- regex An implementation of regular expressions for Rust. This implementation uses finite automata and guarantees linear time matching on all input
- aho-corasick Fast multiple substring searching.
- ryu Fast floating point to string conversion
- clap A simple to use, efficient, and full-featured Command Line Argument Parser
- block-buffer Buffer types for block processing of data
- digest Traits for cryptographic hash functions and message authentication codes
- linux-raw-sys Generated bindings for Linux's userspace API
- parking_lot_core An advanced API for creating custom synchronization primitives.
- windows_x86_64_msvc Import lib for Windows
- parking_lot More compact and efficient implementations of the standard synchronization primitives.
- strsim Implementations of string similarity metrics. Includes Hamming, Levenshtein, OSA, Damerau-Levenshtein, Jaro, Jaro-Winkler, and Sørensen-Dice
- bytes Types and traits for working with bytes
- windows_x86_64_gnu Import lib for Windows
- mio Lightweight non-blocking I/O.
- cpufeatures Lightweight runtime CPU feature detection for aarch64, loongarch64, and x86/x86_64 targets, with no_std support and support for mobile targe
- windows_aarch64_msvc Import lib for Windows
- windows_i686_msvc Import lib for Windows
- windows-targets Import libs for Windows
- pin-project-lite A lightweight version of pin-project written with declarative macros.
- http A set of types for representing HTTP requests and responses.
- windows_i686_gnu Import lib for Windows
- num-traits Numeric traits for generic mathematics
- version_check Tiny crate to check the version of the installed/running rustc.
- either The enum `Either` with variants `Left` and `Right` is a general purpose sum type with two cases.
- sha2 Pure Rust implementation of the SHA-2 hash function family including SHA-224, SHA-256, SHA-384, and SHA-512.
- semver Parser and evaluator for Cargo's flavor of Semantic Versioning
- windows_x86_64_gnullvm Import lib for Windows
- windows_aarch64_gnullvm Import lib for Windows
- lock_api Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
- lazy_static A macro for declaring lazily evaluated statics in Rust.
- anyhow Flexible concrete Error type built on std::error::Error
- idna IDNA (Internationalizing Domain Names in Applications) and Punycode.
- futures-core The core traits and types in for the `futures` library.
- scopeguard A RAII scope guard that will run a given closure when it goes out of scope, even if the code between panics (assuming unwinding panic). Def
- winnow A byte-oriented, zero-copy, parser combinators library
- zerocopy Zerocopy makes zero-cost memory manipulation effortless. We write "unsafe" so you don't have to.
- toml A native Rust encoder and decoder of TOML-formatted files and streams. Provides implementations of the standard Serialize/Deserialize traits
- slab Pre-allocated storage for a uniform data type
- futures-task Tools for working with tasks.
- futures-util Common utilities and extension traits for the futures-rs library.
- hyper A protective and efficient HTTP library for all.
- crypto-common Common traits used by cryptographic algorithms
- rustls Rustls is a modern TLS library written in Rust.
- fastrand A simple and fast random number generator
- crossbeam-utils Utilities for concurrent programming
- typenum Typenum is a Rust library for type-level numbers evaluated at compile time. It currently supports bits, unsigned integers, and signed
- miniz_oxide DEFLATE compression and decompression library rewritten in Rust based on miniz
- percent-encoding Percent encoding and decoding
- generic-array Generic types implementing functionality of arrays
- ppv-lite86 Cross-platform cryptography-oriented low-level SIMD library.
- time Date and time library. Fully interoperable with the standard library. Mostly compatible with #![no_std].
- futures-channel Channels for asynchronous communication using futures-rs.
- shlex Split a string into shell words, like Python's shlex.
- http-body Trait representing an asynchronous, streaming, HTTP request or response body.
- futures-sink The asynchronous `Sink` trait for the futures-rs library.
- url URL library for Rust, based on the WHATWG URL Standard
- clap_lex Minimal, flexible command line parser
- tracing-core Core primitives for application-level tracing.
- tracing Application-level tracing for Rust.
- errno Cross-platform interface to the `errno` variable.
- equivalent Traits for key comparison in maps.
- toml_datetime A TOML-compatible datetime type
- futures-io The `AsyncRead`, `AsyncWrite`, `AsyncSeek`, and `AsyncBufRead` traits for the futures-rs library.
- toml_edit Yet another format-preserving TOML parser.
- rustc-hash A speedy, non-cryptographic hashing algorithm used by rustc
- tempfile A library for managing temporary files and directories.
- uuid A library to generate and parse UUIDs.
- form_urlencoded Parser and serializer for the application/x-www-form-urlencoded syntax, as used by HTML forms.
- chrono Date and time library for Rust
- h2 An HTTP/2 client and server
- tokio-macros Tokio's proc macros.
- unicode-width Determine displayed width of `char` and `str` types according to Unicode Standard Annex #11 rules.
- rustls-webpki Web PKI X.509 Certificate Verification.
- fnv Fowler–Noll–Vo hash function
- futures-macro The futures-rs procedural macro implementations.
- rustversion Conditional compilation according to rustc compiler version
- byteorder Library for reading/writing numbers in big-endian and little-endian.
- untrusted Safe, fast, zero-panic, zero-crashing, zero-allocation parsing of untrusted inputs in Rust.
- tokio-util Additional utilities for working with Tokio.
- futures An implementation of futures and streams featuring zero allocations, composability, and iterator-like interfaces.
- tokio-rustls Asynchronous TLS/SSL streams for Tokio using Rustls.
- pkg-config A library to run the pkg-config system tool at build time in order to be used in Cargo build scripts.
- clap_builder A simple to use, efficient, and full-featured Command Line Argument Parser
- clap_derive Parse command line argument by defining a struct, derive crate.
- webpki-roots Mozilla's CA root certificates for use with webpki
- ahash A non-cryptographic hash function using AES-NI for high performance
- tracing-attributes Procedural macro attributes for automatically instrumenting functions.
- darling_core Helper crate for proc-macro library for reading attributes into structs when implementing custom derives. Use https://crates.io/crates/darli
- darling A proc-macro library for reading attributes into structs when implementing custom derives.
- anstyle ANSI text styling
- darling_macro Internal support for a proc-macro library for reading attributes into structs when implementing custom derives. Use https://crates.io/crates
- futures-executor Executors for asynchronous tasks based on the futures-rs library.
- rustc_version A library for querying the version of a installed rustc compiler
- reqwest higher level HTTP client library
- wasi WASI API bindings for Rust
- signal-hook-registry Backend crate for signal-hook
- tinyvec `tinyvec` provides 100% safe vec-like data structures.
- ring An experiment.
- httparse A tiny, safe, speedy, zero-copy HTTP/1.x parser.
- nom A byte-oriented, zero-copy, parser combinators library
- synstructure Helper methods and macros for custom derives
- zeroize Securely clear secrets from memory with a simple trait built on stable Rust primitives which guarantee memory is zeroed using an operation w
- redox_syscall A Rust library to access raw Redox system calls
- subtle Pure-Rust traits and utilities for constant-time cryptographic implementations.
- memoffset offset_of functionality for Rust structs.
- crc32fast Fast, SIMD-accelerated CRC32 (IEEE) checksum computation
- flate2 DEFLATE compression and decompression exposed as Read/BufRead/Write streams. Supports miniz_oxide and multiple zlib implementations. Support
- time-macros Procedural macros for the time crate. This crate is an implementation detail and should not be relied upon directly.
- anstream IO stream adapters for writing colored text that will gracefully degrade according to your terminal's capabilities.
- num-integer Integer traits and functions
- thread_local Per-object thread-local storage
- tower Tower is a library of modular and reusable components for building robust clients and servers.
- anstyle-parse Parse ANSI Style Escapes
- serde_core Serde traits only, with no support for derive -- use the `serde` crate instead
- crossbeam-epoch Epoch-based garbage collection
- iana-time-zone get the IANA time zone for the current system
- stable_deref_trait An unsafe marker trait for types like Box and Rc that dereference to a stable address even when moved, and hence can be used with libraries
- async-trait Type erasure for async trait methods
- colorchoice Global override of color control
- anstyle-query Look up colored console capabilities
- time-core This crate is an implementation detail and should not be relied upon directly.
- hex Encoding and decoding data into/from hexadecimal representation.
- hyper-rustls Rustls+hyper integration for pure rust HTTPS
- pin-utils Utilities for pinning
- tower-service Trait representing an asynchronous, request / response based, client or server.
- strum_macros Helpful macros for working with enums and strings
- want Detect when another Future wants a result.
- tinyvec_macros Some macros for tiny containers
- strum Helpful macros for working with enums and strings
- try-lock A lightweight atomic lock.
- walkdir Recursively walk a directory.
- crossbeam-deque Concurrent work-stealing deque
- zerocopy-derive Custom derive for traits from the zerocopy crate
- phf_shared Support code shared by PHF libraries
- litemap A key-value Map implementation based on a flat, sorted Vec.
- yoke-derive Custom derive for the yoke crate
- displaydoc A derive macro for implementing the display Trait via a doc comment and string interpolation
- mime Strongly Typed Mimes
- zerovec Zero-copy vector backed by a byte array
- icu_provider Trait and struct definitions for the ICU data provider
- utf8parse Table-driven UTF-8 parser
- icu_properties Definitions for Unicode properties
- same-file A simple crate for determining whether two file paths point to the same file.
- icu_collections Collection of API for use in ICU libraries.
- tinystr A small ASCII-only bounded length string representation.
- zerovec-derive Custom derive for the zerovec crate
- hmac Generic implementation of Hash-based Message Authentication Code (HMAC)
- serde_spanned Serde-compatible spanned Value
- tracing-subscriber Utilities for implementing and composing `tracing` subscribers.
- icu_normalizer_data Data for the icu_normalizer crate
- icu_properties_data Data for the icu_properties crate
- num-bigint Big integer implementation for Rust
- icu_normalizer API for normalizing text into Unicode Normalization Forms
- zerofrom ZeroFrom trait for constructing
- deranged Ranged integers
- openssl-probe A library for helping to find system-wide trust anchor ("root") certificate locations based on paths typically used by `openssl`.
- writeable A more efficient alternative to fmt::Display
- ipnet Provides types and useful methods for working with IPv4 and IPv6 network addresses, commonly called IP prefixes. The new `IpNet`, `Ipv4Net`,
- glob Support for matching file paths against Unix shell style patterns.
- bumpalo A fast bump allocation arena for Rust.
- httpdate HTTP date parsing and formatting
- object A unified interface for reading and writing object file formats.
- zerofrom-derive Custom derive for the zerofrom crate
- unicode-xid Determine whether characters have the XID_Start or XID_Continue properties according to Unicode Standard Annex #31.
- crossbeam-channel Multi-producer multi-consumer channels for message passing
- prost A Protocol Buffers implementation for the Rust Language.
- foldhash A fast, non-cryptographic, minimally DoS-resistant hashing algorithm.