18 files changed, 664 insertions, 368 deletions
diff --git a/shaders/crt.frag.glsl b/shaders/crt.frag.glsl
deleted file mode 100644
index b0b0b93b..00000000
--- a/shaders/crt.frag.glsl
+++ /dev/null
@@ -1,175 +0,0 @@
-#version 450
-
-// The Crt builtin's post-process. Screen point cc shows the scene at
-// uv' = cc*(1 + BARREL*r2), and src/gui/crt.zig maps mouse input through that
-// same transform — keep them equal or clicks drift near the edges.
-
-layout(set = 2, binding = 0) uniform sampler2D u_scene;
-layout(std140, set = 3, binding = 0) uniform CrtUniforms {
-    float time_seconds;
-    float frame;
-    vec2 viewport;
-    // x = CRT, y = ripple, z = glitch. One scene pass can combine them.
-    vec4 effects;
-} u_crt;
-
-layout(location = 0) out vec4 o_col;
-
-const float TAU = 6.28318530718;
-const float BARREL = 0.016; // MUST match src/gui/crt.zig barrel
-const float EDGE_SOFTNESS_PX = 3.5;
-const float CHROMA_PX = 0.28; // radial R/B separation in physical pixels at r2=1
-const float BLOOM_RADIUS_PX = 1.75;
-const float BLOOM_THRESHOLD = 0.60; // linear-light channel peak
-const float BLOOM_SOFTNESS = 0.25;
-const float BLOOM_STRENGTH = 0.045;
-const float SCAN_PERIOD_PX = 3.0;
-const float SCAN_STRENGTH = 0.055;
-const float MASK_PERIOD_PX = 3.0;
-const float MASK_STRENGTH = 0.015;
-const float VIGNETTE_STRENGTH = 0.11; // 11% only at the extreme corners
-const float HUM_STRENGTH = 0.0025;
-const float NOISE_STRENGTH = 0.0020;
-const float EXPOSURE = 1.012;
-
-vec3 srgbToLinear(vec3 c) {
-    vec3 low = c / 12.92;
-    vec3 high = pow((c + 0.055) / 1.055, vec3(2.4));
-    return mix(high, low, lessThanEqual(c, vec3(0.04045)));
-}
-
-vec3 linearToSrgb(vec3 c) {
-    c = max(c, vec3(0.0));
-    vec3 low = c * 12.92;
-    vec3 high = 1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055;
-    return mix(high, low, lessThanEqual(c, vec3(0.0031308)));
-}
-
-vec3 sceneLinear(vec2 uv) {
-    return srgbToLinear(texture(u_scene, uv).rgb);
-}
-
-vec3 brightPass(vec2 uv) {
-    vec3 c = sceneLinear(uv);
-    float peak = max(c.r, max(c.g, c.b));
-    return c * smoothstep(BLOOM_THRESHOLD, BLOOM_THRESHOLD + BLOOM_SOFTNESS, peak);
-}
-
-float noiseAt(vec2 p) {
-    vec3 q = fract(vec3(p.xyx) * 0.1031);
-    q += dot(q, q.yzx + 33.33);
-    return fract((q.x + q.y) * q.z);
-}
-
-// The non-CRT scene effects deliberately distort the source coordinates,
-// rather than remapping the final colors. Themes retain their palette and the
-// effects remain composable with the linear-light CRT treatment below.
-vec2 sceneUv(vec2 uv) {
-    if (u_crt.effects.y > 0.5) {
-        vec2 centered = uv - 0.5;
-        float radius = length(centered);
-        float envelope = 1.0 - smoothstep(0.04, 0.72, radius);
-        float wave = sin(radius * 42.0 - u_crt.time_seconds * 5.2);
-        uv += centered / max(radius, 0.00001) * wave * envelope * 0.0032;
-    }
-    if (u_crt.effects.z > 0.5) {
-        float band = floor(uv.y * 96.0);
-        float seed = noiseAt(vec2(band, floor(u_crt.time_seconds * 13.0)));
-        float tear = smoothstep(0.955, 1.0, seed);
-        uv.x += (noiseAt(vec2(seed, band)) - 0.5) * tear * 0.020;
-    }
-    return uv;
-}
-
-// The scene, ALPHA INCLUDED: with a see-through ground the grid arrives
-// premultiplied and partly empty, and a pass that dropped .a would turn the
-// desktop behind a `*_transparent` theme into opaque black the moment Crt,
-// Ripple or Glitch came on.
-vec4 sceneSrgb(vec2 uv) {
-    vec2 warped = sceneUv(uv);
-    vec4 center = texture(u_scene, warped);
-    if (u_crt.effects.z <= 0.5) return center;
-
-    float band = floor(warped.y * 96.0);
-    float seed = noiseAt(vec2(band, floor(u_crt.time_seconds * 13.0)));
-    float tear = smoothstep(0.955, 1.0, seed);
-    vec2 chroma = vec2((0.35 + 1.25 * tear) / u_crt.viewport.x, 0.0);
-    return vec4(
-        texture(u_scene, warped + chroma).r,
-        center.g,
-        texture(u_scene, warped - chroma).b,
-        center.a
-    );
-}
-
-vec3 effectSceneLinear(vec2 uv) {
-    return srgbToLinear(sceneSrgb(uv).rgb);
-}
-
-void main() {
-    vec2 size = u_crt.viewport;
-    vec2 texel = 1.0 / size;
-    vec2 cc = gl_FragCoord.xy / size * 2.0 - 1.0;
-    float r2 = dot(cc, cc);
-    vec2 uv = cc * (1.0 + BARREL * r2 * u_crt.effects.x) * 0.5 + 0.5;
-
-    // Ripple and glitch are useful without the CRT. They only move samples;
-    // skip every tube-specific light/mask/exposure adjustment.
-    if (u_crt.effects.x <= 0.5) {
-        // The scene texture is already sRGB. Avoid a needless transfer-curve
-        // round trip so a coordinate-only effect preserves theme bytes.
-        vec4 s = sceneSrgb(uv);
-        o_col = vec4(clamp(s.rgb, 0.0, 1.0), clamp(s.a, 0.0, 1.0));
-        return;
-    }
-
-    vec3 col = vec3(0.0);
-    // Outside the tube nothing is drawn, so nothing is covered either: the
-    // old opaque black there would have punched a rectangle out of the
-    // compositor's backdrop.
-    float alpha = 0.0;
-    float edge = min(min(uv.x, uv.y), min(1.0 - uv.x, 1.0 - uv.y));
-    if (edge > 0.0) {
-        vec3 center = effectSceneLinear(uv);
-        vec2 chroma = cc * (CHROMA_PX * r2) * texel;
-        // Each radial sample follows the same ripple/glitch path from its own
-        // pre-warp coordinate. This is also how the Metal kernel composes the
-        // effects; sampling a once-warped center here made combined effects
-        // diverge between the two GUI backends.
-        col = vec3(
-            effectSceneLinear(uv + chroma).r,
-            center.g,
-            effectSceneLinear(uv - chroma).b
-        );
-
-        vec2 bloom_px = texel * BLOOM_RADIUS_PX;
-        vec3 bloom = brightPass(uv + vec2(bloom_px.x, 0.0)) +
-            brightPass(uv - vec2(bloom_px.x, 0.0)) +
-            brightPass(uv + vec2(0.0, bloom_px.y)) +
-            brightPass(uv - vec2(0.0, bloom_px.y));
-        col += bloom * (0.25 * BLOOM_STRENGTH);
-
-        // The mask has unit mean and the scan loss stays small; neither needs
-        // the old global lift that remapped every theme toward white.
-        float scan_wave = 0.5 + 0.5 * cos(gl_FragCoord.y * TAU / SCAN_PERIOD_PX);
-        col *= 1.0 - SCAN_STRENGTH * scan_wave * scan_wave;
-        vec3 mask = 1.0 + MASK_STRENGTH * cos(
-            gl_FragCoord.x * TAU / MASK_PERIOD_PX + vec3(0.0, TAU / 3.0, 2.0 * TAU / 3.0)
-        );
-        col *= mask;
-
-        vec2 edge_px = min(uv, 1.0 - uv) * size;
-        float tube = smoothstep(0.0, EDGE_SOFTNESS_PX, min(edge_px.x, edge_px.y));
-        float vignette = 1.0 - VIGNETTE_STRENGTH * pow(clamp(r2 * 0.5, 0.0, 1.0), 1.6);
-        float hum = 1.0 + HUM_STRENGTH * sin((uv.y * 1.35 - u_crt.time_seconds * 0.11) * TAU);
-        col *= tube * vignette * hum * EXPOSURE;
-        // The tube's edge falloff dims coverage as well as colour; everything
-        // else here is a light adjustment and leaves it alone.
-        alpha = sceneSrgb(uv).a * tube;
-
-        float luma = dot(col, vec3(0.2126, 0.7152, 0.0722));
-        vec2 noise_seed = gl_FragCoord.xy + vec2(u_crt.frame * 17.0, u_crt.frame * 59.0);
-        col += (noiseAt(noise_seed) - 0.5) * NOISE_STRENGTH * (0.15 + 0.85 * clamp(luma, 0.0, 1.0));
-    }
-    o_col = vec4(linearToSrgb(clamp(col, 0.0, 1.0)), clamp(alpha, 0.0, 1.0));
-}
diff --git a/shaders/crt.vert.glsl b/shaders/crt.vert.glsl
deleted file mode 100644
index 4e15fcdf..00000000
--- a/shaders/crt.vert.glsl
+++ /dev/null
@@ -1,9 +0,0 @@
-#version 450
-
-// CRT post-process pass: one fullscreen triangle from gl_VertexIndex, no
-// vertex buffer. The fragment shader derives uv from gl_FragCoord.
-
-void main() {
-    vec2 p = vec2(float((gl_VertexIndex << 1) & 2), float(gl_VertexIndex & 2));
-    gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
-}
diff --git a/shaders/post.vert.glsl b/shaders/post.vert.glsl
new file mode 100644
index 00000000..86739a65
--- /dev/null
+++ b/shaders/post.vert.glsl
@@ -0,0 +1,10 @@
+#version 450
+
+// A post pass (docs/render-pipeline.md §6): one fullscreen triangle from
+// gl_VertexIndex, no vertex buffer. The Shadertoy fragment shader works from
+// gl_FragCoord, y down, as its fragCoord.
+
+void main() {
+    vec2 p = vec2(float((gl_VertexIndex << 1) & 2), float(gl_VertexIndex & 2));
+    gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
+}
diff --git a/shaders/post/crt.glsl b/shaders/post/crt.glsl
new file mode 100644
index 00000000..16a5cdd9
--- /dev/null
+++ b/shaders/post/crt.glsl
@@ -0,0 +1,79 @@
+// Crt: a slot-mask tube's light, with nothing that moves a pixel. There is
+// no barrel: every click lands where it is drawn, rails and grips at the
+// window's edges included. What is left is light: a beam profile for the
+// scanlines, an aperture mask, a soft bloom of the brightest ink, a faint
+// vignette and the hum of a live tube. Everything is worked out in linear
+// light and dithered back into 8 bits, so the vignette never bands. It is a
+// Shadertoy file: pardes puts its prefix before it (shaders/post/prefix.glsl).
+
+const float TAU = 6.28318530718;
+const float CHROMA_PX = 0.35;       // red and blue apart, at the corners
+const float BLOOM_RADIUS_PX = 1.75;
+const float BLOOM_THRESHOLD = 0.60; // linear-light channel peak
+const float BLOOM_SOFTNESS = 0.25;
+const float BLOOM_STRENGTH = 0.05;
+const float SCAN_PERIOD_PX = 3.0;
+const float SCAN_STRENGTH = 0.07;
+const float MASK_PERIOD_PX = 3.0;
+const float MASK_STRENGTH = 0.018;
+const float VIGNETTE_STRENGTH = 0.12; // at the far corners only
+const float HUM_STRENGTH = 0.004;
+const float HUM_HZ = 0.11;
+const float EXPOSURE = 1.015;
+
+vec3 toLinear(vec3 c) {
+    return mix(pow((c + 0.055) / 1.055, vec3(2.4)), c / 12.92, lessThanEqual(c, vec3(0.04045)));
+}
+
+vec3 toSrgb(vec3 c) {
+    c = max(c, vec3(0.0));
+    return mix(1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055, c * 12.92, lessThanEqual(c, vec3(0.0031308)));
+}
+
+vec3 scene(vec2 uv) {
+    return toLinear(texture(iChannel0, uv).rgb);
+}
+
+vec3 brightPass(vec2 uv) {
+    vec3 c = scene(uv);
+    float peak = max(c.r, max(c.g, c.b));
+    return c * smoothstep(BLOOM_THRESHOLD, BLOOM_THRESHOLD + BLOOM_SOFTNESS, peak);
+}
+
+// Interleaved gradient noise: a dither with no visible pattern.
+float ign(vec2 p) {
+    return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715))));
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+    vec2 size = iResolution.xy;
+    vec2 texel = 1.0 / size;
+    vec2 uv = fragCoord / size;
+    vec2 cc = uv * 2.0 - 1.0;
+    float r2 = dot(cc, cc);
+
+    // The beam converges least at the corners: red and blue drift apart
+    // there, by a third of a pixel.
+    vec2 chroma = cc * (CHROMA_PX * r2 * 0.5) * texel;
+    vec3 col = vec3(scene(uv + chroma).r, scene(uv).g, scene(uv - chroma).b);
+
+    vec2 b = texel * BLOOM_RADIUS_PX;
+    vec3 bloom = brightPass(uv + vec2(b.x, 0.0)) + brightPass(uv - vec2(b.x, 0.0)) +
+        brightPass(uv + vec2(0.0, b.y)) + brightPass(uv - vec2(0.0, b.y));
+    col += bloom * (0.25 * BLOOM_STRENGTH);
+
+    // A beam is brightest on its line and falls off between lines; the
+    // mask is three phosphor stripes a triad. Both average to one, so the
+    // theme keeps its brightness.
+    float line = 0.5 + 0.5 * cos(fragCoord.y * TAU / SCAN_PERIOD_PX);
+    col *= 1.0 - SCAN_STRENGTH * (line * line - 0.375) / 0.625;
+    col *= 1.0 + MASK_STRENGTH * cos(fragCoord.x * TAU / MASK_PERIOD_PX + vec3(0.0, TAU / 3.0, 2.0 * TAU / 3.0));
+
+    float vignette = 1.0 - VIGNETTE_STRENGTH * pow(clamp(r2 * 0.5, 0.0, 1.0), 1.6);
+    float hum = 1.0 + HUM_STRENGTH * sin((uv.y * 1.35 - iTime * HUM_HZ) * TAU);
+    col *= vignette * hum * EXPOSURE;
+
+    vec3 srgb = toSrgb(col);
+    srgb += (ign(fragCoord + float(iFrame % 64) * vec2(5.588238, 5.588238)) - 0.5) / 255.0;
+    fragColor = vec4(clamp(srgb, 0.0, 1.0), texture(iChannel0, uv).a);
+}
diff --git a/shaders/post/glitch.glsl b/shaders/post/glitch.glsl
new file mode 100644
index 00000000..ff9ebcb8
--- /dev/null
+++ b/shaders/post/glitch.glsl
@@ -0,0 +1,60 @@
+// Glitch: now and then the signal slips. Every couple of seconds a short
+// burst tears a few horizontal bands sideways and pulls their red and blue
+// apart; the bands are sized in pixels and the burst eases in and out over
+// a fraction of a second, so it reads as one event rather than a flicker,
+// and it looks the same at 60 or 144 Hz because every step is keyed to
+// iTime, not to frames. Between bursts the page is left exactly as it is.
+// A torn band's brightness dips in linear light. It is a Shadertoy file:
+// pardes puts its prefix before it.
+
+const float PERIOD = 2.4;           // seconds between bursts, on average
+const float BURST = 0.28;           // seconds a burst lasts
+const float STEP_HZ = 24.0;         // how often a burst re-tears
+const float SHIFT_PX = 14.0;
+const float SPLIT_PX = 2.5;
+const float DIP = 0.12;
+
+float hash(vec2 p) {
+    vec3 q = fract(vec3(p.xyx) * 0.1031);
+    q += dot(q, q.yzx + 33.33);
+    return fract((q.x + q.y) * q.z);
+}
+
+vec3 toLinear(vec3 c) {
+    return mix(pow((c + 0.055) / 1.055, vec3(2.4)), c / 12.92, lessThanEqual(c, vec3(0.04045)));
+}
+
+vec3 toSrgb(vec3 c) {
+    c = max(c, vec3(0.0));
+    return mix(1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055, c * 12.92, lessThanEqual(c, vec3(0.0031308)));
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+    vec2 size = iResolution.xy;
+    vec2 uv = fragCoord / size;
+    // Which burst window this is, when in it the burst starts, and how far
+    // into the burst we are: 0 outside one.
+    float window = floor(iTime / PERIOD);
+    float start = window * PERIOD + hash(vec2(window, 7.0)) * (PERIOD - BURST);
+    float t = (iTime - start) / BURST;
+    float live = step(0.0, t) * step(t, 1.0);
+    float envelope = live * sin(3.14159265 * clamp(t, 0.0, 1.0));
+    if (envelope <= 0.0) {
+        fragColor = texture(iChannel0, uv);
+        return;
+    }
+    // Bands of 6 to 40 px, re-cut at STEP_HZ during the burst; about one
+    // band in four tears.
+    float tick = floor(iTime * STEP_HZ);
+    float band_px = mix(6.0, 40.0, hash(vec2(tick, 3.0)));
+    float band = floor(fragCoord.y / band_px);
+    float roll = hash(vec2(band, tick));
+    float tear = smoothstep(0.72, 0.9, roll) * envelope;
+    float shift = (hash(vec2(tick, band + 11.0)) - 0.5) * 2.0 * SHIFT_PX * tear;
+    vec2 at = vec2(fragCoord.x + shift, fragCoord.y);
+    vec2 split = vec2(SPLIT_PX * tear, 0.0);
+    vec4 center = texture(iChannel0, at / size);
+    vec3 col = vec3(texture(iChannel0, (at + split) / size).r, center.g, texture(iChannel0, (at - split) / size).b);
+    col = toSrgb(toLinear(col) * (1.0 - DIP * tear));
+    fragColor = vec4(col, center.a);
+}
diff --git a/shaders/post/prefix.glsl b/shaders/post/prefix.glsl
new file mode 100644
index 00000000..efa49483
--- /dev/null
+++ b/shaders/post/prefix.glsl
@@ -0,0 +1,67 @@
+#version 450
+// pardes's Shadertoy prefix (docs/render-pipeline.md §6), put before every
+// post pass: a bundled one in shaders/post/ at build time, a user's file at
+// run time. The uniform names, types and std140 order are ghostty 1.3.2's
+// (src/renderer/shaders/shadertoy_prefix.glsl), so a shader written for
+// ghostty runs here; only the bindings are SDL GPU's (a fragment shader's
+// textures in set 2, its uniform blocks in set 3). Y is down everywhere, as
+// on ghostty's Metal renderer: fragCoord, iChannel0's uv and the cursor
+// rectangles share one top-left space, and iCurrentCursor is (left x,
+// BOTTOM-edge y, width, height) in framebuffer pixels.
+
+layout(set = 3, binding = 0, std140) uniform Globals {
+    uniform vec3  iResolution;
+    uniform float iTime;
+    uniform float iTimeDelta;
+    uniform float iFrameRate;
+    uniform int   iFrame;
+    uniform float iChannelTime[4];
+    uniform vec3  iChannelResolution[4];
+    uniform vec4  iMouse;
+    uniform vec4  iDate;
+    uniform float iSampleRate;
+    uniform vec4  iCurrentCursor;
+    uniform vec4  iPreviousCursor;
+    uniform vec4  iCurrentCursorColor;
+    uniform vec4  iPreviousCursorColor;
+    uniform int   iCurrentCursorStyle;
+    uniform int   iPreviousCursorStyle;
+    uniform int   iCursorVisible;
+    uniform float iTimeCursorChange;
+    uniform float iTimeFocus;
+    uniform int iFocus;
+    uniform vec3  iPalette[256];
+    uniform vec3  iBackgroundColor;
+    uniform vec3  iForegroundColor;
+    uniform vec3  iCursorColor;
+    uniform vec3  iCursorText;
+    uniform vec3  iSelectionForegroundColor;
+    uniform vec3  iSelectionBackgroundColor;
+};
+
+// pardes's own: 1 when the window is opaque, so a pass cannot punch holes
+// in it through its alpha.
+layout(set = 3, binding = 1, std140) uniform PardesPost {
+    float pardesOpaque;
+};
+
+#define CURSORSTYLE_BLOCK        0
+#define CURSORSTYLE_BLOCK_HOLLOW 1
+#define CURSORSTYLE_BAR          2
+#define CURSORSTYLE_UNDERLINE    3
+#define CURSORSTYLE_LOCK         4
+
+layout(set = 2, binding = 0) uniform sampler2D iChannel0;
+
+layout(location = 0) out vec4 _fragColor;
+
+#define texture2D texture
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord);
+void main() {
+    mainImage(_fragColor, gl_FragCoord.xy);
+    if (pardesOpaque > 0.5) _fragColor.a = 1.0;
+}
+
+// The shader's own lines count from 1, so glslc's errors name them.
+#line 1
diff --git a/shaders/post/ripple.glsl b/shaders/post/ripple.glsl
new file mode 100644
index 00000000..ffecbf70
--- /dev/null
+++ b/shaders/post/ripple.glsl
@@ -0,0 +1,49 @@
+// Ripple: the page as a still pool a slow swell crosses. Rings travel out
+// from the middle of the window at a fixed speed in pixels, so they look
+// the same at any size and frame rate; the displacement is at most a couple
+// of pixels, so text stays readable, and it eases in over its first half
+// second instead of snapping on. Each ring catches the light a little on its
+// rising side, in linear light, and the result is dithered so the shading
+// never bands. It is a Shadertoy file: pardes puts its prefix before it.
+
+const float TAU = 6.28318530718;
+const float WAVELENGTH_PX = 150.0;
+const float SPEED_PX = 55.0;        // outward, per second
+const float AMPLITUDE_PX = 2.2;
+const float SHADE = 0.035;          // light on a slope, linear
+const float EASE_IN = 0.5;          // seconds
+
+vec3 toLinear(vec3 c) {
+    return mix(pow((c + 0.055) / 1.055, vec3(2.4)), c / 12.92, lessThanEqual(c, vec3(0.04045)));
+}
+
+vec3 toSrgb(vec3 c) {
+    c = max(c, vec3(0.0));
+    return mix(1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055, c * 12.92, lessThanEqual(c, vec3(0.0031308)));
+}
+
+float ign(vec2 p) {
+    return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715))));
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+    vec2 size = iResolution.xy;
+    vec2 center = 0.5 * size;
+    vec2 offset = fragCoord - center;
+    float radius = length(offset);
+    float reach = 0.5 * length(size);
+    // Strongest a third of the way out, fading to nothing at the middle
+    // and at the edges, so the window's frame never wobbles.
+    float envelope = smoothstep(0.0, 0.18, radius / reach) * (1.0 - smoothstep(0.35, 0.95, radius / reach));
+    float ease = smoothstep(0.0, EASE_IN, iTime);
+    float phase = (radius - iTime * SPEED_PX) * TAU / WAVELENGTH_PX;
+    float height = sin(phase);
+    float slope = cos(phase);
+    vec2 dir = offset / max(radius, 1e-3);
+    vec2 moved = fragCoord + dir * height * AMPLITUDE_PX * envelope * ease;
+
+    vec4 s = texture(iChannel0, moved / size);
+    vec3 col = toLinear(s.rgb) * (1.0 + SHADE * slope * envelope * ease);
+    vec3 srgb = toSrgb(col) + (ign(fragCoord + float(iFrame % 64) * 5.588238) - 0.5) / 255.0;
+    fragColor = vec4(clamp(srgb, 0.0, 1.0), s.a);
+}
diff --git a/shaders/prebuilt/crt.frag.glsl b/shaders/prebuilt/crt.frag.glsl
deleted file mode 100644
index b0b0b93b..00000000
--- a/shaders/prebuilt/crt.frag.glsl
+++ /dev/null
@@ -1,175 +0,0 @@
-#version 450
-
-// The Crt builtin's post-process. Screen point cc shows the scene at
-// uv' = cc*(1 + BARREL*r2), and src/gui/crt.zig maps mouse input through that
-// same transform — keep them equal or clicks drift near the edges.
-
-layout(set = 2, binding = 0) uniform sampler2D u_scene;
-layout(std140, set = 3, binding = 0) uniform CrtUniforms {
-    float time_seconds;
-    float frame;
-    vec2 viewport;
-    // x = CRT, y = ripple, z = glitch. One scene pass can combine them.
-    vec4 effects;
-} u_crt;
-
-layout(location = 0) out vec4 o_col;
-
-const float TAU = 6.28318530718;
-const float BARREL = 0.016; // MUST match src/gui/crt.zig barrel
-const float EDGE_SOFTNESS_PX = 3.5;
-const float CHROMA_PX = 0.28; // radial R/B separation in physical pixels at r2=1
-const float BLOOM_RADIUS_PX = 1.75;
-const float BLOOM_THRESHOLD = 0.60; // linear-light channel peak
-const float BLOOM_SOFTNESS = 0.25;
-const float BLOOM_STRENGTH = 0.045;
-const float SCAN_PERIOD_PX = 3.0;
-const float SCAN_STRENGTH = 0.055;
-const float MASK_PERIOD_PX = 3.0;
-const float MASK_STRENGTH = 0.015;
-const float VIGNETTE_STRENGTH = 0.11; // 11% only at the extreme corners
-const float HUM_STRENGTH = 0.0025;
-const float NOISE_STRENGTH = 0.0020;
-const float EXPOSURE = 1.012;
-
-vec3 srgbToLinear(vec3 c) {
-    vec3 low = c / 12.92;
-    vec3 high = pow((c + 0.055) / 1.055, vec3(2.4));
-    return mix(high, low, lessThanEqual(c, vec3(0.04045)));
-}
-
-vec3 linearToSrgb(vec3 c) {
-    c = max(c, vec3(0.0));
-    vec3 low = c * 12.92;
-    vec3 high = 1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055;
-    return mix(high, low, lessThanEqual(c, vec3(0.0031308)));
-}
-
-vec3 sceneLinear(vec2 uv) {
-    return srgbToLinear(texture(u_scene, uv).rgb);
-}
-
-vec3 brightPass(vec2 uv) {
-    vec3 c = sceneLinear(uv);
-    float peak = max(c.r, max(c.g, c.b));
-    return c * smoothstep(BLOOM_THRESHOLD, BLOOM_THRESHOLD + BLOOM_SOFTNESS, peak);
-}
-
-float noiseAt(vec2 p) {
-    vec3 q = fract(vec3(p.xyx) * 0.1031);
-    q += dot(q, q.yzx + 33.33);
-    return fract((q.x + q.y) * q.z);
-}
-
-// The non-CRT scene effects deliberately distort the source coordinates,
-// rather than remapping the final colors. Themes retain their palette and the
-// effects remain composable with the linear-light CRT treatment below.
-vec2 sceneUv(vec2 uv) {
-    if (u_crt.effects.y > 0.5) {
-        vec2 centered = uv - 0.5;
-        float radius = length(centered);
-        float envelope = 1.0 - smoothstep(0.04, 0.72, radius);
-        float wave = sin(radius * 42.0 - u_crt.time_seconds * 5.2);
-        uv += centered / max(radius, 0.00001) * wave * envelope * 0.0032;
-    }
-    if (u_crt.effects.z > 0.5) {
-        float band = floor(uv.y * 96.0);
-        float seed = noiseAt(vec2(band, floor(u_crt.time_seconds * 13.0)));
-        float tear = smoothstep(0.955, 1.0, seed);
-        uv.x += (noiseAt(vec2(seed, band)) - 0.5) * tear * 0.020;
-    }
-    return uv;
-}
-
-// The scene, ALPHA INCLUDED: with a see-through ground the grid arrives
-// premultiplied and partly empty, and a pass that dropped .a would turn the
-// desktop behind a `*_transparent` theme into opaque black the moment Crt,
-// Ripple or Glitch came on.
-vec4 sceneSrgb(vec2 uv) {
-    vec2 warped = sceneUv(uv);
-    vec4 center = texture(u_scene, warped);
-    if (u_crt.effects.z <= 0.5) return center;
-
-    float band = floor(warped.y * 96.0);
-    float seed = noiseAt(vec2(band, floor(u_crt.time_seconds * 13.0)));
-    float tear = smoothstep(0.955, 1.0, seed);
-    vec2 chroma = vec2((0.35 + 1.25 * tear) / u_crt.viewport.x, 0.0);
-    return vec4(
-        texture(u_scene, warped + chroma).r,
-        center.g,
-        texture(u_scene, warped - chroma).b,
-        center.a
-    );
-}
-
-vec3 effectSceneLinear(vec2 uv) {
-    return srgbToLinear(sceneSrgb(uv).rgb);
-}
-
-void main() {
-    vec2 size = u_crt.viewport;
-    vec2 texel = 1.0 / size;
-    vec2 cc = gl_FragCoord.xy / size * 2.0 - 1.0;
-    float r2 = dot(cc, cc);
-    vec2 uv = cc * (1.0 + BARREL * r2 * u_crt.effects.x) * 0.5 + 0.5;
-
-    // Ripple and glitch are useful without the CRT. They only move samples;
-    // skip every tube-specific light/mask/exposure adjustment.
-    if (u_crt.effects.x <= 0.5) {
-        // The scene texture is already sRGB. Avoid a needless transfer-curve
-        // round trip so a coordinate-only effect preserves theme bytes.
-        vec4 s = sceneSrgb(uv);
-        o_col = vec4(clamp(s.rgb, 0.0, 1.0), clamp(s.a, 0.0, 1.0));
-        return;
-    }
-
-    vec3 col = vec3(0.0);
-    // Outside the tube nothing is drawn, so nothing is covered either: the
-    // old opaque black there would have punched a rectangle out of the
-    // compositor's backdrop.
-    float alpha = 0.0;
-    float edge = min(min(uv.x, uv.y), min(1.0 - uv.x, 1.0 - uv.y));
-    if (edge > 0.0) {
-        vec3 center = effectSceneLinear(uv);
-        vec2 chroma = cc * (CHROMA_PX * r2) * texel;
-        // Each radial sample follows the same ripple/glitch path from its own
-        // pre-warp coordinate. This is also how the Metal kernel composes the
-        // effects; sampling a once-warped center here made combined effects
-        // diverge between the two GUI backends.
-        col = vec3(
-            effectSceneLinear(uv + chroma).r,
-            center.g,
-            effectSceneLinear(uv - chroma).b
-        );
-
-        vec2 bloom_px = texel * BLOOM_RADIUS_PX;
-        vec3 bloom = brightPass(uv + vec2(bloom_px.x, 0.0)) +
-            brightPass(uv - vec2(bloom_px.x, 0.0)) +
-            brightPass(uv + vec2(0.0, bloom_px.y)) +
-            brightPass(uv - vec2(0.0, bloom_px.y));
-        col += bloom * (0.25 * BLOOM_STRENGTH);
-
-        // The mask has unit mean and the scan loss stays small; neither needs
-        // the old global lift that remapped every theme toward white.
-        float scan_wave = 0.5 + 0.5 * cos(gl_FragCoord.y * TAU / SCAN_PERIOD_PX);
-        col *= 1.0 - SCAN_STRENGTH * scan_wave * scan_wave;
-        vec3 mask = 1.0 + MASK_STRENGTH * cos(
-            gl_FragCoord.x * TAU / MASK_PERIOD_PX + vec3(0.0, TAU / 3.0, 2.0 * TAU / 3.0)
-        );
-        col *= mask;
-
-        vec2 edge_px = min(uv, 1.0 - uv) * size;
-        float tube = smoothstep(0.0, EDGE_SOFTNESS_PX, min(edge_px.x, edge_px.y));
-        float vignette = 1.0 - VIGNETTE_STRENGTH * pow(clamp(r2 * 0.5, 0.0, 1.0), 1.6);
-        float hum = 1.0 + HUM_STRENGTH * sin((uv.y * 1.35 - u_crt.time_seconds * 0.11) * TAU);
-        col *= tube * vignette * hum * EXPOSURE;
-        // The tube's edge falloff dims coverage as well as colour; everything
-        // else here is a light adjustment and leaves it alone.
-        alpha = sceneSrgb(uv).a * tube;
-
-        float luma = dot(col, vec3(0.2126, 0.7152, 0.0722));
-        vec2 noise_seed = gl_FragCoord.xy + vec2(u_crt.frame * 17.0, u_crt.frame * 59.0);
-        col += (noiseAt(noise_seed) - 0.5) * NOISE_STRENGTH * (0.15 + 0.85 * clamp(luma, 0.0, 1.0));
-    }
-    o_col = vec4(linearToSrgb(clamp(col, 0.0, 1.0)), clamp(alpha, 0.0, 1.0));
-}
diff --git a/shaders/prebuilt/crt.frag.spv b/shaders/prebuilt/crt.frag.spv
deleted file mode 100644
index f0e14627..00000000
--- a/shaders/prebuilt/crt.frag.spv
+++ /dev/null
diff --git a/shaders/prebuilt/crt.vert.glsl b/shaders/prebuilt/crt.vert.glsl
deleted file mode 100644
index 4e15fcdf..00000000
--- a/shaders/prebuilt/crt.vert.glsl
+++ /dev/null
@@ -1,9 +0,0 @@
-#version 450
-
-// CRT post-process pass: one fullscreen triangle from gl_VertexIndex, no
-// vertex buffer. The fragment shader derives uv from gl_FragCoord.
-
-void main() {
-    vec2 p = vec2(float((gl_VertexIndex << 1) & 2), float(gl_VertexIndex & 2));
-    gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
-}
diff --git a/shaders/prebuilt/post-crt.frag.glsl b/shaders/prebuilt/post-crt.frag.glsl
new file mode 100644
index 00000000..11b95272
--- /dev/null
+++ b/shaders/prebuilt/post-crt.frag.glsl
@@ -0,0 +1,146 @@
+#version 450
+// pardes's Shadertoy prefix (docs/render-pipeline.md §6), put before every
+// post pass: a bundled one in shaders/post/ at build time, a user's file at
+// run time. The uniform names, types and std140 order are ghostty 1.3.2's
+// (src/renderer/shaders/shadertoy_prefix.glsl), so a shader written for
+// ghostty runs here; only the bindings are SDL GPU's (a fragment shader's
+// textures in set 2, its uniform blocks in set 3). Y is down everywhere, as
+// on ghostty's Metal renderer: fragCoord, iChannel0's uv and the cursor
+// rectangles share one top-left space, and iCurrentCursor is (left x,
+// BOTTOM-edge y, width, height) in framebuffer pixels.
+
+layout(set = 3, binding = 0, std140) uniform Globals {
+    uniform vec3  iResolution;
+    uniform float iTime;
+    uniform float iTimeDelta;
+    uniform float iFrameRate;
+    uniform int   iFrame;
+    uniform float iChannelTime[4];
+    uniform vec3  iChannelResolution[4];
+    uniform vec4  iMouse;
+    uniform vec4  iDate;
+    uniform float iSampleRate;
+    uniform vec4  iCurrentCursor;
+    uniform vec4  iPreviousCursor;
+    uniform vec4  iCurrentCursorColor;
+    uniform vec4  iPreviousCursorColor;
+    uniform int   iCurrentCursorStyle;
+    uniform int   iPreviousCursorStyle;
+    uniform int   iCursorVisible;
+    uniform float iTimeCursorChange;
+    uniform float iTimeFocus;
+    uniform int iFocus;
+    uniform vec3  iPalette[256];
+    uniform vec3  iBackgroundColor;
+    uniform vec3  iForegroundColor;
+    uniform vec3  iCursorColor;
+    uniform vec3  iCursorText;
+    uniform vec3  iSelectionForegroundColor;
+    uniform vec3  iSelectionBackgroundColor;
+};
+
+// pardes's own: 1 when the window is opaque, so a pass cannot punch holes
+// in it through its alpha.
+layout(set = 3, binding = 1, std140) uniform PardesPost {
+    float pardesOpaque;
+};
+
+#define CURSORSTYLE_BLOCK        0
+#define CURSORSTYLE_BLOCK_HOLLOW 1
+#define CURSORSTYLE_BAR          2
+#define CURSORSTYLE_UNDERLINE    3
+#define CURSORSTYLE_LOCK         4
+
+layout(set = 2, binding = 0) uniform sampler2D iChannel0;
+
+layout(location = 0) out vec4 _fragColor;
+
+#define texture2D texture
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord);
+void main() {
+    mainImage(_fragColor, gl_FragCoord.xy);
+    if (pardesOpaque > 0.5) _fragColor.a = 1.0;
+}
+
+// The shader's own lines count from 1, so glslc's errors name them.
+#line 1
+// Crt: a slot-mask tube's light, with nothing that moves a pixel. There is
+// no barrel: every click lands where it is drawn, rails and grips at the
+// window's edges included. What is left is light: a beam profile for the
+// scanlines, an aperture mask, a soft bloom of the brightest ink, a faint
+// vignette and the hum of a live tube. Everything is worked out in linear
+// light and dithered back into 8 bits, so the vignette never bands. It is a
+// Shadertoy file: pardes puts its prefix before it (shaders/post/prefix.glsl).
+
+const float TAU = 6.28318530718;
+const float CHROMA_PX = 0.35;       // red and blue apart, at the corners
+const float BLOOM_RADIUS_PX = 1.75;
+const float BLOOM_THRESHOLD = 0.60; // linear-light channel peak
+const float BLOOM_SOFTNESS = 0.25;
+const float BLOOM_STRENGTH = 0.05;
+const float SCAN_PERIOD_PX = 3.0;
+const float SCAN_STRENGTH = 0.07;
+const float MASK_PERIOD_PX = 3.0;
+const float MASK_STRENGTH = 0.018;
+const float VIGNETTE_STRENGTH = 0.12; // at the far corners only
+const float HUM_STRENGTH = 0.004;
+const float HUM_HZ = 0.11;
+const float EXPOSURE = 1.015;
+
+vec3 toLinear(vec3 c) {
+    return mix(pow((c + 0.055) / 1.055, vec3(2.4)), c / 12.92, lessThanEqual(c, vec3(0.04045)));
+}
+
+vec3 toSrgb(vec3 c) {
+    c = max(c, vec3(0.0));
+    return mix(1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055, c * 12.92, lessThanEqual(c, vec3(0.0031308)));
+}
+
+vec3 scene(vec2 uv) {
+    return toLinear(texture(iChannel0, uv).rgb);
+}
+
+vec3 brightPass(vec2 uv) {
+    vec3 c = scene(uv);
+    float peak = max(c.r, max(c.g, c.b));
+    return c * smoothstep(BLOOM_THRESHOLD, BLOOM_THRESHOLD + BLOOM_SOFTNESS, peak);
+}
+
+// Interleaved gradient noise: a dither with no visible pattern.
+float ign(vec2 p) {
+    return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715))));
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+    vec2 size = iResolution.xy;
+    vec2 texel = 1.0 / size;
+    vec2 uv = fragCoord / size;
+    vec2 cc = uv * 2.0 - 1.0;
+    float r2 = dot(cc, cc);
+
+    // The beam converges least at the corners: red and blue drift apart
+    // there, by a third of a pixel.
+    vec2 chroma = cc * (CHROMA_PX * r2 * 0.5) * texel;
+    vec3 col = vec3(scene(uv + chroma).r, scene(uv).g, scene(uv - chroma).b);
+
+    vec2 b = texel * BLOOM_RADIUS_PX;
+    vec3 bloom = brightPass(uv + vec2(b.x, 0.0)) + brightPass(uv - vec2(b.x, 0.0)) +
+        brightPass(uv + vec2(0.0, b.y)) + brightPass(uv - vec2(0.0, b.y));
+    col += bloom * (0.25 * BLOOM_STRENGTH);
+
+    // A beam is brightest on its line and falls off between lines; the
+    // mask is three phosphor stripes a triad. Both average to one, so the
+    // theme keeps its brightness.
+    float line = 0.5 + 0.5 * cos(fragCoord.y * TAU / SCAN_PERIOD_PX);
+    col *= 1.0 - SCAN_STRENGTH * (line * line - 0.375) / 0.625;
+    col *= 1.0 + MASK_STRENGTH * cos(fragCoord.x * TAU / MASK_PERIOD_PX + vec3(0.0, TAU / 3.0, 2.0 * TAU / 3.0));
+
+    float vignette = 1.0 - VIGNETTE_STRENGTH * pow(clamp(r2 * 0.5, 0.0, 1.0), 1.6);
+    float hum = 1.0 + HUM_STRENGTH * sin((uv.y * 1.35 - iTime * HUM_HZ) * TAU);
+    col *= vignette * hum * EXPOSURE;
+
+    vec3 srgb = toSrgb(col);
+    srgb += (ign(fragCoord + float(iFrame % 64) * vec2(5.588238, 5.588238)) - 0.5) / 255.0;
+    fragColor = vec4(clamp(srgb, 0.0, 1.0), texture(iChannel0, uv).a);
+}
diff --git a/shaders/prebuilt/post-crt.frag.spv b/shaders/prebuilt/post-crt.frag.spv
new file mode 100644
index 00000000..e4d98138
--- /dev/null
+++ b/shaders/prebuilt/post-crt.frag.spv
diff --git a/shaders/prebuilt/post-glitch.frag.glsl b/shaders/prebuilt/post-glitch.frag.glsl
new file mode 100644
index 00000000..46538452
--- /dev/null
+++ b/shaders/prebuilt/post-glitch.frag.glsl
@@ -0,0 +1,127 @@
+#version 450
+// pardes's Shadertoy prefix (docs/render-pipeline.md §6), put before every
+// post pass: a bundled one in shaders/post/ at build time, a user's file at
+// run time. The uniform names, types and std140 order are ghostty 1.3.2's
+// (src/renderer/shaders/shadertoy_prefix.glsl), so a shader written for
+// ghostty runs here; only the bindings are SDL GPU's (a fragment shader's
+// textures in set 2, its uniform blocks in set 3). Y is down everywhere, as
+// on ghostty's Metal renderer: fragCoord, iChannel0's uv and the cursor
+// rectangles share one top-left space, and iCurrentCursor is (left x,
+// BOTTOM-edge y, width, height) in framebuffer pixels.
+
+layout(set = 3, binding = 0, std140) uniform Globals {
+    uniform vec3  iResolution;
+    uniform float iTime;
+    uniform float iTimeDelta;
+    uniform float iFrameRate;
+    uniform int   iFrame;
+    uniform float iChannelTime[4];
+    uniform vec3  iChannelResolution[4];
+    uniform vec4  iMouse;
+    uniform vec4  iDate;
+    uniform float iSampleRate;
+    uniform vec4  iCurrentCursor;
+    uniform vec4  iPreviousCursor;
+    uniform vec4  iCurrentCursorColor;
+    uniform vec4  iPreviousCursorColor;
+    uniform int   iCurrentCursorStyle;
+    uniform int   iPreviousCursorStyle;
+    uniform int   iCursorVisible;
+    uniform float iTimeCursorChange;
+    uniform float iTimeFocus;
+    uniform int iFocus;
+    uniform vec3  iPalette[256];
+    uniform vec3  iBackgroundColor;
+    uniform vec3  iForegroundColor;
+    uniform vec3  iCursorColor;
+    uniform vec3  iCursorText;
+    uniform vec3  iSelectionForegroundColor;
+    uniform vec3  iSelectionBackgroundColor;
+};
+
+// pardes's own: 1 when the window is opaque, so a pass cannot punch holes
+// in it through its alpha.
+layout(set = 3, binding = 1, std140) uniform PardesPost {
+    float pardesOpaque;
+};
+
+#define CURSORSTYLE_BLOCK        0
+#define CURSORSTYLE_BLOCK_HOLLOW 1
+#define CURSORSTYLE_BAR          2
+#define CURSORSTYLE_UNDERLINE    3
+#define CURSORSTYLE_LOCK         4
+
+layout(set = 2, binding = 0) uniform sampler2D iChannel0;
+
+layout(location = 0) out vec4 _fragColor;
+
+#define texture2D texture
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord);
+void main() {
+    mainImage(_fragColor, gl_FragCoord.xy);
+    if (pardesOpaque > 0.5) _fragColor.a = 1.0;
+}
+
+// The shader's own lines count from 1, so glslc's errors name them.
+#line 1
+// Glitch: now and then the signal slips. Every couple of seconds a short
+// burst tears a few horizontal bands sideways and pulls their red and blue
+// apart; the bands are sized in pixels and the burst eases in and out over
+// a fraction of a second, so it reads as one event rather than a flicker,
+// and it looks the same at 60 or 144 Hz because every step is keyed to
+// iTime, not to frames. Between bursts the page is left exactly as it is.
+// A torn band's brightness dips in linear light. It is a Shadertoy file:
+// pardes puts its prefix before it.
+
+const float PERIOD = 2.4;           // seconds between bursts, on average
+const float BURST = 0.28;           // seconds a burst lasts
+const float STEP_HZ = 24.0;         // how often a burst re-tears
+const float SHIFT_PX = 14.0;
+const float SPLIT_PX = 2.5;
+const float DIP = 0.12;
+
+float hash(vec2 p) {
+    vec3 q = fract(vec3(p.xyx) * 0.1031);
+    q += dot(q, q.yzx + 33.33);
+    return fract((q.x + q.y) * q.z);
+}
+
+vec3 toLinear(vec3 c) {
+    return mix(pow((c + 0.055) / 1.055, vec3(2.4)), c / 12.92, lessThanEqual(c, vec3(0.04045)));
+}
+
+vec3 toSrgb(vec3 c) {
+    c = max(c, vec3(0.0));
+    return mix(1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055, c * 12.92, lessThanEqual(c, vec3(0.0031308)));
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+    vec2 size = iResolution.xy;
+    vec2 uv = fragCoord / size;
+    // Which burst window this is, when in it the burst starts, and how far
+    // into the burst we are: 0 outside one.
+    float window = floor(iTime / PERIOD);
+    float start = window * PERIOD + hash(vec2(window, 7.0)) * (PERIOD - BURST);
+    float t = (iTime - start) / BURST;
+    float live = step(0.0, t) * step(t, 1.0);
+    float envelope = live * sin(3.14159265 * clamp(t, 0.0, 1.0));
+    if (envelope <= 0.0) {
+        fragColor = texture(iChannel0, uv);
+        return;
+    }
+    // Bands of 6 to 40 px, re-cut at STEP_HZ during the burst; about one
+    // band in four tears.
+    float tick = floor(iTime * STEP_HZ);
+    float band_px = mix(6.0, 40.0, hash(vec2(tick, 3.0)));
+    float band = floor(fragCoord.y / band_px);
+    float roll = hash(vec2(band, tick));
+    float tear = smoothstep(0.72, 0.9, roll) * envelope;
+    float shift = (hash(vec2(tick, band + 11.0)) - 0.5) * 2.0 * SHIFT_PX * tear;
+    vec2 at = vec2(fragCoord.x + shift, fragCoord.y);
+    vec2 split = vec2(SPLIT_PX * tear, 0.0);
+    vec4 center = texture(iChannel0, at / size);
+    vec3 col = vec3(texture(iChannel0, (at + split) / size).r, center.g, texture(iChannel0, (at - split) / size).b);
+    col = toSrgb(toLinear(col) * (1.0 - DIP * tear));
+    fragColor = vec4(col, center.a);
+}
diff --git a/shaders/prebuilt/post-glitch.frag.spv b/shaders/prebuilt/post-glitch.frag.spv
new file mode 100644
index 00000000..8a224958
--- /dev/null
+++ b/shaders/prebuilt/post-glitch.frag.spv
diff --git a/shaders/prebuilt/post-ripple.frag.glsl b/shaders/prebuilt/post-ripple.frag.glsl
new file mode 100644
index 00000000..28059def
--- /dev/null
+++ b/shaders/prebuilt/post-ripple.frag.glsl
@@ -0,0 +1,116 @@
+#version 450
+// pardes's Shadertoy prefix (docs/render-pipeline.md §6), put before every
+// post pass: a bundled one in shaders/post/ at build time, a user's file at
+// run time. The uniform names, types and std140 order are ghostty 1.3.2's
+// (src/renderer/shaders/shadertoy_prefix.glsl), so a shader written for
+// ghostty runs here; only the bindings are SDL GPU's (a fragment shader's
+// textures in set 2, its uniform blocks in set 3). Y is down everywhere, as
+// on ghostty's Metal renderer: fragCoord, iChannel0's uv and the cursor
+// rectangles share one top-left space, and iCurrentCursor is (left x,
+// BOTTOM-edge y, width, height) in framebuffer pixels.
+
+layout(set = 3, binding = 0, std140) uniform Globals {
+    uniform vec3  iResolution;
+    uniform float iTime;
+    uniform float iTimeDelta;
+    uniform float iFrameRate;
+    uniform int   iFrame;
+    uniform float iChannelTime[4];
+    uniform vec3  iChannelResolution[4];
+    uniform vec4  iMouse;
+    uniform vec4  iDate;
+    uniform float iSampleRate;
+    uniform vec4  iCurrentCursor;
+    uniform vec4  iPreviousCursor;
+    uniform vec4  iCurrentCursorColor;
+    uniform vec4  iPreviousCursorColor;
+    uniform int   iCurrentCursorStyle;
+    uniform int   iPreviousCursorStyle;
+    uniform int   iCursorVisible;
+    uniform float iTimeCursorChange;
+    uniform float iTimeFocus;
+    uniform int iFocus;
+    uniform vec3  iPalette[256];
+    uniform vec3  iBackgroundColor;
+    uniform vec3  iForegroundColor;
+    uniform vec3  iCursorColor;
+    uniform vec3  iCursorText;
+    uniform vec3  iSelectionForegroundColor;
+    uniform vec3  iSelectionBackgroundColor;
+};
+
+// pardes's own: 1 when the window is opaque, so a pass cannot punch holes
+// in it through its alpha.
+layout(set = 3, binding = 1, std140) uniform PardesPost {
+    float pardesOpaque;
+};
+
+#define CURSORSTYLE_BLOCK        0
+#define CURSORSTYLE_BLOCK_HOLLOW 1
+#define CURSORSTYLE_BAR          2
+#define CURSORSTYLE_UNDERLINE    3
+#define CURSORSTYLE_LOCK         4
+
+layout(set = 2, binding = 0) uniform sampler2D iChannel0;
+
+layout(location = 0) out vec4 _fragColor;
+
+#define texture2D texture
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord);
+void main() {
+    mainImage(_fragColor, gl_FragCoord.xy);
+    if (pardesOpaque > 0.5) _fragColor.a = 1.0;
+}
+
+// The shader's own lines count from 1, so glslc's errors name them.
+#line 1
+// Ripple: the page as a still pool a slow swell crosses. Rings travel out
+// from the middle of the window at a fixed speed in pixels, so they look
+// the same at any size and frame rate; the displacement is at most a couple
+// of pixels, so text stays readable, and it eases in over its first half
+// second instead of snapping on. Each ring catches the light a little on its
+// rising side, in linear light, and the result is dithered so the shading
+// never bands. It is a Shadertoy file: pardes puts its prefix before it.
+
+const float TAU = 6.28318530718;
+const float WAVELENGTH_PX = 150.0;
+const float SPEED_PX = 55.0;        // outward, per second
+const float AMPLITUDE_PX = 2.2;
+const float SHADE = 0.035;          // light on a slope, linear
+const float EASE_IN = 0.5;          // seconds
+
+vec3 toLinear(vec3 c) {
+    return mix(pow((c + 0.055) / 1.055, vec3(2.4)), c / 12.92, lessThanEqual(c, vec3(0.04045)));
+}
+
+vec3 toSrgb(vec3 c) {
+    c = max(c, vec3(0.0));
+    return mix(1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055, c * 12.92, lessThanEqual(c, vec3(0.0031308)));
+}
+
+float ign(vec2 p) {
+    return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715))));
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+    vec2 size = iResolution.xy;
+    vec2 center = 0.5 * size;
+    vec2 offset = fragCoord - center;
+    float radius = length(offset);
+    float reach = 0.5 * length(size);
+    // Strongest a third of the way out, fading to nothing at the middle
+    // and at the edges, so the window's frame never wobbles.
+    float envelope = smoothstep(0.0, 0.18, radius / reach) * (1.0 - smoothstep(0.35, 0.95, radius / reach));
+    float ease = smoothstep(0.0, EASE_IN, iTime);
+    float phase = (radius - iTime * SPEED_PX) * TAU / WAVELENGTH_PX;
+    float height = sin(phase);
+    float slope = cos(phase);
+    vec2 dir = offset / max(radius, 1e-3);
+    vec2 moved = fragCoord + dir * height * AMPLITUDE_PX * envelope * ease;
+
+    vec4 s = texture(iChannel0, moved / size);
+    vec3 col = toLinear(s.rgb) * (1.0 + SHADE * slope * envelope * ease);
+    vec3 srgb = toSrgb(col) + (ign(fragCoord + float(iFrame % 64) * 5.588238) - 0.5) / 255.0;
+    fragColor = vec4(clamp(srgb, 0.0, 1.0), s.a);
+}
diff --git a/shaders/prebuilt/post-ripple.frag.spv b/shaders/prebuilt/post-ripple.frag.spv
new file mode 100644
index 00000000..1a105a33
--- /dev/null
+++ b/shaders/prebuilt/post-ripple.frag.spv
diff --git a/shaders/prebuilt/post.vert.glsl b/shaders/prebuilt/post.vert.glsl
new file mode 100644
index 00000000..86739a65
--- /dev/null
+++ b/shaders/prebuilt/post.vert.glsl
@@ -0,0 +1,10 @@
+#version 450
+
+// A post pass (docs/render-pipeline.md §6): one fullscreen triangle from
+// gl_VertexIndex, no vertex buffer. The Shadertoy fragment shader works from
+// gl_FragCoord, y down, as its fragCoord.
+
+void main() {
+    vec2 p = vec2(float((gl_VertexIndex << 1) & 2), float(gl_VertexIndex & 2));
+    gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
+}
diff --git a/shaders/prebuilt/crt.vert.spv b/shaders/prebuilt/post.vert.spv
index 8a75ebb3..8a75ebb3 100644
--- a/shaders/prebuilt/crt.vert.spv
+++ b/shaders/prebuilt/post.vert.spv