It's been a quite smooth experience, and I remain very excited about the lib. I believe you are successfully setting the standard. Big congrats for your 1.4.0!

Periodically, I would run into TUI issues and think "I should just finally do it," especially around wanting to replace tmux in general. But I knew from experience the long tail of annoying issues for terminals that it's more time consuming than it appears, and so I again never bothered.

Thanks for the good work to raise all boats :)

I tend to move away from terminal emulation towards GUI when I can (and using custom remote protocols somewhat inspired by arcan), but TUI is still useful for a while. I actually had a need for a good terminal emulation library for the fallback TUI/pty attachment for non-gui programs for my supervisor, so I'll try out libghostty.

(a couple of us working on packaging libghostty and ghostty proper to for Guix at the moment )

That's really cool, but I'm drawing a blank; what's it used for? Embedded terminal something?

It's a pleasure reading your posts.

Wanted to add too that I can't wait for xterm to eventually support libghostty, you've been super supportive providing feedback!

https://github.com/xtermjs/xterm.js/issues/5686

Any interest in moving console typography past the 80's, since computers are fast now?

And right afterwards you write that not only it is the case, but the change is very recent !

it is all open source: https://github.com/hotaisle/hotaisle-website

Although not necessarily advertised as such, I've been successfully using alacritty in several projects injecting terminals into things both serious and silly.

I personally avoid using the terminal as much as possible b/c the whole things feels very archaic/fragile/baroque - but the central idea seems great and I'd love a modern take on it

When you say you've proven, are you hinting at use of formal verification?

I added Tmux control mode (a pretty extensive feature) https://github.com/tmux/tmux/wiki/Control-Mode to Ghostty: https://github.com/eliasfloreteng/ghostty-tmux and I use that version every day

If anyone is interested, I run zellij in my ghostty, and I let AI write a zellij hints plugin. It works ok. https://github.com/viktomas/zellij-hints

As an aside, I love ghostty and I think it's the most responsive terminal emulator around. But kitty was what got me off Terminal.app and I think it's not given enough love around here.

Konsole is a fantastic and very mature terminal emulator, but it does have some real gaps that reveal its age.

The Qt toolkit that most KDE software is based on at some point introduced a next-gen toolkit-within-a-toolkit called Qt Quick, which most of our newer apps are written in. However, in its library form Konsole can only be embedded into apps that use the old gen toolkit. This is a real impediment to some efforts.

The old gen toolkit also typically doesn't use Vulkan or OpenGL for rendering (the new one supports both), and so Konsole's terminal renderer doesn't either. Konsole's real-world performance during use is arguably just fine, but it does leave a lot of performance and battery life on the table.

libghostty also has somewhat wider support for newer stuff like Kitty protocols, even though Konsole certainly trumps it in support for older stuff (like sixels).

There's some other shortcomings to Konsole that are not inherent to the technology, like accessibility support not quite being where it should be.

And while the default UI is, in most distros, OK, there sure is a lot of spiderwebs and spacebar heating lurking in the settings dialogs (of which there are strangely many). It's also a bit dated vs. our HIG at the moment.

Which is to say, these projects can and do have a point, especially if they provide a nice library instead of hoarding all the good to themselves.

1. By default, Konsole disables OSC8 link support. Users can enable it manually, but you need to ship fallbacks by default since otherwise the default users will have a broken experience. Ghostty, Kitty, WezTerm, etc all ship working OSC8 support out of the box.

2. No built-in Nerd Font support, so if you want to render icons, you need to tell your users to set up a patched font or else have fallbacks. Ghostty and WezTerm ship built-in Nerd Font fallbacks if your configured font isn't patched.

That being said Konsole is much better than most emulators. iTerm2 is not bad, although it lacks Symbols for Legacy Computing Unicode support (which all of the above have, including Konsole, and which is very useful for drawing prettier terminal UIs). The worst by far is Apple Terminal, truly the IE6 of terminal emulators.

2) Technical curiosity: some people probably started their own terminal project just for the fuck of having made their own - and they eventually gained a userbase.

3) Feature set: Most terminals implement most features these days, but at the time these projects started, you'd have a feature matrix between features and terminals because most terminals lacked some features; so people would pick whatever suited their needs.

Personally I've been using kitty for years mostly due to 3), at the time I chose my forever terminal, I evaluated like 12 different ones, and kitty was the only one that covered most of my needs without feeling like it suffers from random quirks, and I like that it has built-in terminal multiplexer (a'la tmux) and emoji picker.

Having having an industry player like hashimoto's superlogical driving terminal features is the extreme version of that

I like Ghostty because I find it both fast and configurable, and it's multi-platform without treating macOS like the red headed step child. I also appreciate how its configuration is text-based, which I prefer to someone's opinion of how a configuration GUI should behave, and I think it's good the developers aren't wasting a second of their time thinking about a configuration GUI.

I have used Konsole for many years and I have used kitty for about 2 years in 2024/2025, then I have switched to ghostty around the beginning of 2026.

At least in my computers (with NVIDIA GPUs and Gentoo Linux), kitty was many times faster than Konsole and Ghostty even faster.

Moreover, in the now somewhat distant past when I was still using Konsole, it did not have some font rendering features that I desired, but that might have been solved meanwhile.

A reason why the terminal emulator speed is important for me is that I frequently compile big software projects and I find it unacceptable for a compilation to be slowed down by the low speed at which the compiler output is displayed on the terminal window, which happened frequently with all terminal emulators older than kitty and ghostty (I have always used CPUs with enough cores so that compilation itself is very fast, so the older terminal emulators become the bottleneck).

In Mac, we had the default terminal app which has some problems with TUI apps and other small issues. iTerm2 is the replacement that most users use, but it become too bloated with useless features and AI, while it was hard to keep a good config file that I could share between devices. Ghostty was a sane mid-term for me: a good and modern terminal, with a simple config file, maintained by someone that I trust (Mitchell Hashimoto) and only that.

