React
React Native
Node.js
Python
Rust
PostgreSQL
Solana
Claude
AI Agents
Go

Rust SME Cookbook

Sections

Core Language & Ownership

The Rust Design Philosophy Rust Basics Variables, Mutability & Shadowing Scalar & Compound Types Functions & Expressions Control Flow Ownership Preview References & Slices The Type System & Inference Formatting & Printing Rust Fundamentals Best Practices

The Rust Ownership Model Ownership Basics Move Semantics & Copy Borrowing & References The Borrow Checker Lifetimes Explained Lifetime Annotations Lifetime Elision Non-Lexical Lifetimes & Reborrows 'static & Bounds Fighting the Borrow Checker Ownership Best Practices

Modeling Data with Structs and Enums Structs Basics Methods & Associated Functions Enums Pattern Matching with match if let, let else & while let Option & Result as Enums Destructuring Deriving Traits Enums for State Machines Structs & Enums Best Practices

Rust's Trait System as Interface Design Traits Basics Default Methods & Supertraits Generics Trait Bounds Trait Objects & Dynamic Dispatch Static vs Dynamic Dispatch Associated Types & Constants Operator Overloading Blanket & Conditional Impls Common Standard Traits Traits & Generics Best Practices

The Rust Error-Handling Philosophy Error Handling Basics The ? Operator panic! vs Recoverable Errors Custom Error Types thiserror anyhow Error Context & Backtraces Option Combinators Fallible Iterators & collect()Error Handling Best Practices

The Iterator Model in Rust Collections Basics Vec & Slices HashMap & BTreeMap VecDeque, BinaryHeap & LinkedList The Iterator Trait Iterator Adapters Consuming Iterators Entry API & In-Place Updates IntoIterator & Owned vs Borrowed Collections & Iterators Best Practices

Closures and Rust's Fn Traits Closures Basics Fn, FnMut & FnOnce move Closures Returning Closures Higher-Order Functions Iterator + Closure Patterns Function Pointers vs Closures Closures Best Practices

Smart Pointers as Extensions of Ownership Smart Pointers Basics Box<T>Rc & Arc RefCell & Cell Rc<RefCell<T>> & Arc<Mutex<T>>Weak References Cow (Clone-on-Write)Deref & Deref Coercion Custom Smart Pointers Smart Pointers Best Practices

Strings, UTF-8, and Text in Rust Strings Basics UTF-8 & Indexing String Manipulation Parsing & Conversion Formatting Chars, Bytes & Graphemes Regex OsString, Path & CStr Strings Best Practices

Rust's Module and Crate System Modules Basics Visibility & Privacy use & Paths Crates & Packages Workspaces Designing a Public API Feature Flags Project Structure Patterns Modules & Crates Best Practices

The Unsafe Rust Contract Unsafe Basics Raw Pointers The Rust Memory Model Working with MaybeUninit Sound Abstractions over Unsafe FFI-Safe Types Undefined Behavior Miri & Sanitizers Unsafe Rust Best Practices

Concurrency & Async

Fearless Concurrency in Rust Concurrency Basics Send & Sync Channels Mutex & RwLock Arc for Shared State Atomics & Ordering Scoped Threads Data Parallelism with Rayon Deadlocks & Race Conditions Concurrency Best Practices

The Rust Async Model Async Basics The Future Trait Executors & Runtimes Pinning & Unpin async fn in Traits Streams Combining Futures Cancellation & Timeouts Blocking in Async Async Best Practices

Tokio's Runtime Model Tokio Basics Tasks & JoinHandles Async I/O Channels in Tokio select! & Concurrency Timers & Intervals Shared State in Async Tracing & Instrumentation Graceful Shutdown Tokio Best Practices

Tooling, Quality & Craft

How Cargo Thinks About Dependencies and Builds Cargo Basics Cargo.toml Explained Features & Optional Dependencies Profiles & Build Settings Workspaces Build Scripts (build.rs)Dependency Management Useful Cargo Subcommands Publishing to crates.io Cargo Best Practices

The Rust Testing Model Testing Basics Unit vs Integration Tests Doctests Test Organization Mocking & Test Doubles Property-Based Testing Snapshot Testing Benchmarking with Criterion Testing Async Code Coverage & CI Testing Best Practices

