Analyzing Linux Terminal Memory Usage: From xterm to Kitty

For many power users, the terminal is the primary interface for interacting with a Linux system. While we often obsess over the performance of our compilers, databases, or IDEs, the terminal emulator itself is frequently overlooked. However, when running a dozen instances across multiple virtual desktops, the cumulative memory footprint of your chosen terminal can become a significant system burden.

Recent benchmarks conducted by Giles Orr highlight a stark contrast in resource consumption across the Linux terminal landscape. From the ultra-minimalist st to the feature-heavy kitty, the difference in memory usage can be an order of magnitude, sometimes leading to severe system degradation on older hardware.

The Memory Gap: Benchmarking the Terminals

To understand the impact of terminal choice, a series of tests were conducted across two different environments: Openbox on X11 and KDE on Wayland. The goal was to measure the memory usage (specifically USS and PSS) before and after running a set of commands.

X11 Environment (Openbox)

In the X11 tests, the memory spread was dramatic. Minimalist terminals like st and xterm maintained a tiny footprint, while modern, feature-rich terminals consumed significantly more:

Terminal	USS (Before)	USS (After)
st	2,592	3,396
xterm	6,808	11,640
lxterminal	6,528	7,800
gnome-terminal	10,252	10,692
alacritty	34,224	40,188
kitty	56,376	70,716
ptyxis	54,760	58,252

Wayland Environment (KDE)

Similar trends appeared on Wayland, though some terminals showed slightly different profiles. Notably, foot emerged as a highly efficient Wayland-native option:

Terminal	USS (Before)	USS (After)
st	2,924	3,204
xterm	6,460	9,888
foot	5,096	8,764
gnome-terminal	12,168	12,660
alacritty	25,468	34,188
kitty	46,468	53,048
ptyxis	73,220	75,060

Key Insights and Trade-offs

The Cost of Features

Modern terminals like kitty and alacritty leverage GPU acceleration to provide smoother rendering and advanced features. One such feature is the ability to render pixel-perfect images directly in the terminal using tools like timg. While highly useful for remote server administration, this capability comes at a cost. In one extreme case, ten instances of kitty were found to consume 50GB of swap on an older machine, illustrating how resource-heavy terminals can cripple a system under specific conditions.

The Minimalist Appeal

On the other end of the spectrum, st (simple terminal) and xterm offer the lowest memory overhead. However, minimalism often means sacrificing essential usability. For instance, the base version of st lacks a scrollback buffer entirely. To regain this functionality, users often turn to patched versions such as st-flexipatch or xst.

The Middle Ground

gnome-terminal performed surprisingly well in these tests, offering a balance of stability and relatively low memory usage compared to the GPU-accelerated alternatives. Similarly, foot provides a compelling option for Wayland users, combining low memory usage with support for timg pixel-perfect images.

Community Perspectives and Optimizations

Beyond raw memory numbers, the community suggests several ways to mitigate the resource impact of terminal emulators:

• Client/Server Architectures: Both kitty (via --single-instance) and foot (via footclient) offer ways to run a single server process that manages multiple windows, significantly reducing the memory overhead of spawning new instances.
• Latency vs. Memory: Some users argue that memory is less important than input latency. For example, xfce4-terminal is praised by some for its near-instant startup and low latency, even if it isn't the absolute lowest in memory usage.
• The GPU Debate: While GPU rendering is a selling point for many, others find it problematic in virtualized environments (like VirtualBox or VMware) where graphics drivers are limited, making xterm or st the only reliable choices.

Conclusion

Choosing a terminal is rarely about a single metric. If you are on a memory-constrained system or run dozens of windows, the minimalist path of st or xterm (with patches) is the most efficient. If you need high-performance rendering and advanced features, kitty or alacritty are powerful tools, provided you have the RAM to spare. For those seeking a balanced experience, gnome-terminal or foot (on Wayland) offer a strong compromise between utility and resource efficiency.