Artikel mendalam tentang teknologi yang membentuk masa depan.

Libghostty 1.0: Pelajaran Desain C ABI yang Stabil

Libghostty 1.0 menunjukkan cara mendesain C ABI yang stabil lewat opaque handle, setter berbasis enum, dan versi simbol yang dijaga CI.

Ilustrasi satu inti bercahaya yang menggerakkan banyak layar bergaya terminal berbeda, terhubung oleh untaian cahaya.
Satu inti emulasi, banyak wajah: libghostty kini hadir di IDE, editor, TUI, dan terminal baru sekaligus.

Bayangkan kamu berada di tim yang memegang terminal di dalam IDE JetBrains. Emulator kamu, JediTerm, punya bug, jenis bug yang memang jadi keahlian emulator terminal, di mana sebuah escape sequence yang obskur tampil salah dan bikin frustrasi saat mau direproduksi. Kamu bisa menambalnya. Atau kamu bisa membuang kode emulasi bertahun-tahun dan menautkan ke pustaka C dengan ABI stabil yang dipelihara, di-fuzz, dan di-porting ke sembilan sistem operasi oleh pihak lain. JetBrains memilih opsi kedua. Setiap pengguna IntelliJ, PyCharm, dan GoLand, lebih dari 12,5 juta pengguna aktif menurut laporan JetBrains sendiri, kini menjalankan terminal yang ditenagai libghostty, yang baru saja merilis versi 1.0 minggu ini.

Itu angka utamanya, tapi cerita yang lebih menarik ada di baliknya. Libghostty adalah inti emulasi terminal yang dipisahkan dari Ghostty, terminal GPU-accelerated buatan Mitchell Hashimoto, lalu dirilis sebagai pustaka C mandiri dengan kebijakan stabilitas ABI yang ditegakkan. Setahun lalu, ia belum punya API C dan hanya punya satu konsumen. Sekarang ia punya versi 1.0 yang di-tag, paket yang siap didistribusikan, dan daftar adopsi yang seperti daftar tokoh penting di dunia developer tooling. Cara sebuah proyek berpindah dari "aplikasi dengan internal" menjadi "library yang dipercaya industri" adalah pelajaran disiplin rekayasa yang berlaku jauh melampaui terminal.

Dari Aplikasi ke Library: Bagaimana libghostty Dipisahkan

Emulasi terminal adalah salah satu domain yang dari jauh kelihatan gampang tapi diam-diam brutal begitu kamu masuk ke dalamnya. Puluhan tahun escape sequence, protokol grafis yang saling bersaing, grapheme clustering Unicode, reflow scrollback saat ukuran berubah, setiap penulis terminal akhirnya menemukan ranjau yang sama. Saya pernah menulis tentang cara kerja terminal GPU-accelerated modern, dari parsing TTY sampai glyph atlas, dan tema yang konsisten adalah lapisan emulasi itulah tempat kebenaran menemui ajalnya. Ini persis jenis kode yang ingin kamu tulis sekali, uji sampai habis, lalu bagikan.

Penulis Ghostty tampaknya sudah memahami ini sejak awal. Aplikasinya dibangun dengan Zig, dengan inti emulasi yang disusun supaya bisa dipisahkan: mula-mula sebagai modul Zig, lalu di balik API C, dan sekarang sebagai libghostty-vt 1.0 dengan siklus rilisnya sendiri, tarball-nya sendiri, dan konsumennya sendiri. Ekstraksinya bukan pikiran belakangan atau gestur pemasaran; proyek ini mengumumkan niatnya lebih dari setahun sebelum API C ada, lalu menghabiskan setahun itu untuk membuat batasnya nyata. Urutan kerjanya penting: library ini tidak dinaikkan ke 1.0 saat kodenya sudah berfungsi, tapi saat kontrak di sekitar kodenya cukup stabil untuk dijanjikan sesuatu.