Rust's Built-In Quality Tooling rustfmt Clippy Lint Levels & Attributes Configuring Clippy Documentation Lints Pre-commit & Editor Setup Linting in CI Linting & Formatting Best Practices

Reasoning About Performance in Rust Performance Basics Benchmarking & Profiling Understanding Allocations Zero-Cost Abstractions Avoiding Clones SIMD & Vectorization Release Tuning Memory Layout & Cache Reducing Binary Size Performance Best Practices

Rust's Macro System Macros Basics macro_rules!Procedural Macros Overview Derive Macros Attribute Macros Function-like Proc Macros syn & quote Debugging Macros Macros Best Practices

Rust Design Patterns Rust Patterns Basics The Newtype Pattern Builder Pattern Typestate Pattern RAII & Drop Guards From/Into & TryFrom Iterator & Extension Traits Interior Mutability Patterns Common Anti-Patterns Rust Patterns Best Practices

A Mental Model for Idiomatic Rust 50 Rust Rules Every Specialist Should Follow Rust API Guidelines 30 Unsafe Rules 30 Async Rules 30 Performance Rules Error-Handling Rules Problem / Solution Reference Rust Architecture Decisions

Architecting Rust Systems Architecture Decision Checklist Workspace & Crate Boundaries Error Strategy Trait-Based Abstraction Domain Modeling with Types Configuration & Feature Design Refactoring Decisions Codebase Audit Checklist Migrating from C/C++ to Rust Architecture Best Practices

Diagnosing Rust Compiler and Runtime Errors Borrow-Checker Error Scenarios Lifetime Mismatch Scenarios Move-After-Use Scenarios Send/Sync & Thread Errors Async Deadlocks & Blocking Panic & Unwrap Scenarios Integer Overflow & Numeric Bugs FFI & Unsafe Bugs Debugging Tools Debugging Refactor Snippets

Web, Networking & Data

The Rust Web Backend Model Web Backends Basics Axum Routing & Handlers Extractors & State Middleware & Tower Error Handling in Handlers Request Validation Authentication & Sessions WebSockets & SSE Actix-web Testing Web Services Web Backends Best Practices

How Serde's Serialization Model Works serde Basics JSON with serde_json Other Formats Customizing Serialization Custom (De)serialization Enums & Tagging Zero-Copy Deserialization Error Handling & Validation serde Best Practices

Talking to Databases from Rust Databases Basics sqlx Diesel SeaORM Migrations Connection Pooling Transactions & Isolation Redis & Key-Value Query Patterns & N+1 Databases Best Practices

Rust's Networking and HTTP Stack HTTP Clients (reqwest)hyper gRPC with tonic TLS with rustls Low-Level Sockets WebSockets Retries, Timeouts & Backoff Networking Best Practices

The API Security Model in Rust API Design Basics GraphQL in Rust JWT & OAuth2 Password Hashing Secrets Management Cryptography (ring / RustCrypto)Input Validation & Injection Rate Limiting & Abuse Prevention Supply-Chain Security APIs & Security Best Practices

Systems, WASM & Interop

Building CLIs the Rust Way CLI Basics clap Configuration & Env Terminal Output TUIs with ratatui Error Reporting Shell Completions & Man Pages Packaging & Distribution CLI Best Practices

Rust as a Systems Language Systems Basics libc & Syscalls C Interop with bindgen Exposing Rust to C (cbindgen)Working with Raw Memory Signals & Process Control Building Sound Bindings Cross-Platform Systems Code Systems Programming Best Practices

Rust's WebAssembly Model WebAssembly Basics wasm-bindgen wasm-pack & Bundling DOM & Web APIs (web-sys)Frontend Frameworks (Leptos / Yew)WASI WASM Components & the Component Model Performance & Size WebAssembly Best Practices

Rust in Embedded and no_std Environments Embedded Basics no_std Programming embedded-hal Microcontroller Peripherals Interrupts & Concurrency Memory in Embedded Async on Embedded (Embassy)Debugging Firmware Embedded Best Practices

Embedding and Being Embedded: Rust Interop Interop Basics PyO3 maturin Exposing a Rust Library to C/C++Node.js with napi-rs Embedding Rust in Other Runtimes Data Marshalling Interop Best Practices

Applications & Domains

Rust's High-Performance Data Model Data Basics Apache Arrow Polars DataFusion CSV/Parquet I/O Streaming & Large Data Building Data CLIs & Services Interop with Python/pandas High-Performance Data Best Practices

