Terminology: the EFL terminal that puts media inside the grid

An EFL terminal built for desktops that show media

Terminology is a terminal emulator that sits on top of the Enlightenment Foundation Libraries, and its defining choice is that the character grid is not the limit of the window. The README lists the extras in plain terms: the ability to display in-line images, video and even play music files, background images and videos, Z-Modem style sending so you can ssh into a server and use tysend to send a file back to the local terminal, and GPU accelerated rendering that is optional, enabled by pointing the EFL Elementary toolkit engine at OpenGL.

That feature list points at a specific reader. It is not aimed at someone shopping for the fastest VT parser for a long ssh session. It is aimed at people on Enlightenment, on any other desktop where EFL is available, and on engineers willing to compile their own tools who want a terminal window that can double as a media surface. The repository is C, the topics list terminal, console and terminal-emulators, and the homepage is terminolo.gy.

Building it takes meson, ninja and an EFL checkout

The one hard requirement is EFL, the Enlightenment Foundation Libraries, and the README points to the Enlightenment project for information on obtaining them. There is no package manager recipe in the documentation, no AppImage, no flatpak manifest. You compile it yourself, and the project says compiling and installing are simple once the requirements are met:

meson build
ninja -C build
sudo ninja -C build install

The three commands map cleanly onto a standard Meson workflow. meson build configures the build directory, ninja -C build compiles it, and the install step places the binary and its data files on the system. Expect the configure step to be the part that fails if your EFL installation is incomplete, since the whole toolkit is a build dependency rather than a runtime library the terminal falls back on.

One environment detail matters more than the rest for anyone typing in CJK or other complex scripts. The README notes that to make terminology work with input methods in general you need:

export ECORE_IMF_MODULE="xim"
export XMODIFIERS="@im=none"

Without those two exports the terminal renders fine but an input method may not hook in at all, and the failure looks like a keyboard problem rather than a configuration one.

The terminfo entry it installs but refuses to default to

Terminology reports TERM=xterm-256color by default, and the README is direct about why. That description is missing several capabilities Terminology implements, so a matching terminfo entry named terminology is shipped and installed alongside the xterm-256color one. The entry is not the default because the entry has to exist on every host a session reaches, and remote hosts will not have Terminology installed.

So there is a deliberate split: a safe default for portability, a richer entry for when you know the remote host can support it. When the remote host does not have Terminology, the README suggests pushing the local entry across rather than installing anything there:

infocmp -x terminology | ssh remotehost 'mkdir -p ~/.terminfo && tic -x -'

infocmp reads the local terminology entry and pipes it into tic on the far side, creating ~/.terminfo there. That is a nice one-liner, and it works because the terminfo format is portable and self-contained. It also means the capability gap between what the emulator can draw and what the far side believes it can draw is entirely under your control, without root on the remote box.

Extended escapes and command mode drive the window from inside the shell

The unusual part of Terminology is that the running program can drive the emulator, not just print text into it. The README documents an extended escape sequence specific to Terminology, made up of an ESC character, then a `}` character, then a sequence of UTF8 chars other than nul, then a terminating nul byte. A minimal example from the documentation:

  `echo -n '\033}Hello world\000'`

The trailing nul matters, since it marks the end of the sequence, and the command bytes must not contain nul themselves.

Separately, Alt+Home enters command mode, where you type commands that control terminology itself rather than the shell. The documented commands cover media and layout: `pn[FULL-PATH-OR-URL]` pops up a media file or url now, `pq[FULL-PATH-OR-URL]` queues one, `bt[FULL-PATH-OR-URL]` and `bp[FULL-PATH-OR-URL]` set the terminal background temporarily or permanently, and `at[on/true/yes/off/false/no]` and `ap[on/true/yes/off/false/no]` toggle the alpha state temporarily or permanently. Values in square brackets are replaced by real content, so `aa[PATH-OF-FILE]` becomes something like `aa/tmp/file.png`.