About Linux: I don't use Ghostty in Linux because I'm comfortable with Konsole.

> libghostty: a cross-platform, minimal dependency library that exposes a C API so feature-rich, correct, and fast terminal functionality can be embedded by any application anywhere.

Oh the author actually posted about it just now in rich detail. It's pretty exciting for people who spend much of their time in the terminal.

Actually I think xterm was even more performant, but the eye sore wasn't worth it for me.

The acceleration is the primary point.

Same boat here, though I also get to enjoy some of the benefits of libghostty, via ghostel in Emacs. Ghostel is noticeably faster when there's a lot of output being dumped, but I don't often need the speed and use it only because it's integrated rather well into the rest of my Emacs.

> tmux -CC integration

If you can stomach Emacs, there are at least two packages that implement this, one via eat and another via vterm, though none via ghostel just yet. Shouldn't be difficult to port, though.

WezTerm can run on my Mac but give me a native GUI experience of a Wezterm session on my Linux workstation. It's like tmux, but with a native GUI experience including mouse click-drag selection that doesn't pick up "window" borders.

That alone is what is keeping me on Wezterm, since I get a native experience on some terminal sessions I access remotely on my macbook but then can switch to on my 30" screen when I'm at my desk.

Xterm failed me :( Tabby just works.

I also hate configuring Konsole, most KDE apps for that matter. Being able to have a plaintext configuration file I can keep in my dotfiles is way simpler.

If you're genuinely not trying to be dismissive and just have a sincere question you want to have an answer to then I _strongly_ implore you to be more aware of and careful about how you express yourself.

Because as your first sentence is worded virtually all readers will assume you are hostile and not asking in good faith.

Inspect + build yourself

These kind of features are not available in Ghostty in this form.

And about backups in iTerm2: Just do an export and maybe also a backup of your profiles. So that works.

I also do not care about a "super fast" terminal... my iTerm2 is fast enough for 99% of use cases for me.

But I switched due some iTerm2 bugs and performance reasons (I'm usually running up to ~100 terminal panes, split across 4-5 windows and up to 9 tabs per window) and it was much easier than I expected. I got used to my hotkeys bringing up full-screen quick terminals instead of half screen ones and that's actually usually what I want anyway, and iterm just feels more hackable in general; my agents are able to help get input to and from the various panes quite easily, and I haven't had a single bug or crash so far.

Nowadays, it's also a more fun community. I end up learning things about terminal rendering I never would've otherwise just by reading ghostty-related blogs.

I quit using iTerm 2 because of the AI features. Ew.

I now use ghostty it’s faster definitely. Yes it has some quirks which is hard to overcome as a iterm2 user. But I could live with it. I think ghostty is basically also the only alternative to iterm2

Do you have specific examples of usability issues?

Unfortunately, it seems to be doing something strange - I use vi-mode with nushell and it renders every character I press - even in normal mode.

I might keep an eye on it - hopefully they improve whatever they're doing with local echo.

I should say - I currently use WezTerm for exactly the feature tty7 advertises about session support. Even remote sessions.

https://xkcd.com/1172/

Normally not a fan of appimages, but this group focuses on making higher quality versions that make very few assumptions about the host system and work almost anywhere. While also prioritizing speed, small sizes, and up-to-date dependencies.

..but you can!

Nothing controversial here.

Not really and that isn't a good thing in the long run.

There should not be any more complexity in a terminal emulator that will just lead attackers to craft RCEs exploits to your terminal to steal your secrets on your computer just because "Its cool" and has hundreds of escape codes.

How’re you feeling after the change?

Got the Rex beta but haven’t looked at it really. I made a custom Claude code harness that is orchestrated by go CLI Claude wrote for me and that uses herdr for session management. Probably there’ll be something interesting I can do with Rex in the future as an alternative

The dom renderer is also perfectly fine, just needs a little bit more careful CSS to make it look right with some of the fancy line art.

I do use ghostty and it's alright. It's required for some rich TUI ai seems to be pumping out. Otherwise I prefer tilix and the default gnome terminal, but it might be just because of years of habit.

He also has a blog post and some tweets about how they can find and fix difficult bugs, and otherwise are capable of solving hard problems now. Well, they can.

Is that the LLM bug to you?

  gdbus call --session --dest com.mitchellh.ghostty --object-path /com/mitchellh/ghostty --method org.gtk.Application.Activate '{}'

I like foot but don't mind waiting a few tens of ms in exchange for kitty's graphics.

To some extent on Linux, too, but not under GNOME, apparently: https://ghostty.org/docs/install/release-notes/1-2-0#gtk:-qu...

Have several running; resident set size between 10MB and 19MB.

https://st.suckless.org/

I suspect you're getting down voted on this as it feels like this is a failure to educate yourself on something that feels like it should be relatively easy to do so in less time than it took to type your message.

If on Mac/Win, you should be used to trusting notarized apps after a cooldown period.

Reply and then downvote, but silently downvoting ? not a real men, hiding behind their keyboard :)

An LLM may be fine to implement quickly an application that more or less works, but I have not seen any evidence that any of them is able to write well optimized code, whenever the application is not just a duplicate of something older.

Ghosstty and a few other newer terminal emulators are not only lightweight, but they also implement very fast GPU rendering, which is one of their important advantages.

So not only their set of features matters, but also the achieved performance.

Of course, one could use an LLM to write a very fast terminal emulator, but for that a competent programmer must be included in the feedback loop, which would require many iterations and running benchmarks and emulation conformity tests. It cannot be done by vibe coding with a prompt like "write a lightweight terminal emulator".

However, it is more focused on multiplexing.