Skip to content

Node-based terminal manager for AI coding agents — tmux-backed terminals and parallel agent sessions as draggable nodes on an infinite pan/zoom canvas. macOS, Linux, and a browser Server Edition.

feat(glass): Glass slider from Clear to Tinted, with refraction

iceclatterWTaaa7256bbae7
diff --git a/CLAUDE.md b/CLAUDE.md
index 4da1068af..7815c3bf2 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -3883,6 +3883,25 @@ glass never sits over plain black; a wallpaper the user chose is never replaced.
glass header are ink over a tinted chip (`-webkit-text-fill-color: var(--text)` with the chip
mixed from `currentColor`), not coloured text. `styles.palette.test.ts` pins the mapping and that
no two meanings resolve to the same colour, in both themes.
+- **Glass slider + refraction** (Settings → Appearance, shown only under Liquid Glass; iOS 26's
+ Clear ↔ Tinted). `settings.glassTint` is a slider POSITION, not an alpha (`null` = the Readable
+ tick, read through `resolveGlassSlider`): every surface has its own readable alpha, so each maps
+ the position through three points — `GLASS_CLEAR_ALPHA` 0.2 at Clear, its OWN computed readable
+ alpha at `GLASS_READABLE_TICK` (0.7), `max(readable, 0.95)` at Tinted (`glassSliderAlpha`). At the
+ tick every surface is exactly at the alpha `glassTintAlpha`/`glassChromeAlpha` computed, and every
+ alpha right of it is higher — so Readable→Tinted keeps 4.5:1; left of the tick the row says the
+ guarantee is off. Measured: chrome dark 0.20 / 0.70 / 0.95, chrome light 0.20 / 0.745 / 0.95,
+ nodeterm-dark 0.20 / 0.675 / 0.95 (Clear / Readable / Tinted). App.tsx sets `--glass-t` (blur
+ 16→28px, saturation 200→145%) and `--glass-sheen`. **Refraction** is ONE shared SVG filter
+ (`components/GlassRefraction.tsx`, `#nt-refract`: a 256² edge-lens displacement map generated once,
+ `primitiveUnits="objectBoundingBox"` so one filter fits every element), referenced from
+ `--glass-blur` as `url(#nt-refract)` — no per-node filters. Its scale is `0.06 × (1 − t)`; it moves
+ backdrop pixels, never the tint, so it cannot touch contrast. The specular sheen is a background
+ gradient scaled by `glassSheen(t)`, which is ZERO from the tick on — it lightens the surface, so it
+ may only exist where the promise is already off. Node blur+refraction still pause while the camera
+ moves (`.canvas-moving`); chrome keeps both. MEASURED on the live dev build (CDP computed style):
+ Chromium keeps `url("#nt-refract") blur(…) saturate(…)` on the tab bar, dock, sessions sidebar,
+ minimap, zoom controls and terminal nodes.
- **Surfaces.** Desktop: full. Server Edition: gradients + glass; the stills list is empty (not
macOS) and "Choose image…" is hidden (a picker there browses the SERVER's disk). Relay tabs keep
a stub (no stills, import refused). Mobile: N/A (no canvas). Kanban: N/A (the board is opaque).
diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index 78f744574..414b5c12c 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -19,7 +19,8 @@ import { resolveUiScale } from '../shared/ui-scale'
import { resolveTabBarHeight } from '../shared/window-chrome-metrics'
import { useAppTheme } from './state/useAppTheme'
import { installWindowActivityOnDocument } from './lib/windowActivity'
-import { glassChromeAlpha, parseCssColor } from './lib/glassContrast'
+import { glassChromeAlpha, glassSheen, glassSliderAlpha, parseCssColor, resolveGlassSlider } from './lib/glassContrast'
+import { GlassRefraction } from './components/GlassRefraction'
import { isLiquidGlass } from './lib/appTheme'
export default function App() {
@@ -81,11 +82,16 @@ export default function App() {
// stays the one source of truth; declared after the data-theme effect, so it reads the tokens
// of the theme that effect just applied. An unparseable token leaves the chrome opaque.
const liquidGlass = isLiquidGlass(useSettings((s) => s.settings.appTheme))
+ // The Glass slider moves every surface between Clear and Tinted through its own readable alpha
+ // (glassSliderAlpha); `--glass-t` scales the blur and `--glass-sheen` the specular wash in CSS.
+ const glassSlider = resolveGlassSlider(useSettings((s) => s.settings.glassTint))
useEffect(() => {
const root = document.documentElement
if (!liquidGlass) {
delete root.dataset.ntGlass
root.style.removeProperty('--glass-chrome-bg')
+ root.style.removeProperty('--glass-t')
+ root.style.removeProperty('--glass-sheen')
return
}
// Read the tokens with the glass overrides OFF: under them `--panel` IS the glass fill, and a
@@ -94,14 +100,18 @@ export default function App() {
const css = getComputedStyle(root)
const text = css.getPropertyValue('--text').trim()
const panel = css.getPropertyValue('--panel').trim()
- const alpha = glassChromeAlpha(text, panel)
+ const readable = glassChromeAlpha(text, panel)
const rgb = parseCssColor(panel)?.rgb
root.style.setProperty(
'--glass-chrome-bg',
- alpha !== null && rgb ? `rgba(${rgb.join(', ')}, ${alpha.toFixed(3)})` : panel
+ readable !== null && rgb
+ ? `rgba(${rgb.join(', ')}, ${glassSliderAlpha(glassSlider, readable).toFixed(3)})`
+ : panel
)
+ root.style.setProperty('--glass-t', glassSlider.toFixed(3))
+ root.style.setProperty('--glass-sheen', glassSheen(glassSlider).toFixed(3))
root.dataset.ntGlass = 'on'
- }, [liquidGlass, appTheme])
+ }, [liquidGlass, appTheme, glassSlider])
// Apply the UI scale as page zoom (issue #299 — 4K readability; the why-page-zoom write-up
// lives in shared/ui-scale.ts). Gated on `hydrated` so boot doesn't flash-reset a scaled window
@@ -130,6 +140,7 @@ export default function App() {
{/* The node-icon picker, opened from the node menu, a node header and the kanban card
modal — one dialog for all three, driven by nodeIconDialog(). */}
<NodeIconDialogHost />
+ {liquidGlass && <GlassRefraction slider={glassSlider} />}
</ReactFlowProvider>
</SessionProvider>
)
diff --git a/src/renderer/components/GlassRefraction.tsx b/src/renderer/components/GlassRefraction.tsx
new file mode 100644
index 000000000..98440e279
--- /dev/null
+++ b/src/renderer/components/GlassRefraction.tsx
@@ -0,0 +1,58 @@
+import { glassRefraction } from '../lib/glassContrast'
+
+/**
+ * The ONE refraction filter every Liquid Glass surface references (`backdrop-filter:
+ * url(#nt-refract) …`, styles.css `--glass-refract`). An edge lens: a displacement map that is
+ * neutral in the middle and pushes the backdrop outward near the edges, so the picture bends at a
+ * surface's rim the way it does under Apple's glass. `primitiveUnits="objectBoundingBox"` scales it
+ * to whatever element uses it, so one filter serves nodes, menus and the tab bar alike.
+ */
+let mapUrl: string | null = null
+
+/** The displacement map, generated once per renderer (R = x push, G = y push, 128 = none). */
+function displacementMap(): string {
+ if (mapUrl) return mapUrl
+ const size = 256
+ const edge = 0.12
+ const canvas = document.createElement('canvas')
+ canvas.width = canvas.height = size
+ const ctx = canvas.getContext('2d')
+ if (!ctx) return (mapUrl = '')
+ const img = ctx.createImageData(size, size)
+ const push = (u: number): number => (u < edge ? -(1 - u / edge) : u > 1 - edge ? 1 - (1 - u) / edge : 0)
+ for (let y = 0; y < size; y++) {
+ const dy = push(y / (size - 1))
+ for (let x = 0; x < size; x++) {
+ const dx = push(x / (size - 1))
+ const i = (y * size + x) * 4
+ img.data[i] = 128 + 127 * Math.sign(dx) * dx * dx
+ img.data[i + 1] = 128 + 127 * Math.sign(dy) * dy * dy
+ img.data[i + 2] = 128
+ img.data[i + 3] = 255
+ }
+ }
+ ctx.putImageData(img, 0, 0)
+ return (mapUrl = canvas.toDataURL())
+}
+
+export function GlassRefraction({ slider }: { slider: number }) {
+ const map = displacementMap()
+ if (!map) return null
+ return (
+ <svg width="0" height="0" aria-hidden style={{ position: 'absolute' }}>
+ <filter
+ id="nt-refract"
+ x="0"
+ y="0"
+ width="100%"
+ height="100%"
+ colorInterpolationFilters="sRGB"
+ primitiveUnits="objectBoundingBox"
+ >
+ <feImage href={map} x="0" y="0" width="1" height="1" preserveAspectRatio="none" result="map" />
+ <feGaussianBlur in="SourceGraphic" stdDeviation="0.004" result="soft" />
+ <feDisplacementMap in="soft" in2="map" scale={glassRefraction(slider)} xChannelSelector="R" yChannelSelector="G" />
+ </filter>
+ </svg>
+ )
+}
diff --git a/src/renderer/components/settings/sections/AppearanceSection.tsx b/src/renderer/components/settings/sections/AppearanceSection.tsx
index 82cae8bc6..161f2d633 100644
--- a/src/renderer/components/settings/sections/AppearanceSection.tsx
+++ b/src/renderer/components/settings/sections/AppearanceSection.tsx
@@ -1,6 +1,7 @@
import { useEffect, useState } from 'react'
import { useSettings } from '../../../state/settings'
import { isLiquidGlass } from '@renderer/lib/appTheme'
+import { GLASS_READABLE_TICK, resolveGlassSlider } from '@renderer/lib/glassContrast'
import { showCanvasDots } from '@renderer/lib/canvasDots'
import {
defaultWallpaper,
@@ -69,6 +70,10 @@ const ROWS = {
'native'
]
},
+ glassTint: {
+ title: 'Glass',
+ keywords: ['glass', 'liquid', 'transparency', 'clear', 'tinted', 'frosted', 'blur', 'opacity']
+ },
canvasDots: {
title: 'Show grid dots',
keywords: ['grid', 'dots', 'dot', 'canvas', 'background', 'pattern']
@@ -337,6 +342,7 @@ export function AppearanceSection({ isActive }: { isActive: boolean }): React.JS
const hiddenHeaderButtons = useSettings((s) => s.settings.hiddenHeaderButtons)
const showResumeCard = useSettings((s) => s.settings.showResumeCard)
const canvasDots = useSettings((s) => s.settings.canvasDots)
+ const glassSlider = resolveGlassSlider(useSettings((s) => s.settings.glassTint))
const windowTitleActiveSession = useSettings((s) => s.settings.windowTitleActiveSession)
const update = useSettings((s) => s.update)
// Glass over plain black reads as a dark theme with smudges, so choosing Liquid Glass with no
@@ -382,6 +388,54 @@ export function AppearanceSection({ isActive }: { isActive: boolean }): React.JS
}
/>
</SearchableRow>
+ {isLiquidGlass(appTheme) && (
+ <SearchableRow {...ROWS.glassTint}>
+ <FieldRow
+ label="Glass"
+ description={
+ glassSlider < GLASS_READABLE_TICK
+ ? 'Clearer than Readable: the wallpaper shows through more, and text contrast is no longer guaranteed.'
+ : 'From Readable to Tinted, regular text keeps 4.5:1 contrast over any wallpaper.'
+ }
+ control={
+ <div className="flex w-56 flex-col gap-1">
+ <input
+ type="range"
+ min={0}
+ max={1}
+ step={0.01}
+ list="nt-glass-ticks"
+ value={glassSlider}
+ aria-label="Glass, from Clear to Tinted"
+ aria-valuetext={
+ Math.abs(glassSlider - GLASS_READABLE_TICK) < 0.005
+ ? 'Readable'
+ : `${Math.round(glassSlider * 100)}% tinted`
+ }
+ onChange={(e) => update({ glassTint: Number(e.target.value) })}
+ className="w-full accent-[var(--accent)]"
+ />
+ <datalist id="nt-glass-ticks">
+ <option value={GLASS_READABLE_TICK} label="Readable" />
+ </datalist>
+ <div className="relative h-4 text-[11px] text-muted">
+ <span className="absolute left-0">Clear</span>
+ <button
+ type="button"
+ className="absolute -translate-x-1/2 hover:text-text"
+ style={{ left: `${GLASS_READABLE_TICK * 100}%` }}
+ onClick={() => update({ glassTint: null })}
+ title="Back to the readable point"
+ >
+ Readable
+ </button>
+ <span className="absolute right-0">Tinted</span>
+ </div>
+ </div>
+ }
+ />
+ </SearchableRow>
+ )}
<SearchableRow {...ROWS.uiScale}>
<UiScaleRow />
</SearchableRow>
diff --git a/src/renderer/lib/glassContrast.test.ts b/src/renderer/lib/glassContrast.test.ts
index ac1db97ef..a83c9391f 100644
--- a/src/renderer/lib/glassContrast.test.ts
+++ b/src/renderer/lib/glassContrast.test.ts
@@ -12,7 +12,15 @@ import {
glassChromeAlpha,
parseCssColor,
parseHex,
- worstContrast
+ worstContrast,
+ GLASS_CLEAR_ALPHA,
+ GLASS_READABLE_TICK,
+ GLASS_TINTED_ALPHA,
+ glassRefraction,
+ glassSheen,
+ glassSliderAlpha,
+ glassTint,
+ resolveGlassSlider
} from './glassContrast'
const WHITE = [255, 255, 255] as const
@@ -133,3 +141,60 @@ describe('glassChromeAlpha (Liquid Glass chrome, both app themes)', () => {
expect(glassChromeAlpha('nope', '#000')).toBeNull()
})
})
+
+describe('Glass slider (Clear ↔ Tinted)', () => {
+ const css = readFileSync(join(__dirname, '..', 'styles.css'), 'utf8').replace(/\r\n/g, '\n')
+ const body = (sel: string): string => {
+ const i = css.indexOf(`\n${sel} {\n`)
+ return css.slice(i, css.indexOf('\n}\n', i))
+ }
+ const tok = (b: string, n: string) => new RegExp(`\\n\\s*${n}:\\s*([^;]+);`).exec(b)?.[1].trim()
+ const dark = body(':root')
+ const light = body(":root[data-theme='light']")
+ const chrome = (b: string): number => {
+ const tint = tok(b, '--tint-rgb') ?? tok(dark, '--tint-rgb')!
+ const text = (tok(b, '--text') ?? tok(dark, '--text')!).replace('var(--tint-rgb)', tint)
+ return glassChromeAlpha(text, tok(b, '--panel')!)!
+ }
+ const surfaces: Array<[string, number]> = [
+ ['chrome dark', chrome(dark)],
+ ['chrome light', chrome(light)],
+ ...TERMINAL_THEMES.map((t) => [t.id, glassTintAlpha(t.theme.foreground!, t.theme.background!)] as [string, number])
+ ]
+
+ it.each(surfaces)('%s: the Readable tick is exactly the computed 4.5:1 alpha', (_id, readable) => {
+ expect(glassSliderAlpha(GLASS_READABLE_TICK, readable)).toBeCloseTo(readable, 10)
+ })
+
+ it.each(surfaces)('%s: alpha rises monotonically from Clear to Tinted', (_id, readable) => {
+ let prev = -1
+ for (let i = 0; i <= 100; i++) {
+ const a = glassSliderAlpha(i / 100, readable)
+ expect(a).toBeGreaterThanOrEqual(prev)
+ prev = a
+ }
+ expect(glassSliderAlpha(0, readable)).toBe(GLASS_CLEAR_ALPHA)
+ expect(glassSliderAlpha(1, readable)).toBe(Math.max(readable, GLASS_TINTED_ALPHA))
+ })
+
+ it('an untouched or hand-mangled setting is the Readable tick; numbers clamp', () => {
+ for (const v of [null, undefined, 'x', Number.NaN, Infinity]) expect(resolveGlassSlider(v)).toBe(GLASS_READABLE_TICK)
+ expect(resolveGlassSlider(-3)).toBe(0)
+ expect(resolveGlassSlider(7)).toBe(1)
+ })
+
+ it('the sheen appears only left of the tick; refraction fades to nothing at Tinted', () => {
+ expect(glassSheen(0)).toBe(1)
+ for (const t of [GLASS_READABLE_TICK, 0.85, 1]) expect(glassSheen(t)).toBe(0)
+ expect(glassRefraction(0)).toBeGreaterThan(glassRefraction(GLASS_READABLE_TICK))
+ expect(glassRefraction(1)).toBe(0)
+ })
+
+ it('a terminal tint follows the slider', () => {
+ const t = TERMINAL_THEMES.find((x) => x.id === 'nodeterm-dark') ?? TERMINAL_THEMES[0]
+ const at = (s: number) => Number(/, ([\d.]+)\)$/.exec(glassTint(t.theme, s)!.background)![1])
+ expect(at(0)).toBeLessThan(at(GLASS_READABLE_TICK))
+ expect(at(GLASS_READABLE_TICK)).toBeCloseTo(glassTintAlpha(t.theme.foreground!, t.theme.background!), 3)
+ expect(at(1)).toBeGreaterThanOrEqual(at(GLASS_READABLE_TICK))
+ })
+})
diff --git a/src/renderer/lib/glassContrast.ts b/src/renderer/lib/glassContrast.ts
index c90f64f8e..a1a2c6d7e 100644
--- a/src/renderer/lib/glassContrast.ts
+++ b/src/renderer/lib/glassContrast.ts
@@ -114,12 +114,16 @@ export interface GlassTint {
foreground: string
}
-/** CSS for a theme's glass, or null when its background is not a colour we can parse. */
-export function glassTint(theme: { background?: string; foreground?: string }): GlassTint | null {
+/** CSS for a theme's glass at a Glass-slider position (default: the Readable tick), or null when
+ * its background is not a colour we can parse. */
+export function glassTint(
+ theme: { background?: string; foreground?: string },
+ slider: number = GLASS_READABLE_TICK
+): GlassTint | null {
const bg = theme.background ? parseHex(theme.background) : null
if (!bg) return null
const foreground = theme.foreground ?? '#ffffff'
- const alpha = glassTintAlpha(foreground, theme.background!)
+ const alpha = glassSliderAlpha(slider, glassTintAlpha(foreground, theme.background!))
const rgb = bg.join(', ')
return {
background: `rgba(${rgb}, ${alpha.toFixed(3)})`,
@@ -186,3 +190,54 @@ export function glassChromeAlpha(text: string, panel: string, minRatio = 4.5): n
if (lowest === Infinity) return 1
return Math.max(GLASS_ALPHA_MIN, lowest)
}
+
+/* ------------------------------------------------------------------------------------------- *
+ * The Glass slider (Settings → Appearance, Liquid Glass only): Clear ↔ Tinted, like iOS 26.
+ *
+ * One setting drives every glass surface, and every surface has its OWN readable alpha (the chrome
+ * fill, each terminal theme). So the slider is not an alpha: it is a position `t` in 0..1, and each
+ * surface maps it through three points — Clear at 0, its own readable alpha at the Readable tick,
+ * Tinted at 1. At the tick every surface sits exactly at the alpha the functions above computed,
+ * which is why the tick can promise 4.5:1; right of it every alpha is higher, and the scans above
+ * return the bottom of a range that reaches opaque, so the promise holds all the way to Tinted.
+ * Left of the tick is clearer than the guarantee, and the Settings row says so.
+ * ------------------------------------------------------------------------------------------- */
+
+/** Tint alpha at the Clear end: never fully clear, the tint still says where a surface is. */
+export const GLASS_CLEAR_ALPHA = 0.2
+/** Tint alpha at the Tinted end (a surface whose readable alpha is higher keeps its own). */
+export const GLASS_TINTED_ALPHA = 0.95
+/** Where the Readable tick sits on the track — also the default, so an untouched slider is the
+ * look Liquid Glass shipped with. 0.7 is close to where the chrome's readable alpha falls on a
+ * straight Clear→Tinted scale (dark 0.70 → 0.67, light 0.745 → 0.73), so the track reads as
+ * roughly linear. */
+export const GLASS_READABLE_TICK = 0.7
+
+/** `settings.glassTint` → a slider position. Absent / not a finite number = the Readable tick. */
+export function resolveGlassSlider(value: unknown): number {
+ return typeof value === 'number' && Number.isFinite(value)
+ ? Math.min(1, Math.max(0, value))
+ : GLASS_READABLE_TICK
+}
+
+/** The tint alpha of a surface whose readable alpha is `readable`, at slider position `t`. */
+export function glassSliderAlpha(t: number, readable: number): number {
+ const tinted = Math.max(readable, GLASS_TINTED_ALPHA)
+ if (t <= GLASS_READABLE_TICK) {
+ return GLASS_CLEAR_ALPHA + ((readable - GLASS_CLEAR_ALPHA) * t) / GLASS_READABLE_TICK
+ }
+ return readable + ((tinted - readable) * (t - GLASS_READABLE_TICK)) / (1 - GLASS_READABLE_TICK)
+}
+
+/** Specular sheen strength, 0..1: full at Clear, ZERO from the Readable tick on — the sheen is a
+ * white wash under the text, so it may only appear where the contrast promise is already off. */
+export function glassSheen(t: number): number {
+ return Math.max(0, (GLASS_READABLE_TICK - t) / GLASS_READABLE_TICK)
+}
+
+/** Edge-lens displacement (feDisplacementMap `scale`, objectBoundingBox units): strongest at
+ * Clear, flat at Tinted. It moves backdrop pixels, never the tint, so it cannot touch contrast. */
+export const GLASS_REFRACT_MAX = 0.06
+export function glassRefraction(t: number): number {
+ return GLASS_REFRACT_MAX * (1 - t)
+}
diff --git a/src/renderer/nodes/TerminalNode.tsx b/src/renderer/nodes/TerminalNode.tsx
index f75658d1e..b7c6c900a 100644
--- a/src/renderer/nodes/TerminalNode.tsx
+++ b/src/renderer/nodes/TerminalNode.tsx
@@ -179,7 +179,7 @@ import { useCopyFeedback } from '../terminal/useCopyFeedback'
import { ContextMeter } from '../components/ContextMeter'
import { isZoomModifierHeld } from '../lib/zoomModifier'
import { isHidden } from '../lib/ui-visibility'
-import { glassTint } from '../lib/glassContrast'
+import { glassTint, resolveGlassSlider } from '../lib/glassContrast'
import { isLiquidGlass } from '../lib/appTheme'
import { resolveTerminalTheme } from '../terminal/themes'
import { readsClaudeTranscript } from '../lib/transcriptGates'
@@ -1249,9 +1249,10 @@ export function TerminalNode({
// translucent tint of THIS node's effective theme — project override included — at the alpha
// that keeps its foreground at 4.5:1 over any backdrop (lib/glassContrast.ts).
const glass = isLiquidGlass(useSettings((s) => s.settings.appTheme))
+ const glassSlider = resolveGlassSlider(useSettings((s) => s.settings.glassTint))
const glassVars = useMemo(() => {
if (!glass) return null
- const tint = glassTint(resolveTerminalTheme(visual.terminalTheme).theme)
+ const tint = glassTint(resolveTerminalTheme(visual.terminalTheme).theme, glassSlider)
return tint
? ({
'--term-glass-bg': tint.background,
@@ -1259,7 +1260,7 @@ export function TerminalNode({
'--term-glass-fg': tint.foreground
} as React.CSSProperties)
: null
- }, [glass, visual.terminalTheme])
+ }, [glass, glassSlider, visual.terminalTheme])
// The account list, for the chip and for the READERS below: a config dir the user links while
// this pane sits quiet must resolve to its new account immediately, not at the next hook event.
const claudeAccounts = useSettings((s) => s.settings.claudeAccounts)
diff --git a/src/renderer/styles.css b/src/renderer/styles.css
index 4b19401b4..bed2d42fe 100644
--- a/src/renderer/styles.css
+++ b/src/renderer/styles.css
@@ -13533,7 +13533,26 @@ body.focus-mode .dock:hover {
--surface-overlay: var(--glass-chrome-bg);
--tabbar-bg: var(--glass-chrome-bg);
--glass-edge: rgba(var(--tint-rgb), 0.2);
- --glass-blur: blur(24px) saturate(160%);
+ /* The Glass slider (App.tsx sets the live values inline; these are the Readable-tick defaults):
+ `--glass-t` 0 = Clear … 1 = Tinted, `--glass-sheen` the specular wash (0 from the tick on).
+ Clearer glass blurs a little less and saturates a little more, and refracts at its rim
+ (`#nt-refract`, components/GlassRefraction.tsx — its strength also follows the slider). */
+ --glass-t: 0.7;
+ --glass-sheen: 0;
+ --glass-refract: url(#nt-refract);
+ --glass-blur: var(--glass-refract) blur(calc(16px + 12px * var(--glass-t)))
+ saturate(calc(200% - 55% * var(--glass-t)));
+ /* A diagonal light across the surface, strongest at the top-left rim. Painted as a background
+ layer (under the content), and only left of the Readable tick: it lightens the surface, so it
+ may only appear where the contrast promise is already off. */
+ --glass-sheen-image: linear-gradient(
+ 135deg,
+ rgba(255, 255, 255, calc(0.22 * var(--glass-sheen))) 0%,
+ rgba(255, 255, 255, calc(0.04 * var(--glass-sheen))) 22%,
+ rgba(255, 255, 255, 0) 50%,
+ rgba(255, 255, 255, calc(0.06 * var(--glass-sheen))) 85%,
+ rgba(255, 255, 255, calc(0.14 * var(--glass-sheen))) 100%
+ );
}
/* Outermost chrome: fill + blur. */
@@ -13564,6 +13583,7 @@ body.focus-mode .dock:hover {
.nt-settings
) {
background: var(--glass-chrome-bg) !important;
+ background-image: var(--glass-sheen-image) !important;
-webkit-backdrop-filter: var(--glass-blur);
backdrop-filter: var(--glass-blur);
}
@@ -13591,6 +13611,7 @@ body.focus-mode .dock:hover {
background: var(--glass-chrome-bg);
}
:root[data-nt-glass='on'] :is(.term-node, .files-node, .loop-node, .subagent-node, .trigger-node, .dino-node) {
+ background-image: var(--glass-sheen-image);
-webkit-backdrop-filter: var(--glass-blur);
backdrop-filter: var(--glass-blur);
}
diff --git a/src/shared/types.ts b/src/shared/types.ts
index a4f9417e1..7db7f56ad 100644
--- a/src/shared/types.ts
+++ b/src/shared/types.ts
@@ -1693,6 +1693,9 @@ export interface Settings {
/** Draw the canvas dot grid (Settings → Appearance). Display only — snapping and align-to-grid
* are unchanged. Default ON in every appearance; read through `showCanvasDots`. */
canvasDots: boolean
+ /** The Liquid Glass slider (Settings → Appearance), 0 = Clear … 1 = Tinted. null = the Readable
+ * tick, where text keeps 4.5:1 (renderer/lib/glassContrast.ts `resolveGlassSlider`). */
+ glassTint: number | null
/** Whether usage percentages render as consumed ("32% used"), remaining ("68% left"), or raw
* token counts ("48k/200k tokens" — context-window surfaces only; provider quota surfaces
* have no token counts and fall back to 'used' display). 'remaining' is the historical
@@ -1938,6 +1941,7 @@ export const DEFAULT_SETTINGS: Settings = {
// reads as noise to users who navigate by the trail chords/Dock buttons instead.
showResumeCard: false,
canvasDots: true,
+ glassTint: null,
usagePercentMode: 'remaining',
defaultAgent: 'claude',
// Sessions start in auto mode out of the box. Existing users pick this up on hydrate