Présentation du framework

Rune est un framework UI écrit en Rust capable de dessiner les interfaces directement sur le GPU. Il cible les systèmes d’exploitation macOS, Windows, Linux ainsi que les environnements web, offrant ainsi une portée véritablement multiplateforme. Le dépôt officiel (github.com/anomalyco/rune) indique que le projet est en pré‑release et que chaque version doit être épinglée à un rev immuable pour garantir la reproductibilité.

Le code d’exemple fourni dans le répertoire examples/hello montre une API déclarative où l’on compose des éléments (el(), col()) et on associe des propriétés comme la taille, le rayon ou la couleur via des appels de fonction. Cette approche s’inscrit dans la philosophie Rust de sécurité de type et de composition fonctionnelle.

Architecture du rendu et du layout

Rune intègre son propre moteur de rendu GPU, ainsi que des sous‑systèmes dédiés au texte, au layout et aux ressorts (springs) pour les animations. L’utilisation d’un moteur propriétaire évite la dépendance à des bibliothèques externes comme OpenGL ou Vulkan, mais implique que la performance dépend de l’implémentation interne du pipeline de rasterisation. Le système de ressorts fournit un modèle physique simple pour les transitions d’état, comme le déplacement du bouton « knob » dans l’exemple.

fn view(s: &State, _: &mut Cx) -> 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)
}

Le fragment ci‑dessus illustre la création d’un composant « switch » avec un état binaire, un rendu conditionnel et une interaction via on_press. Chaque appel retourne un nouveau El, ce qui rend le graphe d’UI immuable et donc plus sûr pour le compilateur.

Mode headless et automatisation

Rune propose un mode headless où aucune fenêtre n’est affichée ; l’application peut générer des images PNG, exporter l’arbre d’éléments et recevoir des entrées scriptées. Cette capacité permet d’automatiser les tests d’interface, de créer des agents de rendu ou de produire des captures d’écran sans dépendre d’un affichage physique.

Le workflow recommandé consiste à lancer le binaire depuis le répertoire examples/hello, à spécifier la révision du dépôt via rune = { git = "https://github.com/anomalyco/rune", rev = "" }, puis à vérifier le rendu PNG produit. L’absence de pull‑requests signifie que les contributions passent par la création d’issues, processus que les mainteneurs décrivent comme « rapide ».

État de maturité et perspectives

Étant en pré‑release, Rune ne bénéficie pas encore d’une version stable ni d’un historique de correctifs public. Le choix d’un moteur propriétaire peut limiter l’adoption tant que les performances et la compatibilité avec les drivers GPU ne sont pas évaluées de façon indépendante. De plus, la licence MIT assure une utilisation libre, mais la communauté doit encore fournir des retours d’expérience pour consolider les API.

En résumé, Rune offre une approche novatrice du rendu UI en Rust, combinant GPU natif, layout autonome et exécution headless. Son adoption dépendra de la stabilité du code, de la documentation autour du moteur de rendu et de la capacité du projet à intégrer des contributions externes via le système d’issues.