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

Rust SME Cookbook

Preguntas frecuentes

Secciones

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|Términos

Recurso educativo independiente y no oficial. Sin afiliación, respaldo ni patrocinio de los propietarios o responsables de las marcas.

Buscar en la documentación

Busca en todas las páginas de la documentación

Rust SME Cookbook

From ownership and lifetimes through Tokio, Axum, serde, unsafe soundness, WASM, and fearless concurrency - what every Rust specialist should know. Unofficial guide.

11 pages

The Rust Design Philosophy, Rust Basics, Variables, Mutability & Shadowing, Scalar & Compound Types, Functions & Expressions, Control Flow, Ownership Preview, ...

12 pages

The Rust Ownership Model, Ownership Basics, Move Semantics & Copy, Borrowing & References, The Borrow Checker, Lifetimes Explained, Lifetime Annotations, ...

Structs & Enums

11 pages

Modeling Data with Structs and Enums, Structs Basics, Methods & Associated Functions, Enums, Pattern Matching with match, if let, let else & while let, ...

Traits & Generics

12 pages

Rust's Trait System as Interface Design, Traits Basics, Default Methods & Supertraits, Generics, Trait Bounds, Trait Objects & Dynamic Dispatch, ...

11 pages

The Rust Error-Handling Philosophy, Error Handling Basics, The ? Operator, panic! vs Recoverable Errors, Custom Error Types, thiserror, anyhow, ...

11 pages

The Iterator Model in Rust, Collections Basics, Vec & Slices, HashMap & BTreeMap, VecDeque, BinaryHeap & LinkedList, The Iterator Trait, Iterator Adapters, ...

9 pages

Closures and Rust's Fn Traits, Closures Basics, Fn, FnMut & FnOnce, move Closures, Returning Closures, Higher-Order Functions, Iterator + Closure Patterns, ...

11 pages

Smart Pointers as Extensions of Ownership, Smart Pointers Basics, Box<T>, Rc & Arc, RefCell & Cell, Rc<RefCell<T>> & Arc<Mutex<T>>, Weak References, ...

10 pages

Strings, UTF-8, and Text in Rust, Strings Basics, UTF-8 & Indexing, String Manipulation, Parsing & Conversion, Formatting, Chars, Bytes & Graphemes, Regex, ...

Modules & Crates

10 pages

Rust's Module and Crate System, Modules Basics, Visibility & Privacy, use & Paths, Crates & Packages, Workspaces, Designing a Public API, Feature Flags, ...

10 pages

The Unsafe Rust Contract, Unsafe Basics, Raw Pointers, The Rust Memory Model, Working with MaybeUninit, Sound Abstractions over Unsafe, FFI-Safe Types, ...

11 pages

Fearless Concurrency in Rust, Concurrency Basics, Send & Sync, Channels, Mutex & RwLock, Arc for Shared State, Atomics & Ordering, Scoped Threads, ...

Async & Futures

11 pages

The Rust Async Model, Async Basics, The Future Trait, Executors & Runtimes, Pinning & Unpin, async fn in Traits, Streams, Combining Futures, ...

11 pages

Tokio's Runtime Model, Tokio Basics, Tasks & JoinHandles, Async I/O, Channels in Tokio, select! & Concurrency, Timers & Intervals, Shared State in Async, ...

11 pages

How Cargo Thinks About Dependencies and Builds, Cargo Basics, Cargo.toml Explained, Features & Optional Dependencies, Profiles & Build Settings, Workspaces, ...

12 pages

The Rust Testing Model, Testing Basics, Unit vs Integration Tests, Doctests, Test Organization, Mocking & Test Doubles, Property-Based Testing, Snapshot Testing, ...

Linting & Formatting

9 pages

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

11 pages

Reasoning About Performance in Rust, Performance Basics, Benchmarking & Profiling, Understanding Allocations, Zero-Cost Abstractions, Avoiding Clones, ...

10 pages

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

11 pages

Rust Design Patterns, Rust Patterns Basics, The Newtype Pattern, Builder Pattern, Typestate Pattern, RAII & Drop Guards, From/Into & TryFrom, ...

9 pages

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, ...

Architecture & Design

11 pages

Architecting Rust Systems, Architecture Decision Checklist, Workspace & Crate Boundaries, Error Strategy, Trait-Based Abstraction, Domain Modeling with Types, ...

11 pages

Diagnosing Rust Compiler and Runtime Errors, Borrow-Checker Error Scenarios, Lifetime Mismatch Scenarios, Move-After-Use Scenarios, Send/Sync & Thread Errors, ...

12 pages

