version 0.25.1

Fixes #5105

build-terminfo

@@ -4,7 +4,6 @@
 
 import glob
 import os
-import re
 import shutil
 import subprocess
 import sys
@@ -13,11 +12,10 @@ import tempfile
 
 def compile_terminfo(base):
     with tempfile.TemporaryDirectory() as tdir:
-        proc = subprocess.run(['tic', '-x', f'-o{tdir}', 'terminfo/kitty.terminfo'], check=True, stderr=subprocess.PIPE)
-        regex = '^"terminfo/kitty.terminfo", line [0-9]+, col [0-9]+, terminal \'xterm-kitty\': older tic versions may treat the description field as an alias$'
-        for error in proc.stderr.decode('utf-8').splitlines():
-            if not re.match(regex, error):
-                print(error, file=sys.stderr)
+        proc = subprocess.run(['tic', '-x', f'-o{tdir}', 'terminfo/kitty.terminfo'], capture_output=True)
+        if proc.returncode != 0:
+            sys.stderr.buffer.write(proc.stderr)
+            raise SystemExit(proc.returncode)
         tfiles = glob.glob(os.path.join(tdir, '*', 'xterm-kitty'))
         if not tfiles:
             raise SystemExit('tic failed to output the compiled kitty terminfo file')
@@ -40,6 +38,13 @@ def generate_terminfo():
 
     with open('terminfo/kitty.terminfo', 'w') as f:
         f.write(generate_terminfo())
+    proc = subprocess.run(['tic', '-CrT0', 'terminfo/kitty.terminfo'], capture_output=True)
+    if proc.returncode != 0:
+        sys.stderr.buffer.write(proc.stderr)
+        raise SystemExit(proc.returncode)
+    tcap = proc.stdout.decode('utf-8').splitlines()[-1]
+    with open('terminfo/kitty.termcap', 'w') as f:
+        f.write(tcap)
 
     compile_terminfo(os.path.join(base, 'terminfo'))
 

bypy/linux/__main__.py

@@ -35,6 +35,9 @@ def binary_includes():
             'expat', 'sqlite3', 'ffi', 'z', 'lzma', 'png16', 'lcms2', 'crypt',
             'iconv', 'pcre', 'graphite2', 'glib-2.0', 'freetype', 'rsync',
             'harfbuzz', 'xkbcommon', 'xkbcommon-x11',
+            # fontconfig is not bundled because in typical brain dead Linux
+            # distro fashion, different distros use different default config
+            # paths for fontconfig.
             'ncursesw', 'readline', 'brotlicommon', 'brotlienc', 'brotlidec',
             'wayland-client', 'wayland-cursor',
         ))) + (

docs/basic.rst

@@ -1,12 +1,13 @@
 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:
+|kitty| is capable of running multiple programs organized into tabs and windows.
+The top level of organization is the :term:`OS window <os_window>`. Each OS
+window consists of one or more :term:`tabs <tab>`. Each tab consists of one or more
+:term:`kitty windows <window>`. The kitty windows can be arranged in multiple
+different :term:`layouts <layout>`, like windows are organized in a tiling
+window manager. The keyboard controls (which are :ref:`all customizable
+<conf-kitty-shortcuts>`) for tabs and windows are:
 
 Scrolling
 ~~~~~~~~~~~~~~
@@ -64,8 +65,9 @@ Focus specific window       :sc:`first_window`, :sc:`second_window` ... :sc:`ten
                             (clockwise from the top-left)
 ========================    =======================
 
-Additionally, you can define shortcuts in :file:`kitty.conf` to focus neighboring
-windows and move windows around (similar to window movement in vim)::
+Additionally, you can define shortcuts in :file:`kitty.conf` to focus
+neighboring windows and move windows around (similar to window movement in
+:program:`vim`)::
 
    map ctrl+left neighboring_window left
    map shift+left move_window right
@@ -77,20 +79,20 @@ You can also define a shortcut to switch to the previously active window::
 
    map ctrl+p nth_window -1
 
-``nth_window`` will focus the nth window for positive numbers (starting from
+:ac:`nth_window` will focus the nth window for positive numbers (starting from
 zero) and the previously active windows for negative numbers.
 
-To switch to the nth OS window, you can define ``nth_os_window``. Only positive
-numbers are accepted, starting from one.
+To switch to the nth OS window, you can define :ac:`nth_os_window`. Only
+positive numbers are accepted, starting from one.
 
 .. _detach_window:
 
-You can define shortcuts to detach the current window and
-move it to another tab or another OS window::
+You can define shortcuts to detach the current window and move it to another tab
+or another OS window::
 
     # moves the window into a new OS window
     map ctrl+f2 detach_window
-    # moves the window into a new Tab
+    # moves the window into a new tab
     map ctrl+f3 detach_window new-tab
     # moves the window into the previously active tab
     map ctrl+f3 detach_window tab-prev
@@ -106,8 +108,8 @@ Similarly, you can detach the current tab, with::
     # asks which OS Window to move the tab into
     map ctrl+f4 detach_tab ask
 
-Finally, you can define a shortcut to close all windows in a tab other than
-the currently active window::
+Finally, you can define a shortcut to close all windows in a tab other than the
+currently active window::
 
     map f9 close_other_windows_in_tab
 
@@ -124,18 +126,18 @@ Action                              Shortcut
 Copy to clipboard                   :sc:`copy_to_clipboard` (also :kbd:`⌘+c` on macOS)
 Paste from clipboard                :sc:`paste_from_clipboard` (also :kbd:`⌘+v` on macOS)
 Paste from selection                :sc:`paste_from_selection`
+Pass selection to program           :sc:`pass_selection_to_program`
 Increase font size                  :sc:`increase_font_size` (also :kbd:`⌘++` on macOS)
 Decrease font size                  :sc:`decrease_font_size` (also :kbd:`⌘+-` on macOS)
 Restore font size                   :sc:`reset_font_size` (also :kbd:`⌘+0` on macOS)
 Toggle fullscreen                   :sc:`toggle_fullscreen` (also :kbd:`⌃+⌘+f` on macOS)
 Toggle maximized                    :sc:`toggle_maximized`
-Input unicode character             :sc:`input_unicode_character` (also :kbd:`⌃+⌘+space` on macOS)
+Input Unicode character             :sc:`input_unicode_character` (also :kbd:`⌃+⌘+space` on macOS)
 Open URL in web browser             :sc:`open_url`
 Reset the terminal                  :sc:`reset_terminal` (also :kbd:`⌥+⌘+r` on macOS)
+Edit :file:`kitty.conf`             :sc:`edit_config_file` (also :kbd:`⌘+,` on macOS)
 Reload :file:`kitty.conf`           :sc:`reload_config_file` (also :kbd:`⌃+⌘+,` on macOS)
 Debug :file:`kitty.conf`            :sc:`debug_config` (also :kbd:`⌥+⌘+,` on macOS)
-Pass current selection to program   :sc:`pass_selection_to_program`
-Edit |kitty| config file            :sc:`edit_config_file` (also :kbd:`⌘+,` on macOS)
 Open a |kitty| shell                :sc:`kitty_shell`
 Increase background opacity         :sc:`increase_background_opacity`
 Decrease background opacity         :sc:`decrease_background_opacity`

docs/binary.rst

@@ -4,17 +4,14 @@ Install kitty
 Binary install
 ----------------
 
-.. |ins| replace:: curl -L :literal:`https://sw.kovidgoyal.net/kitty/installer.sh` | sh /dev/stdin
-
 .. highlight:: sh
 
 You can install pre-built binaries of |kitty| if you are on macOS or Linux using
 the following simple command:
 
-.. parsed-literal::
-    :class: pre
+.. code-block:: sh
 
-    |ins|
+    _kitty_install_cmd
 
 
 The binaries will be installed in the standard location for your OS,
@@ -24,7 +21,7 @@ simply re-run the command.
 
 .. warning::
    **Do not** copy the kitty binary out of the installation folder. If you want
-   to add it to your ``PATH`` create a symlink in :file:`~/.local/bin` or
+   to add it to your :envvar:`PATH`, create a symlink in :file:`~/.local/bin` or
    :file:`/usr/bin` or wherever.
 
 
@@ -33,11 +30,12 @@ Manually installing
 
 If something goes wrong or you simply do not want to run the installer, you can
 manually download and install |kitty| from the `GitHub releases page
-<https://github.com/kovidgoyal/kitty/releases>`_. If you are on macOS, download
-the :file:`.dmg` and install as normal. If you are on Linux, download the tarball
-and extract it into a directory. The |kitty| executable will be in the
+<https://github.com/kovidgoyal/kitty/releases>`__. If you are on macOS, download
+the :file:`.dmg` and install as normal. If you are on Linux, download the
+tarball and extract it into a directory. The |kitty| executable will be in the
 :file:`bin` sub-directory.
 
+
 Desktop integration on Linux
 --------------------------------
 
@@ -60,9 +58,19 @@ particular desktop, but it should work for most major desktop environments.
     sed -i "s|Exec=kitty|Exec=/home/$USER/.local/kitty.app/bin/kitty|g" ~/.local/share/applications/kitty*.desktop
 
 .. note::
-    If you use the venerable `stow <https://www.gnu.org/software/stow/>`_
+    In :file:`kitty-open.desktop`, kitty is registered to handle some supported
+    MIME types. This will cause kitty to take precedence on some systems where
+    the default apps are not explicitly set. For example, you expect to use
+    other GUI file managers to open dir paths when using commands such as
+    :program:`xdg-open`, you should configure the default opener for the MIME
+    type ``inode/directory``::
+
+        xdg-mime default org.kde.dolphin.desktop inode/directory
+
+.. note::
+    If you use the venerable `stow <https://www.gnu.org/software/stow/>`__
     command to manage your manual installations, the following takes care of the
-    above for you (use with :file:`dest=~/.local/stow`)::
+    above for you (use with :code:`dest=~/.local/stow`)::
 
         cd ~/.local/stow
         stow -v kitty.app
@@ -75,44 +83,39 @@ Customizing the installation
 
 * You can install the latest nightly kitty build with ``installer``:
 
-  .. parsed-literal::
-     :class: pre
+  .. code-block:: sh
 
-     |ins| \\
+     _kitty_install_cmd \\
          installer=nightly
 
   If you want to install it in parallel to the released kitty specify a
   different install locations with ``dest``:
 
-  .. parsed-literal::
-     :class: pre
+  .. code-block:: sh
 
-     |ins| \\
+     _kitty_install_cmd \\
          installer=nightly dest=/some/other/location
 
 * You can specify a different install location, with ``dest``:
 
-  .. parsed-literal::
-     :class: pre
+  .. code-block:: sh
 
-     |ins| \\
+     _kitty_install_cmd \\
          dest=/some/other/location
 
 * You can tell the installer not to launch |kitty| after installing it with
   ``launch=n``:
 
-  .. parsed-literal::
-     :class: pre
+  .. code-block:: sh
 
-     |ins| \\
+     _kitty_install_cmd \\
          launch=n
 
 * You can use a previously downloaded dmg/tarball, with ``installer``:
 
-  .. parsed-literal::
-     :class: pre
+  .. code-block:: sh
 
-     |ins| \\
+     _kitty_install_cmd \\
          installer=/path/to/dmg or tarball
 
 

docs/build.rst

@@ -7,21 +7,21 @@ Build from source
 
 .. highlight:: sh
 
-|kitty| is designed to run from source, for easy hack-ability. Make sure
-the following dependencies are installed first.
+|kitty| is designed to run from source, for easy hack-ability. Make sure the
+following dependencies are installed first.
 
 .. note::
-   If you just want to test the latest changes to kitty you dont need to build
+   If you just want to test the latest changes to kitty, you don't need to build
    from source. Instead install the :ref:`latest nightly build <nightly>`.
 
 .. note::
-   If you are making small changes only to the python parts of kitty, there is no need to
-   build kitty at all, instead, assuming you have installed the official kitty
-   binaries, you can simply set the KITTY_DEVELOP_FROM enviroment variable to
-   point to the directory into which you have checked out the kitty source
-   code. kitty will then load its python code from there. You should use a
-   version of the source that matches the binary version as closely as
-   possible, since the two are tightly coupled.
+   If you are making small changes only to the Python parts of kitty, there is
+   no need to build kitty at all, instead, assuming you have installed the
+   official kitty binaries, you can simply set the :envvar:`KITTY_DEVELOP_FROM`
+   enviroment variable to point to the directory into which you have checked out
+   the kitty source code. kitty will then load its Python code from there. You
+   should use a version of the source that matches the binary version as closely
+   as possible, since the two are tightly coupled.
 
 
 Dependencies
@@ -46,7 +46,9 @@ Build-time dependencies:
 
 * ``gcc`` or ``clang``
 * ``pkg-config``
-* For building on Linux in addition to the above dependencies you might also need to install the following packages, if they are not already installed by your distro:
+* For building on Linux in addition to the above dependencies you might also
+  need to install the following packages, if they are not already installed by
+  your distro:
 
   - ``libdbus-1-dev``
   - ``libxcursor-dev``
@@ -77,9 +79,8 @@ You can run |kitty|, as::
 
     ./kitty/launcher/kitty
 
-If that works, you can create a symlink to the launcher in :file:`~/bin` or
-some other directory on your PATH so that you can run |kitty| using
-just ``kitty``.
+If that works, you can create a symlink to the launcher in :file:`~/bin` or some
+other directory on your PATH so that you can run |kitty| using just ``kitty``.
 
 
 Building kitty.app on macOS from source
@@ -90,25 +91,24 @@ Run::
     make app
 
 This :file:`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.
+Python and the other dependencies. So if you ever un-install/upgrade those
+dependencies you might have to rebuild the app.
 
 .. note::
    The released :file:`kitty.dmg` includes all dependencies, unlike the
    :file:`kitty.app` built above and is built automatically by using the
-   `bypy framework <https://github.com/kovidgoyal/bypy>`_ however, that is
+   `bypy framework <https://github.com/kovidgoyal/bypy>`__ however, that is
    designed to run on Linux and is not for the faint of heart.
 
 .. note::
-   Apple disallows certain functionality, such as notifications for unsigned applications.
-   If you need this functionality, you can try signing the built kitty.app with
-   a self signed certificate, see for example, `here
-   <https://stackoverflow.com/questions/27474751/how-can-i-codesign-an-app-without-being-in-the-mac-developer-program/27474942>`_.
+   Apple disallows certain functionality, such as notifications for unsigned
+   applications. If you need this functionality, you can try signing the built
+   :file:`kitty.app` with a self signed certificate, see for example, `here
+   <https://stackoverflow.com/questions/27474751/how-can-i-codesign-an-app-without-being-in-the-mac-developer-program/27474942>`__.
 
 .. note::
-   If you are facing issues with ``linker`` while building,
-   try with a ``brew`` installed python instead, see :iss:`289`
-   for more discussion.
+   If you are facing issues with ``linker`` while building, try with a ``brew``
+   installed Python instead, see :iss:`289` for more discussion.
 
 
 Build and run from source with Nix
@@ -116,13 +116,14 @@ Build and run from source with Nix
 
 On NixOS or any other Linux or macOS system with the Nix package manager
 installed, execute `nix-shell
-<https://nixos.org/guides/nix-pills/developing-with-nix-shell.html>`_ to create
+<https://nixos.org/guides/nix-pills/developing-with-nix-shell.html>`__ to create
 the correct environment to build kitty or use ``nix-shell --pure`` instead to
 eliminate most of the influence of the outside system, e.g. globally installed
 packages. ``nix-shell`` will automatically fetch all required dependencies and
 make them available in the newly spawned shell.
 
-Then proceed with ``make`` or ``make app`` according to the platform specific instructions above.
+Then proceed with ``make`` or ``make app`` according to the platform specific
+instructions above.
 
 
 Debug builds
@@ -132,7 +133,8 @@ A basic debug build can be done with::
 
     make debug
 
-This includes debug info in the binary for better traces. To build with address sanitizer, use::
+This includes debug info in the binary for better traces. To build with address
+sanitizer, use::
 
     make asan
 
@@ -144,46 +146,45 @@ Notes for Linux/macOS packagers
 ----------------------------------
 
 The released |kitty| source code is available as a `tarball`_ from
-`the GitHub releases page <https://github.com/kovidgoyal/kitty/releases>`_.
+`the GitHub releases page <https://github.com/kovidgoyal/kitty/releases>`__.
 
-While |kitty| does use python, it is not a traditional python package, so please
+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 :file:`linux-package`. You can run |kitty|
-with :file:`linux-package/bin/kitty`.  All the files needed to run kitty will be in
-:file:`linux-package/lib/kitty`. The terminfo file will be installed into
-:file:`linux-package/share/terminfo`. Simply copy these files into :file:`/usr` to install
-|kitty|. In other words, :file:`linux-package` is the staging area into which |kitty| is
-installed. You can choose a different staging area, by passing the ``--prefix``
-argument to :file:`setup.py`.
+This will install |kitty| into the directory :file:`linux-package`. You can run
+|kitty| with :file:`linux-package/bin/kitty`. All the files needed to run kitty
+will be in :file:`linux-package/lib/kitty`. The terminfo file will be installed
+into :file:`linux-package/share/terminfo`. Simply copy these files into
+:file:`/usr` to install |kitty|. In other words, :file:`linux-package` is the
+staging area into which |kitty| is installed. You can choose a different staging
+area, by passing the ``--prefix`` argument to :file:`setup.py`.
 
 You should probably split |kitty| into three packages:
 
 :code:`kitty-terminfo`
-    installs the terminfo file
+    Installs the terminfo file
 
 :code:`kitty-shell-integration`
-    installs the shell integration scripts (the contents of the
-    shell-integration directory in the kitty source code, probably to
+    Installs the shell integration scripts (the contents of the
+    shell-integration directory in the kitty source code), probably to
     :file:`/usr/share/kitty/shell-integration`
 
 :code:`kitty`
-    installs the main program
+    Installs the main program
 
-This allows users to install the terminfo and shell integration files on
-servers into which they ssh, without needing to install all of |kitty|.
+This allows users to install the terminfo and shell integration files on servers
+into which they ssh, without needing to install all of |kitty|.
 
 .. note::
-   You need a couple of extra dependencies to build linux-package.
-   :file:`tic` to compile terminfo files, usually found in the
-   development package of :file:`ncurses`. Also, if you are building from
-   a git checkout instead of the released source code tarball, you will
-   need to install the dependencies from ``docs/requirements.txt`` to
-   build the kitty documentation. They can be installed most easily with
-   ``python -m pip -r docs/requirements.txt``.
+   You need a couple of extra dependencies to build linux-package. :file:`tic`
+   to compile terminfo files, usually found in the development package of
+   :file:`ncurses`. Also, if you are building from a git checkout instead of the
+   released source code tarball, you will need to install the dependencies from
+   :file:`docs/requirements.txt` to build the kitty documentation. They can be
+   installed most easily with ``python -m pip -r docs/requirements.txt``.
 
 This applies to creating packages for |kitty| for macOS package managers such as
 Homebrew or MacPorts as well.

docs/changelog.rst

@@ -34,6 +34,51 @@ mouse anywhere in the current command to move the cursor there. See
 Detailed list of changes
 -------------------------------------
 
+0.25.1 [2022-05-26]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- Shell integration: Add a command to :ref:`clone_shell`
+
+- Remote control: Allow using :ref:`Boolean operators <search_syntax>` when constructing queries to match windows or tabs
+
+- Sessions: Fix :code:`os_window_size` and :code:`os_window_class` not applying to the first OS Window (:iss:`4957`)
+
+- Allow using the cwd of the oldest as well as the newest foreground process for :option:`launch --cwd` (:disc:`4869`)
+
+- Bash integration: Fix the value of :opt:`shell_integration` not taking effect if the integration script is sourced in bashrc (:pull:`4964`)
+
+- Fix a regression in the previous release that caused mouse move events to be incorrectly reported as drag events even when a button is not pressed (:iss:`4992`)
+
+- remote file kitten: Integrate with the ssh kitten for improved performance
+  and robustness. Re-uses the control master connection of the ssh kitten to
+  avoid round-trip latency.
+
+- Fix tab selection when closing a new tab not correct in some scenarios (:iss:`4987`)
+
+- A new action :ac:`open_url` to open the specified URL (:pull:`5004`)
+
+- A new option :opt:`select_by_word_characters_forward` that allows changing
+  which characters are considered part of a word to the right when double clicking to select
+  words (:pull:`5103`)
+
+- macOS: Make the global menu shortcut to open kitty website configurable (:pull:`5004`)
+
+- macOS: Add the :opt:`macos_colorspace` option to control what color space colors are rendered in (:iss:`4686`)
+
+- Fix reloading of config not working when :file:`kitty.conf` does not exist when kitty is launched (:iss:`5071`)
+
+- Fix deleting images by row not calculating image bounds correctly (:iss:`5081`)
+
+- Increase the max number of combining chars per cell from two to three, without increasing memory usage.
+
+- Linux: Load libfontconfig at runtime to allow the binaries to work for
+  running kittens on servers without FontConfig
+
+- GNOME: Fix for high CPU usage caused by GNOME's text input subsystem going
+  into an infinite loop when IME cursor position is updated after a done event
+  (:iss:`5105`)
+
+
 0.25.0 [2022-04-11]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -43,6 +88,10 @@ Detailed list of changes
 
 - When pasting URLs at shell prompts automatically quote them. Also allow filtering pasted text and confirm pastes. See :opt:`paste_actions` for details. (:iss:`4873`)
 
+- Change the default value of :opt:`confirm_os_window_close` to ask for confirmation when closing windows that are not sitting at shell prompts
+
+- A new value :code:`last_reported` for :option:`launch --cwd` to use the current working directory last reported by the program running in the terminal
+
 - macOS: When using Apple's less as the pager for viewing scrollback strip out OSC codes as it cant parse them (:iss:`4788`)
 
 - diff kitten: Fix incorrect rendering in rare circumstances when scrolling after changing the context size (:iss:`4831`)

docs/color-stack.rst

@@ -2,25 +2,25 @@ Saving and restoring colors
 ==============================
 
 It is often useful for a full screen application with its own color themes to
-set the default foreground, background, selection and cursor colors and the
-ANSI color table. This allows for various performance optimizations when
-drawing the screen. The problem is that if the user previously used the escape
-codes to change these colors herself, then running the full screen application
-will lose her changes even after it exits. To avoid this, kitty introduces a
-new pair of *OSC* escape codes to push and pop the current color values from a
+set the default foreground, background, selection and cursor colors and the ANSI
+color table. This allows for various performance optimizations when drawing the
+screen. The problem is that if the user previously used the escape codes to
+change these colors themselves, then running the full screen application will
+lose those changes even after it exits. To avoid this, kitty introduces a new
+pair of *OSC* escape codes to push and pop the current color values from a
 stack::
 
     <ESC>]30001<ESC>\  # push onto stack
     <ESC>]30101<ESC>\  # pop from stack
 
-These escape codes save/restore the colors, default
-background, default foreground, selection background, selection foreground and
-cursor color and the 256 colors of the ANSI color table.
+These escape codes save/restore the colors, default background, default
+foreground, selection background, selection foreground and cursor color and the
+256 colors of the ANSI color table.
 
-.. note:: In July 2020, after several years, XTerm copied this protocol
+.. note:: In July 2020, after several years, xterm copied this protocol
    extension, without acknowledgement, and using incompatible escape codes
    (XTPUSHCOLORS, XTPOPCOLORS, XTREPORTCOLORS). And they decided to save not
    just the dynamic colors but the entire ANSI color table. In the interests of
-   promoting interoperability, kitty added support for XTerm's escape codes as
+   promoting interoperability, kitty added support for xterm's escape codes as
    well, and changed this extension to also save/restore the entire ANSI color
    table.

docs/conf.py

@@ -104,6 +104,10 @@ rst_prolog = '''
 '''.replace('VERSION', str_version)
 smartquotes_action = 'qe'  # educate quotes and ellipses but not dashes
 
+string_replacements = {
+    '_kitty_install_cmd': 'curl -L https://sw.kovidgoyal.net/kitty/installer.sh | sh /dev/stdin',
+}
+
 
 # -- Options for HTML output -------------------------------------------------
 
@@ -300,8 +304,16 @@ def write_remote_control_protocol_docs() -> None:  # {{{
 # }}}
 
 
+def replace_string(app: Any, docname: str, source: List[str]) -> None:  # {{{
+    src = source[0]
+    for k, v in app.config.string_replacements.items():
+        src = src.replace(k, v)
+    source[0] = src
+# }}}
+
 # config file docs {{{
 
+
 class ConfLexer(RegexLexer):  # type: ignore
     name = 'Conf'
     aliases = ['conf']
@@ -516,6 +528,8 @@ def setup(app: Any) -> None:
     write_cli_docs(kn)
     write_remote_control_protocol_docs()
     write_conf_docs(app, kn)
+    app.add_config_value('string_replacements', {}, True)
+    app.connect('source-read', replace_string)
     app.add_config_value('analytics_id', '', 'env')
     app.connect('html-page-context', add_html_context)
     app.add_lexer('session', SessionLexer() if version_info[0] < 3 else SessionLexer)

docs/conf.rst

@@ -3,13 +3,14 @@ kitty.conf
 
 .. highlight:: conf
 
-|kitty| is highly customizable, everything from keyboard shortcuts, to
-rendering frames-per-second. See below for an overview of all customization
-possibilities.
+|kitty| is highly customizable, everything from keyboard shortcuts, to rendering
+frames-per-second. See below for an overview of all customization possibilities.
 
-You can open the config file within kitty by pressing :sc:`edit_config_file` (:kbd:`⌘+,` on macOS).
-You can reload the config file within kitty by pressing
-:sc:`reload_config_file` (:kbd:`⌃+⌘+,` on macOS) or sending kitty the ``SIGUSR1`` signal.
+You can open the config file within kitty by pressing :sc:`edit_config_file`
+(:kbd:`⌘+,` on macOS). A :file:`kitty.conf` with commented default
+configurations and descriptions will be created if the file does not exist.
+You can reload the config file within kitty by pressing :sc:`reload_config_file`
+(:kbd:`⌃+⌘+,` on macOS) or sending kitty the ``SIGUSR1`` signal.
 You can also display the current configuration by pressing :sc:`debug_config`
 (:kbd:`⌥+⌘+,` on macOS).
 
@@ -17,12 +18,12 @@ You can also display the current configuration by pressing :sc:`debug_config`
 
 |kitty| looks for a config file in the OS config directories (usually
 :file:`~/.config/kitty/kitty.conf`) but you can pass a specific path via the
-:option:`kitty --config` option or use the ``KITTY_CONFIG_DIRECTORY``
-environment variable. See the :option:`kitty --config` option for full details.
+:option:`kitty --config` option or use the :envvar:`KITTY_CONFIG_DIRECTORY`
+environment variable. See :option:`kitty --config` for full details.
 
 Comments can be added to the config file as lines starting with the ``#``
-character. This works only if the ``#`` character is the first character
-in the line.
+character. This works only if the ``#`` character is the first character in the
+line.
 
 .. _include:
 
@@ -42,7 +43,7 @@ from environment variables. For example::
 
 
 .. note:: Syntax highlighting for :file:`kitty.conf` in vim is available via
-   `vim-kitty <https://github.com/fladson/vim-kitty>`_.
+   `vim-kitty <https://github.com/fladson/vim-kitty>`__.
 
 
 .. include:: /generated/conf-kitty.rst
@@ -53,17 +54,17 @@ Sample kitty.conf
 
 .. only:: html
 
-    You can download a sample :file:`kitty.conf` file with all default settings and
-    comments describing each setting by clicking: :download:`sample kitty.conf
-    </generated/conf/kitty.conf>`.
+    You can download a sample :file:`kitty.conf` file with all default settings
+    and comments describing each setting by clicking: :download:`sample
+    kitty.conf </generated/conf/kitty.conf>`.
 
 .. only:: man
 
    You can edit a fully commented sample kitty.conf by pressing the
-   :sc:`edit_config_file` shortcut in kitty. This will generate a config
-   file with full documentation and all settings commented out. If you
-   have a pre-existing kitty.conf, then that will be used instead, delete
-   it to see the sample file.
+   :sc:`edit_config_file` shortcut in kitty. This will generate a config file
+   with full documentation and all settings commented out. If you have a
+   pre-existing :file:`kitty.conf`, then that will be used instead, delete it to
+   see the sample file.
 
 
 All mappable actions

docs/deccara.rst

@@ -3,19 +3,18 @@ Setting text styles/colors in arbitrary regions of the screen
 
 There already exists an escape code to set *some* text attributes in arbitrary
 regions of the screen, `DECCARA
-<https://vt100.net/docs/vt510-rm/DECCARA.html>`_.  However, it is limited to
+<https://vt100.net/docs/vt510-rm/DECCARA.html>`__. However, it is limited to
 only a few attributes. |kitty| extends this to work with *all* SGR attributes.
 So, for example, this can be used to set the background color in an arbitrary
 region of the screen.
 
 The motivation for this extension is the various problems with the existing
 solution for erasing to background color, namely the *background color erase
-(bce)* capability. See
-:iss:`this discussion <160#issuecomment-346470545>`
-and `this FAQ <https://invisible-island.net/ncurses/ncurses.faq.html#bce_mismatches>`_
+(bce)* capability. See :iss:`this discussion <160#issuecomment-346470545>`
+and `this FAQ <https://invisible-island.net/ncurses/ncurses.faq.html#bce_mismatches>`__
 for a summary of problems with *bce*.
 
-For example, to set the background color to blue in a
-rectangular region of the screen from (3, 4) to (10, 11), you use::
+For example, to set the background color to blue in a rectangular region of the
+screen from (3, 4) to (10, 11), you use::
 
     <ESC>[2*x<ESC>[4;3;11;10;44$r<ESC>[*x

docs/desktop-notifications.rst

@@ -5,21 +5,20 @@ Desktop notifications
 =======================
 
 |kitty| implements an extensible escape code (OSC 99) to show desktop
-notifications. It is easy to use from shell scripts and fully extensible to
-show title and body.  Clicking on the notification can optionally focus the
-window it came from, and/or send an escape code back to the application running
-in that window.
+notifications. It is easy to use from shell scripts and fully extensible to show
+title and body. Clicking on the notification can optionally focus the window it
+came from, and/or send an escape code back to the application running in that
+window.
 
-The design of the escape code is partially based on the discussion in
-the defunct
-`terminal-wg <https://gitlab.freedesktop.org/terminal-wg/specifications/-/issues/13>`_
+The design of the escape code is partially based on the discussion in the
+defunct `terminal-wg <https://gitlab.freedesktop.org/terminal-wg/specifications/-/issues/13>`__
 
 The escape code has the form::
 
     <OSC> 99 ; metadata ; payload <terminator>
 
 Here ``<OSC>`` is :code:`<ESC>]` and ``<terminator>`` is
-:code:`<ESC><backslash>`.  The metadata is a section of colon separated
+:code:`<ESC><backslash>`. The ``metadata`` is a section of colon separated
 :code:`key=value` pairs. Every key must be a single character from the set
 :code:`a-zA-Z` and every value must be a word consisting of characters from
 the set :code:`a-zA-Z0-9-_/\+.,(){}[]*&^%$#@!`~`. The payload must be
@@ -45,28 +44,27 @@ The design of the escape code is fundamentally chunked, this is because
 different terminal emulators have different limits on how large a single escape
 code can be. Chunking is accomplished by the ``i`` and ``d`` keys. The ``i``
 key is the *notification id* which can be any string containing the characters
-``[a-zA-Z0-9_-+.]``. The ``d`` key stands for *done* and
-can only take the values ``0`` and ``1``. A value of ``0`` means the
-notification is not yet done and the terminal emulator should hold off
-displaying it. A value of ``1`` means the notification is done, and should be
-displayed. You can specify the title or body multiple times and the terminal
-emulator will concatenate them, thereby allowing arbitrarily long text
-(terminal emulators are free to impose a sensible limit to avoid
-Denial-of-Service attacks).
+``[a-zA-Z0-9_-+.]``. The ``d`` key stands for *done* and can only take the
+values ``0`` and ``1``. A value of ``0`` means the notification is not yet done
+and the terminal emulator should hold off displaying it. A value of ``1`` means
+the notification is done, and should be displayed. You can specify the title or
+body multiple times and the terminal emulator will concatenate them, thereby
+allowing arbitrarily long text (terminal emulators are free to impose a sensible
+limit to avoid Denial-of-Service attacks).
 
 Both the ``title`` and ``body`` payloads must be either UTF-8 encoded plain
-text with no embedded escape codes, or UTF-8 text that is base64 encoded, in
+text with no embedded escape codes, or UTF-8 text that is Base64 encoded, in
 which case there must be an ``e=1`` key in the metadata to indicate the payload
-is base64 encoded.
+is Base64 encoded.
 
 When the user clicks the notification, a couple of things can happen, the
 terminal emulator can focus the window from which the notification came, and/or
 it can send back an escape code to the application indicating the notification
-was activated. This is controlled by the ``a`` key which takes a comma
-separated set of values, ``report`` and ``focus``. The value ``focus`` means
-focus the window from which the notification was issued and is the default.
-``report`` means send an escape code back to the application. The format of the
-returned escape code is::
+was activated. This is controlled by the ``a`` key which takes a comma separated
+set of values, ``report`` and ``focus``. The value ``focus`` means focus the
+window from which the notification was issued and is the default. ``report``
+means send an escape code back to the application. The format of the returned
+escape code is::
 
     <OSC> 99 ; i=identifier ; <terminator>
 
@@ -87,9 +85,9 @@ to display it based on what it does understand.
 
 .. note::
    It is possible to extend this escape code to allow specifying an icon for
-   the notification, however, given that some platforms, such as macOS, dont
-   allow displaying custom icons on a notification, at all, it was decided to
-   leave it out of the spec for the time being.
+   the notification, however, given that some platforms, such as legacy versions
+   of macOS, don't allow displaying custom images on a notification, it was
+   decided to leave it out of the spec for the time being.
 
    Similarly, features such as scheduled notifications could be added in future
    revisions.
@@ -107,7 +105,7 @@ Key      Value                 Default    Description
 ``d``    ``0`` or ``1``        ``1``      Indicates if the notification is
                                           complete or not.
 
-``e``    ``0`` or ``1``        ``0``      If set to ``1`` means the payload is base64 encoded UTF-8,
+``e``    ``0`` or ``1``        ``0``      If set to ``1`` means the payload is Base64 encoded UTF-8,
                                           otherwise it is plain UTF-8 text with no C0 control codes in it
 
 ``i``    ``[a-zA-Z0-9-_+.]``   ``0``      Identifier for the notification
@@ -118,5 +116,6 @@ Key      Value                 Default    Description
 
 
 .. note::
-   |kitty| also supports the legacy OSC 9 protocol developed by iTerm2 for
-   desktop notifications.
+   |kitty| also supports the `legacy OSC 9 protocol developed by iTerm2
+   <https://iterm2.com/documentation-escape-codes.html>`__ for desktop
+   notifications.

docs/faq.rst

@@ -27,14 +27,15 @@ turned off for specific symbols using :opt:`narrow_symbols`.
 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::
+First make sure you have not changed the :envvar:`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 :doc:`here <deccara>` for why |kitty| does not support background color erase.
+See :doc:`here <deccara>` 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?
@@ -47,32 +48,32 @@ terminfo files to the server::
     kitty +kitten ssh myserver
 
 This :doc:`ssh kitten <kittens/ssh>` takes all the same command line arguments
-as ssh, you can alias it to something small in your shell's rc files to avoid
-having to type it each time::
+as :program:`ssh`, you can alias it to something small in your shell's rc files
+to avoid having to type it each time::
 
     alias s="kitty +kitten ssh"
 
-If the ssh kitten fails, use the following one-liner instead (it
-is slower as it needs to ssh into the server twice, but will work with most
-servers)::
+If the ssh kitten fails, use the following one-liner instead (it is slower as it
+needs to ssh into the server twice, but will work with most servers)::
 
     infocmp -a xterm-kitty | ssh myserver tic -x -o \~/.terminfo /dev/stdin
 
-If you are behind a proxy (like Balabit) that prevents this, or ``tic`` comes
-with macOS that does not support reading from STDIN, you must redirect the 1st
-command to a file, copy that to the server and run ``tic`` manually.  If you
-connect to a server, embedded or Android system that doesn't have ``tic``, copy over
-your local file terminfo to the other system as :file:`~/.terminfo/x/xterm-kitty`.
+If you are behind a proxy (like Balabit) that prevents this, or :program:`tic`
+comes with macOS that does not support reading from STDIN, you must redirect the
+first command to a file, copy that to the server and run :program:`tic`
+manually. If you connect to a server, embedded or Android system that doesn't
+have :program:`tic`, copy over your local file terminfo to the other system as
+:file:`~/.terminfo/x/xterm-kitty`.
 
 Really, the correct solution for this is to convince the OpenSSH maintainers to
-have ssh do this automatically, if possible, when connecting to a server, so that
-all terminals work transparently.
+have :program:`ssh` do this automatically, if possible, when connecting to a
+server, so that all terminals work transparently.
 
 If the server is running FreeBSD, or another system that relies on termcap
 rather than terminfo, you will need to convert the terminfo file on your local
 machine by running (on local machine with |kitty|)::
 
-    infocmp -C xterm-kitty
+    infocmp -CrT0 xterm-kitty
 
 The output of this command is the termcap description, which should be appended
 to :file:`/usr/share/misc/termcap` on the remote server. Then run the following
@@ -84,9 +85,9 @@ command to apply your change (on the server)::
 Keys such as arrow keys, backspace, delete, home/end, etc. do not work when using su or sudo?
 -------------------------------------------------------------------------------------------------
 
-Make sure the TERM environment variable, is ``xterm-kitty``.  And either the
-TERMINFO environment variable points to a directory containing :file:`x/xterm-kitty`
-or that file is under :file:`~/.terminfo/x/`.
+Make sure the :envvar:`TERM` environment variable, is ``xterm-kitty``.  And
+either the :envvar:`TERMINFO` environment variable points to a directory
+containing :file:`x/xterm-kitty` or that file is under :file:`~/.terminfo/x/`.
 
 For macOS, you may also need to put that file under :file:`~/.terminfo/78/`::
 
@@ -94,18 +95,19 @@ For macOS, you may also need to put that file under :file:`~/.terminfo/78/`::
     ln -snf ../x/xterm-kitty ~/.terminfo/78/xterm-kitty
     tic -x -o ~/.terminfo "$KITTY_INSTALLATION_DIR/terminfo/kitty.terminfo"
 
-Note that ``sudo`` might remove TERMINFO.  Then setting it at the shell prompt can
-be too late, because command line editing may not be reinitialized.  In that case
-you can either ask ``sudo`` to set it or if that is not supported, insert an ``env``
-command before starting the shell, or, if not possible, after sudo start another
-Shell providing the right terminfo path::
+Note that :program:`sudo` might remove :envvar:`TERMINFO`. Then setting it at
+the shell prompt can be too late, because command line editing may not be
+reinitialized. In that case you can either ask :program:`sudo` to set it or if
+that is not supported, insert an :program:`env` command before starting the
+shell, or, if not possible, after sudo start another shell providing the right
+terminfo path::
 
     sudo … TERMINFO=$HOME/.terminfo bash -i
     sudo … env TERMINFO=$HOME/.terminfo bash -i
     TERMINFO=/home/ORIGINALUSER/.terminfo exec bash -i
 
-You can configure sudo to preserve TERMINFO by running ``sudo
-visudo`` and adding the following line::
+You can configure :program:`sudo` to preserve :envvar:`TERMINFO` by running
+``sudo visudo`` and adding the following line::
 
     Defaults env_keep += "TERM TERMINFO"
 
@@ -129,12 +131,15 @@ You can also define keyboard shortcuts to set colors, for example::
 
     map f1 set_colors --configured /path/to/some/config/file/colors.conf
 
-Or you can enable :doc:`remote control <remote-control>` for |kitty| and use :ref:`at_set-colors`.
-The shortcut mapping technique has the same syntax as the remote control
-command, for details, see :ref:`at_set-colors`.
+Or you can enable :doc:`remote control <remote-control>` for |kitty| and use
+:ref:`at_set-colors`. The shortcut mapping technique has the same syntax as the
+remote control command, for details, see :ref:`at_set-colors`.
+
+To change colors when SSHing into a remote host, use the :opt:`color_scheme
+<kitten-ssh.color_scheme>` setting for the :doc:`ssh kitten <kittens/ssh>`.
 
 Additionally, You can use the
-`OSC terminal escape codes <https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Operating-System-Commands>`_
+`OSC terminal escape codes <https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Operating-System-Commands>`__
 to set colors. Examples of using OSC escape codes to set colors::
 
     Change the default foreground color:
@@ -151,7 +156,7 @@ to set colors. Examples of using OSC escape codes to set colors::
     printf '\x1b]4;n;green\x1b\\'
 
 You can use various syntaxes/names for color specifications in the above
-examples. See `XParseColor <https://linux.die.net/man/3/xparsecolor>`_
+examples. See `XParseColor <https://linux.die.net/man/3/xparsecolor>`__
 for full details.
 
 If a ``?`` is given rather than a color specification, kitty will respond
@@ -164,14 +169,15 @@ 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
 :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.
+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:
-:file:`/Applications/kitty.app/Contents/MacOS/kitty`.
+You can, of course, also run |kitty| from a terminal with command line options,
+using: :file:`/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 :envvar:`PATH`.
 
-And within |kitty| itself, you can always run |kitty| using just `kitty` as it
-cleverly adds itself to the ``PATH``.
 
 I catted a binary file and now kitty is hung?
 -----------------------------------------------
@@ -179,10 +185,10 @@ I catted a binary file and now kitty is hung?
 **Never** output unknown binary data directly into a terminal.
 
 Terminals have a single channel for both data and control. Certain bytes
-are control codes. Some of these control codes are of arbitrary length, so
-if the binary data you output into the terminal happens to contain the starting
-sequence for one of these control codes, the terminal will hang waiting for
-the closing sequence. Press :kbd:`ctrl+shift+delete` to reset the terminal.
+are control codes. Some of these control codes are of arbitrary length, so if
+the binary data you output into the terminal happens to contain the starting
+sequence for one of these control codes, the terminal will hang waiting for the
+closing sequence. Press :sc:`reset_terminal` to reset the terminal.
 
 If you do want to cat unknown data, use ``cat -v``.
 
@@ -190,30 +196,34 @@ If you do want to cat unknown data, use ``cat -v``.
 kitty is not able to use my favorite font?
 ---------------------------------------------
 
-|kitty| achieves its stellar performance by caching alpha masks of each
-rendered character on the GPU, and rendering them all in parallel. This means
-it is a strictly character cell based display. As such it can use only
-monospace fonts, since every cell in the grid has to be the same size.
-Furthermore, it needs fonts to be freely resizable, so it does not support
-bitmapped fonts.
+|kitty| achieves its stellar performance by caching alpha masks of each rendered
+character on the GPU, and rendering them all in parallel. This means it is a
+strictly character cell based display. As such it can use only monospace fonts,
+since every cell in the grid has to be the same size. Furthermore, it needs
+fonts to be freely resizable, so it does not support bitmapped fonts.
 
 .. note::
-   If you are trying to use a font patched with NERD font symbols, dont do that
-   as patching destroys fonts. There is no need, simply install the standalone
-   NERD font (the file :file:`NerdFontsSymbolsOnly.zip` from the `NERD font
-   releases page <https://github.com/ryanoasis/nerd-fonts/releases>`__). kitty
-   should pick up symbols from it automatically, and you can tell it to do so
-   explicitly in case it doesnt with the :opt:`symbol_map` directive::
+   If you are trying to use a font patched with `Nerd Fonts
+   <https://nerdfonts.com/>`__ symbols, don't do that as patching destroys
+   fonts. There is no need, simply install the standalone ``Symbols Nerd Font``
+   (the file :file:`NerdFontsSymbolsOnly.zip` from the `Nerd Fonts releases page
+   <https://github.com/ryanoasis/nerd-fonts/releases>`__). kitty should pick up
+   symbols from it automatically, and you can tell it to do so explicitly in
+   case it doesn't with the :opt:`symbol_map` directive::
 
         symbol_map U+23FB-U+23FE,U+2665,U+26A1,U+2B58,U+E000-U+E00A,U+E0A0-U+E0A3,U+E0B0-U+E0C8,U+E0CA,U+E0CC-U+E0D2,U+E0D4,U+E200-U+E2A9,U+E300-U+E3E3,U+E5FA-U+E62F,U+E700-U+E7C5,U+F000-U+F2E0,U+F300-U+F31C,U+F400-U+F4A9,U+F500-U+F8FF Symbols Nerd Font
 
+   Those Unicode symbols beyond the ``E000-F8FF`` Unicode private use area are
+   not included.
+
 If your font is not listed in ``kitty +list-fonts`` it means that it is not
-monospace or is a bitmapped font. On Linux you can list all monospace fonts with::
+monospace or is a bitmapped font. On Linux you can list all monospace fonts
+with::
 
     fc-list : family spacing outline scalable | grep -e spacing=100 -e spacing=90 | grep -e outline=True | grep -e scalable=True
 
-Note that the spacing property is calculated by fontconfig based on actual
-glyph widths in the font. If for some reason fontconfig concludes your favorite
+Note that the spacing property is calculated by fontconfig based on actual glyph
+widths in the font. If for some reason fontconfig concludes your favorite
 monospace font does not have ``spacing=100`` you can override it by using the
 following :file:`~/.config/fontconfig/fonts.conf`::
 
@@ -275,7 +285,7 @@ homepage:
 
 On macOS you can change the icon by following the steps:
 
-#. Find :file:`kitty.app` in the Applications folder, select it and press :kbd:`⌘+i`
+#. Find :file:`kitty.app` in the Applications folder, select it and press :kbd:`⌘+I`
 #. Drag :file:`kitty.icns` onto the application icon in the kitty info pane
 #. Delete the icon cache and restart Dock::
 
@@ -295,7 +305,10 @@ the :sc:`send_text <send_text>` you can use the ``show_key`` kitten. Run::
 
     kitty +kitten show_key
 
-Then press the key you want to emulate.
+Then press the key you want to emulate. Note that this kitten will only show
+keys that actually reach the terminal program, in particular, keys mapped to
+actions in kitty will not be shown. To check those first map them to
+:ac:`no_op`.
 
 How do I open a new window or tab with the same working directory as the current window?
 --------------------------------------------------------------------------------------------
@@ -322,8 +335,8 @@ variables which kitty will now inherit.
 You need to make sure that the environment variables you define in your shell's
 rc files are either also defined system wide or via the :opt:`env` directive in
 :file:`kitty.conf`. Common environment variables that cause issues are those
-related to localization, such as ``LANG, LC_*`` and loading of configuration
-files such as ``XDG_*, KITTY_CONFIG_DIRECTORY``.
+related to localization, such as :envvar:`LANG`, ``LC_*`` and loading of
+configuration files such as ``XDG_*``, :envvar:`KITTY_CONFIG_DIRECTORY`.
 
 To see the environment variables that kitty sees, you can add the following
 mapping to :file:`kitty.conf`::
@@ -340,40 +353,42 @@ sorts of places where they may or may not work.
 I am using tmux and have a problem
 --------------------------------------
 
-First, terminal multiplexers are :iss:`a bad idea <391#issuecomment-638320745>`, do
-not use them, if at all possible. kitty contains features that do all of what
+First, terminal multiplexers are :iss:`a bad idea <391#issuecomment-638320745>`,
+do not use them, if at all possible. kitty contains features that do all of what
 tmux does, but better, with the exception of remote persistence (:iss:`391`).
 If you still want to use tmux, read on.
 
 Image display will not work, see `tmux issue
-<https://github.com/tmux/tmux/issues/1391>`_.
+<https://github.com/tmux/tmux/issues/1391>`__.
 
-Using ancient versions of tmux such as 1.8 will
-cause gibberish on screen when pressing keys (:iss:`3541`).
+Using ancient versions of tmux such as 1.8 will cause gibberish on screen when
+pressing keys (:iss:`3541`).
 
-If you are using tmux with multiple terminals or you start it under one
-terminal and then switch to another and these terminals have different TERM
-variables, tmux will break. You will need to restart it as tmux does not
-support multiple terminfo definitions.
+If you are using tmux with multiple terminals or you start it under one terminal
+and then switch to another and these terminals have different :envvar:`TERM`
+variables, tmux will break. You will need to restart it as tmux does not support
+multiple terminfo definitions.
 
 If you use any of the advanced features that kitty has innovated, such as
-styled underlines, desktop notifications, extended keyboard support, etc.
-they may or may not work, depending on the whims of tmux's maintainer, your
-version of tmux, etc.
+:doc:`styled underlines </underlines>`, :doc:`desktop notifications
+</desktop-notifications>`, :doc:`extended keyboard support
+</keyboard-protocol>`, etc. they may or may not work, depending on the whims of
+tmux's maintainer, your version of tmux, etc.
 
 
 I opened and closed a lot of windows/tabs and top shows kitty's memory usage is very high?
 -------------------------------------------------------------------------------------------
 
-``top`` is not a good way to measure process memory usage. That is because on
-modern systems, when allocating memory to a process, the C library functions
-will typically allocate memory in large blocks, and give the process chunks of
-these blocks. When the process frees a chunk, the C library will not
+:program:`top` is not a good way to measure process memory usage. That is
+because on modern systems, when allocating memory to a process, the C library
+functions will typically allocate memory in large blocks, and give the process
+chunks of these blocks. When the process frees a chunk, the C library will not
 necessarily release the underlying block back to the OS. So even though the
-application has released the memory, ``top`` will still claim the process is
-using it.
+application has released the memory, :program:`top` will still claim the process
+is using it.
 
-To check for memory leaks, instead use a tool like ``valgrind``. Run::
+To check for memory leaks, instead use a tool like `Valgrind
+<https://valgrind.org/>`__. Run::
 
     PYTHONMALLOC=malloc valgrind --tool=massif kitty
 
@@ -386,18 +401,19 @@ that window, maybe run yes or find again. Then quit kitty and run::
 You will see the allocations graph goes up when you opened the windows, then
 goes back down when you closed them, indicating there were no memory leaks.
 
-For those interested, you can get a similar profile out of ``valgrind`` as you get
-with ``top`` by adding ``--pages-as-heap=yes`` then you will see that memory
-allocated in malloc is not freed in free. This can be further refined if you
-use `glibc`` as your C library by setting the environment variable
-``MALLOC_MMAP_THRESHOLD_=64``. This will cause free to actually free memory
-allocated in sizes of more than 64 bytes. With this set, memory usage will
-climb high, then fall when closing windows, but not fall all the way back. The
-remaining used memory can be investigated using valgrind again, and it will
+For those interested, you can get a similar profile out of :program:`valgrind`
+as you get with :program:`top` by adding ``--pages-as-heap=yes`` then you will
+see that memory allocated in malloc is not freed in free. This can be further
+refined if you use ``glibc`` as your C library by setting the environment
+variable ``MALLOC_MMAP_THRESHOLD_=64``. This will cause free to actually free
+memory allocated in sizes of more than 64 bytes. With this set, memory usage
+will climb high, then fall when closing windows, but not fall all the way back.
+The remaining used memory can be investigated using valgrind again, and it will
 come from arenas in the GPU drivers and the per thread arenas glibc's malloc
-maintains. These too allocate memory in large blocks and dont release it back
+maintains. These too allocate memory in large blocks and don't release it back
 to the OS immediately.
 
+
 Why does kitty sometimes start slowly on my Linux system?
 -------------------------------------------------------------------------------------------
 
@@ -421,4 +437,4 @@ The correct command will depend on your situation and hardware.
 :file:`libEGL_mesa.so` and ignore :file:`libEGL_nvidia.so` also available on the
 system, which will wake the NVIDIA card during device enumeration.
 ``MESA_LOADER_DRIVER_OVERRIDE`` also assures that Mesa won't offer any NVIDIA
-card during enumeration, and will instead just use `/lib/dri/radeonsi_dri.so`.
+card during enumeration, and will instead just use :file:`radeonsi_dri.so`.

docs/glossary.rst

@@ -37,7 +37,8 @@ Glossary
    hyperlinks
       Terminals can have hyperlinks, just like the internet. In kitty you can
       :doc:`control exactly what happens <open_actions>` when clicking on a
-      hyperlink, based on the type of link and its URL.
+      hyperlink, based on the type of link and its URL. See also `Hyperlinks in terminal
+      emulators <https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda>`__.
 
 .. _env_vars:
 
@@ -45,6 +46,7 @@ Environment variables
 ------------------------
 
 Variables that influence kitty behavior
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. envvar:: KITTY_CONFIG_DIRECTORY
 
@@ -65,9 +67,9 @@ Variables that influence kitty behavior
 
 .. envvar:: VISUAL
 
-   The terminal editor (such as ``vi`` or ``nano``) kitty uses, when, for
-   instance, opening :file:`kitty.conf` in response to :sc:`edit_config_file`.
-
+   The terminal based text editor (such as :program:`vi` or :program:`nano`)
+   kitty uses, when, for instance, opening :file:`kitty.conf` in response to
+   :sc:`edit_config_file`.
 
 .. envvar:: EDITOR
 
@@ -84,13 +86,41 @@ Variables that influence kitty behavior
    is possible for the autodiscovery to fail; the default Wayland XKB mappings
    are used in this case. See :pull:`3943` for details.
 
+.. envvar:: SSH_ASKPASS
+
+   Specify the program for SSH to ask for passwords. When this is set, :doc:`ssh
+   kitten </kittens/ssh>` will use this environment variable by default. See
+   :opt:`askpass <kitten-ssh.askpass>` for details.
+
+.. envvar:: KITTY_CLONE_SOURCE_CODE
+
+   Set this to some shell code that will be executed in the cloned window with
+   :code:`eval` when :ref:`clone-in-kitty <clone_shell>` is used.
+
+.. envvar:: KITTY_CLONE_SOURCE_PATH
+
+   Set this to the path of a file that will be sourced in the cloned window when
+   :ref:`clone-in-kitty <clone_shell>` is used.
+
+.. envvar:: KITTY_DEVELOP_FROM
+
+   Set this to the directory path of the kitty source code and its Python code
+   will be loaded from there. Only works with official binary builds.
+
 
 Variables that kitty sets when running child programs
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. envvar:: LANG
 
-   This is set only on macOS, and only if the country and language from the
-   macOS user settings form a valid locale.
+   This is only set on macOS. If the country and language from the macOS user
+   settings form an invalid locale, it will be set to :code:`en_US.UTF-8`.
+
+
+.. envvar:: PATH
+
+   kitty prepends itself to the PATH of its own environment to ensure the
+   functions calling :program:`kitty` will work properly.
 
 
 .. envvar:: KITTY_WINDOW_ID
@@ -137,7 +167,7 @@ Variables that kitty sets when running child programs
 
    Set when the :doc:`remote control <remote-control>` facility is enabled and
    the a socket is used for control via :option:`kitty --listen-on` or :opt:`listen_on`.
-   Contains the path to the socket. Avoids needs to use :option:`kitty @ --to` when
+   Contains the path to the socket. Avoid the need to use :option:`kitty @ --to` when
    issuing remote control commands.
 
 
@@ -158,10 +188,28 @@ Variables that kitty sets when running child programs
 .. envvar:: KITTY_COMMON_OPTS
 
    Set with the values of some common kitty options when running
-   kittens, so kittens can use them without needing to load kitty.conf.
+   kittens, so kittens can use them without needing to load :file:`kitty.conf`.
 
 
 .. envvar:: KITTY_SHELL_INTEGRATION
 
    Set when enabling :ref:`shell_integration`. It is automatically removed by
    the shell integration scripts.
+
+
+.. envvar:: ZDOTDIR
+
+   Set when enabling :ref:`shell_integration` with :program:`zsh`, allowing
+   :program:`zsh` to automatically load the integration script.
+
+
+.. envvar:: XDG_DATA_DIRS
+
+   Set when enabling :ref:`shell_integration` with :program:`fish`, allowing
+   :program:`fish` to automatically load the integration script.
+
+
+.. envvar:: ENV
+
+   Set when enabling :ref:`shell_integration` with :program:`bash`, allowing
+   :program:`bash` to automatically load the integration script.

docs/graphics-protocol.rst

@@ -31,6 +31,7 @@ Some programs and libraries that use the kitty graphics protocol:
 * `ranger <https://github.com/ranger/ranger>`_ - a terminal file manager, with
   image previews, see this `PR <https://github.com/ranger/ranger/pull/1077>`_
 * :doc:`kitty-diff <kittens/diff>` - a side-by-side terminal diff program with support for images
+* `tpix <https://github.com/jesvedberg/tpix>` - a statically compiled binary that can be used to display images and easily installed on remote servers without root access
 * `pixcat <https://github.com/mirukana/pixcat>`_ - a third party CLI and python library that wraps the graphics protocol
 * `neofetch <https://github.com/dylanaraps/neofetch>`_ - A command line system
   information tool

docs/installer.sh

@@ -156,7 +156,6 @@ exec_kitty() {
 }
 
 main() {
-    [ -n "$KITTY_WINDOW_ID" ] && die "You should not try to update kitty from within kitty itself. For best results, quit all kitty instances and run this script from another terminal"
     detect_os
     parse_args "$@"
     detect_network_tool

docs/integrations.rst

@@ -4,8 +4,8 @@ Integrations with other tools
 ================================
 
 kitty provides extremely powerful interfaces such as :doc:`remote-control` and
-:doc:`kittens/custom` and :doc:`kittens/icat`
-that allow it to be integrated with other tools seamlessly.
+:doc:`kittens/custom` and :doc:`kittens/icat` that allow it to be integrated
+with other tools seamlessly.
 
 
 Image and document viewers
@@ -30,19 +30,22 @@ Display markdown files nicely formatted with images in the terminal
 
 `ranger <https://github.com/ranger/ranger>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-A terminal file manager, with previews of file contents powered by kitty's graphics protocol.
+A terminal file manager, with previews of file contents powered by kitty's
+graphics protocol.
 
 .. _tool_nnn:
 
 `nnn <https://github.com/jarun/nnn/>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Another terminal file manager, with previews of file contents powered by kitty's graphics protocol.
+Another terminal file manager, with previews of file contents powered by kitty's
+graphics protocol.
 
 .. _tool_hunter:
 
 `hunter <https://github.com/rabite0/hunter>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Another terminal file manager, with previews of file contents powered by kitty's graphics protocol.
+Another terminal file manager, with previews of file contents powered by kitty's
+graphics protocol.
 
 .. _tool_koneko:
 
@@ -61,8 +64,8 @@ View images in the terminal, similar to kitty's icat.
 
 `nb <https://github.com/xwmx/nb>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-command line and local web note-taking, bookmarking, archiving, and
-knowledge base application that uses kitty's graphics protocol for images.
+Command line and local web note-taking, bookmarking, archiving, and knowledge
+base application that uses kitty's graphics protocol for images.
 
 .. _tool_w3m:
 
@@ -75,9 +78,9 @@ images.
 
 `timg <https://github.com/hzeller/timg>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-A terminal image and video viewer, that displays static and animated
-images or plays videos. Fast multi-threaded loading, JPEG exif rotation,
-grid view and connecting to the webcam make it a versatile terminal utility.
+A terminal image and video viewer, that displays static and animated images or
+plays videos. Fast multi-threaded loading, JPEG exif rotation, grid view and
+connecting to the webcam make it a versatile terminal utility.
 
 
 System and data visualisation tools
@@ -87,7 +90,8 @@ System and data visualisation tools
 
 `neofetch <https://github.com/dylanaraps/neofetch>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-A command line system information tool that shows images using kitty's graphics protocol
+A command line system information tool that shows images using kitty's graphics
+protocol
 
 .. _tool_matplotlib:
 
@@ -105,16 +109,16 @@ Show images from Julia directly in kitty
 
 `euporie <https://github.com/joouha/euporie>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-A text-based user interface for running and editing Jupyter notebooks,
-powered by kitty's graphics protocol for displaying plots
+A text-based user interface for running and editing Jupyter notebooks, powered
+by kitty's graphics protocol for displaying plots
 
 .. _tool_gnuplot:
 
 `gnuplot <http://www.gnuplot.info/>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-A graphing and data visualization tool that can be made to display its
-output in kitty with the following bash snippet:
+A graphing and data visualization tool that can be made to display its output in
+kitty with the following bash snippet:
 
 .. code-block:: sh
 
@@ -171,26 +175,28 @@ Run applications on your system with fuzzy find inside a kitty window
 Editor integration
 -----------------------
 
-|kitty| can be integrated into many different terminal editors to add features
-such a split windows, previews, REPLs etc.
+|kitty| can be integrated into many different terminal based text editors to add
+features such a split windows, previews, REPLs etc.
 
 .. tool_kakoune:
 
 `kakoune <https://kakoune.org/>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-integrates with kitty to use native kitty windows for its windows/panels and REPLs.
+Integrates with kitty to use native kitty windows for its windows/panels and
+REPLs.
 
 .. tool_vim_slime:
 
 `vim-slime <https://github.com/jpalardy/vim-slime#kitty>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-uses kitty remote control for a Lisp REPL.
+Uses kitty remote control for a Lisp REPL.
 
 .. tool_vim_kitty_navigator:
 
 `vim-kitty-navigator <https://github.com/knubie/vim-kitty-navigator>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-allows you to navigate seamlessly between vim and kitty splits using a consistent set of hotkeys.
+Allows you to navigate seamlessly between vim and kitty splits using a
+consistent set of hotkeys.
 
 .. tool_vim_test:
 
@@ -202,7 +208,7 @@ Allows easily running tests in a terminal window
 
 `hologram.nvim <https://github.com/edluffy/hologram.nvim>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Terminal image viewer for nvim
+Terminal image viewer for Neovim
 
 
 Scrollback manipulation
@@ -228,21 +234,21 @@ Miscellaneous
 
 `kitty-smart-tab <https://github.com/yurikhan/kitty-smart-tab>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-use keys to either control tabs or pass them onto running applications if
-no tabs are present
+Use keys to either control tabs or pass them onto running applications if no
+tabs are present
 
 .. tool_kitty_smart_scroll:
 
 `kitty-smart-scroll <https://github.com/yurikhan/kitty-smart-scroll>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-use keys to either scroll or pass them onto running applications if
-no scrollback buffer is present
+Use keys to either scroll or pass them onto running applications if no
+scrollback buffer is present
 
 .. tool_kitti3:
 
 `kitti3 <https://github.com/LandingEllipse/kitti3>`_
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-allow using kitty as a drop-down terminal under the i3 window manager
+Allow using kitty as a drop-down terminal under the i3 window manager
 
 .. tool_weechat_hints:
 

docs/keyboard-protocol.rst

@@ -37,6 +37,7 @@ In addition to kitty, this protocol is also implemented in:
 * The `foot terminal <https://codeberg.org/dnkl/foot/issues/319>`__
 * The `notcurses library
   <https://github.com/dankamongmen/notcurses/issues/2131>`__
+* The `neovim text editor <https://github.com/neovim/neovim/pull/18181>`__
 * The `kakoune text editor <https://github.com/mawww/kakoune/issues/4103>`__
 * The `dte text editor <https://gitlab.com/craigbarnes/dte/-/issues/138>`__
 
@@ -377,7 +378,7 @@ An application can query the terminal for support of this protocol by sending
 the escape code querying for the :ref:`current progressive enhancement
 <progressive_enhancement>` status
 followed by request for the `primary device attributes
-<https://vt100.net/docs/vt510-rm/DA1.html>`. If an answer for the device
+<https://vt100.net/docs/vt510-rm/DA1.html>`__. If an answer for the device
 attributes is received without getting back an answer for the progressive
 enhancement the terminal does not support this protocol.
 

docs/kittens/broadcast.rst

@@ -3,18 +3,21 @@ broadcast
 
 *Type text in all kitty windows simultaneously*
 
-The ``broadcast`` kitten can be used to type text simultaneously in
-all kitty windows (or a subset as desired).
+The ``broadcast`` kitten can be used to type text simultaneously in all
+:term:`kitty windows <window>` (or a subset as desired).
 
 To use it, simply create a mapping in :file:`kitty.conf` such as::
 
-    map F1 launch --allow-remote-control kitty +kitten broadcast
+    map f1 launch --allow-remote-control kitty +kitten broadcast
 
-Then press the :kbd:`F1` key and whatever you type in the newly created widow
+Then press the :kbd:`F1` key and whatever you type in the newly created window
 will be sent to all kitty windows.
 
-You can use the options described below to control which windows
-are selected.
+You can use the options described below to control which windows are selected.
+
+For example, only broadcast to other windows in the current tab::
+
+    map f1 launch --allow-remote-control kitty +kitten broadcast --match-tab state:focused
 
 .. program:: kitty +kitten broadcast
 

docs/kittens/custom.rst

@@ -1,21 +1,20 @@
 Custom kittens
 =================
 
-You can easily create your own kittens to extend kitty. They are just
-terminal programs written in Python. When launching a kitten, kitty will
-open an overlay window over the current window and optionally pass the
-contents of the current window/scrollback to the kitten over its :file:`STDIN`.
-The kitten can then perform whatever actions it likes, just as a normal
-terminal program. After execution of the kitten is complete, it has access
-to the running kitty instance so it can perform arbitrary actions
-such as closing windows, pasting text, etc.
+You can easily create your own kittens to extend kitty. They are just terminal
+programs written in Python. When launching a kitten, kitty will open an overlay
+window over the current window and optionally pass the contents of the current
+window/scrollback to the kitten over its :file:`STDIN`. The kitten can then
+perform whatever actions it likes, just as a normal terminal program. After
+execution of the kitten is complete, it has access to the running kitty instance
+so it can perform arbitrary actions such as closing windows, pasting text, etc.
 
 Let's see a simple example of creating a kitten. It will ask the user for some
 input and paste it into the terminal window.
 
-Create a file in the kitty config folder, :file:`~/.config/kitty/mykitten.py`
-(you might need to adjust the path to wherever the kitty config folder is on
-your machine).
+Create a file in the kitty config directory, :file:`~/.config/kitty/mykitten.py`
+(you might need to adjust the path to wherever the :ref:`kitty config directory
+<confloc>` is on your machine).
 
 
 .. code-block:: python
@@ -43,11 +42,12 @@ Now in :file:`kitty.conf` add the lines::
     map ctrl+k kitten mykitten.py
 
 
-Start kitty and press :kbd:`ctrl+k` and you should see the kitten running.
-The best way to develop your own kittens is to modify one of the built in
-kittens. Look in the kittens sub-directory of the kitty source code for those.
-Or see below for a list of :ref:`third-party kittens <external_kittens>`,
-that other kitty users have created.
+Start kitty and press :kbd:`Ctrl+K` and you should see the kitten running.
+The best way to develop your own kittens is to modify one of the built-in
+kittens. Look in the `kittens sub-directory
+<https://github.com/kovidgoyal/kitty/tree/master/kittens>`__ of the kitty source
+code for those. Or see below for a list of :ref:`third-party kittens
+<external_kittens>`, that other kitty users have created.
 
 
 Passing arguments to kittens
@@ -60,36 +60,40 @@ You can pass arguments to kittens by defining them in the map directive in
 
 These will be available as the ``args`` parameter in the ``main()`` and
 ``handle_result()`` functions. Note also that the current working directory
-of the kitten is set to the working directory of whatever program is
-running in the active kitty window. The special argument ``@selection``
-is replaced by the currently selected text in the active kitty window.
+of the kitten is set to the working directory of whatever program is running in
+the active kitty window. The special argument ``@selection`` is replaced by the
+currently selected text in the active kitty window.
 
 
 Passing the contents of the screen to the kitten
 ---------------------------------------------------
 
 If you would like your kitten to have access to the contents of the screen
-and/or the scrollback buffer, you just need to add an annotation to the ``handle_result()``
-function, telling kitty what kind of input your kitten would like. For example:
+and/or the scrollback buffer, you just need to add an annotation to the
+``handle_result()`` function, telling kitty what kind of input your kitten would
+like. For example:
 
 .. code-block:: py
 
+    from typing import List
+    from kitty.boss import Boss
+
     # in main, STDIN is for the kitten process and will contain
     # the contents of the screen
-    def main(args):
+    def main(args: List[str]) -> str:
         return sys.stdin.read()
 
     # in handle_result, STDIN is for the kitty process itself, rather
     # than the kitten process and should not be read from.
     from kittens.tui.handler import result_handler
     @result_handler(type_of_input='text')
-    def handle_result(args, stdin_data, target_window_id, boss):
+    def handle_result(args: List[str], stdin_data: str, target_window_id: int, boss: Boss) -> None:
         pass
 
 
 This will send the plain text of the active window to the kitten's
-:file:`STDIN`. There are many other types of input you can ask for,
-described in the table below:
+:file:`STDIN`. There are many other types of input you can ask for, described in
+the table below:
 
 .. table:: Types of input to kittens
     :align: left
@@ -121,31 +125,35 @@ and ``first_output`` gives the output of the first command currently on screen.
 These can also be combined with ``screen`` and ``ansi`` for formatting.
 
 .. note::
-   For the types based on the output of a command,
-   :ref:`shell_integration` is required.
+   For the types based on the output of a command, :ref:`shell_integration` is
+   required.
 
 
 Using kittens to script kitty, without any terminal UI
 -----------------------------------------------------------
 
 If you would like your kitten to script kitty, without bothering to write a
-terminal program, you can tell the kittens system to run the
-``handle_result()`` function without first running the ``main()`` function.
+terminal program, you can tell the kittens system to run the ``handle_result()``
+function without first running the ``main()`` function.
 
-For example, here is a kitten that "zooms/unzooms" the current terminal window
-by switching to the stack layout or back to the previous layout. This is
+For example, here is a kitten that "zooms in/zooms out" the current terminal
+window by switching to the stack layout or back to the previous layout. This is
 equivalent to the builtin :ac:`toggle_layout` action.
 
-Create a file in the kitty config folder, :file:`~/.config/kitty/zoom_toggle.py`
+Create a Python file in the :ref:`kitty config directory <confloc>`,
+:file:`~/.config/kitty/zoom_toggle.py`
 
 .. code-block:: py
 
-    def main(args):
+    from typing import List
+    from kitty.boss import Boss
+
+    def main(args: List[str]) -> str:
         pass
 
     from kittens.tui.handler import result_handler
     @result_handler(no_ui=True)
-    def handle_result(args, answer, target_window_id, boss):
+    def handle_result(args: List[str], answer: str, target_window_id: int, boss: Boss) -> None:
         tab = boss.active_tab
         if tab is not None:
             if tab.current_layout.name == 'stack':
@@ -154,7 +162,7 @@ Create a file in the kitty config folder, :file:`~/.config/kitty/zoom_toggle.py`
                 tab.goto_layout('stack')
 
 
-Now in kitty.conf add::
+Now in :file:`kitty.conf` add::
 
     map f11 kitten zoom_toggle.py
 
@@ -165,7 +173,7 @@ layout, by simply adding the line::
     boss.toggle_fullscreen()
 
 
-To the ``handle_result()`` function, above.
+to the ``handle_result()`` function, above.
 
 
 .. _send_mouse_event:
@@ -173,7 +181,7 @@ To the ``handle_result()`` function, above.
 Sending mouse events
 --------------------
 
-If the program running in a window is receiving mouse events you can simulate
+If the program running in a window is receiving mouse events, you can simulate
 those using::
 
     from kitty.fast_data_types import send_mouse_event
@@ -200,15 +208,15 @@ that type, and will return ``True`` if it sent the event, and ``False`` if not.
 Debugging kittens
 --------------------
 
-The part of the kitten that runs in ``main()`` is just a normal program and
-the output of print statements will be visible in the kitten window. Or
-alternately, you can use::
+The part of the kitten that runs in ``main()`` is just a normal program and the
+output of print statements will be visible in the kitten window. Or alternately,
+you can use::
 
     from kittens.tui.loop import debug
     debug('whatever')
 
-The ``debug()`` function is just like ``print()`` except that the output
-will appear in the ``STDOUT`` of the kitty process inside which the kitten is
+The ``debug()`` function is just like ``print()`` except that the output will
+appear in the ``STDOUT`` of the kitty process inside which the kitten is
 running.
 
 The ``handle_result()`` part of the kitten runs inside the kitty process.
@@ -216,12 +224,13 @@ The output of print statements will go to the ``STDOUT`` of the kitty process.
 So if you run kitty from another kitty instance, the output will be visible
 in the first kitty instance.
 
+
 Adding options to kittens
 ----------------------------
 
 If you would like to use kitty's config framework to make your kittens
-configurable, you will need some boilerplate. In the directory
-of your kitten make the following files.
+configurable, you will need some boilerplate. Put the following files in the
+directory of your kitten.
 
 :file:`kitten_options_definition.py`
 
@@ -311,8 +320,9 @@ You can parse and read the options in your kitten using the following code:
         opts.config_overrides = overrides
         return opts
 
-See the code for the builtin diff kitten for examples of creating more options
-and keyboard shortcuts.
+See `the code <https://github.com/kovidgoyal/kitty/tree/master/kittens/diff>`__
+for the builtin :doc:`diff kitten </kittens/diff>` for examples of creating more
+options and keyboard shortcuts.
 
 .. _external_kittens:
 
@@ -320,7 +330,8 @@ Kittens created by kitty users
 ---------------------------------------------
 
 `vim-kitty-navigator <https://github.com/knubie/vim-kitty-navigator>`_
-    Allows you to navigate seamlessly between vim and kitty splits using a consistent set of hotkeys.
+    Allows you to navigate seamlessly between vim and kitty splits using a
+    consistent set of hotkeys.
 
 `smart-scroll <https://github.com/yurikhan/kitty-smart-scroll>`_
     Makes the kitty scroll bindings work in full screen applications

docs/kittens/diff.rst

@@ -12,8 +12,8 @@ Major Features
 
     * Displays diffs side-by-side in the kitty terminal
 
-    * Does syntax highlighting of the displayed diffs, asynchronously, for maximum
-      speed
+    * Does syntax highlighting of the displayed diffs, asynchronously, for
+      maximum speed
 
     * Displays images as well as text diffs, even over SSH
 
@@ -31,11 +31,11 @@ Major Features
 Installation
 ---------------
 
-Simply :ref:`install kitty <quickstart>`.  You also need
-to have either the `git <https://git-scm.com/>`_ program or the ``diff`` program
-installed. Additionally, for syntax highlighting to work,
-`pygments <https://pygments.org/>`_ must be installed (note that pygments is
-included in the official kitty binary builds).
+Simply :ref:`install kitty <quickstart>`.  You also need to have either the `git
+<https://git-scm.com/>`__ program or the :program:`diff` program installed.
+Additionally, for syntax highlighting to work, `pygments
+<https://pygments.org/>`__ must be installed (note that pygments is included in
+the official kitty binary builds).
 
 
 Usage
@@ -45,9 +45,10 @@ In the kitty terminal, run::
 
     kitty +kitten diff file1 file2
 
-to see the diff between file1 and file2.
+to see the diff between :file:`file1` and :file:`file2`.
 
-Create an alias in your shell's startup file to shorten the command, for example:
+Create an alias in your shell's startup file to shorten the command, for
+example:
 
 .. code-block:: sh
 
@@ -67,20 +68,20 @@ Keyboard controls
 =========================   ===========================
 Action                      Shortcut
 =========================   ===========================
-Quit                        :kbd:`q`, :kbd:`ctrl+c`, :kbd:`Esc`
-Scroll line up              :kbd:`k`, :kbd:`Up`
-Scroll line down            :kbd:`j`, :kbd:`Down`
+Quit                        :kbd:`Q`, :kbd:`Ctrl+C`, :kbd:`Esc`
+Scroll line up              :kbd:`K`, :kbd:`Up`
+Scroll line down            :kbd:`J`, :kbd:`Down`
 Scroll page up              :kbd:`PgUp`
 Scroll page down            :kbd:`PgDn`
 Scroll to top               :kbd:`Home`
 Scroll to bottom            :kbd:`End`
 Scroll to next page         :kbd:`Space`, :kbd:`PgDn`
 Scroll to previous page     :kbd:`PgUp`
-Scroll to next change       :kbd:`n`
-Scroll to previous change   :kbd:`p`
+Scroll to next change       :kbd:`N`
+Scroll to previous change   :kbd:`P`
 Increase lines of context   :kbd:`+`
 Decrease lines of context   :kbd:`-`
-All lines of context        :kbd:`a`
+All lines of context        :kbd:`A`
 Restore default context     :kbd:`=`
 Search forwards             :kbd:`/`
 Search backwards            :kbd:`?`
@@ -93,7 +94,7 @@ Scroll to previous match    :kbd:`<`, :kbd:`,`
 Integrating with git
 -----------------------
 
-Add the following to `~/.gitconfig`:
+Add the following to :file:`~/.gitconfig`:
 
 .. code-block:: ini
 
@@ -119,24 +120,23 @@ Why does this work only in kitty?
 ----------------------------------------
 
 The diff kitten makes use of various features that are :doc:`kitty only
-</protocol-extensions>`,  such as the :doc:`kitty graphics protocol
+</protocol-extensions>`, such as the :doc:`kitty graphics protocol
 </graphics-protocol>`, the :doc:`extended keyboard protocol
-</keyboard-protocol>`, etc. It also leverages terminal program
-infrastructure I created for all of kitty's other kittens to reduce the amount
-of code needed (the entire implementation is under 2000 lines of code).
+</keyboard-protocol>`, etc. It also leverages terminal program infrastructure
+I created for all of kitty's other kittens to reduce the amount of code needed
+(the entire implementation is under 2000 lines of code).
 
 And fundamentally, it's kitty only because I wrote it for myself, and I am
 highly unlikely to use any other terminals :)
 
 
-
 Configuration
 ------------------------
 
 You can configure the colors used, keyboard shortcuts, the diff implementation,
-the default lines of context, etc.  by creating a :file:`diff.conf` file in
-your :ref:`kitty config folder <confloc>`. See below for the supported
-configuration directives.
+the default lines of context, etc. by creating a :file:`diff.conf` file in your
+:ref:`kitty config folder <confloc>`. See below for the supported configuration
+directives.
 
 
 .. include:: /generated/conf-kitten-diff.rst
@@ -145,7 +145,6 @@ configuration directives.
 .. include:: /generated/cli-kitten-diff.rst
 
 
-
 Sample diff.conf
 -----------------
 

docs/kittens/hints.rst

@@ -1,9 +1,9 @@
 Hints
 ==========
 
-|kitty| has a *hints mode* to select and act on arbitrary text snippets currently
-visible on the screen.  For example, you can press :sc:`open_url`
-to choose any URL visible on the screen and then open it using your system
+|kitty| has a *hints mode* to select and act on arbitrary text snippets
+currently visible on the screen.  For example, you can press :sc:`open_url`
+to choose any URL visible on the screen and then open it using your default web
 browser.
 
 .. figure:: ../screenshots/hints_mode.png
@@ -13,25 +13,29 @@ browser.
 
     URL hints mode
 
-Similarly, you can press :sc:`insert_selected_path` to
-select anything that looks like a path or filename and then insert it into the
-terminal, very useful for picking files from the output of a ``git`` or ``ls`` command and
-adding them to the command line for the next command.
+Similarly, you can press :sc:`insert_selected_path` to select anything that
+looks like a path or filename and then insert it into the terminal, very useful
+for picking files from the output of a :program:`git` or :program:`ls` command
+and adding them to the command line for the next command.
 
-You can also press :sc:`goto_file_line` to select anything that looks
-like a path or filename followed by a colon and a line number and open
-the file in vim at the specified line number. The patterns and editor
-to be used can be modified using options passed to the kitten. For example::
+You can also press :sc:`goto_file_line` to select anything that looks like a
+path or filename followed by a colon and a line number and open the file in
+:program:`vim` at the specified line number. The patterns and editor to be used
+can be modified using options passed to the kitten. For example::
 
     map ctrl+g kitten hints --type=linenum --linenum-action=tab nvim +{line} {path}
 
-will open the selected file in a new tab inside neovim when you press
-:kbd:`ctrl+g`.
+will open the selected file in a new tab inside `Neovim <https://neovim.io/>`__
+when you press :kbd:`Ctrl+G`.
 
-Pressing :sc:`open_selected_hyperlink` will open hyperlinks, i.e. a URL
+Pressing :sc:`open_selected_hyperlink` will open :term:`hyperlinks`, i.e. a URL
 that has been marked as such by the program running in the terminal,
-for example, by ``ls --hyperlink=auto``. You can also :doc:`customize what actions are
-taken for different types of URLs <../open_actions>`.
+for example, by ``ls --hyperlink=auto``. If :program:`ls` comes with your OS
+does not support hyperlink, you may need to install `GNU Coreutils
+<https://www.gnu.org/software/coreutils/>`__.
+
+You can also :doc:`customize what actions are taken for different types of URLs
+<../open_actions>`.
 
 .. note:: If there are more hints than letters, hints will use multiple
    letters. In this case, when you press the first letter, only hints
@@ -48,13 +52,12 @@ snippets. See :sc:`insert_selected_path <insert_selected_path>` for examples.
 Completely customizing the matching and actions of the kitten
 ---------------------------------------------------------------
 
-The hints kitten supports writing simple python scripts that can be used to
+The hints kitten supports writing simple Python scripts that can be used to
 completely customize how it finds matches and what happens when a match is
-selected. This allows the hints kitten to provide the user interface, while
-you can provide the logic for finding matches and performing actions on them.
-This is best illustrated with an example. Create the file
-:file:`custom-hints.py` in the kitty config directory with the following
-contents:
+selected. This allows the hints kitten to provide the user interface, while you
+can provide the logic for finding matches and performing actions on them. This
+is best illustrated with an example. Create the file :file:`custom-hints.py` in
+the :ref:`kitty config directory <confloc>` with the following contents:
 
 .. code-block:: python
 
@@ -98,9 +101,10 @@ look it up in the Google dictionary.
 
 .. note::
 
-    To avoid having to specify the same command line options on every invocation,
-    you can use the :opt:`action_alias` option in :file:`kitty.conf`, creating aliases
-    that have common sets of options. For example::
+    To avoid having to specify the same command line options on every
+    invocation, you can use the :opt:`action_alias` option in
+    :file:`kitty.conf`, creating aliases that have common sets of options.
+    For example::
 
         action_alias myhints kitten hints --alphabet qfjdkslaureitywovmcxzpq1234567890
         map f1 myhints --customize-processing custom-hints.py

docs/kittens/hyperlinked_grep.rst

@@ -1,11 +1,10 @@
 Hyperlinked grep
 =================
 
-
 This kitten allows you to search your files using `ripgrep
-<https://github.com/BurntSushi/ripgrep>`_ and open the results
-directly in your favorite editor in the terminal, at the line containing
-the search result, simply by clicking on the result you want.
+<https://github.com/BurntSushi/ripgrep>`__ and open the results directly in your
+favorite editor in the terminal, at the line containing the search result,
+simply by clicking on the result you want.
 
 .. versionadded:: 0.19.0
 
@@ -25,19 +24,19 @@ following contents:
     mime text/*
     action launch --type=overlay ${EDITOR} ${FILE_PATH}
 
-
 Now, run a search with::
 
     kitty +kitten hyperlinked_grep something
 
-Hold down the :kbd:`ctrl+shift` keys and click on any of the
-result lines, to open the file in vim at the matching line. If
-you use some editor other than vim, you should adjust the
-:file:`open-actions.conf` file accordingly.
+Hold down the :kbd:`Ctrl+Shift` keys and click on any of the result lines, to
+open the file in :program:`vim` at the matching line. If you use some editor
+other than :program:`vim`, you should adjust the :file:`open-actions.conf` file
+accordingly.
 
-Finally, add an alias to your shell's rc files to invoke the kitten as ``hg``::
+Finally, add an alias to your shell's rc files to invoke the kitten as
+:command:`hg`::
 
-    alias hg='kitty +kitten hyperlinked_grep'
+    alias hg="kitty +kitten hyperlinked_grep"
 
 
 You can now run searches with::
@@ -45,13 +44,13 @@ You can now run searches with::
     hg some-search-term
 
 If you want to enable completion, for the kitten, you can delegate completion
-to rg. How to do that varies based on the shell:
+to :program:`rg`. How to do that varies based on the shell:
 
 
 .. tab:: zsh
 
-    Instead of using an alias create a simple wrapper script named
-    :file:`hg` somewhere in your ``PATH``:
+    Instead of using an alias, create a simple wrapper script named
+    :program:`hg` somewhere in your :envvar:`PATH`:
 
     .. code-block:: sh
 
@@ -64,22 +63,23 @@ to rg. How to do that varies based on the shell:
 
 .. tab:: fish
 
-    You can combine both the aliasing/wrapping and pointing fish
-    to rg's autocompletion with a fish "wrapper" function in your :file:`config.fish`:
+    You can combine both the aliasing/wrapping and pointing fish to ripgrep's
+    autocompletion with a fish wrapper function in your :file:`config.fish`
+    or :file:`~/.config/fish/functions/hg.fish`:
 
-    .. code-block:: sh
+    .. code-block:: fish
 
         function hg --wraps rg; kitty +kitten hyperlinked_grep $argv; end
 
 To learn more about kitty's powerful framework for customizing URL click
-actions, :doc:`see here </open_actions>`.
+actions, see :doc:`here </open_actions>`.
 
 Hopefully, someday this functionality will make it into some `upstream grep
-<https://github.com/BurntSushi/ripgrep/issues/665>`_
-program directly removing the need for this kitten.
+<https://github.com/BurntSushi/ripgrep/issues/665>`__ program directly removing
+the need for this kitten.
 
 
 .. note::
    While you can pass any of ripgrep's comand line options to the kitten and
-   they will be forwarded to rg, do not use options that change the output
-   formatting as the kitten works by parsing the output from ripgrep.
+   they will be forwarded to :program:`rg`, do not use options that change the
+   output formatting as the kitten works by parsing the output from ripgrep.

docs/kittens/icat.rst

@@ -9,8 +9,8 @@ terminal. Using it is as simple as::
     kitty +kitten icat image.jpeg
 
 It supports all image types supported by `ImageMagick
-<https://www.imagemagick.org>`_. It even works over SSH. For details, see
-the :doc:`kitty graphics protocol </graphics-protocol>`.
+<https://www.imagemagick.org>`__. It even works over SSH. For details, see the
+:doc:`kitty graphics protocol </graphics-protocol>`.
 
 You might want to create an alias in your shell's configuration files::
 
@@ -20,14 +20,14 @@ Then you can simply use ``icat image.png`` to view images.
 
 .. note::
 
-    `ImageMagick <https://www.imagemagick.org>`_ must be installed for ``icat`` to
-    work.
+    `ImageMagick <https://www.imagemagick.org>`__ must be installed for icat
+    kitten to work.
 
 .. note::
 
     kitty's image display protocol may not work when used within a terminal
-    multiplexer such as ``screen`` or ``tmux``, depending on whether the
-    multiplexer has added support for it or not.
+    multiplexer such as :program:`screen` or :program:`tmux`, depending on
+    whether the multiplexer has added support for it or not.
 
 
 .. program:: kitty +kitten icat
@@ -35,18 +35,19 @@ Then you can simply use ``icat image.png`` to view images.
 
 The ``icat`` kitten has various command line arguments to allow it to be used
 from inside other programs to display images. In particular, :option:`--place`,
-:option:`--detect-support`, :option:`--silent` and :option:`--print-window-size`.
+:option:`--detect-support`, :option:`--silent` and
+:option:`--print-window-size`.
 
-If you are trying to integrate icat into a complex program like a file
-manager or editor, there are a few things to keep in mind. icat works by
-communicating over the TTY device, it both writes to and reads from the TTY.
-So it is imperative that while it is running the host program does not do
-any TTY I/O. Any key presses or other input from the user on the TTY device
-will be discarded. At a minimum, you should use the :option:`--silent` and
-:option:`--transfer-mode` command line arguments. To be
-really robust you should consider writing proper support for the
-:doc:`../graphics-protocol` in the program instead.  Nowadays there are many
-libraries that have support for it.
+If you are trying to integrate icat into a complex program like a file manager
+or editor, there are a few things to keep in mind. icat works by communicating
+over the TTY device, it both writes to and reads from the TTY. So it is
+imperative that while it is running the host program does not do any TTY I/O.
+Any key presses or other input from the user on the TTY device will be
+discarded. At a minimum, you should use the :option:`--silent` and
+:option:`--transfer-mode` command line arguments. To be really robust you should
+consider writing proper support for the :doc:`kitty graphics protocol
+</graphics-protocol>` in the program instead. Nowadays there are many libraries
+that have support for it.
 
 
 .. include:: /generated/cli-kitten-icat.rst

docs/kittens/panel.rst

@@ -4,8 +4,8 @@ Draw a GPU accelerated dock panel on your desktop
 .. highlight:: sh
 
 
-You can use this kitten to draw a GPU accelerated panel on the edge
-of your screen, that shows the output from an arbitrary terminal program.
+You can use this kitten to draw a GPU accelerated panel on the edge of your
+screen, that shows the output from an arbitrary terminal program.
 
 It is useful for showing status information or notifications on your desktop
 using terminal programs instead of GUI toolkits.
@@ -32,8 +32,8 @@ Using this kitten is simple, for example::
     kitty +kitten panel sh -c 'printf "\n\n\nHello, world."; sleep 5s'
 
 This will show ``Hello, world.`` at the top edge of your screen for five
-seconds. Here the terminal program we are running is ``sh`` with a script to
-print out ``Hello, world!``. You can make the terminal program as complex as
+seconds. Here the terminal program we are running is :program:`sh` with a script
+to print out ``Hello, world!``. You can make the terminal program as complex as
 you like, as demonstrated in the screenshot above.
 
 

docs/kittens/query_terminal.rst

@@ -1,18 +1,18 @@
 Query terminal
 =================
 
-Used to query kitty from terminal programs about version, values of various
-runtime options controlling its features, etc.
+This kitten is used to query |kitty| from terminal programs about version, values
+of various runtime options controlling its features, etc.
 
 The querying is done using the (*semi*) standard XTGETTCAP escape sequence
-pioneered by XTerm, so it works over SSH as well. The downside is that it
-is slow, since it requires a roundtrip to the terminal emulator and back.
+pioneered by xterm, so it works over SSH as well. The downside is that it is
+slow, since it requires a roundtrip to the terminal emulator and back.
 
 If you want to do some of the same querying in your terminal program without
 depending on the kitten, you can do so, by processing the same escape codes.
-Search `this page <https://invisible-island.net/xterm/ctlseqs/ctlseqs.html>`_
-for *XTGETTCAP* to see the syntax for the escape code and read the source
-of this kitten to find the values of the keys for the various queries.
+Search `this page <https://invisible-island.net/xterm/ctlseqs/ctlseqs.html>`__
+for *XTGETTCAP* to see the syntax for the escape code and read the source of
+this kitten to find the values of the keys for the various queries.
 
 
 .. include:: ../generated/cli-kitten-query_terminal.rst

docs/kittens/remote_file.rst

@@ -1,12 +1,12 @@
 Remote files
 ==============
 
-|kitty| has the ability to easily *Edit*, *Open* or *Download* files
-from a computer into which you are SSHed. In your SSH session run::
+|kitty| has the ability to easily *Edit*, *Open* or *Download* files from a
+computer into which you are SSHed. In your SSH session run::
 
     ls --hyperlink=auto
 
-Then hold down :kbd:`ctrl+shift` and click the name of the file.
+Then hold down :kbd:`Ctrl+Shift` and click the name of the file.
 
 .. figure:: ../screenshots/remote_file.png
     :alt: Remote file actions
@@ -19,23 +19,26 @@ Then hold down :kbd:`ctrl+shift` and click the name of the file.
 to *Edit* it in which case kitty will download it and open it locally in your
 :envvar:`EDITOR`. As you make changes to the file, they are automatically
 transferred to the remote computer. Note that this happens without needing
-to install *any* special software on the server, beyond ``ls`` that supports
-hyperlinks.
+to install *any* special software on the server, beyond :program:`ls` that
+supports hyperlinks.
 
 .. seealso:: See the :doc:`transfer` kitten
 
 .. versionadded:: 0.19.0
 
 .. note::
-   Nested SSH sessions are not supported. The kitten will always try to copy
-   remote files from the first SSH host. This is because there is no way for
+   For best results, use this kitten with the :doc:`ssh kitten <./ssh>`.
+   Otherwise, nested SSH sessions are not supported. The kitten will always try to copy
+   remote files from the first SSH host. This is because, without the ssh
+   kitten, there is no way for
    |kitty| to detect and follow a nested SSH session robustly. Use the
    :doc:`transfer` kitten for such situations.
 
 .. note::
-   If you have not setup automatic password-less SSH access, then, when
-   editing starts you will be asked to enter your password just once,
-   thereafter the SSH connection will be re-used.
+   If you have not setup automatic password-less SSH access, and are not using
+   the ssh kitten, then, when editing
+   starts you will be asked to enter your password just once, thereafter the SSH
+   connection will be re-used.
 
 Similarly, you can choose to save the file to the local computer or download
 and open it in its default file handler.

docs/kittens/ssh.rst

@@ -15,28 +15,27 @@ Truly convenient SSH
    Automatic shell integration, file transfer and reuse of connections
 
 The ssh kitten allows you to login easily to remote hosts, and automatically
-setup the environment there to be as comfortable as your local shell. You
-can specify environment variables to set on the remote host and
-files to copy there, making your remote experience just like your
-local shell. Additionally, it automatically sets up :ref:`shell_integration` on
-the remote host and copies the kitty terminfo database there.
+setup the environment there to be as comfortable as your local shell. You can
+specify environment variables to set on the remote host and files to copy there,
+making your remote experience just like your local shell. Additionally, it
+automatically sets up :ref:`shell_integration` on the remote host and copies the
+kitty terminfo database there.
 
 The ssh kitten is a thin wrapper around the traditional `ssh <https://man.openbsd.org/ssh>`__
 command line program and supports all the same options and arguments and configuration.
-In interactive usage scenarios it is a drop in replacement for ``ssh``. To try it
-out, simply run:
+In interactive usage scenarios it is a drop in replacement for :program:`ssh`.
+To try it out, simply run:
 
 .. code-block:: sh
 
     kitty +kitten ssh some-hostname-to-connect-to
 
-You should end up at a shell prompt on the remote host, with shell
-integration enabled. If you like it you can add an alias to it in your shell's
-rc files:
+You should end up at a shell prompt on the remote host, with shell integration
+enabled. If you like it you can add an alias to it in your shell's rc files:
 
 .. code-block:: sh
 
-    alias s=kitty +kitten ssh
+    alias s="kitty +kitten ssh"
 
 So now you can just type ``s hostname`` to connect.
 
@@ -44,13 +43,12 @@ If you define a mapping in :file:`kitty.conf` such as::
 
     map f1 new_window_with_cwd
 
-Then, pressing :kbd:`F1` will open a new window automatically logged
-into the same host using the ssh kitten, at the same directory.
+Then, pressing :kbd:`F1` will open a new window automatically logged into the
+same host using the ssh kitten, at the same directory.
 
-The ssh kitten can be configured using the :file:`~/.config/kitty/ssh.conf`
-file where you can specify environment variables to set on the remote host
-and files to copy from the local to the remote host. Let's see a
-quick example:
+The ssh kitten can be configured using the :file:`~/.config/kitty/ssh.conf` file
+where you can specify environment variables to set on the remote host and files
+to copy from the local to the remote host. Let's see a quick example:
 
 .. code-block:: conf
 
@@ -80,8 +78,9 @@ Additionally, you can pass config options on the command line:
 
 The :code:`--kitten` argument can be specified multiple times, with directives
 from :file:`ssh.conf`. These are merged with :file:`ssh.conf` as if they were
-appended to the end of that file. They apply only to the host being SSHed to
-by this invocation, so any :opt:`hostname <kitten-ssh.hostname>` directives are ignored.
+appended to the end of that file. They apply only to the host being SSHed to by
+this invocation, so any :opt:`hostname <kitten-ssh.hostname>` directives are
+ignored.
 
 .. warning::
 
@@ -98,8 +97,8 @@ A real world example
 Suppose you often SSH into a production server, and you would like to setup
 your shell and editor there using your custom settings. However, other people
 could SSH in as well and you don't want to clobber their settings. Here is how
-this could be achieved using the ssh kitten with zsh and vim as the shell and
-editor, respectively:
+this could be achieved using the ssh kitten with :program:`zsh` and
+:program:`vim` as the shell and editor, respectively:
 
 .. code-block:: conf
 
@@ -125,23 +124,24 @@ How it works
 The ssh kitten works by having SSH transmit and execute a POSIX sh (or
 :opt:`optionally <kitten-ssh.interpreter>` Python) bootstrap script on the
 remote host using an :opt:`interpreter <kitten-ssh.interpreter>`. This script
-reads setup data over the tty device, which kitty sends as a base64 encoded
+reads setup data over the TTY device, which kitty sends as a Base64 encoded
 compressed tarball. The script extracts it and places the :opt:`files <kitten-ssh.copy>`
 and sets the :opt:`environment variables <kitten-ssh.env>` before finally
 launching the :opt:`login shell <kitten-ssh.login_shell>` with :opt:`shell
 integration <kitten-ssh.shell_integration>` enabled. The data is requested by
 the kitten over the TTY with a random one time password. kitty reads the request
 and if the password matches a password pre-stored in shared memory on the
-localhost by the kitten, the transmission is allowed. If your OpenSSH version is
->= 8.4 then the data is transmitted instantly without any roundtrip delay.
+localhost by the kitten, the transmission is allowed. If your local
+`OpenSSH <https://www.openssh.com/>`__ version is >= 8.4 then the data is
+transmitted instantly without any roundtrip delay.
 
 .. note::
 
-   When connecting to BSD hosts, it is possible the bootstrap script will
-   fail or run slowly, because the default shells are crippled in various ways.
+   When connecting to BSD hosts, it is possible the bootstrap script will fail
+   or run slowly, because the default shells are crippled in various ways.
    Your best bet is to install Python on the remote, make sure the login shell
-   is something POSIX sh compliant, and use :code:`python` as the :opt:`interpreter
-   <kitten-ssh.interpreter>` in :file:`ssh.conf`.
+   is something POSIX sh compliant, and use :code:`python` as the
+   :opt:`interpreter <kitten-ssh.interpreter>` in :file:`ssh.conf`.
 
 .. include:: /generated/conf-kitten-ssh.rst
 

docs/kittens/themes.rst

@@ -1,8 +1,8 @@
 Changing kitty colors
 ========================
 
-The themes kitten allows you to easily change color themes, from a collection
-of almost two hundred pre-built themes available at `kitty-themes
+The themes kitten allows you to easily change color themes, from a collection of
+over two hundred pre-built themes available at `kitty-themes
 <https://github.com/kovidgoyal/kitty-themes>`_. To use it, simply run::
 
     kitty +kitten themes
@@ -12,9 +12,9 @@ of almost two hundred pre-built themes available at `kitty-themes
    :alt: The themes kitten in action
    :width: 600
 
-The kitten allows you to pick a theme, with live previews of the colors. You
-can choose between light and dark themes and search by theme name by just
-typing a few characters from the name.
+The kitten allows you to pick a theme, with live previews of the colors. You can
+choose between light and dark themes and search by theme name by just typing a
+few characters from the name.
 
 The kitten maintains a list of recently used themes to allow quick switching.
 
@@ -24,14 +24,15 @@ If you want to restore the colors to default, you can do so by choosing the
 .. versionadded:: 0.23.0
    The themes kitten
 
+
 How it works
 ----------------
 
 A theme in kitty is just a :file:`.conf` file containing kitty settings.
 When you select a theme, the kitten simply copies the :file:`.conf` file
 to :file:`~/.config/kitty/current-theme.conf` and adds an include for
-:file:`current-theme.conf` to :file:`kitty.conf`. It also comments out
-any existing color settings in :file:`kitty.conf` so they do not interfere.
+:file:`current-theme.conf` to :file:`kitty.conf`. It also comments out any
+existing color settings in :file:`kitty.conf` so they do not interfere.
 
 Once that's done, the kitten sends kitty a signal to make it reload its config.
 
@@ -39,9 +40,9 @@ Using your own themes
 -----------------------
 
 You can also create your own themes as :file:`.conf` files. Put them in the
-:file:`themes` sub-directory of the kitty config directory, usually,
-:file:`~/.config/kitty/themes` and the kitten will automatically add them to
-the list of themes. You can use this to modify the builtin themes, by giving
+:file:`themes` sub-directory of the :ref:`kitty config directory <confloc>`,
+usually, :file:`~/.config/kitty/themes`. The kitten will automatically add them
+to the list of themes. You can use this to modify the builtin themes, by giving
 the conf file the name :file:`Some theme name.conf` to override the builtin
 theme of that name. Note that after doing so you have to run the kitten and
 choose that theme once for your changes to be applied.
@@ -52,13 +53,13 @@ Contributing new themes
 
 If you wish to contribute a new theme to the kitty theme repository, start by
 going to the `kitty-themes <https://github.com/kovidgoyal/kitty-themes>`__
-repository.  `Fork it
-<https://docs.github.com/en/get-started/quickstart/fork-a-repo>`_, and use the
+repository. `Fork it
+<https://docs.github.com/en/get-started/quickstart/fork-a-repo>`__, and use the
 file :download:`template.conf
 <https://github.com/kovidgoyal/kitty-themes/raw/master/template.conf>` as a
 template when creating your theme. Once you are satisfied with how it looks,
 `submit a pull request
-<https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request>`_
+<https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request>`__
 to have your theme merged into the `kitty-themes
 <https://github.com/kovidgoyal/kitty-themes>`__ repository, which will make it
 available in this kitten automatically.
@@ -67,12 +68,12 @@ available in this kitten automatically.
 Changing the theme non-interactively
 ---------------------------------------
 
-You can specify the theme name as an argument when invoking the kitten
-to have it change to that theme instantly. For example::
+You can specify the theme name as an argument when invoking the kitten to have
+it change to that theme instantly. For example::
 
     kitty +kitten themes --reload-in=all Dimmed Monokai
 
-Will change the theme to ``Dimmed Monokai`` in all running kitty
-instances. See below for more details on non-interactive operation.
+Will change the theme to ``Dimmed Monokai`` in all running kitty instances. See
+below for more details on non-interactive operation.
 
 .. include:: ../generated/cli-kitten-themes.rst

docs/kittens/transfer.rst

@@ -14,16 +14,16 @@ etc. Anywhere you have a terminal device, you can transfer files.
    :alt: The transfer kitten at work
 
 This kitten supports transferring entire directory trees, preserving soft and
-hard links, file permissions, times, etc. It even supports the rsync_
-protocol to transfer only changes to large files.
+hard links, file permissions, times, etc. It even supports the rsync_ protocol
+to transfer only changes to large files.
 
 .. seealso:: See the :doc:`remote_file` kitten
 
 .. note::
    This kitten (which practically means kitty) must be installed on the other
    machine as well. If that is not possible you can use the :doc:`remote_file`
-   kitten instead. Or write your own script to use the underlying :doc:`file transfer
-   protocol </file-transfer-protocol>`.
+   kitten instead. Or write your own script to use the underlying
+   :doc:`file transfer protocol </file-transfer-protocol>`.
 
 .. versionadded:: 0.24.0
 
@@ -32,7 +32,8 @@ Basic usage
 ---------------
 
 In what follows, the *local computer* is the computer running this kitten and
-the *remote computer* is the computer connected to the other end of the TTY pipe.
+the *remote computer* is the computer connected to the other end of the TTY
+pipe.
 
 To send a file from the local computer to the remote computer, simply run::
 
@@ -42,7 +43,7 @@ You will be prompted by kitty for confirmation on allowing the transfer, and if
 you grant permission, the file will be copied.
 
 Similarly, to get a file from the remote computer to the local computer, use
-the :option:`kitty +kitten transfer --direction` option::
+the :option:`--direction <kitty +kitten transfer --direction>` option::
 
     kitty +kitten transfer --direction=receive /path/to/remote/file /path/to/destination/on/local/computer
 
@@ -58,25 +59,25 @@ the fact that you are copying multiple things) it is good practice to always
 use a trailing slash when the destination is supposed to be a directory.
 
 Also, when transferring multiple files/directories it is a good idea to
-use the :option:`kitty +kitten transfer --confirm-paths` option which will give
-you an opportunity to review and confirm the files that will be touched.
+use the :option:`--confirm-paths <kitty +kitten transfer --confirm-paths>`
+option which will give you an opportunity to review and confirm the files that
+will be touched.
 
 
 Avoiding the confirmation prompt
 ------------------------------------
 
-Normally, when you start a file transfer kitty will prompt you for
-confirmation. This is to ensure that hostile programs running on a remote
-machine cannot read/write files on your computer without your permission.
-If the remote machine is trusted and the connection between your computer
-and the remote machine is secure, then you can disable the confirmation prompt
-by:
+Normally, when you start a file transfer kitty will prompt you for confirmation.
+This is to ensure that hostile programs running on a remote machine cannot
+read/write files on your computer without your permission. If the remote machine
+is trusted and the connection between your computer and the remote machine is
+secure, then you can disable the confirmation prompt by:
 
-#. Setting the :opt:`file_transfer_confirmation_bypass` option to some
-   password.
+#. Setting the :opt:`file_transfer_confirmation_bypass` option to some password.
 
-#. When invoking the kitten use the :option:`kitty +kitten transfer --permissions-bypass`
-   to supply the password you set in step one.
+#. When invoking the kitten use the :option:`--permissions-bypass
+   <kitty +kitten transfer --permissions-bypass>` to supply the password you set
+   in step one.
 
 .. warning:: Using a password to bypass confirmation means any software running
    on the remote machine could potentially learn that password and use it to
@@ -89,9 +90,10 @@ Delta transfers
 -----------------------------------
 
 This kitten has the ability to use the rsync_ protocol to only transfer the
-differences between files. To turn it on use the :option:`kitty +kitten
-transfer --transmit-deltas` option. Note that this will actually be slower when
-transferring small files because of round trip overhead, so use with care.
+differences between files. To turn it on use the :option:`--transmit-deltas
+<kitty +kitten transfer --transmit-deltas>` option. Note that this will actually
+be slower when transferring small files because of round trip overhead, so use
+with care.
 
 
 .. include:: ../generated/cli-kitten-transfer.rst

docs/kittens/unicode_input.rst

@@ -1,27 +1,29 @@
 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.
+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 kitten, shown below.
 
 .. figure:: ../screenshots/unicode.png
-    :alt: A screenshot of the unicode input widget
+    :alt: A screenshot of the unicode input kitten
     :align: center
     :width: 100%
 
-    A screenshot of the unicode input widget
+    A screenshot of the unicode input kitten
 
-In :guilabel:`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.
-The up and down arrow keys can be used to choose the previous and next unicode
-symbol respectively.
+In :guilabel:`Code` mode, you enter a Unicode character by typing in the hex
+code for the character and pressing :kbd:`Enter`. For example, type in ``2716``
+and press :kbd:`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 :kbd:`Enter`.
+The :kbd:`Up` and :kbd:`Down` arrow keys can be used to choose the previous and
+next Unicode symbol respectively.
 
 In :guilabel:`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 space followed by a period and the index for the match if you don't
-like to use arrow keys.
+the :kbd:`ArrowKeys` / :kbd:`Tab` to select the character from the displayed
+matches. You can also type a space followed by a period and the index for the
+match if you don't like to use arrow keys.
 
 You can switch between modes using either the keys :kbd:`F1` ... :kbd:`F4` or
 :kbd:`Ctrl+1` ... :kbd:`Ctrl+4` or by pressing :kbd:`Ctrl+[` and :kbd:`Ctrl+]`

docs/kittens_intro.rst

@@ -20,8 +20,8 @@ Extend with kittens
    kittens/*
 
 |kitty| has a framework for easily creating terminal programs that make use of
-its advanced features. These programs are called kittens. They are used both
-to add features to |kitty| itself and to create useful standalone programs.
+its advanced features. These programs are called kittens. They are used both to
+add features to |kitty| itself and to create useful standalone programs.
 Some prominent kittens:
 
 :doc:`icat <kittens/icat>`
@@ -33,8 +33,8 @@ Some prominent kittens:
     images
 
 
-:doc:`Unicode Input <kittens/unicode_input>`
-    Easily input arbitrary unicode characters in |kitty| by name or hex code.
+:doc:`Unicode input <kittens/unicode_input>`
+    Easily input arbitrary Unicode characters in |kitty| by name or hex code.
 
 
 :doc:`Hints <kittens/hints>`
@@ -48,29 +48,31 @@ Some prominent kittens:
 
 
 :doc:`Transfer files <kittens/transfer>`
-    Transfer files and directories seamlessly and easily from remote machines over your existing
-    SSH sessions with a simple command.
+    Transfer files and directories seamlessly and easily from remote machines
+    over your existing SSH sessions with a simple command.
 
 
 :doc:`Hyperlinked grep <kittens/hyperlinked_grep>`
-    Search your files using `ripgrep <https://github.com/BurntSushi/ripgrep>`_
+    Search your files using `ripgrep <https://github.com/BurntSushi/ripgrep>`__
     and open the results directly in your favorite editor in the terminal,
-    at the line containing the search result, simply by clicking on the result you want.
+    at the line containing the search result, simply by clicking on the result
+    you want.
 
 
 :doc:`Broadcast <kittens/broadcast>`
-    Type in one :term:`kitty window <window>` and have it broadcast to all (or a subset) of
-    other :term:`kitty windows <window>`.
+    Type in one :term:`kitty window <window>` and have it broadcast to all (or a
+    subset) of other :term:`kitty windows <window>`.
 
 
 :doc:`SSH <kittens/ssh>`
-    SSH with automatic shell integration, connection re-use for low latency and easy cloning
-    of local shell and editor configuration to the remote machine.
+    SSH with automatic :ref:`shell integration <shell_integration>`, connection
+    re-use for low latency and easy cloning of local shell and editor
+    configuration to the remote host.
 
 
 :doc:`Panel <kittens/panel>`
-    Draw a GPU accelerated dock panel on your desktop showing the output
-    from an arbitrary terminal program.
+    Draw a GPU accelerated dock panel on your desktop showing the output from an
+    arbitrary terminal program.
 
 
 :doc:`Clipboard <kittens/clipboard>`

docs/launch.rst

@@ -5,22 +5,21 @@ The :command:`launch` command
 
 
 |kitty| has a :code:`launch` action that can be used to run arbitrary programs
-in new windows/tabs. It can be mapped to user defined shortcuts in kitty.conf.
-It is very powerful and allows sending the contents of
-the current window to the launched program, as well as many other options.
+in new windows/tabs. It can be mapped to user defined shortcuts in
+:file:`kitty.conf`. It is very powerful and allows sending the contents of the
+current window to the launched program, as well as many other options.
 
 In the simplest form, you can use it to open a new kitty window running the
 shell, as shown below::
 
     map f1 launch
 
-To run a different program simply pass the command line as arguments to
-launch::
+To run a different program simply pass the command line as arguments to launch::
 
     map f1 launch vim path/to/some/file
 
-To open a new window with the same working directory as the currently
-active window::
+To open a new window with the same working directory as the currently active
+window::
 
     map f1 launch --cwd=current
 
@@ -30,9 +29,10 @@ To open the new window in a new tab::
 
 To run multiple commands in a shell, use::
 
-    map f1 launch sh -c "ls && zsh"
+    map f1 launch sh -c "ls && exec zsh"
 
-To pass the contents of the current screen and scrollback to the started process::
+To pass the contents of the current screen and scrollback to the started
+process::
 
     map f1 launch --stdin-source=@screen_scrollback less
 
@@ -46,16 +46,16 @@ There are many more powerful options, refer to the complete list below.
         map f1 launch_tab vim
         map f2 launch_tab emacs
 
-    The :kbd:`F1` key will now open vim in a new tab with the current windows
-    working directory
+    The :kbd:`F1` key will now open :program:`vim` in a new tab with the current
+    windows working directory.
 
 
 The piping environment
 --------------------------
 
 When using :option:`launch --stdin-source`, the program to which the data is
-piped has a special environment variable declared, :envvar:`KITTY_PIPE_DATA` whose
-contents are::
+piped has a special environment variable declared, :envvar:`KITTY_PIPE_DATA`
+whose contents are::
 
    KITTY_PIPE_DATA={scrolled_by}:{cursor_x},{cursor_y}:{lines},{columns}
 
@@ -73,33 +73,33 @@ the command line:
 
 
 ``@selection``
-    replaced by the currently selected text
+    Replaced by the currently selected text.
 
 ``@active-kitty-window-id``
-    replaced by the id of the currently active kitty window
+    Replaced by the id of the currently active kitty window.
 
 ``@line-count``
-    replaced by the number of lines in STDIN. Only present when passing some
-    data to STDIN
+    Replaced by the number of lines in STDIN. Only present when passing some
+    data to STDIN.
 
 ``@input-line-number``
-    replaced the number of lines a pager should scroll to match the current
-    scroll position in kitty. See :opt:`scrollback_pager` for details
+    Replaced the number of lines a pager should scroll to match the current
+    scroll position in kitty. See :opt:`scrollback_pager` for details.
 
 ``@scrolled-by``
-    replaced by the number of lines kitty is currently scrolled by
+    Replaced by the number of lines kitty is currently scrolled by.
 
 ``@cursor-x``
-    replaced by the current cursor x position with 1 being the leftmost cell
+    Replaced by the current cursor x position with 1 being the leftmost cell.
 
 ``@cursor-y``
-    replaced by the current cursor y position with 1 being the topmost cell
+    Replaced by the current cursor y position with 1 being the topmost cell.
 
 ``@first-line-on-screen``
-    replaced by the first line on screen. Can be used for pager positioning.
+    Replaced by the first line on screen. Can be used for pager positioning.
 
 ``@last-line-on-screen``
-    replaced by the last line on screen. Can be used for pager positioning.
+    Replaced by the last line on screen. Can be used for pager positioning.
 
 
 For example::
@@ -112,44 +112,51 @@ For example::
 Watching launched windows
 ---------------------------
 
-The :option:`launch --watcher` option allows you to specify python functions
+The :option:`launch --watcher` option allows you to specify Python functions
 that will be called at specific events, such as when the window is resized or
-closed. Simply specify the path to a python module that specifies callback
+closed. Simply specify the path to a Python module that specifies callback
 functions for the events you are interested in, for example:
 
 .. code-block:: python
 
-    def on_resize(boss, window, data):
+    from typing import Any, Dict
+
+    from kitty.boss import Boss
+    from kitty.window import Window
+
+
+    def on_resize(boss: Boss, window: Window, data: Dict[str, Any]) -> None:
         # Here data will contain old_geometry and new_geometry
 
-    def on_focus_change(boss, window, data):
+    def on_focus_change(boss: Boss, window: Window, data: Dict[str, Any])-> None:
         # Here data will contain focused
 
-    def on_close(boss, window, data):
+    def on_close(boss: Boss, window: Window, data: Dict[str, Any])-> None:
         # called when window is closed, typically when the program running in
         # it exits.
 
 
 Every callback is passed a reference to the global ``Boss`` object as well as
-the ``Window`` object the action is occurring on. The ``data`` object is
-a dict that contains event dependent data. Some useful methods and attributes
-for the ``Window`` object are: ``as_text(as_ans=False, add_history=False,
+the ``Window`` object the action is occurring on. The ``data`` object is a dict
+that contains event dependent data. Some useful methods and attributes for the
+``Window`` object are: ``as_text(as_ans=False, add_history=False,
 add_wrap_markers=False, alternate_screen=False)`` with which you can get the
 contents of the window and its scrollback buffer. Similarly,
 ``window.child.pid`` is the PID of the processes that was launched
-in the window and ``window.id`` is the internal kitty ``id`` of the
-window.
+in the window and ``window.id`` is the internal kitty ``id`` of the window.
 
 
 Finding executables
 -----------------------
 
 When you specify a command to run as just a name rather than an absolute path,
-it is searched for in the system-wide ``PATH`` environment variable. Note that
-this **may not** be the value of ``PATH`` inside a shell, as shell startup scripts
-often change the value of this variable. If it is not found there, then a
-system specific list of default paths is searched. If it is still not found,
-then your shell is run and the value of ``PATH`` inside the shell is used.
+it is searched for in the system-wide :envvar:`PATH` environment variable. Note
+that this **may not** be the value of :envvar:`PATH` inside a shell, as shell
+startup scripts often change the value of this variable. If it is not found
+there, then a system specific list of default paths is searched. If it is still
+not found, then your shell is run and the value of :envvar:`PATH` inside the
+shell is used.
+
 See :opt:`exe_search_path` for details and how to control this.
 
 Syntax reference

docs/layouts.rst

@@ -10,7 +10,8 @@ other in arbitrary arrangements, based on *Layouts*, see below for examples:
     :align: center
     :width: 100%
 
-    Screenshot, showing vim, tig and git running in |kitty| with the 'Tall' layout
+    Screenshot, showing :program:`vim`, :program:`tig` and :program:`git`
+    running in |kitty| with the *Tall* layout
 
 
 .. figure:: screenshots/splits.png
@@ -18,21 +19,22 @@ other in arbitrary arrangements, based on *Layouts*, see below for examples:
     :align: center
     :width: 100%
 
-    Screenshot, showing windows with arbitrary arrangement in the 'Splits'
+    Screenshot, showing windows with arbitrary arrangement in the *Splits*
     layout
 
 
-There are many different layouts available. They are all enabled by default,
-you can switch layouts using :sc:`next_layout`. To control which layouts
-are available use :opt:`enabled_layouts`, the first listed layout becomes
-the default. Individual layouts and how to use them are described below.
+There are many different layouts available. They are all enabled by default, you
+can switch layouts using :ac:`next_layout` (:sc:`next_layout` by default). To
+control which layouts are available use :opt:`enabled_layouts`, the first listed
+layout becomes the default. Individual layouts and how to use them are described
+below.
 
 
 The Stack Layout
 ------------------
 
-This is the simplest layout it displays a single window using all available
-space, other windows are hidden behind it. It has no options::
+This is the simplest layout. It displays a single window using all available
+space, other windows are hidden behind it. This layout has no options::
 
     enabled_layouts stack
 
@@ -40,14 +42,14 @@ space, other windows are hidden behind it. It has no options::
 The Tall Layout
 ------------------
 
-Displays one (or optionally more) full height windows on the left half of the
+Displays one (or optionally more) full-height windows on the left half of the
 screen. Remaining windows are tiled vertically on the right half of the screen.
 There are options to control how the screen is split horizontally ``bias``
 (an integer between ``10`` and ``90``) and options to control how many
 full-height windows there are ``full_size`` (a positive integer). The
-``mirrored`` option when set to ``true`` will cause the short windows to be
-on the left side of the screen instead of the right. The syntax
-for the options is shown below::
+``mirrored`` option when set to ``true`` will cause the full-height windows to
+be on the right side of the screen instead of the left. The syntax
+for the options is::
 
     enabled_layouts tall:bias=50;full_size=1;mirrored=false
 
@@ -65,7 +67,7 @@ for the options is shown below::
     │              │               │
     └──────────────┴───────────────┘
 
-In addition, you can map keys to increase or decrease the number of full size
+In addition, you can map keys to increase or decrease the number of full-height
 windows, for example::
 
    map ctrl+[ layout_action decrease_num_full_size_windows
@@ -75,14 +77,13 @@ windows, for example::
 The Fat Layout
 ----------------
 
-Displays one (or optionally more) full width windows on the top half of the
-screen. Remaining windows are tiled horizontally on the bottom half of the screen.
-There are options to control how the screen is split vertically ``bias``
+Displays one (or optionally more) full-width windows on the top half of the
+screen. Remaining windows are tiled horizontally on the bottom half of the
+screen. There are options to control how the screen is split vertically ``bias``
 (an integer between ``10`` and ``90``) and options to control how many
-full-height windows there are ``full_size`` (a positive integer). The
-``mirrored`` option when set to ``true`` will cause the narrow windows to be
-on the top of the screen instead of the bottom. The syntax for the options is
-shown below::
+full-width windows there are ``full_size`` (a positive integer). The
+``mirrored`` option when set to ``true`` will cause the full-width windows to be
+on the bottom of the screen instead of the top. The syntax for the options is::
 
     enabled_layouts fat:bias=50;full_size=1;mirrored=false
 
@@ -100,11 +101,16 @@ shown below::
     └─────────┴──────────┴─────────┘
 
 
+This layout also supports ``decrease_num_full_size_windows`` layout action like
+the *Tall* layout, shown above.
+
+
 The Grid Layout
 --------------------
 
 Display windows in a balanced grid with all windows the same size except the
-last column if there are not enough windows to fill the grid. Has no options::
+last column if there are not enough windows to fill the grid. This layout has no
+options::
 
     enabled_layouts grid
 
@@ -132,20 +138,20 @@ define a few extra key bindings in :file:`kitty.conf`::
 
     # Create a new window splitting the space used by the existing one so that
     # the two windows are placed one above the other
-    map F5 launch --location=hsplit
+    map f5 launch --location=hsplit
 
     # Create a new window splitting the space used by the existing one so that
     # the two windows are placed side by side
-    map F6 launch --location=vsplit
+    map f6 launch --location=vsplit
 
     # Create a new window splitting the space used by the existing one so that
     # the two windows are placed side by side if the existing window is wide or
     # one above the other if the existing window is tall.
-    map F4 launch --location=split
+    map f4 launch --location=split
 
     # Rotate the current split, chaging its split axis from vertical to
     # horizontal or vice versa
-    map F7 layout_action rotate
+    map f7 layout_action rotate
 
     # Move the active window in the indicated direction
     map shift+up move_window up
@@ -159,16 +165,16 @@ define a few extra key bindings in :file:`kitty.conf`::
     map ctrl+up neighboring_window up
     map ctrl+down neighboring_window down
 
-Windows can be resized using :ref:`window_resizing`.  You can swap the windows
+Windows can be resized using :ref:`window_resizing`. You can swap the windows
 in a split using the ``rotate`` action with an argument of ``180`` and rotate
 and swap with an argument of ``270``.
 
 This layout takes one option, ``split_axis`` that controls whether new windows
-are placed into vertical or horizontal splits when a ``--location`` is not
-specified. A value of ``horizontal`` (same as ``--location=vsplit``)
-means when a new split is created the two windows will be placed side by side
-and a value of ``vertical`` (same as ``--location=hsplit``) means the two
-windows will be placed one on top of the other. By default::
+are placed into vertical or horizontal splits when a :option:`--location <launch
+--location>` is not specified. A value of ``horizontal`` (same as
+``--location=vsplit``) means when a new split is created the two windows will be
+placed side by side and a value of ``vertical`` (same as ``--location=hsplit``)
+means the two windows will be placed one on top of the other. By default::
 
     enabled_layouts splits:split_axis=horizontal
 
@@ -193,7 +199,7 @@ windows will be placed one on top of the other. By default::
 The Horizontal Layout
 ------------------------
 
-All windows are shown side by side. Has no options::
+All windows are shown side by side. This layout has no options::
 
     enabled_layouts horizontal
 
@@ -213,7 +219,7 @@ All windows are shown side by side. Has no options::
 The Vertical Layout
 -----------------------
 
-All windows are shown one below the other. Has no options::
+All windows are shown one below the other. This layout has no options::
 
     enabled_layouts vertical
 
@@ -239,14 +245,14 @@ Resizing windows
 
 You can resize windows inside layouts. Press :sc:`start_resizing_window` (also
 :kbd:`⌘+r` on macOS) to enter resizing mode and follow the on-screen
-instructions.  In a given window layout only some operations may be possible
-for a particular window. For example, in the Tall layout you can make the first
+instructions. In a given window layout only some operations may be possible for
+a particular window. For example, in the *Tall* layout you can make the first
 window wider/narrower, but not taller/shorter. Note that what you are resizing
 is actually not a window, but a row/column in the layout, all windows in that
 row/column will be resized.
 
 You can also define shortcuts in :file:`kitty.conf` to make the active window
-wider, narrower, taller, or shorter by mapping to the ``resize_window``
+wider, narrower, taller, or shorter by mapping to the :ac:`resize_window`
 action, for example::
 
    map ctrl+left resize_window narrower
@@ -256,22 +262,21 @@ action, for example::
    # reset all windows in the tab to default sizes
    map ctrl+home resize_window reset
 
-The ``resize_window`` action has a second, optional argument to control
+The :ac:`resize_window` action has a second optional argument to control
 the resizing increment (a positive integer that defaults to 1).
 
-
-Some layouts take options to control their behavior. For example, the ``fat``
-and ``tall`` layouts accept the ``bias`` and ``full_size`` options to control
-how the available space is split up.
-To specify the option, in :opt:`kitty.conf <enabled_layouts>` use::
+Some layouts take options to control their behavior. For example, the *Fat*
+and *Tall* layouts accept the ``bias`` and ``full_size`` options to control
+how the available space is split up. To specify the option, in :opt:`kitty.conf
+<enabled_layouts>` use::
 
     enabled_layouts tall:bias=70;full_size=2
 
 This will have ``2`` instead of a single tall window, that occupy ``70%``
-instead of ``50%`` of available width. ``bias`` can be any number between 10
-and 90.
+instead of ``50%`` of available width. ``bias`` can be any number between ``10``
+and ``90``.
 
 Writing a new layout only requires about two hundred lines of code, so if there
 is some layout you want, take a look at one of the existing layouts in the
-`layout <https://github.com/kovidgoyal/kitty/tree/master/kitty/layout>`_
+`layout <https://github.com/kovidgoyal/kitty/tree/master/kitty/layout>`__
 package and submit a pull request!

docs/marks.rst

@@ -9,12 +9,12 @@ running programs or similar. Lets start with a few examples:
 Examples
 ----------
 
-Suppose we want to be able to highlight the word ERROR in the current window.
-Add the following to :file:`kitty.conf`::
+Suppose we want to be able to highlight the word :code:`ERROR` in the current
+window. Add the following to :file:`kitty.conf`::
 
     map f1 toggle_marker text 1 ERROR
 
-Now when you press :kbd:`F1` all instances of the word :code:`ERROR` will be
+Now when you press :kbd:`F1`, all instances of the word :code:`ERROR` will be
 highlighted. To turn off the highlighting, press :kbd:`F1` again.
 If you want to make it case-insensitive, use::
 
@@ -39,41 +39,40 @@ can control the colors used for these groups in :file:`kitty.conf` with::
 
 
 .. note::
-    For performance reasons, matching is done per line only, and only when that line is
-    altered in any way. So you cannot match text that stretches across multiple
-    lines.
+    For performance reasons, matching is done per line only, and only when that
+    line is altered in any way. So you cannot match text that stretches across
+    multiple lines.
 
 
 Creating markers dynamically
 ---------------------------------
 
 If you want to create markers dynamically rather than pre-defining them in
-:file:`kitty.conf` you can do so as follows::
+:file:`kitty.conf`, you can do so as follows::
 
     map f1 create_marker
     map f2 remove_marker
 
-Then pressing :kbd:`F1` will allow you to enter the marker definition and set
-it and pressing :kbd:`F2` will remove the marker. ``create_marker`` accepts
-the same syntax as ``toggle_marker`` above. Note that while creating
-markers, the prompt has history so you can easily re-use previous marker
-expressions.
+Then pressing :kbd:`F1` will allow you to enter the marker definition and set it
+and pressing :kbd:`F2` will remove the marker. :ac:`create_marker` accepts the
+same syntax as :ac:`toggle_marker` above. Note that while creating markers, the
+prompt has history so you can easily re-use previous marker expressions.
 
-You can also use the facilities for :doc:`remote-control` to dynamically
-add/remove markers.
+You can also use the facilities for :doc:`remote-control` to dynamically add or
+remove markers.
 
 
 Scrolling to marks
 --------------------
 
-kitty has an action to scroll to the next line that contains a mark. You can
-use it by mapping it to some shortcut in :file:`kitty.conf`::
+kitty has a :ac:`scroll_to_mark` action to scroll to the next line that contains
+a mark. You can use it by mapping it to some shortcut in :file:`kitty.conf`::
 
     map ctrl+p scroll_to_mark prev
     map ctrl+n scroll_to_mark next
 
-Then pressing :kbd:`ctrl+p` will scroll to the first line in the scrollback
-buffer above the current top line that contains a mark. Pressing :kbd:`ctrl+n`
+Then pressing :kbd:`Ctrl+P` will scroll to the first line in the scrollback
+buffer above the current top line that contains a mark. Pressing :kbd:`Ctrl+N`
 will scroll to show the first line below the current last line that contains
 a mark. If you wish to jump to a mark of a specific type, you can add that to
 the mapping::
@@ -86,26 +85,26 @@ Which will scroll only to marks of type 1.
 The full syntax for creating marks
 -------------------------------------
 
-The syntax of the :code:`toggle_marker` command is::
+The syntax of the :ac:`toggle_marker` action is::
 
     toggle_marker <marker-type> <specification>
 
 Here :code:`marker-type` is one of:
 
-* :code:`text` - simple substring matching
-* :code:`itext` - case-insensitive substring matching
-* :code:`regex` - A python regular expression
-* :code:`iregex` - A case-insensitive python regular expression
-* :code:`function` - An arbitrary function defined in a python file, see :ref:`marker_funcs`.
+* :code:`text` - Simple substring matching
+* :code:`itext` - Case-insensitive substring matching
+* :code:`regex` - A Python regular expression
+* :code:`iregex` - A case-insensitive Python regular expression
+* :code:`function` - An arbitrary function defined in a Python file, see :ref:`marker_funcs`.
 
 .. _marker_funcs:
 
 Arbitrary marker functions
 -----------------------------
 
-You can create your own marker functions. Create a python file named
-:file:`mymarker.py` and in it create a :code:`marker` function. This
-function receives the text of the line as input and must yield three numbers,
+You can create your own marker functions. Create a Python file named
+:file:`mymarker.py` and in it create a :code:`marker` function. This function
+receives the text of the line as input and must yield three numbers,
 the starting character position, the ending character position and the mark
 group (1-3). For example:
 
@@ -122,6 +121,7 @@ Save this file somewhere and in :file:`kitty.conf`, use::
 
     map f1 toggle_marker function /path/to/mymarker.py
 
-If you save the file in the kitty config directory, you can use::
+If you save the file in the :ref:`kitty config directory <confloc>`, you can
+use::
 
     map f1 toggle_marker function mymarker.py

docs/open_actions.rst

@@ -1,15 +1,14 @@
 Scripting the mouse click
 ======================================================
 
-|kitty| has support for `terminal hyperlinks
-<https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda>`_. These
-are generated by many terminal programs, such as ``ls``, ``gcc``, ``systemd``,
-:ref:`tool_mdcat`, etc. You can customize exactly what happens when clicking on these
-hyperlinks in |kitty|.
+|kitty| has support for :term:`terminal hyperlinks <hyperlinks>`. These are
+generated by many terminal programs, such as ``ls``, ``gcc``, ``systemd``,
+:ref:`tool_mdcat`, etc. You can customize exactly what happens when clicking on
+these hyperlinks in |kitty|.
 
-You can tell kitty to take arbitrarily many, complex actions
-when a link is clicked. Let us illustrate with some examples, first. Create
-the file :file:`~/.config/kitty/open-actions.conf` with the following:
+You can tell kitty to take arbitrarily many, complex actions when a link is
+clicked. Let us illustrate with some examples, first. Create the file
+:file:`~/.config/kitty/open-actions.conf` with the following:
 
 .. code:: conf
 
@@ -22,6 +21,13 @@ Now, run ``ls --hyperlink=auto`` in kitty and click on the filename of an
 image, holding down :kbd:`ctrl+shift`. It will be opened over the current
 window. Press any key to close it.
 
+.. note::
+
+    The :program:`ls` comes with macOS does not support hyperlink, you need to
+    install `GNU Coreutils <https://www.gnu.org/software/coreutils/>`__. If you
+    install it via `Homebrew <https://formulae.brew.sh/formula/coreutils>`__, it
+    will be :program:`gls`.
+
 Each entry in :file:`open-actions.conf` consists of one or more
 :ref:`matching_criteria`, such as ``protocol`` and ``mime`` and one or more
 ``action`` entries. In the example above kitty uses the :doc:`launch <launch>`
@@ -29,8 +35,8 @@ action which can be used to run external programs. Entries are separated by
 blank lines.
 
 Actions are very powerful, anything that you can map to a key combination in
-`kitty.conf` can be used as an action. You can specify more than one action per
-entry if you like, for example:
+:file:`kitty.conf` can be used as an action. You can specify more than one
+action per entry if you like, for example:
 
 
 .. code:: conf
@@ -60,7 +66,7 @@ some special variables, documented below:
 
 
 .. note::
-   You can use the :opt:`action_alias` option just as in kitty.conf to
+   You can use the :opt:`action_alias` option just as in :file:`kitty.conf` to
    define aliases for frequently used actions.
 
 
@@ -77,7 +83,7 @@ lines. The various available criteria are:
 
 ``protocol``
     A comma separated list of protocols, for example: ``http, https``. If
-    absent, there is no constraint on protocol
+    absent, there is no constraint on protocol.
 
 ``url``
     A regular expression that must match against the entire (unquoted) URL
@@ -88,11 +94,12 @@ lines. The various available criteria are:
 
 ``mime``
     A comma separated list of MIME types, for example: ``text/*, image/*,
-    application/pdf``. You can add MIME types to kitty by creating the
-    :file:`mime.types` in the kitty configuration directory. Useful if your
-    system MIME database does not have definitions you need. This file is
-    in the standard format of one definition per line, like: ``text/plain rst
-    md``. Note that the MIME type for directories is ``inode/directory``.
+    application/pdf``. You can add MIME types to kitty by creating a file named
+    :file:`mime.types` in the :ref:`kitty configuration directory <confloc>`.
+    Useful if your system MIME database does not have definitions you need. This
+    file is in the standard format of one definition per line, like:
+    ``text/plain rst md``. Note that the MIME type for directories is
+    ``inode/directory``.
 
 ``ext``
     A comma separated list of file extensions, for example: ``jpeg, tar.gz``
@@ -116,9 +123,10 @@ URLs onto the kitty dock icon to open them with kitty. The default actions are:
 
 These actions can also be executed from the command line by running::
 
-    open -a kitty.app file_or_url ... (on macOS only)
-    or
-    kitty +open file_or_url ...
+    kitty +open file_or_url another_url ...
+
+    # macOS only
+    open -a kitty.app file_or_url another_url ...
 
 Since macOS lacks an official interface to set default URL scheme handlers,
 kitty has a command you can use for it. The first argument for is the URL
@@ -133,8 +141,8 @@ defaults to kitty, if not specified. For example:
     kitty +runpy 'from kitty.fast_data_types import cocoa_set_url_handler; import sys; cocoa_set_url_handler(*sys.argv[1:]); print("OK")' xyz someapp.bundle.identifier
 
 You can customize these actions by creating a :file:`launch-actions.conf` file
-in the kitty config directory, just like
-the :file:`open-actions.conf` file above. For example:
+in the :ref:`kitty config directory <confloc>`, just like the
+:file:`open-actions.conf` file above. For example:
 
 .. code:: conf
 

docs/overview.rst

@@ -4,23 +4,22 @@ Overview
 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 configuration in source control).
+|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 configuration 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.
+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 little effort.
+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 little effort.
 
 .. include:: basic.rst
 
@@ -28,10 +27,10 @@ relatively little effort.
 Configuring kitty
 -------------------
 
-|kitty| is highly configurable, everything from keyboard shortcuts to
-painting frames-per-second. Press :sc:`edit_config_file` in kitty
-to open its fully commented sample config file in your text editor.
-For details see the :doc:`configuration docs <conf>`.
+|kitty| is highly configurable, everything from keyboard shortcuts to painting
+frames-per-second. Press :sc:`edit_config_file` in kitty to open its fully
+commented sample config file in your text editor. For details see the
+:doc:`configuration docs <conf>`.
 
 .. toctree::
    :hidden:
@@ -51,17 +50,26 @@ windows automatically, resizing and moving them as needed. You can create a new
 
 Currently, there are seven layouts available:
 
-* **Fat** -- One (or optionally more) windows are shown full width on the top, the rest of the windows are shown side-by-side on the bottom
+* **Fat** -- One (or optionally more) windows are shown full width on the top,
+  the rest of the windows are shown side-by-side on the bottom
+
 * **Grid** -- All windows are shown in a grid
+
 * **Horizontal** -- All windows are shown side-by-side
-* **Splits** -- Windows arranged in arbitrary patterns created using horizontal and vertical splits
+
+* **Splits** -- Windows arranged in arbitrary patterns created using horizontal
+  and vertical splits
+
 * **Stack** -- Only a single maximized window is shown at a time
-* **Tall** -- One (or optionally more) windows are shown full height on the left, the rest of the windows are shown one below the other on the right
+
+* **Tall** -- One (or optionally more) windows are shown full height on the
+  left, the rest of the windows are shown one below the other on the right
+
 * **Vertical** -- All windows are shown one below the other
 
 By default, all layouts are enabled and 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
+particular layouts, and choose which layouts you want to enable, see
 :ref:`conf-kitty-shortcuts.layout` for examples. The first layout listed in
 :opt:`enabled_layouts` becomes the default layout.
 
@@ -79,9 +87,9 @@ Extending kitty
 kitty has a powerful framework for scripting. You can create small terminal
 programs called :doc:`kittens <kittens_intro>`. These can used to add features
 to kitty, for example, :doc:`editing remote files <kittens/remote_file>` or
-:doc:`inputting unicode characters <kittens/unicode_input>`. They can also be
+:doc:`inputting Unicode characters <kittens/unicode_input>`. They can also be
 used to create programs that leverage kitty's powerful features, for example,
-:doc:`viewing images <kittens/icat>` or :doc:`diffing files with images
+:doc:`viewing images <kittens/icat>` or :doc:`diffing files with image support
 <kittens/diff>`.
 
 You can :doc:`create your own kittens to scratch your own itches
@@ -101,9 +109,9 @@ Remote control
 |kitty| has a very powerful system that allows you to control it from the
 :doc:`shell prompt, even over SSH <remote-control>`. You can change colors,
 fonts, open new :term:`windows <window>`, :term:`tabs <tab>`, set their titles,
-change window layout, get text
-from one window and send text to another, etc, etc. The possibilities are
-endless. See the :doc:`tutorial <remote-control>` to get started.
+change window layout, get text from one window and send text to another, etc.
+The possibilities are endless. See the :doc:`tutorial <remote-control>` to get
+started.
 
 .. toctree::
    :hidden:
@@ -117,10 +125,9 @@ Startup Sessions
 ------------------
 
 You can control the :term:`tabs <tab>`, :term:`kitty window <window>` layout,
-working directory, startup programs,
-etc. by creating a "session" file and using the :option:`kitty --session`
-command line flag or the :opt:`startup_session` option in :file:`kitty.conf`.
-For example:
+working directory, startup programs, etc. by creating a *session* file and using
+the :option:`kitty --session` command line flag or the :opt:`startup_session`
+option in :file:`kitty.conf`. For example:
 
 .. code-block:: session
 
@@ -130,28 +137,28 @@ For example:
     cd ~
     # Create a window and run the specified command in it
     launch zsh
-    # Create a window with some environment variables set and run
-    # vim in it
+    # Create a window with some environment variables set and run vim in it
     launch --env FOO=BAR vim
     # Set the title for the next window
     launch --title "Chat with x" 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)
+    # Create a new tab
+    # The part after new_tab is the optional tab title 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
+    enabled_layouts tall,stack
     # Set the current layout
     layout stack
     launch zsh
 
     # Create a new OS window
+    # Any definitions specifed before the first new_os_window will apply to first OS window.
     new_os_window
-    # set new window size to 80x25 cells
-    os_window_size 80c 25c
-    # set the --class for the new OS window
+    # Set new window size to 80x24 cells
+    os_window_size 80c 24c
+    # Set the --class for the new OS window
     os_window_class mywindow
     launch sh
     # Make the current window the active (focused) window
@@ -159,8 +166,8 @@ For example:
     launch emacs
 
 .. note::
-    The :doc:`launch <launch>` command when used in a session file
-    cannot create new OS windows, or tabs.
+    The :doc:`launch <launch>` command when used in a session file cannot create
+    new OS windows, or tabs.
 
 
 Creating tabs/windows
@@ -182,25 +189,25 @@ Mouse features
 * You can click on a URL to open it in a browser.
 * You can double click to select a word and then drag to select more words.
 * You can triple click to select a line and then drag to select more lines.
-* You can triple click while holding :kbd:`ctrl+alt` to select from clicked
+* You can triple click while holding :kbd:`Ctrl+Alt` to select from clicked
   point to end of line.
 * You can right click to extend a previous selection.
-* You can hold down :kbd:`ctrl+alt` and drag with the mouse to select in
+* You can hold down :kbd:`Ctrl+Alt` and drag with the mouse to select in
   columns.
-* Selecting text automatically copies it to the primary clipboard (on
-  platforms with a primary clipboard).
-* You can middle click to paste from the primary clipboard (on platforms
+* Selecting text automatically copies it to the primary clipboard (on platforms
   with a primary clipboard).
-* You can right click while holding :kbd:`ctrl+shift` to open the output
-  of the clicked on command in a pager (requires :ref:`shell_integration`)
-* You can select text with kitty even when a terminal program has grabbed
-  the mouse by holding down the :kbd:`shift` key
+* You can middle click to paste from the primary clipboard (on platforms with a
+  primary clipboard).
+* You can right click while holding :kbd:`Ctrl+Shift` to open the output of the
+  clicked on command in a pager (requires :ref:`shell_integration`)
+* You can select text with kitty even when a terminal program has grabbed the
+  mouse by holding down the :kbd:`Shift` key
 
 All these actions can be customized in :file:`kitty.conf` as described
 :ref:`here <conf-kitty-mouse.mousemap>`.
 
-You can also customize what happens when clicking on :term:`hyperlinks` in kitty,
-having it open files in your editor, download remote files, open things
+You can also customize what happens when clicking on :term:`hyperlinks` in
+kitty, having it open files in your editor, download remote files, open things
 in your browser, etc.
 
 For details, see :doc:`here <open_actions>`.
@@ -214,12 +221,11 @@ 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
-:ref:`conf-kitty-fonts`.
+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 comein handy
+for applications like powerline, without the need to use patched fonts. See the
+various font related configuration directives in :ref:`conf-kitty-fonts`.
 
 
 .. _scrollback:
@@ -228,29 +234,29 @@ The scrollback buffer
 -----------------------
 
 |kitty| supports scrolling back to view history, just like most terminals. You
-can use either 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 buffer
-comfortably within the pager.
+can use either 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` shortcut, which will open the scrollback buffer in
+your favorite pager program (which is :program:`less` by default). Colors and
+text formatting are preserved. You can explore the scrollback buffer comfortably
+within the pager.
 
 Additionally, you can pipe the contents of the scrollback buffer to an
-arbitrary, command running in a new :term:`window`, :term:`tab` or :term:`overlay`,
-for example::
+arbitrary, command running in a new :term:`window`, :term:`tab` or
+:term:`overlay`. For example::
 
    map f1 launch --stdin-source=@screen_scrollback --stdin-add-formatting less +G -R
 
-Would open the scrollback buffer in a new :term:`window` when you press the :kbd:`F1`
-key. See :sc:`show_scrollback <show_scrollback>` for details.
+Would open the scrollback buffer in a new :term:`window` when you press the
+:kbd:`F1` key. See :sc:`show_scrollback <show_scrollback>` for details.
 
-If you want to use it with an editor such as vim to get more powerful features,
-you can see tips for doing so, in :iss:`this thread <719>`.
+If you want to use it with an editor such as :program:`vim` to get more powerful
+features, you can see tips for doing so, in :iss:`this thread <719>`.
 
-If you wish to store very large amounts of scrollback to view using the piping or
-:sc:`show_scrollback <show_scrollback>` features, you can use the
+If you wish to store very large amounts of scrollback to view using the piping
+or :sc:`show_scrollback <show_scrollback>` features, you can use the
 :opt:`scrollback_pager_history_size` option.
 
 
@@ -258,8 +264,8 @@ Integration with shells
 ---------------------------------
 
 kitty has the ability to integrate closely within common shells, such as `zsh
-<https://www.zsh.org/>`_, `fish <https://fishshell.com>`_ and `bash
-<https://www.gnu.org/software/bash/>`_ to enable features such as jumping to
+<https://www.zsh.org/>`__, `fish <https://fishshell.com>`__ and `bash
+<https://www.gnu.org/software/bash/>`__ to enable features such as jumping to
 previous prompts in the scrollback, viewing the output of the last command in
 :program:`less`, using the mouse to move the cursor while editing prompts, etc.
 See :doc:`shell-integration` for details.
@@ -274,17 +280,16 @@ See :doc:`shell-integration` for details.
 Multiple copy/paste buffers
 -----------------------------
 
-In addition to being able to copy/paste from the system clipboard, in |kitty| you
-can also setup an arbitrary number of copy paste buffers. To do so, simply add
-something like the following to your :file:`kitty.conf`::
+In addition to being able to copy/paste from the system clipboard, in |kitty|
+you can also setup an arbitrary number of copy paste buffers. To do so, simply
+add something like the following to your :file:`kitty.conf`::
 
    map f1 copy_to_buffer a
    map f2 paste_from_buffer a
 
 This will allow you to press :kbd:`F1` to copy the current selection to an
 internal buffer named ``a`` and :kbd:`F2` to paste from that buffer. The buffer
-names are arbitrary strings, so you can define as many such buffers as you
-need.
+names are arbitrary strings, so you can define as many such buffers as you need.
 
 
 Marks

docs/performance.rst

@@ -2,30 +2,31 @@ 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
+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. :opt:`repaint_delay`
-and :opt:`input_delay`. These control the artificial delays introduced into the
-render loop to reduce CPU usage. See :ref:`conf-kitty-performance` for details.
-See also the :opt:`sync_to_monitor` option to further decrease latency at the cost
-of some `tearing <https://en.wikipedia.org/wiki/Screen_tearing>`_ while scrolling.
+There are two config options you can tune to adjust the performance,
+:opt:`repaint_delay` and :opt:`input_delay`. These control the artificial delays
+introduced into the render loop to reduce CPU usage. See
+:ref:`conf-kitty-performance` for details. See also the :opt:`sync_to_monitor`
+option to further decrease latency at the cost of some `screen tearing
+<https://en.wikipedia.org/wiki/Screen_tearing>`__ while scrolling.
 
-You can generate detailed per-function performance data using `gperftools
-<https://github.com/gperftools/gperftools>`_. Build |kitty| with `make
-profile`. Run kitty 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.
+You can generate detailed per-function performance data using
+`gperftools <https://github.com/gperftools/gperftools>`__. Build |kitty| with
+``make profile``. Run kitty and perform the task you want to analyse, for
+example, scrolling a large file with :program:`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
+Here are some CPU usage numbers for the task of scrolling a file continuously in
+:program:`less`. The CPU usage is for the terminal process and X together and is
+measured using :program:`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.
 
 ==============   =========================
@@ -49,11 +50,11 @@ admittedly biased, eyes).
 
 .. note::
 
-    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.
+    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.

docs/protocol-extensions.rst

@@ -1,23 +1,24 @@
 Terminal protocol extensions
 ===================================
 
-|kitty| has extensions to the legacy terminal protocol, to enable advanced features.
-These are typically in the form of new or re-purposed escape codes. While these
-extensions are currently |kitty| specific, it would be nice to get some of them
-adopted more broadly, to push the state of terminal emulators forward.
+|kitty| has extensions to the legacy terminal protocol, to enable advanced
+features. These are typically in the form of new or re-purposed escape codes.
+While these extensions are currently |kitty| specific, it would be nice to get
+some of them adopted more broadly, to push the state of terminal emulators
+forward.
 
 The goal of these extensions is to be as small and unobtrusive as possible,
-while filling in some gaps in the existing xterm protocol. In particular, one
-of the goals of this specification is explicitly not to "re-imagine" the tty.
-The tty should remain what it is -- a device for efficiently processing text
+while filling in some gaps in the existing xterm protocol. In particular, one of
+the goals of this specification is explicitly not to "re-imagine" the TTY. The
+TTY should remain what it is -- a device for efficiently processing text
 received as a simple byte stream. Another objective is to only move the minimum
-possible amount of extra functionality into the terminal program itself. This
-is to make it as easy to implement these protocol extensions as possible,
-thereby hopefully encouraging their widespread adoption.
+possible amount of extra functionality into the terminal program itself. This is
+to make it as easy to implement these protocol extensions as possible, thereby
+hopefully encouraging their widespread adoption.
 
-If you wish to discuss these extensions, propose additions/changes to them
-please do so by opening issues in the `GitHub
-<https://github.com/kovidgoyal/kitty/issues>`_ bug tracker.
+If you wish to discuss these extensions, propose additions or changes to them,
+please do so by opening issues in the `GitHub bug tracker
+<https://github.com/kovidgoyal/kitty/issues>`__.
 
 
 .. toctree::

docs/quickstart.rst

@@ -9,9 +9,9 @@ Quickstart
    binary
    build
 
-Pre-built binaries of |kitty| are available for both macOS and Linux.
-See the :doc:`binary install instructions </binary>`. You can also
-:doc:`build from source </build>`.
+Pre-built binaries of |kitty| are available for both macOS and Linux. See the
+:doc:`binary install instructions </binary>`. You can also :doc:`build from
+source </build>`.
 
 Additionally, you can use your favorite package manager to install the |kitty|
 package, but note that some Linux distribution packages are woefully outdated.
@@ -25,4 +25,4 @@ and Linux.
 See :doc:`Configuring kitty <conf>` for help on configuring |kitty| and
 :doc:`Invocation <invocation>` for the command line arguments |kitty| supports.
 
-For a tour of kitty's design and features, see the :doc:`/overview`.
+For a tour of kitty's design and features, see the :doc:`overview`.

docs/rc_protocol.rst

@@ -16,25 +16,26 @@ Where ``<ESC>`` is the byte ``0x1b``. The JSON object has the form::
         "payload": <Optional JSON object>,
     }
 
-The ``version`` above is an array of the form :code:`[0, 14, 2]`. If you are developing a
-standalone client, use the kitty version that you are developing against. Using
-a version greater than the version of the kitty instance you are talking to,
-will cause a failure.
+The ``version`` above is an array of the form :code:`[0, 14, 2]`. If you are
+developing a standalone client, use the kitty version that you are developing
+against. Using a version greater than the version of the kitty instance you are
+talking to, will cause a failure.
 
 Set ``no_response`` to ``true`` if you don't want a response from kitty.
 
-The optional payload is a JSON object that is specific to the actual command being sent.
-The fields in the object for every command are documented below.
+The optional payload is a JSON object that is specific to the actual command
+being sent. The fields in the object for every command are documented below.
 
 As a quick example showing how easy to use this protocol is, we will implement
-the ``@ ls`` command from the shell using only shell tools. First, run kitty
-as::
+the ``@ ls`` command from the shell using only shell tools.
+
+First, run kitty as::
 
     kitty -o allow_remote_control=socket-only --listen-on unix:/tmp/test
 
 Now, in a different terminal, you can get the pretty printed ``@ ls`` output
 with the following command line::
 
-    echo -en '\eP@kitty-cmd{"cmd":"ls","version":[0,14,2]}\e\' | socat - unix:/tmp/test | awk '{ print substr($0, 13, length($0) - 14) }' | jq -c '.data | fromjson' | jq .
+    echo -en '\eP@kitty-cmd{"cmd":"ls","version":[0,14,2]}\e\\' | socat - unix:/tmp/test | awk '{ print substr($0, 13, length($0) - 14) }' | jq -c '.data | fromjson' | jq .
 
 .. include:: generated/rc.rst

docs/remote-control.rst

@@ -4,9 +4,12 @@ Control kitty from scripts
 .. highlight:: sh
 
 |kitty| can be controlled from scripts or the shell prompt. You can open new
-windows, send arbitrary text input to any window, name windows and tabs, etc.
+windows, send arbitrary text input to any window, change the title of windows
+and tabs, etc.
+
 Let's walk through a few examples of controlling |kitty|.
 
+
 Tutorial
 ------------
 
@@ -21,43 +24,44 @@ Now, in the new |kitty| window, enter the command::
 
     kitty @ launch --title Output --keep-focus cat
 
-This will open a new window, running the ``cat`` program that will appear next
-to the current window.
+This will open a new window, running the :program:`cat` program that will appear
+next to the current window.
 
 Let's send some text to this new window::
 
     kitty @ send-text --match cmdline:cat Hello, World
 
-This will make ``Hello, World`` show up in the window running the ``cat`` program.
-The :option:`kitty @ send-text --match` option is very powerful, it allows selecting windows by their
-titles, the command line of the program running in the window, the working
-directory of the program running in the window, etc.  See ``kitty @ send-text
---help`` for details.
+This will make ``Hello, World`` show up in the window running the :program:`cat`
+program. The :option:`kitty @ send-text --match` option is very powerful, it
+allows selecting windows by their titles, the command line of the program
+running in the window, the working directory of the program running in the
+window, etc. See :ref:`kitty @ send-text --help <at_send-text>` for details.
 
 More usefully, you can pipe the output of a command running in one window to
 another window, for example::
 
-    ls | kitty @ send-text --match title:Output --stdin
+    ls | kitty @ send-text --match title:^Output --stdin
 
-This will show the output of ls in the output window instead of the current
-window. You can use this technique to, for example, show the output of running
-``make`` in your editor in a different window. The possibilities are endless.
+This will show the output of :program:`ls` in the output window instead of the
+current window. You can use this technique to, for example, show the output of
+running :program:`make` in your editor in a different window. The possibilities
+are endless.
 
 You can even have things you type show up in a different window. Run::
 
-    kitty @ send-text --match title:Output --stdin
+    kitty @ send-text --match title:^Output --stdin
 
 And type some text, it will show up in the output window, instead of the current
-window. Type ``Ctrl+D`` when you are ready to stop.
+window. Type :kbd:`Ctrl+D` when you are ready to stop.
 
 Now, let's open a new tab::
 
    kitty @ launch --type=tab --tab-title "My Tab" --keep-focus bash
 
 This will open a new tab running the bash shell with the title "My Tab".
-We can change the title of the tab with::
+We can change the title of the tab to "New Title" with::
 
-   kitty @ set-tab-title --match title:My  New Title
+   kitty @ set-tab-title --match title:^My New Title
 
 Let's change the title of the current tab::
 
@@ -65,79 +69,83 @@ Let's change the title of the current tab::
 
 Now lets switch to the newly opened tab::
 
-   kitty @ focus-tab --match title:New
+   kitty @ focus-tab --match title:^New
 
 Similarly, to focus the previously opened output window (which will also switch
 back to the old tab, automatically)::
 
-   kitty @ focus-window --match title:Output
+   kitty @ focus-window --match title:^Output
 
 You can get a listing of available tabs and windows, by running::
 
    kitty @ ls
 
 This outputs a tree of data in JSON format. The top level of the tree is all
-operating system kitty windows. Each OS window has an id and a list of tabs.
-Each tab has its own id, a title and a list of windows. Each window has an id,
-title, current working directory, process id (PID) and command-line of the
-process running in the window. You can use this information with :option:`kitty @ focus-window --match`
-to control individual windows.
+:term:`OS windows <os_window>`. Each OS window has an id and a list of
+:term:`tabs <tab>`. Each tab has its own id, a title and a list of :term:`kitty
+windows <window>`. Each window has an id, title, current working directory,
+process id (PID) and command-line of the process running in the window. You can
+use this information with :option:`kitty @ focus-window --match` to control
+individual windows.
 
-As you can see, it is very easy to control |kitty| using the
-``kitty @`` messaging system. This tutorial touches only the
-surface of what is possible. See ``kitty @ --help`` for more details.
+As you can see, it is very easy to control |kitty| using the ``kitty @``
+messaging system. This tutorial touches only the surface of what is possible.
+See ``kitty @ --help`` for more details.
 
-Note that in the example's above, ``kitty @`` messaging works only when run inside a |kitty| window,
-not anywhere. But, within a |kitty| window it even works over SSH. If you want to control
-|kitty| from programs/scripts not running inside a |kitty| window, you have to implement a couple of
-extra steps. First start |kitty| as::
+Note that in the example's above, ``kitty @`` messaging works only when run
+inside a |kitty| window, not anywhere. But, within a |kitty| window it even
+works over SSH. If you want to control |kitty| from programs/scripts not running
+inside a |kitty| window, you have to implement a couple of extra steps. First
+start |kitty| as::
 
     kitty -o allow_remote_control=yes --listen-on unix:/tmp/mykitty
 
-The :option:`kitty --listen-on` option tells |kitty| to listen for control messages at the
-specified path. See ``kitty --help`` for details. Now you can control this
-instance of |kitty| using the :option:`kitty @ --to` command line argument to ``kitty @``. For example::
+The :option:`kitty --listen-on` option tells |kitty| to listen for control
+messages at the specified UNIX-domain socket. See ``kitty --help`` for details.
+Now you can control this instance of |kitty| using the :option:`kitty @ --to`
+command line argument to ``kitty @``. For example::
 
     kitty @ --to unix:/tmp/mykitty ls
 
 
-Note that if all you want to do is run a single |kitty| "daemon" and have subsequent
-|kitty| invocations appear as new top-level windows, you can use the simpler :option:`kitty --single-instance`
-option, see ``kitty --help`` for that.
+Note that if all you want to do is run a single |kitty| "daemon" and have
+subsequent |kitty| invocations appear as new top-level windows, you can use the
+simpler :option:`kitty --single-instance` option, see ``kitty --help`` for that.
+
 
 The builtin kitty shell
 --------------------------
 
-You can explore the |kitty| command language more easily using the builtin |kitty|
-shell. Run ``kitty @`` with no arguments and you will be dropped into the |kitty|
-shell with completion for |kitty| command names and options.
+You can explore the |kitty| command language more easily using the builtin
+|kitty| shell. Run ``kitty @`` with no arguments and you will be dropped into
+the |kitty| shell with completion for |kitty| command names and options.
 
 You can even open the |kitty| shell inside a running |kitty| using a simple
 keyboard shortcut (:sc:`kitty_shell` by default).
 
 .. note:: This has the added advantage that you don't need to use
-   ``allow_remote_control`` to make it work.
+   :opt:`allow_remote_control` to make it work.
 
 
 Allowing only some windows to control kitty
 ----------------------------------------------
 
-If you do not want to allow all programs running in |kitty| to control it, you can selectively
-enable remote control for only some |kitty| windows. Simply create a shortcut
-such as::
+If you do not want to allow all programs running in |kitty| to control it, you
+can selectively enable remote control for only some |kitty| windows. Simply
+create a shortcut such as::
 
     map ctrl+k launch --allow-remote-control some_program
 
 Then programs running in windows created with that shortcut can use ``kitty @``
 to control kitty. Note that any program with the right level of permissions can
-still write to the pipes of any other program on the same computer and
-therefore can control |kitty|. It can, however, be useful to block programs
-running on other computers (for example, over ssh) or as other users.
+still write to the pipes of any other program on the same computer and therefore
+can control |kitty|. It can, however, be useful to block programs running on
+other computers (for example, over SSH) or as other users.
 
-.. note:: You dont need ``allow_remote_control`` to make this work as it is
+.. note:: You don't need :opt:`allow_remote_control` to make this work as it is
    limited to only programs running in that specific window. Be careful with
    what programs you run in such windows, since they can effectively control
-   kitty, as if you were running with ``allow_remote_control`` turned on.
+   kitty, as if you were running with :opt:`allow_remote_control` turned on.
 
 
 .. _rc_mapping:
@@ -148,15 +156,15 @@ Mapping key presses to remote control commands
 If you wish to trigger a remote control command easily with just a keypress,
 you can map it in :file:`kitty.conf`. For example::
 
-    map F1 remote_control set-spacing margin=30
+    map f1 remote_control set-spacing margin=30
 
-Then pressing the :kbd:`F1` key will set the active window margins to 30.
-The syntax for what follows :code:`remote_control` is exactly the same
+Then pressing the :kbd:`F1` key will set the active window margins to
+:code:`30`. The syntax for what follows :ac:`remote_control` is exactly the same
 as the syntax for what follows :code:`kitty @` above.
 
-.. note:: You do not need ``allow_remote_control`` to use these mappings,
-   as they are not actual remote programs, but are simply a way to resuse
-   the remote control infrastructure via keybings.
+.. note:: You do not need :opt:`allow_remote_control` to use these mappings,
+   as they are not actual remote programs, but are simply a way to resuse the
+   remote control infrastructure via keybings.
 
 
 Broadcasting what you type to all kitty windows
@@ -166,17 +174,36 @@ As a simple illustration of the power of remote control, lets
 have what we type sent to all open kitty windows. To do that define the
 following mapping in :file:`kitty.conf`::
 
-    map F1 launch --allow-remote-control kitty +kitten broadcast
+    map f1 launch --allow-remote-control kitty +kitten broadcast
 
-Now press, F1 and start typing, what you type will be sent to all windows,
+Now press :kbd:`F1` and start typing, what you type will be sent to all windows,
 live, as you type it.
 
 
 The remote control protocol
 -----------------------------------------------
 
-If you wish to develop your own client to talk to |kitty|, you
-can use the :doc:`protocol specification <rc_protocol>`.
+If you wish to develop your own client to talk to |kitty|, you can use the
+:doc:`remote control protocol specification <rc_protocol>`.
+
+
+.. _search_syntax:
+
+Matching windows and tabs
+----------------------------
+
+Many remote control operations operate on windows or tabs. To select these, the
+:code:`--match` option is often used. This allows matching using various
+sophisticated criteria such as title, ids, cmdlines, etc. These criteria are
+expressions of the form :code:`field:query`. Where :italic:`field` is the field
+against which to match and :italic:`query` is the expression to match. They can
+be further combined using Boolean operators, best illustrated with some
+examples::
+
+    title:"My special window" or id:43
+    title:bash and env:USER=kovid
+    not id:1
+    (id:2 or id:3) and title:something
 
 .. toctree::
    :hidden:

docs/shell-integration.rst

@@ -4,8 +4,8 @@ Shell integration
 -------------------
 
 kitty has the ability to integrate closely within common shells, such as `zsh
-<https://www.zsh.org/>`_, `fish <https://fishshell.com>`_ and `bash
-<https://www.gnu.org/software/bash/>`_ to enable features such as jumping to
+<https://www.zsh.org/>`__, `fish <https://fishshell.com>`__ and `bash
+<https://www.gnu.org/software/bash/>`__ to enable features such as jumping to
 previous prompts in the scrollback, viewing the output of the last command in
 :program:`less`, using the mouse to move the cursor while editing prompts, etc.
 
@@ -22,7 +22,7 @@ Features
 
 * Click with the mouse anywhere in the current command to move the cursor there
 
-* Hold :kbd:`ctrl+shift` and right-click on any command output in the scrollback
+* Hold :kbd:`Ctrl+Shift` and right-click on any command output in the scrollback
   to view it in a pager
 
 * The current working directory or the command being executed are automatically
@@ -30,6 +30,9 @@ Features
 
 * The text cursor is changed to a bar when editing commands at the shell prompt
 
+* :ref:`clone_shell` with all environment variables and the working directory
+  copied
+
 * Glitch free window resizing even with complex prompts. Achieved by erasing
   the prompt on resize and allowing the shell to redraw it cleanly.
 
@@ -43,7 +46,7 @@ Configuration
 ---------------
 
 Shell integration is controlled by the :opt:`shell_integration` option. By
-default, all shell integration is enabled. Individual features can be turned
+default, all integration features are enabled. Individual features can be turned
 off or it can be disabled entirely as well. The :opt:`shell_integration` option
 takes a space separated list of keywords:
 
@@ -53,26 +56,28 @@ disabled
     :ref:`manual integration <manual_shell_integration>`.
 
 no-rc
-    Do not modify the shell's launch environment to enable integration. Useful if you prefer
-    to load the kitty shell integration code yourself, either as part of
-    :ref:`manually integration <manual_shell_integration>` or because you have
-    some other software that sets up shell integration.
-    This will still set the :envvar:`KITTY_SHELL_INTEGRATION` environment variable when kitty runs the shell.
+    Do not modify the shell's launch environment to enable integration. Useful
+    if you prefer to load the kitty shell integration code yourself, either as
+    part of :ref:`manually integration <manual_shell_integration>` or because
+    you have some other software that sets up shell integration.
+    This will still set the :envvar:`KITTY_SHELL_INTEGRATION` environment
+    variable when kitty runs the shell.
 
 no-cursor
-    Turn off changing of the text cursor to a bar when editing text
+    Turn off changing of the text cursor to a bar when editing shell command
+    line.
 
 no-title
     Turn off setting the kitty window/tab title based on shell state.
-    Note that for the ``fish`` shell kitty relies on fish's native title
-    setting functionality instead.
+    Note that for the fish shell kitty relies on fish's native title setting
+    functionality instead.
 
 no-cwd
     Turn off reporting the current working directory. This is used to allow
-    :ac:`new_window_with_cwd` and similar to open windows logged
-    into remote machines using the :doc:`ssh kitten <kittens/ssh>`
-    automatically with the same working directory as the current window.
-    Note that for the ``fish`` shell this will not disable its built-in current
+    :ac:`new_window_with_cwd` and similar to open windows logged into remote
+    machines using the :doc:`ssh kitten <kittens/ssh>` automatically with the
+    same working directory as the current window.
+    Note that for the fish shell this will not disable its built-in current
     working directory reporting.
 
 no-prompt-mark
@@ -81,16 +86,16 @@ no-prompt-mark
 
 no-complete
     Turn off completion for the kitty command.
-    Note that for the ``fish`` shell this does not take effect, since fish
-    already comes with a kitty completion script.
+    Note that for the fish shell this does not take effect, since fish already
+    comes with a kitty completion script.
 
 
 More ways to browse command output
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 You can add further key and mouse bindings to browse the output of commands
-easily. For example to select the output of a command by right clicking the mouse
-on the output, define the following in :file:`kitty.conf`:
+easily. For example to select the output of a command by right clicking the
+mouse on the output, define the following in :file:`kitty.conf`:
 
 .. code:: conf
 
@@ -101,8 +106,8 @@ to be copied.
 
 The feature to jump to previous prompts (
 :sc:`scroll_to_previous_prompt` and :sc:`scroll_to_next_prompt`) and mouse
-actions (:ac:`mouse_select_command_output` and :ac:`mouse_show_command_output`) can
-be integrated with browsing command output as well. For example, define the
+actions (:ac:`mouse_select_command_output` and :ac:`mouse_show_command_output`)
+can be integrated with browsing command output as well. For example, define the
 following mapping in :file:`kitty.conf`:
 
 .. code:: conf
@@ -134,34 +139,34 @@ How it works
 -----------------
 
 At startup, kitty detects if the shell you have configured (either system wide
-or in kitty.conf) is a supported shell. If so, kitty injects some shell specific
-code into the shell, to enable shell integration. How it does so varies for
-different shells.
+or the :opt:`shell` option in :file:`kitty.conf`) is a supported shell. If so,
+kitty injects some shell specific code into the shell, to enable shell
+integration. How it does so varies for different shells.
 
 
 .. tab:: zsh
 
-   For zsh, kitty sets the ``ZDOTDIR`` environment variable to make zsh load
-   kitty's :file:`.zshenv` which restores the original value of ``ZDOTDIR``
-   and sources the original :file:`.zshenv`. It then loads the shell integration code.
-   The remainder of zsh's startup process proceeds as normal.
+   For zsh, kitty sets the :envvar:`ZDOTDIR` environment variable to make zsh
+   load kitty's :file:`.zshenv` which restores the original value of
+   :envvar:`ZDOTDIR` and sources the original :file:`.zshenv`. It then loads
+   the shell integration code. The remainder of zsh's startup process proceeds
+   as normal.
 
 .. tab:: fish
 
     For fish, to make it automatically load the integration code provided by
     kitty, the integration script directory path is prepended to the
-    ``XDG_DATA_DIRS`` environment variable. This is only applied to the fish
-    process and will be cleaned up by the integration script after startup. No files
-    are added or modified.
+    :envvar:`XDG_DATA_DIRS` environment variable. This is only applied to the
+    fish process and will be cleaned up by the integration script after startup.
+    No files are added or modified.
 
 .. tab:: bash
 
     For bash, kitty starts bash in POSIX mode, using the environment variable
-    ``ENV`` to load the shell integration script. This prevents bash from
+    :envvar:`ENV` to load the shell integration script. This prevents bash from
     loading any startup files itself. The loading of the startup files is done
-    by the integration script, after disabling POSIX mode. From the
-    perspective of those scripts there should be no difference to running
-    vanilla bash.
+    by the integration script, after disabling POSIX mode. From the perspective
+    of those scripts there should be no difference to running vanilla bash.
 
 
 Then, when launching the shell, kitty sets the environment variable
@@ -215,6 +220,49 @@ shell integration. Alternately, you can :ref:`setup shell integration manually
 the remote server and editing the shell rc files there, as described below.
 
 
+.. _clone_shell:
+
+Clone the current shell into a new window
+-----------------------------------------------
+
+You can clone the current shell into a new kitty window by simply running the
+:command:`clone-in-kitty` command, for example:
+
+.. code-block:: sh
+
+    clone-in-kitty
+    clone-in-kitty --type=tab
+    clone-in-kitty --title "I am a clone"
+
+This will open a new window running a new shell instance but with all
+environment variables and the current working directory copied. This even works
+over SSH when using :doc:`kittens/ssh`.
+
+The :command:`clone-in-kitty` command takes almost all the same arguments as the
+:doc:`launch <launch>` command, so you can open a new tab instead or a new OS
+window, etc. Arguments of launch that can cause code execution or that don't
+make sense when cloning are ignored. Most prominently, the following options are
+ignored: :option:`--allow-remote-control <launch --allow-remote-control>`,
+:option:`--copy-cmdline <launch --copy-cmdline>`, :option:`--copy-env <launch
+--copy-env>`, :option:`--stdin-source <launch --stdin-source>`,
+:option:`--marker <launch --marker>` and :option:`--watcher <launch --watcher>`.
+
+:command:`clone-in-kitty` can be configured to source arbitrary code in the
+cloned window using environment variables. It will automatically clone virtual
+environments created by the :link:`Python venv module
+<https://docs.python.org/3/library/venv.html>` or :link:`Conda
+<https://conda.io/>`. In addition, setting the
+env var :envvar:`KITTY_CLONE_SOURCE_CODE` to some shell code will cause that
+code to be run in the cloned window with :code:`eval`. Similarly, setting
+:envvar:`KITTY_CLONE_SOURCE_PATH` to the path of a file will cause that file to
+be sourced in the cloned window. This can be controlled by
+:opt:`clone_source_strategies`.
+
+:command:`clone-in-kitty` works by asking the shell to serialize its internal
+state (mainly CWD and env vars) and this state is transmitted to kitty and
+restored by the shell integration scripts in the cloned window.
+
+
 .. _manual_shell_integration:
 
 Manual shell integration
@@ -276,9 +324,10 @@ to point to the location of the scripts.
 Integration with other shells
 -------------------------------
 
-There exist third-party integrations to use these features for various other shells:
+There exist third-party integrations to use these features for various other
+shells:
 
-* Jupyter console via a patch (:iss:`4475`)
+* Jupyter console and IPython via a patch (:iss:`4475`)
 * `xonsh <https://github.com/xonsh/xonsh/issues/4623>`__
 
 

docs/underlines.rst

@@ -1,24 +1,25 @@
 Colored and styled underlines
 ================================
 
-|kitty| supports colored and styled (wavy) underlines. This is of particular
-use in terminal editors such as vim and emacs to display red, wavy underlines
-under mis-spelled words and/or syntax errors. This is done by re-purposing some
-SGR escape codes that are not used in modern terminals (`CSI codes
-<https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_(Control_Sequence_Introducer)_sequences>`_)
+|kitty| supports colored and styled (wavy) underlines. This is of particular use
+in terminal based text editors such as :program:`vim` and :program:`emacs` to
+display red, wavy underlines under mis-spelled words and/or syntax errors. This
+is done by re-purposing some SGR escape codes that are not used in modern
+terminals (`CSI codes <https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_(Control_Sequence_Introducer)_sequences>`__)
 
 To set the underline style::
 
-    <ESC>[4:0m  # this is no underline
-    <ESC>[4:1m  # this is a straight underline
-    <ESC>[4:2m  # this is a double underline
-    <ESC>[4:3m  # this is a curly underline
-    <ESC>[4:4m  # this is a dotted underline
-    <ESC>[4:5m  # this is a dashed underline
-    <ESC>[4m    # this is a straight underline (for backwards compat)
-    <ESC>[24m   # this is no underline (for backwards compat)
+    <ESC>[4:0m  # no underline
+    <ESC>[4:1m  # straight underline
+    <ESC>[4:2m  # double underline
+    <ESC>[4:3m  # curly underline
+    <ESC>[4:4m  # dotted underline
+    <ESC>[4:5m  # dashed underline
+    <ESC>[4m    # straight underline (for backwards compat)
+    <ESC>[24m   # no underline (for backwards compat)
 
-To set the underline color (this is reserved and as far as I can tell not actually used for anything)::
+To set the underline color (this is reserved and as far as I can tell not
+actually used for anything)::
 
     <ESC>[58...m
 
@@ -29,8 +30,8 @@ To reset the underline color (also previously reserved and unused)::
 
     <ESC>[59m
 
-The underline color must remain the same under reverse video, if it has a
-color, if not, it should follow the foreground color.
+The underline color must remain the same under reverse video, if it has a color,
+if not, it should follow the foreground color.
 
-To detect support for this feature in a terminal emulator, query the terminfo database
-for the ``Su`` boolean capability.
+To detect support for this feature in a terminal emulator, query the terminfo
+database for the ``Su`` boolean capability.

docs/unscroll.rst

@@ -4,10 +4,10 @@ Unscrolling the screen
 ========================
 
 This is a small extension to the `SD (Pan up) escape code
-<https://vt100.net/docs/vt510-rm/SD.html>`_ from the VT-420 terminal. The
-``SD`` escape code normally causes the text on screen to scroll down by the
-specified number of lines, with empty lines appearing at the top of the screen.
-This extension allows the new lines to be filled in from the scrollback buffer
+<https://vt100.net/docs/vt510-rm/SD.html>`_ from the VT-420 terminal. The ``SD``
+escape code normally causes the text on screen to scroll down by the specified
+number of lines, with empty lines appearing at the top of the screen. This
+extension allows the new lines to be filled in from the scrollback buffer
 instead of being blank.
 
 The motivation for this is that many modern shells will show completions in a
@@ -22,17 +22,17 @@ scrolled down is implementation defined, but must be at least one screen worth.
 
 The syntax of the escape code is identical to that of ``SD`` except that it has
 a trailing ``+`` modifier. This is legal under the `ECMA 48 standard
-<https://www.ecma-international.org/publications-and-standards/standards/ecma-48/>`_
+<https://www.ecma-international.org/publications-and-standards/standards/ecma-48/>`__
 and unused for any other purpose as far as I can tell. So for example, to
 unscroll three lines, the escape code would be::
 
     CSI 3 + T
 
 See `discussion here
-<https://gitlab.freedesktop.org/terminal-wg/specifications/-/issues/30>`_.
+<https://gitlab.freedesktop.org/terminal-wg/specifications/-/issues/30>`__.
 
 .. versionadded:: 0.20.2
 
 Also supported by the terminals:
 
-    * `mintty <https://github.com/mintty/mintty/releases/tag/3.5.2>`_
+* `mintty <https://github.com/mintty/mintty/releases/tag/3.5.2>`__

glfw/cocoa_window.m

@@ -1731,7 +1731,11 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
 
     if (!createNativeWindow(window, wndconfig, fbconfig))
         return false;
-    [window->ns.object setColorSpace:[NSColorSpace sRGBColorSpace]];
+    switch((GlfwCocoaColorSpaces)wndconfig->ns.color_space) {
+        case SRGB_COLORSPACE: [window->ns.object setColorSpace:[NSColorSpace sRGBColorSpace]]; break;
+        case DISPLAY_P3_COLORSPACE: [window->ns.object setColorSpace:[NSColorSpace displayP3ColorSpace]]; break;
+        case DEFAULT_COLORSPACE: break;
+    }
 
     if (ctxconfig->client != GLFW_NO_API)
     {

glfw/glfw3.h

@@ -1024,6 +1024,16 @@ typedef enum GLFWMouseButton {
  *  [window hint](@ref GLFW_COCOA_GRAPHICS_SWITCHING_hint).
  */
 #define GLFW_COCOA_GRAPHICS_SWITCHING 0x00023003
+/*! @brief macOS specific
+ *  [window hint](@ref GLFW_COCOA_COLOR_SPACE_hint).
+ */
+#define GLFW_COCOA_COLOR_SPACE 0x00023004
+typedef enum {
+    DEFAULT_COLORSPACE = 0,
+    SRGB_COLORSPACE = 1,
+    DISPLAY_P3_COLORSPACE = 2,
+} GlfwCocoaColorSpaces;
+
 /*! @brief X11 specific
  *  [window hint](@ref GLFW_X11_CLASS_NAME_hint).
  */
@@ -1206,7 +1216,8 @@ typedef enum {
 typedef enum {
     GLFW_IME_NONE,
     GLFW_IME_PREEDIT_CHANGED,
-    GLFW_IME_COMMIT_TEXT
+    GLFW_IME_COMMIT_TEXT,
+    GLFW_IME_WAYLAND_DONE_EVENT,
 } GLFWIMEState;
 
 typedef enum {

glfw/internal.h

@@ -307,6 +307,7 @@ struct _GLFWwndconfig
     bool          scaleToMonitor;
     struct {
         bool      retina;
+        int       color_space;
         char      frameName[256];
     } ns;
     struct {

glfw/window.c

@@ -332,6 +332,8 @@ void glfwDefaultWindowHints(void)
 
     // The default is to use full Retina resolution framebuffers
     _glfw.hints.window.ns.retina = true;
+    // use the default colorspace assigned by the system
+    _glfw.hints.window.ns.color_space = 0;
 }
 
 GLFWAPI void glfwWindowHint(int hint, int value)
@@ -412,6 +414,9 @@ GLFWAPI void glfwWindowHint(int hint, int value)
         case GLFW_COCOA_RETINA_FRAMEBUFFER:
             _glfw.hints.window.ns.retina = value ? true : false;
             return;
+        case GLFW_COCOA_COLOR_SPACE:
+            _glfw.hints.window.ns.color_space = value;
+            return;
         case GLFW_COCOA_GRAPHICS_SWITCHING:
             _glfw.hints.context.nsgl.offline = value ? true : false;
             return;

glfw/wl_init.c

@@ -143,10 +143,15 @@ static void setCursor(GLFWCursorShape shape, _GLFWwindow* window)
 
     if (!image)
         return;
+    if (image->width % scale || image->height % scale) {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "WARNING: Cursor image size: %dx%d is not a multiple of window scale: %d. This will"
+                " cause some compositors such as GNOME to crash. See https://github.com/kovidgoyal/kitty/issues/4878", image->width, image->height, scale);
+    }
 
     buffer = wl_cursor_image_get_buffer(image);
     if (!buffer)
         return;
+    debug("Calling wl_pointer_set_cursor in setCursor with surface: %p\n", (void*)surface);
     wl_pointer_set_cursor(_glfw.wl.pointer, _glfw.wl.serial,
                           surface,
                           image->hotspot_x / scale,

glfw/wl_text_input.c

@@ -84,7 +84,7 @@ text_input_delete_surrounding_text(
 }
 
 static void
-text_input_done(void *data UNUSED, struct zwp_text_input_v3 *txt_input UNUSED, uint32_t serial UNUSED) {
+text_input_done(void *data UNUSED, struct zwp_text_input_v3 *txt_input UNUSED, uint32_t serial) {
     debug("text-input: done event: serial: %u current_commit_serial: %u\n", serial, commit_serial);
     if (serial != commit_serial) {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Wayland: text_input_done serial mismatch, expected=%u got=%u\n", commit_serial, serial);
@@ -95,7 +95,7 @@ text_input_done(void *data UNUSED, struct zwp_text_input_v3 *txt_input UNUSED, u
         free(pending_pre_edit); pending_pre_edit = NULL;
     } else {
         // Clear pre-edit text
-        send_text(NULL, GLFW_IME_PREEDIT_CHANGED);
+        send_text(NULL, GLFW_IME_WAYLAND_DONE_EVENT);
     }
     if (pending_commit) {
         send_text(pending_commit, GLFW_IME_COMMIT_TEXT);

glfw/wl_window.c

@@ -147,6 +147,7 @@ setCursorImage(_GLFWwindow* window, bool on_theme_change) {
         cursorWayland->yhot = image->hotspot_y;
     }
 
+    debug("Calling wl_pointer_set_cursor in setCursorImage with surface: %p\n", (void*)surface);
     wl_pointer_set_cursor(_glfw.wl.pointer, _glfw.wl.serial,
                           surface,
                           cursorWayland->xhot / scale,
@@ -1397,6 +1398,7 @@ static void lockPointer(_GLFWwindow* window)
     window->wl.pointerLock.relativePointer = relativePointer;
     window->wl.pointerLock.lockedPointer = lockedPointer;
 
+    debug("Calling wl_pointer_set_cursor in lockPointer with surface: %p\n", NULL);
     wl_pointer_set_cursor(_glfw.wl.pointer, _glfw.wl.serial,
                           NULL, 0, 0);
 }
@@ -1433,6 +1435,7 @@ void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor)
     }
     else if (window->cursorMode == GLFW_CURSOR_HIDDEN)
     {
+        debug("Calling wl_pointer_set_cursor in _glfwPlatformSetCursor with surface: %p\n", NULL);
         wl_pointer_set_cursor(_glfw.wl.pointer, _glfw.wl.serial, NULL, 0, 0);
     }
 }

kittens/ask/main.py

@@ -92,17 +92,17 @@ be used for completions and via the browse history readline bindings.
 --choice -c
 type=list
 dest=choices
-A choice for the choices type. Every choice has the syntax: letter:text Where
-letter is the accelerator key and text is the corresponding text.  There can be
-an optional color specification after the letter to indicate what color it should
-be.
-For example: y:Yes and n;red:No
+A choice for the choices type. Can be specified multiple times. Every choice has
+the syntax: ``letter[;color]:text``. Where :italic:`letter` is the accelerator key
+and :italic:`text` is the corresponding text. There can be an optional color
+specification after the letter to indicate what color it should be.
+For example: :code:`y:Yes` and :code:`n;red:No`
 
 
 --default -d
-A default choice or text. If unspecified, it is "y" for :code:`yesno`, the first choice
-for :code:`choices` and empty for others. The default choice is selected when the user
-presses the Enter key.
+A default choice or text. If unspecified, it is :code:`y` for the type
+:code:`yesno`, the first choice for :code:`choices` and empty for others types.
+The default choice is selected when the user presses the :kbd:`Enter` key.
 
 
 --prompt -p
@@ -406,7 +406,7 @@ def main(args: List[str]) -> Response:
     except SystemExit as e:
         if e.code != 0:
             print(e.args[0])
-            input('Press enter to quit...')
+            input('Press Enter to quit')
         raise SystemExit(e.code)
 
     if cli_opts.type in ('yesno', 'choices'):

kittens/broadcast/main.py

@@ -99,7 +99,7 @@ class Broadcast(Handler):
 
 
 OPTIONS = (MATCH_WINDOW_OPTION + '\n\n' + MATCH_TAB_OPTION.replace('--match -m', '--match-tab -t')).format
-help_text = 'Broadcast typed text to all kitty windows. By default text is sent to all windows, unless one of the matching options is specified'
+help_text = 'Broadcast typed text to kitty windows. By default text is sent to all windows, unless one of the matching options is specified'
 usage = '[initial text to send ...]'
 
 

kittens/clipboard/main.py

@@ -57,7 +57,7 @@ OPTIONS = r'''
 default=False
 type=bool-set
 Output the current contents of the clipboard to STDOUT. Note that by default
-kitty will prompt you asking to allow access to the clipboard. Can be controlled
+kitty will prompt for permission to access the clipboard. Can be controlled
 by :opt:`clipboard_control`.
 
 
@@ -93,7 +93,10 @@ def main(args: List[str]) -> NoReturn:
     data: Optional[bytes] = None
     if not sys.stdin.isatty():
         data = sys.stdin.buffer.read()
-        sys.stdin = open(os.ctermid())
+        try:
+            sys.stdin = open(os.ctermid())
+        except FileNotFoundError:
+            raise SystemExit('Not connected to a controlling terminal device, no /dev/tty')
     loop = Loop()
     handler = Clipboard(data, cli_opts)
     loop.loop(handler)

kittens/diff/highlight.py

@@ -161,7 +161,7 @@ def highlight_collection(collection: Collection, aliases: Optional[Dict[str, str
                     if p:
                         is_binary = isinstance(data_for_path(p), bytes)
                         if not is_binary:
-                            jobs[executor.submit(highlight_for_diff, p, aliases)] = p
+                            jobs[executor.submit(highlight_for_diff, p, aliases or {})] = p
         for future in concurrent.futures.as_completed(jobs):
             path = jobs[future]
             try:

kittens/diff/main.py

@@ -571,8 +571,8 @@ OPTIONS = partial('''\
 --context
 type=int
 default=-1
-Number of lines of context to show between changes. Negative values
-use the number set in diff.conf
+Number of lines of context to show between changes. Negative values use the
+number set in :file:`diff.conf`.
 
 
 --config
@@ -599,7 +599,7 @@ class ShowWarning:
 
 
 showwarning = ShowWarning()
-help_text = 'Show a side-by-side diff of the specified files/directories. You can also use ssh:hostname:remote-file-path to diff remote files.'
+help_text = 'Show a side-by-side diff of the specified files/directories. You can also use :italic:`ssh:hostname:remote-file-path` to diff remote files.'
 usage = 'file_or_directory_left file_or_directory_right'
 
 

kittens/diff/options/definition.py

@@ -24,8 +24,8 @@ agr('diff', 'Diffing')
 opt('syntax_aliases', 'pyj:py pyi:py recipe:py',
     option_type='syntax_aliases',
     long_text='''
-File extension aliases for syntax highlight For example, to syntax highlight
-:file:`file.xyz` as :file:`file.abc` use a setting of :code:`xyz:abc`
+File extension aliases for syntax highlight. For example, to syntax highlight
+:file:`file.xyz` as :file:`file.abc` use a setting of :code:`xyz:abc`.
 '''
     )
 
@@ -37,8 +37,9 @@ opt('num_context_lines', '3',
 opt('diff_cmd', 'auto',
     long_text='''
 The diff command to use. Must contain the placeholder :code:`_CONTEXT_` which
-will be replaced by the number of lines of context. The default is to search the
-system for either git or diff and use that, if found.
+will be replaced by the number of lines of context. The default special value
+:code:`auto` is to search the system for either :program:`git` or
+:program:`diff` and use that, if found.
 '''
     )
 

kittens/diff/patch.py

@@ -153,7 +153,7 @@ class Hunk:
         if c.left_start + c.left_count != self.left_start + self.left_count:
             raise ValueError(f'Left side line mismatch {c.left_start + c.left_count} != {self.left_start + self.left_count}')
         if c.right_start + c.right_count != self.right_start + self.right_count:
-            raise ValueError(f'Left side line mismatch {c.right_start + c.right_count} != {self.right_start + self.right_count}')
+            raise ValueError(f'Right side line mismatch {c.right_start + c.right_count} != {self.right_start + self.right_count}')
         for c in self.chunks:
             c.finalize()
 
@@ -200,7 +200,7 @@ def parse_patch(raw: str) -> Patch:
         else:
             if current_hunk is None:
                 continue
-            q = line[0]
+            q = line[0] if line else ''
             if q == '+':
                 current_hunk.add_line()
             elif q == '-':

kittens/diff/render.py

@@ -36,6 +36,8 @@ def images_supported() -> bool:
 
 class Ref:
 
+    __slots__: Tuple[str, ...] = ()
+
     def __setattr__(self, name: str, value: object) -> None:
         raise AttributeError("can't set attribute")
 

kittens/hints/main.py

@@ -525,10 +525,10 @@ OPTIONS = r'''
 --program
 type=list
 What program to use to open matched text. Defaults to the default open program
-for the operating system. Use a value of :file:`-` to paste the match into the
-terminal window instead. A value of :file:`@` will copy the match to the
-clipboard. A value of :file:`*` will copy the match to the primary selection
-(on systems that support primary selections). A value of :file:`default` will
+for the operating system. Use a value of :code:`-` to paste the match into the
+terminal window instead. A value of :code:`@` will copy the match to the
+clipboard. A value of :code:`*` will copy the match to the primary selection
+(on systems that support primary selections). A value of :code:`default` will
 run the default open program. Can be specified multiple times to run multiple
 programs.
 
@@ -538,22 +538,22 @@ default=url
 choices=url,regex,path,line,hash,word,linenum,hyperlink,ip
 The type of text to search for. A value of :code:`linenum` is special, it looks
 for error messages using the pattern specified with :option:`--regex`, which
-must have the named groups, :code:`path` and :code:`line`. If not specified,
+must have the named groups: :code:`path` and :code:`line`. If not specified,
 will look for :code:`path:line`. The :option:`--linenum-action` option
 controls where to display the selected error message, other options are ignored.
 
 
 --regex
 default={default_regex}
-The regular expression to use when :option:`kitty +kitten hints --type`=regex.
-The regular expression is in python syntax. If you specify a numbered group in
-the regular expression only the group will be matched. This allow you to match
-text ignoring a prefix/suffix, as needed. The default expression matches lines.
-To match text over multiple lines you should prefix the regular expression with
+The regular expression to use when option :option:`--type` is set to
+:code:`regex`, in python syntax. If you specify a numbered group in the regular
+expression, only the group will be matched. This allow you to match text
+ignoring a prefix/suffix, as needed. The default expression matches lines. To
+match text over multiple lines, you should prefix the regular expression with
 :code:`(?ms)`, which turns on MULTILINE and DOTALL modes for the regex engine.
-If you specify named groups and a :option:`kitty +kitten hints --program` then
-the program will be passed arguments corresponding to each named group of
-the form key=value.
+If you specify named groups and a :option:`--program`, then the program will be
+passed arguments corresponding to each named group of the form
+:code:`key=value`.
 
 
 --linenum-action
@@ -565,22 +565,22 @@ window, :code:`window` a new kitty window, :code:`tab` a new tab,
 :code:`os_window` a new OS window and :code:`background` run in the background.
 The actual action is whatever arguments are provided to the kitten, for
 example:
-:code:`kitty + kitten hints --type=linenum --linenum-action=tab vim +{line} {path}`
+:code:`kitty +kitten hints --type=linenum --linenum-action=tab vim +{line} {path}`
 will open the matched path at the matched line number in vim in
-a new kitty tab. Note that only when using :code:`self` are the special values for
-:option:`kitty +kitten hints --program` to copy/paste the text respected.
+a new kitty tab. Note that in order to use :option:`--program` to copy or paste
+text, you need to use the special value :code:`self`.
 
 
 --url-prefixes
 default=default
-Comma separated list of recognized URL prefixes. Defaults, to
-the list of prefixes defined in kitty.conf.
+Comma separated list of recognized URL prefixes. Defaults to the list of
+prefixes defined by the :opt:`url_prefixes` option in :file:`kitty.conf`.
 
 
 --word-characters
 Characters to consider as part of a word. In addition, all characters marked as
-alphanumeric in the unicode database will be considered as word characters.
-Defaults to the select_by_word_characters setting from kitty.conf.
+alphanumeric in the Unicode database will be considered as word characters.
+Defaults to the :opt:`select_by_word_characters` option from :file:`kitty.conf`.
 
 
 --minimum-match-length
@@ -591,26 +591,26 @@ The minimum number of characters to consider a match.
 
 --multiple
 type=bool-set
-Select multiple matches and perform the action on all of them together at the end.
-In this mode, press :kbd:`Esc` to finish selecting.
+Select multiple matches and perform the action on all of them together at the
+end. In this mode, press :kbd:`Esc` to finish selecting.
 
 
 --multiple-joiner
 default=auto
-String to use to join multiple selections when copying to the clipboard or
-inserting into the terminal. The special strings: "space", "newline", "empty",
-"json" and "auto" are interpreted as a space character, a newline an empty
-joiner, a JSON serialized list and an automatic choice, based on the type of
-text being selected. In addition, integers are interpreted as zero-based
-indices into the list of selections. You can use 0 for the first selection and
--1 for the last.
+String for joining multiple selections when copying to the clipboard or
+inserting into the terminal. The special values are: :code:`space` - a space
+character, :code:`newline` - a newline, :code:`empty` - an empty joiner,
+:code:`json` - a JSON serialized list, :code:`auto` - an automatic choice, based
+on the type of text being selected. In addition, integers are interpreted as
+zero-based indices into the list of selections. You can use :code:`0` for the
+first selection and :code:`-1` for the last.
 
 
 --add-trailing-space
 default=auto
 choices=auto,always,never
-Add trailing space after matched text. Defaults to auto, which adds the space
-when used together with :option:`--multiple`.
+Add trailing space after matched text. Defaults to :code:`auto`, which adds the
+space when used together with :option:`--multiple`.
 
 
 --hints-offset
@@ -621,45 +621,47 @@ greater than or equal to zero are respected.
 
 
 --alphabet
-The list of characters to use for hints. The default is to use numbers and lowercase
-English alphabets. Specify your preference as a string of characters. Note that
-unless you specify the hints offset as zero the first match will be highlighted with
-the second character you specify.
+The list of characters to use for hints. The default is to use numbers and
+lowercase English alphabets. Specify your preference as a string of characters.
+Note that you need to specify the :option:`--hints-offset` as zero to use the
+first character to highlight the first match, otherwise it will start with the
+second character by default.
 
 
 --ascending
 type=bool-set
-Have the hints increase from top to bottom instead of decreasing from top to bottom.
+Make the hints increase from top to bottom, instead of decreasing from top to
+bottom.
 
 
 --hints-foreground-color
 default=black
 type=str
-The foreground color for hints
+The foreground color for hints.
 
 
 --hints-background-color
 default=green
 type=str
-The background color for hints
+The background color for hints.
 
 
 --hints-text-color
 default=gray
 type=str
-The foreground color for text pointed to by the hints
+The foreground color for text pointed to by the hints.
 
 
 --customize-processing
-Name of a python file in the kitty config directory which will be imported to provide
-custom implementations for pattern finding and performing actions
-on selected matches. See {hints_url}
-for details. You can also specify absolute paths to load the script from elsewhere.
+Name of a python file in the kitty config directory which will be imported to
+provide custom implementations for pattern finding and performing actions
+on selected matches. You can also specify absolute paths to load the script from
+elsewhere. See {hints_url} for details.
 
 
 --window-title
-The window title for the hints window, default title is selected based on
-the type of text being hinted.
+The title for the hints window, default title is based on the type of text being
+hinted.
 '''.format(
     default_regex=DEFAULT_REGEX,
     line='{{line}}', path='{{path}}',

kittens/hyperlinked_grep/main.py

@@ -20,7 +20,7 @@ def write_hyperlink(write: Callable[[bytes], None], url: bytes, line: bytes, fra
 
 
 def main() -> None:
-    if not sys.stdout.isatty() and '--pretty' not in sys.argv:
+    if not sys.stdout.isatty() and '--pretty' not in sys.argv and '-p' not in sys.argv:
         os.execlp('rg', 'rg', *sys.argv[1:])
     cmdline = ['rg', '--pretty', '--with-filename'] + sys.argv[1:]
     try:
@@ -59,7 +59,7 @@ def main() -> None:
                     write(line)
     except KeyboardInterrupt:
         p.send_signal(signal.SIGINT)
-    except EOFError:
+    except (EOFError, BrokenPipeError):
         pass
     finally:
         p.stdout.close()

kittens/icat/main.py

@@ -42,24 +42,24 @@ Horizontal alignment for the displayed image.
 
 
 --place
-Choose where on the screen to display the image. The image will
-be scaled to fit into the specified rectangle. The syntax for
-specifying rectangles is <:italic:`width`>x<:italic:`height`>@<:italic:`left`>x<:italic:`top`>.
-All measurements are in cells (i.e. cursor positions) with the
-origin :italic:`(0, 0)` at the top-left corner of the screen.
+Choose where on the screen to display the image. The image will be scaled to fit
+into the specified rectangle. The syntax for specifying rectangles is
+<:italic:`width`>x<:italic:`height`>@<:italic:`left`>x<:italic:`top`>.
+All measurements are in cells (i.e. cursor positions) with the origin
+:italic:`(0, 0)` at the top-left corner of the screen.
 
 
 --scale-up
 type=bool-set
-When used in combination with :option:`--place` it will cause images that
-are smaller than the specified area to be scaled up to use as much
-of the specified area as possible.
+When used in combination with :option:`--place` it will cause images that are
+smaller than the specified area to be scaled up to use as much of the specified
+area as possible.
 
 
 --background
 default=none
-Specify a background color, this will cause transparent images to be composited on
-top of the specified color.
+Specify a background color, this will cause transparent images to be composited
+on top of the specified color.
 
 
 --mirror
@@ -79,17 +79,18 @@ type=choices
 choices=detect,file,stream
 default=detect
 Which mechanism to use to transfer images to the terminal. The default is to
-auto-detect. :italic:`file` means to use a temporary file and :italic:`stream` means to
-send the data via terminal escape codes. Note that if you use the :italic:`file`
-transfer mode and you are connecting over a remote session then image display
-will not work.
+auto-detect. :italic:`file` means to use a temporary file and :italic:`stream`
+means to send the data via terminal escape codes. Note that if you use the
+:italic:`file` transfer mode and you are connecting over a remote session then
+image display will not work.
 
 
 --detect-support
 type=bool-set
 Detect support for image display in the terminal. If not supported, will exit
 with exit code 1, otherwise will exit with code 0 and print the supported
-transfer mode to stderr, which can be used with the :option:`--transfer-mode` option.
+transfer mode to stderr, which can be used with the :option:`--transfer-mode`
+option.
 
 
 --detection-timeout
@@ -101,17 +102,17 @@ detecting image display support.
 
 --print-window-size
 type=bool-set
-Print out the window size as :italic:`widthxheight` (in pixels) and quit. This is a
-convenience method to query the window size if using :code:`kitty +kitten icat` from a
-scripting language that cannot make termios calls.
+Print out the window size as <:italic:`width`>x<:italic:`height`> (in pixels) and quit. This is a
+convenience method to query the window size if using :code:`kitty +kitten icat`
+from a scripting language that cannot make termios calls.
 
 
 --stdin
 type=choices
 choices=detect,yes,no
 default=detect
-Read image data from stdin. The default is to do it automatically, when STDIN is not a terminal,
-but you can turn it off or on explicitly, if needed.
+Read image data from STDIN. The default is to do it automatically, when STDIN is
+not a terminal, but you can turn it off or on explicitly, if needed.
 
 
 --silent
@@ -121,9 +122,9 @@ Do not print out anything to STDOUT during operation.
 
 --z-index -z
 default=0
-Z-index of the image. When negative, text will be displayed on top of the image. Use
-a double minus for values under the threshold for drawing images under cell background
-colors. For example, :code:`--1` evaluates as -1,073,741,825.
+Z-index of the image. When negative, text will be displayed on top of the image.
+Use a double minus for values under the threshold for drawing images under cell
+background colors. For example, :code:`--1` evaluates as -1,073,741,825.
 
 
 --loop -l

kittens/query_terminal/main.py

@@ -66,7 +66,7 @@ def query(cls: Type[Query]) -> Type[Query]:
 class TerminalName(Query):
     name: str = 'name'
     override_query_name: str = 'name'
-    help_text: str = f'Terminal name ({names[0]})'
+    help_text: str = f'Terminal name (e.g. :code:`{names[0]}`)'
 
     @staticmethod
     def get_result(opts: Options) -> str:
@@ -76,7 +76,7 @@ class TerminalName(Query):
 @query
 class TerminalVersion(Query):
     name: str = 'version'
-    help_text: str = 'Terminal version, for e.g.: 0.19.2'
+    help_text: str = f'Terminal version (e.g. :code:`{str_version}`)'
 
     @staticmethod
     def get_result(opts: Options) -> str:
@@ -86,7 +86,7 @@ class TerminalVersion(Query):
 @query
 class AllowHyperlinks(Query):
     name: str = 'allow_hyperlinks'
-    help_text: str = 'The :opt:`setting <allow_hyperlinks>` for allowing hyperlinks can be yes, no or ask'
+    help_text: str = 'The config option :opt:`allow_hyperlinks` in :file:`kitty.conf` for allowing hyperlinks can be :code:`yes`, :code:`no` or :code:`ask`'
 
     @staticmethod
     def get_result(opts: Options) -> str:
@@ -154,7 +154,7 @@ class FontSize(Query):
 @query
 class ClipboardControl(Query):
     name: str = 'clipboard_control'
-    help_text: str = 'The :opt:`setting <clipboard_control>` for allowing reads/writes to/from the clipboard'
+    help_text: str = 'The config option :opt:`clipboard_control` in :file:`kitty.conf` for allowing reads/writes to/from the clipboard'
 
     @staticmethod
     def get_result(opts: Options) -> str:
@@ -173,17 +173,22 @@ def do_queries(queries: Iterable[str], cli_opts: QueryTerminalCLIOptions) -> Dic
     actions = tuple(all_queries[x]() for x in queries)
     qstring = ''.join(a.query_code() for a in actions)
     received = b''
+    pat = re.compile(rb'\x1b\[\?.+?c')
 
     def more_needed(data: bytes) -> bool:
         nonlocal received
         received += data
+        has_da1_response = pat.search(received) is not None
+        if has_da1_response:
+            return False
         for a in actions:
             if a.more_needed(received):
                 return True
-        return False
+        return has_da1_response
 
     with TTYIO() as ttyio:
         ttyio.send(qstring)
+        ttyio.send('\x1b[c')  # DA1 query https://vt100.net/docs/vt510-rm/DA1.html
         ttyio.recv(more_needed, timeout=cli_opts.wait_for)
 
     return {a.name: a.output_line() for a in actions}
@@ -200,30 +205,28 @@ querying it.
 
 
 help_text = '''\
-Query the terminal this kitten is run in for various
-capabilities. This sends escape codes to the terminal
-and based on its response prints out data about supported
-capabilities. Note that this is a blocking operation, since
-it has to wait for a response from the terminal. You can control
-the maximum wait time via the ``--wait-for`` option.
+Query the terminal this kitten is run in for various capabilities. This sends
+escape codes to the terminal and based on its response prints out data about
+supported capabilities. Note that this is a blocking operation, since it has to
+wait for a response from the terminal. You can control the maximum wait time via
+the :code:`--wait-for` option.
 
 The output is lines of the form::
 
-  query: data
+    query: data
 
-If a particular query is unsupported by the running kitty version,
-the data will be blank.
+If a particular :italic:`query` is unsupported by the running kitty version, the
+:italic:`data` will be blank.
 
-Note that when calling this from another program, be very
-careful not to perform any I/O on the terminal device
-until the kitten exits.
+Note that when calling this from another program, be very careful not to perform
+any I/O on the terminal device until this kitten exits.
 
 Available queries are:
 
 {}
 
 '''.format('\n'.join(
-    f'``{name}``\n  {c.help_text}\n' for name, c in all_queries.items()))
+    f':code:`{name}`:\n  {c.help_text}\n' for name, c in all_queries.items()))
 usage = '[query1 query2 ...]'
 
 

kittens/remote_file/main.py

@@ -27,6 +27,9 @@ from ..tui.operations import (
 from ..tui.utils import get_key_press
 
 
+is_ssh_kitten_sentinel = '!#*&$#($ssh-kitten)(##$'
+
+
 def key(x: str) -> str:
     return styled(x, bold=True, fg='green')
 
@@ -53,10 +56,9 @@ The data used to connect over ssh.
 
 
 def show_error(msg: str) -> None:
-    print(styled(msg, fg='red'))
+    print(styled(msg, fg='red'), file=sys.stderr)
     print()
-    print('Press any key to exit...')
-    sys.stdout.flush()
+    print('Press any key to quit', flush=True)
     with raw_mode():
         while True:
             try:
@@ -112,15 +114,25 @@ class ControlMaster:
         self.remote_path = remote_path
         self.dest = dest
         self.tdir = ''
+        self.last_error_log = ''
         self.cmd_prefix = cmd = [
             conn_data.binary, '-o', f'ControlPath=~/.ssh/kitty-master-{os.getpid()}-%r@%h:%p',
             '-o', 'TCPKeepAlive=yes', '-o', 'ControlPersist=yes'
         ]
-        if conn_data.port:
-            cmd.extend(['-p', str(conn_data.port)])
-        if conn_data.identity_file:
-            cmd.extend(['-i', conn_data.identity_file])
-        self.batch_cmd_prefix = cmd + ['-o', 'BatchMode=yes']
+        self.is_ssh_kitten = conn_data.binary is is_ssh_kitten_sentinel
+        if self.is_ssh_kitten:
+            del cmd[:]
+            self.batch_cmd_prefix = cmd
+            sk_cmdline = json.loads(conn_data.identity_file)
+            while '-t' in sk_cmdline:
+                sk_cmdline.remove('-t')
+            cmd.extend(sk_cmdline[:-2])
+        else:
+            if conn_data.port:
+                cmd.extend(['-p', str(conn_data.port)])
+            if conn_data.identity_file:
+                cmd.extend(['-i', conn_data.identity_file])
+            self.batch_cmd_prefix = cmd + ['-o', 'BatchMode=yes']
 
     def check_call(self, cmd: List[str]) -> None:
         p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL)
@@ -130,31 +142,37 @@ class ControlMaster:
             raise Exception(f'The ssh command: {shlex.join(cmd)} failed with exit code {p.returncode} and output: {out}')
 
     def __enter__(self) -> 'ControlMaster':
-        self.check_call(
-            self.cmd_prefix + ['-o', 'ControlMaster=auto', '-fN', self.conn_data.hostname])
-        self.check_call(
-            self.batch_cmd_prefix + ['-O', 'check', self.conn_data.hostname])
+        if not self.is_ssh_kitten:
+            self.check_call(
+                self.cmd_prefix + ['-o', 'ControlMaster=auto', '-fN', self.conn_data.hostname])
+            self.check_call(
+                self.batch_cmd_prefix + ['-O', 'check', self.conn_data.hostname])
         if not self.dest:
             self.tdir = tempfile.mkdtemp()
             self.dest = os.path.join(self.tdir, os.path.basename(self.remote_path))
         return self
 
     def __exit__(self, *a: Any) -> None:
-        subprocess.Popen(
-            self.batch_cmd_prefix + ['-O', 'exit', self.conn_data.hostname],
-            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL
-        ).wait()
+        if not self.is_ssh_kitten:
+            subprocess.Popen(
+                self.batch_cmd_prefix + ['-O', 'exit', self.conn_data.hostname],
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL
+            ).wait()
         if self.tdir:
             shutil.rmtree(self.tdir)
 
     @property
     def is_alive(self) -> bool:
+        if self.is_ssh_kitten:
+            return True
         return subprocess.Popen(
             self.batch_cmd_prefix + ['-O', 'check', self.conn_data.hostname],
             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL
         ).wait() == 0
 
     def check_hostname_matches(self) -> bool:
+        if self.is_ssh_kitten:
+            return True
         cp = subprocess.run(self.batch_cmd_prefix + [self.conn_data.hostname, 'hostname', '-f'], stdout=subprocess.PIPE,
                             stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL)
         if cp.returncode == 0:
@@ -181,21 +199,35 @@ class ControlMaster:
                 return response == 'y'
         return True
 
+    def show_error(self, msg: str) -> None:
+        if self.last_error_log:
+            print(self.last_error_log, file=sys.stderr)
+            self.last_error_log = ''
+        show_error(msg)
+
     def download(self) -> bool:
+        cmdline = self.batch_cmd_prefix + [self.conn_data.hostname, 'cat', self.remote_path]
         with open(self.dest, 'wb') as f:
-            return subprocess.run(
-                self.batch_cmd_prefix + [self.conn_data.hostname, 'cat', self.remote_path],
-                stdout=f, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL
-            ).returncode == 0
+            cp = subprocess.run(cmdline, stdout=f, stderr=subprocess.PIPE, stdin=subprocess.DEVNULL)
+            if cp.returncode != 0:
+                self.last_error_log = f'The command: {shlex.join(cmdline)} failed\n' + cp.stderr.decode()
+                return False
+        return True
 
     def upload(self, suppress_output: bool = True) -> bool:
         cmd_prefix = self.cmd_prefix if suppress_output else self.batch_cmd_prefix
         cmd = cmd_prefix + [self.conn_data.hostname, 'cat', '>', self.remote_path]
         if not suppress_output:
-            print(' '.join(map(shlex.quote, cmd)))
-        redirect = subprocess.DEVNULL if suppress_output else None
+            print(shlex.join(cmd))
         with open(self.dest, 'rb') as f:
-            return subprocess.run(cmd, stdout=redirect, stderr=redirect, stdin=f).returncode == 0
+            if suppress_output:
+                cp = subprocess.run(cmd, stdin=f, capture_output=True)
+                if cp.returncode == 0:
+                    return True
+                self.last_error_log = f'The command: {shlex.join(cmd)} failed\n' + cp.stdout.decode()
+            else:
+                return subprocess.run(cmd, stdin=f).returncode == 0
+        return False
 
 
 Result = Optional[str]
@@ -208,7 +240,7 @@ def main(args: List[str]) -> Result:
     except SystemExit as e:
         if e.code != 0:
             print(e.args[0])
-            input('Press enter to quit...')
+            input('Press Enter to quit')
         raise SystemExit(e.code)
 
     try:
@@ -236,7 +268,7 @@ def save_as(conn_data: SSHConnectionData, remote_path: str, cli_opts: RemoteFile
         last_used_path = tempfile.gettempdir()
     last_used_file = os.path.join(last_used_path, os.path.basename(remote_path))
     print(
-        'Where do you wish to save the file? Leaving it blank will save it as:',
+        'Where do you want to save the file? Leaving it blank will save it as:',
         styled(last_used_file, fg='yellow')
     )
     print('Relative paths will be resolved from:', styled(os.getcwd(), fg_intense=True, bold=True))
@@ -278,11 +310,15 @@ def save_as(conn_data: SSHConnectionData, remote_path: str, cli_opts: RemoteFile
     with ControlMaster(conn_data, remote_path, cli_opts, dest=dest) as master:
         if master.check_hostname_matches():
             if not master.download():
-                show_error('Failed to copy file from remote machine')
+                master.show_error('Failed to copy file from remote machine')
 
 
 def handle_action(action: str, cli_opts: RemoteFileCLIOptions) -> Result:
-    conn_data = SSHConnectionData(*json.loads(cli_opts.ssh_connection_data or ''))
+    cli_data = json.loads(cli_opts.ssh_connection_data or '')
+    if cli_data and cli_data[0] == is_ssh_kitten_sentinel:
+        conn_data = SSHConnectionData(is_ssh_kitten_sentinel, cli_data[-1], -1, identity_file=json.dumps(cli_data[1:]))
+    else:
+        conn_data = SSHConnectionData(*cli_data)
     remote_path = cli_opts.path or ''
     if action == 'open':
         print('Opening', cli_opts.path, 'from', cli_opts.hostname)
@@ -291,7 +327,7 @@ def handle_action(action: str, cli_opts: RemoteFileCLIOptions) -> Result:
             if master.check_hostname_matches():
                 if master.download():
                     return dest
-                show_error('Failed to copy file from remote machine')
+                master.show_error('Failed to copy file from remote machine')
     elif action == 'edit':
         print('Editing', cli_opts.path, 'from', cli_opts.hostname)
         editor = get_editor()
@@ -299,7 +335,7 @@ def handle_action(action: str, cli_opts: RemoteFileCLIOptions) -> Result:
             if not master.check_hostname_matches():
                 return None
             if not master.download():
-                show_error(f'Failed to download {remote_path}')
+                master.show_error(f'Failed to download {remote_path}')
                 return None
             mtime = os.path.getmtime(master.dest)
             print(reset_terminal(), end='', flush=True)
@@ -314,9 +350,9 @@ def handle_action(action: str, cli_opts: RemoteFileCLIOptions) -> Result:
             print(reset_terminal(), end='', flush=True)
             if master.is_alive:
                 if not master.upload(suppress_output=False):
-                    show_error(f'Failed to upload {remote_path}')
+                    master.show_error(f'Failed to upload {remote_path}')
             else:
-                show_error(f'Failed to upload {remote_path}, SSH master process died')
+                master.show_error(f'Failed to upload {remote_path}, SSH master process died')
     elif action == 'save':
         print('Saving', cli_opts.path, 'from', cli_opts.hostname)
         save_as(conn_data, remote_path, cli_opts)

kittens/runner.py

@@ -175,4 +175,4 @@ def main() -> None:
         print('Unhandled exception running kitten:')
         import traceback
         traceback.print_exc()
-        input('Press Enter to quit...')
+        input('Press Enter to quit')

kittens/show_error/main.py

@@ -1,13 +1,17 @@
 #!/usr/bin/env python3
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
+import json
 import os
 import sys
+import termios
 from contextlib import suppress
 from typing import List
 
 from kitty.cli import parse_args
 from kitty.cli_stub import ErrorCLIOptions
+from kitty.fast_data_types import open_tty
+from kitty.utils import hold_till_enter, no_echo, write_all
 
 from ..tui.operations import styled
 
@@ -21,14 +25,35 @@ The title for the error message.
 def real_main(args: List[str]) -> None:
     msg = 'Show an error message'
     cli_opts, items = parse_args(args[1:], OPTIONS, '', msg, 'hints', result_class=ErrorCLIOptions)
-    error_message = sys.stdin.buffer.read().decode('utf-8')
-    sys.stdin = open(os.ctermid())
+    data = json.loads(sys.stdin.buffer.read())
+    error_message = data['msg']
     if cli_opts.title:
         print(styled(cli_opts.title, fg_intense=True, fg='red', bold=True))
         print()
-    print(error_message)
-    print()
-    input('\x1b[1;32mPress Enter to close\x1b[m')
+    print(error_message, flush=True)
+    if data.get('tb'):
+        import select
+        from kittens.tui.operations import init_state, set_cursor_visible
+        fd, original_termios = open_tty()
+        msg = '\n\r\x1b[1;32mPress e to see detailed traceback or any other key to exit\x1b[m'
+        write_all(fd, msg)
+        write_all(fd, init_state(alternate_screen=False, kitty_keyboard_mode=False) + set_cursor_visible(False))
+        with no_echo(fd):
+            termios.tcdrain(fd)
+            while True:
+                rd = select.select([fd], [], [])[0]
+                if not rd:
+                    break
+                q = os.read(fd, 1)
+                if q in b'eE':
+                    break
+                return
+    if data.get('tb'):
+        tb = data['tb']
+        for ln in tb.splitlines():
+            print('\r\n', ln, sep='', end='')
+        print(flush=True)
+    hold_till_enter()
 
 
 def main(args: List[str]) -> None:

kittens/show_key/main.py

@@ -24,7 +24,7 @@ def print_key(raw: bytearray) -> None:
             unix += chr(ch)
     print(unix + '\t\t', end='')
     for ch in raw:
-        x = chr(ch).encode('ascii')
+        x = chr(ch).encode('utf-8')
         print(styled(repr(x)[2:-1], fg='yellow'), end='')
     print(end='\r\n', flush=True)
 
@@ -57,13 +57,15 @@ OPTIONS = r'''
 default=normal
 type=choices
 choices=normal,application,kitty,unchanged
-The keyboard mode to use when showing keys. "normal" mode is with DECCKM reset and "application" mode is with
-DECCKM set. "kitty" is the full kitty extended keyboard protocol.
+The keyboard mode to use when showing keys. :code:`normal` mode is with DECCKM
+reset and :code:`application` mode is with DECCKM set. :code:`kitty` is the full
+kitty extended keyboard protocol.
 '''.format
+help_text = 'Show the codes generated by the terminal for key presses in various keyboard modes'
 
 
 def main(args: List[str]) -> None:
-    cli_opts, items = parse_args(args[1:], OPTIONS, '', '', 'kitty +kitten show_key', result_class=ShowKeyCLIOptions)
+    cli_opts, items = parse_args(args[1:], OPTIONS, '', help_text, 'kitty +kitten show_key', result_class=ShowKeyCLIOptions)
     if cli_opts.key_mode == 'kitty':
         from .kitty_mode import main as kitty_main
         return kitty_main()

kittens/ssh/main.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python3
 # License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
 
-import atexit
 import fnmatch
 import glob
 import io
@@ -24,8 +23,8 @@ from contextlib import contextmanager, suppress
 from getpass import getuser
 from select import select
 from typing import (
-    Callable, Dict, Iterator, List, NoReturn, Optional, Sequence, Set, Tuple,
-    Union
+    Any, Callable, Dict, Iterator, List, NoReturn, Optional, Sequence, Set,
+    Tuple, Union, cast
 )
 
 from kittens.tui.operations import restore_colors, save_colors
@@ -34,15 +33,20 @@ from kitty.constants import (
     str_version, terminfo_dir
 )
 from kitty.options.types import Options
+from kitty.shell_integration import as_str_literal
 from kitty.shm import SharedMemory
 from kitty.types import run_once
-from kitty.utils import SSHConnectionData, set_echo as turn_off_echo, expandvars, resolve_abs_or_config_path
+from kitty.utils import (
+    SSHConnectionData, expandvars, resolve_abs_or_config_path,
+    set_echo as turn_off_echo, suppress_error_logging
+)
 
 from .completion import complete, ssh_options
 from .config import init_config
 from .copy import CopyInstruction
 from .options.types import Options as SSHOptions
 from .options.utils import DELETE_ENV_VAR
+from .utils import create_shared_memory
 
 
 @run_once
@@ -50,46 +54,54 @@ def ssh_exe() -> str:
     return shutil.which('ssh') or 'ssh'
 
 
-def is_kitten_cmdline(q: List[str]) -> bool:
-    if len(q) < 4:
-        return False
-    if os.path.basename(q[0]).lower() != 'kitty':
-        return False
-    return q[1:3] == ['+kitten', 'ssh'] or q[1:4] == ['+', 'kitten', 'ssh']
-
-
-def set_cwd_in_cmdline(cwd: str, argv: List[str]) -> None:
-    for i, arg in enumerate(tuple(argv)):
-        if arg.startswith('--kitten=cwd'):
-            argv[i] = f'--kitten=cwd={cwd}'
-            return
-        elif i > 0 and argv[i-1] == '--kitten' and (arg.startswith('cwd=') or arg.startswith('cwd ')):
-            argv[i] = cwd
-            return
-    idx = argv.index('ssh')
-    argv.insert(idx + 1, f'--kitten=cwd={cwd}')
+def read_data_from_shared_memory(shm_name: str) -> Any:
+    with SharedMemory(shm_name, readonly=True) as shm:
+        shm.unlink()
+        if shm.stats.st_uid != os.geteuid() or shm.stats.st_gid != os.getegid():
+            raise ValueError('Incorrect owner on pwfile')
+        mode = stat.S_IMODE(shm.stats.st_mode)
+        if mode != stat.S_IREAD:
+            raise ValueError('Incorrect permissions on pwfile')
+        return json.loads(shm.read_data_with_size())
 
 
 # See https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
-quote_pat = re.compile('([\\`"\n])')
+quote_pat = re.compile('([\\`"])')
 
 
-def quote_env_val(x: str) -> str:
+def quote_env_val(x: str, literal_quote: bool = False) -> str:
+    if literal_quote:
+        return as_str_literal(x)
     x = quote_pat.sub(r'\\\1', x)
     x = x.replace('$(', r'\$(')  # prevent execution with $()
     return f'"{x}"'
 
 
-def serialize_env(env: Dict[str, str], base_env: Dict[str, str]) -> bytes:
+def serialize_env(literal_env: Dict[str, str], env: Dict[str, str], base_env: Dict[str, str], for_python: bool = False) -> bytes:
     lines = []
+    literal_quote = True
 
-    def a(k: str, val: str) -> None:
-        lines.append(f'export {shlex.quote(k)}={quote_env_val(val)}')
+    if for_python:
+        def a(k: str, val: str = '', prefix: str = 'export') -> None:
+            if val:
+                lines.append(f'{prefix} {json.dumps((k, val, literal_quote))}')
+            else:
+                lines.append(f'{prefix} {json.dumps((k,))}')
+    else:
+        def a(k: str, val: str = '', prefix: str = 'export') -> None:
+            if val:
+                lines.append(f'{prefix} {shlex.quote(k)}={quote_env_val(val, literal_quote)}')
+            else:
+                lines.append(f'{prefix} {shlex.quote(k)}')
 
+    for k, v in literal_env.items():
+        a(k, v)
+
+    literal_quote = False
     for k in sorted(env):
         v = env[k]
         if v == DELETE_ENV_VAR:
-            lines.append(f'unset {shlex.quote(k)}')
+            a(k, prefix='unset')
         elif v == '_kitty_copy_env_var_':
             q = base_env.get(k)
             if q is not None:
@@ -102,10 +114,11 @@ def serialize_env(env: Dict[str, str], base_env: Dict[str, str]) -> bytes:
 @run_once
 def kitty_opts() -> Options:
     from kitty.cli import create_default_opts
-    return create_default_opts()
+    with suppress_error_logging():
+        return create_default_opts()
 
 
-def make_tarfile(ssh_opts: SSHOptions, base_env: Dict[str, str], compression: str = 'gz') -> bytes:
+def make_tarfile(ssh_opts: SSHOptions, base_env: Dict[str, str], compression: str = 'gz', literal_env: Dict[str, str] = {}) -> bytes:
 
     def normalize_tarinfo(tarinfo: tarfile.TarInfo) -> tarfile.TarInfo:
         tarinfo.uname = tarinfo.gname = ''
@@ -146,11 +159,11 @@ def make_tarfile(ssh_opts: SSHOptions, base_env: Dict[str, str], compression: st
         'TERM': os.environ.get('TERM') or kitty_opts().term,
         'COLORTERM': 'truecolor',
     }
+    env.update(ssh_opts.env)
     for q in ('KITTY_WINDOW_ID', 'WINDOWID'):
         val = os.environ.get(q)
         if val is not None:
             env[q] = val
-    env.update(ssh_opts.env)
     env['KITTY_SHELL_INTEGRATION'] = ksi or DELETE_ENV_VAR
     env['KITTY_SSH_KITTEN_DATA_DIR'] = ssh_opts.remote_dir
     if ssh_opts.login_shell:
@@ -159,7 +172,7 @@ def make_tarfile(ssh_opts: SSHOptions, base_env: Dict[str, str], compression: st
         env['KITTY_LOGIN_CWD'] = ssh_opts.cwd
     if ssh_opts.remote_kitty != 'no':
         env['KITTY_REMOTE'] = ssh_opts.remote_kitty
-    env_script = serialize_env(env, base_env)
+    env_script = serialize_env(literal_env, env, base_env, for_python=compression != 'gz')
     buf = io.BytesIO()
     with tarfile.open(mode=f'w:{compression}', fileobj=buf, encoding='utf-8') as tf:
         rd = ssh_opts.remote_dir.rstrip('/')
@@ -196,18 +209,11 @@ def get_ssh_data(msg: str, request_id: str) -> Iterator[bytes]:
         yield b'invalid ssh data request message\n'
     else:
         try:
-            with SharedMemory(pwfilename, readonly=True) as shm:
-                shm.unlink()
-                if shm.stats.st_uid != os.geteuid() or shm.stats.st_gid != os.getegid():
-                    raise ValueError('Incorrect owner on pwfile')
-                mode = stat.S_IMODE(shm.stats.st_mode)
-                if mode != stat.S_IREAD:
-                    raise ValueError('Incorrect permissions on pwfile')
-                env_data = json.loads(shm.read_data_with_size())
-                if pw != env_data['pw']:
-                    raise ValueError('Incorrect password')
-                if rq_id != request_id:
-                    raise ValueError('Incorrect request id')
+            env_data = read_data_from_shared_memory(pwfilename)
+            if pw != env_data['pw']:
+                raise ValueError('Incorrect password')
+            if rq_id != request_id:
+                raise ValueError('Incorrect request id')
         except Exception as e:
             traceback.print_exc()
             yield f'{e}\n'.encode('utf-8')
@@ -267,8 +273,8 @@ def prepare_export_home_cmd(ssh_opts: SSHOptions, is_python: bool) -> str:
 def bootstrap_script(
     ssh_opts: SSHOptions, script_type: str = 'sh', remote_args: Sequence[str] = (),
     test_script: str = '', request_id: Optional[str] = None, cli_hostname: str = '', cli_uname: str = '',
-    request_data: bool = False, echo_on: bool = True
-) -> Tuple[str, Dict[str, str], SharedMemory]:
+    request_data: bool = False, echo_on: bool = True, literal_env: Dict[str, str] = {}
+) -> Tuple[str, Dict[str, str], str]:
     if request_id is None:
         request_id = os.environ['KITTY_PID'] + '-' + os.environ['KITTY_WINDOW_ID']
     is_python = script_type == 'py'
@@ -277,14 +283,10 @@ def bootstrap_script(
     with open(os.path.join(shell_integration_dir, 'ssh', f'bootstrap.{script_type}')) as f:
         ans = f.read()
     pw = secrets.token_hex()
-    tfd = standard_b64encode(make_tarfile(ssh_opts, dict(os.environ), 'gz' if script_type == 'sh' else 'bz2')).decode('ascii')
+    tfd = standard_b64encode(make_tarfile(ssh_opts, dict(os.environ), 'gz' if script_type == 'sh' else 'bz2', literal_env=literal_env)).decode('ascii')
     data = {'pw': pw, 'opts': ssh_opts._asdict(), 'hostname': cli_hostname, 'uname': cli_uname, 'tarfile': tfd}
-    db = json.dumps(data)
-    with SharedMemory(size=len(db) + SharedMemory.num_bytes_for_size, mode=stat.S_IREAD, prefix=f'kssh-{os.getpid()}-') as shm:
-        shm.write_data_with_size(db)
-        shm.flush()
-        atexit.register(shm.unlink)
-    sensitive_data = {'REQUEST_ID': request_id, 'DATA_PASSWORD': pw, 'PASSWORD_FILENAME': shm.name}
+    shm_name = create_shared_memory(data, prefix=f'kssh-{os.getpid()}-')
+    sensitive_data = {'REQUEST_ID': request_id, 'DATA_PASSWORD': pw, 'PASSWORD_FILENAME': shm_name}
     replacements = {
         'EXPORT_HOME_CMD': export_home_cmd,
         'EXEC_CMD': exec_cmd, 'TEST_SCRIPT': test_script,
@@ -294,7 +296,7 @@ def bootstrap_script(
     if request_data:
         sd.update(sensitive_data)
     replacements.update(sensitive_data)
-    return prepare_script(ans, sd, script_type), replacements, shm
+    return prepare_script(ans, sd, script_type), replacements, shm_name
 
 
 def get_ssh_cli() -> Tuple[Set[str], Set[str]]:
@@ -499,15 +501,15 @@ def wrap_bootstrap_script(sh_script: str, interpreter: str) -> List[str]:
 
 def get_remote_command(
     remote_args: List[str], ssh_opts: SSHOptions, cli_hostname: str = '', cli_uname: str = '',
-    echo_on: bool = True, request_data: bool = False
+    echo_on: bool = True, request_data: bool = False, literal_env: Dict[str, str] = {}
 ) -> Tuple[List[str], Dict[str, str], str]:
     interpreter = ssh_opts.interpreter
     q = os.path.basename(interpreter).lower()
     is_python = 'python' in q
-    sh_script, replacements, shm = bootstrap_script(
-        ssh_opts, script_type='py' if is_python else 'sh', remote_args=remote_args,
+    sh_script, replacements, shm_name = bootstrap_script(
+        ssh_opts, script_type='py' if is_python else 'sh', remote_args=remote_args, literal_env=literal_env,
         cli_hostname=cli_hostname, cli_uname=cli_uname, echo_on=echo_on, request_data=request_data)
-    return wrap_bootstrap_script(sh_script, interpreter), replacements, shm.name
+    return wrap_bootstrap_script(sh_script, interpreter), replacements, shm_name
 
 
 def connection_sharing_args(opts: SSHOptions, kitty_pid: int) -> List[str]:
@@ -602,7 +604,9 @@ def drain_potential_tty_garbage(p: 'subprocess.Popen[bytes]', data_request: str)
 def change_colors(color_scheme: str) -> bool:
     if not color_scheme:
         return False
-    from kittens.themes.collection import load_themes, NoCacheFound, text_as_opts
+    from kittens.themes.collection import (
+        NoCacheFound, load_themes, text_as_opts
+    )
     from kittens.themes.main import colors_as_escape_codes
     if color_scheme.endswith('.conf'):
         conf_file = resolve_abs_or_config_path(color_scheme)
@@ -627,6 +631,14 @@ def change_colors(color_scheme: str) -> bool:
     return True
 
 
+def add_cloned_env(shm_name: str) -> Dict[str, str]:
+    try:
+        return cast(Dict[str, str], read_data_from_shared_memory(shm_name))
+    except FileNotFoundError:
+        pass
+    return {}
+
+
 def run_ssh(ssh_args: List[str], server_args: List[str], found_extra_args: Tuple[str, ...]) -> NoReturn:
     cmd = [ssh_exe()] + ssh_args
     hostname, remote_args = server_args[0], server_args[1:]
@@ -646,12 +658,16 @@ def run_ssh(ssh_args: List[str], server_args: List[str], found_extra_args: Tuple
     else:
         hostname_for_match = hostname
     hostname_for_match = hostname_for_match.split('@', 1)[-1].split(':', 1)[0]
-    overrides = []
+    overrides: List[str] = []
+    literal_env: Dict[str, str] = {}
     pat = re.compile(r'^([a-zA-Z0-9_]+)[ \t]*=')
     for i, a in enumerate(found_extra_args):
         if i % 2 == 1:
             aq = pat.sub(r'\1 ', a.lstrip())
-            if aq.split(maxsplit=1)[0] != 'hostname':
+            key = aq.split(maxsplit=1)[0]
+            if key == 'clone_env':
+                literal_env = add_cloned_env(aq.split(maxsplit=1)[1])
+            elif key != 'hostname':
                 overrides.append(aq)
     if overrides:
         overrides.insert(0, f'hostname {uname}@{hostname_for_match}')
@@ -677,7 +693,7 @@ def run_ssh(ssh_args: List[str], server_args: List[str], found_extra_args: Tuple
             need_to_request_data = False
     with restore_terminal_state() as echo_on:
         rcmd, replacements, shm_name = get_remote_command(
-            remote_args, host_opts, hostname_for_match, uname, echo_on, request_data=need_to_request_data)
+            remote_args, host_opts, hostname_for_match, uname, echo_on, request_data=need_to_request_data, literal_env=literal_env)
         cmd += rcmd
         colors_changed = change_colors(host_opts.color_scheme)
         try:

kittens/ssh/options/definition.py

@@ -24,26 +24,26 @@ opt = definition.add_option
 agr('bootstrap', 'Host bootstrap configuration')  # {{{
 
 opt('hostname', '*', option_type='hostname', long_text='''
-The hostname that the following options apply to. A glob pattern to match multiple
-hosts can be used. Multiple hostnames can also be specified separated by spaces.
-The hostname can include an optional username in the form :code:`user@host`.
-When not specified options apply to all hosts, until the
-first hostname specification is found. Note that matching of hostname is done against
-the name you specify on the command line to connect to the remote host.
-If you wish to include the same basic configuration for many
-different hosts, you can do so with the :ref:`include <include>` directive.
+The hostname that the following options apply to. A glob pattern to match
+multiple hosts can be used. Multiple hostnames can also be specified, separated
+by spaces. The hostname can include an optional username in the form
+:code:`user@host`. When not specified options apply to all hosts, until the
+first hostname specification is found. Note that matching of hostname is done
+against the name you specify on the command line to connect to the remote host.
+If you wish to include the same basic configuration for many different hosts,
+you can do so with the :ref:`include <include>` directive.
 ''')
 
 opt('interpreter', 'sh', long_text='''
-The interpreter to use on the remote host. Must be either a POSIX complaint shell
-or a python executable. If the default sh is not available or broken, using
-an alternate interpreter can be useful.
+The interpreter to use on the remote host. Must be either a POSIX complaint
+shell or a :program:`python` executable. If the default :program:`sh` is not
+available or broken, using an alternate interpreter can be useful.
 ''')
 
 opt('remote_dir', '.local/share/kitty-ssh-kitten', option_type='relative_dir', long_text='''
-The location on the remote host where the files needed for this kitten
-are installed. The location is relative to the HOME directory. Absolute paths or paths
-that resolve to a location outside the HOME are not allowed.
+The location on the remote host where the files needed for this kitten are
+installed. The location is relative to the HOME directory. Absolute paths or
+paths that resolve to a location outside the HOME are not allowed.
 ''')
 
 opt('+copy', '', option_type='copy', add_to_default=False, long_text=f'''
@@ -51,8 +51,7 @@ opt('+copy', '', option_type='copy', add_to_default=False, long_text=f'''
 
     copy .vimrc .zshrc .config/some-dir
 
-If a file should be copied to some other destination on the remote host,
-use :code:`--dest`::
+Use :code:`--dest` to copy a file to some other destination on the remote host::
 
     copy --dest some-other-name some-file
 
@@ -79,51 +78,54 @@ integration on a per-host basis.
 ''')
 
 opt('login_shell', '', long_text='''
-The login shell to execute on the remote host. By default, the remote user account's
-login shell is used.
+The login shell to execute on the remote host. By default, the remote user
+account's login shell is used.
 ''')
 
 opt('+env', '', option_type='env', add_to_default=False, long_text='''
-Specify environment variables to set on the remote host. Note that
-environment variables can refer to each other, so if you use::
-
-    env MYVAR1=a
-    env MYVAR2=$MYVAR1/$HOME/b
-
-The value of MYVAR2 will be :code:`a/<path to home directory>/b`. Using
-:code:`VAR=` will set it to the empty string and using just :code:`VAR`
-will delete the variable from the child process' environment. The definitions
-are processed alphabetically. The special value :code:`_kitty_copy_env_var_`
+Specify the environment variables to be set on the remote host. Using the
+name with an equal sign (e.g. :code:`env VAR=`) will set it to the empty string.
+Specifying only the name (e.g. :code:`env VAR`) will remove the variable from
+the remote shell environment. The special value :code:`_kitty_copy_env_var_`
 will cause the value of the variable to be copied from the local environment.
+The definitions are processed alphabetically. Note that environment variables
+are expanded recursively, for example::
+
+    env VAR1=a
+    env VAR2=${HOME}/${VAR1}/b
+
+The value of :code:`VAR2` will be :code:`<path to home directory>/a/b`.
 ''')
 
 opt('cwd', '', long_text='''
-The working directory on the remote host to change to. Env vars in this
-value are expanded. The default is empty so no changing is done, which
-usually means the home directory is used.
+The working directory on the remote host to change to. Environment variables in
+this value are expanded. The default is empty so no changing is done, which
+usually means the HOME directory is used.
 ''')
 
 opt('color_scheme', '', long_text='''
-Specify a color scheme to use when connecting to the remote host.  If the
-color_scheme ends with :code:`.conf` it is assumed to be the name of a config
-file to load from the kitty config directory, otherwise it is assumed to be the
-name of a color theme to load via the themes kitten. Note that only colors
-applying to the text/background are changed, other config settings in the .conf
-files/themes are ignored.
+Specify a color scheme to use when connecting to the remote host. If this option
+ends with :code:`.conf`, it is assumed to be the name of a config file to load
+from the kitty config directory, otherwise it is assumed to be the name of a
+color theme to load via the :doc:`themes kitten </kittens/themes>`. Note that
+only colors applying to the text/background are changed, other config settings
+in the .conf files/themes are ignored.
 ''')
 
 opt('remote_kitty', 'if-needed', choices=('if-needed', 'no', 'yes'), long_text='''
-Make kitty available on the remote server. Useful to run kittens such as the
-icat kitten to display images or the transfer file kitten to transfer files.
-Only works if the remote server has an architecture for which pre-compiled
-kitty binaries are available. Note that kitty is not actually copied to the
-remote server, instead a small bootstrap script is copied which will download
-and run kitty when kitty is first executed on the remote server. A value of
-:code:`if-needed` means kitty is installed only if not already present in the
-system-wide PATH. A value of :code:`yes` means that kitty is installed even if
-already present, and the installed kitty takes precedence. Finally, :code:`no`
-means no kitty is installed on the remote machine. The installed kitty
-can be updated by running: :code:`kitty +update-kitty` on the remote machine.
+Make :program:`kitty` available on the remote host. Useful to run kittens such
+as the :doc:`icat kitten </kittens/icat>` to display images or the
+:doc:`transfer file kitten </kittens/transfer>` to transfer files. Only works if
+the remote host has an architecture for which :link:`pre-compiled kitty binaries
+<https://github.com/kovidgoyal/kitty/releases>` are available. Note that kitty
+is not actually copied to the remote host, instead a small bootstrap script is
+copied which will download and run kitty when kitty is first executed on the
+remote host. A value of :code:`if-needed` means kitty is installed only if not
+already present in the system-wide PATH. A value of :code:`yes` means that kitty
+is installed even if already present, and the installed kitty takes precedence.
+Finally, :code:`no` means no kitty is installed on the remote host. The
+installed kitty can be updated by running: :code:`kitty +update-kitty` on the
+remote host.
 ''')
 egr()  # }}}
 
@@ -131,20 +133,23 @@ agr('ssh', 'SSH configuration')  # {{{
 
 opt('share_connections', 'yes', option_type='to_bool', long_text='''
 Within a single kitty instance, all connections to a particular server can be
-shared. This reduces startup latency for subsequent connections and means that you have
-to enter the password only once. Under the hood, it uses SSH ControlMasters and
-these are automatically cleaned up by kitty when it quits.
+shared. This reduces startup latency for subsequent connections and means that
+you have to enter the password only once. Under the hood, it uses SSH
+ControlMasters and these are automatically cleaned up by kitty when it quits.
+You can map a shortcut to :ac:`close_shared_ssh_connections` to disconnect all
+active shared connections.
 ''')
 
 opt('askpass', 'unless-set', choices=('unless-set', 'ssh', 'native'), long_text='''
 Control the program SSH uses to ask for passwords or confirmation of host keys
-etc. The default is to use kitty's native askpass, unless the SSH_ASKPASS
-environment variable is set. Set it to :code:`ssh` to not interfere with the
-normal ssh askpass mechanism at all, which typically means that ssh will prompt
-at the terminal. Set it to :code:`native` to always use kitty's native,
-built-in askpass implementation. Note that not using the kitty askpass implementation
-means that SSH might need to use the terminal before the connection is established
-so the kitten cannot use the terminal to send data without an extra roundtrip,
-adding to initial connection latency.
+etc. The default is to use kitty's native :program:`askpass`, unless the
+:envvar:`SSH_ASKPASS` environment variable is set. Set this option to
+:code:`ssh` to not interfere with the normal ssh askpass mechanism at all, which
+typically means that ssh will prompt at the terminal. Set it to :code:`native`
+to always use kitty's native, built-in askpass implementation. Note that not
+using the kitty askpass implementation means that SSH might need to use the
+terminal before the connection is established, so the kitten cannot use the
+terminal to send data without an extra roundtrip, adding to initial connection
+latency.
 ''')
 egr()  # }}}

kittens/ssh/utils.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+# License: GPLv3 Copyright: 2022, Kovid Goyal <kovid at kovidgoyal.net>
+
+
+import os
+from typing import Any, Dict, List
+
+
+def is_kitten_cmdline(q: List[str]) -> bool:
+    if len(q) < 4:
+        return False
+    if os.path.basename(q[0]).lower() != 'kitty':
+        return False
+    return q[1:3] == ['+kitten', 'ssh'] or q[1:4] == ['+', 'kitten', 'ssh']
+
+
+def patch_cmdline(key: str, val: str, argv: List[str]) -> None:
+    for i, arg in enumerate(tuple(argv)):
+        if arg.startswith(f'--kitten={key}='):
+            argv[i] = f'--kitten={key}={val}'
+            return
+        elif i > 0 and argv[i-1] == '--kitten' and (arg.startswith(f'{key}=') or arg.startswith(f'{key} ')):
+            argv[i] = val
+            return
+    idx = argv.index('ssh')
+    argv.insert(idx + 1, f'--kitten={key}={val}')
+
+
+def set_cwd_in_cmdline(cwd: str, argv: List[str]) -> None:
+    patch_cmdline('cwd', cwd, argv)
+
+
+def create_shared_memory(data: Any, prefix: str) -> str:
+    import atexit
+    import json
+    import stat
+
+    from kitty.shm import SharedMemory
+    db = json.dumps(data).encode('utf-8')
+    with SharedMemory(size=len(db) + SharedMemory.num_bytes_for_size, mode=stat.S_IREAD, prefix=prefix) as shm:
+        shm.write_data_with_size(db)
+        shm.flush()
+        atexit.register(shm.unlink)
+    return shm.name
+
+
+def set_env_in_cmdline(env: Dict[str, str], argv: List[str]) -> None:
+    patch_cmdline('clone_env', create_shared_memory(env, 'ksse-'), argv)

kittens/transfer/main.py

@@ -35,26 +35,28 @@ destination path on the receiving computer.
 
 
 --permissions-bypass -p
-The password to use to skip the transfer confirmation popup in kitty. Must match the
-password set for the :opt:`file_transfer_confirmation_bypass` option in kitty.conf. Note that
-leading and trailing whitespace is removed from the password. A password starting with
-., / or ~ characters is assumed to be a file name to read the password from. A value
-of - means read the password from STDIN. A password that is purely a number less than 256
-is assumed to be the number of a file descriptor from which to read the actual password.
+The password to use to skip the transfer confirmation popup in kitty. Must match
+the password set for the :opt:`file_transfer_confirmation_bypass` option in
+:file:`kitty.conf`. Note that leading and trailing whitespace is removed from
+the password. A password starting with :code:`.`, :code:`/` or :code:`~`
+characters is assumed to be a file name to read the password from. A value of
+:code:`-` means read the password from STDIN. A password that is purely a number
+less than 256 is assumed to be the number of a file descriptor from which to
+read the actual password.
 
 
 --confirm-paths -c
 type=bool-set
-Before actually transferring files, show a mapping of local file names to remote file names
-and ask for confirmation.
+Before actually transferring files, show a mapping of local file names to remote
+file names and ask for confirmation.
 
 
 --transmit-deltas -x
 type=bool-set
-If a file on the receiving side already exists, use the rsync algorithm to update it to match
-the file on the sending side, potentially saving lots of bandwidth and also automatically resuming
-partial transfers. Note that this will actually degrade performance on fast links with small
-files, so use with care.
+If a file on the receiving side already exists, use the rsync algorithm to
+update it to match the file on the sending side, potentially saving lots of
+bandwidth and also automatically resuming partial transfers. Note that this will
+actually degrade performance on fast links with small files, so use with care.
 '''
 
 

kittens/unicode_input/main.py

@@ -546,7 +546,7 @@ class UnicodeInput(Handler):
         self.refresh()
 
 
-help_text = 'Input a unicode character'
+help_text = 'Input a Unicode character'
 usage = ''
 OPTIONS = '''
 --emoji-variation
@@ -554,7 +554,7 @@ type=choices
 default=none
 choices=none,graphic,text
 Whether to use the textual or the graphical form for emoji. By default the
-default form specified in the unicode standard for the symbol is used.
+default form specified in the Unicode standard for the symbol is used.
 
 
 '''.format

kitty/backtrace.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2022 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the GPL3 license.
+ */
+
+#pragma once
+
+#include <stdio.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#if __has_include(<execinfo.h>)
+#include <execinfo.h>
+
+static inline void
+print_stack_trace(void) {
+    void *array[256];
+    size_t size;
+
+    // get void*'s for all entries on the stack
+    size = backtrace(array, 256);
+
+    // print out all the frames to stderr
+    backtrace_symbols_fd(array, size, STDERR_FILENO);
+}
+#else
+static inline void
+print_stack_trace(void) {
+    fprintf(stderr, "Stack trace functionality not available.\n");
+}
+#endif

kitty/boss.py

@@ -11,8 +11,8 @@ from functools import partial
 from gettext import gettext as _
 from time import monotonic
 from typing import (
-    Any, Callable, Container, Dict, Iterable, Iterator, List, Optional,
-    Sequence, Tuple, Union
+    Any, Callable, Container, Dict, Iterable, Iterator, List, Optional, Set,
+    Tuple, Union
 )
 from weakref import WeakValueDictionary
 
@@ -62,7 +62,7 @@ from .utils import (
     platform_window_id, remove_socket_file, safe_print, set_primary_selection,
     single_instance, startup_notification_handler, which
 )
-from .window import CommandOutput, CwdRequest, MatchPatternType, Window
+from .window import CommandOutput, CwdRequest, Window
 
 
 class OSWindowDict(TypedDict):
@@ -230,6 +230,7 @@ class Boss:
         global_shortcuts: Dict[str, SingleKey]
     ):
         set_layout_options(opts)
+        self.update_check_started = False
         self.clipboard_buffers: Dict[str, str] = {}
         self.update_check_process: Optional['PopenType[bytes]'] = None
         self.window_id_map: WeakValueDictionary[int, Window] = WeakValueDictionary()
@@ -273,7 +274,7 @@ class Boss:
         for sc in self.global_shortcuts.values():
             self.keymap.pop(sc, None)
 
-    def startup_first_child(self, os_window_id: Optional[int], startup_sessions: Sequence[Optional[Session]] = ()) -> None:
+    def startup_first_child(self, os_window_id: Optional[int], startup_sessions: Iterable[Session] = ()) -> None:
         si = startup_sessions or create_sessions(get_options(), self.args, default_session=get_options().startup_session)
         for startup_session in si:
             self.add_os_window(startup_session, os_window_id=os_window_id)
@@ -340,42 +341,19 @@ class Boss:
             yield from tab
 
     def match_windows(self, match: str) -> Iterator[Window]:
-        try:
-            field, exp = match.split(':', 1)
-        except ValueError:
+        if match == 'all':
+            yield from self.all_windows
             return
-        if field == 'num':
-            tab = self.active_tab
-            if tab is not None:
-                try:
-                    w = tab.get_nth_window(int(exp))
-                except Exception:
-                    return
-                if w is not None:
-                    yield w
-            return
-        if field == 'recent':
-            tab = self.active_tab
-            if tab is not None:
-                try:
-                    num = int(exp)
-                except Exception:
-                    return
-                w = self.window_id_map.get(tab.nth_active_window_id(num))
-                if w is not None:
-                    yield w
-            return
-        if field != 'env':
-            pat: MatchPatternType = re.compile(exp)
-        else:
-            kp, vp = exp.partition('=')[::2]
-            if vp:
-                pat = re.compile(kp), re.compile(vp)
-            else:
-                pat = re.compile(kp), None
-        for window in self.all_windows:
-            if window.matches(field, pat):
-                yield window
+        from .search_query_parser import search
+        tab = self.active_tab
+
+        def get_matches(location: str, query: str, candidates: Set[int]) -> Set[int]:
+            return {wid for wid in candidates if self.window_id_map[wid].matches_query(location, query, tab)}
+
+        for wid in search(match, (
+                'id', 'title', 'pid', 'cwd', 'cmdline', 'num', 'env', 'recent', 'state'
+        ), set(self.window_id_map), get_matches):
+            yield self.window_id_map[wid]
 
     def tab_for_window(self, window: Window) -> Optional[Tab]:
         for tab in self.all_tabs:
@@ -385,55 +363,36 @@ class Boss:
         return None
 
     def match_tabs(self, match: str) -> Iterator[Tab]:
-        try:
-            field, exp = match.split(':', 1)
-        except ValueError:
-            return
-        pat = re.compile(exp)
+        if match == 'all':
+            return self.all_tabs
+        from .search_query_parser import search
+        tm = self.active_tab_manager
+        tim = {t.id: t for t in self.all_tabs}
+
+        def get_matches(location: str, query: str, candidates: Set[int]) -> Set[int]:
+            return {wid for wid in candidates if tim[wid].matches_query(location, query, tm)}
+
         found = False
-        if field in ('title', 'id'):
-            for tab in self.all_tabs:
-                if tab.matches(field, pat):
-                    yield tab
-                    found = True
-        elif field in ('window_id', 'window_title'):
-            wf = field.split('_')[1]
-            tabs = {self.tab_for_window(w) for w in self.match_windows(f'{wf}:{exp}')}
-            for q in tabs:
-                if q:
-                    found = True
-                    yield q
-        elif field == 'index':
-            tm = self.active_tab_manager
-            if tm is not None and len(tm.tabs) > 0:
-                idx = (int(pat.pattern) + len(tm.tabs)) % len(tm.tabs)
-                found = True
-                yield tm.tabs[idx]
-        elif field == 'recent':
-            tm = self.active_tab_manager
-            if tm is not None and len(tm.tabs) > 0:
-                try:
-                    num = int(exp)
-                except Exception:
-                    return
-                q = tm.nth_active_tab(num)
-                if q is not None:
-                    found = True
-                    yield q
+        for tid in search(match, (
+                'id', 'index', 'title', 'window_id', 'window_title', 'pid', 'cwd', 'env', 'cmdline', 'recent', 'state'
+        ), set(tim), get_matches):
+            found = True
+            yield tim[tid]
+
         if not found:
             tabs = {self.tab_for_window(w) for w in self.match_windows(match)}
             for q in tabs:
                 if q:
                     yield q
 
-    def set_active_window(self, window: Window, switch_os_window_if_needed: bool = False) -> Optional[int]:
+    def set_active_window(self, window: Window, switch_os_window_if_needed: bool = False, for_keep_focus: bool = False) -> Optional[int]:
         for os_window_id, tm in self.os_window_map.items():
             for tab in tm:
                 for w in tab:
                     if w.id == window.id:
                         if tab is not self.active_tab:
-                            tm.set_active_tab(tab)
-                        tab.set_active_window(w)
+                            tm.set_active_tab(tab, for_keep_focus=window.tabref() if for_keep_focus else None)
+                        tab.set_active_window(w, for_keep_focus=window if for_keep_focus else None)
                         if switch_os_window_if_needed and current_os_window() != os_window_id:
                             focus_os_window(os_window_id, True)
                         return os_window_id
@@ -769,20 +728,20 @@ class Boss:
     def toggle_macos_secure_keyboard_entry(self) -> None:
         toggle_secure_input()
 
-    def start(self, first_os_window_id: int) -> None:
+    def start(self, first_os_window_id: int, startup_sessions: Iterable[Session]) -> None:
         if not getattr(self, 'io_thread_started', False):
             self.child_monitor.start()
             self.io_thread_started = True
             urls: List[str] = getattr(sys, 'cmdline_args_for_open', [])
-            sess = create_sessions(get_options(), self.args, special_window=SpecialWindow([kitty_exe(), '+runpy', 'input()']))
             if urls:
                 delattr(sys, 'cmdline_args_for_open')
+                sess = create_sessions(get_options(), self.args, special_window=SpecialWindow([kitty_exe(), '+runpy', 'input()']))
                 self.startup_first_child(first_os_window_id, startup_sessions=tuple(sess))
                 self.launch_urls(*urls)
             else:
-                self.startup_first_child(first_os_window_id)
+                self.startup_first_child(first_os_window_id, startup_sessions=startup_sessions)
 
-        if get_options().update_check_interval > 0 and not hasattr(self, 'update_check_started') and getattr(sys, 'frozen', False):
+        if get_options().update_check_interval > 0 and not self.update_check_started and getattr(sys, 'frozen', False):
             from .update_check import run_update_check
             run_update_check(get_options().update_check_interval * 60 * 60)
             self.update_check_started = True
@@ -1215,6 +1174,8 @@ class Boss:
                         if len(actions) > 1:
                             self.drain_actions(list(actions[1:]), window_for_dispatch, dispatch_type)
                 except Exception as e:
+                    import traceback
+                    traceback.print_exc()
                     self.show_error('Key action failed', f'{actions[0].pretty()}\n{e}')
                     consumed = True
         return consumed
@@ -1377,7 +1338,7 @@ class Boss:
         cmd = [kitty_exe(), '+runpy', 'import os, sys, time; time.sleep(0.05); os.execvp(sys.argv[1], sys.argv[1:])'] + get_editor(get_options()) + [confpath]
         self.new_os_window(*cmd)
 
-    def _run_kitten(
+    def run_kitten_with_metadata(
         self,
         kitten: str,
         args: Iterable[str] = (),
@@ -1454,6 +1415,7 @@ class Boss:
                         action_on_removal(wid, self)
                 overlay_window.actions_on_removal.append(callback_wrapper)
             return overlay_window
+    _run_kitten = run_kitten_with_metadata
 
     @ac('misc', 'Run the specified kitten. See :doc:`/kittens/custom` for details')
     def kitten(self, kitten: str, *kargs: str) -> None:
@@ -1496,7 +1458,12 @@ class Boss:
                     break
 
     def show_error(self, title: str, msg: str) -> None:
-        self._run_kitten('show_error', args=['--title', title], input_data=msg)
+        ec = sys.exc_info()
+        tb = ''
+        if ec != (None, None, None):
+            import traceback
+            tb = traceback.format_exc()
+        self._run_kitten('show_error', args=['--title', title], input_data=json.dumps({'msg': msg, 'tb': tb}))
 
     @ac('mk', 'Create a new marker')
     def create_marker(self) -> None:
@@ -1559,6 +1526,10 @@ class Boss:
         if tab:
             tab.set_active_window(window_id)
 
+    def open_kitty_website(self) -> None:
+        self.open_url(website_url())
+
+    @ac('misc', 'Open the specified URL')
     def open_url(self, url: str, program: Optional[Union[str, List[str]]] = None, cwd: Optional[str] = None) -> None:
         if not url:
             return
@@ -1616,7 +1587,7 @@ class Boss:
     def current_primary_selection_or_clipboard(self) -> str:
         return get_primary_selection() if supports_primary_selection else get_clipboard_string()
 
-    @ac('cp', 'Paste from the clipboard to the active window')
+    @ac('cp', 'Paste from the primary selection, if present, otherwise the clipboard to the active window')
     def paste_from_selection(self) -> None:
         text = self.current_primary_selection_or_clipboard()
         self.paste_to_active_window(text)
@@ -1994,8 +1965,10 @@ class Boss:
         ''')
     def load_config_file(self, *paths: str, apply_overrides: bool = True) -> None:
         from .config import load_config
+        from .cli import default_config_paths
         old_opts = get_options()
-        paths = paths or old_opts.config_paths
+        prev_paths = old_opts.config_paths or default_config_paths(self.args.config)
+        paths = paths or prev_paths
         bad_lines: List[BadLine] = []
         opts = load_config(*paths, overrides=old_opts.config_overrides if apply_overrides else None, accumulate_bad_lines=bad_lines)
         if bad_lines:
@@ -2276,7 +2249,11 @@ class Boss:
             output = '\n'.join(f'{k}={v}' for k, v in os.environ.items())
             self.display_scrollback(w, output, title=_('Current kitty env vars'), report_cursor=False)
 
-    @ac('debug', 'Close all shared SSH connections')
+    @ac('debug', '''
+        Close all shared SSH connections
+
+        See :opt:`share_connections <kitten-ssh.share_connections>` for details.
+        ''')
     def close_shared_ssh_connections(self) -> None:
         cleanup_ssh_control_masters()
 

kitty/child-monitor.c

@@ -1041,6 +1041,7 @@ process_cocoa_pending_actions(void) {
     if (cocoa_pending_actions[RELOAD_CONFIG]) { call_boss(load_config_file, NULL); }
     if (cocoa_pending_actions[TOGGLE_MACOS_SECURE_KEYBOARD_ENTRY]) { call_boss(toggle_macos_secure_keyboard_entry, NULL); }
     if (cocoa_pending_actions[TOGGLE_FULLSCREEN]) { call_boss(toggle_fullscreen, NULL); }
+    if (cocoa_pending_actions[OPEN_KITTY_WEBSITE]) { call_boss(open_kitty_website, NULL); }
     if (cocoa_pending_actions_data.wd) {
         if (cocoa_pending_actions[NEW_OS_WINDOW_WITH_WD]) { call_boss(new_os_window_with_wd, "sO", cocoa_pending_actions_data.wd, Py_True); }
         if (cocoa_pending_actions[NEW_TAB_WITH_WD]) { call_boss(new_tab_with_wd, "sO", cocoa_pending_actions_data.wd, Py_True); }

kitty/child.py

@@ -7,12 +7,15 @@ import sys
 from collections import defaultdict
 from contextlib import contextmanager, suppress
 from typing import (
-    DefaultDict, Dict, Generator, List, Optional, Sequence, Tuple, TYPE_CHECKING
+    TYPE_CHECKING, DefaultDict, Dict, Generator, List, Optional, Sequence,
+    Tuple
 )
 
 import kitty.fast_data_types as fast_data_types
 
-from .constants import is_macos, kitty_base_dir, shell_path, terminfo_dir
+from .constants import (
+    is_freebsd, is_macos, kitty_base_dir, shell_path, terminfo_dir
+)
 from .types import run_once
 from .utils import log_error, which
 
@@ -48,9 +51,18 @@ else:
         with open(f'/proc/{pid}/cmdline', 'rb') as f:
             return list(filter(None, f.read().decode('utf-8').split('\0')))
 
-    def cwd_of_process(pid: int) -> str:
-        ans = f'/proc/{pid}/cwd'
-        return os.path.realpath(ans)
+    if is_freebsd:
+        def cwd_of_process(pid: int) -> str:
+            import subprocess
+            cp = subprocess.run(['pwdx', str(pid)], capture_output=True)
+            if cp.returncode != 0:
+                raise ValueError(f'Failed to find cwd of process with pid: {pid}')
+            ans = cp.stdout.decode('utf-8', 'replace').split()[1]
+            return os.path.realpath(ans)
+    else:
+        def cwd_of_process(pid: int) -> str:
+            ans = f'/proc/{pid}/cwd'
+            return os.path.realpath(ans)
 
     def _environ_of_process(pid: int) -> str:
         with open(f'/proc/{pid}/environ', 'rb') as f:
@@ -195,9 +207,11 @@ class Child:
         stdin: Optional[bytes] = None,
         env: Optional[Dict[str, str]] = None,
         cwd_from: Optional['CwdRequest'] = None,
-        allow_remote_control: bool = False
+        allow_remote_control: bool = False,
+        is_clone_launch: str = '',
     ):
         self.allow_remote_control = allow_remote_control
+        self.is_clone_launch = is_clone_launch
         self.argv = list(argv)
         if cwd_from:
             try:
@@ -210,33 +224,36 @@ class Child:
         self.stdin = stdin
         self.env = env or {}
 
-    @property
     def final_env(self) -> Dict[str, str]:
         from kitty.options.utils import DELETE_ENV_VAR
-        env: Optional[Dict[str, str]] = getattr(self, '_final_env', None)
-        if env is None:
-            env = self._final_env = default_env().copy()
-            if is_macos and env.get('LC_CTYPE') == 'UTF-8' and not sys._xoptions.get(
-                    'lc_ctype_before_python') and not getattr(default_env, 'lc_ctype_set_by_user', False):
-                del env['LC_CTYPE']
-            env.update(self.env)
-            env['TERM'] = fast_data_types.get_options().term
-            env['COLORTERM'] = 'truecolor'
-            env['KITTY_PID'] = getpid()
-            if self.cwd:
-                # needed in case cwd is a symlink, in which case shells
-                # can use it to display the current directory name rather
-                # than the resolved path
-                env['PWD'] = self.cwd
-            tdir = checked_terminfo_dir()
-            if tdir:
-                env['TERMINFO'] = tdir
-            env['KITTY_INSTALLATION_DIR'] = kitty_base_dir
-            opts = fast_data_types.get_options()
-            if 'disabled' not in opts.shell_integration:
-                from .shell_integration import modify_shell_environ
-                modify_shell_environ(opts, env, self.argv)
-            env = {k: v for k, v in env.items() if v is not DELETE_ENV_VAR}
+        env = default_env().copy()
+        if is_macos and env.get('LC_CTYPE') == 'UTF-8' and not sys._xoptions.get(
+                'lc_ctype_before_python') and not getattr(default_env, 'lc_ctype_set_by_user', False):
+            del env['LC_CTYPE']
+        env.update(self.env)
+        env['TERM'] = fast_data_types.get_options().term
+        env['COLORTERM'] = 'truecolor'
+        env['KITTY_PID'] = getpid()
+        if self.cwd:
+            # needed in case cwd is a symlink, in which case shells
+            # can use it to display the current directory name rather
+            # than the resolved path
+            env['PWD'] = self.cwd
+        tdir = checked_terminfo_dir()
+        if tdir:
+            env['TERMINFO'] = tdir
+        env['KITTY_INSTALLATION_DIR'] = kitty_base_dir
+        opts = fast_data_types.get_options()
+        self.unmodified_argv = list(self.argv)
+        if 'disabled' not in opts.shell_integration:
+            from .shell_integration import modify_shell_environ
+            modify_shell_environ(opts, env, self.argv)
+        env = {k: v for k, v in env.items() if v is not DELETE_ENV_VAR}
+        if self.is_clone_launch:
+            env['KITTY_IS_CLONE_LAUNCH'] = self.is_clone_launch
+            self.is_clone_launch = '1'  # free memory
+        else:
+            env.pop('KITTY_IS_CLONE_LAUNCH', None)
         return env
 
     def fork(self) -> Optional[int]:
@@ -252,7 +269,7 @@ class Child:
             remove_cloexec(stdin_read_fd)
         else:
             stdin_read_fd = stdin_write_fd = -1
-        env = tuple(f'{k}={v}' for k, v in self.final_env.items())
+        env = tuple(f'{k}={v}' for k, v in self.final_env().items())
         argv = list(self.argv)
         exe = argv[0]
         if is_macos and exe == shell_path:
@@ -271,8 +288,9 @@ class Child:
             # xterm, urxvt, konsole and gnome-terminal do not do it in my
             # testing.
             argv[0] = (f'-{exe.split("/")[-1]}')
-        exe = which(exe) or exe
-        pid = fast_data_types.spawn(exe, self.cwd, tuple(argv), env, master, slave, stdin_read_fd, stdin_write_fd, ready_read_fd, ready_write_fd)
+        self.final_exe = which(exe) or exe
+        self.final_argv0 = argv[0]
+        pid = fast_data_types.spawn(self.final_exe, self.cwd, tuple(argv), env, master, slave, stdin_read_fd, stdin_write_fd, ready_read_fd, ready_write_fd)
         os.close(slave)
         self.pid = pid
         self.child_fd = master
@@ -340,8 +358,7 @@ class Child:
             return cwd_of_process(self.pid)
         return None
 
-    @property
-    def pid_for_cwd(self) -> Optional[int]:
+    def get_pid_for_cwd(self, oldest: bool = False) -> Optional[int]:
         with suppress(Exception):
             assert self.child_fd is not None
             pgrp = os.tcgetpgrp(self.child_fd)
@@ -357,25 +374,32 @@ class Child:
                 # vim
                 # With this script , the foreground process group will contain
                 # both the bash instance running the script and vim.
-                return max(foreground_processes)
+                return min(foreground_processes) if oldest else max(foreground_processes)
         return self.pid
 
     @property
-    def foreground_cwd(self) -> Optional[str]:
+    def pid_for_cwd(self) -> Optional[int]:
+        return self.get_pid_for_cwd()
+
+    def get_foreground_cwd(self, oldest: bool = False) -> Optional[str]:
         with suppress(Exception):
-            assert self.pid_for_cwd is not None
-            return cwd_of_process(self.pid_for_cwd) or None
+            pid = self.get_pid_for_cwd(oldest)
+            if pid is not None:
+                return cwd_of_process(pid) or None
         return None
 
+    @property
+    def foreground_cwd(self) -> Optional[str]:
+        return self.get_foreground_cwd()
+
     @property
     def foreground_environ(self) -> Dict[str, str]:
-        try:
-            assert self.pid_for_cwd is not None
-            return environ_of_process(self.pid_for_cwd)
-        except Exception:
-            try:
-                assert self.pid is not None
-                return environ_of_process(self.pid)
-            except Exception:
-                pass
+        pid = self.pid_for_cwd
+        if pid is not None:
+            with suppress(Exception):
+                return environ_of_process(pid)
+        pid = self.pid
+        if pid is not None:
+            with suppress(Exception):
+                return environ_of_process(pid)
         return {}

kitty/cli.py

@@ -28,26 +28,27 @@ class OptionDict(TypedDict):
 
 CONFIG_HELP = '''\
 Specify a path to the configuration file(s) to use. All configuration files are
-merged onto the builtin {conf_name}.conf, overriding the builtin values. This option
-can be specified multiple times to read multiple configuration files in
-sequence, which are merged. Use the special value NONE to not load a config
-file.
+merged onto the builtin :file:`{conf_name}.conf`, overriding the builtin values.
+This option can be specified multiple times to read multiple configuration files
+in sequence, which are merged. Use the special value :code:`NONE` to not load
+any config file.
 
 If this option is not specified, config files are searched for in the order:
-:file:`$XDG_CONFIG_HOME/{appname}/{conf_name}.conf`, :file:`~/.config/{appname}/{conf_name}.conf`, {macos_confpath}
-:file:`$XDG_CONFIG_DIRS/{appname}/{conf_name}.conf`. The first one that exists is used as the
-config file.
+:file:`$XDG_CONFIG_HOME/{appname}/{conf_name}.conf`,
+:file:`~/.config/{appname}/{conf_name}.conf`,{macos_confpath}
+:file:`$XDG_CONFIG_DIRS/{appname}/{conf_name}.conf`. The first one that exists
+is used as the config file.
 
 If the environment variable :envvar:`KITTY_CONFIG_DIRECTORY` is specified, that
 directory is always used and the above searching does not happen.
 
-If :file:`/etc/xdg/{appname}/{conf_name}.conf` exists it is merged before (i.e. with lower
-priority) than any user config files. It can be used to specify system-wide
-defaults for all users. You can use either :code:`-` or :code:`/dev/stdin` to read the
-config from STDIN.
+If :file:`/etc/xdg/{appname}/{conf_name}.conf` exists, it is merged before (i.e.
+with lower priority) than any user config files. It can be used to specify
+system-wide defaults for all users. You can use either :code:`-` or
+:file:`/dev/stdin` to read the config from STDIN.
 '''.replace(
     '{macos_confpath}',
-    (':file:`~/Library/Preferences/{appname}/{conf_name}.conf`,' if is_macos else ''), 1
+    (' :file:`~/Library/Preferences/{appname}/{conf_name}.conf`,' if is_macos else ''), 1
 )
 
 
@@ -149,6 +150,11 @@ def doc(x: str) -> str:
     return website_url(x)
 
 
+@role
+def ref(x: str) -> str:
+    return re.sub(r'\s*<\S+?>', '', x)
+
+
 OptionSpecSeq = List[Union[str, OptionDict]]
 
 
@@ -289,9 +295,10 @@ def get_defaults_from_seq(seq: OptionSpecSeq) -> Dict[str, Any]:
 
 
 default_msg = ('''\
-Run the :italic:`{appname}` terminal emulator. You can also specify the :italic:`program`
-to run inside :italic:`{appname}` as normal arguments following the :italic:`options`.
-For example: {appname} sh -c "echo hello, world. Press ENTER to quit; read"
+Run the :italic:`{appname}` terminal emulator. You can also specify the
+:italic:`program` to run inside :italic:`{appname}` as normal arguments
+following the :italic:`options`.
+For example: {appname} --hold sh -c "echo hello, world"
 
 For comprehensive documentation for kitty, please see: {url}''').format(
     appname=appname, url=website_url())
@@ -578,17 +585,20 @@ def options_spec() -> str:
 dest=cls
 default={appname}
 condition=not is_macos
-Set the class part of the :italic:`WM_CLASS` window property. On Wayland, it sets the app id.
+Set the class part of the :italic:`WM_CLASS` window property. On Wayland, it
+sets the app id.
 
 
 --name
 condition=not is_macos
-Set the name part of the :italic:`WM_CLASS` property (defaults to using the value from :option:`{appname} --class`)
+Set the name part of the :italic:`WM_CLASS` property. Defaults to using the
+value from :option:`{appname} --class`.
 
 
 --title -T
-Set the OS window title. This will override any title set by the program running inside kitty, permanently
-fixing the OS Window's title. So only use this if you are running a program that does not set titles.
+Set the OS window title. This will override any title set by the program running
+inside kitty, permanently fixing the OS window's title. So only use this if you
+are running a program that does not set titles.
 
 
 --config -c
@@ -599,68 +609,74 @@ type=list
 --override -o
 type=list
 Override individual configuration options, can be specified multiple times.
-Syntax: :italic:`name=value`. For example: :option:`kitty -o` font_size=20
+Syntax: :italic:`name=value`. For example: :option:`{appname} -o` font_size=20
 
 
 --directory --working-directory -d
 default=.
-Change to the specified directory when launching
+Change to the specified directory when launching.
 
 
 --detach
 type=bool-set
 condition=not is_macos
-Detach from the controlling terminal, if any
+Detach from the controlling terminal, if any.
 
 
 --session
-Path to a file containing the startup :italic:`session` (tabs, windows, layout, programs).
-Use - to read from STDIN. See the README file for details and an example.
+Path to a file containing the startup :italic:`session` (tabs, windows, layout,
+programs). Use - to read from STDIN. See the :file:`README` file for details and
+an example.
 
 
 --hold
 type=bool-set
 Remain open after child process exits. Note that this only affects the first
-window. You can quit by either using the close window shortcut or pressing any key.
+window. You can quit by either using the close window shortcut or pressing any
+key.
 
 
 --single-instance -1
 type=bool-set
-If specified only a single instance of :italic:`{appname}` will run. New invocations will
-instead create a new top-level window in the existing :italic:`{appname}` instance. This
-allows :italic:`{appname}` to share a single sprite cache on the GPU and also reduces
-startup time. You can also have separate groups of :italic:`{appname}` instances by using the
-:option:`kitty --instance-group` option
+If specified only a single instance of :italic:`{appname}` will run. New
+invocations will instead create a new top-level window in the existing
+:italic:`{appname}` instance. This allows :italic:`{appname}` to share a single
+sprite cache on the GPU and also reduces startup time. You can also have
+separate groups of :italic:`{appname}` instances by using the :option:`{appname}
+--instance-group` option.
 
 
 --instance-group
-Used in combination with the :option:`kitty --single-instance` option. All :italic:`{appname}` invocations
-with the same :option:`kitty --instance-group` will result in new windows being created
-in the first :italic:`{appname}` instance within that group
+Used in combination with the :option:`{appname} --single-instance` option. All
+:italic:`{appname}` invocations with the same :option:`{appname}
+--instance-group` will result in new windows being created in the first
+:italic:`{appname}` instance within that group.
 
 
 --wait-for-single-instance-window-close
 type=bool-set
-Normally, when using :option:`--single-instance`, :italic:`{appname}` will open a new window in an existing
-instance and quit immediately. With this option, it will not quit till the newly opened
-window is closed. Note that if no previous instance is found, then :italic:`{appname}` will wait anyway,
+Normally, when using :option:`{appname} --single-instance`, :italic:`{appname}`
+will open a new window in an existing instance and quit immediately. With this
+option, it will not quit till the newly opened window is closed. Note that if no
+previous instance is found, then :italic:`{appname}` will wait anyway,
 regardless of this option.
 
 
 --listen-on
-Tell kitty to listen on the specified address for control
-messages. For example, :option:`{appname} --listen-on`=unix:/tmp/mykitty or
+Listen on the specified socket address for control messages. For example,
+:option:`{appname} --listen-on`=unix:/tmp/mykitty or
 :option:`{appname} --listen-on`=tcp:localhost:12345. On Linux systems, you can
 also use abstract UNIX sockets, not associated with a file, like this:
-:option:`{appname} --listen-on`=unix:@mykitty. Environment variables
-in the setting are expanded and relative paths are resolved with
-respect to the temporary directory. To control kitty, you can send
-it commands with :italic:`kitty @` using the :option:`kitty @ --to` option to
-specify this address. This option will be ignored, unless you set
-:opt:`allow_remote_control` to yes in :file:`kitty.conf`. Note that if you run
-:italic:`kitty @` within a kitty window, there is no need to specify the :option:`kitty @ --to`
-option as it is read automatically from the environment. For UNIX sockets, this
-can also be specified in :file:`kitty.conf`.
+:option:`{appname} --listen-on`=unix:@mykitty. Environment variables are
+expanded and relative paths are resolved with respect to the temporary
+directory. To control kitty, you can send commands to it with
+:italic:`{appname} @` using the :option:`{appname} @ --to` option to specify
+this address. Unless you enabled :opt:`allow_remote_control` in
+:file:`{conf_name}.conf`, this option will be ignored. Note that if you run
+:italic:`{appname} @` within a kitty window, there is
+no need to specify the :option:`{appname} @ --to` option as it will
+automatically read from the environment. For UNIX sockets, this can also be
+specified in :file:`{conf_name}.conf`.
 
 
 --start-as
@@ -674,45 +690,48 @@ Control how the initial kitty window is created.
 
 --version -v
 type=bool-set
-The current {appname} version
+The current {appname} version.
 
 
 --dump-commands
 type=bool-set
-Output commands received from child process to stdout
+Output commands received from child process to STDOUT.
 
 
 --replay-commands
-Replay previously dumped commands. Specify the path to a dump file previously created by :option:`kitty --dump-commands`. You
+Replay previously dumped commands. Specify the path to a dump file previously
+created by :option:`{appname} --dump-commands`. You
 can open a new kitty window to replay the commands with::
 
-    kitty sh -c "kitty --replay-commands /path/to/dump/file; read"
+    {appname} sh -c "{appname} --replay-commands /path/to/dump/file; read"
 
 
 --dump-bytes
-Path to file in which to store the raw bytes received from the child process
+Path to file in which to store the raw bytes received from the child process.
 
 
 --debug-rendering --debug-gl
 type=bool-set
 Debug rendering commands. This will cause all OpenGL calls to check for errors
 instead of ignoring them. Also prints out miscellaneous debug information.
-Useful when debugging rendering problems
+Useful when debugging rendering problems.
 
 
 --debug-input --debug-keyboard
 dest=debug_keyboard
 type=bool-set
-This option will cause kitty to print out key and mouse events as they are received
+Print out key and mouse events as they are received.
 
 
 --debug-font-fallback
 type=bool-set
-Print out information about the selection of fallback fonts for characters not present in the main font.
+Print out information about the selection of fallback fonts for characters not
+present in the main font.
 
 
 --watcher
-This option is deprecated in favor of the :opt:`watcher` option in kitty.conf and should not be used.
+This option is deprecated in favor of the :opt:`watcher` option in
+:file:`{conf_name}.conf` and should not be used.
 
 
 --execute -e
@@ -720,7 +739,8 @@ type=bool-set
 !
 '''
         setattr(options_spec, 'ans', OPTIONS.format(
-            appname=appname, config_help=CONFIG_HELP.format(appname=appname, conf_name=appname),
+            appname=appname, conf_name=appname,
+            config_help=CONFIG_HELP.format(appname=appname, conf_name=appname),
         ))
     ans: str = getattr(options_spec, 'ans')
     return ans
@@ -764,12 +784,16 @@ def parse_args(
     return ans, parse_cmdline(oc, disabled, ans, args=args)
 
 
-SYSTEM_CONF = '/etc/xdg/kitty/kitty.conf'
+SYSTEM_CONF = f'/etc/xdg/{appname}/{appname}.conf'
+
+
+def default_config_paths(conf_paths: Sequence[str]) -> Tuple[str, ...]:
+    return tuple(resolve_config(SYSTEM_CONF, defconf, conf_paths))
 
 
 def create_opts(args: CLIOptions, accumulate_bad_lines: Optional[List[BadLineType]] = None) -> KittyOpts:
     from .config import load_config
-    config = tuple(resolve_config(SYSTEM_CONF, defconf, args.config))
+    config = default_config_paths(args.config)
     # Does not cover the case where `name =` when `=` is the value.
     pat = re.compile(r'^([a-zA-Z0-9_]+)[ \t]*=')
     overrides = (pat.sub(r'\1 ', a.lstrip()) for a in args.override or ())
@@ -779,6 +803,6 @@ def create_opts(args: CLIOptions, accumulate_bad_lines: Optional[List[BadLineTyp
 
 def create_default_opts() -> KittyOpts:
     from .config import load_config
-    config = tuple(resolve_config(SYSTEM_CONF, defconf, ()))
+    config = default_config_paths(())
     opts = load_config(*config)
     return opts

kitty/cocoa_window.m

@@ -235,11 +235,7 @@ PENDING(clear_terminal_and_scrollback, CLEAR_TERMINAL_AND_SCROLLBACK)
 PENDING(reload_config, RELOAD_CONFIG)
 PENDING(toggle_macos_secure_keyboard_entry, TOGGLE_MACOS_SECURE_KEYBOARD_ENTRY)
 PENDING(toggle_fullscreen, TOGGLE_FULLSCREEN)
-
-- (void)open_kitty_website_url:(id)sender {
-    (void)sender;
-    [[NSWorkspace sharedWorkspace] openURL:[NSURL URLWithString:@"https://sw.kovidgoyal.net/kitty/"]];
-}
+PENDING(open_kitty_website, OPEN_KITTY_WEBSITE)
 
 - (BOOL)validateMenuItem:(NSMenuItem *)item {
     if (item.action == @selector(toggle_macos_secure_keyboard_entry:)) {
@@ -275,7 +271,7 @@ typedef struct {
 typedef struct {
     GlobalShortcut new_os_window, close_os_window, close_tab, edit_config_file, reload_config;
     GlobalShortcut previous_tab, next_tab, new_tab, new_window, close_window, reset_terminal, clear_terminal_and_scrollback;
-    GlobalShortcut toggle_macos_secure_keyboard_entry, toggle_fullscreen;
+    GlobalShortcut toggle_macos_secure_keyboard_entry, toggle_fullscreen, open_kitty_website;
 } GlobalShortcuts;
 static GlobalShortcuts global_shortcuts;
 
@@ -290,7 +286,7 @@ cocoa_set_global_shortcut(PyObject *self UNUSED, PyObject *args) {
     Q(new_os_window); else Q(close_os_window); else Q(close_tab); else Q(edit_config_file);
     else Q(new_tab); else Q(next_tab); else Q(previous_tab);
     else Q(new_window); else Q(close_window); else Q(reset_terminal); else Q(clear_terminal_and_scrollback); else Q(reload_config);
-    else Q(toggle_macos_secure_keyboard_entry); else Q(toggle_fullscreen);
+    else Q(toggle_macos_secure_keyboard_entry); else Q(toggle_fullscreen); else Q(open_kitty_website);
 #undef Q
     if (gs == NULL) { PyErr_SetString(PyExc_KeyError, "Unknown shortcut name"); return NULL; }
     int cocoa_mods;
@@ -652,10 +648,8 @@ cocoa_create_global_menu(void) {
                 keyEquivalent:@""];
     NSMenu* helpMenu = [[NSMenu alloc] initWithTitle:@"Help"];
     [helpMenuItem setSubmenu:helpMenu];
-    [[helpMenu addItemWithTitle:[NSString stringWithFormat:@"Visit %@ Website", app_name]
-                         action:@selector(open_kitty_website_url:)
-                  keyEquivalent:@"?"]
-                      setTarget:global_menu_target];
+
+    MENU_ITEM(helpMenu, @"Visit kitty Website", open_kitty_website);
     [NSApp setHelpMenu:helpMenu];
     [helpMenu release];
 

kitty/conf/generate.py

@@ -125,7 +125,11 @@ def generate_class(defn: Definition, loc: str) -> Tuple[str, str]:
             if func.__module__ != 'builtins':
                 tc_imports.add((func.__module__, func.__name__))
 
-        defval = repr(func(option.defval_as_string))
+        defval_as_obj = func(option.defval_as_string)
+        if isinstance(defval_as_obj, frozenset):
+            defval = 'frozenset({' + ', '.join(repr(x) for x in sorted(defval_as_obj)) + '})'
+        else:
+            defval = repr(defval_as_obj)
         if len(defval) > 100:
             defval += ' # noqa'
         if option.macos_defval is not unset:

kitty/conf/types.py

@@ -55,6 +55,7 @@ def ref_map() -> Dict[str, str]:
         'functional': f'{website_url("keyboard-protocol")}#functional-key-definitions',
         'ssh_copy_command': f'{website_url("kittens/ssh")}#ssh-copy-command',
         'shell_integration': website_url("shell-integration"),
+        'clone_shell': f'{website_url("shell-integration")}#clone-shell',
         'github_discussions': 'https://github.com/kovidgoyal/kitty/discussions',
     }
     for actions in get_all_actions().values():
@@ -65,23 +66,40 @@ def ref_map() -> Dict[str, str]:
 
 def remove_markup(text: str) -> str:
 
+    def extract(m: 'Match[str]') -> Tuple[str, str]:
+        parts = m.group(2).split('<')
+        t = parts[0].strip()
+        q = parts[-1].rstrip('>')
+        return t, q
+
     def sub(m: 'Match[str]') -> str:
         if m.group(1) == 'ref':
-            q = m.group(2).split('<')[-1].rstrip('>')
-            return ref_map()[q]
+            t, q = extract(m)
+            return f'{t} <{ref_map()[q]}>'
+        if m.group(1) == 'doc':
+            t, q = extract(m)
+            return f'{t} <{website_url(q.lstrip("/"))}>'
         if m.group(1) == 'ac':
             q = m.group(2).split('<')[-1].rstrip('>')
-            return ref_map()[f'action-{q}']
+            return q
+        if m.group(1) == 'term':
+            t, _ = extract(m)
+            return t
+        if m.group(1) == 'option':
+            t, _ = extract(m)
+            return t
         if m.group(1) == 'disc':
-            parts = m.group(2).split('<')
-            t = parts[0].strip()
-            q = parts[-1].rstrip('>')
+            t, q = extract(m)
             return f'{t} {ref_map()["github_discussions"]}/{q}'
         return str(m.group(2))
 
     return re.sub(r':([a-zA-Z0-9]+):`(.+?)`', sub, text, flags=re.DOTALL)
 
 
+def strip_inline_literal(text: str) -> str:
+    return re.sub(r'``([^`]+)``', r'`\1`', text, flags=re.DOTALL)
+
+
 def iter_blocks(lines: Iterable[str]) -> Iterator[Tuple[List[str], int]]:
     current_block: List[str] = []
     prev_indent = 0
@@ -123,6 +141,7 @@ def wrapped_block(lines: Iterable[str], comment_symbol: str = '#: ') -> Iterator
 
 def render_block(text: str, comment_symbol: str = '#: ') -> str:
     text = remove_markup(text)
+    text = strip_inline_literal(text)
     lines = text.splitlines()
     return '\n'.join(wrapped_block(lines, comment_symbol))
 
@@ -270,7 +289,11 @@ class MultiOption:
         for k in self.items:
             if k.documented:
                 documented = True
-                a(f'{self.name} {k.defval_as_str if k.add_to_default else ""}'.rstrip())
+                if k.add_to_default:
+                    a(f'{self.name} {k.defval_as_str}'.rstrip())
+                else:
+                    # Comment out multi-options that have no default values
+                    a(f'# {self.name}'.rstrip())
                 if not k.add_to_default and k.defval_as_str:
                     a('')
                     a(f'#: E.g. {self.name} {k.defval_as_str}'.rstrip())
@@ -546,6 +569,9 @@ class Group:
 
             if commented:
                 ans = [x if x.startswith('#') or not x.strip() else (f'# {x}') for x in ans]
+            else:
+                # Comment out any invalid options that have no value
+                ans = [f'# {x}' if not x.startswith('#') and len(x.strip().split()) == 1 else x for x in ans]
 
         return ans
 

kitty/constants.py

@@ -22,10 +22,11 @@ class Version(NamedTuple):
 
 appname: str = 'kitty'
 kitty_face = '🐱'
-version: Version = Version(0, 25, 0)
+version: Version = Version(0, 25, 1)
 str_version: str = '.'.join(map(str, version))
 _plat = sys.platform.lower()
 is_macos: bool = 'darwin' in _plat
+is_freebsd: bool = 'freebsd' in _plat
 is_running_from_develop: bool = False
 if getattr(sys, 'frozen', False):
     extensions_dir: str = getattr(sys, 'kitty_extensions_dir')

kitty/data-types.h

@@ -9,6 +9,7 @@
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
+#include <assert.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <poll.h>
@@ -163,12 +164,14 @@ typedef struct {
     sprite_index sprite_x, sprite_y, sprite_z;
     CellAttrs attrs;
 } GPUCell;
+static_assert(sizeof(GPUCell) == 20, "Fix the ordering of GPUCell");
 
 typedef struct {
     char_type ch;
-    combining_type cc_idx[2];
     hyperlink_id_type hyperlink_id;
+    combining_type cc_idx[3];
 } CPUCell;
+static_assert(sizeof(CPUCell) == 12, "Fix the ordering of CPUCell");
 
 typedef enum { UNKNOWN_PROMPT_KIND = 0, PROMPT_START = 1, SECONDARY_PROMPT = 2, OUTPUT_START = 3 } PromptKind;
 typedef union LineAttrs {

kitty/file_transmission.py

@@ -976,7 +976,7 @@ class FileTransmission:
             finally:
                 self.drop_receive(ar.id)
         else:
-            log_error('Transmission receive command with unknown action: {cmd.action}, ignoring')
+            log_error(f'Transmission receive command with unknown action: {cmd.action}, ignoring')
 
     def transmit_rsync_signature(
         self, fs: Iterator[memoryview],

kitty/fontconfig.c

@@ -10,6 +10,7 @@
 #include "lineops.h"
 #include "fonts.h"
 #include <fontconfig/fontconfig.h>
+#include <dlfcn.h>
 #include "emoji.h"
 #include "freetype_render_ui_text.h"
 #ifndef FC_COLOR
@@ -18,10 +19,111 @@
 
 
 static bool initialized = false;
+static void* libfontconfig_handle = NULL;
+
+#define FcInit dynamically_loaded_fc_symbol.Init
+#define FcFini dynamically_loaded_fc_symbol.Fini
+#define FcCharSetAddChar dynamically_loaded_fc_symbol.CharSetAddChar
+#define FcPatternDestroy dynamically_loaded_fc_symbol.PatternDestroy
+#define FcObjectSetDestroy dynamically_loaded_fc_symbol.ObjectSetDestroy
+#define FcPatternAddDouble dynamically_loaded_fc_symbol.PatternAddDouble
+#define FcPatternAddString dynamically_loaded_fc_symbol.PatternAddString
+#define FcFontMatch dynamically_loaded_fc_symbol.FontMatch
+#define FcCharSetCreate dynamically_loaded_fc_symbol.CharSetCreate
+#define FcPatternGetString dynamically_loaded_fc_symbol.PatternGetString
+#define FcFontSetDestroy dynamically_loaded_fc_symbol.FontSetDestroy
+#define FcPatternGetInteger dynamically_loaded_fc_symbol.PatternGetInteger
+#define FcPatternAddBool dynamically_loaded_fc_symbol.PatternAddBool
+#define FcFontList dynamically_loaded_fc_symbol.FontList
+#define FcObjectSetBuild dynamically_loaded_fc_symbol.ObjectSetBuild
+#define FcCharSetDestroy dynamically_loaded_fc_symbol.CharSetDestroy
+#define FcConfigSubstitute dynamically_loaded_fc_symbol.ConfigSubstitute
+#define FcDefaultSubstitute dynamically_loaded_fc_symbol.DefaultSubstitute
+#define FcPatternAddInteger dynamically_loaded_fc_symbol.PatternAddInteger
+#define FcPatternCreate dynamically_loaded_fc_symbol.PatternCreate
+#define FcPatternGetBool dynamically_loaded_fc_symbol.PatternGetBool
+#define FcPatternAddCharSet dynamically_loaded_fc_symbol.PatternAddCharSet
+
+static struct {
+    FcBool(*Init)(void);
+    void(*Fini)(void);
+    FcBool (*CharSetAddChar) (FcCharSet *fcs, FcChar32 ucs4);
+    void (*PatternDestroy) (FcPattern *p);
+    void (*ObjectSetDestroy) (FcObjectSet *os);
+    FcBool (*PatternAddDouble) (FcPattern *p, const char *object, double d);
+    FcBool (*PatternAddString) (FcPattern *p, const char *object, const FcChar8 *s);
+    FcPattern * (*FontMatch) (FcConfig	*config, FcPattern	*p, FcResult	*result);
+    FcCharSet* (*CharSetCreate) (void);
+    FcResult (*PatternGetString) (const FcPattern *p, const char *object, int n, FcChar8 ** s);
+    void (*FontSetDestroy) (FcFontSet *s);
+    FcResult (*PatternGetInteger) (const FcPattern *p, const char *object, int n, int *i);
+    FcBool (*PatternAddBool) (FcPattern *p, const char *object, FcBool b);
+    FcFontSet * (*FontList) (FcConfig	*config, FcPattern	*p, FcObjectSet *os);
+    FcObjectSet * (*ObjectSetBuild) (const char *first, ...);
+    void (*CharSetDestroy) (FcCharSet *fcs);
+    FcBool (*ConfigSubstitute) (FcConfig	*config, FcPattern	*p, FcMatchKind	kind);
+    void (*DefaultSubstitute) (FcPattern *pattern);
+    FcBool (*PatternAddInteger) (FcPattern *p, const char *object, int i);
+    FcPattern * (*PatternCreate) (void);
+    FcResult (*PatternGetBool) (const FcPattern *p, const char *object, int n, FcBool *b);
+    FcBool (*PatternAddCharSet) (FcPattern *p, const char *object, const FcCharSet *c);
+} dynamically_loaded_fc_symbol = {0};
+#define LOAD_FUNC(name) {\
+    *(void **) (&dynamically_loaded_fc_symbol.name) = dlsym(libfontconfig_handle, "Fc" #name); \
+    if (!dynamically_loaded_fc_symbol.name) { \
+        const char* error = dlerror(); \
+        fatal("Failed to load the function Fc" #name " with error: %s", error ? error : ""); \
+    } \
+}
+
+
+static void
+load_fontconfig_lib(void) {
+        const char* libnames[] = {
+#if defined(_KITTY_FONTCONFIG_LIBRARY)
+            _KITTY_FONTCONFIG_LIBRARY,
+#else
+            "libfontconfig.so",
+            // some installs are missing the .so symlink, so try the full name
+            "libfontconfig.so.1",
+#endif
+            NULL
+        };
+        for (int i = 0; libnames[i]; i++) {
+            libfontconfig_handle = dlopen(libnames[i], RTLD_LAZY);
+            if (libfontconfig_handle) break;
+        }
+        if (libfontconfig_handle == NULL) { fatal("Failed to find and load fontconfig"); }
+        dlerror();    /* Clear any existing error */
+        LOAD_FUNC(Init);
+        LOAD_FUNC(Fini);
+        LOAD_FUNC(CharSetAddChar);
+        LOAD_FUNC(PatternDestroy);
+        LOAD_FUNC(ObjectSetDestroy);
+        LOAD_FUNC(PatternAddDouble);
+        LOAD_FUNC(PatternAddString);
+        LOAD_FUNC(FontMatch);
+        LOAD_FUNC(CharSetCreate);
+        LOAD_FUNC(PatternGetString);
+        LOAD_FUNC(FontSetDestroy);
+        LOAD_FUNC(PatternGetInteger);
+        LOAD_FUNC(PatternAddBool);
+        LOAD_FUNC(FontList);
+        LOAD_FUNC(ObjectSetBuild);
+        LOAD_FUNC(CharSetDestroy);
+        LOAD_FUNC(ConfigSubstitute);
+        LOAD_FUNC(DefaultSubstitute);
+        LOAD_FUNC(PatternAddInteger);
+        LOAD_FUNC(PatternCreate);
+        LOAD_FUNC(PatternGetBool);
+        LOAD_FUNC(PatternAddCharSet);
+}
+#undef LOAD_FUNC
 
 static void
 ensure_initialized(void) {
     if (!initialized) {
+        load_fontconfig_lib();
         if (!FcInit()) fatal("Failed to initialize fontconfig library");
         initialized = true;
     }
@@ -31,6 +133,8 @@ static void
 finalize(void) {
     if (initialized) {
         FcFini();
+        dlclose(libfontconfig_handle);
+        libfontconfig_handle = NULL;
         initialized = false;
     }
 }

kitty/fonts.c

@@ -422,7 +422,7 @@ load_fallback_font(FontGroup *fg, CPUCell *cell, bool bold, bool italic, bool em
     if (fg->fallback_fonts_count > 100) { log_error("Too many fallback fonts"); return MISSING_FONT; }
     ssize_t f;
 
-    if (bold) f = fg->italic_font_idx > 0 ? fg->bi_font_idx : fg->bold_font_idx;
+    if (bold) f = italic ? fg->bi_font_idx : fg->bold_font_idx;
     else f = italic ? fg->italic_font_idx : fg->medium_font_idx;
     if (f < 0) f = fg->medium_font_idx;
 

kitty/glfw-wrapper.h

@@ -762,6 +762,16 @@ typedef enum GLFWMouseButton {
  *  [window hint](@ref GLFW_COCOA_GRAPHICS_SWITCHING_hint).
  */
 #define GLFW_COCOA_GRAPHICS_SWITCHING 0x00023003
+/*! @brief macOS specific
+ *  [window hint](@ref GLFW_COCOA_COLOR_SPACE_hint).
+ */
+#define GLFW_COCOA_COLOR_SPACE 0x00023004
+typedef enum {
+    DEFAULT_COLORSPACE = 0,
+    SRGB_COLORSPACE = 1,
+    DISPLAY_P3_COLORSPACE = 2,
+} GlfwCocoaColorSpaces;
+
 /*! @brief X11 specific
  *  [window hint](@ref GLFW_X11_CLASS_NAME_hint).
  */
@@ -944,7 +954,8 @@ typedef enum {
 typedef enum {
     GLFW_IME_NONE,
     GLFW_IME_PREEDIT_CHANGED,
-    GLFW_IME_COMMIT_TEXT
+    GLFW_IME_COMMIT_TEXT,
+    GLFW_IME_WAYLAND_DONE_EVENT,
 } GLFWIMEState;
 
 typedef enum {

kitty/glfw.c

@@ -775,6 +775,7 @@ create_os_window(PyObject UNUSED *self, PyObject *args, PyObject *kw) {
     glfwWindowHintString(GLFW_X11_INSTANCE_NAME, wm_class_name);
     glfwWindowHintString(GLFW_X11_CLASS_NAME, wm_class_class);
     glfwWindowHintString(GLFW_WAYLAND_APP_ID, wm_class_class);
+    glfwWindowHint(GLFW_COCOA_COLOR_SPACE, OPT(macos_colorspace));
 #endif
 
     if (global_state.num_os_windows >= MAX_CHILDREN) {

kitty/graphics.c

@@ -1505,7 +1505,7 @@ x_filter_func(const ImageRef *ref, Image UNUSED *img, const void *data, CellPixe
 static bool
 y_filter_func(const ImageRef *ref, Image UNUSED *img, const void *data, CellPixelSize cell UNUSED) {
     const GraphicsCommand *g = data;
-    return ref->start_row <= (int32_t)g->y_offset - 1 && ((int32_t)(g->y_offset - 1 < ref->start_row + ref->effective_num_rows));
+    return ref->start_row <= (int32_t)g->y_offset - 1 && ((int32_t)g->y_offset - 1) < ((int32_t)(ref->start_row + ref->effective_num_rows));
 }
 
 static bool

kitty/keys.c

@@ -136,6 +136,12 @@ on_key_input(GLFWkeyevent *ev) {
     id_type active_window_id = w->id;
 
     switch(ev->ime_state) {
+        case GLFW_IME_WAYLAND_DONE_EVENT:
+            // If we update IME position here it sends GNOME's text input system into
+            // an infinite loop. See https://github.com/kovidgoyal/kitty/issues/5105
+            screen_draw_overlay_text(screen, NULL);
+            debug("handled wayland IME done event\n");
+            return;
         case GLFW_IME_PREEDIT_CHANGED:
             update_ime_position(w, screen);
             screen_draw_overlay_text(screen, text);

kitty/launch.py

@@ -2,6 +2,7 @@
 # License: GPLv3 Copyright: 2019, Kovid Goyal <kovid at kovidgoyal.net>
 
 
+import os
 from typing import Any, Dict, Iterable, List, NamedTuple, Optional, Sequence
 
 from .boss import Boss
@@ -10,7 +11,8 @@ from .cli import parse_args
 from .cli_stub import LaunchCLIOptions
 from .constants import kitty_exe, shell_path
 from .fast_data_types import (
-    get_os_window_title, patch_color_profiles, set_clipboard_string
+    get_boss, get_options, get_os_window_title, patch_color_profiles,
+    set_clipboard_string
 )
 from .options.utils import env as parse_env
 from .tabs import Tab, TabManager
@@ -34,48 +36,51 @@ def options_spec() -> str:
     return '''
 --window-title --title
 The title to set for the new window. By default, title is controlled by the
-child process. The special value :code:`current` will copy the title from the currently
-active window.
+child process. The special value :code:`current` will copy the title from the
+currently active window.
 
 
 --tab-title
 The title for the new tab if launching in a new tab. By default, the title
 of the active window in the tab is used as the tab title. The special value
-:code:`current` will copy the title form the title of the currently active tab.
+:code:`current` will copy the title from the title of the currently active tab.
 
 
 --type
 type=choices
 default=window
 choices=window,tab,os-window,overlay,background,clipboard,primary
-Where to launch the child process, in a new kitty window in the current tab,
-a new tab, or a new OS window or an overlay over the current window.
-Note that if the current window already has an overlay, then it will
-open a new window. The value of background means the process will be
-run in the background. The values clipboard and primary are meant
-to work with :option:`launch --stdin-source` to copy data to the system
-clipboard or primary selection.
+Where to launch the child process, in a new kitty :code:`window` in the current
+tab, a new :code:`tab`, or a new :code:`os-window` or an :code:`overlay` over
+the current window. Note that if the current window already has an overlay, then
+it will open a new window. The value of :code:`background` means the process
+will be run in the background. The values :code:`clipboard` and :code:`primary`
+are meant to work with :option:`--stdin-source <launch --stdin-source>` to copy
+data to the system clipboard or primary selection.
 
 
 --keep-focus --dont-take-focus
 type=bool-set
-Keep the focus on the currently active window instead of switching
-to the newly opened window.
+Keep the focus on the currently active window instead of switching to the newly
+opened window.
 
 
 --cwd
 The working directory for the newly launched child. Use the special value
 :code:`current` to use the working directory of the currently active window.
-The special value :code:`last_reported` uses the last working directory
-reported by the shell (needs :ref:`shell_integration` to work).
+The special value :code:`last_reported` uses the last working directory reported
+by the shell (needs :ref:`shell_integration` to work). The special value
+:code:`oldest` works like :code:`current` but uses the working directory of the
+oldest foreground process associated with the currently active window rather
+than the newest foreground process.
 
 
 --env
 type=list
 Environment variables to set in the child process. Can be specified multiple
-times to set different environment variables.  Syntax: :code:`name=value`.
-Using :code:`name=` will set to empty string and just :code:`name` will
-remove the environment variable.
+times to set different environment variables. Syntax: :code:`name=value`. Using
+:code:`name=` will set to empty string and just :code:`name` will remove the
+environment variable.
 
 
 --hold
@@ -97,121 +102,129 @@ currently active window.
 
 --copy-env
 type=bool-set
-Copy the environment variables from the currently active window into the
-newly launched child process. Note that most shells only set environment
-variables for child processes, so this will only copy the environment
-variables that the shell process itself has not the environment variables
-child processes inside the shell see. To copy that enviroment, use the
-kitty remote control feature with :code:`kitty @launch --copy-env`.
+Copy the environment variables from the currently active window into the newly
+launched child process. Note that most shells only set environment variables
+for child processes, so this will only copy the environment variables that the
+shell process itself has, not the environment variables child processes inside
+the shell see. To copy that enviroment, use either the :ref:`clone-in-kitty
+<clone_shell>` feature or the kitty remote control feature with :option:`kitty
+@ launch --copy-env`.
 
 
 --location
 type=choices
 default=default
 choices=first,after,before,neighbor,last,vsplit,hsplit,split,default
-Where to place the newly created window when it is added to a tab which
-already has existing windows in it. :code:`after` and :code:`before` place the new
-window before or after the active window. :code:`neighbor` is a synonym for :code:`after`.
-Also applies to creating a new tab, where the value of :code:`after`
-will cause the new tab to be placed next to the current tab instead of at the end.
-The values of :code:`vsplit`, :code:`hsplit` and :code:`split` are only used by the
-:code:`splits` layout and control if the new window is placed in a vertical,
-horizontal or automatic split with the currently active window. The default is
-to place the window in a layout dependent manner, typically, after the
-currently active window.
+Where to place the newly created window when it is added to a tab which already
+has existing windows in it. :code:`after` and :code:`before` place the new
+window before or after the active window. :code:`neighbor` is a synonym for
+:code:`after`. Also applies to creating a new tab, where the value of
+:code:`after` will cause the new tab to be placed next to the current tab
+instead of at the end. The values of :code:`vsplit`, :code:`hsplit` and
+:code:`split` are only used by the :code:`splits` layout and control if the new
+window is placed in a vertical, horizontal or automatic split with the currently
+active window. The default is to place the window in a layout dependent manner,
+typically, after the currently active window.
 
 
 --allow-remote-control
 type=bool-set
-Programs running in this window can control kitty (if remote control is
-enabled). Note that any program with the right level of permissions can still
-write to the pipes of any other program on the same computer and therefore can
-control kitty. It can, however, be useful to block programs running on other
-computers (for example, over ssh) or as other users.
+Programs running in this window can control kitty (even if remote control is not
+enabled in :file:`kitty.conf`). Note that any program with the right level of
+permissions can still write to the pipes of any other program on the same
+computer and therefore can control kitty. It can, however, be useful to block
+programs running on other computers (for example, over SSH) or as other users.
 
 
 --stdin-source
 type=choices
 default=none
 choices=none,@selection,@screen,@screen_scrollback,@alternate,@alternate_scrollback,@first_cmd_output_on_screen,@last_cmd_output,@last_visited_cmd_output
-Pass the screen contents as :code:`STDIN` to the child process. :code:`@selection` is
-the currently selected text. :code:`@screen` is the contents of the currently active
-window. :code:`@screen_scrollback` is the same as :code:`@screen`, but includes the
-scrollback buffer as well. :code:`@alternate` is the secondary screen of the current
-active window. For example if you run a full screen terminal application, the
-secondary screen will be the screen you return to when quitting the application.
-:code:`@first_cmd_output_on_screen` is the output from the first command run in the shell on screen,
-:code:`@last_cmd_output` is the output from the last command run in the shell,
-:code:`@last_visited_cmd_output` is the first output below the last scrolled position via
-scroll_to_prompt, this three needs :ref:`shell_integration` to work.
+Pass the screen contents as :file:`STDIN` to the child process.
+:code:`@selection` is the currently selected text. :code:`@screen` is the
+contents of the currently active window. :code:`@screen_scrollback` is the same
+as :code:`@screen`, but includes the scrollback buffer as well.
+:code:`@alternate` is the secondary screen of the current active window. For
+example if you run a full screen terminal application, the secondary screen will
+be the screen you return to when quitting the application.
+:code:`@first_cmd_output_on_screen` is the output from the first command run in
+the shell on screen, :code:`@last_cmd_output` is the output from the last
+command run in the shell, :code:`@last_visited_cmd_output` is the first output
+below the last scrolled position via :ac:`scroll_to_prompt`, this three needs
+:ref:`shell integration <shell_integration>` to work.
 
 
 --stdin-add-formatting
 type=bool-set
-When using :option:`launch --stdin-source` add formatting escape codes, without this
-only plain text will be sent.
+When using :option:`--stdin-source <launch --stdin-source>` add formatting
+escape codes, without this only plain text will be sent.
 
 
 --stdin-add-line-wrap-markers
 type=bool-set
-When using :option:`launch --stdin-source` add a carriage return at every line wrap
-location (where long lines are wrapped at screen edges). This is useful if you
-want to pipe to program that wants to duplicate the screen layout of the
-screen.
+When using :option:`--stdin-source <launch --stdin-source>` add a carriage
+return at every line wrap location (where long lines are wrapped at screen
+edges). This is useful if you want to pipe to program that wants to duplicate
+the screen layout of the screen.
 
 
 --marker
 Create a marker that highlights text in the newly created window. The syntax is
-the same as for the :code:`toggle_marker` map action (see :doc:`/marks`).
+the same as for the :ac:`toggle_marker` action (see :doc:`/marks`).
 
 
 --os-window-class
-Set the WM_CLASS property on X11 and the application id property on Wayland for
-the newly created OS Window when using :option:`launch --type`=os-window.
-Defaults to whatever is used by the parent kitty process, which in turn
-defaults to :code:`kitty`.
+Set the *WM_CLASS* property on X11 and the application id property on Wayland
+for the newly created OS window when using :option:`--type=os-window
+<launch --type>`. Defaults to whatever is used by the parent kitty process,
+which in turn defaults to :code:`kitty`.
 
 
 --os-window-name
-Set the WM_NAME property on X11 for the newly created OS Window when using
-:option:`launch --type`=os-window. Defaults to :option:`launch --os-window-class`.
+Set the *WM_NAME* property on X11 for the newly created OS Window when using
+:option:`--type=os-window <launch --type>`. Defaults to
+:option:`--os-window-class <launch --os-window-class>`.
 
 
 --os-window-title
 Set the title for the newly created OS window. This title will override any
-titles set by programs running in kitty. The special value :code:`current`
-will use the title of the current OS Window, if any.
+titles set by programs running in kitty. The special value :code:`current` will
+use the title of the current OS window, if any.
 
 
 --logo
-Path to a PNG image to use as the logo for the newly created window. See :opt:`window_logo_path`.
+Path to a PNG image to use as the logo for the newly created window. See
+:opt:`window_logo_path`.
 
 
 --logo-position
-The position for the window logo. Only takes effect if :option:`--logo` is specified. See :opt:`window_logo_position`.
+The position for the window logo. Only takes effect if :option:`--logo` is
+specified. See :opt:`window_logo_position`.
 
 
 --logo-alpha
 type=float
 default=-1
-The amount the window logo should be faded into the background.
-Only takes effect if :option:`--logo` is specified. See :opt:`window_logo_position`.
+The amount the window logo should be faded into the background. Only takes
+effect if :option:`--logo` is specified. See :opt:`window_logo_position`.
 
 
 --color
 type=list
-Change colors in the newly launched window. You can either specify a path to a .conf
-file with the same syntax as kitty.conf to read the colors from, or specify them
-individually, for example: ``--color background=white`` ``--color foreground=red``
+Change colors in the newly launched window. You can either specify a path to a
+:file:`.conf` file with the same syntax as :file:`kitty.conf` to read the colors
+from, or specify them individually, for example: ``--color background=white``
+``--color foreground=red``
 
 
 --watcher -w
 type=list
-Path to a python file. Appropriately named functions in this file will be called
-for various events, such as when the window is resized, focused or closed. See the section
-on watchers in the launch command documentation: :ref:`watchers`. Relative paths are
-resolved relative to the kitty config directory. Global watchers for all windows can be
-specified with :opt:`watcher`.
+Path to a Python file. Appropriately named functions in this file will be called
+for various events, such as when the window is resized, focused or closed. See
+the section on watchers in the launch command documentation: :ref:`watchers`.
+Relative paths are resolved relative to the :ref:`kitty config directory
+<confloc>`. Global watchers for all windows can be specified with
+:opt:`watcher` in :file:`kitty.conf`.
 '''
 
 
@@ -224,7 +237,7 @@ def parse_launch_args(args: Optional[Sequence[str]] = None) -> LaunchSpec:
     return LaunchSpec(opts, args)
 
 
-def get_env(opts: LaunchCLIOptions, active_child: Optional[Child]) -> Dict[str, str]:
+def get_env(opts: LaunchCLIOptions, active_child: Optional[Child] = None) -> Dict[str, str]:
     env: Dict[str, str] = {}
     if opts.copy_env and active_child:
         env.update(active_child.foreground_environ)
@@ -335,6 +348,7 @@ class ForceWindowLaunch:
 
 
 force_window_launch = ForceWindowLaunch()
+non_window_launch_types = 'background', 'clipboard', 'primary'
 
 
 def launch(
@@ -342,9 +356,11 @@ def launch(
     opts: LaunchCLIOptions,
     args: List[str],
     target_tab: Optional[Tab] = None,
-    force_target_tab: bool = False
+    force_target_tab: bool = False,
+    active: Optional[Window] = None,
+    is_clone_launch: str = '',
 ) -> Optional[Window]:
-    active = boss.active_window_for_cwd
+    active = active or boss.active_window_for_cwd
     if active:
         active_child = active.child
     else:
@@ -353,7 +369,7 @@ def launch(
         opts.window_title = active.title if active else None
     if opts.tab_title == 'current':
         atab = boss.active_tab
-        opts.tab_title = atab.title if atab else None
+        opts.tab_title = atab.effective_title if atab else None
     if opts.os_window_title == 'current':
         tm = boss.active_tab_manager
         opts.os_window_title = get_os_window_title(tm.os_window_id) if tm else None
@@ -377,6 +393,9 @@ def launch(
         elif opts.cwd == 'last_reported':
             if active:
                 kw['cwd_from'] = CwdRequest(active, CwdRequestType.last_reported)
+        elif opts.cwd == 'oldest':
+            if active:
+                kw['cwd_from'] = CwdRequest(active, CwdRequestType.oldest)
         else:
             kw['cwd'] = opts.cwd
     if opts.location != 'default':
@@ -435,7 +454,7 @@ def launch(
         if exe:
             final_cmd[0] = exe
         kw['cmd'] = final_cmd
-    if force_window_launch and opts.type not in ('background', 'clipboard', 'primary'):
+    if force_window_launch and opts.type not in non_window_launch_types:
         opts.type = 'window'
     if opts.type == 'overlay' and active:
         kw['overlay_for'] = active.id
@@ -461,12 +480,164 @@ def launch(
             tab = tab_for_window(boss, opts, target_tab)
         if tab is not None:
             watchers = load_watch_modules(opts.watcher)
-            new_window: Window = tab.new_window(env=env or None, watchers=watchers or None, **kw)
+            new_window: Window = tab.new_window(env=env or None, watchers=watchers or None, is_clone_launch=is_clone_launch, **kw)
             if opts.color:
                 apply_colors(new_window, opts.color)
             if opts.keep_focus and active:
-                boss.set_active_window(active, switch_os_window_if_needed=True)
+                boss.set_active_window(active, switch_os_window_if_needed=True, for_keep_focus=True)
             if opts.logo:
                 new_window.set_logo(opts.logo, opts.logo_position or '', opts.logo_alpha)
             return new_window
     return None
+
+
+def parse_opts_for_clone(args: List[str]) -> LaunchCLIOptions:
+    unsafe, unsafe_args = parse_launch_args(args)
+    default_opts, default_args = parse_launch_args()
+    # only copy safe options, those that dont lead to local code exec
+    for x in (
+        'window_title', 'tab_title', 'type', 'keep_focus', 'cwd', 'env', 'hold',
+        'location', 'os_window_class', 'os_window_name', 'os_window_title',
+        'logo', 'logo_position', 'logo_alpha', 'color'
+    ):
+        setattr(default_opts, x, getattr(unsafe, x))
+    return default_opts
+
+
+def parse_bash_env(text: str) -> Dict[str, str]:
+    # See https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
+    ans = {}
+    pos = 0
+    escapes = r'"\$`'
+    while pos < len(text):
+        idx = text.find('="', pos)
+        if idx < 0:
+            break
+        i = text.rfind(' ', 0, idx)
+        if i < 0:
+            break
+        key = text[i+1:idx]
+        pos = idx + 2
+        buf: List[str] = []
+        a = buf.append
+        while pos < len(text):
+            ch = text[pos]
+            pos += 1
+            if ch == '\\':
+                if text[pos] in escapes:
+                    a(text[pos])
+                    pos += 1
+                    continue
+                a(ch)
+            elif ch == '"':
+                break
+            else:
+                a(ch)
+        ans[key] = ''.join(buf)
+    return ans
+
+
+def parse_null_env(text: str) -> Dict[str, str]:
+    ans = {}
+    for line in text.split('\0'):
+        if line:
+            try:
+                k, v = line.split('=', 1)
+            except ValueError:
+                continue
+            ans[k] = v
+    return ans
+
+
+class CloneCmd:
+
+    def __init__(self, msg: str) -> None:
+        self.args: List[str] = []
+        self.env: Optional[Dict[str, str]] = None
+        self.cwd = ''
+        self.shell = ''
+        self.envfmt = 'default'
+        self.pid = -1
+        self.history = ''
+        self.parse_message(msg)
+        self.opts = parse_opts_for_clone(self.args)
+
+    def parse_message(self, msg: str) -> None:
+        import base64
+        simple = 'pid', 'envfmt', 'shell'
+        for x in msg.split(','):
+            k, v = x.split('=', 1)
+            if k in simple:
+                setattr(self, k, int(v) if k == 'pid' else v)
+                continue
+            v = base64.standard_b64decode(v).decode('utf-8', 'replace')
+            if k == 'a':
+                self.args.append(v)
+            elif k == 'env':
+                env = parse_bash_env(v) if self.envfmt == 'bash' else parse_null_env(v)
+                self.env = {k: v for k, v in env.items() if k not in {
+                    'HOME', 'LOGNAME', 'USER', 'PWD',
+                    # some people export these. We want the shell rc files to recreate them
+                    'PS0', 'PS1', 'PS2', 'PS3', 'PS4', 'RPS1', 'PROMPT_COMMAND', 'SHLVL',
+                    # conda state env vars
+                    'CONDA_SHLVL', 'CONDA_PREFIX', 'CONDA_PROMPT_MODIFIER', 'CONDA_EXE', 'CONDA_PYTHON_EXE', '_CE_CONDA', '_CE_M',
+                    # skip SSH environment variables
+                    'SSH_CLIENT', 'SSH_CONNECTION', 'SSH_ORIGINAL_COMMAND', 'SSH_TTY', 'SSH2_TTY',
+                    'SSH_TUNNEL', 'SSH_USER_AUTH', 'SSH_AUTH_SOCK',
+                } and not k.startswith((
+                    # conda state env vars for multi-level virtual environments
+                    'CONDA_PREFIX_',
+                ))}
+            elif k == 'cwd':
+                self.cwd = v
+            elif k == 'history':
+                self.history = v
+
+
+def clone_and_launch(msg: str, window: Window) -> None:
+    from .child import cmdline_of_process
+    from .shell_integration import serialize_env
+    c = CloneCmd(msg)
+    if c.cwd and not c.opts.cwd:
+        c.opts.cwd = c.cwd
+    c.opts.copy_colors = True
+    c.opts.copy_env = False
+    if c.opts.type in non_window_launch_types:
+        c.opts.type = 'window'
+    env_to_serialize = c.env or {}
+    if env_to_serialize.get('PATH') and env_to_serialize.get('VIRTUAL_ENV'):
+        # only pass VIRTUAL_ENV if it is currently active
+        if f"{env_to_serialize['VIRTUAL_ENV']}/bin" not in env_to_serialize['PATH'].split(os.pathsep):
+            del env_to_serialize['VIRTUAL_ENV']
+    env_to_serialize['KITTY_CLONE_SOURCE_STRATEGIES'] = ',' + ','.join(get_options().clone_source_strategies) + ','
+    is_clone_launch = serialize_env(c.shell, env_to_serialize)
+    ssh_kitten_cmdline = window.ssh_kitten_cmdline()
+    if ssh_kitten_cmdline:
+        from kittens.ssh.utils import (
+            patch_cmdline, set_cwd_in_cmdline, set_env_in_cmdline
+        )
+        cmdline = ssh_kitten_cmdline
+        if c.opts.cwd:
+            set_cwd_in_cmdline(c.opts.cwd, cmdline)
+            c.opts.cwd = None
+        if c.env:
+            set_env_in_cmdline({
+                'KITTY_IS_CLONE_LAUNCH': is_clone_launch,
+            }, cmdline)
+            c.env = None
+        if c.opts.env:
+            for entry in reversed(c.opts.env):
+                patch_cmdline('env', entry, cmdline)
+            c.opts.env = []
+    else:
+        try:
+            cmdline = cmdline_of_process(c.pid)
+        except Exception:
+            cmdline = []
+        if not cmdline:
+            cmdline = list(window.child.argv)
+        if cmdline and cmdline[0] == window.child.final_argv0:
+            cmdline[0] = window.child.final_exe
+        if cmdline and cmdline == [window.child.final_exe] + window.child.argv[1:]:
+            cmdline = window.child.unmodified_argv
+    launch(get_boss(), c.opts, cmdline, active=window, is_clone_launch=is_clone_launch)

kitty/main.py

@@ -17,7 +17,7 @@ from .conf.utils import BadLine
 from .config import cached_values_for
 from .constants import (
     appname, beam_cursor_data_file, config_dir, glfw_path, is_macos,
-    is_wayland, kitty_exe, logo_png_file, running_in_kitty
+    is_wayland, kitty_exe, logo_png_file, running_in_kitty, website_url
 )
 from .fast_data_types import (
     GLFW_IBEAM_CURSOR, GLFW_MOD_ALT, GLFW_MOD_SHIFT, create_os_window,
@@ -29,7 +29,7 @@ from .fonts.render import set_font_family
 from .options.types import Options
 from .options.utils import DELETE_ENV_VAR
 from .os_window_size import initial_window_size_func
-from .session import get_os_window_sizing_data
+from .session import create_sessions, get_os_window_sizing_data
 from .types import SingleKey
 from .utils import (
     cleanup_ssh_control_masters, detach, expandvars, log_error,
@@ -163,19 +163,24 @@ def _run_app(opts: Options, args: CLIOptions, bad_lines: Sequence[BadLine] = ())
         val = get_macos_shortcut_for(func_map, 'load_config_file', lookup_name='reload_config')
         if val is not None:
             global_shortcuts['reload_config'] = val
+        val = get_macos_shortcut_for(func_map, f'open_url {website_url()}', lookup_name='open_kitty_website')
+        if val is not None:
+            global_shortcuts['open_kitty_website'] = val
     if is_macos and opts.macos_custom_beam_cursor:
         set_custom_ibeam_cursor()
     if not is_wayland() and not is_macos:  # no window icons on wayland
         set_x11_window_icon()
     with cached_values_for(run_app.cached_values_name) as cached_values:
+        startup_sessions = tuple(create_sessions(opts, args, default_session=opts.startup_session))
+        wincls = (startup_sessions[0].os_window_class if startup_sessions else '') or args.cls or appname
         with startup_notification_handler(extra_callback=run_app.first_window_callback) as pre_show_callback:
             window_id = create_os_window(
-                    run_app.initial_window_size_func(get_os_window_sizing_data(opts), cached_values),
+                    run_app.initial_window_size_func(get_os_window_sizing_data(opts, startup_sessions[0] if startup_sessions else None), cached_values),
                     pre_show_callback,
                     args.title or appname, args.name or args.cls or appname,
-                    args.cls or appname, load_all_shaders, disallow_override_title=bool(args.title))
+                    wincls, load_all_shaders, disallow_override_title=bool(args.title))
         boss = Boss(opts, args, cached_values, global_shortcuts)
-        boss.start(window_id)
+        boss.start(window_id, startup_sessions)
         if bad_lines:
             boss.show_bad_config_lines(bad_lines)
         try:

kitty/modes.h

@@ -58,7 +58,7 @@
 // National Replacement Character Set Mode
 #define DECNRCM (42 << 5)
 
-// Xterm mouse protocol
+// xterm mouse protocol
 #define MOUSE_BUTTON_TRACKING (1000 << 5)
 #define MOUSE_MOTION_TRACKING  (1002 << 5)
 #define MOUSE_MOVE_TRACKING (1003 << 5)

kitty/mouse.c

@@ -120,9 +120,13 @@ encode_mouse_button(Window *w, int button, MouseAction action, int mods) {
     if (button == GLFW_MOUSE_BUTTON_LEFT) {
         switch(action) {
             case PRESS:
-                global_state.tracked_drag_in_window = w->id; break;
+                global_state.tracked_drag_in_window = w->id;
+                global_state.tracked_drag_button = button;
+                break;
             case RELEASE:
-                global_state.tracked_drag_in_window = 0; break;
+                global_state.tracked_drag_in_window = 0;
+                global_state.tracked_drag_button = -1;
+                break;
             default:
                 break;
         }
@@ -360,7 +364,7 @@ HANDLER(handle_move_event) {
         handle_mouse_movement_in_kitty(w, button, mouse_cell_changed | cell_half_changed);
     } else {
         if (!mouse_cell_changed && screen->modes.mouse_tracking_protocol != SGR_PIXEL_PROTOCOL) return;
-        int sz = encode_mouse_button(w, MAX(0, button), button >=0 ? DRAG : MOVE, modifiers);
+        int sz = encode_mouse_button(w, button, button >=0 ? DRAG : MOVE, modifiers);
         if (sz > 0) { mouse_event_buf[sz] = 0; write_escape_code_to_child(screen, CSI, mouse_event_buf); }
     }
 }
@@ -769,7 +773,7 @@ mouse_event(const int button, int modifiers, int action) {
                         clamp_to_window = true;
                         Tab *t = global_state.callback_os_window->tabs + global_state.callback_os_window->active_tab;
                         for (window_idx = 0; window_idx < t->num_windows && t->windows[window_idx].id != w->id; window_idx++);
-                        handle_move_event(w, button, modifiers, window_idx);
+                        handle_move_event(w, global_state.tracked_drag_button, modifiers, window_idx);
                         clamp_to_window = false;
                         debug("sent to child as drag move\n");
                         return;

kitty/options/parse.py

@@ -8,15 +8,16 @@ from kitty.conf.utils import (
 from kitty.options.utils import (
     action_alias, active_tab_title_template, adjust_baseline, adjust_line_height, allow_hyperlinks,
     allow_remote_control, bell_on_tab, box_drawing_scale, clear_all_mouse_actions, clear_all_shortcuts,
-    clipboard_control, config_or_absolute_path, copy_on_select, cursor_text_color,
-    deprecated_hide_window_decorations_aliases, deprecated_macos_show_window_title_in_menubar_alias,
-    deprecated_send_text, disable_ligatures, edge_width, env, font_features, hide_window_decorations,
-    macos_option_as_alt, macos_titlebar_color, narrow_symbols, optional_edge_width, parse_map,
-    parse_mouse_map, paste_actions, resize_draw_strategy, scrollback_lines,
-    scrollback_pager_history_size, shell_integration, store_multiple, symbol_map, tab_activity_symbol,
-    tab_bar_edge, tab_bar_margin_height, tab_bar_min_tabs, tab_fade, tab_font_style, tab_separator,
-    tab_title_template, titlebar_color, to_cursor_shape, to_font_size, to_layout_names, to_modifiers,
-    url_prefixes, url_style, visual_window_select_characters, window_border_width, window_size
+    clipboard_control, clone_source_strategies, config_or_absolute_path, copy_on_select,
+    cursor_text_color, deprecated_hide_window_decorations_aliases,
+    deprecated_macos_show_window_title_in_menubar_alias, deprecated_send_text, disable_ligatures,
+    edge_width, env, font_features, hide_window_decorations, macos_option_as_alt, macos_titlebar_color,
+    narrow_symbols, optional_edge_width, parse_map, parse_mouse_map, paste_actions,
+    resize_draw_strategy, scrollback_lines, scrollback_pager_history_size, shell_integration,
+    store_multiple, symbol_map, tab_activity_symbol, tab_bar_edge, tab_bar_margin_height,
+    tab_bar_min_tabs, tab_fade, tab_font_style, tab_separator, tab_title_template, titlebar_color,
+    to_cursor_shape, to_font_size, to_layout_names, to_modifiers, url_prefixes, url_style,
+    visual_window_select_characters, window_border_width, window_size
 )
 
 
@@ -50,6 +51,14 @@ class Parser:
     def adjust_line_height(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
         ans['adjust_line_height'] = adjust_line_height(val)
 
+    def allow_cloning(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
+        val = val.lower()
+        if val not in self.choices_for_allow_cloning:
+            raise ValueError(f"The value {val} is not a valid choice for allow_cloning")
+        ans["allow_cloning"] = val
+
+    choices_for_allow_cloning = frozenset(('yes', 'y', 'true', 'no', 'n', 'false', 'ask'))
+
     def allow_hyperlinks(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
         ans['allow_hyperlinks'] = allow_hyperlinks(val)
 
@@ -112,6 +121,9 @@ class Parser:
     def clipboard_max_size(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
         ans['clipboard_max_size'] = positive_float(val)
 
+    def clone_source_strategies(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
+        ans['clone_source_strategies'] = clone_source_strategies(val)
+
     def close_on_child_death(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
         ans['close_on_child_death'] = to_bool(val)
 
@@ -1023,6 +1035,14 @@ class Parser:
     def listen_on(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
         ans['listen_on'] = str(val)
 
+    def macos_colorspace(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
+        val = val.lower()
+        if val not in self.choices_for_macos_colorspace:
+            raise ValueError(f"The value {val} is not a valid choice for macos_colorspace")
+        ans["macos_colorspace"] = val
+
+    choices_for_macos_colorspace = frozenset(('srgb', 'default', 'displayp3'))
+
     def macos_custom_beam_cursor(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
         ans['macos_custom_beam_cursor'] = to_bool(val)
 
@@ -1143,6 +1163,9 @@ class Parser:
     def select_by_word_characters(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
         ans['select_by_word_characters'] = str(val)
 
+    def select_by_word_characters_forward(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
+        ans['select_by_word_characters_forward'] = str(val)
+
     def selection_background(self, val: str, ans: typing.Dict[str, typing.Any]) -> None:
         ans['selection_background'] = to_color_or_none(val)
 

kitty/options/to-c-generated.h

@@ -304,6 +304,19 @@ convert_from_opts_select_by_word_characters(PyObject *py_opts, Options *opts) {
     Py_DECREF(ret);
 }
 
+static void
+convert_from_python_select_by_word_characters_forward(PyObject *val, Options *opts) {
+    select_by_word_characters_forward(val, opts);
+}
+
+static void
+convert_from_opts_select_by_word_characters_forward(PyObject *py_opts, Options *opts) {
+    PyObject *ret = PyObject_GetAttrString(py_opts, "select_by_word_characters_forward");
+    if (ret == NULL) return;
+    convert_from_python_select_by_word_characters_forward(ret, opts);
+    Py_DECREF(ret);
+}
+
 static void
 convert_from_python_click_interval(PyObject *val, Options *opts) {
     opts->click_interval = parse_s_double_to_monotonic_t(val);
@@ -1006,6 +1019,19 @@ convert_from_opts_macos_menubar_title_max_length(PyObject *py_opts, Options *opt
     Py_DECREF(ret);
 }
 
+static void
+convert_from_python_macos_colorspace(PyObject *val, Options *opts) {
+    opts->macos_colorspace = macos_colorspace(val);
+}
+
+static void
+convert_from_opts_macos_colorspace(PyObject *py_opts, Options *opts) {
+    PyObject *ret = PyObject_GetAttrString(py_opts, "macos_colorspace");
+    if (ret == NULL) return;
+    convert_from_python_macos_colorspace(ret, opts);
+    Py_DECREF(ret);
+}
+
 static bool
 convert_opts_from_python_opts(PyObject *py_opts, Options *opts) {
     convert_from_opts_font_size(py_opts, opts);
@@ -1054,6 +1080,8 @@ convert_opts_from_python_opts(PyObject *py_opts, Options *opts) {
     if (PyErr_Occurred()) return false;
     convert_from_opts_select_by_word_characters(py_opts, opts);
     if (PyErr_Occurred()) return false;
+    convert_from_opts_select_by_word_characters_forward(py_opts, opts);
+    if (PyErr_Occurred()) return false;
     convert_from_opts_click_interval(py_opts, opts);
     if (PyErr_Occurred()) return false;
     convert_from_opts_focus_follows_mouse(py_opts, opts);
@@ -1162,5 +1190,7 @@ convert_opts_from_python_opts(PyObject *py_opts, Options *opts) {
     if (PyErr_Occurred()) return false;
     convert_from_opts_macos_menubar_title_max_length(py_opts, opts);
     if (PyErr_Occurred()) return false;
+    convert_from_opts_macos_colorspace(py_opts, opts);
+    if (PyErr_Occurred()) return false;
     return true;
 }

kitty/options/to-c.h

@@ -127,6 +127,13 @@ pointer_shape(PyObject *shape_name) {
     return BEAM;
 }
 
+static int
+macos_colorspace(PyObject *csname) {
+    if (PyUnicode_CompareWithASCIIString(csname, "srgb")) return 1;
+    if (PyUnicode_CompareWithASCIIString(csname, "displayp3")) return 2;
+    return 0;
+}
+
 static inline void
 free_url_prefixes(void) {
     OPT(url_prefixes).num = 0;
@@ -180,6 +187,12 @@ select_by_word_characters(PyObject *chars, Options *opts) {
     opts->select_by_word_characters = list_of_chars(chars);
 }
 
+static void
+select_by_word_characters_forward(PyObject *chars, Options *opts) {
+    free(opts->select_by_word_characters_forward);
+    opts->select_by_word_characters_forward = list_of_chars(chars);
+}
+
 static void
 tab_bar_style(PyObject *val, Options *opts) {
     opts->tab_bar_hidden = PyUnicode_CompareWithASCIIString(val, "hidden") == 0 ? true: false;

kitty/options/types.py

@@ -13,9 +13,11 @@ from kitty.types import FloatEdges, SingleKey
 import kitty.types
 
 if typing.TYPE_CHECKING:
+    choices_for_allow_cloning = typing.Literal['yes', 'y', 'true', 'no', 'n', 'false', 'ask']
     choices_for_background_image_layout = typing.Literal['mirror-tiled', 'scaled', 'tiled', 'clamped']
     choices_for_default_pointer_shape = typing.Literal['arrow', 'beam', 'hand']
     choices_for_linux_display_server = typing.Literal['auto', 'wayland', 'x11']
+    choices_for_macos_colorspace = typing.Literal['srgb', 'default', 'displayp3']
     choices_for_macos_show_window_title_in = typing.Literal['all', 'menubar', 'none', 'window']
     choices_for_placement_strategy = typing.Literal['center', 'top-left']
     choices_for_pointer_shape_when_dragging = typing.Literal['arrow', 'beam', 'hand']
@@ -27,9 +29,11 @@ if typing.TYPE_CHECKING:
     choices_for_tab_switch_strategy = typing.Literal['last', 'left', 'previous', 'right']
     choices_for_window_logo_position = typing.Literal['top-left', 'top', 'top-right', 'left', 'center', 'right', 'bottom-left', 'bottom', 'bottom-right']
 else:
+    choices_for_allow_cloning = str
     choices_for_background_image_layout = str
     choices_for_default_pointer_shape = str
     choices_for_linux_display_server = str
+    choices_for_macos_colorspace = str
     choices_for_macos_show_window_title_in = str
     choices_for_placement_strategy = str
     choices_for_pointer_shape_when_dragging = str
@@ -51,6 +55,7 @@ option_names = (  # {{{
  'adjust_baseline',
  'adjust_column_width',
  'adjust_line_height',
+ 'allow_cloning',
  'allow_hyperlinks',
  'allow_remote_control',
  'background',
@@ -70,6 +75,7 @@ option_names = (  # {{{
  'click_interval',
  'clipboard_control',
  'clipboard_max_size',
+ 'clone_source_strategies',
  'close_on_child_death',
  'color0',
  'color1',
@@ -369,6 +375,7 @@ option_names = (  # {{{
  'kitty_mod',
  'linux_display_server',
  'listen_on',
+ 'macos_colorspace',
  'macos_custom_beam_cursor',
  'macos_hide_from_tasks',
  'macos_menubar_title_max_length',
@@ -404,6 +411,7 @@ option_names = (  # {{{
  'scrollback_pager',
  'scrollback_pager_history_size',
  'select_by_word_characters',
+ 'select_by_word_characters_forward',
  'selection_background',
  'selection_foreground',
  'shell',
@@ -461,6 +469,7 @@ class Options:
     adjust_baseline: typing.Union[int, float] = 0
     adjust_column_width: typing.Union[int, float] = 0
     adjust_line_height: typing.Union[int, float] = 0
+    allow_cloning: choices_for_allow_cloning = 'ask'
     allow_hyperlinks: int = 1
     allow_remote_control: str = 'n'
     background: Color = Color(0, 0, 0)
@@ -480,6 +489,7 @@ class Options:
     click_interval: float = -1.0
     clipboard_control: typing.Tuple[str, ...] = ('write-clipboard', 'write-primary', 'read-clipboard-ask', 'read-primary-ask')
     clipboard_max_size: float = 64.0
+    clone_source_strategies: typing.FrozenSet[str] = frozenset({'conda', 'env_var', 'path', 'venv'})
     close_on_child_death: bool = False
     command_on_bell: typing.List[str] = ['none']
     confirm_os_window_close: int = -1
@@ -519,6 +529,7 @@ class Options:
     kitty_mod: int = 5
     linux_display_server: choices_for_linux_display_server = 'auto'
     listen_on: str = 'none'
+    macos_colorspace: choices_for_macos_colorspace = 'srgb'
     macos_custom_beam_cursor: bool = False
     macos_hide_from_tasks: bool = False
     macos_menubar_title_max_length: int = 0
@@ -551,6 +562,7 @@ class Options:
     scrollback_pager: typing.List[str] = ['less', '--chop-long-lines', '--RAW-CONTROL-CHARS', '+INPUT_LINE_NUMBER']
     scrollback_pager_history_size: int = 0
     select_by_word_characters: str = '@-./_~?&=%+#'
+    select_by_word_characters_forward: str = ''
     selection_background: typing.Optional[kitty.fast_data_types.Color] = Color(255, 250, 205)
     selection_foreground: typing.Optional[kitty.fast_data_types.Color] = Color(0, 0, 0)
     shell: str = '.'
@@ -916,6 +928,7 @@ if is_macos:
     defaults.map.append(KeyDefinition(trigger=SingleKey(mods=8, key=107), definition='clear_terminal to_cursor active'))  # noqa
     defaults.map.append(KeyDefinition(trigger=SingleKey(mods=12, key=44), definition='load_config_file'))  # noqa
     defaults.map.append(KeyDefinition(trigger=SingleKey(mods=10, key=44), definition='debug_config'))  # noqa
+    defaults.map.append(KeyDefinition(trigger=SingleKey(mods=9, key=47), definition='open_url https://sw.kovidgoyal.net/kitty/'))  # noqa
 defaults.mouse_map = [
     # click_url_or_select
     MouseMapping(repeat_count=-2, definition='mouse_handle_click selection link prompt'),  # noqa

kitty/options/utils.py

@@ -91,6 +91,20 @@ def kitten_parse(func: str, rest: str) -> FuncArgsType:
     return func, [args[0]] + (to_cmdline(args[1]) if len(args) > 1 else [])
 
 
+@func_with_args('open_url')
+def open_url_parse(func: str, rest: str) -> FuncArgsType:
+    from urllib.parse import urlparse
+    url = ''
+    try:
+        url = python_string(rest)
+        tokens = urlparse(url)
+        if not all((tokens.scheme, tokens.netloc,)):
+            raise ValueError('Invalid URL')
+    except Exception:
+        log_error('Ignoring invalid URL string: ' + rest)
+    return func, (url,)
+
+
 @func_with_args('goto_tab')
 def goto_tab_parse(func: str, rest: str) -> FuncArgsType:
     args = (max(0, int(rest)), )
@@ -746,6 +760,10 @@ def tab_bar_margin_height(x: str) -> TabBarMarginHeight:
     return TabBarMarginHeight(next(ans), next(ans))
 
 
+def clone_source_strategies(x: str) -> FrozenSet[str]:
+    return frozenset({'venv', 'conda', 'path', 'env_var'} & set(x.lower().split(',')))
+
+
 def clear_all_mouse_actions(val: str, dict_with_parse_results: Optional[Dict[str, Any]] = None) -> bool:
     ans = to_bool(val)
     if ans and dict_with_parse_results is not None:

kitty/parser.c

@@ -1001,7 +1001,7 @@ dispatch_csi(Screen *screen, PyObject DUMP_UNUSED *dump_callback) {
         case 'm':
             if (start_modifier == '>' && !end_modifier) {
                 REPORT_ERROR(
-                    "The application is trying to use XTerm's modifyOtherKeys."
+                    "The application is trying to use xterm's modifyOtherKeys."
                     " This is superseded by the kitty keyboard protocol: https://sw.kovidgoyal.net/kitty/keyboard-protocol/"
                     " the application should be updated to use that"
                 );
@@ -1086,6 +1086,7 @@ dispatch_dcs(Screen *screen, PyObject DUMP_UNUSED *dump_callback) {
                 } else IF_SIMPLE_PREFIX("echo|", handle_remote_echo)
                 } else IF_SIMPLE_PREFIX("ssh|", handle_remote_ssh)
                 } else IF_SIMPLE_PREFIX("ask|", handle_remote_askpass)
+                } else IF_SIMPLE_PREFIX("clone|", handle_remote_clone)
 #undef IF_SIMPLE_PREFIX
                 } else {
                     REPORT_ERROR("Unrecognized DCS @ code: 0x%x", screen->parser_buf[1]);