Skip to content
Learn Rust
Theme

The crates everyone uses

Rust’s standard library has less in it than you may be used to. Its list of all items has TCP and UDP sockets, a Future trait, and Instant, SystemTime and Duration for time. When I looked on 25 October 2026 it had no JSON, regular-expression, HTTP, UUID or calendar items, and nothing that runs futures for you. Those jobs come from crates. A tour of the standard library covers what std does have, and Finding and using crates covers how to add one.

RememberFind your job in the table, read what the crate says it is with cargo info <name>, then cargo add it.

The map

Section titled “The map”

In the Rust column, a name links to this site’s page when there is one, and to docs.rs when there isn’t (reqwest links to the axum page, where its client is used). “Usual” is my judgement, not a ranking. As a check on it, here are all-time downloads from the crates.io API on 25 October 2026: from 16 million (polars) to 1.7 billion (thiserror). diesel, SeaORM, datafusion, polars and tantivy are under 50 million, so read those rows as “an option”, not “the standard”.

In the other columns, “built in” means it ships with the language or its runtime. Most of those cells I ran, in the image behind this site, but a few built-in ones I did not (the last section says which, and what each run covers: what I ran, and what I only checked). The rest are library names that I checked exist; I did not run them. A Go module path can end in a version, such as /v2 (duckdb-go) or /v18 (arrow-go), so copy the path from the project’s own README before go get.

What each crate says it is

Section titled “What each crate says it is”

This is each Rust crate’s own description, read by cargo info from the crate’s Cargo.toml. It is what the authors wrote, not a review, and the descriptions change when authors change them. Some say what the crate does and some barely do (thiserror is derive(Error)), so open the docs before you depend on one. The docs for tantivy say “Think Lucene, but in Rust”, which is why Lucene sits next to it in the table.

terminal
$ cargo info <crate>    # once per crate; the description sits between the name and the version
serde: A generic serialization/deserialization framework 
serde_json: A JSON serialization file format 
tokio: An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications. 
axum: HTTP routing and request handling library that focuses on ergonomics and modularity 
reqwest: higher level HTTP client library 
tonic: A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility. 
prost: A Protocol Buffers implementation for the Rust Language. 
sqlx: 🧰 The Rust SQL Toolkit. An async, pure Rust SQL crate featuring compile-time checked queries without a DSL. Supports PostgreSQL, MySQL, and SQLite. 
diesel: A safe, extensible ORM and Query Builder for PostgreSQL, SQLite, and MySQL 
sea-orm: 🐚 An async & dynamic ORM for Rust 
clap: A simple to use, efficient, and full-featured Command Line Argument Parser 
anyhow: Flexible concrete Error type built on std::error::Error 
thiserror: derive(Error) 
tracing: Application-level tracing for Rust. 
proptest: Hypothesis-like property-based testing and shrinking. 
insta: A snapshot testing library for Rust 
chrono: Date and time library for Rust 
jiff: A date-time library that encourages you to jump into the pit of success.  This library is heavily inspired by the Temporal project. 
regex: An implementation of regular expressions for Rust. This implementation uses finite automata and guarantees linear time matching on all inputs. 
uuid: A library to generate and parse UUIDs. 
rayon: Simple work-stealing parallelism for Rust 
datafusion: DataFusion is an in-memory query engine that uses Apache Arrow as the memory model 
polars: DataFrame library based on Apache Arrow 
tantivy: Search engine library

Five of them in one program

Section titled “Five of them in one program”

The pages above cover most of these crates. regex, chrono, jiff and uuid have no page of their own, so here is a first line of each, run at the versions in Cargo.lock, plus a first line of rayon, which has its own page.

Rust
[package]
name = "crates-map"
version = "0.1.0"
edition = "2024"


[dependencies]
chrono = "0.4.45"
jiff = "0.2.38"
rayon = "1.12.0"
regex = "1.13.1"
uuid = "1.29.0"
$ cargo run
regex:  year 2026, month 10, day 25
chrono: Sun
jiff:   Sunday
uuid:   version 4
rayon:  338350

The rayon line (more on the rayon page, and on mixing it with async code on the Rayon and Tokio together page) sums the squares from 1 to 100 on its thread pool and asserts that the plain iterator gives the same total. It says nothing about speed. Both date crates agree on the weekday of 25 October 2026.

Try it yourself

Section titled “Try it yourself”

I did both in the image behind this page.

  1. Read a crate’s features before you add it. Run cargo info uuid in any folder. Under features: the default is only std, and v4 = [rng] is a separate switch.

    terminal
    $ cargo info uuid
uuid #guid #unique #uuid
A library to generate and parse UUIDs.
version: 1.29.0
license: Apache-2.0 OR MIT
rust-version: 1.89.0
documentation: https://docs.rs/uuid
repository: https://github.com/uuid-rs/uuid
crates.io: https://crates.io/crates/uuid/1.29.0
features:
 +default               = [std]
  std                   = [wasm-bindgen?/std, js-sys?/std]
  arbitrary             = [dep:arbitrary]
  atomic                = [dep:atomic]
  borsh                 = [dep:borsh, dep:borsh-derive]
  bytemuck              = [dep:bytemuck]
  fast-rng              = [rng, dep:rand]
  js                    = [dep:wasm-bindgen, dep:js-sys]
  macro-diagnostics     = []
  md5                   = [dep:md-5]
  rng                   = [dep:getrandom]
  rng-getrandom         = [rng, dep:getrandom, uuid-rng-internal-lib, uuid-rng-internal-lib/getrandom]
  rng-rand              = [rng, dep:rand, uuid-rng-internal-lib, uuid-rng-internal-lib/rand]
  serde                 = [dep:serde_core]
  sha1                  = [dep:sha1_smol]
  slog                  = [dep:slog]
  uuid-rng-internal-lib = [dep:uuid-rng-internal-lib]
  v1                    = [atomic]
  v3                    = [md5]
  v4                    = [rng]
  v5                    = [sha1]
  v6                    = [atomic]
  v7                    = [rng]
  v8                    = []
  zerocopy              = [dep:zerocopy]

  2. Switch one on. Call Uuid::new_v4() in a project that depends on uuid as above. cargo build fails with E0599, “no associated function or constant named new_v4”. cargo add uuid --features v4 turns the feature on, and the program builds and prints version 4. The uuid docs show the same features = ["v4"] line. See Features in the Cargo Book.

    terminal
    $ cargo build
