Skip to main content
skill CX Codex

shader-effects — Claude Code skill: effects, installation

This skill provides GLSL patterns for glow, distortion, grain, glitch, and other shader effects. Use it for post-processing or stylized rendering.

MIT 225 installs ★ 9 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Bbeierle12/Skill-MCP-Claude --skill shader-effects -a claude-code
Open on GitHub

What shader-effects does

shader-effects is a set of GLSL examples for visual treatment of shader output. It covers glow and bloom, chromatic aberration, wave and barrel distortion, vignette, film grain, scanlines, glitch, dissolve, and SDF outlines. Bloom examples include a multi-sample pass and a separable Gaussian blur.

The snippets take textures, UV coordinates, time, and effect parameters as inputs, so several can be chained in one fragment shader. The quick-start pattern combines vignette, grain, and chromatic aberration. The dissolve and heatHaze examples call snoise; those parts depend on that function being available in the project.

What it helps with

  • add glow around a shape or texture
  • build post-processing with bloom and blur
  • warp UV coordinates with waves or ripples
  • layer grain, scanlines, or glitch effects
  • create SDF outlines and dissolve transitions

Example prompts for the agent

  • Add vignette, film grain, and chromatic aberration to this fragment shader.
  • Create a dissolve transition with a colored edge and a progress parameter.
  • Build a low-cost bloom pass for this sampler2D using multi-sample blur.

How to install shader-effects

1Skills CLI (Vercel)

npx skills add Bbeierle12/Skill-MCP-Claude --skill shader-effects -a claude-code

2Manually: put the files in place

~/.claude/skills/shader-effects/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/shader-effects/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about shader-effects

How do I install shader-effects in Claude Code?

Run npx skills add Bbeierle12/Skill-MCP-Claude --skill shader-effects -a claude-code, then check ~/.claude/skills/shader-effects/SKILL.md.

What does shader-effects do?

It provides GLSL functions and patterns for glow, bloom, distortion, vignette, grain, scanlines, glitch, dissolve, and outlines. The snippets can be combined in a shader.

What does the dissolve example need?

The dissolve and heatHaze snippets call snoise, so the project needs to provide that function.

Source text

SKILL.md · MIT
---
name: shader-effects
description: Visual shader effects—glow/bloom, chromatic aberration, distortion, vignette, film grain, scanlines, glitch, dissolve, outline, and fresnel. Use when adding visual polish, post-processing effects, or stylized rendering to shaders.
---

# Shader Effects

Visual effects that add polish, style, and atmosphere to shader output.

## Quick Start

```glsl
// Combine multiple effects
vec3 color = baseColor;
color = applyVignette(color, uv, 0.5);
color = applyGrain(color, uv, uTime, 0.1);
color = applyChromaticAberration(color, uv, 0.005);
```

## Glow / Bloom

### Simple Glow

```glsl
// Distance-based glow
float glow(float d, float radius, float intensity) {
  return pow(radius / max(d, 0.001), intensity);
}

// Usage
float d = sdCircle(uv, 0.2);
vec3 color = vec3(glow(d, 0.1, 2.0)) * glowColor;
```

### Bloom (Multi-sample)

```glsl
// Sample in cross pattern for cheap bloom
vec3 bloom(sampler2D tex, vec2 uv, float radius) {
  vec3 color = vec3(0.0);
  float total = 0.0;
  
  for (float x = -4.0; x <= 4.0; x += 1.0) {
    for (float y = -4.0; y <= 4.0; y += 1.0) {
      float weight = 1.0 / (1.0 + length(vec2(x, y)));
      color += texture2D(tex, uv + vec2(x, y) * radius).rgb * weight;
      total += weight;
    }
  }
  
  return color / total;
}
```

### Gaussian Blur (Separable)

```glsl
// Horizontal pass
vec3 blurH(sampler2D tex, vec2 uv, float radius) {
  vec3 color = vec3(0.0);
  float weights[5] = float[](0.227, 0.194, 0.121, 0.054, 0.016);
  
  color += texture2D(tex, uv).rgb * weights[0];
  for (int i = 1; i < 5; i++) {
    vec2 offset = vec2(float(i) * radius, 0.0);
    color += texture2D(tex, uv + offset).rgb * weights[i];
    color += texture2D(tex, uv - offset).rgb * weights[i];
  }
  
  return color;
}

// Vertical pass (same, swap x/y)
```