This is a real API surface, not a theme. It means a script can surface a diagram or a video without the user copying a file path into a viewer.

Group input and split terminals treat one window as a console of its own

Terminology treats a single window as a grid of terminals, and the key map is worth reading in full before you adopt it. Splits come from Ctrl+Shift+PgUp for a horizontal split with one terminal above the other, and Ctrl+Shift+PgDn for a vertical split with one terminal to the left of the other. Ctrl+Shift+t creates a new terminal on top of the current one inside the window, which is the tab model, and Ctrl+Shift+End closes the focused terminal. Ctrl+1 through Ctrl+9 and Ctrl+0 switch directly to terminal tab 1 through tab 10.

The feature that has no equivalent in most emulators is group input. Alt+g sends your input to all visible terminals in the window, and Alt+Shift+g sends input to all terminals in the window, including ones scrolled out of view. That is the feature that makes Terminology worth the compilation: run a command across six ssh sessions at once, or watch a build fan out, without a multiplexer.

Scrolling and selection follow the same pattern. Shift+Up and Shift+Down scroll a line, Shift+PgUp and Shift+PgDn scroll a page, Shift+Home jumps to the top of the backlog, and Ctrl+Shift+h toggles the miniview of the history. On the mouse side, the right button opens the controls menu, the middle button pastes the highlighted selection, Ctrl+Left drag makes a block selection, and Ctrl+Wheel zooms the font size.

Companion tools push the terminal past the shell prompt

The package installs a family of small commands that take over work the shell would otherwise do. `tyls` lists directory contents with bells and whistles, `tyalpha` sets the transparency level of the background, `tybg` changes the background image, `tycat` displays a media file or a URI inline, `typop` shows one in a popup, `tyq` queues media files or URIs to be popped up, and `tysend` sends files to the terminal.

`tysend` is the interesting one, because it pairs with the Z-Modem style sending the README advertises. The workflow described is to ssh into a server and run tysend to send a file back to the local terminal, which turns a remote session into a transfer channel without configuring scp. `tycat` and `typop` are what make inline media practical, since a program can hand a URI to the terminal and get a picture rather than a filename.

The alternative approach for most of this is a terminal multiplexer plus a separate media viewer, which gives you group input but makes you leave the window for anything visual. Terminology's approach is one surface, at the cost of depending on the EFL stack to draw it.

What Terminology does not settle for you

Several gaps are worth naming before you plan a migration. The repository has no GitHub releases, so there is no tagged version to pin, no changelog entry in the release feed and no upgrade path. The ChangeLog and NEWS files live in the repository root, and the README directs bug reports to git.enlightenment.org rather than to the GitHub issue tracker, so the upstream workflow is the Enlightenment one even though the code is mirrored here. The last push was on 2026-10-18, so the code is current, but current is not the same as released.

Licensing is also less tidy than it looks. The repository lists a custom licence that GitHub cannot classify, with a COPYING file at the root, so anyone shipping Terminology inside a product needs to read that file rather than assume Apache or MIT terms.

Finally, the dependency ceiling is real. Everything visual rides on EFL and the Elementary toolkit, and the optional OpenGL path depends on which engine the toolkit is configured to use. For a desktop that already runs Enlightenment, that is a non-issue. For a minimal X11 session or a server without a graphics stack, it rules the emulator out entirely, and no amount of configuration changes it. The README also does not document how the emulator behaves when the toolkit is missing, so treat the EFL requirement as a hard precondition rather than a soft one.

Editorial conclusion

Adopt Terminology if you run an Enlightenment or EFL desktop and want your shell window to display images, video and music in place, and verify first that the EFL libraries on your machine match what the meson build expects. Do not adopt it if you need a package manager binary, a stable release channel or a terminal that does not require compiling against a desktop toolkit stack, because the repository publishes no GitHub releases and carries a custom licence file rather than a standard SPDX identifier.

Frequently asked questions

Official sources

1. borisfaure/terminology on GitHub
2. Issues
3. Project website
4. README