Libghostty 1.0: स्थिर C ABI डिज़ाइन के सबक
Libghostty 1.0 से सीखें कि स्थिर C ABI कैसे डिज़ाइन करें: opaque handles, enum-keyed setters, CI में symbol versioning और library-first आर्किटेक्चर।

कल्पना कीजिए कि आप JetBrains IDEs के अंदर मौजूद टर्मिनल की टीम में हैं। आपके emulator, JediTerm, में एक बग है — ऐसा बग जिसके लिए टर्मिनल emulators जाने जाते हैं, जहाँ कोई अजीब escape sequence गलत तरीके से render होती है और उसे दोबारा पैदा करना पागल कर देने वाला होता है। आप उसे पैच कर सकते हैं। या फिर दशकों का जमा emulation code हटाकर किसी C library से link कर सकते हैं, जिसका ABI स्थिर है और जिसे कोई और मेंटेन करता है, फज़िंग करता है और आपके लिए नौ operating systems पर पोर्ट करता है। JetBrains ने दूसरा रास्ता चुना। हर IntelliJ, PyCharm और GoLand उपयोगकर्ता — JetBrains की अपनी रिपोर्ट के अनुसार 1.25 करोड़ से ज़्यादा सक्रिय उपयोगकर्ता — अब libghostty से चलने वाला टर्मिनल इस्तेमाल करते हैं, जो इस हफ़्ते 1.0 पर पहुँची है।
यह तो मुख्य आँकड़ा है, लेकिन इसके नीचे की कहानी ज़्यादा दिलचस्प है। Libghostty, Mitchell Hashimoto के GPU-accelerated टर्मिनल Ghostty से निकाला गया terminal-emulation core है, जिसे ABI स्थिरता नीति के साथ एक स्वतंत्र C library के रूप में जारी किया गया है। एक साल पहले इसका कोई C API नहीं था और सिर्फ़ एक consumer था। आज इसका टैग किया गया 1.0 है, distribution के लिए तैयार packaging है, और adopters की सूची developer tooling की प्रमुख हस्तियों जैसी लगती है। “अंदरूनी ढाँचे वाला app” से “ऐसी library जिस पर इंडस्ट्री भरोसा करे” तक कैसे पहुँचा जाए, यह इंजीनियरिंग अनुशासन का ऐसा सबक है जो टर्मिनलों से कहीं आगे लागू होता है।
App से Library तक: libghostty कैसे अलग किया गया
टर्मिनल emulation उन समस्या-क्षेत्रों में से है जो दूर से आसान लगते हैं और पास से चुपचाप बेरहम होते हैं। दशकों के escape sequences, आपस में प्रतिस्पर्धा करते graphics protocols, Unicode grapheme clustering, resize पर scrollback reflow — हर टर्मिनल लेखक वही भूलभुलैया दोबारा खोजता है। मैंने पहले आधुनिक GPU-accelerated टर्मिनल कैसे काम करते हैं, इस पर लिखा है, TTY parsing से glyph atlases तक, और मुख्य बात यह निकलती है कि emulation layer ही वह जगह है जहाँ correctness दम तोड़ देती है। यह ठीक वैसा कोड है जिसे आप एक बार लिखना चाहते हैं, जी भरकर टेस्ट करना चाहते हैं, और साझा करना चाहते हैं।
Ghostty के लेखक को शुरू से ही यह बात समझ आ गई लगती है। एप्लिकेशन Zig में बनाया गया था, और उसका emulation core इस तरह संरचित था कि उसे अलग किया जा सके — पहले Zig module के रूप में, फिर C API के पीछे, और अब libghostty-vt 1.0 के रूप में, अपने release cycle, अपने tarballs और अपने consumers के साथ। यह निकासी कोई बाद का विचार या marketing का इशारा नहीं थी; प्रोजेक्ट ने C API बनने से एक साल पहले ही इरादा घोषित कर दिया था, और फिर वह साल उस सीमा को वास्तविक बनाने में लगाया। क्रम मायने रखता है: library को 1.0 इसलिए नहीं बनाया गया कि कोड काम करने लगा था, बल्कि तब बनाया गया जब कोड के चारों ओर का contract इतना स्थिर हो गया कि उसके बारे में वादे किए जा सकें।
Consumer सूची बताती है कि यह दांव सफल रहा। Neovim में एक approved pull request है जो libvterm की जगह libghostty-vt लाता है — यह बदलाव resize पर scrollback reflow से जुड़े दस साल पुराने issue को बंद करता है, जो बताता है कि जब हर प्रोजेक्ट अपना अलग emulator मेंटेन करता है तो ये घाव कितने लंबे समय तक खुले रहते हैं। KDE के डेवलपर इसके ऊपर Konsole के उत्तराधिकारी का prototype बना रहे हैं। Vercel का Turborepo task output render करने के लिए इसका उपयोग करता है। Antithesis ने TUI programs को fuzz करने के लिए इसका इस्तेमाल किया और btop में असली बग पकड़े। किसी ने इसके ऊपर Emacs terminal बनाया है, और एक WebAssembly build भी है जिसमें xterm.js-compatible API है। Rust, Go, JavaScript, Swift, Python, .NET, Elixir, Dart और Java के लिए community bindings मौजूद हैं।
स्थिर C ABI डिज़ाइन करना: Opaque Handles और Enum Keys
यह वह हिस्सा है जिसे आप अपने प्रोजेक्ट्स में ज़रूर अपनाना चाहेंगे। ज़्यादातर C libraries लंबी उम्र में इसलिए नहीं टिकतीं कि कोड सड़ जाता है, बल्कि इसलिए कि ABI जम जाता है: किसी struct में field जुड़ा और हर consumer को recompile करना पड़ा, function signature बदला और symbols गायब हो गए, enum बढ़ा और values खिसक गईं। Libghostty का डिज़ाइन इन तीनों से बचने का एक छोटा masterclass है, और इसकी तकनीकें पुरानी, परखी हुई और बहुत कम इस्तेमाल होने वाली हैं।
/* 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);
तीन फ़ैसले सबसे ज़्यादा काम करते हैं। पहला, हर object एक opaque handle है: callers pointers रखते हैं, structs नहीं, इसलिए library releases के बीच अपने internals को खुलकर बदल सकती है। दूसरा, सैकड़ों पढ़ने और लिखने योग्य values एक छोटे से enum-keyed getters और setters सेट के पीछे रहती हैं। नई functionality का मतलब है नया enum constant, नया exported symbol नहीं — और नए headers से build किया गया, पर पुरानी library पर चलने वाला program crash या गलत डेटा के बजाय साफ़ GHOSTTY_UNSUPPORTED नतीजा पाता है। यही एक छोटी बात सुंदर degradation और किसी और के product में 3 बजे रात के segfault के बीच का फ़र्क है।
तीसरा, जो कुछ public structs हैं, वे अपना size साथ रखते हैं, या padding रिज़र्व करते हैं, ताकि layout टूटे बिना fields जोड़े जा सकें — वही तरकीब जो sockaddr और Win32 API दशकों से इस्तेमाल कर रहे हैं। Enums हर compiler पर, जहाँ तक C standard अनुमति देता है, int पर pinned हैं, क्योंकि ऐसा enum जिसका underlying type compilers के बीच बदलता है, ABI के लिए टाइम बम है। इनमें से कुछ भी अनोखा नहीं है। यह वही चीज़ें हैं जो आप तभी करते हैं जब पहले ही दिन तय कर लें कि ABI एक product feature है, न कि मौजूदा source layout की एक दुर्घटना। यह specification और implementation के बीच के अंतर का सबसे शुद्ध रूप है: ABI ही specification है, बाकी सब पर बात हो सकती है।
- हर चीज़ के लिए opaque handles। Callers कभी layout नहीं देखते, इसलिए layout बदलने के लिए आज़ाद रहता है।
- Enum-keyed getters और setters। नई settings नए constants हैं, नए symbols नहीं — और पुरानी libraries GHOSTTY_UNSUPPORTED लौटाती हैं, crash नहीं करतीं।
- स्वयं-आकार वाले public structs। struct_size field आपको बाद में fields जोड़ने देता है; reserved padding भविष्य के लिए जगह देता है।
- Pinned enum types। Enums को int पर तय किया गया है, ताकि ABI compilers के बीच न खिसके।
- ELF पर versioned symbols। Dynamic loader गलत मेल खाती library को नाम लेकर, ज़ोर से, load time पर मना कर देता है — रहस्यमय तरीके से, runtime पर नहीं।
ABI स्थिरता को CI में लागू करना, सिर्फ़ इरादों पर नहीं
हर प्रोजेक्ट backward compatibility का दावा करता है। बहुत कम कोई किसी आम मंगलवार को इसे साबित कर सकता है। Libghostty का CI Linux पर libabigail को एक commit किए गए baseline के खिलाफ चलाता है, हर बदलाव में ABI drift जाँचता है, और macOS व WebAssembly पर golden type manifests की तुलना करता है। ELF platforms पर exported symbols versioned हैं, इसलिए loader खुद एक enforcement mechanism बन जाता है। यह वादा code review और सतर्कता से नहीं, बल्कि उन मशीनों से निभाया जाता है जो किसी इंसान की चूक पर build फेल कर देती हैं।
ABI कोई ऐसा contract नहीं है जिस पर आप एक बार दस्तखत करें। यह ऐसा वादा है जिसे आपके CI को हर एक commit पर निभाना पड़ता है।
यही वह चीज़ है जिसे मैं हर library लेखक को सबसे पहले कॉपी करने की सलाह दूँगा, किसी भी API design से पहले। Automated ABI checking सेट अप करना सस्ता है — libabigail का abidiff एक ही tool है — और यह एक धुंधले सामाजिक वादे (“हम चीज़ें तोड़ने से बचने की कोशिश करते हैं”) को एक कठोर, review हो सकने वाले artifact (“यह baseline है; यह diff है; यह बदलाव compatible है या नहीं”) में बदल देता है। Distributions यह तय करते समय कि आपकी library package करें या नहीं, और कंपनियाँ यह तय करते समय कि उसे dynamically link करें या नहीं, असल में उसी artifact का मूल्यांकन कर रही होती हैं। Neovim के maintainers merge से पहले tagged release का इंतज़ार क्यों कर रहे थे, यह कोई औपचारिकता नहीं है — distributions को एक versioned, अलग से packageable dependency चाहिए, जिसकी compatibility कहानी वे डिफ़ेंड कर सकें।

पैकेजिंग और लाइसेंसिंग: वह उबाऊ काम जो libraries को शिप करता है
किसी distribution maintainer से पूछिए कि library के मौके किस चीज़ से बिगड़ते हैं, तो वह शायद ही “कोड” कहेगा। यह वह build है जो --prefix या DESTDIR का सम्मान नहीं करता, गायब SONAME, साफ़ न होने वाले licenses वाली vendored dependencies, वह tarball जो offline build नहीं हो सकता। Libghostty 1.0 इस सबको release surface मानता है: signed source tarballs, Zig के cache layout में एक companion dependencies tarball ताकि पूरी तरह offline builds हों, उचित SONAMEs, pkg-config files, CMake package configs, और debug info डिफ़ॉल्ट रूप से रखा गया ताकि distros उसे strip कर सकें। एक PACKAGING-LIBGHOSTTY.md है जो tarball के अंदर ही शिप होती है — अंतिम उपयोगकर्ता के लिए नहीं, packager के लिए लिखी गई।
लाइसेंसिंग के साथ भी यही व्यवहार हुआ, और यह दिखने से ज़्यादा रणनीतिक है। Library MIT है, runtime पर libc के अलावा कुछ नहीं चाहिए (और इसे उसके बिना भी freestanding बनाया जा सकता है), और कुछ गिने-चुने permissively licensed dependencies को शामिल करती है — SIMD के लिए simdutf और Google Highway, एक compact Unicode table, Kitty graphics decoding के लिए Wuffs — और इन्हें libc++ के बिना बनाया गया है, इसलिए C++ standard library पर कोई निर्भरता नहीं। पूरे tree में कहीं भी zero copyleft। हर dependency एक machine-readable manifest में version, SPDX license और hash के साथ सूचीबद्ध है, खास तौर पर ताकि distros बिना पुरातत्व खोदे bundled-library metadata भर सकें। सिस्टम के simdutf या Highway को उसकी जगह dynamically link करने के लिए एक build flag भी है।
इनमें से हर चुनाव किसी खास gatekeeper की किसी खास आपत्ति को हटाता है। व्यवहार में “enterprise-ready” का असल मतलब यही है — sales page नहीं, बल्कि सैकड़ों छोटी रगड़ें पहले ही घिस दी जाएँ, इससे पहले कि किसी को पूछना पड़े। यह इस बात की भी याद दिलाता है कि अच्छे सॉफ़्टवेयर को समय क्यों लगता है: इनमें से कोई काम कठिन नहीं है, पर सब धीमा है।
पोर्टेबिलिटी और संसाधन अनुशासन को API वादों के रूप में
परीक्षित platform matrix में Linux (glibc और musl), macOS, iOS, FreeBSD, Windows, Android और freestanding WebAssembly शामिल हैं, और दूसरा स्तर — bare-metal RISC-V और ARM thumb, WASI, Windows ARM64, illumos, 32-bit x86 — जो CI में build होता है पर अभी tests नहीं चलाता। हर platform को उसके ecosystem की अपेक्षित artifacts मिलती हैं: Apple के लिए @rpath वाली dylibs और XCFrameworks, Windows के लिए PDB और import library के साथ DLL (MSVC linking CI में verified), Android 15+ के लिए 16 KB page size वाला Android build, और सभी features चालू होने पर एक megabyte से कम का WASM module — search, selection और Kitty graphics जैसे subsystems हटाकर इसे आधा किया जा सकता है, और हर function फिर भी exported रहता है और GHOSTTY_UNSUPPORTED लौटाता है, ताकि embedder का कोड कभी बदलना न पड़े।
पर पोर्टेबिलिटी की जो कहानी मैं बार-बार लौटकर देखता हूँ, वह व्यवहार से जुड़ी है। Library कोई thread नहीं बनाती। यह सिर्फ़ उस allocator के ज़रिए allocate करती है जो आप देते हैं। लेखक बताते हैं कि उन्होंने 4-core, 8 GB वाले Linux server पर 10,000 live terminals चलाए, हर एक में असली shell चल रहा था और आउटपुट दे रहा था — और बाधा library नहीं, bash की memory भूख निकली; shells को RAM में फिट करने के लिए उन्हें dash पर जाना पड़ा, जबकि libghostty-vt आराम से चलती रही। “हम threads नहीं बनाते” और “हम आपका allocator नहीं लेते” उतने ही असली API वादे हैं जितना कोई function signature, और यही वे चीज़ें हैं जो library को ऐसे संदर्भों में embeddable बनाती हैं — game engines, embedded devices, fuzzing harnesses, दूसरों के event loops — जहाँ thread-happy dependency एक dealbreaker होती।
Libghostty हमें library-first architecture के बारे में क्या सिखाती है
स्पष्ट तुलना libvte से होती है, वह GTK से जुड़ी emulation library जो GNOME Terminal, XFCE के terminal और आधा दर्जन दूसरों के नीचे है। Libvte ने सालों पहले इस मॉडल को साबित किया — एक साझा core, कई पतले wrappers — पर उसकी GTK कप्लिंग ने उसकी दुनिया को एक खास toolkit वाले Linux desktops तक सीमित कर दिया। Libghostty का दांव है कि वही मॉडल, किसी UI toolkit से अलग होकर और एक स्थिर C ABI में पक्का होकर, कहीं ज़्यादा दूर तक जाता है: Java में लिखी IDEs, C में लिखे editors, Go में लिखे TUIs, WASM के ज़रिए browsers, और ऐसे commercial products में जो कभी GTK dependency शिप नहीं कर सकते थे। शुरुआती सबूत बताते हैं कि दांव सही है। libghostty से चलने वाला टर्मिनल इस्तेमाल करने वाले लोग अब खुद Ghostty इस्तेमाल करने वालों से कई गुना ज़्यादा हैं।
गहरा सबक क्रम (sequencing) का है। Library-first architecture का मतलब यह नहीं कि उपयोग का मामला होने से पहले library लिख दी जाए — इसी तरह ऐसे सुंदर abstractions बनते हैं जिनकी किसी को ज़रूरत नहीं होती। Ghostty ने उल्टा किया: एक असली application बनाया, production के दबाव में domain की सीमाओं को उभरने दिया, और फिर उस seam को पक्का किया जिसे वह शुरू से संभाल रहा था। C API देर से आया, और ठीक इसी वजह से साफ़ आया। अगर आप किसी ऐसे application पर बैठे हैं जिसका कोई सच में कठिन, दोबारा इस्तेमाल होने वाला core है — parser, emulator, layout engine, protocol stack — तो playbook यहाँ साफ़ दिखती है: शुरू से सीमा को ईमानदार रखें, उसे सबसे संकरे संभव contract के ज़रिए expose करें, ABI को CI की निगरानी में रखें, और packaging की उबाऊ मेहनत पूरे मन से करें। इसके बाद ecosystem के असर जुड़ते जाते हैं। एक embedder का रिपोर्ट किया हर bug बाकी हर consumer का टर्मिनल बेहतर बनाता है, और हर नया protocol एक साथ हर जगह पहुँचता है, न कि एक दर्जन निजी forks में बिखर जाता है।
Hashimoto का दावा है कि अब आप लगभग 1,500 lines of C में ऐसा टर्मिनल बना सकते हैं जो एक साल पहले मौजूद लगभग किसी भी चीज़ से ज़्यादा features रखता हो। यह ऐसा वाक्य है जिसे मैं आम तौर पर maintainer के उत्साह में डाल देता — सिवाय इसके कि सौ से ज़्यादा ट्रैक किए गए प्रोजेक्ट और पूरा JetBrains IDE बेड़ा बताते हैं कि यह दावा वास्तविकता की कसौटी पर टिकता है। हर application का अपना terminal emulator हाथ से लिखने का दौर शायद अब खत्म हो रहा है, और वह उसी तरह खत्म हो रहा है जैसे ऐसी चीज़ें आम तौर पर खत्म होती हैं: किसी बेहतर application से नहीं, बल्कि एक बेहतर library से।


