Rust plugins

Automate technical debt reduction, dependency updates, and code refactoring by scanning for vulnerabilities and code smells, generating prioritized remediation plans, and leveraging AI-powered test automation and code review.

Run comprehensive security analysis: SAST vulnerability detection across multiple languages, dependency scanning with automated remediation, threat modeling (STRIDE/attack trees), container and cloud security hardening, and compliance checks (OWASP Top 10, GDPR/HIPAA/SOC2) — all automated through CLI commands and agents.

Write safe, concurrent systems code across Rust, Go, C++, and C with production patterns for memory management, async/await, and concurrency, plus scaffolding and expert agents for each language.

Accelerate full-stack development with 66 specialized skills covering 12 languages, frontend/backend frameworks, infrastructure, DevOps, security, and testing, plus Jira/Confluence project management commands for epic planning, discovery, and retrospectives.

Audit dependencies across multiple languages for vulnerabilities, license issues, and outdated packages, with actionable remediation strategies. Also modernizes legacy codebases through safe, incremental framework migrations and dependency updates.

Write modern, memory-safe systems code in C++, Go, and Rust with idiomatic patterns for concurrency, RAII, smart pointers, and performance optimization.

Provides a team of specialized expert agents that each deep-dive into specific languages and frameworks—from Angular and React to Rust, Go, Java, Swift, and more—so you can delegate complex, language-specific tasks like architecture design, performance optimization, and enterprise patterns to the right expert on demand.

Build, test, and secure Solidity smart contracts for DeFi protocols and NFT platforms, with templates for staking, AMMs, governance, lending, flash loans, and ERC-721/ERC-1155 standards, plus Hardhat/Foundry testing and security auditing.

Guides developers through building GUI applications with the Makepad framework in Rust, covering project setup, widget layout, event handling, shader effects, and cross-platform packaging for desktop, mobile, and web.

Package any website or local web build into a lightweight ~5MB desktop app using Pake's CLI. Customize icons, bundle IDs, proxy settings, and output JSON for automated workflows.

Write high-performance, memory-safe systems code in C++, Go, and Rust with idiomatic patterns for concurrency, resource management, and modern language features.

Guides developers through building GUI applications with the Makepad framework in Rust, covering project setup, widget layout, event handling, custom shaders, and cross-platform packaging for desktop, mobile, and web.

Get full Rust code intelligence — diagnostics, go-to-definition, find references, and type information — directly in Claude Code for .rs files.

Write safe systems code by applying RAII, ownership, smart pointers, and resource management patterns across Rust, C++, and C, preventing memory bugs and managing resources.

Master Rust async with Tokio: async traits, error handling, concurrent patterns. Build async Rust apps, implement concurrent systems, or debug async code.

Scans codebases for security vulnerabilities using CodeQL and Semgrep static analysis. Automatically creates databases, runs query suites, processes SARIF output, and integrates findings into CI/CD pipelines.

Fuzz C/C++, Rust, Python, and Ruby code with coverage-guided fuzzers (libFuzzer, AFL++, cargo-fuzz), detect memory errors via sanitizers, and set up continuous fuzzing with OSS-Fuzz. Includes static analysis with Semgrep and CodeQL, timing side-channel detection, and cryptographic test vectors.

Audit smart contracts across 6 blockchains (Ethereum/Solidity, Solana, Cosmos, Substrate, Algorand, TON, StarkNet) using Trail of Bits' Building Secure Contracts framework. Runs automated vulnerability scans, generates security documentation, assesses codebase maturity, and guides secure development workflows.

Audit project dependencies for known vulnerabilities, outdated packages, and license compliance across Node.js, Python, PHP, Ruby, Go, and Rust, generating detailed reports with CVEs, upgrade paths, and recommended fixes.

Work with Azure services from Rust: authenticate via Entra ID, manage Key Vault secrets/keys/certificates, use Cosmos DB (NoSQL), Blob/Queue Storage, Event Hubs, and Service Bus for messaging and streaming data.

Map state-changing entry points in smart contracts (Solidity, Vyper, Solana/Rust) by access level for security audits. Generates structured audit reports categorizing externally callable functions that modify state.

Build multi-language source code graphs for security analysis, including call graphs, attack surface mapping, blast radius, taint propagation, and complexity hotspots. Generate Mermaid diagrams, compare graph snapshots for structural diff, triage mutation testing results, and extract crypto protocol flows into ProVerif formal verification models.

54 domain-specific skills and 9 agents for Godot 4.x game development in GDScript and C#, covering 2D/3D rendering, AI, animation, UI, multiplayer, performance optimization, editor tooling, and project architecture across the full game development lifecycle. Includes code review, debugging, and testing workflows.

