Rune è un framework UI per Rust costruito perché un agente possa verificare il proprio lavoro

Rune è un framework UI per Rust di Anomaly. 7.199 stelle al 15 novembre 2026, licenza MIT, nativo e renderizzato su GPU su macOS, Windows, Linux e web, con renderer, stack di testo, motore di layout e molle propri. Quasi tutto questo è il minimo. Una riga del README no.
> Ogni app può girare headless, così un agente può renderizzare in PNG, esportare l'albero degli elementi e pilotarla con input scriptato.
E poi:
Dai questo repository al tuo agente di coding. Fallo partire da examples/hello e crates/rune/README.md, poi fallo verificare il proprio lavoro in headless renderizzando PNG e ispezionando l'albero degli elementi.
Si legge come note di setup per un tool di build, tranne per il fatto che la cosa documentata è un'interfaccia utente.
L'esempio è un interruttore, e la parte interessante sono i metadati
L'esempio hello è un interruttore della luce. Ridotto:
fn view(s: &State, _: &mut Cx<State>) -> El {
let t = tok::theme(true);
let label = text(if s.on { "Lights on" } else { "Lights off" })
.font(type_::TITLE).color(t.text);
let knob = el().key("knob").size(18.0, 18.0).radius(9.0).fill(t.knob)
.absolute(if s.on { 18.0 } else { 2.0 }, 2.0);
let switch = el().key("switch").role("switch").label("Lights").checked(s.on)
.focusable(true).size(38.0, 22.0).radius(11.0)
.fill(if s.on { tok::accent(0, true) } else { t.control_off })
.motion(motion::SNAPPY)
.on_press(|s: &mut State| s.on = !s.on)
.child(knob);
col().w_full().h_full().center().gap(16.0).fill(t.bg)
.child(label).child(switch)
}
La firma è una funzione da stato e contesto a un albero di elementi. Il tema passa per tok::theme(true) per lo scuro e tok::accent() per l'accento, un valore che si passa invece di un file che si carica. Le proprietà sono tipizzate e incatenabili: .font, .color, .size, .radius, .fill, .absolute, .key, .role, .label, .checked, .focusable, .on_press. È sul preset .motion(motion::SNAPPY) del contenitore che si agganciano le molle.

