New Terminal Ghostty

info

date: 2024-12-28 01:08:21

tags: shell Linux

category: Apple

Created by: Stephan Bösebeck

logged in

ADMIN


New Terminal Ghostty

New Terminal Emulator Ghostty

Terminal Emulator - What is it?

Many people may not be familiar with the term "Terminal Emulator" or "Terminal," but it is an essential tool in IT and software development. The terminal is the "thing" that opens when you use the so-called "Command Prompt" on Windows or the "Terminal" program on Mac or Linux. It allows you to interact with the system in a different way through text inputs and outputs rather than using a mouse.

The history of the terminal goes back to the good old days of large IBM hosts. Back then, you didn't have a computer under your desk but rather multiple terminals connected to the host. Each terminal allowed someone to work on it. These terminals were pretty "dumb," only communicating with the host via a serial interface. And this is exactly what a terminal emulator now emulates.

This is important because it allows you to control, monitor, and customize virtually everything on a computer. Due to the "serial" and historically "remote" nature of terminals, it’s incredibly simple to send such data over a network. Previously, tools like Telnet were used for this purpose; today, ssh is more common.

On Linux or Unix systems in general (Macs are also Unix systems), the shell is probably more significant than on Windows. The command prompt in Windows is not as powerful as the shell running in a Unix-based terminal. However, PowerShell has significantly enhanced this, and with the Linux Subsystem for Windows, it is now possible to run a Unix shell on Windows.

Terminal Emulators

There are numerous terminal emulators, and each operating system comes with its own. However, there are also other emulators with special capabilities. Most of these terminals (the "emulator" part is often omitted) are designed to run on any Unix system and, ideally, on Windows as well. This can lead to issues, which I will discuss later.

Important Features of Terminals

One might wonder what features such a text-based tool could have. This is where things get interesting. Unlike the old days, when interfaces were text-based, today’s interfaces are graphical, and text rendering (fonts) is a surprisingly complex and sometimes resource-intensive task.

As a user, I naturally want a well-readable terminal for productive work. Nowadays, we can't limit ourselves to the 255 ASCII codes; we have Unicode with millions of characters that can and must be displayed.

Fonts are important, but colors are incredibly helpful too. For tools like "NeoVim" or "LazyGit" to function correctly, at least 256 colors are required. However, that is not up-to-date anymore. Most terminals I know stick to this limitation because there is a quasi-standard, xterm, which only supports 256 colors.

Additionally, everything should be fast. Since terminals often deal with large amounts of text, even a small millisecond delay in rendering individual characters can significantly impact performance. In my work, some scripts noticeably run longer in xterm or the default MacOS terminal compared to Kitty. While some argue that terminal performance isn’t important, I strongly disagree: performance matters!

For Mac users, it’s especially beneficial to use Metal as a graphics library to maximize performance. Many other terminals also use GPUs but rely on OpenGL, which is "translated" to Metal on Mac—this translation costs time.

