godot-shaders

Q: How do I install godot-shaders?

Run npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills --skill godot-shaders in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/godot-shaders/ (personal) or .claude/skills/godot-shaders/ (project).

by gamedev-skillsMedia & Creative

Write Godot 4.7 shaders in the Godot Shading Language: canvasitem shaders for 2D and spatial shaders for 3D, with vertex/fragment functions, uniforms (sourcecolor, hintrange), TIME/UV animation, and screen-reading via hintscreentexture. Use when authoring .gdshader files, writing fragment/vertex code, making 2D/3D visual effects, or porting 3.x shaders (SCREENTEXTURE, hintcolor) to 4.x.

Installs: 6.8K
Last 24h: +342
Trending rank: #887
Security: Pass

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills --skill godot-shaders

01
Install
Run the command in your project. The CLI asks which agents to install for.
02
Describe the task
Ask your agent for something this skill covers. It loads godot-shaders automatically when relevant.
03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.

Security audits

Independent scans of the skill's instructions and bundled files.

Gen Agent Trust Hub PassSAFE ·This skill provides documentation and examples for writing Godot 4.7 shaders. It contains no executable scripts, network requests, or system-level commands and is considered safe for use.

Socket PassNo alerts

Snyk PassLOW ·Risk: LOW · No issues

SKILL.md

The instructions your agent reads when the skill is triggered.

Godot Shaders (4.x)

Write canvas_item (2D) and spatial (3D) shaders in the Godot Shading Language, animate with TIME/UV, expose uniforms, and read the screen. Targets Godot 4.7.

When to use

Use when writing .gdshader code or a ShaderMaterial: 2D effects (outline, dissolve, flash, water), 3D surface shaders (rim light, toon, scrolling UV), or screen-space post effects.

When not to use: the cross-engine concepts of shading (UVs, vertex/fragment theory) → shader-programming; particles/VFX nodes → general 3D; non-shader visuals.

Core workflow

Pick the shader type on the first line: shader_type canvas_item; for 2D (Sprite2D, TextureRect, anything CanvasItem) or shader_type spatial; for 3D materials. (particles, sky, fog also exist.)
Attach via a ShaderMaterial. Create a ShaderMaterial, assign your .gdshader, and put it on the node's material. Uniforms appear in the Inspector.
Write fragment() to set the output: COLOR (2D) or ALBEDO/EMISSION/ALPHA (3D). Optionally vertex() to move geometry and light() for custom lighting.
Expose tunables as uniforms with hints (source_color, hint_range) so they are editable and correctly color-managed.
Animate with the built-in TIME and sample textures with texture(tex, UV).
Set uniforms from code with material.set_shader_parameter("name", value).

Patterns

1. 2D (canvas_item): tint + scrolling UV

shader_type canvas_item;

uniform vec4 tint : source_color = vec4(1.0);     // source_color = sRGB-correct color
uniform float scroll_speed : hint_range(0.0, 2.0) = 0.3;

void fragment() {
    vec2 uv = UV;
    uv.x += TIME * scroll_speed;                  // scroll horizontally over time
    COLOR = texture(TEXTURE, uv) * tint;          // TEXTURE = the node's texture
}

2. 2D dissolve using a noise threshold

shader_type canvas_item;

uniform sampler2D noise : repeat_enable;          // a NoiseTexture2D
uniform float amount : hint_range(0.0, 1.0) = 0.0;

void fragment() {
    vec4 tex = texture(TEXTURE, UV);
    float n = texture(noise, UV).r;
    if (n < amount) {
        discard;                                  // cut the pixel away
    }
    COLOR = tex;
}

3. 3D (spatial): emissive rim light

shader_type spatial;

uniform vec4 base_color : source_color = vec4(0.2, 0.5, 1.0, 1.0);
uniform vec3 rim_color : source_color = vec3(0.6, 0.8, 1.0);
uniform float rim_power : hint_range(0.5, 8.0) = 3.0;

void fragment() {
    ALBEDO = base_color.rgb;
    // VIEW and NORMAL are view-space built-ins; rim is strong at grazing angles.
    float rim = pow(1.0 - dot(NORMAL, VIEW), rim_power);
    EMISSION = rim_color * rim;
}

4. Screen-reading post effect (4.x hint, not SCREEN_TEXTURE)

shader_type canvas_item;

// 4.x: declare the screen as a uniform with hint_screen_texture.
uniform sampler2D screen_tex : hint_screen_texture, filter_linear_mipmap;
uniform float blur : hint_range(0.0, 4.0) = 1.0;

void fragment() {
    vec2 px = SCREEN_PIXEL_SIZE * blur;
    vec4 c = texture(screen_tex, SCREEN_UV);
    c += texture(screen_tex, SCREEN_UV + vec2(px.x, 0.0));
    c += texture(screen_tex, SCREEN_UV - vec2(px.x, 0.0));
    COLOR = c / 3.0;
}

Set a uniform from GDScript:

$Sprite2D.material.set_shader_parameter("amount", 0.7)

Pitfalls

3.x → 4.x renames. SCREEN_TEXTURE is removed — declare uniform sampler2D x : hint_screen_texture; and sample with SCREEN_UV. Color hints hint_color/hint_albedo→source_color; hint_white/hint_black→ hint_default_white/hint_default_black; hint_range stays. Depth/normal use hint_depth_texture / hint_normal_roughness_texture.
Wrong output variable. In canvas_item write COLOR; in spatial write ALBEDO (and EMISSION, ALPHA, ROUGHNESS, METALLIC). Writing COLOR in a spatial shader does nothing.
Color uniforms without source_color are treated as raw linear values and look wrong (washed/dark) because Godot won't sRGB-convert them.
Object drawn in the wrong order, casts no shadow, or skips SSAO (3D) → the spatial shader reads or writes ALPHA, which moves the whole material to the transparent pipeline even if the value is always 1.0. Don't touch ALPHA in opaque shaders; for hard cut-outs also set ALPHA_SCISSOR_THRESHOLD (alpha-scissor stays in the opaque pass).
Sampling outside [0,1] UV without repeat_enable clamps. Add : repeat_enable to the sampler uniform for tiling/scroll.
Effect jumps once an hour → TIME (seconds since start, affected by time_scale, not by pausing) wraps every rendering/limits/time/time_rollover_secs (3600 by default). Pick periods that divide the rollover, or feed your own time through a uniform.
discard is costly on some hardware and breaks early-Z; prefer setting ALPHA/ COLOR.a when you can.

References

For built-in variables per shader type, render modes, varying, custom light(), vertex() displacement, and the visual shader graph, read references/shading-language.md.

Related skills

shader-programming — engine-agnostic shader concepts (GLSL/HLSL).
godot-3d-essentials — materials, environment, and where spatial shaders live.
godot-ui-control — applying shaders to UI for effects.

FAQ

What does the godot-shaders skill do?

How do I install godot-shaders?

Run npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills --skill godot-shaders in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/godot-shaders/ (personal) or .claude/skills/godot-shaders/ (project).

Which AI agents can use godot-shaders?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is godot-shaders safe to install?

Security partners have reviewed it: Gen Agent Trust Hub passed; Socket passed; Snyk passed. As with any skill, read the SKILL.md and bundled scripts before installing.

Who maintains godot-shaders?

It is published by gamedev-skills in gamedev-skills/awesome-gamedev-agent-skills. It has 6,833 recorded installs.