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 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 simple devices with just a keyboard and a printer. Today, we mostly use devices with a keyboard and screen.

Text screens come in three main types: local displays controlled by a computer’s processor, text mode emulators like xterm that copy old text screens, and remote text terminals that talk to each other over networks. Each type shows information and works with programs in its own way.

ANSI-compatible terminals

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

MS-DOS and Windows

On IBM PC compatibles, systems like MS-DOS let programmers make simple text-based interfaces. These programs were fast and easy to use. They often had blue backgrounds with white or yellow text and used special characters to make boxes and shapes on the screen.

Later, these interfaces added features like menus, windows, and dialog boxes. They could use a mouse, and many popular programs from that time, such as Microsoft Word and Lotus 1-2-3, used these text-based interfaces. Even when graphical interfaces became more common, some text-based programs were still used. Modern Windows systems still support text-based applications using tools like Windows Terminal.

Unix-like systems

In Unix-like operating systems, text-based user interfaces (TUIs) are made using special tools like curses, ncurses, or S-Lang. These tools help programmers make programs that fill the whole screen. This makes 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, let users switch between different screens called virtual consoles. They use special keyboard combinations to do this. Programs like GNU Screen and Tmux help manage many tasks in one text screen. They work like windows on modern computers. Text editors like Emacs, Vim, and Neovim also have 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, released in 1988, uses a text-based user interface. It 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. This lets you edit and use text on the screen as commands, making it 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 display text-based user interfaces, much like those on a personal computer. They often use special chips or modules, or they might use something called an FPGA. These systems typically follow commands based on the VT100 standard sent over a connection known as UART. Some designs also allow direct access to the video memory.

Other uses

The full screen editor of the Commodore 64 computers was advanced. Users moved the cursor to enter and change BASIC program lines. All Commodore 8-bit computers used the PETSCII character set for text.

Apple's Macintosh Programmer's Workshop had a tool called Commando. This was a text-based interface that inspired later software. Later Apple II models used MouseText for text. The Corvus Concept computer from 1982 also used a text interface.