feat(ghostty): add stellar cursor shaders

Author: ALX99

.config/ghostty/config

@@ -7,6 +7,8 @@ window-inherit-font-size = true
 mouse-hide-while-typing = true
 
 custom-shader = ~/.config/ghostty/cursor-blaze.glsl
+custom-shader = ~/.config/ghostty/quiet-star.glsl
+custom-shader-animation = true
 
 # PS1 / LS_COLORS theme
 # Mirrors the xterm-256 colors used in home/.bashrc and home/.profile:

.config/ghostty/cursor-blaze.glsl

@@ -1,130 +1,206 @@
-float ease(float x) {
-    return pow(1.0 - x, 10.0);
-}
-
-float sdBox(in vec2 p, in vec2 xy, in vec2 b)
+// Cursor Blaze
+//
+// A coronal cursor treatment that complements Stellar Dynamics:
+//   - a shrinking white-blue cursor comet
+//   - photospheric-white sparks on cursor movement
+//   - a cool corona aura and restrained refraction
+//   - faint scanlines and a vignette
+//
+// Ghostty exposes the terminal as iChannel0 and supplies cursor uniforms.
+
+#define PI 3.14159265358979323846
+
+// These are shared in spirit with quiet-star.glsl: a cool white corona
+// surrounding a slightly warmer stellar photosphere.
+const vec3 DEEP_NAVY = vec3(0.012, 0.027, 0.058);
+const vec3 CORONAL_BLUE = vec3(0.320, 0.600, 0.940);
+const vec3 CORONA_WHITE = vec3(0.720, 0.850, 1.000);
+const vec3 PHOTOSPHERE_WHITE = vec3(1.000, 0.940, 0.700);
+
+float saturate(float value)
 {
-    vec2 d = abs(p - xy) - b;
-    return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+    return clamp(value, 0.0, 1.0);
 }
 
-float getSdfRectangle(in vec2 p, in vec2 xy, in vec2 b)
+float hash11(float value)
 {
-    vec2 d = abs(p - xy) - b;
-    return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+    value = fract(value * 0.1031);
+    value *= value + 33.33;
+    value *= value + value;
+    return fract(value);
 }