Generate pre-configured devcontainers with Claude Code integrated alongside Python, Node, Rust, or Go tooling, including persistent volumes for sandboxed development.

Configure mutation testing campaigns using mewt or muton, including scoping targets, tuning timeouts, and optimizing long-running runs to improve code quality.

Delegate coding tasks to expert AI agents specialized in Python, Go, Rust, Java, JavaScript, PHP, Ruby/Rails, C/C++, SQL, and TypeScript. They proactively write idiomatic code, refactor for performance, implement advanced features like concurrency and generics, add tests with pytest or RSpec, optimize queries/schemas, and handle builds like Cargo.toml or CMake.

Build and review Freya Rust GUI applications with guided best practices on components, hooks, element builder patterns, and project conventions.

Provides comprehensive Rust development assistance: resolves ownership/borrow/lifetime errors, guides crate selection and integration, enforces coding guidelines, generates crate documentation skills from docs.rs, runs clippy and safety audits, visualizes dependency trees and call graphs, and offers domain-specific patterns for web services, CLI, embedded, fintech, IoT, and ML/AI.

Audits C/C++/Rust code for missing or compiler-optimized zeroization of cryptographic secrets using LLVM IR/assembly analysis, data-flow tracking, and control-flow verification to ensure sensitive data is properly wiped.

Manage Ubiquiti UniFi networks from Claude Code: configure VLANs, SSIDs, firewalls, NAT, and DHCP; audit security posture; monitor controller health and device status; automate infrastructure tasks via an autonomous agent.

Perform fast structural code search across 15+ languages using SQLite+FTS5 for symbol lookup, implementations, usages, class hierarchy, and project map.

Profile API endpoints and benchmark code implementations across multiple runtimes to identify performance bottlenecks, comparing metrics like latency, ops/sec, and memory usage.

Drive full-cycle project development: brainstorm ideas, create specifications, plan architecture, scaffold projects, execute implementation, and enforce quality gates — all with automatic state tracking and resume support.

Automates git workflows including conventional commits, stacked branches, PR preparation and review, changelog generation, and version management. Also handles documentation consolidation, dependency updates, test generation, and workflow self-improvement through retrospective analysis.

Build and debug custom visuals for Power BI using Deneb (Vega/Vega-Lite), Python (matplotlib/seaborn), R (ggplot2), SVG via DAX, and distributable .pbiviz packages with the pbiviz CLI.

Scaffold production-ready projects with configurable stacks (TypeScript, Python, Go, Rust) and add feature modules (CRUD, services, CLI commands, UI components) with auto-generated tests and wiring.

Audit project dependencies for vulnerabilities, licensing, and maintenance issues, then safely update them with automatic categorization, changelog review, compatibility verification, and test validation.

Execute trades on Taiwan equity and derivatives markets (TWSE/TPEX/TAIFEX) through Shioaji's Python binding, CLI tool, or HTTP API server with server-sent events for real-time market data and order handling.

Perform security code reviews across all languages using Project CodeGuard and OWASP rules, produce markdown reports with prioritized findings, and guide migration of C/C++/Assembly code to memory-safe languages like Rust, Go, Java, C#, or Swift.

Orchestrate medical research workflows: intake projects, discover meta-analysis topics, audit study designs, generate reproducible analyses, check manuscript compliance with reporting guidelines, and prepare submission-ready documents.

Access a comprehensive C/C++ reference with modern standard coverage, CUDA GPU computing, system programming, debugging, and Rust interop examples. Enforce readability rules for C, C++, Rust, and CUDA code during writing, review, or refactoring.

Manage Qdrant vector search deployments end-to-end: scaling, performance tuning, search relevance optimization, multitenancy, zero-downtime upgrades, embedding model migration, monitoring with Prometheus/Grafana, and Edge deployment for local vector search

Run structured, multi-domain code reviews with blast radius analysis, architecture evaluation, security audits, and test coverage checks across Rust, Python, shell, and Makefiles.

Fast structural code search across polyglot projects using ast-index CLI — find symbols, classes, usages, implementations, hierarchies, and dependencies in Android/Kotlin/Java, iOS/Swift/ObjC, TypeScript/JavaScript, Rust, Ruby, C#, Python, Go, and more.

Automate the full Git and GitHub coding workflow: intelligent commits, branch cleanup, PR management, changelog and README generation, CLAUDE.md maintenance, and GitHub Actions setup

AI-powered markdown editor that integrates OpenAI Codex for code generation and assistance, with local Tauri app development tools for project management and builds.

Improve Rust code quality and performance using 265 AI-driven rules covering ownership, error handling, async, concurrency, unsafe code, API design, memory management, and testing.