Guarda cosa è dichiarato su quell'interruttore. .key("switch"), .role("switch"), .label("Lights"), .checked(s.on), .focusable(true). Ognuno è metadato di accessibilità, presente perché uno screen reader possa dire "Lights, interruttore, acceso" invece di "elemento senza etichetta". Sono anche le asserzioni che vuole un ciclo di test: trova il nodo con chiave switch, conferma che role è switch, conferma che checked è passato da false a true, conferma che la x assoluta della manopola è passata da 2.0 a 18.0.
Dubito che qualcuno abbia scritto .role() pensando a un agente. Deriva dal fatto che uno screen reader e un modello linguistico hanno bisogno delle stesse due cose: un nome stabile per una parte dell'albero, e uno stato dichiarato con cui confrontarsi. L'accessibilità è stato il primo consumatore ad aver bisogno di semantica leggibile dalla macchina. Gli agenti sono il secondo, e ereditano il vocabolario gratis.
Un PNG è un segnale debole, un albero è un segnale forte
Uno screenshot è un canale con perdita per un modello testuale. Puoi rimandare un PNG a un modello multimodale e ottenere una risposta su se sembra giusto. Quella risposta non è diffabile e non è stabile. Sposta un pulsante di due pixel e il verdetto può ribaltarsi senza motivo. Cambia l'etichetta in qualcosa di fuorviante e il verdetto può non cambiare affatto.
Un albero di elementi si comporta diversamente. È testo, è ordinato, ha chiavi, e un diff tra due dump è una lista di cambiamenti specifici. Un agente può asserire su di esso come un test asserisce su JSON: questa chiave esiste, questo ruolo è impostato, questo nodo di testo contiene quella stringa. I segnali verificabili sono ciò che permette a un ciclo di girare più di un giro senza un umano in mezzo.
Il problema è che un render headless dimostra che i pixel esistono, e dimostra che l'albero corrisponde a quello atteso. Non dimostra che il layout si legga bene. Un interruttore 38 per 22 con una manopola 18 per 18 dentro una pista di raggio 11 soddisfa ogni asserzione di quell'esempio e resta brutto con un corpo del testo più grande, o stringe l'etichetta con gap 16.0, o sta fuori centro in una finestra larga.
Un agente può verificare di aver costruito ciò che intendeva costruire. Non può verificare che ciò che intendeva costruire fosse buono. Il progetto rende verificabile la metà meccanica del lavoro di UI e lascia la metà del gusto dov'era.
L'installazione è una revisione git, e Windows vuole dlltool
Rune è in pre-release. Non si aggiunge per numero di versione:
rune = { git = "https://github.com/anomalyco/rune", rev = "<dev rev>" }
Il README dice di fissare una rev di dev, e che dev non viene mai riscritto. È una promessa più forte di semver in un senso stretto, perché una rev è immutabile e una build che funzionava ieri si risolve ancora oggi. È più debole nel senso ovvio, perché non ci sono versioni pubblicate e nessuna garanzia che l'API fissata assomigli a quella su dev il mese prossimo.
Su Windows c'è una trappola precisa. La toolchain MSVC, quella predefinita di rustup, richiede solo i build tools C++ di Visual Studio. La toolchain GNU richiede anche i binutils MinGW-w64 nel PATH, e la ragione è a strati: windows-link, che sta sotto parking_lot, libloading, windows-core e windows-sys, quindi sotto ogni crate UI per Windows, importa con raw-dylib; rustc costruisce quelle librerie di import con dlltool sui target GNU; e il dlltool dentro rust-mingw di rustup non può girare senza un as che non include, ed è rust-lang/rust#140704. La build si ferma su windows-result con "error calling dlltool 'dlltool.exe': program not found".
La soluzione è nel README, che è più di quanto facciano quasi tutti i progetti: installa MSYS2, lancia pacman -S mingw-w64-ucrt-x86_64-binutils, metti C:\msys64\ucrt64\bin nel PATH, oppure passa RUSTFLAGS=-Cdlltool=C:\msys64\ucrt64\bin\dlltool.exe. Il bug di fondo è del packaging di rustup, ma il costo cade nella prima ora di Rune per chiunque usi la toolchain GNU.
Niente pull request
Dal README, alla lettera:
> Non accettiamo pull request. Fai aprire al tuo agente una issue che descriva il bug o l'idea, e i nostri agenti di solito la chiudono in fretta.
È la prima sezione sui contributi che leggo che chiude una porta e ne apre un'altra nello stesso respiro. Come affermazione su chi scriverà software d'ora in poi, si accorda con tutto quanto sopra. Se il flusso di lavoro è già guidato dagli agenti, una pull request umana arriva in una forma che non entra nella pipeline. Una issue in prosa sì.
Come scommessa su un progetto da cui potresti dipendere, è più rischiosa. Niente pull request significa che nessun contributore esterno imparerà mai la codebase abbastanza da diventare maintainer. Il bus factor resta quello del primo giorno: chiunque stia dietro Anomaly, più i loro agenti. E "i nostri agenti di solito la chiudono in fretta" è un'affermazione che non puoi verificare dall'esterno.
Niente di tutto questo rende la scelta sbagliata. La rende una scelta con un costo, e il costo cade su chi adotta un framework in pre-release e si aspetta che attorno si formi una community. Le community si formano attorno a percorsi di contribuzione. Questo è deliberatamente stretto.
Il pattern è più grande di un repository
Le funzioni che ora cerco in un nuovo strumento rivolto in parte agli agenti stanno in una lista breve: rendering headless perché l'output sia ispezionabile senza display, un albero di elementi deterministico invece di un framebuffer opaco, input scriptato perché un ciclo possa cliccare senza mouse, e una revisione fissata perché il ciclo riproduca ieri. Rune le ha tutte e quattro e le mette in testa.
Quell'ordine è la notizia. L'API serve ancora gli umani, perché qualcuno deve leggere la funzione view e decidere che l'interruttore debba essere largo 38 pixel. Ma il vincolo che ha plasmato la modalità headless, il dump degli elementi e lo scripting dell'input era un consumatore che non vede. Un framework il cui primo lettore è un ciclo ha un aspetto diverso da uno il cui primo lettore è una persona. La cartella demo dice fin dove arriva: un'app di agente di coding, un'interfaccia di chat, un diff affiancato, un effetto metallo liquido, una finestra di impostazioni. È l'arredamento degli strumenti con cui oggi si scrive software.
Una cosa concreta da provare se hai un pomeriggio: prendi l'esempio dell'interruttore, renderizzalo headless al 100 per cento e al 150 per cento, esporta entrambi gli alberi, fai il diff e conta quanta parte della differenza è layout e quanta è metrica del testo. Quel diff ti dice più sull'idoneità di Rune al tuo progetto di quante stelle abbia.
Articoli correlati
Un foglio di calcolo comunitario di tocchi che spegne la pubblicità negli Android cinesi
Non tocca il sistema, non sblocca niente, non flasha niente. Ribalta solo gli interruttori che i produttori hanno già previsto. Il prezzo è una lista che qualcuno deve continuare a scrivere.
GPT Image 2.6 ha tenuto il prezzo dei token e alzato la fattura
GPT Image 2.6 conserva ogni tariffa per token di 2.5 e costa comunque di più per immagine, perché buona parte del lavoro passa ora nei token di output. Undici giorni dopo il lancio, la struttura dei prezzi dice più della classifica.
Qualcuno ha ricostruito IDM dall'esterno e ha scritto cosa non ha toccato
Una reimplementazione in Rust di Internet Download Manager promette 5 volte la velocità e 86 lingue. Il documento più interessante è il paragrafo che spiega come è stata costruita senza copiare nulla.
agent-autoloop conserva l'attesa di un umano come riga di database
Un piccolo hub locale che lascia lavorare in background un agente di codice da riga di comando e interrompe l'umano solo per una decisione. La parte interessante è cosa prende dalle code di messaggi, i due punti in cui rifiuta di fare il furbo e il rischio di supply chain che un'installazione pulita non elimina.