Commit graph

20054 commits

Author SHA1 Message Date
Kovid Goyal
375c751dce
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-19 07:35:32 +05:30
Kovid Goyal
6c88ea3e37
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-19 07:35:32 +05:30
Kovid Goyal
4cc8f79cad
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-19 07:35:32 +05:30
Kovid Goyal
4eabccbaf3
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-19 07:35:32 +05:30
Kovid Goyal
f051de1b7c
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-19 07:35:32 +05:30
Kovid Goyal
f6d3b1e537
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-19 07:35:32 +05:30
Kovid Goyal
ed21ef4f95
Do not import the launch module when there are no watchers
Creating the first window imported kitty.launch, which is slow to
import, just to find out there are no watchers to load. This delayed
the launch of the first child by a few ms.
2026-11-19 07:35:32 +05:30
Kovid Goyal
e17a8383a6
Disable garbage collection during startup
Python garbage collections triggered while importing modules, parsing
the config and creating the first window cost ~10ms and find almost
nothing to collect. Disable the collector until the main loop starts,
then freeze the, mostly long lived, objects created during startup so
they are not repeatedly scanned by later collections.
2026-11-19 07:35:32 +05:30
Kovid Goyal
a2af3dadea
Fix margins drawn with the wrong viewport with the Vulkan driver
The viewport is driver state shared by all surfaces with Vulkan (and
Metal), unlike OpenGL where it is per context. It was set only when an
OS Window's size changed, so a resize of another OS Window could leave
a stale viewport in place, causing the border/margin rects to be drawn
at the wrong size. Set it every time an OS Window is rendered.

Fixes #10813
2026-11-19 07:35:32 +05:30
Kovid Goyal
9f2c4703b0
Update shell.nix for vulkan support 2026-11-19 07:35:32 +05:30
Kovid Goyal
a6cbbb1122
Fix freeze build failure 2026-11-19 07:35:32 +05:30
Kovid Goyal
8613e1f816
Bump generated MSL version to that used on macOS 14 2026-11-19 07:35:32 +05:30
Kovid Goyal
0756e68ca8
macOS: Fix notification urgency being ignored
The switch mapping urgency to interruption level had no break statements, so
every notification ended up with the Active interruption level. Also use
Time Sensitive rather than Critical for urgency 2, as Critical requires a
special entitlement from Apple.
2026-11-19 07:35:32 +05:30
Kovid Goyal
bf6d65f375
macOS: Require macOS 14 and drop code for older versions
Increase the minimum supported macOS version from 12 to 14. Remove the
CVDisplayLink fallback, using only CADisplayLink. Since CADisplayLink fires
on the main thread, the display link locking and cross thread dispatch are no
longer needed. Also remove other code paths that were only used on macOS
versions older than 14.
2026-11-19 07:35:32 +05:30
Kovid Goyal
f8e9061bc5
macOS: CVDisplayLink -> CADisplayLink 2026-11-19 07:35:31 +05:30
Kovid Goyal
b68d018438
Fix the colors of the live resize text
The text showing the size of the window in cells during a live resize
is drawn directly into the window after the layers are composited, when
encoding to sRGB is disabled, so its linear colors were output as is,
making them too dark, for example #ffcc00 was drawn as #ff9a00. Encode
the output to sRGB when drawing alpha masks into the window, or when the
window does not support that, pass the colors without linearizing them.
The software rendering banner now uses the same code.
2026-11-19 07:35:31 +05:30
Kovid Goyal
a8fb53bca4
Add software rendering as a fallback GPU driver
On Linux and BSD, kitty now falls back to rendering on the CPU with the
Mesa lavapipe (Vulkan) or llvmpipe (OpenGL) software renderers when no
usable GPU is found, such as in virtual machines or with broken GPU
drivers. This is the new software value of the gpu_driver option, last
in the default list.

Drivers are now told which kind of renderer they may use. The software
candidates use only software renderers: Vulkan selects CPU devices and
OpenGL sets LIBGL_ALWAYS_SOFTWARE and __GLX_VENDOR_LIBRARY_NAME while
the renderer is chosen, restoring them afterwards so they are not passed
on to child programs. The other candidates reject software renderers,
unless they are last, so that a working GPU, even one usable only by a
later driver, is always preferred to the CPU. Previously, on systems
with a GPU usable only with OpenGL, kitty would use lavapipe. Drivers
report whether they render in software in their capabilities.