Enforces a verification-first engineering workflow across investigation, design, implementation, verification, and shipping phases with structured skills, specialist agents, and evidence requirements for senior ICs and tech leads.

A Chinese-language toolkit for developer workflows: architecture analysis, code review, git automation, performance optimization, error diagnosis, documentation management, and dependency updates with specialized expert roles.

Spanish-language command and role collection for code analysis, refactoring, PR management, dependency updates, and architectural reviews across multiple stacks.

Boost development productivity with a Portuguese-language command and role collection for code analysis, performance audits, git workflow automation, dependency management, and documentation generation in Claude Code.

Analyze code quality, security, and architecture across projects with specialized agents for dependency analysis, PR review, performance auditing, and technical debt quantification. Generate structured plans, commit messages, and documentation in Japanese or English.

Interactively debug source code by setting breakpoints, stepping through execution, inspecting live variables, evaluating expressions, and tracing root causes for crashes, exceptions, or wrong output.

Run CodSpeed benchmarks to measure and optimize code performance with flamegraph analysis and iterative improvement. Automatically detects your project's language, sets up the appropriate benchmarking framework, and configures CI for continuous performance tracking.

Enforce a dual-review, state-machine-gated development workflow with hook-enforced code review, pre-commit checks, test coverage analysis, and fail-closed safety gates across feature development, bug fixes, and refactoring.

Automate code review with language-aware analysis, pre-commit verification for staged changes, and multi-specialist deep reviews that post to GitHub or GitLab. Supports Go, Python, Rust, TypeScript, Java.

Set up, upgrade, and review smart contracts across multiple platforms (Solidity, Cairo, Soroban, Stylus, Sui Move) using OpenZeppelin libraries. Supports scaffolding, dependency management, proxy upgrades (UUPS, Transparent, Beacon), and code review for security.

Run a comprehensive cybersecurity audit on any local project. Detects code security flaws, dependency vulnerabilities, secret leaks, authentication/authorization issues, cryptographic weaknesses, misconfigurations, supply chain risks, and CI/CD security gaps. Outputs a prioritized report with actionable remediation steps.

Adds Rust language server support to Claude Code, enabling code completion, diagnostics, and refactoring for Rust projects.

Route every LLM call through the cheapest viable path using BitRouter, an LLM proxy that unifies OpenAI, Anthropic, Google, OpenRouter, GitHub Copilot, and OpenCode behind one endpoint for cost-optimized agentic loops.

Develop Makepad 2.0 GUI applications with Rust and Splash scripting, covering layout, widgets, themes, animations, events, shaders, migration from 1.x, and performance debugging

Offload RTOS, bare-metal, firmware, and IoT development to specialized agents—handle system architecture, device drivers, bootloaders, OTA updates, edge computing, and sensor integration.

Guides embedded hardware debugging for probe-rs targets (ARM Cortex-M, RISC-V) via CLI or MCP server, supporting flash, RTT, fault diagnosis, and OpenOCD backend for chips like ESP32.

Accelerate development with subagent-based parallel execution, TDD enforcement, git automation, structured planning, and code review across any codebase.

Develop and manage Apollo GraphQL applications across the full stack: build servers with Apollo Server, client apps with Apollo Client (React, iOS, Kotlin), federated schemas, router configuration, and schema design. Includes MCP integration with Apollo GraphOS and LSP for GraphQL files.

Auto-detect your project's tech stack from configuration files and generate a CLAUDE.md file with curated coding standards for TypeScript, React, Python, Go, and Rust.

Explore, map, and document unfamiliar codebases using static analysis, AST navigation, and semantic search. Generate blast-radius reports, interactive code maps, feature documentation, and knowledge graphs with bidirectional source anchoring. Perform semantic code searches and Python-specific symbol resolution via pyright and tree-sitter.

Automate and test Tauri v2 applications from the terminal: start driver sessions, control webviews, capture UI state and screenshots, execute JavaScript, debug IPC, and manage mobile or remote devices.

Enforce Rust style guidelines for IDALIB bindings contributions, covering imports, naming, accessors, error handling, borrowed types, and module layout

Reference documentation and usage guidance for Thermite, a generic Rust SIMD library with companion crates for special functions, autodiff, compensated arithmetic, SDF, and geometry. Helps developers write SIMD kernels generic over vector types and run them on any backend.

Generate production-grade Solana programs with Anchor/Quasar, Rust, and TypeScript, including onchain math, escrows, AMMs, vaults, oracle freshness, and slippage, plus LiteSVM tests and config files.

Automate statistical software development with multi-agent teams that plan, implement, test, and ship R/Python packages via GitHub workflows, including Monte Carlo simulation studies and knowledge sharing across sessions.

Write, understand, and debug Rust code with ownership, async patterns, and robust error handling, backed by rust-analyzer's code intelligence for real-time diagnostics and navigation.