## Chromatic Aberration

```glsl
vec3 chromaticAberration(sampler2D tex, vec2 uv, float amount) {
  vec2 dir = uv - 0.5;
  vec2 offset = dir * amount;
  
  vec3 color;
  color.r = texture2D(tex, uv + offset).r;
  color.g = texture2D(tex, uv).g;
  color.b = texture2D(tex, uv - offset).b;
  
  return color;
}

// Radial chromatic aberration (stronger at edges)
vec3 radialCA(sampler2D tex, vec2 uv, float amount) {
  vec2 dir = uv - 0.5;
  float dist = length(dir);
  vec2 offset = dir * amount * dist;
  
  vec3 color;
  color.r = texture2D(tex, uv + offset).r;
  color.g = texture2D(tex, uv).g;
  color.b = texture2D(tex, uv - offset).b;
  
  return color;
}
```

## Distortion

### Wave Distortion

```glsl
vec2 waveDistort(vec2 uv, float time, float freq, float amp) {
  uv.x += sin(uv.y * freq + time) * amp;
  uv.y += cos(uv.x * freq + time) * amp;
  return uv;
}
```

### Barrel/Pincushion Distortion

```glsl
vec2 barrelDistort(vec2 uv, float amount) {
  vec2 centered = uv - 0.5;
  float r2 = dot(centered, centered);
  vec2 distorted = centered * (1.0 + amount * r2);
  return distorted + 0.5;
}
```

### Heat Haze

```glsl
vec2 heatHaze(vec2 uv, float time, float intensity) {
  float noise = snoise(vec3(uv * 10.0, time));
  return uv + vec2(noise) * intensity;
}
```

### Ripple

```glsl
vec2 ripple(vec2 uv, vec2 center, float time, float freq, float amp) {
  vec2 dir = uv - center;
  float dist = length(dir);
  float wave = sin(dist * freq - time) * amp;
  return uv + normalize(dir) * wave;
}
```

## Vignette

```glsl
vec3 vignette(vec3 color, vec2 uv, float intensity, float smoothness) {
  vec2 centered = uv - 0.5;
  float dist = length(centered);
  float vig = smoothstep(0.5, 0.5 - smoothness, dist * intensity);
  return color * vig;
}

// Colored vignette
vec3 coloredVignette(vec3 color, vec2 uv, vec3 vigColor, float intensity) {
  vec2 centered = uv - 0.5;
  float dist = length(centered);
  float vig = smoothstep(0.0, 0.5, dist * intensity);
  return mix(color, vigColor, vig);
}
```

## Film Grain

```glsl
float random(vec2 st) {
  return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453123);
}

vec3 filmGrain(vec3 color, vec2 uv, float time, float intensity) {
  float grain = random(uv + fract(time)) * 2.0 - 1.0;
  return color + grain * intensity;
}

// Animated grain (smoother)
vec3 animatedGrain(vec3 color, vec2 uv, float time, float intensity) {
  float x = (uv.x + 4.0) * (uv.y + 4.0) * (time * 10.0);
  float grain = mod((mod(x, 13.0) + 1.0) * (mod(x, 123.0) + 1.0), 0.01) - 0.005;
  return color + grain * intensity * 50.0;
}
```

## Scanlines

```glsl
vec3 scanlines(vec3 color, vec2 uv, float count, float intensity) {
  float scanline = sin(uv.y * count * 3.14159) * 0.5 + 0.5;
  return color * (1.0 - intensity + scanline * intensity);
}

// CRT-style scanlines
vec3 crtScanlines(vec3 color, vec2 fragCoord, float intensity) {
  float scanline = sin(fragCoord.y * 0.7) * 0.1 * intensity;
  float flicker = sin(uTime * 10.0) * 0.01 * intensity;
  return color * (1.0 - scanline - flicker);
}
```

## Glitch

