- Home
- Skills
- Game Development
- Game Shader Development Assistant
Works with the AI Agents you already use
Game Shader Development Assistant
Expert assistance for designing, debugging, and optimizing shaders across Unity, Unreal, Godot, and custom pipelines.
$14.99
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
- Create a new Lead Material in Unity and assign this shader to verify the
_Timeuniform scaling. - Adjust
_FoamCutoffto tune the edge sharpness based on your foam texture's alpha/red channel. - If performance drops on low-end GLES3 devices, consider packing the foam mask into the
_MainTexalpha 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
- Define the environment by providing the engine version, render pipeline (URP, HDRP, Forward+), and target hardware.
- Translate the visual goal into a technical requirement list covering geometry, lighting, and transparency.
- Generate or review logic for vertex/fragment stages, compute shaders, or node-based graph instructions.
- 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
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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 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