Build High-Performance Rust Applications

Expert-level guidance for modern Rust (1.75+) development: advanced type-system features (const generics, generic associated types, procedural and declarative macros), ownership and memory management (borrowing, Rc/Arc/weak references, Box/RefCell/Mutex/RwLock, custom allocators, zero-sized types), async programming and concurrency on Tokio (streams, mpsc/broadcast/watch channels, the axum/tower/hyper web stack, backpressure handling), performance and systems programming (SIMD via portable-simd, lock-free atomics, cache-friendly data structures, profiling with perf/valgrind/cargo-flamegraph), web-service development (axum, warp, actix-web, HTTP/2-3 via hyper, sqlx/diesel, serde, async-graphql, tonic gRPC), error handling (thiserror, anyhow, Result/Option combinators), testing (built-in tests, proptest/quickcheck property-based testing, mockall, criterion.rs benchmarks, tarpaulin coverage), unsafe code and FFI (safe abstractions, bindgen, invariant documentation), and modern tooling (Cargo workspaces, Clippy, rustfmt, cargo-audit/deny/outdated).

Use it when building Rust services, libraries, or systems tooling, or solving ownership, lifetime, or async design issues that need memory-safety guarantees alongside performance. Not a fit for a quick throwaway script, a dynamic-runtime use case, basic Rust syntax questions, or a stack that cannot introduce Rust at all.

Input: a Rust design or implementation problem - a new service, a performance hotspot, a lifetime or ownership error, or an unsafe/FFI boundary needing a safe wrapper. Output: type-safe APIs with comprehensive error handling, efficient implementations using zero-cost abstractions, unit/integration/property-based tests, documented safety invariants for any unsafe code, and profiling-driven performance optimizations - following a response approach that analyzes requirements, designs the API, implements it, tests it, and documents unsafe blocks in that order.

Centers on the Tokio async runtime and its ecosystem (axum, tower, hyper), web frameworks warp and actix-web, database crates sqlx and diesel, serde for serialization, thiserror/anyhow for error handling, proptest/quickcheck/mockall/criterion.rs/tarpaulin for testing, and Cargo tooling (Clippy, rustfmt, cargo-audit/deny/outdated, bindgen for FFI).

Developers building performance-critical, memory-safe Rust services or libraries who need expert-level guidance across async, systems programming, and the modern Rust ecosystem, not basic syntax help.

Its stated behavioral traits favor leveraging the type system for compile-time correctness, avoiding runtime overhead through zero-cost abstractions, and documenting unsafe code with explicit safety invariants over ad hoc comments. Representative requests it's built to handle include designing a lock-free concurrent data structure with atomic operations, building a safe FFI wrapper around a C library, and debugging lifetime issues in complex generic code. It likewise expects to design streaming data processors with backpressure handling and plugin systems combining dynamic loading with compile-time type safety.