error[E0599]: no associated function or constant named `new_v4` found for struct `Uuid` in the current scope
   --> src/main.rs:4:20
    |
  4 |     let id = Uuid::new_v4();
    |                    ^^^^^^ associated function or constant not found in `Uuid`
  ... (notes pointing into library source code trimmed)
$ cargo add uuid --features v4
    Updating crates.io index
      Adding uuid v1.29.0 to dependencies
             Features:
             + rng
             + std
             + v4
             - arbitrary
             - atomic
             - borsh
             - bytemuck
             - fast-rng
             - js
             - macro-diagnostics
             - md5
             - rng-getrandom
             - rng-rand
             - serde
             - sha1
             - slog
             - uuid-rng-internal-lib
             - v1
             - v3
             - v5
             - v6
             - v7
             - v8
             - zerocopy
     Locking 2 packages to highest Rust 1.99.1 compatible versions
      Adding getrandom v0.4.3
      Adding r-efi v6.0.0
$ cargo run
version 4

What I ran, and what I only checked

Section titled “What I ran, and what I only checked”

For the Rust crates: the descriptions above come from cargo info, and the five-crate program above was built and run. The crates that have their own page were run there. I did not run diesel, sea-orm, proptest, insta, polars or tantivy. For them I have only the description and, for the last four, the front page of their docs.rs documentation.

For the other languages, I ran one small program per language to check that most of the built-in names exist in the image (Go 1.27, Python 3.13, Node, Java 25, Kotlin, .NET 10, gcc 14). Some built-in cells were not part of those runs: TypeScript’s JSON, Date, RegExp and Error with a cause, C#’s async/await with Task, Go’s sync.WaitGroup and fmt.Errorf (for Go I only read the first line of go doc sync and go doc errors), and Kotlin’s Result. They are standard features, but I did not run them. For C++, <execution> only compiles; it does not link and run here.

The runs
terminal
$ go doc <package>    # once per package
package json // import "encoding/json"
package http // import "net/http"
package sql // import "database/sql"
package flag // import "flag"
package errors // import "errors"
package slog // import "log/slog"
package testing // import "testing"
package time // import "time"
package regexp // import "regexp"
package sync // import "sync"
$ python3 check.py
Python: imported argparse, asyncio, concurrent.futures, datetime, json, logging, multiprocessing, re, unittest, uuid
$ node check.js
TypeScript/Node: function fetch, function crypto.randomUUID, function worker_threads.Worker, function node:test, object Intl
$ javap -public <class>    # once per class
public abstract class java.net.http.HttpClient implements java.lang.AutoCloseable {
public interface java.sql.Connection extends java.sql.Wrapper,java.lang.AutoCloseable {
public final class java.util.UUID implements java.io.Serializable, java.lang.Comparable<java.util.UUID> {
public final class java.util.regex.Pattern implements java.io.Serializable {
public final class java.time.LocalDate implements java.time.temporal.Temporal,java.time.temporal.TemporalAdjuster,java.time.chrono.ChronoLocalDate,java.io.Serializable {
$ javap -public java.lang.Thread java.util.Collection
  public static java.lang.Thread$Builder$OfVirtual ofVirtual();
  public default java.util.stream.Stream<E> parallelStream();
$ kotlinc check.kt -include-runtime -d check.jar && java -jar check.jar
Kotlin: Regex 2026-10-25, parallelStream total 55
$ dotnet run
C#: Guid 67e55044, JsonSerializer {"a":1}, Regex 2026-10-25, Parallel.For total 45, PLINQ total 45, HttpClient HttpClient, DateTime Sunday
$ gcc -Wall -Wextra check.c -o check_c && ./check_c
C: regcomp/regexec matched, getopt returned -1, struct tm weekday 0 (0 = Sunday), syslog declared
$ g++ -std=c++23 -Wall -Wextra check.cpp -o check_cpp && ./check_cpp
C++: regex 2026-10-25, chrono weekday 0 (0 = Sunday), expected not a number
$ g++ -std=c++17 -fsyntax-only par.cpp
par.cpp compiles with -std=c++17

Everything else in the other columns is a name only. I looked each one up and it exists: the npm, PyPI, Go module proxy, NuGet and Maven Central registries answered for the libraries on those, and the C and C++ libraries have a live home page or repository. The registry checks show the name exists. They do not show the library is maintained or a good choice. The JVM libraries, kotlinx.coroutines among them, were looked up on Maven Central only.

Read more

Section titled “Read more”

Learn Rust is an independent project, not affiliated with the Rust Project or the Rust Foundation. Code and text are under the MIT licence.Source on GitHub.