Validates multi-language tool installations across Python, Node.js, Java, Go, Rust, and C/C++; generates HTML artifacts and Preact SPAs; creates MCP servers and bookmarklets; produces git patches for local application; and queries Markdown documents structurally.

Generate idiomatic, production-ready backend code for common primitives (kv, queue, pubsub, etc.) using forgelib, with verified API calls enforced across Rust, Node, Python, and Postgres.

Accelerate game development with specialized agents for engine architecture, gameplay systems, performance profiling, and tooling, enabling rapid prototyping and optimization of real-time interactive experiences.

Index and explore codebases with tree-sitter: locate function definitions, trace cross-file callers, discover tests, and perform scope-aware grep for precise symbol extraction.

Enforces a consistent code and writing style across TypeScript, React, PostgreSQL, and testing, with property-driven design, defense-in-depth validation, and Functional Core/Imperative Shell patterns.

Guides developers through configuring tsk Docker container images for their project, including detecting project stacks (Rust, Go, Node, Python, Java, Lua), migrating deprecated Dockerfiles to tsk.toml layers, running dry-run builds, and troubleshooting issues.

Provides 70+ slash commands organized across 12 development phases, with specialized agents for Rust, Python, Go, JavaScript, Bash, FastAPI, documentation, performance analysis, real-time systems, and subagent creation, plus a Dagger-based safety system and multi-dimensional validation.

Automatically maintains CLAUDE.md and AGENTS.md memory files by analyzing codebase structure, detecting frameworks, and updating memory sections as files change, with configurable sync, commit, and push settings.

Run a full audit-firm lifecycle for Solana/Anchor programs and any-language codebases: automated + interactive audits with 1,346+ checklist items across 20 domains, differential PR scanning, economic exploit quantification, PoC generation, verified fix patches, and professional report assembly with maturity scorecards.

Automates the full feature development lifecycle—from PRD and design through implementation, testing, and acceptance—for Rust, React, Flutter, and miniapp projects using DDD-driven workflows and specialized sub-agents.

Sync solana-keychain dependency versions and auto-generate signer adapter scaffolding for new signer types discovered in the upstream crate. Also bundles code repositories into a single file for LLM context sharing.

Enforce AI-first code conventions, audit staged diffs for OWASP security issues, generate architecture docs and session summaries, and check tool-stack freshness — all via skills, hooks, and agents that complement other plugins.

Develop on the Stellar blockchain end-to-end: write and deploy Soroban smart contracts in Rust, issue and manage assets, build dApp frontends with wallet integration, query chain data via RPC/Horizon, implement ZK proofs, and navigate SEPs/CAPs for payments, KYC, and token interfaces.

Configure and apply Clippy lints for Rust projects, including custom lint development, workspace setup, and lint group configuration to enforce code quality standards.

Build and maintain Vovk.ts TypeScript RPC backends for Next.js — scaffold projects, define typed procedures with Zod/Valibot validation, configure decorator-based routing, generate OpenAPI specs, and auto-create type-safe clients for JavaScript, Python, and Rust. Includes CLI scaffolding, multi-tenant setup, streaming endpoints, LLM tool definitions, and npm/crates.io/PyPI publishing workflows.

Review Rust code patterns for ownership, lifetimes, error handling, unsafe code, FFI, macros, async runtime, web frameworks, serialization, and database queries. Scaffold new projects with linting and CI best practices. Verify findings with a multi-step protocol to reduce false positives.

Generates production-ready Dockerfiles with multi-stage builds, security hardening, and docker-compose for local development across Node.js, Python, Go, Rust, Java, and Ruby applications. Activates on requests like 'create Dockerfile' or 'dockerize this'.

Map backend routes, middleware stacks, database models, dependencies, and auth mechanisms, and assess code quality for project takeover

Design, audit, and optimize embedded/IoT firmware: generate architecture specs, device drivers, OTA update systems, and power management plans; assess code quality, security, and debug artifacts for MCU platforms like ESP32, STM32, nRF52.

Generate complete GitHub Actions CI/CD pipelines from project analysis, including lint, test, build, and deploy stages for Node.js, Python, Go, Rust, and Java stacks.

Audit power management in embedded and IoT firmware by analyzing sleep modes, wake sources, power state machines, radio duty cycles, and battery life estimates to diagnose battery drain and optimize power budgets.

Write property-based tests across Rust, Go, C++, and TypeScript projects using Hegel, generating random inputs and shrinking failures to minimal counterexamples.

Implements an ADR-driven 4-phase development workflow (preflight, implementation, formatting, release) with polyglot monorepo scaffolding, code quality enforcement, dependency management, and release automation.