Machine Learning in Rust: The Landscape ML in Rust Basics candle burn ONNX Runtime (ort)Tokenizers LLM Inference & Serving Embeddings & Vector Search GPU & Acceleration Serving Models with Axum ML in Rust Best Practices

Rust in Blockchain and Cryptography Blockchain Basics in Rust Solana Programs Substrate & ink!Applied Cryptography Wallets & Key Management Consensus & P2P Zero-Knowledge & Advanced Crypto Security & Auditing Blockchain Best Practices

Rust GUI Architecture Models GUI Basics Tauri egui iced State & Architecture Native Integration Packaging & Distribution GUI Best Practices

Rust Game Development Architecture Game Dev Basics Bevy Engine Assets & Scenes Input & Events Graphics with wgpu Physics & Audio Game Loops & Timing Performance for Games Game Dev Best Practices

Ecosystem, Ops & Team

The Rust Ecosystem's Core Crates serde tokio anyhow & thiserror tracing clap rayon reqwest & sqlx chrono & time itertools & rand once_cell / LazyLock & dashmap Essential Crates Best Practices

Shipping Rust Binaries to Production Deployment Basics Cross-Compilation Minimal Docker Images musl & Static Linking CI/CD for Rust Configuration & Secrets in Prod Observability Release & Versioning Deployment Best Practices

Using Agent Skills for Rust Development Axum Service Skill Async / Tokio Skill Unsafe Review Skill WASM Skill Embedded Skill Crate Publishing Skill Performance Skill Error-Handling Skill Rust Best-Practices Skill

The Git Mental Model for Rust Teams Essential Git Commands Branching & Merging Merge Conflict Resolution Checklist Git Worktrees GitHub CLI CI Config for Rust Git Configuration Git Best Practices

The Linux Command-Line Model for Rust Developers Sysadmin Essentials rustup & Toolchain Management Build & Inspect Tooling Search & Regex Rust-Based CLI Tools Pipes & Text Processing Process & Resource Management Linux CLI Best Practices

Onboarding and Team Conventions for Rust Codebases Onboarding Devs Checklist Toolchain Setup Checklist Codebase Orientation Conventions & Style Guide Code Review Guidelines Team Best Practices

Tech-Lead Craft

The Incident Response Mental Model for Rust Services Production Debugging Incident Response Playbooks Blameless Post-Mortems & RCA Common Production Failure Modes Rollback & Recovery Runbooks Turning Incidents into Guardrails On-Call Health

Enterprise Delivery Practices for Rust Teams Release Management Feature Flags & Progressive Delivery Rollback Strategies DORA Metrics A/B Testing & Experimentation Environments & Config Promotion Delivery Best Practices

Technical Leadership Fundamentals Technical Decision-Making Architecture Decision Records (ADRs)Running Design Reviews Code Review Culture Mentoring & Leveling Delegation & Spreading Context Handling Technical Disagreements Leadership Best Practices

Working with Product and Stakeholders as a Rust Engineer Requirements to Technical Specs Prioritizing Platform & Tech Debt Estimation & Risk Roadmap Contributions Stakeholder Communication Making the Process Work (Scrum/Kanban/SAFe)Product Collaboration Best Practices

How to Read These Case Studies Reference: A High-Throughput Axum Service Reference: A CLI Tool Shipped to Users Reference: A WASM Module in Production Before/After: Rewriting a C/C++ Component in Rust Before/After: Cutting Allocations on a Hot Path Latency & Throughput Benchmarks Lessons-Learned Catalog

Governance Models for Rust Codebases Coding Standards & API Guidelines Documentation Conventions Contribution Guidelines Unsafe & Dependency Governance Edition & Toolchain Upgrades Spikes, PoCs & Adopting New Crates Career Growth: Senior to Lead to Staff/Principal Governance Best Practices

/

/

© 2026 @csjcode|SystemsArchitect.io: Cloud Systems Tools|Terms

An independent, unofficial educational resource. Not affiliated with, endorsed, or sponsored by the brand/trademark maintainers/owners.

Search Documentation

Search across all documentation pages

Rust SME/Tags/Systems

#Systems3 pages

Pages tagged Systems across 1 section.

Cross-Platform Systems Code Systems Basics Systems Programming Best Practices

Related tags

Rust Systems Ffi