
Kitty – a fast, featureful, GPU based terminal emulator - Ayey_
https://sw.kovidgoyal.net/kitty/
======
adamch
I've been using Kitty for a month now. I really like it. It's slightly less
usable out of the box than iTerm 2. The default shortcuts are very
counterintuitive (no CMD T for new tab or CMD W to close tab). But editing the
preferences is straightforward.

I prefer it to iTerm because it's so. Damn. Fast. It's the only software
(besides Sublime) I run on my laptop that actually feels like it's using the
40 years of transistor improvements I'm paying for.

I know iTerm recently added a Metal renderer but I need ligature support,
which iTerm Metal doesn't have.

Maintainer has also been responsive on GitHub.

~~~
murukesh_s
From a marketing perspective I was wondering how did you discover it one month
back? Product hunt? or here itself ?

~~~
iokanuon
It's easy to find if you search for terminal emulators with low latency.

~~~
1996
Different conclusion for the same article: I picked mlterm

[https://anarc.at/blog/2018-05-04-terminal-
emulators-2/](https://anarc.at/blog/2018-05-04-terminal-emulators-2/)

------
krick
I love this seemingly new tendency of re-building the most basic things with
much better design choices than originally made in 90-s (or 70-s) — it's
sometimes baffling how people are ok with using weird unintuitive tools all
day every day, because it's always been this way and after spending a couple
months on it everyone gets used to it.

I mean, I love how user friendly (meaning configuration and all) kitty is out
of the box. That's how tools made by programmers for programmers should look
like.

That said, kitty behaves a little weird when scrolling back and forth in vim —
at least on my laptop with my vim colorscheme. It leaves out background of a
line black until I jump on that specific line or simple refresh the screen. I
wonder what might be the issue here.

~~~
aumerle
[https://sw.kovidgoyal.net/kitty/faq.html#using-a-color-
theme...](https://sw.kovidgoyal.net/kitty/faq.html#using-a-color-theme-with-a-
background-color-does-not-work-well-in-vim)

~~~
krick
Thank you, I just installed it and am simply playing around, so didn't
actually read the docs yet. This seems to help, however redrawing is still
kind of weird, with artifacts appearing when resizing windows and such.
Probably has to do with laptop's quasi-GPU. Also, alt+tab doesn't switch back
to kitty's window, when kitty is in fullscreen mode.

------
christoph-heiss
Another GPU-accelerated terminal emulator is alacritty[0].

Although it has a lot less features than kitty and really is only usable with
tmux (or GNU screen, whatever), it is more or less perfect for people who want
their terminal to do just one thing and that one thing pretty fast.

Disclaimer: Haven't tried kitty yet and using alacritty for a nearly a year
now.

[0] [https://github.com/jwilm/alacritty](https://github.com/jwilm/alacritty)

~~~
hdra
I was pretty impressed when I found alacritty a while ago, but I stopped using
it as I soon found out that pretty much any speed gain I got from using the
terminal is pretty much negated from having to use tmux in order to have any
form of window management..

~~~
mjtribue
Could you please provide more details on the speed issues with tmux?

~~~
jstimpfle
It's, well, slow. Haven't done any measurements, but it's noticeable. To do
its work tmux must be basically another terminal emulator, and it seems it
isn't the fastest at it. It's still strange, neither a little context
switching (tmux is an extra process in the pipeline) nor doing the terminal
things should amount to more than a millisecond. I think.

~~~
tazard
I haven't had any speed issues with tmux. Maybe you have something in your
config that's slowing it down?

~~~
jamesgeck0
It's extremely noticeable in certain situations on MacOS.

Use a full screen terminal with a 12pt font on a 4K display. Split the tmux
window into quarters and pull up some logs in each pane. Now use the mouse to
click and drag on the center vertical border; quickly resize it from left to
right. The border takes about half a second to catch up with the mouse cursor
as tmux repeatedly reflows all the text on the screen.

------
jjcm
Side note, the author's home page is an absolute relic from the past:
[https://kovidgoyal.net](https://kovidgoyal.net) , including things like
provisions for 56k modems, iframes, detection scripts for IE3 and AOL, and
other gems.

It even looks like he has his own pre-jquery compliance library written about
18 years ago:
[https://kovidgoyal.net/scripts/VisualDocumentAPI.js](https://kovidgoyal.net/scripts/VisualDocumentAPI.js)

~~~
ricardobeat
And most of it still works perfectly fine on an iPad Pro, in a completely new
browser from the future. Good times!

~~~
ilogik
On safari desktop and mobile, I get:

> W A R N I N G! Your browser is not supported by this site.I cannot guarantee
> that things will work as they should. Consider downloading either Mozilla
> >=1.4 or Internet Explorer >= 6

~~~
BurnGpuBurn
Considering Safari only exists for about 15 years, and the site is older than
that, I think it does a very reasonable suggestion.

------
unixhero
Not to be confused with Kitty, the terminal emulator.

[http://www.9bis.net/kitty/](http://www.9bis.net/kitty/)

~~~
gear54rus
Exactly. A bit unfortunate since this is a successor? to putty which is widely
used so this name clash is kind of prominent.

~~~
Thlom
Kitty is a fork of Putty, or maybe more precisely it's built on putty. I used
it a lot in my previous job as we didn't have key-based auth on customer
servers. With Kitty I could create profiles with login information, and where
needed automatically switch user to root. Good times.

------
karakanb
Please forgive my ignorance: what do these terminal emulators do better than a
basic terminal application, such as Terminal.app? My work with terminal is
quite basic, I edit a few files, execute a few commands and sometimes cURL
something. Terminal.app has some basic colors, has tabs, and works out of box
without any visible performance issues for basic usage. What improvements
would these emulators bring to my daily life?

~~~
rbanffy
You may have better font rendering (anti-aliasing support on low-dpi screens),
faster rendering and scrolling, better support for terminal attributes
(crossed-out, overline, italic, etc). iTerm does a lot of optimizations so it
can render and scroll faster (I volunteered to add a feature to it, and I dug
a bit through the code).

For instance, iTerm supports italic, which Terminal.app doesn't. Gnome's
terminal (vte, actually) does support overline (I volunteered adding it to
iTerm, but I'm nowhere near close), which is handy for status lines, as well.
I think there is one that takes ANSI codes seriously enough to support double-
height and width.

To see what's missing, you can look into
[https://en.wikipedia.org/wiki/ANSI_escape_code](https://en.wikipedia.org/wiki/ANSI_escape_code)

~~~
matt4077
Terminal.app is orders of magnitude faster than iTerm, or any other
alternative. As in: less than a second v 30 seconds for cat <big file>.

~~~
coldtea
With the metal renderer?

------
yason
Why render with the GPU? I don't think I've seen a visually slow terminal
emulator since 2000 and barely even in the 1990's.

Text rendering is basically just blitting cached glyph bitmaps into a buffer,
and CPUs have been more than overly fast doing that for eons. And CPU
rendering has none of the compatibility problems/quirks that GPUs have. I can
fire up a Gnome Terminal onto an unaccelerated Vesa X11 display if my graphics
card doesn't work or I haven't configured it yet.

For better responsivity I suppose a terminal that behaves like mosh would be a
good approach. It would maintain the tty state in memory and only render the
latest view, dropping the rendering of any intermediate diffs in the buffer. I
would guess most terminal emulators do work like that these days but I haven't
checked.

~~~
dancek
Input latency makes for a bad user experience. People just usually don't
notice it when typing as it's so common. See [https://danluu.com/term-
latency/](https://danluu.com/term-latency/) for measurements of some terminal
software and discussion of why latency is bad.

I'm not sure if Kitty is using GPU specifically to minimize latency, but it
would be a good reason.

~~~
simias
I work in video and as a consequence I tend to be very sensitive to latency
(I've spent more hours than I can count trying to figure out subtle
synchronization issues) yet I've just spent one minute trying to detect input
latency on my st terminal (which fares pretty badly in the benchmark you
linked) without success. And that's running inside tmux on top of that.

That being said I think it is valuable to have a reasonably fast terminal
because it's not uncommon to have applications slow down dramatically if they
output a lot of information on stdout/stderr while the terminal struggles to
render everything.

~~~
matt4077
I would have said the same, until I recently had to boot into an UEFI shell.

Input was just so .... immediate? It’s really hard to describe, but it was
surprisingly obviou.

~~~
dancek
Yeah, the feeling is pretty much "the letter appears while I'm pushing the key
down" vs. "the letter appears when the key returns to the top position". Both
feel immediate in their own way.

------
mixedCase
Best terminal I've found except for a complete deal-breaker for me: Lack of
support for bitmap fonts (meaning I cannot comfortably use them in low DPI
monitors), and the author has no intention of adding them.

A pity, maybe some day either the author changes his mind or Alacritty will be
less buggy to make it a straight upgrade to Kitty. In the meantime, Termite it
is.

~~~
snvzz
Likewise, I found this as I was trying to make it work with Terminus:

[https://github.com/kovidgoyal/kitty/issues/106](https://github.com/kovidgoyal/kitty/issues/106)

Obviously using the truetype version (which isn't pixel perfect but a mess) is
not an option.

Too bad. I'll stick to libvte (sakura).

------
oever
Two simple speed tests:

    
    
        time find ~
    

/dev/null takes 8 seconds

alacritty takes 8.5 seconds and uses 75% CPU

kitty takes 15 seconds and uses 100% CPU

konsole takes 16 seconds and uses 100% CPU

    
    
        time for i in {1..2000000}; do echo $i; done
    

/dev/null takes 8 seconds

alacritty takes 16 seconds and uses 75% CPU

kitty takes 17 seconds and uses 100% CPU

konsole takes 16 seconds and uses 98% CPU

~~~
hd4
I'm guessing you're on KDE (as am I) but it would be cool to see GNOME
Terminal compared also. What I got from these results is that Konsole is
already good enough to not bother switching.

~~~
oever
Yes, I'm on KDE on X. gnome-terminal does not work (easily) on my distro so I
cannot measure that. I did measure xterm which takes over a minute for both
tests and also stresses out X. None of the other terminal emulators did that.

Still, I wonder if the terminal emulators could use less CPU and be faster if
they refreshed only with the frequency of the monitor.

An interesting insight from the tests is that the execution speed of a program
can depend on the speed of the terminal emulator.

~~~
vanderZwan
How about Terminology?

[https://www.enlightenment.org/about-
terminology](https://www.enlightenment.org/about-terminology)

~~~
oever
Terminology 1.1 takes 26 seconds and 100% CPU on find and 15 seconds and 90%
CPU on the bash counting.

------
fcarraldo
Not affiliated, but recently switched to Kitty from iTerm 2 on OS X on my main
at-work MacBook Pro and I’ve been very impressed. It’s snappy, easy to
configure and works well with my zsh/tmux setup with a few tweaks. I would
love to drop tmux in favor of kitty’s sessions and multiplexing, but old
habits die hard, so it will take some time.

~~~
colordrops
What does kitty buy you on top of tmux that is worth locking yourself into a
particular terminal?

~~~
rovr138
Speed.

Locking how? He can keep his tmux configuration and use it when he needs to in
the future.

------
rahimnathwani
Wow. This is from the guy that created the calibre ebook software.

------
haberman
Terminal emulators have tabs/windows, tmux has tabs/windows, vim has
tabs/windows. All with different keyboard shortcuts and semantics.

I wish this were all unified into a single window/tab/keybinding model. That
was easy to code against and write your own interactions for.

I keep hoping I'll see a boundary-pushing project like Kitty do something new
in this space.

~~~
scolby33
vim-tmux-navigator[0] is probably the best thing I've installed in my terminal
for transparently moving between splits. Using it has allowed switching splits
to become so thoughtless that it's automatic as I move my eyes.

[0] [https://github.com/christoomey/vim-tmux-
navigator](https://github.com/christoomey/vim-tmux-navigator)

------
self_awareness
This doesn't work on half of Nvidia-powered laptops:

[https://github.com/kovidgoyal/kitty/issues/456](https://github.com/kovidgoyal/kitty/issues/456)

~~~
Rantenki
Closed and locked with:

> I'm widely known for my extreme stupidity.

Loving the zero <expletives> given approach from the maintainer. Installing
now.

~~~
guitarbill
Kovid Goyal is infamous/known to be a bit toxic, see Calibre:
[https://news.ycombinator.com/item?id=8213946](https://news.ycombinator.com/item?id=8213946)
(and the setuid "issue":
[https://lwn.net/Articles/465311/](https://lwn.net/Articles/465311/))

~~~
michaelmrose
He seems to be sarcastic especially when needled, opinionated, sometimes
incorrect, and willing to argue a point.

On the other hand he actually fixes things.

Even if you actually were paying money for his services, which most of us are
not, which would you prefer an obsequious kind person who didn't fix your
problem or a dick that did.

I would take the dick every day of the week.

~~~
self_awareness
> I would take the dick every day of the week.

When I'm asked a question whether it's better to hire a dickhead that is an
expert in some field, or a normal person that isn't an expert of this field
but showing promises, I'm probably always going with the non-dickhead person.

Dickheads are hard to communicate with, they are lowering team morale, make
teamwork harder so in the end expert dickheads are less valuable than non-
dickheads.

------
burfog
What I could really use would be a terminal emulator that is:

a library that I can feed data directly into (without a pty)

LGPL, MIT, or BSD

able to quickly serialize its internal state (make me a blob)

able to restore state if I feed it a blob of saved state, even across
different software builds

portable to recent versions of Linux and Windows

~~~
laumars
Theres no way you can build a terminal emulator without a PTY and still expect
terminal UIs (eg stuff that uses ncursors) to work.

Moreover, the session state saving is not possible either since you need to
save the internal state of running programs as well as their cached output
(saving the output is really very easy but it's the least of your worries
given the specifications you've described).

You might also find this problem is better solved with a $SHELL replacement
rather than a terminal emulator.

~~~
burfog
Yes you can. I want to hook this up to an emulator (like qemu or MAME) with an
emulated serial port. That is the PTY equivalent. I'm writing this emulator.

So the emulator gets bytes from the emulated virtual machine, and then what?
This needs to get fed into a terminal. While it is possible to invoke xterm
with the very buggy -S option, there is no way for the emulator to suck the
state back out of xterm for coherent snapshots. Simics uses xterm with the -S
option. It sucks.

A library interface is required. The whole point of a library interface is to
allow session state saving. Using a $SHELL replacement is way off. That has
nothing to do with the problem.

So, if you were hacking on an emulator (qemu, MAME, Simics, VirtualBox, etc.)
and you were trying to emulate a device with a serial port or even a modem,
how would you get snapshots to contain the terminal state? To make this work,
you need that state within the emulator. Passing stuff over a PTY is not going
to work.

~~~
laumars
You're only solving half of the problem (and doing it in a needlessly
complicated way at that). As I said, capturing the TTY output is the easy
part. Storing the running state of the program that's writing to the TTY is
your bigger issue. That's why I suggested a custom $SHELL (I guess there's no
need to reinvent the command line so you could probably use a multiplexer
instead?) that could manage the running state of the executing programs and
their PTY.

~~~
burfog
Storing the running state of the program that's writing to the... serial port
or whatever... is a solved issue. Most emulators and virtual machines can do
this. For example, VMWare Workstation can do it. Simics can do it. Qemu can do
it.

The state of an entire OS, with all running programs, gets saved. It's more
complete than when a laptop/notebook does suspend-to-disk. The emulator saves
the CPU registers, the RAM, the disks, the parallel port mode, etc.

The trouble is that a connected terminal is not included in that list.

~~~
laumars
There isn't anything writing to the serial port. The process of writing to the
serial port is fast enough that the IO isnt the problem. What you're after is
the capture of stuff that has already been outputted on the terminal and that
can be captured. It's called a scroll back buffer history. Some terminals can
even make that persistent.

You keep trying to reinvent terminals with features that already exist to
solve a problem that needs to be fixed in the server itself.

~~~
burfog
I didn't see a "reply" link below. This is a
[https://news.ycombinator.com/item?id=17949657](https://news.ycombinator.com/item?id=17949657)
response.

I emulate lots of different things. I'll make up an extra-simple case to
illustrate the problem.

The guest OS running in the emulator is just a bootable floppy image for
testing. All it does is print a counter to the serial port, once per hour.
Just after 3 hours it has written 0, 1, 2, 3. At this point I make a snapshot
file named 0123.snap and let the software continue running. More numbers get
printed. Eventually the terminal is showing 0, 1, 2, 3, 4, 5, 6. I decide that
I wish to go back in time, so I issue a command to load the 0123.snap file
into the emulator. The internal state of the emulator warps back to the point
at which I took the snapshot. The CPU registers, the RAM, and everything else
within the emulator are now as they were earlier. The terminal retains the old
state however, because it is a separate program with no awareness of the fact
that I just loaded the 0123.snap file into my emulator. The guest OS carries
on from the original point of course, since that is what the CPU and RAM state
dictates, so a "4" will be printed next. The terminal then shows 0, 1, 2, 3,
4, 5, 6, 4. The numbers are simply wrong. They should be 0, 1, 2, 3, 4.

I can only avoid this fate by saving full terminal state whenever I save the
emulator state, and of course restoring it at the same time too. There is no
reasonable way to extract terminal state from a separate terminal program.
(attacking it with ptrace is not reasonable) I thus conclude that the terminal
must be built into the emulator.

~~~
laumars
> _I can only avoid this fate by saving full terminal state whenever I save
> the emulator state, and of course restoring it at the same time too. There
> is no reasonable way to extract terminal state from a separate terminal
> program. (attacking it with ptrace is not reasonable) I thus conclude that
> the terminal must be built into the emulator._

It's called a "terminal multiplexer" and that is exactly what I suggested with
the tmux solution right from the bloody start. I've lost track of how many
times I've said this needed to be solved on the server yet you repeatedly
pushed back on both points when they were made, insisting it was a terminal
emulator issue on the client side.

~~~
burfog
I'm normally not a BSD user. I'm more familiar with "screen" than "tmux". To
me, a "terminal multiplexer" is a physical piece of hardware. It has numerous
slow serial lines to which one may attach terminals, modems, or consoles. It
time-multiplexes them to/from a single high-speed link, typically by
interleaving the streams of data bit by bit.

I don't see tmux being available as a library that I could link into my
emulator. If it can be a library, then yes my emulator could implement the
tmux protocol. This turns out to be almost exactly what I was proposing, with
the terminal state implemented by a library within the emulator. I'd just be
missing the user-friendly aspect of automatically popping up the terminal
windows when my emulator starts, but perhaps that could be arranged by having
the emulator start xterm running tmux.

This is comparable to using vnc protocol for VGA. I have this implemented, but
nobody likes to use it. Everybody prefers the built-in video window to show
the guest's VGA.

If you meant to not link in the tmux code though, that won't work.

Instead of insisting that there is a terminal emulator issue on the client
side, I insist that there not be a distinct client. The code that tracks
terminal state (cursor position, current character attributes, etc.) pretty
much needs to live in the emulator. That is the only reasonable way to ensure
that the state can be saved and restored by the emulator. Actually displaying
this state could be done by connecting a client (annoying) or just by popping
up a window.

Another nice thing about having the terminal windows built into the emulator
is that they all go away when the emulator does, even if that is a crash.

~~~
laumars
To be honest I think you've decided on the worst possible way to solve your
problem. But good luck with your endeavour non-the-less. :)

~~~
burfog
I think it is unavoidable. It follows naturally from insisting on user-
friendly snapshots.

It is typical for emulator authors to just give up, letting the terminal be
inconsistent after loading a snapshot.

So far I've done just that... but my users love loading snapshots.

------
supernintendo
This is somewhat of an aside, but the fastest terminal emulator I've ever used
is rxvt-unicode. I don't even know if it utilizes the GPU (doubt it), but damn
is it snappy. Try it out if you're on GNU / Linux.

~~~
jgtrosh
This nice study goes into nicely thought out detail to compare speed of
emulators, I recommend it. Urxvt is not so blazing fast at latency, and it
manages great scrolling speed by dropping content. (It's my current emulator
of choice though !)

[https://lwn.net/Articles/751763/](https://lwn.net/Articles/751763/)

~~~
flukus
Does it drop it or simply not show it? Will scrolling back through history
display the "dropped" content? If so I'm fine with that, it's annoying when
you finally finish a task and pipe the results to a file just to find the
bottleneck slowing you down was display refreshes.

------
green7ea
I've switched to kitty a few months ago and it works REALLY well. It's very
fast and has the best support for ligatures I've seen in a terminal. With
FiraCode, it makes code beautiful in the terminal

~~~
dfee
Despite my efforts to try FC, I always come back to Monaco.

------
a012
I tried it on MacOS (MBP retina) and damn, it renders text awfully.

~~~
fooblat
The text looks very nice on my rMBP on the built-in display and absolutely
terrible on my attached 2k display.

~~~
skykooler
I remember seeing this in iTerm, but it was fixed by changing the subpixel
hinting mode. Is there an option for this in kitty? I couldn't find one in the
config, unless it has a different name.

------
qyron
About a year ago I was deciding between Kitty and Alacritty and I chose Kitty
because of 2 important features it had over Alacritty: proper underline
rendering (Alacritty just draws underscores) and text selection with
Shift+Mouse. Kitty also compiles instantly as it's written in plain old C. The
author is also very responsive on GitHub and addresses each issue quickly.

------
memco
Tried it out and it seems ok. It does seem quite responsive and wasn't too
hard to customize. Doesn't have a lot of discoverability out of the box since
there's no menus: I had to search through the config file to figure out that
tabs exist and that to make one I need to enable the command. I would love a
guide of some sort: perhaps a video showing some of the features and how they
would fit into a workflow. I toyed around with tmux, but my current setup
relies on panes in iterm. Since there's no option to transfer over, it'd be
nice to see how to migrate. Looking forward to trying out the kittens later
since I didn't mess with those at all.

~~~
adimitrov
And now I feel old. Menus in a terminal? _Videos_ explaining a _terminal
emulator_? Migration guide from arbitrary terminal emulators configs? Get off
my lawn! Kids these days, never having had to compile their own xterm and then
seeing the light of our holy lord and saviour rxvt, and its endless man pages.

There's a huge configuration doc[1], and the homepage already does a very good
job of introducing you to its features. You have to _read_ that, yeah, but
maybe you can get a screen reader to read it for you. Dunno.

[1]
[https://sw.kovidgoyal.net/kitty/conf.html](https://sw.kovidgoyal.net/kitty/conf.html)

~~~
heavenlyblue
Videos are the worst. No copy/paste. The only was to go back in the
information flow is through a dumb scroller without any semantic addendum.
It's a joke.

More importantly, making a video probably takes more time that having a nice
write-up about anything.

I am 26, BTW.

------
jwr
Question for other tmux users: if I do not intend to replace tmux, is this
still a good choice for a terminal to run your toplevel tmux session in?

(compared to Apple's Terminal.app, which I found to be the fastest and least
problematic on a Mac)

------
swagonomixxx
Gpu powered terminal emulator? This performs almost 100x worse than Mac OS
Terminal.app. Cat-ting a long file takes 100x longer to draw on the screen!
Isn’t it supposed to be faster if it’s “GPU powered”?

~~~
knaik94
"Some people have asked why kitty does not perform better than terminal XXX in
the test of sinking large amounts of data, such as catting a large text file.
The answer is because this is not a goal for kitty. kitty deliberately
throttles input parsing and output rendering to minimize resource usage while
still being able to sink output faster than any real world program can produce
it. Reducing CPU usage, and hence battery drain while achieving instant
response times and smooth scrolling to a human eye is a far more important
goal."

From the performance page:
[https://sw.kovidgoyal.net/kitty/performance.html](https://sw.kovidgoyal.net/kitty/performance.html)

~~~
Jyaif
That... doesn't make any sense.

~~~
tvmalsv
I think it does if you consider "speed" as meaning response latency and
perceived speed, not data throughput. From what I've read here so far, it
_feels_ fast, while not killing your battery with bulk cat'ing of text. That's
my take on it anyway. Just now going to download and try out...

EDIT/Whinging: Welp, scratch that, kitty requires an OS X one version higher
than what apple will allow me to install. And while it _is_ an older MBP from
2010, at least it's fast and reliable. AND it has the multitude of ports that
I like. And the magsafe.

I'm sure I'm venting into an echo changer, but, here goes. Why won't Apple
simply provide me (an option to buy) a modern solid mid-level 15" rMBP for
under $2000. I bought mine for $1700 and it came with a $200 ipod as a gift
(sold on eBay).

Give me that. A rMBP, with all the ports, plus the new USB-C. They could leave
out some of the stuff that's pricy.

Ya, give me a new version of what I have, and will last at least another 8
years (fully supported by MacOS releases), and price it under $2000. That I
would buy. When I replace this one, I'm just going to have to buy something to
linux or Windows (probably both, realistically), since I've been priced out
the product I would have normally purchased and recommended.

------
jaxn
I wish this ran in Windows so I could use it with WSL.

WSL desperately needs a good terminal.

~~~
Svenskunganka
Mintty works great for me. Their wsltty installer works wonders:
[https://github.com/mintty/wsltty](https://github.com/mintty/wsltty)

------
gravelc
Wow! Really like it. The windows organisation is well done. Usually just use
whatever comes with Ubuntu, but this is much nicer. As an aside, had to add
TERM=xterm-256color to my Raspberry Pi's .bashrc to get it to play nice when I
SSH in from Kitty (otherwise commands like 'clear' don't work).

~~~
aumerle
[https://sw.kovidgoyal.net/kitty/faq.html#i-get-errors-
about-...](https://sw.kovidgoyal.net/kitty/faq.html#i-get-errors-about-the-
terminal-being-unknown-or-opening-the-terminal-failing-when-sshing-into-a-
different-computer)

~~~
gravelc
Thanks - missed that.

------
WillKirkby
Seems to render The Emoji Demo [0] nice and buttery smooth, though the
skintone cube scene appears a tad broken. Quite impressed.

[0]
[http://www.pouet.net/prod.php?which=76627](http://www.pouet.net/prod.php?which=76627)

------
ptman
How does this compare to alacritty?

~~~
the_duke
Alacritty is quite buggy and not very maintained, the author doesn't put a lot
of work in except the occasional small merge. (They still haven't finished the
scrollback support branch that's been open for ages).

I've switched to kitty and am much happier.

~~~
beefsack
This is less of an issue if you use a multiplexer like tmux, so how
appropriate Alacritty is depends on how you use it.

~~~
sime2009
The big idea of Alacritty is that it uses the GPU for superfast rendering and
updates. But relying on tmux for scrolling seems to be a case of "penny wise
and pound foolish". Having to round trip key presses and updates through a
separate and possibly remote process (tmux) just to do scrolling, introduces a
bunch of latency. "Normal" emulators with built in scrolling don't have this
problem. Scrolling is purely local operation.

~~~
JdeBP
It's not for _scrolling_ , it is for _scrollback_.

~~~
sime2009
You are right. Replace 'scrolling' with 'scrollback' when you read my comment.
:)

------
jbb67
I don't even know where to start with this. We had terminals that were way
faster than you could type or see 30 years ago. They didn't need a GPU and ran
on a CPU 1000 times slower than what we have now.

If this is progress... I'm not sure I want it

~~~
syn0byte
They were also char based display at something like 320x240 resolution and
maybe 16-256 colors.

Modern displays at 1920x1080 in millions of colors.

30 years ago a terminal was the whole display and nothing more. Now its a
single window amid dozens of other windows including content ranging from high
definition video to real-time rasterized 3D graphics.

Yes, that's progress.

~~~
lytedev
Also, as others have noted, with many new layers of abstraction between user
and system including the compositor, window manager, display manager, display
server, and probably a host of others within the operating system and places
I'm unfamiliar with.

------
toastal
Everyone is talking about speed and latency, but how is it on battery
consumption?

------
duniel
I grew up and lived with urxvt and xterm for the longest time. I switched to
Kitty full time, and I do not regret it.

I wish Alacritty had better scrollback, I'd give that a go as well. But for
now, I am sticking to Kitty.

------
stuartaxelowen
Why use the GPU? Is terminal redraw latency really this big of a problem?

~~~
dunpeal
It is if you have very large windows display a large amount of text with
plenty of redraws.

Data analysis and data science comes to mind.

------
C4K3
I tried kitty very briefly, but its startup speed feels very slow. As someone
who prefers using my WM to manage multiple windows, a slow startup speed is
absolutely killer for me.

Edit: I did some basic tests using slow motion recording on my phone, and this
is how long I found it took a few terminal emulators to start: (Recorded in
240FPS)

\- rxvt-unicode 33 frames

\- kitty 298 frames

\- lilyterm 20 frames

\- sakura 55 frames

Alacritty apparently accepts input before it is able to display anything. It
took 53 frames before it would take input, and 180 frames (total from startup)
before it displayed anything.

~~~
b3n
You might like alacritty[1].

[1] [https://github.com/jwilm/alacritty](https://github.com/jwilm/alacritty)

~~~
snvzz
No, he wouldn't. Latency matters to him, and alacritty has abysmal latency.

[https://danluu.com/term-latency/](https://danluu.com/term-latency/)

------
I_complete_me
I've installed it and I like it. Much easier than having to install tmux and
built-in copy paste. I'm not a power user but I will certainly be using this.
Good work.

------
iddan
This is the real shit
[https://github.com/jwilm/alacritty](https://github.com/jwilm/alacritty)

~~~
eigenloss
> build: failing

:(

~~~
Gracana
The build on rust nightly is failing. The stable build is fine.

------
nimbius
Ill give that Kitty is featureful. Not sure how many times ill need to render
something i cant invoke from feh in the term, but its a neat hat trick.

but fast? on an intel haswell graphics card Im seeing input latency. Sure, its
technically beautiful, but the st terminal from suckless.org is lightning fast
compared to this.

update: this is on a 2015 macbook with retina running funtoo, so this may be a
performance consideration specific to the hardware.

~~~
snvzz
It's not that featureful. It can't even handle bitmap fonts, only slow and
blurry truetype fonts.

------
orsenthil
The developer is of the Calibre fame. I had little hesitancy on the UI aspects
of this project, but I am completely surprised. Ready to give a try.

------
tobias__
I like KiTTY on Windows. If you want it to be more visually appealing than
PuTTY, I found this repository helpful: [https://github.com/yograf/kitty-
solarized](https://github.com/yograf/kitty-solarized)

Clone it/download the .zip and replace the kitty.exe with a recent one

~~~
mikelward
Different Kitty? This one is Linux/macOS only.

~~~
ObsoleteNerd
Yeah OP needs to seriously reconsider the name.

[http://www.9bis.net/kitty/](http://www.9bis.net/kitty/)

------
oarfish
I wish this would support easy theming so I could make it a drop-in
replacement for iTerm in which I use Solarized.

~~~
ethelward
Like this?

[https://sw.kovidgoyal.net/kitty/conf.html#color-
scheme](https://sw.kovidgoyal.net/kitty/conf.html#color-scheme)

------
xgantan
Just tried kitty on MacOS -- Loved it. The diff and icat tools are must-haves.
Won't use iTerm anymore

------
jarvuschris
Has anyone found a way to do a visor / "hotkey window" like with visor or
iterm?

~~~
brandonmenc
Yeah, without this, it's pretty useless imo.

------
mega-tux
How "bad" is libvte?
[https://gitlab.gnome.org/GNOME/vte](https://gitlab.gnome.org/GNOME/vte) There
are a lot of terminals using it, like my current fav. Tilix (using D lang)

------
hestefisk
Echo comments on rxvt. It’s blazingly fast and customisable (set fg white and
bg gray8 in .Xresources). It has full Unicode support too. Firing it up on my
10 year old FreeBSD workstation is still snappier than macOS or Win10 WSL will
ever be.

------
brotherjerky
Used (and enjoyed it) -- just wish it were in Debian Stable (or backports)
already.

~~~
cosmojg
It will be in the next stable! You can install it from Testing or Sid.

------
muhammadusman
I can't seem to get the config changes to show up on my install, is there
something I'm missing in my setup? I update the config, save it, quit Kitty
and start it up again, nothing still :/

~~~
Spiritus
The file is in a different location depending on OS. For example on macOS it’s
~/Library/Preferences/kitty/kitty.conf

~~~
muhammadusman
Thanks, didn't realize that :o

------
Synroc
How is this going to work with OpenGL's deprecation on MacOS?

~~~
Volt
Like everything else, it will probably use a shim.

------
harel
Is there a repository for ubuntu? I tried to use the binary but don't even
have scroll bars on the window, and when I ssh somewhere I cannot start a
screen session

------
noloblo
1\. no preferences window 2\. no resize option for text 3\. "Cannot find
terminfo entry for 'xterm-kitty'." ie screen doesn't work in ssh

makes this hardly usable

~~~
cosmojg
1\. There's a configuration file, and it's incredibly well-documented. You can
simply reference the default config, read the manpages, or read the available
documentation for help. See:

[https://sw.kovidgoyal.net/kitty](https://sw.kovidgoyal.net/kitty)

2\. There is a resize option for text. Hell, in my experience, Kitty seems to
have the most powerful font management of any terminal. See:

[https://sw.kovidgoyal.net/kitty/conf.html#conf-kitty-
fonts](https://sw.kovidgoyal.net/kitty/conf.html#conf-kitty-fonts)

3\. That's because the machine you're SSHing into doesn't have Kitty's
terminfo files. That's easily fixed by running "kitty +kitten ssh myserver"
where "myserver" is the IP/domain of your server. See:

[https://sw.kovidgoyal.net/kitty/faq.html#i-get-errors-
about-...](https://sw.kovidgoyal.net/kitty/faq.html#i-get-errors-about-the-
terminal-being-unknown-or-opening-the-terminal-failing-when-sshing-into-a-
different-computer)

------
laurent123456
Another terminal emulator for systems that have already plenty of very good
terminal emulators. A version for Windows on the other hand would have been
very useful.

------
Zardoz84
I would try it if there is a way to imitate Yakuake behaviour. The way that
kitty allows to be controlled looks more powerful that Yakuake exposed dbus
API.

------
vlunkr
I tried this recently. Unfortunately it doesn’t support bitmap fonts, so I
can’t use Terminus there.

------
rawoke083600
I live and die by my emulator(Guake) :) Can't live without it !

~~~
Toorkit
I do something similar. I put any tty's I use in i3wm's scratch buffer and
move it to the top. A key press then pops it up like a drop-down window
without an animation.

I quite like Kitty compared to urxvt, which I was using before. Just looking
at cmatrix, you can tell the difference. Smooth characters dropping down in
kitty, sketchy 10fps on urxvt.

The only thing that bothers me is the theme being set in the config file. For
urxvt, I put the theme separately in xresources and have a shell alias to
change it (which then requires opening a new terminal, but that's what I use
tmux for).

Maybe I can do something similar for Kitty, haven't really read the docs.

------
ionforce
Does it support transparent/translucent windows?

------
rezeroed
What is this shortcut?

Increase background opacity ctrl+shift+a>m

------
joshu
Does it have an equivalent to iterm2’s imgcat?

~~~
aumerle
[https://sw.kovidgoyal.net/kitty/graphics-
protocol.html](https://sw.kovidgoyal.net/kitty/graphics-protocol.html)

------
amelius
How do we install the GPU without a terminal?

~~~
comesee
Software emulated gpu library backend

~~~
amelius
On that note, it would be cool if QEMU could emulate a GPU.

~~~
comesee
You can make that happen :) FOSS drivers for Nvidia/AMD/intel gpus could serve
as a basis for the hardware interface you target. I would probably target an
Intel GPU.

------
baybal2
How fast it is compared to VTE?

------
zumu
is there support for any sort of 'guake' drop down terminal mode?

~~~
feydaykyn
The author won't integrate this for portabilities reasons :
[https://github.com/kovidgoyal/kitty/issues/45](https://github.com/kovidgoyal/kitty/issues/45)
"This is not possible to do in a cross-platform manner, as it depends on the
details of the desktop environment/window manager. Really this function should
be implemented in the window manager, so it can be performed with any window."

There are a few pointers for Linux solutions in the issue.

------
heroprotagonist
I was surprised that kitty became 'GPU based'. Then I realized it's an
entirely different tool than the kitty fork of putty.

I do wish creators of these tools would search for existing names to see if
they are already in use. I would not mind if they were tools with sufficiently
different purpose. But this just confuses users (and potential users) of
either one.

~~~
kimat
9th issue on their tracker:
[https://github.com/kovidgoyal/kitty/issues/9](https://github.com/kovidgoyal/kitty/issues/9)

~~~
suspectdoubloon
Looks like its unlikely to get changed, as stated in the last comment of the
thread by the owner.

[https://github.com/kovidgoyal/kitty/issues/9#issuecomment-41...](https://github.com/kovidgoyal/kitty/issues/9#issuecomment-418566309)

------
cjbprime
Wonder how it compares to [https://hyper.is/](https://hyper.is/) \-- Hyper
isn't directly bound to OpenGL, but it uses Electron, and maybe ends up in a
similar place?

~~~
_sdegutis
[https://github.com/zeit/hyper/issues?utf8=%E2%9C%93&q=is%3Ai...](https://github.com/zeit/hyper/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+slow)

~~~
cdaringe
Gaaaazoooks!

