Rune is a native UI framework written in Rust that targets macOS, Windows, Linux, and the web. Rather than wrapping platform widgets or delegating to an existing rendering layer, it ships its own GPU renderer, text engine, layout system, and spring-based animation. The ambition is vertical integration: one codebase controls every pixel. The API is declarative and immediate-mode-flavored. A view function takes application state and returns an element tree built from composable primitives — el(), col(), text() — with chained methods for sizing, radius, color, motion, and event handlers. The code sample shows a toggle switch built from first principles in about fifteen lines. There is no JSX, no template language, no separate stylesheet — everything is Rust expressions. The headless execution model is the most distinctive design decision. Every Rune app can render to PNG and expose its element tree for programmatic inspection without a display server. The explicit pitch: hand the repo to a coding agent, let it build UI, then have the agent verify its own work by rendering screenshots and querying the tree. This positions Rune not just as a human-facing toolkit but as an agent-facing one. The project is pre-release and openly says so. Users pin a specific git revision of the dev branch, which the maintainers promise is never rewritten. There are no crates.io releases yet, no semver guarantees, and the contribution model is unusual — pull requests are not accepted. Instead, the maintainers ask contributors to have their agents file issues, and claim their own agents handle triage and fixes. The team behind Rune is Anomaly, and the framework is MIT-licensed. Documentation exists for components and examples, and there is a changelog. But the surface area of what is being attempted — cross-platform GPU rendering, text shaping, layout, accessibility roles, animation physics — is enormous for what appears to be a small team at an early stage. The competitive landscape is crowded. Rust UI contenders include Iced, Slint, Dioxus, Tauri (wrapping webviews), Xilem, and the GPU-rendered Zed editor's GPUI. Each makes different tradeoffs on native widgets vs custom rendering, web targets, and maturity. Rune's bet is that full vertical control plus agent-friendliness is worth the cost of reimplementing everything from scratch. Whether this succeeds depends on execution depth in areas that have historically eaten Rust GUI projects alive: text rendering across scripts, accessibility on each platform, and the long tail of platform integration (clipboard, IME, drag-and-drop, system dialogs). The headless-agent angle is genuinely novel framing, but the hard problems are the same ones every custom-renderer framework faces.
