Rune é um framework de UI em Rust feito para que um agente possa verificar o próprio trabalho

Rune é um framework de UI em Rust da Anomaly. 7.199 estrelas em 15 de novembro de 2026, licença MIT, nativo e renderizado por GPU no macOS, Windows, Linux e na web, com renderizador, pilha de texto, motor de layout e molas próprios. Quase tudo isso é o básico. Uma linha do README não é.
> Todo app pode rodar sem interface, então um agente pode renderizar em PNG, despejar a árvore de elementos e conduzi-la com entrada roteirizada.
E então:
Dê este repositório ao seu agente de código. Faça ele começar por examples/hello e crates/rune/README.md, e depois verificar o próprio trabalho sem interface, renderizando PNGs e inspecionando a árvore de elementos.
Isso soa como notas de instalação de uma ferramenta de build, exceto que a coisa documentada é uma interface de usuário.
O exemplo é um interruptor, e os metadados são a parte interessante
O exemplo hello é um interruptor de luz. Enxuto:
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)
}
A assinatura é uma função de estado e contexto para uma árvore de elementos. O tema passa por tok::theme(true) para escuro e tok::accent() para o destaque, um valor que você passa em vez de um arquivo que carrega. As propriedades são tipadas e encadeáveis: .font, .color, .size, .radius, .fill, .absolute, .key, .role, .label, .checked, .focusable, .on_press. É no preset .motion(motion::SNAPPY) do contêiner que as molas se prendem.

