diff --git a/ghostty/shaders/animated-gradient-shader.glsl b/ghostty/shaders/animated-gradient-shader.glsl
new file mode 100644
index 0000000..01b541c
--- /dev/null
+++ b/ghostty/shaders/animated-gradient-shader.glsl
@@ -0,0 +1,40 @@
+// credits: https://github.com/unkn0wncode
+void mainImage(out vec4 fragColor, in vec2 fragCoord)
+{
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ // Create seamless gradient animation
+ float speed = 0.2;
+ float gradientFactor = (uv.x + uv.y) / 2.0;
+
+ // Use smoothstep and multiple sin waves for smoother transition
+ float t = sin(iTime * speed) * 0.5 + 0.5;
+ gradientFactor = smoothstep(0.0, 1.0, gradientFactor);
+
+ // Create smooth circular animation
+ float angle = iTime * speed;
+ vec3 color1 = vec3(0.1, 0.1, 0.5);
+ vec3 color2 = vec3(0.5, 0.1, 0.1);
+ vec3 color3 = vec3(0.1, 0.5, 0.1);
+
+ // Smooth interpolation between colors using multiple mix operations
+ vec3 gradientStartColor = mix(
+ mix(color1, color2, smoothstep(0.0, 1.0, sin(angle) * 0.5 + 0.5)),
+ color3,
+ smoothstep(0.0, 1.0, sin(angle + 2.0) * 0.5 + 0.5)
+ );
+
+ vec3 gradientEndColor = mix(
+ mix(color2, color3, smoothstep(0.0, 1.0, sin(angle + 1.0) * 0.5 + 0.5)),
+ color1,
+ smoothstep(0.0, 1.0, sin(angle + 3.0) * 0.5 + 0.5)
+ );
+
+ vec3 gradientColor = mix(gradientStartColor, gradientEndColor, gradientFactor);
+
+ vec4 terminalColor = texture(iChannel0, uv);
+ float mask = 1.0 - step(0.5, dot(terminalColor.rgb, vec3(1.0)));
+ vec3 blendedColor = mix(terminalColor.rgb, gradientColor, mask);
+
+ fragColor = vec4(blendedColor, terminalColor.a);
+}
diff --git a/ghostty/shaders/bettercrt.glsl b/ghostty/shaders/bettercrt.glsl
new file mode 100644
index 0000000..8f58b89
--- /dev/null
+++ b/ghostty/shaders/bettercrt.glsl
@@ -0,0 +1,33 @@
+// Original shader collected from: https://www.shadertoy.com/view/WsVSzV
+// Licensed under Shadertoy's default since the original creator didn't provide any license. (CC BY NC SA 3.0)
+// Slight modifications were made to give a green-ish effect.
+
+// This shader was modified by April Hall (arithefirst)
+// Sourced from https://github.com/m-ahdal/ghostty-shaders/blob/main/retro-terminal.glsl
+// Changes made:
+// - Removed tint
+// - Made the boundaries match ghostty's background color
+
+float warp = 0.25; // simulate curvature of CRT monitor
+float scan = 0.50; // simulate darkness between scanlines
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord)
+{
+ // squared distance from center
+ vec2 uv = fragCoord / iResolution.xy;
+ vec2 dc = abs(0.5 - uv);
+ dc *= dc;
+
+ // warp the fragment coordinates
+ uv.x -= 0.5; uv.x *= 1.0 + (dc.y * (0.3 * warp)); uv.x += 0.5;
+ uv.y -= 0.5; uv.y *= 1.0 + (dc.x * (0.4 * warp)); uv.y += 0.5;
+
+ // determine if we are drawing in a scanline
+ float apply = abs(sin(fragCoord.y) * 0.25 * scan);
+
+ // sample the texture
+ vec3 color = texture(iChannel0, uv).rgb;
+
+ // mix the sampled color with the scanline intensity
+ fragColor = vec4(mix(color, vec3(0.0), apply), 1.0);
+}
diff --git a/ghostty/shaders/bloom.glsl b/ghostty/shaders/bloom.glsl
new file mode 100644
index 0000000..1d20930
--- /dev/null
+++ b/ghostty/shaders/bloom.glsl
@@ -0,0 +1,52 @@
+// source: https://gist.github.com/qwerasd205/c3da6c610c8ffe17d6d2d3cc7068f17f
+// credits: https://github.com/qwerasd205
+// Golden spiral samples, [x, y, weight] weight is inverse of distance.
+const vec3[24] samples = {
+ vec3(0.1693761725038636, 0.9855514761735895, 1),
+ vec3(-1.333070830962943, 0.4721463328627773, 0.7071067811865475),
+ vec3(-0.8464394909806497, -1.51113870578065, 0.5773502691896258),
+ vec3(1.554155680728463, -1.2588090085709776, 0.5),
+ vec3(1.681364377589461, 1.4741145918052656, 0.4472135954999579),
+ vec3(-1.2795157692199817, 2.088741103228784, 0.4082482904638631),
+ vec3(-2.4575847530631187, -0.9799373355024756, 0.3779644730092272),
+ vec3(0.5874641440200847, -2.7667464429345077, 0.35355339059327373),
+ vec3(2.997715703369726, 0.11704939884745152, 0.3333333333333333),
+ vec3(0.41360842451688395, 3.1351121305574803, 0.31622776601683794),
+ vec3(-3.167149933769243, 0.9844599011770256, 0.30151134457776363),
+ vec3(-1.5736713846521535, -3.0860263079123245, 0.2886751345948129),
+ vec3(2.888202648340422, -2.1583061557896213, 0.2773500981126146),
+ vec3(2.7150778983300325, 2.5745586041105715, 0.2672612419124244),
+ vec3(-2.1504069972377464, 3.2211410627650165, 0.2581988897471611),
+ vec3(-3.6548858794907493, -1.6253643308191343, 0.25),
+ vec3(1.0130775986052671, -3.9967078676335834, 0.24253562503633297),
+ vec3(4.229723673607257, 0.33081361055181563, 0.23570226039551587),
+ vec3(0.40107790291173834, 4.340407413572593, 0.22941573387056174),
+ vec3(-4.319124570236028, 1.159811599693438, 0.22360679774997896),
+ vec3(-1.9209044802827355, -4.160543952132907, 0.2182178902359924),
+ vec3(3.8639122286635708, -2.6589814382925123, 0.21320071635561041),
+ vec3(3.3486228404946234, 3.4331800232609, 0.20851441405707477),
+ vec3(-2.8769733643574344, 3.9652268864187157, 0.20412414523193154)
+ };
+
+float lum(vec4 c) {
+ return 0.299 * c.r + 0.587 * c.g + 0.114 * c.b;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ vec4 color = texture(iChannel0, uv);
+
+ vec2 step = vec2(1.414) / iResolution.xy;
+
+ for (int i = 0; i < 24; i++) {
+ vec3 s = samples[i];
+ vec4 c = texture(iChannel0, uv + s.xy * step);
+ float l = lum(c);
+ if (l > 0.2) {
+ color += l * s.z * c * 0.2;
+ }
+ }
+
+ fragColor = color;
+}
diff --git a/ghostty/shaders/bloom025.glsl b/ghostty/shaders/bloom025.glsl
new file mode 100644
index 0000000..5b6afe9
--- /dev/null
+++ b/ghostty/shaders/bloom025.glsl
@@ -0,0 +1,52 @@
+// source: https://gist.github.com/qwerasd205/c3da6c610c8ffe17d6d2d3cc7068f17f
+// credits: https://github.com/qwerasd205
+// Golden spiral samples, [x, y, weight] weight is inverse of distance.
+const vec3[24] samples = {
+ vec3(0.1693761725038636, 0.9855514761735895, 1),
+ vec3(-1.333070830962943, 0.4721463328627773, 0.7071067811865475),
+ vec3(-0.8464394909806497, -1.51113870578065, 0.5773502691896258),
+ vec3(1.554155680728463, -1.2588090085709776, 0.5),
+ vec3(1.681364377589461, 1.4741145918052656, 0.4472135954999579),
+ vec3(-1.2795157692199817, 2.088741103228784, 0.4082482904638631),
+ vec3(-2.4575847530631187, -0.9799373355024756, 0.3779644730092272),
+ vec3(0.5874641440200847, -2.7667464429345077, 0.35355339059327373),
+ vec3(2.997715703369726, 0.11704939884745152, 0.3333333333333333),
+ vec3(0.41360842451688395, 3.1351121305574803, 0.31622776601683794),
+ vec3(-3.167149933769243, 0.9844599011770256, 0.30151134457776363),
+ vec3(-1.5736713846521535, -3.0860263079123245, 0.2886751345948129),
+ vec3(2.888202648340422, -2.1583061557896213, 0.2773500981126146),
+ vec3(2.7150778983300325, 2.5745586041105715, 0.2672612419124244),
+ vec3(-2.1504069972377464, 3.2211410627650165, 0.2581988897471611),
+ vec3(-3.6548858794907493, -1.6253643308191343, 0.25),
+ vec3(1.0130775986052671, -3.9967078676335834, 0.24253562503633297),
+ vec3(4.229723673607257, 0.33081361055181563, 0.23570226039551587),
+ vec3(0.40107790291173834, 4.340407413572593, 0.22941573387056174),
+ vec3(-4.319124570236028, 1.159811599693438, 0.22360679774997896),
+ vec3(-1.9209044802827355, -4.160543952132907, 0.2182178902359924),
+ vec3(3.8639122286635708, -2.6589814382925123, 0.21320071635561041),
+ vec3(3.3486228404946234, 3.4331800232609, 0.20851441405707477),
+ vec3(-2.8769733643574344, 3.9652268864187157, 0.20412414523193154)
+ };
+
+float lum(vec4 c) {
+ return 0.299 * c.r + 0.587 * c.g + 0.114 * c.b;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ vec4 color = texture(iChannel0, uv);
+
+ vec2 step = vec2(1.414) / iResolution.xy;
+
+ for (int i = 0; i < 24; i++) {
+ vec3 s = samples[i];
+ vec4 c = texture(iChannel0, uv + s.xy * step);
+ float l = lum(c);
+ if (l > 0.2) {
+ color += l * s.z * c * 0.025;
+ }
+ }
+
+ fragColor = color;
+}
diff --git a/ghostty/shaders/bloom050.glsl b/ghostty/shaders/bloom050.glsl
new file mode 100644
index 0000000..4eb1e22
--- /dev/null
+++ b/ghostty/shaders/bloom050.glsl
@@ -0,0 +1,52 @@
+// source: https://gist.github.com/qwerasd205/c3da6c610c8ffe17d6d2d3cc7068f17f
+// credits: https://github.com/qwerasd205
+// Golden spiral samples, [x, y, weight] weight is inverse of distance.
+const vec3[24] samples = {
+ vec3(0.1693761725038636, 0.9855514761735895, 1),
+ vec3(-1.333070830962943, 0.4721463328627773, 0.7071067811865475),
+ vec3(-0.8464394909806497, -1.51113870578065, 0.5773502691896258),
+ vec3(1.554155680728463, -1.2588090085709776, 0.5),
+ vec3(1.681364377589461, 1.4741145918052656, 0.4472135954999579),
+ vec3(-1.2795157692199817, 2.088741103228784, 0.4082482904638631),
+ vec3(-2.4575847530631187, -0.9799373355024756, 0.3779644730092272),
+ vec3(0.5874641440200847, -2.7667464429345077, 0.35355339059327373),
+ vec3(2.997715703369726, 0.11704939884745152, 0.3333333333333333),
+ vec3(0.41360842451688395, 3.1351121305574803, 0.31622776601683794),
+ vec3(-3.167149933769243, 0.9844599011770256, 0.30151134457776363),
+ vec3(-1.5736713846521535, -3.0860263079123245, 0.2886751345948129),
+ vec3(2.888202648340422, -2.1583061557896213, 0.2773500981126146),
+ vec3(2.7150778983300325, 2.5745586041105715, 0.2672612419124244),
+ vec3(-2.1504069972377464, 3.2211410627650165, 0.2581988897471611),
+ vec3(-3.6548858794907493, -1.6253643308191343, 0.25),
+ vec3(1.0130775986052671, -3.9967078676335834, 0.24253562503633297),
+ vec3(4.229723673607257, 0.33081361055181563, 0.23570226039551587),
+ vec3(0.40107790291173834, 4.340407413572593, 0.22941573387056174),
+ vec3(-4.319124570236028, 1.159811599693438, 0.22360679774997896),
+ vec3(-1.9209044802827355, -4.160543952132907, 0.2182178902359924),
+ vec3(3.8639122286635708, -2.6589814382925123, 0.21320071635561041),
+ vec3(3.3486228404946234, 3.4331800232609, 0.20851441405707477),
+ vec3(-2.8769733643574344, 3.9652268864187157, 0.20412414523193154)
+ };
+
+float lum(vec4 c) {
+ return 0.299 * c.r + 0.587 * c.g + 0.114 * c.b;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ vec4 color = texture(iChannel0, uv);
+
+ vec2 step = vec2(1.414) / iResolution.xy;
+
+ for (int i = 0; i < 24; i++) {
+ vec3 s = samples[i];
+ vec4 c = texture(iChannel0, uv + s.xy * step);
+ float l = lum(c);
+ if (l > 0.2) {
+ color += l * s.z * c * 0.050;
+ }
+ }
+
+ fragColor = color;
+}
diff --git a/ghostty/shaders/bloom060.glsl b/ghostty/shaders/bloom060.glsl
new file mode 100644
index 0000000..c122fae
--- /dev/null
+++ b/ghostty/shaders/bloom060.glsl
@@ -0,0 +1,52 @@
+// source: https://gist.github.com/qwerasd205/c3da6c610c8ffe17d6d2d3cc7068f17f
+// credits: https://github.com/qwerasd205
+// Golden spiral samples, [x, y, weight] weight is inverse of distance.
+const vec3[24] samples = {
+ vec3(0.1693761725038636, 0.9855514761735895, 1),
+ vec3(-1.333070830962943, 0.4721463328627773, 0.7071067811865475),
+ vec3(-0.8464394909806497, -1.51113870578065, 0.5773502691896258),
+ vec3(1.554155680728463, -1.2588090085709776, 0.5),
+ vec3(1.681364377589461, 1.4741145918052656, 0.4472135954999579),
+ vec3(-1.2795157692199817, 2.088741103228784, 0.4082482904638631),
+ vec3(-2.4575847530631187, -0.9799373355024756, 0.3779644730092272),
+ vec3(0.5874641440200847, -2.7667464429345077, 0.35355339059327373),
+ vec3(2.997715703369726, 0.11704939884745152, 0.3333333333333333),
+ vec3(0.41360842451688395, 3.1351121305574803, 0.31622776601683794),
+ vec3(-3.167149933769243, 0.9844599011770256, 0.30151134457776363),
+ vec3(-1.5736713846521535, -3.0860263079123245, 0.2886751345948129),
+ vec3(2.888202648340422, -2.1583061557896213, 0.2773500981126146),
+ vec3(2.7150778983300325, 2.5745586041105715, 0.2672612419124244),
+ vec3(-2.1504069972377464, 3.2211410627650165, 0.2581988897471611),
+ vec3(-3.6548858794907493, -1.6253643308191343, 0.25),
+ vec3(1.0130775986052671, -3.9967078676335834, 0.24253562503633297),
+ vec3(4.229723673607257, 0.33081361055181563, 0.23570226039551587),
+ vec3(0.40107790291173834, 4.340407413572593, 0.22941573387056174),
+ vec3(-4.319124570236028, 1.159811599693438, 0.22360679774997896),
+ vec3(-1.9209044802827355, -4.160543952132907, 0.2182178902359924),
+ vec3(3.8639122286635708, -2.6589814382925123, 0.21320071635561041),
+ vec3(3.3486228404946234, 3.4331800232609, 0.20851441405707477),
+ vec3(-2.8769733643574344, 3.9652268864187157, 0.20412414523193154)
+ };
+
+float lum(vec4 c) {
+ return 0.299 * c.r + 0.587 * c.g + 0.114 * c.b;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ vec4 color = texture(iChannel0, uv);
+
+ vec2 step = vec2(1.414) / iResolution.xy;
+
+ for (int i = 0; i < 24; i++) {
+ vec3 s = samples[i];
+ vec4 c = texture(iChannel0, uv + s.xy * step);
+ float l = lum(c);
+ if (l > 0.2) {
+ color += l * s.z * c * 0.060;
+ }
+ }
+
+ fragColor = color;
+}
diff --git a/ghostty/shaders/bloom075.glsl b/ghostty/shaders/bloom075.glsl
new file mode 100644
index 0000000..ffb81cb
--- /dev/null
+++ b/ghostty/shaders/bloom075.glsl
@@ -0,0 +1,52 @@
+// source: https://gist.github.com/qwerasd205/c3da6c610c8ffe17d6d2d3cc7068f17f
+// credits: https://github.com/qwerasd205
+// Golden spiral samples, [x, y, weight] weight is inverse of distance.
+const vec3[24] samples = {
+ vec3(0.1693761725038636, 0.9855514761735895, 1),
+ vec3(-1.333070830962943, 0.4721463328627773, 0.7071067811865475),
+ vec3(-0.8464394909806497, -1.51113870578065, 0.5773502691896258),
+ vec3(1.554155680728463, -1.2588090085709776, 0.5),
+ vec3(1.681364377589461, 1.4741145918052656, 0.4472135954999579),
+ vec3(-1.2795157692199817, 2.088741103228784, 0.4082482904638631),
+ vec3(-2.4575847530631187, -0.9799373355024756, 0.3779644730092272),
+ vec3(0.5874641440200847, -2.7667464429345077, 0.35355339059327373),
+ vec3(2.997715703369726, 0.11704939884745152, 0.3333333333333333),
+ vec3(0.41360842451688395, 3.1351121305574803, 0.31622776601683794),
+ vec3(-3.167149933769243, 0.9844599011770256, 0.30151134457776363),
+ vec3(-1.5736713846521535, -3.0860263079123245, 0.2886751345948129),
+ vec3(2.888202648340422, -2.1583061557896213, 0.2773500981126146),
+ vec3(2.7150778983300325, 2.5745586041105715, 0.2672612419124244),
+ vec3(-2.1504069972377464, 3.2211410627650165, 0.2581988897471611),
+ vec3(-3.6548858794907493, -1.6253643308191343, 0.25),
+ vec3(1.0130775986052671, -3.9967078676335834, 0.24253562503633297),
+ vec3(4.229723673607257, 0.33081361055181563, 0.23570226039551587),
+ vec3(0.40107790291173834, 4.340407413572593, 0.22941573387056174),
+ vec3(-4.319124570236028, 1.159811599693438, 0.22360679774997896),
+ vec3(-1.9209044802827355, -4.160543952132907, 0.2182178902359924),
+ vec3(3.8639122286635708, -2.6589814382925123, 0.21320071635561041),
+ vec3(3.3486228404946234, 3.4331800232609, 0.20851441405707477),
+ vec3(-2.8769733643574344, 3.9652268864187157, 0.20412414523193154)
+ };
+
+float lum(vec4 c) {
+ return 0.299 * c.r + 0.587 * c.g + 0.114 * c.b;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ vec4 color = texture(iChannel0, uv);
+
+ vec2 step = vec2(1.414) / iResolution.xy;
+
+ for (int i = 0; i < 24; i++) {
+ vec3 s = samples[i];
+ vec4 c = texture(iChannel0, uv + s.xy * step);
+ float l = lum(c);
+ if (l > 0.2) {
+ color += l * s.z * c * 0.075;
+ }
+ }
+
+ fragColor = color;
+}
diff --git a/ghostty/shaders/bloom1.glsl b/ghostty/shaders/bloom1.glsl
new file mode 100644
index 0000000..86ec7b8
--- /dev/null
+++ b/ghostty/shaders/bloom1.glsl
@@ -0,0 +1,52 @@
+// source: https://gist.github.com/qwerasd205/c3da6c610c8ffe17d6d2d3cc7068f17f
+// credits: https://github.com/qwerasd205
+// Golden spiral samples, [x, y, weight] weight is inverse of distance.
+const vec3[24] samples = {
+ vec3(0.1693761725038636, 0.9855514761735895, 1),
+ vec3(-1.333070830962943, 0.4721463328627773, 0.7071067811865475),
+ vec3(-0.8464394909806497, -1.51113870578065, 0.5773502691896258),
+ vec3(1.554155680728463, -1.2588090085709776, 0.5),
+ vec3(1.681364377589461, 1.4741145918052656, 0.4472135954999579),
+ vec3(-1.2795157692199817, 2.088741103228784, 0.4082482904638631),
+ vec3(-2.4575847530631187, -0.9799373355024756, 0.3779644730092272),
+ vec3(0.5874641440200847, -2.7667464429345077, 0.35355339059327373),
+ vec3(2.997715703369726, 0.11704939884745152, 0.3333333333333333),
+ vec3(0.41360842451688395, 3.1351121305574803, 0.31622776601683794),
+ vec3(-3.167149933769243, 0.9844599011770256, 0.30151134457776363),
+ vec3(-1.5736713846521535, -3.0860263079123245, 0.2886751345948129),
+ vec3(2.888202648340422, -2.1583061557896213, 0.2773500981126146),
+ vec3(2.7150778983300325, 2.5745586041105715, 0.2672612419124244),
+ vec3(-2.1504069972377464, 3.2211410627650165, 0.2581988897471611),
+ vec3(-3.6548858794907493, -1.6253643308191343, 0.25),
+ vec3(1.0130775986052671, -3.9967078676335834, 0.24253562503633297),
+ vec3(4.229723673607257, 0.33081361055181563, 0.23570226039551587),
+ vec3(0.40107790291173834, 4.340407413572593, 0.22941573387056174),
+ vec3(-4.319124570236028, 1.159811599693438, 0.22360679774997896),
+ vec3(-1.9209044802827355, -4.160543952132907, 0.2182178902359924),
+ vec3(3.8639122286635708, -2.6589814382925123, 0.21320071635561041),
+ vec3(3.3486228404946234, 3.4331800232609, 0.20851441405707477),
+ vec3(-2.8769733643574344, 3.9652268864187157, 0.20412414523193154)
+ };
+
+float lum(vec4 c) {
+ return 0.299 * c.r + 0.587 * c.g + 0.114 * c.b;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ vec4 color = texture(iChannel0, uv);
+
+ vec2 step = vec2(1.414) / iResolution.xy;
+
+ for (int i = 0; i < 24; i++) {
+ vec3 s = samples[i];
+ vec4 c = texture(iChannel0, uv + s.xy * step);
+ float l = lum(c);
+ if (l > 0.2) {
+ color += l * s.z * c * 0.1;
+ }
+ }
+
+ fragColor = color;
+}
diff --git a/ghostty/shaders/crt.glsl b/ghostty/shaders/crt.glsl
new file mode 100644
index 0000000..31d1bec
--- /dev/null
+++ b/ghostty/shaders/crt.glsl
@@ -0,0 +1,310 @@
+// source: https://gist.github.com/qwerasd205/c3da6c610c8ffe17d6d2d3cc7068f17f
+// credits: https://github.com/qwerasd205
+//==============================================================
+//
+// [CRTS] PUBLIC DOMAIN CRT-STYLED SCALAR by Timothy Lottes
+//
+// [+] Adapted with alterations for use in Ghostty by Qwerasd.
+// For more information on changes, see comment below license.
+//
+//==============================================================
+//
+// LICENSE = UNLICENSE (aka PUBLIC DOMAIN)
+//
+//--------------------------------------------------------------
+// This is free and unencumbered software released into the
+// public domain.
+//--------------------------------------------------------------
+// Anyone is free to copy, modify, publish, use, compile, sell,
+// or distribute this software, either in source code form or as
+// a compiled binary, for any purpose, commercial or
+// non-commercial, and by any means.
+//--------------------------------------------------------------
+// In jurisdictions that recognize copyright laws, the author or
+// authors of this software dedicate any and all copyright
+// interest in the software to the public domain. We make this
+// dedication for the benefit of the public at large and to the
+// detriment of our heirs and successors. We intend this
+// dedication to be an overt act of relinquishment in perpetuity
+// of all present and future rights to this software under
+// copyright law.
+//--------------------------------------------------------------
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+// KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+// AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+// OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//--------------------------------------------------------------
+// For more information, please refer to
+//
+//==============================================================
+
+// This shader is a modified version of the excellent
+// FixingPixelArtFast by Timothy Lottes on Shadertoy.
+//
+// The original shader can be found at:
+// https://www.shadertoy.com/view/MtSfRK
+//
+// Modifications have been made to reduce the verbosity,
+// and many of the comments have been removed / reworded.
+// Additionally, the license has been moved to the top of
+// the file, and can be read above. I (Qwerasd) choose to
+// release the modified version under the same license.
+
+// The appearance of this shader can be altered
+// by adjusting the parameters defined below.
+
+// "Scanlines" per real screen pixel.
+// e.g. SCALE 0.5 means each scanline is 2 pixels.
+// Recommended values:
+// o High DPI displays: 0.33333333
+// - Low DPI displays: 0.66666666
+#define SCALE 0.33333333
+
+// "Tube" warp
+#define CRTS_WARP 1
+
+// Darkness of vignette in corners after warping
+// 0.0 = completely black
+// 1.0 = no vignetting
+#define MIN_VIN 0.5
+
+// Try different masks
+// #define CRTS_MASK_GRILLE 1
+// #define CRTS_MASK_GRILLE_LITE 1
+// #define CRTS_MASK_NONE 1
+#define CRTS_MASK_SHADOW 1
+
+// Scanline thinness
+// 0.50 = fused scanlines
+// 0.70 = recommended default
+// 1.00 = thinner scanlines (too thin)
+#define INPUT_THIN 0.75
+
+// Horizonal scan blur
+// -3.0 = pixely
+// -2.5 = default
+// -2.0 = smooth
+// -1.0 = too blurry
+#define INPUT_BLUR -2.75
+
+// Shadow mask effect, ranges from,
+// 0.25 = large amount of mask (not recommended, too dark)
+// 0.50 = recommended default
+// 1.00 = no shadow mask
+#define INPUT_MASK 0.65
+
+float FromSrgb1(float c) {
+ return (c <= 0.04045) ? c * (1.0 / 12.92) :
+ pow(c * (1.0 / 1.055) + (0.055 / 1.055), 2.4);
+}
+vec3 FromSrgb(vec3 c) {
+ return vec3(
+ FromSrgb1(c.r), FromSrgb1(c.g), FromSrgb1(c.b));
+}
+
+vec3 CrtsFetch(vec2 uv) {
+ return FromSrgb(texture(iChannel0, uv.xy).rgb);
+}
+
+#define CrtsRcpF1(x) (1.0/(x))
+#define CrtsSatF1(x) clamp((x),0.0,1.0)
+
+float CrtsMax3F1(float a, float b, float c) {
+ return max(a, max(b, c));
+}
+
+vec2 CrtsTone(
+ float thin,
+ float mask) {
+ #ifdef CRTS_MASK_NONE
+ mask = 1.0;
+ #endif
+
+ #ifdef CRTS_MASK_GRILLE_LITE
+ // Normal R mask is {1.0,mask,mask}
+ // LITE R mask is {mask,1.0,1.0}
+ mask = 0.5 + mask * 0.5;
+ #endif
+
+ vec2 ret;
+ float midOut = 0.18 / ((1.5 - thin) * (0.5 * mask + 0.5));
+ float pMidIn = 0.18;
+ ret.x = ((-pMidIn) + midOut) / ((1.0 - pMidIn) * midOut);
+ ret.y = ((-pMidIn) * midOut + pMidIn) / (midOut * (-pMidIn) + midOut);
+
+ return ret;
+}
+
+vec3 CrtsMask(vec2 pos, float dark) {
+ #ifdef CRTS_MASK_GRILLE
+ vec3 m = vec3(dark, dark, dark);
+ float x = fract(pos.x * (1.0 / 3.0));
+ if (x < (1.0 / 3.0)) m.r = 1.0;
+ else if (x < (2.0 / 3.0)) m.g = 1.0;
+ else m.b = 1.0;
+ return m;
+ #endif
+
+ #ifdef CRTS_MASK_GRILLE_LITE
+ vec3 m = vec3(1.0, 1.0, 1.0);
+ float x = fract(pos.x * (1.0 / 3.0));
+ if (x < (1.0 / 3.0)) m.r = dark;
+ else if (x < (2.0 / 3.0)) m.g = dark;
+ else m.b = dark;
+ return m;
+ #endif
+
+ #ifdef CRTS_MASK_NONE
+ return vec3(1.0, 1.0, 1.0);
+ #endif
+
+ #ifdef CRTS_MASK_SHADOW
+ pos.x += pos.y * 3.0;
+ vec3 m = vec3(dark, dark, dark);
+ float x = fract(pos.x * (1.0 / 6.0));
+ if (x < (1.0 / 3.0)) m.r = 1.0;
+ else if (x < (2.0 / 3.0)) m.g = 1.0;
+ else m.b = 1.0;
+ return m;
+ #endif
+}
+
+vec3 CrtsFilter(
+ vec2 ipos,
+ vec2 inputSizeDivOutputSize,
+ vec2 halfInputSize,
+ vec2 rcpInputSize,
+ vec2 rcpOutputSize,
+ vec2 twoDivOutputSize,
+ float inputHeight,
+ vec2 warp,
+ float thin,
+ float blur,
+ float mask,
+ vec2 tone
+) {
+ // Optional apply warp
+ vec2 pos;
+ #ifdef CRTS_WARP
+ // Convert to {-1 to 1} range
+ pos = ipos * twoDivOutputSize - vec2(1.0, 1.0);
+
+ // Distort pushes image outside {-1 to 1} range
+ pos *= vec2(
+ 1.0 + (pos.y * pos.y) * warp.x,
+ 1.0 + (pos.x * pos.x) * warp.y);
+
+ // TODO: Vignette needs optimization
+ float vin = 1.0 - (
+ (1.0 - CrtsSatF1(pos.x * pos.x)) * (1.0 - CrtsSatF1(pos.y * pos.y)));
+ vin = CrtsSatF1((-vin) * inputHeight + inputHeight);
+
+ // Leave in {0 to inputSize}
+ pos = pos * halfInputSize + halfInputSize;
+ #else
+ pos = ipos * inputSizeDivOutputSize;
+ #endif
+
+ // Snap to center of first scanline
+ float y0 = floor(pos.y - 0.5) + 0.5;
+ // Snap to center of one of four pixels
+ float x0 = floor(pos.x - 1.5) + 0.5;
+
+ // Inital UV position
+ vec2 p = vec2(x0 * rcpInputSize.x, y0 * rcpInputSize.y);
+ // Fetch 4 nearest texels from 2 nearest scanlines
+ vec3 colA0 = CrtsFetch(p);
+ p.x += rcpInputSize.x;
+ vec3 colA1 = CrtsFetch(p);
+ p.x += rcpInputSize.x;
+ vec3 colA2 = CrtsFetch(p);
+ p.x += rcpInputSize.x;
+ vec3 colA3 = CrtsFetch(p);
+ p.y += rcpInputSize.y;
+ vec3 colB3 = CrtsFetch(p);
+ p.x -= rcpInputSize.x;
+ vec3 colB2 = CrtsFetch(p);
+ p.x -= rcpInputSize.x;
+ vec3 colB1 = CrtsFetch(p);
+ p.x -= rcpInputSize.x;
+ vec3 colB0 = CrtsFetch(p);
+
+ // Vertical filter
+ // Scanline intensity is using sine wave
+ // Easy filter window and integral used later in exposure
+ float off = pos.y - y0;
+ float pi2 = 6.28318530717958;
+ float hlf = 0.5;
+ float scanA = cos(min(0.5, off * thin) * pi2) * hlf + hlf;
+ float scanB = cos(min(0.5, (-off) * thin + thin) * pi2) * hlf + hlf;
+
+ // Horizontal kernel is simple gaussian filter
+ float off0 = pos.x - x0;
+ float off1 = off0 - 1.0;
+ float off2 = off0 - 2.0;
+ float off3 = off0 - 3.0;
+ float pix0 = exp2(blur * off0 * off0);
+ float pix1 = exp2(blur * off1 * off1);
+ float pix2 = exp2(blur * off2 * off2);
+ float pix3 = exp2(blur * off3 * off3);
+ float pixT = CrtsRcpF1(pix0 + pix1 + pix2 + pix3);
+
+ #ifdef CRTS_WARP
+ // Get rid of wrong pixels on edge
+ pixT *= max(MIN_VIN, vin);
+ #endif
+
+ scanA *= pixT;
+ scanB *= pixT;
+
+ // Apply horizontal and vertical filters
+ vec3 color =
+ (colA0 * pix0 + colA1 * pix1 + colA2 * pix2 + colA3 * pix3) * scanA +
+ (colB0 * pix0 + colB1 * pix1 + colB2 * pix2 + colB3 * pix3) * scanB;
+
+ // Apply phosphor mask
+ color *= CrtsMask(ipos, mask);
+
+ // Tonal control, start by protecting from /0
+ float peak = max(1.0 / (256.0 * 65536.0),
+ CrtsMax3F1(color.r, color.g, color.b));
+ // Compute the ratios of {R,G,B}
+ vec3 ratio = color * CrtsRcpF1(peak);
+ // Apply tonal curve to peak value
+ peak = peak * CrtsRcpF1(peak * tone.x + tone.y);
+ // Reconstruct color
+ return ratio * peak;
+}
+
+float ToSrgb1(float c) {
+ return (c < 0.0031308 ? c * 12.92 : 1.055 * pow(c, 0.41666) - 0.055);
+}
+vec3 ToSrgb(vec3 c) {
+ return vec3(
+ ToSrgb1(c.r), ToSrgb1(c.g), ToSrgb1(c.b));
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+ float aspect = iResolution.x / iResolution.y;
+ fragColor.rgb = CrtsFilter(
+ fragCoord.xy,
+ vec2(1.0),
+ iResolution.xy * SCALE * 0.5,
+ 1.0 / (iResolution.xy * SCALE),
+ 1.0 / iResolution.xy,
+ 2.0 / iResolution.xy,
+ iResolution.y,
+ vec2(1.0 / (50.0 * aspect), 1.0 / 50.0),
+ INPUT_THIN,
+ INPUT_BLUR,
+ INPUT_MASK,
+ CrtsTone(INPUT_THIN, INPUT_MASK)
+ );
+
+ // Linear to SRGB for output.
+ fragColor.rgb = ToSrgb(fragColor.rgb);
+}
\ No newline at end of file
diff --git a/ghostty/shaders/cubes.glsl b/ghostty/shaders/cubes.glsl
new file mode 100644
index 0000000..2a09505
--- /dev/null
+++ b/ghostty/shaders/cubes.glsl
@@ -0,0 +1,114 @@
+// credits: https://github.com/rymdlego
+
+const float speed = 0.2;
+const float cube_size = 1.0;
+const float cube_brightness = 1.0;
+const float cube_rotation_speed = 2.8;
+const float camera_rotation_speed = 0.1;
+
+
+
+mat3 rotationMatrix(vec3 m,float a) {
+ m = normalize(m);
+ float c = cos(a),s=sin(a);
+ return mat3(c+(1.-c)*m.x*m.x,
+ (1.-c)*m.x*m.y-s*m.z,
+ (1.-c)*m.x*m.z+s*m.y,
+ (1.-c)*m.x*m.y+s*m.z,
+ c+(1.-c)*m.y*m.y,
+ (1.-c)*m.y*m.z-s*m.x,
+ (1.-c)*m.x*m.z-s*m.y,
+ (1.-c)*m.y*m.z+s*m.x,
+ c+(1.-c)*m.z*m.z);
+}
+
+float sphere(vec3 pos, float radius)
+{
+ return length(pos) - radius;
+}
+
+float box(vec3 pos, vec3 size)
+{
+ float t = iTime;
+ pos = pos * 0.9 * rotationMatrix(vec3(sin(t/4.0*speed)*10.,cos(t/4.0*speed)*12.,2.7), t*2.4/4.0*speed*cube_rotation_speed);
+ return length(max(abs(pos) - size, 0.0));
+}
+
+
+float distfunc(vec3 pos)
+{
+ float t = iTime;
+
+ float size = 0.45 + 0.25*abs(16.0*sin(t*speed/4.0));
+ // float size = 2.3 + 1.8*tan((t-5.4)*6.549);
+ size = cube_size * 0.16 * clamp(size, 2.0, 4.0);
+
+ //pos = pos * rotationMatrix(vec3(0.,-3.,0.7), 3.3 * mod(t/30.0, 4.0));
+ vec3 q = mod(pos, 5.0) - 2.5;
+ float obj1 = box(q, vec3(size));
+ return obj1;
+}
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+ float t = iTime;
+ vec2 screenPos = -1.0 + 2.0 * fragCoord.xy / iResolution.xy;
+ screenPos.x *= iResolution.x / iResolution.y;
+ vec3 cameraOrigin = vec3(t*1.0*speed, 0.0, 0.0);
+ // vec3 cameraOrigin = vec3(t*1.8*speed, 3.0+t*0.02*speed, 0.0);
+ vec3 cameraTarget = vec3(t*100., 0.0, 0.0);
+ cameraTarget = vec3(t*20.0,0.0,0.0) * rotationMatrix(vec3(0.0,0.0,1.0), t*speed*camera_rotation_speed);
+
+ vec3 upDirection = vec3(0.5, 1.0, 0.6);
+
+ vec3 cameraDir = normalize(cameraTarget - cameraOrigin);
+ vec3 cameraRight = normalize(cross(upDirection, cameraOrigin));
+ vec3 cameraUp = cross(cameraDir, cameraRight);
+
+ vec3 rayDir = normalize(cameraRight * screenPos.x + cameraUp * screenPos.y + cameraDir);
+
+ const int MAX_ITER = 64;
+ const float MAX_DIST = 48.0;
+ const float EPSILON = 0.001;
+
+ float totalDist = 0.0;
+ vec3 pos = cameraOrigin;
+ float dist = EPSILON;
+
+ for (int i = 0; i < MAX_ITER; i++)
+ {
+ if (dist < EPSILON || totalDist > MAX_DIST)
+ break;
+ dist = distfunc(pos);
+ totalDist += dist;
+ pos += dist*rayDir;
+ }
+
+ vec4 cubes;
+
+ if (dist < EPSILON)
+ {
+ // Lighting Code
+ vec2 eps = vec2(0.0, EPSILON);
+ vec3 normal = normalize(vec3(
+ distfunc(pos + eps.yxx) - distfunc(pos - eps.yxx),
+ distfunc(pos + eps.xyx) - distfunc(pos - eps.xyx),
+ distfunc(pos + eps.xxy) - distfunc(pos - eps.xxy)));
+ float diffuse = max(0., dot(-rayDir, normal));
+ float specular = pow(diffuse, 32.0);
+ vec3 color = vec3(diffuse + specular);
+ vec3 cubeColor = vec3(abs(screenPos),0.5+0.5*sin(t*2.0))*0.8;
+ cubeColor = mix(cubeColor.rgb, vec3(0.0,0.0,0.0), 1.0);
+ color += cubeColor;
+ cubes = vec4(color, 1.0) * vec4(1.0 - (totalDist/MAX_DIST));
+ cubes = vec4(cubes.rgb*0.02*cube_brightness, 0.1);
+ }
+ else {
+ cubes = vec4(0.0);
+ }
+
+ vec2 uv = fragCoord/iResolution.xy;
+ vec4 terminalColor = texture(iChannel0, uv);
+ vec3 blendedColor = terminalColor.rgb + cubes.rgb;
+ fragColor = vec4(blendedColor, terminalColor.a);
+}
diff --git a/ghostty/shaders/cursor_blaze.glsl b/ghostty/shaders/cursor_blaze.glsl
new file mode 100644
index 0000000..9cbb57f
--- /dev/null
+++ b/ghostty/shaders/cursor_blaze.glsl
@@ -0,0 +1,117 @@
+float getSdfRectangle(in vec2 p, in vec2 xy, in vec2 b)
+{
+ vec2 d = abs(p - xy) - b;
+ return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}
+// 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);
+}
+
+vec2 normalize(vec2 value, float isPosition) {
+ return (value * 2.0 - (iResolution.xy * isPosition)) / iResolution.y;
+}
+
+float blend(float t)
+{
+ float sqr = t * t;
+ return sqr / (2.0 * (sqr - t) + 1.0);
+}
+
+float antialising(float distance) {
+ return 1. - smoothstep(0., normalize(vec2(2., 2.), 0.).x, distance);
+}
+
+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.));
+}
+
+const vec4 TRAIL_COLOR = vec4(1.0, 0.725, 0.161, 1.0);
+const vec4 TRAIL_COLOR_ACCENT = vec4(1.0, 0., 0., 1.0);
+// const vec4 TRAIL_COLOR = vec4(0.482, 0.886, 1.0, 1.0);
+// const vec4 TRAIL_COLOR_ACCENT = vec4(0.0, 0.424, 1.0, 1.0);
+const vec4 CURRENT_CURSOR_COLOR = TRAIL_COLOR;
+const vec4 PREVIOUS_CURSOR_COLOR = TRAIL_COLOR;
+const float DURATION = 0.3;
+
+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.0));
+
+ //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 * (1.0 - progress));
+
+ 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, 1.0 - smoothstep(sdfTrail, -0.01, 0.001));
+ newColor = mix(newColor, TRAIL_COLOR, antialising(sdfTrail));
+ newColor = mix(fragColor, newColor, 1.0 - alphaModifier);
+ newColor = mix(newColor, TRAIL_COLOR_ACCENT, 1.0 - smoothstep(sdfCursor, -0.000, 0.003 * (1. - progress)));
+ newColor = mix(newColor, CURRENT_CURSOR_COLOR, 1.0 - smoothstep(sdfCursor, -0.000, 0.003 * (1. - progress)));
+ fragColor = mix(newColor, fragColor, step(sdfCursor, 0.));
+}
diff --git a/ghostty/shaders/cursor_blaze_no_trail.glsl b/ghostty/shaders/cursor_blaze_no_trail.glsl
new file mode 100644
index 0000000..87c4e18
--- /dev/null
+++ b/ghostty/shaders/cursor_blaze_no_trail.glsl
@@ -0,0 +1,162 @@
+
+float sdBox(in vec2 p, in vec2 xy, in vec2 b)
+{
+ vec2 d = abs(p - xy) - b;
+ return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}
+
+// //Author: https://iquilezles.org/articles/distfunctions2d/
+float sdTrail(in vec2 p, in vec2 v0, in vec2 v1, in vec2 v2, in vec2 v3)
+{
+ float d = dot(p - v0, p - v0);
+ float s = 1.0;
+
+ // Edge from v3 to v0
+ {
+ vec2 e = v3 - v0;
+ vec2 w = p - v0;
+ vec2 b = w - e * clamp(dot(w, e) / dot(e, e), 0.0, 1.0);
+ d = min(d, dot(b, b));
+
+ // Compute branchless boolean conditions:
+ float c0 = step(0.0, p.y - v0.y); // 1 if (p.y >= v0.y)
+ float c1 = 1.0 - step(0.0, p.y - v3.y); // 1 if (p.y < v3.y)
+ float c2 = 1.0 - step(0.0, e.x * w.y - e.y * w.x); // 1 if (e.x*w.y > e.y*w.x)
+ float allCond = c0 * c1 * c2;
+ float noneCond = (1.0 - c0) * (1.0 - c1) * (1.0 - c2);
+ // If either allCond or noneCond is 1, then flip factor becomes -1.
+ float flip = mix(1.0, -1.0, step(0.5, allCond + noneCond));
+ s *= flip;
+ }
+
+ // Edge from v0 to v1
+ {
+ vec2 e = v0 - v1;
+ vec2 w = p - v1;
+ vec2 b = w - e * clamp(dot(w, e) / dot(e, e), 0.0, 1.0);
+ d = min(d, dot(b, b));
+
+ float c0 = step(0.0, p.y - v1.y);
+ float c1 = 1.0 - step(0.0, p.y - v0.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;
+ }
+
+ // Edge from v1 to v2
+ {
+ vec2 e = v1 - v2;
+ vec2 w = p - v2;
+ vec2 b = w - e * clamp(dot(w, e) / dot(e, e), 0.0, 1.0);
+ d = min(d, dot(b, b));
+
+ float c0 = step(0.0, p.y - v2.y);
+ float c1 = 1.0 - step(0.0, p.y - v1.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;
+ }
+
+ // Edge from v2 to v3
+ {
+ vec2 e = v2 - v3;
+ vec2 w = p - v3;
+ vec2 b = w - e * clamp(dot(w, e) / dot(e, e), 0.0, 1.0);
+ d = min(d, dot(b, b));
+
+ float c0 = step(0.0, p.y - v3.y);
+ float c1 = 1.0 - step(0.0, p.y - v2.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 s * sqrt(d);
+}
+
+vec2 normalize(vec2 value, float isPosition) {
+ return (value * 2.0 - (iResolution.xy * isPosition)) / iResolution.y;
+}
+
+float ParametricBlend(float t)
+{
+ float sqr = t * t;
+ return sqr / (2.0 * (sqr - t) + 1.0);
+}
+
+float antialising(float distance) {
+ return 1. - smoothstep(0., normalize(vec2(2., 2.), 0.).x, distance);
+}
+
+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);
+}
+
+const vec4 TRAIL_COLOR = vec4(0.651, 0.545, 0.980, 1.0);
+const vec4 TRAIL_COLOR_ACCENT = vec4(0.957, 0.447, 0.714, 1.0);
+// const vec4 TRAIL_COLOR = vec4(0.482, 0.886, 1.0, 1.0);
+// const vec4 TRAIL_COLOR_ACCENT = vec4(0.0, 0.424, 1.0, 1.0);
+const vec4 CURRENT_CURSOR_COLOR = TRAIL_COLOR;
+const vec4 PREVIOUS_CURSOR_COLOR = TRAIL_COLOR;
+const float DURATION = 0.3;
+
+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 = ParametricBlend(clamp((iTime - iTimeCursorChange) / DURATION, 0.0, 1.0));
+
+ //Distance between cursors determine the total length of the parallelogram;
+ float lineLength = distance(currentCursor.xy, previousCursor.xy);
+ float distanceToEnd = distance(vu.xy, vec2(currentCursor.x + (currentCursor.z / 2.), currentCursor.y - (currentCursor.w / 2.)));
+ float alphaModifier = distanceToEnd / (lineLength * (1.0 - progress));
+
+ // float d2 = sdTrail(vu, v0, v1, v2, v3);
+ // newColor = mix(newColor, TRAIL_COLOR_ACCENT, 1.0 - smoothstep(d2, -0.01, 0.001));
+ // newColor = mix(newColor, TRAIL_COLOR, 1.0 - smoothstep(d2, -0.01, 0.001));
+ // newColor = mix(newColor, TRAIL_COLOR, antialising(d2));
+
+ float cCursorDistance = sdBox(vu, currentCursor.xy - (currentCursor.zw * offsetFactor), currentCursor.zw * 0.5);
+ newColor = mix(newColor, TRAIL_COLOR_ACCENT, 1.0 - smoothstep(cCursorDistance, -0.000, 0.003 * (1. - progress)));
+ newColor = mix(newColor, CURRENT_CURSOR_COLOR, 1.0 - smoothstep(cCursorDistance, -0.000, 0.003 * (1. - progress)));
+
+ // float pCursorDistance = sdBox(vu, previousCursor.xy - (previousCursor.zw * offsetFactor), previousCursor.zw * 0.5);
+ // newColor = mix(newColor, PREVIOUS_CURSOR_COLOR, antialising(pCursorDistance));
+
+ fragColor = mix(fragColor, newColor, 1.);
+ // fragColor = mix(fragColor, newColor, 1.0 - alphaModifier);
+}
diff --git a/ghostty/shaders/cursor_smear.glsl b/ghostty/shaders/cursor_smear.glsl
new file mode 100644
index 0000000..63119de
--- /dev/null
+++ b/ghostty/shaders/cursor_smear.glsl
@@ -0,0 +1,117 @@
+float getSdfRectangle(in vec2 p, in vec2 xy, in vec2 b)
+{
+ vec2 d = abs(p - xy) - b;
+ return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}
+
+// 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);
+}
+
+vec2 normalize(vec2 value, float isPosition) {
+ return (value * 2.0 - (iResolution.xy * isPosition)) / iResolution.y;
+}
+
+float antialising(float distance) {
+ return 1. - smoothstep(0., normalize(vec2(2., 2.), 0.).x, distance);
+}
+
+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.));
+}
+float ease(float x) {
+ return pow(1.0 - x, 3.0);
+}
+
+// Use this site to convert from HEX to vec4
+// https://enchanted.games/app/colour-converter/
+// const vec4 TRAIL_COLOR = vec4(1., 1., 0., 1.0); // yellow
+const vec4 TRAIL_COLOR = vec4(0.9s76, 0.302, 1.0, 1.0); // cursor
+// const vec4 TRAIL_COLOR = vec4(0.914, 0.702, 0.992, 1.0); // light cursor
+// const vec4 TRAIL_COLOR = vec4(0.016, 0.82, 0.976, 1.0); // cyan
+// const vec4 TRAIL_COLOR = vec4(0.216, 0.957, 0.6, 1.0); // green
+const float OPACITY = 0.6;
+const float DURATION = 0.10; //IN SECONDS
+
+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);
+
+ float sdfCurrentCursor = getSdfRectangle(vu, currentCursor.xy - (currentCursor.zw * offsetFactor), currentCursor.zw * 0.5);
+ float sdfTrail = getSdfParallelogram(vu, v0, v1, v2, v3);
+
+ float progress = clamp((iTime - iTimeCursorChange) / DURATION, 0.0, 1.0);
+ 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);
+
+ vec4 newColor = vec4(fragColor);
+ // Draw trail
+ newColor = mix(newColor, TRAIL_COLOR, antialising(sdfTrail));
+ // Draw current cursor
+ newColor = mix(newColor, TRAIL_COLOR, antialising(sdfCurrentCursor));
+ newColor = mix(newColor, fragColor, step(sdfCurrentCursor, 0.));
+ // newColor = mix(fragColor, newColor, OPACITY);
+ fragColor = mix(fragColor, newColor, step(sdfCurrentCursor, easedProgress * lineLength));
+}
diff --git a/ghostty/shaders/cursor_smear_fade.glsl b/ghostty/shaders/cursor_smear_fade.glsl
new file mode 100644
index 0000000..fa8be9d
--- /dev/null
+++ b/ghostty/shaders/cursor_smear_fade.glsl
@@ -0,0 +1,114 @@
+float getSdfRectangle(in vec2 p, in vec2 xy, in vec2 b)
+{
+ vec2 d = abs(p - xy) - b;
+ return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}
+
+// 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);
+}
+
+vec2 normalize(vec2 value, float isPosition) {
+ return (value * 2.0 - (iResolution.xy * isPosition)) / iResolution.y;
+}
+
+float antialising(float distance) {
+ return 1. - smoothstep(0., normalize(vec2(2., 2.), 0.).x, distance);
+}
+
+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.));
+}
+float ease(float x) {
+ return pow(1.0 - x, 3.0);
+}
+
+const vec4 TRAIL_COLOR = vec4(1., 1., 0., 1.0);
+const float DURATION = 0.5; //IN SECONDS
+
+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);
+
+ float sdfCurrentCursor = getSdfRectangle(vu, currentCursor.xy - (currentCursor.zw * offsetFactor), currentCursor.zw * 0.5);
+ float sdfTrail = getSdfParallelogram(vu, v0, v1, v2, v3);
+
+ float progress = clamp((iTime - iTimeCursorChange) / DURATION, 0.0, 1.0);
+ 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);
+
+ vec4 newColor = vec4(fragColor);
+ // Compute fade factor based on distance along the trail
+ float fadeFactor = 1.0 - smoothstep(lineLength, sdfCurrentCursor, easedProgress * lineLength);
+
+ // Apply fading effect to trail color
+ vec4 fadedTrailColor = TRAIL_COLOR * fadeFactor;
+
+ // Blend trail with fade effect
+ newColor = mix(newColor, fadedTrailColor, antialising(sdfTrail));
+ // Draw current cursor
+ newColor = mix(newColor, TRAIL_COLOR, antialising(sdfCurrentCursor));
+ newColor = mix(newColor, fragColor, step(sdfCurrentCursor, 0.));
+ fragColor = mix(fragColor, newColor, step(sdfCurrentCursor, easedProgress * lineLength));
+}
diff --git a/ghostty/shaders/cursor_warp.glsl b/ghostty/shaders/cursor_warp.glsl
new file mode 100644
index 0000000..82afade
--- /dev/null
+++ b/ghostty/shaders/cursor_warp.glsl
@@ -0,0 +1,303 @@
+// --- CONFIGURATION ---
+vec4 TRAIL_COLOR = vec4(0.957, 0.447, 0.714, 1.0); // can change to eg: vec4(0.2, 0.6, 1.0, 0.5);
+const float DURATION = 0.2; // total animation time
+const float TRAIL_SIZE = 0.8; // 0.0 = all corners move together. 1.0 = max smear (leading corners jump instantly)
+const float THRESHOLD_MIN_DISTANCE = 1.5; // min distance to show trail (units of cursor height)
+const float BLUR = 1.0; // blur size in pixels (for antialiasing)
+const float TRAIL_THICKNESS = 1.0; // 1.0 = full cursor height, 0.0 = zero height, >1.0 = funky aah
+const float TRAIL_THICKNESS_X = 0.9;
+
+const float FADE_ENABLED = 0.0; // 1.0 to enable fade gradient along the trail, 0.0 to disable
+const float FADE_EXPONENT = 5.0; // exponent for fade gradient along the trail
+
+// --- CONSTANTS for easing functions ---
+const float PI = 3.14159265359;
+const float C1_BACK = 1.70158;
+const float C2_BACK = C1_BACK * 1.525;
+const float C3_BACK = C1_BACK + 1.0;
+const float C4_ELASTIC = (2.0 * PI) / 3.0;
+const float C5_ELASTIC = (2.0 * PI) / 4.5;
+const float SPRING_STIFFNESS = 9.0;
+const float SPRING_DAMPING = 0.9;
+
+// --- EASING FUNCTIONS ---
+
+// // Linear
+// float ease(float x) {
+// return x;
+// }
+
+// // EaseOutQuad
+// float ease(float x) {
+// return 1.0 - (1.0 - x) * (1.0 - x);
+// }
+
+// // EaseOutCubic
+// float ease(float x) {
+// return 1.0 - pow(1.0 - x, 3.0);
+// }
+
+// // EaseOutQuart
+// float ease(float x) {
+// return 1.0 - pow(1.0 - x, 4.0);
+// }
+
+// // EaseOutQuint
+// float ease(float x) {
+// return 1.0 - pow(1.0 - x, 5.0);
+// }
+
+// // EaseOutSine
+// float ease(float x) {
+// return sin((x * PI) / 2.0);
+// }
+
+// // EaseOutExpo
+// float ease(float x) {
+// return x == 1.0 ? 1.0 : 1.0 - pow(2.0, -10.0 * x);
+// }
+
+// EaseOutCirc
+float ease(float x) {
+ return sqrt(1.0 - pow(x - 1.0, 2.0));
+}
+
+// // EaseOutBack
+// float ease(float x) {
+// return 1.0 + C3_BACK * pow(x - 1.0, 3.0) + C1_BACK * pow(x - 1.0, 2.0);
+// }
+
+// // EaseOutElastic
+// float ease(float x) {
+// return x == 0.0 ? 0.0
+// : x == 1.0 ? 1.0
+// : pow(2.0, -10.0 * x) * sin((x * 10.0 - 0.75) * C4_ELASTIC) + 1.0;
+// }
+
+// // Parametric Spring
+// float ease(float x) {
+// x = clamp(x, 0.0, 1.0);
+// float decay = exp(-SPRING_DAMPING * SPRING_STIFFNESS * x);
+// float freq = sqrt(SPRING_STIFFNESS * (1.0 - SPRING_DAMPING * SPRING_DAMPING));
+// float osc = cos(freq * 6.283185 * x) + (SPRING_DAMPING * sqrt(SPRING_STIFFNESS) / freq) * sin(freq * 6.283185 * x);
+// return 1.0 - decay * osc;
+// }
+
+float getSdfRectangle(in vec2 p, in vec2 xy, in vec2 b)
+{
+ vec2 d = abs(p - xy) - b;
+ return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}
+
+// 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 getSdfConvexQuad(in vec2 p, in vec2 v1, in vec2 v2, in vec2 v3, in vec2 v4) {
+ float s = 1.0;
+ float d = dot(p - v1, p - v1);
+
+ d = seg(p, v1, v2, s, d);
+ d = seg(p, v2, v3, s, d);
+ d = seg(p, v3, v4, s, d);
+ d = seg(p, v4, v1, s, d);
+
+ return s * sqrt(d);
+}
+
+vec2 normalize(vec2 value, float isPosition) {
+ return (value * 2.0 - (iResolution.xy * isPosition)) / iResolution.y;
+}
+
+float antialising(float distance, float blurAmount) {
+ return 1. - smoothstep(0., normalize(vec2(blurAmount, blurAmount), 0.).x, distance);
+}
+
+// Determines animation duration based on a corner's alignment with the move direction(dot product)
+// dot_val will be in [-2, 2]
+// > 0.5 (1 or 2) = Leading
+// > -0.5 (0) = Side
+// <= -0.5 (-1 or -2) = Trailing
+float getDurationFromDot(float dot_val, float DURATION_LEAD, float DURATION_SIDE, float DURATION_TRAIL) {
+ float isLead = step(0.5, dot_val);
+ float isSide = step(-0.5, dot_val) * (1.0 - isLead);
+
+ // Start with trailing duration
+ float duration = mix(DURATION_TRAIL, DURATION_SIDE, isSide);
+ // Mix in leading duration
+ duration = mix(duration, DURATION_LEAD, isLead);
+ return duration;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord){
+ #if !defined(WEB)
+ fragColor = texture(iChannel0, fragCoord.xy / iResolution.xy);
+ #endif
+
+ // normalization & setup(-1, 1 coords)
+ vec2 vu = normalize(fragCoord, 1.);
+ vec2 offsetFactor = vec2(-.5, 0.5);
+
+ vec4 currentCursor = vec4(normalize(iCurrentCursor.xy, 1.), normalize(iCurrentCursor.zw, 0.));
+ vec4 previousCursor = vec4(normalize(iPreviousCursor.xy, 1.), normalize(iPreviousCursor.zw, 0.));
+
+ vec2 centerCC = currentCursor.xy - (currentCursor.zw * offsetFactor);
+ vec2 halfSizeCC = currentCursor.zw * 0.5;
+ vec2 centerCP = previousCursor.xy - (previousCursor.zw * offsetFactor);
+ vec2 halfSizeCP = previousCursor.zw * 0.5;
+
+ float sdfCurrentCursor = getSdfRectangle(vu, centerCC, halfSizeCC);
+
+ float lineLength = distance(centerCC, centerCP);
+ float minDist = currentCursor.w * THRESHOLD_MIN_DISTANCE;
+
+ vec4 newColor = vec4(fragColor);
+
+ float baseProgress = iTime - iTimeCursorChange;
+
+ if (lineLength > minDist && baseProgress < DURATION - 0.001) {
+ // defining corners of cursors
+
+ // Y (Height) with TRAIL_THICKNESS
+ float cc_half_height = currentCursor.w * 0.5;
+ float cc_center_y = currentCursor.y - cc_half_height;
+ float cc_new_half_height = cc_half_height * TRAIL_THICKNESS;
+ float cc_new_top_y = cc_center_y + cc_new_half_height;
+ float cc_new_bottom_y = cc_center_y - cc_new_half_height;
+
+ // X (Width) with TRAIL_THICKNESS
+ float cc_half_width = currentCursor.z * 0.5;
+ float cc_center_x = currentCursor.x + cc_half_width;
+ float cc_new_half_width = cc_half_width * TRAIL_THICKNESS_X;
+ float cc_new_left_x = cc_center_x - cc_new_half_width;
+ float cc_new_right_x = cc_center_x + cc_new_half_width;
+
+ vec2 cc_tl = vec2(cc_new_left_x, cc_new_top_y);
+ vec2 cc_tr = vec2(cc_new_right_x, cc_new_top_y);
+ vec2 cc_bl = vec2(cc_new_left_x, cc_new_bottom_y);
+ vec2 cc_br = vec2(cc_new_right_x, cc_new_bottom_y);
+
+ // same thing for previous cursor
+ float cp_half_height = previousCursor.w * 0.5;
+ float cp_center_y = previousCursor.y - cp_half_height;
+ float cp_new_half_height = cp_half_height * TRAIL_THICKNESS;
+ float cp_new_top_y = cp_center_y + cp_new_half_height;
+ float cp_new_bottom_y = cp_center_y - cp_new_half_height;
+
+ float cp_half_width = previousCursor.z * 0.5;
+ float cp_center_x = previousCursor.x + cp_half_width;
+ float cp_new_half_width = cp_half_width * TRAIL_THICKNESS_X;
+ float cp_new_left_x = cp_center_x - cp_new_half_width;
+ float cp_new_right_x = cp_center_x + cp_new_half_width;
+
+ vec2 cp_tl = vec2(cp_new_left_x, cp_new_top_y);
+ vec2 cp_tr = vec2(cp_new_right_x, cp_new_top_y);
+ vec2 cp_bl = vec2(cp_new_left_x, cp_new_bottom_y);
+ vec2 cp_br = vec2(cp_new_right_x, cp_new_bottom_y);
+
+ // calculating durations for every corner
+ const float DURATION_TRAIL = DURATION;
+ const float DURATION_LEAD = DURATION * (1.0 - TRAIL_SIZE);
+ const float DURATION_SIDE = (DURATION_LEAD + DURATION_TRAIL) / 2.0;
+
+ vec2 moveVec = centerCC - centerCP;
+ vec2 s = sign(moveVec);
+
+ // dot products for each corner, determining alignment with movement direction
+ float dot_tl = dot(vec2(-1., 1.), s);
+ float dot_tr = dot(vec2( 1., 1.), s);
+ float dot_bl = dot(vec2(-1.,-1.), s);
+ float dot_br = dot(vec2( 1.,-1.), s);
+
+ // assign durations based on dot products
+ float dur_tl = getDurationFromDot(dot_tl, DURATION_LEAD, DURATION_SIDE, DURATION_TRAIL);
+ float dur_tr = getDurationFromDot(dot_tr, DURATION_LEAD, DURATION_SIDE, DURATION_TRAIL);
+ float dur_bl = getDurationFromDot(dot_bl, DURATION_LEAD, DURATION_SIDE, DURATION_TRAIL);
+ float dur_br = getDurationFromDot(dot_br, DURATION_LEAD, DURATION_SIDE, DURATION_TRAIL);
+
+ // check direction of horizontal movement
+ float isMovingRight = step(0.5, s.x);
+ float isMovingLeft = step(0.5, -s.x);
+
+ // calculate vertical-rail durations
+ float dot_right_edge = (dot_tr + dot_br) * 0.5;
+ float dur_right_rail = getDurationFromDot(dot_right_edge, DURATION_LEAD, DURATION_SIDE, DURATION_TRAIL);
+
+ float dot_left_edge = (dot_tl + dot_bl) * 0.5;
+ float dur_left_rail = getDurationFromDot(dot_left_edge, DURATION_LEAD, DURATION_SIDE, DURATION_TRAIL);
+
+ float final_dur_tl = mix(dur_tl, dur_left_rail, isMovingLeft);
+ float final_dur_bl = mix(dur_bl, dur_left_rail, isMovingLeft);
+
+ float final_dur_tr = mix(dur_tr, dur_right_rail, isMovingRight);
+ float final_dur_br = mix(dur_br, dur_right_rail, isMovingRight);
+
+ // calculate progress for each corner based on the duration and time since cursor change
+ float prog_tl = ease(clamp(baseProgress / final_dur_tl, 0.0, 1.0));
+ float prog_tr = ease(clamp(baseProgress / final_dur_tr, 0.0, 1.0));
+ float prog_bl = ease(clamp(baseProgress / final_dur_bl, 0.0, 1.0));
+ float prog_br = ease(clamp(baseProgress / final_dur_br, 0.0, 1.0));
+
+ // get the trial corner positions based on progress
+ vec2 v_tl = mix(cp_tl, cc_tl, prog_tl);
+ vec2 v_tr = mix(cp_tr, cc_tr, prog_tr);
+ vec2 v_br = mix(cp_br, cc_br, prog_br);
+ vec2 v_bl = mix(cp_bl, cc_bl, prog_bl);
+
+ // DRAWING THE TRAIL
+ float sdfTrail = getSdfConvexQuad(vu, v_tl, v_tr, v_br, v_bl);
+
+ // --- FADE GRADIENT CALCULATION ---
+ vec2 fragVec = vu - centerCP;
+
+ // project fragment onto movement vector, normalize to [0, 1]
+ // 0.0 at tail, 1.0 at head
+ // tiny epsilon to avoid division by zero if moveVec is (0,0)
+ float fadeProgress = clamp(dot(fragVec, moveVec) / (dot(moveVec, moveVec) + 1e-6), 0.0, 1.0);
+
+ vec4 trail = TRAIL_COLOR;
+
+ float effectiveBlur = BLUR;
+ if (BLUR < 2.5) {
+ // no antialising on horizontal/vertical movement, fixes 'pulse' like thing on end cursor
+ float isDiagonal = abs(s.x) * abs(s.y); // 1.0 if diagonal, 0.0 if H/V
+ float effectiveBlur = mix(0.0, BLUR, isDiagonal);
+ }
+ float shapeAlpha = antialising(sdfTrail, effectiveBlur); // shape mask
+
+ if (FADE_ENABLED > 0.5) {
+ // apply fade gradient along the trail
+ // float fadeStart = 0.2;
+ // float easedProgress = smoothstep(fadeStart, 1.0, fadeProgress);
+ // easedProgress = pow(2.0, 10.0 * (fadeProgress - 1.0));
+ float easedProgress = pow(fadeProgress, FADE_EXPONENT);
+ trail.a *= easedProgress;
+ }
+
+ float finalAlpha = trail.a * shapeAlpha;
+
+ // newColor.a to preserve the background alpha.
+ newColor = mix(newColor, vec4(trail.rgb, newColor.a), finalAlpha);
+
+ // punch hole on the trail, so current cursor is drawn on top
+ newColor = mix(newColor, fragColor, step(sdfCurrentCursor, 0.));
+
+ }
+
+ fragColor = newColor;
+}
diff --git a/ghostty/shaders/dither.glsl b/ghostty/shaders/dither.glsl
new file mode 100644
index 0000000..7bfe740
--- /dev/null
+++ b/ghostty/shaders/dither.glsl
@@ -0,0 +1,30 @@
+// Simple "dithering" effect
+// (c) moni-dz (https://github.com/moni-dz)
+// CC BY-NC-SA 4.0 (https://creativecommons.org/licenses/by-nc-sa/4.0/)
+
+// Packed bayer pattern using bit manipulation
+const float bayerPattern[4] = float[4](
+ 0x0514, // Encoding 0,8,2,10
+ 0xC4E6, // Encoding 12,4,14,6
+ 0x3B19, // Encoding 3,11,1,9
+ 0xF7D5 // Encoding 15,7,13,5
+);
+
+float getBayerFromPacked(int x, int y) {
+ int idx = (x & 3) + ((y & 3) << 2);
+ return float((int(bayerPattern[y & 3]) >> ((x & 3) << 2)) & 0xF) * (1.0 / 16.0);
+}
+
+#define LEVELS 2.0 // Available color steps per channel
+#define INV_LEVELS (1.0 / LEVELS)
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord)
+{
+ vec2 uv = fragCoord * (1.0 / iResolution.xy);
+ vec3 color = texture(iChannel0, uv).rgb;
+
+ float threshold = getBayerFromPacked(int(fragCoord.x), int(fragCoord.y));
+ vec3 dithered = floor(color * LEVELS + threshold) * INV_LEVELS;
+
+ fragColor = vec4(dithered, 1.0);
+}
diff --git a/ghostty/shaders/drunkard.glsl b/ghostty/shaders/drunkard.glsl
new file mode 100644
index 0000000..e900d4a
--- /dev/null
+++ b/ghostty/shaders/drunkard.glsl
@@ -0,0 +1,68 @@
+// Drunken stupor effect using fractal Brownian motion and Perlin noise
+// (c) moni-dz (https://github.com/moni-dz)
+// CC BY-NC-SA 4.0 (https://creativecommons.org/licenses/by-nc-sa/4.0/)
+
+vec2 hash2(vec2 p) {
+ uvec2 q = uvec2(floatBitsToUint(p.x), floatBitsToUint(p.y));
+ q = (q * uvec2(1597334673U, 3812015801U)) ^ (q.yx * uvec2(2798796415U, 1979697793U));
+ return vec2(q) * (1.0/float(0xffffffffU)) * 2.0 - 1.0;
+}
+
+float perlin2d(vec2 p) {
+ vec2 i = floor(p);
+ vec2 f = fract(p);
+ vec2 u = f*f*(3.0-2.0*f);
+
+ return mix(mix(dot(hash2(i + vec2(0.0,0.0)), f - vec2(0.0,0.0)),
+ dot(hash2(i + vec2(1.0,0.0)), f - vec2(1.0,0.0)), u.x),
+ mix(dot(hash2(i + vec2(0.0,1.0)), f - vec2(0.0,1.0)),
+ dot(hash2(i + vec2(1.0,1.0)), f - vec2(1.0,1.0)), u.x), u.y);
+}
+
+#define OCTAVES 10 // How many passes of fractal Brownian motion to perform
+#define GAIN 0.5 // How much should each pixel move
+#define LACUNARITY 2.0 // How fast should each ripple be per pass
+
+float fbm(vec2 p) {
+ float sum = 0.0;
+ float amp = 0.5;
+ float freq = 1.0;
+
+ for(int i = 0; i < OCTAVES; i++) {
+ sum += amp * perlin2d(p * freq);
+ freq *= LACUNARITY;
+ amp *= GAIN;
+ }
+
+ return sum;
+}
+
+
+#define NOISE_SCALE 1.0 // How distorted the image you want to be
+#define NOISE_INTENSITY 0.05 // How strong the noise effect is
+#define ABERRATION true // Chromatic aberration
+#define ABERRATION_DELTA 0.1 // How strong the chromatic aberration effect is
+#define ANIMATE true
+#define SPEED 0.4 // Animation speed
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord)
+{
+ vec2 uv = fragCoord/iResolution.xy;
+ float time = ANIMATE ? iTime * SPEED : 0.0;
+
+ vec2 noisePos = uv * NOISE_SCALE + vec2(time);
+ float noise = fbm(noisePos) * NOISE_INTENSITY;
+
+ vec3 col;
+
+ if (ABERRATION) {
+ col.r = texture(iChannel0, uv + vec2(noise * (1.0 + ABERRATION_DELTA))).r;
+ col.g = texture(iChannel0, uv + vec2(noise)).g;
+ col.b = texture(iChannel0, uv + vec2(noise * (1.0 - ABERRATION_DELTA))).b;
+ } else {
+ vec2 distortedUV = uv + vec2(noise);
+ col = texture(iChannel0, distortedUV).rgb;
+ }
+
+ fragColor = vec4(col, 1.0);
+}
diff --git a/ghostty/shaders/fireworks-rockets.glsl b/ghostty/shaders/fireworks-rockets.glsl
new file mode 100644
index 0000000..e2f0b5a
--- /dev/null
+++ b/ghostty/shaders/fireworks-rockets.glsl
@@ -0,0 +1,109 @@
+// This Ghostty shader is a lightly modified port of https://www.shadertoy.com/view/4dBGRw
+
+#define BLACK_BLEND_THRESHOLD .4
+
+//Creates a diagonal red-and-white striped pattern.
+vec3 barberpole(vec2 pos, vec2 rocketpos) {
+ float d = (pos.x - rocketpos.x) + (pos.y - rocketpos.y);
+ vec3 col = vec3(1.0);
+
+ d = mod(d * 20., 2.0);
+ if (d > 1.0) {
+ col = vec3(1.0, 0.0, 0.0);
+ }
+
+ return col;
+}
+
+vec3 rocket(vec2 pos, vec2 rocketpos) {
+ vec3 col = vec3(0.0);
+ float f = 0.;
+ float absx = abs(rocketpos.x - pos.x);
+ float absy = abs(rocketpos.y - pos.y);
+
+ // Wooden stick
+ if (absx < 0.01 && absy < 0.22) {
+ col = vec3(1.0, 0.5, 0.5);
+ }
+
+ // Barberpole
+ if (absx < 0.05 && absy < 0.15) {
+ col = barberpole(pos, rocketpos);
+ }
+
+ // Rocket Point
+ float pointw = (rocketpos.y - pos.y - 0.25) * -0.7;
+ if ((rocketpos.y - pos.y) > 0.1) {
+ f = smoothstep(pointw - 0.001, pointw + 0.001, absx);
+
+ col = mix(vec3(1.0, 0.0, 0.0), col, f);
+ }
+
+ // Shadow
+ f = -.5 + smoothstep(-0.05, 0.05, (rocketpos.x - pos.x));
+ col *= 0.7 + f;
+
+ return col;
+}
+
+float rand(float val, float seed) {
+ return cos(val * sin(val * seed) * seed);
+}
+
+float distance2(in vec2 a, in vec2 b) {
+ return dot(a - b, a - b);
+}
+
+mat2 rr = mat2(cos(1.0), -sin(1.0), sin(1.0), cos(1.0));
+
+vec3 drawParticles(vec2 pos, vec3 particolor, float time, vec2 cpos, float gravity, float seed, float timelength) {
+ vec3 col = vec3(0.0);
+ vec2 pp = vec2(1.0, 0.0);
+ for (float i = 1.0; i <= 128.0; i++) {
+ float d = rand(i, seed);
+ float fade = (i / 128.0) * time;
+ vec2 particpos = cpos + time * pp * d;
+ pp = rr * pp;
+ col = mix(particolor / fade, col, smoothstep(0.0, 0.0001, distance2(particpos, pos)));
+ }
+ col *= smoothstep(0.0, 1.0, (timelength - time) / timelength);
+
+ return col;
+}
+vec3 drawFireworks(float time, vec2 uv, vec3 particolor, float seed) {
+ float timeoffset = 2.0;
+ vec3 col = vec3(0.0);
+ if (time <= 0.) {
+ return col;
+ }
+ if (mod(time, 6.0) > timeoffset) {
+ col = drawParticles(uv, particolor, mod(time, 6.0) - timeoffset, vec2(rand(ceil(time / 6.0), seed), -0.5), 0.5, ceil(time / 6.0), seed);
+ } else {
+ col = rocket(uv * 3., vec2(3. * rand(ceil(time / 6.0), seed), 3. * (-0.5 + (timeoffset - mod(time, 6.0)))));
+ }
+ return col;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord)
+{
+ vec2 uv = 1.0 - 2.0 * fragCoord.xy / iResolution.xy;
+ uv.x *= iResolution.x / iResolution.y;
+ vec3 col = vec3(0.1, 0.1, 0.2);
+
+ // Flip the y-axis so that the rocket is drawn from the bottom of the screen
+ uv.y = -uv.y;
+
+ col += 0.1 * uv.y;
+
+ col += drawFireworks(iTime, uv, vec3(1.0, 0.1, 0.1), 1.);
+ col += drawFireworks(iTime - 2.0, uv, vec3(0.0, 1.0, 0.5), 2.);
+ col += drawFireworks(iTime - 4.0, uv, vec3(1.0, 1.0, 0.1), 3.);
+
+ vec2 termUV = fragCoord.xy / iResolution.xy;
+ vec4 terminalColor = texture(iChannel0, termUV);
+
+ float alpha = step(length(terminalColor.rgb), BLACK_BLEND_THRESHOLD);
+ vec3 blendedColor = mix(terminalColor.rgb * 1.0, col.rgb * 0.3, alpha);
+
+ fragColor = vec4(blendedColor, terminalColor.a);
+}
diff --git a/ghostty/shaders/fireworks.glsl b/ghostty/shaders/fireworks.glsl
new file mode 100644
index 0000000..42bc98d
--- /dev/null
+++ b/ghostty/shaders/fireworks.glsl
@@ -0,0 +1,116 @@
+// This Ghostty shader is a port of https://www.shadertoy.com/view/lscGRl
+
+// "Fireworks" by Martijn Steinrucken aka BigWings - 2015
+// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
+// Email:countfrolic@gmail.com Twitter:@The_ArtOfCode
+
+#define BLACK_BLEND_THRESHOLD .4
+#define PI 3.141592653589793238
+#define TWOPI 6.283185307179586
+#define S(x,y,z) smoothstep(x,y,z)
+#define B(x,y,z,w) S(x-z, x+z, w)*S(y+z, y-z, w)
+#define saturate(x) clamp(x,0.,1.)
+
+#define NUM_EXPLOSIONS 3.
+#define NUM_PARTICLES 42.
+
+// Noise functions by Dave Hoskins
+#define MOD3 vec3(.1031,.11369,.13787)
+vec3 hash31(float p) {
+ vec3 p3 = fract(vec3(p) * MOD3);
+ p3 += dot(p3, p3.yzx + 19.19);
+ return fract(vec3((p3.x + p3.y) * p3.z, (p3.x + p3.z) * p3.y, (p3.y + p3.z) * p3.x));
+}
+float hash12(vec2 p) {
+ vec3 p3 = fract(vec3(p.xyx) * MOD3);
+ p3 += dot(p3, p3.yzx + 19.19);
+ return fract((p3.x + p3.y) * p3.z);
+}
+
+float circ(vec2 uv, vec2 pos, float size) {
+ uv -= pos;
+
+ size *= size;
+ return S(size * 1.1, size, dot(uv, uv));
+}
+
+float light(vec2 uv, vec2 pos, float size) {
+ uv -= pos;
+
+ size *= size;
+ return size / dot(uv, uv);
+}
+
+vec3 explosion(vec2 uv, vec2 p, float seed, float t) {
+ vec3 col = vec3(0.);
+
+ vec3 en = hash31(seed);
+ vec3 baseCol = en;
+ for (float i = 0.; i < NUM_PARTICLES; i++) {
+ vec3 n = hash31(i) - .5;
+
+ vec2 startP = p - vec2(0., t * t * .1);
+ vec2 endP = startP + normalize(n.xy) * n.z - vec2(0., t * .2);
+
+ float pt = 1. - pow(t - 1., 2.);
+ vec2 pos = mix(p, endP, pt);
+ float size = mix(.01, .005, S(0., .1, pt));
+ size *= S(1., .1, pt);
+
+ float sparkle = (sin((pt + n.z) * 21.) * .5 + .5);
+ sparkle = pow(sparkle, pow(en.x, 3.) * 50.) * mix(0.01, .01, en.y * n.y);
+
+ //size += sparkle*B(.6, 1., .1, t);
+ size += sparkle * B(en.x, en.y, en.z, t);
+
+ col += baseCol * light(uv, pos, size);
+ }
+
+ return col;
+}
+
+vec3 Rainbow(vec3 c) {
+ float t = iTime;
+
+ float avg = (c.r + c.g + c.b) / 3.;
+ c = avg + (c - avg) * sin(vec3(0., .333, .666) + t);
+
+ c += sin(vec3(.4, .3, .3) * t + vec3(1.1244, 3.43215, 6.435)) * vec3(.4, .1, .5);
+
+ return c;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord)
+{
+ vec2 uv = fragCoord.xy / iResolution.xy;
+ uv.x -= .5;
+ uv.x *= iResolution.x / iResolution.y;
+
+ // Flip the y-axis so that the gravity is downwards
+ uv.y = -uv.y + 1.;
+
+ float n = hash12(uv + 10.);
+ float t = iTime * .5;
+
+ vec3 c = vec3(0.);
+
+ for (float i = 0.; i < NUM_EXPLOSIONS; i++) {
+ float et = t + i * 1234.45235;
+ float id = floor(et);
+ et -= id;
+
+ vec2 p = hash31(id).xy;
+ p.x -= .5;
+ p.x *= 1.6;
+ c += explosion(uv, p, id, et);
+ }
+ c = Rainbow(c);
+
+ vec2 termUV = fragCoord.xy / iResolution.xy;
+ vec4 terminalColor = texture(iChannel0, termUV);
+
+ float alpha = step(length(terminalColor.rgb), BLACK_BLEND_THRESHOLD);
+ vec3 blendedColor = mix(terminalColor.rgb * 1.0, c.rgb * 0.3, alpha);
+
+ fragColor = vec4(blendedColor, terminalColor.a);
+}
diff --git a/ghostty/shaders/gears-and-belts.glsl b/ghostty/shaders/gears-and-belts.glsl
new file mode 100644
index 0000000..9976b34
--- /dev/null
+++ b/ghostty/shaders/gears-and-belts.glsl
@@ -0,0 +1,377 @@
+// sligltly modified version of https://www.shadertoy.com/view/DsVSDV
+// The only changes are done in the mainImage function
+// Ive added comments on what to modify
+// works really well with most colorschemes
+
+#define Rot(a) mat2(cos(a),-sin(a),sin(a),cos(a))
+#define antialiasing(n) n/min(iResolution.y,iResolution.x)
+#define S(d,b) smoothstep(antialiasing(3.0),b,d)
+#define B(p,s) max(abs(p).x-s.x,abs(p).y-s.y)
+#define deg45 .707
+#define R45(p) (( p + vec2(p.y,-p.x) ) *deg45)
+#define Tri(p,s) max(R45(p).x,max(R45(p).y,B(p,s)))
+#define DF(a,b) length(a) * cos( mod( atan(a.y,a.x)+6.28/(b*8.0), 6.28/((b*8.0)*0.5))+(b-1.)*6.28/(b*8.0) + vec2(0,11) )
+
+float random (vec2 p) {
+ return fract(sin(dot(p.xy, vec2(12.9898,78.233)))* 43758.5453123);
+}
+
+float innerGear(vec2 p, float dir){
+ p*=Rot(radians(-iTime*45.+45.)*dir);
+ vec2 prevP = p;
+
+ //p*=Rot(radians(iTime*45.+20.));
+ p = DF(p,7.);
+ p-=vec2(0.24);
+ p*=Rot(deg45);
+ float d = B(p,vec2(0.01,0.06));
+ p = prevP;
+ float d2 = abs(length(p)-0.42)-0.02;
+ d = min(d,d2);
+ d2 = abs(length(p)-0.578)-0.02;
+ d = min(d,d2);
+ d2 = abs(length(p)-0.499)-0.005;
+ d = min(d,d2);
+
+ p = DF(p,7.);
+ p-=vec2(0.43);
+ p*=Rot(deg45);
+ d2 = B(p,vec2(0.01,0.04));
+ d = min(d,d2);
+
+ return d;
+}
+
+vec3 pattern1(vec2 p, vec3 col, float dir){
+ vec2 prevP = p;
+ float size = 0.499;
+ float thick = 0.15;
+
+ p+=vec2(size);
+ float d = abs(length(p)-size)-thick;
+ d = max(d,innerGear(p,dir));
+ col = mix(col,vec3(1.),S(d,0.0));
+
+ p = prevP;
+ p-=vec2(size);
+ d = abs(length(p)-size)-thick;
+ d = max(d,innerGear(p,dir));
+ col = mix(col,vec3(1.),S(d,0.0));
+
+ return col;
+}
+
+vec3 pattern2(vec2 p, vec3 col, float dir){
+
+ vec2 prevP = p;
+ float size = 0.33;
+ float thick = 0.15;
+ float thift = 0.0;
+ float speed = 0.3;
+
+ p-=vec2(size,0.);
+ float d = B(p,vec2(size,thick));
+
+ p.x+=thift;
+ p.x-=iTime*speed*dir;
+ p.x=mod(p.x,0.08)-0.04;
+ d = max(d,B(p,vec2(0.011,thick)));
+ p = prevP;
+ d = max(-(abs(p.y)-0.1),d);
+ //d = min(B(p,vec2(1.,0.1)),d);
+ p.y=abs(p.y)-0.079;
+ d = min(B(p,vec2(1.,0.02)),d);
+
+ p = prevP;
+ p-=vec2(0.0,size);
+ float d2 = B(p,vec2(thick,size));
+
+ p.y+=thift;
+ p.y+=iTime*speed*dir;
+ p.y=mod(p.y,0.08)-0.04;
+ d2 = max(d2,B(p,vec2(thick,0.011)));
+
+ p = prevP;
+ d2 = max(-(abs(p.x)-0.1),d2);
+ d2 = min(B(p,vec2(0.005,1.)),d2);
+ p.x=abs(p.x)-0.079;
+ d2 = min(B(p,vec2(0.02,1.)),d2);
+
+ d = min(d,d2);
+
+ p = prevP;
+ p+=vec2(0.0,size);
+ d2 = B(p,vec2(thick,size));
+
+ p.y+=thift;
+ p.y-=iTime*speed*dir;
+ p.y=mod(p.y,0.08)-0.04;
+ d2 = max(d2,B(p,vec2(thick,0.011)));
+
+ p = prevP;
+ d2 = max(-(abs(p.x)-0.1),d2);
+ d2 = min(B(p,vec2(0.005,1.)),d2);
+ p.x=abs(p.x)-0.079;
+ d2 = min(B(p,vec2(0.02,1.)),d2);
+
+ d = min(d,d2);
+
+ p = prevP;
+ p+=vec2(size,0.0);
+ d2 = B(p,vec2(size,thick));
+
+ p.x+=thift;
+ p.x+=iTime*speed*dir;
+ p.x=mod(p.x,0.08)-0.04;
+ d2 = max(d2,B(p,vec2(0.011,thick)));
+ d = min(d,d2);
+ p = prevP;
+ d = max(-(abs(p.y)-0.1),d);
+ d = min(B(p,vec2(1.,0.005)),d);
+ p.y=abs(p.y)-0.079;
+ d = min(B(p,vec2(1.,0.02)),d);
+
+ p = prevP;
+ d2 = abs(B(p,vec2(size*0.3)))-0.05;
+ d = min(d,d2);
+
+ col = mix(col,vec3(1.),S(d,0.0));
+
+ d = B(p,vec2(0.08));
+ col = mix(col,vec3(0.),S(d,0.0));
+
+ p*=Rot(radians(60.*iTime*dir));
+ d = B(p,vec2(0.03));
+ col = mix(col,vec3(1.),S(d,0.0));
+
+ return col;
+}
+
+vec3 drawBelt(vec2 p, vec3 col, float size){
+ vec2 prevP = p;
+
+ p*=size;
+ vec2 id = floor(p);
+ vec2 gr = fract(p)-0.5;
+ float dir = mod(id.x+id.y,2.)*2.-1.;
+ float n = random(id);
+
+ if(n<0.5){
+ if(n<0.25){
+ gr.x*=-1.;
+ }
+ col = pattern1(gr,col,dir);
+ } else {
+ if(n>0.75){
+ gr.x*=-1.;
+ }
+ col = pattern2(gr,col,dir);
+ }
+
+ return col;
+}
+
+vec3 gear(vec2 p, vec3 col, float dir){
+ vec2 prevP = p;
+
+ p*=Rot(radians(iTime*45.+13.)*-dir);
+ p = DF(p,7.);
+ p-=vec2(0.23);
+ p*=Rot(deg45);
+ float d = B(p,vec2(0.01,0.04));
+ p = prevP;
+ float d2 = abs(length(p)-0.29)-0.02;
+ d = min(d,d2);
+ col = mix(col,vec3(1.),S(d,0.0));
+
+ p*=Rot(radians(iTime*30.-30.)*dir);
+ p = DF(p,6.);
+ p-=vec2(0.14);
+ p*=Rot(radians(45.));
+ d = B(p,vec2(0.01,0.03));
+ p = prevP;
+ d2 =abs( length(p)-0.1)-0.02;
+ p*=Rot(radians(iTime*25.+30.)*-dir);
+ d2 = max(-(abs(p.x)-0.05),d2);
+ d = min(d,d2);
+ col = mix(col,vec3(1.),S(d,0.0));
+
+ return col;
+}
+
+vec3 item0(vec2 p, vec3 col, float dir){
+ vec2 prevP = p;
+ p.x*=dir;
+ p*=Rot(radians(iTime*30.+30.));
+ float d = abs(length(p)-0.2)-0.05;
+ col = mix(col,vec3(0.3),S(d,0.0));
+
+ d = abs(length(p)-0.2)-0.05;
+ d = max(-p.x,d);
+ float a = clamp(atan(p.x,p.y)*0.5,0.3,1.);
+
+ col = mix(col,vec3(a),S(d,0.0));
+
+ return col;
+}
+
+
+vec3 item1(vec2 p, vec3 col, float dir){
+ p.x*=dir;
+ vec2 prevP = p;
+ p*=Rot(radians(iTime*30.+30.));
+ float d = abs(length(p)-0.25)-0.04;
+ d = abs(max((abs(p.y)-0.15),d))-0.005;
+ float d2 = abs(length(p)-0.25)-0.01;
+ d2 = max((abs(p.y)-0.12),d2);
+ d = min(d,d2);
+
+ d2 = abs(length(p)-0.27)-0.01;
+ d2 = max(-(abs(p.y)-0.22),d2);
+ d = min(d,d2);
+ d2 = B(p,vec2(0.01,0.32));
+ d2 = max(-(abs(p.y)-0.22),d2);
+ d = min(d,d2);
+
+ p = prevP;
+ p*=Rot(radians(iTime*-20.+30.));
+ p = DF(p,2.);
+ p-=vec2(0.105);
+ p*=Rot(radians(45.));
+ d2 = B(p,vec2(0.03,0.01));
+ d = min(d,d2);
+
+ p = prevP;
+ d2 = abs(length(p)-0.09)-0.005;
+ d2 = max(-(abs(p.x)-0.03),d2);
+ d2 = max(-(abs(p.y)-0.03),d2);
+ d = min(d,d2);
+
+ col = mix(col,vec3(0.6),S(d,0.0));
+
+ return col;
+}
+
+vec3 item2(vec2 p, vec3 col, float dir){
+ p.x*=dir;
+ p*=Rot(radians(iTime*50.-10.));
+ vec2 prevP = p;
+ float d = abs(length(p)-0.15)-0.005;
+ float d2 = abs(length(p)-0.2)-0.01;
+ d2 = max((abs(p.y)-0.15),d2);
+ d = min(d,d2);
+
+ p = DF(p,1.);
+ p-=vec2(0.13);
+ p*=Rot(radians(45.));
+ d2 = B(p,vec2(0.008,0.1));
+ d = min(d,d2);
+
+ p = prevP;
+ p = DF(p,4.);
+ p-=vec2(0.18);
+ p*=Rot(radians(45.));
+ d2 = B(p,vec2(0.005,0.02));
+ d = min(d,d2);
+
+ col = mix(col,vec3(0.6),S(d,0.0));
+
+ return col;
+}
+
+float needle(vec2 p){
+ p.y-=0.05;
+ p*=1.5;
+ vec2 prevP = p;
+ p.y-=0.3;
+ p.x*=6.;
+ float d = Tri(p,vec2(0.3));
+ p = prevP;
+ p.y+=0.1;
+ p.x*=2.;
+ p.y*=-1.;
+ float d2 = Tri(p,vec2(0.1));
+ d = min(d,d2);
+ return d;
+}
+
+vec3 item3(vec2 p, vec3 col, float dir){
+
+ p*=Rot(radians(sin(iTime*dir)*120.));
+ vec2 prevP = p;
+
+ p.y= abs(p.y)-0.05;
+ float d = needle(p);
+ p = prevP;
+ float d2 = abs(length(p)-0.1)-0.003;
+ d2 = max(-(abs(p.x)-0.05),d2);
+ d = min(d,d2);
+ d2 = abs(length(p)-0.2)-0.005;
+ d2 = max(-(abs(p.x)-0.08),d2);
+ d = min(d,d2);
+
+ p = DF(p,4.);
+ p-=vec2(0.18);
+ d2 = length(p)-0.01;
+ p = prevP;
+ d2 = max(-(abs(p.x)-0.03),d2);
+ d = min(d,d2);
+
+ col = mix(col,vec3(0.6),S(d,0.0));
+
+ return col;
+}
+
+vec3 drawGearsAndItems(vec2 p, vec3 col, float size){
+ vec2 prevP = p;
+ p*=size;
+ p+=vec2(0.5);
+
+ vec2 id = floor(p);
+ vec2 gr = fract(p)-0.5;
+
+ float n = random(id);
+ float dir = mod(id.x+id.y,2.)*2.-1.;
+ if(n<0.3){
+ col = gear(gr,col,dir);
+ } else if(n>=0.3 && n<0.5){
+ col = item0(gr,col,dir);
+ } else if(n>=0.5 && n<0.7){
+ col = item1(gr,col,dir);
+ } else if(n>=0.7 && n<0.8) {
+ col = item2(gr,col,dir);
+ } else if(n>=0.8){
+ col = item3(gr,col,dir);
+ }
+
+ return col;
+}
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+ vec2 p = (fragCoord-0.5*iResolution.xy)/iResolution.y;
+ // set speed of downwards motion
+ p.y+=iTime*0.02;
+
+ float size = 4.;
+ vec3 col = vec3(0.);
+
+ // Modify the colors to be darker by multiplying with a small factor
+ vec3 darkFactor = vec3(.5); // This makes everything 50% as bright
+
+ // Get the original colors but make them darker
+ col = drawBelt(p, col, size) * darkFactor;
+ col = drawGearsAndItems(p, col, size) * darkFactor;
+
+ // Additional option: you can add a color tint to make it less stark white
+ vec3 tint = vec3(0.1, 0.12, 0.15); // Slight blue-ish dark tint
+ col = col * tint;
+
+ vec2 uv = fragCoord/iResolution.xy;
+ vec4 terminalColor = texture(iChannel0, uv);
+
+ // Blend with reduced opacity for the shader elements
+ vec3 blendedColor = terminalColor.rgb + col.rgb * 0.7; // Reduced blend factor
+
+ fragColor = vec4(blendedColor, terminalColor.a);
+}
diff --git a/ghostty/shaders/glitchy.glsl b/ghostty/shaders/glitchy.glsl
new file mode 100644
index 0000000..603e3ec
--- /dev/null
+++ b/ghostty/shaders/glitchy.glsl
@@ -0,0 +1,117 @@
+// modified version of https://www.shadertoy.com/view/wld3WN
+// amount of seconds for which the glitch loop occurs
+#define DURATION 10.
+// percentage of the duration for which the glitch is triggered
+#define AMT .1
+
+#define SS(a, b, x) (smoothstep(a, b, x) * smoothstep(b, a, x))
+
+#define UI0 1597334673U
+#define UI1 3812015801U
+#define UI2 uvec2(UI0, UI1)
+#define UI3 uvec3(UI0, UI1, 2798796415U)
+#define UIF (1. / float(0xffffffffU))
+
+// Hash by David_Hoskins
+vec3 hash33(vec3 p)
+{
+ uvec3 q = uvec3(ivec3(p)) * UI3;
+ q = (q.x ^ q.y ^ q.z)*UI3;
+ return -1. + 2. * vec3(q) * UIF;
+}
+
+// Gradient noise by iq
+float gnoise(vec3 x)
+{
+ // grid
+ vec3 p = floor(x);
+ vec3 w = fract(x);
+
+ // quintic interpolant
+ vec3 u = w * w * w * (w * (w * 6. - 15.) + 10.);
+
+ // gradients
+ vec3 ga = hash33(p + vec3(0., 0., 0.));
+ vec3 gb = hash33(p + vec3(1., 0., 0.));
+ vec3 gc = hash33(p + vec3(0., 1., 0.));
+ vec3 gd = hash33(p + vec3(1., 1., 0.));
+ vec3 ge = hash33(p + vec3(0., 0., 1.));
+ vec3 gf = hash33(p + vec3(1., 0., 1.));
+ vec3 gg = hash33(p + vec3(0., 1., 1.));
+ vec3 gh = hash33(p + vec3(1., 1., 1.));
+
+ // projections
+ float va = dot(ga, w - vec3(0., 0., 0.));
+ float vb = dot(gb, w - vec3(1., 0., 0.));
+ float vc = dot(gc, w - vec3(0., 1., 0.));
+ float vd = dot(gd, w - vec3(1., 1., 0.));
+ float ve = dot(ge, w - vec3(0., 0., 1.));
+ float vf = dot(gf, w - vec3(1., 0., 1.));
+ float vg = dot(gg, w - vec3(0., 1., 1.));
+ float vh = dot(gh, w - vec3(1., 1., 1.));
+
+ // interpolation
+ float gNoise = va + u.x * (vb - va) +
+ u.y * (vc - va) +
+ u.z * (ve - va) +
+ u.x * u.y * (va - vb - vc + vd) +
+ u.y * u.z * (va - vc - ve + vg) +
+ u.z * u.x * (va - vb - ve + vf) +
+ u.x * u.y * u.z * (-va + vb + vc - vd + ve - vf - vg + vh);
+
+ return 2. * gNoise;
+}
+
+// gradient noise in range [0, 1]
+float gnoise01(vec3 x)
+{
+ return .5 + .5 * gnoise(x);
+}
+
+// warp uvs for the crt effect
+vec2 crt(vec2 uv)
+{
+ float tht = atan(uv.y, uv.x);
+ float r = length(uv);
+ // curve without distorting the center
+ r /= (1. - .1 * r * r);
+ uv.x = r * cos(tht);
+ uv.y = r * sin(tht);
+ return .5 * (uv + 1.);
+}
+
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+ vec2 uv = fragCoord / iResolution.xy;
+ float t = iTime;
+
+ // smoothed interval for which the glitch gets triggered
+ float glitchAmount = SS(DURATION * .001, DURATION * AMT, mod(t, DURATION));
+ float displayNoise = 0.;
+ vec3 col = vec3(0.);
+ vec2 eps = vec2(5. / iResolution.x, 0.);
+ vec2 st = vec2(0.);
+
+ // analog distortion
+ float y = uv.y * iResolution.y;
+ float distortion = gnoise(vec3(0., y * .01, t * 500.)) * (glitchAmount * 4. + .1);
+ distortion *= gnoise(vec3(0., y * .02, t * 250.)) * (glitchAmount * 2. + .025);
+
+ ++displayNoise;
+ distortion += smoothstep(.999, 1., sin((uv.y + t * 1.6) * 2.)) * .02;
+ distortion -= smoothstep(.999, 1., sin((uv.y + t) * 2.)) * .02;
+ st = uv + vec2(distortion, 0.);
+ // chromatic aberration
+ col.r += textureLod(iChannel0, st + eps + distortion, 0.).r;
+ col.g += textureLod(iChannel0, st, 0.).g;
+ col.b += textureLod(iChannel0, st - eps - distortion, 0.).b;
+
+ // white noise + scanlines
+ displayNoise = 0.2 * clamp(displayNoise, 0., 1.);
+ col += (.15 + .65 * glitchAmount) * (hash33(vec3(fragCoord, mod(float(iFrame),
+ 1000.))).r) * displayNoise;
+ col -= (.25 + .75 * glitchAmount) * (sin(4. * t + uv.y * iResolution.y * 1.75))
+ * displayNoise;
+ fragColor = vec4(col, 1.0);
+}
diff --git a/ghostty/shaders/glow-rgbsplit-twitchy.glsl b/ghostty/shaders/glow-rgbsplit-twitchy.glsl
new file mode 100644
index 0000000..9411e4e
--- /dev/null
+++ b/ghostty/shaders/glow-rgbsplit-twitchy.glsl
@@ -0,0 +1,144 @@
+// First it does a "chromatic aberration" by splitting the rgb signals by a product of sin functions
+// over time, then it does a glow effect in a perceptual color space
+// Based on kalgynirae's Ghostty passable glow shader and NickWest's Chromatic Aberration shader demo
+// Passable glow: https://github.com/kalgynirae/dotfiles/blob/main/ghostty/glow.glsl
+// "Chromatic Aberration": https://www.shadertoy.com/view/Mds3zn
+
+// sRGB linear -> nonlinear transform from https://bottosson.github.io/posts/colorwrong/
+float f(float x) {
+ if (x >= 0.0031308) {
+ return 1.055 * pow(x, 1.0 / 2.4) - 0.055;
+ } else {
+ return 12.92 * x;
+ }
+}
+
+float f_inv(float x) {
+ if (x >= 0.04045) {
+ return pow((x + 0.055) / 1.055, 2.4);
+ } else {
+ return x / 12.92;
+ }
+}
+
+// Oklab <-> linear sRGB conversions from https://bottosson.github.io/posts/oklab/
+vec4 toOklab(vec4 rgb) {
+ vec3 c = vec3(f_inv(rgb.r), f_inv(rgb.g), f_inv(rgb.b));
+ float l = 0.4122214708 * c.r + 0.5363325363 * c.g + 0.0514459929 * c.b;
+ float m = 0.2119034982 * c.r + 0.6806995451 * c.g + 0.1073969566 * c.b;
+ float s = 0.0883024619 * c.r + 0.2817188376 * c.g + 0.6299787005 * c.b;
+ float l_ = pow(l, 1.0 / 3.0);
+ float m_ = pow(m, 1.0 / 3.0);
+ float s_ = pow(s, 1.0 / 3.0);
+ return vec4(
+ 0.2104542553 * l_ + 0.7936177850 * m_ - 0.0040720468 * s_,
+ 1.9779984951 * l_ - 2.4285922050 * m_ + 0.4505937099 * s_,
+ 0.0259040371 * l_ + 0.7827717662 * m_ - 0.8086757660 * s_,
+ rgb.a
+ );
+}
+
+vec4 toRgb(vec4 oklab) {
+ vec3 c = oklab.rgb;
+ float l_ = c.r + 0.3963377774 * c.g + 0.2158037573 * c.b;
+ float m_ = c.r - 0.1055613458 * c.g - 0.0638541728 * c.b;
+ float s_ = c.r - 0.0894841775 * c.g - 1.2914855480 * c.b;
+ float l = l_ * l_ * l_;
+ float m = m_ * m_ * m_;
+ float s = s_ * s_ * s_;
+ vec3 linear_srgb = vec3(
+ 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+ -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+ -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s
+ );
+ return vec4(
+ clamp(f(linear_srgb.r), 0.0, 1.0),
+ clamp(f(linear_srgb.g), 0.0, 1.0),
+ clamp(f(linear_srgb.b), 0.0, 1.0),
+ oklab.a
+ );
+}
+
+// Bloom samples from https://gist.github.com/qwerasd205/c3da6c610c8ffe17d6d2d3cc7068f17f
+const vec3[24] samples = {
+ vec3(0.1693761725038636, 0.9855514761735895, 1),
+ vec3(-1.333070830962943, 0.4721463328627773, 0.7071067811865475),
+ vec3(-0.8464394909806497, -1.51113870578065, 0.5773502691896258),
+ vec3(1.554155680728463, -1.2588090085709776, 0.5),
+ vec3(1.681364377589461, 1.4741145918052656, 0.4472135954999579),
+ vec3(-1.2795157692199817, 2.088741103228784, 0.4082482904638631),
+ vec3(-2.4575847530631187, -0.9799373355024756, 0.3779644730092272),
+ vec3(0.5874641440200847, -2.7667464429345077, 0.35355339059327373),
+ vec3(2.997715703369726, 0.11704939884745152, 0.3333333333333333),
+ vec3(0.41360842451688395, 3.1351121305574803, 0.31622776601683794),
+ vec3(-3.167149933769243, 0.9844599011770256, 0.30151134457776363),
+ vec3(-1.5736713846521535, -3.0860263079123245, 0.2886751345948129),
+ vec3(2.888202648340422, -2.1583061557896213, 0.2773500981126146),
+ vec3(2.7150778983300325, 2.5745586041105715, 0.2672612419124244),
+ vec3(-2.1504069972377464, 3.2211410627650165, 0.2581988897471611),
+ vec3(-3.6548858794907493, -1.6253643308191343, 0.25),
+ vec3(1.0130775986052671, -3.9967078676335834, 0.24253562503633297),
+ vec3(4.229723673607257, 0.33081361055181563, 0.23570226039551587),
+ vec3(0.40107790291173834, 4.340407413572593, 0.22941573387056174),
+ vec3(-4.319124570236028, 1.159811599693438, 0.22360679774997896),
+ vec3(-1.9209044802827355, -4.160543952132907, 0.2182178902359924),
+ vec3(3.8639122286635708, -2.6589814382925123, 0.21320071635561041),
+ vec3(3.3486228404946234, 3.4331800232609, 0.20851441405707477),
+ vec3(-2.8769733643574344, 3.9652268864187157, 0.20412414523193154)
+};
+
+float offsetFunction(float iTime) {
+ float amount = 1.0;
+ const float periods[4] = {6.0, 16.0, 19.0, 27.0};
+ for (int i = 0; i < 4; i++) {
+ amount *= 1.0 + 0.5 * sin(iTime*periods[i]);
+ }
+ //return amount;
+ return amount * periods[3];
+}
+
+const float DIM_CUTOFF = 0.35;
+const float BRIGHT_CUTOFF = 0.65;
+const float ABBERATION_FACTOR = 0.05;
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ float amount = offsetFunction(iTime);
+
+ vec3 col;
+ col.r = texture( iChannel0, vec2(uv.x-ABBERATION_FACTOR*amount / iResolution.x, uv.y) ).r;
+ col.g = texture( iChannel0, uv ).g;
+ col.b = texture( iChannel0, vec2(uv.x+ABBERATION_FACTOR*amount / iResolution.x, uv.y) ).b;
+
+ vec4 splittedColor = vec4(col, 1.0);
+ vec4 source = toOklab(splittedColor);
+ vec4 dest = source;
+
+ if (source.x > DIM_CUTOFF) {
+ dest.x *= 1.2;
+ // dest.x = 1.2;
+ } else {
+ vec2 step = vec2(1.414) / iResolution.xy;
+ vec3 glow = vec3(0.0);
+ for (int i = 0; i < 24; i++) {
+ vec3 s = samples[i];
+ float weight = s.z;
+ vec4 c = toOklab(texture(iChannel0, uv + s.xy * step));
+ if (c.x > DIM_CUTOFF) {
+ glow.yz += c.yz * weight * 0.3;
+ if (c.x <= BRIGHT_CUTOFF) {
+ glow.x += c.x * weight * 0.05;
+ } else {
+ glow.x += c.x * weight * 0.10;
+ }
+ }
+ }
+ // float lightness_diff = clamp(glow.x - dest.x, 0.0, 1.0);
+ // dest.x = lightness_diff;
+ // dest.yz = dest.yz * (1.0 - lightness_diff) + glow.yz * lightness_diff;
+ dest.xyz += glow.xyz;
+ }
+
+ fragColor = toRgb(dest);
+}
diff --git a/ghostty/shaders/gradient-background.glsl b/ghostty/shaders/gradient-background.glsl
new file mode 100644
index 0000000..beae0cf
--- /dev/null
+++ b/ghostty/shaders/gradient-background.glsl
@@ -0,0 +1,25 @@
+// credits: https://github.com/unkn0wncode
+void mainImage(out vec4 fragColor, in vec2 fragCoord)
+{
+ // Normalize pixel coordinates (range from 0 to 1)
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ // Create a gradient from bottom right to top left as a function (x + y)/2
+ float gradientFactor = (uv.x + uv.y) / 2.0;
+
+ // Define gradient colors (adjust to your preference)
+ vec3 gradientStartColor = vec3(0.1, 0.1, 0.5); // Start color (e.g., dark blue)
+ vec3 gradientEndColor = vec3(0.5, 0.1, 0.1); // End color (e.g., dark red)
+
+ vec3 gradientColor = mix(gradientStartColor, gradientEndColor, gradientFactor);
+
+ // Sample the terminal screen texture including alpha channel
+ vec4 terminalColor = texture(iChannel0, uv);
+
+ // Make a mask that is 1.0 where the terminal content is not black
+ float mask = 1 - step(0.5, dot(terminalColor.rgb, vec3(1.0)));
+ vec3 blendedColor = mix(terminalColor.rgb, gradientColor, mask);
+
+ // Apply terminal's alpha to control overall opacity
+ fragColor = vec4(blendedColor, terminalColor.a);
+}
\ No newline at end of file
diff --git a/ghostty/shaders/inside-the-matrix.glsl b/ghostty/shaders/inside-the-matrix.glsl
new file mode 100644
index 0000000..6992069
--- /dev/null
+++ b/ghostty/shaders/inside-the-matrix.glsl
@@ -0,0 +1,413 @@
+/*
+ Feel free to do anything you want with this code.
+ This shader uses "runes" code by FabriceNeyret2 (https://www.shadertoy.com/view/4ltyDM)
+ which is based on "runes" by otaviogood (https://shadertoy.com/view/MsXSRn).
+ These random runes look good as matrix symbols and have acceptable performance.
+
+ @pkazmier modified this shader to work in Ghostty.
+*/
+
+const int ITERATIONS = 40; //use less value if you need more performance
+const float SPEED = .5;
+
+const float STRIP_CHARS_MIN = 7.;
+const float STRIP_CHARS_MAX = 40.;
+const float STRIP_CHAR_HEIGHT = 0.15;
+const float STRIP_CHAR_WIDTH = 0.10;
+const float ZCELL_SIZE = 1. * (STRIP_CHAR_HEIGHT * STRIP_CHARS_MAX); //the multiplier can't be less than 1.
+const float XYCELL_SIZE = 12. * STRIP_CHAR_WIDTH; //the multiplier can't be less than 1.
+
+const int BLOCK_SIZE = 10; //in cells
+const int BLOCK_GAP = 2; //in cells
+
+const float WALK_SPEED = 0.5 * XYCELL_SIZE;
+const float BLOCKS_BEFORE_TURN = 3.;
+
+
+const float PI = 3.14159265359;
+
+
+// ---- random ----
+
+float hash(float v) {
+ return fract(sin(v)*43758.5453123);
+}
+
+float hash(vec2 v) {
+ return hash(dot(v, vec2(5.3983, 5.4427)));
+}
+
+vec2 hash2(vec2 v)
+{
+ v = vec2(v * mat2(127.1, 311.7, 269.5, 183.3));
+ return fract(sin(v)*43758.5453123);
+}
+
+vec4 hash4(vec2 v)
+{
+ vec4 p = vec4(v * mat4x2( 127.1, 311.7,
+ 269.5, 183.3,
+ 113.5, 271.9,
+ 246.1, 124.6 ));
+ return fract(sin(p)*43758.5453123);
+}
+
+vec4 hash4(vec3 v)
+{
+ vec4 p = vec4(v * mat4x3( 127.1, 311.7, 74.7,
+ 269.5, 183.3, 246.1,
+ 113.5, 271.9, 124.6,
+ 271.9, 269.5, 311.7 ) );
+ return fract(sin(p)*43758.5453123);
+}
+
+
+// ---- symbols ----
+// Slightly modified version of "runes" by FabriceNeyret2 - https://www.shadertoy.com/view/4ltyDM
+// Which is based on "runes" by otaviogood - https://shadertoy.com/view/MsXSRn
+
+float rune_line(vec2 p, vec2 a, vec2 b) { // from https://www.shadertoy.com/view/4dcfW8
+ p -= a, b -= a;
+ float h = clamp(dot(p, b) / dot(b, b), 0., 1.); // proj coord on line
+ return length(p - b * h); // dist to segment
+}
+
+float rune(vec2 U, vec2 seed, float highlight)
+{
+ float d = 1e5;
+ for (int i = 0; i < 4; i++) // number of strokes
+ {
+ vec4 pos = hash4(seed);
+ seed += 1.;
+
+ // each rune touches the edge of its box on all 4 sides
+ if (i == 0) pos.y = .0;
+ if (i == 1) pos.x = .999;
+ if (i == 2) pos.x = .0;
+ if (i == 3) pos.y = .999;
+ // snap the random line endpoints to a grid 2x3
+ vec4 snaps = vec4(2, 3, 2, 3);
+ pos = ( floor(pos * snaps) + .5) / snaps;
+
+ if (pos.xy != pos.zw) //filter out single points (when start and end are the same)
+ d = min(d, rune_line(U, pos.xy, pos.zw + .001) ); // closest line
+ }
+ return smoothstep(0.1, 0., d) + highlight*smoothstep(0.4, 0., d);
+}
+
+float random_char(vec2 outer, vec2 inner, float highlight) {
+ vec2 seed = vec2(dot(outer, vec2(269.5, 183.3)), dot(outer, vec2(113.5, 271.9)));
+ return rune(inner, seed, highlight);
+}
+
+
+// ---- digital rain ----
+
+// xy - horizontal, z - vertical
+vec3 rain(vec3 ro3, vec3 rd3, float time) {
+ vec4 result = vec4(0.);
+
+ // normalized 2d projection
+ vec2 ro2 = vec2(ro3);
+ vec2 rd2 = normalize(vec2(rd3));
+
+ // we use formulas `ro3 + rd3 * t3` and `ro2 + rd2 * t2`, `t3_to_t2` is a multiplier to convert t3 to t2
+ bool prefer_dx = abs(rd2.x) > abs(rd2.y);
+ float t3_to_t2 = prefer_dx ? rd3.x / rd2.x : rd3.y / rd2.y;
+
+ // at first, horizontal space (xy) is divided into cells (which are columns in 3D)
+ // then each xy-cell is divided into vertical cells (along z) - each of these cells contains one raindrop
+
+ ivec3 cell_side = ivec3(step(0., rd3)); //for positive rd.x use cell side with higher x (1) as the next side, for negative - with lower x (0), the same for y and z
+ ivec3 cell_shift = ivec3(sign(rd3)); //shift to move to the next cell
+
+ // move through xy-cells in the ray direction
+ float t2 = 0.; // the ray formula is: ro2 + rd2 * t2, where t2 is positive as the ray has a direction.
+ ivec2 next_cell = ivec2(floor(ro2/XYCELL_SIZE)); //first cell index where ray origin is located
+ for (int i=0; i= t2s && tmin <= t2) {
+ float u = s.x * rd2.y - s.y * rd2.x; //horizontal coord in the matrix strip
+ if (abs(u) < target_rad) {
+ u = (u/target_rad + 1.) / 2.;
+ float z = ro3.z + rd3.z * tmin/t3_to_t2;
+ float v = (z - target_z) / target_length; //vertical coord in the matrix strip
+ if (v >= 0.0 && v < 1.0) {
+ float c = floor(v * chars_count); //symbol index relative to the start of the strip, with addition of char_z_shift it becomes an index relative to the whole cell
+ float q = fract(v * chars_count);
+ vec2 char_hash = hash2(vec2(c+char_z_shift, cell_hash2.x));
+ if (char_hash.x >= 0.1 || c == 0.) { //10% of missed symbols
+ float time_factor = floor(c == 0. ? time*5.0 : //first symbol is changed fast
+ time*(1.0*cell_hash2.z + //strips are changed sometime with different speed
+ cell_hash2.w*cell_hash2.w*4.*pow(char_hash.y, 4.))); //some symbols in some strips are changed relatively often
+ float a = random_char(vec2(char_hash.x, time_factor), vec2(u,q), max(1., 3. - c/2.)*0.2); //alpha
+ a *= clamp((chars_count - 0.5 - c) / 2., 0., 1.); //tail fade
+ if (a > 0.) {
+ float attenuation = 1. + pow(0.06*tmin/t3_to_t2, 2.);
+ vec3 col = (c == 0. ? vec3(0.67, 1.0, 0.82) : vec3(0.25, 0.80, 0.40)) / attenuation;
+ float a1 = result.a;
+ result.a = a1 + (1. - a1) * a;
+ result.xyz = (result.xyz * a1 + col * (1. - a1) * a) / result.a;
+ if (result.a > 0.98) return result.xyz;
+ }
+ }
+ }
+ }
+ }
+ // not found in this cell - go to next vertical cell
+ zcell += cell_shift.z;
+ }
+ // go to next horizontal cell
+ }
+
+ return result.xyz * result.a;
+}
+
+
+// ---- main, camera ----
+
+vec2 rotate(vec2 v, float a) {
+ float s = sin(a);
+ float c = cos(a);
+ mat2 m = mat2(c, -s, s, c);
+ return m * v;
+}
+
+vec3 rotateX(vec3 v, float a) {
+ float s = sin(a);
+ float c = cos(a);
+ return mat3(1.,0.,0.,0.,c,-s,0.,s,c) * v;
+}
+
+vec3 rotateY(vec3 v, float a) {
+ float s = sin(a);
+ float c = cos(a);
+ return mat3(c,0.,-s,0.,1.,0.,s,0.,c) * v;
+}
+
+vec3 rotateZ(vec3 v, float a) {
+ float s = sin(a);
+ float c = cos(a);
+ return mat3(c,-s,0.,s,c,0.,0.,0.,1.) * v;
+}
+
+float smoothstep1(float x) {
+ return smoothstep(0., 1., x);
+}
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+ if (STRIP_CHAR_WIDTH > XYCELL_SIZE || STRIP_CHAR_HEIGHT * STRIP_CHARS_MAX > ZCELL_SIZE) {
+ // error
+ fragColor = vec4(1., 0., 0., 1.);
+ return;
+ }
+
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ float time = iTime * SPEED;
+
+ const float turn_rad = 0.25 / BLOCKS_BEFORE_TURN; //0 .. 0.5
+ const float turn_abs_time = (PI/2.*turn_rad) * 1.5; //multiplier different than 1 means a slow down on turns
+ const float turn_time = turn_abs_time / (1. - 2.*turn_rad + turn_abs_time); //0..1, but should be <= 0.5
+
+ float level1_size = float(BLOCK_SIZE) * BLOCKS_BEFORE_TURN * XYCELL_SIZE;
+ float level2_size = 4. * level1_size;
+ float gap_size = float(BLOCK_GAP) * XYCELL_SIZE;
+
+ vec3 ro = vec3(gap_size/2., gap_size/2., 0.);
+ vec3 rd = vec3(uv.x, 2.0, uv.y);
+
+ float tq = fract(time / (level2_size*4.) * WALK_SPEED); //the whole cycle time counter
+ float t8 = fract(tq*4.); //time counter while walking on one of the four big sides
+ float t1 = fract(t8*8.); //time counter while walking on one of the eight sides of the big side
+
+ vec2 prev;
+ vec2 dir;
+ if (tq < 0.25) {
+ prev = vec2(0.,0.);
+ dir = vec2(0.,1.);
+ } else if (tq < 0.5) {
+ prev = vec2(0.,1.);
+ dir = vec2(1.,0.);
+ } else if (tq < 0.75) {
+ prev = vec2(1.,1.);
+ dir = vec2(0.,-1.);
+ } else {
+ prev = vec2(1.,0.);
+ dir = vec2(-1.,0.);
+ }
+ float angle = floor(tq * 4.); //0..4 wich means 0..2*PI
+
+ prev *= 4.;
+
+ const float first_turn_look_angle = 0.4;
+ const float second_turn_drift_angle = 0.5;
+ const float fifth_turn_drift_angle = 0.25;
+
+ vec2 turn;
+ float turn_sign = 0.;
+ vec2 dirL = rotate(dir, -PI/2.);
+ vec2 dirR = -dirL;
+ float up_down = 0.;
+ float rotate_on_turns = 1.;
+ float roll_on_turns = 1.;
+ float add_angel = 0.;
+ if (t8 < 0.125) {
+ turn = dirL;
+ //dir = dir;
+ turn_sign = -1.;
+ angle -= first_turn_look_angle * (max(0., t1 - (1. - turn_time*2.)) / turn_time - max(0., t1 - (1. - turn_time)) / turn_time * 2.5);
+ roll_on_turns = 0.;
+ } else if (t8 < 0.250) {
+ prev += dir;
+ turn = dir;
+ dir = dirL;
+ angle -= 1.;
+ turn_sign = 1.;
+ add_angel += first_turn_look_angle*0.5 + (-first_turn_look_angle*0.5+1.0+second_turn_drift_angle)*t1;
+ rotate_on_turns = 0.;
+ roll_on_turns = 0.;
+ } else if (t8 < 0.375) {
+ prev += dir + dirL;
+ turn = dirR;
+ //dir = dir;
+ turn_sign = 1.;
+ add_angel += second_turn_drift_angle*sqrt(1.-t1);
+ //roll_on_turns = 0.;
+ } else if (t8 < 0.5) {
+ prev += dir + dir + dirL;
+ turn = dirR;
+ dir = dirR;
+ angle += 1.;
+ turn_sign = 0.;
+ up_down = sin(t1*PI) * 0.37;
+ } else if (t8 < 0.625) {
+ prev += dir + dir;
+ turn = dir;
+ dir = dirR;
+ angle += 1.;
+ turn_sign = -1.;
+ up_down = sin(-min(1., t1/(1.-turn_time))*PI) * 0.37;
+ } else if (t8 < 0.750) {
+ prev += dir + dir + dirR;
+ turn = dirL;
+ //dir = dir;
+ turn_sign = -1.;
+ add_angel -= (fifth_turn_drift_angle + 1.) * smoothstep1(t1);
+ rotate_on_turns = 0.;
+ roll_on_turns = 0.;
+ } else if (t8 < 0.875) {
+ prev += dir + dir + dir + dirR;
+ turn = dir;
+ dir = dirL;
+ angle -= 1.;
+ turn_sign = 1.;
+ add_angel -= fifth_turn_drift_angle - smoothstep1(t1) * (fifth_turn_drift_angle * 2. + 1.);
+ rotate_on_turns = 0.;
+ roll_on_turns = 0.;
+ } else {
+ prev += dir + dir + dir;
+ turn = dirR;
+ //dir = dir;
+ turn_sign = 1.;
+ angle += fifth_turn_drift_angle * (1.5*min(1., (1.-t1)/turn_time) - 0.5*smoothstep1(1. - min(1.,t1/(1.-turn_time))));
+ }
+
+ if (iMouse.x > 10. || iMouse.y > 10.) {
+ vec2 mouse = iMouse.xy / iResolution.xy * 2. - 1.;
+ up_down = -0.7 * mouse.y;
+ angle += mouse.x;
+ rotate_on_turns = 1.;
+ roll_on_turns = 0.;
+ } else {
+ angle += add_angel;
+ }
+
+ rd = rotateX(rd, up_down);
+
+ vec2 p;
+ if (turn_sign == 0.) {
+ // move forward
+ p = prev + dir * (turn_rad + 1. * t1);
+ }
+ else if (t1 > (1. - turn_time)) {
+ // turn
+ float tr = (t1 - (1. - turn_time)) / turn_time;
+ vec2 c = prev + dir * (1. - turn_rad) + turn * turn_rad;
+ p = c + turn_rad * rotate(dir, (tr - 1.) * turn_sign * PI/2.);
+ angle += tr * turn_sign * rotate_on_turns;
+ rd = rotateY(rd, sin(tr*turn_sign*PI) * 0.2 * roll_on_turns); //roll
+ } else {
+ // move forward
+ t1 /= (1. - turn_time);
+ p = prev + dir * (turn_rad + (1. - turn_rad*2.) * t1);
+ }
+
+ rd = rotateZ(rd, angle * PI/2.);
+
+ ro.xy += level1_size * p;
+
+ ro += rd * 0.2;
+ rd = normalize(rd);
+
+ // vec3 col = rain(ro, rd, time);
+ vec3 col = rain(ro, rd, time) * 0.25;
+
+ // Sample the terminal screen texture including alpha channel
+ vec4 terminalColor = texture(iChannel0, uv);
+
+ // Combine the matrix effect with the terminal color
+ // vec3 blendedColor = terminalColor.rgb + col;
+
+ // Make a mask that is 1.0 where the terminal content is not black
+ float mask = 1.2 - step(0.5, dot(terminalColor.rgb, vec3(1.0)));
+ vec3 blendedColor = mix(terminalColor.rgb * 1.2, col, mask);
+
+ fragColor = vec4(blendedColor, terminalColor.a);
+}
diff --git a/ghostty/shaders/just-snow.glsl b/ghostty/shaders/just-snow.glsl
new file mode 100644
index 0000000..c72b7fd
--- /dev/null
+++ b/ghostty/shaders/just-snow.glsl
@@ -0,0 +1,52 @@
+// Copyright (c) 2013 Andrew Baldwin (twitter: baldand, www: http://thndl.com)
+// License = Attribution-NonCommercial-ShareAlike (http://creativecommons.org/licenses/by-nc-sa/3.0/deed.en_US)
+
+// "Just snow"
+// Simple (but not cheap) snow made from multiple parallax layers with randomly positioned
+// flakes and directions. Also includes a DoF effect. Pan around with mouse.
+
+#define LIGHT_SNOW // Comment this out for a blizzard
+
+#ifdef LIGHT_SNOW
+ #define LAYERS 50
+ #define DEPTH .5
+ #define WIDTH .3
+ #define SPEED .6
+#else // BLIZZARD
+ #define LAYERS 200
+ #define DEPTH .1
+ #define WIDTH .8
+ #define SPEED 1.5
+#endif
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+ const mat3 p = mat3(13.323122,23.5112,21.71123,21.1212,28.7312,11.9312,21.8112,14.7212,61.3934);
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ vec3 acc = vec3(0.0);
+ float dof = 5.0 * sin(iTime * 0.1);
+ for (int i = 0; i < LAYERS; i++) {
+ float fi = float(i);
+ vec2 q =-uv*(1.0 + fi * DEPTH);
+ q += vec2(q.y * (WIDTH * mod(fi * 7.238917, 1.0) - WIDTH * 0.5), -SPEED * iTime / (1.0 + fi * DEPTH * 0.03));
+ vec3 n = vec3(floor(q), 31.189 + fi);
+ vec3 m = floor(n) * 0.00001 + fract(n);
+ vec3 mp = (31415.9 + m) / fract(p * m);
+ vec3 r = fract(mp);
+ vec2 s = abs(mod(q, 1.0) - 0.5 + 0.9 * r.xy - 0.45);
+ s += 0.01 * abs(2.0 * fract(10.0 * q.yx) - 1.0);
+ float d = 0.6 * max(s.x - s.y, s.x + s.y) + max(s.x, s.y) - 0.01;
+ float edge = 0.005 + 0.05 * min(0.5 * abs(fi - 5.0 - dof), 1.0);
+ acc += vec3(smoothstep(edge, -edge, d) * (r.x / (1.0 + 0.02 * fi * DEPTH)));
+ }
+
+ // Sample the terminal screen texture including alpha channel
+ vec4 terminalColor = texture(iChannel0, uv);
+
+ // Combine the snow effect with the terminal color
+ vec3 blendedColor = terminalColor.rgb + acc;
+
+ // Use the terminal's original alpha
+ fragColor = vec4(blendedColor, terminalColor.a);
+}
diff --git a/ghostty/shaders/matrix-hallway.glsl b/ghostty/shaders/matrix-hallway.glsl
new file mode 100644
index 0000000..2bbee86
--- /dev/null
+++ b/ghostty/shaders/matrix-hallway.glsl
@@ -0,0 +1,40 @@
+// based on the following Shader Toy entry
+//
+// [SH17A] Matrix rain. Created by Reinder Nijhoff 2017
+// Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
+// @reindernijhoff
+//
+// https://www.shadertoy.com/view/ldjBW1
+//
+
+#define SPEED_MULTIPLIER 1.
+#define GREEN_ALPHA .33
+
+#define BLACK_BLEND_THRESHOLD .4
+
+#define R fract(1e2 * sin(p.x * 8. + p.y))
+
+void mainImage(out vec4 fragColor, vec2 fragCoord) {
+ vec3 v = vec3(fragCoord, 1) / iResolution - .5;
+ // vec3 s = .5 / abs(v);
+ // scale?
+ vec3 s = .9 / abs(v);
+ s.z = min(s.y, s.x);
+ vec3 i = ceil( 8e2 * s.z * ( s.y < s.x ? v.xzz : v.zyz ) ) * .1;
+ vec3 j = fract(i);
+ i -= j;
+ vec3 p = vec3(9, int(iTime * SPEED_MULTIPLIER * (9. + 8. * sin(i).x)), 0) + i;
+ vec3 col = fragColor.rgb;
+ col.g = R / s.z;
+ p *= j;
+ col *= (R >.5 && j.x < .6 && j.y < .8) ? GREEN_ALPHA : 0.;
+
+ // Sample the terminal screen texture including alpha channel
+ vec2 uv = fragCoord.xy / iResolution.xy;
+ vec4 terminalColor = texture(iChannel0, uv);
+
+ float alpha = step(length(terminalColor.rgb), BLACK_BLEND_THRESHOLD);
+ vec3 blendedColor = mix(terminalColor.rgb * 1.2, col, alpha);
+
+ fragColor = vec4(blendedColor, terminalColor.a);
+}
diff --git a/ghostty/shaders/negative.glsl b/ghostty/shaders/negative.glsl
new file mode 100644
index 0000000..48101f6
--- /dev/null
+++ b/ghostty/shaders/negative.glsl
@@ -0,0 +1,8 @@
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+ vec2 uv = fragCoord/iResolution.xy;
+ vec4 color = texture(iChannel0, uv);
+ fragColor = vec4(1.0 - color.x, 1.0 - color.y, 1.0 - color.z, color.w);
+}
+
diff --git a/ghostty/shaders/retro-terminal.glsl b/ghostty/shaders/retro-terminal.glsl
new file mode 100644
index 0000000..c5f315a
--- /dev/null
+++ b/ghostty/shaders/retro-terminal.glsl
@@ -0,0 +1,34 @@
+// Original shader collected from: https://www.shadertoy.com/view/WsVSzV
+// Licensed under Shadertoy's default since the original creator didn't provide any license. (CC BY NC SA 3.0)
+// Slight modifications were made to give a green-ish effect.
+
+float warp = 0.25; // simulate curvature of CRT monitor
+float scan = 0.50; // simulate darkness between scanlines
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord)
+{
+ // squared distance from center
+ vec2 uv = fragCoord / iResolution.xy;
+ vec2 dc = abs(0.5 - uv);
+ dc *= dc;
+
+ // warp the fragment coordinates
+ uv.x -= 0.5; uv.x *= 1.0 + (dc.y * (0.3 * warp)); uv.x += 0.5;
+ uv.y -= 0.5; uv.y *= 1.0 + (dc.x * (0.4 * warp)); uv.y += 0.5;
+
+ // sample inside boundaries, otherwise set to black
+ if (uv.y > 1.0 || uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0)
+ fragColor = vec4(0.0, 0.0, 0.0, 1.0);
+ else
+ {
+ // determine if we are drawing in a scanline
+ float apply = abs(sin(fragCoord.y) * 0.5 * scan);
+
+ // sample the texture and apply a teal tint
+ vec3 color = texture(iChannel0, uv).rgb;
+ vec3 tealTint = vec3(0.0, 0.8, 0.6); // teal color (slightly more green than blue)
+
+ // mix the sampled color with the teal tint based on scanline intensity
+ fragColor = vec4(mix(color * tealTint, vec3(0.0), apply), 1.0);
+ }
+}
diff --git a/ghostty/shaders/ripple_cursor.glsl b/ghostty/shaders/ripple_cursor.glsl
new file mode 100644
index 0000000..30a14cf
--- /dev/null
+++ b/ghostty/shaders/ripple_cursor.glsl
@@ -0,0 +1,132 @@
+// CONFIGURATION
+const float DURATION = 0.15; // How long the ripple animates (seconds)
+const float MAX_RADIUS = 0.05; // Max radius in normalized coords (0.5 = 1/4 screen height)
+const float RING_THICKNESS = 0.02; // Ring width in normalized coords
+const float CURSOR_WIDTH_CHANGE_THRESHOLD = 0.5; // Triggers ripple if cursor width changes by this fraction
+vec4 COLOR = iCurrentCursor; // change to iCurrentCursorColor for your cursor's color
+const float BLUR = 3.0; // Blur level in pixels
+const float ANIMATION_START_OFFSET = 0.0; // Start the ripple slightly progressed (0.0 - 1.0)
+
+
+// Easing functions
+float easeOutQuad(float t) {
+ return 1.0 - (1.0 - t) * (1.0 - t);
+}
+float easeInOutQuad(float t) {
+ return t < 0.5 ? 2.0 * t * t : 1.0 - pow(-2.0 * t + 2.0, 2.0) / 2.0;
+}
+float easeOutCubic(float t) {
+ return 1.0 - pow(1.0 - t, 3.0);
+}
+float easeOutQuart(float t) {
+ return 1.0 - pow(1.0 - t, 4.0);
+}
+float easeOutQuint(float t) {
+ return 1.0 - pow(1.0 - t, 5.0);
+}
+float easeOutExpo(float t) {
+ return t == 1.0 ? 1.0 : 1.0 - pow(2.0, -10.0 * t);
+}
+float easeOutCirc(float t) {
+ return sqrt(1.0 - pow(t - 1.0, 2.0));
+}
+float easeOutSine(float t) {
+ return sin((t * 3.1415916) / 2.0);
+}
+float easeOutElastic(float t) {
+ const float c4 = (2.0 * 3.1415916) / 3.0;
+ return t == 0.0 ? 0.0 : t == 1.0 ? 1.0 : pow(2.0, -10.0 * t) * sin((t * 10.0 - 0.75) * c4) + 1.0;
+}
+float easeOutBounce(float t) {
+ const float n1 = 7.5625;
+ const float d1 = 2.75;
+ if (t < 1.0 / d1) {
+ return n1 * t * t;
+ } else if (t < 2.0 / d1) {
+ return n1 * (t -= 1.5 / d1) * t + 0.75;
+ } else if (t < 2.5 / d1) {
+ return n1 * (t -= 2.25 / d1) * t + 0.9375;
+ } else {
+ return n1 * (t -= 2.625 / d1) * t + 0.984375;
+ }
+}
+float easeOutBack(float t) {
+ const float c1 = 1.70158;
+ const float c3 = c1 + 1.0;
+ return 1.0 + c3 * pow(t - 1.0, 3.0) + c1 * pow(t - 1.0, 2.0);
+}
+
+// Pulse fade functions
+float easeOutPulse(float t) {
+ return t * (2.0 - t);
+}
+float exponentialDecayPulse(float t) {
+ return exp(-3.0 * t) * sin(t * 3.1415916);
+}
+
+vec2 normalize(vec2 value, float isPosition) {
+ return (value * 2.0 - (iResolution.xy * isPosition)) / iResolution.y;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord){
+ #if !defined(WEB)
+ fragColor = texture(iChannel0, fragCoord.xy / iResolution.xy);
+ #endif
+
+ // Normalization & setup (-1 to 1 coords)
+ vec2 vu = normalize(fragCoord, 1.);
+ vec2 offsetFactor = vec2(-.5, 0.5);
+
+ vec4 currentCursor = vec4(normalize(iCurrentCursor.xy, 1.), normalize(iCurrentCursor.zw, 0.));
+ vec4 previousCursor = vec4(normalize(iPreviousCursor.xy, 1.), normalize(iPreviousCursor.zw, 0.));
+
+ vec2 centerCC = currentCursor.xy - (currentCursor.zw * offsetFactor);
+
+ float cellWidth = max(currentCursor.z, previousCursor.z); // width of the 'block' cursor
+
+ // check for significant width change
+ float widthChange = abs(currentCursor.z - previousCursor.z);
+ float widthThresholdNorm = cellWidth * CURSOR_WIDTH_CHANGE_THRESHOLD;
+ float isModeChange = step(widthThresholdNorm, widthChange);
+
+
+ // ANIMATION
+ float rippleProgress = (iTime - iTimeCursorChange) / DURATION + ANIMATION_START_OFFSET;
+ // don't clamp yet; we need to know if it's > 1.0 (finished)
+ float isAnimating = 1.0 - step(1.0, rippleProgress); // progress < 1.0 ? 1.0: 0.0
+
+ if (isModeChange > 0.0 && isAnimating > 0.0) {
+ // Apply easing to progress
+ // float easedProgress = rippleProgress;
+ // float easedProgress = easeOutQuad(rippleProgress);
+ // float easedProgress = easeInOutQuad(rippleProgress);
+ // float easedProgress = easeOutCubic(rippleProgress);
+ // float easedProgress = easeOutQuart(rippleProgress);
+ // float easedProgress = easeOutQuint(rippleProgress);
+ // float easedProgress = easeOutExpo(rippleProgress);
+ float easedProgress = easeOutCirc(rippleProgress);
+ // float easedProgress = easeOutSine(rippleProgress);
+ // float easedProgress = easeOutBack(rippleProgress);
+
+ // RIPPLE CALCULATION
+ float rippleRadius = easedProgress * MAX_RADIUS;
+
+ // float fade = 1.0; // no fade
+ // float fade = 1.0 - easedProgress; // linear fade
+ float fade = 1.0 - easeOutPulse(rippleProgress);
+ // float fade = 1.0 - exponentialDecayPulse(rippleProgress);
+
+ // Calculate distance from frag to cursor center
+ float dist = distance(vu, centerCC);
+
+ float sdfRing = abs(dist - rippleRadius) - RING_THICKNESS * 0.5;
+
+ // Antialias (1-pixel width in normalized coords)
+ float antiAliasSize = normalize(vec2(BLUR, BLUR), 0.0).x;
+ float ripple = (1.0 - smoothstep(-antiAliasSize, antiAliasSize, sdfRing)) * fade;
+
+ // Apply ripple effect
+ fragColor = mix(fragColor, COLOR, ripple * COLOR.a);
+ }
+ // else: do nothing, keep original fragColor
+}
diff --git a/ghostty/shaders/smoke-and-ghost.glsl b/ghostty/shaders/smoke-and-ghost.glsl
new file mode 100644
index 0000000..a11f8dc
--- /dev/null
+++ b/ghostty/shaders/smoke-and-ghost.glsl
@@ -0,0 +1,193 @@
+// Settings for detection
+#define TARGET_COLOR vec3(0.0, 0.0, 0.0) // RGB target pixels to transform
+#define REPLACE_COLOR vec3(0.0, 0.0, 0.0) // Color to replace target pixels
+#define COLOR_TOLERANCE 0.001 // Color matching tolerance
+
+// Smoke effect settings
+#define SMOKE_COLOR vec3(1., 1., 1.0) // Base color of smoke
+#define SMOKE_RADIUS 0.011 // How far the smoke spreads
+#define SMOKE_SPEED 0.5 // Speed of smoke movement
+#define SMOKE_SCALE 25.0 // Scale of smoke detail
+#define SMOKE_INTENSITY 0.2 // Intensity of the smoke effect
+#define SMOKE_RISE_HEIGHT 0.14 // How high the smoke rises
+#define ALPHA_MAX 0.5 // Maximum opacity for smoke
+#define VERTICAL_BIAS 1.0
+
+// Ghost face settings
+#define FACE_COUNT 1 // Number of ghost faces
+#define FACE_SCALE vec2(0.03, 0.05) // Size of faces, can be wider/elongated
+#define FACE_DURATION 1.2 // How long faces last, can be wider/elongated
+#define FACE_TRANSITION 1.5 // Face fade in/out duration
+#define FACE_COLOR vec3(0.0, 0.0, 0.0)
+#define GHOST_BG_COLOR vec3(1.0, 1.0, 1.0)
+#define GHOST_BG_SCALE vec2(0.03, 0.06)
+
+float random(vec2 st) {
+ return fract(sin(dot(st.xy, vec2(12.9898,78.233))) * 43758.5453123);
+}
+
+float random1(float n) {
+ return fract(sin(n) * 43758.5453123);
+}
+
+vec2 random2(float n) {
+ return vec2(
+ random1(n),
+ random1(n + 1234.5678)
+ );
+}
+
+float noise(vec2 st) {
+ vec2 i = floor(st);
+ vec2 f = fract(st);
+
+ float a = random(i);
+ float b = random(i + vec2(1.0, 0.0));
+ float c = random(i + vec2(0.0, 1.0));
+ float d = random(i + vec2(1.0, 1.0));
+
+ vec2 u = f * f * (3.0 - 2.0 * f);
+ return mix(a, b, u.x) + (c - a)* u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
+}
+
+// Modified elongated ellipse for more cartoon-like shapes
+float cartoonEllipse(vec2 uv, vec2 center, vec2 scale) {
+ vec2 d = (uv - center) / scale;
+ float len = length(d);
+ // Add cartoon-like falloff
+ return smoothstep(1.0, 0.8, len);
+}
+
+// Function to create ghost background shape
+float ghostBackground(vec2 uv, vec2 center) {
+ vec2 d = (uv - center) / GHOST_BG_SCALE;
+ float baseShape = length(d * vec2(1.0, 0.8)); // Slightly oval
+
+ // Add wavy bottom
+ float wave = sin(d.x * 6.28 + iTime) * 0.2;
+ float bottomWave = smoothstep(0.0, -0.5, d.y + wave);
+
+ return smoothstep(1.0, 0.8, baseShape) + bottomWave;
+}
+
+float ghostFace(vec2 uv, vec2 center, float time, float seed) {
+ vec2 faceUV = (uv - center) / FACE_SCALE;
+
+ float eyeSize = 0.25 + random1(seed) * 0.05;
+ float eyeSpacing = 0.35;
+ vec2 leftEyePos = vec2(-eyeSpacing, 0.2);
+ vec2 rightEyePos = vec2(eyeSpacing, 0.2);
+
+ float leftEye = cartoonEllipse(faceUV, leftEyePos, vec2(eyeSize));
+ float rightEye = cartoonEllipse(faceUV, rightEyePos, vec2(eyeSize));
+
+ // Add simple eye highlights
+ float leftHighlight = cartoonEllipse(faceUV, leftEyePos + vec2(0.1, 0.1), vec2(eyeSize * 0.3));
+ float rightHighlight = cartoonEllipse(faceUV, rightEyePos + vec2(0.1, 0.1), vec2(eyeSize * 0.3));
+
+ vec2 mouthUV = faceUV - vec2(0.0, -0.9);
+ float mouthWidth = 0.5 + random1(seed + 3.0) * 0.1;
+ float mouthHeight = 0.8 + random1(seed + 7.0) * 0.1;
+
+ float mouth = cartoonEllipse(mouthUV, vec2(0.0), vec2(mouthWidth, mouthHeight));
+
+ // Combine features
+ float face = max(max(leftEye, rightEye), mouth);
+ face = max(face, max(leftHighlight, rightHighlight));
+
+ // Add border falloff
+ face *= smoothstep(1.2, 0.8, length(faceUV));
+
+ return face;
+}
+
+float calculateSmoke(vec2 uv, vec2 sourcePos) {
+ float verticalDisp = (uv.y - sourcePos.y) * VERTICAL_BIAS;
+ vec2 smokeUV = uv * SMOKE_SCALE;
+ smokeUV.y -= iTime * SMOKE_SPEED * (1.0 + verticalDisp);
+ smokeUV.x += sin(iTime * 0.5 + uv.y * 4.0) * 0.1;
+
+ float n = noise(smokeUV) * 0.5 + 0.5;
+ n += noise(smokeUV * 2.0 + iTime * 0.1) * 0.25;
+
+ float verticalFalloff = 1.0 - smoothstep(0.0, SMOKE_RISE_HEIGHT, verticalDisp);
+ return n * verticalFalloff;
+}
+
+float isTargetPixel(vec2 uv) {
+ vec4 color = texture(iChannel0, uv);
+ return float(all(lessThan(abs(color.rgb - TARGET_COLOR), vec3(COLOR_TOLERANCE))));
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+ vec2 uv = fragCoord/iResolution.xy;
+ vec4 originalColor = texture(iChannel0, uv);
+
+ // Calculate smoke effect
+ float smokeAccum = 0.0;
+ float targetInfluence = 0.0;
+
+ float stepSize = SMOKE_RADIUS / 4.0;
+ for (float x = -SMOKE_RADIUS; x <= SMOKE_RADIUS; x += stepSize) {
+ for (float y = -SMOKE_RADIUS; y <= 0.0; y += stepSize) {
+ vec2 offset = vec2(x, y);
+ vec2 sampleUV = uv + offset;
+
+ if (sampleUV.x >= 0.0 && sampleUV.x <= 1.0 &&
+ sampleUV.y >= 0.0 && sampleUV.y <= 1.0) {
+ float isTarget = isTargetPixel(sampleUV);
+ if (isTarget > 0.0) {
+ float dist = length(offset);
+ float falloff = 1.0 - smoothstep(0.0, SMOKE_RADIUS, dist);
+ float smoke = calculateSmoke(uv, sampleUV);
+ smokeAccum += smoke * falloff;
+ targetInfluence += falloff;
+ }
+ }
+ }
+ }
+
+ smokeAccum /= max(targetInfluence, 1.0);
+ targetInfluence = smoothstep(0.0, 1.0, targetInfluence);
+ float smokePresence = smokeAccum * targetInfluence;
+
+ // Calculate ghost faces with backgrounds
+ float faceAccum = 0.0;
+ float bgAccum = 0.0;
+ float timeBlock = floor(iTime / FACE_DURATION);
+
+ if (smokePresence > 0.2) {
+ for (int i = 0; i < FACE_COUNT; i++) {
+ vec2 facePos = random2(timeBlock + float(i) * 1234.5);
+ facePos = facePos * 0.8 + 0.1;
+
+ float faceTime = mod(iTime, FACE_DURATION);
+ float fadeFactor = smoothstep(0.0, FACE_TRANSITION, faceTime) *
+ (1.0 - smoothstep(FACE_DURATION - FACE_TRANSITION, FACE_DURATION, faceTime));
+
+ // Add ghost background
+ float ghostBg = ghostBackground(uv, facePos) * fadeFactor;
+ bgAccum = max(bgAccum, ghostBg);
+
+ // Add face features
+ float face = ghostFace(uv, facePos, iTime, timeBlock + float(i) * 100.0) * fadeFactor;
+ faceAccum = max(faceAccum, face);
+ }
+
+ bgAccum *= smoothstep(0.2, 0.4, smokePresence);
+ faceAccum *= smoothstep(0.2, 0.4, smokePresence);
+ }
+
+ // Combine all elements
+ bool isTarget = all(lessThan(abs(originalColor.rgb - TARGET_COLOR), vec3(COLOR_TOLERANCE)));
+ vec3 baseColor = isTarget ? REPLACE_COLOR : originalColor.rgb;
+
+ // Layer the effects: base -> smoke -> ghost background -> face features
+ vec3 smokeEffect = mix(baseColor, SMOKE_COLOR, smokeAccum * SMOKE_INTENSITY * targetInfluence * (1.0 - faceAccum));
+ vec3 withBackground = mix(smokeEffect, GHOST_BG_COLOR, bgAccum * 0.7);
+ vec3 finalColor = mix(withBackground, FACE_COLOR, faceAccum);
+
+ float alpha = mix(originalColor.a, ALPHA_MAX, max(smokePresence, max(bgAccum, faceAccum) * smokePresence));
+
+ fragColor = vec4(finalColor, alpha);
+}
diff --git a/ghostty/shaders/sparks-from-fire.glsl b/ghostty/shaders/sparks-from-fire.glsl
new file mode 100644
index 0000000..e48b6e1
--- /dev/null
+++ b/ghostty/shaders/sparks-from-fire.glsl
@@ -0,0 +1,242 @@
+// adapted by Alex Sherwin for Ghstty from https://www.shadertoy.com/view/wl2Gzc
+
+//Shader License: CC BY 3.0
+//Author: Jan Mróz (jaszunio15)
+
+#define SMOKE_INTENSITY_MULTIPLIER 0.9
+#define PARTICLES_ALPHA_MOD 0.9
+#define SMOKE_ALPHA_MOD 0.5
+#define LAYERS_COUNT 8
+
+#define BLACK_BLEND_THRESHOLD .4
+
+#define VEC3_1 (vec3(1.0))
+
+#define PI 3.1415927
+#define TWO_PI 6.283185
+
+#define ANIMATION_SPEED 1.0
+#define MOVEMENT_SPEED .33
+#define MOVEMENT_DIRECTION vec2(0.7, 1.0)
+
+#define PARTICLE_SIZE 0.0025
+
+#define PARTICLE_SCALE (vec2(0.5, 1.6))
+#define PARTICLE_SCALE_VAR (vec2(0.25, 0.2))
+
+#define PARTICLE_BLOOM_SCALE (vec2(0.5, 0.8))
+#define PARTICLE_BLOOM_SCALE_VAR (vec2(0.3, 0.1))
+
+#define SPARK_COLOR vec3(1.0, 0.4, 0.05) * 1.5
+#define BLOOM_COLOR vec3(1.0, 0.4, 0.05) * 0.8
+#define SMOKE_COLOR vec3(1.0, 0.43, 0.1) * 0.8
+
+#define SIZE_MOD 1.05
+
+
+float hash1_2(in vec2 x)
+{
+ return fract(sin(dot(x, vec2(52.127, 61.2871))) * 521.582);
+}
+
+vec2 hash2_2(in vec2 x)
+{
+ return fract(sin(x * mat2x2(20.52, 24.1994, 70.291, 80.171)) * 492.194);
+}
+
+//Simple interpolated noise
+vec2 noise2_2(vec2 uv)
+{
+ //vec2 f = fract(uv);
+ vec2 f = smoothstep(0.0, 1.0, fract(uv));
+
+ vec2 uv00 = floor(uv);
+ vec2 uv01 = uv00 + vec2(0,1);
+ vec2 uv10 = uv00 + vec2(1,0);
+ vec2 uv11 = uv00 + 1.0;
+ vec2 v00 = hash2_2(uv00);
+ vec2 v01 = hash2_2(uv01);
+ vec2 v10 = hash2_2(uv10);
+ vec2 v11 = hash2_2(uv11);
+
+ vec2 v0 = mix(v00, v01, f.y);
+ vec2 v1 = mix(v10, v11, f.y);
+ vec2 v = mix(v0, v1, f.x);
+
+ return v;
+}
+
+//Simple interpolated noise
+float noise1_2(in vec2 uv)
+{
+ vec2 f = fract(uv);
+ //vec2 f = smoothstep(0.0, 1.0, fract(uv));
+
+ vec2 uv00 = floor(uv);
+ vec2 uv01 = uv00 + vec2(0,1);
+ vec2 uv10 = uv00 + vec2(1,0);
+ vec2 uv11 = uv00 + 1.0;
+
+ float v00 = hash1_2(uv00);
+ float v01 = hash1_2(uv01);
+ float v10 = hash1_2(uv10);
+ float v11 = hash1_2(uv11);
+
+ float v0 = mix(v00, v01, f.y);
+ float v1 = mix(v10, v11, f.y);
+ float v = mix(v0, v1, f.x);
+
+ return v;
+}
+
+
+float layeredNoise1_2(in vec2 uv, in float sizeMod, in float alphaMod, in int layers, in float animation)
+{
+ float noise = 0.0;
+ float alpha = 1.0;
+ float size = 1.0;
+ vec2 offset;
+ for (int i = 0; i < layers; i++)
+ {
+ offset += hash2_2(vec2(alpha, size)) * 10.0;
+
+ //Adding noise with movement
+ noise += noise1_2(uv * size + iTime * animation * 8.0 * MOVEMENT_DIRECTION * MOVEMENT_SPEED + offset) * alpha;
+ alpha *= alphaMod;
+ size *= sizeMod;
+ }
+
+ noise *= (1.0 - alphaMod)/(1.0 - pow(alphaMod, float(layers)));
+ return noise;
+}
+
+//Rotates point around 0,0
+vec2 rotate(in vec2 point, in float deg)
+{
+ float s = sin(deg);
+ float c = cos(deg);
+ return mat2x2(s, c, -c, s) * point;
+}
+
+//Cell center from point on the grid
+vec2 voronoiPointFromRoot(in vec2 root, in float deg)
+{
+ vec2 point = hash2_2(root) - 0.5;
+ float s = sin(deg);
+ float c = cos(deg);
+ point = mat2x2(s, c, -c, s) * point * 0.66;
+ point += root + 0.5;
+ return point;
+}
+
+//Voronoi cell point rotation degrees
+float degFromRootUV(in vec2 uv)
+{
+ return iTime * ANIMATION_SPEED * (hash1_2(uv) - 0.5) * 2.0;
+}
+
+vec2 randomAround2_2(in vec2 point, in vec2 range, in vec2 uv)
+{
+ return point + (hash2_2(uv) - 0.5) * range;
+}
+
+
+vec3 fireParticles(in vec2 uv, in vec2 originalUV)
+{
+ vec3 particles = vec3(0.0);
+ vec2 rootUV = floor(uv);
+ float deg = degFromRootUV(rootUV);
+ vec2 pointUV = voronoiPointFromRoot(rootUV, deg);
+ float dist = 2.0;
+ float distBloom = 0.0;
+
+ //UV manipulation for the faster particle movement
+ vec2 tempUV = uv + (noise2_2(uv * 2.0) - 0.5) * 0.1;
+ tempUV += -(noise2_2(uv * 3.0 + iTime) - 0.5) * 0.07;
+
+ //Sparks sdf
+ dist = length(rotate(tempUV - pointUV, 0.7) * randomAround2_2(PARTICLE_SCALE, PARTICLE_SCALE_VAR, rootUV));
+
+ //Bloom sdf
+ distBloom = length(rotate(tempUV - pointUV, 0.7) * randomAround2_2(PARTICLE_BLOOM_SCALE, PARTICLE_BLOOM_SCALE_VAR, rootUV));
+
+ //Add sparks
+ particles += (1.0 - smoothstep(PARTICLE_SIZE * 0.6, PARTICLE_SIZE * 3.0, dist)) * SPARK_COLOR;
+
+ //Add bloom
+ particles += pow((1.0 - smoothstep(0.0, PARTICLE_SIZE * 6.0, distBloom)) * 1.0, 3.0) * BLOOM_COLOR;
+
+ //Upper disappear curve randomization
+ float border = (hash1_2(rootUV) - 0.5) * 2.0;
+ float disappear = 1.0 - smoothstep(border, border + 0.5, originalUV.y);
+
+ //Lower appear curve randomization
+ border = (hash1_2(rootUV + 0.214) - 1.8) * 0.7;
+ float appear = smoothstep(border, border + 0.4, originalUV.y);
+
+ return particles * disappear * appear;
+}
+
+
+//Layering particles to imitate 3D view
+vec3 layeredParticles(in vec2 uv, in float sizeMod, in float alphaMod, in int layers, in float smoke)
+{
+ vec3 particles = vec3(0);
+ float size = 1.0;
+ // float alpha = 1.0;
+ float alpha = 1.0;
+ vec2 offset = vec2(0.0);
+ vec2 noiseOffset;
+ vec2 bokehUV;
+
+ for (int i = 0; i < layers; i++)
+ {
+ //Particle noise movement
+ noiseOffset = (noise2_2(uv * size * 2.0 + 0.5) - 0.5) * 0.15;
+
+ //UV with applied movement
+ bokehUV = (uv * size + iTime * MOVEMENT_DIRECTION * MOVEMENT_SPEED) + offset + noiseOffset;
+
+ //Adding particles if there is more smoke, remove smaller particles
+ particles += fireParticles(bokehUV, uv) * alpha * (1.0 - smoothstep(0.0, 1.0, smoke) * (float(i) / float(layers)));
+
+ //Moving uv origin to avoid generating the same particles
+ offset += hash2_2(vec2(alpha, alpha)) * 10.0;
+
+ alpha *= alphaMod;
+ size *= sizeMod;
+ }
+
+ return particles;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+ vec2 uv = (2.0 * fragCoord - iResolution.xy) / iResolution.x;
+
+ // float vignette = 1.1 - smoothstep(0.4, 1.4, length(uv + vec2(0.0, 0.3)));
+ float vignette = 1.3 - smoothstep(0.4, 1.4, length(uv + vec2(0.0, 0.3)));
+
+ uv *= 2.5;
+
+ float smokeIntensity = layeredNoise1_2(uv * 10.0 + iTime * 4.0 * MOVEMENT_DIRECTION * MOVEMENT_SPEED, 1.7, 0.7, 6, 0.2);
+ smokeIntensity *= pow(smoothstep(-1.0, 1.6, uv.y), 2.0);
+ vec3 smoke = smokeIntensity * SMOKE_COLOR * vignette * SMOKE_INTENSITY_MULTIPLIER * SMOKE_ALPHA_MOD;
+
+ //Cutting holes in smoke
+ smoke *= pow(layeredNoise1_2(uv * 4.0 + iTime * 0.5 * MOVEMENT_DIRECTION * MOVEMENT_SPEED, 1.8, 0.5, 3, 0.2), 2.0) * 1.5;
+
+ vec3 particles = layeredParticles(uv, SIZE_MOD, PARTICLES_ALPHA_MOD, LAYERS_COUNT, smokeIntensity);
+
+ vec3 col = particles + smoke + SMOKE_COLOR * 0.02;
+ col *= vignette;
+
+ col = smoothstep(-0.08, 1.0, col);
+
+ vec2 termUV = fragCoord.xy / iResolution.xy;
+ vec4 terminalColor = texture(iChannel0, termUV);
+
+ float alpha = step(length(terminalColor.rgb), BLACK_BLEND_THRESHOLD);
+ vec3 blendedColor = mix(terminalColor.rgb, col, alpha);
+
+ fragColor = vec4(blendedColor, terminalColor.a);
+}
diff --git a/ghostty/shaders/spotlight.glsl b/ghostty/shaders/spotlight.glsl
new file mode 100644
index 0000000..19f457a
--- /dev/null
+++ b/ghostty/shaders/spotlight.glsl
@@ -0,0 +1,42 @@
+// Created by Paul Robello
+
+
+// Smooth oscillating function that varies over time
+float smoothOscillation(float t, float frequency, float phase) {
+ return sin(t * frequency + phase);
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+ // Resolution and UV coordinates
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ // Used to fix distortion when calculating distance to circle center
+ vec2 ratio = vec2(iResolution.x / iResolution.y, 1.0);
+
+ // Get the texture from iChannel0
+ vec4 texColor = texture(iChannel0, uv);
+
+ // Spotlight center moving based on a smooth random pattern
+ float time = iTime * 1.0; // Control speed of motion
+ vec2 spotlightCenter = vec2(
+ 0.5 + 0.4 * smoothOscillation(time, 1.0, 0.0), // Smooth X motion
+ 0.5 + 0.4 * smoothOscillation(time, 1.3, 3.14159) // Smooth Y motion with different frequency and phase
+ );
+
+ // Distance from the spotlight center
+ float distanceToCenter = distance(uv * ratio, spotlightCenter);
+
+ // Spotlight intensity based on distance
+ float spotlightRadius = 0.25; // Spotlight radius
+ float softness = 20.0; // Spotlight edge softness. Higher values have sharper edge
+ float spotlightIntensity = smoothstep(spotlightRadius, spotlightRadius - (1.0 / softness), distanceToCenter);
+
+ // Ambient light level
+ float ambientLight = 0.5; // Controls the minimum brightness across the texture
+
+ // Combine the spotlight effect with the texture
+ vec3 spotlightEffect = texColor.rgb * mix(vec3(ambientLight), vec3(1.0), spotlightIntensity);
+
+ // Final color output
+ fragColor = vec4(spotlightEffect, texColor.a);
+}
\ No newline at end of file
diff --git a/ghostty/shaders/starfield-colors.glsl b/ghostty/shaders/starfield-colors.glsl
new file mode 100644
index 0000000..cf125a9
--- /dev/null
+++ b/ghostty/shaders/starfield-colors.glsl
@@ -0,0 +1,145 @@
+// divisions of grid
+const float repeats = 30.;
+
+// number of layers
+const float layers = 21.;
+
+// star colours
+const vec3 blue = vec3(51.,64.,195.)/255.;
+const vec3 cyan = vec3(117.,250.,254.)/255.;
+const vec3 white = vec3(255.,255.,255.)/255.;
+const vec3 yellow = vec3(251.,245.,44.)/255.;
+const vec3 red = vec3(247,2.,20.)/255.;
+
+// spectrum function
+vec3 spectrum(vec2 pos){
+ pos.x *= 4.;
+ vec3 outCol = vec3(0);
+ if( pos.x > 0.){
+ outCol = mix(blue, cyan, fract(pos.x));
+ }
+ if( pos.x > 1.){
+ outCol = mix(cyan, white, fract(pos.x));
+ }
+ if( pos.x > 2.){
+ outCol = mix(white, yellow, fract(pos.x));
+ }
+ if( pos.x > 3.){
+ outCol = mix(yellow, red, fract(pos.x));
+ }
+
+ return 1.-(pos.y * (1.-outCol));
+}
+
+float N21(vec2 p) {
+ p = fract(p * vec2(233.34, 851.73));
+ p += dot(p, p + 23.45);
+ return fract(p.x * p.y);
+}
+
+vec2 N22(vec2 p) {
+ float n = N21(p);
+ return vec2(n, N21(p + n));
+}
+
+mat2 scale(vec2 _scale) {
+ return mat2(_scale.x, 0.0,
+ 0.0, _scale.y);
+}
+
+// 2D Noise based on Morgan McGuire
+float noise(in vec2 st) {
+ vec2 i = floor(st);
+ vec2 f = fract(st);
+
+ // Four corners in 2D of a tile
+ float a = N21(i);
+ float b = N21(i + vec2(1.0, 0.0));
+ float c = N21(i + vec2(0.0, 1.0));
+ float d = N21(i + vec2(1.0, 1.0));
+
+ // Smooth Interpolation
+ vec2 u = f * f * (3.0 - 2.0 * f); // Cubic Hermite Curve
+
+ // Mix 4 corners percentages
+ return mix(a, b, u.x) +
+ (c - a) * u.y * (1.0 - u.x) +
+ (d - b) * u.x * u.y;
+}
+
+float perlin2(vec2 uv, int octaves, float pscale) {
+ float col = 1.;
+ float initScale = 4.;
+ for (int l; l < octaves; l++) {
+ float val = noise(uv * initScale);
+ if (col <= 0.01) {
+ col = 0.;
+ break;
+ }
+ val -= 0.01;
+ val *= 0.5;
+ col *= val;
+ initScale *= pscale;
+ }
+ return col;
+}
+
+vec3 stars(vec2 uv, float offset) {
+ float timeScale = -(iTime + offset) / layers;
+ float trans = fract(timeScale);
+ float newRnd = floor(timeScale);
+ vec3 col = vec3(0.);
+
+ // Translate uv then scale for center
+ uv -= vec2(0.5);
+ uv = scale(vec2(trans)) * uv;
+ uv += vec2(0.5);
+
+ // Create square aspect ratio
+ uv.x *= iResolution.x / iResolution.y;
+
+ // Create boxes
+ uv *= repeats;
+
+ // Get position
+ vec2 ipos = floor(uv);
+
+ // Return uv as 0 to 1
+ uv = fract(uv);
+
+ // Calculate random xy and size
+ vec2 rndXY = N22(newRnd + ipos * (offset + 1.)) * 0.9 + 0.05;
+ float rndSize = N21(ipos) * 100. + 200.;
+
+ vec2 j = (rndXY - uv) * rndSize;
+ float sparkle = 1. / dot(j, j);
+
+ // Set stars to be pure white
+ col += spectrum(fract(rndXY*newRnd*ipos)) * vec3(sparkle);
+
+ col *= smoothstep(1., 0.8, trans);
+ return col; // Return pure white stars only
+}
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+ // Normalized pixel coordinates (from 0 to 1)
+ vec2 uv = fragCoord/iResolution.xy;
+
+ vec3 col = vec3(0.);
+
+ for (float i = 0.; i < layers; i++ ){
+ col += stars(uv, i);
+ }
+
+ // Sample the terminal screen texture including alpha channel
+ vec4 terminalColor = texture(iChannel0, uv);
+
+ // Make a mask that is 1.0 where the terminal content is not black
+ float mask = 1 - step(0.5, dot(terminalColor.rgb, vec3(1.0)));
+ vec3 blendedColor = mix(terminalColor.rgb, col, mask);
+
+ // Apply terminal's alpha to control overall opacity
+ fragColor = vec4(blendedColor, terminalColor.a);
+
+}
diff --git a/ghostty/shaders/starfield.glsl b/ghostty/shaders/starfield.glsl
new file mode 100644
index 0000000..d5fa23c
--- /dev/null
+++ b/ghostty/shaders/starfield.glsl
@@ -0,0 +1,125 @@
+// divisions of grid
+const float repeats = 30.;
+
+// number of layers
+const float layers = 21.;
+
+// star colors
+const vec3 white = vec3(1.0); // Set star color to pure white
+
+float N21(vec2 p) {
+ p = fract(p * vec2(233.34, 851.73));
+ p += dot(p, p + 23.45);
+ return fract(p.x * p.y);
+}
+
+vec2 N22(vec2 p) {
+ float n = N21(p);
+ return vec2(n, N21(p + n));
+}
+
+mat2 scale(vec2 _scale) {
+ return mat2(_scale.x, 0.0,
+ 0.0, _scale.y);
+}
+
+// 2D Noise based on Morgan McGuire
+float noise(in vec2 st) {
+ vec2 i = floor(st);
+ vec2 f = fract(st);
+
+ // Four corners in 2D of a tile
+ float a = N21(i);
+ float b = N21(i + vec2(1.0, 0.0));
+ float c = N21(i + vec2(0.0, 1.0));
+ float d = N21(i + vec2(1.0, 1.0));
+
+ // Smooth Interpolation
+ vec2 u = f * f * (3.0 - 2.0 * f); // Cubic Hermite Curve
+
+ // Mix 4 corners percentages
+ return mix(a, b, u.x) +
+ (c - a) * u.y * (1.0 - u.x) +
+ (d - b) * u.x * u.y;
+}
+
+float perlin2(vec2 uv, int octaves, float pscale) {
+ float col = 1.;
+ float initScale = 4.;
+ for (int l; l < octaves; l++) {
+ float val = noise(uv * initScale);
+ if (col <= 0.01) {
+ col = 0.;
+ break;
+ }
+ val -= 0.01;
+ val *= 0.5;
+ col *= val;
+ initScale *= pscale;
+ }
+ return col;
+}
+
+vec3 stars(vec2 uv, float offset) {
+ float timeScale = -(iTime + offset) / layers;
+ float trans = fract(timeScale);
+ float newRnd = floor(timeScale);
+ vec3 col = vec3(0.);
+
+ // Translate uv then scale for center
+ uv -= vec2(0.5);
+ uv = scale(vec2(trans)) * uv;
+ uv += vec2(0.5);
+
+ // Create square aspect ratio
+ uv.x *= iResolution.x / iResolution.y;
+
+ // Create boxes
+ uv *= repeats;
+
+ // Get position
+ vec2 ipos = floor(uv);
+
+ // Return uv as 0 to 1
+ uv = fract(uv);
+
+ // Calculate random xy and size
+ vec2 rndXY = N22(newRnd + ipos * (offset + 1.)) * 0.9 + 0.05;
+ float rndSize = N21(ipos) * 100. + 200.;
+
+ vec2 j = (rndXY - uv) * rndSize;
+ float sparkle = 1. / dot(j, j);
+
+ // Set stars to be pure white
+ col += white * sparkle;
+
+ col *= smoothstep(1., 0.8, trans);
+ return col; // Return pure white stars only
+}
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+ // Normalized pixel coordinates (from 0 to 1)
+ vec2 uv = fragCoord/iResolution.xy;
+
+ vec3 col = vec3(0.);
+
+ for (float i = 0.; i < layers; i++ ){
+ col += stars(uv, i);
+ }
+
+
+ // Output to screen
+ // fragColor = vec4(col,1.0);
+
+ // Sample the terminal screen texture including alpha channel
+ vec4 terminalColor = texture(iChannel0, uv);
+
+ // Make a mask that is 1.0 where the terminal content is not black
+ float mask = 1 - step(0.5, dot(terminalColor.rgb, vec3(1.0)));
+ vec3 blendedColor = mix(terminalColor.rgb, col, mask);
+
+ // Apply terminal's alpha to control overall opacity
+ fragColor = vec4(blendedColor, terminalColor.a);
+
+}
diff --git a/ghostty/shaders/tft.glsl b/ghostty/shaders/tft.glsl
new file mode 100644
index 0000000..3d77443
--- /dev/null
+++ b/ghostty/shaders/tft.glsl
@@ -0,0 +1,23 @@
+/** Size of TFT "pixels" */
+float resolution = 4.0;
+
+/** Strength of effect */
+float strength = 0.5;
+
+void _scanline(inout vec3 color, vec2 uv)
+{
+ float scanline = step(1.2, mod(uv.y * iResolution.y, resolution));
+ float grille = step(1.2, mod(uv.x * iResolution.x, resolution));
+ color *= max(1.0 - strength, scanline * grille);
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord)
+{
+ vec2 uv = fragCoord.xy / iResolution.xy;
+ vec3 color = texture(iChannel0, uv).rgb;
+
+ _scanline(color, uv);
+
+ fragColor.xyz = color;
+ fragColor.w = 1.0;
+}
diff --git a/ghostty/shaders/underwater.glsl b/ghostty/shaders/underwater.glsl
new file mode 100644
index 0000000..8c2fb22
--- /dev/null
+++ b/ghostty/shaders/underwater.glsl
@@ -0,0 +1,74 @@
+// adapted by Alex Sherwin for Ghostty from https://www.shadertoy.com/view/lljGDt
+
+#define BLACK_BLEND_THRESHOLD .4
+
+float hash21(vec2 p) {
+ p = fract(p * vec2(233.34, 851.73));
+ p += dot(p, p + 23.45);
+ return fract(p.x * p.y);
+}
+
+float rayStrength(vec2 raySource, vec2 rayRefDirection, vec2 coord, float seedA, float seedB, float speed)
+{
+ vec2 sourceToCoord = coord - raySource;
+ float cosAngle = dot(normalize(sourceToCoord), rayRefDirection);
+
+ // Add subtle dithering based on screen coordinates
+ float dither = hash21(coord) * 0.015 - 0.0075;
+
+ float ray = clamp(
+ (0.45 + 0.15 * sin(cosAngle * seedA + iTime * speed)) +
+ (0.3 + 0.2 * cos(-cosAngle * seedB + iTime * speed)) + dither,
+ 0.0, 1.0);
+
+ // Smoothstep the distance falloff
+ float distFade = smoothstep(0.0, iResolution.x, iResolution.x - length(sourceToCoord));
+ return ray * mix(0.5, 1.0, distFade);
+}
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ uv.y = 1.0 - uv.y;
+ vec2 coord = vec2(fragCoord.x, iResolution.y - fragCoord.y);
+
+ // Set the parameters of the sun rays
+ vec2 rayPos1 = vec2(iResolution.x * 0.7, iResolution.y * 1.1);
+ vec2 rayRefDir1 = normalize(vec2(1.0, 0.116));
+ float raySeedA1 = 36.2214;
+ float raySeedB1 = 21.11349;
+ float raySpeed1 = 1.1;
+
+ vec2 rayPos2 = vec2(iResolution.x * 0.8, iResolution.y * 1.2);
+ vec2 rayRefDir2 = normalize(vec2(1.0, -0.241));
+ const float raySeedA2 = 22.39910;
+ const float raySeedB2 = 18.0234;
+ const float raySpeed2 = 0.9;
+
+ // Calculate the colour of the sun rays on the current fragment
+ vec4 rays1 =
+ vec4(1.0, 1.0, 1.0, 0.0) *
+ rayStrength(rayPos1, rayRefDir1, coord, raySeedA1, raySeedB1, raySpeed1);
+
+ vec4 rays2 =
+ vec4(1.0, 1.0, 1.0, 0.0) *
+ rayStrength(rayPos2, rayRefDir2, coord, raySeedA2, raySeedB2, raySpeed2);
+
+ vec4 col = rays1 * 0.5 + rays2 * 0.4;
+
+ // Attenuate brightness towards the bottom, simulating light-loss due to depth.
+ // Give the whole thing a blue-green tinge as well.
+ float brightness = 1.0 - (coord.y / iResolution.y);
+ col.r *= 0.05 + (brightness * 0.8);
+ col.g *= 0.15 + (brightness * 0.6);
+ col.b *= 0.3 + (brightness * 0.5);
+
+ vec2 termUV = fragCoord.xy / iResolution.xy;
+ vec4 terminalColor = texture(iChannel0, termUV);
+
+ float alpha = step(length(terminalColor.rgb), BLACK_BLEND_THRESHOLD);
+ vec3 blendedColor = mix(terminalColor.rgb * 1.0, col.rgb * 0.3, alpha);
+
+ fragColor = vec4(blendedColor, terminalColor.a);
+}
diff --git a/ghostty/shaders/water.glsl b/ghostty/shaders/water.glsl
new file mode 100644
index 0000000..c240b58
--- /dev/null
+++ b/ghostty/shaders/water.glsl
@@ -0,0 +1,35 @@
+
+#define TAU 6.28318530718
+#define MAX_ITER 6
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+ vec3 water_color = vec3(1.0, 1.0, 1.0) * 0.5;
+ float time = iTime * 0.5+23.0;
+ vec2 uv = fragCoord.xy / iResolution.xy;
+
+ vec2 p = mod(uv*TAU, TAU)-250.0;
+ vec2 i = vec2(p);
+ float c = 1.0;
+ float inten = 0.005;
+
+ for (int n = 0; n < MAX_ITER; n++)
+ {
+ float t = time * (1.0 - (3.5 / float(n+1)));
+ i = p + vec2(cos(t - i.x) + sin(t + i.y), sin(t - i.y) + cos(t + i.x));
+ c += 1.0/length(vec2(p.x / (sin(i.x+t)/inten),p.y / (cos(i.y+t)/inten)));
+ }
+ c /= float(MAX_ITER);
+ c = 1.17-pow(c, 1.4);
+ vec3 color = vec3(pow(abs(c), 15.0));
+ color = clamp((color + water_color)*1.2, 0.0, 1.0);
+
+ // perterb uv based on value of c from caustic calc above
+ vec2 tc = vec2(cos(c)-0.75,sin(c)-0.75)*0.04;
+ uv = clamp(uv + tc,0.0,1.0);
+
+ fragColor = texture(iChannel0, uv);
+ // give transparent pixels a color
+ if ( fragColor.a == 0.0 ) fragColor=vec4(1.0,1.0,1.0,1.0);
+ fragColor *= vec4(color, 1.0);
+}
\ No newline at end of file