Typing latency of Zutty (in comparison with others)

It is a follow-up publish to my previous article evaluating Zutty to
varied different X terminal emulators. That evaluation, whereas going into
loads of element, missed an essential facet: the typing latency of
every program.

On essentially the most fundamental degree, we’re speaking concerning the delay it takes for
an interactive program (equivalent to a terminal emulator) to appropriately
reply to an enter occasion, on this case by altering its display screen output
in response to the consumer urgent a key. That is fairly elementary for
usability: excessive latencies are inclined to have an effect on the consumer negatively, because the
fixed lag between consumer motion and perceptional suggestions acts as a
(maybe unregistered) psychological burden.
This article by Pavel
Fatin argues for the significance of sufficiently low latencies a lot
higher than I might, so I encourage you to test it out.

Clearly, typing latency is a necessary metric to contemplate when
evaluating any terminal emulator, and since I had the current pleasure
of inflicting Zutty on a very unassuming world of harmless Linux
customers, it is just pure that I additionally benchmark it to show how
it suits in with different, extra established packages. In case you are not
acquainted with my previous article, I encourage you to test it out,
because it incorporates a abstract of all packages in my check that I can’t
repeat right here. In brief: we might be taking a look at seven packages in complete,
examined on the identical {hardware} setup as documented there. The one
distinction right here is that I’m testing a barely newer revision of
Zutty (tagged as
Release 0.7)
with some fixes and enhancements that didn’t but exist on the time
of my final article.

To measure the typing latency of every program, I used Pavel Fatin’s
wonderful typometer. This program measures end-to-end latency: it
emits keypress occasions and captures the display screen to notice when it will get
up to date (as truly seen to the consumer), and that is clearly the
proper factor to do (take a look at Pavel’s cool article with numerous element
on varied elements of latency).

The default measurement settings have been used (200 chars with 150 ms
delay, utilizing native API) with the exception that I additionally enabled async
mode. I did this to decouple the periodicity of typing from the
show lag, and likewise as a result of in my expertise it produced much less noisy
outcomes. To measure solely important latency induced by the packages
themselves, I ran every of them full-screen (with none window
decorations, their consumer space being equal to the foundation window)
for the time of the measurement in a non-compositing, light-weight
tiling window supervisor (i3). The display screen decision was 1920×1080 and
the LCD refresh charge 60 Hz. The machine was not operating something different
than the packages concerned within the measurement.

Outcomes:

Graph information in tabular format (all numbers are milliseconds):

The figures just about converse for themselves, so I’ll depart it as much as
you to attract your conclusions. A few of my very own factors although:

See Also

Tens of 1000’s protest in Germany towards the rise of the far proper : NPR

• xterm does direct rendering by way of Xlib, which is the first purpose it
  may be so quick in responding to consumer enter. That is additionally the rationale
  why its throughput is, alternatively, fairly poor.

• Kitty appears to ship fairly low latency on a really constant
  foundation, which is a non-trivial reality provided that it’s GPU-based. It’s
  nearly as responsive as Zutty. In reality, I’m not certain whether or not anybody
  would have the ability to inform them aside in a blind check. [Update: Kitty’s
  author informs me that in order to achieve the lowest possible
  latency with Kitty, its configuration option input_delay should be
  set to 0 (the default value is 3). I found this to improve Kitty’s
  overall numbers by about 2 milliseconds, putting it squarely in the
  same spot (within measurement error) as Zutty.]

• Alacritty is surprisingly sluggish right here and worse, its efficiency
  displays nice variation, which can be unhealthy for consumer expertise.
  This appears to be straight tied in with this system’s design; a
  number of tickets in Alacritty’s situation tracker show that its
  builders are properly conscious of the issue (however there isn’t any simple
  resolution).

• Talking of the remaining terminal emulators, there may be clearly room for
  enchancment.