mirror of
https://github.com/kovidgoyal/kitty.git
synced 2024-08-16 18:10:32 +03:00
557 lines
21 KiB
Plaintext
557 lines
21 KiB
Plaintext
= kitty - A terminal emulator
|
|
:toc:
|
|
:toc-placement!:
|
|
// START_SHORTCUT_BLOCK
|
|
:sc_close_tab: pass:quotes[`ctrl+shift+q`]
|
|
:sc_close_window: pass:quotes[`ctrl+shift+w`]
|
|
:sc_copy_to_clipboard: pass:quotes[`ctrl+shift+c`]
|
|
:sc_decrease_font_size: pass:quotes[`ctrl+shift+minus`]
|
|
:sc_edit_config_file: pass:quotes[`ctrl+shift+f2`]
|
|
:sc_eighth_window: pass:quotes[`ctrl+shift+8`]
|
|
:sc_fifth_window: pass:quotes[`ctrl+shift+5`]
|
|
:sc_first_window: pass:quotes[`ctrl+shift+1`]
|
|
:sc_fourth_window: pass:quotes[`ctrl+shift+4`]
|
|
:sc_increase_font_size: pass:quotes[`ctrl+shift+equal`]
|
|
:sc_input_unicode_character: pass:quotes[`ctrl+shift+u`]
|
|
:sc_kitty_shell_window: pass:quotes[`ctrl+shift+escape`]
|
|
:sc_move_tab_backward: pass:quotes[`ctrl+shift+,`]
|
|
:sc_move_tab_forward: pass:quotes[`ctrl+shift+.`]
|
|
:sc_move_window_backward: pass:quotes[`ctrl+shift+b`]
|
|
:sc_move_window_forward: pass:quotes[`ctrl+shift+f`]
|
|
:sc_move_window_to_top: pass:quotes[`ctrl+shift+``]
|
|
:sc_new_os_window: pass:quotes[`ctrl+shift+n`]
|
|
:sc_new_tab: pass:quotes[`ctrl+shift+t`]
|
|
:sc_new_window: pass:quotes[`ctrl+shift+enter`]
|
|
:sc_next_layout: pass:quotes[`ctrl+shift+l`]
|
|
:sc_next_tab: pass:quotes[`ctrl+shift+right`]
|
|
:sc_next_window: pass:quotes[`ctrl+shift+]`]
|
|
:sc_ninth_window: pass:quotes[`ctrl+shift+9`]
|
|
:sc_pass_selection_to_program: pass:quotes[`ctrl+shift+o`]
|
|
:sc_paste_from_clipboard: pass:quotes[`ctrl+shift+v`]
|
|
:sc_paste_from_selection: pass:quotes[`ctrl+shift+s` or `shift+insert`]
|
|
:sc_previous_tab: pass:quotes[`ctrl+shift+left`]
|
|
:sc_previous_window: pass:quotes[`ctrl+shift+[`]
|
|
:sc_restore_font_size: pass:quotes[`ctrl+shift+backspace`]
|
|
:sc_run_simple_kitten_text_url_hints: pass:quotes[`ctrl+shift+e`]
|
|
:sc_scroll_end: pass:quotes[`ctrl+shift+end`]
|
|
:sc_scroll_home: pass:quotes[`ctrl+shift+home`]
|
|
:sc_scroll_line_down: pass:quotes[`ctrl+shift+down` or `ctrl+shift+j`]
|
|
:sc_scroll_line_up: pass:quotes[`ctrl+shift+up` or `ctrl+shift+k`]
|
|
:sc_scroll_page_down: pass:quotes[`ctrl+shift+page_down`]
|
|
:sc_scroll_page_up: pass:quotes[`ctrl+shift+page_up`]
|
|
:sc_second_window: pass:quotes[`ctrl+shift+2`]
|
|
:sc_set_tab_title: pass:quotes[`ctrl+shift+alt+t`]
|
|
:sc_seventh_window: pass:quotes[`ctrl+shift+7`]
|
|
:sc_show_scrollback: pass:quotes[`ctrl+shift+h`]
|
|
:sc_sixth_window: pass:quotes[`ctrl+shift+6`]
|
|
:sc_tenth_window: pass:quotes[`ctrl+shift+0`]
|
|
:sc_third_window: pass:quotes[`ctrl+shift+3`]
|
|
:sc_toggle_fullscreen: pass:quotes[`ctrl+shift+f11`]
|
|
// END_SHORTCUT_BLOCK
|
|
|
|
++++
|
|
<img align="left" role="left" src="logo/kitty.png?raw=true"/>
|
|
++++
|
|
image::https://travis-ci.org/kovidgoyal/kitty.svg?branch=master[Build status, link=https://travis-ci.org/kovidgoyal/kitty]
|
|
|
|
== Major Features
|
|
|
|
* Uses OpenGL for rendering, offloads rendering to the GPU for link:#performance[lower system
|
|
load] and buttery smooth scrolling. Uses threaded rendering to minimize input
|
|
latency.
|
|
|
|
* Supports all modern terminal features: link:graphics-protocol.asciidoc[graphics (images)], unicode,
|
|
true-color, OpenType ligatures, mouse protocol, focus tracking, bracketed paste and so on.
|
|
|
|
* Supports tiling multiple terminal windows side by side in different
|
|
link:#layouts[layouts] without needing to use an extra program like tmux
|
|
|
|
* Can be link:remote-control.asciidoc[controlled from scripts or the shell prompt], even over SSH.
|
|
|
|
* Has a framework for _kittens_, small terminal programs that can be used to extend kitty's functionality.
|
|
For example, they are used for link:#unicode-input[Unicode input] and link:#url-hints[URL hints].
|
|
|
|
* Supports link:#startup-sessions[startup sessions] which allow you to specify the window/tab layout,
|
|
working directories and programs to run on startup.
|
|
|
|
* Cross-platform support: kitty currently works on Linux and macOS, but because
|
|
it uses only OpenGL for rendering, it should be trivial to port to other
|
|
platforms.
|
|
|
|
* Allows you to open link:#the-scrollback-buffer[the scrollback buffer] in a separate
|
|
window using arbitrary programs of your choice. This is useful for browsing
|
|
the history comfortably in a pager or editor.
|
|
|
|
|
|
image::screenshot.png?raw=true[Screenshot, showing three programs in the "Tall" layout]
|
|
|
|
toc::[]
|
|
|
|
|
|
== Installation
|
|
|
|
kitty is designed to run from source, for easy hackability. Make sure
|
|
the following dependencies are installed first.
|
|
|
|
=== Dependencies
|
|
|
|
* python >= 3.5
|
|
* harfbuzz >= 1.5.0
|
|
* zlib
|
|
* libpng
|
|
* freetype (not needed on macOS)
|
|
* fontconfig (not needed on macOS)
|
|
* ImageMagick (optional, needed to use the `kitty icat` tool to display images in the terminal)
|
|
* gcc or clang (required only for building)
|
|
* pkg-config (required only for building)
|
|
* For building on Linux in addition to the above dependencies you might also need to install the `-dev` packages for `xcursor`, `xrandr`, `xinerama`, `libgl1-mesa` and `xkbcommon-x11`, if they are not already installed by your distro.
|
|
|
|
=== Install and run from source
|
|
|
|
....
|
|
git clone https://github.com/kovidgoyal/kitty && cd kitty
|
|
....
|
|
|
|
Now build the C parts of kitty with the following command:
|
|
|
|
....
|
|
make
|
|
....
|
|
|
|
You can run kitty, as:
|
|
|
|
....
|
|
python3 .
|
|
....
|
|
|
|
=== Linux packages
|
|
|
|
* Arch Linux: AUR git package https://aur.archlinux.org/packages/kitty-git/
|
|
|
|
* Arch Linux: AUR stable package https://aur.archlinux.org/packages/kitty/
|
|
|
|
* NixOS / nixpkgs: https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/misc/kitty/default.nix
|
|
|
|
* Gentoo: https://packages.gentoo.org/packages/x11-terms/kitty
|
|
|
|
* openSUSE: https://build.opensuse.org/package/show/X11:terminals/kitty
|
|
|
|
=== macOS packages
|
|
|
|
kitty is available as a macOS `dmg` file for easy installation from the
|
|
link:../../releases[releases page]. You can also run kitty directly from
|
|
source using the above install from source instructions, after installing its
|
|
dependencies using http://brew.sh/[brew] or a similar package manager.
|
|
|
|
|
|
== Design philosophy
|
|
|
|
kitty is designed for power keyboard users. To that end all its controls
|
|
work with the keyboard (although it fully supports mouse interactions as
|
|
well). Its configuration is a simple, human editable, single file for
|
|
easy reproducibility (I like to store config files in source control).
|
|
|
|
The code in kitty is designed to be simple, modular and hackable. It is
|
|
written in a mix of C (for performance sensitive parts) and Python (for
|
|
easy hackability of the UI). It does not depend on any large and complex
|
|
UI toolkit, using only OpenGL for rendering everything.
|
|
|
|
Finally, kitty is designed from the ground up to support all modern
|
|
terminal features, such as unicode, true color, bold/italic fonts, text
|
|
formatting, etc. It even extends existing text formatting escape codes,
|
|
to add support for features not available elsewhere, such as colored and
|
|
styled (curly) underlines. One of the design goals of kitty is to be
|
|
easily extensible so that new features can be added in the future with
|
|
relatively less effort.
|
|
|
|
== Tabs and Windows
|
|
|
|
kitty is capable of running multiple programs organized into tabs and
|
|
windows. The top level of organization is the _Tab_. Each tab consists
|
|
of one or more _windows_. The windows can be arranged in multiple
|
|
different layouts, like windows are organized in a tiling window
|
|
manager. The keyboard controls (which are all customizable) for tabs and
|
|
windows are:
|
|
|
|
[[scrolling-shortcuts]]
|
|
[options="header"]
|
|
|
|
=== Scrolling
|
|
|
|
|===
|
|
|Action |Shortcut
|
|
|
|
|Scroll line up | {sc_scroll_line_up}
|
|
|Scroll line down | {sc_scroll_line_down}
|
|
|Scroll page up | {sc_scroll_page_up}
|
|
|Scroll page down | {sc_scroll_page_down}
|
|
|Scroll to top | {sc_scroll_home}
|
|
|Scroll to bottom | {sc_scroll_end}
|
|
|
|
|===
|
|
|
|
[options="header"]
|
|
|
|
=== Tabs
|
|
|
|
|===
|
|
|Action |Shortcut
|
|
|
|
|New tab | {sc_new_tab}
|
|
|Close tab | {sc_close_tab}
|
|
|Next tab | {sc_next_tab}
|
|
|Previous tab | {sc_previous_tab}
|
|
|Next layout | {sc_next_layout}
|
|
|Move tab forward | {sc_move_tab_forward}
|
|
|Move tab backward | {sc_move_tab_backward}
|
|
|Set tab title | {sc_set_tab_title}
|
|
|
|
|===
|
|
|
|
|
|
[options="header"]
|
|
|
|
=== Windows
|
|
|
|
|===
|
|
|Action |Shortcut
|
|
|
|
|New window | {sc_new_window}
|
|
|New OS window| {sc_new_os_window}
|
|
|Close window | {sc_close_window}
|
|
|Next window | {sc_next_window}
|
|
|Previous window | {sc_previous_window}
|
|
|Move window forward | {sc_move_window_forward}
|
|
|Move window backward | {sc_move_window_backward}
|
|
|Move window to top | {sc_move_window_to_top}
|
|
|Focus specific window (windows are counted clockwise from the top left corner) | {sc_first_window}, {sc_second_window} ... {sc_tenth_window}
|
|
|
|
|===
|
|
|
|
=== Miscellaneous
|
|
|
|
|===
|
|
|Action |Shortcut
|
|
|
|
|Increase font size | {sc_increase_font_size}
|
|
|Decrease font size | {sc_decrease_font_size}
|
|
|Restore font size | {sc_restore_font_size}
|
|
|Toggle fullscreen | {sc_toggle_fullscreen}
|
|
|Input unicode character | {sc_input_unicode_character}
|
|
|Click URL using the keyboard | {sc_run_simple_kitten_text_url_hints}
|
|
|Pass current selection to program | {sc_pass_selection_to_program}
|
|
|Edit kitty config file | {sc_edit_config_file}
|
|
|Open a kitty shell | {sc_kitty_shell}
|
|
|===
|
|
|
|
|
|
== Controlling kitty from scripts
|
|
|
|
You can control kitty from the command line/scripts by sending it messages.
|
|
You can tell kitty to open/close/rename tabs and windows. You can even send
|
|
arbitrary input/text to any specified window. Messages can be sent using `kitty
|
|
@`. Note that you must set `allow_remote_control yes` in your
|
|
link:kitty/kitty.conf[kitty.conf] to use this feature. It even works over SSH
|
|
connections. This feature is best illustrated with a
|
|
link:remote-control.asciidoc[tutorial].
|
|
|
|
|
|
== The scrollback buffer
|
|
|
|
kitty supports scrolling back to view history, just like most terminals. You
|
|
can use either the <<scrolling-shortcuts,keyboard shortcuts>> or the mouse
|
|
scroll wheel to do so. However, kitty has an extra, neat feature. Sometimes
|
|
you need to explore the scrollback buffer in more detail, maybe search for some
|
|
text or refer to it side-by-side while typing in a follow-up command. kitty
|
|
allows you to do this by pressing the {sc_show_scrollback} key-combination,
|
|
which will open the scrollback buffer in your favorite pager program (which is
|
|
`less` by default). Colors and text formatting are preserved. You can explore
|
|
the scrollback pager comfortably within the pager.
|
|
|
|
|
|
== Unicode input
|
|
|
|
You can input unicode characters by name, hex code, recently used and even an editable favorites list.
|
|
Press {sc_input_unicode_character} to start the unicode input widget, shown below.
|
|
|
|
image::unicode.png?raw=true[Unicode input widget, showing selection of unicode characters by name]
|
|
|
|
In Code mode, you enter a unicode character by typing in the hex code for the
|
|
character and pressing enter, for example, type in 2716 and press enter to get
|
|
✖. You can also choose a character from the list of recently used characters by
|
|
typing a leading period and then the two character index and pressing Enter.
|
|
|
|
In Name mode you instead type words from the character name and use the arrow
|
|
keys/tab to select the character from the displayed matches. You can also type
|
|
a leading period and the index for the match if you dont like to use arrow
|
|
keys.
|
|
|
|
== URL hints
|
|
|
|
kitty has a _hints mode_ to click URLs visible on the screen by using only the keyboard.
|
|
Press {sc_run_simple_kitten_text_url_hints} to activate hints mode, as shown below.
|
|
|
|
image::hints_mode.png?raw=true[URL hints mode]
|
|
|
|
== Miscellaneous features
|
|
|
|
* You can also hold down `ctrl+shift` and click on a URL to open it in a browser.
|
|
* You can double click to select a word and triple click to select a line.
|
|
* You can right click to extend a previous selection
|
|
|
|
|
|
== Layouts
|
|
|
|
Currently, there are five layouts available,
|
|
|
|
* Stack -- Only a single maximized window is shown at a time
|
|
* Tall -- One window is shown full height on the left, the rest of the windows are shown one below the other on the right
|
|
* Grid -- All windows are shown in a grid
|
|
* Horizontal -- All windows are shown side-by-side
|
|
* Vertical -- All windows are shown one below the other
|
|
|
|
You can switch between layouts using the {sc_next_layout} key combination. You can
|
|
also create shortcuts to select particular layouts, and choose which layouts
|
|
you want to enable/disable, see link:kitty/kitty.conf[kitty.conf] for examples.
|
|
|
|
Writing a new layout only requires about fifty lines of code, so if there is
|
|
some layout you want, take a look at link:kitty/layout.py[layout.py] and submit
|
|
a pull request!
|
|
|
|
|
|
== Configuration
|
|
|
|
kitty is highly customizable, everything from keyboard shortcuts, to painting
|
|
frames-per-second. See the heavily commented link:kitty/kitty.conf[default
|
|
config file] for an overview of all customization possibilities.
|
|
|
|
By default kitty looks for a config file in the OS config directories (usually
|
|
`~/.config/kitty/kitty.conf` and additionally
|
|
`~/Library/Preferences/kitty/kitty.conf` on macOS) but you can pass a specific
|
|
path via the `--config` option or use the `KITTY_CONFIG_DIRECTORY` environment
|
|
variable. See the help for the `--config` option in `kitty --help` for full
|
|
details. You can also dump the current configuration kitty is using using the
|
|
`--debug-config` option.
|
|
|
|
|
|
== Startup Sessions
|
|
|
|
You can control the tabs, window layout, working directory, startup
|
|
programs, etc. by creating a "session" file and using the `--session`
|
|
command line flag. For example:
|
|
|
|
....
|
|
# Set the window layout for the current tab
|
|
layout tall
|
|
# Set the working directory for windows in the current tab
|
|
cd ~
|
|
# Create a window and run the specified command in it
|
|
launch zsh
|
|
launch vim
|
|
# Set the title for the next window
|
|
title Chat with x
|
|
launch irssi --profile x
|
|
|
|
# Create a new tab (the part after new_tab is the optional tab name which will
|
|
# be displayed in the tab bar, if omitted, the title of the active window will
|
|
# be used instead)
|
|
new_tab my tab
|
|
cd ~/somewhere
|
|
# Set the layouts allowed in this tab
|
|
enabled_layouts tall, stack
|
|
# Set the current layout
|
|
layout stack
|
|
launch zsh
|
|
# Make the current window the active (focused) window
|
|
focus
|
|
launch emacs
|
|
....
|
|
|
|
== Protocol Extensions
|
|
|
|
kitty has a few extensions to the xterm protocol, to enable advanced features,
|
|
see link:protocol-extensions.asciidoc[Protocol Extensions].
|
|
|
|
|
|
== Font control
|
|
|
|
kitty has extremely flexible and powerful font selection features. You can
|
|
specify individual families for the regular, bold, italic and bold+italic
|
|
fonts. You can even specify specific font families for specific ranges of
|
|
unicode characters. This allows precise control over text rendering. It can
|
|
come in handy for applications like powerline, without the need to use patched
|
|
fonts. See the various font related configuration directives in the
|
|
link:kitty/kitty.conf[config file].
|
|
|
|
== Performance
|
|
|
|
The main goals for kitty performance are user perceived latency while typing
|
|
and "smoothness" while scrolling as well as CPU usage. kitty tries hard to find
|
|
an optimum balance for these. To that end it keeps a cache of each rendered
|
|
glyph in video RAM so that font rendering is not a bottleneck. Interaction
|
|
with child programs takes place in a separate thread from rendering, to improve
|
|
smoothness.
|
|
|
|
There are two parameters you can tune to adjust the performance. ``repaint_delay``
|
|
and ``input_delay``. These control the artificial delays introduced into the
|
|
render loop to reduce CPU usage. See the link:kitty/kitty.conf[config file] for details.
|
|
See also the ``sync_to_monitor`` option to further decrease latency at the cost
|
|
of some link:https://en.wikipedia.org/wiki/Screen_tearing[tearing] while scrolling.
|
|
|
|
You can generate detailed per-function performance data using
|
|
link:https://github.com/gperftools/gperftools[gperftools]. Build kitty with
|
|
`make profile` which will create an executable called `kitty-profile`. Run
|
|
that and perform the task you want to analyse, for example, scrolling a large
|
|
file with `less`. After you quit, function call statistics will be printed to
|
|
`stdout` and you can use tools like *kcachegrind* for more detailed analysis.
|
|
|
|
Here are some CPU usage numbers for the task of scrolling a file continuously in less.
|
|
The CPU usage is for the terminal process and X together and is measured using htop.
|
|
The measurements are taken at the same font and window size for all terminals on a
|
|
`Intel(R) Core(TM) i7-4820K CPU @ 3.70GHz` CPU with a
|
|
`Advanced Micro Devices, Inc. [AMD/ATI] Cape Verde XT [Radeon HD 7770/8760 / R7 250X]` GPU.
|
|
|
|
|===
|
|
| Terminal | CPU usage (X + terminal)
|
|
|
|
| kitty | 6 - 8%
|
|
| xterm | 5 - 7% (but scrolling was extremely janky)
|
|
| termite | 10 - 13%
|
|
| urxvt | 12 - 14%
|
|
| gnome-terminal | 15 - 17%
|
|
| konsole | 29 - 31%
|
|
|
|
|===
|
|
|
|
As you can see, kitty uses much less CPU than all terminals, except xterm, but
|
|
its scrolling "smoothness" is much better than that of xterm (at least to my,
|
|
admittedly biased, eyes).
|
|
|
|
== Note for Linux/macOS packagers
|
|
|
|
While kitty does use python, it is not a traditional python package, so please do not install it in site-packages.
|
|
Instead run,
|
|
|
|
```
|
|
python3 setup.py linux-package
|
|
```
|
|
|
|
This will install kitty into the directory `linux-package`. You can run kitty
|
|
with `linux-package/bin/kitty`. All the files needed to run kitty will be in
|
|
`linux-package/lib/kitty`. The terminfo file will be installed into
|
|
`linux-package/share/terminfo`. Simply copy these files into `/usr` to install
|
|
kitty. In other words, `linux-package` is the staging area into which kitty is
|
|
installed. You can choose a different staging area, by passing the `--prefix`
|
|
argument to `setup.py`.
|
|
|
|
You should probably split kitty into two packages, `kitty-terminfo` that
|
|
installs the terminfo file and `kitty` that installs the main program.
|
|
This allows users to install the terminfo file on servers into which they ssh,
|
|
without needing to install all of kitty.
|
|
|
|
You also need `tic` to compile the terminfo files, it is usually found in the development package of `ncurses`
|
|
|
|
This applies to creating packages for kitty for macOS package managers such as
|
|
brew or MacPorts as well.
|
|
|
|
|
|
== Frequently Asked Questions
|
|
|
|
=== Some special symbols are rendered small/truncated in kitty?
|
|
|
|
The number of cells a unicode character takes up are controlled by the unicode
|
|
standard. All characters are rendered in a single cell unless the unicode
|
|
standard says they should be rendered in two cells. When a symbol does not fit,
|
|
it will either be rescaled to be smaller or truncated (depending on how much
|
|
extra space it needs). This is often different from other terminals which just
|
|
let the character overflow into neighboring cells, which is fine if the
|
|
neighboring cell is empty, but looks terrible if it is not.
|
|
|
|
Some programs, like powerline, vim with fancy gutter symbols/status-bar, etc.
|
|
misuse unicode characters from the private use area to represent symbols. Often
|
|
these symbols are square and should be rendered in two cells. However, since
|
|
private use area symbols all have their width set to one in the unicode
|
|
standard, kitty renders them either smaller or truncated. The exception is if
|
|
these characters are followed by a space or empty cell in which case kitty
|
|
makes use of the extra cell to render them in two cells.
|
|
|
|
=== How do I build kitty.app on macOS?
|
|
|
|
Install `imagemagick`, `optipng` and `librsvg` using `brew` or similar (needed for the logo generation step).
|
|
|
|
And run:
|
|
```
|
|
make app
|
|
```
|
|
|
|
This `kitty.app` unlike the released one does not include its own copy of
|
|
python and the other dependencies. So if you ever un-install/upgrade those dependencies
|
|
you might have to rebuild the app.
|
|
|
|
Note that the released kitty.dmg includes all dependencies, unlike the
|
|
`kitty.app` built above and is built automatically by using the `kitty` branch of
|
|
link:https://github.com/kovidgoyal/build-calibre[build-calibre] however, that
|
|
is designed to run on Linux and is not for the faint of heart.
|
|
|
|
|
|
=== Using a color theme with a background color does not work well in vim?
|
|
|
|
First make sure you have not changed the TERM environment variable, it should
|
|
be `xterm-kitty`. vim uses *background color erase* even if the terminfo file
|
|
does not contain the `bce` capability. This is a bug in vim. You can work around
|
|
it by adding the following to your vimrc:
|
|
|
|
....
|
|
let &t_ut=''
|
|
....
|
|
|
|
See link:https://github.com/kovidgoyal/kitty/blob/master/protocol-extensions.asciidoc#setting-text-styles-colors-in-arbitrary-regions-of-the-screen[here]
|
|
for why kitty does not support background color erase.
|
|
|
|
=== I get errors about the terminal being unknown or opening the terminal failing when SSHing into a different computer?
|
|
|
|
This happens because the kitty terminfo files are not available on the server.
|
|
Either install kitty on the server, or simply copy over the terminfo files,
|
|
using:
|
|
|
|
....
|
|
ssh myserver mkdir -p \~/.terminfo
|
|
infocmp xterm-kitty | ssh myserver "cat > /tmp/kitty.terminfo"
|
|
ssh myserver tic -x -o \~/.terminfo /tmp/kitty.terminfo
|
|
....
|
|
|
|
Really, the correct solution for this is to convince the OpenSSH maintainers to
|
|
have ssh do this automatically when connecting to a server, so that all
|
|
terminals work transparently.
|
|
|
|
|
|
=== How do I change the colors in a running kitty instance?
|
|
|
|
You can either use the
|
|
link:http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Operating-System-Commands[OSC
|
|
terminal escape codes] to set colors or you can enable link:remote-control.asciidoc[remote control]
|
|
for kitty and use `kitty @ set-colors --help`.
|
|
|
|
|
|
=== How do I specify command line options for kitty on macOS?
|
|
|
|
Apple does not want you to use command line options with GUI applications. To
|
|
workaround that limitation, kitty will read command line options from the file
|
|
`<kitty config dir>/macos-launch-services-cmdline` when it is launched
|
|
from the GUI, i.e. by clicking the kitty application icon or using `open -a kitty`.
|
|
Note that this file is *only read* when running via the GUI.
|
|
|
|
You can, of course, also run kitty from a terminal with command line options, using:
|
|
`/Applications/kitty.app/Contents/MacOS/kitty`.
|
|
|
|
And within kitty itself, you can always run kitty using just `kitty` as it
|
|
cleverly adds itself to the PATH.
|
|
|
|
== Resources on terminal behavior
|
|
|
|
http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
|
|
|
|
https://en.wikipedia.org/wiki/C0_and_C1_control_codes
|
|
|
|
https://vt100.net/
|