Skip to content
←

필사 모드: A Tour of the Rust Ecosystem: Great Crates and Projects

English
0%
정확도 0%
💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

Introduction — The Ecosystem Over the Language

When we talk about Rust, we usually reach first for language features: ownership, the borrow checker, memory safety. But what makes a language usable in practice is not syntax alone. Is there a library that already does the thing you need well? How easily can you pull it in? The maturity of the ecosystem is the crux.

On this front, Rust has grown dramatically over the past few years. Since the 1.0 release in 2015, crates.io has accumulated hundreds of thousands of crates, and several of them have become the de facto standard in their domains. This post is a map that tours those flagship crates and famous projects. It focuses on "what each crate is for," so it should help you get a feel for where to look when you start something in Rust.

cargo and crates.io — The Foundation of the Ecosystem

Before talking about crates, we should cover the foundation that makes them possible. A big part of why Rust's ecosystem matured so quickly is that a well-designed toolchain existed from the start.

cargo is Rust's official build tool and package manager. Creating a project (cargo new), building (cargo build), testing (cargo test), running (cargo run), and dependency management are all handled through one consistent command. Compared with languages where the build tool, package manager, formatter, and test runner are all separate, a single unified experience dramatically lowers the barrier to entry.

crates.io is the public crate registry. Write a crate name and version in Cargo.toml, and cargo downloads and builds it for you. Combine that with semantic versioning and a lock file (Cargo.lock), and reproducible builds are guaranteed by default.

