Info
Creation Moment: 2025-06-04 @ 23:11
I have heard that I should install a separate terminal if I want to fully customize it. 2 options that were provided were:
This below table is a summarization of this reddit thread made with chatgpt.
| Category | Kitty | WezTerm |
|---|---|---|
| Configuration Language | Plain-text config with fixed attributes; easy to edit but less programmatic flexibility. | Lua-based, highly scriptable—matches Neovim/other dotfiles and allows conditional logic. |
| Performance | Smooth scrolling, lower RAM usage, very responsive for keystrokes. | Some users report slight scroll lag and higher memory usage. |
| Image Support | Native image backend (kitten icat); fast and reliable for inline images. | Uses iTerm2 protocol (Kitty-protocol support still in progress); requires ueberzugpp for some plugins (slower for image.nvim). |
| Multiplexing & SSH | Relies on external tmux; no built-in session persistence. | Built-in multiplexer (tmux replacement) that persists remote sessions if connection drops; however, Unix-domain sockets can break clipboard pasting in Neovim for some workflows. |
| Cross-Platform | Linux & macOS (no official Windows version). | Linux, macOS & Windows—consistent experience across all three platforms. |
| Documentation | Well-organized docs; easy to find settings for colors, opacity, themes, etc. | Praised for “amazing” documentation and quick issue resolution on GitHub. |
| Text Rendering | Superior subpixel anti-aliasing out of the box; crisper, sharper fonts. | Some fonts look thin/fuzzy or artifact-y; disabling hinting can help, but still perceived as less crisp by some users. |
| Themes & Aesthetics | Supports “kitty kitten-themes” or custom .conf files (e.g., cherry-midnight); fewer built-in themes by default. | Hundreds of built-in themes; Lua scripts can toggle light/dark, allow dynamic background workflows, and integrate theme switching with Neovim or window manager. |
| Community Feedback | Stable track record; fewer reported issues, many users praise its reliability. | Enthusiastic user base, but a growing number of GitHub issues (e.g., CPU usage spikes, clipboard quirks). |
| User Preference | Chosen by users who prioritize smoothness, fast image support, and lower resource usage. | Favored by those who want Lua configuration, built-in multiplexing, and a uniform terminal on Linux/macOS/Windows. |
And this is a bigger table that chatgpt added it’s own facts to:
| Category | Kitty | WezTerm |
|---|---|---|
| Configuration Language | Plain-text config (kitty.conf) with fixed attributes and directives. Easy to edit for straightforward settings (e.g., color schemes, font sizes, transparency), but lacks conditional logic or advanced scripting. Adding complex behavior often requires external scripts or workarounds. | Lua-based config (wezterm.lua), which allows conditional logic, functions, and direct integration with other Lua-based tools (Neovim, AwesomeWM). You can dynamically generate keybindings, adjust settings based on environment variables, and even embed custom UI elements. This makes complex, context-aware configuration (e.g., toggling light/dark themes automatically) more concise. |
| Performance | Generally very smooth scrolling, low CPU load, and modest RAM usage (typically under 50 MB at idle). GPU-accelerated rendering ensures minimal redraw lag even with intensive workloads (e.g., long scrollback history). Startup is near-instantaneous. On Wayland, performance remains snappy, though some users report minor flickering when resizing extremely quickly. | Excellent GPU performance via OpenGL/Vulkan backends, but some users report slightly higher RAM usage (around 70–100 MB at idle) and occasional brief stutters when scrolling very long outputs. Startup time is fast but can be marginally slower if many Lua extensions or themes load at launch. On Wayland, it integrates well and can yield smooth rendering, though early Wayland adopters have noted occasional flicker when resizing or font hinting adjustments. Overall, performance is competitive, but you may need to tweak font rendering settings (disable hinting or adjust “font_size”) to match Kitty’s crispness. |
| Image Support | Native image backend via kitty +kitten icat, offering fast inline PNG/JPEG/BMP display with true color and transparency support. Excellent for tools like viu, ranger previews, or displaying static graphics in-line. Supports sixel and other protocols via third-party plugins. | Supports the iTerm2 image protocol for inline images and is gradually adding support for the Kitty image protocol. Plugins like image.nvim may require ueberzugpp or fallback libraries if Kitty protocol is not yet fully usable. WezTerm’s CLI (wezterm imgcat) can display images, but performance is sometimes reported as slightly slower than Kitty’s native implementation. You can also pass SVG or even animated GIFs in-line, though animation support can be experimental. |
| Multiplexing & SSH | Does not include a built-in multiplexer. Many users pair Kitty with tmux or byobu; session persistence and split-pane management rely on these external tools. Clipboard copy-on-select is supported out of the box (Yank on select), but integration with Neovim in tmux can require custom keybindings. SSH sessions function as in any terminal; no special session persistence. | Includes a built-in multiplexer that can replace tmux entirely, with tabs, splits, and even “Workspaces” that auto-launch programs on startup. Sessions can persist remote SSH connections even if the network drops (via Unix domain sockets), though some users report clipboard-paste issues in Neovim when using this feature. Keybindings for multiplexing can be dynamically reconfigured in Lua. Built-in SSH multiplexing means you don’t need tmux unless you prefer it. |
| Cross-Platform | Officially supported on Linux (X11 and Wayland) and macOS. No native Windows binary—Windows users rely on WSL/X server or Cygwin workarounds. Feature set is identical across X11 and Wayland desktops, though Wayland clipboard integration may need wl-clipboard utilities. | Truly cross-platform: Linux (X11, Wayland), macOS, and Windows (via native Win32 or DirectWrite). Ensures consistent behavior and config across all OSes. For teams or users switching between OSes, you can carry the same wezterm.lua file without modifications. Some Windows-specific features (like Windows Conpty integration) make it feel more native than other terminals on Windows. |
| Documentation | Well-organized and concise documentation on the official site, with a clear list of configuration directives and examples. Includes “Kittens” section for built-in helper tools. Community-contributed snippets cover most common tweaks (opacity, color schemes, keybindings). However, advanced topics (e.g., Wayland-specific config or custom kitten development) can require searching GitHub issues. | Praised for extensive, example-rich documentation that covers Lua API reference, event hooks, and advanced use cases (e.g., custom tab bars or status updates driven by external scripts). The official docs include code snippets for theme cycling, custom layouts, and remote multiplexer setup. GitHub Discussions and an active Discord channel provide rapid feedback on user-reported issues. |
| Text Rendering | Uses FreeType with subpixel anti-aliasing and full HarfBuzz shaping. Text appears crisp, and ligatures work out of the box if you install a ligature-capable font. Subpixel hinting ensures clarity on most displays, especially non-HiDPI screens. Vertical and horizontal text alignment is precise, making powerline/powerline-like prompts look flawless. | Also uses FreeType and HarfBuzz, but some users notice thin or fuzzy rendering at certain font sizes or DPI settings. Hinting can be toggled off or configured in Lua: font { hinting = "None" } improves appearance but may make small fonts less readable. Ligature support is excellent, but on some monitors (particularly lower-end or non-HiDPI panels), glyph edges can appear slightly less sharp than in Kitty. If you tweak “font_shaper” (e.g., use Freetype or CoreText on macOS), you can get close to Kitty’s rendering. |
| Fonts & Ligatures | Full support for ligatures (e.g., Fira Code, JetBrains Mono). Fallback fonts can be defined, but advanced “font rules” (e.g., change font for specific Unicode ranges) require external scripts or manual switching. Line spacing, letter spacing, and DPI scaling are readily configured (e.g., letter_spacing, line_height). | Advanced “font_rules” allow specifying different fonts for emoji, CJK characters, or even conditional logic (e.g., if font fallback missing glyph). Ligatures are supported if the font includes them. You can also scale specific fonts differently (e.g., use a larger Nerd Font size for icons). This granular control is achievable directly in Lua, making it easier to set up multi-language emoji or powerline icons without external utilities. |
| Themes & Aesthetics | Includes a built-in “kitten themes” command that can switch between dozens of color schemes (e.g., Solarized, Gruvbox). You can download .conf files (e.g., cherry-midnight.conf) and include them via include /path/to/theme.conf. Supports per-window background images, transparency, and blur (on Wayland with wl-clipboard/picom). No native light/dark toggling; must use external scripts or tmux integration. | Ships with hundreds of built-in themes accessible via Lua or CLI toggles. You can write a small function in wezterm.lua to toggle between light/dark modes (e.g., based on time of day or Neovim’s active theme). Background images are supported (PNG, JPG) with configurable opacity and stretch modes. Animations—like fading in a new color scheme—can be scripted via events. Transparency requires a compositor (picom on Linux). WezTerm also supports “visual bell” and “audible bell” customizations, as well as fine-grained cursor styles (e.g., blinking bar vs. breadbox block). |
| Unicode & Emoji Support | Excellent Unicode support, including emoji. Uses HarfBuzz to render complex scripts (Devanagari, Arabic) correctly. Emoji rendering depends on installed fonts (e.g., Noto Color Emoji), and color emoji display may require additional libraries. Some users need to install kitty +kitten emoji plugin for faster emoji previews. | Supports full Unicode range and color emoji if your OS and font renderer allow it (e.g., Noto Color Emoji on Linux with Color Emoji patched fonts). Lua config can specify emoji fallback fonts automatically. Some users report more consistent emoji sizing compared to Kitty, especially when using “scaled” fonts for different Unicode blocks. Complex scripts render correctly, and right-to-left languages (Hebrew, Arabic) are displayed well. |
| Keybindings Customization | Keybindings defined in kitty.conf with a simple syntax (map ctrl+shift+t new_tab). Easy to remap common shortcuts (copy, paste, split window), but adding conditional logic (e.g., “if Neovim is focused, send this key; else do something else”) is not possible without external scripts. Mouse support (e.g., URL click, copy-on-select) is built-in. | Keybindings defined in Lua tables (e.g., `keys = { {key=“t”, mods=“CTRL |
| Protocol Support | Supports most common protocols: OSC 52 clipboard integration, Kitty’s own protocol extensions (like high-resolution graphics), sixel (via enabled “sixel support”), and true color (24-bit). Does not support WezTerm’s experimental glyphs or iTerm2-specific features. | Native support for OSC 52, iTerm2 image protocol, Sixel (if enabled at compile time), and even custom hyperlinks via OSC 8. Experimental support for Kitty’s image protocol is in progress but not fully stable. WezTerm can also handle advanced features like “Focusable hyperlinks” and hyperlinks with custom mouse-over tooltips. Its Lua API allows you to intercept and respond to escape sequences programmatically (e.g., display a widget when a certain sequence is received). |
| Compositing & Effects | Supports background transparency and blur on Wayland (with wl-clipboard and picom). You can use a local video or animated GIF as the background by piping frames via external scripts, though this is unofficial and requires CPU/GPU workarounds. No built-in particle or shader effects; any advanced graphics rely on external compositors. | Supports transparent backgrounds if a compositor (e.g., picom or xcompmgr) is running. You can set blur levels on the background or overlay semi-transparent images. Because it renders with GPU via OpenGL/Vulkan, it can integrate with desktop effects more seamlessly. Users have created Lua scripts to cycle backgrounds periodically (e.g., dynamic wallpapers) or fade between themes. While not as “flashy” as a window manager shader, WezTerm’s GPU foundation allows smoother transitions when toggling transparency or changing background images. |
| Startup Time | Near-instant launch (< 0.1 s) even with complex themes or background images. Configuration parsing is very fast due to the simple, declarative format. | Fast startup (~ 0.2–0.3 s) on most systems. If your wezterm.lua contains extensive Lua logic (e.g., functions that fetch data, query environment variables, or load many modules), initialization can take slightly longer. Cache-friendly: you can enable “config_bonjour” to reload faster, but extremely complex configs may add noticeable startup delay. |
| Community & Issue Response | Active GitHub repository with ~ 30 contributors. Issues tend to be triaged quickly, but major feature requests (e.g., new protocols) can take time. Community snippets and Gist examples for color schemes or config tips are plentiful. There’s a subreddit (/r/kitty_terminal) and a Gitter/Discord channel for discussions. | Rapidly growing community with ~ 100 contributors. The maintainer, Kovid Goyal, is highly responsive—many issues resolved or discussed within hours. An official Discord server with dedicated channels for scripting, color schemes, and troubleshooting fosters fast peer support. GitHub Discussions posts often include complete example configs. |
| Learning Curve | Low to medium: Basic edits are straightforward (colors, fonts, transparency). To leverage advanced features (e.g., kittens, protocol extensions), you may need to read more documentation or experiment with command-line options. | Medium to high: Requires familiarity with Lua syntax and some programming concepts to fully take advantage. Simple changes (font size, colors) are easy, but writing functions or conditional configurations demands understanding Lua tables, functions, and WezTerm’s API. New users without Lua experience may need a brief learning period. |
| Update Frequency & Stability | Releases every 2–3 months on average, with minor patches in between. Versioning follows semantic patterns, and backward-incompatible changes are rare. Most users feel comfortable upgrading without fearing major breakage. | Aggressive release cycle: new features and bug fixes released every few weeks. Major version bumps occur roughly every 4–6 months. Some users appreciate the fast pace and rapid bug fixes; others report occasional regressions or minor API changes in config. Overall, commits are well-documented, changelogs are detailed, and rolling back to previous versions is straightforward. |
| Plugin & Extension Ecosystem | Kitty isn’t inherently “pluggable” beyond its built-in kittens, but external utilities like ranger or lsix can integrate seamlessly. Users share “kittens” (small Python scripts) for tasks like periodic screenshots or notifications. No centralized plugin marketplace; most examples live on GitHub or Gists. | WezTerm supports embedding Lua modules directly in the config. There’s no formal plugin system, but you can require community-maintained Lua scripts for custom status bars, event handling, or theme cycling. LuaRocks packages can be used if you integrate with your system’s Lua environment. Community-curated “wezterm-extensions” GitHub org hosts sample plugins. |
| Wayland & X11 Support | Full support for Wayland (via wl-clipboard integration) and X11. Clipboard integration on Wayland requires extra utilities (wl-clipboard, xclip). You can configure keyboard shortcuts differently for each backend. Wayland performance is on par with X11, and blur/transparency effects work best on Wayland composite managers. | Equally robust on X11 and Wayland. Clipboard integration on Wayland is seamless (no extra tools required), and you can configure Wayland-specific settings (e.g., enable_wayland = true). Font DPI scaling is more consistent on Wayland. Some early Alpha Wayland features (like fractional scaling) are still being polished but overall are production-ready. |
| Security & Sandboxing | Kitty doesn’t sandbox or restrict escape sequences by default; you can enable allow_remote_control or disable unsafe protocols manually. Users on shared systems sometimes recommend running Kitty with a restricted profile to avoid malicious escape sequences. | WezTerm includes options to disable certain escape sequences (enable_kitty_keyboard_input, disable_lua) and can operate in a more locked-down mode. Since it’s written in Rust, memory safety bugs are less common than in C/C++ applications. You can run WezTerm with --config-file pointing to a trusted directory to avoid untrusted configs. |
| Extensibility & Scripting | Limited to “kittens” (Python scripts packaged with Kitty) and command-line flags. For truly custom behavior (e.g., pulling weather info into the tab bar), you need an external script that writes to STDOUT or sends escape codes. No embedded scripting language beyond kittens. | Deeply extensible via Lua: you can register event handlers (e.g., window:perform_action(Action)), write custom status lines, intercept key events, and even draw custom overlays on the terminal viewport. For example, you could write a Lua function that fetches CPU usage every second and displays it in the title bar. This level of programmatic control is unparalleled compared to Kitty’s kittens. |
| Remote Development | Typically used in conjunction with ssh, mosh, or remote pairing tools. Kitty itself doesn’t manage persistence; users rely on tmux or ssh -t. Copy-on-select and primary selection work over SSH with xclip or wl-clipboard. | Built-in remote multiplexing: you can configure a “remote workspace” in wezterm.lua that spawns an SSH session and automatically reconnects if the connection drops. This removes the need for tmux for many users. Clipboard integration over SSH is automatic, though some advanced URIs (e.g., hyperlinks) may require special handling. |
| Startup Artwork & Customization | Kitty does not have native support for displaying artwork on startup, but you can call external utilities (e.g., neofetch, catimg, jp2a, or chafa) in your shell’s startup file (~/.bashrc/~/.zshrc). Because Kitty supports sixel and true color, you can render complex images or ASCII art easily. Users have scripted periodic background changes with shell hooks. | Similar approach: use shell startup scripts to call wezterm imgcat /path/to/image.png or run neofetch. Additionally, because of Lua’s event hooks, you could theoretically write a small Lua function that displays an image in the terminal buffer when WezTerm window opens (window:perform_action(Action::ShowLauncher), or a custom on_startup hook). This yields slightly tighter integration than Kitty, but usually externals tools suffice. |
| Compositor & Visual Effects | Relies on an external compositor (e.g., picom on X11, wlroots compositors on Wayland) for blur, transparency, and drop shadows. Fine-grained control over background blur strength isn’t exposed in Kitty; you adjust it in the compositor’s config. | Also requires a compositor for effects. However, WezTerm’s GPU rendering means transitions (e.g., changing opacity) appear smoother. Some users even experiment with dynamic shader injections (e.g., edge glow, custom fragment shaders) because WezTerm exposes its rendering context through Lua, though these are experimental. |
| Fallback & Recovery | If Kitty fails to render (e.g., missing font glyph), it substitutes a fallback glyph but does not crash. If a config directive is invalid, Kitty logs an error to STDERR and uses default settings for that directive. Does not support “safe mode” on launch. | Provides a “safe mode” (wezterm --config-file /dev/null) to launch with defaults if your wezterm.lua is broken. If a Lua error occurs during parsing, WezTerm prints a stack trace and falls back to compiled defaults. This makes it easier to recover from syntax errors. |
| Community Themes & Assets | Hundreds of community theme files scattered across GitHub and Gist, but no centralized repository. Users often share “dotfiles” that include their custom Kitty configs. Sites like terminal.sexy can export to Kitty format. | Official “wezterm-themes” repository on GitHub curates dozens of color schemes with one-liner imports. You can git clone and then add require("wezterm_themes").load("Gruvbox") to your config. Thematic consistency can be achieved across WezTerm, Neovim, and other Lua-based tools via shared theme modules. |
| Noise & Distractions | Kitty’s default bell is a visual flash; you can disable it or replace it with an audible beep. Some users find Kitty’s animations (e.g., when scrolling fast) to be too subtle; no options for customizing scrollback “rubber-band” effect. | WezTerm allows customizing visual bell (e.g., fade to a specific color). You can even script a blinking notification in the corner of the window via Lua. Audible bell can be replaced with a sound file. For users who dislike animations altogether, you can disable smooth scrolling and configure “immediate” redraw. |
| Scripting & Automation | Automation revolves around external scripts (Bash, Python) that send escape sequences or call kitty +kitten .... There’s no embedded language (aside from Python-Kittens) for complex logic. Example: to automatically split panes based on SSH destination, you’d write a shell script that calls Kitty’s CLI. | Lua’s complete integration means you can write functions to change layouts when certain programs start or react to terminal events (e.g., on “zoom changed” or “pane closed”). You can hook into a “format_tab_title” event to display dynamic content (battery, time) without external scripts. This reduces reliance on shell scripts and centralizes logic in one wezterm.lua. |
| Resource Footprint | Typically uses around 30–50 MB RAM when idle, spiking moderately under heavy scrolling or with large scrollback buffers. GPU usage is minimal (< 2% on modern hardware). No significant memory leaks reported over long uptimes (days). | Often uses 60–100 MB RAM at idle, depending on loaded modules and themes. GPU usage peaks (~ 5–10%) during intensive redraws (e.g., when rapidly updating many lines). Some users report minor memory growth over days of continuous use, though this is usually cleared by restarting. Overall resource demands are higher than Kitty’s, but still modest for modern systems. |