# Trying Rune with a small MacBook notch app

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

Engineering note by Oleksandr Ponomarov · 17 November 2026 · Topics: rust, macos, devex
Canonical: https://oponomarov.com/blog/posts/trying-rune-with-a-macbook-notch-app/

[Rune](https://github.com/anomalyco/rune) is a new Rust UI framework from
Anomaly, the people behind [OpenCode](https://github.com/anomalyco/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](https://github.com/shmileee/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.

> [!NOTE] Source
>
> Code is quoted from
> [notch-assistant](https://github.com/shmileee/notch-assistant/tree/c218d0d800affe8a6c810428887f776cc2f55eb5)
> at `c218d0d`, which pins Rune in
> [`Cargo.toml`](https://github.com/shmileee/notch-assistant/blob/c218d0d800affe8a6c810428887f776cc2f55eb5/Cargo.toml#L8-L11).
> The video is the repository's own demo: the real app in its demo mode,
> on mock data with made-up names, recorded while a script moves the
> pointer.

## 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:

<figure class="media-figure media-figure-wide wide">
  <div class="media-frame media-frame-dark">
    <video
      src="/blog-static/notch-assistant-demo.mp4"
      poster="/blog-static/notch-assistant-demo-poster.webp"
      width="1920"
      height="1246"
      controls
      playsinline
      preload="metadata"
      aria-label="Recording: a small black island at the top of a purple gradient springs open into a panel showing who is on call, switches to two open incidents and back, closes when the pointer leaves, opens again, and its gear button opens a Settings window where a key is pasted and saved, after which the panel says Live"
    ></video>
  </div>
  <figcaption>Hover, switch tabs, move away, then ⚙ to Settings: a made-up key is saved, the connection test passes, and the panel goes Live.</figcaption>
</figure>

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:

```bash
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:

```rust title="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:

```bash
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:

| Framework | In its own words | Draws with |
| --- | --- | --- |
| [egui](https://github.com/emilk/egui) | "an easy-to-use immediate mode GUI" | wgpu or glow |
| [iced](https://github.com/iced-rs/iced) | "inspired by Elm" | wgpu, or tiny-skia in software |
| [Slint](https://github.com/slint-ui/slint) | a "declarative GUI toolkit" with its own markup language | femtovg, Skia or software |
| [GPUI](https://www.gpui.rs/) | "hybrid immediate and retained mode" | the GPU |
| [Tauri](https://github.com/tauri-apps/tauri) | apps "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](https://github.com/shmileee/notch-assistant) has the source,
and Rune's README suggests starting from its `examples/hello`.
