Des articles approfondis sur les technologies qui façonnent l'avenir.

Libghostty 1.0 : leçons sur une ABI C stable

Libghostty 1.0 montre comment concevoir une ABI C stable : handles opaques, setters par enum, versioning des symboles en CI.

Illustration d'un noyau lumineux partagé alimentant plusieurs écrans de type terminal reliés par des fils de lumière.
Un seul cœur d'émulation, plusieurs visages : libghostty équipe désormais IDE, éditeurs, TUI et nouveaux terminaux.

Imaginez que vous faites partie de l'équipe qui gère le terminal intégré aux IDE JetBrains. Votre émulateur, JediTerm, a un bug, du genre que les émulateurs de terminal adorent, où une séquence d'échappement obscure s'affiche mal d'une façon exaspérante à reproduire. Vous pourriez le corriger. Ou bien supprimer une décennie de code d'émulation accumulé et lier une bibliothèque C à ABI stable, maintenue, fuzzée et portée sur neuf systèmes d'exploitation par quelqu'un d'autre. JetBrains a choisi la seconde option. Chaque utilisateur d'IntelliJ, PyCharm et GoLand, soit plus de 12,5 millions d'utilisateurs actifs selon JetBrains, utilise désormais un terminal propulsé par libghostty, qui a atteint la version 1.0 cette semaine.

C'est le chiffre qui fait la une, mais l'histoire la plus intéressante se cache derrière. Libghostty est le cœur d'émulation de terminal extrait de Ghostty, le terminal accéléré par GPU de Mitchell Hashimoto, et publié sous forme de bibliothèque C autonome avec une politique de stabilité de l'ABI appliquée. Il y a un an, elle n'avait aucune API C et un seul consommateur. Aujourd'hui, elle dispose d'une version 1.0 étiquetée, d'un packaging prêt à être distribué et d'une liste d'adoptions digne du « qui est qui » des outils pour développeurs. Passer de « application avec des entrailles » à « bibliothèque en laquelle l'industrie a confiance » est une leçon de discipline d'ingénierie qui dépasse largement le monde des terminaux.

De l'application à la bibliothèque : comment libghostty a été extrait

L'émulation de terminal est un de ces domaines qui paraissent simples de loin et qui sont discrètement brutaux de près. Des décennies de séquences d'échappement, de protocoles graphiques concurrents, de regroupement de graphèmes Unicode, de reflow du scrollback au redimensionnement : chaque auteur de terminal redécouvre le même champ de mines. J'ai déjà écrit sur le fonctionnement des terminaux modernes accélérés par GPU, du parsing TTY aux atlas de glyphes, et le fil conducteur est toujours le même : c'est dans la couche d'émulation que la correction va mourir. C'est exactement le genre de code qu'on veut écrire une fois, tester à mort et partager.

L'auteur de Ghostty semble l'avoir compris dès le départ. L'application a été écrite en Zig, avec un cœur d'émulation structuré pour pouvoir être séparé : d'abord comme module Zig, puis derrière une API C, et maintenant sous forme de libghostty-vt 1.0 avec son propre cycle de release, ses propres archives et ses propres consommateurs. L'extraction n'était ni une réflexion après coup ni un coup de com' ; le projet a annoncé son intention plus d'un an avant que l'API C n'existe, puis a passé cette année à rendre la frontière réelle. L'ordre des opérations compte : la bibliothèque n'a pas été promue en 1.0 quand le code fonctionnait, mais quand le contrat autour du code était assez stable pour qu'on puisse s'engager dessus.

La liste des consommateurs suggère que le pari a payé. Neovim a une pull request approuvée qui remplace libvterm par libghostty-vt, un changement qui ferme un ticket vieux de dix ans sur le reflow du scrollback au redimensionnement, ce qui en dit long sur la durée de vie de ces plaies quand chaque projet maintient son propre émulateur. Les développeurs de KDE prototypent un successeur de Konsole basé dessus. Le Turborepo de Vercel l'utilise pour afficher la sortie des tâches. Antithesis l'a utilisé pour fuzzer des programmes TUI et a mis au jour de vrais bugs dans btop. Quelqu'un a construit un terminal Emacs dessus, et il existe un build WebAssembly avec une API compatible xterm.js. Des bindings communautaires existent pour Rust, Go, JavaScript, Swift, Python, .NET, Elixir, Dart et Java.

