Contour: a GPU-accelerated terminal emulator with daemon sessions and Sixel graphics

What Contour solves that a stock terminal does not

Most terminal emulators treat graphics and session lifetime as separate problems. Contour treats both as terminal features. The README lists Sixel inline images and ReGIS vector graphics (VT330/VT340) as supported escape sequences, so a plotting tool that emits ReGIS or Sixel can draw inside the terminal instead of opening a separate window. The repository ships examples/regis-plot2d.cpp, regis-plot3d.cpp and regis-animation.cpp, which shows the maintainers treat ReGIS as something to demonstrate rather than merely parse.

The second problem is session lifetime. Tabs and split panes keep several shells in one window, but closing the window ends them. Contour's daemon mode moves the sessions into a background process so they outlive the window. The README's example is a long build that keeps running after you close the window, or work over SSH that survives the link dropping. That is the same ground tmux covers, and Contour meets tmux halfway: it speaks tmux control mode in both directions, so tmux-aware tooling and the stock tmux binary can attach to a Contour daemon, and contour client --tmux mirrors a running tmux server into a Contour window with windows as tabs and panes as splits.

The audience is stated plainly: power users with a modern feature mindset. If you live in a terminal all day and want Unicode emoji with ZWJ and variation selectors, grapheme cluster handling, ligatures and high-DPI rendering, Contour is built for that. If you want a terminal that never surprises you, the experimental daemon is the part to weigh.

How Contour renders and where the daemon sits

The README describes GPU-accelerated rendering and requires a driver supporting at least OpenGL 3.3 hardware accelerated, or a software rasterizer. The CPU requirement is x86-64 AMD or Intel with AES-NI, or ARMv8 with crypto extensions. Those two lines tell you the architecture: text shaping and terminal state live in the C++23 codebase, and the final composition happens on the GPU.

Unicode handling is split into layers the README names separately. Emoji support covers ZWJ sequences and VS15/VS16 variation selectors, and grapheme cluster support is listed as its own feature. Sixel and ReGIS are separate again, as is the terminal page buffer capture extension used to extract contents. Several behaviours are toggled by private mode sequences rather than configuration keys: synchronized rendering via SM ? 2026 and RM ? 2026, and text reflow via SM ? 2028 and RM ? 2028. That means an application can turn reflow off for itself, which is unusual and worth knowing before you file a bug about text not rewrapping.

Daemon mode sits between the client window and the session. contour client attaches to the daemon and starts one if none is running. The README states the daemon is built into every Contour and is covered by the test suite, but also labels it experimental, new in 0.7.0 and still settling, with command-line flags and wire protocol that may change between releases. Treat that as a compatibility boundary, not marketing hedging: scripts that drive the daemon are the most likely thing to break on upgrade.

Installing Contour and opening a first session

The README points at distribution packages first. Fedora, Arch, Void and openSUSE all carry official packages. Additional builds on the release page include an Ubuntu package, an AppImage, a static build, a macOS bundle, and a Windows installer plus a zipped app. Pick the package for your distribution before considering a source build.

If you prefer Flatpak, the README requires flatpak 0.10 or newer and the Flathub remote. Check the version first, then add the remote:

flatpak --version
flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo

The version check should print 0.10 or higher. If it prints something older, the Flathub install path is not the one the README describes.

On first launch Contour generates its configuration file at $HOME/.config/contour/contour.yml. That file is where color schemes, profiles, key bindings and the login shell are set. The README notes that some features also need shell integration, which can be generated through the CLI, and that zsh, fish and tcsh are currently covered. If you use bash and want those integrations, the README does not offer a generated path for it.

To try the daemon, run the client subcommand. It attaches to the daemon and starts one if none is running:

contour client

You should end up in a session owned by a background process rather than by the window. Closing the window should leave that session alive. To check the tmux interop instead, the README gives contour client --tmux, which mirrors a running tmux server into a Contour window. Both directions are documented: tmux-aware tooling and the stock tmux binary can attach to a Contour daemon.

Building from source is the last resort. The README's UNIX path runs a dependency script and then a CMake build:

./scripts/install-deps.sh

The script may ask for an administrator password when a dependency is installed through the system package manager. The README's compile section is truncated in the published text, so treat the dependency script as the documented starting point and follow the remaining build steps from the repository's CMake files rather than guessing flags.

