AI pill: several Ollama servers (pills.ai.servers, comma-separated, in order): the model list shows all their models, a question goes to the first server that has the chosen one; a local ollama is started only when no other server has it

A playing pill cost the iGPU about 2.9 ms and the CPU 3.7 ms a frame, 60 frames a
second: two vello passes over the whole island window for the surface's shadow and
gradients (vello keeps no gradient between frames) and one for the bars. Now 0.4 ms
GPU and 1.2 ms CPU. The open card went from 5.2 to 2.6 ms GPU and 6.2 to 3.4 ms CPU
a frame. surface.wgsl draws every design's shadow, fill and inner gradient in one
pass, with vello's own blurred-rectangle formula

README.md

@@ -2,7 +2,7 @@
 
 A Dynamic-Island-style media widget for Amane (Rust Wayland shell library), running on Hyprland. It sits as a small pill at the top centre of the screen and opens into a now-playing card.
 
-- **Pill:** cover thumbnail, title, 7 live bars from the shown player's own sound (lows left, highs right, growing up and down from the middle), or a pause sign. With no player open, an idle pill: a music note and "Nothing playing".
+- **Pill:** cover thumbnail, title, 7 live bars from the shown player's own sound (lows left, highs right, growing up and down from the middle), or a pause sign. With no player open, an idle pill: a music note and "Nothing playing". It opens too, into the last song played (kept across restarts) with Play, which starts its player and asks it to play, and chips that start the players of `island.idle.players` (desktop file names, `gtk-launch`).
 - **Card:** a still CD of the cover ringed by 40 cava "candles", title and artist, a seekable time bar, previous / play-pause / next.
 - **Player switcher** ("VIA …" chip): every MPRIS player; picking one pins it, otherwise the island follows whichever plays.
 - **Output switcher:** moves only the shown player's audio to another device.
@@ -115,10 +115,10 @@ Whether the open card takes the song cover's colours instead (`appearance.colors
 
 Two small one-icon pills sit left of the island and two right of it, on every monitor; they move outward while the island opens. A click morphs a pill into its card. Only one card is open across the shell: opening the island closes a card, and opening a card closes the island. Esc, the cross or a click elsewhere closes it.
 