Failing to initialize the GPU driver for the first window is no longer
fatal: the window is recreated with the next driver, as is already done
for failures creating surfaces. OpenGL can only detect that it is using
llvmpipe once a context is current.

When software rendering is used, a message saying so is shown at the
top of every OS window for five seconds after it is first rendered.
2026-11-19 07:35:31 +05:30
Kovid Goyal
70ca44ae1d
Simplify is_selected buffer Metal compatibility 2026-11-19 07:35:31 +05:30
Kovid Goyal
5d60395312
Get Metal driver working 2026-11-19 07:35:31 +05:30
Kovid Goyal
979087e044
Add a Metal GPU driver and an MSL shader target
On macOS, kitty now tries to render using Metal, falling back to OpenGL,
see the gpu_driver option. The driver has not yet been compiled or run
on macOS, it was written on Linux and only syntax checked against stub
headers.

Shader targets of the form msl-NN (for MSL N.N) compile each program to
a single MSL source file containing the entry points for all stages,
compiled by the driver at runtime, for the built-in and custom shaders.
slangc ignores [[vk::binding]] for Metal, so the program metadata keeps
the kitty binding slots and passes the argument table indices assigned
by slangc as native names. The push constant block, emitted as an
ordinary constant buffer, is recognized by the name of its type. As
Metal has y=1 at the top in NDC, the generated code is fixed up to
negate the y coordinate of the position output by vertex entry points.
Layouts that would differ because bool is a single byte in MSL are
rejected. The MSL is validated with the Metal compiler when available.
The MSL shaders are temporarily built on all platforms, for development.

The driver follows the design of the Vulkan driver: command buffers with
serials and at most three in flight, copy on write of buffer storage the
GPU may still use, private textures uploaded with blits from staging
memory, pipeline variants created when first used and a CAMetalLayer
per window. Vertex inputs whose offset or stride is not a multiple of
four bytes, as Metal requires, are repacked into a cached copy.
2026-11-19 07:35:31 +05:30
Kovid Goyal
a4d5c2ebfc
Build the Vulkan GPU driver in the Linux binary builds
Add vulkan-headers to the Linux dependencies, and fail freezing on Linux
if either the OpenGL or the Vulkan GPU driver, or the built-in shaders
for its shader target, are missing. Document vulkan-headers as a build
dependency.
2026-11-19 07:35:31 +05:30
Kovid Goyal
8cbb366f4d
Add a Vulkan GPU driver
On Linux and BSD, kitty now renders using Vulkan 1.3, falling back to
OpenGL if Vulkan is not available, see the gpu_driver option. The driver
is built when the Vulkan headers are present, libvulkan is loaded at
runtime.

The driver implements the immediate mode GPU API on top of a small ring
of command buffers, submitted when windows are presented or when the CPU
needs results, such as when reading back pixels. It uses dynamic
rendering, synchronization2, push descriptors for textures and uniform
buffers and push constants for the uniform parameters of pipelines.
Buffers are host visible and written only by the CPU, with copy on write
of storage still in use by the GPU, which preserves the OpenGL semantics
the rest of kitty relies on without the CPU ever waiting for the GPU.
Pipelines have variants for each render target format, blend mode and
set of vertex input formats, created when first used. Vertex strides are
dynamic state.

Rendering is pixel identical to OpenGL in the screenshot comparisons,
with the validation layers reporting no errors.

Integer textures are now declared in the shaders with their actual
number of channels, as Vulkan requires the format of the image in the
SPIR-V to match the texture. Drivers that cannot determine the size of
uniform blocks, such as Vulkan without SPIR-V reflection, can now report
it as zero.
2026-11-19 07:35:31 +05:30
Kovid Goyal
bfbc1b25ed
Add a SPIR-V shader target for the built-in and custom shaders
Shader targets of the form spirv-NN (for SPIR-V N.N) compile each
program to a single SPIR-V module containing the entry points for all
stages, along with the same backend neutral program metadata as for
GLSL. The compiled modules are validated with spirv-val, when it is
available. Custom shaders are compiled at runtime for SPIR-V targets as
well, and the tests compile and validate all bundled custom shaders for
SPIR-V in addition to the target of the loaded driver.

The program metadata now includes the names of the entry points, which
are passed to drivers in GPUShaderSource, since a module can contain
the entry points of several stages. compile_program() accepts binary
shaders as bytes.

This replaces the unused, untargeted .spv files that were built before.
2026-11-19 07:35:31 +05:30
Kovid Goyal
21e84451d0
Use the coordinate conventions of Vulkan and Metal for the GPU API
Pixel coordinates of viewports, scissor rectangles and read back pixels
now have their origin at the top left of the render target, rows are
read back top to bottom, NDC y=-1 is the top of the viewport and render
targets have their top row at texture coordinate t=0, the same as
uploaded images. Vulkan and Metal drivers can then render with no flips
at all.

The OpenGL driver is now the special case. Framebuffer objects already
behave this way, so it converts only when rendering to a window: vertex
shaders negate gl_Position.y via a kitty_flip_y uniform that the GLSL
fixup adds, viewport and scissor y coordinates are converted, rows of
read back pixels are reversed and copying to a texture uses a flipping
blit.

kitty's code gets simpler: viewports and scissor rectangles no longer
need the framebuffer height, screenshots no longer need their rows
flipped and textures produced by rendering are sampled the same way as
uploaded ones. The rounded rect shader no longer uses SV_Position, whose
origin differs between backends.

User facing custom shader UV coordinates are unchanged, still with
their origin at the bottom left.

Rendering is pixel identical to before.
2026-11-19 07:35:31 +05:30
Kovid Goyal
9367df7010
Add a gpu_driver option to choose between GPU drivers with fallback
The gpu_driver option is an ordered list of the GPU drivers to try,
defaulting to metal, vulkan, opengl. Drivers that are not part of the
build are skipped.

Add connect() to the GPU driver API. It is called once the windowing
system has been initialized, with the connection to the display, so
that drivers can check that they are able to render to windows on it,
before any windows are created. The driver is now loaded after
glfwInit() for this reason. If a driver cannot connect, the next one is
tried. If the driver fails to choose a visual or create a surface for
the first window, before any GPU resources exist, kitty switches to the
next usable driver and creates the window again.

--debug-rendering reports the driver used and why others were rejected.
2026-11-19 07:35:31 +05:30
Kovid Goyal
0b386f5564
Pass the uniform parameters of shaders in a single push constant block
Declare the uniform parameters of every program as a single Params
struct, shared by all stages of the program, in a push constant block,
instead of as uniform parameters of the entry points. Slang lays out
the uniform parameters of each entry point starting at offset zero, so
the vertex and fragment parameters overlap, which Vulkan does not allow
in push constants. A single block shared by all stages is also what
Metal wants, and it is still emitted as loose uniforms for OpenGL.

The build now fails if a program has entry point uniform parameters or
more than 128 bytes of them, the push constant size guaranteed by Vulkan.

Since a program now has at most one block of uniform parameters, drop
the stage from GPUParamBlock, bump the GPU API version, and simplify
the lookup of parameters by name in kitty, as each name is now present
in only one parameter block.
2026-11-19 07:35:31 +05:30
Kovid Goyal
5a4ee9912f
fix build on macOS 2026-11-19 07:35:31 +05:30
Kovid Goyal
b0fdcdcdf4
Replace loose uniforms with parameter blocks
The small, frequently changing parameters of a pipeline, the uniform
parameters of each entry point and uniform blocks whose contents are
constant for the lifetime of a pipeline (currently only the gamma LUT),
are now parameter blocks whose layout comes from the shader reflection
data. kitty writes their contents into memory it owns and passes changed
blocks to the driver with set_params() just before drawing, instead of
setting individual uniforms by location.

This is the only way parameters are set, so the GL specific
pipeline_uniform_slot() and set_uniform_*() functions are gone from the
driver API. Drivers are free to implement parameter blocks as they see
fit: the OpenGL driver uses loose uniforms, uploading only the fields that
changed, Vulkan would use push constants and Metal set*Bytes().