Where Contour is the wrong terminal

The hardware floor is real. OpenGL 3.3 hardware acceleration or a software rasterizer, plus AES-NI on x86-64 or ARMv8 crypto extensions, rules out older machines, some virtualized desktops with weak GPU passthrough, and remote X sessions where the GL driver is a stub. A terminal that cannot start is worse than one with fewer features, and the README offers no fallback path beyond the software rasterizer it names.

Daemon mode is the second risk. The README calls it experimental, says it is new in 0.7.0 and still settling, and warns that its command-line flags and its wire protocol may change between releases. If you build automation on top of contour client, plan for that automation to need revision. The README does not document rollback for a daemon upgrade, and it does not describe what happens to running sessions when the daemon binary is replaced. That silence is the limitation, not a hidden feature.

Configuration is a third boundary. Everything lives in contour.yml under $HOME/.config/contour, and the README says some features require shell integration generated by the CLI, currently for zsh, fish and tcsh. There is no documented GUI settings editor and no documented sync of that file across machines. Runtime configuration reload is listed as a feature, which softens the cost, but the file is still the single source of truth you will hand-edit.

Finally, the project is not a drop-in replacement for a minimal terminal. It carries a large feature surface: ReGIS, Sixel, buffer capture, progress bars, vertical line markers, vi-like input modes, profiles, blurred backgrounds. If your requirement is a small, auditable terminal binary, Contour's scope works against you.

Contour against tmux as the session layer

The honest comparison is not against another emulator but against tmux, because that is the job daemon mode takes on. tmux is a separate process you start inside any terminal. Contour folds the same capability into the emulator, so the session and the rendering surface are managed by one program, and reattachment happens through contour client rather than tmux attach.

The difference in approach shows in the interop. Contour does not ask you to abandon tmux; it speaks tmux control mode in both directions. A tmux-aware tool can attach to a Contour daemon, and contour client --tmux mirrors an existing tmux server into a Contour window, mapping windows to tabs and panes to splits. tmux, by contrast, has no notion of Sixel or ReGIS rendering beyond passing bytes through, and no GPU compositor. If your work is text and multiplexing, tmux is the more conservative choice and it does not care about your OpenGL version. If your work involves inline graphics or you want the session layer to be part of the terminal, Contour is the one that closes that gap.

The trade-off is maturity. tmux's control mode is a long-standing interface with a stable protocol. Contour's daemon is explicitly not stable yet. Choosing Contour for sessions means accepting that the interface underneath you may move.

Maintenance, licensing and upgrade cost

The repository is not archived, and the last push was on 2026-09-18. Releases are not on a fixed cadence: v0.7.0.8982 on 2026-08-17, v0.6.3.8249 on 2026-04-09, and v0.6.2.8008 on 2026-01-07. That is roughly a minor release every few months, with the 0.7 line arriving in August 2026. The version strings carry a build number after the semantic part, which is worth noting when you pin a package: two builds of 0.7.0 differ.

The project is licensed Apache-2.0, and the repository carries LICENSE.txt at the top level. Apache-2.0 is a permissive licence with an explicit patent grant, which matters if you redistribute Contour inside a product. This is a description of the licence text, not legal advice; if you ship it, have your own counsel read LICENSE.txt.

Upgrade cost concentrates in two places. The daemon is the flagged one: the README states its flags and wire protocol may change between releases, so any script or wrapper around contour client is exposed. The configuration file is the quieter one. contour.yml is generated on first run and then owned by you, and the README does not describe a migration tool for it. After a release that adds or renames keys, expect to reconcile the file by hand. Runtime configuration reload helps you test edits without restarting, but it does not tell you which keys changed.

Editorial conclusion

Adopt Contour if you want Sixel or ReGIS output, font ligatures and a terminal that speaks tmux control mode in both directions, and you are willing to track a moving daemon protocol. Do not adopt it for a locked-down fleet where you cannot guarantee OpenGL 3.3 or AES-NI class CPUs. Verify first that your GPU driver exposes OpenGL 3.3 hardware acceleration, that your distribution package matches the release you intend to run, and that the persistent-session flags you script against are still present after the next release, since the README marks daemon mode experimental and warns that its command-line flags and wire protocol may change.

Frequently asked questions

Official sources

1. contour-terminal/contour on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases