C++ plugins

Build secure, high-performance systems software with memory-safe patterns in Rust, C, and C++, and leverage advanced Go concurrency for scalable microservices and APIs.

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 and deploy NVIDIA-powered workflows across GPU acceleration, CUDA, AI inference, robotics, simulation, and Omniverse USD pipelines, with skills for infrastructure setup, deep research queries, optimization SDKs, and synthetic data generation.

Write and review Godot 4.x game code in GDScript and C# with 51 domain-specific skills covering 2D/3D rendering, physics, animation, AI, multiplayer, UI, shaders, performance optimization, and editor tooling, plus 9 specialized agents for architecture, code review, animation, UI, shaders, performance, and C#-first development.

Review and improve Qt6 C++ and QML code with deterministic linting and agentic deep analysis, generate Markdown documentation from source files, build CMake projects, write QML unit tests, profile QML application performance, and extract Figma design tokens into production-ready QML controls.

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.

Migrates AI models and custom operators to Huawei Ascend NPUs, handles GPU-to-NPU code adaptation, profiling, performance optimization, distributed training deployment, and provides developer tooling for vLLM inference, Ascend C/Triton kernel development, and environment diagnostics.

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.

Extend Claude Code with TDD enforcement, security audits, automated code reviews, multi-agent orchestration, and session-based learning across Go, Rust, C++, Java, Kotlin, Python, TypeScript, and more.

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.

Develop, compile, flash, and debug embedded firmware for STM32, ESP32, and Cortex-M targets across Keil, IAR, CMake, ESP-IDF, and PlatformIO build systems with integrated static analysis, RTOS-aware debugging, and CAN/Modbus/VISA instrument communication. Supports a structured RIPER-5 protocol with multi-agent competition mode, layered architecture enforcement, and disk-based memory tracking.

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.

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.

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.

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.

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.

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.

Set up a C/C++ LSP environment with clangd for code intelligence, clang-tidy linting, clang-format formatting, and cppcheck analysis. Automates compilation database generation for CMake and Make projects.

Develop audio plugins end-to-end: scaffold projects, implement DSP with C++/Rust/FAUST, design UIs with native and web views (including Figma import), integrate with DAWs via VST3/AU/CLAP/AAX, validate signal correctness, and automate signing, notarization, CI/CD, and distribution across macOS, Windows, iOS, and Android.

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.

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.

Replaces bulky source-code copy-paste with file:line references for Claude Code, slashing token usage. Searches code via language servers (clangd, Roslyn, tsserver, pyright) or tree-sitter, hunts down provably dead symbols, and visualizes savings in a local dashboard. Everything runs offline.

Enables LSP-first code intelligence in Claude Code with mandatory pre-editing checks, impact analysis before refactoring, and post-edit diagnostics while automating LSP server installation and configuration across many languages

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.