Detection, done like sync:

- ESC[?u goes to every VT100-like terminal at attach, whatever the options. - A reply turns on a new kittykeys terminal feature. Users can force it on or off with terminal-features kittykeys, including kittykeys@ to turn it off. - Changing extended-keys now takes effect immediately for attached clients (options.c). Use, per client, when extended-keys is on: Kitty for clients that have kittykeys, modifyOtherKeys for clients with extkeys, VT10x otherwise. Pane side: - Applications can request either protocol; Kitty wins if one asks for both. - Each application gets what it asked for, whichever client typed the key. - ESC[?u is answered truthfully. - The per-client gate is gone. window.c and popup.c are simply master's versions again. extended-keys always is back to its master meaning, forcing modifyOtherKeys mode 1 only. Forcing Kitty on every program would have sent bash ESC[97;5u for Ctrl-A. extended-keys-format kitty is still accepted, but now behaves the same as csi-u.
Add a test for Kitty keyboard protocol input parsing
2026-09-19 19:38:09 +00:00 · 2026-09-19 07:32:57 +01:00 · 2026-09-17 06:16:11 +01:00 · 2026-09-17 06:00:13 +01:00 · 2026-09-15 06:14:43 +01:00 · 2026-09-15 06:11:25 +01:00
35 changed files with 1965 additions and 65 deletions
--- a/18
+++ b/18
@@ -33,9 +33,7 @@ CHANGES FROM 3.7c TO 3.8
    line;

  - pane-border-status has top-floating and bottom-floating, and there are new
-    default bindings under C-b g for common move and resize operations;
-
-  - floating panes are unzoomed before creation to avoid a crash.
+    default bindings under C-b g for common move and resize operations.

 * Layout strings now use a JSON subset format which includes floating panes.
  The old format is still accepted; control mode clients receive old layouts
@@ -113,6 +111,18 @@ CHANGES FROM 3.7c TO 3.8

 * Change show-options and show-hooks to use formats and add a -F flag to each.

+* Add support for the Kitty keyboard protocol. When extended-keys is on,
+  tmux uses it with terminals which support it, detected when a client
+  attaches or set with a new kittykeys terminal feature, and standard
+  extended keys or VT10x keys with other terminals, so terminals with
+  different capabilities may be attached at the same time. Programs inside
+  tmux may ask for either the Kitty protocol or modifyOtherKeys and get keys
+  in the form they asked for. The Kitty protocol can report the Super and
+  Hyper modifiers (key name prefixes s- and H-).
+
+* Add a client_key_mode format giving the extended key reporting mode in
+  use for a client, alongside the existing pane_key_mode for a pane.
+
 * Allow individual terminal features to be disabled by adding @ to their names
  in terminal-features, and add a utf8 feature for terminals which support
  UTF-8 output.
@@ -132,6 +142,8 @@ CHANGES FROM 3.7c TO 3.8

 * Add capture-pane -I to include the time each line entered history.

+* Various memory leak fixes from Heon Jeong.
+
 * Add a default C-b T binding to change the current pane title.

 * Menus now belong to the window, so appear on all clients.
--- a/Makefile.am
+++ b/Makefile.am
@@ -171,6 +171,7 @@ dist_tmux_SOURCES = \
 	grid.c \
 	hooks.c \
 	hyperlinks.c \
+	input-kitty.c \
 	input-keys.c \
 	input.c \
 	job.c \
@@ -212,6 +213,7 @@ dist_tmux_SOURCES = \
 	tty-acs.c \
 	tty-draw.c \
 	tty-features.c \
+	tty-kitty.c \
 	tty-keys.c \
 	tty-term.c \
 	tty.c \
--- a/cmd-split-window.c
+++ b/cmd-split-window.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-split-window.c,v 1.150 2026/08/20 09:19:24 nicm Exp $ */
+/* $OpenBSD: cmd-split-window.c,v 1.151 2026/09/10 11:02:18 nicm Exp $ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -40,8 +40,8 @@ const struct cmd_entry cmd_new_pane_entry = {
 	.name = "new-pane",
 	.alias = "newp",

-	.args = { "AbB:Cc:de:EfF:hIkl:KLMm:Op:PR:s:S:t:T:vWx:X:y:Y:Z", 0, -1, NULL },
-	.usage = "[-AbCdefhIkKLMOPvWZ] [-B border-lines] "
+	.args = { "AbB:Cc:Dde:EfF:hIkl:KLMm:Op:PR:s:S:t:T:vWx:X:y:Y:Z", 0, -1, NULL },
+	.usage = "[-AbCDefhIkKLMOPvWZ] [-B border-lines] "
 		 "[-c start-directory] [-e environment] "
 		 "[-F format] [-l size] [-m message] [-p percentage] "
 		 "[-s style] [-S active-border-style] "
@@ -219,6 +219,8 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 		new_wp->flags |= PANE_CAPTUREALLKEYS;
 	if (args_has(args, 'C') && args_has(args, 'O'))
 		new_wp->flags |= PANE_CLOSEONCLICK;
+	if (args_has(args, 'D') && args_has(args, 'O'))
+		new_wp->flags |= PANE_CLOSEONCANCEL;

 	style = args_get(args, 's');
 	if (style != NULL) {
--- a/configure.ac
+++ b/configure.ac
@@ -1,6 +1,6 @@
 # configure.ac

-AC_INIT([tmux], next-3.8)
+AC_INIT([tmux], next-3.9)
 AC_PREREQ([2.60])

 AC_CONFIG_AUX_DIR(etc)
--- a/format.c
+++ b/format.c
@@ -1617,6 +1617,41 @@ format_cb_client_height(struct format_tree *ft)
 	return (NULL);
 }

+/* Callback for client_key_mode. */
+static void *
+format_cb_client_key_mode(struct format_tree *ft)
+{
+	struct client	*c = ft->c;
+	const char	*mode;
+	char		*s;
+	int		 kitty, eks;
+
+	if (c == NULL || (~c->tty.flags & TTY_STARTED))
+		return (NULL);
+
+	if (c->tty.flags & TTY_KKBPUSHED) {
+		xasprintf(&s, "Kitty %u", c->tty.kitty_keys);
+		return (s);
+	}
+
+	/* This mirrors the choice made in tty_update_features(). */
+	kitty = ((c->tty.term->flags & TERM_KITTYKEYS) != 0);
+	eks = (options_get_number(global_options, "extended-keys") != 0);
+	if (kitty)
+		eks = 0;
+	if (eks && tty_term_has(c->tty.term, TTYC_ENEKS))
+		mode = "Ext";
+	else
+		mode = "VT10x";
+
+	/* The terminal supports Kitty keys but they are not in use. */
+	if (kitty) {
+		xasprintf(&s, "%s (Kitty)", mode);
+		return (s);
+	}
+	return (xstrdup(mode));
+}
+
 /* Callback for client_key_table. */
 static void *
 format_cb_client_key_table(struct format_tree *ft)
@@ -2487,7 +2522,14 @@ format_cb_pane_unseen_changes(struct format_tree *ft)
 static void *
 format_cb_pane_key_mode(struct format_tree *ft)
 {
+	char	*s;
+
 	if (ft->wp != NULL && ft->wp->screen != NULL) {
+		if (ft->wp->screen->kitty_keys.flags != 0) {
+			xasprintf(&s, "Kitty %u",
+			    ft->wp->screen->kitty_keys.flags);
+			return (s);
+		}
 		switch (ft->wp->screen->mode & EXTENDED_KEY_MODES) {
 		case MODE_KEYS_EXTENDED:
 			return (xstrdup("Ext 1"));
@@ -3642,6 +3684,9 @@ static const struct format_table_entry format_table[] = {
 	{ "client_height", FORMAT_TABLE_STRING,
 	  format_cb_client_height
 	},
+	{ "client_key_mode", FORMAT_TABLE_STRING,
+	  format_cb_client_key_mode
+	},
 	{ "client_key_table", FORMAT_TABLE_STRING,
 	  format_cb_client_key_table
 	},
--- a/input-keys.c
+++ b/input-keys.c
@@ -464,7 +464,8 @@ input_key_extended(struct bufferevent *bev, key_code key)
 	} else
 		key &= KEYC_MASK_KEY;

-	if (options_get_number(global_options, "extended-keys-format") == 1)
+	if (options_get_number(global_options, "extended-keys-format") ==
+	    EXTENDED_KEYS_XTERM)
 		xsnprintf(tmp, sizeof tmp, "\033[27;%c;%llu~", modifier, key);
 	else
 		xsnprintf(tmp, sizeof tmp, "\033[%llu;%cu", key, modifier);
@@ -588,6 +589,10 @@ input_key(struct screen *s, struct bufferevent *bev, key_code key)
 		return (0);
 	}

+	/* Kitty keys take precedence if the application asked for them. */
+	if (input_key_kitty(s, bev, key) == 0)
+		return (0);
+
 	/* Is this backspace? */
 	if ((key & KEYC_MASK_KEY) == KEYC_BSPACE) {
 		newkey = options_get_number(global_options, "backspace");
@@ -677,6 +682,10 @@ input_key(struct screen *s, struct bufferevent *bev, key_code key)
 		log_debug("%s: ignoring key 0x%llx", __func__, key);
 		return (0);
 	}
+	if (key & (KEYC_SUPER|KEYC_HYPER))
+		return (input_key_vt10x(bev, key));
+	if (s->kitty_keys.flags & KITTY_KEY_SUPPORTED)
+		return (input_key_vt10x(bev, key));

 	/*
 	 * No builtin key sequence; construct an extended key sequence
--- a/input-kitty.c
+++ b/input-kitty.c
@@ -0,0 +1,313 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2026 Michael Grant <mgrant@grant.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+
+#include <string.h>
+#include <wchar.h>
+
+#include "tmux.h"
+
+/* Track pane keyboard state and encode keys for applications. */
+
+struct input_kitty_key {
+	key_code	 key;
+	u_int		 number;
+	char		 final;
+};
+
+static const struct input_kitty_key input_kitty_keys[] = {
+	{ C0_ESC, 27, 'u' },
+	{ C0_CR, 13, 'u' },
+	{ C0_HT, 9, 'u' },
+	{ KEYC_BSPACE, 127, 'u' },
+	{ KEYC_IC, 2, '~' },
+	{ KEYC_DC, 3, '~' },
+	{ KEYC_LEFT, 1, 'D' },
+	{ KEYC_RIGHT, 1, 'C' },
+	{ KEYC_UP, 1, 'A' },
+	{ KEYC_DOWN, 1, 'B' },
+	{ KEYC_PPAGE, 5, '~' },
+	{ KEYC_NPAGE, 6, '~' },
+	{ KEYC_HOME, 1, 'H' },
+	{ KEYC_END, 1, 'F' },
+	{ KEYC_F1, 1, 'P' },
+	{ KEYC_F2, 1, 'Q' },
+	{ KEYC_F3, 13, '~' },
+	{ KEYC_F4, 1, 'S' },
+	{ KEYC_F5, 15, '~' },
+	{ KEYC_F6, 17, '~' },
+	{ KEYC_F7, 18, '~' },
+	{ KEYC_F8, 19, '~' },
+	{ KEYC_F9, 20, '~' },
+	{ KEYC_F10, 21, '~' },
+	{ KEYC_F11, 23, '~' },
+	{ KEYC_F12, 24, '~' },
+	{ KEYC_CAPSLOCK, 57358, 'u' },
+	{ KEYC_SCROLLLOCK, 57359, 'u' },
+	{ KEYC_NUMLOCK, 57360, 'u' },
+	{ KEYC_PRINTSCREEN, 57361, 'u' },
+	{ KEYC_PAUSE, 57362, 'u' },
+	{ KEYC_MENU, 57363, 'u' },
+	{ KEYC_F13, 57376, 'u' },
+	{ KEYC_F14, 57377, 'u' },
+	{ KEYC_F15, 57378, 'u' },
+	{ KEYC_F16, 57379, 'u' },
+	{ KEYC_F17, 57380, 'u' },
+	{ KEYC_F18, 57381, 'u' },
+	{ KEYC_F19, 57382, 'u' },
+	{ KEYC_F20, 57383, 'u' },
+	{ KEYC_F21, 57384, 'u' },
+	{ KEYC_F22, 57385, 'u' },
+	{ KEYC_F23, 57386, 'u' },
+	{ KEYC_F24, 57387, 'u' },
+	{ KEYC_F25, 57388, 'u' },
+	{ KEYC_F26, 57389, 'u' },
+	{ KEYC_F27, 57390, 'u' },
+	{ KEYC_F28, 57391, 'u' },
+	{ KEYC_F29, 57392, 'u' },
+	{ KEYC_F30, 57393, 'u' },
+	{ KEYC_F31, 57394, 'u' },
+	{ KEYC_F32, 57395, 'u' },
+	{ KEYC_F33, 57396, 'u' },
+	{ KEYC_F34, 57397, 'u' },
+	{ KEYC_F35, 57398, 'u' },
+	{ KEYC_KP_ZERO|KEYC_KEYPAD, 57399, 'u' },
+	{ KEYC_KP_ONE|KEYC_KEYPAD, 57400, 'u' },
+	{ KEYC_KP_TWO|KEYC_KEYPAD, 57401, 'u' },
+	{ KEYC_KP_THREE|KEYC_KEYPAD, 57402, 'u' },
+	{ KEYC_KP_FOUR|KEYC_KEYPAD, 57403, 'u' },
+	{ KEYC_KP_FIVE|KEYC_KEYPAD, 57404, 'u' },
+	{ KEYC_KP_SIX|KEYC_KEYPAD, 57405, 'u' },
+	{ KEYC_KP_SEVEN|KEYC_KEYPAD, 57406, 'u' },
+	{ KEYC_KP_EIGHT|KEYC_KEYPAD, 57407, 'u' },
+	{ KEYC_KP_NINE|KEYC_KEYPAD, 57408, 'u' },
+	{ KEYC_KP_PERIOD|KEYC_KEYPAD, 57409, 'u' },
+	{ KEYC_KP_SLASH|KEYC_KEYPAD, 57410, 'u' },
+	{ KEYC_KP_STAR|KEYC_KEYPAD, 57411, 'u' },
+	{ KEYC_KP_MINUS|KEYC_KEYPAD, 57412, 'u' },
+	{ KEYC_KP_PLUS|KEYC_KEYPAD, 57413, 'u' },
+	{ KEYC_KP_ENTER|KEYC_KEYPAD, 57414, 'u' },
+	{ KEYC_KP_EQUAL|KEYC_KEYPAD, 57415, 'u' },
+	{ KEYC_KP_SEPARATOR|KEYC_KEYPAD, 57416, 'u' },
+	{ KEYC_KP_LEFT|KEYC_KEYPAD, 57417, 'u' },
+	{ KEYC_KP_RIGHT|KEYC_KEYPAD, 57418, 'u' },
+	{ KEYC_KP_UP|KEYC_KEYPAD, 57419, 'u' },
+	{ KEYC_KP_DOWN|KEYC_KEYPAD, 57420, 'u' },
+	{ KEYC_KP_PPAGE|KEYC_KEYPAD, 57421, 'u' },
+	{ KEYC_KP_NPAGE|KEYC_KEYPAD, 57422, 'u' },
+	{ KEYC_KP_HOME|KEYC_KEYPAD, 57423, 'u' },
+	{ KEYC_KP_END|KEYC_KEYPAD, 57424, 'u' },
+	{ KEYC_KP_IC|KEYC_KEYPAD, 57425, 'u' },
+	{ KEYC_KP_DC|KEYC_KEYPAD, 57426, 'u' },
+	{ KEYC_KP_BEGIN|KEYC_KEYPAD, 57427, '~' },
+	{ KEYC_MEDIA_PLAY, 57428, 'u' },
+	{ KEYC_MEDIA_PAUSE, 57429, 'u' },
+	{ KEYC_MEDIA_PLAYPAUSE, 57430, 'u' },
+	{ KEYC_MEDIA_REVERSE, 57431, 'u' },
+	{ KEYC_MEDIA_STOP, 57432, 'u' },
+	{ KEYC_MEDIA_FASTFORWARD, 57433, 'u' },
+	{ KEYC_MEDIA_REWIND, 57434, 'u' },
+	{ KEYC_MEDIA_NEXT, 57435, 'u' },
+	{ KEYC_MEDIA_PREVIOUS, 57436, 'u' },
+	{ KEYC_MEDIA_RECORD, 57437, 'u' },
+	{ KEYC_VOLUME_DOWN, 57438, 'u' },
+	{ KEYC_VOLUME_UP, 57439, 'u' },
+	{ KEYC_VOLUME_MUTE, 57440, 'u' },
+	{ KEYC_LEFT_SHIFT, 57441, 'u' },
+	{ KEYC_LEFT_CTRL, 57442, 'u' },
+	{ KEYC_LEFT_ALT, 57443, 'u' },
+	{ KEYC_LEFT_SUPER, 57444, 'u' },
+	{ KEYC_LEFT_HYPER, 57445, 'u' },
+	{ KEYC_LEFT_META, 57446, 'u' },
+	{ KEYC_RIGHT_SHIFT, 57447, 'u' },
+	{ KEYC_RIGHT_CTRL, 57448, 'u' },
+	{ KEYC_RIGHT_ALT, 57449, 'u' },
+	{ KEYC_RIGHT_SUPER, 57450, 'u' },
+	{ KEYC_RIGHT_HYPER, 57451, 'u' },
+	{ KEYC_RIGHT_META, 57452, 'u' },
+	{ KEYC_ISO_LEVEL3_SHIFT, 57453, 'u' },
+	{ KEYC_ISO_LEVEL5_SHIFT, 57454, 'u' }
+};
+
+void
+input_kitty_reset(struct screen *s)
+{
+	memset(&s->kitty_keys, 0, sizeof s->kitty_keys);
+}
+
+void
+input_kitty_alternate_on(struct screen *s)
+{
+	s->saved_kitty_keys = s->kitty_keys;
+	input_kitty_reset(s);
+}
+
+void
+input_kitty_alternate_off(struct screen *s)
+{
+	s->kitty_keys = s->saved_kitty_keys;
+	memset(&s->saved_kitty_keys, 0, sizeof s->saved_kitty_keys);
+}
+
+void
+input_kitty_set(struct screen *s, u_int flags, int mode)
+{
+	flags &= KITTY_KEY_SUPPORTED;
+	if (mode == 2)
+		s->kitty_keys.flags |= flags;
+	else if (mode == 3)
+		s->kitty_keys.flags &= ~flags;
+	else
+		s->kitty_keys.flags = flags;
+}
+
+void
+input_kitty_push(struct screen *s, u_int flags)
+{
+	s->kitty_keys.saved_flags = s->kitty_keys.flags;
+	s->kitty_keys.have_saved = 1;
+	s->kitty_keys.flags = flags & KITTY_KEY_SUPPORTED;
+}
+
+void
+input_kitty_pop(struct screen *s, u_int count)
+{
+	if (count == 0)
+		return;
+	if (s->kitty_keys.have_saved && count == 1)
+		s->kitty_keys.flags = s->kitty_keys.saved_flags;
+	else
+		s->kitty_keys.flags = 0;
+	s->kitty_keys.have_saved = 0;
+}
+
+static u_int
+input_kitty_modifiers(key_code key)
+{
+	u_int	modifiers = 1;
+
+	if (key & KEYC_SHIFT)
+		modifiers += 1;
+	if (key & KEYC_META)
+		modifiers += 2;
+	if (key & KEYC_CTRL)
+		modifiers += 4;
+	if (key & KEYC_SUPER)
+		modifiers += 8;
+	if (key & KEYC_HYPER)
+		modifiers += 16;
+	return (modifiers);
+}
+
+static const struct input_kitty_key *
+input_kitty_lookup(key_code key)
+{
+	key_code	lookup;
+	u_int		i;
+
+	lookup = key & (KEYC_MASK_KEY|KEYC_KEYPAD);
+	for (i = 0; i < nitems(input_kitty_keys); i++) {
+		if (input_kitty_keys[i].key == lookup)
+			return (&input_kitty_keys[i]);
+	}
+	return (NULL);
+}
+
+int
+input_key_kitty(struct screen *s, struct bufferevent *bev, key_code key)
+{
+	const struct input_kitty_key	*ikk;
+	struct utf8_data			 ud;
+	wchar_t				 wc;
+	key_code			 modifiers, onlykey;
+	u_int				 flags, number, modifier;
+	char				 tmp[64];
+	size_t				 size;
+
+	flags = s->kitty_keys.flags & KITTY_KEY_SUPPORTED;
+	if (flags == 0)
+		return (-1);
+	if ((key & KEYC_MASK_KEY) == KEYC_BTAB)
+		key = C0_HT|(key & ~KEYC_MASK_KEY)|KEYC_SHIFT;
+
+	modifiers = key & (KEYC_SHIFT|KEYC_META|KEYC_CTRL|KEYC_SUPER|KEYC_HYPER);
+	ikk = input_kitty_lookup(key);
+	if (ikk != NULL) {
+		if ((flags & KITTY_KEY_REPORT_ALL) == 0) {
+			if (ikk->key == C0_CR || ikk->key == C0_HT ||
+			    ikk->key == KEYC_BSPACE)
+				return (-1);
+			if (ikk->final != 'u' &&
+			    (modifiers & (KEYC_SUPER|KEYC_HYPER)) == 0)
+				return (-1);
+		}
+		number = ikk->number;
+		modifier = input_kitty_modifiers(key);
+		if (ikk->final == 'u') {
+			if (modifier == 1)
+				size = xsnprintf(tmp, sizeof tmp, "\033[%uu", number);
+			else
+				size = xsnprintf(tmp, sizeof tmp, "\033[%u;%uu",
+				    number, modifier);
+		} else if (ikk->final == '~') {
+			if (modifier == 1)
+				size = xsnprintf(tmp, sizeof tmp, "\033[%u~", number);
+			else
+				size = xsnprintf(tmp, sizeof tmp, "\033[%u;%u~",
+				    number, modifier);
+		} else {
+			if (modifier == 1)
+				size = xsnprintf(tmp, sizeof tmp, "\033[%c",
+				    ikk->final);
+			else
+				size = xsnprintf(tmp, sizeof tmp, "\033[1;%u%c",
+				    modifier, ikk->final);
+		}
+		goto write;
+	}
+
+	if ((flags & KITTY_KEY_REPORT_ALL) == 0 &&
+	    (modifiers & (KEYC_META|KEYC_CTRL|KEYC_SUPER|KEYC_HYPER)) == 0)
+		return (-1);
+
+	onlykey = key & KEYC_MASK_KEY;
+	if (KEYC_IS_UNICODE(key)) {
+		utf8_to_data(onlykey, &ud);
+		if (utf8_towc(&ud, &wc) != UTF8_DONE)
+			return (-1);
+		number = wc;
+	} else if (onlykey <= 0x7f)
+		number = onlykey;
+	else
+		return (-1);
+	if ((key & KEYC_SHIFT) && number >= 'A' && number <= 'Z')
+		number += 'a' - 'A';
+
+	modifier = input_kitty_modifiers(key);
+	if (modifier == 1)
+		size = xsnprintf(tmp, sizeof tmp, "\033[%uu", number);
+	else
+		size = xsnprintf(tmp, sizeof tmp, "\033[%u;%uu", number,
+		    modifier);
+
+write:
+	log_debug("%s: %.*s", __func__, (int)size, tmp);
+	bufferevent_write(bev, tmp, size);
+	return (0);
+}
--- a/input.c
+++ b/input.c
@@ -279,6 +279,10 @@ enum input_csi_type {
 	INPUT_CSI_HPA,
 	INPUT_CSI_ICH,
 	INPUT_CSI_IL,
+	INPUT_CSI_KITTY_POP,
+	INPUT_CSI_KITTY_PUSH,
+	INPUT_CSI_KITTY_QUERY,
+	INPUT_CSI_KITTY_SET,
 	INPUT_CSI_MODOFF,
 	INPUT_CSI_MODSET,
 	INPUT_CSI_QUERY,
@@ -344,7 +348,11 @@ static const struct input_table_entry input_csi_table[] = {
 	{ 'r', "",  INPUT_CSI_DECSTBM },
 	{ 's', "",  INPUT_CSI_SCP },
 	{ 't', "",  INPUT_CSI_WINOPS },
-	{ 'u', "",  INPUT_CSI_RCP }
+	{ 'u', "",  INPUT_CSI_RCP },
+	{ 'u', "<", INPUT_CSI_KITTY_POP },
+	{ 'u', "=", INPUT_CSI_KITTY_SET },
+	{ 'u', ">", INPUT_CSI_KITTY_PUSH },
+	{ 'u', "?", INPUT_CSI_KITTY_QUERY }
 };

 /* Input transition. */
@@ -1557,6 +1565,33 @@ input_csi_dispatch(struct input_ctx *ictx)
 		if (options_get_number(global_options, "extended-keys") == 2)
 			screen_write_mode_set(sctx, MODE_KEYS_EXTENDED);
 		break;
+	case INPUT_CSI_KITTY_QUERY:
+		if (options_get_number(global_options, "extended-keys") == 0)
+			break;
+		input_reply(ictx, 1, "\033[?%uu", s->kitty_keys.flags);
+		break;
+	case INPUT_CSI_KITTY_SET:
+		if (options_get_number(global_options, "extended-keys") == 0)
+			break;
+		n = input_get(ictx, 0, 0, 0);
+		m = input_get(ictx, 1, 1, 1);
+		if (n >= 0 && m >= 1 && m <= 3)
+			input_kitty_set(s, n, m);
+		break;
+	case INPUT_CSI_KITTY_PUSH:
+		if (options_get_number(global_options, "extended-keys") == 0)
+			break;
+		n = input_get(ictx, 0, 0, 0);
+		if (n >= 0)
+			input_kitty_push(s, n);
+		break;
+	case INPUT_CSI_KITTY_POP:
+		if (options_get_number(global_options, "extended-keys") == 0)
+			break;
+		n = input_get(ictx, 0, 1, 1);
+		if (n >= 0)
+			input_kitty_pop(s, n);
+		break;
 	case INPUT_CSI_WINOPS:
 		input_csi_dispatch_winops(ictx);
 		break;
--- a/key-string.c
+++ b/key-string.c
@@ -45,6 +45,29 @@ static const struct {
 	{ "F10",	KEYC_F10|KEYC_IMPLIED_META },
 	{ "F11",	KEYC_F11|KEYC_IMPLIED_META },
 	{ "F12",	KEYC_F12|KEYC_IMPLIED_META },
+	{ "F13",	KEYC_F13|KEYC_IMPLIED_META },
+	{ "F14",	KEYC_F14|KEYC_IMPLIED_META },
+	{ "F15",	KEYC_F15|KEYC_IMPLIED_META },
+	{ "F16",	KEYC_F16|KEYC_IMPLIED_META },
+	{ "F17",	KEYC_F17|KEYC_IMPLIED_META },
+	{ "F18",	KEYC_F18|KEYC_IMPLIED_META },
+	{ "F19",	KEYC_F19|KEYC_IMPLIED_META },
+	{ "F20",	KEYC_F20|KEYC_IMPLIED_META },
+	{ "F21",	KEYC_F21|KEYC_IMPLIED_META },
+	{ "F22",	KEYC_F22|KEYC_IMPLIED_META },
+	{ "F23",	KEYC_F23|KEYC_IMPLIED_META },
+	{ "F24",	KEYC_F24|KEYC_IMPLIED_META },
+	{ "F25",	KEYC_F25|KEYC_IMPLIED_META },
+	{ "F26",	KEYC_F26|KEYC_IMPLIED_META },
+	{ "F27",	KEYC_F27|KEYC_IMPLIED_META },
+	{ "F28",	KEYC_F28|KEYC_IMPLIED_META },
+	{ "F29",	KEYC_F29|KEYC_IMPLIED_META },
+	{ "F30",	KEYC_F30|KEYC_IMPLIED_META },
+	{ "F31",	KEYC_F31|KEYC_IMPLIED_META },
+	{ "F32",	KEYC_F32|KEYC_IMPLIED_META },
+	{ "F33",	KEYC_F33|KEYC_IMPLIED_META },
+	{ "F34",	KEYC_F34|KEYC_IMPLIED_META },
+	{ "F35",	KEYC_F35|KEYC_IMPLIED_META },
 	{ "IC",		KEYC_IC|KEYC_IMPLIED_META },
 	{ "Insert",	KEYC_IC|KEYC_IMPLIED_META },
 	{ "DC",		KEYC_DC|KEYC_IMPLIED_META },
@@ -122,6 +145,54 @@ static const struct {
 	{ "KPEnter",	KEYC_KP_ENTER|KEYC_KEYPAD },
 	{ "KP0",	KEYC_KP_ZERO|KEYC_KEYPAD },
 	{ "KP.",	KEYC_KP_PERIOD|KEYC_KEYPAD },
+	{ "KP=",	KEYC_KP_EQUAL|KEYC_KEYPAD },
+	{ "KP,",	KEYC_KP_SEPARATOR|KEYC_KEYPAD },
+	{ "KPLeft",	KEYC_KP_LEFT|KEYC_KEYPAD },
+	{ "KPRight",	KEYC_KP_RIGHT|KEYC_KEYPAD },
+	{ "KPUp",	KEYC_KP_UP|KEYC_KEYPAD },
+	{ "KPDown",	KEYC_KP_DOWN|KEYC_KEYPAD },
+	{ "KPPageUp",	KEYC_KP_PPAGE|KEYC_KEYPAD },
+	{ "KPPageDown",	KEYC_KP_NPAGE|KEYC_KEYPAD },
+	{ "KPHome",	KEYC_KP_HOME|KEYC_KEYPAD },
+	{ "KPEnd",	KEYC_KP_END|KEYC_KEYPAD },
+	{ "KPInsert",	KEYC_KP_IC|KEYC_KEYPAD },
+	{ "KPDelete",	KEYC_KP_DC|KEYC_KEYPAD },
+	{ "KPBegin",	KEYC_KP_BEGIN|KEYC_KEYPAD },
+
+	/* Other function keys. */
+	{ "CapsLock",	KEYC_CAPSLOCK },
+	{ "ScrollLock",	KEYC_SCROLLLOCK },
+	{ "NumLock",	KEYC_NUMLOCK },
+	{ "PrintScreen", KEYC_PRINTSCREEN },
+	{ "Pause",	KEYC_PAUSE },
+	{ "Menu",	KEYC_MENU },
+	{ "MediaPlay",	KEYC_MEDIA_PLAY },
+	{ "MediaPause", KEYC_MEDIA_PAUSE },
+	{ "MediaPlayPause", KEYC_MEDIA_PLAYPAUSE },
+	{ "MediaReverse", KEYC_MEDIA_REVERSE },
+	{ "MediaStop",	KEYC_MEDIA_STOP },
+	{ "MediaFastForward", KEYC_MEDIA_FASTFORWARD },
+	{ "MediaRewind", KEYC_MEDIA_REWIND },
+	{ "MediaNext",	KEYC_MEDIA_NEXT },
+	{ "MediaPrevious", KEYC_MEDIA_PREVIOUS },
+	{ "MediaRecord", KEYC_MEDIA_RECORD },
+	{ "VolumeDown", KEYC_VOLUME_DOWN },
+	{ "VolumeUp",	KEYC_VOLUME_UP },
+	{ "VolumeMute", KEYC_VOLUME_MUTE },
+	{ "LeftShift",	KEYC_LEFT_SHIFT },
+	{ "LeftControl", KEYC_LEFT_CTRL },
+	{ "LeftAlt",	KEYC_LEFT_ALT },
+	{ "LeftSuper",	KEYC_LEFT_SUPER },
+	{ "LeftHyper",	KEYC_LEFT_HYPER },
+	{ "LeftMeta",	KEYC_LEFT_META },
+	{ "RightShift", KEYC_RIGHT_SHIFT },
+	{ "RightControl", KEYC_RIGHT_CTRL },
+	{ "RightAlt",	KEYC_RIGHT_ALT },
+	{ "RightSuper", KEYC_RIGHT_SUPER },
+	{ "RightHyper", KEYC_RIGHT_HYPER },
+	{ "RightMeta",	KEYC_RIGHT_META },
+	{ "ISOLevel3Shift", KEYC_ISO_LEVEL3_SHIFT },
+	{ "ISOLevel5Shift", KEYC_ISO_LEVEL5_SHIFT },

 	/* Mouse keys. */
 	KEYC_MOUSE_STRING(MOUSEDOWN1, MouseDown1),
@@ -226,9 +297,14 @@ key_string_get_modifiers(const char **string)
 			modifiers |= KEYC_META;
 			break;
 		case 'S':
-		case 's':
 			modifiers |= KEYC_SHIFT;
 			break;
+		case 's':
+			modifiers |= KEYC_SUPER;
+			break;
+		case 'H':
+			modifiers |= KEYC_HYPER;
+			break;
 		default:
 			*string = NULL;
 			return (0);
@@ -349,6 +425,10 @@ key_string_lookup_key(key_code key, int with_flags)
 		strlcat(out, "M-", sizeof out);
 	if (key & KEYC_SHIFT)
 		strlcat(out, "S-", sizeof out);
+	if (key & KEYC_SUPER)
+		strlcat(out, "s-", sizeof out);
+	if (key & KEYC_HYPER)
+		strlcat(out, "H-", sizeof out);
 	key &= KEYC_MASK_KEY;

 	/* Handle no key. */
--- a/layout-custom.c
+++ b/layout-custom.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: layout-custom.c,v 1.40 2026/09/09 07:03:39 nicm Exp $ */
+/* $OpenBSD: layout-custom.c,v 1.41 2026/09/09 09:01:19 nicm Exp $ */

 /*
 * Copyright (c) 2010 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -28,8 +28,8 @@
 #include "tmux.h"

 /*
- * Layouts can be represented as strings in a JSON format (v2). The legacy
- * format (v1) will be removed in the future and should no longer be used.
+ * Layouts can be represented as strings in a JSON format (v2). The version 1
+ * format will be removed in the future and should no longer be used.
 *
 * The current (v2) format is JSON. The top level has two keys:
 *    "V": version number, currently 2
@@ -57,6 +57,9 @@
 *    "z": z-index, if a floating pane
 */

+/* Maximum nesting depth for version 1 layouts. */
+#define LAYOUT_V1_MAX_DEPTH 1000
+
 /* Layout string. */
 struct layout_string {
 	char	*dat;
@@ -362,7 +365,7 @@ layout_append_v2(struct layout_cell *lc, struct layout_string *ls)
 	return (0);
 }

-/* Append information for a single cell in the legacy (v1) format. */
+/* Append information for a single cell in the version 1 format. */
 static int
 layout_append_v1(struct layout_cell *lc, struct layout_string *ls)
 {
@@ -778,7 +781,7 @@ layout_assign(struct window *w, struct layout_parse_ctx *pctx)
 		layout_assign_fallback(w, w->layout_root);
 }

-/* Construct a cell from the legacy (v1) format. */
+/* Construct a cell from the version 1 format. */
 static struct layout_cell *
 layout_construct_cell(struct layout_cell *lcparent, const char **layout)
 {
@@ -827,12 +830,15 @@ layout_construct_cell(struct layout_cell *lcparent, const char **layout)
 	return (lc);
 }

-/* Construct a layout from the legacy (v1) format. */
+/* Construct a layout from the version 1 format. */
 static struct layout_cell *
-layout_construct_v1(struct layout_cell *lcparent, const char **layout)
+layout_construct_v1(struct layout_cell *lcparent, const char **layout, u_int depth)
 {
 	struct layout_cell	*lc, *lcchild;

+	if (depth > LAYOUT_V1_MAX_DEPTH)
+		return (NULL);
+
 	lc = layout_construct_cell(lcparent, layout);
 	if (lc == NULL)
 		return (NULL);
@@ -855,7 +861,7 @@ layout_construct_v1(struct layout_cell *lcparent, const char **layout)

 	do {
 		(*layout)++;
-		lcchild = layout_construct_v1(lc, layout);
+		lcchild = layout_construct_v1(lc, layout, depth + 1);
 		if (lcchild == NULL)
 			goto fail;
 		TAILQ_INSERT_TAIL(&lc->cells, lcchild, entry);
@@ -1068,7 +1074,8 @@ layout_construct(const char *input, struct layout_parse_ctx *pctx)
 			*pctx->cause = xstrdup("invalid layout checksum");
 			return (-1);
 		}
-		if ((pctx->root = layout_construct_v1(NULL, &input)) == NULL) {
+		pctx->root = layout_construct_v1(NULL, &input, 0);
+		if (pctx->root == NULL) {
 			*pctx->cause = xstrdup("invalid layout");
 			return (-1);
 		}
--- a/layout.c
+++ b/layout.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: layout.c,v 1.99 2026/09/09 07:03:39 nicm Exp $ */
+/* $OpenBSD: layout.c,v 1.100 2026/09/11 08:16:14 nicm Exp $ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -768,6 +768,49 @@ layout_free(struct window *w, int only_nodes)
 	layout_free_cell(w->layout_root, only_nodes);
 }

+/* Move and resize floating panes so they stay inside the window. */
+static void
+layout_clamp_floating_panes(struct window *w, u_int sx, u_int sy)
+{
+	struct window_pane	*wp;
+	struct layout_cell	*lc;
+	u_int			 pad, avail, csx, csy;
+
+	TAILQ_FOREACH(wp, &w->z_index, zentry) {
+		lc = wp->layout_cell;
+		if (lc == NULL || (~lc->flags & LAYOUT_CELL_FLOATING))
+			continue;
+		if (window_pane_get_pane_lines(wp) == PANE_LINES_NONE)
+			pad = 0;
+		else
+			pad = 1;
+
+		csx = lc->g.sx;
+		avail = (sx > 2 * pad) ? sx - 2 * pad : 0;
+		if (csx > avail)
+			csx = (avail > PANE_MINIMUM) ? avail : PANE_MINIMUM;
+		csy = lc->g.sy;
+		avail = (sy > 2 * pad) ? sy - 2 * pad : 0;
+		if (csy > avail)
+			csy = (avail > PANE_MINIMUM) ? avail : PANE_MINIMUM;
+		if (csx != lc->g.sx || csy != lc->g.sy)
+			layout_set_size(lc, csx, csy, lc->g.xoff, lc->g.yoff);
+
+		if (lc->g.xoff + lc->g.sx + pad > sx) {
+			if (lc->g.sx + 2 * pad >= sx)
+				lc->g.xoff = pad;
+			else
+				lc->g.xoff = sx - lc->g.sx - pad;
+		}
+		if (lc->g.yoff + lc->g.sy + pad > sy) {
+			if (lc->g.sy + 2 * pad >= sy)
+				lc->g.yoff = pad;
+			else
+				lc->g.yoff = sy - lc->g.sy - pad;
+		}
+	}
+}
+
 /* Resize the entire layout after window resize. */
 void
 layout_resize(struct window *w, u_int sx, u_int sy)
@@ -788,8 +831,11 @@ layout_resize(struct window *w, u_int sx, u_int sy)
 	 * out proportionately - this should leave the layout fitting the new
 	 * window size.
 	 */
-	if (lc->type == LAYOUT_WINDOWPANE && (lc->flags & LAYOUT_CELL_FLOATING))
+	if (lc->type == LAYOUT_WINDOWPANE && (lc->flags & LAYOUT_CELL_FLOATING)) {
+		layout_clamp_floating_panes(w, sx, sy);
+		layout_fix_panes(w, NULL);
 		return;
+	}
 	xchange = sx - lc->g.sx;
 	xlimit = layout_resize_check(w, lc, LAYOUT_LEFTRIGHT);
 	if (xchange < 0 && xchange < -xlimit)
@@ -819,6 +865,7 @@ layout_resize(struct window *w, u_int sx, u_int sy)

 	/* Fix cell offsets. */
 	layout_fix_offsets(w);
+	layout_clamp_floating_panes(w, sx, sy);
 	layout_fix_panes(w, NULL);
 }

--- a/options-table.c
+++ b/options-table.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: options-table.c,v 1.244 2026/09/01 12:49:49 nicm Exp $ */
+/* $OpenBSD: options-table.c,v 1.246 2026/09/11 10:17:16 nicm Exp $ */

 /*
 * Copyright (c) 2011 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -76,7 +76,8 @@ static const char *options_table_pane_border_indicators_list[] = {
 	"off", "colour", "arrows", "both", NULL
 };
 static const char *options_table_pane_border_lines_list[] = {
-	"single", "double", "heavy", "simple", "number", "spaces", "none", NULL
+	"single", "double", "heavy", "simple", "number", "spaces", "none",
+	"rounded", NULL
 };
 static const char *options_table_popup_border_lines_list[] = {
 	"single", "double", "heavy", "simple", "rounded", "padded", "none", NULL
@@ -91,7 +92,7 @@ static const char *options_table_window_size_list[] = {
 	"largest", "smallest", "manual", "latest", NULL
 };
 static const char *options_table_remain_on_exit_list[] = {
-	"off", "on", "failed", "key", NULL
+	"off", "on", "failed", "key", "failed-key", NULL
 };
 static const char *options_table_destroy_unattached_list[] = {
 	"off", "on", "keep-last", "keep-group", NULL
@@ -103,7 +104,7 @@ static const char *options_table_extended_keys_list[] = {
 	"off", "on", "always", NULL
 };
 static const char *options_table_extended_keys_format_list[] = {
-	"csi-u", "xterm", NULL
+	"csi-u", "xterm", "kitty", NULL
 };
 static const char *options_table_allow_passthrough_list[] = {
 	"off", "on", "all", NULL
@@ -1698,7 +1699,8 @@ const struct options_table_entry options_table[] = {
 	  .choices = options_table_remain_on_exit_list,
 	  .default_num = 0,
 	  .text = "Whether panes should remain ('on'), remain until a key is "
-		  "pressed ('key') or be automatically killed ('off' or "
+		  "pressed after any exit ('key') or after a failure "
+		  "('failed-key'), or be automatically killed ('off' or "
 		  "'failed') when the program inside exits."
 	},

--- a/options.c
+++ b/options.c
@@ -1400,6 +1400,12 @@ options_push_changes(const char *name)
 		TAILQ_FOREACH(loop, &clients, entry)
 			server_client_set_key_table(loop, NULL);
 	}
+	if (strcmp(name, "extended-keys") == 0) {
+		TAILQ_FOREACH(loop, &clients, entry) {
+			if (loop->tty.flags & TTY_STARTED)
+				tty_update_features(&loop->tty);
+		}
+	}
 	if (strcmp(name, "user-keys") == 0) {
 		TAILQ_FOREACH(loop, &clients, entry) {
 			if (loop->tty.flags & TTY_OPENED)
--- a/regress/control-client-sanity.sh
+++ b/regress/control-client-sanity.sh
@@ -30,8 +30,11 @@ killw
 EOF
 sleep 1
 $TMUX has || exit 1
-$TMUX lsp -aF '#{pane_id} #{window_layout}' >$TMP || exit 1
-cat <<EOF|cmp -s $TMP - || exit 1
+# Use a control client to request legacy layouts, keeping only pane lines
+# from the control protocol output.
+$TMUX -C lsp -aF '#{pane_id} #{window_layout}' |
+	grep '^%[0-9]' >$TMP || exit 1
+cat <<EOF|cmp $TMP - || exit 1
 %0 f5ab,200x200,0,0[200x50,0,0,0,200x149,0,51,3]
 %3 f5ab,200x200,0,0[200x50,0,0,0,200x149,0,51,3]
 %2 dcbd,200x200,0,0[200x100,0,0,2,200x99,0,101,4]
--- a/regress/floating-pane-geometry.sh
+++ b/regress/floating-pane-geometry.sh
@@ -268,5 +268,149 @@ $TMUX kill-pane -t "$floating" || exit 1
 $TMUX kill-pane -t "$right" || exit 1
 $TMUX kill-pane -t "$lower" || exit 1

+# --- Floating panes clamped when the window shrinks (issue #5581, PR #5582) ---
+#
+# layout_resize clamps floating panes back inside the window when it shrinks:
+# move them and, only if they cannot fit, shrink them (never below
+# PANE_MINIMUM). A floating cell is the pane's content, so with the default
+# single-line border the clamp counts 1 cell of border per side, exactly as
+# layout_floating_args_parse does on creation; with no border it counts 0.
+# Each case below gets its own window, since resize-window fixes a window at
+# a manual size for the rest of its life.
+
+# Case 1: a lone floating pane -- break-pane -W on a window's only pane --
+# takes the early-return path in layout_resize, added during PR #5582's
+# review round, since there is no tiled tree to walk.
+win=$($TMUX new-window -dPF '#{window_id}') ||
+	fail "new-window for lone float failed"
+
+# -x 20 -y 6 -> pane 18x4; -X 60 -Y 18 -> pane_left 61, pane_top 19: with the
+# border, the footprint is columns 60-79, rows 18-23, flush with the 80x24
+# window's right and bottom edges, so the float fits before it is shrunk.
+$TMUX break-pane -W -s "$win" -x 20 -y 6 -X 60 -Y 18 ||
+	fail "break-pane -W for lone float failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   61
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    19
+
+# Shrink to 40x16. The float still fits at its own size (18 <= 40-2, 4 <=
+# 16-2) so only its position moves, flush to the new right/bottom edges:
+# xoff = 40 - 18 - 1 = 21; yoff = 16 - 4 - 1 = 11.
+$TMUX resize-window -t "$win" -x 40 -y 16 ||
+	fail "resize-window (lone float) failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   21
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    11
+
+# Case 5: grow the window back. The clamp must not chase the window back
+# outward -- it only ever pulls a float in, never restores where it was.
+$TMUX resize-window -t "$win" -x 80 -y 24 ||
+	fail "resize-window grow (lone float) failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   21
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    11
+$TMUX kill-window -t "$win" || exit 1
+
+# Case 2: the same float, but with a tiled sibling surviving alongside it, so
+# the window's root cell stays tiled and layout_resize takes the normal path
+# (the clamp call after layout_fix_offsets) instead of the early return
+# above. Same geometry as case 1, so the same numbers should come out.
+win=$($TMUX new-window -dPF '#{window_id}') ||
+	fail "new-window for tiled sibling failed"
+$TMUX split-window -t "$win" 'sleep 100' ||
+	fail "split-window for tiled sibling failed"
+$TMUX break-pane -W -s "$win" -x 20 -y 6 -X 60 -Y 18 ||
+	fail "break-pane -W for tiled sibling failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   61
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    19
+
+$TMUX resize-window -t "$win" -x 40 -y 16 ||
+	fail "resize-window (tiled sibling) failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   21
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    11
+$TMUX kill-window -t "$win" || exit 1
+
+# Case 3: new-pane float, the original repro from issue #5581 and the PR
+# body -- also the normal path, via the tiled base pane new-window creates.
+win=$($TMUX new-window -dPF '#{window_id}') ||
+	fail "new-window for new-pane repro failed"
+$TMUX resize-window -t "$win" -x 120 -y 40 ||
+	fail "resize-window to 120x40 failed"
+
+# -x 30 -y 10 -> pane 28x8; -X 85 -Y 25 -> pane_left 86, pane_top 26.
+floating=$($TMUX new-pane -t "$win" -dPF '#{pane_id}' \
+	-x 30 -y 10 -X 85 -Y 25 'sleep 100') ||
+	fail "new-pane for new-pane repro failed"
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_width}')"  28
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_height}')" 8
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_left}')"   86
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_top}')"    26
+
+# Shrink to 60x20: xoff = 60 - 28 - 1 = 31; yoff = 20 - 8 - 1 = 11.
+$TMUX resize-window -t "$win" -x 60 -y 20 ||
+	fail "resize-window (new-pane repro) failed"
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_width}')"  28
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_height}')" 8
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_left}')"   31
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_top}')"    11
+$TMUX kill-window -t "$win" || exit 1
+
+# Case 4: a float that already fits inside the shrunk window is left alone --
+# assert position and size are both unchanged, not just one of them.
+win=$($TMUX new-window -dPF '#{window_id}') ||
+	fail "new-window for untouched float failed"
+
+# -x 20 -y 6 -> pane 18x4; -X 8 -Y 3 -> pane_left 9, pane_top 4 (as at the top
+# of this file). Footprint columns 8-27, rows 3-8: well inside 60x20 too.
+floating=$($TMUX new-pane -t "$win" -dPF '#{pane_id}' \
+	-x 20 -y 6 -X 8 -Y 3 'sleep 100') ||
+	fail "new-pane for untouched float failed"
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_left}')"   9
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_top}')"    4
+
+$TMUX resize-window -t "$win" -x 60 -y 20 ||
+	fail "resize-window (untouched float) failed"
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_left}')"   9
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_top}')"    4
+$TMUX kill-window -t "$win" || exit 1
+
+# Case 6: pad = 0, via the pane-border-lines window option set to none. The
+# border arithmetic differs here (no -2/+1 adjustment either on creation or
+# in the clamp).
+win=$($TMUX new-window -dPF '#{window_id}') ||
+	fail "new-window for pad=0 float failed"
+$TMUX set-option -w -t "$win" pane-border-lines none ||
+	fail "set pane-border-lines none failed"
+
+# No border: -x 20 -y 6 -> pane 20x6 directly; -X 60 -Y 18 -> pane_left 60,
+# pane_top 18 directly. Footprint (== content, no border) is columns 60-79,
+# rows 18-23: flush right/bottom of the 80x24 window, same as case 1.
+$TMUX break-pane -W -s "$win" -x 20 -y 6 -X 60 -Y 18 ||
+	fail "break-pane -W for pad=0 float failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  20
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 6
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   60
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    18
+
+# Shrink to 40x16 with pad=0: xoff = 40 - 20 - 0 = 20; yoff = 16 - 6 - 0 = 10.
+$TMUX resize-window -t "$win" -x 40 -y 16 ||
+	fail "resize-window (pad=0 float) failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  20
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 6
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   20
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    10
+$TMUX kill-window -t "$win" || exit 1
+
 $TMUX kill-server 2>/dev/null
 exit 0
--- a/regress/kitty-keys-clients.sh
+++ b/regress/kitty-keys-clients.sh
@@ -0,0 +1,146 @@
+#!/bin/sh
+
+# Test per-client keyboard protocol detection and pane-side encoding.
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+KCONF=$(mktemp)
+LCONF=$(mktemp)
+OUT=$(mktemp)
+TMP=$(mktemp)
+SOCKETS="testKmc$$ testKka$$ testKua$$ testKrt$$ testKru$$ testKlq$$ testKlu$$"
+
+printf '%s\n' 'set -g extended-keys on' >"$KCONF"
+printf '%s\n' 'set -g extended-keys off' >"$LCONF"
+
+cleanup()
+{
+	rm -f "$KCONF" "$LCONF" "$OUT" "$TMP"
+	for socket in $SOCKETS; do
+		$TEST_TMUX -L"$socket" kill-server 2>/dev/null
+	done
+}
+trap cleanup 0 1 15
+
+wait_for_mode()
+{
+	tmux=$1
+	wanted=$2
+	i=0
+	while [ "$($tmux display-message -pt: '#{pane_key_mode}')" != "$wanted" ] &&
+	    [ "$i" -lt 50 ]; do
+		sleep 0.1
+		i=$((i + 1))
+	done
+	[ "$($tmux display-message -pt: '#{pane_key_mode}')" = "$wanted" ]
+}
+
+wait_for_output()
+{
+	i=0
+	while [ ! -s "$1" ] && [ "$i" -lt 50 ]; do
+		sleep 0.1
+		i=$((i + 1))
+	done
+	[ -s "$1" ]
+}
+
+client_mode()
+{
+	tmux=$1
+	session=$2
+
+	if [ -z "$session" ]; then
+		$tmux list-clients -F '#{client_key_mode}'
+	else
+		$tmux list-clients -F '#{client_session}:#{client_key_mode}' |
+		    sed -n "s/^$session://p"
+	fi
+}
+
+wait_for_client_mode()
+{
+	tmux=$1
+	session=$2
+	wanted=$3
+	i=0
+	while [ "$(client_mode "$tmux" "$session")" != "$wanted" ] &&
+	    [ "$i" -lt 50 ]; do
+		sleep 0.1
+		i=$((i + 1))
+	done
+	[ "$(client_mode "$tmux" "$session")" = "$wanted" ]
+}
+
+# Each client must be negotiated independently. A tmux with extended-keys off
+# stands in for a terminal without Kitty keys, since it does not answer the
+# query.
+M="$TEST_TMUX -LtestKmc$$ -f$KCONF"
+KA="$TEST_TMUX -LtestKka$$ -f$KCONF"
+UA="$TEST_TMUX -LtestKua$$ -f$LCONF"
+$M new-session -d -x80 -y24 -s kitty || exit 1
+$M new-session -d -x80 -y24 -s csiu || exit 1
+$KA new-session -d -x80 -y24 "$M attach-session -t kitty" || exit 1
+$UA new-session -d -x80 -y24 "$M attach-session -t csiu" || exit 1
+wait_for_mode "$KA" 'Kitty 1' || exit 1
+
+# Each client must report the protocol its own terminal negotiated.
+wait_for_client_mode "$M" kitty 'Kitty 1' || exit 1
+wait_for_client_mode "$M" csiu 'Ext' || exit 1
+
+uc=$($M list-clients -F '#{client_name} #{client_session}' |
+    awk '$2 == "csiu" { print $1 }')
+[ -n "$uc" ] || exit 1
+$M command-prompt -t"$uc" -k 'display-message -pl "%%"' >"$TMP" &
+pid=$!
+sleep 0.2
+$UA send-keys Escape '[97;5u'
+wait "$pid"
+[ "$(tr -d '[:space:]' <"$TMP")" = 'C-a' ] || exit 1
+
+# A Kitty-capable terminal must still be reported when it is not in use.
+$M set-option -g extended-keys off
+wait_for_client_mode "$M" kitty 'VT10x (Kitty)' || exit 1
+wait_for_client_mode "$M" csiu 'VT10x' || exit 1
+$M set-option -g extended-keys on
+wait_for_client_mode "$M" kitty 'Kitty 1' || exit 1
+
+$KA kill-server 2>/dev/null
+$UA kill-server 2>/dev/null
+$M kill-server 2>/dev/null
+
+# Standard extended input must be translated for a Kitty-requesting pane.
+: >"$OUT"
+R="$TEST_TMUX -LtestKrt$$ -f$KCONF"
+RU="$TEST_TMUX -LtestKru$$ -f$LCONF"
+$R new-session -d -x80 -y24 \
+    "stty raw -echo; printf '\033[>1u'; dd bs=1 count=7 2>/dev/null | od -An -v -t x1 >'$OUT'; sleep 5" || exit 1
+$RU new-session -d -x80 -y24 "$R attach-session" || exit 1
+wait_for_client_mode "$R" '' 'Ext' || exit 1
+$RU send-keys C-a
+wait_for_output "$OUT" || exit 1
+[ "$(tr -d ' \n' <"$OUT")" = '1b5b39373b3575' ] || exit 1
+$RU kill-server 2>/dev/null
+$R kill-server 2>/dev/null
+
+# An application is told the Kitty flags it asked for even when a client that
+# only supports VT10x is attached, and keys from that client are encoded as it
+# asked.
+: >"$OUT"
+: >"$TMP"
+printf '%s\n' "set -as terminal-overrides ',*:Eneks@:Dseks@'" >>"$KCONF"
+LQ="$TEST_TMUX -LtestKlq$$ -f$KCONF"
+LU="$TEST_TMUX -LtestKlu$$ -f$LCONF"
+$LQ new-session -d -x80 -y24 \
+    "stty raw -echo; sleep 2; printf '\033[>1u\033[?u'; dd bs=1 count=5 2>/dev/null | od -An -v -t x1 >'$OUT'; dd bs=1 count=7 2>/dev/null | od -An -v -t x1 >'$TMP'; sleep 5" || exit 1
+$LU new-session -d -x80 -y24 "$LQ attach-session" || exit 1
+wait_for_output "$OUT" || exit 1
+[ "$(tr -d ' \n' <"$OUT")" = '1b5b3f3175' ] || exit 1
+wait_for_client_mode "$LQ" '' 'VT10x' || exit 1
+$LU send-keys C-a
+wait_for_output "$TMP" || exit 1
+[ "$(tr -d ' \n' <"$TMP")" = '1b5b39373b3575' ] || exit 1
+
+exit 0
--- a/regress/kitty-keys-input.sh
+++ b/regress/kitty-keys-input.sh
@@ -0,0 +1,116 @@
+#!/bin/sh
+
+# Test client-side Kitty keyboard protocol support: an outer tmux acts as a
+# Kitty-capable terminal for the inner tmux which is the one under test. The
+# inner tmux queries the outer one, the outer one replies, and the inner one
+# then parses the key sequences sent to it.
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+CONF=$(mktemp)
+TMP=$(mktemp)
+
+printf '%s\n' 'set -g extended-keys on' >"$CONF"
+
+TMUX="$TEST_TMUX -LtestKIA$$ -f$CONF"
+TMUX2="$TEST_TMUX -LtestKIB$$ -f$CONF"
+
+trap 'rm -f "$CONF" "$TMP"; $TMUX kill-server 2>/dev/null; \
+    $TMUX2 kill-server 2>/dev/null' 0 1 15
+
+$TMUX2 new-session -d -x80 -y24 || exit 1
+$TMUX new-session -d -x80 -y24 "$TMUX2 attach" || exit 1
+
+exit_status=0
+
+wait_for_mode()
+{
+	i=0
+	while [ "$($TMUX display-message -pt: '#{pane_key_mode}')" != "$1" ] &&
+	    [ "$i" -lt 50 ]; do
+		sleep 0.1
+		i=$((i + 1))
+	done
+	[ "$($TMUX display-message -pt: '#{pane_key_mode}')" = "$1" ]
+}
+
+assert_key()
+{
+	keys=$1
+	expected=$2
+
+	$TMUX2 command-prompt -k 'display-message -pl "%%"' >"$TMP" &
+	sleep 0.15
+	# Send raw bytes so the outer tmux does not encode them itself.
+	raw=$(printf '%s' "$keys" | sed -e 's/Escape /\\033/g' -e 's/ //g')
+	$TMUX send-keys -H $(printf "$raw" | od -An -v -t x1)
+	wait
+
+	actual=$(tr -d '[:space:]' <"$TMP")
+	if [ "$actual" = "$expected" ]; then
+		[ -n "$VERBOSE" ] && echo "[PASS] $keys -> $actual"
+	else
+		echo "[FAIL] $keys -> $expected (got '$actual')"
+		exit_status=1
+	fi
+}
+
+# The inner tmux must detect the outer one and push its flags.
+if ! wait_for_mode 'Kitty 1'; then
+	echo "[FAIL] inner tmux did not enable the Kitty protocol"
+	exit 1
+fi
+
+# Modifiers, including the Kitty-only Super and Hyper.
+assert_key 'Escape [97;2u' 'S-a'
+assert_key 'Escape [97;3u' 'M-a'
+assert_key 'Escape [97;5u' 'C-a'
+assert_key 'Escape [97;6u' 'C-S-a'
+assert_key 'Escape [97;7u' 'C-M-a'
+assert_key 'Escape [97;9u' 's-a'
+assert_key 'Escape [97;17u' 'H-a'
+assert_key 'Escape [65;2u' 'S-A'
+
+# Keys with a dedicated tmux key code.
+assert_key 'Escape [9;5u' 'C-Tab'
+assert_key 'Escape [9;2u' 'BTab'
+assert_key 'Escape [13;5u' 'C-Enter'
+assert_key 'Escape [27u' 'Escape'
+assert_key 'Escape [32;5u' 'C-Space'
+assert_key 'Escape [127;5u' 'C-BSpace'
+
+# Keys with a CSI final byte other than u.
+assert_key 'Escape [1;5A' 'C-Up'
+assert_key 'Escape [1;3D' 'M-Left'
+assert_key 'Escape [1;5H' 'C-Home'
+assert_key 'Escape [1;5P' 'C-F1'
+
+# Functional and non-ASCII keys.
+assert_key 'Escape [57399;5u' 'C-KP0'
+assert_key 'Escape [233;5u' 'C-é'
+
+# The alternate key and associated text fields are not requested but must be
+# ignored if a terminal sends them anyway.
+assert_key 'Escape [97:65;2u' 'S-a'
+assert_key 'Escape [97:65:97;5u' 'C-a'
+assert_key 'Escape [97;5;97u' 'C-a'
+
+# A repeat event is a key press, a release event is dropped. The C-b that
+# follows shows that the sequence was consumed and not passed through.
+assert_key 'Escape [97;5:1u' 'C-a'
+assert_key 'Escape [97;5:2u' 'C-a'
+assert_key 'Escape [97;5:3u Escape [98;5u' 'C-b'
+
+# The Meta modifier bit is not representable and is dropped.
+assert_key 'Escape [97;33u Escape [98;5u' 'C-b'
+
+# Lock modifiers are ignored rather than dropping the key.
+assert_key 'Escape [97;65u' 'a'
+assert_key 'Escape [97;129u' 'a'
+
+$TMUX kill-server 2>/dev/null
+$TMUX2 kill-server 2>/dev/null
+
+exit $exit_status
--- a/regress/kitty-keys-terminal.sh
+++ b/regress/kitty-keys-terminal.sh
@@ -0,0 +1,85 @@
+#!/bin/sh
+
+# Test the Kitty keyboard protocol against a real terminal rather than against
+# another copy of tmux. This drives kitty through its remote control interface
+# so that kitty itself encodes the key presses.
+#
+# This has to be run by hand from this directory. The Makefile runs tests with
+# env -i, which removes DISPLAY and HOME, so kitty cannot start and this exits
+# immediately without testing anything. It is also skipped unless kitty is
+# installed and is new enough to have send-key.
+
+PATH=/bin:/usr/bin
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+
+command -v kitty >/dev/null 2>&1 || exit 0
+[ -n "$DISPLAY" ] || [ -n "$WAYLAND_DISPLAY" ] || exit 0
+kitty @ --help 2>/dev/null | grep -q 'send-key' || exit 0
+
+DIR=$(mktemp -d)
+CONF=$DIR/conf
+SOCKET=$DIR/kitty
+OUT=$DIR/out
+TMUX="$TEST_TMUX -LtestKrt$$ -f$CONF"
+
+printf '%s\n' 'set -g extended-keys on' \
+    'set -g extended-keys-format kitty' >"$CONF"
+
+cleanup()
+{
+	$TMUX kill-server 2>/dev/null
+	rm -rf "$DIR"
+}
+trap cleanup 0 1 15
+
+kitty -o allow_remote_control=yes --listen-on "unix:$SOCKET" \
+    -o confirm_os_window_close=0 -e \
+    $TMUX new-session -s r "sleep 120" >"$DIR/err" 2>&1 &
+
+# The terminfo entry for kitty may be missing, so treat a server which never
+# appears as a reason to skip rather than as a failure.
+i=0
+while ! $TMUX has-session -t r 2>/dev/null && [ "$i" -lt 150 ]; do
+	sleep 0.1
+	i=$((i + 1))
+done
+$TMUX has-session -t r 2>/dev/null || exit 0
+
+# The client must negotiate the protocol with the real terminal.
+i=0
+while [ "$($TMUX list-clients -F '#{client_key_mode}')" != 'Kitty 1' ] &&
+    [ "$i" -lt 100 ]; do
+	sleep 0.1
+	i=$((i + 1))
+done
+[ "$($TMUX list-clients -F '#{client_key_mode}')" = 'Kitty 1' ] || exit 1
+
+# kitty encodes the key, tmux parses it and encodes it again for the pane.
+try_key()
+{
+	key=$1
+	expected=$2
+
+	: >"$OUT"
+	$TMUX respawn-pane -k -t r: \
+	    "stty raw -echo; printf '\033[>1u'; dd bs=1 count=7 2>/dev/null | od -An -v -t x1 >'$OUT'; sleep 20" || return 1
+	sleep 1
+	kitty @ --to "unix:$SOCKET" send-key "$key" 2>/dev/null || return 1
+	i=0
+	while [ ! -s "$OUT" ] && [ "$i" -lt 50 ]; do
+		sleep 0.1
+		i=$((i + 1))
+	done
+	[ "$(tr -d ' \n' <"$OUT")" = "$expected" ]
+}
+
+try_key ctrl+a '1b5b39373b3575' || exit 1
+try_key alt+a '1b5b39373b3375' || exit 1
+try_key ctrl+shift+a '1b5b39373b3675' || exit 1
+
+# Super cannot be represented by the standard extended keys at all, so this
+# only succeeds if the whole chain used the Kitty protocol.
+try_key super+a '1b5b39373b3975' || exit 1
+
+exit 0
--- a/regress/kitty-keys.sh
+++ b/regress/kitty-keys.sh
@@ -0,0 +1,108 @@
+#!/bin/sh
+
+# Test pane-side Kitty keyboard protocol state and key encoding. This uses
+# synthetic protocol sequences and does not require a particular terminal.
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+CONF=$(mktemp)
+OUT=$(mktemp)
+TMUX="$TEST_TMUX -LtestK$$ -f$CONF"
+
+trap 'rm -f "$CONF" "$OUT"; $TMUX kill-server 2>/dev/null' 0 1 15
+
+printf '%s\n' 'set -g extended-keys on' >"$CONF"
+
+wait_for_output()
+{
+	i=0
+	while [ ! -s "$OUT" ] && [ "$i" -lt 50 ]; do
+		sleep 0.1
+		i=$((i + 1))
+	done
+	[ -s "$OUT" ]
+}
+
+wait_for_mode()
+{
+	wanted=$1
+	i=0
+	while [ "$($TMUX display-message -pt: '#{pane_key_mode}')" != "$wanted" ] &&
+	    [ "$i" -lt 50 ]; do
+		sleep 0.1
+		i=$((i + 1))
+	done
+	[ "$($TMUX display-message -pt: '#{pane_key_mode}')" = "$wanted" ]
+}
+
+check_output()
+{
+	expected=$1
+	actual=$(tr -d ' \n' <"$OUT")
+	if [ "$actual" != "$expected" ]; then
+		echo "expected $expected, got $actual"
+		exit 1
+	fi
+}
+
+$TMUX new-session -d -x80 -y24 \
+    "stty raw -echo; printf '\033[>1u'; dd bs=1 count=7 2>/dev/null | od -An -v -t x1 >'$OUT'; sleep 5" || exit 1
+wait_for_mode 'Kitty 1'
+$TMUX send-keys -t: C-S-a
+wait_for_output
+check_output 1b5b39373b3675
+
+: >"$OUT"
+$TMUX respawn-pane -k -t: \
+    "stty raw -echo; printf '\033[>1u'; dd bs=1 count=7 2>/dev/null | od -An -v -t x1 >'$OUT'; sleep 5"
+wait_for_mode 'Kitty 1'
+$TMUX send-keys -t: s-a
+wait_for_output
+check_output 1b5b39373b3975
+
+: >"$OUT"
+$TMUX respawn-pane -k -t: \
+    "stty raw -echo; printf '\033[>8u'; dd bs=1 count=5 2>/dev/null | od -An -v -t x1 >'$OUT'; sleep 5"
+wait_for_mode 'Kitty 8'
+$TMUX send-keys -t: a
+wait_for_output
+check_output 1b5b393775
+
+: >"$OUT"
+$TMUX respawn-pane -k -t: \
+    "stty raw -echo; printf '\033[>1u\033[?u'; dd bs=1 count=5 2>/dev/null | od -An -v -t x1 >'$OUT'; sleep 5"
+wait_for_output
+check_output 1b5b3f3175
+
+: >"$OUT"
+$TMUX respawn-pane -k -t: \
+    "stty raw -echo; printf '\033[>4;2m\033[?u'; dd bs=1 count=5 2>/dev/null | od -An -v -t x1 >'$OUT'; sleep 5"
+wait_for_output
+check_output 1b5b3f3075
+
+: >"$OUT"
+$TMUX respawn-pane -k -t: \
+    "stty raw -echo; printf '\033[>1u\033[>8u\033[<u\033[?u\033[>8u\033[<2u\033[?u'; dd bs=1 count=10 2>/dev/null | od -An -v -t x1 >'$OUT'; sleep 5"
+wait_for_output
+check_output 1b5b3f31751b5b3f3075
+
+: >"$OUT"
+# "always" forces modifyOtherKeys mode 1, not Kitty keys.
+$TMUX set-option -g extended-keys always
+$TMUX respawn-pane -k -t: \
+    "stty raw -echo; printf '\033[>0u\033[?u'; dd bs=1 count=5 2>/dev/null | od -An -v -t x1 >'$OUT'; sleep 5"
+wait_for_output
+check_output 1b5b3f3075
+wait_for_mode 'Ext 1'
+$TMUX set-option -g extended-keys on
+
+: >"$OUT"
+$TMUX respawn-pane -k -t: \
+    "stty raw -echo; printf '\033[>1u\033[?u\033[?1049h\033[?u\033[>8u\033[?u\033[?1049l\033[?u'; dd bs=1 count=20 2>/dev/null | od -An -v -t x1 >'$OUT'; sleep 5"
+wait_for_output
+check_output 1b5b3f31751b5b3f30751b5b3f38751b5b3f3175
+
+$TMUX kill-server 2>/dev/null
+exit 0
--- a/regress/modal-pane.sh
+++ b/regress/modal-pane.sh
@@ -337,9 +337,9 @@ $TMUX set -g @modal-prefix no
 $TMUX set -g @modal-root no
 $TMUX bind -n z set -g @modal-root yes

-modal=$($TMUX new-pane -OKPF '#{pane_id}' -t "$p0" \
+modal=$($TMUX new-pane -ODKPF '#{pane_id}' -t "$p0" \
    -x 20 -y 5 -X 20 -Y 10 'cat') ||
-	fail "new-pane -OK failed"
+	fail "new-pane -ODK failed"
 sleep 1
 $TMUX2 send-keys -t "$OUTER" C-b x z Enter
 sleep 1
@@ -356,9 +356,50 @@ new_left=$(fmt "$modal" '#{pane_left}')
 new_top=$(fmt "$modal" '#{pane_top}')
 [ "$new_left" -gt "$left" ] || [ "$new_top" -gt "$top" ] ||
 	fail "key-capturing modal pane did not move"
+$TMUX2 send-keys -t "$OUTER" Escape
+sleep 1
+must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''
+
+modal=$($TMUX new-pane -ODKPF '#{pane_id}' -t "$p0" \
+    -x 20 -y 5 -X 20 -Y 10 'trap "" INT; exec cat') ||
+	fail "new-pane -ODK failed"
+sleep 1
+$TMUX2 send-keys -t "$OUTER" C-c
+sleep 1
+must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''
+
+# A dead modal does not close on Escape or C-c without -D.
+modal=$($TMUX new-pane -OPF '#{pane_id}' -t "$p0" \
+    -x 20 -y 5 -X 20 -Y 10 'sleep 1') ||
+	fail "new-pane -O failed"
+check_ok set-option -p -t "$modal" remain-on-exit on
+sleep 2
+must_equal "$(fmt "$modal" '#{pane_dead}:#{pane_modal_flag}')" 1:1
+$TMUX2 send-keys -t "$OUTER" Escape
+sleep 1
+must_equal "$(fmt modal:0 '#{window_modal_pane}')" "$modal"
 check_ok kill-pane -t "$modal"
 sleep 1

+# failed-key closes successful panes and retains failed panes until a key.
+modal=$($TMUX new-pane -OPF '#{pane_id}' -t "$p0" \
+    -x 20 -y 5 -X 20 -Y 10 'sleep 1') ||
+	fail "new-pane -O failed"
+check_ok set-option -p -t "$modal" remain-on-exit failed-key
+sleep 2
+must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''
+
+modal=$($TMUX new-pane -OPF '#{pane_id}' -t "$p0" \
+    -x 20 -y 5 -X 20 -Y 10 'sleep 1; exit 1') ||
+	fail "new-pane -O failed"
+check_ok set-option -p -t "$modal" remain-on-exit failed-key
+sleep 2
+must_equal "$(fmt "$modal" '#{pane_dead}:#{pane_modal_flag}')" 1:1
+must_equal "$($TMUX show-options -pv -t "$modal" remain-on-exit)" failed-key
+$TMUX2 send-keys -t "$OUTER" a
+sleep 1
+must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''
+
 # A nonmodal floating pane may remain above zoom, and switching between it and
 # the zoomed tiled pane must not unzoom the window.
 check_ok new-window -d -t modal: -n float-over-zoom 'cat'
--- a/regress/options-values.sh
+++ b/regress/options-values.sh
@@ -86,6 +86,11 @@ check_value "-gv status-keys" "vi"
 check_fail "unknown value: bogus" set -g status-keys bogus
 check_value "-gv status-keys" "vi"

+# pane-border-lines accepts rounded as a pane border style.
+check_ok set -gw pane-border-lines rounded
+check_value "-gwv pane-border-lines" "rounded"
+check_ok set -gw pane-border-lines single
+
 # --- flag options ---------------------------------------------------------
 #
 # focus-events is an on/off flag.  Setting with no value toggles it; explicit
--- a/regress/pane-ops.sh
+++ b/regress/pane-ops.sh
@@ -104,6 +104,25 @@ assert_alive()
 	fi
 }

+# Compare layout geometry and pane ordering, ignoring the active pane and
+# last-pane history in the JSON layout. Selection is checked separately.
+pane_layout()
+{
+	$TMUX display-message -p -t "$1" '#{window_layout}' |
+		sed 's/,"a":true//g; s/,"l":[0-9][0-9]*//g'
+}
+
+check_layout()
+{
+	out=$(pane_layout "$1")
+	if [ "$out" != "$2" ]; then
+		echo "Layout for '$1' wrong."
+		echo "Expected: '$2'"
+		echo "But got:  '$out'"
+		exit 1
+	fi
+}
+
 # ---------------------------------------------------------------------------
 # split-window geometry.

@@ -309,12 +328,12 @@ check_ok kill-pane -t "$p6"

 # Zoom and unzoom preserve the exact tiled layout. Selecting another pane
 # without -Z unzooms, while -Z transfers zoom to the selected pane.
-layout=$($TMUX display-message -p -t P:0 '#{window_layout}')
+layout=$(pane_layout P:0)
 check_ok select-pane -t "$p0"
 check_ok resize-pane -Z -t "$p0"
 check_ok select-pane -t "$p2"
 check_fmt "$p2" '#{window_zoomed_flag}:#{pane_active}' '0:1'
-check_fmt P:0 '#{window_layout}' "$layout"
+check_layout P:0 "$layout"

 check_ok select-pane -t "$p0"
 check_ok resize-pane -Z -t "$p0"
@@ -322,7 +341,7 @@ check_ok select-pane -Z -t "$p2"
 check_fmt "$p2" '#{window_zoomed_flag}:#{pane_zoomed_flag}:#{pane_active}' \
 	'1:1:1'
 check_ok resize-pane -Z -t "$p2"
-check_fmt P:0 '#{window_layout}' "$layout"
+check_layout P:0 "$layout"

 # Directional selection temporarily restores the full layout to find its
 # neighbour, then follows the same unzoom or -Z transfer rules.
@@ -340,7 +359,7 @@ check_ok select-pane -D -Z -t "$p0"
 check_fmt "$p2" '#{window_zoomed_flag}:#{pane_zoomed_flag}:#{pane_active}' \
 	'1:1:1'
 check_ok resize-pane -Z -t "$p2"
-check_fmt P:0 '#{window_layout}' "$layout"
+check_layout P:0 "$layout"

 # The last-pane path has separate zoom handling, both with and without -Z.
 check_ok select-pane -t "$p0"
@@ -357,7 +376,7 @@ check_ok select-pane -l -Z -t P:0
 check_fmt "$p0" '#{window_zoomed_flag}:#{pane_zoomed_flag}:#{pane_active}' \
 	'1:1:1'
 check_ok resize-pane -Z -t "$p0"
-check_fmt P:0 '#{window_layout}' "$layout"
+check_layout P:0 "$layout"

 # Killing either a hidden ordinary pane or the zoom target unzooms.
 check_ok new-window -d -t P:12 -n zoom-kill 'cat'
--- a/regress/screen-redraw-floating.sh
+++ b/regress/screen-redraw-floating.sh
@@ -107,6 +107,12 @@ $TMUX2 new-pane -x28 -y8 -X4 -Y1 -B double \
 	"sh -c 'printf FLOAT; exec sleep 100'" || exit 1
 compare floating-border-double

+# Larger floating pane with rounded border lines.
+new_scene 40 12
+$TMUX2 new-pane -x28 -y8 -X4 -Y1 -B rounded \
+	"sh -c 'printf FLOAT; exec sleep 100'" || exit 1
+compare floating-border-rounded
+
 # Floating pane with no border lines: redraw_mark_pane_borders returns early so
 # the float has no border at all, only its (clipped) content over the base pane.
 new_scene 40 12
--- a/regress/screen-redraw-results/floating-border-rounded.result
+++ b/regress/screen-redraw-results/floating-border-rounded.result
@@ -0,0 +1,12 @@
+base
+    ╭──────────────────────────╮
+    │FLOAT                     │
+    │                          │
+    │                          │
+    │                          │
+    │                          │
+    │                          │
+    ╰──────────────────────────╯
+
+
+
--- a/screen-write.c
+++ b/screen-write.c
@@ -439,6 +439,7 @@ screen_write_reset(struct screen_write_ctx *ctx)

 	if (options_get_number(global_options, "extended-keys") == 2)
 		s->mode = (s->mode & ~EXTENDED_KEY_MODES)|MODE_KEYS_EXTENDED;
+	input_kitty_reset(s);

 	screen_write_clearscreen(ctx, 8);
 	screen_write_set_cursor(ctx, 0, 0);
--- a/screen.c
+++ b/screen.c
@@ -88,6 +88,8 @@ screen_init(struct screen *s, u_int sx, u_int sy, u_int hlimit)
 	s->default_cstyle = SCREEN_CURSOR_DEFAULT;
 	s->mode = MODE_CURSOR;
 	s->default_mode = 0;
+	memset(&s->kitty_keys, 0, sizeof s->kitty_keys);
+	memset(&s->saved_kitty_keys, 0, sizeof s->saved_kitty_keys);
 	s->ccolour = -1;
 	s->default_ccolour = -1;
 	s->tabs = NULL;
@@ -118,9 +120,9 @@ screen_reinit(struct screen *s, int check)

 	if (options_get_number(global_options, "extended-keys") == 2)
 		s->mode = (s->mode & ~EXTENDED_KEY_MODES)|MODE_KEYS_EXTENDED;
-
 	if (SCREEN_IS_ALTERNATE(s))
 		screen_alternate_off(s, NULL, 0);
+	input_kitty_reset(s);
 	s->saved_cx = UINT_MAX;
 	s->saved_cy = UINT_MAX;

@@ -698,6 +700,7 @@ screen_alternate_on(struct screen *s, struct grid_cell *gc, int cursor)

 	if (SCREEN_IS_ALTERNATE(s))
 		return 0;
+	input_kitty_alternate_on(s);
 	sx = screen_size_x(s);
 	sy = screen_size_y(s);

@@ -758,6 +761,7 @@ screen_alternate_off(struct screen *s, struct grid_cell *gc, int cursor)
 			s->cy = screen_size_y(s) - 1;
 		return 0;
 	}
+	input_kitty_alternate_off(s);

 	/* Restore the saved grid. */
 	grid_duplicate_lines(s->grid, screen_hsize(s), s->saved_grid, 0,
--- a/server-client.c
+++ b/server-client.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: server-client.c,v 1.511 2026/09/08 10:20:08 nicm Exp $ */
+/* $OpenBSD: server-client.c,v 1.512 2026/09/10 11:02:18 nicm Exp $ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -1391,15 +1391,19 @@ server_client_repeat_time(struct client *c, struct key_binding *bd)
 	return (repeat);
 }

-/* Handle a key press on a dead pane waiting for a key. */
+/* Handle a key press which closes a dead pane. */
 static int
 server_client_handle_dead_key(struct window_pane *wp, key_code key)
 {
+	int	remain_on_exit;
+
 	if (wp == NULL ||
 	    (~wp->flags & PANE_EXITED) ||
 	    KEYC_IS_MOUSE(key) ||
-	    KEYC_IS_PASTE(key) ||
-	    options_get_number(wp->options, "remain-on-exit") != 3)
+	    KEYC_IS_PASTE(key))
+		return (0);
+	remain_on_exit = options_get_number(wp->options, "remain-on-exit");
+	if (remain_on_exit != 3 && remain_on_exit != 4)
 		return (0);
 	options_set_number(wp->options, "remain-on-exit", 0);
 	server_destroy_pane(wp, 0);
@@ -1756,9 +1760,10 @@ server_client_handle_key0(struct client *c, struct key_event *event,
 	}

 	/*
-	 * Key presses in overlay mode, for panes capturing all keys and in the
-	 * command prompt are a special case. The queue might be blocked so they
-	 * need to be processed immediately rather than queued.
+	 * Key presses in overlay mode, dead panes waiting for a key, modal cancel
+	 * keys, panes capturing all keys and the command prompt are special cases.
+	 * The queue might be blocked so they need to be processed immediately
+	 * rather than queued.
 	 */
 	if (~c->flags & CLIENT_READONLY) {
 		if (c->message_string != NULL) {
@@ -1780,12 +1785,18 @@ server_client_handle_key0(struct client *c, struct key_event *event,
 		server_client_clear_overlay(c);

 		wp = s->curw->window->active;
+		if (server_client_handle_dead_key(wp, event->key))
+			return (0);
+		if (wp != NULL && wp == wp->window->modal &&
+		    (wp->flags & PANE_CLOSEONCANCEL) &&
+		    (event->key == '\033' || event->key == ('c'|KEYC_CTRL))) {
+			server_kill_pane(wp);
+			return (0);
+		}
 		if (wp != NULL &&
 		    (wp->flags & PANE_CAPTUREALLKEYS) &&
 		    TAILQ_EMPTY(&wp->modes) &&
 		    !KEYC_IS_MOUSE(event->key)) {
-			if (server_client_handle_dead_key(wp, event->key))
-				return (0);
 			if (~wp->flags & PANE_EXITED) {
 				window_pane_key(wp, c, s, s->curw, event->key,
 				    &event->m);
@@ -2183,6 +2194,7 @@ server_client_reset_state(struct client *c)
 		log_debug("%s: client %s mode %s", __func__, c->name,
 		    screen_mode_to_string(mode));
 	}
+	tty_update_kitty(tty, s);

 	/* Reset region and margin. */
 	tty_region_off(tty);
--- a/server-fn.c
+++ b/server-fn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: server-fn.c,v 1.152 2026/09/03 19:12:36 nicm Exp $ */
+/* $OpenBSD: server-fn.c,v 1.153 2026/09/10 11:02:18 nicm Exp $ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -386,6 +386,7 @@ server_destroy_pane(struct window_pane *wp, int notify)
 	case 0:
 		break;
 	case 2:
+	case 4:
 		if (WIFEXITED(wp->status) && WEXITSTATUS(wp->status) == 0)
 			break;
 		/* FALLTHROUGH */
--- a/tmux.1
+++ b/tmux.1
@@ -1,4 +1,4 @@
-.\" $OpenBSD: tmux.1,v 1.1168 2026/09/09 07:03:39 nicm Exp $
+.\" $OpenBSD: tmux.1,v 1.1170 2026/09/11 10:17:16 nicm Exp $
 .\"
 .\" Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
 .\"
@@ -14,7 +14,7 @@
 .\" IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 .\" OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 .\"
-.Dd $Mdocdate: September 9 2026 $
+.Dd $Mdocdate: September 11 2026 $
 .Dt TMUX 1
 .Os
 .Sh NAME
@@ -3655,7 +3655,7 @@ but a different format may be specified with
 .Fl F .
 .Tg newp
 .It Xo Ic new\-pane
-.Op Fl AbCdefhIkKLMOPvWZ
+.Op Fl AbCDefhIkKLMOPvWZ
 .Op Fl B Ar border\-lines
 .Op Fl c Ar start\-directory
 .Op Fl e Ar environment
@@ -3717,6 +3717,13 @@ all keys, including the prefix key, are passed directly to the modal pane.
 With
 .Fl C ,
 the modal pane is closed when the mouse is clicked outside it.
+With
+.Fl D ,
+the modal pane is closed when
+.Ql Escape
+or
+.Ql C-c
+is pressed.
 .Pp
 The
 .Fl L
@@ -4900,14 +4907,30 @@ If enabled, the server will exit when there are no attached clients.
 .It Xo Ic extended\-keys
 .Op Ic on | off | always
 .Xc
-Controls how modified keys (keys pressed together with Control, Meta, or Shift)
-are reported.
-This is the equivalent of the
+Controls how modified keys are reported.
+When enabled,
+.Nm
+uses the Kitty keyboard protocol with terminals which support it, and the
 .Ic modifyOtherKeys
 .Xr xterm 1
-resource.
+resource with other terminals which support extended keys.
+Each client uses the best that its terminal supports, so clients with different
+terminals may be attached at the same time.
 .Pp
-When set to
+Programs inside panes may request either the Kitty keyboard protocol or
+.Ic modifyOtherKeys ,
+and keys are sent to each program in the form it requested, whichever client
+they were typed on.
+The Kitty keyboard protocol can report the Super and Hyper modifiers, whose key
+name prefixes are
+.Ql s-
+and
+.Ql H- ;
+its disambiguate and report-all enhancements are supported.
+.Pp
+For
+.Ic modifyOtherKeys ,
+when set to
 .Ic on ,
 the program inside the pane can request one of two modes: mode 1 which changes
 the sequence for only keys which lack an existing well-known representation; or
@@ -4916,26 +4939,35 @@ When set to
 .Ic always ,
 modes 1 and 2 can still be requested by applications, but mode 1 will be forced
 instead of the standard mode.
+This applies only to applications inside panes; it does not force the Kitty
+keyboard protocol or change what
+.Nm
+requests from the terminal.
 When set to
 .Ic off ,
 this feature is disabled and only standard keys are reported.
 .Pp
 .Nm
 will always request extended keys itself if the terminal supports them.
+Support for the Kitty keyboard protocol is detected when a client attaches.
 See also the
+.Ic kittykeys
+and
 .Ic extkeys
-feature for the
+features for the
 .Ic terminal\-features
 option, the
 .Ic extended\-keys\-format
 option and the
 .Ic pane_key_mode
-variable.
+and
+.Ic client_key_mode
+variables.
 .It Xo Ic extended\-keys\-format
-.Op Ic csi\-u | xterm
+.Op Ic csi\-u | xterm | kitty
 .Xc
-Selects one of the two possible formats for reporting modified keys to
-applications.
+Selects the format for reporting modified keys to programs which request
+.Ic modifyOtherKeys .
 This is the equivalent of the
 .Ic formatOtherKeys
 .Xr xterm 1
@@ -4948,6 +4980,11 @@ and as
 .Ql \[ha][[65;6u
 when set to
 .Ic csi\-u .
+.Ic kitty
+is accepted for compatibility and is the same as
+.Ic csi\-u ;
+programs which request the Kitty keyboard protocol receive it whatever this
+option is set to.
 .It Xo Ic focus\-events
 .Op Ic on | off
 .Xc
@@ -5096,6 +5133,9 @@ Ignore function keys from
 and use the
 .Nm
 internal set only.
+.It kittykeys
+Supports the Kitty keyboard protocol.
+This is added automatically if the terminal answers the Kitty keyboard query.
 .It margins
 Supports DECSLRM margins.
 .It mouse
@@ -5973,6 +6013,8 @@ single lines using ACS or UTF\-8 characters
 double lines using UTF\-8 characters
 .It heavy
 heavy lines using UTF\-8 characters
+.It rounded
+single lines with rounded corners using UTF\-8 characters
 .It simple
 simple ASCII characters
 .It number
@@ -6328,7 +6370,7 @@ uses when the colour with that index is requested.
 The index may be from zero to 255.
 .Pp
 .It Xo Ic remain\-on\-exit
-.Op Ic on | off | failed | key
+.Op Ic on | off | failed | key | failed\-key
 .Xc
 A pane with this flag set is not destroyed when the program running in it
 exits.
@@ -6338,6 +6380,10 @@ then only when the program exit status is not zero.
 If set to
 .Ic key ,
 the pane stays open and closes when a key is pressed.
+If set to
+.Ic failed\-key ,
+the pane stays open and closes when a key is pressed only if the program exit
+status is not zero.
 The pane may be reactivated with the
 .Ic respawn\-pane
 command.
@@ -7296,6 +7342,7 @@ The following variables are available, where appropriate:
 .It Li "client_discarded" Ta "" Ta "Bytes discarded when client behind"
 .It Li "client_flags" Ta "" Ta "List of client flags"
 .It Li "client_height" Ta "" Ta "Height of client"
+.It Li "client_key_mode" Ta "" Ta "Extended key reporting mode for this client"
 .It Li "client_key_table" Ta "" Ta "Current key table"
 .It Li "client_last_session" Ta "" Ta "Name of the client's last session"
 .It Li "client_name" Ta "" Ta "Name of client"
--- a/tmux.h
+++ b/tmux.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: tmux.h,v 1.1438 2026/09/09 08:30:05 nicm Exp $ */
+/* $OpenBSD: tmux.h,v 1.1440 2026/09/11 10:17:16 nicm Exp $ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -142,6 +142,8 @@ struct winlink;
 #define VISUAL_BOTH 2

 /* Key modifier bits. */
+#define KEYC_SUPER           0x00010000000000ULL
+#define KEYC_HYPER           0x00020000000000ULL
 #define KEYC_META            0x00100000000000ULL
 #define KEYC_CTRL            0x00200000000000ULL
 #define KEYC_SHIFT           0x00400000000000ULL
@@ -374,6 +376,29 @@ enum {
 	KEYC_F10,
 	KEYC_F11,
 	KEYC_F12,
+	KEYC_F13,
+	KEYC_F14,
+	KEYC_F15,
+	KEYC_F16,
+	KEYC_F17,
+	KEYC_F18,
+	KEYC_F19,
+	KEYC_F20,
+	KEYC_F21,
+	KEYC_F22,
+	KEYC_F23,
+	KEYC_F24,
+	KEYC_F25,
+	KEYC_F26,
+	KEYC_F27,
+	KEYC_F28,
+	KEYC_F29,
+	KEYC_F30,
+	KEYC_F31,
+	KEYC_F32,
+	KEYC_F33,
+	KEYC_F34,
+	KEYC_F35,
 	KEYC_IC,
 	KEYC_DC,
 	KEYC_HOME,
@@ -405,6 +430,54 @@ enum {
 	KEYC_KP_ENTER,
 	KEYC_KP_ZERO,
 	KEYC_KP_PERIOD,
+	KEYC_KP_EQUAL,
+	KEYC_KP_SEPARATOR,
+	KEYC_KP_LEFT,
+	KEYC_KP_RIGHT,
+	KEYC_KP_UP,
+	KEYC_KP_DOWN,
+	KEYC_KP_PPAGE,
+	KEYC_KP_NPAGE,
+	KEYC_KP_HOME,
+	KEYC_KP_END,
+	KEYC_KP_IC,
+	KEYC_KP_DC,
+	KEYC_KP_BEGIN,
+
+	/* Other function keys. */
+	KEYC_CAPSLOCK,
+	KEYC_SCROLLLOCK,
+	KEYC_NUMLOCK,
+	KEYC_PRINTSCREEN,
+	KEYC_PAUSE,
+	KEYC_MENU,
+	KEYC_MEDIA_PLAY,
+	KEYC_MEDIA_PAUSE,
+	KEYC_MEDIA_PLAYPAUSE,
+	KEYC_MEDIA_REVERSE,
+	KEYC_MEDIA_STOP,
+	KEYC_MEDIA_FASTFORWARD,
+	KEYC_MEDIA_REWIND,
+	KEYC_MEDIA_NEXT,
+	KEYC_MEDIA_PREVIOUS,
+	KEYC_MEDIA_RECORD,
+	KEYC_VOLUME_DOWN,
+	KEYC_VOLUME_UP,
+	KEYC_VOLUME_MUTE,
+	KEYC_LEFT_SHIFT,
+	KEYC_LEFT_CTRL,
+	KEYC_LEFT_ALT,
+	KEYC_LEFT_SUPER,
+	KEYC_LEFT_HYPER,
+	KEYC_LEFT_META,
+	KEYC_RIGHT_SHIFT,
+	KEYC_RIGHT_CTRL,
+	KEYC_RIGHT_ALT,
+	KEYC_RIGHT_SUPER,
+	KEYC_RIGHT_HYPER,
+	KEYC_RIGHT_META,
+	KEYC_ISO_LEVEL3_SHIFT,
+	KEYC_ISO_LEVEL5_SHIFT,

 	/* Theme reporting. */
 	KEYC_REPORT_DARK_THEME,
@@ -702,6 +775,16 @@ enum tty_code_code {
 #define CURSOR_MODES (MODE_CURSOR|MODE_CURSOR_BLINKING|MODE_CURSOR_VERY_VISIBLE)
 #define EXTENDED_KEY_MODES (MODE_KEYS_EXTENDED|MODE_KEYS_EXTENDED_2)

+/* Extended key output formats. */
+#define EXTENDED_KEYS_CSI_U 0
+#define EXTENDED_KEYS_XTERM 1
+#define EXTENDED_KEYS_KITTY 2
+
+/* Supported Kitty keyboard protocol flags. */
+#define KITTY_KEY_DISAMBIGUATE 0x1
+#define KITTY_KEY_REPORT_ALL 0x8
+#define KITTY_KEY_SUPPORTED (KITTY_KEY_DISAMBIGUATE|KITTY_KEY_REPORT_ALL)
+
 /* Mouse protocol constants. */
 #define MOUSE_PARAM_MAX 0xff
 #define MOUSE_PARAM_UTF8_MAX 0x7ff
@@ -1068,6 +1151,11 @@ struct progress_bar {
 /* Virtual screen. */
 struct screen_sel;
 struct screen_titles;
+struct kitty_key_state {
+	u_int	flags;
+	u_int	saved_flags;
+	int	have_saved;
+};
 struct screen {
 	char				*title;
 	char				*path;
@@ -1089,6 +1177,8 @@ struct screen {

 	int				 mode;
 	int				 default_mode;
+	struct kitty_key_state		 kitty_keys;
+	struct kitty_key_state		 saved_kitty_keys;

 	u_int				 saved_cx;
 	u_int				 saved_cy;
@@ -1150,7 +1240,8 @@ enum pane_lines {
 	PANE_LINES_SIMPLE,
 	PANE_LINES_NUMBER,
 	PANE_LINES_SPACES,
-	PANE_LINES_NONE
+	PANE_LINES_NONE,
+	PANE_LINES_ROUNDED
 };

 /* Pane border indicator option. */
@@ -1339,6 +1430,7 @@ struct window_pane {
 #define PANE_CLOSEONCLICK 0x80000
 #define PANE_CAPTUREALLKEYS 0x100000
 #define PANE_FLOATOVERZOOM 0x200000
+#define PANE_CLOSEONCANCEL 0x400000

 	bitstr_t	*sync_dirty;
 	u_int		 sync_dirty_size;
@@ -1737,6 +1829,7 @@ struct tty_term {
 #define TERM_VT100LIKE 0x20
 #define TERM_SIXEL 0x40
 #define TERM_INVALIDMS 0x80
+#define TERM_KITTYKEYS 0x100
 	int		 flags;

 	LIST_ENTRY(tty_term) entry;
@@ -1817,9 +1910,12 @@ struct tty {
 #define TTY_WAITBG 0x4000
 #define TTY_BRACKETPASTE 0x8000
 #define TTY_HAVESYNC 0x10000
+#define TTY_HAVEKKB 0x20000
+#define TTY_KKBPUSHED 0x40000
 #define TTY_ALL_REQUEST_FLAGS \
-	(TTY_HAVEDA|TTY_HAVEDA2|TTY_HAVEXDA|TTY_HAVESYNC)
+	(TTY_HAVEDA|TTY_HAVEDA2|TTY_HAVEXDA|TTY_HAVESYNC|TTY_HAVEKKB)
 	int		 flags;
+	u_int		 kitty_keys;

 	struct tty_term	*term;

@@ -2972,6 +3068,7 @@ int	tty_open(struct tty *, char **);
 void	tty_close(struct tty *);
 void	tty_free(struct tty *);
 void	tty_update_features(struct tty *);
+void	tty_update_kitty(struct tty *, struct screen *);
 void	tty_set_selection(struct tty *, const char *, const char *, size_t);
 void	tty_write(void (*)(struct tty *, const struct tty_ctx *),
 	    struct tty_ctx *);
@@ -3453,6 +3550,20 @@ int	 input_key(struct screen *, struct bufferevent *, key_code);
 int	 input_key_get_mouse(struct screen *, struct mouse_event *, u_int,
 	     u_int, const char **, size_t *);

+/* input-kitty.c */
+void	 input_kitty_reset(struct screen *);
+void	 input_kitty_alternate_on(struct screen *);
+void	 input_kitty_alternate_off(struct screen *);
+void	 input_kitty_set(struct screen *, u_int, int);
+void	 input_kitty_push(struct screen *, u_int);
+void	 input_kitty_pop(struct screen *, u_int);
+int	 input_key_kitty(struct screen *, struct bufferevent *, key_code);
+
+/* tty-kitty.c */
+int	 tty_keys_kitty(struct tty *, const char *, size_t, size_t *,
+	     key_code *);
+int	 tty_keys_kitty_query(struct tty *, const char *, size_t, size_t *);
+
 /* colour.c */
 int	 colour_find_rgb(u_char, u_char, u_char);
 int	 colour_join_rgb(u_char, u_char, u_char);
--- a/tty-features.c
+++ b/tty-features.c
@@ -235,6 +235,13 @@ static const struct tty_feature tty_feature_sync = {
 	0
 };

+/* Terminal supports the Kitty keyboard protocol. */
+static const struct tty_feature tty_feature_kittykeys = {
+	"kittykeys",
+	NULL,
+	TERM_KITTYKEYS
+};
+
 /* Terminal supports extended keys. */
 static const char *const tty_feature_extkeys_capabilities[] = {
 	"Eneks=\\E[>4;2m",
@@ -386,6 +393,7 @@ static const struct tty_feature *const tty_features[] = {
 	&tty_feature_extkeys,
 	&tty_feature_focus,
 	&tty_feature_ignorefkeys,
+	&tty_feature_kittykeys,
 	&tty_feature_margins,
 	&tty_feature_mouse,
 	&tty_feature_osc7,
--- a/tty-keys.c
+++ b/tty-keys.c
@@ -772,6 +772,17 @@ tty_keys_next(struct tty *tty)
 		goto partial_key;
 	}

+	/* Is this a Kitty keyboard protocol response? */
+	switch (tty_keys_kitty_query(tty, buf, len, &size)) {
+	case 0:		/* yes */
+		key = KEYC_UNKNOWN;
+		goto complete_key;
+	case -1:	/* no, or not valid */
+		break;
+	case 1:		/* partial */
+		goto partial_key;
+	}
+
 	/* Is this a synchronized update mode response? */
 	switch (tty_keys_sync(tty, buf, len, &size)) {
 	case 0:		/* yes */
@@ -858,6 +869,18 @@ tty_keys_next(struct tty *tty)
 		goto partial_key;
 	}

+	/* Is this an extended key press? */
+	switch (tty_keys_kitty(tty, buf, len, &size, &key)) {
+	case 0:		/* yes */
+		goto complete_key;
+	case -1:	/* no, or not valid */
+		break;
+	case -2:	/* yes, but not representable by tmux */
+		goto discard_key;
+	case 1:		/* partial */
+		goto partial_key;
+	}
+
 	/* Is this an extended key press? */
 	switch (tty_keys_extended_key(tty, buf, len, &size, &key)) {
 	case 0:		/* yes */
@@ -1089,6 +1112,8 @@ tty_keys_extended_key(struct tty *tty, const char *buf, size_t len,
 	utf8_char	 uc;

 	*size = 0;
+	if (tty->flags & TTY_KKBPUSHED)
+		return (-1);

 	/* First two bytes are always \033[. */
 	if (buf[0] != '\033')
@@ -1527,6 +1552,8 @@ tty_keys_device_attributes(struct tty *tty, const char *buf, size_t len,
 	}
 	log_debug("%s: received primary DA %.*s", c->name, (int)*size, buf);

+	/* A DA response without a preceding keyboard response means no support. */
+	tty->flags |= TTY_HAVEKKB;
 	tty_update_features(tty);
 	tty->flags |= TTY_HAVEDA;

--- a/tty-kitty.c
+++ b/tty-kitty.c
@@ -0,0 +1,430 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2026 Michael Grant <mgrant@grant.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+
+#include <ctype.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "tmux.h"
+
+/* Detect support in the outside terminal and decode its key sequences. */
+
+struct tty_kitty_key {
+	u_int		 number;
+	key_code	 key;
+};
+
+static const struct tty_kitty_key tty_kitty_keys[] = {
+	{ 57358, KEYC_CAPSLOCK },
+	{ 57359, KEYC_SCROLLLOCK },
+	{ 57360, KEYC_NUMLOCK },
+	{ 57361, KEYC_PRINTSCREEN },
+	{ 57362, KEYC_PAUSE },
+	{ 57363, KEYC_MENU },
+	{ 57376, KEYC_F13 },
+	{ 57377, KEYC_F14 },
+	{ 57378, KEYC_F15 },
+	{ 57379, KEYC_F16 },
+	{ 57380, KEYC_F17 },
+	{ 57381, KEYC_F18 },
+	{ 57382, KEYC_F19 },
+	{ 57383, KEYC_F20 },
+	{ 57384, KEYC_F21 },
+	{ 57385, KEYC_F22 },
+	{ 57386, KEYC_F23 },
+	{ 57387, KEYC_F24 },
+	{ 57388, KEYC_F25 },
+	{ 57389, KEYC_F26 },
+	{ 57390, KEYC_F27 },
+	{ 57391, KEYC_F28 },
+	{ 57392, KEYC_F29 },
+	{ 57393, KEYC_F30 },
+	{ 57394, KEYC_F31 },
+	{ 57395, KEYC_F32 },
+	{ 57396, KEYC_F33 },
+	{ 57397, KEYC_F34 },
+	{ 57398, KEYC_F35 },
+	{ 57399, KEYC_KP_ZERO|KEYC_KEYPAD },
+	{ 57400, KEYC_KP_ONE|KEYC_KEYPAD },
+	{ 57401, KEYC_KP_TWO|KEYC_KEYPAD },
+	{ 57402, KEYC_KP_THREE|KEYC_KEYPAD },
+	{ 57403, KEYC_KP_FOUR|KEYC_KEYPAD },
+	{ 57404, KEYC_KP_FIVE|KEYC_KEYPAD },
+	{ 57405, KEYC_KP_SIX|KEYC_KEYPAD },
+	{ 57406, KEYC_KP_SEVEN|KEYC_KEYPAD },
+	{ 57407, KEYC_KP_EIGHT|KEYC_KEYPAD },
+	{ 57408, KEYC_KP_NINE|KEYC_KEYPAD },
+	{ 57409, KEYC_KP_PERIOD|KEYC_KEYPAD },
+	{ 57410, KEYC_KP_SLASH|KEYC_KEYPAD },
+	{ 57411, KEYC_KP_STAR|KEYC_KEYPAD },
+	{ 57412, KEYC_KP_MINUS|KEYC_KEYPAD },
+	{ 57413, KEYC_KP_PLUS|KEYC_KEYPAD },
+	{ 57414, KEYC_KP_ENTER|KEYC_KEYPAD },
+	{ 57415, KEYC_KP_EQUAL|KEYC_KEYPAD },
+	{ 57416, KEYC_KP_SEPARATOR|KEYC_KEYPAD },
+	{ 57417, KEYC_KP_LEFT|KEYC_KEYPAD },
+	{ 57418, KEYC_KP_RIGHT|KEYC_KEYPAD },
+	{ 57419, KEYC_KP_UP|KEYC_KEYPAD },
+	{ 57420, KEYC_KP_DOWN|KEYC_KEYPAD },
+	{ 57421, KEYC_KP_PPAGE|KEYC_KEYPAD },
+	{ 57422, KEYC_KP_NPAGE|KEYC_KEYPAD },
+	{ 57423, KEYC_KP_HOME|KEYC_KEYPAD },
+	{ 57424, KEYC_KP_END|KEYC_KEYPAD },
+	{ 57425, KEYC_KP_IC|KEYC_KEYPAD },
+	{ 57426, KEYC_KP_DC|KEYC_KEYPAD },
+	{ 57427, KEYC_KP_BEGIN|KEYC_KEYPAD },
+	{ 57428, KEYC_MEDIA_PLAY },
+	{ 57429, KEYC_MEDIA_PAUSE },
+	{ 57430, KEYC_MEDIA_PLAYPAUSE },
+	{ 57431, KEYC_MEDIA_REVERSE },
+	{ 57432, KEYC_MEDIA_STOP },
+	{ 57433, KEYC_MEDIA_FASTFORWARD },
+	{ 57434, KEYC_MEDIA_REWIND },
+	{ 57435, KEYC_MEDIA_NEXT },
+	{ 57436, KEYC_MEDIA_PREVIOUS },
+	{ 57437, KEYC_MEDIA_RECORD },
+	{ 57438, KEYC_VOLUME_DOWN },
+	{ 57439, KEYC_VOLUME_UP },
+	{ 57440, KEYC_VOLUME_MUTE },
+	{ 57441, KEYC_LEFT_SHIFT },
+	{ 57442, KEYC_LEFT_CTRL },
+	{ 57443, KEYC_LEFT_ALT },
+	{ 57444, KEYC_LEFT_SUPER },
+	{ 57445, KEYC_LEFT_HYPER },
+	{ 57446, KEYC_LEFT_META },
+	{ 57447, KEYC_RIGHT_SHIFT },
+	{ 57448, KEYC_RIGHT_CTRL },
+	{ 57449, KEYC_RIGHT_ALT },
+	{ 57450, KEYC_RIGHT_SUPER },
+	{ 57451, KEYC_RIGHT_HYPER },
+	{ 57452, KEYC_RIGHT_META },
+	{ 57453, KEYC_ISO_LEVEL3_SHIFT },
+	{ 57454, KEYC_ISO_LEVEL5_SHIFT }
+};
+
+static int
+tty_kitty_parse_number(const char *s, u_int *value, int empty)
+{
+	char		*end;
+	unsigned long	 number;
+
+	if (*s == '\0') {
+		if (!empty)
+			return (-1);
+		return (0);
+	}
+	if (!isdigit((u_char)*s))
+		return (-1);
+	number = strtoul(s, &end, 10);
+	if (*end != '\0' || number > UINT_MAX)
+		return (-1);
+	*value = number;
+	return (0);
+}
+
+static int
+tty_kitty_parse_list(char *s, u_int *first, u_int *second, int empty,
+    u_int maximum)
+{
+	char	*copy, *item;
+	u_int	 n = 0, value;
+	int	 result = 0;
+
+	copy = s;
+	while ((item = strsep(&copy, ":")) != NULL) {
+		if (maximum != 0 && n == maximum)
+			return (-1);
+		value = 0;
+		if (tty_kitty_parse_number(item, &value, empty) != 0) {
+			result = -1;
+			break;
+		}
+		if (n == 0 && *item != '\0')
+			*first = value;
+		else if (n == 1 && *item != '\0')
+			*second = value;
+		n++;
+	}
+	return (result);
+}
+
+static int
+tty_kitty_find_end(const char *buf, size_t len, size_t *end)
+{
+	size_t	i;
+
+	for (i = 2; i < len; i++) {
+		if (buf[i] == 'u' || buf[i] == '~' || buf[i] == 'A' ||
+		    buf[i] == 'B' || buf[i] == 'C' || buf[i] == 'D' ||
+		    buf[i] == 'E' || buf[i] == 'F' || buf[i] == 'H' ||
+		    buf[i] == 'P' || buf[i] == 'Q' || buf[i] == 'S') {
+			*end = i;
+			return (0);
+		}
+		if (!isdigit((u_char)buf[i]) && buf[i] != ';' && buf[i] != ':')
+			return (-1);
+	}
+	return (1);
+}
+
+static key_code
+tty_kitty_function(u_int number, char final)
+{
+	u_int	i;
+
+	if (final == 'u') {
+		switch (number) {
+		case 9:
+			return (C0_HT);
+		case 13:
+			return (C0_CR);
+		case 27:
+			return (C0_ESC);
+		case 127:
+			return (KEYC_BSPACE);
+		}
+		for (i = 0; i < nitems(tty_kitty_keys); i++) {
+			if (tty_kitty_keys[i].number == number)
+				return (tty_kitty_keys[i].key);
+		}
+		return (KEYC_NONE);
+	}
+
+	if (final == '~') {
+		switch (number) {
+		case 2: return (KEYC_IC);
+		case 3: return (KEYC_DC);
+		case 5: return (KEYC_PPAGE);
+		case 6: return (KEYC_NPAGE);
+		case 7: return (KEYC_HOME);
+		case 8: return (KEYC_END);
+		case 11: return (KEYC_F1);
+		case 12: return (KEYC_F2);
+		case 13: return (KEYC_F3);
+		case 14: return (KEYC_F4);
+		case 15: return (KEYC_F5);
+		case 17: return (KEYC_F6);
+		case 18: return (KEYC_F7);
+		case 19: return (KEYC_F8);
+		case 20: return (KEYC_F9);
+		case 21: return (KEYC_F10);
+		case 23: return (KEYC_F11);
+		case 24: return (KEYC_F12);
+		case 29: return (KEYC_MENU);
+		case 57427: return (KEYC_KP_BEGIN|KEYC_KEYPAD);
+		}
+		return (KEYC_UNKNOWN);
+	}
+	if (number != 1)
+		return (KEYC_UNKNOWN);
+	switch (final) {
+	case 'A': return (KEYC_UP|KEYC_CURSOR);
+	case 'B': return (KEYC_DOWN|KEYC_CURSOR);
+	case 'C': return (KEYC_RIGHT|KEYC_CURSOR);
+	case 'D': return (KEYC_LEFT|KEYC_CURSOR);
+	case 'E': return (KEYC_KP_BEGIN|KEYC_KEYPAD);
+	case 'F': return (KEYC_END);
+	case 'H': return (KEYC_HOME);
+	case 'P': return (KEYC_F1);
+	case 'Q': return (KEYC_F2);
+	case 'S': return (KEYC_F4);
+	}
+	return (KEYC_UNKNOWN);
+}
+
+int
+tty_keys_kitty_query(struct tty *tty, const char *buf, size_t len,
+    size_t *size)
+{
+	struct client	*c = tty->client;
+	size_t		 i;
+	u_int		 flags = 0;
+
+	*size = 0;
+	if (tty->flags & TTY_HAVEKKB)
+		return (-1);
+
+	if (buf[0] != '\033')
+		return (-1);
+	if (len == 1)
+		return (1);
+	if (buf[1] != '[')
+		return (-1);
+	if (len == 2)
+		return (1);
+	if (buf[2] != '?')
+		return (-1);
+	if (len == 3)
+		return (1);
+
+	for (i = 3; i < len && isdigit((u_char)buf[i]); i++) {
+		if (flags > (UINT_MAX - (buf[i] - '0')) / 10)
+			return (-1);
+		flags = (flags * 10) + (buf[i] - '0');
+	}
+	if (i == len)
+		return (1);
+	if (i == 3 || buf[i] != 'u')
+		return (-1);
+
+	*size = i + 1;
+	tty->kitty_keys = flags;
+	tty->flags |= TTY_HAVEKKB;
+	log_debug("%s: received Kitty keyboard flags %u", c->name, flags);
+	tty_parse_client_features(c, "kittykeys", ",");
+	tty_update_features(tty);
+	return (0);
+}
+
+void
+tty_update_kitty(struct tty *tty, struct screen *s)
+{
+	u_int	flags;
+	char	buf[32];
+
+	if (options_get_number(global_options, "extended-keys") == 0 ||
+	    (~tty->term->flags & TERM_KITTYKEYS)) {
+		if (tty->flags & TTY_KKBPUSHED) {
+			tty_puts(tty, "\033[<u");
+			tty->flags &= ~TTY_KKBPUSHED;
+		}
+		return;
+	}
+	flags = KITTY_KEY_DISAMBIGUATE;
+	if (s != NULL && (s->kitty_keys.flags & KITTY_KEY_SUPPORTED) != 0)
+		flags = s->kitty_keys.flags & KITTY_KEY_SUPPORTED;
+	if ((tty->flags & TTY_KKBPUSHED) == 0) {
+		xsnprintf(buf, sizeof buf, "\033[>%uu", flags);
+		tty_puts(tty, buf);
+		tty->flags |= TTY_KKBPUSHED;
+	} else if (tty->kitty_keys != flags) {
+		xsnprintf(buf, sizeof buf, "\033[=%uu", flags);
+		tty_puts(tty, buf);
+	}
+	tty->kitty_keys = flags;
+}
+
+int
+tty_keys_kitty(struct tty *tty, const char *buf, size_t len, size_t *size,
+    key_code *key)
+{
+	struct client	*c = tty->client;
+	struct utf8_data ud;
+	utf8_char	 uc;
+	size_t		 end;
+	char		 tmp[128], *copy, *field, final;
+	u_int		 number = 0, modifiers = 1, event = 1, value;
+	u_int		 fields = 0;
+	key_code	 nkey, onlykey;
+	int		 result;
+
+	*size = 0;
+	if ((tty->flags & TTY_KKBPUSHED) == 0)
+		return (-1);
+	if (len == 0 || buf[0] != '\033')
+		return (-1);
+	if (len == 1)
+		return (1);
+	if (buf[1] != '[')
+		return (-1);
+	if (len == 2)
+		return (1);
+	if (buf[2] == '?')
+		return (-1);
+
+	result = tty_kitty_find_end(buf, len, &end);
+	if (result != 0)
+		return (result);
+	if (end - 2 >= sizeof tmp)
+		return (-1);
+	memcpy(tmp, buf + 2, end - 2);
+	tmp[end - 2] = '\0';
+	final = buf[end];
+	*size = end + 1;
+
+	copy = tmp;
+	while ((field = strsep(&copy, ";")) != NULL) {
+		if (fields == 3)
+			return (-1);
+		value = 0;
+		if (fields == 0) {
+			if (*field == '\0') {
+				if (final == 'u')
+					return (-1);
+				number = 1;
+			} else if (tty_kitty_parse_list(field, &number, &value,
+			    1, 3) != 0)
+				return (-1);
+		} else if (fields == 1) {
+			if (tty_kitty_parse_list(field, &modifiers, &event, 1,
+			    2) != 0)
+				return (-1);
+		} else if (tty_kitty_parse_list(field, &value, &value, 1, 0) != 0)
+			return (-1);
+		fields++;
+	}
+	if (fields == 0 || number == 0 || modifiers == 0)
+		return (-1);
+	if (event == 0 || event == 3 || event > 3)
+		return (-2);
+
+	modifiers--;
+	if (modifiers & 32)
+		return (-2);
+	nkey = tty_kitty_function(number, final);
+	if (nkey == KEYC_NONE) {
+		if (final != 'u')
+			return (-1);
+		if (number >= 57344 && number <= 63743)
+			return (-2);
+		if (number <= 0x7f)
+			nkey = number;
+		else if (utf8_fromwc(number, &ud) != UTF8_DONE ||
+		    utf8_from_data(&ud, &uc) != UTF8_DONE)
+			return (-2);
+		else
+			nkey = uc;
+	} else if (nkey == KEYC_UNKNOWN)
+		return (-1);
+
+	if (modifiers & 1)
+		nkey |= KEYC_SHIFT;
+	if (modifiers & 2)
+		nkey |= KEYC_META|KEYC_IMPLIED_META;
+	if (modifiers & 4)
+		nkey |= KEYC_CTRL;
+	if (modifiers & 8)
+		nkey |= KEYC_SUPER;
+	if (modifiers & 16)
+		nkey |= KEYC_HYPER;
+
+	/* Shift-Tab has a dedicated tmux key code. */
+	onlykey = nkey & KEYC_MASK_KEY;
+	if (onlykey == C0_HT && (nkey & KEYC_SHIFT))
+		nkey = KEYC_BTAB|(nkey & ~KEYC_MASK_KEY & ~KEYC_SHIFT);
+
+	if (log_get_level() != 0) {
+		log_debug("%s: Kitty key %.*s is %llx (%s)", c->name,
+		    (int)*size, buf, nkey, key_string_lookup_key(nkey, 1));
+	}
+	*key = nkey;
+	return (0);
+}
--- a/tty.c
+++ b/tty.c
@@ -409,6 +409,8 @@ tty_send_requests(struct tty *tty)
 		return;

 	if (tty->term->flags & TERM_VT100LIKE) {
+		if (~tty->flags & TTY_HAVEKKB)
+			tty_puts(tty, "\033[?u");
 		if (~tty->flags & TTY_HAVEDA)
 			tty_puts(tty, "\033[c");
 		if (~tty->flags & TTY_HAVEDA2)
@@ -507,6 +509,10 @@ tty_stop_tty(struct tty *tty)
 		tty_raw(tty, "\033[?7727l");
 	tty_raw(tty, tty_term_string(tty->term, TTYC_DSFCS));
 	tty_raw(tty, tty_term_string(tty->term, TTYC_DSEKS));
+	if (tty->flags & TTY_KKBPUSHED) {
+		tty_raw(tty, "\033[<u");
+		tty->flags &= ~TTY_KKBPUSHED;
+	}

 	if (tty_use_margin(tty))
 		tty_raw(tty, tty_term_string(tty->term, TTYC_DSMG));
@@ -559,8 +565,12 @@ tty_update_features(struct tty *tty)

 	if (tty_use_margin(tty))
 		tty_putcode(tty, TTYC_ENMG);
-	if (options_get_number(global_options, "extended-keys"))
+	if (options_get_number(global_options, "extended-keys") == 0 ||
+	    (tty->term->flags & TERM_KITTYKEYS))
+		tty_puts(tty, tty_term_string(tty->term, TTYC_DSEKS));
+	else
 		tty_puts(tty, tty_term_string(tty->term, TTYC_ENEKS));
+	tty_update_kitty(tty, NULL);
 	if (options_get_number(global_options, "focus-events"))
 		tty_puts(tty, tty_term_string(tty->term, TTYC_ENFCS));
 	if (tty->term->flags & TERM_VT100LIKE)
--- a/window-border.c
+++ b/window-border.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: window-border.c,v 1.3 2026/07/23 09:38:27 nicm Exp $ */
+/* $OpenBSD: window-border.c,v 1.4 2026/09/11 10:17:16 nicm Exp $ */

 /*
 * Copyright (c) 2026 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -120,6 +120,10 @@ window_get_border_cell(struct window_pane *wp, enum pane_lines pane_lines,
 		gc->attr &= ~GRID_ATTR_CHARSET;
 		utf8_copy(&gc->data, tty_acs_heavy_borders(cell_type));
 		break;
+	case PANE_LINES_ROUNDED:
+		gc->attr &= ~GRID_ATTR_CHARSET;
+		utf8_copy(&gc->data, tty_acs_rounded_borders(cell_type));
+		break;
 	case PANE_LINES_SIMPLE:
 		gc->attr &= ~GRID_ATTR_CHARSET;
 		utf8_set(&gc->data, SIMPLE_BORDERS[cell_type]);
Author	SHA1	Message	Date
Michael Grant	8c96fde851	Detection, done like sync: - ESC[?u goes to every VT100-like terminal at attach, whatever the options. - A reply turns on a new kittykeys terminal feature. Users can force it on or off with terminal-features kittykeys, including kittykeys@ to turn it off. - Changing extended-keys now takes effect immediately for attached clients (options.c). Use, per client, when extended-keys is on: Kitty for clients that have kittykeys, modifyOtherKeys for clients with extkeys, VT10x otherwise. Pane side: - Applications can request either protocol; Kitty wins if one asks for both. - Each application gets what it asked for, whichever client typed the key. - ESC[?u is answered truthfully. - The per-client gate is gone. window.c and popup.c are simply master's versions again. extended-keys always is back to its master meaning, forcing modifyOtherKeys mode 1 only. Forcing Kitty on every program would have sent bash ESC[97;5u for Ctrl-A. extended-keys-format kitty is still accepted, but now behaves the same as csi-u.	2026-09-19 07:32:57 +01:00
Michael Grant	1abf9f7023	Add a test for Kitty keyboard protocol input parsing Also note that kitty-keys-terminal.sh cannot run under the regress Makefile, which uses env -i and so removes DISPLAY and HOME, and make the Kitty test file modes match the rest of regress.	2026-09-17 06:16:11 +01:00
Michael Grant	cb80f01460	Cleanup.	2026-09-17 06:00:13 +01:00
Michael Grant	e2334c3205	Document Kitty query snapshot semantics	2026-09-15 06:14:43 +01:00
Michael Grant	9e88490a05	Simplify Kitty query completion flag	2026-09-15 06:11:25 +01:00
Michael Grant	10ea823da6	Make Kitty keyboard negotiation per client	2026-09-15 05:45:58 +01:00
Michael Grant	75cb580e36	Add Kitty keyboard protocol support	2026-09-14 14:14:28 +01:00
tmux update bot	e880cf63e0	Merge remote-tracking branch 'refs/remotes/tmux-openbsd/master' * refs/remotes/tmux-openbsd/master: Add rounded borders option for panes like popups.	2026-09-11 17:00:20 +00:00
nicm	325b40e8c4	Add rounded borders option for panes like popups.	2026-09-11 17:00:18 +00:00
tmux update bot	f95363aa83	Merge remote-tracking branch 'refs/remotes/tmux-openbsd/master' * refs/remotes/tmux-openbsd/master: Rather than allowing floating panes to remain outside the window and invisible after resize, move them and resize them so they are fully inside the window. GitHub issue 5582 from Noam Stolero.	2026-09-11 12:58:31 +00:00
nicm	f8fc53b6f8	Rather than allowing floating panes to remain outside the window and invisible after resize, move them and resize them so they are fully inside the window. GitHub issue 5582 from Noam Stolero.	2026-09-11 12:58:29 +00:00
Nicholas Marriott	d215280b00	Add rounded border tests.	2026-09-11 11:17:35 +01:00
Nicholas Marriott	d859a0f410	Test for resizing floating panes, from Noam Stolero.	2026-09-11 09:16:55 +01:00
Nicholas Marriott	10d00cc7cb	Modal pane test changes.	2026-09-11 09:10:14 +01:00
Nicholas Marriott	14a01dd337	Note changes from Heon Jeong.	2026-09-11 09:05:06 +01:00
tmux update bot	a958883625	Merge remote-tracking branch 'refs/remotes/tmux-openbsd/master' * refs/remotes/tmux-openbsd/master: Add remain-on-exit failed-key and a -D flag to new-pane to have a modal pane wait for Escape/C-c. Both to allow better compatibility with popups.	2026-09-10 13:04:13 +00:00
nicm	d202aa7ac1	Add remain-on-exit failed-key and a -D flag to new-pane to have a modal pane wait for Escape/C-c. Both to allow better compatibility with popups.	2026-09-10 13:04:11 +00:00
Nicholas Marriott	d9a5e82678	Fix tests.	2026-09-10 12:00:01 +01:00
tmux update bot	13c10f672c	Merge remote-tracking branch 'refs/remotes/tmux-openbsd/master' * refs/remotes/tmux-openbsd/master: Add a nesting limit for v1 layouts, reported by M Khalilov, fix based on issue 5572 from Afonso Januário. Also tweak some language while here.	2026-09-09 19:23:09 +00:00
nicm	b7c5030004	Add a nesting limit for v1 layouts, reported by M Khalilov, fix based on issue 5572 from Afonso Januário. Also tweak some language while here.	2026-09-09 19:23:07 +00:00
Nicholas Marriott	4839123510	Tweak changes.	2026-09-09 13:50:42 +01:00
Nicholas Marriott	9b3268a2a0	Bump version.	2026-09-09 13:28:07 +01:00