Daftar konsumennya menunjukkan taruhannya terbayar. Neovim punya pull request yang sudah disetujui untuk mengganti libvterm dengan libghostty-vt, perubahan yang menutup isu berumur sepuluh tahun soal reflow scrollback saat ukuran berubah. Itu menunjukkan betapa lamanya luka seperti ini terbuka ketika setiap proyek memelihara emulatornya sendiri. Pengembang KDE sedang membuat prototipe penerus Konsole di atasnya. Turborepo milik Vercel memakainya untuk merender output task. Antithesis memakainya untuk melakukan fuzzing program TUI dan menemukan bug nyata di btop. Ada yang membuat terminal Emacs di atasnya, dan ada build WebAssembly dengan API yang kompatibel dengan xterm.js. Binding dari komunitas tersedia untuk Rust, Go, JavaScript, Swift, Python, .NET, Elixir, Dart, dan Java.

Mendesain C ABI yang Stabil: Opaque Handle dan Kunci Enum

Ini bagian yang layak kamu contoh untuk proyekmu sendiri. Kebanyakan pustaka C gagal bertahan bukan karena kodenya membusuk, tapi karena ABI-nya mengeras: sebuah struct mendapat field baru dan semua konsumen harus dikompilasi ulang, tanda tangan fungsi berubah dan simbol hilang, enum bertambah dan nilainya bergeser. Desain libghostty adalah masterclass singkat dalam menghindari ketiganya, dan tekniknya sudah lama, teruji, dan kronis kurang dipakai.

