← Volver al blog
Aiaprox. 8 min de lectura

Rune es un framework de UI en Rust creado para que un agente pueda comprobar su propio trabajo

Publicado 15 nov 2026
Rune es un framework de UI en Rust creado para que un agente pueda comprobar su propio trabajo

Rune es un framework de UI en Rust de Anomaly. 7.199 estrellas al 15 de noviembre de 2026, licencia MIT, nativo y renderizado por GPU en macOS, Windows, Linux y la web, con su propio renderizador, pila de texto, motor de layout y muelles. Casi todo eso es lo mínimo esperable. Una línea del README no lo es.

> Cada aplicación puede correr sin interfaz, así que un agente puede renderizar a PNG, volcar el árbol de elementos y manejarlo con entrada programada.

Y luego:

Dale este repositorio a tu agente de código. Haz que empiece por examples/hello y crates/rune/README.md, y que después compruebe su propio trabajo sin interfaz renderizando PNG e inspeccionando el árbol de elementos.

Eso se lee como notas de configuración de una herramienta de build, salvo que lo documentado es una interfaz de usuario.

El ejemplo es un interruptor, y lo interesante son los metadatos

El ejemplo hello es un interruptor de luz. Recortado:

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 es una función del estado y un contexto a un árbol de elementos. El tema pasa por tok::theme(true) para oscuro y tok::accent() para el acento, un valor que se pasa en lugar de un archivo que se carga. Las propiedades son tipadas y encadenables: .font, .color, .size, .radius, .fill, .absolute, .key, .role, .label, .checked, .focusable, .on_press. En el preajuste .motion(motion::SNAPPY) del contenedor se enganchan los muelles.

Mira lo que está declarado en ese interruptor. .key("switch"), .role("switch"), .label("Lights"), .checked(s.on), .focusable(true). Cada uno es metadato de accesibilidad, presente para que un lector de pantalla pueda decir "Lights, interruptor, encendido" en lugar de "elemento sin etiqueta". También son las aserciones que quiere un bucle de pruebas: encontrar el nodo con clave switch, confirmar que role es switch, confirmar que checked pasó de false a true, confirmar que la x absoluta del mando pasó de 2.0 a 18.0.

Dudo que alguien haya escrito .role() pensando en un agente. Sale del hecho de que un lector de pantalla y un modelo de lenguaje necesitan las mismas dos cosas: un nombre estable para una parte del árbol, y un estado declarado con el que comparar. La accesibilidad fue el primer consumidor que necesitó semántica legible por máquina. Los agentes son el segundo, y heredan el vocabulario gratis.

Un PNG es una señal débil, un árbol es una señal fuerte

Una captura de pantalla es un canal con pérdida para un modelo de texto. Puedes devolver un PNG a un modelo multimodal y obtener una respuesta sobre si se ve bien. Esa respuesta no es diffeable ni estable. Mueve un botón dos píxeles y el veredicto puede cambiar sin motivo. Cambia la etiqueta por algo engañoso y el veredicto puede no cambiar en absoluto.

Un árbol de elementos se comporta distinto. Es texto, está ordenado, tiene claves, y un diff entre dos volcados es una lista de cambios concretos. Un agente puede aseverar sobre él como un test asevera sobre JSON: esta clave existe, este rol está puesto, este nodo de texto contiene esa cadena. Las señales comprobables son lo que permite que un bucle corra más de una iteración sin un humano en medio.

El problema es que un render sin interfaz prueba que los píxeles existen, y prueba que el árbol coincide con el que esperabas. No prueba que el layout se lea bien. Un interruptor de 38 por 22 con un mando de 18 por 18 dentro de una pista de radio 11 cumple todas las aserciones de ese ejemplo y aun así se ve mal con un tamaño de fuente mayor, o aprieta la etiqueta con gap 16.0, o queda descentrado en una ventana ancha.

Un agente puede verificar que construyó lo que quería construir. No puede verificar que lo que quería construir fuera bueno. El proyecto hace verificable la mitad mecánica del trabajo de UI y deja la mitad del gusto donde estaba.

La instalación es una revisión de git, y Windows pide dlltool

Rune está en prelanzamiento. No se añade por número de versión:

rune = { git = "https://github.com/anomalyco/rune", rev = "<dev rev>" }

El README dice que fijes una rev de dev, y que dev nunca se reescribe. Es una promesa más fuerte que semver en un sentido estrecho, porque una rev es inmutable y una build que funcionó ayer sigue resolviendo hoy. Es más débil en el sentido obvio, porque no hay versiones publicadas ni garantía de que la API que fijaste se parezca a la de dev el mes que viene.

En Windows hay una trampa concreta. La cadena MSVC, la predeterminada de rustup, solo necesita las herramientas de compilación de C++ de Visual Studio. La cadena GNU también necesita binutils de MinGW-w64 en el PATH, y la razón va por capas: windows-link, que está debajo de parking_lot, libloading, windows-core y windows-sys, o sea debajo de cada crate de UI para Windows, importa con raw-dylib; rustc construye esas bibliotecas de importación con dlltool en objetivos GNU; y el dlltool dentro de rust-mingw de rustup no puede correr sin un as que no incluye, que es rust-lang/rust#140704. La build se detiene en windows-result con "error calling dlltool 'dlltool.exe': program not found".

El arreglo está en el README, lo cual es más de lo que logran la mayoría de los proyectos: instalar MSYS2, ejecutar pacman -S mingw-w64-ucrt-x86_64-binutils, poner C:\msys64\ucrt64\bin en el PATH, o pasar RUSTFLAGS=-Cdlltool=C:\msys64\ucrt64\bin\dlltool.exe. El bug de fondo pertenece al empaquetado de rustup, pero el coste cae en la primera hora de Rune para cualquiera con la cadena GNU.

Sin pull requests

Del README, textual:

> No aceptamos pull requests. Haz que tu agente abra un issue describiendo el bug o la idea, y nuestros agentes suelen resolverlo rápido.

Es la primera sección de contribución que leo que cierra una puerta y abre otra en la misma frase. Como declaración sobre quién escribirá software después, encaja con todo lo anterior. Si el flujo ya está guiado por agentes, un pull request humano llega con una forma que no encaja en el pipeline. Un issue en prosa sí.

Como apuesta sobre un proyecto del que podrías depender, es más arriesgado. Sin pull requests, ningún colaborador externo aprenderá nunca la base de código lo suficiente como para ser maintainer. El bus factor se queda como estaba el primer día: quien esté detrás de Anomaly, más sus agentes. Y "nuestros agentes suelen resolverlo rápido" es una afirmación que no puedes auditar desde fuera.

Nada de eso hace que la elección sea errónea. La convierte en una elección con un coste, y el coste cae sobre cualquiera que adopte un framework en prelanzamiento y espere que se forme una comunidad alrededor. Las comunidades se forman alrededor de vías de contribución. Esta es deliberadamente estrecha.

El patrón es más grande que un repositorio

Las funciones que ahora busco en una herramienta nueva dirigida en parte a agentes caben en una lista corta: render sin interfaz para poder inspeccionar la salida sin pantalla, un árbol de elementos determinista en lugar de un framebuffer opaco, entrada programada para que un bucle pueda hacer clic sin ratón, y una revisión fijada para que el bucle reproduzca el ayer. Rune tiene las cuatro y las pone por delante.

Ese orden es la noticia. La API sigue sirviendo a humanos, porque alguien tiene que leer la función view y decidir que el interruptor debe medir 38 píxeles de ancho. Pero la restricción que dio forma al modo sin interfaz, al volcado de elementos y al script de entrada fue un consumidor que no puede ver. Un framework cuyo primer lector es un bucle se ve distinto de uno cuyo primer lector es una persona. La carpeta demo dice hasta dónde llega: una app de agente de código, una interfaz de chat, un diff dividido, un efecto de metal líquido, una ventana de ajustes. Ese es el mobiliario de las herramientas con las que la gente escribe software hoy.

Algo concreto para probar si tienes una tarde: toma el ejemplo del interruptor, renderízalo sin interfaz al 100 por ciento y al 150 por ciento de escala, vuelca ambos árboles, haz diff y cuenta cuánto de la diferencia es layout y cuánto es métrica de texto. Ese diff te dice más sobre si Rune está listo para tu proyecto que el número de estrellas.

Artículos relacionados