-// Based on Inigo Quilez's 2D distance functions article: https://iquilezles.org/articles/distfunctions2d/
-// Potencially optimized by eliminating conditionals and loops to enhance performance and reduce branching
-float seg(in vec2 p, in vec2 a, in vec2 b, inout float s, float d) {
-    vec2 e = b - a;
-    vec2 w = p - a;
-    vec2 proj = a + e * clamp(dot(w, e) / dot(e, e), 0.0, 1.0);
-    float segd = dot(p - proj, p - proj);
-    d = min(d, segd);
-
-    float c0 = step(0.0, p.y - a.y);
-    float c1 = 1.0 - step(0.0, p.y - b.y);
-    float c2 = 1.0 - step(0.0, e.x * w.y - e.y * w.x);
-    float allCond = c0 * c1 * c2;
-    float noneCond = (1.0 - c0) * (1.0 - c1) * (1.0 - c2);
-    float flip = mix(1.0, -1.0, step(0.5, allCond + noneCond));
-    s *= flip;
-    return d;
-}
-
-float getSdfParallelogram(in vec2 p, in vec2 v0, in vec2 v1, in vec2 v2, in vec2 v3) {
-    float s = 1.0;
-    float d = dot(p - v0, p - v0);
 
-    d = seg(p, v0, v3, s, d);
-    d = seg(p, v1, v0, s, d);
-    d = seg(p, v2, v1, s, d);
-    d = seg(p, v3, v2, s, d);
-
-    return s * sqrt(d);
+float smootherstep(float value)
+{
+    value = saturate(value);
+    return value * value * value * (value * (value * 6.0 - 15.0) + 10.0);
 }
 
-vec2 normalize(vec2 value, float isPosition) {
-    return (value * 2.0 - (iResolution.xy * isPosition)) / iResolution.y;
+vec2 cursorCenter(vec4 cursor)
+{
+    return vec2(cursor.x + cursor.z * 0.5, cursor.y - cursor.w * 0.5);
 }
 
-float blend(float t)
+float segmentDistance(vec2 point, vec2 start, vec2 end, out float along)
 {
-    float sqr = t * t;
-    return sqr / (2.0 * (sqr - t) + 1.0);
+    vec2 segment = end - start;
+    along = saturate(dot(point - start, segment) / max(dot(segment, segment), 0.0001));
+    return length(point - (start + segment * along));
 }
 
-float antialising(float distance) {
-    return 1. - smoothstep(0., normalize(vec2(2., 2.), 0.).x, distance);
+float roundedBoxDistance(vec2 point, vec2 center, vec2 halfSize, float radius)
+{
+    vec2 distanceToEdge = abs(point - center) - halfSize + radius;
+    return length(max(distanceToEdge, 0.0))
+        + min(max(distanceToEdge.x, distanceToEdge.y), 0.0)
+        - radius;
 }
 
-float determineStartVertexFactor(vec2 a, vec2 b) {
-    // Conditions using step
-    float condition1 = step(b.x, a.x) * step(a.y, b.y); // a.x < b.x && a.y > b.y
-    float condition2 = step(a.x, b.x) * step(b.y, a.y); // a.x > b.x && a.y < b.y
-
-    // If neither condition is met, return 1 (else case)
-    return 1.0 - max(condition1, condition2);
-}
-vec2 getRectangleCenter(vec4 rectangle) {
-    return vec2(rectangle.x + (rectangle.z / 2.), rectangle.y - (rectangle.w / 2.));
+vec3 terminalEmission(vec2 uv, vec2 offset, vec3 background)
+{
+    vec3 sampleColor = texture(iChannel0, clamp(uv + offset, 0.0, 1.0)).rgb;
+    float ink = smoothstep(0.08, 0.70, length(sampleColor - background));
+    return max(sampleColor - background, 0.0) * ink;
 }
 
-const vec4 TRAIL_COLOR = vec4(0.2, 0.8, 1.0, 1.0); // neon blue
-const vec4 CURRENT_CURSOR_COLOR = TRAIL_COLOR;
-const vec4 PREVIOUS_CURSOR_COLOR = TRAIL_COLOR;
-const vec4 TRAIL_COLOR_ACCENT = vec4(0.0, 0.4, 1.0, 1.0); // deeper blue
-const float DURATION = .5;
-const float OPACITY = .2;
-
 void mainImage(out vec4 fragColor, in vec2 fragCoord)
 {
-    #if !defined(WEB)
-    fragColor = texture(iChannel0, fragCoord.xy / iResolution.xy);
-    #endif
-    //Normalization for fragCoord to a space of -1 to 1;
-    vec2 vu = normalize(fragCoord, 1.);
-    vec2 offsetFactor = vec2(-.5, 0.5);
-
-    //Normalization for cursor position and size;
-    //cursor xy has the postion in a space of -1 to 1;
-    //zw has the width and height
-    vec4 currentCursor = vec4(normalize(iCurrentCursor.xy, 1.), normalize(iCurrentCursor.zw, 0.));
-    vec4 previousCursor = vec4(normalize(iPreviousCursor.xy, 1.), normalize(iPreviousCursor.zw, 0.));
-
-    //When drawing a parellelogram between cursors for the trail i need to determine where to start at the top-left or top-right vertex of the cursor
-    float vertexFactor = determineStartVertexFactor(currentCursor.xy, previousCursor.xy);
-    float invertedVertexFactor = 1.0 - vertexFactor;
-
-    //Set every vertex of my parellogram
-    vec2 v0 = vec2(currentCursor.x + currentCursor.z * vertexFactor, currentCursor.y - currentCursor.w);
-    vec2 v1 = vec2(currentCursor.x + currentCursor.z * invertedVertexFactor, currentCursor.y);
-    vec2 v2 = vec2(previousCursor.x + currentCursor.z * invertedVertexFactor, previousCursor.y);
-    vec2 v3 = vec2(previousCursor.x + currentCursor.z * vertexFactor, previousCursor.y - previousCursor.w);
-
-    vec4 newColor = vec4(fragColor);
-
-    float progress = blend(clamp((iTime - iTimeCursorChange) / DURATION, 0.0, 1));
-    float easedProgress = ease(progress);
-
-    //Distance between cursors determine the total length of the parallelogram;
-    vec2 centerCC = getRectangleCenter(currentCursor);
-    vec2 centerCP = getRectangleCenter(previousCursor);
-    float lineLength = distance(centerCC, centerCP);
-    float distanceToEnd = distance(vu.xy, centerCC);
-    float alphaModifier = distanceToEnd / (lineLength * (easedProgress));
-
-    if (alphaModifier > 1.0) { // this change fixed it for me.
-      alphaModifier = 1.0;
+    vec2 resolution = iResolution.xy;
+    vec2 uv = fragCoord / resolution;
+    vec2 pixel = 1.0 / resolution;
+    vec4 source = texture(iChannel0, uv);
+    vec3 color = source.rgb;
+
+    vec2 current = cursorCenter(iCurrentCursor);
+    vec2 previous = cursorCenter(iPreviousCursor);
+    vec2 movement = current - previous;
+    float movementLength = length(movement);
+    float cellSize = max(max(iCurrentCursor.z, iCurrentCursor.w), 1.0);
+    float cursorAge = max(iTime - iTimeCursorChange, 0.0);
+
+    // A subtle phosphor bloom around bright terminal glyphs. Keeping this
+    // small preserves sharp text while still giving colours a soft halo.
+    vec2 bloomNear = pixel * 1.5;
+    vec2 bloomFar = pixel * 3.5;
+    vec3 bloom = vec3(0.0);
+    bloom += terminalEmission(uv, vec2(bloomNear.x, 0.0), iBackgroundColor);
+    bloom += terminalEmission(uv, vec2(-bloomNear.x, 0.0), iBackgroundColor);
+    bloom += terminalEmission(uv, vec2(0.0, bloomNear.y), iBackgroundColor);
+    bloom += terminalEmission(uv, vec2(0.0, -bloomNear.y), iBackgroundColor);
+    bloom += terminalEmission(uv, vec2(bloomFar.x, bloomFar.y), iBackgroundColor);
+    bloom += terminalEmission(uv, vec2(-bloomFar.x, bloomFar.y), iBackgroundColor);
+    bloom += terminalEmission(uv, vec2(bloomFar.x, -bloomFar.y), iBackgroundColor);
+    bloom += terminalEmission(uv, vec2(-bloomFar.x, -bloomFar.y), iBackgroundColor);
+    color += bloom * 0.018;
+
+    // Pull the old end of the trail towards the new cursor. Short movements
+    // disappear quickly, while longer jumps linger just enough to stay
+    // readable.
+    float movementCells = movementLength / cellSize;
+    float trailLifetime = mix(0.30, 0.52, smoothstep(0.5, 10.0, movementCells));
+    float trailProgress = smootherstep(cursorAge / trailLifetime);
+    float trailAlive = 1.0 - smoothstep(trailLifetime * 0.58, trailLifetime, cursorAge);
+    vec2 trailStart = mix(previous, current, trailProgress);
+    float along;
+    float trailDistance = segmentDistance(fragCoord, trailStart, current, along);
+    float trailWidth = cellSize * mix(0.38, 0.16, trailProgress);
+
+    // Taper and dim the old end so the trail reads as a comet rather than a
+    // uniformly thick beam.
+    float trailTaper = mix(0.28, 1.0, smootherstep(along));
+    float localTrailWidth = trailWidth * trailTaper;
+    float tailFade = mix(0.20, 1.0, smootherstep(along));
+    float trailCore = 1.0
+        - smoothstep(localTrailWidth * 0.12, localTrailWidth * 0.55, trailDistance);
+    float trailBeam = 1.0
+        - smoothstep(localTrailWidth * 0.45, localTrailWidth * 1.50, trailDistance);
+    float trailAura = 1.0
+        - smoothstep(localTrailWidth, localTrailWidth * 4.5, trailDistance);
+    float shimmer = 0.90 + 0.10 * sin(along * 18.0 - iTime * 9.0);
+    vec3 trailColor = mix(CORONAL_BLUE, CORONA_WHITE, smootherstep(along));
+    trailColor = mix(
+        trailColor,
+        PHOTOSPHERE_WHITE,
+        0.18 * sin(along * PI)
+    );
+    color += trailColor
+        * (trailCore * 0.78 + trailBeam * 0.25 + trailAura * 0.10)
+        * trailAlive
+        * tailFade
+        * shimmer;
+
+    // A few deterministic particles split gently away from the beam. The
+    // cursor-change timestamp acts as a stable random seed for each movement.
+    vec2 direction = movement / max(movementLength, 0.0001);
+    vec2 normal = vec2(-direction.y, direction.x);
+    float movementGate = smoothstep(cellSize * 0.20, cellSize * 0.90, movementLength);
+    float sparkLife = 1.0 - smoothstep(0.12, 0.48, cursorAge);
+    float eventSeed = floor(iTimeCursorChange * 120.0);
+    for (int index = 0; index < 5; index++) {
+        float id = float(index);
+        float seedA = hash11(eventSeed + id * 17.17);
+        float seedB = hash11(eventSeed + id * 41.73 + 9.2);
+        float seedC = hash11(eventSeed + id * 73.91 + 2.8);
+        vec2 sparkPosition = mix(previous, current, seedA);
+        sparkPosition += normal * (seedB - 0.5) * cursorAge * (28.0 + 52.0 * seedC);
+        sparkPosition -= direction * cursorAge * (8.0 + 22.0 * seedA);
+        float sparkRadius = mix(2.2, 0.45, saturate(cursorAge / 0.48));
+        float spark = 1.0 - smoothstep(sparkRadius * 0.25, sparkRadius, distance(fragCoord, sparkPosition));
+        float twinkle = 0.78 + 0.22 * sin(iTime * 18.0 + id * 3.1);
+        color += mix(CORONA_WHITE, PHOTOSPHERE_WHITE, seedB)
+            * spark
+            * sparkLife
+            * movementGate
+            * twinkle
+            * 0.72;
     }
 
-    float sdfCursor = getSdfRectangle(vu, currentCursor.xy - (currentCursor.zw * offsetFactor), currentCursor.zw * 0.5);
-    float sdfTrail = getSdfParallelogram(vu, v0, v1, v2, v3);
-
-    newColor = mix(newColor, TRAIL_COLOR_ACCENT, 1.0 - smoothstep(sdfTrail, -0.01, 0.001));
-    newColor = mix(newColor, TRAIL_COLOR, antialising(sdfTrail));
-
-    newColor = mix(fragColor, newColor, 1.0 - alphaModifier);
-    fragColor = mix(newColor, fragColor, step(sdfCursor, 0));
-
+    // An always-on aura outlines the actual cursor. It follows block, bar, and
+    // underline cursors because it uses Ghostty's supplied cursor dimensions.
+    vec2 cursorHalfSize = max(iCurrentCursor.zw * 0.5, vec2(0.75));
+    float cursorDistance = roundedBoxDistance(
+        fragCoord,
+        current,
+        cursorHalfSize,
+        min(2.5, min(cursorHalfSize.x, cursorHalfSize.y))
+    );
+    float cursorOutside = step(0.0, cursorDistance);
+    float cursorAura = (1.0 - smoothstep(0.0, 18.0, cursorDistance)) * cursorOutside;
+    float cursorEdge = 1.0 - smoothstep(0.2, 1.8, abs(cursorDistance));
+    float heartbeat = 0.86 + 0.14 * sin(iTime * 4.0);
+    color += CORONA_WHITE * cursorAura * 0.11 * heartbeat;
+    color += mix(CORONA_WHITE, PHOTOSPHERE_WHITE, 0.45)
+        * cursorEdge
+        * 0.30;
+
+    // Locally split RGB channels near an active trail. The cool coronal
+    // fringe stays visible while moving but disappears while reading output.
+    float radialDistance = distance(fragCoord, current);
+    vec2 radial = (fragCoord - current) / max(radialDistance, 1.0);
+    vec2 prismOffset = radial * pixel * 1.35;
+    vec3 refracted = color;
+    refracted.r = texture(iChannel0, clamp(uv + prismOffset, 0.0, 1.0)).r;
+    refracted.b = texture(iChannel0, clamp(uv - prismOffset, 0.0, 1.0)).b;
+    float prismMask = trailAlive
+        * movementGate
+        * (1.0 - smoothstep(20.0, 150.0, radialDistance))
+        * 0.30;
+    color = mix(color, refracted + (color - source.rgb), prismMask);
+
+    // A nearly invisible energy ripple in background pixels makes the cursor
+    // feel luminous without tinting text.
+    float backgroundMask = 1.0 - smoothstep(0.025, 0.16, length(source.rgb - iBackgroundColor));
+    float angle = atan(fragCoord.y - current.y, fragCoord.x - current.x);
+    float ripple = 0.5 + 0.5 * sin(radialDistance * 0.055 - iTime * 2.2 + angle * 3.0);
+    float ambient = (1.0 - smoothstep(20.0, 330.0, radialDistance)) * ripple * backgroundMask;
+    color += mix(DEEP_NAVY, CORONAL_BLUE, ripple) * ambient * 0.012;
+
+    // Finish with faint moving scanlines and a soft vignette.
+    float scanline = 0.5 + 0.5 * sin(fragCoord.y * PI + iTime * 2.0);
+    color *= 0.986 + scanline * 0.014;
+    vec2 vignetteUv = uv * (1.0 - uv.yx);
+    float vignette = pow(saturate(vignetteUv.x * vignetteUv.y * 18.0), 0.10);
+    color *= mix(0.90, 1.0, vignette);
+
+    fragColor = vec4(clamp(color, 0.0, 1.0), source.a);
 }