/* 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);

Ada tiga keputusan yang mengerjakan sebagian besar beban. Pertama, setiap objek adalah opaque handle: pemanggil memegang pointer, bukan struct, sehingga library bebas mengubah internalnya antar rilis. Kedua, ratusan nilai yang bisa dibaca dan ditulis berada di balik sekumpulan kecil getter dan setter berbasis enum. Fungsionalitas baru berarti konstanta enum baru, bukan simbol ekspor baru. Program yang dibangun dengan header yang lebih baru tapi berjalan dengan library yang lebih lama akan mendapat hasil GHOSTTY_UNSUPPORTED yang bersih, bukan crash atau data sampah diam-diam. Detail kecil itu adalah perbedaan antara degradasi yang elegan dan segfault jam 3 pagi di produk orang lain.

Ketiga, beberapa struct publik yang memang ada membawa ukurannya sendiri atau menyisakan padding, sehingga field bisa ditambahkan tanpa merusak layout, trik yang sama dipakai sockaddr dan Win32 API selama puluhan tahun. Enum dipatok ke int di setiap compiler, sejauh standar C memungkinkan, karena enum yang tipe dasarnya bergeser antar compiler adalah bom waktu ABI. Tidak ada satu pun dari ini yang eksotis. Semuanya adalah hal yang hanya kamu lakukan jika sejak hari pertama kamu memutuskan bahwa ABI adalah fitur produk, bukan kecelakaan dari tata letak kode saat ini. Ini adalah kesenjangan spesifikasi-implementasi dalam bentuk paling murninya: ABI adalah spesifikasinya, dan segala hal lainnya bisa dinegosiasikan.

  • Opaque handle untuk semuanya. Pemanggil tidak pernah melihat layout, jadi layout bebas berubah.
  • Getter dan setter berbasis enum. Setelan baru berarti konstanta baru, bukan simbol baru, dan library lama menjawab GHOSTTY_UNSUPPORTED alih-alih crash.
  • Struct publik yang mengatur ukurannya sendiri. Field struct_size memungkinkan kamu menambahkan field nanti, dan padding cadangan memberi ruang untuk masa depan.
  • Tipe enum yang dipatok. Enum dikunci ke int supaya ABI tidak bergeser antar compiler.
  • Simbol berversi di ELF. Dynamic loader menolak library yang tidak cocok dengan menyebut namanya, dengan jelas, saat load, bukan secara misterius saat runtime.

Menegakkan Stabilitas ABI di CI, Bukan Lewat Niat Baik

Setiap proyek mengklaim kompatibilitas mundur. Hampir tidak ada yang bisa membuktikannya pada hari Selasa biasa. CI libghostty menjalankan libabigail terhadap baseline yang sudah di-commit di Linux, memeriksa setiap perubahan untuk mencari drift ABI, dan membandingkan golden type manifest di macOS dan WebAssembly. Simbol ekspor di platform ELF diberi versi, sehingga loader itu sendiri menjadi mekanisme penegakan. Janjinya tidak dijaga oleh code review dan kewaspadaan; ia dijaga oleh mesin yang menggagalkan build ketika manusia lalai.

ABI bukan kontrak yang ditandatangani sekali lalu selesai. Ia adalah janji yang harus dijaga CI kamu di setiap commit.

Ini bagian yang paling saya desak agar setiap penulis library salin lebih dulu, sebelum desain API apa pun. Pemeriksaan ABI otomatis itu murah untuk disiapkan, abidiff dari libabigail hanya satu alat, dan ia mengubah janji sosial yang kabur ("kami berusaha tidak merusak apa pun") menjadi artefak yang keras dan bisa ditinjau ("ini baseline-nya; ini diff-nya; perubahan ini kompatibel atau tidak"). Distribusi yang memutuskan apakah akan mengemas library kamu, dan perusahaan yang memutuskan apakah akan menautkannya secara dinamis, sebenarnya sedang menilai artefak itu. Alasan para maintainer Neovim menunggu rilis yang di-tag sebelum merge bukan sekadar seremoni, melainkan karena distribusi butuh dependensi yang berversi, bisa dikemas terpisah, dan punya cerita kompatibilitas yang bisa mereka pertanggungjawabkan.

Sebuah figur penjaga yang mengukur jembatan batu di gerbang masuknya, memeriksanya sebelum mengizinkan lewat.
Stabilitas ABI ditegakkan seperti pos pemeriksaan: setiap perubahan diukur terhadap baseline sebelum melewati gerbang.

Packaging dan Lisensi: Pekerjaan Membosankan yang Membuat Library Benar-Benar Dikirim

Tanyakan kepada maintainer distribusi mana yang menggagalkan peluang sebuah library, dan jarang ada yang bilang "kodenya". Yang sering adalah build yang tidak menghormati --prefix atau DESTDIR, SONAME yang hilang, dependensi vendored dengan lisensi tidak jelas, atau tarball yang tidak bisa dibangun offline. Libghostty 1.0 memperlakukan semua ini sebagai permukaan rilis: tarball sumber yang ditandatangani, tarball dependensi pendamping dengan layout cache Zig untuk build offline penuh, SONAME yang benar, file pkg-config, konfigurasi paket CMake, dan debug info yang disimpan secara default supaya distro bisa menghapusnya. Ada PACKAGING-LIBGHOSTTY.md yang ikut dikirim di dalam tarball, ditulis untuk packager, bukan untuk pengguna akhir.

Lisensi mendapat perlakuan yang sama, dan lebih strategis daripada kelihatannya. Library ini berlisensi MIT, tidak butuh apa pun selain libc saat runtime (dan bisa dibangun freestanding tanpa bahkan itu), dan menyertakan beberapa dependensi berlisensi permisif: simdutf dan Google Highway untuk SIMD, tabel Unicode yang ringkas, Wuffs untuk decoding grafik Kitty, semuanya dibangun tanpa libc++ sehingga tidak ada dependensi ke library standar C++. Tidak ada copyleft sama sekali di dalam tree. Setiap dependensi tercantum dalam manifest yang bisa dibaca mesin, lengkap dengan versi, SPDX license, dan hash, khusus supaya distro bisa mengisi metadata library bundel tanpa harus menggali-gali. Ada juga flag build untuk menautkan simdutf atau Highway milik sistem secara dinamis.

Setiap pilihan itu menghapus keberatan spesifik dari gatekeeper spesifik. Begitulah "siap untuk enterprise" sebenarnya bekerja dalam praktik: bukan halaman penjualan, tapi ratusan gesekan kecil yang sudah dihaluskan sebelum ada yang perlu bertanya. Ini juga pengingat mengapa perangkat lunak yang bagus butuh waktu: tidak ada pekerjaan ini yang sulit, tapi semuanya lambat.

Portabilitas dan Disiplin Sumber Daya sebagai Janji API

Matriks platform yang diuji mencakup Linux (glibc dan musl), macOS, iOS, FreeBSD, Windows, Android, dan WebAssembly freestanding, dengan tingkat kedua yang mencakup RISC-V dan ARM thumb bare-metal, WASI, Windows ARM64, illumos, dan x86 32-bit. Tingkat kedua ini dibangun di CI tapi belum menjalankan tes. Setiap platform mendapat artefak yang diharapkan ekosistemnya: dylib dengan @rpath dan XCFramework untuk Apple, DLL dengan PDB dan import library untuk Windows (linking MSVC diverifikasi di CI), build Android dengan ukuran halaman 16 KB untuk Android 15+, dan modul WASM di bawah satu megabyte dengan semua fitur aktif. Ukurannya bisa dipangkas dengan mengeluarkan subsistem seperti pencarian, seleksi, dan grafik Kitty, dengan setiap fungsi tetap diekspor dan mengembalikan GHOSTTY_UNSUPPORTED sehingga kode embedder tidak perlu berubah.

Tapi cerita portabilitas yang terus saya pikirkan adalah sisi perilakunya. Library ini tidak membuat thread. Ia hanya mengalokasikan memori lewat allocator yang kamu sediakan. Penulisnya melaporkan menjalankan 10.000 terminal aktif, masing-masing menjalankan shell sungguhan yang menghasilkan output, di server Linux 4-core dengan RAM 8 GB, dan mencatat bahwa bottleneck-nya adalah nafsu memori bash, bukan library-nya; ia harus beralih ke dash agar shell muat di RAM sementara libghostty-vt berjalan lancar. "Kami tidak membuat thread" dan "kami tidak memiliki allocator kamu" adalah janji API senyata tanda tangan fungsi apa pun, dan janji itulah yang membuat library bisa di-embed di konteks seperti game engine, perangkat embedded, fuzzing harness, dan event loop milik orang lain, tempat dependensi yang gemar membuat thread akan menjadi penghalang.

Pelajaran dari libghostty tentang Arsitektur Library-First

Perbandingan yang paling jelas adalah libvte, library emulasi berbasis GTK di bawah GNOME Terminal, terminal XFCE, dan beberapa lainnya. libvte membuktikan model ini bertahun-tahun lalu, yaitu satu inti bersama dengan banyak wrapper tipis, tapi keterikatannya pada GTK mempersempit dunianya menjadi desktop Linux dengan toolkit tertentu. Taruhan libghostty adalah bahwa model yang sama, dilepaskan dari toolkit UI apa pun dan diperkeras menjadi ABI C yang stabil, bisa menjangkau jauh lebih jauh: ke IDE yang ditulis dengan Java, editor yang ditulis dengan C, TUI yang ditulis dengan Go, browser lewat WASM, dan produk komersial yang tidak akan pernah bisa mengirim dependensi GTK. Bukti awalnya menunjukkan taruhan ini tepat. Lebih banyak orang sudah memakai terminal bertenaga libghostty daripada memakai Ghostty itu sendiri, dengan selisih yang besar.

Pelajaran yang lebih dalam menyangkut urutan kerja. Arsitektur library-first bukan berarti menulis library sebelum punya kasus penggunaan, karena itu cara membuat abstraksi indah yang tidak dibutuhkan siapa pun. Ghostty melakukan kebalikannya: membangun aplikasi nyata, membiarkan batas domain muncul di bawah tekanan produksi, lalu memperkeras sambungan yang sudah dipelihara sejak awal. API C datang terlambat, dan justru itu sebabnya ia datang dengan bersih. Jika kamu punya aplikasi dengan inti yang sulit dan bisa dipakai ulang, seperti parser, emulator, layout engine, atau protocol stack, pola kerjanya terlihat jelas di sini: jaga batasnya tetap jujur sejak awal, ekspos lewat kontrak yang sesempit mungkin, pantau ABI dengan CI, dan kerjakan pekerjaan packaging yang membosankan itu dengan serius. Efek ekosistemnya akan berlipat dari sana. Setiap bug yang dilaporkan satu embedder membuat terminal semua konsumen lain lebih baik, dan setiap protokol baru mendarat di semua tempat sekaligus, alih-alih terpecah di belasan fork privat.

Hashimoto mengklaim kamu sekarang bisa membangun terminal dalam sekitar 1.500 baris C yang fiturnya mengalahkan hampir semua yang ada setahun lalu. Biasanya saya akan menganggap kalimat seperti itu sebagai antusiasme maintainer, tapi lebih dari seratus proyek yang terlacak dan seluruh armada IDE JetBrains menunjukkan klaim itu bertahan saat berhadapan dengan kenyataan. Era ketika setiap aplikasi menulis emulator terminalnya sendiri mungkin akhirnya berakhir, dan caranya biasanya begitu: bukan dengan aplikasi yang lebih baik, tapi dengan library yang lebih baik.