-- **AI** (sparkle): a chat with a local Ollama model, `gemma4:e4b` at `http://localhost:11434` by default. Answers stream in through curl. When Ollama doesn't answer, the shell starts the OpenRC service with `doas rc-service ollama start` (`pills.ai.start_service`). Stop ends an answer and New chat starts over. Nothing leaves the machine.
-- **System** (pulse): CPU, GPU clock, memory, network and disk read/write as graphs over the last minute, plus the hottest sensors. Everything is read from `/proc` and `/sys`, so there is no process list. Processes opens `ghostty --class=amane.monitor -e btm` on the special workspace `monitor`; a second press shows or hides it.
-- **Home** (house): `~/.face` as the avatar (a person glyph until the file exists), a greeting, the date, a big clock, and Munich's weather now and for four days from open-meteo (no key). The month grid dots the days with events. The iCloud calendar shows the coming events once you sign in from the card with your Apple ID and an [app-specific password](https://account.apple.com). The password goes into the keyring through `secret-tool` (libsecret, so a Secret Service like gnome-keyring or KeePassXC has to run), never into `config.toml`. The calendar is read over CalDAV from `pills.calendar.server`, so other CalDAV servers work too.
-- **Notifications** (bell, with the unread count): Amane is the notification daemon (`org.freedesktop.Notifications`), so dunst must not run; it is commented out in `~/.config/hypr/autocmds.lua` (the old file is beside it as `autocmds.lua.before-amane-notifications`). Popups appear at the top right of the focused monitor with the app's icon or image, summary, body (simple markup) and action buttons. They time out by urgency (critical ones stay) and wait while the pointer is over them. A click runs the default action. The card lists the history, newest first; each entry's cross deletes it, and Clear all deletes everything. Mute turns popups off.
+- **AI** (sparkle): a chat with an Ollama model on your own servers, `gemma4:e4b` at `http://localhost:11434` by default. `pills.ai.servers` takes several, comma-separated, in order: the model chip in the header lists every server's models (each once, with its server when there are several) and switches at once, and a question goes to the first server that has the chosen model. Answers stream in through curl. When Ollama doesn't answer, the shell starts the OpenRC service with `doas rc-service ollama start` (`pills.ai.start_service`). Stop ends an answer and New chat starts over. Nothing goes to a cloud service, only to the servers listed.
+- **System** (pulse): CPU, the integrated GPU's clock, the external GPU's load (with its video memory and the programs on it, formerly in the control centre), memory, swap, network and disk read/write as graphs over the last minute, plus the hottest sensors with icons, in cool/warm/hot colours (`pills.monitor.warm|hot`). Everything is read from `/proc` and `/sys`, so there is no process list. Processes opens `ghostty --class=amane.monitor -e btm` on the special workspace `monitor`; a second press shows or hides it.
+- **Home** (house): `~/.face` as the avatar (a person glyph until the file exists), a greeting, the date, a big clock, and Munich's weather now and for four days from open-meteo (no key), over a photo of the current weather (`~/.config/amane/weather/<kind>-<day|night>.jpg`, downloaded once from Wikimedia Commons, credits in `weather/CREDITS.md`; swap any file, `pills.home.photo_opacity` tones it down). A big month grid marks events (dots in their calendars' colours), birthdays from your iCloud contacts (a cake) and the public holidays of `pills.calendar.holidays` (BY by default); click a day for its list. Events can be created, edited and deleted there (a series: title, place and calendar only). For iCloud, set `pills.calendar.account` to your Apple ID and store an [app-specific password](https://account.apple.com) in the keyring: `secret-tool store --label='Magic Island calendar' service amane-calendar account <Apple ID>` (gnome-keyring or another Secret Service has to run). The password never goes into `config.toml`. Other CalDAV/CardDAV servers work through `pills.calendar.server` and `contacts_server`.
+- **Notifications** (bell, with the unread count): Amane is the notification daemon (`org.freedesktop.Notifications`), so dunst must not run; it is commented out in `~/.config/hypr/autocmds.lua` (the old file is beside it as `autocmds.lua.before-amane-notifications`). Popups appear at the top right of the focused monitor with the app's icon or image, summary, body (simple markup) and action buttons. They time out by urgency (critical ones stay) and wait while the pointer is over them. A click runs the default action. The card lists the history, newest first; each entry's cross deletes it, and Clear all deletes everything. Mute app keeps an app's notifications in the history without popups; Block app drops them (`notifications.apps.muted|blocked`, undone from chips at the top of the card). Do not disturb turns all popups off.
 
 `amane ipc call pods open|toggle ai|monitor|home|notifications [monitor]`, `close`, `ask <question>`, `processes`, `notices list|dismiss <id>|clear`, `status`. Sizes, colours, poll intervals, the city and its coordinates, the model and the popup timeouts are under Side pills and Notifications in the [settings](#settings).
 
@@ -128,11 +128,17 @@ Left out on purpose: phone stats (iOS shares nothing Linux can read without extr
 
 Every setting lives in `~/.config/amane/config.toml`: sizes, timings, text sizes, colours, poll intervals, equalizer presets and bands, the hotspot profile, the extra Sound output. The shell writes the file with every setting and its explanation the first time it starts (moving `cover_colors`, `transition_ms`, `hotspot` and `extra_output` over from an old `shell.conf`, which it no longer reads). Saving the file applies it at once; a line left out takes its default, and a line the shell can't use is listed at the top of the config window. The font and the cava bar count take effect on restart.
 
-The config window edits the same file: Settings at the foot of the control centre, or `amane ipc call config toggle`. It is a normal window with a page per part of the shell, a page per Hyprland category, and a search over everything. Numbers with a range get a slider and a field, switches toggle, colours show a swatch; a typed value applies on Enter. Reset brings back the default.
+The config window edits the same file: Settings at the foot of the control centre, or `amane ipc call config toggle`. It is a normal window with a page per part of the shell, a page per Hyprland category, and a search over everything; typing with no field selected (as right after opening it) goes into the search. Numbers with a range get a slider and a field, switches toggle, colours show a swatch; a typed value applies on Enter. Reset brings back the default.
 
 ### Glass
 
-`appearance.surface.design` picks what the island, the pills, the tray menu, the control centre and its popups are made of: `solid` (the wallpaper's gradient with an accent glow), `frosted` (a thin tint, a hairline white rim, a sheen along the top, a soft shadow) or `liquid` (clear glass, denser toward the bottom right, a light-catching edge, the accent's glow). Each design's opacity, rim and light are settings of their own (`appearance.solid|frosted|liquid.*`); the look itself is `src/surface.rs`. On see-through glass a face fades with `.opacity()` instead of a veil, a GPU layer only while it fades.
+`appearance.surface.design` picks what the island, the pills, the tray menu, the control centre and its popups are made of: `solid` (the wallpaper's gradient with an accent glow), `frosted` (a thin tint, a hairline white rim, a sheen along the top, a soft shadow) or `liquid` (clear glass, denser toward the bottom right, a light-catching edge, the accent's glow). Each design's opacity, rim and light are settings of their own (`appearance.solid|frosted|liquid.*`); the look itself is `src/surface.rs`, drawn by one shader (`src/surface.wgsl`: the shadow, the fill and the sheen or lit edge in one pass; the rim stays a border). On see-through glass a face fades with `.opacity()` instead of a veil, a GPU layer only while it fades.
+
+### Performance
+
+Amane draws rectangles, borders, letters and pictures as cheap quads, and gradients, shadows and `Canvas` paths with vello, which renders over the whole window and then lays the result on top. vello keeps a result between frames only when its shapes didn't change and hold no gradient, so anything drawn with it on every frame costs a pass over the whole window. What redraws every frame is therefore kept off vello: the surfaces are a shader, the pill's bars are rounded rectangles, the candle ring and the equalizer's curve are shaders (`src/ring.wgsl`, `src/curve.wgsl`). A shader's file is written to `$XDG_RUNTIME_DIR/magic-island/` when it is first drawn. A shader must not contain the word `time`, or amane redraws its window on every frame.
+
+`tools/perf.sh PID [SECONDS]` (on the desktop) prints a process's CPU (and its children's), GPU per engine (DRM fdinfo) and memory.
 
 Amane can only blur what the shell draws, so the frosting comes from Hyprland: a layer rule for the shell's windows (the namespace match is a full match). `ignore_alpha` leaves pixels at or below that opacity unblurred, which keeps the clear margin around the pills sharp; keep it below the design's thinnest part, or that part shows the desktop unblurred (liquid at its default 0.4 is 0.22 in its top left corner).
 
@@ -177,14 +183,15 @@ src/png.rs         a stdlib png writer, for tray icons sent as pixels
 src/system.rs      what the control centre shows: iwd, wired cards, openvpn, power, the external GPU
 src/glyph.rs       every drawn icon, as a Canvas or as shapes for a shared one
 src/theme.rs       the shell's colours: the matugen theme file, the cross-fade; watches config.toml
-src/surface.rs     what the island, pills, menus and popups are made of: the solid, frosted and liquid designs
+src/surface.rs     what the island, pills, menus and popups are made of: the solid, frosted and liquid designs as values for surface.wgsl
+src/*.wgsl         shaders: surface (every surface), ring (the candles), curve (the equalizer's line)
 src/config.rs      every setting, declared once (typed accessors + the window's list), config.toml read and written
 src/hypr.rs        Hyprland's options for the config window: hyprctl descriptions/getoption, hl.config, amane.lua
 src/settings.rs    the config window, `config` IPC
 src/parse.rs       pure text parsing with unit tests, no amane dependency
 matugen/           the matugen template (amane.colors), rendered by skwd-wall into ./theme
 island-eq          saved equalizer curves (a snapshot of ~/.config/amane/island-eq)
-tools/             remote test driver, fake MPRIS players, a fake tray app (`fake_tray.py name|path`), see AGENTS.md
+tools/             remote test driver, fake MPRIS players, a fake tray app (`fake_tray.py name|path`), perf.sh (CPU, GPU, memory of a process), see AGENTS.md
 ```
 
 ## Requirements
@@ -238,8 +245,9 @@ bind = SUPER, M, exec, amane ipc call island toggle
 
 - `~/.config/amane/config.toml`: every setting (see [Settings](#settings)); rewritten by the config window.
 - `~/.config/hypr/amane.lua`: the Hyprland options set in the config window, as `hl.config`; rewritten by the shell.
+- `$XDG_STATE_HOME/amane/` (`~/.local/state/amane/`): `last-played` (the song the island last heard, `key = value`) and a copy of its cover, for the card shown while nothing plays.
 - `~/.config/amane/island-eq`: one line per player identity, `<player>\t<preset or Custom>\t<10 gains in dB>`.
-- `$XDG_RUNTIME_DIR/magic-island/`: downloaded covers, `palette-cover`, `cava.conf`, `eq-<key>.conf`. On tmpfs, gone at logout.
+- `$XDG_RUNTIME_DIR/magic-island/`: downloaded covers, `palette-cover`, `cava.conf`, `eq-<key>.conf`, the shaders (`*.wgsl`). On tmpfs, gone at logout.
 - Equalizer nodes are named `magic_island_eq.<key>`. The key is the player's MPRIS bus name without `org.mpris.MediaPlayer2.`, non-alphanumerics as `_` (e.g. `chromium_instance123`).
 
 ## Known limits

src/ai.rs

@@ -14,10 +14,11 @@ use crate::parse::{self, Chunk};
 use crate::{pods, theme};
 
 /*
- * the AI card: a chat with a local model through ollama's http api (curl, streamed line
- * by line), never a cloud service. ollama isn't kept running: the first question starts
- * its openrc service when it doesn't answer (doas, the same fixed rc-service rule the
- * control centre uses)
+ * the AI card: a chat with a model on your own ollama servers (pills.ai.servers) through
+ * their http api (curl, streamed line by line), never a cloud service. a question goes to
+ * the first server that has the chosen model. a local ollama isn't kept running: it's
+ * started (doas, the same fixed rc-service rule the control centre uses) when it doesn't
+ * answer and no other server has the model
  */
 #[derive(Clone, Copy, PartialEq)]
 pub enum Who {
@@ -36,11 +37,13 @@ pub struct Ai {
     typed: String,
     // bumped by Stop and New chat, so an answer still streaming stops writing
     round: u32,
+    // (server, model) for every model the servers have, while the model list is open (empty while it loads)
+    models: Option<Vec<(String, String)>>,
 }
 
 impl Service for Ai {
     fn new() -> Self {
-        Self { said: Vec::new(), busy: false, note: None, back: 0.0, typed: String::new(), round: 0 }
+        Self { said: Vec::new(), busy: false, note: None, back: 0.0, typed: String::new(), round: 0, models: None }
     }
 
     // changes only through input and the answering thread
@@ -112,32 +115,15 @@ fn new_chat() {
     ai.back = 0.0;
 }
 
-// on the answering thread: start ollama if needed, then stream the reply into the chat
+// on the answering thread: find the model's server (starting a local ollama if needed), then stream the reply into the chat
 fn answer(round: u32) -> Result<(), String> {
-    let server = settings::server().trim_end_matches('/').to_string();
+    let model = settings::model();
 
-    if !answers(&server) {
-        let local = server.contains("://localhost") || server.contains("://127.0.0.1");
-
-        if !(settings::start_service() && local) {
-            return Err(format!("Ollama doesn't answer at {server}"));
-        }
-
-        note(round, "Starting ollama…");
-
-        let _ = Command::new("doas").args(["-n", "rc-service", "ollama", "start"]).output();
-        let until = Instant::now() + Duration::from_secs(30);
-
-        while !answers(&server) {
-            if Instant::now() > until {
-                return Err(String::from("Ollama didn't start (doas rc-service ollama start)"));
-            }
-
-            thread::sleep(Duration::from_millis(500));
-        }
-
-        note(round, "");
-    }
+    let server = models(Some(&model), |words| note(round, words))?
+        .into_iter()
+        .find(|(_, name)| *name == model)
+        .map(|(server, _)| server)
+        .ok_or_else(|| format!("None of pills.ai.servers has {model}"))?;
 
     let body = request();
 
@@ -189,6 +175,154 @@ fn answer(round: u32) -> Result<(), String> {
     Ok(())
 }
 
+// pills.ai.servers, in order, without trailing slashes
+fn servers() -> Vec<String> {
+    settings::servers().split(',').map(|server| server.trim().trim_end_matches('/').to_string()).filter(|server| !server.is_empty()).collect()
+}
+
+fn local(server: &str) -> bool {
+    server.contains("://localhost") || server.contains("://127.0.0.1")
+}
+
+// the models a server has; none when it doesn't answer
+fn models_on(server: &str) -> Option<Vec<String>> {
+    let done = Command::new("curl").args(["-s", "--connect-timeout", "1", "-m", "5", &format!("{server}/api/tags")]).output().ok()?;
+
+    if !done.status.success() {
+        return None;
+    }
+
+    let tags = parse::json(&String::from_utf8_lossy(&done.stdout));
+
+    let names = tags.first().and_then(|tags| tags.get("models")).map(|models| match models {
+        parse::Value::List(models) => models.iter().filter_map(|model| model.get("name").and_then(parse::Value::text).map(str::to_string)).collect(),
+        _ => Vec::new(),
+    });
+
+    Some(names.unwrap_or_default())
+}
+
+/*
+ * (server, model) for the servers' models, in the servers' order, each model once with the
+ * first server that has it; with `wanted`, only until a server has that model. a local
+ * server that doesn't answer is started (pills.ai.start_service) when the others don't have
+ * `wanted`, or for the whole list; `say` tells what's going on
+ */
+fn models(wanted: Option<&str>, say: impl Fn(&str)) -> Result<Vec<(String, String)>, String> {
+    let servers = servers();
+
+    if servers.is_empty() {
+        return Err(String::from("pills.ai.servers names no server"));
+    }
+
+    let mut started = false;
+
+    loop {
+        let mut found: Vec<(String, String)> = Vec::new();
+        let mut silent_local = None;
+        let mut answered = false;
+
+        for server in &servers {
+            let Some(names) = models_on(server) else {
+                if local(server) && silent_local.is_none() {
+                    silent_local = Some(server.clone());
+                }
+
+                continue;
+            };
+
+            answered = true;
+
+            for name in names {
+                if !found.iter().any(|(_, known)| *known == name) {
+                    found.push((server.clone(), name));
+                }
+            }
+
+            if wanted.is_some_and(|wanted| found.iter().any(|(_, name)| name == wanted)) {
+                return Ok(found);
+            }
+        }
+
+        if let Some(server) = silent_local.filter(|_| !started && settings::start_service()) {
+            wake(&server, &say)?;
+
+            started = true;
+
+            continue;
+        }
+
+        return match (answered, found.is_empty()) {
+            (false, _) => Err(format!("No Ollama server answers ({})", servers.join(", "))),
+            (true, true) => Err(String::from("The servers have no models (ollama pull <model>)")),
+            (true, false) => Ok(found),
+        };
+    }
+}
+
+// starts the local ollama service, telling `say` what's going on, and waits until it answers
+fn wake(server: &str, say: impl Fn(&str)) -> Result<(), String> {
+    if answers(server) {
+        return Ok(());
+    }
+
+    say("Starting ollama…");
+
+    let _ = Command::new("doas").args(["-n", "rc-service", "ollama", "start"]).output();
+    let until = Instant::now() + Duration::from_secs(30);
+
+    while !answers(server) {
+        if Instant::now() > until {
+            return Err(String::from("Ollama didn't start (doas rc-service ollama start)"));
+        }
+
+        thread::sleep(Duration::from_millis(500));
+    }
+
+    say("");
+
+    Ok(())
+}
+
+// the model list opens (asking ollama which models it has) or closes
+fn pick() {
+    let mut ai = Ai::write();
+
+    if ai.models.take().is_some() {
+        return;
+    }
+
+    ai.models = Some(Vec::new());
+
+    drop(ai);
+
+    thread::spawn(|| {
+        let names = models(None, |words| Ai::write().note = (!words.is_empty()).then(|| words.to_string()));
+
+        let mut ai = Ai::write();
+
+        match names {
+            // only if the list wasn't closed meanwhile
+            Ok(names) => {
+                if ai.models.is_some() {
+                    ai.models = Some(names);
+                }
+            }
+            Err(why) => {
+                ai.models = None;
+                ai.note = Some(why);
+            }
+        }
+    });
+}
+
+// another model from the list; kept in config.toml, used from the next question on
+fn choose(name: String) {
+    Ai::write().models = None;
+
+    let _ = crate::config::set("pills.ai.model", parse::Value::Text(name));
+}
+
 // whether ollama answers at all, within a second
 fn answers(server: &str) -> bool {
     Command::new("curl")
@@ -253,7 +387,10 @@ pub fn card(width: f32, height: f32) -> Rectangle {
     let ai = Ai::read();
     let theme = theme::now();
 
-    let mut buttons: Vec<Box<dyn Widget>> = Vec::new();
+    // the model, as a chip that opens the list of the others
+    // the model, as a chip that opens the list of the others; its arrow points up while the list is open
+    let arrow = if ai.models.is_some() { Glyph::ChevronUp } else { Glyph::Chevron };
+    let mut buttons: Vec<Box<dyn Widget>> = vec![Box::new(pods::chip(&settings::model(), Some(arrow), pick))];
 
     if ai.busy {
         buttons.push(Box::new(pods::chip("Stop", None, stop)));
@@ -261,7 +398,7 @@ pub fn card(width: f32, height: f32) -> Rectangle {
         buttons.push(Box::new(pods::chip("New chat", None, new_chat)));
     }
 
-    let header = pods::header(&format!("AI · {}", settings::model()), buttons, width);
+    let header = pods::header("AI", buttons, width);
 
     let field_h = 40.0;
     let note_h = text::small() + 8.0;
@@ -294,8 +431,43 @@ pub fn card(width: f32, height: f32) -> Rectangle {
         bubbles.push(Box::new(row.child(bubble)));
     }
 
-    let chat: Box<dyn Widget> = if bubbles.is_empty() {
-        Box::new(Rectangle::new().width(width).height(chat_h).align_child(Center, Center).child(Text::new(format!("Ask {} anything; it runs on this computer", settings::model())).size(text::small()).color(theme.dim)))
+    let chat: Box<dyn Widget> = if let Some(models) = &ai.models {
+        let current = settings::model();
+        let several = servers().len() > 1;
+        let mut rows: Vec<Box<dyn Widget>> = vec![Box::new(Text::new(if models.is_empty() { "Asking the servers for their models…" } else { "Chat with" }).size(text::small()).color(theme.dim))];
+
+        for (server, name) in models {
+            let chosen = *name == current;
+            let picked = name.clone();
+
+            // with more than one server, where the model is, without the scheme
+            let host = if several { server.split("://").last().unwrap_or(server) } else { "" };
+            let host_w = host.chars().count() as f32 * text::small() * crate::config::appearance::font::letter_width();
+
+            rows.push(Box::new(
+                Rectangle::new()
+                    .width(width)
+                    .height(34.0)
+                    .radius(12.0)
+                    .fill(if chosen { faded(theme.accent, 70) } else { overlays::chip() })
+                    .padding(amane::Padding { top: 0.0, right: 12.0, bottom: 0.0, left: 12.0 })
+                    .align_child(Start, Center)
+                    .cursor(amane::Pointer)
+                    .on_click(move |_| choose(picked.clone()))
+                    .child(
+                        Row::new(vec![
+                            Box::new(Rectangle::new().width(width - 24.0 - host_w - 12.0).height(34.0).align_child(Start, Center).child(Text::new(name.as_str()).size(text::body()).color(theme.text).elide())) as Box<dyn Widget>,
+                            Box::new(Text::new(host).size(text::small()).color(theme.dim)),
+                        ])
+                        .gap(12.0)
+                        .align(Center),
+                    ),
+            ));
+        }
+
+        Box::new(Rectangle::new().width(width).height(chat_h).clip().child(Column::new(rows).gap(6.0)))
+    } else if bubbles.is_empty() {
+        Box::new(Rectangle::new().width(width).height(chat_h).align_child(Center, Center).child(Text::new(if servers().iter().all(|server| local(server)) { format!("Ask {} anything; it runs on this computer", settings::model()) } else { format!("Ask {} anything; it runs on your own servers", settings::model()) }).size(text::small()).color(theme.dim)))
     } else {
         // the column's bottom on the area's bottom, moved down by the scroll back; what's above is cut
         let back = ai.back.min((total - chat_h).max(0.0));

src/art.rs

@@ -42,6 +42,15 @@ impl Service for Art {
                 *Self::write() = Self { url, path };
             }
 
+            // the song playing, kept for the card shown while nothing plays
+            let (url, path) = {
+                let art = Self::read();
+
+                (art.url.clone(), art.path.clone())
+            };
+
+            crate::last::watch(&url, &path);
+
             // 4 checks a second: after next/previous the new cover follows the title quickly
             thread::sleep(Duration::from_millis(timing::cover_check_ms()));
         }

src/config.rs

@@ -329,6 +329,11 @@ settings! {
             row_letters: usize = 30, 4..=200; "Letters of a device name a menu row shows before cutting the middle"
             chip_letters: usize = 13, 4..=200; "Letters of a device name the output chip shows before cutting the middle"
         }
+        idle {
+            players: String = String::from("cider, spotify, tidal-hifi"); "Players the card offers to start while nothing plays: their desktop file names (cider for cider.desktop), comma-separated"
+            wait_s: u64 = 30, 1..=300; "How long a player started from the card gets to start playing before the card gives up"
+            check_ms: u64 = 500, 100..=5000; "How often a player started from the card is looked for and asked to play"
+        }
     }
 
     sound {
@@ -420,9 +425,6 @@ settings! {
             slider_height: f32 = 28.0, 8..=100; "Height of a slider"
             keys_height: f32 = 26.0, 8..=100; "Height of the keyboard light's buttons"
             profile_height: f32 = 48.0, 16..=200; "Height of the performance profile buttons"
-            vram_height: f32 = 14.0, 4..=60; "Height of the external GPU's memory line"
-            row_height: f32 = 22.0, 8..=100; "Height of a program row under the external GPU"
-            max_rows: usize = 5, 1..=50; "Programs listed under the external GPU before \"and N more\""
         }
         menus {
             pad: f32 = 12.0, 0..=100; "Padding inside a menu"
@@ -506,11 +508,12 @@ settings! {
             open_ms: u64 = 420, 0..=5000; "How long a small pill takes to open into its card, and to close"
             radius: f32 = 22.0, 0..=60; "Corner radius of the opened cards"
             pad: f32 = 18.0, 0..=60; "Padding inside the opened cards"
+            reveal_at: f32 = 0.2, 0..=1; "How much of a closing card's growth is left when the pills beside it start to show again behind it (0 = only once it's closed)"
         }
         ai {
             width: f32 = 440.0, 280..=1200; "Width of the AI card"
             height: f32 = 520.0, 200..=1200; "Height of the AI card"
-            server: String = String::from("http://localhost:11434"); "The Ollama server the AI card talks to"
+            servers: String = String::from("http://localhost:11434"); "The Ollama servers the AI card talks to, comma-separated, in order: the model list shows all their models, a question goes to the first that has the chosen one"
             model: String = String::from("gemma4:e4b"); "The Ollama model to chat with, with its tag (ollama list shows them)"
             start_service: bool = true; "Start the local ollama service (doas rc-service ollama start) when it isn't answering"
             system: String = String::from("You are a helpful assistant inside a Linux desktop shell. Answer briefly and plainly."); "What the model is told before every chat"
@@ -520,27 +523,61 @@ settings! {
             interval_ms: u64 = 1000, 200..=10000; "How often the system monitor reads the system"
             history: usize = 60, 10..=600; "How many readings the graphs show"
             graph_height: f32 = 34.0, 10..=200; "Height of each graph"
-            temperatures: usize = 6, 0..=20; "How many temperature sensors to show, hottest first"
+            temperatures: usize = 6, 0..=20; "How many temperature sensors to show, always in the same order: CPU, iGPU, eGPU, NVMe, memory, board, then the rest"
+            warm: f32 = 65.0, 20..=120; "From this temperature (°C) a sensor shows in the warm colour"
+            hot: f32 = 85.0, 20..=130; "From this temperature (°C) a sensor shows in the hot colour"
+            cool_color: Color = Color::rgb(120, 200, 255); "Colour of a sensor below the warm temperature"
+            warm_color: Color = Color::rgb(255, 196, 92); "Colour of a warm sensor"
+            hot_color: Color = Color::rgb(255, 105, 97); "Colour of a hot sensor"
+            programs: usize = 5, 1..=50; "Programs on the external GPU listed before the rest are counted"
             terminal: String = String::from("ghostty"); "The terminal that runs the process list"
             processes: String = String::from("btm --default_widget_type proc --expanded"); "The process list command, opened on a special workspace"
             workspace: String = String::from("processes"); "The special workspace the process list opens on"
         }
         home {
-            width: f32 = 460.0, 300..=1200; "Width of the home card"
+            width: f32 = 820.0, 300..=1600; "Width of the home card. It opens rightwards from beside the island, so on a 1920 px wide monitor about 820 fits"
             clock_size: f32 = 64.0, 20..=200; "Size of the big clock"
+            clock_font: String = String::new(); "The big clock's font family, any installed one (fc-list : family lists them); empty takes the shell's font"
+            clock_weight: u64 = 700, 100..=900; "The big clock's weight, 100 (thin) to 900 (black); a font without that weight shows its nearest one"
+            clock_letter_width: f32 = 0.0, 0..=2; "Width of one of the clock's digits as a share of its size, so the weather beside it makes room; 0 takes the shell font's"
             seconds: bool = false; "Show seconds on the big clock"
             avatar: String = String::from("~/.face"); "The picture shown as the user's avatar; a drawn person without one"
+            avatar_size: f32 = 84.0, 24..=200; "Size of the avatar; the greeting row is as tall"
+            gap: f32 = 12.0, 0..=60; "Space between the home card's parts"
             city: String = String::from("Munich"); "The weather's place, as shown"
             latitude: f32 = 48.137, -90.0..=90.0; "The weather's latitude"
             longitude: f32 = 11.575, -180.0..=180.0; "The weather's longitude"
             weather_minutes: u64 = 20, 5..=360; "How often the weather is fetched, in minutes"
+            weather_height: f32 = 60.0, 30..=200; "Height of the weather now"
+            weather_icon: f32 = 44.0, 16..=120; "Size of the icon of the weather now"
+            temperature_size: f32 = 28.0, 10..=100; "Size of the temperature now"
+            forecast_height: f32 = 64.0, 30..=200; "Height of the coming days' weather"
+            forecast_icon: f32 = 22.0, 10..=80; "Size of the coming days' weather icons"
+            photo: bool = true; "Show a photo of the weather now behind the home card"
+            photos: String = String::from("~/.config/amane/weather"); "Folder of the weather photos: <kind>-<day|night>.jpg for clear, partly-cloudy, cloudy, fog, rain, snow and storm. A missing one is downloaded once from Wikimedia Commons (credits in the repo's weather/CREDITS.md); a file that's there is never replaced, so put your own in its place (the shell shows a swapped file after a restart)"
+            photo_opacity: f32 = 0.45, 0..=1; "How much the weather photo shows through behind the home card: the card's colour veils the rest, 0 hides it"
         }
         calendar {
             server: String = String::from("https://caldav.icloud.com/"); "The CalDAV server; iCloud's by default"
-            account: String = String::new(); "The Apple ID (or CalDAV user). Sign in from the home card; the app-specific password goes to the keyring, never here"
-            days: u64 = 14, 1..=90; "How many days ahead the calendar shows events"
-            sync_minutes: u64 = 15, 1..=360; "How often the calendar is synced, in minutes"
-            events: usize = 6, 1..=30; "How many upcoming events the home card lists"
+            contacts_server: String = String::from("https://contacts.icloud.com/"); "The CardDAV server the birthdays come from, with the same account; iCloud's by default"
+            account: String = String::new(); "Your Apple ID (or CalDAV user). Store its app-specific password (account.apple.com > Sign-In and Security > App-Specific Passwords) in the keyring with: secret-tool store --label='Magic Island calendar' service amane-calendar account <Apple ID>"
+            sync_minutes: u64 = 15, 1..=360; "How often the calendar and the birthdays are synced, in minutes"
+            holidays: String = String::from("BY"); "The German state whose public holidays the calendar marks: BW, BY, BE, BB, HB, HH, HE, MV, NI, NW, RP, SL, SN, ST, SH or TH; empty marks none"
+            birthdays: bool = true; "Show the birthdays of your contacts"
+            cell: f32 = 52.0, 32..=96; "Size of a day in the month grid; the card grows with it"
+            disc: f32 = 0.72, 0.3..=1.0; "Size of today's disc and the selected day's ring, as a share of a day"
+            ring: f32 = 2.0, 0.5..=6.0; "Thickness of the selected day's ring"
+            dot: f32 = 5.0, 2..=16; "Size of the dots under a day with events, one per calendar"
+            dots: usize = 3, 1..=6; "Most dots under one day"
+            mark: f32 = 13.0, 6..=30; "Size of the cake on a day with a birthday"
+            list_gap: f32 = 24.0, 0..=100; "Space between the month grid and the selected day's list"
+            item_gap: f32 = 8.0, 0..=40; "Space between the selected day's items"
+            field_height: f32 = 32.0, 20..=60; "Height of the event form's text fields"
+            length_minutes: u64 = 60, 5..=1440; "How long a new event lasts until you change its end"
+            holiday_color: Color = Color::rgb(255, 122, 104); "Colour of public holidays: the day's number, its tint and flag"
+            holiday_tint: f32 = 0.2, 0..=1; "How strongly a public holiday is tinted in its colour"
+            birthday_color: Color = Color::rgb(255, 138, 196); "Colour of birthdays: the cake on the day and in its list"
+            selected_color: Color = Color::rgba(255, 255, 255, 220); "Colour of the selected day's ring"
         }
     }
 
@@ -554,6 +591,10 @@ settings! {
             count: usize = 4, 1..=10; "How many popups show at once"
             icon: f32 = 40.0, 16..=128; "Size of a notification's icon or picture"
         }
+        apps {
+            muted: String = String::new(); "Apps whose notifications don't pop up but stay in the history, comma-separated (Mute app on a notification adds it)"
+            blocked: String = String::new(); "Apps whose notifications are dropped at once, comma-separated (Block app on a notification adds it)"
+        }
         history {
             width: f32 = 420.0, 280..=1200; "Width of the notification card"
             height: f32 = 560.0, 200..=1400; "Height of the notification card"

src/control.rs

@@ -2,7 +2,7 @@
  * the control centre: a status pill in the top right corner of every monitor (wi-fi,
  * vpn, bluetooth, battery) that opens, on the monitor it was clicked on, into a panel
  * like macOS's: connection tiles, sound, the screen and keyboard light, the performance
- * mode with the battery, and the external gpu with the programs using it. it opens on
+ * mode with the battery (the external gpu moved to the system monitor pill). it opens on
  * the island's timeline (island::phases): pill out, the empty shape grows, panel in
  */
 use std::collections::HashMap;
@@ -26,7 +26,7 @@ use crate::parse;
 use crate::prompt;
 use crate::settings;
 use crate::sound::Sound;
-use crate::system::{self, Charge, Gpu, Links, Power, VpnState};
+use crate::system::{self, Charge, Links, Power, VpnState};
 use crate::{surface, theme};
 
 // every size and timing is a setting (config.rs: control.*); these follow from them
@@ -266,12 +266,11 @@ struct Layout {
     keyboard: bool,
     profiles: bool,
     battery: bool,
-    gpu_rows: Option<usize>,
 }
 
 impl Layout {
     fn largest() -> Layout {
-        Layout { ethernet: true, extra_output: true, screen: true, keyboard: true, profiles: true, battery: true, gpu_rows: Some(c::modules::max_rows()) }
+        Layout { ethernet: true, extra_output: true, screen: true, keyboard: true, profiles: true, battery: true }
     }
 
     fn sound(&self) -> f32 {
@@ -292,12 +291,8 @@ impl Layout {
         module_height(&parts)
     }
 
-    fn gpu(&self) -> Option<f32> {
-        self.gpu_rows.map(|rows| 2.0 * c::modules::pad() + c::modules::title_height() + c::modules::vram_height() + rows.max(1) as f32 * c::modules::row_height() + 2.0 * c::modules::line_gap())
-    }
-
     fn height(&self) -> f32 {
-        let modules: f32 = [Some(self.sound()), self.display(), self.performance(), self.gpu()].into_iter().flatten().map(|height| c::panel::gap() + height).sum();
+        let modules: f32 = [Some(self.sound()), self.display(), self.performance()].into_iter().flatten().map(|height| c::panel::gap() + height).sum();
         let tile_rows = if self.ethernet { 3.0 } else { 2.0 };
 
         // the Settings button closes the panel
@@ -321,7 +316,6 @@ struct Scene<'a> {
     bluetooth: &'a Bluetooth,
     audio: &'a Audio,
     screen: &'a Brightness,
-    gpu: &'a Gpu,
     hotspot: &'a str,
     extra_output: Option<&'a parse::Sink>,
     layout: Layout,
@@ -375,7 +369,6 @@ pub fn view(monitor: &Monitor) -> LayerWindow {
 
     let audio = open.then(Audio::read);
     let screen = open.then(Brightness::read);
-    let gpu = open.then(Gpu::read);
     let settings = open.then(|| (c::services::hotspot(), c::services::extra_output()));
     let sound = open.then(Sound::read);
 
@@ -391,7 +384,6 @@ pub fn view(monitor: &Monitor) -> LayerWindow {
         keyboard: power.keyboard.is_some(),
         profiles: !power.profiles.is_empty(),
         battery: power.battery.is_some(),
-        gpu_rows: gpu.as_deref().filter(|gpu| !gpu.name.is_empty()).map(|gpu| gpu.programs.len().min(c::modules::max_rows())),
     };
 
     /*
@@ -427,8 +419,8 @@ pub fn view(monitor: &Monitor) -> LayerWindow {
     let colors = theme::now().surfaces();
 
     // at most one face at a time, each faded by a veil instead of a gpu layer
-    let face = match (&audio, &screen, &gpu, &settings) {
-        (Some(audio), Some(screen), Some(gpu), Some((hotspot, _))) if reveal > 0.0 && fade > 0.0 => {
+    let face = match (&audio, &screen, &settings) {
+        (Some(audio), Some(screen), Some((hotspot, _))) if reveal > 0.0 && fade > 0.0 => {
             let scene = Scene {
                 control: &control,
                 links: &links,
@@ -436,7 +428,6 @@ pub fn view(monitor: &Monitor) -> LayerWindow {
                 bluetooth: &bluetooth,
                 audio,
                 screen,
-                gpu,
                 hotspot,
                 extra_output,
                 layout,
@@ -880,10 +871,6 @@ fn panel(scene: &Scene) -> Rectangle {
         blocks.push(Box::new(performance(scene, height)));
     }
 
-    if let Some(height) = scene.layout.gpu() {
-        blocks.push(Box::new(gpu(scene, height)));
-    }
-
     blocks.push(Box::new(settings_button(scene.control)));
 
     let height = scene.layout.height();
@@ -1480,84 +1467,6 @@ fn battery_words(charge: &Charge) -> String {
     }
 }
 
-// the external gpu: its load, memory and temperature, and who uses it
-
-fn gpu(scene: &Scene, height: f32) -> Rectangle {
-    let theme = theme::now();
-    let gpu = scene.gpu;
-
-    let mut facts = vec![format!("{}%", gpu.busy)];
-
-    if let Some(celsius) = gpu.celsius {
-        facts.push(format!("{celsius}°C"));
-    }
-
-    if let Some(watts) = gpu.watts {
-        facts.push(format!("{watts:.0} W"));
-    }
-
-    let title = Row::new(children![icon(Glyph::Chip, 15.0, theme.accent), Text::new(gpu.name.as_str()).size(text::body()).weight(Weight::Bold).color(theme.text).elide()]).gap(8.0).align(Center);
-
-    let top = Row::new(children![title, note(facts.join(" · "))]).justify(SpaceBetween).align(Center).width(module_w()).height(c::modules::title_height());
-
-    let share = if gpu.vram_total > 0 { gpu.vram_used as f32 / gpu.vram_total as f32 } else { 0.0 };
-
-    let memory_label = format!("{} of {}", size(gpu.vram_used / 1024), size(gpu.vram_total / 1024));
-    let memory_w = label_width(&memory_label, 10.5, 4.0);
-    let bar_w = module_w() - memory_w - 10.0;
-
-    let memory = Row::new(children![
-        Rectangle::new().width(bar_w).height(6.0).radius(Full).fill(overlays::track()).child(Rectangle::new().width((bar_w * share).max(6.0)).height(6.0).radius(Full).fill(theme.accent)),
-        Text::new(memory_label).size(text::caption()).color(theme.dim),
-    ])
-    .gap(10.0)
-    .align(Center)
-    .width(module_w())
-    .height(c::modules::vram_height());
-
-    let mut rows: Vec<Box<dyn Widget>> = Vec::new();
-
-    let shown = if gpu.programs.len() > c::modules::max_rows() { c::modules::max_rows() - 1 } else { c::modules::max_rows() };
-
-    for program in gpu.programs.iter().take(shown) {
-        let mut amount = size(program.vram_kib);
-
-        if let Some(busy) = program.busy {
-            amount = format!("{amount} · {busy}%");
-        }
-
-        rows.push(Box::new(
-            Row::new(children![
-                Text::new(program.name.as_str()).size(text::body()).color(theme.text).elide(),
-                note(amount),
-            ])
-            .justify(SpaceBetween)
-            .align(Center)
-            .width(module_w())
-            .height(c::modules::row_height()),
-        ));
-    }
-
-    if gpu.programs.len() > c::modules::max_rows() {
-        rows.push(Box::new(Rectangle::new().width(module_w()).height(c::modules::row_height()).align_child(Start, Center).child(note(format!("and {} more", gpu.programs.len() - shown)))));
-    }
-
-    if gpu.programs.is_empty() {
-        rows.push(Box::new(Rectangle::new().width(module_w()).height(c::modules::row_height()).align_child(Start, Center).child(note("No programs on it"))));
-    }
-
-    module(height, Column::new(children![top, memory, Column::new(rows)]).gap(c::modules::line_gap()))
-}
-
-// video memory in KiB, the way a person reads it
-fn size(kib: u64) -> String {
-    match kib {
-        0..1024 => String::from("<1 MB"),
-        1024..1_048_576 => format!("{} MB", kib / 1024),
-        _ => format!("{:.1} GB", kib as f64 / 1_048_576.0),
-    }
-}
-
 /*
  * the menus: a window of their own per monitor, over the panel, so the panel never
  * re-lays out. a menu grows out of the tile or block that opened it (the island's

src/curve.wgsl

@@ -0,0 +1,79 @@
+// the equalizer's curve: a line through the sliders' knobs, eased between neighbours,
+// shivering up and down with the music, a faint wide stroke under a thin bright one.
+// island.rs fills the values:
+//   0: x of the first point, width the points span, steps, bands
+//   1: levels given, glow width, line width, unused
+//   2: glow colour, 3: line colour (plain, 0 to 1)
+//   4-6: the knobs' heights, one per band
+//   7-15: the live levels, low to high, 0 to 1
+const PI: f32 = 3.14159265359;
+
+fn knob(band: u32) -> f32 {
+    return values[4u + band / 4u][band % 4u];
+}
+
+fn loudness(along: f32) -> f32 {
+    let count = u32(values[1].x);
+
+    if count == 0u {
+        return 0.0;
+    }
+
+    let index = min(u32(round(along * f32(count - 1u))), count - 1u);
+
+    return values[7u + index / 4u][index % 4u];
+}
+
+// the curve's point number `step`, as island.rs placed it on the old canvas
+fn point(step: u32) -> vec2<f32> {
+    let steps = values[0].z;
+    let bands = u32(values[0].w);
+    let along = f32(step) / steps;
+
+    let place = along * f32(bands - 1u);
+    let band = min(u32(floor(place)), bands - 2u);
+    let eased = (1.0 - cos((place - f32(band)) * PI)) / 2.0;
+
+    let shiver = loudness(along) * 9.0 * select(0.6, -1.0, step % 2u == 0u);
+
+    return vec2<f32>(values[0].x + along * values[0].y, mix(knob(band), knob(band + 1u), eased) + shiver);
+}
+
+fn segment(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>) -> f32 {
+    let ab = b - a;
+    let t = clamp(dot(p - a, ab) / max(dot(ab, ab), 1e-5), 0.0, 1.0);
+
+    return length(p - a - ab * t);
+}
+
+fn stroke(d: f32, width: f32, pixel: f32) -> f32 {
+    return clamp((width / 2.0 - d) / pixel + 0.5, 0.0, 1.0);
+}
+
+@fragment
+fn main(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+    let p = uv * size;
+    let pixel = max(fwidth(p.x), 1e-4);
+    let steps = u32(values[0].z);
+
+    // the segment under this pixel and its neighbours: a stroke can't reach further
+    let here = i32(floor((p.x - values[0].x) / max(values[0].y, 1e-5) * values[0].z));
+
+    var d = 1e9;
+
+    for (var offset = -1; offset <= 1; offset++) {
+        let first = clamp(here + offset, 0, i32(steps) - 1);
+
+        d = min(d, segment(p, point(u32(first)), point(u32(first) + 1u)));
+    }
+
+    let glow = vec4<f32>(values[2].rgb * values[2].a, values[2].a) * stroke(d, values[1].y, pixel);
+    let line = vec4<f32>(values[3].rgb * values[3].a, values[3].a) * stroke(d, values[1].z, pixel);
+    let color = line + glow * (1.0 - line.a);
+
+    if color.a <= 0.0 {
+        return vec4<f32>(0.0);
+    }
+
+    return vec4<f32>(color.rgb / color.a, color.a);
+}

src/glyph.rs

@@ -12,6 +12,7 @@ pub enum Glyph {
     Muted,
     Bluetooth,
     Chevron,
+    ChevronUp,
     // pointing left, for a menu's way back
     Back,
     Note,
@@ -52,6 +53,15 @@ pub enum Glyph {
     Snow,
     Storm,
     Fog,
+    Thermometer,
+    Drive,
+    Memory,
+    Gpu,
+    Plus,
+    Pencil,
+    Trash,
+    Cake,
+    Flag,
 }
 
 pub fn icon(glyph: Glyph, size: f32, color: Color) -> Canvas {
@@ -129,6 +139,7 @@ pub fn glyph_shapes(glyph: Glyph, size: f32, color: Color, weight: f32, origin:
                 .cap(Cap::Round)
         ],
         Glyph::Chevron => shapes![Path::new().move_to(x(0.12), y(0.32)).line_to(x(0.5), y(0.7)).line_to(x(0.88), y(0.32)).stroke(1.5, color).cap(Cap::Round)],
+        Glyph::ChevronUp => shapes![Path::new().move_to(x(0.12), y(0.68)).line_to(x(0.5), y(0.3)).line_to(x(0.88), y(0.68)).stroke(1.5, color).cap(Cap::Round)],
         Glyph::Back => shapes![Path::new().move_to(x(0.64), y(0.14)).line_to(x(0.3), y(0.5)).line_to(x(0.64), y(0.86)).stroke(thin.max(1.6), color).cap(Cap::Round)],
         // an eighth note: round head, stem, a curved flag
         Glyph::Note => shapes![
@@ -307,6 +318,34 @@ pub fn glyph_shapes(glyph: Glyph, size: f32, color: Color, weight: f32, origin:
             line(0.5, 0.08, 0.5, 0.16),
         ],
         Glyph::Cross => shapes![line(0.24, 0.24, 0.76, 0.76), line(0.76, 0.24, 0.24, 0.76)],
+        // a tube with its bulb
+        Glyph::Thermometer => shapes![
+            Path::new().move_to(x(0.4), y(0.62)).line_to(x(0.4), y(0.16)).quad_to(x(0.4), y(0.06), x(0.5), y(0.06)).quad_to(x(0.6), y(0.06), x(0.6), y(0.16)).line_to(x(0.6), y(0.62)).stroke(thin, color),
+            Circle::new().center(x(0.5), y(0.76)).radius(0.17 * s).fill(color),
+            line(0.5, 0.3, 0.5, 0.7),
+        ],
+        // a flat drive with its connector
+        Glyph::Drive => shapes![frame(0.08, 0.3, 0.92, 0.7).stroke(thin, color), line(0.2, 0.5, 0.2, 0.5), line(0.66, 0.5, 0.8, 0.5)],
+        // a memory stick: a board with chips and pins
+        Glyph::Memory => shapes![frame(0.06, 0.28, 0.94, 0.62).stroke(thin, color), frame(0.18, 0.38, 0.34, 0.52).fill(color), frame(0.42, 0.38, 0.58, 0.52).fill(color), frame(0.66, 0.38, 0.82, 0.52).fill(color), line(0.2, 0.62, 0.2, 0.76), line(0.4, 0.62, 0.4, 0.76), line(0.6, 0.62, 0.6, 0.76), line(0.8, 0.62, 0.8, 0.76)],
+        // a graphics card: a board with a fan
+        Glyph::Gpu => shapes![frame(0.06, 0.24, 0.94, 0.72).stroke(thin, color), Circle::new().center(x(0.4), y(0.48)).radius(0.14 * s).stroke(thin, color), line(0.66, 0.4, 0.8, 0.4), line(0.66, 0.56, 0.8, 0.56), line(0.16, 0.72, 0.16, 0.86)],
+        Glyph::Plus => shapes![line(0.5, 0.2, 0.5, 0.8), line(0.2, 0.5, 0.8, 0.5)],
+        Glyph::Pencil => shapes![
+            Path::new().move_to(x(0.2), y(0.8)).line_to(x(0.24), y(0.62)).line_to(x(0.66), y(0.2)).line_to(x(0.8), y(0.34)).line_to(x(0.38), y(0.76)).close().stroke(thin, color),
+            line(0.58, 0.28, 0.72, 0.42),
+        ],
+        Glyph::Trash => shapes![
+            Path::new().move_to(x(0.24), y(0.3)).line_to(x(0.3), y(0.88)).line_to(x(0.7), y(0.88)).line_to(x(0.76), y(0.3)).stroke(thin, color),
+            line(0.14, 0.3, 0.86, 0.3),
+            line(0.4, 0.14, 0.6, 0.14),
+            line(0.44, 0.44, 0.44, 0.74),
+            line(0.56, 0.44, 0.56, 0.74),
+        ],
+        // a cake with a candle, for birthdays
+        Glyph::Cake => shapes![frame(0.14, 0.5, 0.86, 0.86).fill(color), line(0.5, 0.26, 0.5, 0.44), Circle::new().center(x(0.5), y(0.16)).radius(0.07 * s).fill(color)],
+        // a flag on a pole, for holidays
+        Glyph::Flag => shapes![line(0.22, 0.1, 0.22, 0.9), Path::new().move_to(x(0.22), y(0.12)).line_to(x(0.82), y(0.12)).line_to(x(0.68), y(0.3)).line_to(x(0.82), y(0.48)).line_to(x(0.22), y(0.48)).close().fill(color)],
         Glyph::Send => shapes![
             Path::new().move_to(x(0.1), y(0.14)).line_to(x(0.92), y(0.5)).line_to(x(0.1), y(0.86)).line_to(x(0.24), y(0.5)).close().fill(color)
         ],

src/island.rs

@@ -1,13 +1,13 @@
 use std::collections::HashMap;
-use std::f32::consts::{PI, TAU};
+use std::path::PathBuf;
+use std::sync::LazyLock;
 use std::thread;
 use std::time::{Duration, Instant};
 
 use amane::{
-    Animation, Argument, Blend, Bus, Canvas, Cap, Center, Color, Column, Easing, End, Full, Gradient, Image,
-    InputArea, Layer, LayerWindow, Media, MediaPlayer, Monitor, Padding, Palette, Parent, Path, Pointer,
-    Rectangle, Row, Scroll, ScrollArea, Service, Shadow, Shape, SpaceBetween, Stack, Start, Text, Vertical,
-    Weight, Widget, Workspaces, Zone, children, shapes,
+    Animation, Argument, Blend, Bus, Center, Color, Column, Easing, End, Full, Gradient, Image, InputArea, Layer,
+    LayerWindow, Media, MediaPlayer, Monitor, Padding, Palette, Parent, Pointer, Rectangle, Row, Scroll, ScrollArea,
+    Service, Shadow, SpaceBetween, Stack, Start, Text, Vertical, Weight, Widget, Workspaces, Zone, children,
 };
 
 use crate::art::Art;
@@ -245,23 +245,8 @@ pub fn view(monitor: &Monitor) -> LayerWindow {
     let spectrum = live.then(Spectrum::read);
     let levels: &[f32] = spectrum.as_deref().map_or(&[], |spectrum| spectrum.levels.as_slice());
 
-    let Some(player) = shown(&media, island.selected.as_deref()) else {
-        /*
-         * nothing playing: a quiet pill, so the island is always there. never
-         * visible(false): hyprland 0.56 configures a layer surface before its first
-         * commit, so a window that starts hidden gets a size anyway, amane logs "no
-         * child to draw" and waits for frame callbacks an undrawn surface never gets
-         */
-        return window.click_through().child(
-            Rectangle::new()
-                .width(Parent)
-                .height(Parent)
-                .padding(Padding { top: c::pill::top_gap(), right: 0.0, bottom: 0.0, left: 0.0 })
-                .align_child(Center, Start)
-                .translate(0.0, slide)
-                .child(idle(&theme::now().surfaces())),
-        );
-    };
+    // nothing playing: a quiet pill, which opens into the last song's card (last.rs)
+    let player = shown(&media, island.selected.as_deref());
 
     let (grow, pill, reveal) = phases(open);
 
@@ -280,7 +265,7 @@ pub fn view(monitor: &Monitor) -> LayerWindow {
     }
 
     let width = mix(c::pill::width() + c::animation::hover_grow() * (lift + 2.0 * pop), c::card::width(), grow);
-    let height = mix(c::pill::height(), wide_h(), grow);
+    let height = mix(c::pill::height(), if player.is_some() { wide_h() } else { crate::last::height() }, grow);
     let radius = mix(c::pill::height() / 2.0, c::card::radius(), grow);
 
     /*
@@ -290,7 +275,7 @@ pub fn view(monitor: &Monitor) -> LayerWindow {
      */
     let wallpaper = theme::now().surfaces();
 
-    let colors = if cover_colors {
+    let colors = if cover_colors && player.is_some() {
         let cover = backdrop_colors(&Palette::read());
 
         std::array::from_fn(|stop| Color::blend(wallpaper[stop], cover[stop], reveal))
@@ -299,7 +284,8 @@ pub fn view(monitor: &Monitor) -> LayerWindow {
     };
 
     // at most one face at a time, each faded by a veil instead of a gpu layer
-    let face = if reveal > 0.0 {
+    let face = match player {
+        Some(player) if reveal > 0.0 => {
             let scene = Scene {
                 player,
                 players: media.players(),
@@ -310,11 +296,12 @@ pub fn view(monitor: &Monitor) -> LayerWindow {
             };
 
             veiled(card(&scene), width, height, radius, reveal, &colors)
-    } else if pill > 0.0 {
-        veiled(compact(player, playing(player, &island), &art.path, levels), width, height, radius, pill, &colors)
-    } else {
+        }
+        Some(player) if pill > 0.0 => veiled(compact(player, playing(player, &island), &art.path, levels), width, height, radius, pill, &colors),
+        None if reveal > 0.0 => veiled(crate::last::card(), width, height, radius, reveal, &colors),
+        None if pill > 0.0 => veiled(idle(), width, height, radius, pill, &colors),
         // mid-grow: the empty shape alone, the cheapest frames of the animation
-        Rectangle::new().width(0.0).height(0.0)
+        _ => Rectangle::new().width(0.0).height(0.0),
     };
 
     // the face centred along the top: while the shape grows it is narrower than the shape
@@ -600,15 +587,15 @@ pub fn faded(color: Color, alpha: u8) -> Color {
     Color::rgba(color.red(), color.green(), color.blue(), alpha)
 }
 
-// the island while no player is open: a music note and "Nothing playing", on the pill's surface
-fn idle(colors: &[Color; 3]) -> Rectangle {
-    let content = Rectangle::new()
-        .width(c::pill::width())
-        .height(c::pill::height())
-        .align_child(Center, Center)
-        .child(Row::new(children![icon(Glyph::Note, 15.0, theme::now().accent), Text::new("Nothing playing").size(text::body()).color(theme::now().dim)]).gap(8.0).align(Center));
+// the pill while no player is open: a music note and "Nothing playing"; the words only
+// where they fit with half the pill's height to spare at each end, else the note alone, so it never nears the rim
+fn idle() -> Rectangle {
+    let (width, h, note) = (c::pill::width(), c::pill::height(), 15.0);
+    let words = Text::new("Nothing playing").size(text::body()).color(theme::now().dim);
+    let fits = matches!(words.width(), amane::Size::Fixed(words_w) if note + 8.0 + words_w + h <= width);
 
-    surface::shell(c::pill::width(), c::pill::height(), c::pill::height() / 2.0, colors, 0.0, content)
+    let row = if fits { Row::new(children![icon(Glyph::Note, note, theme::now().accent), words]) } else { Row::new(children![icon(Glyph::Note, note, theme::now().accent)]) };
+    Rectangle::new().width(width).height(h).align_child(Center, Center).child(row.gap(8.0).align(Center))
 }
 
 // the pill: cover, title, the player's live levels
@@ -683,46 +670,35 @@ fn stepped(volume: u8, scroll: Scroll) -> u8 {
     (i32::from(volume) + step).clamp(0, 100) as u8
 }
 
+static RING: LazyLock<PathBuf> = LazyLock::new(|| surface::shader_file("ring.wgsl", include_str!("ring.wgsl")));
+static CURVE: LazyLock<PathBuf> = LazyLock::new(|| surface::shader_file("curve.wgsl", include_str!("curve.wgsl")));
+
 /*
- * every candle goes into one path per look (glow, body, flame) instead of a
- * shape each: 120 shapes cost this iGPU a third of its frame rate, 3 cost nothing
+ * the candles, drawn by ring.wgsl: as stroked paths they cost a vello pass over the whole
+ * island window on every frame of the music. the shader gets half the ring's levels (the
+ * other half mirrors them), at most 44 of them, eased the way the paths were
  */
-fn ring(levels: &[f32]) -> Canvas {
-    let center = c::disc::size() / 2.0;
-    let inner = c::disc::cover() / 2.0 + 7.0;
+fn ring(levels: &[f32]) -> Rectangle {
+    let candles = c::disc::candles();
+    let half = (candles / 2).max(1);
+    let given = half.min(44);
 
-    let mut glow = Path::new();
-    let mut body = Path::new();
-    let mut flames = Path::new();
+    let theme = theme::now();
+    let size = c::disc::size();
 
-    for index in 0..c::disc::candles() {
-        // a gentle curve lifts the quiet bands, so the ring isn't all bass
-        let level = mirrored(levels, index).powf(0.75);
+    let eased: Vec<f32> = (0..given).map(|slot| mirrored(levels, slot * half / given).powf(0.75)).collect();
 
-        let (sin, cos) = (index as f32 / c::disc::candles() as f32 * TAU).sin_cos();
+    let mut values = vec![
+        [size / 2.0, c::disc::cover() / 2.0 + 7.0, candles as f32, given as f32],
+        [c::disc::candle_reach(), 9.0, 4.5, 4.0],
+        surface::plain(faded(theme.accent, 50)),
+        surface::plain(faded(theme.accent, 215)),
+        surface::plain(theme.flame),
+    ];
 
-        let reach = inner + 3.0 + level * c::disc::candle_reach();
+    values.extend(surface::rows(&eased));
 
-        let (x0, y0) = (center + sin * inner, center - cos * inner);
-        let (x1, y1) = (center + sin * reach, center - cos * reach);
-
-        body = body.move_to(x0, y0).line_to(x1, y1);
-
-        // the loud ones glow, and burn at the tip
-        if level > 0.25 {
-            glow = glow.move_to(x0, y0).line_to(x1, y1);
-        }
-
-        if level > 0.45 {
-            flames = flames.move_to(x1 - sin * 0.5, y1 + cos * 0.5).line_to(x1, y1);
-        }
-    }
-
-    Canvas::new().width(c::disc::size()).height(c::disc::size()).shapes(shapes![
-        glow.stroke(9.0, faded(theme::now().accent, 50)).cap(Cap::Round),
-        body.stroke(4.5, faded(theme::now().accent, 215)).cap(Cap::Round),
-        flames.stroke(4.0, theme::now().flame).cap(Cap::Round),
-    ])
+    Rectangle::new().width(size).height(size).shader(RING.as_path()).shader_values(values)
 }
 
 // low frequencies at the top, rising down both sides, so the ring is symmetric
@@ -1170,40 +1146,34 @@ fn equalizer(scene: &Scene) -> Column {
 }
 
 // the curve through the knobs, shivering with the player's sound
-fn curve(gains: &[f32; 10], levels: &[f32]) -> Canvas {
-    let column = inner_w() / crate::config::sound::equalizer::bands().len() as f32;
+/*
+ * drawn by curve.wgsl, for the same reason as the ring: the points are worked out there,
+ * from the knobs' heights and at most 36 live levels
+ */
+fn curve(gains: &[f32; 10], levels: &[f32]) -> Rectangle {
+    let bands = crate::config::sound::equalizer::bands().len().clamp(2, gains.len());
+    let column = inner_w() / bands as f32;
 
-    let points: Vec<(f32, f32)> = (0..=c::equalizer::curve_steps())
-        .map(|step| {
-            let along = step as f32 / c::equalizer::curve_steps() as f32;
+    let given = levels.len().min(36);
+    let sampled: Vec<f32> = (0..given).map(|slot| levels[if given > 1 { slot * (levels.len() - 1) / (given - 1) } else { 0 }]).collect();
 
-            // cosine blend between neighbouring knobs keeps the curve round
-            let place = along * (crate::config::sound::equalizer::bands().len() - 1) as f32;
-            let band = (place.floor() as usize).min(crate::config::sound::equalizer::bands().len() - 2);
-            let eased = (1.0 - ((place - band as f32) * PI).cos()) / 2.0;
+    let knobs: Vec<f32> = gains[..bands].iter().map(|&gain| knob_y(gain)).collect();
 
-            let y = mix(knob_y(gains[band]), knob_y(gains[band + 1]), eased);
+    let mut values = vec![
+        [column / 2.0, inner_w() - column, c::equalizer::curve_steps() as f32, bands as f32],
+        [given as f32, 7.0, 2.0, 0.0],
+        surface::plain(faded(theme::now().accent, 45)),
+        surface::plain(faded(theme::now().accent, 235)),
+    ];
 
-            let level = if levels.is_empty() { 0.0 } else { levels[((along * (levels.len() - 1) as f32).round() as usize).min(levels.len() - 1)] };
+    // three rows of knobs whatever their number, so the levels always start at row 7
+    let mut knob_rows = surface::rows(&knobs);
 
-            let shiver = level * 9.0 * if step % 2 == 0 { -1.0 } else { 0.6 };
+    knob_rows.resize(3, [0.0; 4]);
+    values.extend(knob_rows);
+    values.extend(surface::rows(&sampled));
 
-            (column / 2.0 + along * (inner_w() - column), y + shiver)
-        })
-        .collect();
-
-    let stroke = |width: f32, alpha: u8| {
-        let mut path = Path::new().move_to(points[0].0, points[0].1);
-
-        for (x, y) in &points[1..] {
-            path = path.line_to(*x, *y);
-        }
-
-        path.stroke(width, faded(theme::now().accent, alpha)).cap(Cap::Round)
-    };
-
-    // a wide faint stroke under a thin bright one reads as a glow
-    Canvas::new().width(inner_w()).height(c::equalizer::slider_height()).shapes(shapes![stroke(7.0, 45), stroke(2.0, 235)])
+    Rectangle::new().width(inner_w()).height(c::equalizer::slider_height()).shader(CURVE.as_path()).shader_values(values)
 }
 
 fn presets(scene: &Scene) -> Column {
@@ -1337,7 +1307,7 @@ fn title(player: &MediaPlayer) -> &str {
 }
 
 // a round cover with a pink rim, optionally with a cd hole; a soft gradient while there is none or it decodes
-fn cover(art: &str, size: f32, rim: f32, hole: bool) -> Rectangle {
+pub fn cover(art: &str, size: f32, rim: f32, hole: bool) -> Rectangle {
     let frame = Rectangle::new()
         .width(size)
         .height(size)
@@ -1364,20 +1334,27 @@ fn cover(art: &str, size: f32, rim: f32, hole: bool) -> Rectangle {
 /*
  * the pill's visualiser: seven bars from the shown player's own sound, glowing when
  * loud; a pause sign while paused, and still bars while the capture starts or the
- * player has no stream to listen to
+ * player has no stream to listen to. the bars are rounded rectangles, which amane draws
+ * as quads: as stroked paths on a canvas they cost a vello pass over the whole island
+ * window on every frame of the music
  */
-fn pill_levels(playing: bool, levels: &[f32]) -> Canvas {
+fn pill_levels(playing: bool, levels: &[f32]) -> Rectangle {
     let (bars, width, height) = (c::pill::bars(), c::pill::bars_width(), c::pill::bars_height());
 
     if !playing {
-        return icon(Glyph::Pause, 13.0, theme::now().dim);
+        return Rectangle::new().width(13.0).height(13.0).child(icon(Glyph::Pause, 13.0, theme::now().dim));
     }
 
     // lows on the left, highs on the right, no mirroring; every bar grows up and down from the middle line
     let middle = height / 2.0;
 
-    let mut glow = Path::new();
-    let mut body = Path::new();
+    // a round-capped line `thick` wide from y0 to y1 at x: a pill shape reaching past both ends by half its width
+    let line = |x: f32, y0: f32, y1: f32, thick: f32, color: Color| {
+        Rectangle::new().width(thick).height(y1 - y0 + thick).radius(Full).fill(color).translate(x - thick / 2.0, y0 - thick / 2.0)
+    };
+
+    let mut glow: Vec<Box<dyn Widget>> = Vec::new();
+    let mut body: Vec<Box<dyn Widget>> = Vec::new();
 
     for index in 0..bars {
         let level = if levels.is_empty() {
@@ -1394,17 +1371,17 @@ fn pill_levels(playing: bool, levels: &[f32]) -> Canvas {
         let half = 1.5 + level * (middle - 3.0);
         let x = 3.0 + index as f32 * (width - 6.0) / bars.saturating_sub(1).max(1) as f32;
 
-        body = body.move_to(x, middle - half).line_to(x, middle + half);
+        body.push(Box::new(line(x, middle - half, middle + half, 3.2, theme::now().accent)));
 
         if level > 0.3 {
-            glow = glow.move_to(x, middle - half).line_to(x, middle + half);
+            glow.push(Box::new(line(x, middle - half, middle + half, 7.0, faded(theme::now().accent, 55))));
         }
     }
 
-    Canvas::new().width(width).height(height).shapes(shapes![
-        glow.stroke(7.0, faded(theme::now().accent, 55)).cap(Cap::Round),
-        body.stroke(3.2, theme::now().accent).cap(Cap::Round),
-    ])
+    // every glow under every bar, as the two strokes were
+    glow.extend(body);
+
+    Rectangle::new().width(width).height(height).child(Stack::new(glow).width(width).height(height))
 }
 
 // the loudest level in one of `groups` equal slices of the spectrum, low to high

src/last.rs

@@ -0,0 +1,314 @@
+use std::collections::hash_map::DefaultHasher;
+use std::hash::{Hash, Hasher};
+use std::path::PathBuf;
+use std::process::{Command, Stdio};
+use std::thread;
+use std::time::{Duration, Instant};
+use std::{env, fs};
+
+use amane::{Bus, Center, Column, Full, Media, Pointer, Rectangle, Row, Service, Start, Text, Weight, Widget};
+
+use crate::config::appearance::{font, overlays, text};
+use crate::config::island::{card, controls, disc, idle};
+use crate::glyph::{Glyph, icon};
+use crate::island::{self, Island};
+use crate::{parse, theme};
+
+/*
+ * the island's card while nothing plays: the song it last heard (kept in
+ * $XDG_STATE_HOME/amane across restarts, its cover copied beside it) with a button that
+ * starts its player and asks it to play, and chips that start the players of
+ * island.idle.players. art.rs's thread calls watch() with every check it makes, so this
+ * needs no thread of its own
+ */
+#[derive(Clone, Default, PartialEq)]
+struct Song {
+    // the player's mpris bus name and the name it goes by
+    player: String,
+    identity: String,
+    title: String,
+    artist: String,
+    // the cover's copy, empty without one
+    cover: String,
+}
+
+pub struct Last {
+    song: Option<Song>,
+    // the players to start, as (desktop file name, the name it shows), and the setting they were read for
+    apps: Vec<(String, String)>,
+    apps_for: Option<String>,
+    // what a start is doing, or what went wrong
+    note: Option<String>,
+}
+
+impl Service for Last {
+    fn new() -> Self {
+        let saved = parse::settings(&fs::read_to_string(folder().join("last-played")).unwrap_or_default());
+        let get = |key: &str| saved.iter().find(|(name, _)| name == key).map_or(String::new(), |(_, value)| value.clone());
+
+        let song = Song { player: get("player"), identity: get("identity"), title: get("title"), artist: get("artist"), cover: get("cover") };
+
+        Self { song: Some(song).filter(|song| !song.title.is_empty()), apps: Vec::new(), apps_for: None, note: None }
+    }
+
+    // changes through watch() and the buttons
+    fn listen() {}
+}
+
+const PREFIX: &str = "org.mpris.MediaPlayer2.";
+
+fn folder() -> PathBuf {
+    let state = env::var_os("XDG_STATE_HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from(env::var_os("HOME").unwrap_or_default()).join(".local/state"));
+
+    state.join("amane")
+}
+
+// one line, for the key = value file
+fn clean(words: &str) -> String {
+    words.replace(['\n', '\r'], " ").trim().to_string()
+}
+
+/*
+ * art.rs's check, with the cover it holds for the island's player: notes the song the
+ * island's player plays, and reads the players to start again when their setting changed
+ */
+pub fn watch(url: &str, path: &str) {
+    let wanted = idle::players();
+
+    if Last::read().apps_for.as_deref() != Some(wanted.as_str()) {
+        let apps = desktop_apps(&wanted);
+        let mut last = Last::write();
+
+        last.apps = apps;
+        last.apps_for = Some(wanted);
+    }
+
+    let selected = Island::read().selected.clone();
+
+    let now = {
+        let media = Media::read();
+
+        island::shown(&media, selected.as_deref()).filter(|player| player.playing() && !player.title().is_empty()).map(|player| {
+            let song = Song { player: player.name().to_string(), identity: clean(player.identity()), title: clean(player.title()), artist: clean(player.artist()), cover: String::new() };
+
+            (song, player.art_url() == url && !path.is_empty())
+        })
+    };
+
+    let Some((mut song, cover_ready)) = now else { return };
+
+    let known = Last::read().song.clone();
+    let same = known.as_ref().is_some_and(|known| known.player == song.player && known.title == song.title && known.artist == song.artist);
+    let has_cover = known.as_ref().is_some_and(|known| !known.cover.is_empty());
+
+    // the same song, and its cover kept already or not there yet
+    if same && (has_cover || !cover_ready) {
+        return;
+    }
+
+    song.cover = if cover_ready { keep_cover(path, &song) } else { String::new() };
+
+    if let Some(old) = known.filter(|old| !old.cover.is_empty() && old.cover != song.cover) {
+        let _ = fs::remove_file(&old.cover);
+    }
+
+    save(&song);
+
+    Last::write().song = Some(song);
+}
+
+// a copy of the cover under a name of its own (amane keeps a picture by its path, so a reused name would show the old one)
+fn keep_cover(path: &str, song: &Song) -> String {
+    let mut hasher = DefaultHasher::new();
+
+    (&song.player, &song.title, &song.artist).hash(&mut hasher);
+
+    let file = folder().join(format!("cover-{:016x}", hasher.finish()));
+    let _ = fs::create_dir_all(folder());
+
+    if fs::copy(path, &file).is_ok() { file.to_string_lossy().into_owned() } else { String::new() }
+}
+
+fn save(song: &Song) {
+    let _ = fs::create_dir_all(folder());
+
+    let text = format!(
+        "# the song the island last heard, for its card while nothing plays\nplayer = {}\nidentity = {}\ntitle = {}\nartist = {}\ncover = {}\n",
+        song.player, song.identity, song.title, song.artist, song.cover
+    );
+
+    let _ = fs::write(folder().join("last-played"), text);
+}
+
+// the players of the setting that have a desktop file, with the name it gives them
+fn desktop_apps(wanted: &str) -> Vec<(String, String)> {
+    let home = PathBuf::from(env::var_os("HOME").unwrap_or_default());
+    let folders = [home.join(".local/share/applications"), PathBuf::from("/usr/local/share/applications"), PathBuf::from("/usr/share/applications")];
+
+    wanted
+        .split(',')
+        .map(str::trim)
+        .filter(|id| !id.is_empty())
+        .filter_map(|id| {
+            let entry = folders.iter().find_map(|folder| fs::read_to_string(folder.join(format!("{id}.desktop"))).ok())?;
+            let name = parse::settings(&entry).into_iter().find(|(key, _)| key == "Name").map_or_else(|| id.to_string(), |(_, name)| name);
+
+            Some((id.to_string(), name))
+        })
+        .collect()
+}
+
+// a player's desktop file name from its bus name: org.mpris.MediaPlayer2.firefox.instance_1_2 is firefox
+fn app_of(bus: &str) -> String {
+    bus.strip_prefix(PREFIX).unwrap_or(bus).split('.').next().unwrap_or_default().to_string()
+}
+
+fn say(note: Option<String>) {
+    Last::write().note = note;
+}
+
+/*
+ * starts a player (gtk-launch), and with `resume` (its bus name) asks it to play until it
+ * does or island.idle.wait_s runs out. the card closes: the pill shows the song once it plays
+ */
+fn start(id: String, resume: Option<String>) {
+    let name = Last::read().apps.iter().find(|(app, _)| *app == id).map_or_else(|| id.clone(), |(_, name)| name.clone());
+
+    island::collapse();
+
+    thread::spawn(move || {
+        say(Some(format!("Starting {name}…")));
+
+        let started = Command::new("gtk-launch").arg(&id).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null()).status().is_ok_and(|status| status.success());
+
+        if !started {
+            say(Some(format!("{name} couldn't be started (gtk-launch {id})")));
+
+            return;
+        }
+
+        let Some(bus) = resume else {
+            say(None);
+
+            return;
+        };
+
+        let until = Instant::now() + Duration::from_secs(idle::wait_s());
+
+        while Instant::now() < until {
+            // an instance number may follow the name it had before
+            let found = {
+                let media = Media::read();
+
+                media.players().iter().find(|player| player.name() == bus || player.name().starts_with(&format!("{bus}."))).map(|player| (player.name().to_string(), player.playing()))
+            };
+
+            match found {
+                Some((_, true)) => {
+                    say(None);
+
+                    return;
+                }
+                // Play is harmless when it already plays, so it's asked until it does
+                Some((player, false)) => {
+                    Bus::session().call(&player, "/org/mpris/MediaPlayer2", "org.mpris.MediaPlayer2.Player", "Play", &[]);
+                }
+                None => {}
+            }
+
+            thread::sleep(Duration::from_millis(idle::check_ms()));
+        }
+
+        say(Some(format!("{name} opened but didn't start playing")));
+    });
+}
+
+pub fn height() -> f32 {
+    2.0 * card::pad() + disc::size() + card::gap() + controls::chip_height()
+}
+
+// a line of text in a box as wide as the side, cut with … when longer
+fn line(words: impl Into<String>, size: f32, color: amane::Color, bold: bool, width: f32) -> Rectangle {
+    let words = Text::new(words).size(size).color(color).weight(if bold { Weight::Bold } else { Weight::Regular }).elide();
+
+    Rectangle::new().width(width).height(size + 8.0).align_child(Start, Center).child(words)
+}
+
+fn chip(words: &str, pressed: impl Fn() + 'static) -> Rectangle {
+    let width = words.chars().count() as f32 * text::small() * font::letter_width() + 18.0;
+
+    Rectangle::new()
+        .width(width)
+        .height(controls::chip_height())
+        .radius(Full)
+        .fill(overlays::chip())
+        .align_child(Center, Center)
+        .cursor(Pointer)
+        .on_click(move |_| pressed())
+        .child(Text::new(words).size(text::small()).color(theme::now().text))
+}
+
+pub fn card() -> Rectangle {
+    let last = Last::read();
+    let theme = theme::now();
+    let (width, pad, gap) = (card::width(), card::pad(), card::gap());
+    let inner_w = width - 2.0 * pad;
+    let side_w = inner_w - disc::size() - card::side_gap();
+
+    // the last song's cover on the cd, or the empty cd
+    let cover = last.song.as_ref().map_or("", |song| song.cover.as_str());
+    let cd = Rectangle::new().width(disc::size()).height(disc::size()).align_child(Center, Center).child(island::cover(cover, disc::cover(), 2.0, true));
+
+    let mut lines: Vec<Box<dyn Widget>> = Vec::new();
+
+    match &last.song {
+        Some(song) => {
+            let (app, bus) = (app_of(&song.player), song.player.clone());
+            let words = format!("Play in {}", song.identity);
+            let button_w = words.chars().count() as f32 * text::small() * font::letter_width() + 44.0;
+
+            lines.push(Box::new(line("Last played", text::small(), theme.dim, false, side_w)));
+            lines.push(Box::new(line(song.title.as_str(), text::title(), theme.text, true, side_w)));
+            lines.push(Box::new(line(song.artist.as_str(), text::body(), theme.dim, false, side_w)));
+
+            lines.push(Box::new(
+                Rectangle::new()
+                    .width(button_w)
+                    .height(controls::chip_height() + 10.0)
+                    .radius(Full)
+                    .fill(theme.accent)
+                    .align_child(Center, Center)
+                    .cursor(Pointer)
+                    .on_click(move |_| start(app.clone(), Some(bus.clone())))
+                    .child(Row::new(vec![Box::new(icon(Glyph::Play, 12.0, theme.on_accent)) as Box<dyn Widget>, Box::new(Text::new(words).size(text::small()).weight(Weight::Bold).color(theme.on_accent))]).gap(8.0).align(Center)),
+            ));
+        }
+        None => {
+            lines.push(Box::new(line("Nothing playing", text::title(), theme.text, true, side_w)));
+            lines.push(Box::new(line("Start a player below", text::small(), theme.dim, false, side_w)));
+        }
+    }
+
+    if let Some(note) = &last.note {
+        lines.push(Box::new(line(note.as_str(), text::small(), theme.dim, false, side_w)));
+    }
+
+    let side = Rectangle::new().width(side_w).height(disc::size()).align_child(Start, Center).child(Column::new(lines).gap(gap / 2.0));
+
+    // the players to start
+    let mut chips: Vec<Box<dyn Widget>> = vec![Box::new(Text::new("Start").size(text::small()).color(theme.dim))];
+
+    for (id, name) in &last.apps {
+        let id = id.clone();
+
+        chips.push(Box::new(chip(name, move || start(id.clone(), None))));
+    }
+
+    if last.apps.is_empty() {
+        chips.push(Box::new(Text::new("no player of island.idle.players has a desktop file").size(text::small()).color(theme.dim)));
+    }
+
+    let bottom = Rectangle::new().width(inner_w).height(controls::chip_height()).align_child(Start, Center).child(Row::new(chips).gap(gap / 2.0).align(Center));
+
+    Rectangle::new().width(width).height(height()).padding(pad).child(Column::new(vec![Box::new(Row::new(vec![Box::new(cd) as Box<dyn Widget>, Box::new(side)]).gap(card::side_gap())) as Box<dyn Widget>, Box::new(bottom)]).gap(gap))
+}

src/main.rs

@@ -7,6 +7,7 @@ mod glyph;
 mod home;
 mod hypr;
 mod island;
+mod last;
 mod map;
 mod notices;
 mod parse;

src/notices.rs

@@ -11,7 +11,7 @@ use amane::{
 use crate::config::appearance::{overlays, text};
 use crate::config::control::pill as control_pill;
 use crate::config::island::pill as island_pill;
-use crate::config::notifications::popups as settings;
+use crate::config::notifications::{apps, popups as settings};
 use crate::glyph::Glyph;
 use crate::island::{self, faded};
 use crate::parse::{self, Value};
@@ -72,8 +72,11 @@ fn timeout(urgency: Urgency) -> Option<Duration> {
 }
 
 fn watch() {
-    let current: Vec<(u32, SystemTime, Urgency, String, String)> =
-        Notifications::read().list().iter().map(|notice| (notice.id(), notice.received(), notice.urgency(), notice.icon().to_string(), notice.image().to_string())).collect();
+    let current: Vec<(u32, SystemTime, Urgency, String, String, String)> = Notifications::read()
+        .list()
+        .iter()
+        .map(|notice| (notice.id(), notice.received(), notice.urgency(), notice.icon().to_string(), notice.image().to_string(), notice.app_name().to_string()))
+        .collect();
 
     let (arrived, gone, expired) = {
         let notices = Notices::read();
@@ -99,25 +102,34 @@ fn watch() {
         return;
     }
 
+    // a blocked app's notifications are dropped at once; a muted one's stay in the history without popping up
+    let (blocked, muted) = (apps::blocked(), apps::muted());
+    let (dropped, arrived): (Vec<_>, Vec<_>) = arrived.into_iter().partition(|(.., app)| listed(&blocked, app));
+
+    for (id, ..) in &dropped {
+        Notifications::dismiss(*id);
+    }
+
     // icon lookups walk the themes: here, not under the lock and never in a view
-    let pictures: Vec<(u32, Option<String>)> = arrived.iter().map(|(id, _, _, icon, image)| (*id, picture(icon, image))).collect();
+    let pictures: Vec<(u32, Option<String>)> = arrived.iter().map(|(id, _, _, icon, image, _)| (*id, picture(icon, image))).collect();
 
     let looking = pods::open_card() == Some(pods::Pod::Notifications);
     let popping = settings::enabled();
 
     let mut notices = Notices::write();
 
-    for (id, received, ..) in &arrived {
+    for (id, received, .., app) in &arrived {
         let fresh = !notices.known.contains_key(id);
+        let quiet = listed(&muted, app);
 
         notices.known.insert(*id, *received);
         notices.popups.retain(|(shown, _)| shown != id);
 
-        if popping {
+        if popping && !quiet {
             notices.popups.insert(0, (*id, Instant::now()));
         }
 
-        if fresh && !looking {
+        if fresh && !looking && !quiet {
             notices.unread += 1;
         }
     }
@@ -139,6 +151,46 @@ fn watch() {
     notices.unread = notices.unread.min(notices.known.len());
 }
 
+// whether `app` is in a comma-separated list of app names, in any case
+fn listed(list: &str, app: &str) -> bool {
+    !app.is_empty() && list.split(',').any(|name| name.trim().eq_ignore_ascii_case(app))
+}
+
+// puts an app into the list at `path` in config.toml, or takes it out
+fn relist(path: &str, list: String, app: &str, on: bool) {
+    let mut names: Vec<&str> = list.split(',').map(str::trim).filter(|name| !name.is_empty() && !name.eq_ignore_ascii_case(app)).collect();
+
+    if on {
+        names.push(app);
+    }
+
+    let _ = config::set(path, Value::Text(names.join(", ")));
+}
+
+// Mute app: its notifications stop popping up (its popups now go too) but stay in the history
+fn mute(app: &str, on: bool) {
+    relist("notifications.apps.muted", apps::muted(), app, on);
+
+    if on {
+        hide_app(app);
+    }
+}
+
+// Block app: its notifications are dropped from now on
+fn block(app: &str, on: bool) {
+    relist("notifications.apps.blocked", apps::blocked(), app, on);
+
+    if on {
+        hide_app(app);
+    }
+}
+
+fn hide_app(app: &str) {
+    let ids: Vec<u32> = Notifications::read().list().iter().filter(|notice| notice.app_name().eq_ignore_ascii_case(app)).map(Notification::id).collect();
+
+    Notices::write().popups.retain(|(shown, _)| !ids.contains(shown));
+}
+
 // a notification's picture as a file: its image (a path or file:// url), else its icon (a path or a theme name)
 fn picture(icon: &str, image: &str) -> Option<String> {
     for wanted in [image, icon] {
@@ -394,14 +446,29 @@ pub fn card(width: f32, height: f32) -> Rectangle {
     let list = Notifications::read();
     let theme = theme::now();
 
-    let mut buttons: Vec<Box<dyn Widget>> = vec![Box::new(pods::chip(if settings::enabled() { "Mute" } else { "Unmute" }, None, toggle_quiet))];
+    let mut buttons: Vec<Box<dyn Widget>> = vec![Box::new(pods::chip(if settings::enabled() { "Do not disturb" } else { "Popups on" }, None, toggle_quiet))];
 
     if !list.list().is_empty() {
         buttons.push(Box::new(pods::chip("Clear all", None, Notifications::clear)));
     }
 
     let header = pods::header("Notifications", buttons, width);
-    let list_h = height - pods::header_height() - 10.0;
+
+    // the muted and blocked apps, each a chip that takes it off its list again
+    let (muted, blocked) = (apps::muted(), apps::blocked());
+    let names = |list: &str| list.split(',').map(str::trim).filter(|name| !name.is_empty()).map(str::to_string).collect::<Vec<_>>();
+    let mut undo: Vec<Box<dyn Widget>> = Vec::new();
+
+    for app in names(&muted) {
+        undo.push(Box::new(pods::chip(&format!("Unmute {app}"), Some(Glyph::Muted), move || mute(&app, false))));
+    }
+
+    for app in names(&blocked) {
+        undo.push(Box::new(pods::chip(&format!("Unblock {app}"), Some(Glyph::Cross), move || block(&app, false))));
+    }
+
+    let undo_h = if undo.is_empty() { 0.0 } else { 26.0 + 10.0 };
+    let list_h = height - pods::header_height() - 10.0 - undo_h;
 
     let body: Box<dyn Widget> = if !list.running() {
         Box::new(
@@ -430,7 +497,25 @@ pub fn card(width: f32, height: f32) -> Rectangle {
             let (content, inner_h) = face(notice, notices.pictures.get(&id), item_w - 24.0, 4, Box::new(move || Notifications::dismiss(id)));
             let has_default = notice.has_default_action();
 
-            let item = Rectangle::new().width(item_w).height(inner_h + 24.0).radius(16.0).fill(overlays::chip()).padding(12.0).child(content);
+            // Mute app keeps its notifications quiet in the history, Block app drops them
+            let app = notice.app_name().to_string();
+            let content: Box<dyn Widget> = if app.is_empty() {
+                Box::new(content)
+            } else {
+                let quiet = listed(&muted, &app);
+                let (for_mute, for_block) = (app.clone(), app.clone());
+
+                let choices = Row::new(vec![
+                    Box::new(pods::chip(if quiet { "Unmute app" } else { "Mute app" }, Some(Glyph::Muted), move || mute(&for_mute, !quiet))) as Box<dyn Widget>,
+                    Box::new(pods::chip("Block app", Some(Glyph::Cross), move || block(&for_block, true))),
+                ])
+                .gap(6.0);
+
+                Box::new(Column::new(vec![Box::new(content) as Box<dyn Widget>, Box::new(Rectangle::new().width(item_w - 24.0).height(26.0).align_child(amane::End, Center).child(choices))]).gap(8.0))
+            };
+            let inner_h = if app.is_empty() { inner_h } else { inner_h + 26.0 + 8.0 };
+
+            let item = Rectangle::new().width(item_w).height(inner_h + 24.0).radius(16.0).fill(overlays::chip()).padding(12.0).child(Column::new(vec![content]));
             let item = if has_default { item.cursor(Pointer).on_click(move |_| Notifications::click(id)) } else { item };
 
             items.push(Box::new(item));
@@ -439,5 +524,14 @@ pub fn card(width: f32, height: f32) -> Rectangle {
         Box::new(ScrollArea::new("notices-history", Column::new(items).gap(8.0)).width(width).height(list_h))
     };
 
-    Rectangle::new().width(width).height(height).child(Column::new(vec![Box::new(header) as Box<dyn Widget>, body]).gap(10.0))
+    let mut parts: Vec<Box<dyn Widget>> = vec![Box::new(header)];
+
+    if !undo.is_empty() {
+        // ponytail: one row, cut at the card's edge; the config window has the whole lists
+        parts.push(Box::new(Rectangle::new().width(width).height(26.0).clip().child(Row::new(undo).gap(6.0))));
+    }
+
+    parts.push(body);
+
+    Rectangle::new().width(width).height(height).child(Column::new(parts).gap(10.0))
 }

src/parse.rs

@@ -1632,41 +1632,49 @@ struct Draft {
     summary: String,
     location: String,
     cancelled: bool,
+    uid: String,
+    recurring: bool,
 }
 
 impl Draft {
     // the finished event, none without a start or when cancelled; with no end it lasts its duration, else a day or an hour
-    fn event(self) -> Option<Event> {
+    fn occurrence(self) -> Option<Occurrence> {
         let (start, all_day) = self.start.filter(|_| !self.cancelled)?;
         let end = self.end.or_else(|| self.duration.map(|duration| start.saturating_add(duration))).unwrap_or(start + if all_day { 86_400 } else { 3_600 });
 
-        Some(Event { start, end, all_day, summary: self.summary, location: self.location })
+        Some(Occurrence { event: Event { start, end, all_day, summary: self.summary, location: self.location }, uid: self.uid, recurring: self.recurring })
     }
 }
 
 /*
  * the events in an icalendar text (a caldav report's calendar-data): utc times as they are;
  * dates, TZID and floating times as local time `offset_s` seconds east of utc. cancelled events
- * are skipped, alarms can't overwrite their event, and recurrences are left to the server
+ * are skipped, alarms can't overwrite their event, and recurrences are left to the server.
+ * the shell reads ics_occurrences; this is the events alone, as the tests read them
  */
+#[cfg(test)]
 pub fn ics_events(ics: &str, offset_s: i64) -> Vec<Event> {
-    // a line starting with a space or tab continues the one before
-    let mut lines: Vec<String> = Vec::new();
+    ics_occurrences(ics, offset_s).into_iter().map(|occurrence| occurrence.event).collect()
+}
 
-    for line in ics.lines().map(|line| line.trim_end_matches('\r')) {
-        match (line.strip_prefix([' ', '\t']), lines.last_mut()) {
-            (Some(more), Some(last)) => last.push_str(more),
-            _ => lines.push(line.to_string()),
-        }
-    }
+// one event of an icalendar text with what changing it takes: its UID, and whether it's part of a series
+#[derive(Debug, Clone, PartialEq)]
+pub struct Occurrence {
+    pub event: Event,
+    pub uid: String,
+    // an RRULE or RDATE, or one instance the server expanded from a series (it has a RECURRENCE-ID)
+    pub recurring: bool,
+}
 
-    let mut events = Vec::new();
+// the events of an icalendar text like ics_events, each with its UID and whether it repeats
+pub fn ics_occurrences(ics: &str, offset_s: i64) -> Vec<Occurrence> {
+    let mut occurrences = Vec::new();
     let mut draft: Option<Draft> = None;
 
     // how deep inside a VEVENT's own blocks, like VALARM, a line is
     let mut nested = 0;
 
-    for line in &lines {
+    for line in &unfolded(ics) {
         let Some((head, value)) = content_line(line) else {
             continue;
         };
@@ -1677,7 +1685,7 @@ pub fn ics_events(ics: &str, offset_s: i64) -> Vec<Event> {
             ("BEGIN", None) if value.eq_ignore_ascii_case("VEVENT") => draft = Some(Draft::default()),
             ("BEGIN", Some(_)) => nested += 1,
             ("END", Some(_)) if nested > 0 => nested -= 1,
-            ("END", Some(_)) if value.eq_ignore_ascii_case("VEVENT") => events.extend(draft.take().and_then(Draft::event)),
+            ("END", Some(_)) if value.eq_ignore_ascii_case("VEVENT") => occurrences.extend(draft.take().and_then(Draft::occurrence)),
             (_, Some(_)) if nested > 0 => {}
             ("SUMMARY", Some(event)) => event.summary = ics_text(value),
             ("LOCATION", Some(event)) => event.location = ics_text(value),
@@ -1685,11 +1693,27 @@ pub fn ics_events(ics: &str, offset_s: i64) -> Vec<Event> {
             ("DTSTART", Some(event)) => event.start = ics_time(value, offset_s),
             ("DTEND", Some(event)) => event.end = ics_time(value, offset_s).map(|(time, _)| time),
             ("DURATION", Some(event)) => event.duration = ics_duration(value),
+            ("UID", Some(event)) => event.uid = ics_text(value.trim()),
+            ("RRULE" | "RDATE" | "RECURRENCE-ID", Some(event)) => event.recurring = true,
             _ => {}
         }
     }
 
-    events
+    occurrences
+}
+
+// an icalendar or vcard text as whole content lines: a line starting with a space or tab continues the one before
+fn unfolded(text: &str) -> Vec<String> {
+    let mut lines: Vec<String> = Vec::new();
+
+    for line in text.lines().map(|line| line.trim_end_matches('\r')) {
+        match (line.strip_prefix([' ', '\t']), lines.last_mut()) {
+            (Some(more), Some(last)) => last.push_str(more),
+            _ => lines.push(line.to_string()),
+        }
+    }
+
+    lines
 }
 
 // an ics line as (name with its parameters, value), split at the first ':' outside quotes
@@ -1825,6 +1849,563 @@ pub fn dav_time(unix: i64) -> String {
     format!("{year:04}{month:02}{day:02}T{:02}{:02}{:02}Z", seconds / 3_600, seconds / 60 % 60, seconds % 60)
 }
 
+/*
+ * webdav answers beyond calendars' own: the href inside a property (current-user-principal,
+ * calendar-home-set, addressbook-home-set), a report's resources, address books, and the
+ * calendars the user may only read
+ */
+pub fn dav_href(xml: &str, property: &str) -> Option<String> {
+    xml_blocks(xml, property).iter().find_map(|block| xml_texts(block, "href").into_iter().find(|href| !href.is_empty()))
+}
+
+// one resource in a calendar-query or addressbook-query answer: its href, etag (quotes kept) and data
+#[derive(Debug, Clone, PartialEq)]
+pub struct Resource {
+    pub href: String,
+    pub etag: String,
+    pub data: String,
+}
+
+// the resources in a report answer, `data` naming the element that holds each one's text (calendar-data, address-data)
+pub fn dav_resources(xml: &str, data: &str) -> Vec<Resource> {
+    xml_blocks(xml, "response")
+        .iter()
+        .filter_map(|response| {
+            let found: String = xml_blocks(response, "propstat").into_iter().filter(|propstat| xml_texts(propstat, "status").iter().all(|status| status.contains(" 200"))).collect();
+            let href = xml_texts(response, "href").into_iter().next()?;
+            let text = xml_texts(&found, data).into_iter().next().filter(|text| !text.is_empty())?;
+            let etag = xml_texts(&found, "getetag").into_iter().next().unwrap_or_default();
+
+            Some(Resource { href, etag, data: text })
+        })
+        .collect()
+}
+
+// the address books in a depth 1 propfind answer, by href
+pub fn dav_addressbooks(xml: &str) -> Vec<String> {
+    xml_blocks(xml, "response")
+        .iter()
+        .filter(|response| xml_blocks(response, "resourcetype").iter().any(|kinds| !xml_blocks(kinds, "addressbook").is_empty()))
+        .filter_map(|response| xml_texts(response, "href").into_iter().next())
+        .collect()
+}
+
+// the calendars in a propfind answer whose current-user-privilege-set grants no writing; one without the property counts as writable
+pub fn dav_read_only(xml: &str) -> Vec<String> {
+    xml_blocks(xml, "response")
+        .iter()
+        .filter(|response| {
+            let found: String = xml_blocks(response, "propstat").into_iter().filter(|propstat| xml_texts(propstat, "status").iter().all(|status| status.contains(" 200"))).collect();
+            let sets = xml_blocks(&found, "current-user-privilege-set");
+
+            !sets.is_empty() && sets.iter().all(|set| ["write", "write-content", "all"].iter().all(|right| xml_blocks(set, right).is_empty()))
+        })
+        .filter_map(|response| xml_texts(response, "href").into_iter().next())
+        .collect()
+}
+
+/*
+ * curl's output with `-w "\n%{http_code}\n%header{etag}"` after the body, as
+ * (body, status code, etag); the etag is empty when the server sent none, or when
+ * a curl older than 7.84 printed the variable as it was
+ */
+pub fn curl_answer(printed: &str) -> (&str, &str, &str) {
+    let mut parts = printed.rsplitn(3, '\n');
+    let etag = parts.next().unwrap_or("").trim();
+    let status = parts.next().unwrap_or("");
+    let body = parts.next().unwrap_or("");
+
+    (body, status.trim(), if etag.starts_with("%header") { "" } else { etag })
+}
+
+/*
+ * text as a quoted value in a curl config file (read with -K - from stdin, which is how the
+ * password and the bodies reach curl): backslashes, quotes and line breaks escaped
+ */
+pub fn curl_quoted(text: &str) -> String {
+    let mut quoted = String::with_capacity(text.len() + 2);
+
+    quoted.push('"');
+
+    for letter in text.chars() {
+        match letter {
+            '\\' => quoted.push_str("\\\\"),
+            '"' => quoted.push_str("\\\""),
+            '\n' => quoted.push_str("\\n"),
+            '\r' => quoted.push_str("\\r"),
+            '\t' => quoted.push_str("\\t"),
+            other => quoted.push(other),
+        }
+    }
+
+    quoted.push('"');
+
+    quoted
+}
+
+// a utc offset as `date +%z` prints it (+0200, -0930) in seconds east of utc
+pub fn zone_offset(printed: &str) -> Option<i64> {
+    let printed = printed.trim();
+    let (sign, digits) = match printed.strip_prefix('-') {
+        Some(digits) => (-1, digits),
+        None => (1, printed.strip_prefix('+').unwrap_or(printed)),
+    };
+
+    if digits.len() != 4 || !digits.chars().all(|digit| digit.is_ascii_digit()) {
+        return None;
+    }
+
+    let hours: i64 = digits.get(..2)?.parse().ok()?;
+    let minutes: i64 = digits.get(2..)?.parse().ok()?;
+
+    Some(sign * (hours * 3_600 + minutes * 60))
+}
+
+// a time of day as typed (9, 930, 0930, 9:30, 09.30, 9h30) in minutes after midnight
+pub fn clock_minutes(typed: &str) -> Option<u32> {
+    let typed = typed.trim();
+    let (hours, minutes) = match typed.find([':', '.', 'h', 'H']) {
+        Some(at) => (typed.get(..at)?, typed.get(at + 1..)?),
+        None if typed.len() <= 2 => (typed, "0"),
+        None if typed.len() <= 4 => typed.split_at(typed.len() - 2),
+        None => return None,
+    };
+
+    if hours.is_empty() || minutes.is_empty() || !hours.chars().chain(minutes.chars()).all(|digit| digit.is_ascii_digit()) || minutes.len() > 2 {
+        return None;
+    }
+
+    let (hours, minutes): (u32, u32) = (hours.parse().ok()?, minutes.parse().ok()?);
+
+    (hours < 24 && minutes < 60).then_some(hours * 60 + minutes)
+}
+
+// days since 1970 as an icalendar DATE, like "20261016"
+pub fn ics_date(days: i64) -> String {
+    let (year, month, day) = civil_from_days(days);
+
+    format!("{year:04}{month:02}{day:02}")
+}
+
+// text for an icalendar TEXT value (RFC 5545 3.3.11): backslashes, commas, semicolons and line breaks escaped
+pub fn ics_escape(text: &str) -> String {
+    let mut escaped = String::with_capacity(text.len() + 8);
+    let mut letters = text.chars().peekable();
+
+    while let Some(letter) = letters.next() {
+        match letter {
+            '\\' => escaped.push_str("\\\\"),
+            ',' => escaped.push_str("\\,"),
+            ';' => escaped.push_str("\\;"),
+            '\n' => escaped.push_str("\\n"),
+            '\r' => {
+                letters.next_if_eq(&'\n');
+                escaped.push_str("\\n");
+            }
+            other => escaped.push(other),
+        }
+    }
+
+    escaped
+}
+
+// one content line folded so no line is longer than 75 octets (RFC 5545 3.1), never inside a utf-8 character, ending in CRLF
+pub fn ics_fold(line: &str) -> String {
+    let mut folded = String::with_capacity(line.len() + line.len() / 64 * 3 + 2);
+    let mut used = 0;
+
+    for letter in line.chars() {
+        if used + letter.len_utf8() > 75 {
+            folded.push_str("\r\n ");
+            used = 1;
+        }
+
+        folded.push(letter);
+        used += letter.len_utf8();
+    }
+
+    folded.push_str("\r\n");
+
+    folded
+}
+
+// when an event happens, as written: whole days from `first` (days since 1970) for `days` days, or utc unix seconds
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum When {
+    AllDay { first: i64, days: i64 },
+    Timed { start: i64, end: i64 },
+}
+
+impl When {
+    fn lines(self) -> [String; 2] {
+        match self {
+            Self::AllDay { first, days } => [format!("DTSTART;VALUE=DATE:{}", ics_date(first)), format!("DTEND;VALUE=DATE:{}", ics_date(first + days.max(1)))],
+            Self::Timed { start, end } => [format!("DTSTART:{}", dav_time(start)), format!("DTEND:{}", dav_time(end.max(start)))],
+        }
+    }
+}
+
+const PRODID: &str = "PRODID:-//Magic Island//amane-config//EN";
+
+// a new calendar resource holding one event, `stamp` (unix seconds) as its creation time
+pub fn ics_new(uid: &str, stamp: i64, summary: &str, location: &str, when: When) -> String {
+    let [start, end] = when.lines();
+    let stamp = dav_time(stamp);
+
+    let mut lines = vec![
+        String::from("BEGIN:VCALENDAR"),
+        String::from("VERSION:2.0"),
+        String::from(PRODID),
+        String::from("CALSCALE:GREGORIAN"),
+        String::from("BEGIN:VEVENT"),
+        format!("UID:{}", ics_escape(uid)),
+        format!("DTSTAMP:{stamp}"),
+        format!("CREATED:{stamp}"),
+        format!("LAST-MODIFIED:{stamp}"),
+        start,
+        end,
+        format!("SUMMARY:{}", ics_escape(summary.trim())),
+    ];
+
+    if !location.trim().is_empty() {
+        lines.push(format!("LOCATION:{}", ics_escape(location.trim())));
+    }
+
+    lines.extend(["SEQUENCE:0", "END:VEVENT", "END:VCALENDAR"].map(String::from));
+
+    lines.iter().map(|line| ics_fold(line)).collect()
+}
+
+// what an edit sets in an existing event; `when` none keeps its days and times
+#[derive(Debug, Clone, PartialEq)]
+pub struct Change {
+    pub summary: String,
+    pub location: String,
+    pub when: Option<When>,
+}
+
+/*
+ * an existing calendar resource with the change made, `stamp` the time of the edit. every
+ * VEVENT in it (a series and its moved instances) gets the summary and location; the days
+ * and times go only to VEVENTs without a RECURRENCE-ID, replacing DTSTART, DTEND and
+ * DURATION. SEQUENCE goes up, DTSTAMP and LAST-MODIFIED are the stamp, Apple's structured
+ * location goes when the location changes. alarms and everything else stay as they were.
+ * none when the text holds no VEVENT
+ */
+pub fn ics_change(ics: &str, stamp: i64, change: &Change) -> Option<String> {
+    let stamp = dav_time(stamp);
+    let summary = format!("SUMMARY:{}", ics_escape(change.summary.trim()));
+    let location = (!change.location.trim().is_empty()).then(|| format!("LOCATION:{}", ics_escape(change.location.trim())));
+
+    let mut out: Vec<String> = Vec::new();
+    let mut events = 0;
+
+    // the VEVENT being copied: its lines so far, how deep in its own blocks (VALARM) a line is
+    let mut event: Option<Vec<String>> = None;
+    let mut nested = 0;
+
+    for line in unfolded(ics) {
+        if line.trim().is_empty() {
+            continue;
+        }
+
+        let Some((head, value)) = content_line(&line) else {
+            match event.as_mut() {
+                Some(lines) => lines.push(line),
+                None => out.push(line),
+            }
+
+            continue;
+        };
+
+        let key = head.split(';').next().unwrap_or(head).to_ascii_uppercase();
+
+        let Some(lines) = event.as_mut() else {
+            if key == "BEGIN" && value.trim().eq_ignore_ascii_case("VEVENT") {
+                event = Some(vec![line]);
+                nested = 0;
+            } else {
+                out.push(line);
+            }
+
+            continue;
+        };
+
+        match key.as_str() {
+            "BEGIN" => nested += 1,
+            "END" if nested > 0 => nested -= 1,
+            "END" => {
+                lines.push(line);
+                out.extend(changed_event(lines, &stamp, &summary, location.as_deref(), change));
+                event = None;
+                events += 1;
+
+                continue;
+            }
+            _ => {}
+        }
+
+        lines.push(line);
+    }
+
+    (events > 0).then(|| out.iter().map(|line| ics_fold(line)).collect())
+}
+
+// one VEVENT's lines (BEGIN to END) with the change made, see ics_change
+fn changed_event(lines: &[String], stamp: &str, summary: &str, location: Option<&str>, change: &Change) -> Vec<String> {
+    let key_of = |line: &str| content_line(line).map(|(head, _)| head.split(';').next().unwrap_or(head).to_ascii_uppercase()).unwrap_or_default();
+
+    // its own properties come before its first nested block (or its END)
+    let body_end = lines.iter().skip(1).position(|line| matches!(key_of(line).as_str(), "BEGIN" | "END")).map_or(lines.len(), |at| at + 1);
+    let (own, rest) = lines.split_at(body_end);
+
+    let instance = own.iter().any(|line| key_of(line) == "RECURRENCE-ID");
+    let when = change.when.filter(|_| !instance);
+
+    let old_location = own.iter().find(|line| key_of(line) == "LOCATION").and_then(|line| content_line(line)).map(|(_, value)| ics_text(value)).unwrap_or_default();
+    let moved = old_location.trim() != change.location.trim();
+
+    let sequence = own.iter().find(|line| key_of(line) == "SEQUENCE").and_then(|line| content_line(line)?.1.trim().parse::<u32>().ok()).map_or(1, |number| number + 1);
+
+    let mut kept: Vec<String> = Vec::new();
+
+    for line in own {
+        let key = key_of(line);
+
+        let dropped = match key.as_str() {
+            "SUMMARY" | "LOCATION" | "SEQUENCE" | "DTSTAMP" | "LAST-MODIFIED" => true,
+            "X-APPLE-STRUCTURED-LOCATION" => moved,
+            "DTSTART" | "DTEND" | "DURATION" => when.is_some(),
+            _ => false,
+        };
+
+        if !dropped {
+            kept.push(line.clone());
+        }
+    }
+
+    kept.push(format!("DTSTAMP:{stamp}"));
+    kept.push(format!("LAST-MODIFIED:{stamp}"));
+    kept.push(format!("SEQUENCE:{sequence}"));
+
+    if let Some(when) = when {
+        kept.extend(when.lines());
+    }
+
+    kept.push(summary.to_string());
+    kept.extend(location.map(String::from));
+    kept.extend(rest.iter().cloned());
+
+    kept
+}
+
+// a contact's birthday; `year` none when the card leaves it out (Apple writes 1604 with X-APPLE-OMIT-YEAR)
+#[derive(Debug, Clone, PartialEq)]
+pub struct Birthday {
+    pub name: String,
+    pub month: u32,
+    pub day: u32,
+    pub year: Option<i64>,
+}
+
+/*
+ * the birthdays in vcards (one or many in a text, 3.0 or 4.0): BDAY as 19900315, 1990-03-15,
+ * --0315, --03-15, with VALUE=date or a time after it, and Apple's year-less 1604-03-15 with
+ * X-APPLE-OMIT-YEAR=1604. the name is FN, else N's given and family names, else ORG
+ */
+pub fn vcard_birthdays(text: &str) -> Vec<Birthday> {
+    #[derive(Default)]
+    struct Card {
+        full: String,
+        parts: String,
+        org: String,
+        date: Option<(Option<i64>, u32, u32)>,
+    }
+
+    let mut birthdays = Vec::new();
+    let mut card: Option<Card> = None;
+
+    for line in unfolded(text) {
+        let Some((head, value)) = content_line(&line) else {
+            continue;
+        };
+
+        let mut params = head.split(';');
+
+        // grouped properties like item1.X-ABDATE carry their group before a dot
+        let name = params.next().unwrap_or("").rsplit('.').next().unwrap_or("").to_ascii_uppercase();
+
+        match (name.as_str(), card.as_mut()) {
+            ("BEGIN", _) if value.trim().eq_ignore_ascii_case("VCARD") => card = Some(Card::default()),
+            ("END", Some(_)) if value.trim().eq_ignore_ascii_case("VCARD") => {
+                let Some(done) = card.take() else { continue };
+                let Some((year, month, day)) = done.date else { continue };
+
+                let given_family = {
+                    let fields: Vec<String> = done.parts.split(';').map(ics_text).collect();
+                    let given = fields.get(1).map_or("", |given| given.trim());
+                    let family = fields.first().map_or("", |family| family.trim());
+
+                    format!("{given} {family}").trim().to_string()
+                };
+
+                let name = [done.full.trim().to_string(), given_family, done.org.split(';').next().map(ics_text).unwrap_or_default().trim().to_string()].into_iter().find(|name| !name.is_empty());
+
+                if let Some(name) = name {
+                    birthdays.push(Birthday { name, month, day, year });
+                }
+            }
+            ("FN", Some(card)) => card.full = ics_text(value),
+            ("N", Some(card)) => card.parts = value.to_string(),
+            ("ORG", Some(card)) => card.org = value.to_string(),
+            ("BDAY", Some(card)) => {
+                let omitted = params.find_map(|param| {
+                    let (key, number) = param.split_once('=')?;
+
+                    key.trim().eq_ignore_ascii_case("X-APPLE-OMIT-YEAR").then(|| number.trim().trim_matches('"').parse::<i64>().ok())?
+                });
+
+                card.date = birthday_date(value, omitted);
+            }
+            _ => {}
+        }
+    }
+
+    birthdays
+}
+
+// a BDAY value as (year if known, month, day)
+fn birthday_date(value: &str, omitted_year: Option<i64>) -> Option<(Option<i64>, u32, u32)> {
+    let date = value.trim().split(['T', 't']).next().unwrap_or("");
+
+    let (year, digits) = match date.strip_prefix("--") {
+        Some(rest) => (None, rest.replace('-', "")),
+        None => {
+            let digits = date.replace('-', "");
+            let year: i64 = digits.get(..4)?.parse().ok()?;
+
+            (Some(year), digits.get(4..)?.to_string())
+        }
+    };
+
+    if digits.len() != 4 || !digits.chars().all(|digit| digit.is_ascii_digit()) {
+        return None;
+    }
+
+    let month: u32 = digits.get(..2)?.parse().ok()?;
+    let day: u32 = digits.get(2..)?.parse().ok()?;
+
+    if !(1..=12).contains(&month) || !(1..=31).contains(&day) {
+        return None;
+    }
+
+    Some((year.filter(|year| Some(*year) != omitted_year), month, day))
+}
+
+// easter sunday of a year in the gregorian calendar (the anonymous gregorian computus), as days since 1970
+pub fn easter(year: i64) -> i64 {
+    let golden = year.rem_euclid(19);
+    let (century, rest) = (year.div_euclid(100), year.rem_euclid(100));
+    let (leap_centuries, century_rest) = (century / 4, century % 4);
+    let correction = (century + 8) / 25;
+    let moon = (century - correction + 1) / 3;
+    let epact = (19 * golden + century - leap_centuries - moon + 15) % 30;
+    let (leap_years, year_rest) = (rest / 4, rest % 4);
+    let weekday = (32 + 2 * century_rest + 2 * leap_years - epact - year_rest) % 7;
+    let shift = (golden + 11 * epact + 22 * weekday) / 451;
+    let month = (epact + weekday - 7 * shift + 114) / 31;
+    let day = (epact + weekday - 7 * shift + 114) % 31 + 1;
+
+    days_from_civil(year, month as u32, day as u32)
+}
+
+const STATES: [&str; 16] = ["BW", "BY", "BE", "BB", "HB", "HH", "HE", "MV", "NI", "NW", "RP", "SL", "SN", "ST", "SH", "TH"];
+
+/*
+ * the public holidays (gesetzliche Feiertage) of a German state in a year, as (days since
+ * 1970, German name), in date order: the nationwide ones and the state's own. `state` is
+ * its code (BW, BY, BE, BB, HB, HH, HE, MV, NI, NW, RP, SL, SN, ST, SH, TH); empty gives
+ * none, an unknown code only the nationwide ones. school holidays are not public holidays.
+ * Mariä Himmelfahrt counts for all of BY although it's only official in its mostly catholic
+ * places, the majority; regional ones (Augsburg's Friedensfest, Fronleichnam in parts of
+ * SN and TH) are left out
+ */
+pub fn holidays(year: i64, state: &str) -> Vec<(i64, &'static str)> {
+    let state = state.trim().to_ascii_uppercase();
+
+    if state.is_empty() {
+        return Vec::new();
+    }
+
+    let known = STATES.contains(&state.as_str());
+    let here = |states: &[&str]| known && states.contains(&state.as_str());
+    let date = |month: u32, day: u32| days_from_civil(year, month, day);
+    let easter = easter(year);
+
+    let mut days: Vec<(i64, &'static str)> = vec![
+        (date(1, 1), "Neujahr"),
+        (easter - 2, "Karfreitag"),
+        (easter + 1, "Ostermontag"),
+        (date(5, 1), "Tag der Arbeit"),
+        (easter + 39, "Christi Himmelfahrt"),
+        (easter + 50, "Pfingstmontag"),
+        (date(12, 25), "1. Weihnachtstag"),
+        (date(12, 26), "2. Weihnachtstag"),
+    ];
+
+    if year >= 1990 {
+        days.push((date(10, 3), "Tag der Deutschen Einheit"));
+    }
+
+    if here(&["BW", "BY", "ST"]) {
+        days.push((date(1, 6), "Heilige Drei Könige"));
+    }
+
+    if (here(&["BE"]) && year >= 2019) || (here(&["MV"]) && year >= 2023) {
+        days.push((date(3, 8), "Internationaler Frauentag"));
+    }
+
+    if here(&["BB", "HE"]) {
+        days.push((easter, "Ostersonntag"));
+        days.push((easter + 49, "Pfingstsonntag"));
+    }
+
+    if here(&["BE"]) && (year == 2020 || year == 2025) {
+        days.push((date(5, 8), "Tag der Befreiung"));
+    }
+
+    if here(&["BW", "BY", "HE", "NW", "RP", "SL"]) {
+        days.push((easter + 60, "Fronleichnam"));
+    }
+
+    if here(&["BY", "SL"]) {
+        days.push((date(8, 15), "Mariä Himmelfahrt"));
+    }
+
+    if here(&["TH"]) && year >= 2019 {
+        days.push((date(9, 20), "Weltkindertag"));
+    }
+
+    if year == 2017 || here(&["BB", "MV", "SN", "ST", "TH"]) || (here(&["HB", "HH", "NI", "SH"]) && year >= 2018) {
+        days.push((date(10, 31), "Reformationstag"));
+    }
+
+    if here(&["BW", "BY", "NW", "RP", "SL"]) {
+        days.push((date(11, 1), "Allerheiligen"));
+    }
+
+    // the wednesday before 23 november; everywhere until 1994
+    if here(&["SN"]) || year <= 1994 {
+        let before = date(11, 22);
+
+        days.push((before - (i64::from(weekday(before)) + 5) % 7, "Buß- und Bettag"));
+    }
+
+    days.sort_by_key(|(day, _)| *day);
+
+    days
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -2346,4 +2927,254 @@ Sink #80
         assert_eq!(dav_time(1_792_146_607), "20261016T103007Z");
         assert_eq!(dav_time(-1), "19691231T235959Z");
     }
+
+    #[test]
+    fn reads_dav_discovery_and_reports() {
+        // icloud's principal, its calendar home on another host, and a carddav home
+        let principal = r#"<?xml version="1.0" encoding="UTF-8"?><multistatus xmlns="DAV:"><response><href>/</href><propstat><prop><current-user-principal><href>/123456789/principal/</href></current-user-principal></prop><status>HTTP/1.1 200 OK</status></propstat></response></multistatus>"#;
+        let home = r#"<multistatus xmlns="DAV:"><response><href>/123456789/principal/</href><propstat><prop><calendar-home-set xmlns="urn:ietf:params:xml:ns:caldav"><href xmlns="DAV:">https://p42-caldav.icloud.com:443/123456789/calendars/</href></calendar-home-set></prop><status>HTTP/1.1 200 OK</status></propstat></response></multistatus>"#;
+        let cards = r#"<d:multistatus xmlns:d="DAV:"><d:response><d:href>/123456789/principal/</d:href><d:propstat><d:prop><card:addressbook-home-set xmlns:card="urn:ietf:params:xml:ns:carddav"><d:href>https://p42-contacts.icloud.com:443/123456789/carddavhome/</d:href></card:addressbook-home-set></d:prop><d:status>HTTP/1.1 200 OK</d:status></d:propstat></d:response></d:multistatus>"#;
+
+        assert_eq!(dav_href(principal, "current-user-principal").as_deref(), Some("/123456789/principal/"));
+        assert_eq!(dav_href(home, "calendar-home-set").as_deref(), Some("https://p42-caldav.icloud.com:443/123456789/calendars/"));
+        assert_eq!(dav_href(cards, "addressbook-home-set").as_deref(), Some("https://p42-contacts.icloud.com:443/123456789/carddavhome/"));
+        assert_eq!(dav_href(principal, "calendar-home-set"), None);
+
+        let books = r#"<multistatus xmlns="DAV:"><response><href>/123456789/carddavhome/</href><propstat><prop><resourcetype><collection/></resourcetype></prop><status>HTTP/1.1 200 OK</status></propstat></response><response><href>/123456789/carddavhome/card/</href><propstat><prop><resourcetype><collection/><addressbook xmlns="urn:ietf:params:xml:ns:carddav"/></resourcetype></prop><status>HTTP/1.1 200 OK</status></propstat></response></multistatus>"#;
+
+        assert_eq!(dav_addressbooks(books), ["/123456789/carddavhome/card/"]);
+
+        // a calendar shared read-only, the user's own with every right, one that doesn't say
+        let rights = r#"<multistatus xmlns="DAV:"><response><href>/1/calendars/shared/</href><propstat><prop><current-user-privilege-set><privilege><read/></privilege><privilege><read-current-user-privilege-set/></privilege></current-user-privilege-set></prop><status>HTTP/1.1 200 OK</status></propstat></response><response><href>/1/calendars/home/</href><propstat><prop><current-user-privilege-set><privilege><all/></privilege><privilege><read/></privilege><privilege><write/></privilege></current-user-privilege-set></prop><status>HTTP/1.1 200 OK</status></propstat></response><response><href>/1/calendars/work/</href><propstat><prop><current-user-privilege-set/></prop><status>HTTP/1.1 404 Not Found</status></propstat></response></multistatus>"#;
+
+        assert_eq!(dav_read_only(rights), ["/1/calendars/shared/"]);
+
+        // a calendar-query answer: icloud's cdata, entity-escaped data with &#13;, a 404 one left out
+        let report = "<?xml version='1.0' encoding='UTF-8'?><multistatus xmlns='DAV:'><response><href>/123456789/calendars/home/6B1C9E6A.ics</href><propstat><prop><getetag>\"mfe0k8mi\"</getetag><calendar-data xmlns='urn:ietf:params:xml:ns:caldav'><![CDATA[BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nUID:6B1C9E6A\r\nDTSTART:20261016T090000Z\r\nSUMMARY:A & B <c>\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n]]></calendar-data></prop><status>HTTP/1.1 200 OK</status></propstat></response>\
+                      <response><href>/123456789/calendars/home/x2.ics</href><propstat><prop><getetag>&quot;abc&quot;</getetag><C:calendar-data xmlns:C='urn:ietf:params:xml:ns:caldav'>BEGIN:VCALENDAR&#13;\nSUMMARY:Tom &amp; Jerry&#13;\nEND:VCALENDAR&#13;\n</C:calendar-data></prop><status>HTTP/1.1 200 OK</status></propstat></response>\
+                      <response><href>/123456789/calendars/home/gone.ics</href><propstat><prop><calendar-data/></prop><status>HTTP/1.1 404 Not Found</status></propstat></response></multistatus>";
+
+        let found = dav_resources(report, "calendar-data");
+
+        assert_eq!(found.len(), 2);
+        assert_eq!((found[0].href.as_str(), found[0].etag.as_str()), ("/123456789/calendars/home/6B1C9E6A.ics", "\"mfe0k8mi\""));
+        assert!(found[0].data.starts_with("BEGIN:VCALENDAR\r\n") && found[0].data.contains("SUMMARY:A & B <c>\r\n"));
+        assert_eq!((found[1].etag.as_str(), found[1].data.as_str()), ("\"abc\"", "BEGIN:VCALENDAR\r\nSUMMARY:Tom & Jerry\r\nEND:VCALENDAR"));
+
+        assert_eq!(curl_answer("<xml/>\nline\n207\n\"etag-1\""), ("<xml/>\nline", "207", "\"etag-1\""));
+        assert_eq!(curl_answer("\n000\n"), ("", "000", ""));
+        assert_eq!(curl_answer(""), ("", "", ""));
+        assert_eq!(curl_answer("ok\n204\n%header{etag}"), ("ok", "204", ""));
+        assert_eq!(curl_quoted("ann@icloud.com:ab\"c\\d"), "\"ann@icloud.com:ab\\\"c\\\\d\"");
+        assert_eq!(curl_quoted("BEGIN:VCALENDAR\r\n\tX"), "\"BEGIN:VCALENDAR\\r\\n\\tX\"");
+    }
+
+    #[test]
+    fn reads_offsets_and_typed_times() {
+        assert_eq!(["+0200\n", "-0930", "+0000", "0100", "+02", "bogus", ""].map(zone_offset), [Some(7_200), Some(-34_200), Some(0), Some(3_600), None, None, None]);
+
+        assert_eq!(
+            ["9", "930", "0930", "9:30", "09.30", "9h30", "23:59", "0:00", "1:5", " 18:45 "].map(clock_minutes),
+            [Some(540), Some(570), Some(570), Some(570), Some(570), Some(570), Some(1_439), Some(0), Some(65), Some(1_125)]
+        );
+        assert_eq!(["24:00", "12:60", "", "ab", "12345", ":30", "9:", "9:300", "-1"].map(clock_minutes), [None; 9]);
+    }
+
+    #[test]
+    fn reads_series_and_instances() {
+        // icloud's answer to an expanded report: an instance of a series in utc, and an all-day event
+        let ics = "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//CALENDARSERVER.ORG//NONSGML Version 1//EN\r\n\
+                   BEGIN:VEVENT\r\nUID:series-1\r\nDTSTART:20261019T080000Z\r\nDTEND:20261019T083000Z\r\nRECURRENCE-ID:20261019T070000Z\r\nSUMMARY:Stand-up\r\nEND:VEVENT\r\n\
+                   BEGIN:VEVENT\r\nUID:one-off\r\nDTSTART;VALUE=DATE:20261020\r\nDTEND;VALUE=DATE:20261021\r\nSUMMARY:Day off\r\nEND:VEVENT\r\n\
+                   BEGIN:VEVENT\r\nUID:weekly\r\nDTSTART:20261021T100000Z\r\nRRULE:FREQ=WEEKLY\r\nSUMMARY:Unexpanded\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
+
+        let day = |month, day| days_from_civil(2026, month, day) * 86_400;
+        let found = ics_occurrences(ics, 7_200);
+
+        assert_eq!(found.iter().map(|occurrence| (occurrence.uid.as_str(), occurrence.recurring)).collect::<Vec<_>>(), [("series-1", true), ("one-off", false), ("weekly", true)]);
+        assert_eq!((found[0].event.start, found[0].event.end, found[0].event.all_day), (day(10, 19) + 8 * 3_600, day(10, 19) + 8 * 3_600 + 1_800, false));
+        assert_eq!((found[1].event.start, found[1].event.end, found[1].event.all_day), (day(10, 20) - 7_200, day(10, 21) - 7_200, true));
+        assert_eq!(ics_events(ics, 7_200), found.iter().map(|occurrence| occurrence.event.clone()).collect::<Vec<_>>());
+    }
+
+    #[test]
+    fn writes_icalendar() {
+        assert_eq!(ics_escape("a, b; c\\d\ne\r\nf"), "a\\, b\\; c\\\\d\\ne\\nf");
+        assert_eq!(ics_text(&ics_escape("Tom, Jerry; \\ and\nmore")), "Tom, Jerry; \\ and\nmore");
+        assert_eq!(ics_date(days_from_civil(2026, 10, 16)), "20261016");
+
+        // 100 letters: 75 on the first line, a space and the other 25 on the next
+        let long = "X".repeat(100);
+
+        assert_eq!(ics_fold(&long), format!("{}\r\n {}\r\n", "X".repeat(75), "X".repeat(25)));
+        assert_eq!(ics_fold("SHORT:yes"), "SHORT:yes\r\n");
+
+        // two-byte letters are never cut, and no line passes 75 octets
+        let wide = format!("SUMMARY:{}", "ä".repeat(80));
+        let folded = ics_fold(&wide);
+
+        assert!(folded.split("\r\n").all(|line| line.len() <= 75));
+        assert_eq!(folded.split("\r\n").next().map(str::len), Some(74));
+        assert_eq!(unfolded(&folded), [wide]);
+
+        let stamp = 1_792_022_400;
+        let start = days_from_civil(2026, 10, 16) * 86_400 + 9 * 3_600;
+
+        assert_eq!(
+            ics_new("ABC-1", stamp, "Lunch, with Ann; Bob ", "Café Einstein", When::Timed { start, end: start + 5_400 }),
+            "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//Magic Island//amane-config//EN\r\nCALSCALE:GREGORIAN\r\nBEGIN:VEVENT\r\nUID:ABC-1\r\nDTSTAMP:20261015T000000Z\r\nCREATED:20261015T000000Z\r\n\
+             LAST-MODIFIED:20261015T000000Z\r\nDTSTART:20261016T090000Z\r\nDTEND:20261016T103000Z\r\nSUMMARY:Lunch\\, with Ann\\; Bob\r\nLOCATION:Café Einstein\r\nSEQUENCE:0\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n"
+        );
+
+        // an all-day event over two days reads back; no location, no LOCATION line
+        let trip = ics_new("T-2", stamp, "Trip", " ", When::AllDay { first: days_from_civil(2026, 10, 16), days: 2 });
+
+        assert!(trip.contains("\r\nDTSTART;VALUE=DATE:20261016\r\nDTEND;VALUE=DATE:20261018\r\n") && !trip.contains("LOCATION"));
+        assert_eq!(
+            ics_occurrences(&trip, 0),
+            [Occurrence {
+                event: Event { start: days_from_civil(2026, 10, 16) * 86_400, end: days_from_civil(2026, 10, 18) * 86_400, all_day: true, summary: String::from("Trip"), location: String::new() },
+                uid: String::from("T-2"),
+                recurring: false
+            }]
+        );
+    }
+
+    #[test]
+    fn changes_icalendar_events() {
+        // an event as apple calendar stores it on icloud: a zone, a structured location, an alarm
+        let stored = "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//Apple Inc.//macOS 15.0//EN\r\nCALSCALE:GREGORIAN\r\nBEGIN:VTIMEZONE\r\nTZID:Europe/Berlin\r\nBEGIN:DAYLIGHT\r\nTZOFFSETFROM:+0100\r\n\
+                      RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=-1SU\r\nDTSTART:19810329T020000\r\nTZNAME:CEST\r\nTZOFFSETTO:+0200\r\nEND:DAYLIGHT\r\nEND:VTIMEZONE\r\n\
+                      BEGIN:VEVENT\r\nCREATED:20261001T080000Z\r\nDTEND;TZID=Europe/Berlin:20261016T120000\r\nDTSTAMP:20261001T080000Z\r\nDTSTART;TZID=Europe/Berlin:20261016T110000\r\n\
+                      LAST-MODIFIED:20261001T080000Z\r\nLOCATION:Café Einstein\\nUnter den Linden 42\r\nSEQUENCE:2\r\nSUMMARY:Coffee\r\nUID:6B1C9E6A-1F7A-4C8E-9C51-0E3F2D8A7B11\r\n\
+                      X-APPLE-STRUCTURED-LOCATION;VALUE=URI;X-ADDRESS=Unter den Linden 42;X-APPLE-RADIUS=70;X-TITLE=\"Café Einst\r\n ein\":geo:52.517,13.389\r\n\
+                      BEGIN:VALARM\r\nACTION:DISPLAY\r\nDESCRIPTION:Reminder\r\nTRIGGER:-PT15M\r\nUID:ALARM-1\r\nEND:VALARM\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
+
+        let stamp = 1_792_022_400;
+        let start = days_from_civil(2026, 10, 16) * 86_400 + 11 * 3_600;
+        let change = Change { summary: String::from("Coffee with Ann"), location: String::from("Home"), when: Some(When::Timed { start, end: start + 3_600 }) };
+        let changed = ics_change(stored, stamp, &change).unwrap_or_default();
+
+        // the zone stays as it was; the event keeps its uid, creation and alarm
+        assert!(changed.starts_with("BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//Apple Inc.//macOS 15.0//EN\r\nCALSCALE:GREGORIAN\r\nBEGIN:VTIMEZONE\r\nTZID:Europe/Berlin\r\n"));
+        assert!(changed.ends_with(
+            "BEGIN:VEVENT\r\nCREATED:20261001T080000Z\r\nUID:6B1C9E6A-1F7A-4C8E-9C51-0E3F2D8A7B11\r\nDTSTAMP:20261015T000000Z\r\nLAST-MODIFIED:20261015T000000Z\r\nSEQUENCE:3\r\n\
+             DTSTART:20261016T110000Z\r\nDTEND:20261016T120000Z\r\nSUMMARY:Coffee with Ann\r\nLOCATION:Home\r\nBEGIN:VALARM\r\nACTION:DISPLAY\r\nDESCRIPTION:Reminder\r\nTRIGGER:-PT15M\r\n\
+             UID:ALARM-1\r\nEND:VALARM\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n"
+        ));
+        assert_eq!(
+            ics_events(&changed, 7_200),
+            [Event { start, end: start + 3_600, all_day: false, summary: String::from("Coffee with Ann"), location: String::from("Home") }]
+        );
+
+        // the same location keeps apple's structured one; no times given keeps them; an empty location drops it
+        let renamed = ics_change(stored, stamp, &Change { summary: String::from("Coffee"), location: String::from("Café Einstein\nUnter den Linden 42"), when: None }).unwrap_or_default();
+
+        assert!(renamed.contains("X-APPLE-STRUCTURED-LOCATION") && renamed.contains("DTSTART;TZID=Europe/Berlin:20261016T110000\r\n"));
+
+        let cleared = ics_change(stored, stamp, &Change { summary: String::from("Coffee"), location: String::new(), when: None }).unwrap_or_default();
+
+        assert!(!cleared.contains("LOCATION"));
+
+        // a series with a moved instance: both renamed, neither's days touched, each SEQUENCE up by one
+        let series = "BEGIN:VCALENDAR\nVERSION:2.0\nPRODID:-//Apple Inc.//iOS 18.0//EN\n\
+                      BEGIN:VEVENT\nUID:series-1\nDTSTART;TZID=Europe/Berlin:20261005T090000\nDTEND;TZID=Europe/Berlin:20261005T093000\nRRULE:FREQ=WEEKLY;BYDAY=MO\nEXDATE;TZID=Europe/Berlin:20261012T090000\nSUMMARY:Stand-up\nDTSTAMP:20261001T080000Z\nEND:VEVENT\n\
+                      BEGIN:VEVENT\nUID:series-1\nRECURRENCE-ID;TZID=Europe/Berlin:20261019T090000\nDTSTART;TZID=Europe/Berlin:20261019T100000\nDTEND;TZID=Europe/Berlin:20261019T103000\nSUMMARY:Stand-up\nSEQUENCE:1\nDTSTAMP:20261001T080000Z\nEND:VEVENT\n\
+                      END:VCALENDAR\n";
+
+        let renamed = ics_change(series, stamp, &Change { summary: String::from("Daily, sync"), location: String::new(), when: None }).unwrap_or_default();
+        let read = ics_occurrences(&renamed, 7_200);
+
+        assert_eq!(read.iter().map(|occurrence| (occurrence.event.summary.as_str(), occurrence.recurring)).collect::<Vec<_>>(), [("Daily, sync", true), ("Daily, sync", true)]);
+        assert_eq!(read.iter().map(|occurrence| occurrence.event.start).collect::<Vec<_>>(), ics_occurrences(series, 7_200).iter().map(|occurrence| occurrence.event.start).collect::<Vec<_>>());
+        assert!(renamed.contains("RRULE:FREQ=WEEKLY;BYDAY=MO\r\n") && renamed.contains("EXDATE;TZID=Europe/Berlin:20261012T090000\r\n"));
+        assert_eq!(renamed.matches("SEQUENCE:1\r\n").count() + renamed.matches("SEQUENCE:2\r\n").count(), 2);
+
+        // times given to a series go to its first VEVENT only, never to a moved instance
+        let moved = ics_change(series, stamp, &Change { summary: String::from("x"), location: String::new(), when: Some(When::AllDay { first: days_from_civil(2026, 10, 6), days: 1 }) }).unwrap_or_default();
+
+        assert_eq!(moved.matches("DTSTART;VALUE=DATE:20261006").count(), 1);
+        assert!(moved.contains("DTSTART;TZID=Europe/Berlin:20261019T100000"));
+
+        assert_eq!(ics_change("BEGIN:VCALENDAR\r\nEND:VCALENDAR\r\n", stamp, &change), None);
+    }
+
+    #[test]
+    fn reads_birthdays_from_vcards() {
+        // icloud's vcard 3.0 with a folded name, apple's year-less date, vcard 4.0 forms, fallbacks
+        let cards = "BEGIN:VCARD\r\nVERSION:3.0\r\nPRODID:-//Apple Inc.//iOS 18.0//EN\r\nN:Müller;Anna;;;\r\nFN:Anna Mül\r\n ler\r\nBDAY;VALUE=date:1990-03-15\r\nEND:VCARD\r\n\
+                     BEGIN:VCARD\r\nVERSION:3.0\r\nN:Smith;John;;;\r\nFN:Smith\\, John\r\nBDAY;X-APPLE-OMIT-YEAR=1604:1604-07-02\r\nEND:VCARD\r\n\
+                     BEGIN:VCARD\nVERSION:4.0\nFN:Lena\nBDAY:--0704\nEND:VCARD\n\
+                     BEGIN:VCARD\nVERSION:4.0\nFN:Max\nBDAY:--07-05\nEND:VCARD\n\
+                     BEGIN:VCARD\nVERSION:3.0\nN:Doe;Jane;;;\nBDAY:19851224\nEND:VCARD\n\
+                     BEGIN:VCARD\nVERSION:3.0\nORG:ACME GmbH;Sales\nBDAY:2001-10-16T00:00:00Z\nEND:VCARD\n\
+                     BEGIN:VCARD\nVERSION:3.0\nFN:No Birthday\nTEL:+49 89 1234\nEND:VCARD\n\
+                     BEGIN:VCARD\nVERSION:3.0\nFN:Broken\nBDAY:1990-13-40\nEND:VCARD\n\
+                     BEGIN:VCARD\nVERSION:3.0\nFN:Leap\nbday;value=date:2000-02-29\nEND:VCARD\n";
+
+        let birthday = |name: &str, month, day, year| Birthday { name: String::from(name), month, day, year };
+
+        assert_eq!(
+            vcard_birthdays(cards),
+            [
+                birthday("Anna Müller", 3, 15, Some(1990)),
+                birthday("Smith, John", 7, 2, None),
+                birthday("Lena", 7, 4, None),
+                birthday("Max", 7, 5, None),
+                birthday("Jane Doe", 12, 24, Some(1985)),
+                birthday("ACME GmbH", 10, 16, Some(2001)),
+                birthday("Leap", 2, 29, Some(2000)),
+            ]
+        );
+        assert!(vcard_birthdays("").is_empty());
+    }
+
+    #[test]
+    fn computes_german_holidays() {
+        let date = |year, month, day| days_from_civil(year, month, day);
+
+        // known easter sundays, the earliest and latest possible among them
+        for (year, month, day) in [(2024, 3, 31), (2025, 4, 20), (2026, 4, 5), (2027, 3, 28), (2000, 4, 23), (2008, 3, 23), (2011, 4, 24), (1818, 3, 22), (2038, 4, 25), (2285, 3, 22)] {
+            assert_eq!(easter(year), date(year, month, day), "easter {year}");
+        }
+
+        let bavaria = holidays(2026, "BY");
+        let named = |name: &str| bavaria.iter().find(|(_, holiday)| *holiday == name).map(|(day, _)| *day);
+
+        assert_eq!(bavaria.len(), 13);
+        assert_eq!(named("Karfreitag"), Some(date(2026, 4, 3)));
+        assert_eq!(named("Ostermontag"), Some(date(2026, 4, 6)));
+        assert_eq!(named("Christi Himmelfahrt"), Some(date(2026, 5, 14)));
+        assert_eq!(named("Pfingstmontag"), Some(date(2026, 5, 25)));
+        assert_eq!(named("Fronleichnam"), Some(date(2026, 6, 4)));
+        assert_eq!(named("Heilige Drei Könige"), Some(date(2026, 1, 6)));
+        assert_eq!(named("Mariä Himmelfahrt"), Some(date(2026, 8, 15)));
+        assert_eq!(named("Allerheiligen"), Some(date(2026, 11, 1)));
+        assert_eq!(named("Reformationstag"), None);
+        assert!(bavaria.windows(2).all(|pair| pair[0].0 < pair[1].0));
+
+        // berlin in 2025: women's day and the one-off day of liberation
+        let berlin: Vec<&str> = holidays(2025, "be").iter().map(|(_, name)| *name).collect();
+
+        assert_eq!(
+            berlin,
+            ["Neujahr", "Internationaler Frauentag", "Karfreitag", "Ostermontag", "Tag der Arbeit", "Tag der Befreiung", "Christi Himmelfahrt", "Pfingstmontag", "Tag der Deutschen Einheit", "1. Weihnachtstag", "2. Weihnachtstag"]
+        );
+
+        // saxony's day of repentance is the wednesday before 23 november, 22 november itself in 2023
+        let repentance = |year| holidays(year, "SN").into_iter().find(|(_, name)| *name == "Buß- und Bettag").map(|(day, _)| day);
+
+        assert_eq!([2023, 2024, 2025, 2026].map(repentance), [Some(date(2023, 11, 22)), Some(date(2024, 11, 20)), Some(date(2025, 11, 19)), Some(date(2026, 11, 18))]);
+        assert_eq!(holidays(2026, "SN").iter().filter(|(_, name)| *name == "Reformationstag").count(), 1);
+
+        // brandenburg and hesse keep easter and whit sunday; thuringia children's day; the north the reformation since 2018
+        assert!(holidays(2026, "BB").contains(&(date(2026, 4, 5), "Ostersonntag")) && holidays(2026, "HE").contains(&(date(2026, 5, 24), "Pfingstsonntag")));
+        assert!(holidays(2026, "TH").contains(&(date(2026, 9, 20), "Weltkindertag")) && !holidays(2018, "TH").iter().any(|(_, name)| *name == "Weltkindertag"));
+        assert!(holidays(2018, "HH").contains(&(date(2018, 10, 31), "Reformationstag")) && !holidays(2016, "HH").iter().any(|(_, name)| *name == "Reformationstag"));
+        assert!(holidays(2017, "BY").contains(&(date(2017, 10, 31), "Reformationstag")));
+
+        // none without a state, the nationwide nine for an unknown code
+        assert!(holidays(2026, "").is_empty());
+        assert_eq!(holidays(2026, "XX").len(), 9);
+    }
 }

src/pods.rs

@@ -61,7 +61,7 @@ impl Pod {
 
     // whether its card takes typing: then it has the keyboard and stays open when the pointer leaves
     fn types(self) -> bool {
-        self == Self::Ai || (self == Self::Home && home::signing_in())
+        self == Self::Ai || (self == Self::Home && home::typing())
     }
 
     fn word(self) -> &'static str {
@@ -225,9 +225,15 @@ fn side(monitor: &Monitor, left: bool) -> LayerWindow {
 
     let (card_w, card_h) = card.map_or((0.0, 0.0), |(pod, _)| pod.size());
 
-    // room for the pills to move away from the open island, or for the card
+    /*
+     * room for the pills to move away from the open island, or for this side's widest
+     * card. the width never follows the open card: a narrower window would move with
+     * its margin, and Hyprland applies size and position on different frames, so the
+     * pills jumped when a card closed
+     */
     let room = (island_card::width() - island_pill::width()) / 2.0;
-    let inner_w = (group_w + room).max(card_w);
+    let widest = pods.iter().map(|pod| pod.size().0).fold(0.0, f32::max);
+    let inner_w = (group_w + room).max(widest);
     let window_h = top + h.max(card_h) + shadow;
 
     // the group's edge nearest the island, in the window, and where the window starts on the monitor
@@ -261,19 +267,35 @@ fn side(monitor: &Monitor, left: bool) -> LayerWindow {
 
     let (grow, pill_shown, reveal) = card.map_or((0.0, 1.0, 0.0), |(_, t)| phases(t));
 
+    /*
+     * the pills beside an open card are gone; a closing card shrinks back into its own
+     * pill's place, and they come back behind it only over the last `reveal_at` of its
+     * shrinking, so they don't pop up around a big card
+     */
+    let reveal_at = layout::reveal_at();
+    let others = if grow <= 0.0 {
+        1.0
+    } else if reveal_at <= 0.0 {
+        0.0
+    } else {
+        let k = (1.0 - grow / reveal_at).clamp(0.0, 1.0);
+
+        k * k * (3.0 - 2.0 * k)
+    };
+
     let mut layers: Vec<Box<dyn Widget>> = Vec::new();
     let mut regions: Vec<InputArea> = Vec::new();
 
     for pod in pods {
-        // the open one becomes the card; the others fade while it grows over them
-        if card.is_some_and(|(open, _)| open == pod) || grow >= 1.0 {
+        // the open one is the card, drawn last, over the others
+        if card.is_some_and(|(open, _)| open == pod) || others <= 0.0 {
             continue;
         }
 
         let x = pill_x(pod);
         let lit = state.hover.get(&pod).map_or(0.0, Animation::value);
         let pill = pill(pod, lit, &colors, here);
-        let pill = if grow > 0.0 { pill.opacity(1.0 - grow) } else { pill };
+        let pill = if others < 1.0 { pill.opacity(others) } else { pill };
 
         regions.push(InputArea { x: x as i32, y: (top + slide) as i32, width: h.ceil() as i32, height: h.ceil() as i32 });
         layers.push(Box::new(pill.translate(x, top + slide)));
@@ -312,7 +334,8 @@ fn side(monitor: &Monitor, left: bool) -> LayerWindow {
 
     let window = if typing {
         window.keyboard(Keyboard::OnDemand).on_key(|key| {
-            if key == Key::Escape {
+            // Esc closes the home card's event form first, then the card
+            if key == Key::Escape && !home::escape() {
                 close();
             }
         })

src/ring.wgsl

@@ -0,0 +1,90 @@
+// the ring of candles around the cd, one candle per angle step, each a line from the
+// cover's edge outward as far as its level reaches, with a glow under the loud ones and
+// a flame at the tip of the loudest. island.rs fills the values:
+//   0: centre, inner radius, candles, levels given
+//   1: reach at full level, glow width, body width, flame width
+//   2: glow colour, 3: body colour, 4: flame colour (plain, 0 to 1)
+//   5-15: levels for half the ring (the other half mirrors it), already eased, 0 to 1
+const TAU: f32 = 6.28318530718;
+
+fn level(step: u32, half: u32) -> f32 {
+    let count = u32(values[0].w);
+
+    if count == 0u {
+        return 0.0;
+    }
+
+    let index = min(step * count / max(half, 1u), count - 1u);
+
+    return values[5u + index / 4u][index % 4u];
+}
+
+// distance from p to the line from `start` to `end` along `direction`, out from the centre
+fn line(p: vec2<f32>, direction: vec2<f32>, start: f32, end: f32) -> f32 {
+    let along = dot(p, direction);
+    let across = dot(p, vec2<f32>(-direction.y, direction.x));
+
+    return length(vec2<f32>(across, along - clamp(along, start, end)));
+}
+
+// how much of a pixel a round-capped stroke `width` wide covers, at distance d from its line
+fn stroke(d: f32, width: f32, pixel: f32) -> f32 {
+    return clamp((width / 2.0 - d) / pixel + 0.5, 0.0, 1.0);
+}
+
+fn over(top: vec4<f32>, under: vec4<f32>) -> vec4<f32> {
+    return top + under * (1.0 - top.a);
+}
+
+@fragment
+fn main(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+    let ring = values[0];
+    let widths = values[1];
+    let candles = u32(ring.z);
+    let half = candles / 2u;
+    let inner = ring.y;
+
+    let p = uv * size - vec2<f32>(ring.x);
+    let pixel = max(fwidth(p.x), 1e-4);
+
+    // the nearest candle by angle, 0 at the top going clockwise, and its neighbours
+    let angle = atan2(p.x, -p.y);
+    let nearest = i32(round(select(angle, angle + TAU, angle < 0.0) / TAU * f32(candles)));
+
+    var glow = 0.0;
+    var body = 0.0;
+    var flame = 0.0;
+
+    for (var offset = -1; offset <= 1; offset++) {
+        let index = u32((nearest + offset + i32(candles)) % i32(candles));
+        let step = select(candles - 1u - index, index, index < half);
+        let loud = level(step, half);
+
+        let a = f32(index) / f32(candles) * TAU;
+        let direction = vec2<f32>(sin(a), -cos(a));
+        let reach = inner + 3.0 + loud * widths.x;
+
+        let d = line(p, direction, inner, reach);
+
+        body = max(body, stroke(d, widths.z, pixel));
+
+        if loud > 0.25 {
+            glow = max(glow, stroke(d, widths.y, pixel));
+        }
+
+        if loud > 0.45 {
+            flame = max(flame, stroke(line(p, direction, reach - 0.5, reach), widths.w, pixel));
+        }
+    }
+
+    var color = vec4<f32>(values[2].rgb * values[2].a, values[2].a) * glow;
+
+    color = over(vec4<f32>(values[3].rgb * values[3].a, values[3].a) * body, color);
+    color = over(vec4<f32>(values[4].rgb * values[4].a, values[4].a) * flame, color);
+
+    if color.a <= 0.0 {
+        return vec4<f32>(0.0);
+    }
+
+    return vec4<f32>(color.rgb / color.a, color.a);
+}

src/settings.rs

@@ -37,17 +37,21 @@ pub struct Ui {
     query: String,
     message: Option<(String, bool)>,
     hover: Option<String>,
+    // just opened, or a key went to the search: it takes the keys on the next frame
+    focus_search: bool,
 }
 
 impl Service for Ui {
     fn new() -> Self {
-        Self { page: String::from("appearance"), query: String::new(), message: None, hover: None }
+        Self { page: String::from("appearance"), query: String::new(), message: None, hover: None, focus_search: false }
     }
 
     fn listen() {}
 }
 
 pub fn open() {
+    Ui::write().focus_search = true;
+
     open_window(NAME, view);
 
     hypr::load();
@@ -158,6 +162,16 @@ fn say(result: Result<(), String>, done: String) {
 pub fn view() -> Window {
     theme::begin();
 
+    /*
+     * only on this frame: a TextInput that's .focused() takes the keys every frame it's
+     * drawn, so always focused, the search would take them back from a value being typed
+     */
+    let focus_search = Ui::read().focus_search;
+
+    if focus_search {
+        Ui::write().focus_search = false;
+    }
+
     let colors = theme::now();
     let ui = Ui::read();
     let hypr = Hypr::read();
@@ -283,22 +297,43 @@ pub fn view() -> Window {
         .title(TITLE)
         .size(1100.0, 760.0)
         .resizable(true)
-        // Escape closes it, also from a field (a typed value only applies on Enter)
-        .on_key(|key| {
-            if key == Key::Escape {
-                close_window(NAME);
-            }
+        /*
+         * Escape closes it, also from a field (a typed value only applies on Enter). keys no
+         * field takes, like right after opening, are typed into the search, which then takes
+         * the keys itself: amane drops a field's focus whenever one of the shell's windows
+         * loses the keyboard, as one does when this window opens
+         */
+        .on_key(|key| match key {
+            Key::Escape => close_window(NAME),
+            Key::Character(letter) => search_key(Some(letter)),
+            Key::Space => search_key(Some(' ')),
+            Key::Backspace => search_key(None),
+            _ => {}
         })
         .child(
             Rectangle::new()
                 .width(width)
                 .height(height)
                 .fill(colors.surface_low)
-                .child(Row::new(children![sidebar(&ui, &hypr, height, &colors), main])),
+                .child(Row::new(children![sidebar(&ui, &hypr, height, &colors, focus_search), main])),
         )
 }
 
-fn sidebar(ui: &Ui, hypr: &Hypr, height: f32, colors: &Colors) -> Rectangle {
+// a key typed with no field focused: into the search (none: Backspace), which takes the next keys
+fn search_key(letter: Option<char>) {
+    let mut ui = Ui::write();
+
+    match letter {
+        Some(letter) => ui.query.push(letter),
+        None => {
+            ui.query.pop();
+        }
+    }
+
+    ui.focus_search = true;
+}
+
+fn sidebar(ui: &Ui, hypr: &Hypr, height: f32, colors: &Colors, focus_search: bool) -> Rectangle {
     let mut entries: Vec<Box<dyn Widget>> = vec![Box::new(caption("SHELL", colors))];
 
     for module in config::modules() {
@@ -333,11 +368,15 @@ fn sidebar(ui: &Ui, hypr: &Hypr, height: f32, colors: &Colors) -> Rectangle {
         .padding(Padding { top: 0.0, right: 10.0, bottom: 0.0, left: 10.0 })
         .align_child(Start, Center)
         .cursor(Cursor::Text)
-        .child(TextInput::new(SEARCH).placeholder("Search all settings").size(config::appearance::text::body()).color(colors.text).on_change(|text| {
+        .child({
+            let input = TextInput::new(SEARCH).placeholder("Search all settings").size(config::appearance::text::body()).color(colors.text).on_change(|text| {
                 SYNCED.with_borrow_mut(|synced| synced.insert(SEARCH, text.clone()));
 
                 Ui::write().query = text;
-        }));
+            });
+
+            if focus_search { input.focused() } else { input }
+        });
 
     Rectangle::new()
         .width(SIDEBAR_W)

src/stats.rs

@@ -4,21 +4,23 @@ use std::process::Command;
 use std::thread;
 use std::time::{Duration, Instant};
 
-use amane::{Canvas, Color, Column, Path, Rectangle, Row, Service, Shape, SpaceBetween, Stack, Text, Weight, Widget};
+use amane::{Blend, Canvas, Center, Color, Column, Full, Path, Rectangle, Row, Service, Shape, SpaceBetween, Stack, Start, Text, Weight, Widget};
 
-use crate::config::appearance::text;
+use crate::config::appearance::{overlays, text};
 use crate::config::pills::{layout, monitor as settings};
-use crate::glyph::Glyph;
+use crate::glyph::{Glyph, glyph_shapes};
 use crate::island::faded;
 use crate::parse;
 use crate::system::Gpu;
 use crate::{pods, theme};
 
 /*
- * the system monitor card: cpu, gpu, memory, network, disk reads and writes as graphs
- * over the last readings, and the hottest temperature sensors. everything comes from
- * /proc and /sys on this Service's thread; no process list here, its button opens
- * btm's in a terminal on a special workspace instead
+ * the system monitor card: cpu, the integrated gpu, the external gpu, memory, swap,
+ * network, disk reads and writes as graphs over the last readings; the external gpu's
+ * memory and the programs on it; the hottest temperature sensors in their colours.
+ * everything comes from /proc and /sys on this Service's thread (the external gpu from
+ * system::Gpu, which reads only while this card is open); no process list here, its
+ * button opens btm's in a terminal on a special workspace instead
  */
 #[derive(Default)]
 pub struct Stats {
@@ -27,15 +29,19 @@ pub struct Stats {
     // the integrated gpu's clock as a share of its highest, and in words
     gpu: Vec<f32>,
     gpu_words: String,
+    // the external gpu's busy share
+    egpu: Vec<f32>,
     ram: Vec<f32>,
     ram_words: String,
+    swap: Vec<f32>,
+    swap_words: String,
     // bytes a second
     down: Vec<f32>,
     up: Vec<f32>,
     read: Vec<f32>,
     write: Vec<f32>,
-    // (sensor, °C), hottest first
-    temps: Vec<(String, f32)>,
+    // (sensor, its icon, °C), hottest first
+    temps: Vec<(String, Glyph, f32)>,
 }
 
 struct Sample {
@@ -63,7 +69,9 @@ impl Service for Stats {
             let busy = now.cpu.0.saturating_sub(before.cpu.0) as f32 / now.cpu.1.saturating_sub(before.cpu.1).max(1) as f32;
             let memory = parse::memory(&read("/proc/meminfo")).unwrap_or_default();
             let used = memory.total_kb.saturating_sub(memory.available_kb);
+            let swapped = memory.swap_total_kb.saturating_sub(memory.swap_free_kb);
             let (clock, clock_words) = gpu_clock();
+            let egpu = Gpu::read().busy as f32 / 100.0;
             let temps = temperatures();
 
             {
@@ -72,14 +80,17 @@ impl Service for Stats {
 
                 push(&mut stats.cpu, busy, keep);
                 push(&mut stats.gpu, clock, keep);
+                push(&mut stats.egpu, egpu, keep);
                 push(&mut stats.ram, used as f32 / memory.total_kb.max(1) as f32, keep);
+                push(&mut stats.swap, swapped as f32 / memory.swap_total_kb.max(1) as f32, keep);
                 push(&mut stats.down, rate(now.net.0, before.net.0), keep);
                 push(&mut stats.up, rate(now.net.1, before.net.1), keep);
                 push(&mut stats.read, rate(now.disk.0, before.disk.0) * 512.0, keep);
                 push(&mut stats.write, rate(now.disk.1, before.disk.1) * 512.0, keep);
 
                 stats.gpu_words = clock_words;
-                stats.ram_words = format!("{:.1} of {:.1} GB", used as f32 / 1048576.0, memory.total_kb as f32 / 1048576.0);
+                stats.ram_words = format!("{} of {}", gigabytes(used), gigabytes(memory.total_kb));
+                stats.swap_words = if memory.swap_total_kb == 0 { String::from("no swap") } else { format!("{} of {}", gigabytes(swapped), gigabytes(memory.swap_total_kb)) };
                 stats.temps = temps;
             }
 
@@ -88,6 +99,10 @@ impl Service for Stats {
     }
 }
 
+fn gigabytes(kb: u64) -> String {
+    format!("{:.1} GB", kb as f32 / 1048576.0)
+}
+
 fn push(history: &mut Vec<f32>, value: f32, keep: usize) {
     history.push(value);
 
@@ -141,12 +156,19 @@ fn gpu_clock() -> (f32, String) {
     (0.0, String::from("no clock to read"))
 }
 
-// every hwmon device's hottest sensor, named for what it is, hottest first
-fn temperatures() -> Vec<(String, f32)> {
-    let mut found: Vec<(String, f32)> = Vec::new();
+// what the temperatures are shown in, always: a sensor keeps its place whatever its reading
+const ORDER: [&str; 8] = ["CPU", "iGPU", "eGPU", "NVMe", "Memory", "Board", "ThinkPad", "Wi-Fi"];
 
-    for entry in fs::read_dir("/sys/class/hwmon").into_iter().flatten().flatten() {
-        let device = entry.path();
+// every hwmon device's hottest sensor, named for what it is, in ORDER (then by name, then by device)
+fn temperatures() -> Vec<(String, Glyph, f32)> {
+    let mut found: Vec<(String, Glyph, f32)> = Vec::new();
+
+    // the devices in their numbers' order (hwmon2 before hwmon10), so two of a kind keep theirs too
+    let mut devices: Vec<PathBuf> = fs::read_dir("/sys/class/hwmon").into_iter().flatten().flatten().map(|entry| entry.path()).collect();
+
+    devices.sort_by_key(|path| path.file_name().and_then(|name| name.to_str()).and_then(|name| name.trim_start_matches("hwmon").parse::<u32>().ok()).unwrap_or(u32::MAX));
+
+    for device in devices {
         let kind = read(device.join("name")).trim().to_string();
 
         let hottest = fs::read_dir(&device)
@@ -161,28 +183,29 @@ fn temperatures() -> Vec<(String, f32)> {
 
         let Some(celsius) = hottest else { continue };
 
-        let name = match kind.as_str() {
-            "coretemp" | "k10temp" | "zenpower" => "CPU",
-            "nvme" => "NVMe",
-            "amdgpu" | "nouveau" => "eGPU",
-            "xe" | "i915" => "GPU",
-            "acpitz" => "Board",
-            "thinkpad" => "ThinkPad",
-            "spd5118" | "jc42" => "Memory",
-            other if other.starts_with("iwlwifi") => "Wi-Fi",
-            other => other,
+        let (name, glyph) = match kind.as_str() {
+            "coretemp" | "k10temp" | "zenpower" => ("CPU", Glyph::Chip),
+            "nvme" => ("NVMe", Glyph::Drive),
+            "amdgpu" | "nouveau" => ("eGPU", Glyph::Gpu),
+            "xe" | "i915" => ("iGPU", Glyph::Gpu),
+            "acpitz" => ("Board", Glyph::Thermometer),
+            "thinkpad" => ("ThinkPad", Glyph::Laptop),
+            "spd5118" | "jc42" => ("Memory", Glyph::Memory),
+            other if other.starts_with("iwlwifi") => ("Wi-Fi", Glyph::Thermometer),
+            other => (other, Glyph::Thermometer),
         };
 
-        found.push((name.to_string(), celsius));
+        found.push((name.to_string(), glyph, celsius));
     }
 
-    found.sort_by(|a, b| b.1.total_cmp(&a.1));
+    // a stable sort: same kinds keep the devices' order
+    found.sort_by_key(|(name, ..)| (ORDER.iter().position(|kind| kind == name).unwrap_or(ORDER.len()), name.clone()));
     found.truncate(settings::temperatures());
 
     // a kind shown more than once is numbered, in the order shown
-    let names: Vec<String> = found.iter().map(|(name, _)| name.clone()).collect();
+    let names: Vec<String> = found.iter().map(|(name, ..)| name.clone()).collect();
 
-    for (index, (name, _)) in found.iter_mut().enumerate() {
+    for (index, (name, ..)) in found.iter_mut().enumerate() {
         if names.iter().filter(|other| *other == name).count() > 1 {
             let number = names[..index].iter().filter(|other| *other == name).count() + 1;
 
@@ -193,6 +216,19 @@ fn temperatures() -> Vec<(String, f32)> {
     found
 }
 
+// a temperature's colour: cool below `warm`, then warm turning hot up to `hot`
+fn temperature_color(celsius: f32) -> Color {
+    let (warm, hot) = (settings::warm(), settings::hot());
+
+    if celsius < warm {
+        settings::cool_color()
+    } else if celsius >= hot {
+        settings::hot_color()
+    } else {
+        Color::blend(settings::warm_color(), settings::hot_color(), (celsius - warm) / (hot - warm).max(0.1))
+    }
+}
+
 /*
  * opens btm's process list in a terminal on a special workspace, or shows and hides that
  * workspace when it runs already. the window is told apart by its class
@@ -222,19 +258,39 @@ fn label_height() -> f32 {
 }
 
 fn temp_row_height() -> f32 {
-    text::small() + 8.0
+    text::small() + 16.0
 }
 
 fn temp_rows() -> usize {
     settings::temperatures().div_ceil(2)
 }
 
-// the card's height, from settings only, so the window's size doesn't follow the readings
-pub fn height() -> f32 {
-    let graphs = 5.0 * (label_height() + settings::graph_height()) + 4.0 * 10.0;
+fn program_row_height() -> f32 {
+    text::small() + 8.0
+}
 
-    // header, graphs, rule, the temperatures' label and rows, with the column's four gaps
-    2.0 * layout::pad() + pods::header_height() + graphs + 1.0 + label_height() + temp_rows() as f32 * temp_row_height() + 4.0 * 10.0
+// the external gpu's rows under its graph: its memory, then the programs on it (at least one line)
+fn egpu_rows(gpu: &Gpu) -> usize {
+    1 + gpu.programs.len().clamp(1, settings::programs())
+}
+
+fn graph_count(gpu: &Gpu) -> usize {
+    if gpu.name.is_empty() { 6 } else { 7 }
+}
+
+/*
+ * the card's height, from settings and from whether there is an external gpu and how
+ * many programs use it, so the window's size doesn't follow the readings
+ */
+pub fn height() -> f32 {
+    let gpu = Gpu::read();
+    let count = graph_count(&gpu) as f32;
+    let graphs = count * (label_height() + settings::graph_height()) + (count - 1.0) * 10.0;
+
+    // header, graphs, the external gpu's rows, rule, the temperatures' label and rows, with the column's gaps
+    let (egpu, parts) = if gpu.name.is_empty() { (0.0, 5.0) } else { (egpu_rows(&gpu) as f32 * program_row_height(), 6.0) };
+
+    2.0 * layout::pad() + pods::header_height() + graphs + egpu + 1.0 + label_height() + temp_rows() as f32 * temp_row_height() + (parts - 1.0) * 10.0
 }
 
 // bytes a second in words
@@ -247,6 +303,15 @@ fn rate(bytes: f32) -> String {
     }
 }
 
+// video memory in KiB, the way a person reads it
+fn size(kib: u64) -> String {
+    match kib {
+        0..1024 => String::from("<1 MB"),
+        1024..1_048_576 => format!("{} MB", kib / 1024),
+        _ => format!("{:.1} GB", kib as f64 / 1_048_576.0),
+    }
+}
+
 // one graph's readings, the value at its top, its colour
 type Series<'a> = (&'a [f32], f32, Color);
 
@@ -287,6 +352,119 @@ fn graph(history: &[f32], top: f32, origin: (f32, f32), size: (f32, f32), color:
     vec![Box::new(area.line_to(last_x, y0 + height).close().fill(faded(color, 40))), Box::new(line.stroke(1.5, color))]
 }
 
+// a label on the left and its value on the right, one line
+fn line_of(name: impl Into<String>, value: impl Into<String>, width: f32, height: f32, name_color: Color) -> Rectangle {
+    let theme = theme::now();
+
+    Rectangle::new().width(width).height(height).align_child(Start, Center).child(
+        Row::new(vec![
+            Box::new(Text::new(name).size(text::small()).color(name_color).elide()) as Box<dyn Widget>,
+            Box::new(Text::new(value).size(text::small()).color(theme.dim)),
+        ])
+        .width(width)
+        .justify(SpaceBetween)
+        .align(Center),
+    )
+}
+
+// the external gpu's memory as a bar, and the programs on it, the most memory first
+fn egpu_detail(gpu: &Gpu, width: f32) -> Column {
+    let theme = theme::now();
+    let row_h = program_row_height();
+
+    let share = if gpu.vram_total > 0 { gpu.vram_used as f32 / gpu.vram_total as f32 } else { 0.0 };
+    let words = format!("{} of {}", size(gpu.vram_used / 1024), size(gpu.vram_total / 1024));
+    let bar_w = width * 0.32;
+
+    let memory = Row::new(vec![
+        Box::new(Text::new("Video memory").size(text::small()).color(theme.text)) as Box<dyn Widget>,
+        Box::new(
+            Row::new(vec![
+                Box::new(Rectangle::new().width(bar_w).height(6.0).radius(Full).fill(overlays::track()).child(Rectangle::new().width((bar_w * share).max(6.0)).height(6.0).radius(Full).fill(theme.accent)))
+                    as Box<dyn Widget>,
+                Box::new(Text::new(words).size(text::small()).color(theme.dim)),
+            ])
+            .gap(10.0)
+            .align(Center),
+        ),
+    ])
+    .width(width)
+    .height(row_h)
+    .justify(SpaceBetween)
+    .align(Center);
+
+    let mut rows: Vec<Box<dyn Widget>> = vec![Box::new(memory)];
+    let most = settings::programs();
+    let shown = if gpu.programs.len() > most { most - 1 } else { most };
+
+    for program in gpu.programs.iter().take(shown) {
+        let amount = match program.busy {
+            Some(busy) => format!("{} · {busy}%", size(program.vram_kib)),
+            None => size(program.vram_kib),
+        };
+
+        rows.push(Box::new(line_of(program.name.as_str(), amount, width, row_h, theme.text)));
+    }
+
+    if gpu.programs.len() > most {
+        rows.push(Box::new(line_of(format!("and {} more", gpu.programs.len() - shown), "", width, row_h, theme.dim)));
+    }
+
+    if gpu.programs.is_empty() {
+        rows.push(Box::new(line_of("No programs on it", "", width, row_h, theme.dim)));
+    }
+
+    Column::new(rows)
+}
+
+// the temperatures in two columns: icon, name, value in its colour, a bar up to `hot`
+fn temperature_grid(temps: &[(String, Glyph, f32)], width: f32) -> Stack {
+    let theme = theme::now();
+    let cell_w = width / 2.0 - 8.0;
+    let (row_h, line_h, icon) = (temp_row_height(), text::small() + 6.0, 14.0);
+    let bar_w = cell_w - icon - 8.0;
+
+    // every icon into one canvas behind the rows
+    let mut shapes: Vec<Box<dyn Shape>> = Vec::new();
+    let mut rows: Vec<Box<dyn Widget>> = Vec::new();
+
+    for (row, pair) in temps.chunks(2).enumerate() {
+        let mut cells: Vec<Box<dyn Widget>> = Vec::new();
+
+        for (column, (name, glyph, celsius)) in pair.iter().enumerate() {
+            let color = temperature_color(*celsius);
+            let share = (celsius / settings::hot().max(1.0)).clamp(0.0, 1.0);
+
+            shapes.extend(glyph_shapes(*glyph, icon, color, 0.0, (column as f32 * (cell_w + 16.0), row as f32 * row_h + (line_h - icon) / 2.0)));
+
+            cells.push(Box::new(
+                Rectangle::new().width(cell_w).height(row_h).padding(amane::Padding { top: 0.0, right: 0.0, bottom: 0.0, left: icon + 8.0 }).child(
+                    Column::new(vec![
+                        Box::new(
+                            Row::new(vec![
+                                Box::new(Text::new(name.as_str()).size(text::small()).color(theme.text)) as Box<dyn Widget>,
+                                Box::new(Text::new(format!("{celsius:.0} °C")).size(text::small()).weight(Weight::Bold).color(color)),
+                            ])
+                            .width(bar_w)
+                            .height(line_h)
+                            .justify(SpaceBetween)
+                            .align(Center),
+                        ) as Box<dyn Widget>,
+                        Box::new(Rectangle::new().width(bar_w).height(3.0).radius(Full).fill(overlays::track()).child(Rectangle::new().width((bar_w * share).max(3.0)).height(3.0).radius(Full).fill(color))),
+                    ])
+                    .gap(2.0),
+                ),
+            ));
+        }
+
+        rows.push(Box::new(Row::new(cells).gap(16.0)));
+    }
+
+    let height = temp_rows() as f32 * row_h;
+
+    Stack::new(vec![Box::new(Canvas::new().width(width).height(height).shapes(shapes)) as Box<dyn Widget>, Box::new(Column::new(rows))]).width(width).height(height)
+}
+
 pub fn card(width: f32, height: f32) -> Rectangle {
     let stats = Stats::read();
     let gpu = Gpu::read();
@@ -300,23 +478,33 @@ pub fn card(width: f32, height: f32) -> Rectangle {
     let net_top = peak(&stats.down, &stats.up);
     let disk_top = peak(&stats.read, &stats.write);
 
-    let egpu = if gpu.name.is_empty() {
-        String::new()
-    } else {
-        let celsius = gpu.celsius.map_or(String::new(), |celsius| format!(" · {celsius} °C"));
-
-        format!(" · {} {}%{celsius}", gpu.name, gpu.busy)
-    };
-
     // (name, value in words, graphs as (history, top, colour))
-    let blocks: Vec<(&str, String, Vec<Series>)> = vec![
-        ("CPU", format!("{:.0} %", last(&stats.cpu) * 100.0), vec![(&stats.cpu, 1.0, theme.accent)]),
-        ("GPU", format!("{}{egpu}", stats.gpu_words), vec![(&stats.gpu, 1.0, theme.accent)]),
-        ("Memory", stats.ram_words.clone(), vec![(&stats.ram, 1.0, theme.accent)]),
-        ("Network", format!("↓ {}  ↑ {}", rate(last(&stats.down)), rate(last(&stats.up))), vec![(&stats.down, net_top, theme.accent), (&stats.up, net_top, theme.flame)]),
-        ("Disk", format!("read {}  write {}", rate(last(&stats.read)), rate(last(&stats.write))), vec![(&stats.read, disk_top, theme.accent), (&stats.write, disk_top, theme.flame)]),
+    let mut blocks: Vec<(String, String, Vec<Series>)> = vec![
+        (String::from("CPU"), format!("{:.0} %", last(&stats.cpu) * 100.0), vec![(&stats.cpu, 1.0, theme.accent)]),
+        (String::from("iGPU"), stats.gpu_words.clone(), vec![(&stats.gpu, 1.0, theme.accent)]),
     ];
 
+    if !gpu.name.is_empty() {
+        let mut facts = vec![format!("{}%", gpu.busy)];
+
+        if let Some(celsius) = gpu.celsius {
+            facts.push(format!("{celsius} °C"));
+        }
+
+        if let Some(watts) = gpu.watts {
+            facts.push(format!("{watts:.0} W"));
+        }
+
+        blocks.push((gpu.name.clone(), facts.join(" · "), vec![(&stats.egpu, 1.0, theme.flame)]));
+    }
+
+    blocks.extend([
+        (String::from("Memory"), stats.ram_words.clone(), vec![(stats.ram.as_slice(), 1.0, theme.accent)]),
+        (String::from("Swap"), stats.swap_words.clone(), vec![(stats.swap.as_slice(), 1.0, theme.flame)]),
+        (String::from("Network"), format!("↓ {}  ↑ {}", rate(last(&stats.down)), rate(last(&stats.up))), vec![(stats.down.as_slice(), net_top, theme.accent), (stats.up.as_slice(), net_top, theme.flame)]),
+        (String::from("Disk"), format!("read {}  write {}", rate(last(&stats.read)), rate(last(&stats.write))), vec![(stats.read.as_slice(), disk_top, theme.accent), (stats.write.as_slice(), disk_top, theme.flame)]),
+    ]);
+
     let (label_h, graph_h) = (label_height(), settings::graph_height());
 
     // every graph into one canvas under the labels: each canvas costs the gpu on its own
@@ -342,41 +530,27 @@ pub fn card(width: f32, height: f32) -> Rectangle {
         ));
     }
 
-    let graphs_h = 5.0 * (label_h + graph_h) + 4.0 * 10.0;
+    let count = graph_count(&gpu) as f32;
+    let graphs_h = count * (label_h + graph_h) + (count - 1.0) * 10.0;
 
     let graphs = Stack::new(vec![Box::new(Canvas::new().width(width).height(graphs_h).shapes(shapes)) as Box<dyn Widget>, Box::new(Column::new(rows).gap(10.0))]).width(width).height(graphs_h);
 
-    // the temperatures in two columns
-    let mut temp_rows: Vec<Box<dyn Widget>> = Vec::new();
+    let mut parts: Vec<Box<dyn Widget>> = vec![Box::new(header), Box::new(graphs)];
 
-    for pair in stats.temps.chunks(2) {
-        let cell = |(name, celsius): &(String, f32)| -> Box<dyn Widget> {
-            let hot = if *celsius >= 85.0 { crate::config::appearance::overlays::low_battery() } else { theme.text };
-
-            Box::new(
-                Rectangle::new().width(width / 2.0 - 8.0).height(temp_row_height()).child(
-                    Row::new(vec![Box::new(Text::new(name.as_str()).size(text::small()).color(theme.dim)) as Box<dyn Widget>, Box::new(Text::new(format!("{celsius:.0} °C")).size(text::small()).color(hot))])
-                        .width(width / 2.0 - 8.0)
-                        .justify(SpaceBetween),
-                ),
-            )
-        };
-
-        temp_rows.push(Box::new(Row::new(pair.iter().map(cell).collect()).gap(16.0)));
+    if !gpu.name.is_empty() {
+        parts.push(Box::new(egpu_detail(&gpu, width)));
     }
 
+    parts.push(Box::new(pods::rule(width)));
+    parts.push(Box::new(Rectangle::new().width(width).height(label_h).child(Text::new("Temperatures").size(text::small()).weight(Weight::Bold).color(theme.text))));
+
     if stats.temps.is_empty() {
-        temp_rows.push(Box::new(Text::new(if stats.cpu.is_empty() { "Reading…" } else { "No temperature sensors" }).size(text::small()).color(theme.dim)));
+        let words = if stats.cpu.is_empty() { "Reading…" } else { "No temperature sensors" };
+
+        parts.push(Box::new(Rectangle::new().width(width).height(temp_rows() as f32 * temp_row_height()).child(Text::new(words).size(text::small()).color(theme.dim))));
+    } else {
+        parts.push(Box::new(temperature_grid(&stats.temps, width)));
     }
 
-    Rectangle::new().width(width).height(height).child(
-        Column::new(vec![
-            Box::new(header) as Box<dyn Widget>,
-            Box::new(graphs),
-            Box::new(pods::rule(width)),
-            Box::new(Rectangle::new().width(width).height(label_h).child(Text::new("Temperatures").size(text::small()).weight(Weight::Bold).color(theme.text))),
-            Box::new(Column::new(temp_rows)),
-        ])
-        .gap(10.0),
-    )
+    Rectangle::new().width(width).height(height).child(Column::new(parts).gap(10.0))
 }

src/surface.rs

@@ -1,7 +1,10 @@
-use amane::{Blend, Color, Gradient, Rectangle, Shadow, Stack, children};
+use std::path::PathBuf;
+use std::sync::LazyLock;
+
+use amane::{Blend, Color, Rectangle, Stack, children};
 
 use crate::config::appearance::{frosted, liquid, solid, surface};
-use crate::island::{backdrop, faded};
+use crate::island::faded;
 use crate::theme;
 
 /*
@@ -10,48 +13,74 @@ use crate::theme;
  * `content` (already width x height, with its own padding and alignment) in the surface.
  * `lift` (0 to 1) is how raised it is: hovered, or a popup over the rest.
  * see-through designs need Hyprland's blur behind the shell (README: Glass)
+ *
+ * every design is a shadow, a gradient fill and maybe a second gradient just inside the
+ * rim, which surface.wgsl draws in one pass. drawn as amane's shadow and gradients they
+ * took two vello passes over the whole window on every frame (vello keeps no gradient
+ * between frames), so a playing pill, whose bars redraw it 60 times a second, cost the
+ * igpu about 3 ms a frame; the shader costs a few hundred thousand pixels of arithmetic.
+ * the rim stays a border, which amane draws as a quad
  */
 pub fn shell(width: f32, height: f32, radius: f32, colors: &[Color; 3], lift: f32, content: Rectangle) -> Rectangle {
     let theme = theme::now();
-    let base = Rectangle::new().width(width).height(height).radius(radius);
 
-    match surface::design().as_str() {
+    let look = match surface::design().as_str() {
         // after Apple's materials: a thin tint, a hairline light rim (the accent when hovered),
         // a soft highlight along the top as if lit from above, one soft low shadow instead of a glow
         "frosted" => {
-            let sheen = inner(width, height, radius).fill(Gradient::linear(180.0, [(0.0, white(frosted::sheen())), (0.3, white(frosted::sheen() * 0.26)), (0.65, white(0.0))]));
+            let a = alpha(frosted::opacity());
+            let sheen = frosted::sheen();
 
-            base.fill(backdrop(colors, alpha(frosted::opacity())))
-                .border(1.0, Color::blend(white(frosted::rim()), faded(theme.accent, 150), lift))
-                .shadow(Shadow::drop(Color::BLACK).opacity(frosted::shadow() + 0.1 * lift).blur(24.0).offset(0.0, 6.0))
-                .child(Stack::new(children![sheen, content]).width(width).height(height))
+            Look {
+                shadow: (Color::BLACK, frosted::shadow() + 0.1 * lift, 24.0, (0.0, 6.0)),
+                fill: (150.0, vec![(0.0, faded(colors[0], a)), (0.55, faded(colors[1], a)), (1.0, faded(colors[2], a))]),
+                inner: (180.0, vec![(0.0, white(sheen)), (0.3, white(sheen * 0.26)), (0.65, white(0.0))]),
+                rim: (1.0, Color::blend(white(frosted::rim()), faded(theme.accent, 150), lift)),
+            }
         }
 
         // clear glass, denser toward the bottom right where the equalizer's labels sit; a bright
         // edge where light enters at the top left and leaves at the bottom right; the accent's glow
         "liquid" => {
             let glass = liquid::opacity();
-            let fill = Gradient::linear(150.0, [(0.0, faded(colors[0], alpha(glass * 0.55))), (0.55, faded(colors[1], alpha(glass))), (1.0, faded(colors[2], alpha(glass * 1.6)))]);
-
             let light = liquid::light();
-            let edge = inner(width, height, radius).fill(Gradient::linear(
-                135.0,
-                [(0.0, white(light)), (0.16, white(light * 0.23)), (0.4, white(0.0)), (0.82, white(0.0)), (1.0, white(light * 0.43))],
-            ));
 
-            base.fill(fill)
-                .border(liquid::rim_width(), Color::blend(white(liquid::rim()), faded(theme.flame, 200), lift))
-                .shadow(Shadow::drop(theme.accent).opacity(liquid::glow() + 0.3 * lift).blur(24.0))
-                .child(Stack::new(children![edge, content]).width(width).height(height))
+            Look {
+                shadow: (theme.accent, liquid::glow() + 0.3 * lift, 24.0, (0.0, 0.0)),
+                fill: (150.0, vec![(0.0, faded(colors[0], alpha(glass * 0.55))), (0.55, faded(colors[1], alpha(glass))), (1.0, faded(colors[2], alpha(glass * 1.6)))]),
+                inner: (135.0, vec![(0.0, white(light)), (0.16, white(light * 0.23)), (0.4, white(0.0)), (0.82, white(0.0)), (1.0, white(light * 0.43))]),
+                rim: (liquid::rim_width(), Color::blend(white(liquid::rim()), faded(theme.flame, 200), lift)),
+            }
         }
 
         // the original: the wallpaper's gradient, a 1 px rim, a soft glow in the accent
-        _ => base
-            .fill(backdrop(colors, alpha(solid::opacity())))
-            .border(1.0, Color::blend(theme.outline, faded(theme.accent, 110), lift))
-            .shadow(Shadow::drop(theme.accent).opacity(solid::glow() + (solid::hover_glow() - solid::glow()) * lift).blur(22.0))
-            .child(content),
+        _ => {
+            let a = alpha(solid::opacity());
+
+            Look {
+                shadow: (theme.accent, solid::glow() + (solid::hover_glow() - solid::glow()) * lift, 22.0, (0.0, 0.0)),
+                fill: (150.0, vec![(0.0, faded(colors[0], a)), (0.55, faded(colors[1], a)), (1.0, faded(colors[2], a))]),
+                inner: (0.0, Vec::new()),
+                rim: (1.0, Color::blend(theme.outline, faded(theme.accent, 110), lift)),
             }
+        }
+    };
+
+    // room for the shadow: vello draws a blurred rectangle 2.5 deviations (half the blur each) past its edge
+    let (_, _, blur, (dx, dy)) = look.shadow;
+    let margin = (1.25 * blur + dx.abs().max(dy.abs())).ceil();
+
+    let paint = Rectangle::new()
+        .width(width + 2.0 * margin)
+        .height(height + 2.0 * margin)
+        .translate(-margin, -margin)
+        .shader(SHADER.as_path())
+        .shader_values(look.values(width, height, radius, margin));
+
+    let (thickness, rim_color) = look.rim;
+    let rim = Rectangle::new().width(width).height(height).radius(radius).border(thickness, rim_color);
+
+    Rectangle::new().width(width).height(height).child(Stack::new(children![paint, rim, content]).width(width).height(height))
 }
 
 // whether the desktop shows through: then a veil can't hide a face, so faces fade with .opacity()
@@ -59,9 +88,80 @@ pub fn clear() -> bool {
     surface::design() != "solid" || solid::opacity() < 1.0
 }
 
-// a layer just inside the rim, so the rim stays crisp over it
-fn inner(width: f32, height: f32, radius: f32) -> Rectangle {
-    Rectangle::new().width(width - 2.0).height(height - 2.0).radius((radius - 1.0).max(0.0)).translate(1.0, 1.0)
+static SHADER: LazyLock<PathBuf> = LazyLock::new(|| shader_file("surface.wgsl", include_str!("surface.wgsl")));
+
+// a shader's source is part of the shell; amane wants a file, so it goes beside cava's config
+pub fn shader_file(name: &str, source: &str) -> PathBuf {
+    let path = crate::art::folder().join(name);
+
+    let _ = std::fs::write(&path, source);
+
+    path
+}
+
+// numbers as a shader's rows of four, the last one padded with 0
+pub fn rows(numbers: &[f32]) -> Vec<[f32; 4]> {
+    numbers.chunks(4).map(|chunk| std::array::from_fn(|index| chunk.get(index).copied().unwrap_or(0.0))).collect()
+}
+
+type Stops = Vec<(f32, Color)>;
+
+struct Look {
+    // colour, strength, blur, offset
+    shadow: (Color, f32, f32, (f32, f32)),
+    // angle and stops: up to 3 for the fill, 5 for the gradient inside the rim (none: no stops)
+    fill: (f32, Stops),
+    inner: (f32, Stops),
+    // width and colour
+    rim: (f32, Color),
+}
+
+impl Look {
+    // the rows surface.wgsl reads, see its top
+    fn values(&self, width: f32, height: f32, radius: f32, margin: f32) -> Vec<[f32; 4]> {
+        let (color, strength, blur, (dx, dy)) = self.shadow;
+        let mut shadow = plain(color);
+
+        shadow[3] *= strength.clamp(0.0, 1.0);
+
+        let mut rows = vec![
+            [width, height, radius, margin],
+            shadow,
+            [blur / 2.0, dx, dy, 1.0],
+            [self.fill.0, self.inner.0, self.fill.1.len().min(3) as f32, self.inner.1.len().min(5) as f32],
+        ];
+
+        let (colors, offsets) = stops::<3>(&self.fill.1);
+
+        rows.extend(colors);
+        rows.push([offsets[0], offsets[1], offsets[2], 0.0]);
+
+        let (colors, offsets) = stops::<5>(&self.inner.1);
+
+        rows.extend(colors);
+        rows.push([offsets[0], offsets[1], offsets[2], offsets[3]]);
+        rows.push([offsets[4], 0.0, 0.0, 0.0]);
+
+        rows
+    }
+}
+
+// N (at most 5) stops as colours and their offsets, missing ones clear
+fn stops<const N: usize>(stops: &[(f32, Color)]) -> ([[f32; 4]; N], [f32; 5]) {
+    let mut colors = [[0.0; 4]; N];
+    let mut offsets = [0.0; 5];
+
+    for (index, (offset, color)) in stops.iter().take(N).enumerate() {
+        colors[index] = plain(*color);
+        offsets[index] = *offset;
+    }
+
+    (colors, offsets)
+}
+
+// a colour as a shader reads it: plain, not premultiplied, 0 to 1
+pub fn plain(color: Color) -> [f32; 4] {
+    [color.red(), color.green(), color.blue(), color.alpha()].map(|part| f32::from(part) / 255.0)
 }
 
 // an opacity, 0 to 1, as a colour's alpha

src/surface.wgsl

@@ -0,0 +1,148 @@
+// a surface in one pass: its drop shadow, its gradient fill and a second gradient just
+// inside the rim (frosted's sheen, liquid's lit edge), shaped by the rounded outline
+// worked out here rather than by a path, so amane lays it straight onto the window
+// without a layer of its own. surface.rs fills the values:
+//   0: shape width, height, corner radius, margin (room around the shape for the shadow)
+//   1: shadow colour, its alpha already scaled by the shadow's strength
+//   2: shadow deviation, its x and y offset, the inset of the inner gradient
+//   3: fill angle, inner angle, fill stops (up to 3), inner stops (0 to 5)
+//   4-6: fill colours, 7: their offsets
+//   8-12: inner colours, 13: offsets of the first four, 14.x: the fifth's
+// colours are plain (not premultiplied), 0 to 1. the shadow follows vello's own
+// blurred rounded rectangle, the gradients amane's linear ones, so it looks the same
+
+// vello's error function approximation (raphlinus.github.io, blurred rounded rects)
+fn erf7(x: f32) -> f32 {
+    let y = clamp(x * 1.1283791671, -100.0, 100.0);
+    let yy = y * y;
+    let z = y + (0.24295 + (0.03395 + 0.0104 * yy) * yy) * (y * yy);
+
+    return z / sqrt(1.0 + z * z);
+}
+
+// vello's blurred rounded rectangle at p, from its centre
+fn shadow(p: vec2<f32>, w: f32, h: f32, radius: f32, deviation: f32) -> f32 {
+    let s = max(deviation, 1e-5);
+    let inv = 1.0 / s;
+    let min_edge = min(w, h);
+    let radius_max = 0.5 * min_edge;
+    let r0 = min(length(vec2<f32>(radius, s * 1.15)), radius_max);
+    let r1 = min(length(vec2<f32>(radius, s * 2.0)), radius_max);
+    let exponent = 2.0 * r1 / r0;
+
+    let delta = 1.25 * s * (exp(-pow(0.5 * inv * w, 2.0)) - exp(-pow(0.5 * inv * h, 2.0)));
+    let width = w + min(delta, 0.0);
+    let height = h - max(delta, 0.0);
+
+    let scale = 0.5 * erf7(inv * 0.5 * (max(width, height) - 0.5 * radius));
+
+    let y0 = abs(p.y) - (height * 0.5 - r1);
+    let x0 = abs(p.x) - (width * 0.5 - r1);
+    let d_pos = pow(pow(max(x0, 0.0), exponent) + pow(max(y0, 0.0), exponent), 1.0 / exponent);
+    let d = d_pos + min(max(x0, y0), 0.0) - r1;
+
+    return scale * (erf7(inv * (min_edge + d)) - erf7(inv * d));
+}
+
+// signed distance to a rounded rectangle centred on 0, negative inside
+fn rounded(p: vec2<f32>, half: vec2<f32>, radius: f32) -> f32 {
+    let r = min(radius, min(half.x, half.y));
+    let q = abs(p) - half + vec2<f32>(r);
+
+    return length(max(q, vec2<f32>(0.0))) + min(max(q.x, q.y), 0.0) - r;
+}
+
+// how much of a pixel `pixel` wide the shape covers at distance d
+fn cover(d: f32, pixel: f32) -> f32 {
+    return clamp(0.5 - d / pixel, 0.0, 1.0);
+}
+
+// where p falls along amane's linear gradient over a box at `origin`, 0 to 1:
+// a line through the centre, 0 degrees pointing up, long enough to reach the corners
+fn along(p: vec2<f32>, origin: vec2<f32>, extent: vec2<f32>, angle: f32) -> f32 {
+    let a = radians(angle);
+    let direction = vec2<f32>(sin(a), -cos(a));
+    let half_length = (extent.x * abs(direction.x) + extent.y * abs(direction.y)) / 2.0;
+
+    return clamp(0.5 + dot(p - origin - extent / 2.0, direction) / max(2.0 * half_length, 1e-5), 0.0, 1.0);
+}
+
+fn premultiplied(c: vec4<f32>) -> vec4<f32> {
+    return vec4<f32>(c.rgb * c.a, c.a);
+}
+
+// the fill's colour at t, premultiplied; stops past the last repeat it
+fn fill_color(t: f32) -> vec4<f32> {
+    let count = u32(values[3].z);
+    var color = premultiplied(values[4]);
+
+    for (var i = 1u; i < count; i++) {
+        let lo = values[7][i - 1u];
+        let hi = values[7][i];
+        let k = clamp((t - lo) / max(hi - lo, 1e-5), 0.0, 1.0);
+
+        color = select(color, mix(premultiplied(values[3u + i]), premultiplied(values[4u + i]), k), t > lo);
+    }
+
+    return color;
+}
+
+fn inner_offset(i: u32) -> f32 {
+    return select(values[13][min(i, 3u)], values[14].x, i == 4u);
+}
+
+fn inner_color(t: f32) -> vec4<f32> {
+    let count = u32(values[3].w);
+    var color = premultiplied(values[8]);
+
+    for (var i = 1u; i < count; i++) {
+        let lo = inner_offset(i - 1u);
+        let hi = inner_offset(i);
+        let k = clamp((t - lo) / max(hi - lo, 1e-5), 0.0, 1.0);
+
+        color = select(color, mix(premultiplied(values[7u + i]), premultiplied(values[8u + i]), k), t > lo);
+    }
+
+    return color;
+}
+
+@fragment
+fn main(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+    let shape = values[0];
+    let margin = shape.w;
+    let extent = shape.xy;
+
+    // this pixel, from the shape's top left corner
+    let p = uv * size - vec2<f32>(margin);
+    let pixel = max(fwidth(p.x), 1e-4);
+
+    let centre = extent / 2.0;
+
+    // the shadow, under everything
+    let offset = values[2].yz;
+    let shade = shadow(p - centre - offset, extent.x, extent.y, shape.z, values[2].x);
+    var color = premultiplied(vec4<f32>(values[1].rgb, values[1].a * shade));
+
+    // the fill over it
+    let inside = cover(rounded(p - centre, centre, shape.z), pixel);
+    let fill = fill_color(along(p, vec2<f32>(0.0), extent, values[3].x)) * inside;
+
+    color = fill + color * (1.0 - fill.a);
+
+    // the inner gradient, inset from the rim by values[2].w
+    if values[3].w > 0.0 {
+        let inset = values[2].w;
+        let inner = extent - vec2<f32>(2.0 * inset);
+        let within = cover(rounded(p - centre, inner / 2.0, max(shape.z - inset, 0.0)), pixel);
+        let light = inner_color(along(p, vec2<f32>(inset), inner, values[3].y)) * within;
+
+        color = light + color * (1.0 - light.a);
+    }
+
+    // amane blends a plain colour over the window
+    if color.a <= 0.0 {
+        return vec4<f32>(0.0);
+    }
+
+    return vec4<f32>(color.rgb / color.a, color.a);
+}

src/system.rs

@@ -14,7 +14,6 @@ use std::{fs, thread};
 
 use amane::{Argument, Bluetooth, Bus, Service, Value};
 
-use crate::control::Control;
 use crate::parse;
 use crate::config::control::{polling, services};
 
@@ -800,13 +799,13 @@ impl Service for Gpu {
         Self::default()
     }
 
-    // ponytail: scans every process's open files every 2 s, so only while the control centre is open
+    // ponytail: scans every process's open files every 2 s, so only while the system monitor's card is open
     fn listen() {
         let mut names: HashMap<String, String> = HashMap::new();
         let mut engines: HashMap<u32, (u64, Instant)> = HashMap::new();
 
         loop {
-            if !Control::read().expanded() {
+            if crate::pods::open_card() != Some(crate::pods::Pod::Monitor) {
                 thread::sleep(Duration::from_millis(polling::gpu_wait_ms()));
 
                 continue;

tools/perf.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+# perf.sh PID [SECONDS]: a process's cpu %, the cpu % of the commands it ran and waited for
+# (children), its gpu busy % per engine (drm fdinfo, xe and i915) and its resident memory
+# over SECONDS (default 10). cpu 100 % is one core
+pid=${1:?pid}; secs=${2:-10}
+
+sample() {
+    # utime + stime in clock ticks, then engine cycles summed over every drm fd as "engine used total"
+    awk '{print "cpu", $14 + $15, $16 + $17}' /proc/$pid/stat
+    cat /proc/$pid/fdinfo/* 2>/dev/null | awk '
+        /^drm-cycles-/ {e=substr($1, 12); sub(":", "", e); used[e]+=$2}
+        /^drm-total-cycles-/ {e=substr($1, 18); sub(":", "", e); total[e]=$2}
+        /^drm-engine-[a-z]+:/ && $3 == "ns" {e=substr($1, 12); sub(":", "", e); ns[e]+=$2}
+        END {for (e in used) print "cyc", e, used[e], total[e]; for (e in ns) print "ns", e, ns[e]}'
+}
+
+a=$(sample); start=$(date +%s%N); sleep "$secs"; b=$(sample); end=$(date +%s%N)
+
+printf '%s\n--\n%s\n' "$a" "$b" | awk -v tck="$(getconf CLK_TCK)" -v wall="$(( (end - start) / 1000 ))" '
+    $1 == "--" {second=1; next}
+    $1 == "cpu" {if (second) {cpu1=$2; kid1=$3} else {cpu0=$2; kid0=$3}}
+    $1 == "cyc" {if (second) {u1[$2]=$3; t1[$2]=$4} else {u0[$2]=$3; t0[$2]=$4}}
+    $1 == "ns" {if (second) n1[$2]=$3; else n0[$2]=$3}
+    END {
+        printf "cpu %.1f %%  children %.1f %%", (cpu1 - cpu0) / tck * 1e6 / wall * 100, (kid1 - kid0) / tck * 1e6 / wall * 100
+        for (e in u1) if (t1[e] > t0[e]) printf "  %s %.2f %%", e, (u1[e] - u0[e]) / (t1[e] - t0[e]) * 100
+        for (e in n1) printf "  %s %.2f %%", e, (n1[e] - n0[e]) / (wall * 1000) * 100
+    }'
+printf '  rss %s MiB\n' "$(awk '/^VmRSS/ {printf "%.0f", $2 / 1024}' /proc/$pid/status)"

weather/CREDITS.md

@@ -0,0 +1,33 @@
+# Weather photos
+
+The home card shows a photo of the weather now behind it. On first use the shell downloads the
+one it needs from Wikimedia Commons (1280 px wide thumbnails) into `pills.home.photos`
+(`~/.config/amane/weather` by default) as `<kind>-<day|night>.jpg`. It never replaces a file
+that's already there, so any of them can be swapped for your own picture (a swapped file shows
+after the shell restarts).
+
+All of them are free to use under the licence given, with credit to their authors:
+
+| File | Photo | Author | Licence |
+|---|---|---|---|
+| clear-day.jpg | [Zugspitze, Alpspitze und Jubiläumsgrat von Kinderburg, Allmannshausen, Starnberger See](https://commons.wikimedia.org/wiki/File:Zugspitze,_Alpspitze_und_Jubil%C3%A4umsgrat_von_Kinderburg,_Allmannshausen,_Starnberger_See.jpg) | TGoeller | CC0 1.0 |
+| clear-night.jpg | [Starry night at Old Uppsala, Sweden](https://commons.wikimedia.org/wiki/File:Starry_night_at_Old_Uppsala,_Sweden.jpg) | Kevin Cho | CC BY-SA 4.0 |
+| partly-cloudy-day.jpg | [Cumulus humilis Schönwald im Schwarzwald 20180810](https://commons.wikimedia.org/wiki/File:Cumulus_humilis_Sch%C3%B6nwald_im_Schwarzwald_20180810.jpg) | Uoaei1 | CC BY-SA 4.0 |
+| partly-cloudy-night.jpg | [Full moon over Gullmarn fjord at Holma Marina 1](https://commons.wikimedia.org/wiki/File:Full_moon_over_Gullmarn_fjord_at_Holma_Marina_1.jpg) | W.carter | CC BY-SA 4.0 |
+| cloudy-day.jpg | [Vragender (NL), Vragenderveen -- 2014 -- 3102](https://commons.wikimedia.org/wiki/File:Vragender_(NL),_Vragenderveen_--_2014_--_3102.jpg) | Dietmar Rabich | CC BY-SA 4.0 |
+| cloudy-night.jpg | [Stora Bornö on a cloudy night 2](https://commons.wikimedia.org/wiki/File:Stora_Born%C3%B6_on_a_cloudy_night_2.jpg) | W.carter | CC BY-SA 4.0 |
+| fog-day.jpg | [Dülmen, Umland -- 2014 -- 7056](https://commons.wikimedia.org/wiki/File:D%C3%BClmen,_Umland_--_2014_--_7056.jpg) | Dietmar Rabich | CC BY-SA 4.0 |
+| fog-night.jpg | [Foggy Autumn Evening on Pawia Street, Warsaw](https://commons.wikimedia.org/wiki/File:Foggy_Autumn_Evening_on_Pawia_Street,_Warsaw.jpg) | Oleslawlama | CC BY-SA 4.0 |
+| rain-day.jpg | [Rain drops on window 01 ies](https://commons.wikimedia.org/wiki/File:Rain_drops_on_window_01_ies.jpg) | Frank Vincentz | CC BY-SA 3.0 |
+| rain-night.jpg | [City streets; Reflections on the street surface after rain](https://commons.wikimedia.org/wiki/File:City_streets;_Reflections_on_the_street_surface_after_rain.jpg) | Tarasna0922 | CC BY-SA 4.0 |
+| snow-day.jpg | [Sninský kameň (v zime) 001](https://commons.wikimedia.org/wiki/File:Sninsk%C3%BD_kame%C5%88_(v_zime)_001.jpg) | Milan Bališin | CC BY-SA 4.0 |
+| snow-night.jpg | [TwinLamp@snowyNight(byHideObara)](https://commons.wikimedia.org/wiki/File:TwinLamp@snowyNight(byHideObara).jpg) | Hide Obara | CC0 1.0 |
+| storm-day.jpg | [2011-07 Unwetter Schwäbisch Gmünd](https://commons.wikimedia.org/wiki/File:2011-07_Unwetter_Schw%C3%A4bisch_Gm%C3%BCnd.jpg) | Kreuzschnabel | CC BY-SA 3.0 |
+| storm-night.jpg | [Lightning, Friedrichshafen (OW1A0402)](https://commons.wikimedia.org/wiki/File:Lightning,_Friedrichshafen_(OW1A0402).jpg) | Matti Blume | CC BY-SA 4.0 |
+
+Licences: [CC0 1.0](https://creativecommons.org/publicdomain/zero/1.0/),
+[CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/),
+[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/). The shell shows the photos
+scaled, cropped to the card and veiled in the card's colour; the files themselves are unchanged
+Wikimedia thumbnails. Authors and licences were read from each file's Commons page
+(`extmetadata`) on 2026-10-15.