Other useful features I wouldn’t want to miss include:

  • Simple configuration: Often, you need to tweak settings like colors. This should be straightforward. For instance, [wezterm](https://wezfurlong.org/wezterm/) uses a Lua-based configuration, which is very powerful but can quickly become overly complicated.
  • Quick startup: When I open a terminal, it should ideally open instantly. I might open and close my terminal hundreds of times a day, and waiting each time would be annoying.
  • Graphics support: While terminals are text-based, we’re no longer in the 70s, so it’s reasonable to expect image support. Fortunately, Kitty introduced a protocol for this, which most terminals have adopted.
  • Tabs and splits: When working with text, having multiple tabs or split windows is essential. This is particularly useful when comparing files or referencing documentation.
  • Compatibility: This is one of the most critical aspects. It’s incredibly frustrating when a highly-featured terminal fails to work because of compatibility issues with the shell or editor.

Terminals

From the perspective of a MacOS user (I use Linux daily but without a graphical interface), here are my favorite terminal emulators:

The OS-Provided Terminals

These terminals deserve mention because they are the ones you start with when a system is freshly installed. Typically, their feature set is limited, and they don’t look particularly appealing. Most of the time, apart from changing the font, there isn't much you can configure. And yes, they tend to be slow.

Here’s an example using the default terminal app on MacOS:

CategoryRatingComments
Features-It supports tabs and splits, but the terminal itself is very limited.
Configuration-You can’t configure much. For instance, custom keyboard shortcuts are not an option.
Appearance--Problems with font rendering.
StabilityoCrashed twice during benchmarks.
Compatibility++No compatibility issues.
Memory Usage++Around 1GB.
Performance++Surprisingly fast, even with Unicode rendering.

Performance Tests

bench.sh
0.07s user 0.90s system 15% cpu 6.442 total
termbench
CPU: Apple M1 Ultra 20 Core Processor (HP:16 LP:4)
VT support: no
ManyLine: 46.4265s (0.0215gb/s)
LongLine: 35.8506s (0.0279gb/s)
FGPerChar: 21.0962s (0.0138gb/s)
FGBGPerChar: 31.9099s (0.0177gb/s)
TermMarkV2 Normal: 135.2832s (0.0211gb/s)

(Note: The terminal crashed after this benchmark.)

vtebench
Results:

  dense_cells (299 samples @ 1 MiB):
    32.97ms avg (90% < 38ms) +-4.22ms

  medium_cells (164 samples @ 1.06 MiB):
    60.49ms avg (90% < 78ms) +-13.74ms

  scrolling (28 samples @ 1 MiB):
    302.11ms avg (90% < 315ms) +-10.97ms

  scrolling_bottom_region (39 samples @ 1 MiB):
    257.59ms avg (90% < 274ms) +-46.42ms

  scrolling_bottom_small_region (40 samples @ 1 MiB):
    250.95ms avg (90% < 265ms) +-11.03ms

  scrolling_fullscreen (17 samples @ 1 MiB):
    559.29ms avg (90% < 2747ms) +-856.96ms

  scrolling_top_region (30 samples @ 1 MiB):
    334.87ms avg (90% < 278ms) +-507.16ms

  scrolling_top_small_region (39 samples @ 1 MiB):
    261.49ms avg (90% < 280ms) +-9.94ms

  unicode (343 samples @ 1.06 MiB):
    28.66ms avg (90% < 61ms) +-53.92ms

iTerm2

One of the older and still widely used terminals on Mac. iTerm2 has a lot of unique features, such as automatically adjusting the theme when specific texts appear on the screen or triggering alarms when certain outputs are displayed. Unfortunately, iTerm2 is one of the slowest terminals in comparison. Its configuration is entirely graphical, which isn't necessarily a problem, but due to its sheer number of features, it can feel completely overloaded and confusing (at least for me).

That said, I used iTerm2 for a long time until I found an alternative—and I didn’t even realize I needed one. 😉

CategoryRatingComments
Features++Unique features.
Configuration-GUI-only, but overloaded and confusing.
AppearanceoSupports themes and background images.
Stability++No issues.
Compatibility++No issues.
Memory Usage++128MB + 300MB (with Tmux).
Performance--Very slow.

Performance Tests

bench.sh
0.07s user 0.76s system 5% cpu 14.996 total
termbench
CPU: Apple M1 Ultra 20 Core Processor (HP:16 LP:4)
VT support: no
ManyLine: 102.4746s (0.0098gb/s)
LongLine: 111.7195s (0.0090gb/s)
FGPerChar: 15.3591s (0.0189gb/s)
FGBGPerChar: 21.7056s (0.0260gb/s)
TermMarkV2 Normal: 251.2588s (0.0114gb/s)
vtebench
Results:

  dense_cells (62 samples @ 1 MiB):
    162.79ms avg (90% < 182ms) +-11.96ms

  medium_cells (12 samples @ 1.06 MiB):
    860.58ms avg (90% < 883ms) +-26.82ms

  scrolling (7 samples @ 1 MiB):
    1296.57ms avg (90% < 1305ms) +-4.76ms

  scrolling_bottom_region (8 samples @ 1 MiB):
    1386.13ms avg (90% < 1442ms) +-24.15ms

  scrolling_bottom_small_region (8 samples @ 1 MiB):
    1352.75ms avg (90% < 1371ms) +-12.13ms

  scrolling_fullscreen (5 samples @ 1 MiB):
    2048.8ms avg (90% < 2062ms) +-9.31ms

  scrolling_top_region (3 samples @ 1 MiB):
    4859ms avg (90% < 4887ms) +-28ms

  scrolling_top_small_region (8 samples @ 1 MiB):
    1357.63ms avg (90% < 1371ms) +-10.53ms

  unicode (74 samples @ 1.06 MiB):
    143.46ms avg (90% < 137ms) +-156.46ms

Alacritty

Alacritty is one of the first GPU-based terminal emulators for Mac, as far as I know. Alacritty is built for speed but doesn’t offer many features beyond that. Without TMUX, I find Alacritty almost unusable since it doesn’t support tabs.

I also had significant trouble adapting Alacritty to the specificities of MacOS. Many keyboard shortcuts didn’t work, and it took me a long time to get the configuration somewhat functional. Even then, I always had issues with the colors not displaying correctly.

Alacritty is very popular, especially among Linux users and those who like TMUX. However, I found the entry barrier too steep. Alacritty was tested in conjunction with TMUX since that’s the only way I could use it.

In fairness, comparing Alacritty to other terminals is tricky because it doesn’t offer many of the features that others do. For example, it lacks a scrollback buffer (the ability to scroll back in the window) and tabs. Thus, I had to test it with TMUX. For completeness, I’ve also listed test results without TMUX.

CategoryRatingComments
Features--Can be improved with TMUX, but why bother?
Configuration--I struggled a lot with configuration on MacOS.
Appearance--Colors were always incorrect for me.
Stability++No issues.
Compatibility++No issues.
Memory Usage++128MB + 300MB (with TMUX).
Performance++Very fast.

Performance Tests

bench.sh

With TMUX:

0.07s user 0.99s system 15% cpu 6.815 total

Without TMUX:

0.07s user 0.69s system 24% cpu 3.057 total
termbench

With TMUX:

CPU: Apple M1 Ultra 20 Core Processor (HP:16 LP:4)
VT support: no
ManyLine: 51.7055s (0.0193gb/s)
LongLine: 35.6015s (0.0281gb/s)
FGPerChar: 17.3334s (0.0168gb/s)
FGBGPerChar: 34.2513s (0.0165gb/s)
TermMarkV2 Normal: 138.8918s (0.0206gb/s)

Without TMUX:

CPU: Apple M1 Ultra 20 Core Processor (HP:16 LP:4)
VT support: no
ManyLine: 22.1249s (0.0452gb/s)
LongLine: 17.2509s (0.0580gb/s)
FGPerChar: 4.2486s (0.0683gb/s)
FGBGPerChar: 9.4715s (0.0595gb/s)
TermMarkV2 Normal: 53.0959s (0.0538gb/s)
vtebench

With TMUX:

Results:

  dense_cells (229 samples @ 1 MiB):
    43.23ms avg (90% < 44ms) +-0.88ms

  medium_cells (169 samples @ 1.06 MiB):
    58.79ms avg (90% < 60ms) +-1.28ms

  scrolling (36 samples @ 1 MiB):
    235.94ms avg (90% < 242ms) +-4.35ms

  scrolling_bottom_region (44 samples @ 1 MiB):
    229.8ms avg (90% < 231ms) +-1.05ms

  scrolling_bottom_small_region (44 samples @ 1 MiB):
    228.82ms avg (90% < 230ms) +-0.72ms

  scrolling_fullscreen (38 samples @ 1 MiB):
    222.13ms avg (90% < 223ms) +-0.93ms

  scrolling_top_region (55 samples @ 1 MiB):
    183.44ms avg (90% < 184ms) +-0.86ms

  scrolling_top_small_region (44 samples @ 1 MiB):
    229.48ms avg (90% < 230ms) +-0.66ms

  unicode (95 samples @ 1.06 MiB):
    105.72ms avg (90% < 107ms) +-1.07ms

Without TMUX:

Results:

  dense_cells (634 samples @ 1 MiB):
    15.29ms avg (90% < 16ms) +-0.73ms

  medium_cells (516 samples @ 1.06 MiB):
    18.92ms avg (90% < 20ms) +-0.69ms

  scrolling (46 samples @ 1 MiB):
    84ms avg (90% < 92ms) +-5ms

  scrolling_bottom_region (379 samples @ 1 MiB):
    25.9ms avg (90% < 26ms) +-0.66ms

  scrolling_bottom_small_region (380 samples @ 1 MiB):
    25.81ms avg (90% < 26ms) +-0.73ms

  scrolling_fullscreen (46 samples @ 1 MiB):
    84.04ms avg (90% < 89ms) +-3.54ms

  scrolling_top_region (255 samples @ 1 MiB):
    38.79ms avg (90% < 41ms) +-1.33ms

  scrolling_top_small_region (384 samples @ 1 MiB):
    25.6ms avg (90% < 26ms) +-0.72ms

  unicode (699 samples @ 1.06 MiB):
    13.79ms avg (90% < 15ms) +-1.4ms

Kitty

This is a truly good, fast terminal emulator. It is available for many platforms, and its configuration is simple. Kitty has been around for ages and is also the "inventor" of the protocol for displaying images in the shell.

I used Kitty as my default terminal for a while. However, there are some downsides. For example, Kitty uses its own TERM variable to manage terminal capabilities, which can cause problems on some systems. Fortunately, this can be easily resolved using the kitten utility, which is included with Kitty. Still, it can be a bit annoying.

CategoryRatingComments
Features++Offers a lot, and the kitten utility is very handy.
Configuration++Very simple.
Appearance++Nice touches like the "smear" cursor.
Stability++No issues.
Compatibility++No issues.
Memory Usage++370 MB.
Performance++Very fast.

Performance Tests

bench.sh
0.07s user 0.72s system 15% cpu 5.203 total
termbench
CPU: Apple M1 Ultra 20 Core Processor (HP:16 LP:4)
VT support: no
ManyLine: 39.3815s (0.0254gb/s)
LongLine: 22.8285s (0.0438gb/s)
FGPerChar: 7.5034s (0.0387gb/s)
FGBGPerChar: 11.2190s (0.0503gb/s)
TermMarkV2 Normal: 80.9324s (0.0353gb/s)
vtebench
Results:

  dense_cells (233 samples @ 1 MiB):
    42.5ms avg (90% < 23ms) +-310.19ms

  medium_cells (242 samples @ 1.06 MiB):
    40.9ms avg (90% < 45ms) +-7.7ms

  scrolling (23 samples @ 1 MiB):
    353.7ms avg (90% < 477ms) +-119.18ms

  scrolling_bottom_region (153 samples @ 1 MiB):
    65.4ms avg (90% < 82ms) +-16.3ms

  scrolling_bottom_small_region (152 samples @ 1 MiB):
    65.3ms avg (90% < 82ms) +-16.26ms

  scrolling_fullscreen (13 samples @ 1 MiB):
    682.23ms avg (90% < 733ms) +-59.74ms

  scrolling_top_region (227 samples @ 1 MiB):
    43.74ms avg (90% < 53ms) +-9.15ms

  scrolling_top_small_region (152 samples @ 1 MiB):
    65.52ms avg (90% < 83ms) +-16.39ms

  unicode (401 samples @ 1.06 MiB):
    24.44ms avg (90% < 20ms) +-93.44ms

wezterm

One of the coolest terminals. I used it for quite some time as my daily driver, primarily because the Lua-based configuration is quite appealing. This allows for a lot of options that wouldn’t be possible with a standard configuration file. However, this also means the configuration can quickly become overly complex.

CategoryRatingComments
Features+++Packed with features, can do almost everything.
Configuration-More like programming than configuring.
Appearance+Looks good, the only terminal with a parallax effect when scrolling.
Stability++No issues.
Compatibility++No issues.
Memory Usage++2.7 GB.
Performance++Very fast.

Performance Tests

bench.sh
0.07s user 0.65s system 14% cpu 5.131 total
termbench
CPU: Apple M1 Ultra 20 Core Processor (HP:16 LP:4)
VT support: no
ManyLine: 42.2684s (0.0237gb/s)
LongLine: 46.8052s (0.0214gb/s)
FGPerChar: 4.9405s (0.0588gb/s)
FGBGPerChar: 8.6801s (0.0650gb/s)
TermMarkV2 Normal: 102.6943s (0.0278gb/s)
vtebench
Results:

  dense_cells (745 samples @ 1 MiB):
    12.91ms avg (90% < 13ms) +-0.51ms

  medium_cells (161 samples @ 1.06 MiB):
    61.7ms avg (90% < 69ms) +-5.62ms

  scrolling (86 samples @ 1 MiB):
    98.44ms avg (90% < 99ms) +-1.39ms

  scrolling_bottom_region (112 samples @ 1 MiB):
    89.27ms avg (90% < 91ms) +-1.45ms

  scrolling_bottom_small_region (109 samples @ 1 MiB):
    91.34ms avg (90% < 95ms) +-2.48ms

  scrolling_fullscreen (71 samples @ 1 MiB):
    123.15ms avg (90% < 124ms) +-1.02ms

  scrolling_top_region (81 samples @ 1 MiB):
    123.69ms avg (90% < 127ms) +-2.76ms

  scrolling_top_small_region (110 samples @ 1 MiB):
    91.16ms avg (90% < 94ms) +-2.51ms

  unicode (72 samples @ 1.06 MiB):
    138.42ms avg (90% < 207ms) +-56.64ms

Ghostty

The star of the show. I’ve used all these other terminals daily, and I finally landed on Kitty and wezterm. Now comes a challenger that gets so many things right. Configuration is super simple—all parameters can also be passed as startup arguments. The configuration consists of just name = value pairs, nothing complex.

[Ghostty](https://Ghostty.dev) looks great out of the box, and you don’t really need to do much. My configuration only increased the font size (I’m old 😉) and adjusted the window size—that’s it.

You can also customize all the shortcuts that Ghostty recognizes, but the default values are already excellent.

CategoryRatingComments
Features+Still missing some features, but the basics are solid.
Configuration++Super simple, easy to understand.
Appearance+Great out of the box, excellent font rendering.
Stability+Crashed once during benchmarks.
Compatibility++No issues (except for TERM).
Memory Usage++730 MB.
Performance++Very fast.

Performance Tests

bench.sh
0.06s user 0.65s system 31% cpu 2.247 total
termbench
CPU: Apple M1 Ultra 20 Core Processor (HP:16 LP:4)
VT support: no
ManyLine: 16.2177s (0.0617gb/s)
LongLine: 14.7059s (0.0680gb/s)
FGPerChar: 5.3566s (0.0542gb/s)
FGBGPerChar: 11.6974s (0.0482gb/s)
TermMarkV2 Normal: 47.9777s (0.0595gb/s)
vtebench
Results:

  dense_cells (337 samples @ 1 MiB):
    29.2ms avg (90% < 30ms) +-1.78ms

  medium_cells (354 samples @ 1.06 MiB):
    27.81ms avg (90% < 30ms) +-1.93ms

  scrolling (181 samples @ 1 MiB):
    45.3ms avg (90% < 49ms) +-4.93ms

  scrolling_bottom_region (210 samples @ 1 MiB):
    47.26ms avg (90% < 49ms) +-2.19ms

  scrolling_bottom_small_region (210 samples @ 1 MiB):
    47.2ms avg (90% < 48ms) +-0.7ms

  scrolling_fullscreen (120 samples @ 1 MiB):
    73.93ms avg (90% < 75ms) +-0.86ms

  scrolling_top_region (194 samples @ 1 MiB):
    51.09ms avg (90% < 53ms) +-1.24ms

  scrolling_top_small_region (209 samples @ 1 MiB):
    47.54ms avg (90% < 49ms) +-0.87ms

  unicode (784 samples @ 1.06 MiB):
    12.14ms avg (90% < 13ms) +-0.4ms

Performance Matters

As mentioned earlier, let’s take a closer look at the performance tests.

I am fully aware that these tests can vary greatly and depend on many factors. I’ve run and repeated these tests several times. All terminals were set to the same size and configuration. Only Alacritty was tested with TMUX because otherwise, its feature set would not be comparable. For completeness, I’ve also listed the times without TMUX.

When we compare the results side by side, we get the following order:

bench.sh

  1. Ghostty: 2.247s
  2. wezterm: 5.131s
  3. Kitty: 5.203s
  4. OSX Terminal: 6.442s
  5. Alacritty: 6.815s (without TMUX: 3.057s)
  6. iTerm2: 14.996s

What surprises me here is that the OSX Terminal is as fast as Alacritty. I’ve run the tests multiple times. Without TMUX, Alacritty comes in second place with 3.057s, but this is of little use since it lacks tabs and other essential features.

I always knew that iTerm2 was relatively slow, but I didn’t expect it to be so far behind in last place.

termbench

  1. Ghostty: 48.9777s
  2. Kitty: 80.9324s
  3. wezterm: 102.6943s
  4. OSX Terminal: 135.2832s
  5. Alacritty: 138.8918s (without TMUX: 53.0959s, placing it in 2nd place)
  6. iTerm2: 251.2588s

vtebench

The results from vtebench are harder to summarize into a single value, but if we focus on the critical Unicode rendering, the ranking is as follows:

  1. Ghostty: 12.14ms
  2. Kitty: 24.44ms
  3. OSX Terminal: 28.66ms
  4. wezterm: 56.64ms
  5. Alacritty: 105.72ms (without TMUX: 13.79ms, placing it in 2nd place)
  6. iTerm2: 143.46ms

Once again, the same pattern emerges: Ghostty is in first place. Alacritty could take second place, but TMUX prevents that.

Results on an Intel MacBookPro

I ran the tests also an an older Macbook with Corei9 processor. Of course, everything took longer, but the order is more or less the same.

OSX-Terminal

bench.sh

 0,07s user 1,28s system 21% cpu 6,244 total

termbench

CPU: Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz
VT support: no
ManyLine: 49.8353s (0.0201gb/s)
LongLine: 25.0697s (0.0399gb/s)
FGPerChar: 17.8134s (0.0163gb/s)
FGBGPerChar: 57.5686s (0.0098gb/s)
TermMarkV2 Normal: 150.2870s (0.0190gb/s)

crashed several times at first, had to switch off scrollback buffer.

vtebench

Results:

  dense_cells (294 samples @ 1 MiB):
    33.6ms avg (90% < 38ms) +-3.72ms

  medium_cells (124 samples @ 1.06 MiB):
    80.58ms avg (90% < 92ms) +-11.45ms

  scrolling (26 samples @ 1 MiB):
    324.04ms avg (90% < 349ms) +-12.34ms

  scrolling_bottom_region (38 samples @ 1 MiB):
    268.37ms avg (90% < 284ms) +-28.3ms

  scrolling_bottom_small_region (37 samples @ 1 MiB):
    273.7ms avg (90% < 288ms) +-11.45ms

  scrolling_fullscreen (27 samples @ 1 MiB):
    323.19ms avg (90% < 334ms) +-6.96ms

  scrolling_top_region (38 samples @ 1 MiB):
    267.5ms avg (90% < 281ms) +-9.29ms

  scrolling_top_small_region (40 samples @ 1 MiB):
    255.33ms avg (90% < 266ms) +-9.5ms

  unicode (183 samples @ 1.06 MiB):
    54.32ms avg (90% < 177ms) +-112.46ms

iTerm2

bench.sh

0,07s user 1,12s system 4% cpu 29,147 total

termbench

CPU: Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz
VT support: no
ManyLine: 199.4939s (0.0050gb/s)
LongLine: 99.7370s (0.0100gb/s)
FGPerChar: 24.9018s (0.0117gb/s)
FGBGPerChar: 38.7812s (0.0145gb/s)
TermMarkV2 Normal: 362.9138s (0.0079gb/s)

vtebench

Results:

  dense_cells (154 samples @ 1 MiB):
    64.53ms avg (90% < 34ms) +-414.61ms

  medium_cells (139 samples @ 1.06 MiB):
    71.72ms avg (90% < 80ms) +-8.25ms

  scrolling (28 samples @ 1 MiB):
    306.43ms avg (90% < 315ms) +-5.76ms

  scrolling_bottom_region (41 samples @ 1 MiB):
    247.93ms avg (90% < 259ms) +-51.69ms

  scrolling_bottom_small_region (41 samples @ 1 MiB):
    246.71ms avg (90% < 255ms) +-46.68ms

  scrolling_fullscreen (25 samples @ 1 MiB):
    341.28ms avg (90% < 362ms) +-50.75ms

  scrolling_top_region (39 samples @ 1 MiB):
    257.31ms avg (90% < 269ms) +-11.38ms

  scrolling_top_small_region (41 samples @ 1 MiB):
    248.63ms avg (90% < 254ms) +-6.38ms

  unicode (199 samples @ 1.06 MiB):
    50.16ms avg (90% < 139ms) +-121ms

Alacritty

bench.sh

0.08s user 0.98s system 27% cpu 3.870 total

termbench

CPU: Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz
VT support: no
ManyLine: 40.0785s (0.0250gb/s)
LongLine: 29.5656s (0.0338gb/s)
FGPerChar: 4.6676s (0.0622gb/s)
FGBGPerChar: 10.1072s (0.0558gb/s)
TermMarkV2 Normal: 84.4189s (0.0338gb/s)

vtebench

Results:

  dense_cells (485 samples @ 1 MiB):
    20.13ms avg (90% < 21ms) +-1.33ms

  medium_cells (342 samples @ 1.06 MiB):
    28.8ms avg (90% < 30ms) +-0.9ms

  scrolling (29 samples @ 1 MiB):
    114.97ms avg (90% < 122ms) +-4.78ms

  scrolling_bottom_region (289 samples @ 1 MiB):
    34.13ms avg (90% < 35ms) +-1.09ms

  scrolling_bottom_small_region (289 samples @ 1 MiB):
    34.16ms avg (90% < 35ms) +-1.02ms

  scrolling_fullscreen (24 samples @ 1 MiB):
    194.67ms avg (90% < 203ms) +-4.66ms

  scrolling_top_region (194 samples @ 1 MiB):
    51.11ms avg (90% < 52ms) +-1.37ms

  scrolling_top_small_region (289 samples @ 1 MiB):
    34.12ms avg (90% < 36ms) +-1.3ms

  unicode (537 samples @ 1.06 MiB):
    18.13ms avg (90% < 20ms) +-1.35ms

Ghostty

bench.sh

 0.08s user 1.06s system 32% cpu 3.460 total

termbench

CPU: Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz
VT support: no
ManyLine: 23.2250s (0.0431gb/s)
LongLine: 19.2002s (0.0521gb/s)
FGPerChar: 9.0523s (0.0321gb/s)
FGBGPerChar: 16.9596s (0.0333gb/s
TermMarkV2 Normal: 68.4370s (0.0417gb/s)

vtebench

Results:

  dense_cells (209 samples @ 1 MiB):
    47.47ms avg (90% < 50ms) +-2.22ms

  medium_cells (254 samples @ 1.06 MiB):
    39.19ms avg (90% < 61ms) +-15.37ms

  scrolling (97 samples @ 1 MiB):
    82.65ms avg (90% < 112ms) +-25.63ms

  scrolling_bottom_region (126 samples @ 1 MiB):
    78.93ms avg (90% < 89ms) +-7.09ms

  scrolling_bottom_small_region (128 samples @ 1 MiB):
    77.75ms avg (90% < 81ms) +-10.66ms

  scrolling_fullscreen (71 samples @ 1 MiB):
    123.48ms avg (90% < 138ms) +-10.86ms

  scrolling_top_region (185 samples @ 1 MiB):
    53.78ms avg (90% < 57ms) +-12.21ms

  scrolling_top_small_region (197 samples @ 1 MiB):
    50.46ms avg (90% < 54ms) +-2.53ms

  unicode (598 samples @ 1.06 MiB):
    16.22ms avg (90% < 18ms) +-1.36ms

wezterm

bench.sh

0.09s user 1.13s system 9% cpu 12.398 total

termbench

CPU: Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz
VT support: no
ManyLine: 100.4589s (0.0100gb/s)
LongLine: 90.7136s (0.0110gb/s)
FGPerChar: 13.0643s (0.0222gb/s)
FGBGPerChar: 21.0286s (0.0268gb/s)
TermMarkV2 Normal: 225.2654s (0.0127gb/s)

vtebench

Results:

  dense_cells (316 samples @ 1 MiB):
    31.19ms avg (90% < 33ms) +-1.76ms

  medium_cells (62 samples @ 1.06 MiB):
    161.32ms avg (90% < 177ms) +-11.03ms

  scrolling (24 samples @ 1 MiB):
    349.21ms avg (90% < 370ms) +-17.57ms

  scrolling_bottom_region (40 samples @ 1 MiB):
    252.93ms avg (90% < 255ms) +-4.66ms

  scrolling_bottom_small_region (40 samples @ 1 MiB):
    252.63ms avg (90% < 256ms) +-4.09ms

  scrolling_fullscreen (20 samples @ 1 MiB):
    457.9ms avg (90% < 502ms) +-31.66ms

  scrolling_top_region (35 samples @ 1 MiB):
    288.03ms avg (90% < 295ms) +-7.85ms

  scrolling_top_small_region (40 samples @ 1 MiB):
    253.45ms avg (90% < 257ms) +-4.88ms

  unicode (20 samples @ 1.06 MiB):
    503.5ms avg (90% < 792ms) +-741.63ms#

Ranking on the Intel Mac

bench.sh

  1. Ghostty: 3,460s
  2. Alacritty: 3,870s (Ohne Tmux)
  3. OSX Terminal: 6,244s
  4. wezterm: 12,398s
  5. iTerm2: 29,147s

termbench

  1. Ghostty: 68,4370s
  2. Alacritty: 84,4189s
  3. OSX-Terminal: 150,2870s
  4. wezterm: 225,2654s
  5. iTerm2: 362,9138s

Interestingly Alacritty took the lead in some runs here. I tried several times. The average of all runs was around 75s.

vtebench (Unicode)

  1. Ghostty: 16.22 ms
  2. Alacritty; 18,13ms
  3. iTerm2: 50,16ms
  4. OSX-Terminal: 54,32ms
  5. wezterm: 503.5ms

Conclusion

Among all the terminals tested, [Ghostty](https://ghostty.dev) stands out as one of the best. With robust font rendering and exceptional performance, it’s a top-notch choice. While it lacks a few quality-of-life features and gimmicks, it’s highly recommended for Mac users who work in the shell!