Text-based user interface

In computing, text-based user interfaces (TUI) are a way for people to talk to computers using only text. They were very common in the early days of computers, before we had colorful pictures and windows on screens. Instead of clicking on icons, users type special words or commands to tell the computer what to do.

These interfaces can fill up the whole screen, just like modern computer programs. They can also accept input from a mouse and sometimes use colors to make things clearer. They often use special characters, like little boxes and lines, to organize information on the screen.

Today, people usually use these text-based interfaces inside something called a terminal emulator. This lets users work with older programs or special tasks that still need text commands, even though most modern programs have friendly graphical pictures to click on.

Types of text terminals

In the early days of computing, text terminals were often just keyboard and printer devices, but now we mainly use keyboard and screen devices.

Text screens can be of three main types: local displays controlled by a computer’s processor, text mode emulators like xterm that mimic old text screens, and remote text terminals that communicate over networks. Each type has its own way of showing information and interacting with programs.

ANSI-compatible terminals

The American National Standards Institute created a standard called ANSI X3.64 for making text-based interfaces work better. This standard uses special codes called escape sequences, which help control where text appears and change colors on old computer screens. Not every old screen followed this exact standard, but many used similar codes to do the same things. These codes are also known as ANSI escape code. They let you move the cursor anywhere on the screen and change colors, making text-based interfaces more useful and colorful.

MS-DOS and Windows

On IBM PC compatibles, systems like MS-DOS allowed programmers to create text-based interfaces that were quick and easy to use. These programs often had blue backgrounds with white or yellow text and used special characters to create boxes and other shapes on the screen.

Later, these interfaces borrowed ideas from graphical user interfaces, adding features like menus, windows, and dialog boxes. They could also use the mouse, and many popular programs from that time, such as Microsoft Word and Lotus 1-2-3, used these text-based interfaces. Even as graphical interfaces became more common, some text-based programs continued to be used, and modern Windows systems still support text-based applications through special tools like Windows Terminal.

Unix-like systems

In Unix-like operating systems, text-based user interfaces (TUIs) are often built using special tools like curses, ncurses, or S-Lang. These tools help programmers create programs that fill up the whole screen, making them easier to read and use. Popular examples include text editors like vi, email programs like pine and mutt, and web browsers like lynx.

Many Unix-like systems, such as Linux and FreeBSD, allow users to switch between different screens called virtual consoles using special keyboard combinations. Programs like GNU Screen and Tmux help manage multiple tasks in one text screen, similar to how windows work on modern computers. Text editors like Emacs, Vim, and Neovim also include features to run these text-based interfaces inside their programs.

OpenVMS

OpenVMS had a special feature called the Screen Management facility, or SMG. This feature could be started from the command line or used in programs by calling the SMG$ library. It worked in a way similar to another system called curses.

Oberon

The Oberon operating system, first released in 1988, uses a special kind of text-based user interface. Unlike many others, Oberon needs a large screen where you can click on text with a mouse. By clicking the middle button on your mouse, you can run commands written in a special format. This lets you edit and use any text on the screen as a command, making it very flexible and different from older text menus or command lines.

Oberon's design influenced later tools like the Acme text editor and email client for the Plan 9 from Bell Labs operating system.

Embedded systems

Modern embedded systems can show text-based user interfaces, similar to what you might see on a personal computer. They often use special chips or modules to do this, or they might use something called an FPGA. These systems usually follow commands based on the VT100 standard sent over a connection called UART, and some designs allow direct access to the video memory.

Other uses

The full screen editor of the Commodore 64 8-bit computers was advanced for its time. Users could move the cursor across the screen to enter and edit BASIC program lines and commands. All Commodore 8-bit computers used the PETSCII character set, which helped create a text-based interface.

Apple's Macintosh Programmer's Workshop included a tool called Commando, a text-based interface that inspired later software. Later Apple II models used MouseText, special graphics for text interfaces. The Corvus Concept computer from 1982 also used a text interface with function keys on a special display.