The Rust Web Backend Model, Web Backends Basics, Axum Routing & Handlers, Extractors & State, Middleware & Tower, Error Handling in Handlers, Request Validation, ...

10 pages

How Serde's Serialization Model Works, serde Basics, JSON with serde_json, Other Formats, Customizing Serialization, Custom (De)serialization, Enums & Tagging, ...

11 pages

Talking to Databases from Rust, Databases Basics, sqlx, Diesel, SeaORM, Migrations, Connection Pooling, Transactions & Isolation, Redis & Key-Value, ...

HTTP & Networking

9 pages

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

11 pages

The API Security Model in Rust, API Design Basics, GraphQL in Rust, JWT & OAuth2, Password Hashing, Secrets Management, Cryptography (ring / RustCrypto), ...

10 pages

Building CLIs the Rust Way, CLI Basics, clap, Configuration & Env, Terminal Output, TUIs with ratatui, Error Reporting, Shell Completions & Man Pages, ...

10 pages

Rust as a Systems Language, Systems Basics, libc & Syscalls, C Interop with bindgen, Exposing Rust to C (cbindgen), Working with Raw Memory, ...

10 pages

Rust's WebAssembly Model, WebAssembly Basics, wasm-bindgen, wasm-pack & Bundling, DOM & Web APIs (web-sys), Frontend Frameworks (Leptos / Yew), WASI, ...

10 pages

Rust in Embedded and no_std Environments, Embedded Basics, no_std Programming, embedded-hal, Microcontroller Peripherals, Interrupts & Concurrency, ...

9 pages

Embedding and Being Embedded: Rust Interop, Interop Basics, PyO3, maturin, Exposing a Rust Library to C/C++, Node.js with napi-rs, ...

10 pages

Rust's High-Performance Data Model, Data Basics, Apache Arrow, Polars, DataFusion, CSV/Parquet I/O, Streaming & Large Data, Building Data CLIs & Services, ...

11 pages

Machine Learning in Rust: The Landscape, ML in Rust Basics, candle, burn, ONNX Runtime (ort), Tokenizers, LLM Inference & Serving, Embeddings & Vector Search, ...

10 pages

Rust in Blockchain and Cryptography, Blockchain Basics in Rust, Solana Programs, Substrate & ink!, Applied Cryptography, Wallets & Key Management, ...

9 pages

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

10 pages

Rust Game Development Architecture, Game Dev Basics, Bevy Engine, Assets & Scenes, Input & Events, Graphics with wgpu, Physics & Audio, Game Loops & Timing, ...

Essential Crates

12 pages

The Rust Ecosystem's Core Crates, serde, tokio, anyhow & thiserror, tracing, clap, rayon, reqwest & sqlx, chrono & time, itertools & rand, ...

Deployment & Ops

10 pages

Shipping Rust Binaries to Production, Deployment Basics, Cross-Compilation, Minimal Docker Images, musl & Static Linking, CI/CD for Rust, ...

10 pages

Using Agent Skills for Rust Development, Axum Service Skill, Async / Tokio Skill, Unsafe Review Skill, WASM Skill, Embedded Skill, Crate Publishing Skill, ...

9 pages

The Git Mental Model for Rust Teams, Essential Git Commands, Branching & Merging, Merge Conflict Resolution Checklist, Git Worktrees, GitHub CLI, ...

9 pages

The Linux Command-Line Model for Rust Developers, Sysadmin Essentials, rustup & Toolchain Management, Build & Inspect Tooling, Search & Regex, ...

Team & Onboarding

7 pages

Onboarding and Team Conventions for Rust Codebases, Onboarding Devs Checklist, Toolchain Setup Checklist, Codebase Orientation, Conventions & Style Guide, ...

Incident Response

8 pages

The Incident Response Mental Model for Rust Services, Production Debugging, Incident Response Playbooks, Blameless Post-Mortems & RCA, ...

Enterprise Delivery

8 pages

Enterprise Delivery Practices for Rust Teams, Release Management, Feature Flags & Progressive Delivery, Rollback Strategies, DORA Metrics, ...

Technical Leadership

9 pages

Technical Leadership Fundamentals, Technical Decision-Making, Architecture Decision Records (ADRs), Running Design Reviews, Code Review Culture, ...

Product & Stakeholders

8 pages

Working with Product and Stakeholders as a Rust Engineer, Requirements to Technical Specs, Prioritizing Platform & Tech Debt, Estimation & Risk, ...

8 pages

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, ...

9 pages

Governance Models for Rust Codebases, Coding Standards & API Guidelines, Documentation Conventions, Contribution Guidelines, Unsafe & Dependency Governance, ...