Build a Disk Usage Analyzer in Rust Like du and ncdu
du walks a tree and adds up file sizes. The interesting decisions are hard links counted once, symlinks left alone and how to keep going when a directory is unreadable.
CLI
16 min read
Read itGuides
Explore various tutorials from the learning catalog.
The rest of the guides
CLI
Build a Fuzzy Finder in Rust With Crossterm and Nucleo
A fuzzy finder reads lines, filters them as you type and prints the one you pick. The pieces are raw mode input, a matching engine and a small redraw loop.
21 min read
CLI
Build a Markdown to HTML Converter CLI in Rust With Pulldown
pulldown-cmark turns Markdown into a stream of events, and its HTML writer renders them. A small CLI adds file handling, options and a page template around it.
20 min read
CLI
Build a jq Style JSON Query Tool in Rust Step by Step
A jq clone needs three parts: a parser for a small path language, an evaluator over serde_json values and a printer. The core is about 150 lines.
16 min read
DevOps
eBPF and Rust With Aya for Observability Tools Step by Step
Aya lets you write both the eBPF program and its loader in Rust. A small tracepoint program counts syscalls and a user space process reads the counters from a map.
14 min read
Tooling
Editing Rust in Neovim With LSP and Treesitter Setup
Neovim talks to rust-analyzer through its built-in LSP client. A short config gives completion, diagnostics, formatting and Treesitter highlighting, and rustaceanvim adds Rust extras.
14 min read
DevOps
Rust Dev Containers for VS Code and Reproducible Setup
A dev container puts the toolchain, system libraries and services in a Docker image that the editor attaches to. A new contributor opens the folder and everything works.
13 min read
Testing
Continuous Integration for Rust Test Format Lint Build
A good Rust pipeline runs the same few checks in the same order every time. Format, clippy, tests, docs and a cache cover most projects in about forty lines of YAML.
14 min read
Databases
Vector Search From Rust With pgvector and Embeddings
pgvector adds a vector type and nearest-neighbor operators to Postgres. From Rust you store embeddings as arrays, index them with HNSW and query with an ORDER BY on distance.
18 min read
Systems
Node Addons in Rust With Napi rs for JavaScript Speed
napi-rs generates a Node-API addon from annotated Rust. Functions become JavaScript functions, async work runs on a thread pool, and TypeScript types come for free.
19 min read
Systems
Python Extensions in Rust With PyO3 and Maturin Step by Step
PyO3 turns Rust functions and structs into Python modules, and Maturin builds and publishes them as wheels. A hot loop moves to Rust and the rest of the program stays Python.
18 min read
Systems
Safe Rust Bindings for a C Library a Worked Example
A good binding is two crates. The sys crate mirrors the C header exactly, and the safe crate hides the pointers behind types that cannot be misused.
19 min read
Systems
Calling Rust From C With Cbindgen and Staticlib Step by Step
To expose Rust to C, mark functions extern "C" with a stable name, build a staticlib or cdylib and let cbindgen write the header. The rules are about layout, ownership and panics.
17 min read
Systems
Calling C From Rust With Extern and Bindgen Step by Step
Rust calls C through extern declarations that you write or generate. bindgen reads a header and produces them, leaving you to wrap the unsafe calls in a safe API.
17 min read
Systems
Writing a Safe Wrapper Around Unsafe Code in Rust Explained
The goal of unsafe code is to contain it. A safe wrapper has a small unsafe core, private fields that protect invariants and an API that cannot be misused from safe code.
15 min read
Systems
Writing a Custom Global Allocator in Rust to Track Memory
A global allocator is a type implementing GlobalAlloc, registered with one attribute. Wrapping the system allocator with atomic counters gives you live memory numbers.
19 min read
Systems
Rust Firmware Size Optimization Down to Tens of Kilobytes
Microcontrollers have kilobytes, not megabytes. Most of the savings come from five profile settings, avoiding the formatting machinery and finding the large symbols with cargo-bloat.
13 min read
Systems
Game Development in Rust With Bevy and Its ECS Model
Bevy organizes a game as data and functions. Entities are IDs, components are plain structs and systems are ordinary functions that query for the components they need.
17 min read
Systems
Writing a Linux Daemon in Rust With Systemd Notify
Under systemd a daemon does not fork or write pid files. It stays in the foreground, tells systemd when it is ready and exits cleanly on SIGTERM.
15 min read
Systems
Raw Sockets and Packet Parsing in Rust for Network Tools
Network tools read bytes off the wire and interpret headers. Rust makes the parsing safe with slices and explicit offsets, and crates handle the platform socket details.
20 min read
CLI
Releasing a Rust CLI With Cargo Dist and GitHub Actions
cargo-dist generates a release workflow that builds your binary for every platform, packages it and publishes installers when you push a version tag.
14 min read
CLI
Build a Log Analyzer in Rust With Regex and Iterators
A log analyzer is a streaming pipeline: read lines, parse with a regex, fold into counters and print the top entries. Iterators keep memory flat on gigabyte files.
16 min read
Web
Observability for Rust Services With OpenTelemetry
OpenTelemetry gives traces, metrics and logs one vocabulary and one export path. In Rust you keep using tracing and add layers that ship to a collector.
17 min read
Web
Profiling a Slow Rust Endpoint From Flamegraph to Fix
Guessing at performance wastes time. Reproduce the slowness, record a flamegraph and fix the widest bar. This walks one endpoint from 40 ms to 6 ms.
15 min read
Web
Load Testing a Rust Service With Oha and Grafana k6
A load test is only useful if it models real traffic and reports percentiles. oha gives a quick check, and k6 scripts realistic user flows with thresholds.
14 min read
Web
File Uploads to S3 From a Rust Service With Presigned URLs
A presigned URL lets the browser upload straight to S3, so your service never touches the bytes. The server signs, the client uploads, and a confirmation step records the result.
15 min read
Web
Background Jobs in Rust With Queues Workers and Retries
A web request should not wait for email or image resizing. Move that work to a queue, run workers that retry on failure, and decide how durable the queue must be.
16 min read
Web
Actix Web With SQLx and Connection Pools in One Repository
Wire Actix Web 4 to a SQLx 0.9 pool the right way: build the pool once outside the factory closure, share it as web::Data, map errors with ResponseError, and see the 8 versus 28 connection difference when it goes wrong.
16 min read
Cross Compiling With Cargo to Linux ARM and Musl Targets
Compiling Rust is easy to retarget, and linking is the hard part. Add the target, point Cargo at a linker, or let cross or zig supply a toolchain.
14 min read
Writing Your Own Cargo Subcommand in Rust From Scratch
A Cargo subcommand is a binary named cargo-something. The interesting parts are the argument Cargo passes, reading the workspace with cargo_metadata and installing it.
16 min read
Concurrency
Build a Connection Pool in Rust and Learn What Pools Do
A pool hands out reusable connections, caps how many exist and takes them back on drop. Building a small one explains the knobs on SQLx and deadpool.
21 min read
Concurrency
Build a Rate Limiter in Rust With Tokio and a Token Bucket
A token bucket allows bursts up to a capacity and a steady refill rate. The whole algorithm is a timestamp and a float, and the async part is waiting for the next token.
17 min read
Concurrency
Build a Chat Server in Rust With Tokio Broadcast Channels
A chat room is a one to many fan out. Tokio's broadcast channel gives each client its own receiver, and lagging clients are handled for you.
17 min read
Concurrency
Async Networking in Rust With Tokio TCP Listener and Stream
The core of every network service is an accept loop that spawns a task per connection. This walks through an echo server and a line protocol with Tokio, then adds limits.
22 min read
Concurrency
Debugging a Hung Async Rust Program Step by Step Explained
A hang is usually one of four things: a blocked runtime thread, a lock held across an await, a future that never wakes or a channel nobody closes. Here is the order to check them.
18 min read
Concurrency
Build a Tiny Async Executor in Rust to See How Wakers Work
An executor is a loop that polls tasks when their wakers fire. Build one with the standard library alone and Tokio stops looking like magic.
17 min read
Concurrency
Writing a Future by Hand in Rust With Poll and Wakers
An async fn is a state machine behind the Future trait. Writing a future yourself, with poll and a waker, removes the mystery from await.
18 min read
Rust
A Learning Path for Rust That Skips the Common Dead Ends
Most people stall in Rust at the same three places. This path orders the topics so each one rests on the last, and tells you what to skip until you need it.
16 min read
Rust
Rust for PHP Developers a Practical Translation Guide
PHP developers move from a request-per-process model to long lived services. This guide translates arrays, classes, exceptions and Composer into Rust and covers what changes at runtime.
16 min read
Rust
Rust for Java Developers a Practical Translation Guide
Java developers know strong typing and tooling. This guide translates classes, interfaces, generics, exceptions and Maven into their Rust equivalents, and shows what changes without a JVM.
17 min read
Rust
Rust for C Plus Plus Developers a Practical Guide Explained
C++ developers know manual lifetimes. Rust turns the rules you follow by habit into compiler checks. This guide maps RAII, templates, move semantics and build tools across.
20 min read
Rust
Rust for Go Developers a Practical Translation Guide
Go and Rust share a preference for plain code and explicit errors. This guide shows where they diverge: ownership, traits, generics and the way concurrency is checked.
18 min read
Rust
Rust for JavaScript Developers a Practical Translation Guide
TypeScript developers already think in types and async code. This guide maps each JavaScript habit to its Rust form and warns about the places where the mapping breaks.
18 min read
Rust
Rust for Python Developers a Practical Translation Guide
Python developers already know most of what Rust asks for. This guide maps each Python habit to its Rust equivalent and names the three shifts that cause most of the early compiler errors.
18 min read
Architecture
Migrating a Python or Node Service to Rust Incrementally
Move a Python or Node service to Rust one route at a time: the strangler approach with a proxy, shared contracts, parity tests, data ownership and when to stop.
14 min read
Architecture
Refactoring With the Compiler in Rust Safely and Fast
Change a type or signature and let rustc list every place that must change. A method for safe large refactors: make the change, follow errors, keep tests green at each step.
16 min read
Architecture
Command Pattern and Undo in Rust Built With Enums Explained
Implement undo and redo in Rust with the command pattern: commands as an enum, execute and undo methods, history stacks, merging, and a text editor example.
19 min read
Architecture
Event Sourcing in Rust With a Small Working Example
Event sourcing stores changes as an append-only list of events and derives state by folding them. A small Rust example: events enum, aggregate, command handling, store and replay.
21 min read
DevOps
Monitoring Rust Services With Grafana Dashboards Explained
Build a Grafana dashboard for a Rust service from Prometheus metrics: the RED panels, PromQL for rate, errors and p99, saturation panels, variables and alert rules.
14 min read
DevOps
Rust on Kubernetes Probes Resources and Graceful Shutdown
Run a Rust service on Kubernetes properly: a Deployment with liveness and readiness probes, resource requests and limits, graceful shutdown with SIGTERM, and a rolling update strategy.
15 min read
DevOps
Deploying Rust to AWS Lambda With Cargo Lambda Tooling
Build and deploy a Rust function to AWS Lambda with cargo-lambda: project template, lambda_runtime handler, ARM builds, deploy, invoke locally, cold starts and limits.
15 min read
DevOps
Deploying a Rust Service to Fly io Step by Step From Scratch
Deploy a Rust web service to Fly.io from scratch: Dockerfile, fly launch, fly.toml with health checks, secrets, a Postgres attachment, scaling and rollbacks.
14 min read
Security
Sandboxing Untrusted Code From Rust With WebAssembly
Run untrusted plugins or user code from Rust inside WebAssembly with wasmtime: fuel for CPU limits, memory caps, no ambient file or network access, and host functions you choose.
16 min read
Security
Fuzzing for Security Bugs in Rust Parsers Step by Step
Fuzz a Rust parser for security bugs: panics, hangs, huge allocations and unsafe memory errors. Set up targets with limits, run with sanitizers and triage crashes.
16 min read
Security
OAuth 2 Clients in Rust With the oauth2 Crate Step by Step
Implement the OAuth 2 authorization code flow with PKCE in Rust using the oauth2 crate: build the client, redirect, verify state, exchange the code and store tokens safely.
14 min read
Security
Reproducible Builds in Rust and Verifying a Binary
A reproducible build produces the same bytes from the same source anywhere. See what breaks it in Rust (paths, timestamps, toolchains), how to fix each, and how to verify a binary.
14 min read
Web
Rust to WebAssembly and When It Is Worth the Effort
A guide to compiling Rust to WebAssembly: the targets, wasm-bindgen, calling between Rust and JavaScript, size, testing and when WebAssembly is worth it.
15 min read
Tooling
Debugging Rust in VS Code With Codelldb Step by Step
Debug Rust in VS Code with the CodeLLDB extension: install, a launch.json, breakpoints, conditional breakpoints, watch expressions, debugging tests and common problems.
13 min read
Tooling
Debugging Rust From Printing to Breakpoints and Backtraces
A map of Rust debugging tools in the order to reach for them: compiler messages, dbg!, tests, backtraces, tracing, a debugger and sanitizers, with when each one wins.
16 min read
Performance
Memory Usage in Rust Services and Finding Leaks Step by Step
Find where a Rust service's memory goes: read RSS and allocator stats, profile allocations with dhat or heaptrack, tell a leak from growth, and fix the usual causes.
18 min read
Performance
Profile Guided Optimization for Rust Binaries Step by Step
Profile guided optimization compiles twice: once to collect a profile from a real workload, once to optimize with it. Do it by hand or with cargo-pgo, and judge the gain.
14 min read
Rust
Error Handling in Rust With Result Option and Question Mark
A working guide to error handling in Rust: Result, the question mark, custom error types, anyhow and thiserror, and the line between a panic and an error.
17 min read
Testing
Fuzzing Rust Code With Cargo Fuzz and Libfuzzer Step by Step
Fuzz a Rust function with cargo-fuzz and libFuzzer: init, write a target, run, read crashes, minimize inputs, add a corpus and turn findings into regression tests.
14 min read
Systems
Unsafe Rust Explained and What the Keyword Really Promises
A guide to unsafe Rust: what the keyword allows, the contract it creates, how to wrap it in a safe API, how to check it with Miri and where it is actually needed.
15 min read
Systems
Booting a Minimal Kernel in Rust With Bootloader and Qemu
Boot a minimal Rust kernel in QEMU: a no_std crate, the bootloader crate, a disk image, a panic handler and writing text to the serial port in a few dozen lines.
15 min read
Systems
Writing an Operating System Kernel in Rust a Roadmap
A plan for writing an operating system kernel in Rust: the order of milestones from booting to a shell, which crates help, what to read and the traps at each stage.
15 min read
Systems
Rust on STM32 Microcontrollers With Probe RS Tooling
Program an STM32 in Rust with probe-rs: pick the target, create a project from the cortex-m template, use embassy-stm32 or a PAC and HAL, flash, log and debug.
14 min read
Systems
Rust on the Raspberry Pi Pico With Embassy Step by Step
Blink an LED on a Raspberry Pi Pico in async Rust with Embassy: toolchain target, memory.x, probe-rs runner, the main task and a second task with a button.
15 min read
CLI
Build a Git Hook Manager in Rust From Scratch Step by Step
Build a git hook manager in Rust: read a hooks config, install shims into .git/hooks, run commands on staged files in order, and report results with proper exit codes.
16 min read
CLI
Build a Todo CLI in Rust With Serde and a JSON File
Build a todo list CLI in Rust with clap subcommands, serde JSON storage, stable ids, atomic and durable saves, and a file lock that stops concurrent runs from losing items. Every claim measured.
17 min read
CLI
Build a Markdown Link Checker in Rust With Reqwest
Build a Markdown link checker in Rust: extract links with pulldown-cmark, check them concurrently with reqwest and a semaphore, retry, report and set exit codes.
18 min read
CLI
Build a Fast File Finder in Rust With Parallel Walking
Build a fast file finder in Rust: parallel directory walking with the ignore crate, glob and regex filters, size and type predicates, and sorted deterministic output.
16 min read
CLI
Build a Grep Clone in Rust and Learn File Handling
Build a grep clone in Rust from a naive version that panics on Latin-1 text to a streaming one that searches 72 MB in 77 ms with 2.5 MB of memory, handling binary files, exit codes and broken pipes.
20 min read
CLI
Terminal User Interfaces in Rust With Ratatui Step by Step
Build a terminal user interface with Ratatui: init and restore, the draw loop, widgets and layout, handling key events and state, with a small counter and list app.
16 min read
Web
Axum Integration Tests With a Real Database in Docker
Test an Axum API against a real Postgres started by Testcontainers: one container per test binary, one migrated database per test, the leaks and version traps that bite, and measured timings for each isolation strategy.
18 min read
Web
Axum and SQLx Together for a Typed Database Layer Explained
Wire Axum 0.8 and SQLx 0.9 into a typed database layer: a pool in state, a db module of compile-time checked queries, one error type, a transaction, offline builds and tests on throwaway databases.
18 min read
Web
Axum WebSockets With Broadcast Channels as a Weekend Project
Build a chat room over WebSockets in Axum 0.8, using a Tokio broadcast channel to fan messages out, two tasks per socket, size limits and an integration test that drives real clients.
16 min read
Shrink a Rust Binary Step by Step and Track Each Gain
Shrink a Rust binary in steps: strip symbols, size optimization, LTO, panic abort, dependency pruning and cargo bloat to find what takes the space.
13 min read
Cargo Workspaces Features and Publishing a Crate Guide
A guide to Cargo beyond cargo build: the manifest, dependency versions, features, workspaces, profiles, MSRV, publishing and the errors you will meet along the way.
14 min read
Security
Security for Rust Developers a Practical Threat Model
A practical threat model for Rust code: what the compiler prevents, what it does not, and the checklist of supply chain, input handling, secrets, cryptography and deployment risks.
14 min read
TestingEditor's pick
Testing in Rust Unit Integration Doc and Property Tests
A guide to testing Rust code: unit tests beside the code, integration tests in tests, doc tests, property tests, snapshots, mocks, async tests and the commands to run them.
17 min read
DevOps
Shipping Rust to Production From Build to Running Service
A guide to taking a Rust service from cargo build to production: release profile, CI, containers, configuration, secrets, health checks, observability and safe rollouts.
14 min read
Performance
Profiling Rust Programs From Flamegraph to a Fix Guide
A guide to making Rust programs faster by measuring first: release builds, flamegraphs, allocation counts, benchmarks and the order to look at things.
14 min read
Tooling
Rustup Explained Toolchains Targets and Components
rustup installs and switches Rust toolchains, targets and components. A guide to channels, overrides, rust-toolchain.toml, cross targets, offline use and clean upgrades.
13 min read
Architecture
Organizing Rust Projects as They Grow Into Workspaces
How to structure a Rust codebase as it grows: modules, a lib and bin split, workspaces, layers and the boundaries that keep compile times and coupling in check.
13 min read
DatabasesEditor's pick
SQLx Explained and How Compile Time Checked Queries Work
A guide to SQLx: async queries without an ORM, compile-time checked SQL, pools, migrations, transactions and the choices around them.
17 min read
Systems
Embedded Rust From Blinking an LED to Real Firmware
A guide to embedded Rust from the first blinking LED to firmware structure: no_std, the HAL traits, runtimes, flashing, debugging and size.
15 min read
CLIEditor's pick
A Command Line Tool in Rust From Clap to a Shipped Release
Build a command line tool in Rust from the first clap derive to a release binary: arguments, config, output, exit codes, tests and distribution.
17 min read
WebEditor's pick
An Axum Service You Can Run in Production From Zero
Build a small Axum 0.8 service from an empty crate to something you can deploy: a testable router, one error type, limits and timeouts, tracing, oneshot tests and graceful shutdown on SIGTERM.
17 min read
ConcurrencyEditor's pick
Async Rust and Tokio From Futures to a Production Service
A guide to async Rust and Tokio: futures, the runtime, spawning, blocking, channels and the mistakes that make a service stop answering.
16 min read
Generics
Traits Generics and Trait Objects and How to Choose
A guide to choosing between generics, impl Trait, trait objects and enums in Rust, with one example solved four ways and the costs of each.
18 min read
RustEditor's pick
A Rust Language Tour for Developers Who Already Code
A fast route through the Rust language for developers who already code in another language, built around one small program that touches ownership, enums, traits and errors.
18 min read
Get new posts by email
We send one email when a new post is published. No spam.