# Changelog Rune has no releases yet; consumers pin `dev` revs. This lists changes that can move an app's output without a code change (goldens, layout, input), newest first, with the rev that introduced each. ## dev - `RollingText` now remembers at most 512 labels (and 256 KiB of text) per thread, dropping the least recently built; a label that comes back after that starts its roll over (t841). - Docs: a "Fast apps" page (rules with before and after snippets, the memo lesson) and `scripts/app-audit `, a quick grep for the slow patterns it lists; no API change. - **`Tx::scroll_center` and `Tx::scroll_center_in` reveal and vertically centre elements, virtual rows and `TextHighlight`s.** Passing `"row/mark"` mounts an unrealized virtual row `row` first and centres `mark` inside it, gliding on the scroll spring (`scroll_center_instant` and `scroll_center_in_instant` jump, as `Tx::instant` does). A centring sent mid-glide keeps the glide's speed without carrying past its new stop. `Tx::scroll_into_view` takes `"row/mark"` too, and `Tx::scroll_key_to` also resolves `TextHighlight` keys. - **`Cx::layout` and `Cx::layout_with` read an element inside `virtual_rows` (or `virtualize`) where it draws.** With rows culled above the mounted window, the rect read was the culled rows' height too far down. - A `Tx::launch` flight re-aimed mid-flight (its row or an ancestor moved) keeps the speed it was drawn moving at, including the part a scroll view's correction under it added, instead of slowing for a frame and picking up again. `Scene::shift_travel`, which nothing called, is replaced by `Scene::retarget_drawn`, a `set_frame` that starts the new path where the renderer draws the node and at the speed it's drawn moving. The motion audit reports such a one-frame speed dip as `stall`. - A `memo` hit no longer deep-clones its subtree: the cached subtree is shared, its flattened nodes and layout subtree are reused when its parent didn't change, and apply skips unchanged reused subtrees. On a chat-sized test window, a keystroke's commit takes about half the CPU and 79% fewer bytes. No API change. - Growth stacks: a row that moves to a new place and changes height in the same animated commit now slides from where it was drawn, instead of stepping by its height change on the commit's frame. A `Tx::launch` flight whose row (or an ancestor) is moved mid-flight now heads for the new place from where it was drawn, instead of jumping by the move. And when a commit changes the padding, gap or margin above a row's contents (a row that stops sitting close to the one above it), those contents slide from where they were drawn; a sibling's new size still moves the contents under it at once. - **`Tx::keep_on_screen` holds a stuck header in place.** Shutting a group from its `sticky_top` header while the header is stuck (for example in a `stick_bottom` timeline scrolled into a group taller than the view) keeps the header where it's drawn for the whole commit, and the rows below fold up to it on the growth spring. Before, the header unstuck as its group shrank, the scroll jumped to bring it back, and the rows below dipped hundreds of points while the group's first rows flashed for a frame. Anchors that aren't stuck behave as before. - **`Latest` gains `set_waker`, `request_if_changed` and `request_opt`.** `set_waker` attaches the waker in `setup` to a `Latest::default().debounce(..)` built in `init`, keeping its debounce, pending request and answer. `request_if_changed(&key, work)` (`K: Clone + PartialEq`) does nothing when the key equals the last such request's, so `poll` can call it every time without restarting work; `request`, `request_opt` and `cancel` forget the key. `request_opt` takes work returning `Option`: `None` lands nothing and doesn't wake the window, but still supersedes older requests. - `El::anchored` overlays draw at their anchor's zoom: inside a subtree drawn at `El::scale(1.6)`, a popover and its text draw at 1.6 (crisp once still) beside where the anchor draws, growing away from it, with the gap zoomed and flipping, `anchored_fit` and hit testing on the drawn size. An overlay with its own `El::scale` keeps it instead of the inherited zoom, so popovers already wrapped in `.scale(zoom)` by hand don't zoom twice. One that scales a child inside it instead needs `El::anchored_unscaled()`, which keeps an overlay at window scale. - `El::help_when_truncated` now shows its tooltip when an `El::truncate_fade` text runs past its box, as it does for `truncate` and `max_lines`, so a faded label no longer needs a "…" to get its tooltip. The fade still draws no ellipsis. - **`rune::Latest`: latest-wins background requests.** `Latest::new(waker)` (the `setup` waker), optionally `.debounce(wait)`; `request(key, |key| work(key))` from a handler runs the work on a small shared worker pool (up to four threads, which exit when idle) and supersedes every earlier request: one not yet started never runs, and a stale answer is dropped even when it finishes last. The landed answer wakes the window once and `take()` returns it once, so `poll` returns true only when it changed. `cancel()` and dropping the `Latest` stop its requests; `is_pending()` drives a spinner. On the web the work runs on the main thread from `spawn_local`. The debug stall warning points here. - A drag in a selection group reaches only text that shows: text clipped out of sight but laid out under the words (a folded part above them) no longer takes the drag, which selected everything between it and the press. - Growth stacks and virtual lists: rows an animated commit puts in a new order slide from where they were drawn into their new places on the layout spring (or the transaction's motion), instead of jumping there in one frame. Only rows whose order changed move; inserts, removals, window shifts, instant commits, Reduce Motion and rows out of sight before and after still land as before. A virtual list read from its top no longer re-anchors to the row that moved. - **Typing or streaming into a text no longer fills the layout cache with each edit's copy.** The cache kept every version of an edited paragraph as a stale layout until its budget ran out: about 100 copies, over 3 MB, of a 600-byte paragraph being typed into, pushing out the layouts of views that would be shown again. When a node's text changes into an edit of itself (most of it shared at the start and end), the old version's layouts now go at the end of that commit unless another node still shows them; text replaced by something unrelated, as a reader switching notes, stays cached for when it comes back. The stale budget is now counted in estimated heap bytes (3 MB) rather than bytes of text. - **Resizing a window lays the last tree out again instead of running the view.** When only the viewport changed since the last commit (same state, scale and env, no layout or caret read that moved), a commit re-solves layout on the nodes it already has and re-breaks their text at the new widths, skipping the view and flattening. A view that reads layout (`Cx::layout`, `Cx::layout_size`), the caret, a breakpoint or the env still runs when what it read changes. Virtual lists keep their mounted rows and lay them out again; the view runs only when the viewport nears the edge of the mounted rows, or rows outside the overscan add up to more than a viewport. A notes-sized Markdown page resizes in 2.5 ms per step, down from 3.6 ms, with 42% fewer allocations; a virtual list of Markdown rows in 0.62 ms, down from 0.82. - **A dimmed box with a solid fill fades as CSS `opacity` does.** `El::dim`, which disabled kit controls use, no longer lets the box's outer shadows show through its faded fill, and a fill under a gradient (a contrast button's sheen) fades with it as one, still without a layer. A disabled contrast button on white now paints the browser's light grey (about 176 instead of 159 mid-height with the OpenCode theme), and a disabled neutral button no longer shows its drop shadow through. A crisp offset shadow under a native material, backdrop blur or dimmed box now leaves the interior clear too. - **Resizable playground columns** (`Playground::widths`): the story list and the right-hand controls column in `App::playground` drag by their separator edges to resize and double-click back to their default widths, persisted in `Prefs` by default for windowed apps or through `Playground::widths(load, save)`. - **Theme colours authored for sRGB blending are painted as authored now that windows blend in sRGB.** A theme with `"blend": {"mode": "srgb"}`, the OpenCode theme's translucent tokens and shadows, `Kit::alpha`, `Kit::on` and `Kit::from_palette`'s borders and tints re-solve alpha only in a window that blends in linear light (`srgb_blend(false)`), so fills, selected rows, disabled controls and status banners look as they did before the sRGB default instead of double-compensated. Colours resolve for the blend mode of the window building the view (`rune::theme::blends_srgb`, `rune::theme::for_blend`, `rune::theme::with_blend`), a live `Tx::set_srgb_blend` re-resolves them (memoised rows included), and `rune_theme_opencode::kit` returns the kit for the current mode, so get it in the view. - **Debug builds warn about two slow patterns, once per site, on stderr.** A `virtualize` list handed more than 200 rows and four times what it mounts names its path and `.virtualize` call site and points to `El::virtual_rows`, which builds only the mounted rows. A handler, `poll`, `update` closure, `init` or `on_ready` that spends over 8 ms on the main thread and over four times its CPU time warns as "`poll` blocked 263 ms (CPU 2 ms) on the main thread: move IO off it with `rune::Latest` or a thread". `RUNE_PERF_WARN=0` silences both; release builds contain neither. On macOS `libc` is now a regular dependency for the thread CPU clock. - Text: underlines sit on whole device pixels, and one that ends its line runs to the text box's rounded-up edge, so a link split into an element a word draws one line with no gaps at the spaces. - **Elements that never animate keep no motion tracks.** A property gets a track only when its value first changes, starting from what was last drawn, so a static tree holds none: on a 60-card settings column (about 5,300 nodes) a commit's apply phase takes about a third less time and the heap is 12 MB smaller. A node mounted with the first frame has no `prop::PRESENCE` track until it leaves (`Scene::get` still reads 1.0), and fill, text, border, shadow, gradient, outline, hover and press follow the same rule, so `AnimationStore::track_len`, `has` and `get` see only what has moved. A `Scene::set` or `Scene::animate` that leaves a property where it already rests no longer marks the node changed. - `ElementInfo` implements `Default` (a plain, opaque `el()` at rest) and adds `ElementInfo::stub(key)`, so a test that stands in for `Runtime::elements` can write `ElementInfo { focused: true, ..ElementInfo::stub("send") }` and keep building when Rune adds a field. - **`rune::is_headless()`, and `--script` alone runs headless.** `is_headless()` answers from the process's arguments, parsed once, whether the run renders offscreen, so an app can skip a tray, global shortcuts or network work before `run` without scanning argv itself; it leaves `extra_args` for an app that passes `App::args`. A window never replayed a script, so `--script FILE` without `--snap`, `--video` or another output used to open a real window and ignore the script; it now replays it headless like `--frames` (`--native` still opens the window). - `MenuItem::keys_first()` lets the window's own key handling see a menu item's key equivalent before the item does: the focused element, modals and `on_key` get the press first, and the item runs only if none takes it (picking it in the menu always runs it). Without it AppKit hands the chord to the menu before any view, as before. - **`rune::set_app_icon(bytes)` sets the Dock icon from image bytes.** macOS shows an `.icns`, PNG or any image `NSImage` reads as the app's Dock and app-switcher icon while it runs, so an app no longer needs its own `NSImage` and `setApplicationIconImage` glue. Call it from any thread, before `run` (applied once the app finishes launching) or after; it fails on bytes that aren't an image and does nothing elsewhere or in a headless run. - `Transition::none()`, `SpringPair::NONE` and `Spring::NONE` give a node no motion at all: it shows whole the frame it mounts and unmounts the frame after it's removed, focus returns as with any transition, and the rest of the change still animates. A spring of `Spring::NONE` becomes `Curve::Instant`, so Reduce Motion no longer stretches it into a fade the way it does a 0.001 s spring. The split shell's panes use it. - **A compositor that asks for `wgpu::Features::IMMEDIATES` can use immediates.** `Compositor::features` returning `IMMEDIATES` now also raises the device's `max_immediate_size` to the adapter's (4 KB on Metal), so per-draw values set with `RenderPass::set_immediates` travel inside the pass instead of in a uniform written through `Queue::write_buffer` or `Frame::write_buffer`, which costs a macOS overlay frame another command buffer. - **An overlay whose compositor animates over a still view no longer steps or rebuilds the view each frame.** When the last frame asked for no other and nothing has changed since (no input, state change, timer, live value, poll or playground), a frame only advances `Runtime::clock` and `Runtime::t`, then draws the last build again, so a compositor reading the clock still animates. The macOS overlay frame also waits on its present thread only once a frame is due, reads the panel's occlusion once per loop turn, and doesn't sample the pointer for a click-through overlay that follows nothing. - On web, `App::canvas_id` mounts onto an existing `