Pipeline creation, including all parsing of the program metadata, now
lives in kitty/gpu.c.
2026-11-19 07:35:31 +05:30
Kovid Goyal
7cbe680869
Declare texture and uniform block binding slots in the shaders
Every texture and uniform block in kitty's shaders now declares its
binding slot with [[vk::binding(N)]], from a single documented table,
SHADER_BINDING_SLOTS, which the shader build verifies. Slots are unique
across shaders and kinds of resource, as Vulkan requires, and so that
resources bound once and used by many programs, such as the sprite
textures, are never displaced by another program's bindings.

The slots are passed to the C code in the program metadata, which no
longer hard codes texture units or uniform buffer binding points, and no
longer sets sampler uniforms or calls glUniformBlockBinding() equivalents.
Instead the driver receives the slots when a pipeline is created. The
OpenGL driver applies them to the linked program since OpenGL 3 has no
layout(binding) qualifiers; targets where the slots are part of the
compiled code can ignore them.
2026-11-19 07:35:31 +05:30
Kovid Goyal
b746bc6ad9
Make shader targets driver defined and program metadata reflection based
Each GPU driver now declares the shader target it consumes (glsl-140 for
the OpenGL driver), a fixed property available as soon as the driver is
loaded. setup.py compiles the built-in shaders for the targets of the
drivers it builds, into a directory per target, and custom shaders are
compiled at runtime for the target of the loaded driver. The GLSL_VERSION
constant is no longer exported to Python.

The program metadata passed to the C code is now generated from the
reflection data produced by slangc and is backend neutral: vertex input
locations, uniform names, uniform block sizes and array layouts, all
identified by their names in the Slang source. Block sizes are verified
against the driver. The only target specific part is a map from Slang
names to the identifiers in the compiled code, which the OpenGL driver
needs to look up parameters by name and which is passed to the driver
when creating a pipeline. The driver no longer needs to be queried for
uniform array layouts.

The debug config output now uses the name reported by the driver.
2026-11-19 07:35:30 +05:30
Kovid Goyal
a219bf7ffc
Move OpenGL context creation from glfw into the GPU driver
glfw is now a windowing only library. It no longer creates OpenGL
contexts and contains no GLX, EGL, NSGL or OSMesa code. Instead it
exposes native window handles, and the GPU driver creates surfaces that
render into them, owning everything needed to render and present, such
as OpenGL contexts or, in future, Vulkan swapchains.

The GPU driver API (now version 2) gains surfaces: creation from native
X11, Wayland and Cocoa windows, making current, resizing, presenting,
swap interval, handling native view changes and recreation (macOS) and
choosing the X11 visual before window creation. The OpenGL driver
implements them with GLX on X11, EGL on Wayland and NSGL on macOS, all
ported from glfw, loading every library at runtime.

glfw gains a GLFW_X11_VISUAL_ID window hint, a native surface changed
callback (used on macOS where the NSOpenGLContext must be updated) and
glfwWindowContentsPresented(), which on Wayland commits surface state
after a frame is presented. The OpenGL context API, hints and the
share parameter of glfwCreateWindow() are removed.

The macOS (NSGL) code is untested as it could not be built.
2026-11-19 07:35:30 +05:30
Kovid Goyal
79f6482342
glfw: Remove the null/OSMesa and Win32 platform entries
kitty never builds them and the Win32 sources do not exist in the repo.
2026-11-19 07:35:30 +05:30
Kovid Goyal
33eeb81878
Add a build check for the OpenGL GPU driver 2026-11-19 07:35:30 +05:30
Kovid Goyal
a7d0537a19
Move the kitty OpenGL code into a dynamically loaded GPU driver
All OpenGL calls now live in gpu/opengl, which is built as kitty/opengl.so,
next to the glfw backends. glfw_init() is passed the path to the driver and
loads it. The driver is initialized once the first OpenGL context is
current. fast_data_types no longer links against libGL.

kitty/gpu.c contains the driver loader and the higher level helpers
(programs and their metadata, vertex array objects, viewport stack) that
were previously in kitty/gl.c, implemented on top of the driver API.
shaders.c and the rest of kitty use only the driver API.

