C++ plugins

Scaffold, write, and optimize systems-level code in Rust, Go, C, and C++ with agents and skills for memory safety, concurrency (goroutines, Tokio async), and production project setup

Write systems-level code in C++, Go, and Rust with idiomatic patterns, concurrency, memory safety, and performance profiling for production-ready services, CLIs, and libraries.

Build NVIDIA-powered workflows across GPU acceleration, CUDA, AI inference, robotics, Omniverse USD scenes, and Physical AI — from setup and validation to deployment and optimization on Docker, Kubernetes, or Azure.

Provides 48 domain-specific skills and 9 agents for Godot 4.x game development in GDScript and C#, covering 2D/3D systems, animation, AI, UI, multiplayer, performance optimization, and editor tooling.

Code, review, and document Qt C++ and QML projects with AI-assisted linting, deep-analysis agents, and live Qt API lookups via an MCP server. Generates QML components from Figma, runs performance profiling, and produces unit tests and reference documentation.

Enforce readability rules like short functions, flat control flow, and idiomatic patterns in C/C++/Rust/CUDA code while writing, reviewing, or refactoring. Fetch precise examples from cppcheatsheet for modern C11-C23/C++11-C++23 features, CUDA GPU computing, system programming, debugging tools, and Rust interop to write correct code or prep for interviews.

Guide end-to-end Xilinx/AMD FPGA and MPSoC development workflows from high-level C/C++ algorithm synthesis in Vitis HLS, through Vivado hardware design with Block Design/IP/XDC/bitstream generation and Vitis embedded software, to PetaLinux Linux boot image builds. Activates on Vivado/FPGA/Zynq mentions.

Automates the full lifecycle of migrating and optimizing AI models for Huawei Ascend NPUs: environment setup, code analysis and adaptation, operator development (AscendC/Triton), distributed training with MindSpeed/Megatron, performance profiling and tuning, precision verification, and deployment as vLLM inference services.

A scaffolded game development workflow for Claude Code that enforces production-quality conventions across art, audio, design, code, and release pipelines for Unity, Unreal, Godot, and web projects. Provides layered rules, specialized agents, and reusable skills to keep asset pipelines consistent, performance budgets tracked, and builds release-ready without per-asset fixes.

Review and improve Rust projects with deep checks for ownership, lifetimes, async/tokio, serde, sqlx, axum, FFI, macros, unsafe code, and testing patterns — including git-diff auditing, false-positive verification, and project scaffolding with linting and CI.

Generates property-based tests with random inputs and automatic failure shrinking for Rust, Go, C++, and TypeScript projects using the Hegel framework.

Integrate security into AI development workflows with skills for fuzzing, static analysis, MCP server hardening, cryptography auditing, Kubernetes security, and supply chain verification.

Integrate C++ libraries like SQLite, OpenCV, or OpenSSL into JavaScript/TypeScript projects running in browsers, Node.js, React Native, or Cloudflare Workers via the cpp.js WebAssembly runtime. Detect frameworks like Next.js or Vite to apply tailored integration playbooks, scaffold reusable pnpm-installable cpp.js packages with CMake, troubleshoot configurations, and fix monorepo bugs.

Embedded firmware development lifecycle: compile, flash, debug, monitor, and analyze for STM32/ESP32/RISC-V MCUs across CMake, Keil, IAR, ESP-IDF, PlatformIO, and Makefile build systems. Multi-agent competition mode orchestrates architecture, driver implementation, application logic, MATLAB algorithm export, verification, and report generation with layered architecture enforcement and Git-backed rollbacks.

Build, test, and refactor MoonBit projects with agent-assisted workflows for FFI bindings, formal specifications, proof-carrying code, and migration from OCaml.

Enforce uniform contributing standards for the IOWarp/Clio C++ ecosystem: automated git branch naming, commit message formatting, PR validation, and pre-commit checks for compilation, tests, formatting, and licensing.

Equips AI assistants with skills to use the Xmake build system across 50+ areas, enabling them to configure, build, test, package, and cross-compile C/C++ and other-language projects, manage dependencies, set up toolchains, write custom scripts, and optimize build performance.

Run 50+ OWASP security checks against codebases during development — detecting injection flaws, broken authentication, cryptographic misuse, prompt injection, SSRF, and supply-chain risks across web, API, and LLM applications — with automated fix generation and attack chain analysis

Bootstrap JUCE audio plugin projects from template, integrate Visage GPU-accelerated UI for macOS/iOS, add iOS app targets, build/test/sign/notarize across macOS/Windows/Linux via CMake and GitHub Actions, manage test VMs, set up auto-updates, generate themes, and create GitHub Pages download pages.

