Rust Glossary
96 Rust terms explained plain: ownership, async, traits, macros and more.
[ A ]
Actix Web (Rust): Why It's the Fastest HTTP Framework
Actix Web is Rust's fastest HTTP framework, built on the Tokio async runtime. Learn what Actix is, how it works, when to use it, and how it compares to Axum.
anyhow (Rust): Error Context & vs thiserror Guide
anyhow simplifies Rust error handling with one dynamic error type for application code. Learn to propagate, wrap, and display errors without boilerplate.
Arc<T> in Rust: Thread-Safe Shared Ownership Guide
Arc<T> is Rust's thread-safe reference-counted pointer for shared ownership. Learn how it differs from Rc and pairs with Mutex for shared mutable state.
Argon2 (Rust): Password Hashing in Axum Guide 2026
Argon2 is the recommended password hashing choice in Rust. Learn how Argon2 works, when to use it, and how Argon2 vs bcrypt compares in 2026.
Associated Types in Rust: vs Generics Explained
Associated types let a trait define a placeholder type implementors must specify. Learn how they differ from generics and clean up trait APIs.
Async/Await in Rust: Runtimes & Concurrent Tasks
async/await in Rust lets you write non-blocking code that looks synchronous. Learn how Rust's async model works, how it differs from Go and Node.js, and when to use it.
async-trait (Rust): Async Fns in Traits Pre-1.75
async_trait is a macro that enables async fn in traits before Rust 1.75. Learn why it was needed and what changed with native async fn in traits.
Axum (Rust): Web Framework vs Actix, Rocket & Warp
Axum is a Rust web framework for APIs and backend services. Learn how Axum works, when to choose it, and how Axum vs Actix Web looks in 2026.
[ B ]
Bevy (Rust): ECS Game Engine & Ecosystem Guide 2026
Bevy is a data-driven Rust game engine using an Entity Component System (ECS). Learn how its ECS works and why it's Rust's most popular game engine.
Rust Borrow Checker: Rules & Common Errors Explained
The borrow checker is Rust's compiler system that enforces safe references. Learn how it works, what errors it prevents, and how to work with it effectively.
Box<T> in Rust: Heap Allocation & Deref Coercion
Box<T> is Rust's simplest smart pointer; it heap-allocates and owns a value. Learn how it enables recursive types, trait objects, and dynamic sizing.
[ C ]
Cargo (Rust): Commands, Cargo.toml & vs npm/pip
Cargo is Rust's official build tool and package manager. Learn how Cargo works, when to use it, and why Cargo vs npm or pip feels different in 2026.
Channels in Rust: Tokio Types & Backpressure Guide
Channels let async Rust tasks communicate by sending values without shared memory. Learn mpsc, oneshot, broadcast, and watch channel types.
chrono (Rust): Dates, Serde/SQLx Integration & vs time
chrono is Rust's classic crate for dates, times, and timezones. Learn how chrono works, when to use it, and how chrono vs time looks in 2026.
clap (Rust): Derive API, Subcommands & Env Vars Guide
clap is Rust's most popular CLI argument parser. Learn the derive API for commands, flags, and subcommands with automatic help text.
Clippy (Rust): Lints, Suppressing Warnings & CI Guide
Clippy is Rust's official linter, catching mistakes and suggesting idiomatic patterns beyond compiler checks. Learn to configure and fix its warnings.
Closures in Rust: Fn, FnMut, FnOnce & Iterators
Closures in Rust are anonymous functions that capture their environment. Learn how they capture by reference or value, and how Fn/FnMut/FnOnce differ.
Const Generics in Rust: vs Type Generics Explained
Const generics parameterize types and functions over constant values like array lengths. Learn how to use them and where std relies on them.
const vs static in Rust: const fn & Global State
const inlines a value at each use site; static holds one value at a fixed memory address. Learn the difference and how static mut works.
Copy vs Clone in Rust: Key Differences Explained
Copy and Clone control how Rust values duplicate. Copy is implicit and cheap; Clone is explicit and may allocate. Learn when each applies.
Criterion (Rust): Benchmarking & black_box Guide 2026
Criterion is Rust's standard benchmarking library. Learn how to write benchmarks, measure throughput, and avoid dead code elimination pitfalls.
[ D ]
#[derive] in Rust: Traits, Serde & Custom Macros
#[derive] generates trait implementations like Debug, Clone, and Serialize automatically. Learn which traits you can derive and when to implement manually.
Diesel (Rust) ORM: CLI, Async & vs SQLx Guide
Diesel is Rust's compile-time safe ORM and query builder. Learn how it compares to SQLx for schema-driven, type-checked queries.
Dioxus (Rust): Cross-Platform UI vs Leptos & Yew
Dioxus is a Rust UI framework for web, desktop, and mobile apps. Learn how Dioxus works, when to use it, and how Dioxus vs Leptos looks in 2026.
Display vs Debug in Rust: dbg!() & Error Types Guide
Display and Debug are Rust's two formatting traits. Learn the difference between {} and {:?}, and when to implement each for your types.
dyn Trait in Rust: Object Safety & Box<dyn Error>
dyn Trait is Rust's syntax for trait objects and dynamic dispatch. Learn when to use dyn vs generics, and what object safety means.
[ E ]
Rust Enums: Option, Result & Pattern Matching Guide
Rust enums hold data in each variant, unlike enums in most languages. Learn how pattern matching works, and how Option and Result use them.
Error Handling in Rust: thiserror, anyhow, and the ? Operator
Rust handles errors with Result<T, E> and the ? operator, no exceptions. Learn thiserror for library errors and anyhow for application errors.
[ F ]
Cargo Feature Flags: ssr Pattern & Workspaces Guide
Feature flags let Rust crates compile optional code and dependencies. Learn how Cargo features work and feature flags vs runtime flags in 2026.
From and Into in Rust: vs TryFrom/TryInto Guide
From and Into are Rust's standard traits for type conversion. Learn to implement From<T> and use Into<T> in idiomatic function signatures.
Future in Rust: Polling & Combining Futures Explained
A Future in Rust represents a value available later; the building block of async code. Learn how polling works and how executors drive futures.
[ G ]
[ H ]
HashMap in Rust: Ownership, Iterators & Map Types
HashMap<K, V> is Rust's key-value collection with O(1) average lookup. Learn how to create, query, and update maps under ownership rules.
Hyper (Rust): Low-Level HTTP Server & Client Guide
hyper is Rust's low-level HTTP library that Axum, Reqwest, and Warp are built on. Learn what it does and when to use it directly.
[ I ]
if let in Rust: while let, let-else & match Guide
if let is Rust's concise syntax for matching one pattern with destructuring. Learn how it compares to match, while let, and let-else.
impl Trait in Rust: Argument, Return & Async Fn Use
impl Trait lets you return or accept a type implementing a trait without naming it. Learn impl Trait (static dispatch) vs dyn Trait (dynamic).
Interior Mutability in Rust: Cell, RefCell & Mutex
Interior mutability lets you mutate data through a shared reference in Rust. Learn how RefCell, Cell, and Mutex implement it, and why.
Iterators in Rust: Adapters & Custom Iterator Guide
Iterators in Rust are lazy, composable sequences: .map(), .filter(), .collect(). Learn how the Iterator trait chains adapters at zero cost.
[ L ]
Leptos (Rust): Full-Stack SSR Framework vs Dioxus
Leptos is a Rust full-stack web framework for SSR and WebAssembly apps. Learn how Leptos works, when to use it, and how Leptos vs Dioxus looks in 2026.
Lifetimes in Rust: Elision & 'static Explained
Lifetimes track how long references stay valid in Rust. Learn what lifetime annotations mean and how to read common lifetime errors.
[ M ]
macro_rules! in Rust: Metavariables & vs Proc-Macro
macro_rules! defines pattern-based macros that expand at compile time. Learn the syntax and when to use it over functions or proc-macros.
Rust Macros: macro_rules!, Proc Macros & vs C Macros
Rust macros are code that writes code: macro_rules! for declarative patterns, proc macros for derive and attributes. Learn when to use each.
Middleware in Rust: Axum, Actix & Tower Service Guide
Middleware in Rust web frameworks intercepts HTTP requests and responses. Learn how middleware works in Axum and Actix Web, with real Rust code examples.
mockall (Rust): Mocking Async Traits Guide 2026
mockall is Rust's most popular mocking library, generating mock trait implementations automatically. Learn to set expectations and verify behavior.
Rust Modules: pub, use & Project Structure Guide
Rust modules organize code into namespaced units and control visibility with pub. Learn how mod, use, pub, and crate paths work in 2026.
mpsc in Rust: Bounded vs Unbounded Channels
mpsc is Rust's standard multi-producer, single-consumer channel. Learn std::sync::mpsc vs tokio::sync::mpsc and when to choose each.
Mutex<T> in Rust: RwLock, Data Races & Deadlocks
Mutex<T> gives exclusive access to shared mutable data across Rust threads. Learn how it pairs with Arc and prevents data races at compile time.
[ O ]
OnceLock & LazyLock in Rust: vs lazy_static! Guide
OnceLock and LazyLock give safe lazy initialization for Rust statics. Learn how they replace lazy_static and how OnceCell differs.
Option in Rust: Methods, the ? Operator & vs Null
Option<T> represents values that may or may not exist, replacing null entirely. Learn Option's key methods and common patterns.
Rust Ownership: Move vs Copy & No Garbage Collection
Ownership is Rust's memory management system, no garbage collector, no manual malloc/free. Learn what ownership means, the three rules, and why it matters.
[ P ]
Panic in Rust: vs Result & Handling in Web Servers
A panic in Rust is an unrecoverable error that unwinds the stack. Learn how it differs from Result and when to use each in production.
Pattern Matching in Rust: match, if let & vs Switch
Pattern matching in Rust is exhaustive and compile-time verified. Learn match, if let, while let, and destructuring beyond switch statements.
Pin<T> in Rust: Unpin & Pin Projection Explained
Pin<T> stops a value from moving in memory once pinned; essential for async state machines. Learn why Pin exists and when you need it.
Polars (Rust): Lazy API & vs pandas DataFrame Guide
Polars is a blazing-fast Rust DataFrame library, also usable from Python. Learn data manipulation, filtering, and how it compares to pandas.
Procedural Macros in Rust: syn, quote & vs macro_rules!
Procedural macros let you write Rust code that generates code at compile time. Learn the three types: derive, attribute, and function-like.
proptest (Rust): Property Testing & Shrinking Guide
proptest generates random inputs to find edge cases unit tests miss. Learn to write property tests with proptest strategies.
PyO3 (Rust): Python Bindings vs ctypes & CFFI
PyO3 lets you write Python extensions in Rust or call Python from Rust. Learn to expose functions and build native modules with maturin.
[ R ]
rand Crate (Rust): Shuffling, Sampling & RNGs Guide
The rand crate is Rust's standard random number library. Learn to generate numbers, shuffle collections, and choose between RNGs.
Rayon (Rust): Parallel Iterators vs Tokio Guide
Rayon is Rust's data parallelism library: change .iter() to .par_iter() and run across all CPU cores. Learn how it compares to async Rust.
Rc<T> in Rust: vs Arc & Weak References Explained
Rc<T> is Rust's reference-counted pointer for single-threaded shared ownership. Learn how it differs from Arc and pairs with RefCell.
RefCell<T> in Rust: Borrow Rules & vs Mutex Guide
RefCell<T> is Rust's escape hatch for interior mutability through a shared reference. Learn how it works and how it differs from Mutex.
References in Rust: &T, &mut T & Deref Coercion
References in Rust let you borrow a value without taking ownership. Learn &T vs &mut T, borrow checker rules, and how lifetimes relate.
regex Crate (Rust): Capture Groups & Performance Guide
The regex crate is Rust's fast, safe library guaranteed to run in linear time. Learn to match, search, capture, and replace text patterns.
Reqwest (Rust): JSON Requests & Reusable Client Guide
Reqwest is Rust's most popular async HTTP client; built on Tokio and Hyper. Learn how to make GET and POST requests, handle JSON, set headers, and manage timeouts with Reqwest.
Result in Rust: Custom Errors & vs Panics Explained
Result<T, E> is Rust's error handling type: an enum with Ok(T) for success and Err(E) for failure. Learn how to use Result, the ? operator, and idiomatic error handling.
Rocket (Rust): Request Guards & vs Axum/Actix Guide
Rocket is a Rust web framework known for its ergonomic API and request guards. Learn how it compares to Axum and Actix, and build your first app.
rustls: HTTPS for Axum & Reqwest in Rust Guide
rustls is a modern, memory-safe TLS library written in pure Rust with no C dependencies. Learn how it enables HTTPS with Axum and Reqwest.
rustup: Toolchains, Cross-Compilation & Channels Guide
rustup is Rust's official toolchain manager: installs Rust, adds cross-compile targets, and switches stable, beta, and nightly channels.
RwLock<T> in Rust: vs Mutex & Writer Starvation
RwLock<T> allows many concurrent readers or one writer; more efficient than Mutex for read-heavy workloads. Learn writer starvation risks.
[ S ]
SeaORM (Rust): Async ORM vs Diesel & SQLx
SeaORM is an async ORM for Rust that supports PostgreSQL, MySQL, and SQLite. Learn how it compares to Diesel and SQLx, how to define entities, run migrations, and query the database.
tokio::select! (Rust): Guide & Docs 2026
tokio::select! waits on multiple async operations and runs whichever finishes first. Learn cancellation safety and common select! pitfalls.
Send and Sync in Rust: 'Future is not Send' Explained
Send and Sync are Rust's thread-safety marker traits. Send moves a type across threads; Sync shares it. Learn why the compiler enforces both.
Serde (Rust): Custom Behavior & Supported Formats Guide
Serde is Rust's de-facto serialization framework for JSON, TOML, YAML, and more with zero-copy efficiency. Learn how it works.
serde_json (Rust): Dynamic JSON & Error Handling Guide
serde_json is Rust's standard crate for JSON. Learn to serialize structs, deserialize into typed structs, and work with dynamic Value.
Slices in Rust: &[T] vs &Vec<T> & Indexing Guide
A slice borrows a contiguous sequence from a Vec, array, or String without copying. Learn how slices work and how indexing applies.
tokio::spawn: vs spawn_blocking & Task Cancellation
tokio::spawn runs async tasks concurrently on the Tokio runtime. Learn how tokio::spawn works and tokio::spawn vs spawn_blocking in 2026.
SQLx (Rust): Migrations & vs Diesel Guide 2026
SQLx is Rust's async SQL toolkit with compile-time checked queries. Learn how SQLx works, when to use it, and SQLx vs Diesel in 2026.
Stream in Rust: Sources & vs Iterator Explained
Stream is Rust's async version of Iterator, producing values over time. Learn tokio_stream and how to create and consume async streams.
String vs &str in Rust: Key Differences Explained
Rust has two string types: owned String and borrowed &str. Learn when to use each, how to convert between them, and why both are UTF-8.
Structs in Rust: Kinds, Derive & Ownership Guide
Structs in Rust group related fields into named types. Learn to define structs, add methods with impl, and derive common traits.
[ T ]
Tauri (Rust): Lightweight Desktop Framework vs Electron
Tauri is a Rust framework for desktop apps with a web UI. Learn how Tauri works, when to use it, and how Tauri vs Electron looks in 2026.
thiserror (Rust): #[from] & vs anyhow Guide 2026
thiserror is a derive macro that eliminates boilerplate when defining custom error types. Learn to generate Display, Error, and From impls.
Tokio: Rust's Async Runtime & Ecosystem Guide 2026
Tokio is Rust's most widely used async runtime. Learn what Tokio is, how it powers async/await in Rust, how its scheduler works, and when to use it.
Tonic (Rust): gRPC Services vs Axum & Actix Guide
Tonic is Rust's leading gRPC framework built on Tokio. Learn to define services with Protocol Buffers and generate Rust code with prost.
Topcoat (Rust): Full-Stack Framework vs Leptos & Dioxus
Topcoat is an experimental Rust full-stack web framework with SSR, server-driven reactivity, and built-in UI tooling. Learn Topcoat vs Leptos and Dioxus in 2026.
Tower (Rust): Service Trait & tower-http Guide 2026
Tower defines the Service trait, the common abstraction for middleware, clients, and servers across Rust's async ecosystem. Learn how it works.
tracing (Rust): Spans, Subscribers & vs log Guide
tracing is Rust's structured, async-aware logging framework. Learn how spans, events, and subscribers work compared to the log crate.
Traits in Rust: Bounds, Objects & Std Traits Guide
Traits define shared behavior in Rust; similar to interfaces in other languages but more powerful. Learn what traits are, how to implement them, and when to use them.
[ U ]
unsafe in Rust: Raw Pointers & Safe Abstractions Guide
unsafe opts out of certain compiler checks for a specific block of code. Learn the five unsafe superpowers and how to wrap them safely.
uuid Crate (Rust): v4 vs v7 & Serde/SQLx Guide
The uuid crate generates and parses UUIDs in Rust. Learn UUID v4 vs v7, and how to use them with serde and sqlx as database primary keys.
[ V ]
[ W ]
wasm-bindgen: JS Interop & vs wit-bindgen Guide 2026
wasm-bindgen connects Rust WebAssembly modules to JavaScript. Learn to export Rust functions, import JS APIs, and pass complex types.
Rust and WebAssembly: Compiling & vs JavaScript Guide
Rust compiles to WebAssembly, running near-native speed code in the browser. Learn what wasm-bindgen does and when to reach for Rust over JS.
Cargo Workspaces: Shared Deps & Multi-Crate Commands
A Cargo workspace groups multiple related crates into one project with a shared lock file and build cache. Learn to set one up and share deps.