Also remove the unused GL_* constants and the unused bind_program,
create_vao, etc. functions exported to Python.
2026-11-19 07:35:30 +05:30
Kovid Goyal
db7ddb006b
Add a backend neutral GPU driver API
gpu/api.h defines the interface between kitty and dynamically loaded GPU
drivers. It uses only standard C types, with opaque 64 bit handles for all
resources, so that it can be implemented with OpenGL, Vulkan or Metal.
2026-11-19 07:35:30 +05:30
Kovid Goyal
9a5c37a01d
Fix crash in Screen.hyperlink_at() with out of bounds coordinates
Fixes #10890
2026-11-19 07:23:44 +05:30
Kovid Goyal
c83027daa9
Fix test_launch_wrapper_invalid_shell on macOS
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
CodeQL / CodeQL-Build (actions, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, macos-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (go, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (python, ubuntu-latest) (push) Waiting to run
Depscan / Scan dependencies for vulnerabilities (push) Waiting to run
On macOS the default shell is run via /usr/bin/login and the run-shell
kitten, with the user wrapper placed inside login, so the expected argv
differs from Linux.
2026-11-18 20:44:44 +05:30
Kovid Goyal
e87f68becd
skip test under qemu emulation 2026-11-18 20:17:58 +05:30
Kovid Goyal
2e62f9c96b
fix flaky test 2026-11-18 19:48:52 +05:30
Kovid Goyal
32f3f1dc71
version 0.51.0
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
CodeQL / CodeQL-Build (actions, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, macos-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (go, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (python, ubuntu-latest) (push) Waiting to run
Depscan / Scan dependencies for vulnerabilities (push) Waiting to run
2026-11-18 19:06:55 +05:30
Kovid Goyal
ecac1af6dd
Update changelog 2026-11-18 19:06:05 +05:30
Kovid Goyal
5b33eff326
Cleanup previous PR 2026-11-18 17:11:36 +05:30
Kovid Goyal
8c281acb99
Merge branch 'codex/fix-launch-wrapper-shell-fallback' of https://github.com/hezhizhen/kitty 2026-11-18 17:09:59 +05:30
Zhizhen He
c805a6e2a4 Fall back when launch wrapper context setup fails
Building LaunchContext resolves the configured shell. Catch that failure at the launch wrapper boundary so an explicit command can still start.
2026-11-18 19:14:42 +08:00
Kovid Goyal
b4b186a6ad
Cleanup previous PR
- Treat trailing empty SGR color parameters as zero, matching the terminal
- Ignore the color space id in colon form RGB colors (38:2:id:r:g:b)
- Fix bright colors (90-97, 100-107, 38;5;8-15) being re-emitted off by one
- Handle parse errors explicitly and simplify color target selection
- Add tests for SGR state parsing
2026-11-18 15:04:55 +05:30
Kovid Goyal
f8e5ec9345
Merge branch 'codex/fix-sgr-wrap-colors' of https://github.com/hezhizhen/kitty 2026-11-18 15:03:27 +05:30
Zhizhen He
188d248965 Fix wrapping of text with extended SGR colors 2026-11-18 15:33:48 +08:00
Kovid Goyal
8ddc22cd96
Merge branch 'codex/fix-launch-wrapper-child-cache' of https://github.com/hezhizhen/kitty
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
CodeQL / CodeQL-Build (actions, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, macos-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (go, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (python, ubuntu-latest) (push) Waiting to run
Depscan / Scan dependencies for vulnerabilities (push) Waiting to run
2026-11-18 09:48:44 +05:30
Kovid Goyal
179b4b1c5a
docs: Have the :commit: role fall back to linking the given id when there is no git history
Source archives have no git history, so building the docs from them
produced errors for every :commit: reference. Closes #10885
2026-11-18 09:40:29 +05:30
Zhizhen He
fea2fff082 Avoid caching helper PIDs for launch wrappers
A user launch wrapper can start a persistent helper before the command. Use a lone, unmatched child for the current lookup and cache the child only once its command line matches the launch arguments.
2026-11-18 12:04:49 +08:00