Port games and engines to Apple platforms (macOS, iOS) by translating graphics code from D3D12/Vulkan/OpenGL to Metal 4, compiling HLSL/DXIL shaders to metallib, integrating MetalFX temporal upscaling and frame interpolation, validating and debugging GPU correctness with GPU traces and Metal validation, and managing the full porting lifecycle via a milestone-based assistant agent.

Generate, troubleshoot, and optimize ESPHome YAML configurations for ESP32/ESP8266 IoT devices with Home Assistant integration. Handle sensors, relays, displays, I2S audio pipelines on ESP32-S3-BOX-3, networking, OTA updates, C++ lambdas, automations, triggers, and bidirectional entity syncing via specialized agents.

Perform structural find, replace, delete, and insert operations on code using AST-aware patterns instead of regex, enabling safe renaming of functions, changing API signatures, or removing logging statements across multiple languages.

Reference the full CBLAS and LAPACKE C APIs from LAPACK v3.12.1 to implement high-performance numerical linear algebra in C/C++ projects, covering 1284 functions for vector/matrix operations, linear solvers, eigenvalue computations, SVD, least squares, and factorizations. Accelerate API lookups, code generation, library linking, and solver selection in scientific computing workflows.

Reference the complete llama.cpp C/C++ API to load GGUF models, run local LLM inference, generate text and embeddings, handle chat sessions, apply advanced sampling like XTC and DRY, manage per-sequence states, integrate LoRA adapters, and troubleshoot C/C++ AI workflows.

Build a VillageSQL (VSQL) extension for MySQL end-to-end via a 7-phase persona-driven workflow using C++ or Rust, with dynamic VEF API discovery from live SDK sources.

Develop and manage Memgraph graph databases: write Cypher queries with Memgraph-specific extensions, build custom query modules in C++, Python, or Rust, design graph data models, configure triggers and storage, run graph algorithms, and build GraphRAG systems with hybrid retrieval.

Implement machine learning inference and training in C/C++ using ggml tensor library: build computation graphs, manage GGUF model I/O, apply quantization like Q4_0 or Q5_K, and accelerate with CPU, CUDA, Metal, or Vulkan backends via 560+ optimized functions.

Develop cross-platform GPU/CPU parallel computing applications in C/C++ with OpenCL SDK, managing devices, contexts, queues, kernels, buffers, images, programs, and using C++ bindings for heterogeneous acceleration.

Develop high-performance GPU compute applications on AMD hardware using ROCm's HIP kernels, rocBLAS/rocFFT/rocSPARSE libraries for linear algebra and transforms, rocprof for performance profiling, CUDA-to-HIP code porting, CMake/Makefile builds, and rocGDB debugging.

Build GPU-accelerated applications by writing CUDA C/C++ kernels and integrating NVIDIA libraries like cuBLAS for linear algebra, cuFFT for Fourier transforms, cuSPARSE for sparse operations, cuRAND for random numbers, cuSolver for linear systems, Thrust for STL-like parallelism, and Cooperative Groups for fine-grained control.

Build, test, debug, and ship audio plugins and apps with the Pulp framework, including cross-platform builds, DSP validation, UI prototyping, CI automation, and release packaging

Scan object-oriented source code in Python, Java, TypeScript, C#, C++, Kotlin, Go, or Rust for SOLID principles violations using subcommands like `solid srp`. Receive severity-rated findings pinpointing issues with file locations and actionable refactoring suggestions to enforce Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion.

Trace PyTorch operator implementations across Python, C++, and CUDA layers, analyze nn.Module-to-native binding chains, map code changes to affected tests, and query dispatch mechanisms.

Extend Claude Code with 190+ battle-tested skills, commands, agents, and hooks for multi-language development, testing, security, automation, and documentation. Covers TypeScript, Python, Go, Rust, Kotlin, Java, C++, and more with TDD workflows, code review, CI/CD patterns, and autonomous agent orchestration.

Automate udcp development workflows in GoFrame projects by performing rated code reviews on Git commits and Gerrit changes for Go, C++, Ansible; enforcing layered architecture, validation, and API standards; standardizing Ginkgo/Gomega unit tests with Docker MySQL templates; and diagnosing remote Kubernetes, Docker, and Linux server issues via SSH with reports.

Develop STM32 firmware with AI agents that generate HAL peripheral init code, debug HardFaults and bus issues, search full documentation, optimize low-power modes, configure bootloaders and security, analyze safety compliance, and review hardware designs.