Olhe o que está declarado naquele interruptor. .key("switch"), .role("switch"), .label("Lights"), .checked(s.on), .focusable(true). Cada um é metadado de acessibilidade, ali para que um leitor de tela possa dizer "Lights, interruptor, ligado" em vez de "elemento sem rótulo". São também as asserções que um ciclo de teste quer: achar o nó com chave switch, confirmar que role é switch, confirmar que checked virou de false para true, confirmar que o x absoluto do botão foi de 2.0 para 18.0.
Duvido que alguém tenha escrito .role() pensando em um agente. Isso sai do fato de que um leitor de tela e um modelo de linguagem precisam das mesmas duas coisas: um nome estável para uma parte da árvore, e um estado declarado para comparar. A acessibilidade foi o primeiro consumidor a precisar de semântica legível por máquina. Os agentes são o segundo, e herdam o vocabulário de graça.
Um PNG é um sinal fraco, uma árvore é um sinal forte
Um screenshot é um canal com perda para um modelo de texto. Você pode devolver um PNG a um modelo multimodal e receber uma resposta sobre se parece certo. Essa resposta não é diffável nem estável. Mova um botão dois pixels e o veredito pode virar sem motivo. Mude o rótulo para algo enganoso e o veredito pode não mudar nada.
Uma árvore de elementos se comporta diferente. É texto, é ordenada, tem chaves, e um diff entre dois despejos é uma lista de mudanças específicas. Um agente pode fazer asserções nela como um teste faz em JSON: esta chave existe, este papel está definido, este nó de texto contém aquela string. Sinais checáveis são o que permite um ciclo rodar mais de uma iteração sem um humano no meio.
O problema é que um render sem interface prova que os pixels existem, e prova que a árvore bate com a árvore esperada. Não prova que o layout lê bem. Um interruptor de 38 por 22 com um botão de 18 por 18 dentro de uma trilha de raio 11 satisfaz toda asserção daquele exemplo e ainda fica feio com uma fonte maior, ou aperta o rótulo em gap 16.0, ou fica fora do centro numa janela larga.
Um agente pode verificar que construiu o que queria construir. Não pode verificar que o que queria construir era bom. O projeto torna verificável a metade mecânica do trabalho de UI e deixa a metade do gosto onde estava.
A instalação é uma revisão do git, e o Windows quer dlltool
Rune está em pré-lançamento. Você não o adiciona por número de versão:
rune = { git = "https://github.com/anomalyco/rune", rev = "<dev rev>" }
O README diz para fixar uma rev de dev, e que dev nunca é reescrito. É uma promessa mais forte que semver num sentido estreito, já que uma rev é imutável e um build que funcionou ontem ainda resolve hoje. É mais fraca no sentido óbvio, porque não há versões publicadas nem garantia de que a API que você fixou pareça com a do dev no mês que vem.
No Windows há uma armadilha específica. A toolchain MSVC, padrão do rustup, só precisa das ferramentas de build C++ do Visual Studio. A toolchain GNU também precisa do binutils do MinGW-w64 no PATH, e o motivo é em camadas: windows-link, que fica sob parking_lot, libloading, windows-core e windows-sys, ou seja, sob todo crate de UI para Windows, importa com raw-dylib; o rustc constrói essas bibliotecas de importação com dlltool em alvos GNU; e o dlltool dentro do rust-mingw do rustup não roda sem um as que ele não traz, o que é rust-lang/rust#140704. O build para em windows-result com "error calling dlltool 'dlltool.exe': program not found".
A correção está no README, o que é mais do que a maioria dos projetos faz: instale o MSYS2, rode pacman -S mingw-w64-ucrt-x86_64-binutils, coloque C:\msys64\ucrt64\bin no PATH, ou passe RUSTFLAGS=-Cdlltool=C:\msys64\ucrt64\bin\dlltool.exe. O bug de fundo é do empacotamento do rustup, mas o custo cai na primeira hora do Rune para quem usa a toolchain GNU.
Sem pull requests
Do README, ipsis litteris:
> Não aceitamos pull requests. Peça ao seu agente para abrir uma issue descrevendo o bug ou a ideia, e nossos agentes costumam resolver rápido.
É a primeira seção de contribuição que leio que fecha uma porta e abre outra na mesma frase. Como afirmação sobre quem vai escrever software daqui em diante, combina com tudo acima. Se o fluxo de trabalho já é guiado por agentes, um pull request humano chega num formato que não encaixa no pipeline. Uma issue em prosa encaixa.
Como aposta num projeto do qual você pode depender, é mais arriscada. Sem pull requests, nenhum colaborador externo vai aprender a base de código o suficiente para virar mantenedor. O bus factor fica como estava no primeiro dia: quem estiver por trás da Anomaly, mais os agentes deles. E "nossos agentes costumam resolver rápido" é uma afirmação que você não consegue auditar de fora.
Nada disso torna a escolha errada. Torna a escolha uma escolha com custo, e o custo cai sobre quem adota um framework em pré-lançamento e espera que se forme uma comunidade em volta. Comunidades se formam em volta de caminhos de contribuição. Este é deliberadamente estreito.
O padrão é maior que um repositório
Os recursos que agora procuro numa ferramenta nova voltada em parte a agentes cabem numa lista curta: render sem interface para que a saída possa ser inspecionada sem tela, uma árvore de elementos determinística em vez de um framebuffer opaco, entrada roteirizada para que um ciclo clique sem mouse, e uma revisão fixada para que o ciclo reproduza ontem. Rune tem as quatro e as coloca na frente.
Essa ordem é a notícia. A API ainda serve humanos, porque alguém precisa ler a função view e decidir que o interruptor deve ter 38 pixels de largura. Mas a restrição que moldou o modo sem interface, o despejo de elementos e o script de entrada foi um consumidor que não enxerga. Um framework cujo primeiro leitor é um ciclo parece diferente de um cujo primeiro leitor é uma pessoa. A pasta demo mostra até onde vai: um app de agente de código, uma interface de chat, um diff lado a lado, um efeito de metal líquido, uma janela de configurações. É a mobília das ferramentas com que as pessoas escrevem software hoje.
Uma coisa concreta para testar se você tiver uma tarde: pegue o exemplo do interruptor, renderize sem interface a 100 por cento e a 150 por cento de escala, despeje as duas árvores, faça o diff e conte quanto da diferença é layout e quanto é métrica de texto. Esse diff te diz mais sobre se o Rune está pronto para o seu projeto do que o número de estrelas.
Artigos relacionados
Uma planilha comunitária de toques que desliga os anúncios dos Android chineses
Não mexe no sistema, não desbloqueia nada, não faz flash de nada. Só vira os botões que os fabricantes já deixaram à mostra. O preço é uma lista que alguém precisa continuar escrevendo.
GPT Image 2.6 manteve o preço por token e elevou a fatura
O GPT Image 2.6 mantém cada tarifa por token do 2.5 e mesmo assim custa mais por imagem, porque boa parte do trabalho acontece agora nos tokens de saída. Onze dias após o lançamento, a estrutura de preços diz mais que o ranking.
Alguém reconstruiu o IDM por fora e anotou o que não tocou
Uma reimplementação em Rust do Internet Download Manager promete 5 vezes a velocidade e 86 idiomas. O documento mais interessante é o parágrafo que explica como ela foi feita sem copiar nada.
agent-autoloop guarda a espera por um humano como uma linha no banco de dados
Um hub local pequeno que deixa um agente de código de linha de comando trabalhar em segundo plano e só interrompe o humano quando há uma decisão. O interessante é o que ele pega das filas de mensagens, os dois pontos em que se recusa a ser esperto e o risco de cadeia de suprimentos que uma instalação limpa não elimina.