Portfolio · Notes · Dotfiles

Search everything

Search case studies, engineering notes, and Dotfiles documentation.

    all notes

    Trying Rune with a small MacBook notch app

    I tried Rune, a new Rust UI framework, on a small MacBook notch app.

    Rune is a new Rust UI framework from Anomaly, the people behind OpenCode. Its repository appeared in late October 2026, and it describes itself in one line: “A native GPU-rendered Rust UI framework for macOS, Windows, Linux and the web, with its own renderer, text, layout and springs.” The second line is the one that makes it interesting for someone like me: “Every app can run headless, so an agent can render to PNG, dump the element tree and drive it with scripted input.” I’m not a Rust developer, and most of the code in this post was written by a coding agent.

    To try it, I built something small: Notch Assistant, a panel that hangs off the MacBook notch and shows my FireHydrant on-call rotation and open incidents. This post is a short tour of the app, of what Rune was like to build it with, and of how Rune sits next to the Rust UI frameworks that came before it.

    The app

    Hover the notch and the panel springs open; move away and it closes. Here it is on a short tour, ending in Settings:

    Hover, switch tabs, move away, then ⚙ to Settings: a made-up key is saved, the connection test passes, and the panel goes Live.

    The On-call tab shows who is primary and secondary, how much of my shift is left, and five weeks of the rotation; the Incidents tab lists the team’s open incidents. On a display without a notch, the panel sits in the middle of the menu bar instead. The ⚙ button opens Settings, where the FireHydrant API key (kept in the Keychain), the team and my name on the schedule go; saving tests the connection, and the top bar switches from “Mock data” to “Live”. It refreshes every five minutes. It’s a small experiment rather than a pager, and it installs with Homebrew:

    Terminal window
    brew install --cask shmileee/tap/notch-assistant

    Working with Rune

    A Rune app is a view function: given the app’s state, it returns a tree of elements. Handlers change the state, the view runs again, and Rune animates the difference. For the panel, that means the whole open and close animation is one keyed element with two possible sizes and a spring:

    src/view.rs
    let shape = if open {
    col().w(PANEL.0).max_h(PANEL.1)
    } else {
    col().size(s.geo.width + 2.0 * WING, s.geo.height)
    };
    let island = shape.key("island").hit().fill(BLACK)
    .corners([0.0, 0.0, r, r]).clip_corners([0.0, 0.0, r, r])
    // ... a shadow while open ...
    .motion(SPRING)
    // ... hover and press handlers ...
    .child(body);

    The rest of the motion, including what happens when a hover interrupts it halfway, is Rune’s job. Putting the panel above the menu bar was just as short: Rune has overlays, surfaces that sit above every app without taking keyboard focus, and a handful of options put this one on the display under the pointer, move it to the next display when the pointer does, and let clicks through everywhere except on the panel itself.

    Rune’s README tells you to give your agent the repository and have it “check its own work headlessly by rendering PNGs and inspecting the element tree”, and the app is set up for that. It has named scenes with the clock pinned, and any of them renders to a PNG without a window, which is where the screenshots in its README come from:

    Terminal window
    cargo run -- --scene open --snap snaps/open.png

    The same tooling can play a script of timed pointer events against a scene and write a video. Rune was easy to work with, and it’s fast: rendering a 12.6-second scripted tour that way took 6.1 seconds for 757 frames on an Apple-silicon Mac, and the median frame took a third of a millisecond of CPU.

    Rune is pre-release, though, and it shows in small ways. Its README asks you to “Pin a rev of dev”, which the app does. It drops quit requests made from an overlay, so the panel’s × button did nothing at first, until the quit went through the Settings window instead. And a headless render has no notch: it draws every pixel, including the ones the hardware hides, so text that slid under the notch only showed up as missing on the MacBook itself.

    How it compares

    There are several Rust UI frameworks already, and I’m no expert in any of them, so take this as a map rather than a review. Each description is the project’s own:

    FrameworkIn its own wordsDraws with
    egui“an easy-to-use immediate mode GUI”wgpu or glow
    iced“inspired by Elm”wgpu, or tiny-skia in software
    Slinta “declarative GUI toolkit” with its own markup languagefemtovg, Skia or software
    GPUI“hybrid immediate and retained mode”the GPU
    Tauriapps “with a web frontend”the system webview
    Rune“its own renderer, text, layout and springs”its own renderer, on Metal or wgpu

    As far as I can tell, Rune’s view function puts it closest to iced, and like GPUI it is GPU-accelerated. What stands out is how central running without a window is: headless rendering, scripted input and an inspectable element tree are the second line of its README. For an app that was mostly written by an agent, that’s a good fit.

    Where to from here?

    Notch Assistant does one small job, and it was a pleasant way to find out what Rune is like: easy to pick up, quick to render, and built with coding agents in mind. Rune is young and moving fast, so I’d pin a revision and expect things to change.

    If you want to try either, the app’s repository has the source, and Rune’s README suggests starting from its examples/hello.

    Comments