Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Game Shader Development Assistant

    1

    Expert assistance for designing, debugging, and optimizing shaders across Unity, Unreal, Godot, and custom pipelines.

    $14.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Game Shader Development Assistant

    Example session with this skill installed

    I need a URP HLSL shader for Unity 2022.3 that creates a simple scrolling UV water effect with a foam mask. I am targeting mobile (GLES3).

    • Read your context and instructions
    • Compiled the game shader development

    I will outline the implementation for a scrolling water shader in Unity 2022.3 URP using HLSL, optimized for GLES3 mobile devices.

    Mobile Water Shader (URP HLSL)

    // Unity 2022.3 URP - Mobile Optimized
    Shader "Custom/MobileWater"
    {
        Properties
        {
            _MainTex ("Water Texture", 2D) = "white" {}
            _FoamTex ("Foam Texture", 2D) = "white" {}
            _ScrollSpeed ("Scroll Speed", Vector) = (0.1, 0.1, 0, 0)
            _FoamCutoff ("Foam Cutoff", Range(0, 1)) = 0.5
        }
    
        SubShader
        {
            Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" }
            Pass
            {
                HLSLPROGRAM
                #pragma vertex vert
                #pragma fragment frag
                #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
    
                struct Attributes {
                    float4 positionOS : POSITION;
                    float2 uv : TEXCOORD0;
                };
    
                struct Varyings {
                    float4 positionCS : SV_POSITION;
                    float2 uv : TEXCOORD0;
                };
    
                TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex);
                TEXTURE2D(_FoamTex); SAMPLER(sampler_FoamTex);
    
                CBUFFER_START(UnityPerMaterial)
                    float4 _MainTex_ST;
                    float4 _ScrollSpeed;
                    half _FoamCutoff;
                CBUFFER_END
    
                Varyings vert(Attributes input) {
                    Varyings output;
                    output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                    output.uv = TRANSFORM_TEX(input.uv, _MainTex);
                    return output;
                }
    
                half4 frag(Varyings input) : SV_Target {
                    // Use half precision for mobile optimization
                    float2 scrollingUV = input.uv + _ScrollSpeed.xy * _Time.y;
                    half4 water = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, scrollingUV);
                    half4 foam = SAMPLE_TEXTURE2D(_FoamTex, sampler_FoamTex, input.uv);
                    
                    // Simple step for foam mask
                    half foamMask = step(_FoamCutoff, foam.r);
                    half3 finalColor = lerp(water.rgb, foam.rgb, foamMask);
                    
                    return half4(finalColor, 1.0);
                }
                ENDHLSL
            }
        }
    }
    

    Next steps

    1. Create a new Lead Material in Unity and assign this shader to verify the _Time uniform scaling.
    2. Adjust _FoamCutoff to tune the edge sharpness based on your foam texture's alpha/red channel.
    3. If performance drops on low-end GLES3 devices, consider packing the foam mask into the _MainTex alpha channel to save a texture fetch.

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

    About this skill

    Writing shaders for real-time environments is a constant battle against visual artifacts, platform inconsistencies, and tight GPU budgets. This skill provides expert-level assistance in designing, implementing, and optimizing shaders for Unity, Unreal Engine, Godot, and custom rendering pipelines.

    What it does

    • Architect implementation plans for surface effects, vertex deformations, and post-processing passes.
    • Write commented shader code in HLSL, GLSL, WGSL, or Godot Shading Language tailored to specific engine versions.
    • Diagnose visual defects such as Z-fighting, aliasing, temporal instability, and incorrect coordinate transforms.
    • Audit GPU performance to reduce instruction counts, texture samples, and register pressure.
    • Ensure cross-platform portability by validating depth conventions, precision requirements, and API-specific behavior.

    How it works

    1. Define the environment by providing the engine version, render pipeline (URP, HDRP, Forward+), and target hardware.
    2. Translate the visual goal into a technical requirement list covering geometry, lighting, and transparency.
    3. Generate or review logic for vertex/fragment stages, compute shaders, or node-based graph instructions.
    4. Iterate through debugging using a minimal reproduction strategy to isolate compiler errors or runtime artifacts.

    Frameworks & tools

    Supports Unity (Built-in, URP, HDRP), Unreal Engine (Material Editor and Custom HLSL), Godot (Spatial, Canvas, Particle), and custom rendering pipelines using HLSL, GLSL, or WGSL.

    Why this beats prompting it yourself

    Generic LLMs often hallucinate engine-specific macros or mix coordinate systems between Unity and Unreal. This skill enforces a strict intake checklist to ensure code respects the specific constraints of your render pipeline and target hardware.

    Use cases

    • Refactoring a desktop shader for mobile tile-based GPUs to fix precision artifacts.
    • Designing a custom vertex animation shader for wind or water effects.
    • Debugging transparent sorting issues in a complex multi-pass render graph.
    • Optimizing expensive fragment shaders to fit within a specific millisecond GPU budget.

    Known limitations

    Does not reproduce proprietary shader source and cannot provide verified performance benchmarks without user-provided profiling data. Code is provided as uncompiled unless compiler diagnostics are supplied.

    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.

    Code is uncompiled unless compiler logs are provided. Requires specific engine/pipeline context to avoid hallucinations. No access to proprietary engine source.

    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

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 5 days ago

    Permissions

    No special permissions declared or detected

    Listed5 days ago

    What's inside

    Frequently Asked Questions

    The assistant supports Unity (URP, HDRP, and Built-in), Unreal Engine (Material Editor nodes and custom HLSL blocks), Godot (Spatial and CanvasItem), and generic custom pipelines using HLSL, GLSL, or WGSL.

    Unlike general AI models, this skill uses a strict intake checklist to account for engine-specific macros, coordinate systems, and hardware-specific precision issues (like mobile fp16 vs. desktop fp32).

    Yes, the assistant can analyze existing shader code to identify high instruction counts, unnecessary texture samples, or register pressure, providing specific refactoring recommendations to meet GPU budgets.

    Simply provide your engine version, render pipeline, and target hardware (e.g., Unity URP for Android); the skill will then guide you through translating your visual concept into a technical implementation plan.

    The assistant identifies the root cause of visual artifacts—such as Z-fighting, temporal instability, or incorrect depth conventions—and provides the math or logic needed to resolve them.

    New in Game Development