kitty/kitty/constants.py
Kovid Goyal 2b4422cc9a
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-18 08:26:41 +05:30

374 lines
12 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#!/usr/bin/env python
# License: GPL v3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
import os
import pwd
import sys
from collections.abc import Iterable, Iterator
from contextlib import suppress
from typing import TYPE_CHECKING, Any, NamedTuple, Optional
from .types import run_once
if TYPE_CHECKING:
from .options.types import Options
class Version(NamedTuple):
major: int
minor: int
patch: int
appname: str = 'kitty'
kitty_face = '🐱'
version: Version = Version(0, 50, 0)
str_version: str = '.'.join(map(str, version))
_plat = sys.platform.lower()
is_macos: bool = 'darwin' in _plat
is_freebsd: bool = 'freebsd' in _plat
is_running_from_develop: bool = False
RC_ENCRYPTION_PROTOCOL_VERSION = '1'
website_base_url = 'https://sw.kovidgoyal.net/kitty/'
default_pager_for_help = ('less', '-iRXF')
kitty_run_data: dict[str, Any] = getattr(sys, 'kitty_run_data', {})
launched_by_launch_services = kitty_run_data.get('launched_by_launch_services', False)
is_quick_access_terminal_app = kitty_run_data.get('is_quick_access_terminal_app', False)
unserialize_launch_flag = 'kitty-unserialize-data='
_slangc: tuple[str, ...] = ()
def slangc() -> tuple[str, ...]:
global _slangc
if not _slangc:
from kitty.fast_data_types import DEVELOP_ROOT, Shlex
if DEVELOP_ROOT:
_slangc = (os.path.join(DEVELOP_ROOT, 'bin', 'slangc'),)
else:
_slangc = tuple(Shlex(os.environ.get('SLANGC', 'slangc'), False))
return _slangc
if getattr(sys, 'frozen', False):
extensions_dir: str = kitty_run_data['extensions_dir']
def get_frozen_base() -> str:
global is_running_from_develop
try:
from bypy_importer import running_in_develop_mode # type: ignore
except ImportError:
pass
else:
is_running_from_develop = running_in_develop_mode()
if is_running_from_develop:
q = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
try:
if os.path.isdir(q):
return q
except OSError:
pass
ans = os.path.dirname(extensions_dir)
if is_macos:
ans = os.path.dirname(os.path.dirname(ans))
ans = os.path.join(ans, 'kitty')
return ans
kitty_base_dir = get_frozen_base()
if rpath := kitty_run_data.get('bundle_exe_dir'):
_slangc = (os.path.join(rpath, 'slangc'),)
del get_frozen_base, rpath
else:
kitty_base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
extensions_dir = os.path.join(kitty_base_dir, 'kitty')
@run_once
def kitty_exe() -> str:
rpath = kitty_run_data.get('bundle_exe_dir')
if not rpath:
items = os.environ.get('PATH', '').split(os.pathsep) + [os.path.join(kitty_base_dir, 'kitty', 'launcher')]
seen: set[str] = set()
for candidate in filter(None, items):
if candidate not in seen:
seen.add(candidate)
if os.access(os.path.join(candidate, 'kitty'), os.X_OK):
rpath = candidate
break
else:
raise RuntimeError('kitty binary not found')
return os.path.join(rpath, 'kitty')
@run_once
def kitten_exe() -> str:
return os.path.join(os.path.dirname(kitty_exe()), 'kitten')
def _get_config_dir() -> str:
cdir = kitty_run_data.get('config_dir', '')
if cdir:
return str(cdir)
import atexit
import tempfile
ans = tempfile.mkdtemp(prefix='kitty-conf-')
def cleanup() -> None:
import shutil
with suppress(Exception):
shutil.rmtree(ans)
atexit.register(cleanup)
return ans
config_dir = _get_config_dir()
del _get_config_dir
defconf = os.path.join(config_dir, 'kitty.conf')
# When True, auxiliary files in config_dir that kitty loads implicitly, such as
# the automatic color theme files, open-actions.conf, etc. are ignored. Set when
# kitty is run with --config=NONE.
_ignore_config_dir_files = False
def set_ignore_config_dir_files(val: bool) -> None:
global _ignore_config_dir_files
_ignore_config_dir_files = val
def config_dir_files_ignored() -> bool:
return _ignore_config_dir_files
@run_once
def cache_dir() -> str:
if 'KITTY_CACHE_DIRECTORY' in os.environ:
candidate = os.path.abspath(os.environ['KITTY_CACHE_DIRECTORY'])
elif is_macos:
candidate = os.path.join(os.path.expanduser('~/Library/Caches'), appname)
else:
candidate = os.environ.get('XDG_CACHE_HOME', '~/.cache')
candidate = os.path.join(os.path.expanduser(candidate), appname)
os.makedirs(candidate, exist_ok=True)
return candidate
@run_once
def runtime_dir() -> str:
if 'KITTY_RUNTIME_DIRECTORY' in os.environ:
candidate = os.path.abspath(os.environ['KITTY_RUNTIME_DIRECTORY'])
elif is_macos:
from .fast_data_types import user_cache_dir
candidate = user_cache_dir()
elif 'XDG_RUNTIME_DIR' in os.environ:
candidate = os.path.abspath(os.environ['XDG_RUNTIME_DIR'])
else:
candidate = f'/run/user/{os.geteuid()}'
if not os.path.isdir(candidate) or not os.access(candidate, os.X_OK | os.W_OK | os.R_OK):
candidate = os.path.join(cache_dir(), 'run')
os.makedirs(candidate, exist_ok=True)
import stat
if stat.S_IMODE(os.stat(candidate).st_mode) != 0o700:
os.chmod(candidate, 0o700)
return candidate
def wakeup_io_loop() -> None:
from .fast_data_types import get_boss
b = get_boss()
if b is not None:
b.child_monitor.wakeup()
terminfo_dir = os.path.join(kitty_base_dir, 'terminfo')
logo_png_file = os.path.join(kitty_base_dir, 'logo', 'kitty.png')
beam_cursor_data_file = os.path.join(kitty_base_dir, 'logo', 'beam-cursor.png')
shell_integration_dir = os.path.join(kitty_base_dir, 'shell-integration')
fonts_dir = os.path.join(kitty_base_dir, 'fonts')
shaders_dir = os.path.join(kitty_base_dir, 'shaders')
try:
shell_path = os.environ.get('SHELL') or pwd.getpwuid(os.geteuid()).pw_shell or '/bin/sh'
except KeyError:
with suppress(Exception):
print('Failed to read login shell via getpwuid() for current user, falling back to /bin/sh', file=sys.stderr)
shell_path = '/bin/sh'
# Keep this short as it is limited to 103 bytes on macOS
# https://github.com/ansible/ansible/issues/11536#issuecomment-153030743
ssh_control_master_template = 'kssh-{kitty_pid}-{ssh_placeholder}'
# See https://specifications.freedesktop.org/icon-naming-spec/latest/ar01s04.html
# Update the spec in docs/desktop-notifications.rst if you change this.
standard_icon_names = {
'error': ('dialog-error', '☠'),
'warning': ('dialog-warning', '⚠'),
'warn': ('dialog-warning', '⚠'),
'info': ('dialog-information', 'ℹ'),
'question': ('dialog-question', '❔'),
'help': ('system-help', '📖'),
'file-manager': ('system-file-manager', '🗄'),
'system-monitor': ('utilities-system-monitor', '🎛'),
'text-editor': ('utilities-text-editor', '📄'),
}
# See https://github.com/TUNER88/iOSSystemSoundsLibrary for Apple's system
# sound ids not all of which are available on macOS.
standard_sound_names = {
'error': ('dialog-error', 1),
'info': ('dialog-information', 2),
'warning': ('dialog-warning', 3),
'warn': ('dialog-warning', 3),
'question': ('dialog-question', 4),
}
def glfw_path(module: str) -> str:
prefix = 'kitty.' if getattr(sys, 'frozen', False) else ''
return os.path.join(extensions_dir, f'{prefix}glfw-{module}.so')
def gpu_driver_path(driver: str = 'opengl') -> str:
prefix = 'kitty.' if getattr(sys, 'frozen', False) else ''
return os.path.join(extensions_dir, f'{prefix}{driver}.so')
# The drivers that can render using a software renderer, used for the software
# value of the gpu_driver option, in order of preference. macOS has no
# software renderers for Metal and modern OpenGL.
SOFTWARE_GPU_DRIVERS = () if is_macos else ('vulkan', 'opengl')
def available_gpu_drivers(names: Iterable[str]) -> list[tuple[str, str, bool]]:
# The (name, path, software) of the specified GPU drivers that are present
# in this build of kitty, in the specified order. software is True for the
# drivers that must use a software renderer, from the software value.
ans = []
for name in names:
software = name == 'software'
for driver in SOFTWARE_GPU_DRIVERS if software else (name,):
path = gpu_driver_path(driver)
if os.path.exists(path):
ans.append((driver, path, software))
return ans
def detect_if_wayland_ok() -> bool:
if not os.environ.get('WAYLAND_DISPLAY') and not os.environ.get('WAYLAND_SOCKET'):
return False
if os.environ.get('KITTY_DISABLE_WAYLAND'):
return False
wayland = glfw_path('wayland')
if not os.path.exists(wayland):
return False
import ctypes
with suppress(Exception):
setattr(detect_if_wayland_ok, 'keep_module_loaded', ctypes.CDLL(wayland))
return True
return False
def is_wayland(opts: Optional['Options'] = None) -> bool:
if is_macos:
return False
if opts is None:
return bool(getattr(is_wayland, 'ans'))
if opts.linux_display_server == 'auto':
ans = detect_if_wayland_ok()
else:
ans = opts.linux_display_server == 'wayland'
setattr(is_wayland, 'ans', ans)
return ans
supports_primary_selection = not is_macos
def running_in_kitty(set_val: bool | None = None) -> bool:
if set_val is not None:
setattr(running_in_kitty, 'ans', set_val)
return bool(getattr(running_in_kitty, 'ans', False))
def list_kitty_resources(package: str = 'kitty') -> Iterator[str]:
from importlib.resources import files
return (path.name for path in files(package).iterdir())
def read_kitty_resource(name: str, package_name: str = 'kitty') -> bytes:
from importlib.resources import files
return (files(package_name) / name).read_bytes()
def website_url(doc_name: str = '', website: str = website_base_url) -> str:
if doc_name:
base, _, frag = doc_name.partition('#')
base = base.rstrip('/')
if base:
base += '/'
doc_name = base + (f'#{frag}' if frag else '')
return website + doc_name.lstrip('/')
handled_signals: set[int] = set()
def clear_handled_signals(*a: Any) -> None:
if not handled_signals:
return
import signal
if hasattr(signal, 'pthread_sigmask'):
signal.pthread_sigmask(signal.SIG_UNBLOCK, handled_signals)
for s in handled_signals:
signal.signal(s, signal.SIG_DFL)
@run_once
def local_docs() -> str:
d = os.path.dirname
base = d(d(kitty_exe()))
from_source = kitty_run_data.get('from_source')
if is_macos and from_source and '/kitty.app/Contents/' in kitty_exe():
base = d(d(d(base)))
subdir = os.path.join('doc', 'kitty', 'html')
linux_ans = os.path.join(base, 'share', subdir)
if getattr(sys, 'frozen', False):
if is_macos:
return os.path.join(d(d(d(extensions_dir))), subdir)
return linux_ans
if os.path.isdir(linux_ans):
return linux_ans
if from_source:
sq = os.path.join(d(base), 'docs', '_build', 'html')
if os.path.isdir(sq):
return sq
for candidate in ('/usr', '/usr/local', '/opt/homebrew'):
q = os.path.join(candidate, 'share', subdir)
if os.path.isdir(q):
return q
return ''
@run_once
def wrapped_kitten_names() -> frozenset[str]:
import kitty.fast_data_types as f
return frozenset(f.wrapped_kitten_names())
_supports_window_occlusion = False
def supports_window_occlusion(set: bool | None = None) -> bool:
global _supports_window_occlusion
if set is not None:
_supports_window_occlusion = set
return _supports_window_occlusion