```glsl
vec3 glitch(sampler2D tex, vec2 uv, float time, float intensity) {
  // Random block offset
  float blockTime = floor(time * 20.0);
  float blockRand = random(vec2(blockTime, 0.0));
  
  if (blockRand > 0.9) {
    // Horizontal shift
    float shift = (random(vec2(uv.y, blockTime)) - 0.5) * intensity;
    uv.x += shift;
  }
  
  // Color channel split
  vec3 color;
  color.r = texture2D(tex, uv + vec2(intensity * 0.01, 0.0)).r;
  color.g = texture2D(tex, uv).g;
  color.b = texture2D(tex, uv - vec2(intensity * 0.01, 0.0)).b;
  
  // Random color inversion blocks
  if (random(vec2(floor(uv.y * 20.0), blockTime)) > 0.98) {
    color = 1.0 - color;
  }
  
  return color;
}

// Digital glitch with blocks
vec3 blockGlitch(sampler2D tex, vec2 uv, float time, float intensity) {
  vec2 blockSize = vec2(0.1, 0.05);
  vec2 block = floor(uv / blockSize);
  float blockRand = random(block + floor(time * 10.0));
  
  if (blockRand > 1.0 - intensity * 0.1) {
    uv.x += (blockRand - 0.5) * 0.1;
  }
  
  return texture2D(tex, uv).rgb;
}
```

## Dissolve

```glsl
vec3 dissolve(vec3 color, vec2 uv, float progress, float edgeWidth, vec3 edgeColor) {
  float noise = snoise(uv * 10.0);
  
  // Discard dissolved pixels
  if (noise < progress) {
    discard;
  }
  
  // Edge glow
  float edge = smoothstep(progress, progress + edgeWidth, noise);
  return mix(edgeColor, color, edge);
}

// With alpha instead of discard
vec4 dissolveAlpha(vec3 color, vec2 uv, float progress, float edgeWidth, vec3 edgeColor) {
  float noise = snoise(uv * 10.0);
  
  float alpha = smoothstep(progress - edgeWidth, progress, noise);
  float edge = smoothstep(progress, progress + edgeWidth, noise);
  vec3 finalColor = mix(edgeColor, color, edge);
  
  return vec4(finalColor, alpha);
}
```

## Outline

```glsl
// SDF-based outline
vec3 sdfOutline(float d, vec3 fillColor, vec3 outlineColor, float outlineWidth) {
  float aa = fwidth(d);
  float fill = smoothstep(aa, -aa, d);
  float outline = smoothstep(aa, -aa, abs(d) - outlineWidth);
  
  return mix(vec3(0.0), mix(outlineColor, fillColor, fill), max(fill, outline));
}

// Texture-based outline (sample neighbors)
float textureOutline(sampler2D tex, vec2 uv, float thickness) {
  float alpha = texture2D(tex, uv).a;
  
  float outline = 0.0;
  for (float x = -1.0; x <= 1.0; x += 1.0) {
    for (float y = -1.0; y <= 1.0; y += 1.0) {
      outline += texture2D(tex, uv + vec2(x, y) * thickness).a;
    }
  }
  
  return clamp(outline - alpha * 9.0, 0.0, 1.0);
}
```

## Fresnel / Rim Light

```glsl
// 3D fresnel (needs view direction and normal)
float fresnel(vec3 viewDir, vec3 normal, float power) {
  return pow(1.0 - max(dot(viewDir, normal), 0.0), power);
}

// 2D fake fresnel (based on UV distance from center)
float fakeFresnel2D(vec2 uv, float power) {
  vec2 centered = uv - 0.5;
  float dist = length(centered) * 2.0;
  return pow(dist, power);
}

// Usage
vec3 color = baseColor;
float rim = fresnel(viewDir, normal, 3.0);
color += rimColor * rim * rimIntensity;
```

## Color Grading

### Contrast / Brightness / Saturation

```glsl
vec3 adjustContrast(vec3 color, float contrast) {
  return (color - 0.5) * contrast + 0.5;
}

vec3 adjustBrightness(vec3 color, float brightness) {
  return color + brightness;
}

vec3 adjustSaturation(vec3 color, float saturation) {
  float gray = dot(color, vec3(0.299, 0.587, 0.114));
  return mix(vec3(gray), color, saturation);
}
```

### Color Remap