[dependencies]
serde = { version = "1", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

That one simple declaration pulls in a library and its entire transitive dependency tree. Every crate introduced below ultimately sits on top of these two tools.

Foundational Crates — serde and tokio

Open almost any Rust project and two crates show up nearly every time. They are the pillars that hold up the floor of the ecosystem.

serde is a serialization/deserialization framework. Just by attaching a derive macro to a struct, it converts to and from countless formats: JSON, YAML, TOML, MessagePack, and more. Its core design separates the "data model" from the "format," which lets you handle the same type across many formats.

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct Config {
    name: String,
    port: u16,
}

// This type now moves freely to and from JSON, YAML, TOML, and so on
let cfg: Config = serde_json::from_str(r#"{"name":"web","port":8080}"#)?;

tokio is Rust's async runtime. Rust keeps the async/await syntax in the language but leaves the runtime that actually schedules and executes those tasks to a library. tokio is the de facto standard for that runtime, providing an async task scheduler, non-blocking I/O, timers, channels, and more. Many of the network, web, and DB crates you will see below run on top of tokio.

#[tokio::main]
async fn main() {
    let handle = tokio::spawn(async {
        // An async task that runs concurrently
        "done"
    });
    println!("{}", handle.await.unwrap());
}

Parallelism and Data — rayon and polars

One of Rust's strengths is "fearless concurrency." Because the type system prevents data races at compile time, you can write parallel code with far more confidence. The crate that best showcases this strength is rayon.

rayon is a data parallelism library. What is striking is how simple it is to use. Just change a sequential iterator (iter) to a parallel iterator (par_iter), and collection processing is automatically distributed across multiple cores.

use rayon::prelude::*;

// iter() -> par_iter(): a one-word change for parallel processing
let sum: u64 = (0..1_000_000)
    .into_par_iter()
    .filter(|n| n % 3 == 0)
    .map(|n| n as u64)
    .sum();

Internally, a work-stealing scheduler spreads the load evenly across cores. The correctness of the parallelization is guaranteed by Rust's type system, so you can chase performance without worrying about data races.

polars is a high-performance dataframe library. It occupies the position that pandas holds in Python, but it combines Apache Arrow-based columnar storage with lazy evaluation and query optimization, making it very fast on large data. You can use it directly from Rust, and its Python bindings are widely used too, so it is steadily growing its presence in the data analysis world.

Networking and Web — reqwest, hyper, axum

The web is a big area in any language, and in Rust this layer is well organized.

hyper is a low-level HTTP library. It is a correct and fast implementation of HTTP/1 and HTTP/2 that supports both client and server. It is low-level to use directly, but the higher-level crates below are built on top of hyper.

reqwest is an easy-to-use HTTP client that wraps hyper. It handles JSON requests/responses, cookies, redirects, and TLS with a concise API. It is the first crate you reach for when doing the everyday task of "calling another service's API."

let body: serde_json::Value = reqwest::get("https://api.example.com/status")
    .await?
    .json()
    .await?;

axum is a web framework built by the tokio team. It is built on top of hyper and tower (a middleware abstraction), and it expresses routing and request parsing through a type-safe "extractor" style. A defining trait is that you write handlers with ordinary functions and types rather than relying on macros.

use axum::{routing::get, Router};

async fn hello() -> &'static str {
    "Hello, world!"
}

let app = Router::new().route("/", get(hello));

Databases and CLIs — sqlx, diesel, clap

An application usually needs a database and a command-line interface. Rust has mature options for both.

For database access, there are two main camps. sqlx is an async SQL toolkit that, interestingly, checks your SQL queries against the actual database schema at compile time. That means it catches a wrong column name or a type mismatch during the build. diesel, by contrast, is a full ORM and query builder that assembles queries type-safely in Rust code. sqlx fits when you want to write SQL directly but still have it verified; diesel fits when you want ORM-style abstraction.

clap (Command Line Argument Parser) is the de facto standard for parsing command-line arguments. Attach a derive macro to a struct, and it auto-generates the parser, the help text, and subcommands from your argument definitions.

use clap::Parser;

#[derive(Parser)]
struct Cli {
    /// The input file to process
    path: String,
    /// Whether to print verbose output
    #[arg(short, long)]
    verbose: bool,
}

let cli = Cli::parse(); // --help is generated automatically too

Graphics and Apps — Bevy, wgpu, Tauri

As befits a systems language, Rust has also produced interesting projects in graphics and application development.

wgpu is a cross-platform graphics API. It is based on WebGPU, the browser standard, and behind it maps to each platform's native graphics backend, such as Vulkan, Metal, or DirectX 12. Its strength is the portability of driving GPUs on many platforms from a single codebase.

Bevy is a game engine written in Rust. Its defining feature is that it foregrounds an ECS (Entity Component System) architecture, where data-oriented design meshes well with Rust's parallelism. It is open source and actively developed, and it is used not only for games but also for simulations and interactive applications.

Tauri is a framework for building desktop (and mobile) apps. Its purpose is similar to Electron, but its approach differs. Where Electron bundles an entire Chromium browser with every app, Tauri uses the system webview provided by the operating system and puts the backend in Rust. The result is a much smaller binary size and memory footprint. You write the frontend in familiar web technologies, and Rust handles the heavy logic and system access.

Famous Projects — What Rust Has Left in the World

If crates are parts, the finished products made from those parts also show Rust's standing well. Let us look at a few widely known projects.

  • ripgrep (rg): A blazing-fast code search tool written in Rust. It combines a regex engine, parallel traversal, and .gitignore awareness to achieve astonishing speed on large codebases. Many developers use it daily as a grep replacement, and VS Code's search feature uses ripgrep internally.
  • Deno: A JavaScript/TypeScript runtime built by the creator of Node.js. Its core is written in Rust and embeds the V8 engine. It emphasizes security by default (a permission model) and first-class TypeScript support.
  • Firecracker: A lightweight virtualization technology (microVM) built by AWS. Written in Rust, it serves as the isolation foundation for serverless (AWS Lambda) and container services. As a lightweight VM that boots in tens of milliseconds, it aims for secure isolation and fast startup at the same time.
  • Rust support in the Linux kernel: Starting with Linux 6.1 in 2022, the groundwork for using Rust in the kernel was merged. It was a symbolic event for Rust to enter a domain dominated by C for decades, primarily an effort to gain memory safety in areas such as new drivers.

Beyond these, Rust is used across many fields: several Firefox components, packaging tools, web servers, blockchains, embedded systems, and more. The common thread is that it is especially strong "where performance and safety both matter at once."

Try It Yourself

The crates and projects surveyed here all stand on the foundation of the Rust language itself. Once you get a feel for concepts like ownership, traits, and enums, it becomes clearer why the ecosystem is shaped the way it is. If you want to experiment with Rust's core concepts directly in code, you can explore them with this site's Rust Learning Lab. Rust is also a leading language in the WebAssembly world, and just as wgpu builds on WebGPU, the web is an important stage for Rust. If you are curious how WebAssembly works, you can examine its structure in WebAssembly Principles.

Conclusion

Rust's power does not stop at the language. On top of a well-built foundation of cargo and crates.io, there is a layered stack: foundational crates like serde and tokio, data and parallelism tools like rayon and polars, a web layer running through reqwest, hyper, and axum, application parts like sqlx, diesel, and clap, and graphics and app frameworks like Bevy, wgpu, and Tauri.

And from those parts, real tools like ripgrep, Deno, and Firecracker were built, and Rust finally set foot even in the Linux kernel. The common thread running through all of it is that Rust shines especially where you want code that is both fast and safe.

When you start something new, I hope this map serves as a signpost for where to look first. The crate you need probably already exists, and one line of cargo brings it into your hands.

References

현재 단락 (1/88)

When we talk about Rust, we usually reach first for language features: ownership, the borrow checker...

작성 글자: 0자원문 글자: 9,959자작성 단락: 0/88