Rust skills

This skill explains and optimizes Rust smart pointers and resource management with practical examples for Box, Rc, Arc, RefCell, and Drop.

This skill helps you implement safe Rust FFI with C/C++ bindings, generate bindings, and design robust interop patterns.

This skill helps you optimize Rust performance by guiding profiling, memory layout, and NUMA-aware strategies to reduce hot-path costs.

This skill helps engineers harness Rust macros and proc-macros to reduce boilerplate, improve compile-time checks, and generate robust, reusable code patterns.

This skill helps design and optimize Rust actor systems for reliable message passing, isolation, and fault tolerance using supervision patterns.

This skill helps you design, analyze, and optimize Rust eBPF workflows, from maps and tail calls to kprobes, improving kernel tracing and performance.

This skill analyzes Rust ownership patterns, diagnoses common errors, and guides safe borrowing, lifetimes, and memory management to prevent compile-time

This skill helps optimize GPU memory management and CUDA/OpenCL workflows in Rust engineering, enabling efficient data transfer, memory access, and kernel

This skill helps you diagnose and optimize Rust code by guiding ownership, lifetimes, concurrency, and async patterns with practical examples.

This skill analyzes Rust interior mutability patterns and guides safe, efficient use of Cell, RefCell, Mutex, and RwLock across single- and multi-threaded

This skill helps you design and implement Rust web services with axum, actix, and domain-driven patterns for scalable APIs.

This skill helps you enforce Rust coding conventions and idiomatic patterns with naming, spacing, clippy, rustfmt, and documentation practices.

This skill analyzes and applies linear type principles to Rust ownership, ensuring resource safety, unique ownership, and deterministic destruction.

This skill helps Rust engineers leverage const generics, const fn, and compile-time validation to optimize performance and safety.

This skill helps engineers write safer, higher-performance unsafe Rust code by enforcing SAFETY comments, validating patterns, and guiding FFI and pointer use.

This skill helps you implement and optimize advanced Rust async patterns, including streams, backpressure, cancellation, and join operations, across real-world

This skill helps you apply DCjanus preferences to select libraries and usage scenarios across Python, Rust, and Go.

This skill helps you bootstrap a polyglot monorepo from scratch, wiring Python, Rust, and Bun with autonomous 9-phase workflows.

This skill helps you integrate hREA GraphQL mappings with ValueFlows, enabling proposal creation, prerequisite management, and automatic retry of queued items.

This skill guides you in writing and debugging unit and integration tests, mocking services, and testing Tryorama scenarios.

This skill guides Stellar and Soroban development end-to-end, enabling secure asset issuance, dApp frontends, and RPC-driven integrations.