```glsl
vec3 colorRemap(vec3 color, vec3 shadowColor, vec3 highlightColor) {
  float luma = dot(color, vec3(0.299, 0.587, 0.114));
  return mix(shadowColor, highlightColor, luma);
}
```

### Posterize

```glsl
vec3 posterize(vec3 color, float levels) {
  return floor(color * levels) / levels;
}
```

## Dithering

```glsl
// Bayer 4x4 dithering
float bayer4x4(vec2 fragCoord) {
  int x = int(mod(fragCoord.x, 4.0));
  int y = int(mod(fragCoord.y, 4.0));
  
  int bayer[16] = int[](
    0, 8, 2, 10,
    12, 4, 14, 6,
    3, 11, 1, 9,
    15, 7, 13, 5
  );
  
  return float(bayer[y * 4 + x]) / 16.0;
}

vec3 dither(vec3 color, vec2 fragCoord, float levels) {
  float threshold = bayer4x4(fragCoord);
  return floor(color * levels + threshold) / levels;
}
```

## Combining Effects

```glsl
vec3 applyEffects(vec3 color, vec2 uv, float time) {
  // Order matters!
  
  // 1. Distortion (modify UVs first)
  // Already applied to texture sampling
  
  // 2. Color adjustments
  color = adjustContrast(color, 1.1);
  color = adjustSaturation(color, 1.2);
  
  // 3. Chromatic aberration
  // (apply during texture sampling)
  
  // 4. Vignette
  color = vignette(color, uv, 1.2, 0.4);
  
  // 5. Film grain (last, before final output)
  color = filmGrain(color, uv, time, 0.05);
  
  return color;
}
```

## File Structure

```
shader-effects/
├── SKILL.md
├── references/
│   ├── effect-order.md       # Recommended effect ordering
│   └── performance.md        # Effect costs
└── scripts/
    ├── effects/
    │   ├── glow.glsl         # Glow/bloom
    │   ├── distortion.glsl   # Distortion effects
    │   ├── color.glsl        # Color grading
    │   └── retro.glsl        # CRT/retro effects
    └── examples/
        ├── cyberpunk.glsl    # Cyberpunk style combo
        └── vintage.glsl      # Vintage film look
```

## Reference

- `references/effect-order.md` — Recommended order for combining effects
- `references/performance.md` — Performance cost of each effect

© Bbeierle12 · MIT · Bbeierle12/Skill-MCP-Claude

Similar skills

All skills for Game dev and 3D: Unity, Unreal, Godot, Blender →

From the same set19

The whole set →
gsap-react gsap-react — a skill for Claude Code, Codex, Cursor and other agents covering GSAP integration patterns inside React. Handles the useGSAP hook, ref strategies, animation cleanup on unmount, and context management. CX Codex +1 728installs gsap-scrolltrigger A skill for GSAP ScrollTrigger: tie animations to scroll position, pin sections, build parallax and snap points. Useful when a page has to react to scrolling. CX Codex +1 612installs gsap-fundamentals gsap-fundamentals is a Claude Code skill covering GSAP tweens, timelines, easing, and animation properties. It explains adding motion to UI elements and getting started with GSAP. CX Codex +1 286installs frontend-dev-guidelines frontend-dev-guidelines — a convention set for React and TypeScript work: folder layout, data loading, styling and tests. It loads when the agent touches frontend code. CX Codex +1 105installs d3js-visualization d3js-visualization teaches the agent to write D3.js charts: bars, lines, pies, tooltips, zoom. Useful when the visual has to be coded rather than pulled from a chart library. CX Codex +1 189installs particles-gpu particles-gpu generates GPU-accelerated particle systems for Three.js and React Three Fiber. Ideal for rendering thousands to millions of points smoothly. CX Codex +1 173installs shader-fundamentals The shader-fundamentals skill covers GLSL basics, from vertex and fragment shaders to coordinates, types, and data flow. Use it when building or debugging shader code. CX Codex +1 173installs gsap-sequencing The gsap-sequencing skill guides complex GSAP timelines with labels, nested sequences, callbacks, and precise placement. Use it for coordinated UI motion. CX Codex +1 163installs

Project sponsors

Companies that keep this analytics open