From 87ad46cb7e7410c53419c20cef7df53ed4c15f60 Mon Sep 17 00:00:00 2001
From: Gabriel Schneider <gbrls@0x4200.cafe>
Date: Tue, 29 Sep 2026 07:31:35 -0300
Subject: G11: HoverGlow, a soft underline of light under a look-hover's word

HoverGlow on|off (off, a pixel shell's; Chrome.glows bit 1, SelectionGlow
bit 0 now that there are two): under the word a look-hover would open (its
cells in the affordance's tint) a strip three logical pixels tall along
its foot, blurred by one, in the theme's accent, at most 22% and under
the text's contrast floor, fading in over 80 ms; kept to the bodies and
split round a cursor. glowBlocks serves G9 and G11. The strip is cast from
a row away so addSoft's caster cut-out misses it.

Tests: the glow comes up by 90 ms and never falls on the cursor's cell.
Gates as G10 (a loaded machine shifted the GUI goldens a scene once; a
rerun matched 01-08). Feel review: .scratch/render/hover/.
---
 src/surface.zig | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'src/surface.zig')

diff --git a/src/surface.zig b/src/surface.zig
index 7256ecc1..26783df4 100644
--- a/src/surface.zig
+++ b/src/surface.zig
@@ -448,8 +448,10 @@ pub const Chrome = struct {
     decor_title_px: u8 = 2,
     name_ink: [3]u8 = .{ 0, 0, 0 },
     active_name_ink: [3]u8 = .{ 0, 0, 0 },
-    /// G9: a pixel shell glows round the body's selection (SelectionGlow).
-    selection_glow: u8 = 0,
+    /// A pixel shell's glows: bit 0 round the body's selection (G9,
+    /// SelectionGlow), bit 1 under the word a look-hover would open (G11,
+    /// HoverGlow).
+    glows: u8 = 0,
 };
 
 /// The canonical interface: what a frame of pardes IS. The tty shell writes
-- 
cgit v1.3


From ab668719385c94df3e274f71cb744f5917c1da7e Mon Sep 17 00:00:00 2001
From: Gabriel Schneider <gbrls@0x4200.cafe>
Date: Tue, 29 Sep 2026 07:47:39 -0300
Subject: G12: Occlusion, pane bodies darkening faintly toward their edges
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Occlusion on|off (off, a pixel shell's; Chrome.fx bit 2 — the glow bits
field is now `fx`): four soft strips cast from just outside each pane body
inward, clipped to the body and round a cursor, black pre-warped to
linear light, 2% at most (§9.1) and under the lift's contrast ceiling,
in the pane's own group.

Tests: the shade stays inside the body, off the cursor, at most 2%.
Gates as G11. Feel review: .scratch/render/occlusion/ (with an x40 diff).
---
 docs/config.md        |  2 ++
 docs/effects.md       |  8 +++++
 src/config.zig        | 12 +++++--
 src/detached/wire.zig |  2 +-
 src/draw.zig          |  2 +-
 src/gui/gui.zig       | 91 +++++++++++++++++++++++++++++++++++++++++++++++----
 src/surface.zig       |  9 ++---
 7 files changed, 111 insertions(+), 15 deletions(-)

(limited to 'src/surface.zig')

diff --git a/docs/config.md b/docs/config.md
index cd1244f7..44f37079 100644
--- a/docs/config.md
+++ b/docs/config.md
@@ -576,6 +576,8 @@ SelectionGlow on a soft halo of the selection's colour round it in the body,
                  fading in over 100 ms, never over a tag, a grip or the cursor
 HoverGlow on     a soft glow under the word a look-hover would open, fading
                  in over 80 ms
+Occlusion on     pane bodies darken faintly toward their edges (2%), never
+                 over the cursor
 CursorBlink on   the cursor blinks, solid while typing and half a second
                  after, eased at each edge, solid after 10 idle seconds
 GripWidth 150    the grip's button and the scrollbar under it, percent of the
diff --git a/docs/effects.md b/docs/effects.md
index c11ff070..ad454775 100644
--- a/docs/effects.md
+++ b/docs/effects.md
@@ -45,6 +45,7 @@ why. The verdict is the user's.
 | G9 selection glow | `SelectionGlow on\|off` (off) | a soft halo of the selection's colour round each block of it in a body, fading in over 100 ms | .scratch/render/selection/ (forge, acme, lapis; lapis-glow-zoom.png) | pending |
 | G10 theme crossfade | always (a theme change) | the chrome's colours fade through OKLab, easing in and out (out when retargeted) | .scratch/render/crossfade/ (forge, lapis, acme cut short by dusk) | pending |
 | G11 look-hover glow | `HoverGlow on\|off` (off) | a soft underline of the theme's accent under the word a look-hover would open, fading in over 80 ms | .scratch/render/hover/ (forge, acme, lapis; zooms) | pending |
+| G12 ambient occlusion | `Occlusion on\|off` (off) | pane bodies darken toward their edges, at most 2% (§9.1: 1 to 2%) | .scratch/render/occlusion/ (on/off on forge, acme, lapis; acme-diff-x40.png) | pending |
 
 ## Motion flavours
 
@@ -219,3 +220,10 @@ Found while reviewing: with the machine loaded, test/gui_golden.py's
 two-captures-agree settle can take a scene's frame before the scene's
 change lands, and every later hash moves up a scene; a rerun on a quiet
 machine matches.
