Use foot, the Lean Wayland Terminal

foot is a fast, minimal Wayland-native terminal emulator written in C. It has no X11 dependency, starts in under 10 ms on modern hardware, and handles server mode so subsequent windows appear almost instantly. If you spend most of your time at a terminal and run a Wayland compositor (Sway, river, Hyprland, or GNOME on Wayland), foot is worth a close look.

Install foot

Debian / Ubuntu (24.04 LTS or later)

sudo apt update && sudo apt install foot

Ubuntu 22.04 ships an older build. On that release, prefer the Sway PPA or build from source to get server mode and recent fixes.

Fedora / RHEL family

sudo dnf install foot

foot is in the default Fedora repos. On RHEL 9 / Rocky 9, enable EPEL first:

sudo dnf install epel-release
sudo dnf install foot

Arch Linux

sudo pacman -S foot

The foot package includes both the terminal and footclient. The optional foot-terminfo package ships the terminfo entries; install it on remote machines so applications render correctly over SSH.

First Launch

From inside a Wayland session, run:

foot

A bare window opens with your default shell. foot reads $TERM and sets it to foot automatically. Confirm your session is Wayland, not XWayland:

echo $WAYLAND_DISPLAY

You should see something like wayland-1. If the variable is empty you are in an X session and foot will not start.

Configure foot.ini

foot looks for its config in $XDG_CONFIG_HOME/foot/foot.ini, which resolves to ~/.config/foot/foot.ini for most users. Copy the shipped example to get started:

mkdir -p ~/.config/foot
cp /usr/share/doc/foot/foot.ini ~/.config/foot/foot.ini 2>/dev/null ||
cp /usr/share/foot/foot.ini ~/.config/foot/foot.ini

The path varies by distro; if neither glob matches, generate a clean default:

foot --print-default-config > ~/.config/foot/foot.ini

Key sections to change first

[main] — font, shell, and geometry:

[main]
font=monospace:size=12
shell=/bin/bash
initial-window-size-chars=120x36
term=foot

[colors] — 16-colour palette plus alpha for compositor transparency:

[colors]
alpha=0.95
foreground=cdd6f4
background=1e1e2e

Colour values are plain hex without a leading #. The example above uses the Catppuccin Mocha palette.

[scrollback] — history lines (default is 1000; raise it if you tail logs):

[scrollback]
lines=10000

[mouse] — disable mouse if you prefer pure keyboard workflows:

[mouse]
hide-when-typing=yes

[key-bindings] — remap anything that conflicts with your compositor:

[key-bindings]
new-window=Control+Shift+n
copy=Control+Shift+c
paste=Control+Shift+v
font-increase=Control+plus
font-decrease=Control+minus

foot reloads its config on SIGHUP — no restart needed:

pkill -SIGHUP foot

Server Mode for Fast Launches

In server mode a single foot process listens on a Unix socket. Each new window is a client (footclient) that connects to the server. The window appears immediately because the heavy initialisation (font shaping, Wayland connection, config parsing) already happened at server start. Cold-start time drops from ~80 ms to under 5 ms on typical hardware.

Start the server

foot --server &

The server daemonises into the background. Confirm it is listening:

ls $XDG_RUNTIME_DIR/foot*.sock 2>/dev/null || ls /run/user/$(id -u)/foot*.sock

Open windows via footclient

footclient

Every subsequent footclient call opens a new window in under 5 ms. Bind this command to a key shortcut in your compositor config instead of bare foot.

Sway example keybind

# ~/.config/sway/config
bindsym $mod+Return exec footclient

Autostart the server with systemd (user session)

Starting the server manually on login is fragile. Use a systemd user service instead:

mkdir -p ~/.config/systemd/user
cat > ~/.config/systemd/user/foot-server.service << 'EOF'
[Unit]
Description=foot Wayland terminal server
PartOf=graphical-session.target
After=graphical-session.target

[Service]
Type=simple
ExecStart=/usr/bin/foot --server
Restart=on-failure

[Install]
WantedBy=graphical-session.target
EOF

systemctl --user enable --now foot-server.service

Check it started cleanly:

systemctl --user status foot-server.service

Expected output will show Active: active (running). If your compositor does not set graphical-session.target, replace it with default.target in both PartOf and WantedBy.

Passing Options to footclient

Most foot flags work with footclient too. Useful examples:

# Open in a specific directory
footclient --working-directory ~/projects/myapp

# Override the window title
footclient --title "logs"

# Run a command and close when it exits
footclient -- htop

Install terminfo on Remote Hosts

When you SSH from foot into a server that lacks the foot terminfo entry, applications may render incorrectly or warn about an unknown terminal. The fastest fix is to copy the terminfo over:

infocmp foot | ssh user@remote-host -- "mkdir -p ~/.terminfo && tic -x -"

Alternatively, set TERM=xterm-256color before SSH if you cannot modify the remote host:

TERM=xterm-256color ssh user@remote-host

Verify Everything Works

# Confirm foot version
foot --version

# Confirm server is running
systemctl --user is-active foot-server.service

# Time a client launch (should be < 100 ms, often < 10 ms)
time footclient -- true

The time footclient -- true command opens a window, runs true (exits immediately), and reports wall-clock time. Sub-20 ms real time is normal in server mode on any SSD-equipped machine.

Troubleshooting

• foot: no Wayland compositor running — You are in an X11 session. Switch to a Wayland compositor or set WAYLAND_DISPLAY correctly.
• footclient: failed to connect to server — The server is not running. Start it with systemctl --user start foot-server.service or run foot --server & manually.
• Unknown terminal / garbled output over SSH — Install foot terminfo on the remote host (see section above) or export TERM=xterm-256color.
• Font not found / fallback font used — Run fc-list | grep -i mono to list available monospace fonts and set the exact family name in foot.ini.
• Config changes not taking effect — foot reads config at startup. Send SIGHUP (pkill -SIGHUP foot) or restart the server: systemctl --user restart foot-server.service.