Concevoir une ABI C stable : handles opaques et clés enum

Voici la partie à piquer pour vos propres projets. La plupart des bibliothèques C ne vieillissent mal non pas parce que le code pourrit, mais parce que l'ABI se fige : une structure gagne un champ et tous les consommateurs doivent recompiler, une signature de fonction change et les symboles disparaissent, une énumération grandit et ses valeurs se décalent. La conception de libghostty est une courte leçon de magistère pour éviter les trois, et les techniques sont anciennes, éprouvées et chroniquement sous-utilisées.

/* The clunky way: the struct IS the ABI.
* Add a field and every consumer recompiles or corrupts memory. */
typedef struct {
int rows;
int cols;
int scrollback_limit;
/* ... forty more fields your ABI now depends on forever */
} term_config_t;
/* The libghostty way: an opaque handle plus enum-keyed access.
* The library can add a hundred new settings without one new symbol. */
typedef struct ghostty_terminal_s ghostty_terminal_t;
typedef enum {
GHOSTTY_TERMINAL_ROWS,
GHOSTTY_TERMINAL_COLS,
GHOSTTY_TERMINAL_SCROLLBACK_LIMIT,
/* new keys append here, forever */
} ghostty_terminal_key_t;
ghostty_result_t ghostty_terminal_get(
const ghostty_terminal_t *terminal,
ghostty_terminal_key_t key,
void *out);
ghostty_result_t ghostty_terminal_set(
ghostty_terminal_t *terminal,
ghostty_terminal_key_t key,
const void *value);

Trois décisions font le gros du travail. Premièrement, chaque objet est un handle opaque : les appelants manipulent des pointeurs, jamais des structures, si bien que la bibliothèque peut remodeler ses entrailles librement entre deux versions. Deuxièmement, les centaines de valeurs lisibles et modifiables passent par un petit ensemble de getters et setters indexés par enum. Une nouvelle fonctionnalité signifie une nouvelle constante d'enum, pas un nouveau symbole exporté, et un programme compilé avec des headers récents mais exécuté avec une bibliothèque plus ancienne obtient un résultat propre GHOSTTY_UNSUPPORTED au lieu d'un crash ou de données corrompues en silence. Ce détail fait toute la différence entre une dégradation gracieuse et un segfault à 3 h du matin dans le produit de quelqu'un d'autre.

Troisièmement, les quelques structures publiques portent leur propre taille ou réservent du padding, afin que des champs puissent être ajoutés sans casser la disposition en mémoire, la même astuce qu'utilisent sockaddr et l'API Win32 depuis des décennies. Les enums sont fixées à int sur tous les compilateurs, dans la mesure où la norme C le permet, parce qu'un enum dont le type sous-jacent varie d'un compilateur à l'autre est une bombe à retardement pour l'ABI. Rien de tout cela n'est exotique. Tout cela est le genre de chose qu'on ne fait que si l'on décide, dès le premier jour, que l'ABI est une fonctionnalité produit et non un accident de la disposition actuelle du code source. C'est l'écart entre spécification et implémentation dans sa forme la plus pure : l'ABI est la spécification, et tout le reste est négociable.

  • Des handles opaques pour tout. Les appelants ne voient jamais la disposition, donc elle peut changer librement.
  • Getters et setters indexés par enum. Les nouveaux réglages sont de nouvelles constantes, pas de nouveaux symboles, et les anciennes bibliothèques répondent GHOSTTY_UNSUPPORTED au lieu de planter.
  • Structures publiques auto-dimensionnées. Un champ struct_size permet d'ajouter des champs plus tard ; le padding réservé ménage de la place pour l'avenir.
  • Types enum figés. Les enums sont fixées à int pour que l'ABI ne varie pas d'un compilateur à l'autre.
  • Symboles versionnés sur ELF. Le chargeur dynamique refuse une bibliothèque incompatible en la nommant, bruyamment, au chargement, et non de façon mystérieuse, à l'exécution.

Faire respecter la stabilité de l'ABI en CI, pas à coups de bonnes intentions

