libghostty-vt 1.0 released: stable C ABI, and JetBrains IDE terminals now run on it

Ghostty creator Mitchell Hashimoto released libghostty-vt 1.0 on 6 November 2026, declaring both the library and its C ABI stable. It is a portable, MIT-licensed C library that does the hard part of a terminal emulator: it takes the bytes a program writes and keeps track of the screen, cursor and scrollback. The release matters because JetBrains has already switched the built-in terminal of its 2026.3 IDEs to it (on by default in the early-access builds), and the stable ABI is the promise that lets other projects build on it without fearing breakage.

Key points

• libghostty-vt 1.0.0 was released on 6 November 2026 as a C library under the MIT licence, with a stable C ABI and semantic versioning, according to Hashimoto's announcement and the project site lib.ghostty.org.
• JetBrains replaced its JediTerm terminal engine with libghostty starting in 2026.3; it is on by default in the 2026.3 early-access builds and stays on through beta, release candidate and stable, per the JetBrains blog.
• JetBrains says the new engine handles almost 50 control sequences that JediTerm ignored or misread, and adds support for the Kitty keyboard protocol.
• By default the library needs only libc, creates no threads and allocates only through a customisable allocator; Hashimoto reports running 10,000 live terminals on a 4-core, 8 GB Linux server.
• Neovim's adoption is not final: Hashimoto's post lists an approved pull request pending a tagged release.

What happened

On 6 November 2026 Hashimoto published "libghostty-vt 1.0" on his site. The post describes the library as a portable, high-performance C library for terminal emulation extracted from Ghostty's core, and says both the library and its C ABI are now stable. The project site at lib.ghostty.org lists the current version as 1.0.0 and describes the same scope. The library follows semantic versioning with strict ABI compatibility promises.

The post lists who uses it. JetBrains' IDE terminals (IntelliJ, PyCharm, GoLand and others) now run on it; the post cites JetBrains as reporting over 12.5 million active users. It says Neovim has an approved pull request replacing libvterm that is pending a tagged release, and that KDE is experimenting with a Konsole replacement. Other users it names include Turborepo, devenv, Antithesis, Ghostel (Emacs), ghostty-web (a WebAssembly build with an Xterm.js-compatible API), OrbStack, herdr and cmux. Community bindings exist for Rust, Go, JavaScript, Swift, Python, .NET, Elixir, Dart, Java and more, and the post says the awesome-libghostty list tracks over 100 projects. We could not independently verify the Neovim pull request's status or the other projects' adoption, so those items come from the announcement alone.

Background

A terminal emulator has two jobs: draw text on screen, and interpret the stream of control sequences programs send (move the cursor, set a colour, switch screens, report a key press). The second job is the hard one. Programs such as Neovim, tmux and the AI coding agents Claude Code and Codex lean on modern protocols, and an emulator that misreads them shows garbage or mishandles keys. Hashimoto's post says the library was announced about a year earlier, when only a Zig module existed and Ghostty was the only consumer.

JetBrains described the problem in its own post. It says terminal tools increasingly depend on modern protocols that its previous engine, JediTerm, never supported, and that the gap felt like a minor inconvenience that was not disruptive enough to warrant a bug report. The company says many projects already embed libghostty and that it is widely regarded as reliable and performant, so it preferred it over the other options it considered.

How it works

You feed libghostty-vt the bytes a program writes, and it processes them and exposes terminal state such as the screen, cursor and scrollback, according to the project site. Parsers and encoders can be used without a full terminal. It does not draw anything: in JetBrains' words, libghostty takes over parsing and terminal state while the IDE still handles rendering and higher-level features.

The stability promise is concrete, per Hashimoto's post:

• Every object is an opaque handle, and values are read and written through enum-keyed getters and setters, so new values do not require new symbols.
• A program built against newer headers and linked with an older library gets GHOSTTY_UNSUPPORTED back instead of crashing.
• Non-opaque structs carry sizes or reserved padding for future fields, and enums are pinned to int.
• Continuous integration checks the ABI against a committed baseline on Linux with libabigail, and against golden type manifests on macOS and WebAssembly. ELF exported symbols are versioned.

Packaging follows the same logic. The library has its own release cycle, separate from the Ghostty application, and each release ships a signed source tarball plus a dependencies tarball for fully offline builds. It installs shared and static libraries with SONAMEs, headers, pkg-config files and a CMake package config.

The numbers

The post gives several figures worth knowing if you plan to embed it:

• Dependencies: simdutf and Google Highway for SIMD, a compact Unicode table for grapheme data, and Wuffs for image decoding for the Kitty graphics protocol. Hashimoto says there is no copyleft code in the dependency tree, and a machine-readable manifest lists each dependency's version, SPDX licence and hash. A footnote corrects an earlier claim: the default build does link libc.
• Footprint: it creates no threads, and allocates only through a customisable allocator. The WebAssembly small build is under 1 MB with all features, and feature flags can compile out subsystems to roughly halve the module size. Removed functions still exist and return GHOSTTY_UNSUPPORTED.
• Scale test: 10,000 live terminals ran on a 4-core, 8 GB Linux server. The test used dash, because bash used too much RAM. This is the author's own test, not independent.
• Platforms built and tested in CI: Linux (glibc and musl) on x86_64 and aarch64; macOS 13+ and iOS 13+; FreeBSD; Windows x86_64; Android; and freestanding WebAssembly. Built but not tested: bare metal (riscv32, thumb), WASI, Windows arm64, illumos and 32-bit x86.

What it means

For developers of IDEs, editors and terminals: a stable C ABI with a permissive licence lowers the cost of not writing your own parser. JetBrains' blog says that libghostty already parses many sequences the IDE does not yet act on, including OSC 52 clipboard, desktop notifications, progress bars and Kitty graphics, and that only the IDE side remains, so expect these to arrive faster than they did with JediTerm. Those features are not shipped yet.

For people who use JetBrains IDEs: the JetBrains post lists practical changes. With the Kitty keyboard protocol, terminal apps can tell Enter, Shift+Enter and Ctrl+Enter apart. That means Shift+Enter starts a new line in a prompt of tools such as Claude Code instead of sending a half-written message. The terminal also answers the dark/light query from the IDE theme, so tools such as Neovim and tmux can follow the theme, and it fixes rendering faults such as stray colons in colour codes. If something goes wrong, you can switch back: open Help, Find Action, Registry, and turn off terminal.use.ghostty.emulator. JetBrains asks for feedback on IJPL-218849.

For the ecosystem: one well-tested emulation core shared by many tools means fewer inconsistent corner cases. The trade-off, which the post's own list of future work hints at (more protocols, each switchable), is that the library's choices about which protocols to support become shared choices.

What we don't know yet

• Neovim's final decision. The approved pull request is pending a tagged release, per the announcement, and we did not confirm its state ourselves.
• KDE's plans. The post says only that KDE is experimenting.
• Independent performance numbers. The 10,000-terminal figure and the size figures are the author's.
• When JetBrains' stable release lands. The JetBrains blog commits to libghostty through beta, release candidate and stable for 2026.3, but gives no date.
• Which of the built-but-untested targets will become supported.

What to watch next

• A tagged Neovim release that replaces libvterm.
• JetBrains wiring up clipboard, notifications, progress bars and images in the IDE.
• Whether more editors and terminals adopt the stable ABI, and how the awesome-libghostty list grows.
• The library's work on more terminal protocols, which the post says will each be switchable.

Sources

• Mitchell Hashimoto: libghostty-vt 1.0
• lib.ghostty.org: libghostty-vt documentation
• The JetBrains Blog: The Terminal in JetBrains IDEs Now Runs on libghostty