Commit graph

20071 commits

Author SHA1 Message Date
Kovid Goyal
2d3ff7b240
Support detailed wheel events in the kittens framework
Some checks are pending
CI / Linux (python=3.14 cc=clang sanitize=1) (push) Waiting to run
CI / Linux (python=3.12 cc=gcc sanitize=0) (push) Waiting to run
CI / Linux (python=3.13 cc=gcc sanitize=1) (push) Waiting to run
CI / Linux package (push) Waiting to run
CI / Bundle test (macos-latest) (push) Waiting to run
CI / Bundle test (ubuntu-latest) (push) Waiting to run
CI / macOS Brew (push) Waiting to run
CI / Test ./dev.sh and benchmark (push) Waiting to run
Kittens can opt in with Loop.DetailedWheelEvents(), after which scroll
events arrive as MOUSE_WHEEL mouse events whose Wheel field has the
deltas, unit, multiplier, source, phase and momentum/inverted flags.
WheelEvent.Lines() converts the deltas to lines using the terminal's
multiplier when available.

The mouse-demo kitten uses this to move a block drawn with the graphics
protocol up and down with pixel precision, falling back to wheel button
presses in terminals without support, and shows the event details.
2026-11-16 13:43:41 +05:30
Kovid Goyal
a481180d48
Add a mode to report scroll events to programs in full detail
Mode 5523, while mouse tracking is on, makes kitty report each scroll event
as a single CSI > ... M escape code instead of as button 4-7 presses. It
carries integer deltas in v120 units or pixels, with fractions carried
over, the user's scroll multiplier as a hint, the kind of device, the
gesture phase, and flags for momentum and inverted (natural) scrolling,
and the full set of modifiers. Only the sign of the multipliers is applied.

To support this GLFW scroll events now carry the source device, the
gesture phase and whether the direction is inverted, on Wayland, X11 and
macOS. The momentum scroller now forwards the gesture end before starting
momentum and no longer reports a cancel for momentum that never began.
2026-11-16 13:43:41 +05:30
Kovid Goyal
b691ccf3b6
Do not run Python code in the child between fork() and exec() in spawn()
PyOS_AfterFork_Child() runs Python at-fork handlers, re-initializes thread
state and allocates memory in the forked child. On macOS this can get the
child killed with SIGKILL before it execs, which is still happening on CI in
the file transmission tests even after the previous fix. The Python docs only
require PyOS_AfterFork_Child() when the child will call back into the
interpreter, which ours never does, so do not call it. Also convert pass_fds
to a C array before forking, and use only async-signal-safe functions in the
child (_exit() instead of exit(), no snprintf()).
2026-11-16 13:43:41 +05:30
Kovid Goyal
fbc812c7a3
Fix children being killed with SIGKILL on macOS after GPU drivers are loaded
The child side of spawn() closed every inherited fd from 3 to 255. On macOS
system frameworks such as Metal and libdispatch create guarded file
descriptors and calling close() on one of them raises EXC_GUARD which kills
the process with SIGKILL. Instead mark the inherited fds close-on-exec, which
is always allowed for guarded fds, and let exec() close them.
2026-11-16 13:43:41 +05:30
Kovid Goyal
e33dd1d4cb
... 2026-11-16 13:43:41 +05:30
Kovid Goyal
161fc04a66
Ignore the paused rendering snapshot when rendering is not paused
The snapshot of the screen taken for a synchronized update is kept after
the update ends, so its cells prevented the style table from being
emptied on hard resets and clearing of the scrollback, and kept their
styles alive through garbage collection. It is unused when rendering is
not paused and is overwritten entirely when rendering is next paused, so
only consider it while rendering is paused.

Also detect use of the formatting of stale line copies when comparing
lines and in test_shape() and test_render_line().
2026-11-16 13:43:41 +05:30
Kovid Goyal
13c7980ab4
Speed up processing of text that scrolls the screen
Lines scrolled onto the screen no longer have their render data cleared,
instead they are marked dirty so that rendering recomputes it, except when
there is a marker, as marks are render data used without rendering. This
reduces the memory written to clear a line by 40%.

The ASCII fast path in draw_text no longer checks for multicell cells in
a line that was just cleared by a line feed scrolling the screen, until
something that can create multicell cells happens.

Together these make the ascii benchmark ~14% and the scrollback and
render benchmarks ~8% and ~14% faster. Also update the throughput
numbers in the performance docs, using the median of several runs.
2026-11-16 13:43:41 +05:30
Kovid Goyal
6f312275f3
Make ty happy 2026-11-16 13:43:41 +05:30
Kovid Goyal
a49882a5f9
Update performance docs 2026-11-16 13:43:41 +05:30
Kovid Goyal
675d4e8c63
Add a script to run the benchmark kitten in multiple terminals for comparison
Runs the benchmark kitten in all installed terminals from xterm, foot,
kitty, ghostty, alacritty, wezterm, konsole, ptyxis and alacritty+tmux,
with default configuration except for font, font size and window size.
Terminals are pinned to the fast cores on machines with heterogeneous
cores and the performance governor is set if root access is available.
2026-11-16 13:43:41 +05:30
Kovid Goyal
c2567d63d3
Only empty the style table on hard resets and clearing the scrollback
Emptying it whenever the whole screen was erased meant that full screen
programs, which erase the screen on every redraw, had all their styles
interned again and the style texture uploaded again every frame. Also do
not empty tables with few styles, as they are not worth it. Empty it when
the scrollback is cleared by the clear_terminal action as well.

Improves the truecolor text and half blocks benchmarks by 50% and 33%.
2026-11-16 13:43:40 +05:30
Kovid Goyal
a7f8853231
disable scrollback prefetch on apple silicon as it hurts rather than helping 2026-11-16 13:43:40 +05:30
Kovid Goyal
3b7784b84c
Rename Style and StyleTable to CellStyle and CellStyleTable
Fixes build on macOS where the names clash with the Style typedef from
MacTypes.h and struct StyleTable from QD Fonts.h pulled in via Carbon.h
2026-11-16 13:43:40 +05:30
Kovid Goyal
313a1bc68f
Use non-temporal stores to add lines to the scrollback
The history buffer is much larger than the CPU cache and lines added to
it are not read again soon. Normal stores to it stall acquiring
ownership of the destination cache lines, filling the store buffer and
stalling the drawing of the next line. Write the whole cache lines of
the cells with non-temporal stores instead, using normal stores for the
partial cache lines at either end, as partial non-temporal writes are
slow. Fence once per parse pass rather than after every line.

benchmark.py scrollback: +32%, in-process parsing to the main screen
+26% to +62% depending on the number of columns. Builds without SSE2
keep using prefetching.
2026-11-16 13:43:40 +05:30
Kovid Goyal
bf37d5841b
benchmark kitten: Add scrollback and render benchmarks and --output
Replace the --with-scrollback and --render flags with two new
benchmarks, scrollback and render, that use the ASCII text with the
main screen and with rendering allowed, respectively. All other
benchmarks use the alternate screen with rendering suppressed. Add an
--output flag to also write the results to a file as JSON and list the
available benchmarks with descriptions in the help text.
2026-11-16 13:43:40 +05:30
Kovid Goyal
c9a99c093d
Make the ASCII and Unicode text benchmarks comparable
The two benchmarks now use text with the same structure: the same lines,
of the same widths in cells, ending in CRLF and with tabs at the same
positions, differing only in the characters used to fill them. Before,
the ASCII text had a bare newline about every 90 bytes, while the
Unicode text was long lines of mostly CJK text, so they were dominated
by different costs. Also report the rate at which cells are drawn for
them, since non-ASCII characters are encoded in more bytes.
2026-11-16 13:43:40 +05:30
Kovid Goyal
7c549dc83a
Double the maximum number of cell styles
Remove the temp_flag bit from CPUCell, which was used only to mark the
cells whose text is extracted for a selection, and use a temporary bitmap
for that instead. The freed bit is used for the style index, doubling
the maximum number of styles to 262144.
2026-11-16 13:43:40 +05:30
Kovid Goyal
0726ec71b1
Detect use of the formatting of stale line copies
Copies of lines made with LineBuf.create_line_copy() are not remapped
when the style table of their screen is garbage collected, so their
style indices become invalid. Record the generation of the style table
in copies and raise ValueError when the formatting of a copy made
before a collection is used. Copying a whole line into a copy makes
its formatting valid again.
2026-11-16 13:43:40 +05:30
Kovid Goyal
08333a778a
Empty the style table when no cell uses a style
On a hard reset or when erasing the whole display, if the scrollback is
empty and no cell on any screen buffer has a style, empty the style
table, freeing the memory used by styles from, for example, a burst of
output with many colors. Checking is cheap as only the screen buffers
need to be scanned.
2026-11-16 13:43:40 +05:30
Kovid Goyal
927401a7cd
Look up cell styles in the shaders
Upload only the sprite index and the style index and mark of each cell,
8 bytes instead of 20, and have the cell and padding shaders get the
style from a per screen texture holding the style table. Styles are
uploaded incrementally, all of them when the table is garbage collected.

Also only build the attributes and sprites of cells when rendering
lines, as nothing else is used. Together these bring the CPU cost of
preparing cells for the GPU back to what it was before styles were
interned.
2026-11-16 13:43:40 +05:30
Kovid Goyal
bd353afb9c
Intern cell styles and store only CPUCells in the scrollback
The formatting of cells (colors and SGR attributes) is now interned per
screen in a StyleTable and cells store a 17 bit index into it in the
previously unused bits of CPUCell. Render data (sprite and mark) is kept
in a separate RenderCell array for screen lines and in a small render
cache for history lines being displayed, so the scrollback stores only
CPUCells, 12 bytes per cell instead of 32. GPUCell is now only the upload
format, built from the CPUCell, its style and its RenderCell.

When the table fills up, it is compacted at the start of drawing text,
reducing the color precision of cells in the scrollback if needed, cells
on screen always keep their exact styles. The map from styles to indices
is a verstable set of indices with a small cache of recent styles in
front of it.

benchmark.py throughput: ascii +48%, unicode +29%, csi +10%, truecolor
text -22%, truecolor half blocks -9%.
2026-11-16 13:43:40 +05:30
Kovid Goyal
8af327b85c
... 2026-11-16 13:43:40 +05:30
Kovid Goyal
02f0f6ec00
Only test abstract UNIX sockets on Linux
Abstract sockets are a Linux-only feature, binding to one on macOS fails
with ENOENT.
2026-11-16 13:43:40 +05:30
Kovid Goyal
03e24d85c7
Report render frame stalls once per stall and on X11
With --debug-rendering, the "No render frame received" message was
logged on every main loop wakeup while frames were stalled, which can be
indefinitely, for example, while a Wayland window is hidden. Report each
stall only once, till a render frame is next received.

Also report stalls on X11, when the X server stops reporting vertical
blanks and frames are rendered without them. A single missed frame while
frames are arriving is a glitch and is not reported.
2026-11-16 13:43:40 +05:30
Kovid Goyal
5034f51249
macOS: Fix a few issues with the new render logic
1. Stuck display link when screen is off
2. Blank frames during live resize
2026-11-16 13:43:39 +05:30
Kovid Goyal
909e3d6359
Use an accurate title for the overlay showing startup errors
Errors during startup that are not caused by invalid config lines, such
as failing to listen on the remote control socket, were shown under the
title "Errors parsing configuration" with the heading "In final effective
configuration". The title now reflects whether the errors are config
parse errors, startup errors or both.
2026-11-16 13:43:39 +05:30
Kovid Goyal
d2562cb186
Wayland: Limit rendering to 120 FPS soon after a resize
For a second after a resize, render frames are not used, so that the
resized buffer is filled immediately. This meant that continuous output
was rendered as fast as possible, about 900 FPS, during that second.
Now only the first render after the resize is immediate, subsequent
renders are limited to 120 FPS, unless a render frame arrives sooner.
2026-11-16 13:43:39 +05:30
Kovid Goyal
b4d3876fc2
Remove stale UNIX sockets when listening for remote control
If the socket file for --listen-on was left behind by a kitty instance
that was killed, binding to it failed, so remote control was disabled
and an error was shown over the program. Now, if no process is listening
on the socket, it is removed and binding is retried. A socket that a
process is listening on and files that are not sockets are never
removed, and the error shown includes the reason for the failure.
2026-11-16 13:43:39 +05:30
Kovid Goyal
8efb82b5b8
Replace sync_to_monitor and repaint_delay with render_interval
The new render_interval option either syncs redraws to the monitor
(the default), optionally with a minimum interval between frames, or
redraws on a schedule with a minimum interval between frames. The
interval is now enforced per OS window, including when output is being
parsed, which the old repaint_delay was not.

On X11, render frames are now provided by the Present extension, with
libxcb-present loaded at runtime. Frames are requested lazily on X11,
since a pending NotifyMSC request delays buffer presentation by the GPU
driver under Xwayland. Xwayland completing requests early and failing to
report vertical blanks for long periods are handled. Without Present,
kitty falls back to blocking buffer swaps as before.

Render frames now only wake up the main loop when something is waiting
for them, so animations such as the eased cursor blink are no longer
sampled at the monitor refresh rate. On Wayland, frame callbacks are
also used when not syncing to the monitor, to stop rendering hidden
windows.

The removed options are converted to render_interval if it is not
specified anywhere, including in other config files and overrides,
otherwise they are ignored with a warning.

Also fix gen config failing on options whose type is a builtin.
2026-11-16 13:43:39 +05:30
Kovid Goyal
173ece7911
Fix CI failures from the SIMD UTF-8 decoder changes
The SIMD UTF-8 decoders read up to a vector past the end of their input,
which is fine for real callers that have slack after their data, but
test_utf8_decode_to_sentinel passed the Python buffer directly, so the
new long input test triggered heap-buffer-overflow reports under ASAN.
Copy the input into a padded buffer, as the other SIMD test helpers do.

Also fix clang-format violations and broken references to the removed
input_delay option in the changelog that failed the docs build.
2026-11-16 13:43:39 +05:30
Kovid Goyal
14191bbbee
Read variable font data from WOFF and WOFF2 files in font selection
The C font selection code read font tables only from sfnt files, so
variable fonts in WOFF/WOFF2 files had no variable data, causing wrong
faces to be selected, for example, for FiraCode-VF.woff2.

Read WOFF tables using zlib and WOFF2 tables using brotli, decompressing
only the prefix of the stream containing the needed tables, in fixed
size chunks so that memory use does not depend on possibly corrupt
offsets. kitty now links against libbrotlidec on platforms other than
macOS.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 13:43:39 +05:30
Kovid Goyal
03218e35b3
ARM optimisations for new new UTF8 decoder 2026-11-16 13:43:39 +05:30
Kovid Goyal
7326d3075a
Speed up drawing of cells with many combining chars
- Add runs of plain combining chars to a cell with a single lookup in
  the text cache, rather than one for each char, which also added the
  intermediate texts of the cell to the cache.

- Also collect garbage in the text cache when starting a new line, not
  just when starting to draw text, as a single draw can add a great many
  entries, making the cache slower to use the larger it grows.

- Size the hash map of the text cache for the expected number of entries
  after garbage collection, to avoid repeatedly rehashing it as it grows.

This makes the unique multi-codepoint cells benchmark ~80% faster.

The differential test of batched drawing now compares cells by content,
since cells with multiple codepoints store indices into the text cache,
which change as intermediate texts are no longer added to it.
2026-11-16 13:43:39 +05:30
Kovid Goyal
13de2c0660
Do not require AVX-512 VBMI2 for the AVX-512 SIMD code
VBMI2 was only used by the AVX-512 UTF-8 decoder, which has been
removed, so CPUs with AVX-512 F, BW and VL but not VBMI2, such as
Skylake-X, can now use the AVX-512 implementations of the remaining
functions.
2026-11-16 13:43:39 +05:30
Kovid Goyal
b815054414
Much faster SIMD UTF-8 decoding of valid UTF-8
Decode 64 byte blocks of valid UTF-8 containing no ESC using the
approach of simdutf: blocks are validated with the lookup tables of
Keiser and Lemire and converted twelve bytes at a time using shuffles
looked up from a mask of the bytes that end code points, with fast
paths for runs of ASCII, two byte and three byte sequences. Anything
else, ESC, invalid UTF-8 and the end of the input, is decoded as
before.

The shuffle tables are generated by gen/utf8_decode_tables.py.

This decodes the text of the unicode benchmark 2.6 times faster, faster
than simdutf's own conversion with error checking, and speeds up the
unicode benchmark by ~8%.

The new AVX2 decoder is faster than the AVX-512 one, so remove the
AVX-512 decoder and use the AVX2 one on CPUs with AVX-512 as well.

Also add a test comparing the SIMD decoders with the scalar one on long
inputs, which exercise the decoding of blocks, as the existing tests use
short inputs.
2026-11-16 13:43:39 +05:30
Kovid Goyal
3df2858e36
Avoid store forwarding stalls when writing wide char cells
Building the cells of wide chars with bitfield initializers made
compilers write parts of them to the stack and reload them with wider
loads, which stalls on store forwarding on every call of the batched
non-ASCII draw path and for every wide char drawn by the scalar path.
Build the cells from constant words in registers instead, using helpers
shared by both paths.

This speeds up the unicode benchmark by ~6%.
2026-11-16 13:43:39 +05:30
Kovid Goyal
61c953491e
Use a compact per char draw info table in the batched draw path
Decoding the packed bitfields of CharProps took about half the
instructions of the batched non-ASCII draw loop. Precompute, for each
distinct CharProps value, the number of cells a char occupies and its
grapheme segmentation property, and use that in the loop instead.

This speeds up the unicode benchmark by ~8%.

Also add test cases for a batched run that stops at an existing
multicell char after an unpaired regional indicator, which the random
test cases did not cover.
2026-11-16 13:43:39 +05:30
Kovid Goyal
832216f752
Speed up parsing of CSI codes and erasing of lines
- Check for multicell chars in the erased range before looking for them
  cell by cell, with a branch free check that reads only the word of each
  cell containing the multicell flag. The common case is a line with no
  multicell chars.

- Add a fast path that parses CSI codes of the common form, an optional
  private marker, numeric params separated by ; or : and the final byte,
  in a single pass, falling back to the generic CSI parser for anything
  else.

- Do not call the UTF-8 decoder for no text when an escape code directly
  follows another one, and start parsing CSI codes right after ESC [
  rather than in the next iteration of the parse loop.

This speeds up the CSI benchmark by 25% to 30% and the truecolor
benchmarks by ~10%.

A differential test compares the fast path and the generic CSI parser on
random input, and a new test covers erasing parts of multicell chars,
which no existing test did.
2026-11-16 13:43:39 +05:30
Kovid Goyal
51b1495103
Add a batched draw path for runs of non-ASCII text
Draw runs of non-ASCII chars that each start a new cell of width one or
two in a tight loop, with the run invariant checks done once and state
kept in locals, falling back to the scalar path for anything that needs
special handling: combining chars, zero width chars, the image
placeholder, existing multicell cells, wrapping, insert mode and charset
translation.

Cells are written as 64 bit values built in registers, since assembling
them as structs makes compilers go through the stack with partial stores
that stall on store forwarding. The grapheme segmentation step is cached
as it depends only on the state and the segmentation property of the
char, which repeat in a run of text, breaking the chain of dependent
table lookups between consecutive chars.

This speeds up the unicode benchmark by ~30%, drawing CJK text by ~70%.

A differential test compares the batched and scalar paths on random
operations.
2026-11-16 13:43:39 +05:30
Kovid Goyal
e7597bc443
benchmark kitten: Add benchmarks for text with many distinct colors
Add truecolor_text, where every char has a random 24-bit foreground,
palette16_text, the same but with only 16 distinct colors, and
halfblocks, rows of half blocks with random 24-bit foreground and
background as written by terminal image viewers.

The existing benchmarks use either no colors or a handful of fixed
SGR codes, which favors terminals that store styles in a per page
deduplicated table rather than in each cell. These benchmarks measure
the cost of output with many distinct styles, which is common in
practice.
2026-11-16 13:43:39 +05:30
Kovid Goyal
752bf496a8
Remove input_delay and parse output as soon as it is received
Holding large chunks of input for input_delay left the parser idle about
30% of the time during bulk output: the parser started only when the
buffer was nearly full, and freed space only at the end of a pass, so the
I/O thread could not read while the parser worked.

Now the I/O thread wakes the main loop whenever new input arrives and no
wakeup is already outstanding, and a parse pass compacts the buffer as it
goes, waking the I/O thread if the buffer had filled up. A pass parses at
most 1MB of input so that a continuous stream cannot starve rendering and
event handling.

This raises parser utilization during kitten __benchmark__ from ~70% to
~97% and throughput by 12% to 30% depending on the kind of output.
2026-11-16 13:43:38 +05:30
Kovid Goyal
4e88737b33
macOS: shave another 30ms of startup time by initializing while slow python imports are being done 2026-11-16 13:43:38 +05:30
Kovid Goyal
c5a9253568
macOS: minor fixes to the new C based font selection code 2026-11-16 13:43:38 +05:30
Kovid Goyal
1005ae5c7d
Prepare the builtin NERD font in the font selection thread
Loading the builtin NERD font, which includes a fontconfig match for its
hinting settings, was done on the main thread when the results of font
selection were first used. Do the slow parts of it in the font selection
thread instead. On Linux the PostScript name is read from the name table
of the font file and the fontconfig match is done in the thread, and the
FreeType face, which is only used for fallback, is created when first
needed. On macOS the font descriptor is created in the thread.

This saves ~0.6ms on the main thread during startup on Linux.
2026-11-16 13:43:38 +05:30
Kovid Goyal
e6731cdb0c
Add a --debug-startup command line flag
Prints the time taken by the various phases of startup, measured from
when the launcher started, including the time spent in the threads that
load the GPU driver and select fonts and how long the main thread waited
for them. Printing stops after the first frame is presented.
2026-11-16 13:43:38 +05:30
Kovid Goyal
e1a00bfeed
Select fonts in C, in a thread, during startup
Font selection was done in Python on the main thread, taking ~15ms at
startup on Linux and much more on macOS, where all installed fonts were
listed from CoreText and converted to Python, taking ~165ms.

Port the selection algorithm to pure C in font-select.c, with platform
backends in fontconfig.c and core_text.m, so that it can run in a thread
started by set_font_family(). The results are used when the first font
group is created, typically when the first OS Window is created. The
data for variable fonts is read from the font tables by C code that does
not use Python or FreeType.

The fontconfig backend lists all monospace fonts once and filters them
in C, as listing fonts is dominated by scanning all fonts. The CoreText
backend queries only the needed font families and PostScript names
instead of all installed fonts.

On Linux, the selected fonts are identical to those selected by the
previous Python implementation for ~1400 font specifications, including
variable fonts. The CoreText backend has not yet been compiled or tested.
2026-11-16 13:43:38 +05:30
Kovid Goyal
e9f9c628f5
Fix position and scale of the live resize text
The viewport was being reset to the pre-resize size on every render,
so the resizing text overlay was drawn into a stale viewport, making it
off center and scaled inversely to the window size.

Fixes #10814
2026-11-16 13:43:38 +05:30
Kovid Goyal
8c11fa3118
Import the boss, session and shader modules after initializing glfw
These modules are slow to import, so import them in _run_app() and
load_all_shaders() instead of at the top of kitty/main.py, so that on
Wayland they are imported while the GPU driver is loaded in a thread
started by init_glfw(), instead of before it. Previously the driver
thread overlapped only with loading fonts and the main thread then had
to wait ~10ms for it. Now it finishes well before the first OS Window
is created.
2026-11-16 13:43:38 +05:30
Kovid Goyal
1df813e7eb
Wayland: Load the GPU driver in a thread
Connecting to the GPU driver takes ~25ms with Vulkan, almost all of it
in the Vulkan loader and the GPU drivers it loads. On Wayland, where the
connection to the compositor can be used from multiple threads, do it in
a thread started by glfw_init(), so that it overlaps with loading fonts
and creating the startup sessions. It is waited for when the first OS
Window is created.

Only the first candidate driver is tried in the thread, the remaining
ones, if any, are tried synchronously when waiting, as the software
OpenGL driver modifies environment variables, which is not thread safe.

Together with the previous startup changes, this reduces the time to
the first frame by ~25-35ms.
2026-11-16 13:43:38 +05:30
Kovid Goyal
c702ef7f24
Vulkan: Create the swapchain with the right present mode the first time
The swapchain was created with the FIFO present mode and then recreated
on the first frame, because the swap interval of the window was set
only after the surface was created. Pass the initial swap interval to
the driver in GPUSurfaceConfig so the swapchain is created correctly
when the surface is created.
2026-11-16 13:43:38 +05:30