← Voltar ao blog
Aicerca de 8 min de leitura

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

Publicado 15 de nov. de 2026
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