Seaglass

Seaglass

A soft-pastel frosted glass theme for Zed, built from an original palette. The editor, panels, tabs and bars stay translucent over a blurred window, while every floating surface (command palette, completions, hovers, menus, tooltips) is fully opaque so nothing bleeds through the text you are reading.

Variants

Four levels, dark and light (eight variants). One material, four thicknesses - the level only changes how much of your wallpaper survives behind the window:

The light family runs one notch thicker at every level, on purpose. The two appearances are not symmetric: a dark tint over a bright wallpaper merely lightens the substrate, and light text tolerates that for a long while, whereas a light tint has to keep the substrate near-white for dark text to work - so any wallpaper that is not itself bright eats the contrast very fast. Equal alphas are exactly what made the old "Light Airy" unreadable. Matching legibility instead of matching alpha is what makes the pair feel like siblings.

On glass levels the tint is painted once, by the app background. The editor, panels, bars and terminal are transparent panes over that one layer. This is important because Zed reuses editor.background and panel.background inside nested components such as Project Panel rows, Agent inputs and code blocks. Giving those tokens their own translucent tint stacks the same colour two or three times and produces dark rectangles. Separation now comes only from borders and explicit interaction states. The audit enforces both rules: all base pane tokens have zero alpha and editor/chrome ΔL remains 0.

This is a Zed limitation rather than a missing Agent-specific colour: inputs currently reuse editor.background, and Project Panel rows reuse panel.background. Zed tracks the alpha-stacking problem in zed#41425. Until dedicated tokens exist, painting the glass once is the only rule that remains correct at every nesting depth.

Blur itself is not a theme setting: the radius comes from the OS compositor. What the levels change is the thickness and the tone of the tint on top of it.

Rule of thumb: transparency and legibility trade against each other. Pick the airiest level that still reads comfortably on your wallpaper - if code starts to fight the background, go one level deeper. The Solid pair is a plain opaque theme (background.appearance: "opaque") with the exact same palette, so switching costs you nothing but the glass.

Platform notes

Glass depends on the window compositor, not on Zed alone.

• macOS - works out of the box.
• Linux - works on Wayland/X11 compositors that blur behind windows.
• Windows - works, with caveats: see below.

An opaque window or titlebar override in your settings also cancels the glass.

Windows

What Zed actually does on Windows (verified in crates/gpui_windows of the Zed source, not guessed):

• background.appearance: "blurred" calls the undocumented SetWindowCompositionAttribute with ACCENT_ENABLE_ACRYLICBLURBEHIND. DWM supplies the blur; the tint comes from the theme (Zed passes an essentially transparent gradient colour), which is why the level you pick is what you see.
• That call is skipped on Windows 10 builds older than 17763 (1809). Nothing turns black though: the window is per-pixel transparent anyway (a DirectComposition swap chain with premultiplied alpha), so you get plain transparency without blur.
• The system switch Settings → Personalization → Colors → Transparency effects governs DWM transparency, and Windows turns it off in battery/energy saver. With it off, expect the blur to go away (Microsoft's own guidance is that acrylic falls back to a solid colour).
• If you run Zed with GPUI_DISABLE_DIRECT_COMPOSITION=1 (a workaround for some GPU drivers), the swap chain is created with DXGI_ALPHA_MODE_IGNORE: alpha is discarded and translucent surfaces render muddy. Use a Solid variant there.
• Zed defaults to ClearType subpixel antialiasing on Windows. Subpixel antialiasing over a translucent surface is what makes small text look fringed and smeared (zed#41230, closed as not planned). Grayscale antialiasing fixes it.

So, a Windows setup that behaves:

{
  "theme": {
    "mode": "system",
    "dark": "Seaglass Deep",       // or Seaglass Solid to skip the compositor
    "light": "Seaglass Light Deep"
  },
  // stops ClearType fringing on translucent surfaces
  "text_rendering_mode": "grayscale"
}

The theme also does its part: the app-level background always provides a tint under text, while nested pane tokens stay transparent so Zed cannot compound their alpha. Floating reading surfaces remain fully opaque.

Legibility

Every foreground colour in the theme is solved for a contrast target instead of being picked by eye. Each role belongs to a tier:

The target is checked against the worst case of the appearance: the airiest level composited over a mid-tone wallpaper. Lightness is adjusted in OkLCh, so hue and chroma - the identity of the palette - are untouched. In practice the dark palette comes out identical to the original one (text, accents and all nine syntax colours); only comments, hints, disabled text and the whole light palette needed to move.

The light column is stricter because the WCAG formula is not symmetric either: a dark variant gains contrast quickly as the wallpaper darkens, a light variant barely gains anything as it brightens. That extra half point is what stops the light family from looking washed out next to its dark sibling.

A light theme on a near-white substrate must use dark, saturated accents - pastels on white cannot reach 5.5:1, which is why the light variants used to be illegible. To keep them from all flattening to the same darkness, the light palette inherits the contrast rhythm of the dark one: the relative spacing between hues is measured on the dark family and re-applied (damped, see RHYTHM_DAMPING) to the light family, so lavender still reads deeper than sand rather than every colour landing on one lightness.

Run the audit yourself:

python3 scripts/build_theme.py --check

It ends with a sweep: the worst readable-text contrast of every variant over five reference wallpapers (black → white), so you can see at a glance which level stops coping with your desktop.

If you want even more weight behind the glass without changing the theme, bump the font weight in your settings (a theme cannot do this for you):

"buffer_font_weight": 500,
"ui_font_weight": 500

How it's built

themes/seaglass.json is generated - do not hand-edit it. One palette plus one role map produces all eight variants:

python3 scripts/build_theme.py            # regenerate themes/seaglass.json
python3 scripts/build_theme.py --check    # audit contrast per variant
python3 scripts/build_theme.py --palette  # dump the resolved palette

Only the standard library is needed. All 186 theme keys that Zed supports are assigned in every variant, so nothing falls back to a Zed default. To tweak the theme, edit the palette, the level alphas or the role map at the top of scripts/build_theme.py and regenerate. The three knobs that change the feel of the theme are LEVELS (glass thickness per appearance), TARGETS (contrast per tier) and RHYTHM_DAMPING (how strongly the light palette mirrors the dark one's colour spacing).

Install locally (dev extension)

1. Open Zed.
2. Command palette → zed: install dev extension.
3. Select this folder (seaglass-theme/).
4. Open the theme selector (theme selector: toggle) and pick Seaglass (or Seaglass Light).

To point your settings at it directly:

"theme": {
  "mode": "system",
  "light": "Seaglass Light", // level: Airy / (none) / Deep / Solid
  "dark": "Seaglass"
}

No experimental.theme_overrides needed — everything is baked into the theme.

Publish to the Zed extension registry

1. Push this repo to GitHub (keep repository in extension.toml in sync).
2. Fork zed-industries/extensions.
3. Add this repo as a submodule in your fork:

   git submodule add https://github.com/mrcoolbay/seaglass-theme.git extensions/seaglass-theme

4. Add an entry to extensions.toml:

   [seaglass-theme]
   submodule = "extensions/seaglass-theme"
   version = "0.2.1"

5. Run pnpm sort-extensions, commit, and open a pull request.

License

MIT © MrCoolBay