Huiali

This skill provides a fast entry point to navigate and query Rust skills, enabling quick access to core, advanced, and expert entries.

This skill helps design and optimize Rust actor systems for reliable message passing, isolation, and fault tolerance using supervision 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 Rust engineers leverage const generics, const fn, and compile-time validation to optimize performance and safety.

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 helps optimize GPU memory management and CUDA/OpenCL workflows in Rust engineering, enabling efficient data transfer, memory access, and kernel

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 engineers harness Rust macros and proc-macros to reduce boilerplate, improve compile-time checks, and generate robust, reusable code patterns.

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

This skill helps Rust engineers diagnose, design, and optimize concurrent and async code, ensuring thread safety, deadlock prevention, and efficient runtime

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 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 you implement and optimize advanced Rust async patterns, including streams, backpressure, cancellation, and join operations, across real-world

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

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