Crates

A thin, portable wrapper over the operating system's readiness API — epoll, kqueue, IOCP. The event loop tokio is built on, and almost never what application code should use directly.

Values initialised once, on first use: a cell you can fill later and a lazy static that runs its initialiser at first access. Most of it is now in std — this is the version for older toolchains, no_std, and the parts std still lacks.

Replacements for std's Mutex, RwLock, Condvar and Once — smaller, with no lock poisoning, and with timeouts, fairness and reentrancy that std doesn't offer.

The async runtime the ecosystem settled on: an executor for tasks, non-blocking I/O, timers, and the channels and locks that work across .await points.

The shared vocabulary of HTTP in Rust — Request, Response, HeaderMap, StatusCode, Uri. Types only: it sends nothing and serves nothing, which is exactly why every client and server agrees on it.

Base64 encoding and decoding, with the alphabet and padding rules made explicit. Pick an engine — standard, URL-safe, padded or not — and call encode and decode on it.

The serialization framework the whole ecosystem shares. Derive Serialize and Deserialize once, and your type reads and writes JSON, TOML, YAML, MessagePack and the rest without knowing about any of them.

JSON for Rust: parse into your own types with from_str, write them back with to_string, or work with untyped Value when the shape isn't known ahead of time.

Reads and writes TOML through serde, so a configuration file deserialises straight into your own struct. Its parse errors point at the offending line with a caret, which is most of why you would pick it.

One error type for applications: anyhow::Error holds any error, keeps the whole chain of causes, and lets ? work everywhere without writing a single From impl.

A derive for std::error::Error. Write the enum, put the message on each variant, and get Display, source() and the From conversions that make ? work — without the boilerplate, and without the macro appearing in your public API.

Command-line parsing from a struct definition: derive Parser, and the fields become flags and arguments with validation, --help, --version and error messages generated for you.

Case conversion between the shapes identifiers take: snake_case, camelCase, UpperCamelCase, kebab-case and the shouty variants — with one consistent rule for where a word begins.

Regular expressions with a linear-time guarantee: matching can never blow up exponentially, because the engine deliberately omits backreferences and lookaround.

A parser combinator library: build a parser from small functions that compose, instead of writing a state machine or reaching for a regex. Parsers are ordinary functions taking &mut Stream.

One enum — Left or Right — that lets a function return either of two unrelated types. It forwards Iterator, Read, Write, Future and Deref to whichever side it holds, so the branch disappears from the call site.

The SwissTable hash map that std::collections::HashMap is built from, available as a crate — for no_std code, custom allocators, the low-level HashTable, and lookups that don't allocate a key.

A hash map that remembers insertion order and can be indexed by position. Hash lookup like HashMap, deterministic iteration like a Vec, and sorting without changing the type.

Extra iterator adaptors, as one extension trait: grouping, chunking, deduplication, combinations, and the Result-aware adaptors that let a fallible pipeline stay a pipeline.

Pre-allocated storage that hands you a usize key for each value you insert. Constant-time insert, lookup and remove with no hashing and no per-element allocation — the structure behind connection tables and arenas.

A Vec that keeps its first few elements inline instead of on the heap, spilling only when it outgrows them. A targeted allocation optimisation for collections that are usually small.

A deep learning framework written in Rust: tensors, autodiff, neural network layers, optimizers, a training loop and model storage, with one model definition running on GPUs, CPUs and WebAssembly.

Linear algebra with dimensions in the type system: vectors, matrices, transformations and decompositions, where multiplying a 3×2 by a 4×4 is a compile error rather than a runtime one.

The numeric traits the standard library leaves out — Zero, One, Num, Float, PrimInt, and the checked, wrapping and saturating operations — so a function can be generic over number types.

Random numbers from a free function, with no setup and no dependencies — fastrand::u32(1..=6). Fast and simple, and explicitly not cryptographically secure.

Random number generation: a thread-local generator that needs no setup, seedable generators for reproducible runs, and the distributions and sequence operations — shuffle, choose, weighted pick — built on top.

The traits every RustCrypto hash implements. Write code once against Digest and it works with SHA-2, BLAKE2, SHA-3 or MD5 — and swapping the algorithm becomes a type parameter.

A fast non-cryptographic hash for hash maps and sketches, in two variants: one tuned for table lookup speed, one for statistical quality. It is hashbrown's default hasher, which is why it turns up everywhere.

The hasher rustc itself uses: a non-cryptographic hash tuned for speed on small integer keys, with a zero-sized BuildHasher and no randomness, so iteration order is reproducible.

The SHA-2 family — SHA-256, SHA-512 and the truncated variants — as pure-Rust implementations of the Digest traits, with hardware acceleration where the CPU offers it.

Raw declarations of the platform's C library — types, constants, structs and functions, exactly as C sees them. The bottom layer under every crate that talks to the operating system, and unsafe all the way down.

Byte buffers that slice and share without copying. Bytes clones by bumping a reference count, BytesMut splits a read buffer into frames, and the Buf/BufMut traits abstract over both.

Turns bytes into typed values without copying or unsafe. Derives prove at compile time that a type can be reinterpreted from a byte slice, so parsing a packet header is a cast rather than a field-by-field read.

Rust bindings for every JavaScript standard built-in — Array, Object, Map, Promise, JSON, Reflect, the typed arrays. The ECMAScript library, declared once so you need not write the extern blocks yourself.

The bridge between Rust compiled to WebAssembly and JavaScript. One attribute exports Rust functions, structs and methods to JS, and declares the JS functions Rust may call.

Joins Rust's async to JavaScript's promises: JsFuture makes a promise awaitable, spawn_local runs a future on the browser's event loop, and future_to_promise hands one back to JS.

Bindings for every browser API — the DOM, fetch, canvas, storage, events, WebGL — generated from the web platform's own WebIDL. Each type sits behind its own Cargo feature, and none are on by default.

Turns a set of named bits into a real type. The bitflags! macro generates a struct with typed set operations, so a permissions mask stops being a bare u32 that anything can be assigned to.

A TokenStream that works outside a procedural macro. Mirrors the compiler's proc_macro API so macro code can be unit tested, called from ordinary functions, and reused by build scripts.

Quasi-quoting for procedural macros: write the Rust you want to generate as Rust, and interpolate values into it with #name. The output half of every macro, opposite syn.

Parses a stream of Rust tokens into a syntax tree. The parsing half of every procedural macro — DeriveInput for derives, the Parse trait for custom syntax, and spanned errors that point at the user's code.

The logging facade the ecosystem agrees on. Libraries call info! and warn! against it; the application chooses one implementation, and every library's output goes there.

Compiles C, C++ and assembly from a build script and links the result into your crate. The standard way a Rust crate wraps existing native code — and the reason that crate needs a C compiler to build.

Parses and compares version numbers, and evaluates the requirement syntax Cargo uses — ^1.2, ~1.2.3, >=1.0, <2.0. The same implementation Cargo itself resolves dependencies with.