Chaque projet affirme être rétrocompatible. Presque aucun ne peut le prouver un mardi quelconque. La CI de libghostty exécute libabigail contre une baseline versionnée sous Linux, vérifie chaque modification pour détecter toute dérive de l'ABI, et compare des manifestes de types de référence sur macOS et WebAssembly. Les symboles exportés sur les plateformes ELF sont versionnés, si bien que le chargeur lui-même devient un mécanisme d'application. La promesse ne repose pas sur la revue de code et la vigilance ; elle est tenue par des machines qui font échouer le build dès qu'un humain flanche.

Une ABI n'est pas un contrat qu'on signe une fois. C'est une promesse que votre CI doit tenir à chaque commit.

C'est le point que j'exhorterais chaque auteur de bibliothèque à copier en premier, avant toute conception d'API. La vérification automatique de l'ABI est peu coûteuse à mettre en place (abidiff de libabigail est un seul outil) et elle transforme une promesse sociale floue (« on essaie de ne rien casser ») en un artefact précis et relisible (« voici la baseline, voici le diff, ce changement est ou n'est pas compatible »). Les distributions qui décident de packager votre bibliothèque, et les entreprises qui décident de la lier dynamiquement, évaluent en réalité cet artefact. Si les mainteneurs de Neovim attendaient une release étiquetée avant de merger, ce n'est pas de la cérémonie : les distributions ont besoin d'une dépendance versionnée, packageable séparément, avec une histoire de compatibilité qu'elles peuvent défendre.

Une figure de sentinelle mesurant un pont de pierre à son entrée, le vérifiant avant de laisser passer.
Stabilité de l'ABI appliquée comme un point de contrôle : chaque modification est mesurée par rapport à la baseline avant de passer.

Packaging et licence : le travail ingrat qui livre les bibliothèques

Demandez à n'importe quel mainteneur de distribution ce qui tue les chances d'une bibliothèque et il ne parlera que rarement du « code ». Ce sont les builds qui ignorent --prefix ou DESTDIR, le SONAME manquant, les dépendances vendorisées aux licences floues, l'archive qui ne peut pas se construire hors ligne. Libghostty 1.0 traite tout cela comme une surface de release : archives source signées, archive de dépendances complémentaire dans le format de cache de Zig pour des builds entièrement hors ligne, SONAME appropriés, fichiers pkg-config, configurations de paquet CMake, informations de débogage conservées par défaut pour que les distributions puissent les retirer. On trouve un PACKAGING-LIBGHOSTTY.md livré dans l'archive, écrit pour l'empaqueteur et non pour l'utilisateur final.

La licence a reçu le même soin, et c'est plus stratégique qu'il n'y paraît. La bibliothèque est sous MIT, n'a besoin de rien d'autre que libc à l'exécution (et peut même être compilée en freestanding, sans libc du tout), et embarque une poignée de dépendances permissives : simdutf et Google Highway pour le SIMD, une table Unicode compacte, Wuffs pour le décodage des graphismes Kitty. Elle est compilée sans libc++, donc sans dépendance à la bibliothèque standard C++. Aucun copyleft dans l'arbre. Chaque dépendance figure dans un manifeste lisible par machine, avec version, licence SPDX et hash, précisément pour que les distributions puissent renseigner les métadonnées des bibliothèques embarquées sans archéologie. Il existe même un drapeau de build pour lier dynamiquement la simdutf ou Highway du système à la place.

Chacun de ces choix supprime une objection précise qu'un gardien précis aurait soulevée. C'est ce que signifie concrètement « prêt pour l'entreprise » : pas une page de vente, mais une centaine de petites frictions poncées avant même que quelqu'un ait à le demander. C'est aussi un rappel de pourquoi un excellent logiciel demande du temps : aucun de ces travaux n'est difficile, et tous sont lents.

Portabilité et discipline des ressources comme promesses d'API

La matrice de plateformes testées couvre Linux (glibc et musl), macOS, iOS, FreeBSD, Windows, Android et WebAssembly freestanding, avec un second niveau (RISC-V et ARM thumb bare-metal, WASI, Windows ARM64, illumos, x86 32 bits) qui se compile en CI mais n'exécute pas encore de tests. Chaque plateforme reçoit les artefacts attendus par son écosystème : dylibs avec @rpath et XCFrameworks pour Apple, une DLL avec PDB et bibliothèque d'import pour Windows (édition de liens MSVC vérifiée en CI), un build Android avec une taille de page de 16 Ko pour Android 15 et plus, et un module WASM de moins d'un mégaoctet avec toutes les fonctionnalités activées. Ce module est réductible en excluant des sous-systèmes comme la recherche, la sélection et les graphismes Kitty, tout en exportant toujours chaque fonction et en renvoyant GHOSTTY_UNSUPPORTED pour que le code de l'hôte n'ait jamais à changer.

Mais l'argument de portabilité auquel je reviens sans cesse est comportemental. La bibliothèque ne crée aucun thread. Elle n'alloue qu'à travers un allocateur que vous fournissez. L'auteur rapporte avoir fait tourner 10 000 terminaux en direct, chacun pilotant un vrai shell qui produit de la sortie, sur un serveur Linux à 4 cœurs et 8 Go de RAM. Il note que le goulot d'étranglement était la gourmandise en mémoire de bash, et non la bibliothèque : il a dû passer à dash pour faire tenir les shells en RAM pendant que libghostty-vt tournait tranquillement. « Nous ne créons pas de threads » et « nous ne possédons pas votre allocateur » sont des promesses d'API aussi concrètes que n'importe quelle signature de fonction, et ce sont elles qui rendent une bibliothèque embarquable dans des contextes (moteurs de jeu, appareils embarqués, harnais de fuzzing, boucles d'événements d'autrui) où une dépendance trop gourmande en threads serait rédhibitoire.

Ce que libghostty enseigne sur l'architecture library-first

La comparaison évidente est libvte, la bibliothèque d'émulation liée à GTK sous GNOME Terminal, le terminal de XFCE et une demi-douzaine d'autres. libvte a prouvé le modèle il y a des années (un cœur partagé, de nombreux wrappers fins), mais son couplage avec GTK a restreint son univers aux bureaux Linux utilisant une boîte à outils précise. Le pari de libghostty est que le même modèle, découplé de toute boîte à outils d'interface et durci en une ABI C stable, voyage bien plus loin : vers les IDE écrits en Java, les éditeurs écrits en C, les TUI écrites en Go, les navigateurs via WASM, et les produits commerciaux qui ne pourraient jamais embarquer une dépendance GTK. Les premiers signes lui donnent raison. Plus de gens utilisent déjà un terminal propulsé par libghostty que Ghostty lui-même, et ce, d'un facteur important.

La leçon la plus profonde porte sur le séquençage. L'architecture library-first ne signifie pas écrire une bibliothèque avant d'avoir un cas d'usage, car c'est ainsi qu'on obtient de belles abstractions dont personne n'a besoin. Ghostty a fait l'inverse : il a construit une vraie application, laissé les frontières du domaine émerger sous la pression de la production, puis durci la jointure qu'il entretenait depuis le début. L'API C est arrivée tard, et c'est précisément pour cela qu'elle est arrivée propre. Si vous êtes assis sur une application dotée d'un cœur réutilisable et vraiment difficile (un parseur, un émulateur, un moteur de mise en page, une pile de protocoles), la méthode est visible ici : garder la frontière honnête dès le départ, l'exposer via le contrat le plus étroit possible, placer l'ABI sous surveillance CI, et faire le travail d'empaquetage ingrat avec sérieux. Les effets sur l'écosystème s'accumulent ensuite. Chaque bug signalé par un intégrateur améliore le terminal de tous les autres consommateurs, et chaque nouveau protocole arrive partout en même temps au lieu de se fragmenter entre une douzaine de forks privés.

Hashimoto affirme qu'on peut aujourd'hui construire un terminal en environ 1 500 lignes de C qui dépasse en fonctionnalités à peu près tout ce qui existait il y a un an. D'habitude, je classerais ce genre de phrase dans l'enthousiasme de mainteneur, sauf qu'une centaine de projets suivis et toute la flotte d'IDE JetBrains laissent penser que l'affirmation résiste au contact de la réalité. L'ère où chaque application codait à la main son propre émulateur de terminal est peut-être en train de s'achever, et elle s'achève comme ces choses finissent d'habitude : non pas avec une meilleure application, mais avec une meilleure bibliothèque.