Libghostty 1.0 Is Already Inside JetBrains and Neovim — Now It Has a Stable ABI to Match
libghostty-vt 1.0 freezes its C ABI under CI-enforced semantic versioning. JetBrains already ships it to 12.5M users; Neovim's PR is unblocked but not yet merged.
Mitchell Hashimoto shipped libghostty-vt 1.0 on November 6 with a detail that buries the usual open-source lead: the library was already running in production for more than 12.5 million people before it had a stable version number. JetBrains migrated all of its IDE terminals — IntelliJ, PyCharm, GoLand, and the rest — to libghostty before 1.0. Neovim's maintainers have an approved pull request to replace libvterm with it; they were waiting only for a tagged release so Linux distributions could package the dependency separately. That tagged release is now here.
The inversion is worth sitting with. More people use a libghostty-powered terminal today than use Ghostty the application itself, by what Hashimoto describes as "a very large multiple." The 1.0 announcement is not a launch; it is a stability contract issued after the product already won the market.
What "Stable ABI" Actually Means in Practice
ABI stability is a stronger guarantee than API stability, and the distinction matters for anyone evaluating this as a dependency. API stability means your source code keeps compiling. ABI stability means a binary compiled against version 1.0 continues to work correctly when linked against version 1.1 or 1.9 — without recompilation. That is the property that lets a Linux distribution package libghostty-vt as a shared library that dozens of programs link against, the same way they link against libz or libssl.
Hashimoto describes the design decisions that make the promise enforceable. Every object in the API is an opaque handle, so the internal layout of no structure is part of the contract. The hundreds of configuration values a program might read or write go through a small set of enum-keyed getters and setters:
#include <ghostty/vt.h>
#include <string.h>
GhosttyTerminal terminal;
ghostty_terminal_new(NULL, &terminal, 80, 24);
const char *text = "Hello, \x1b[1;32mworld\x1b[0m!\r\n";
ghostty_terminal_vt_write(terminal, (const uint8_t *)text, strlen(text));
ghostty_terminal_free(terminal);
Configuration follows the same pattern:
ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_BELL, bell_config);
ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_USERDATA, records);
Using a single set function and an enum, rather than exporting a new symbol for each option, keeps the ABI surface flat. When a program compiled with newer headers runs against an older library that doesn't know a particular enum value, it gets GHOSTTY_UNSUPPORTED instead of a crash. The few non-opaque structs carry their own size so fields can be appended later. Enums are pinned to int on every compiler.
The policy is not just documented — it is enforced in CI. On Linux, every pull request is checked with libabigail against a committed baseline; a change that breaks ABI compatibility fails the build before it merges. On macOS and WebAssembly, golden type manifests serve the same role. On ELF platforms, every exported symbol is versioned, so the dynamic loader refuses to load a mismatched library rather than failing at some opaque point at runtime. A maintainer can run the same comparison locally:
abidiff libghostty-vt.so.1.0.0 libghostty-vt.so.1.1.0
The notable thing about this setup is placement: ABI checking sits in the merge path, not in a release checklist, so the policy cannot silently decay between releases.
Platform Coverage and Resource Profile
The release post publishes a full platform matrix. The tier with full unit tests and example runs in CI:
| Platform | Architectures |
|---|---|
| Linux (glibc, musl) | x86_64, aarch64 |
| macOS 13+ | x86_64, aarch64 |
| iOS 13+ | aarch64 |
| FreeBSD | x86_64, aarch64 |
| Windows | x86_64 |
| Android | aarch64, x86_64, arm |
| WebAssembly | wasm32 (freestanding) |
A second tier builds in CI without automated test runs, with known users on each: bare-metal RISC-V and ARM (thumb), WASI, Windows arm64, illumos, and 32-bit x86.
Each platform gets the artifact shape it expects. Linux and FreeBSD get a shared library with a proper SONAME and versioned symbols, a static library, headers, pkg-config files, and a CMake package config. macOS and iOS get a dylib with an @rpath install name plus an XCFramework that drops straight into Xcode or Swift Package Manager. Windows gets a DLL with a .pdb, an import library, and a static library built with the GNU ABI; CI verifies that MSVC programs can link against it via the import library. Android targets are built against the NDK with 16 KB page size support, as required by Android 15+.
The WASM build ships in speed-optimized and size-optimized flavors. The size-optimized build comes in under one megabyte with every feature enabled. Subsystems like input encoding, search, selection, and Kitty graphics can be compiled out — roughly halving the module — and every disabled function still exports and returns GHOSTTY_UNSUPPORTED, so calling code doesn't have to change.
Resource usage is intentionally minimal. The library creates no threads. Memory allocation goes through a customizable allocator; the default is malloc. Hashimoto reports running 10,000 active terminals, each with a live shell producing output, on a four-core, 8 GB Linux server. He had to use dash as the shell rather than bash because bash's own RAM consumption would have exceeded the machine's budget before libghostty did.
Who Is Actually Embedding It Now
The adopter list in the announcement is specific enough to evaluate.
JetBrains replaced JediTerm — the terminal emulator that shipped in every JetBrains IDE for years — with libghostty. Hashimoto used a JediTerm bug as his motivating example when he first announced the library a year ago. That bug is now closed by virtue of the replacement. JetBrains reports 12.5 million recurring active users across its IDE lineup, all of whom now run libghostty-powered terminals.
Neovim has an approved pull request replacing libvterm with libghostty-vt. The merge was explicitly gated on a tagged release so that distributions can package the library as a separate dependency rather than bundling it. This also closes a ten-year-old issue about scrollback reflowing correctly when the terminal is resized — a limitation that libvterm never addressed. The 1.0 tag removes that blocker.
Vercel's Turborepo uses libghostty to render task output in its TUI. devenv uses it to drive shells. The testing company Antithesis used it to fuzz TUI programs and found real bugs in btop and other tools. OrbStack (the macOS Docker and Linux VM manager) embeds it commercially. KDE developers are experimenting with a Konsole replacement built on top of it.
On the WASM side, ghostty-web wraps the WebAssembly build with an Xterm.js-compatible API, lowering the adoption bar for browser-based terminal panels. The awesome-libghostty list tracks over a hundred projects, including community bindings for Rust, Go, JavaScript, Swift, Python, .NET, Elixir, Dart, and Java. New terminals and agentic coding tools — herdr and cmux are named specifically — were built on the library rather than writing fresh emulators.
What the Library Does Not Do
The boundaries matter for evaluating realistic adoption paths. libghostty-vt handles the terminal state machine: parsing VT sequences, maintaining the screen grid, scrollback buffer, cursor, styles, and modes. It understands the Kitty keyboard protocol, the Kitty graphics protocol, and the terminal protocols that have accumulated over decades.
It does not own the pseudoterminal (pty), it does not render pixels, and it does not manage a window. The embedder supplies the pty, reads bytes from the shell process, feeds them to the library, and draws whatever the library's render state describes. This division of labor is deliberate — it makes libghostty-vt embeddable in a GUI toolkit, a web renderer, a TUI framework, or a headless test harness without forcing a choice about any of them.
For comparison: libvte (the terminal library underlying GNOME Terminal and many GTK-based terminals) is tightly coupled to GTK, which limits its usefulness outside that ecosystem and makes it unsuitable for embedding in an IDE that ships its own UI framework. libvterm handles VT parsing but has less comprehensive protocol support and, as the decade-old resize bug demonstrates, unresolved correctness issues. The libghostty-vt design is explicitly aimed at this gap: a library that handles the hard emulation work without coupling you to any rendering or windowing system.
What It Takes to Actually Integrate
The lowest-friction path is probably via the language binding for your stack. The C API is the common surface; every binding wraps it. For Python:
import ctypes
lib = ctypes.CDLL("libghostty-vt.so")
lib.ghostty_terminal_new.restype = ctypes.c_int
That pattern — load the shared library, call through its C ABI — is how the entire binding ecosystem works. The Rust, Go, and other bindings automate the FFI layer.
For projects that need to ship to users who may not have libghostty installed, the static library is an option. For Linux distributions and package maintainers, the new release tooling provides what was previously missing: a signed source tarball, a companion dependencies tarball with every Zig package in Zig's cache layout (so the build can run completely offline), proper SONAME on the shared library, pkg-config files, and a CMake package config. A PACKAGING-LIBGHOSTTY.md ships with the tarball and documents the packaging conventions the build honors, including --prefix, DESTDIR, and lib64.
The Zig build toolchain is a dependency for building from source. That is an unusual requirement for a C library, though Zig's ability to cross-compile is part of why the platform matrix is as wide as it is. Distros that want to avoid bundling simdutf or Google Highway can dynamically link system copies using build flags.
The IDE and Editor Opportunity
For IDE vendors, the JetBrains adoption is the clearest proof of concept. IDEs that currently ship their own terminal panels — VS Code's integrated terminal (which uses xterm.js), and JetBrains' now-replaced JediTerm — represent the category most likely to evaluate libghostty as a backend. VS Code's xterm.js is a JavaScript implementation that runs well in an Electron context; whether a native C library integration offers meaningful gains over a mature WASM or JS implementation is a question that would require benchmarking on actual editor workloads. The ghostty-web WASM build with an Xterm.js-compatible API may be the more practical path there.
For SSH tools, remote development environments, and agentic coding tools that need to render terminal output — the cmux and herdr cases in the announcement — the library's thread-free, allocator-customizable design makes it straightforward to embed without fighting a larger runtime.
The clearest near-term candidate is Neovim: maintainers approved a PR to replace libvterm and were waiting on a tagged release so distros could package the dependency separately. Libghostty 1.0 removes that blocker — but rollout still depends on Neovim maintainers deciding to merge and downstream packagers building the new dependency. If that happens, it would bring reflowing scrollback and improved protocol support to Neovim users. The official post says the 1.0 release "should enable that," not that it guarantees it.
Licensing and Lock-In
Libghostty-vt is MIT licensed. Its runtime dependencies — simdutf, Google Highway, a compact Unicode table, and Wuffs for Kitty graphics decoding — are all permissively licensed. There is no copyleft code in the dependency tree. The machine-readable dependency manifest ships with every release, specifically to help distributions fill in their bundled-library metadata. Building without C++ standard library dependencies was an explicit goal; simdutf and Highway are both built without libc++.
Lock-in risk here is about the C ABI surface, not licensing. Because the API is a C interface, switching away from libghostty-vt in the future would mean rewriting against a different VT parsing and state management library — not an easy lift, but no harder than the problem the library itself was created to solve.
The project documentation, examples, and downloads are at lib.ghostty.org.
Comments ()