Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    vulkan rendering expert skill

    2

    Senior Vulkan graphics engineering for API implementation, debugging VUID errors, and performance optimization.

    Free

    Security scanned
    vulkan rendering expert skill

    vulkan rendering expert skill

    Example session with this skill installed

    My Android Vulkan app is hitting a VUID-VkImageMemoryBarrier-oldLayout-01197 error during the main render pass. Here is my barrier setup and the validation log. How do I fix the synchronization?

    • Read your context and instructions
    • Compiled the vulkan rendering expert

    The validation error indicates a mismatch between the reported oldLayout in your VkImageMemoryBarrier and the actual state tracked by the GPU. This typically occurs when a previous subpass or external operation transitioned the image without the current command buffer's knowledge.

    Root Cause & Synchronization Fix

    ComponentCurrent StateRequired StateImpact
    Image LayoutVK_IMAGE_LAYOUT_UNDEFINEDVK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMALVUID 01197 Violation
    Access Mask0VK_ACCESS_COLOR_ATTACHMENT_WRITE_BITPotential Data Race
    Stage MaskVK_PIPELINE_STAGE_TOP_OF_PIPE_BITVK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BITExecution Dependency Gap

    Recommended Minimal Fix

    Update your transition barrier in Renderer::recordMainPass to match the transition performed by the previous compute post-processing dispatch.

    // Change the transition logic in your command buffer recording
    VkImageMemoryBarrier barrier = {};
    barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barrier.oldLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; // Match actual previous state
    barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
    barrier.srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
    barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
    barrier.image = m_renderTarget.image;
    barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
    
    vkCmdPipelineBarrier(
        commandBuffer,
        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
        0, 0, nullptr, 0, nullptr, 1, &barrier
    );
    

    Next steps

    1. Check initialLayout in the render pass’s VkAttachmentDescription, not VkRenderPassBeginInfo. Unless it is VK_IMAGE_LAYOUT_UNDEFINED, it must match the attachment subresource’s actual layout when the render pass begins. Also verify the render pass’s layout transitions and subpass dependencies.
    2. Run with VK_LAYER_KHRONOS_validation enabled to confirm the VUID is cleared.
    3. Check the dstStageMask to ensure it doesn't block the UI thread unnecessarily.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Vulkan development is notorious for its steep learning curve and unforgiving error handling. A single synchronization oversight or incorrect image layout transition can lead to silent GPU hangs, flickering, or hardware-specific crashes that validation layers might miss. This skill provides senior-level graphics engineering expertise to navigate the complexities of Vulkan 1.3/1.4 and Android integration.

    What it does

    • Architects engines by providing trade-off analysis for RenderPass vs. Dynamic Rendering, Bindless designs, and RenderGraph implementations.
    • Debugs complex failures including device lost errors, VUID violations, and GPU hangs with root-cause analysis.
    • Optimizes performance by identifying bottlenecks in command buffer recording, descriptor management, and async compute workflows.
    • Validates resource lifecycles ensuring correct synchronization, image layout transitions, and swapchain management.
    • Analyzes code impact by mapping architectural dependencies and regression risks before implementing changes.

    How it works

    1. Route the task based on whether you are designing, debugging, or optimizing.
    2. Establish evidence through code maps, SPEC references, or platform-specific Android constraints.
    3. Execute specialized workflows for regression reasoning and progressive retrieval to fill information gaps.
    4. Deliver structured solutions ranging from minimal workarounds to full structural fixes with clear DoD (Definition of Done).

    Frameworks & tools

    Targeted at Vulkan 1.3/1.4 environments, Android NDK/Vulkan integration, and desktop graphics stacks. It integrates with validation layers, SPIR-V workflows, and GPU profiling tools.

    Why this beats prompting it yourself

    Generic AI often hallucinates API fields or suggests OpenGL-style patterns that fail in Vulkan. This skill enforces strict adherence to specifications and hard engineering constraints, ensuring that synchronization logic and memory barriers are physically correct rather than just "plausible-looking" code.

    Use cases

    • Fix persistent Validation Errors or VUID conflicts in complex draw calls.
    • Design a high-performance bindless descriptor set architecture for a custom engine.
    • Troubleshoot frame stuttering or swapchain synchronization issues on Android devices.
    • Refactor legacy RenderPass code to use modern Dynamic Rendering extensions.

    Known limitations

    Does not support alternative APIs like OpenGL or Metal. Requires specific project context (files, functions, or VUIDs) to provide precise evidence-based diagnostics.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Game Development.

    Does not support OpenGL, Metal, or Skia. Requires specific VUIDs or code context for diagnostics. Implementation fixes require manual validation gate checks.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 17 days ago

    • Free with an Agensi account

    Software
    PythonGit

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Listed17 days ago

    What's inside

    Frequently Asked Questions

    The skill covers Vulkan 1.0 through 1.4, with specialized expertise in modern features like Dynamic Rendering, Bindless descriptors, and Android-specific NDK extensions.

    While the skill performs best with C++ and GLSL, it provides accurate architectural guidance for any language with Vulkan bindings (like Rust or C#) by focusing on API-level constraints and memory layouts.

    Yes, simply provide the specific VUID code and the relevant code snippet; the skill is designed to perform root-cause analysis on synchronization hazards and lifecycle errors that standard validation might flag.

    You receive the fully optimized agent persona and its specialized reasoning workflows, designed for immediate integration into your preferred AI development environment or IDE plugin.

    Unlike generic models, this skill uses a specialized workflow that prioritizes physical correctness in synchronization and memory barriers, preventing the 'hallucinated' API patterns that often cause GPU hangs.

    The skill requires specific technical context, such as your current RenderPass structure, descriptor layout, or pipeline state, to provide actionable architectural fixes.

    New in Game Development

    Free