baklava/doc/Zenity1.md

je me souviens d'une librairie sous linux gnome (donc gtk je pense) qui à partir d'une commande terminal avec paramètres, affichait une widget. Une espèce de generative ui pilotée depuis le terminal. est-ce que tu pourrais m'en dire plus ? existe-t-il d'autres libs de ce type ? laquelle me conseilles tu ?

---

Ce que tu décris est très probablement YAD (Yet Another Dialog), ou éventuellement Zenity. Ce ne sont pas vraiment des bibliothèques, mais des programmes qui permettent de créer des fenêtres et des widgets GTK depuis une commande shell, avec les valeurs de retour et les événements transmis au terminal. YAD est le candidat le plus probable si tu te souviens d’une interface relativement riche ou « générative ». packages.debian

Le candidat principal : YAD

YAD permet de construire des dialogues GTK depuis Bash :

yad \
  --form \
  --title="Configuration" \
  --field="Nom" \
  --field="Actif":CHK \
  --field="Mode":CB \
  --button="Annuler":1 \
  --button="Valider":0

La valeur saisie est généralement renvoyée sur la sortie standard, par exemple sous forme de champs séparés par |.

Quelques exemples :

# Message
yad --info --title="Terminé" --text="La génération est terminée."

# Question
if yad --question --text="Continuer ?"; then
    echo "Oui"
fi

# Formulaire
result=$(yad --form \
  --field="Utilisateur" \
  --field="Mot de passe":H \
  --separator="|")

IFS='|' read -r user password <<< "$result"

# Liste
yad --list \
  --title="Fichiers" \
  --column="Nom" \
  --column="Taille" \
  fichier1.txt 12K \
  fichier2.txt 25K

YAD prend en charge beaucoup plus de types de dialogues que Zenity : formulaires, listes, arbres, texte, HTML selon la compilation, calendrier, sélection de fichiers, barres de progression, menus, onglets et interactions avec des pipes. Il dépend principalement de GTK et sa version actuelle demande GTK 3.22 ou supérieur. github

Sur Debian ou Ubuntu :

sudo apt install yad

La version du projet indique une release 14.2 publiée en novembre 2025, mais le rythme de maintenance reste relativement modéré. github

Zenity : la version GNOME classique

Zenity est probablement le nom que tu as pu rencontrer dans des scripts GNOME. Il fournit des dialogues simples :

zenity --info --text="Bonjour"

zenity --question --text="Supprimer le fichier ?"

zenity --entry \
  --title="Nom du projet" \
  --text="Saisir un nom :"

zenity --list \
  --checklist \
  --column="Sélectionné" \
  --column="Nom" \
  FALSE "Projet A" \
  TRUE  "Projet B"

Zenity est très pratique pour ajouter rapidement une petite interface graphique à un script Bash. En revanche, il est moins flexible que YAD pour créer une interface composée ou réagir dynamiquement à des actions utilisateur. Zenity est présenté comme une réécriture GTK de gdialog, l’ancien outil de dialogues graphiques GNOME. ostechnix

Je le choisirais dans les cas suivants :

• une boîte d’information ou de confirmation ;
• demander une valeur à l’utilisateur ;
• sélectionner un fichier, une date ou une entrée dans une liste ;
• éviter toute dépendance ou syntaxe trop spécifique à YAD.

Les autres solutions intéressantes

Outil	Technologie	Niveau de richesse	Cas d’usage
zenity	GTK	Faible à moyen	Dialogues simples et scripts GNOME
yad	GTK 3	Moyen à élevé	Formulaires, listes, mini-applications Bash
gtkdialog	GTK + XML	Élevé	Décrire une interface entière en XML depuis Bash
AdwDialog	GTK 4 + libadwaita	Faible à moyen	Dialogues modernes cohérents avec GNOME
gtkdialog/forks divers	GTK	Variable	Projets anciens ou spécialisés
pygobject	GTK directement depuis Python	Très élevé	Application réelle et interface complètement dynamique
gtk4-rs	GTK 4 depuis Rust	Très élevé	Application robuste et distribuable
QML/Qt	Qt Quick	Très élevé	Interface déclarative et fortement dynamique

gtkdialog

gtkdialog est peut-être ce que tu as en tête si tu te souviens d’une interface décrite dans un fichier ou une chaîne XML. Il permet de définir des widgets GTK depuis Bash, par exemple avec des balises représentant des fenêtres, boutons, entrées, listes ou terminal embarqué. Il expose même un widget terminal basé sur VteTerminal. fossies

Son intérêt est sa capacité à décrire une interface plus complète qu’avec Zenity :

<window title="Mon outil">
  <vbox>
    <text>
      <label>Paramètres</label>
    </text>
    <entry>
      <variable>NAME</variable>
    </entry>
    <button ok>
      <action>EXIT:0</action>
    </button>
  </vbox>
</window>

Mais je serais prudent : c’est un outil plus ancien, moins standard aujourd’hui, avec une maintenance et une disponibilité variables selon les distributions.

AdwDialog

Pour GTK 4 et GNOME moderne, AdwDialog est une petite solution qui permet d’afficher des dialogues libadwaita depuis le terminal et des scripts. Sa syntaxe est volontairement limitée : titre, description, icône et type de dialogue. github

adwdialog \
  --title "Mise à jour terminée" \
  --description "Le système est à jour." \
  --type info

C’est intéressant pour l’intégration visuelle GNOME, mais ce n’est pas un équivalent complet de YAD : le projet est beaucoup plus petit et ne semble pas viser la génération de formulaires complexes. libadwaita fournit par ailleurs des widgets et des comportements adaptés aux recommandations GNOME et aux différentes tailles d’écran. gtk-rs

Ma recommandation

Pour ton profil de générateur de logiciels, je choisirais :

1. YAD pour prototyper rapidement une interface pilotée par Bash.
2. GTKDialog si tu veux une interface XML plus structurée et que tu acceptes un outil plus ancien.
3. PyGObject + GTK 4/libadwaita pour un véritable générateur d’interfaces dynamiques.
4. AdwDialog uniquement pour quelques dialogues GNOME simples.

En pratique, YAD constitue le meilleur compromis :

#!/usr/bin/env bash

while true; do
    choice=$(yad --list \
        --title="Outil de génération" \
        --text="Que souhaitez-vous faire ?" \
        --column="Action" \
        "Créer un projet" \
        "Configurer le projet" \
        "Quitter" \
        --height=250 \
        --width=400 \
        --print-column=1) || exit 0

    case "$choice" in
        "Créer un projet")
            yad --form \
                --title="Nouveau projet" \
                --field="Nom du projet" \
                --field="Langage":CB "Python!Rust!Go" \
                --field="Créer un dépôt":CHK
            ;;
        "Configurer le projet")
            yad --info --text="Configuration en cours..."
            ;;
        "Quitter")
            exit 0
            ;;
    esac
done

Le point important est la distinction suivante :

• YAD/Zenity génèrent des dialogues prêts à l’emploi ;
• GTKDialog décrit une interface plus complète depuis XML ;
• PyGObject ou Rust/GTK te donnent réellement accès à l’arbre de widgets, aux signaux, au binding de données et à la mise à jour dynamique.

Donc, si tu te souvenais d’une commande du genre yad --form, yad --list ou yad --notebook, c’était probablement YAD. Si tu te souvenais de balises XML comme <window>, <vbox>, <button> et <entry>, c’était plutôt gtkdialog.