Linux users sure can’t complain about not having enough terminal emulators—there’s a massive selection out there to fit just about every need. One of them, the Foot terminal, somehow flew under my radar until recently. But after spending a few days testing it, I have to say—it’s quickly becoming my go-to terminal thanks to its outstanding performance and thoughtful design. Here’s what it’s all about.
Meet Foot Terminal
First off, let’s clear something up right away — despite its name—and especially its logo—giving you vibes of the popular GNOME desktop environment, the Foot terminal has nothing to do with it. Now that we’ve got that out of the way, let’s get into what really matters.
Foot is a fast, extremely performant, and minimalist terminal emulator written in C, explicitly built for Wayland, with a focus on simplicity, speed, and standards compliance, while avoiding unnecessary features and dependencies.
Unlike many older terminal emulators that still rely on XWayland compatibility layers, Foot runs natively on Wayland, delivering smoother rendering and lower latency, making it a perfect match for Wayland compositors like Sway, Hyprland, Wayfire, Niri, etc.
At the same time, it’s actually one of the few terminal emulators that intentionally avoids hardware acceleration. Instead, Foot relies on CPU-side software rendering and efficiently submits frames to the Wayland compositor. The result is a terminal that’s lighter, faster, and simpler than many GPU-based alternatives (such as Alacritty or Kitty), with lower input latency and minimal memory usage.
And speaking of memory usage—well, you know what they all say, a picture’s worth a thousand words. Here’s a quick look at how much memory (without performing operations) several terminal emulators use side by side: Kitty, Alacritty, Konsole, and Foot. Just 21 MB—that’s what I call lightweight.
Sure, most modern desktops come with 16 or 32 GB of RAM these days, so memory usage might not seem like a big deal. But it still matters when it comes to startup speed—and with Foot, that difference is instantly noticeable. You click the icon, and the terminal pops up instantly —faster than you can blink.
Finally, it’s important to understand one key thing so you can have realistic expectations: Foot is all about simplicity and speed—it’s not a terminal multiplexer or a full-featured terminal manager. That means it doesn’t support tabs, split windows, session management, or profiles. It focuses entirely on doing one thing well: rendering terminal output quickly and cleanly under Wayland.
And speaking of rendering, the Foot’s lead developer, Daniel Eklöf, has written an excellent article that clearly explains how this terminal achieves its lightning-fast performance—and how it stacks up against GPU-powered ones. Want to see some benchmarks? Look here.
Understanding Foot’s Server and Client Model
One of the most confusing aspects for first-time Foot users is that installing the foot package actually gives you two binaries:
- foot
- footclient
Let me explain. Foot implements a server/client architecture, which is unusual among terminal emulators but extremely efficient. You can run foot --server which runs a server process in the background without opening a terminal window, which handles all the heavy lifting: rendering, font management, and communication with the Wayland compositor.
Then, the companion command, footclient, connects to that running server and opens a new terminal window. Because it reuses the server’s already loaded resources — like fonts and configuration — new windows start up instantly and consume very little additional memory.
This design keeps the Foot terminal lightweight and simple, though it has drawbacks. Single-threaded multiplexing can cause slowdowns if a single window is overloaded, and a crash in the server process closes all windows. Still, this approach reduces overhead and helps maintain Foot’s minimal, efficient architecture.
However, if this sounds too complicated for a simple terminal emulator, I have some good news: you don’t have to bother with the server–client setup at all—Foot can be started as a standalone terminal. In this mode, it runs directly without the extra process layer, making it simpler and just as fast for everyday use.
Client-Side Decorations
As I mentioned in the beginning, the Foot terminal emulator is designed to be minimalist and fast. With that said, it deliberately avoids unnecessary dependencies and visual clutter — including all kinds of window decorations.
However, there are a few quirks worth mentioning to save you some time and confusion. Here’s the deal: if you’re using Foot on KDE Plasma, you’ll get the expected window decorations.
On the GNOME desktop, though, things look a bit different — the usual GTK window decorations are completely missing.
Okay, what’s happening? Let me explain. On Plasma, Foot looks perfectly integrated because KWin, KDE’s Wayland compositor, provides server-side window decorations by default for all clients that don’t draw their own (like Foot).
By contrast, in GNOME, Mutter (the compositor) doesn’t draw any decorations for non-GTK apps — it expects applications to render their own CSDs. Since Foot doesn’t use GTK, it can’t adopt GNOME’s Adwaita-style titlebar or rounded corners and ends up with only a thin border or even no frame at all. For that reason, it shows a plain rectangular window with simple server-side decorations drawn by your Wayland compositor —in this case, GNOME’s Mutter.
Finally, I’d like to point out that Foot not offering its own server-side window decorations is actually a strength rather than a drawback. Anyone using a Wayland compositor like Hyprland or similar will know exactly what I mean—Foot match like a dream come true in such a setup.
Foot Configuration
Despite its minimalist approach, Foot offers extensive configuration options that let you fine-tune everything—from fonts and colors to key bindings and window behavior. Its configuration is handled entirely through a simple foot.ini text file, usually located in ~/.config/foot/.
If the file doesn’t exist, you can create it manually or start from the system-wide example provided with the package:
mkdir ~/.config/foot
cp /etc/xdg/foot/foot.ini ~/.config/foot/foot.iniCode language: Bash (bash)Then edit it with your preferred text editor—tweak only what you need —and enjoy a terminal that integrates perfectly with any modern Linux desktop. Any line left untouched inherits the default behavior.
The most important options include the global settings for fonts, padding, and shell settings. [colors] for text, background, and transparency; [cursor] for shape and blinking; [csd] for window decorations and borders; and [key-bindings] for customizing shortcuts. Other sections like [scrollback], [url], and [search] control history, link handling, and text search.
Installation
Foot is available in the repositories of all major Linux distributions. To install it, just use your package manager—whether that’s APT, DNF, Pacman, or Zypper—search for the “foot” package, and install it. Also, make sure to install the “foot-terminfo” package for better terminal compatibility.
Bottom Line
The Foot terminal emulator stands out as one of the most prominent examples of the legendary UNIX philosophy “Do one thing and do it well” — it’s small, efficient, and embraces a clean design philosophy that delivers exceptional speed and responsiveness without relying on GPU acceleration or unnecessary dependencies.
The project is actively developed and well-maintained. Its lead developer, Daniel Eklöf, is known for being an incredibly friendly and responsive guy—you can always count on having a good conversation with him about anything related to Foot.
For anyone running a Wayland compositor and seeking a fast, minimalist, and reliable terminal, Foot is hard to beat — it’s lean, modern, and crafted with remarkable attention to efficiency. Do I recommend using it? Absolutely — it’s more than worth a try.
