Skip to content

Guides Library Snippets Topics

Rust Web Generics CLI Concurrency Systems Databases Architecture All topics →

Home
Sitemap

Sitemap

Every post, snippet and tool on the site, by title.

Posts (400)

A Command Line Tool in Rust From Clap to a Shipped Release
Actix Web With SQLx and Connection Pools in One Repository
A Learning Path for Rust That Skips the Common Dead Ends
Allocators in Rust Jemalloc Mimalloc and the System One
An Axum Service You Can Run in Production From Zero
An In Process Event Bus in Rust With Broadcast Channels
Any and Downcasting in Rust Trait Objects Explained
Anyhow vs Thiserror and Which One to Use in Your Crate
Arc Mutex in Rust and the Pattern Behind Shared State
A Rust Language Tour for Developers Who Already Code
A Small Docker Image for Rust With Multi Stage Builds
Assertions in Rust Assert Eq Matches and Custom Messages
Associated Types Versus Generic Parameters in Rust Traits
Async and Await in Rust and What the Compiler Generates
Async Networking in Rust With Tokio TCP Listener and Stream
Async Retries Timeouts and Circuit Breakers in Rust Clients
Async Rust and Tokio From Futures to a Production Service
Axum 0.8 Changes and How to Migrate Your Routes Explained
Axum and SQLx Together for a Typed Database Layer Explained
Axum Error Handling With IntoResponse and Custom Errors
Axum Extractors Explained and the Order That Matters
Axum Form Data and File Uploads Handled Safely Step by Step
Axum Graceful Shutdown and Draining Connections Step by Step
Axum Integration Tests With a Real Database in Docker
Axum Middleware With Tower Layers and From Fn Compared
Axum Rate Limiting With Tower Governor and Redis Explained
Axum Request Timeouts Limits and Body Size Caps Step by Step
Axum Routing Explained With Handlers and Responses
Axum Server Sent Events for Live Updates Without WebSockets
Axum Structured Logging and Request IDs With Tracing
Axum Testing With Tower Oneshot and In Memory Requests
Axum Versus Actix Web and How to Choose With Numbers
Axum WebSockets With Broadcast Channels as a Weekend Project
Background Job Queues in Rust Compared by Trade Off
Background Jobs in Rust With Queues Workers and Retries
Backpressure in Rust Pipelines and Services Explained
Benchmarking in Rust With Criterion and Divan Compared
Benchmarking Pitfalls in Rust and Dead Code Removal
Benchmarking Rust CLIs Against Shell Pipelines Fairly
Bevy Systems Queries and Resources Explained Simply
Blanket Implementations in Rust and Their Coherence Limits
Blocking the Tokio Runtime and How to Find the Culprit
Booting a Minimal Kernel in Rust With Bootloader and Qemu
Bounded Channels and Backpressure in Tokio Done Explained
Bounds Checks in Rust and When the Optimizer Removes Them
Box dyn Trait in Rust and When Allocation Is Worth It
Box Rc and Arc in Rust Compared With Examples Explained
Branch Prediction and Cache Friendly Code in Rust Explained
Breaking Changes in Rust Libraries and What Counts as One
Build a Chat Server in Rust With Tokio Broadcast Channels
Build a Connection Pool in Rust and Learn What Pools Do
Build a Disk Usage Analyzer in Rust Like du and ncdu
Build a Fast File Finder in Rust With Parallel Walking
Build a Fuzzy Finder in Rust With Crossterm and Nucleo
Build a Git Hook Manager in Rust From Scratch Step by Step
Build a Grep Clone in Rust and Learn File Handling
Build a jq Style JSON Query Tool in Rust Step by Step
Build a Log Analyzer in Rust With Regex and Iterators
Build a Markdown Link Checker in Rust With Reqwest
Build a Markdown to HTML Converter CLI in Rust With Pulldown
Build a Rate Limiter in Rust With Tokio and a Token Bucket
Build a Tiny Async Executor in Rust to See How Wakers Work
Build a Todo CLI in Rust With Serde and a JSON File
Cache Invalidation Strategies for Rust Services Compared
Caching Cargo Builds in CI With Swatinem Rust Cache
Caching Computed Values in Rust With Memoization Explained
Calling C From Rust With Extern and Bindgen Step by Step
Calling Rust From C With Cbindgen and Staticlib Step by Step
Cancelling Tasks in Tokio With Abort and Cancellation Tokens
Cargo Audit and Cargo Deny for Dependency Safety Explained
Cargo Build Times and Seven Changes That Actually Help
Cargo Chef and Layer Caching for Faster Rust Image Builds
Cargo Features Explained and How They Unify in a Workspace
Cargo Lock Explained and Whether to Commit It for New Code
Cargo Outdated and Cargo Upgrade for Keeping Crates Fresh
Cargo Profiles Explained Dev Release and Custom Profiles
Cargo Toml Explained Section by Section With Real Examples
Cargo Tree for Finding Why a Dependency Is in Your Build
Cargo Workspaces Explained for Splitting a Large Project
Cargo Workspaces Features and Publishing a Crate Guide
Checking Licenses and Bans With Cargo Deny Config Explained
Choosing Between Postgres and SQLite for a New Rust Service
Circuit Breakers and Bulkheads in Rust Service Clients
Clap Subcommands Flags and Positional Arguments Explained
Clean Architecture in Rust and How Much of It You Need
Clippy Explained How Lints Are Grouped and Configured
Closures in Rust and How Fn FnMut and FnOnce Differ
Codegen Units and Opt Level in Rust and When to Change Them
Colored Terminal Output in Rust With Anstyle and Owo Colors
Command Pattern and Undo in Rust Built With Enums Explained
Configuration for Rust Services With Environment Variables
Configuring Lints in Cargo Toml for the Whole Workspace
Constant Time Comparisons in Rust and Why Equality Is Unsafe
Continuous Integration for Rust Test Format Lint Build
Continuous Integration for Rust With GitHub Actions
Copy Versus Clone in Rust and Which Types Are Copy
CQRS in Rust and Whether It Pays Off for You Compared
Crates Packages and Modules in Rust Told Apart Explained
Cross Compiling With Cargo to Linux ARM and Musl Targets
Cutting Monomorphization Bloat in Rust With Cargo Llvm Lines
Data Oriented Design in Rust and Why It Speeds Up Code
Data Parallelism in Rust With Rayon and Parallel Iterators
Debugging a Hung Async Rust Program Step by Step Explained
Debugging a Stack Overflow in Rust and Recursion Limits
Debugging Async Backtraces and Task Dumps in Tokio
Debugging Deadlocks in Rust With Thread Dumps and Traces
Debugging Embedded Rust With Probe rs and Defmt Logging
Debugging Memory Errors in Unsafe Rust With Sanitizers
Debugging Rust From Printing to Breakpoints and Backtraces
Debugging Rust in VS Code With Codelldb Step by Step
Denial of Service Through Rust Parsers and Resource Limits
Dependency Injection in Rust With Traits and Generics
Dependency Inversion With Rust Traits Without Overdoing It
Dependency Risk in Rust and Reading Advisories Explained
Deploying a Rust Service to a Plain VPS With Systemd
Deploying a Rust Service to Fly io Step by Step From Scratch
Deploying Rust to AWS Lambda With Cargo Lambda Tooling
Detecting a Terminal and Handling Pipes in Rust CLIs
Distributed Rate Limiting for Multi Instance Rust Services
Distroless Alpine Scratch and Debian Slim for Rust Images
Docker Compose for a Rust Service With Postgres and Redis
Doc Tests in Rust and Keeping Examples Honest Step by Step
Domain Driven Design in Rust Types That Mirror the Domain
Dyn Compatibility in Rust and the Rules That Block dyn
eBPF and Rust With Aya for Observability Tools Step by Step
Editing Rust in Neovim With LSP and Treesitter Setup
Embedded HAL Traits in Rust and Writing Portable Drivers
Embedded Rust From Blinking an LED to Real Firmware
Enum Dispatch in Rust for Speed Without Trait Objects
Error Boundaries Between Layers in a Rust Application
Error Handling in Rust With Result Option and Question Mark
Event Sourcing in Rust With a Small Working Example
Exit Codes and Error Output for Rust Command Line Tools
Extension Traits in Rust to Add Methods to Foreign Types
Fan Out and Fan In Work Pipelines in Rust Services Design
Feature Flags That Break Builds and How to Test Them All
File Upload Security in Rust Checking Type Size and Name
File Uploads to S3 From a Rust Service With Presigned URLs
Flaky Tests in Rust and Seven Usual Causes to Check
From and Into Traits in Rust and Implementing Both Correctly
Full Text Search in Rust With PostgreSQL or Tantivy
Futures in Rust Explained as State Machines You Can Read
Fuzzing for Security Bugs in Rust Parsers Step by Step
Fuzzing Rust Code With Cargo Fuzz and Libfuzzer Step by Step
Game Development in Rust With Bevy and Its ECS Model
Generics in Rust and How Monomorphization Makes Them Fast
Git Ignore for Rust Projects and What to Commit Step by Step
Graceful Degradation in Rust Services Under Heavy Load
Graceful Shutdown in Tokio With Signals and Task Tracking
Graceful Shutdown on Kubernetes for Rust Services Explained
Handling Database Timeouts and Retries in Rust Services
Handling Secrets in Rust With Zeroize and Secrecy Explained
HashMap Performance in Rust and Faster Hashers Step by Step
Health Checks Readiness and Liveness for Rust Services
Hexagonal Architecture in Rust With Traits as Ports
Holding a Mutex Guard Across an Await in Rust and the Fix
Hyper Directly in Rust and When to Skip the Framework
Idempotency Keys in a Rust API for Safe Retries Step by Step
Idempotency Keys in Rust APIs and Safe Request Retries
Ignoring and Filtering Tests in Rust for Slow Suites
Impl Trait Versus dyn Trait in Rust Arguments and Returns
Incident Response for Rust Services a Short Runbook
In Process Caches in Rust Moka Quick Cache and Cached
Install Rust With Rustup and Set Up Your First Project
Integer Overflow Bugs in Rust Release Builds and Fixes
Integer Overflow in Rust and Why Debug and Release Differ
Integration Tests in Rust and the Tests Directory Explained
Iterator Chains Versus Loops in Rust and Their Real Speed
Iterators in Rust From For Loops to Adapter Chains
Job Queues With SKIP LOCKED in Postgres From Rust Explained
JoinSet in Tokio for Managing Many Tasks as a Group
JSON Requests and Responses in Axum With Serde Step by Step
JWT Validation in Rust Without the Usual Mistakes Explained
Leaking Memory in Safe Rust Through Reference Cycles
Library or Binary Splitting a Rust Crate for Testability
Link Time Optimization in Rust and Its Build Time Cost
Load Testing a Rust Service With Oha and Grafana k6
LocalSet and Non Send Futures in Tokio Explained Made Clear
Logging in Rust With the log Crate and Env Logger Explained
Logging Without Leaking Secrets in Rust Web Services
Log Levels and What to Log in a Rust Service Explained
Macro Rules Basics in Rust With Patterns and Repetitions
Measuring Memory Use of a Rust Program With Heaptrack
Memory Mapped Registers in Rust and Why PACs Exist
Memory Usage in Rust Services and Finding Leaks Step by Step
Message Passing in Rust With std mpsc Channels Step by Step
Microbenchmarks That Lie and How to Write Honest Rust Ones
Migrating a Python or Node Service to Rust Incrementally
Minimum Supported Rust Version and How to Declare Yours
Mocking in Rust With Mockall and When Fakes Are Better
Modules and Visibility in Rust Without the Confusion
Monitoring Rust Services With Grafana Dashboards Explained
Newtypes for Database IDs in Rust to Stop Mixing Them Up
Node Addons in Rust With Napi rs for JavaScript Speed
No Std Rust Explained and What You Lose Without Std
OAuth 2 Clients in Rust With the oauth2 Crate Step by Step
Observability Architecture for Rust Services Explained
Observability for Rust Services With OpenTelemetry
Optional Dependencies and Feature Flags in Cargo Done Right
Option in Rust and How to Stop Fearing the Null Case
Organizing Rust Projects as They Grow Into Workspaces
Ownership Across FFI in Rust Who Frees the Memory Explained
Ownership in Rust Explained With a Mental Model That Holds
Pagination With Keyset Queries in Rust and SQLx Step by Step
Password Hashing in Rust With Argon2 Parameters That Hold Up
Path Traversal in Rust File Servers and Safe Joins
Per Test Databases in Rust With SQLx Test Attribute
Pin Box and Dyn Future in Rust and Why All Three Appear
Pinning a Toolchain With Rust Toolchain Toml in a Project
Postgres Isolation Levels and Serialization Retries in Rust
Processing a Stream With Buffer Unordered in Rust Explained
Profile Guided Optimization for Rust Binaries Step by Step
Profiling a Slow Rust Endpoint From Flamegraph to Fix
Profiling Async Rust Services With Tokio Metrics in Steps
Profiling Rust Programs From Flamegraph to a Fix Guide
Progress Bars and Spinners in Rust With Indicatif Explained
Prometheus Metrics Exported From a Rust Service Step by Step
Property Based Testing in Rust With Proptest Step by Step
Public API Design for Rust Crates That Survive Releases
Publishing a Crate to the Crates Registry Step by Step
Python Extensions in Rust With PyO3 and Maturin Step by Step
Rate Limiting and Abuse Prevention in Rust APIs Explained
Raw Sockets and Packet Parsing in Rust for Network Tools
Reading EXPLAIN Output From Rust Queries and Adding Indexes
Reading Large Files in Rust With Buffered IO and Memory Maps
Reading Rust Backtraces and Setting the Right Variables
Reading Standard Input in Rust Lines Bytes and Pipes
Reducing Allocations in Rust and Finding the Hot Ones
Refactoring With the Compiler in Rust Safely and Fast
Regex in Rust the regex Crate and Its Guarantees Explained
Regex Performance in Rust and Avoiding Catastrophic Cases
Release Mode Versus Debug Mode in Rust and the Speed Gap
Release Plz and Cargo Release Compared for Crate Releases
Release Profile Settings for Smaller Faster Rust Binaries
Releasing a Rust CLI With Cargo Dist and GitHub Actions
Repository Pattern in Rust and Whether You Need It
Reproducible Builds in Rust and Verifying a Binary
Request Coalescing to Stop Cache Stampedes in Rust Services
Request Limits and Slow Client Attacks in Rust Services
Reqwest Error Handling and Status Code Checks Done Right
Result in Rust Explained and How to Handle Both Outcomes
RTIC Versus Embassy for Real Time Embedded Rust Compared
Running Rust Containers as a Non Root User Safely Explained
Running Rust Tests Faster With Cargo Nextest in CI
Rust Analyzer Setup in VS Code Neovim and Zed Editors
Rust and PostgreSQL JSONB Columns Done Right With Serde
Rust and PostgreSQL Listen Notify for Lightweight Events
Rust and Redis With Redis rs and Connection Managers
Rust and SQLite With Rusqlite and SQLx Compared for New Code
Rust and Systemd Services Sockets and Watchdogs Explained
Rust Collections Compared Vec HashMap HashSet and BTreeMap
Rust Data Types From Integers to Tuples and Arrays
Rust Dev Containers for VS Code and Reproducible Setup
Rust Docker Builds That Recompile Everything and the Fix
Rust Enums and Why They Replace Class Hierarchies Explained
Rust Error Address Already in Use When Binding a Port
Rust Error Broken Pipe When Writing to Standard Output
Rust Error Called Option Unwrap on a None Value Explained
Rust Error Connection Refused From Reqwest and Sockets
Rust Error E0038 The Trait Cannot Be Made Into an Object
Rust Error E0117 Only Traits Defined Here Can Be Implemented
Rust Error E0119 Conflicting Implementations of Trait
Rust Error E0277 Trait Bound Not Satisfied and the Fix
Rust Error E0282 Type Annotations Needed and How to Add Them
Rust Error E0308 Mismatched Types With Practical Fixes
Rust Error E0369 Binary Operation Cannot Be Applied
Rust Error E0382 Borrow of Moved Value and Three Fixes
Rust Error E0499 Cannot Borrow as Mutable More Than Once
Rust Error E0502 Cannot Borrow as Mutable and Immutable
Rust Error E0597 Borrowed Value Does Not Live Long Enough
Rust Error E0599 No Method Found for This Type Fixed
Rust Error Failed to Select a Version for the Requirement
Rust Error Future Cannot Be Sent Between Threads Safely
Rust Error Linking With cc Failed and Common Causes
Rust Error Multiple Versions of One Crate in the Graph
Rust Error Recursion in an Async Fn Requires Boxing
Rust Error Too Many Open Files and Raising the Limit
Rust Firmware Size Optimization Down to Tens of Kilobytes
Rust for C Plus Plus Developers a Practical Guide Explained
Rust for Go Developers a Practical Translation Guide
Rust for Java Developers a Practical Translation Guide
Rust for JavaScript Developers a Practical Translation Guide
Rust for Linux Drivers and Out of Tree Kernel Modules
Rust for PHP Developers a Practical Translation Guide
Rust for Python Developers a Practical Translation Guide
Rust Interview Questions With Answers That Show Reasoning
Rust Is Not Always Faster and the Cases That Prove It
Rust on Kubernetes Probes Resources and Graceful Shutdown
Rust on STM32 Microcontrollers With Probe RS Tooling
Rust on the Raspberry Pi Pico With Embassy Step by Step
Rust Panics Without Std and Choosing a Panic Handler
Rust Pattern Matching From Simple Match to Slice Patterns
Rust Performance Basics Measure First Then Change One Thing
Rust Security Checklist to Run Before Shipping a Service
Rust Strings Explained and When to Use String or str
Rust to WebAssembly and When It Is Worth the Effort
Rustup Explained Toolchains Targets and Components
Rust vs C Plus Plus for New Systems Code and When Each Wins
Rust vs Go for a New Backend Service and How to Choose
Rust vs Python and Where Each Language Earns Its Place
Rust Warning Unused Future Must Be Used and What It Hides
Safe Rust Bindings for a C Library a Worked Example
Sandboxing Untrusted Code From Rust With WebAssembly
Schema Design for a Rust Service Types That Match Columns
Secrets Management for Rust Services in Production
Security for Rust Developers a Practical Threat Model
Security Headers Set From a Rust Web Service Step by Step
Semver Checks for Libraries With Cargo Semver Checks
Send and Sync in Rust Explained and Why They Are Auto Traits
Serializing and Deserializing JSON in Rust With Serde JSON
Shadowing in Rust and When It Beats Mutation Explained
Sharing State Between Axum Handlers With State and Arc
Sharing State in Tokio With Arc Mutex and Message Passing
Shipping Rust to Production From Build to Running Service
Shrink a Rust Binary Step by Step and Track Each Gain
Snapshot Tests in Rust With Insta and Review Workflow
Soft Deletes and Audit Trails in a Rust Application
Sorting in Rust Stable Versus Unstable and Their Costs
Spawn Blocking in Tokio and When Rayon Is the Better Tool
Spawning Tasks With tokio spawn and Joining Their Results
Spawning Threads in Rust With std thread and Joining Them
Specialization in Rust and Why It Is Still Unstable
SQL Injection in Rust and Why Typed Queries Help Explained
SQLx Connection Pools Sizing and Timeouts in Rust Explained
SQLx Dynamic Queries With QueryBuilder Without SQL Injection
SQLx Error Handling and Unique Violation Detection
SQLx Explained and How Compile Time Checked Queries Work
SQLx Migrations in Rust and Running Them in CI and Prod
SQLx Offline Mode and the Query Cache for CI Builds
SQLx Query As and FromRow Mapping Rows to Structs Explained
SQLx Transactions in Rust and Avoiding Half Written Data
SQLx Versus Diesel and SeaORM and How to Choose for New Code
Stale While Revalidate Caching in Rust Services Explained
State Machines in Rust With Enums and Typestate Explained
Static Linking Rust for Scratch Images With Musl Explained
Static Versus Dynamic Dispatch in Rust and the Real Cost
Streams in Rust With Futures and Tokio Stream Explained
Structs in Rust With Fields Methods and Associated Functions
Structured Logging in Rust With Tracing and JSON Output
Supertraits in Rust and Building Trait Hierarchies Safely
Tail Latency in Rust Services and Why Averages Mislead You
Ten Rust Project Ideas That Teach One Hard Idea Each
Terminal User Interfaces in Rust With Ratatui Step by Step
Testing Code That Uses Randomness in Rust Reliably
Testing Concurrent Rust Code With Loom Interleavings
Testing Database Code in Rust With Test Containers
Testing Embedded Rust on the Host With Mocks and Simulators
Testing Graceful Shutdown and Signal Handling in Rust Apps
Testing in Rust Unit Integration Doc and Property Tests
Testing Panics in Rust With Should Panic and Catch Unwind
Testing Rate Limiters and Quotas in Rust Web Services
Testing Retry and Timeout Logic in Rust Without Sleeping
Testing Rust Command Line Tools With Assert Cmd Step by Step
Testing Time Dependent Code in Rust With Injected Clocks
Test Organization in Rust for Large Workspaces Explained
The Actor Model in Rust With Tokio Tasks and Channels
The Newtype Pattern in Rust for Safer Function Signatures
The Orphan Rule in Rust and How to Work Around It Explained
The Outbox Pattern in Rust for Reliable Event Publishing
The Visitor Pattern in Rust With Traits and Enums Compared
Timeouts in Tokio and Why a Timeout Does Not Stop the Work
Tokio Channels Compared mpsc oneshot broadcast and watch
Tokio Console for Finding Stuck Tasks in Rust Services
Tokio Metrics and Runtime Stats for Production Dashboards
Tokio Mutex Versus Std Mutex and When Each Is Correct
Tokio Runtime Explained Workers Tasks and the Scheduler
Tokio Select and Cancellation Safety Explained With Traps
Tokio Semaphores for Limiting Concurrency in Rust Services
Tokio Tasks Never Finish and Five Reasons It Happens
Tokio Uring and Linux io uring From Rust a Cautious Look
Tower Services and Layers Explained for Axum Users
Tracing Spans and Events Explained for Beginners Made Clear
Trait Bounds and Where Clauses in Rust Explained Made Clear
Trait Objects in Rust and Why Some Traits Cannot Be One
Traits Generics and Trait Objects and How to Choose
Traits in Rust Explained as Shared Behavior With Examples
Tuning Tokio Worker Threads and When to Leave Defaults
Unit Tests in Rust and Where the Test Module Lives
Unsafe Documentation Safety Comments That Reviewers Trust
Unsafe Rust Explained and What the Keyword Really Promises
Using Miri to Catch Undefined Behavior in Unsafe Rust
UUIDs Versus Integer Keys in Rust Services and Their Costs
Variables and Mutability in Rust Explained With Examples
Vector Search From Rust With pgvector and Embeddings
Vec With Capacity and Reusing Buffers in Rust Loops
Webhook Signature Verification in Rust With HMAC Checks
Why Rust Feels Hard at First and What Actually Helps
Why Rust Has No Garbage Collector and What It Uses Instead
Why Tokio Spawn Needs a Static Future and How to Cope
Workspace Dependencies in Cargo and Sharing Versions
Workspace Lints and Package Inheritance in Cargo Explained
Writing a Custom Global Allocator in Rust to Track Memory
Writing a Derive Macro in Rust With Syn and Quote Explained
Writing a Future by Hand in Rust With Poll and Wakers
Writing a Linux Daemon in Rust With Systemd Notify
Writing an Operating System Kernel in Rust a Roadmap
Writing a Safe Wrapper Around Unsafe Code in Rust Explained
Writing Your Own Cargo Subcommand in Rust From Scratch
Yanking a Crate Version and What It Does Not Do Explained
Zero Downtime Database Migrations With Rust Services

Tools (351)

rusthacks.dev

Practical guides and hacks for Rust developers.

Stacks

Rust
Web
Generics
CLI
Concurrency
Systems
All topics

Skills

Architecture
Tooling
Performance
Testing
DevOps
Security

Site

About
Contact
RSS
Sitemap XML
Sitemap Links

Legal

Privacy
Terms

Code samples are MIT licensed and provided as is, for learning. Each post names the Rust version it was tested on; check the release notes of yours, and run anything that changes data against a copy first.

© 2026 RustHacks. All rights reserved.