+
+Notes on G12: four soft strips cast from just outside each body inward,
+clipped to it and round a cursor, black in linear light, 2% at most and
+under the lift's contrast ceiling, in the pane's own group so it moves
+with it. At §9.1's strength it is all but invisible on a dark page (a
+level of 255 on forge) and faint on a light one (acme's page steps one
+level toward the edges); acme-diff-x40.png shows where it falls.
diff --git a/src/config.zig b/src/config.zig
index 4e159d01..22e65c46 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -124,6 +124,7 @@ pub const leader_path = paths: {
     if (builtins.capabilities.lift) table.set(.CursorBlink, null);
     if (builtins.capabilities.lift) table.set(.SelectionGlow, null);
     if (builtins.capabilities.lift) table.set(.HoverGlow, null);
+    if (builtins.capabilities.lift) table.set(.Occlusion, null);
     if (builtins.capabilities.lift) table.set(.Lift, null);
     table.set(.Motion, null);
     table.set(.InactiveDim, null);
@@ -674,6 +675,9 @@ pub const Runtime = struct {
     /// G11: a soft glow under the word a look-hover would open, fading in
     /// over 80 ms, a pixel shell's.
     hover_glow: bool = false,
+    /// G12: pane bodies darken faintly toward their edges (ambient
+    /// occlusion, at most 2%), a pixel shell's.
+    occlusion: bool = false,
     /// How long a message stays after the key or click that dismisses it.
     message_linger_ms: u16 = 800,
     /// How long its fall into the row takes, easing out (§8.1: arriving,
@@ -897,7 +901,7 @@ pub const Runtime = struct {
     /// The message timings a setting word sets, each in milliseconds.
     pub const MessageTime = enum { linger, fall, dissolve };
 
-    pub const Toggle = enum { colors, wrap, tree_context_tag_style, tag_bottom, debug, focus_tint, syntax_bold, verbose, message_animation, ligatures, cursor_blink, selection_glow, hover_glow };
+    pub const Toggle = enum { colors, wrap, tree_context_tag_style, tag_bottom, debug, focus_tint, syntax_bold, verbose, message_animation, ligatures, cursor_blink, selection_glow, hover_glow, occlusion };
     /// A bundled post pass, a Shadertoy file in shaders/post/: the CRT, and
     /// G4's bloom, vignette and grain (docs/effects.md).
     pub const Scene = enum { crt, bloom, vignette, grain };
@@ -958,6 +962,7 @@ pub const Runtime = struct {
         .{ .word = "CursorBlink", .action = .{ .toggle = .cursor_blink }, .availability = .lift, .doc = "The cursor blinks, solid while typing, on or off." },
         .{ .word = "SelectionGlow", .action = .{ .toggle = .selection_glow }, .availability = .lift, .doc = "A soft halo of the selection's colour round it in the body, on or off." },
         .{ .word = "HoverGlow", .action = .{ .toggle = .hover_glow }, .availability = .lift, .doc = "A soft underline of light under the word a look-hover would open, on or off." },
+        .{ .word = "Occlusion", .action = .{ .toggle = .occlusion }, .availability = .lift, .doc = "Pane bodies darken faintly toward their edges, on or off." },
         .{ .word = "Lift", .action = .lift, .availability = .lift, .doc = "How the focused pane stands off the page: off, shadow, rim or auto." },
         .{ .word = "Motion", .action = .motion, .doc = "How animations move: off, crisp, smooth, bouncy or playful." },
         .{ .word = "InactiveDim", .action = .inactive_dim, .doc = "Fade the unfocused panes' text by a percentage, 0 through 100, 0 off." },
@@ -1034,9 +1039,9 @@ pub const Runtime = struct {
                 .toggle => |field| if (field == .ligatures) {
                     if (setting.availability != .ligatures)
                         @compileError("the ligatures toggle must use the ligatures capability");
-                } else if (field == .cursor_blink or field == .selection_glow or field == .hover_glow) {
+                } else if (field == .cursor_blink or field == .selection_glow or field == .hover_glow or field == .occlusion) {
                     if (setting.availability != .lift)
-                        @compileError("CursorBlink, SelectionGlow and HoverGlow must use the lift capability (a pixel shell's)");
+                        @compileError("CursorBlink, SelectionGlow, HoverGlow and Occlusion must use the lift capability (a pixel shell's)");
                 } else if (setting.availability != null)
                     @compileError("unconditional toggles cannot carry a backend capability"),
                 else => if (setting.availability != null)
@@ -1693,6 +1698,7 @@ pub const Runtime = struct {
                     .cursor_blink => "CursorBlink off\n",
                     .selection_glow => "SelectionGlow on\n",
                     .hover_glow => "HoverGlow on\n",
+                    .occlusion => "Occlusion on\n",
                 },
                 .shell => "Shell requested (new panes) fish\n",
                 .tagline_size => "TaglineSize 73\n",
diff --git a/src/detached/wire.zig b/src/detached/wire.zig
index cf5a8711..3a914e42 100644
--- a/src/detached/wire.zig
+++ b/src/detached/wire.zig
@@ -13,7 +13,7 @@ pub const version: u16 = 8;
 
 /// The Chrome palette is carried field by field as its declaration lists
 /// them, so any change to it changes the wire: bump `version`, then this.
-const chrome_layout: u64 = 0x3195816f182fe5bc;
+const chrome_layout: u64 = 0x5e758b47fb0cf8da;
 comptime {
     @setEvalBranchQuota(10_000);
     var hash = std.hash.Fnv1a_64.init();
diff --git a/src/draw.zig b/src/draw.zig
index 5e40f0fa..027326fa 100644
--- a/src/draw.zig
+++ b/src/draw.zig
@@ -472,7 +472,7 @@ pub fn render(p: *Pardes, arena: std.mem.Allocator) !*Surface {
         .rail_px = @intCast(@min(255, @as(u32, p.theme().rail_px orelse 12) * p.settings.grip_width / 100)),
         .name_ink = chrome.tag_name_fg,
         .active_name_ink = if (p.settings.focus_tint) chrome.tag_active_name_fg else chrome.tag_name_fg,
-        .glows = @as(u8, @intFromBool(p.settings.selection_glow)) | @as(u8, @intFromBool(p.settings.hover_glow)) << 1,
+        .fx = @as(u8, @intFromBool(p.settings.selection_glow)) | @as(u8, @intFromBool(p.settings.hover_glow)) << 1 | @as(u8, @intFromBool(p.settings.occlusion)) << 2,
     };
     if (p.theme().decor) |decor| {
         s.chrome.decor_dots = decor.page_dots;
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index 45861ea4..6bde8b60 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -5815,9 +5815,9 @@ fn renderFrame(
     if (g.glide.pending) g.glide.measure(gpa, surface);
     g.sel_glow.now_ns = if (core) |p| p.now_ns else c.SDL_GetTicksNS();
     // Off, or while panes move, no glow and nothing fading.
-    if (surface.chrome.glows & 1 == 0 or surface.panelTracks().len != 0) g.sel_glow = .{ .now_ns = g.sel_glow.now_ns };
+    if (surface.chrome.fx & 1 == 0 or surface.panelTracks().len != 0) g.sel_glow = .{ .now_ns = g.sel_glow.now_ns };
     g.hover_glow.now_ns = g.sel_glow.now_ns;
-    if (surface.chrome.glows & 2 == 0 or surface.panelTracks().len != 0) g.hover_glow = .{ .now_ns = g.sel_glow.now_ns };
+    if (surface.chrome.fx & 2 == 0 or surface.panelTracks().len != 0) g.hover_glow = .{ .now_ns = g.sel_glow.now_ns };
     if (g.glide.moving()) g.glide.offset = g.glide.spring.value(g.glide.now_ns);
     cell_decor = CellDecor.of(chrome);
     // Plaques need an opaque window: with WindowOpacity under 100 the cells
@@ -8708,9 +8708,11 @@ fn buildDecor(g: *Gui, gpa: std.mem.Allocator, surface: *const pardes.Surface, g
             const bodies = body_buf[0..nbodies];
             try paneDecor(g, gpa, placed, groups, index, chrome, layout, surface.cols, surface.rows, win_w, win_h, track);
             // G9, while nothing moves: a halo round the body's selection.
-            if (index == 0 and groups.tracks == 0 and chrome.glows & 1 != 0) try glowBlocks(g, gpa, surface, .selection, layout, win_w, win_h);
+            if (index == 0 and groups.tracks == 0 and chrome.fx & 1 != 0) try glowBlocks(g, gpa, surface, .selection, layout, win_w, win_h);
             // G11: a glow under the word a look-hover would open.
-            if (index == 0 and groups.tracks == 0 and chrome.glows & 2 != 0) try glowBlocks(g, gpa, surface, .hover, layout, win_w, win_h);
+            if (index == 0 and groups.tracks == 0 and chrome.fx & 2 != 0) try glowBlocks(g, gpa, surface, .hover, layout, win_w, win_h);
+            // G12: the bodies' edges shaded, a pane's in its own group.
+            if (chrome.fx & 4 != 0) try occlusion(g, gpa, placed, groups, index, surface, ceilings, layout, win_w, win_h, track);
             // A single spine runs down each column, through every tag and body.
             if (index == 0) for (regions) |column| {
                 if (column.kind != .column) continue;
@@ -9092,6 +9094,44 @@ fn glowBlocks(g: *Gui, gpa: std.mem.Allocator, surface: *const pardes.Surface, k
     tracker.* = next;
 }
 
+/// G12: ambient occlusion, a pane body darkening faintly toward its edges
+/// (§9.1: an inner shadow of 1 to 2%): four soft strips cast from just
+/// outside the body inward, clipped to it and round a cursor, black in
+/// linear light, under the same contrast ceiling as a lift.
+fn occlusion(g: *Gui, gpa: std.mem.Allocator, regions: []const pardes.Region, groups: *const Groups, index: usize, surface: *const pardes.Surface, ceilings: LiftCeilings, layout: CellLayout, win_w: f32, win_h: f32, track: ?pardes.animation.Track) !void {
+    const strength = @min(0.02, ceilings.shadow);
+    if (strength <= 0.002) return;
+    const reach = 0.5 * layout.h;
+    for (regions) |body| {
+        if (body.kind != .body or body.rect.w == 0 or body.rect.h == 0 or groupOf(groups, body.serial) != index) continue;
+        const b = bodyPixels(body, layout);
+        // The body, less a cursor's cell in it: left, right, above, below.
+        var parts: [4][4]f32 = undefined;
+        var nparts: usize = 0;
+        const cursor: ?[4]f32 = if (surface.cursor) |cu| .{ @as(f32, @floatFromInt(cu.x)) * layout.w, @as(f32, @floatFromInt(cu.y)) * layout.h, @as(f32, @floatFromInt(cu.x + 1)) * layout.w, @as(f32, @floatFromInt(cu.y + 1)) * layout.h } else null;
+        if (cursor) |cb| if (!(cb[0] >= b[2] or cb[2] <= b[0] or cb[1] >= b[3] or cb[3] <= b[1])) {
+            parts = .{ .{ b[0], b[1], cb[0], b[3] }, .{ cb[2], b[1], b[2], b[3] }, .{ cb[0], b[1], cb[2], cb[1] }, .{ cb[0], cb[3], cb[2], b[3] } };
+            nparts = 4;
+        };
+        if (nparts == 0) {
+            parts[0] = b;
+            nparts = 1;
+        }
+        const t = reach / 3;
+        const strips = [_][4]f32{
+            .{ b[0], b[1] - t, b[2], b[1] },
+            .{ b[0], b[3], b[2], b[3] + t },
+            .{ b[0] - t, b[1], b[0], b[3] },
+            .{ b[2], b[1], b[2] + t, b[3] },
+        };
+        for (strips) |strip| {
+            const first = g.decor.items.len;
+            try addSoft(g, gpa, strip, reach / 3, 0, 0, strength, .{ 0, 0, 0 }, track, win_w, win_h);
+            try clipToBodies(g, gpa, first, parts[0..nparts]);
+        }
+    }
+}
+
 /// A theme's tag plaques (Chrome.decor_box_*), drawn under the cells of
 /// group `index`: each pane tag, and with the still panes the column and
 /// workspace tags, becomes a framed box inside its own band with a hard
@@ -9536,7 +9576,7 @@ test "the selection glows round its block, on the body only, fading in over 100
     core.settings.selection_glow = true;
     pardes.test_api.sync(core);
     const s = try core.render(core.scratch.allocator());
-    try std.testing.expectEqual(@as(u8, 1), s.chrome.glows);
+    try std.testing.expectEqual(@as(u8, 1), s.chrome.fx);
     // Two rows of a selection in the body, as the core paints one.
     const body = for (s.regionList()) |region| {
         if (region.kind == .body) break region;
@@ -9586,7 +9626,7 @@ test "a hovered word glows along its foot, never over the cursor, fading in over
     core.settings.hover_glow = true;
     pardes.test_api.sync(core);
     const s = try core.render(core.scratch.allocator());
-    try std.testing.expectEqual(@as(u8, 2), s.chrome.glows);
+    try std.testing.expectEqual(@as(u8, 2), s.chrome.fx);
     const body = for (s.regionList()) |region| {
         if (region.kind == .body) break region;
     } else return error.NoBody;
@@ -9628,6 +9668,45 @@ test "a hovered word glows along its foot, never over the cursor, fading in over
     try std.testing.expect(!g.hover_glow.fading);
 }
 
+test "occlusion shades each body's edges, inside it, never a tag, a grip or the cursor" {
+    const gpa = std.testing.allocator;
+    const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+    defer core.deinit();
+    _ = try core.setTestFile("some text on a line\n" ** 30);
+    core.settings.occlusion = true;
+    pardes.test_api.sync(core);
+    const s = try core.render(core.scratch.allocator());
+    try std.testing.expectEqual(@as(u8, 4), s.chrome.fx);
+    const body = for (s.regionList()) |region| {
+        if (region.kind == .body) break region;
+    } else return error.NoBody;
+    // The cursor on the body's top-left cell, where the shade is.
+    s.cursor = .{ .x = body.rect.x, .y = body.rect.y };
+    var g: Gui = undefined;
+    g.decor = .empty;
+    defer g.decor.deinit(gpa);
+    g.cell_w = 10;
+    g.cell_h = 20;
+    g.tagline_width = 6;
+    g.tagline_height = 12;
+    g.sel_glow = .{};
+    g.hover_glow = .{};
+    var groups = makeGroups(&.{}, false);
+    try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 800, 480, true);
+    const r = bodyPixels(body, fixedCellLayout(&g));
+    var shades: usize = 0;
+    for (g.decor.items) |item| {
+        if (item.effect & soft_shadow_bit == 0) continue;
+        shades += 1;
+        try std.testing.expect(item.fr <= 0.02 + 1e-6);
+        try std.testing.expect(item.clip_x0 >= r[0] - 0.01 and item.clip_x1 <= r[2] + 0.01 and item.clip_y0 >= r[1] - 0.01 and item.clip_y1 <= r[3] + 0.01);
+        const cx: f32 = @floatFromInt(@as(u32, s.cursor.?.x) * 10);
+        const cy: f32 = @floatFromInt(@as(u32, s.cursor.?.y) * 20);
+        try std.testing.expect(item.clip_x1 <= cx + 0.01 or item.clip_x0 >= cx + 10 - 0.01 or item.clip_y1 <= cy + 0.01 or item.clip_y0 >= cy + 20 - 0.01);
+    }
+    try std.testing.expect(shades >= 4);
+}
+
 /// What a bundled post pass leaves alone (Post.Frame.spare), in window
 /// pixels: every tag with its grip, the column and workspace tags, and the
 /// notices, the chrome the focus indicators live in. A grip, the gap after
diff --git a/src/surface.zig b/src/surface.zig
index 26783df4..02e4bb5d 100644
--- a/src/surface.zig
+++ b/src/surface.zig
@@ -448,10 +448,11 @@ pub const Chrome = struct {
     decor_title_px: u8 = 2,
     name_ink: [3]u8 = .{ 0, 0, 0 },
     active_name_ink: [3]u8 = .{ 0, 0, 0 },
-    /// A pixel shell's glows: bit 0 round the body's selection (G9,
-    /// SelectionGlow), bit 1 under the word a look-hover would open (G11,
-    /// HoverGlow).
-    glows: u8 = 0,
+    /// A pixel shell's small effects: bit 0 a glow round the body's
+    /// selection (G9, SelectionGlow), bit 1 one under the word a look-hover
+    /// would open (G11, HoverGlow), bit 2 the bodies' edge shade (G12,
+    /// Occlusion).
+    fx: u8 = 0,
 };
 
 /// The canonical interface: what a frame of pardes IS. The tty shell writes
-- 
cgit v1.3


From 0a2694e935fa8a79f1a399f2d2cbc643f8c3734e Mon Sep 17 00:00:00 2001
From: Gabriel Schneider <gbrls@0x4200.cafe>
Date: Tue, 29 Sep 2026 08:28:40 -0300
Subject: G13: Parallax, lapis's dots drift with the text at a quarter of its
 speed

Parallax on|off (off, a pixel shell's; Chrome.fx bit 3). A body region
carries its first line (Region.line, a file's scroll or a terminal's grid
offset; the wire's region record grows a u32). The GUI offsets each
body's page dots by a quarter of its line in rows, and of G6's glide
offset while one runs, so the pattern drifts with the text and settles
with it; the cell shader reads it from the instance's serial slot, whose
per-cell dissolve noise G7 left unused (the dead noise code goes).

Tests: a scrolled body tells its line; the shift handed to the shader is
a quarter of it within the dots' period. Measured in a capture: four lines
move the dots 13 px (140 px / 4 mod 22). Gates as before, goldens
byte-identical. Feel review: .scratch/render/parallax/.
---
 docs/config.md                |   2 ++
 docs/effects.md               |  10 ++++++++
 shaders/prebuilt/ui.frag.glsl |  18 +++----------
 shaders/prebuilt/ui.frag.spv  | Bin 8176 -> 6968 bytes
 shaders/ui.frag.glsl          |  18 +++----------
 src/config.zig                |  12 ++++++---
 src/detached/wire.zig         |   4 ++-
 src/draw.zig                  |   5 ++--
 src/gui/gui.zig               |  57 +++++++++++++++++++++++++++++++++++++++++-
 src/surface.zig               |   6 ++++-
 10 files changed, 96 insertions(+), 36 deletions(-)

(limited to 'src/surface.zig')

diff --git a/docs/config.md b/docs/config.md
index 44f37079..97bf95a1 100644
--- a/docs/config.md
+++ b/docs/config.md
@@ -578,6 +578,8 @@ HoverGlow on     a soft glow under the word a look-hover would open, fading
                  in over 80 ms
 Occlusion on     pane bodies darken faintly toward their edges (2%), never
                  over the cursor
+Parallax on      a theme's page pattern (lapis's dots) moves with the text
+                 at a quarter of its speed
 CursorBlink on   the cursor blinks, solid while typing and half a second
                  after, eased at each edge, solid after 10 idle seconds
 GripWidth 150    the grip's button and the scrollbar under it, percent of the
diff --git a/docs/effects.md b/docs/effects.md
index ad454775..fbb44dfa 100644
--- a/docs/effects.md
+++ b/docs/effects.md
@@ -46,6 +46,7 @@ why. The verdict is the user's.
 | G10 theme crossfade | always (a theme change) | the chrome's colours fade through OKLab, easing in and out (out when retargeted) | .scratch/render/crossfade/ (forge, lapis, acme cut short by dusk) | pending |
 | G11 look-hover glow | `HoverGlow on\|off` (off) | a soft underline of the theme's accent under the word a look-hover would open, fading in over 80 ms | .scratch/render/hover/ (forge, acme, lapis; zooms) | pending |
 | G12 ambient occlusion | `Occlusion on\|off` (off) | pane bodies darken toward their edges, at most 2% (§9.1: 1 to 2%) | .scratch/render/occlusion/ (on/off on forge, acme, lapis; acme-diff-x40.png) | pending |
+| G13 parallax | `Parallax on\|off` (off) | a theme's page pattern under the bodies (lapis's dots) moves with the text at a quarter of its speed, glides included | .scratch/render/parallax/ (lapis, notches down and up) | pending |
 
 ## Motion flavours
 
@@ -227,3 +228,12 @@ under the lift's contrast ceiling, in the pane's own group so it moves
 with it. At §9.1's strength it is all but invisible on a dark page (a
 level of 255 on forge) and faint on a light one (acme's page steps one
 level toward the edges); acme-diff-x40.png shows where it falls.
+
+Notes on G13: a body region now carries its first line (Region.line: a
+file's scroll, a terminal's grid offset; on the wire, a u32 more a
+region). Under Parallax the dots under each body are offset by a quarter
+of its line times the row height, plus G6's glide offset while one runs,
+so they drift with the text as it glides and settle with it (measured: 4
+lines at 35 px move the 22 px grid 13 px, 35 mod 22). The cell shader
+reads the offset from the instance's serial slot, free since G7 took the
+dissolve's per-cell noise out. Without a pattern, nothing happens.
diff --git a/shaders/prebuilt/ui.frag.glsl b/shaders/prebuilt/ui.frag.glsl
index cb38fff1..51ec5b8c 100644
--- a/shaders/prebuilt/ui.frag.glsl
+++ b/shaders/prebuilt/ui.frag.glsl
@@ -27,16 +27,6 @@ layout(location = 5) flat in vec4 v_clip;
 
 layout(location = 0) out vec4 o_col;
 
-float cellNoise(uint serial, uint col, uint row) {
-    uint x = serial ^ (col * 0x9e3779b9u) ^ (row * 0x85ebca6bu);
-    x ^= x >> 16;
-    x *= 0x7feb352du;
-    x ^= x >> 15;
-    x *= 0x846ca68bu;
-    x ^= x >> 16;
-    return float(x & 0xffffu) / 65535.0;
-}
-
 void main() {
     if (v_clip.z >= v_clip.x && (gl_FragCoord.x < v_clip.x || gl_FragCoord.x >= v_clip.z ||
         gl_FragCoord.y < v_clip.y || gl_FragCoord.y >= v_clip.w)) discard;
@@ -51,9 +41,6 @@ void main() {
         : clamp(u_ui.background_opacity, 0.0, 1.0);
     uint effect = v_effect.x & 0x07ffffffu;
     float progress = clamp(uintBitsToFloat(v_effect.y), 0.0, 1.0);
-    uint cellCol = v_effect.w & 0xffffu;
-    uint cellRow = v_effect.w >> 16;
-    float noise = cellNoise(v_effect.z, cellCol, cellRow);
 
     // Ink over ground, both premultiplied: v_fg*a + (v_bg*bgA)*(1-a), which is
     // mix() with the ground already premultiplied. At bgA = 1 that is exactly
@@ -63,7 +50,10 @@ void main() {
     // dot every period pixels, fixed to the window, under the text.
     if ((v_effect.x & 0x10000000u) != 0u) {
         float period = u_ui.decor_dot_geom.x;
-        vec2 d = mod(gl_FragCoord.xy, period) - 0.5 * period;
+        // v_effect.z: how far its pane's text has moved the dots (G13's
+        // parallax), in pixels, as a float's bits (0 without).
+        vec2 at = gl_FragCoord.xy - vec2(0.0, uintBitsToFloat(v_effect.z));
+        vec2 d = mod(at, period) - 0.5 * period;
         float dot_a = 1.0 - smoothstep(u_ui.decor_dot_geom.y, u_ui.decor_dot_geom.z, length(d));
         ground = mix(ground, u_ui.decor_dots.rgb, u_ui.decor_dots.a * dot_a);
     }
diff --git a/shaders/prebuilt/ui.frag.spv b/shaders/prebuilt/ui.frag.spv
index 15318214..02e3edc4 100644
Binary files a/shaders/prebuilt/ui.frag.spv and b/shaders/prebuilt/ui.frag.spv differ
diff --git a/shaders/ui.frag.glsl b/shaders/ui.frag.glsl
index cb38fff1..51ec5b8c 100644
--- a/shaders/ui.frag.glsl
+++ b/shaders/ui.frag.glsl
@@ -27,16 +27,6 @@ layout(location = 5) flat in vec4 v_clip;
 
 layout(location = 0) out vec4 o_col;
 
-float cellNoise(uint serial, uint col, uint row) {
-    uint x = serial ^ (col * 0x9e3779b9u) ^ (row * 0x85ebca6bu);
-    x ^= x >> 16;
-    x *= 0x7feb352du;
-    x ^= x >> 15;
-    x *= 0x846ca68bu;
-    x ^= x >> 16;
-    return float(x & 0xffffu) / 65535.0;
-}
-
 void main() {
     if (v_clip.z >= v_clip.x && (gl_FragCoord.x < v_clip.x || gl_FragCoord.x >= v_clip.z ||
         gl_FragCoord.y < v_clip.y || gl_FragCoord.y >= v_clip.w)) discard;
@@ -51,9 +41,6 @@ void main() {
         : clamp(u_ui.background_opacity, 0.0, 1.0);
     uint effect = v_effect.x & 0x07ffffffu;
     float progress = clamp(uintBitsToFloat(v_effect.y), 0.0, 1.0);
-    uint cellCol = v_effect.w & 0xffffu;
-    uint cellRow = v_effect.w >> 16;
-    float noise = cellNoise(v_effect.z, cellCol, cellRow);
 
     // Ink over ground, both premultiplied: v_fg*a + (v_bg*bgA)*(1-a), which is
     // mix() with the ground already premultiplied. At bgA = 1 that is exactly
@@ -63,7 +50,10 @@ void main() {
     // dot every period pixels, fixed to the window, under the text.
     if ((v_effect.x & 0x10000000u) != 0u) {
         float period = u_ui.decor_dot_geom.x;
-        vec2 d = mod(gl_FragCoord.xy, period) - 0.5 * period;
+        // v_effect.z: how far its pane's text has moved the dots (G13's
+        // parallax), in pixels, as a float's bits (0 without).
+        vec2 at = gl_FragCoord.xy - vec2(0.0, uintBitsToFloat(v_effect.z));
+        vec2 d = mod(at, period) - 0.5 * period;
         float dot_a = 1.0 - smoothstep(u_ui.decor_dot_geom.y, u_ui.decor_dot_geom.z, length(d));
         ground = mix(ground, u_ui.decor_dots.rgb, u_ui.decor_dots.a * dot_a);
     }
diff --git a/src/config.zig b/src/config.zig
index 22e65c46..d11cbe76 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -125,6 +125,7 @@ pub const leader_path = paths: {
     if (builtins.capabilities.lift) table.set(.SelectionGlow, null);
     if (builtins.capabilities.lift) table.set(.HoverGlow, null);
     if (builtins.capabilities.lift) table.set(.Occlusion, null);
+    if (builtins.capabilities.lift) table.set(.Parallax, null);
     if (builtins.capabilities.lift) table.set(.Lift, null);
     table.set(.Motion, null);
     table.set(.InactiveDim, null);
@@ -678,6 +679,9 @@ pub const Runtime = struct {
     /// G12: pane bodies darken faintly toward their edges (ambient
     /// occlusion, at most 2%), a pixel shell's.
     occlusion: bool = false,
+    /// G13: a theme's page pattern under the bodies (lapis's dots) moves
+    /// with the text at a quarter of its speed, a pixel shell's.
+    parallax: bool = false,
     /// How long a message stays after the key or click that dismisses it.
     message_linger_ms: u16 = 800,
     /// How long its fall into the row takes, easing out (§8.1: arriving,
@@ -901,7 +905,7 @@ pub const Runtime = struct {
     /// The message timings a setting word sets, each in milliseconds.
     pub const MessageTime = enum { linger, fall, dissolve };
 
-    pub const Toggle = enum { colors, wrap, tree_context_tag_style, tag_bottom, debug, focus_tint, syntax_bold, verbose, message_animation, ligatures, cursor_blink, selection_glow, hover_glow, occlusion };
+    pub const Toggle = enum { colors, wrap, tree_context_tag_style, tag_bottom, debug, focus_tint, syntax_bold, verbose, message_animation, ligatures, cursor_blink, selection_glow, hover_glow, occlusion, parallax };
     /// A bundled post pass, a Shadertoy file in shaders/post/: the CRT, and
     /// G4's bloom, vignette and grain (docs/effects.md).
     pub const Scene = enum { crt, bloom, vignette, grain };
@@ -963,6 +967,7 @@ pub const Runtime = struct {
         .{ .word = "SelectionGlow", .action = .{ .toggle = .selection_glow }, .availability = .lift, .doc = "A soft halo of the selection's colour round it in the body, on or off." },
         .{ .word = "HoverGlow", .action = .{ .toggle = .hover_glow }, .availability = .lift, .doc = "A soft underline of light under the word a look-hover would open, on or off." },
         .{ .word = "Occlusion", .action = .{ .toggle = .occlusion }, .availability = .lift, .doc = "Pane bodies darken faintly toward their edges, on or off." },
+        .{ .word = "Parallax", .action = .{ .toggle = .parallax }, .availability = .lift, .doc = "A theme's page pattern moves with the text at a quarter of its speed, on or off." },
         .{ .word = "Lift", .action = .lift, .availability = .lift, .doc = "How the focused pane stands off the page: off, shadow, rim or auto." },
         .{ .word = "Motion", .action = .motion, .doc = "How animations move: off, crisp, smooth, bouncy or playful." },
         .{ .word = "InactiveDim", .action = .inactive_dim, .doc = "Fade the unfocused panes' text by a percentage, 0 through 100, 0 off." },
@@ -1039,9 +1044,9 @@ pub const Runtime = struct {
                 .toggle => |field| if (field == .ligatures) {
                     if (setting.availability != .ligatures)
                         @compileError("the ligatures toggle must use the ligatures capability");
-                } else if (field == .cursor_blink or field == .selection_glow or field == .hover_glow or field == .occlusion) {
+                } else if (field == .cursor_blink or field == .selection_glow or field == .hover_glow or field == .occlusion or field == .parallax) {
                     if (setting.availability != .lift)
-                        @compileError("CursorBlink, SelectionGlow, HoverGlow and Occlusion must use the lift capability (a pixel shell's)");
+                        @compileError("CursorBlink, SelectionGlow, HoverGlow, Occlusion and Parallax must use the lift capability (a pixel shell's)");
                 } else if (setting.availability != null)
                     @compileError("unconditional toggles cannot carry a backend capability"),
                 else => if (setting.availability != null)
@@ -1699,6 +1704,7 @@ pub const Runtime = struct {
                     .selection_glow => "SelectionGlow on\n",
                     .hover_glow => "HoverGlow on\n",
                     .occlusion => "Occlusion on\n",
+                    .parallax => "Parallax on\n",
                 },
                 .shell => "Shell requested (new panes) fish\n",
                 .tagline_size => "TaglineSize 73\n",
diff --git a/src/detached/wire.zig b/src/detached/wire.zig
index 3a914e42..6903a1e8 100644
--- a/src/detached/wire.zig
+++ b/src/detached/wire.zig
@@ -270,6 +270,7 @@ pub const Frame = struct {
             region.notice = try r.getByte();
             region.clip = try r.getU16();
             region.lift = @bitCast(try r.getU32());
+            region.line = @bitCast(try r.getU32());
             // A springy flavour overshoots, and a wind-up dips below.
             if (!(region.lift >= -1 and region.lift <= 2)) return error.BadValue;
             if (region.rect.x > f.cols or region.rect.w > f.cols - region.rect.x or
@@ -754,7 +755,7 @@ pub fn layersBound(layers: []const pardes.Layer, tags: []const pardes.Layer, reg
     return n + regions.len * region_len + chrome_len;
 }
 
-const region_len = 1 + 1 + 4 + 8 + 1 + 2 + 2 + 1 + 2 + 4;
+const region_len = 1 + 1 + 4 + 8 + 1 + 2 + 2 + 1 + 2 + 4 + 4;
 /// The palette: each colour three bytes, a theme's optional ones a flag
 /// before them.
 const chrome_len = @typeInfo(pardes.Chrome).@"struct".fields.len * 4 + 8 * 4;
@@ -839,6 +840,7 @@ pub fn encodeFrameLayers(out: []u8, cols: u16, rows: u16, cursor: ?Cursor, point
             try w.putByte(region.notice);
             try w.putU16(region.clip);
             try w.putU32(@bitCast(region.lift));
+            try w.putU32(@bitCast(region.line));
         }
         inline for (@typeInfo(pardes.Chrome).@"struct".fields) |field| {
             const rgb = @field(chrome, field.name);
diff --git a/src/draw.zig b/src/draw.zig
index 027326fa..aef93f51 100644
--- a/src/draw.zig
+++ b/src/draw.zig
@@ -63,7 +63,8 @@ pub fn place(p: *Pardes, s: *Surface) void {
         // A folded pane is its tag rows and nothing else.
         if (pane.collapsed) continue;
         const body_h = r.h -| pane.tag_rows;
-        s.addRegion(.{ .kind = .body, .owner = owner, .serial = pane.serial, .active = active, .rect = .{ .x = r.x + config.GUTTER, .y = body_y, .w = r.w - config.GUTTER, .h = body_h } });
+        const line: i32 = if (pane.file) |f| @intCast(@min(f.scroll, std.math.maxInt(i32))) else if (pane.isTerminal()) panes.Terminal.gridOffset(pane) else 0;
+        s.addRegion(.{ .kind = .body, .owner = owner, .serial = pane.serial, .active = active, .line = line, .rect = .{ .x = r.x + config.GUTTER, .y = body_y, .w = r.w - config.GUTTER, .h = body_h } });
         var rail: Region = .{ .kind = .rail, .owner = owner, .serial = pane.serial, .active = active, .rect = .{ .x = r.x, .y = body_y, .w = config.GUTTER, .h = body_h } };
         // An image's rail has no thumb; a native PDF's is measured as its
         // pages are placed (Pdf.draw); every other pane's is here.
@@ -472,7 +473,7 @@ pub fn render(p: *Pardes, arena: std.mem.Allocator) !*Surface {
         .rail_px = @intCast(@min(255, @as(u32, p.theme().rail_px orelse 12) * p.settings.grip_width / 100)),
         .name_ink = chrome.tag_name_fg,
         .active_name_ink = if (p.settings.focus_tint) chrome.tag_active_name_fg else chrome.tag_name_fg,
-        .fx = @as(u8, @intFromBool(p.settings.selection_glow)) | @as(u8, @intFromBool(p.settings.hover_glow)) << 1 | @as(u8, @intFromBool(p.settings.occlusion)) << 2,
+        .fx = @as(u8, @intFromBool(p.settings.selection_glow)) | @as(u8, @intFromBool(p.settings.hover_glow)) << 1 | @as(u8, @intFromBool(p.settings.occlusion)) << 2 | @as(u8, @intFromBool(p.settings.parallax)) << 3,
     };
     if (p.theme().decor) |decor| {
         s.chrome.decor_dots = decor.page_dots;
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index 8d9c29ab..dc58ee3f 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -5827,6 +5827,17 @@ fn renderFrame(
     if (surface.chrome.fx & 2 == 0 or surface.panelTracks().len != 0) g.hover_glow = .{ .now_ns = g.sel_glow.now_ns };
     if (g.glide.moving()) g.glide.offset = g.glide.spring.value(g.glide.now_ns);
     cell_decor = CellDecor.of(chrome);
+    // G13: a body's dots follow its text at a quarter of its speed: its
+    // first line, and a glide's picture offset, in rows.
+    if (chrome.fx & 8 != 0 and chrome.decor_dots != null) for (surface.regionList()) |region| {
+        if (region.kind != .body or cell_decor.nbodies == cell_decor.bodies.len) continue;
+        var rows: f32 = @floatFromInt(region.line);
+        if (g.glide.moving() and g.glide.pane == region.owner) rows += g.glide.offset;
+        const period = cell_decor.uniforms[4];
+        cell_decor.bodies[cell_decor.nbodies] = bodyPixels(region, layout);
+        cell_decor.shifts[cell_decor.nbodies] = @mod(-rows * layout.h * 0.25, period);
+        cell_decor.nbodies += 1;
+    };
     // Plaques need an opaque window: with WindowOpacity under 100 the cells
     // are drawn as they are, and the plaques not at all.
     cell_decor.plaques_off = backgroundOpacity(g.applied_window_opacity) < 1;
@@ -7004,7 +7015,13 @@ fn emitInstance(
             (cell_decor.inPlaque(px0 + 0.5, py0 + 0.5) or cell_decor.inPlaque(px0 + layout.w - 0.5, py0 + 0.5)))
             instances[idx].effect |= clear_bg_bit;
         if (cell_decor.dots) |dotted| {
-            if (!resolved.clear_bg and std.mem.eql(u8, &resolved.bg, &dotted)) instances[idx].effect |= dotted_bit;
+            if (!resolved.clear_bg and std.mem.eql(u8, &resolved.bg, &dotted)) {
+                instances[idx].effect |= dotted_bit;
+                // G13: the dots under a body move with its text, a quarter
+                // as far; the serial slot carries it (the shader reads it
+                // as the dots' offset alone).
+                instances[idx].serial = @bitCast(cell_decor.parallaxAt(px0 + 0.5, py0 + 0.5));
+            }
         }
         if (cell_decor.title) |inks| {
             if (resolved.role == .tagline and (std.mem.eql(u8, &resolved.fg, &inks[0]) or std.mem.eql(u8, &resolved.fg, &inks[1]))) instances[idx].effect |= title_bit;
@@ -8954,6 +8971,17 @@ const CellDecor = struct {
     grounds: [2][3]u8 = .{ .{ 0, 0, 0 }, .{ 0, 0, 0 } },
     plaques_off: bool = false,
 
+    /// G13: each body's rectangle and how far its dots have moved.
+    bodies: [pardes.MAX_PANES][4]f32 = undefined,
+    shifts: [pardes.MAX_PANES]f32 = undefined,
+    nbodies: usize = 0,
+
+    fn parallaxAt(decor: *const CellDecor, x: f32, y: f32) f32 {
+        for (decor.bodies[0..decor.nbodies], decor.shifts[0..decor.nbodies]) |band, shift|
+            if (x >= band[0] and x < band[2] and y >= band[1] and y < band[3]) return shift;
+        return 0;
+    }
+
     fn inPlaque(decor: *const CellDecor, x: f32, y: f32) bool {
         for (decor.plaques[0..decor.nplaques]) |band|
             if (x >= band[0] and x < band[2] and y >= band[1] and y < band[3]) return true;
@@ -9740,6 +9768,33 @@ test "occlusion shades each body's edges, inside it, never a tag, a grip or the
     try std.testing.expect(shades >= 4);
 }
 
+test "a body tells its first line, and lapis's dots under it move a quarter as far" {
+    const gpa = std.testing.allocator;
+    const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+    defer core.deinit();
+    const pane = try core.setTestFile("line\n" ** 80);
+    pane.scrollBy(8);
+    try std.testing.expect(core.executeBuiltinLine(0, "Theme lapis"));
+    core.settings.parallax = true;
+    for (0..40) |_| core.update(.tick);
+    pardes.test_api.sync(core);
+    const s = try core.render(core.scratch.allocator());
+    const body = for (s.regionList()) |region| {
+        if (region.kind == .body) break region;
+    } else return error.NoBody;
+    try std.testing.expectEqual(@as(i32, 8), body.line);
+    try std.testing.expect(s.chrome.fx & 8 != 0);
+    // The shift the cell shader is handed: a quarter of 8 rows of 20 px,
+    // upward, within the dots' period.
+    var decor = CellDecor.of(&s.chrome);
+    const period = decor.uniforms[4];
+    decor.bodies[0] = .{ 0, 0, 800, 480 };
+    decor.shifts[0] = @mod(-8.0 * 20.0 * 0.25, period);
+    decor.nbodies = 1;
+    try std.testing.expectApproxEqAbs(@mod(-40.0, period), decor.parallaxAt(10, 10), 1e-4);
+    try std.testing.expectEqual(@as(f32, 0), decor.parallaxAt(900, 10));
+}
+
 /// What a bundled post pass leaves alone (Post.Frame.spare), in window
 /// pixels: every tag with its grip, the column and workspace tags, and the
 /// notices, the chrome the focus indicators live in. A grip, the gap after
diff --git a/src/surface.zig b/src/surface.zig
index 02e4bb5d..d1ea78b1 100644
--- a/src/surface.zig
+++ b/src/surface.zig
@@ -370,6 +370,10 @@ pub const Region = struct {
     /// focus (Lift, on a spring), a notice's while Lift is on. A pixel shell
     /// casts a soft shadow from it; the tier it is drawn in never changes.
     lift: f32 = 0,
+    /// A body's view: the first line it shows (a file's scroll, a
+    /// terminal's grid offset), for what a pixel shell moves with the text
+    /// (G13's parallax).
+    line: i32 = 0,
     /// Cells the column-move rail takes off the right edge while it runs
     /// there: layers and pixel shells stop short of them, the grid does not.
     clip: u16 = 0,
@@ -451,7 +455,7 @@ pub const Chrome = struct {
     /// A pixel shell's small effects: bit 0 a glow round the body's
     /// selection (G9, SelectionGlow), bit 1 one under the word a look-hover
     /// would open (G11, HoverGlow), bit 2 the bodies' edge shade (G12,
-    /// Occlusion).
+    /// Occlusion), bit 3 the page pattern's parallax (G13, Parallax).
     fx: u8 = 0,
 };
 
-- 
cgit v1.3


From 52f9c1423bc4e58079b008e763b5485ae49911f7 Mon Sep 17 00:00:00 2001
From: Gabriel Schneider <gbrls@0x4200.cafe>
Date: Tue, 29 Sep 2026 08:37:12 -0300
Subject: G14: Afterglow, changed text glows a moment and fades

Afterglow on|off (off, a pixel shell's; Chrome.fx bit 4): the GUI keeps
the grid it last drew and when each cell changed; a body cell whose text
changed glows in the theme's accent, at most 18% and under the text's
contrast floor, fading with an ease-out over 250 ms, one flat rectangle a
run of cells that changed together; never a tag or a grip, the cursor or a
selection; a scrolled body (its first line moved) starts over rather than
lighting up whole. On the continuous path while anything glows.

Tests: three changed cells glow as a run of two (the cursor's left out),
gone by 250 ms, a scroll lights nothing. Gates as before; goldens
byte-identical. Feel review: .scratch/render/afterglow/.
---
 docs/config.md  |   2 +
 docs/effects.md |  10 ++++
 src/config.zig  |  12 +++--
 src/draw.zig    |   2 +-
 src/gui/gui.zig | 154 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 src/surface.zig |   3 +-
 6 files changed, 177 insertions(+), 6 deletions(-)

(limited to 'src/surface.zig')

diff --git a/docs/config.md b/docs/config.md
index 97bf95a1..c66b124e 100644
--- a/docs/config.md
+++ b/docs/config.md
@@ -580,6 +580,8 @@ Occlusion on     pane bodies darken faintly toward their edges (2%), never
                  over the cursor
 Parallax on      a theme's page pattern (lapis's dots) moves with the text
                  at a quarter of its speed
+Afterglow on     text that changes glows for a moment in the theme's accent
+                 and fades (250 ms), never on a tag, the cursor or a selection
 CursorBlink on   the cursor blinks, solid while typing and half a second
                  after, eased at each edge, solid after 10 idle seconds
 GripWidth 150    the grip's button and the scrollbar under it, percent of the
diff --git a/docs/effects.md b/docs/effects.md
index fbb44dfa..6a283e45 100644
--- a/docs/effects.md
+++ b/docs/effects.md
@@ -47,6 +47,7 @@ why. The verdict is the user's.
 | G11 look-hover glow | `HoverGlow on\|off` (off) | a soft underline of the theme's accent under the word a look-hover would open, fading in over 80 ms | .scratch/render/hover/ (forge, acme, lapis; zooms) | pending |
 | G12 ambient occlusion | `Occlusion on\|off` (off) | pane bodies darken toward their edges, at most 2% (§9.1: 1 to 2%) | .scratch/render/occlusion/ (on/off on forge, acme, lapis; acme-diff-x40.png) | pending |
 | G13 parallax | `Parallax on\|off` (off) | a theme's page pattern under the bodies (lapis's dots) moves with the text at a quarter of its speed, glides included | .scratch/render/parallax/ (lapis, notches down and up) | pending |
+| G14 afterglow | `Afterglow on\|off` (off) | a body cell whose text changed glows in the accent at 18% and fades over 250 ms | .scratch/render/afterglow/ (forge, acme: two in-place edits) | pending |
 
 ## Motion flavours
 
@@ -237,3 +238,12 @@ so they drift with the text as it glides and settle with it (measured: 4
 lines at 35 px move the 22 px grid 13 px, 35 mod 22). The cell shader
 reads the offset from the instance's serial slot, free since G7 took the
 dissolve's per-cell noise out. Without a pattern, nothing happens.
+
+Notes on G14: the GUI keeps the grid it last drew and when each cell last
+changed; a changed cell of a pane body glows in the theme's accent, 18% at
+most and under the text's contrast floor, and fades with an ease-out over
+250 ms, drawn as one flat rectangle a run of cells that changed together.
+Never on a tag or a grip (bodies only), the cursor's cell or a selection;
+a body whose first line moved (a scroll) starts over instead of lighting
+up whole. It runs on the continuous path while anything glows, and costs
+a compare of the grid a frame while on, nothing while off.
diff --git a/src/config.zig b/src/config.zig
index d11cbe76..2a764118 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -126,6 +126,7 @@ pub const leader_path = paths: {
     if (builtins.capabilities.lift) table.set(.HoverGlow, null);
     if (builtins.capabilities.lift) table.set(.Occlusion, null);
     if (builtins.capabilities.lift) table.set(.Parallax, null);
+    if (builtins.capabilities.lift) table.set(.Afterglow, null);
     if (builtins.capabilities.lift) table.set(.Lift, null);
     table.set(.Motion, null);
     table.set(.InactiveDim, null);
@@ -682,6 +683,9 @@ pub const Runtime = struct {
     /// G13: a theme's page pattern under the bodies (lapis's dots) moves
     /// with the text at a quarter of its speed, a pixel shell's.
     parallax: bool = false,
+    /// G14: text that changes glows for a moment in the theme's accent and
+    /// fades, a pixel shell's.
+    afterglow: bool = false,
     /// How long a message stays after the key or click that dismisses it.
     message_linger_ms: u16 = 800,
     /// How long its fall into the row takes, easing out (§8.1: arriving,
@@ -905,7 +909,7 @@ pub const Runtime = struct {
     /// The message timings a setting word sets, each in milliseconds.
     pub const MessageTime = enum { linger, fall, dissolve };
 
-    pub const Toggle = enum { colors, wrap, tree_context_tag_style, tag_bottom, debug, focus_tint, syntax_bold, verbose, message_animation, ligatures, cursor_blink, selection_glow, hover_glow, occlusion, parallax };
+    pub const Toggle = enum { colors, wrap, tree_context_tag_style, tag_bottom, debug, focus_tint, syntax_bold, verbose, message_animation, ligatures, cursor_blink, selection_glow, hover_glow, occlusion, parallax, afterglow };
     /// A bundled post pass, a Shadertoy file in shaders/post/: the CRT, and
     /// G4's bloom, vignette and grain (docs/effects.md).
     pub const Scene = enum { crt, bloom, vignette, grain };
@@ -968,6 +972,7 @@ pub const Runtime = struct {
         .{ .word = "HoverGlow", .action = .{ .toggle = .hover_glow }, .availability = .lift, .doc = "A soft underline of light under the word a look-hover would open, on or off." },
         .{ .word = "Occlusion", .action = .{ .toggle = .occlusion }, .availability = .lift, .doc = "Pane bodies darken faintly toward their edges, on or off." },
         .{ .word = "Parallax", .action = .{ .toggle = .parallax }, .availability = .lift, .doc = "A theme's page pattern moves with the text at a quarter of its speed, on or off." },
+        .{ .word = "Afterglow", .action = .{ .toggle = .afterglow }, .availability = .lift, .doc = "Text that changes glows for a moment and fades, on or off." },
         .{ .word = "Lift", .action = .lift, .availability = .lift, .doc = "How the focused pane stands off the page: off, shadow, rim or auto." },
         .{ .word = "Motion", .action = .motion, .doc = "How animations move: off, crisp, smooth, bouncy or playful." },
         .{ .word = "InactiveDim", .action = .inactive_dim, .doc = "Fade the unfocused panes' text by a percentage, 0 through 100, 0 off." },
@@ -1044,9 +1049,9 @@ pub const Runtime = struct {
                 .toggle => |field| if (field == .ligatures) {
                     if (setting.availability != .ligatures)
                         @compileError("the ligatures toggle must use the ligatures capability");
-                } else if (field == .cursor_blink or field == .selection_glow or field == .hover_glow or field == .occlusion or field == .parallax) {
+                } else if (field == .cursor_blink or field == .selection_glow or field == .hover_glow or field == .occlusion or field == .parallax or field == .afterglow) {
                     if (setting.availability != .lift)
-                        @compileError("CursorBlink, SelectionGlow, HoverGlow, Occlusion and Parallax must use the lift capability (a pixel shell's)");
+                        @compileError("CursorBlink, SelectionGlow, HoverGlow, Occlusion, Parallax and Afterglow must use the lift capability (a pixel shell's)");
                 } else if (setting.availability != null)
                     @compileError("unconditional toggles cannot carry a backend capability"),
                 else => if (setting.availability != null)
@@ -1705,6 +1710,7 @@ pub const Runtime = struct {
                     .hover_glow => "HoverGlow on\n",
                     .occlusion => "Occlusion on\n",
                     .parallax => "Parallax on\n",
+                    .afterglow => "Afterglow on\n",
                 },
                 .shell => "Shell requested (new panes) fish\n",
                 .tagline_size => "TaglineSize 73\n",
diff --git a/src/draw.zig b/src/draw.zig
index aef93f51..93d5b2d9 100644
--- a/src/draw.zig
+++ b/src/draw.zig
@@ -473,7 +473,7 @@ pub fn render(p: *Pardes, arena: std.mem.Allocator) !*Surface {
         .rail_px = @intCast(@min(255, @as(u32, p.theme().rail_px orelse 12) * p.settings.grip_width / 100)),
         .name_ink = chrome.tag_name_fg,
         .active_name_ink = if (p.settings.focus_tint) chrome.tag_active_name_fg else chrome.tag_name_fg,
-        .fx = @as(u8, @intFromBool(p.settings.selection_glow)) | @as(u8, @intFromBool(p.settings.hover_glow)) << 1 | @as(u8, @intFromBool(p.settings.occlusion)) << 2 | @as(u8, @intFromBool(p.settings.parallax)) << 3,
+        .fx = @as(u8, @intFromBool(p.settings.selection_glow)) | @as(u8, @intFromBool(p.settings.hover_glow)) << 1 | @as(u8, @intFromBool(p.settings.occlusion)) << 2 | @as(u8, @intFromBool(p.settings.parallax)) << 3 | @as(u8, @intFromBool(p.settings.afterglow)) << 4,
     };
     if (p.theme().decor) |decor| {
         s.chrome.decor_dots = decor.page_dots;
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index dc58ee3f..b631a1cb 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -1874,6 +1874,8 @@ const Gui = struct {
     /// last drawn, for their fade-in.
     sel_glow: SelGlow = .{},
     hover_glow: SelGlow = .{},
+    /// G14: the cells last drawn and when each last changed.
+    afterglow: Afterglow = .{},
 
     /// The cursor's blink (blinkNow): when the frame drawn last arrived,
     /// a redraw owed for an edge, and this frame's cursor mode and alpha.
@@ -2583,6 +2585,7 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
     defer c.ui_font_free(g.font);
     defer gpa.free(g.scroll_edge); // grown on demand by stepScroll
     defer g.glide.deinit(gpa);
+    defer g.afterglow.deinit(gpa);
     resetGlyphAtlas(&g);
 
     if (attach) |requested| return attachRequested(gpa, &g, requested);
@@ -4997,7 +5000,7 @@ fn stepGlide(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
     const glide = &g.glide;
     // The glide runs on the core's continuous path: frames every loop, and
     // a virtual clock carried on.
-    defer core.shell_continuous = glide.moving() or g.sel_glow.fading or g.hover_glow.fading;
+    defer core.shell_continuous = glide.moving() or g.sel_glow.fading or g.hover_glow.fading or g.afterglow.glowing;
     glide.now_ns = core.now_ns;
     glide.motion = pardes.animation.Motion.of(core.settings.motion);
     if (!glide.spring.settled) {
@@ -5823,6 +5826,7 @@ fn renderFrame(
     g.sel_glow.now_ns = if (core) |p| p.now_ns else c.SDL_GetTicksNS();
     // Off, or while panes move, no glow and nothing fading.
     if (surface.chrome.fx & 1 == 0 or surface.panelTracks().len != 0) g.sel_glow = .{ .now_ns = g.sel_glow.now_ns };
+    if (surface.chrome.fx & 16 == 0) g.afterglow.glowing = false;
     g.hover_glow.now_ns = g.sel_glow.now_ns;
     if (surface.chrome.fx & 2 == 0 or surface.panelTracks().len != 0) g.hover_glow = .{ .now_ns = g.sel_glow.now_ns };
     if (g.glide.moving()) g.glide.offset = g.glide.spring.value(g.glide.now_ns);
@@ -8761,6 +8765,8 @@ fn buildDecor(g: *Gui, gpa: std.mem.Allocator, surface: *const pardes.Surface, g
             if (index == 0 and groups.tracks == 0 and chrome.fx & 1 != 0) try glowBlocks(g, gpa, surface, .selection, layout, win_w, win_h);
             // G11: a glow under the word a look-hover would open.
             if (index == 0 and groups.tracks == 0 and chrome.fx & 2 != 0) try glowBlocks(g, gpa, surface, .hover, layout, win_w, win_h);
+            // G14: what changed glows, while nothing moves.
+            if (index == 0 and groups.tracks == 0 and chrome.fx & 16 != 0) try afterglowDecor(g, gpa, surface, layout, win_w, win_h);
             // G12: the bodies' edges shaded, a pane's in its own group.
             if (chrome.fx & 4 != 0) try occlusion(g, gpa, placed, groups, index, surface, ceilings, layout, win_w, win_h, track);
             // A single spine runs down each column, through every tag and body.
@@ -9193,6 +9199,91 @@ fn occlusion(g: *Gui, gpa: std.mem.Allocator, regions: []const pardes.Region, gr
     }
 }
 
+/// G14's state: the grid last drawn, when each cell last changed, and each
+/// body's line then (a scroll changes every cell and is not a change).
+const Afterglow = struct {
+    cells: []pardes.Cell = &.{},
+    changed: []u64 = &.{},
+    cols: u16 = 0,
+    rows: u16 = 0,
+    lines: [pardes.MAX_PANES]i32 = @splat(std.math.minInt(i32)),
+    /// A cell still glows: the core keeps frames coming.
+    glowing: bool = false,
+
+    fn deinit(glow: *Afterglow, gpa: std.mem.Allocator) void {
+        gpa.free(glow.cells);
+        gpa.free(glow.changed);
+    }
+};
+
+const afterglow_ns: u64 = 250 * std.time.ns_per_ms;
+
+/// G14: a cell of a pane body whose text changed since the last frame
+/// glows in the theme's accent at 18% and fades out over 250 ms with an
+/// ease-out, as a run of cells a row. Never on a tag or a grip (bodies
+/// only), the cursor or a selection; a body whose view moved (a scroll)
+/// starts over rather than lighting up whole.
+fn afterglowDecor(g: *Gui, gpa: std.mem.Allocator, surface: *const pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32) !void {
+    const glow = &g.afterglow;
+    const now = g.sel_glow.now_ns;
+    const n = @as(usize, surface.cols) * surface.rows;
+    const fresh = glow.cols != surface.cols or glow.rows != surface.rows or glow.cells.len != n;
+    if (fresh) {
+        glow.cells = try gpa.realloc(glow.cells, n);
+        glow.changed = try gpa.realloc(glow.changed, n);
+        @memcpy(glow.cells, surface.cells);
+        @memset(glow.changed, 0);
+        glow.cols = surface.cols;
+        glow.rows = surface.rows;
+    }
+    const chrome = &surface.chrome;
+    const page = chrome.page orelse bg_default;
+    const fg = chrome.fg orelse fg_default;
+    const cap = @min(0.18, lightenCeiling(fg, page, chrome.accent));
+    var glowing = false;
+    for (surface.regionList()) |body| {
+        if (body.kind != .body or body.owner >= glow.lines.len) continue;
+        const scrolled = glow.lines[body.owner] != body.line;
+        glow.lines[body.owner] = body.line;
+        var row = body.rect.y;
+        while (row < body.rect.y + body.rect.h and row < surface.rows) : (row += 1) {
+            var run_start: ?u16 = null;
+            var run_age: u64 = 0;
+            var col = body.rect.x;
+            while (col <= body.rect.x + body.rect.w and col <= surface.cols) : (col += 1) {
+                var age: ?u64 = null;
+                if (col < body.rect.x + body.rect.w and col < surface.cols) {
+                    const at = @as(usize, row) * surface.cols + col;
+                    const cell = surface.cells[at];
+                    const differs = !std.meta.eql(cell.style, glow.cells[at].style) or !std.mem.eql(u8, cell.grapheme(), glow.cells[at].grapheme()) or cell.default != glow.cells[at].default;
+                    if (differs and !fresh) glow.changed[at] = if (scrolled) 0 else now;
+                    const selected = !cell.default and switch (cell.style.bg) {
+                        .rgb => |rgb| std.mem.eql(u8, &rgb, &chrome.sel_bg),
+                        else => false,
+                    };
+                    const cursor_here = if (surface.cursor) |cu| cu.x == col and cu.y == row else false;
+                    const since = now -| glow.changed[at];
+                    if (glow.changed[at] != 0 and since < afterglow_ns and !selected and !cursor_here) age = since;
+                }
+                // A run is cells that changed together.
+                if (run_start) |start| if (age == null or age.? != run_age) {
+                    const t = @as(f32, @floatFromInt(run_age)) / @as(f32, @floatFromInt(afterglow_ns));
+                    const fade = (1 - t) * (1 - t) * (1 - t);
+                    try addDecor(g, gpa, @as(f32, @floatFromInt(start)) * layout.w, @as(f32, @floatFromInt(row)) * layout.h, @as(f32, @floatFromInt(col)) * layout.w, @as(f32, @floatFromInt(row + 1)) * layout.h, chrome.accent, cap * fade, null, win_w, win_h);
+                    glowing = true;
+                    run_start = null;
+                };
+                if (age) |a| if (run_start == null) {
+                    run_start = col;
+                    run_age = a;
+                };
+            }
+        }
+    }
+    @memcpy(glow.cells, surface.cells);
+    glow.glowing = glowing;
+}
+
 /// A theme's tag plaques (Chrome.decor_box_*), drawn under the cells of
 /// group `index`: each pane tag, and with the still panes the column and
 /// workspace tags, becomes a framed box inside its own band with a hard
@@ -9795,6 +9886,67 @@ test "a body tells its first line, and lapis's dots under it move a quarter as f
     try std.testing.expectEqual(@as(f32, 0), decor.parallaxAt(900, 10));
 }
 
+test "changed text glows and fades in 250 ms; the cursor and a scroll do not light up" {
+    const gpa = std.testing.allocator;
+    const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+    defer core.deinit();
+    const pane = try core.setTestFile("line\n" ** 60);
+    core.settings.afterglow = true;
+    pardes.test_api.sync(core);
+    const s = try core.render(core.scratch.allocator());
+    const body = for (s.regionList()) |region| {
+        if (region.kind == .body) break region;
+    } else return error.NoBody;
+    s.cursor = .{ .x = body.rect.x + 12, .y = body.rect.y + 2 };
+    var g: Gui = undefined;
+    g.decor = .empty;
+    defer g.decor.deinit(gpa);
+    g.cell_w = 10;
+    g.cell_h = 20;
+    g.afterglow = .{};
+    defer g.afterglow.deinit(gpa);
+    const layout = fixedCellLayout(&g);
+    const Count = struct {
+        fn glows(items: []const CellInstance, accent: [3]u8) usize {
+            var n: usize = 0;
+            for (items) |item| {
+                const rgb: [3]u8 = .{ @intFromFloat(@round(item.br * 255)), @intFromFloat(@round(item.bg * 255)), @intFromFloat(@round(item.bb * 255)) };
+                if (std.mem.eql(u8, &rgb, &accent) and item.fr > 0.001) n += 1;
+            }
+            return n;
+        }
+    };
+    g.sel_glow = .{ .now_ns = std.time.ns_per_s };
+    try afterglowDecor(&g, gpa, s, layout, 800, 480);
+    try std.testing.expectEqual(@as(usize, 0), g.decor.items.len);
+    // Three cells of a row change, the cursor's among them.
+    for (10..13) |x| {
+        const cell = &s.cells[@as(usize, body.rect.y + 2) * s.cols + body.rect.x + x];
+        cell.* = .{ .default = false, .style = .{ .fg = .{ .rgb = .{ 1, 2, 3 } } } };
+        cell.text[0] = 'X';
+        cell.len = 1;
+    }
+    g.sel_glow.now_ns += 16 * std.time.ns_per_ms;
+    try afterglowDecor(&g, gpa, s, layout, 800, 480);
+    try std.testing.expectEqual(@as(usize, 1), Count.glows(g.decor.items, s.chrome.accent));
+    const lit = g.decor.items[0];
+    // Two cells wide: the cursor's is left out.
+    try std.testing.expectApproxEqAbs(@as(f32, 2 * 10 * 2.0 / 800.0), lit.x1 - lit.x0, 1e-4);
+    try std.testing.expect(g.afterglow.glowing);
+    // Gone by 250 ms.
+    g.decor.clearRetainingCapacity();
+    g.sel_glow.now_ns += 260 * std.time.ns_per_ms;
+    try afterglowDecor(&g, gpa, s, layout, 800, 480);
+    try std.testing.expectEqual(@as(usize, 0), g.decor.items.len);
+    try std.testing.expect(!g.afterglow.glowing);
+    // A scroll changes every cell and lights none.
+    pane.scrollBy(5);
+    const scrolled = try core.render(core.scratch.allocator());
+    g.sel_glow.now_ns += 16 * std.time.ns_per_ms;
+    try afterglowDecor(&g, gpa, scrolled, layout, 800, 480);
+    try std.testing.expectEqual(@as(usize, 0), g.decor.items.len);
+}
+
 /// What a bundled post pass leaves alone (Post.Frame.spare), in window
 /// pixels: every tag with its grip, the column and workspace tags, and the
 /// notices, the chrome the focus indicators live in. A grip, the gap after
diff --git a/src/surface.zig b/src/surface.zig
index d1ea78b1..22a71a27 100644
--- a/src/surface.zig
+++ b/src/surface.zig
@@ -455,7 +455,8 @@ pub const Chrome = struct {
     /// A pixel shell's small effects: bit 0 a glow round the body's
     /// selection (G9, SelectionGlow), bit 1 one under the word a look-hover
     /// would open (G11, HoverGlow), bit 2 the bodies' edge shade (G12,
-    /// Occlusion), bit 3 the page pattern's parallax (G13, Parallax).
+    /// Occlusion), bit 3 the page pattern's parallax (G13, Parallax), bit 4
+    /// changed text's afterglow (G14, Afterglow).
     fx: u8 = 0,
 };
 
-- 
cgit v1.3