Fact-checked by Grok 2 weeks ago

Text-based user interface

A text-based user interface (TUI), also known as a textual user interface, is a form of human-computer interaction in which digital information is displayed and user input is received exclusively through text characters arranged in a terminal or console environment, often simulating graphical elements like windows, menus, and dialogs using character-based rendering.^[1] Unlike simple command-line interfaces (CLIs), which process input line-by-line, TUIs leverage the full screen area for persistent, interactive displays that support cursor movement, scrolling, and multi-region layouts, enabling more structured navigation via keyboard (and sometimes mouse) controls.^[1]^[2] TUIs trace their origins to the earliest computing systems in the mid-20th century, beginning with teletypewriters (TTYs) that provided basic text input and output over serial connections, and evolving in the 1970s with video display terminals such as the Lear-Siegler ADM-3A and DEC VT100, which introduced cursor addressing and control sequences for dynamic screen updates.^[2] By the late 1970s, libraries like the original curses API—initially developed for the vi text editor in Berkeley Software Distribution (BSD) Unix—facilitated the creation of more sophisticated TUIs by abstracting terminal-specific behaviors through databases like termcap and later terminfo.^[3]^[4] Modern implementations, such as the open-source ncurses library (initiated in the early 1990s as a portable clone of System V curses), extend these foundations with support for color, mouse events, Unicode characters, and extensions for panels, forms, and menus, ensuring compatibility across diverse terminal emulators like xterm and Windows Terminal.^[3]^[4] TUIs remain prevalent in server environments, embedded systems, and development tools due to their low resource demands—requiring minimal CPU, memory, and bandwidth compared to graphical user interfaces (GUIs)—making them ideal for remote access over networks and headless operation.^[2]^[4] They offer advantages in efficiency for expert users, such as rapid keyboard-driven workflows and easy scripting or automation, as demonstrated in studies where TUIs enabled faster task completion in data entry scenarios like electronic dental records.^[5] However, TUIs can pose disadvantages for novices, including a steeper learning curve due to reliance on memorized commands and modes (e.g., vi's normal and insert modes), limited visual intuitiveness, and challenges with accessibility for screen readers or complex scripts like bidirectional text.^[1]^[5] Notable examples include the vim editor, which builds on vi's TUI foundations for modal text manipulation; package managers like aptitude; and full applications such as htop for system monitoring, highlighting TUIs' enduring role in Unix-like ecosystems.^[1]^[6]

Fundamentals

Definition and Characteristics

A text-based user interface (TUI), also referred to as a text user interface, is a type of user interface that relies exclusively on text characters for both input and output, using text characters to present information in a fixed grid, such as on a terminal or console display, often simulating graphical elements like windows and menus without bitmapped graphics or icons. Distinct from command-line interfaces (CLIs), which handle input and output line-by-line, TUIs employ the full terminal screen for interactive, multi-region displays supporting cursor movement and structured navigation. This design enables direct communication between the user and the system through alphanumeric input and textual feedback, often within a character-based environment that supports only symbols, text, and limited formatting options available in text modes.^[7] Key characteristics of TUIs include their reliance on keyboard-driven input, where users enter commands or selections sequentially, and output that is typically monochrome or restricted to a basic color palette defined by the display hardware or software.^[7] Navigation occurs via command-line prompts, where users recall and type specific instructions, or through menu-based systems that present options as text lists, emphasizing user expertise in syntax and function recall over visual recognition.^[8] TUIs primarily rely on keyboard-driven input for navigation and commands, though advanced TUIs support mouse interactions; they emphasize efficient, low-resource operations suitable for terminals.^[8] In contrast to graphical user interfaces (GUIs), which employ visual paradigms such as windows, pointers, and icons for intuitive point-and-click interactions, TUIs prioritize sequential text processing, where information is conveyed linearly and users interact through typed responses rather than spatial manipulation.^[7] This distinction highlights TUIs' suitability for environments demanding precise, scripted control, though they can pose challenges in navigation due to the absence of visual aids.^[8] Fundamental components of TUIs encompass cursor positioning mechanisms to relocate the active input/output point on the screen, scrolling regions that handle text overflow by shifting content vertically or horizontally, and character encoding schemes like ASCII, which define a 7-bit standard for representing 128 characters including letters, digits, and control codes to ensure consistent text rendering across systems.^[9]^[10] These elements collectively enable the structured display and manipulation of text in a grid-based format, forming the backbone of TUI functionality.^[9]

Historical Context

The origins of text-based user interfaces trace back to electromechanical devices like teletypewriters, which emerged in the early 20th century but saw significant adoption in computing during the 1930s and 1940s as precursors to interactive text input and output. These machines, such as the Teletype Model 15 introduced in 1930, functioned as automated telegraphs capable of printing and transmitting text over distances, providing a foundation for remote data entry and display in early computer systems.^[11] By the mid-1940s, they influenced the design of computing peripherals, exemplified by the ENIAC (Electronic Numerical Integrator and Computer), completed in 1945, which primarily relied on punched cards read via an IBM card reader for input and produced output through an IBM card punch, with programming accomplished via switches and plugboards for operator control.^[12] The 1960s and 1970s marked a pivotal evolution toward more dynamic text-based interfaces, driven by the rise of time-sharing systems that enabled multiple users to interact with a single computer via remote terminals. Pioneering efforts included John McCarthy's 1957 proposal for time-sharing on the IBM 704 at MIT, leading to the development of the Compatible Time-Sharing System (CTSS) demonstrated in 1962 by Fernando Corbató, which allowed interactive text sessions over teletype connections.^[13] This period also saw the introduction of video display terminals (VDTs), with Digital Equipment Corporation's VT05 in 1970 representing a key milestone as the company's first raster-scan CRT terminal, supporting uppercase ASCII text in a 20-by-72 character display and basic cursor controls at 300 baud, effectively replacing mechanical teletypes with electronic screens for real-time text rendering.^[14] Concurrently, the ARPANET, launched in 1969, influenced text-based networking through protocols like Telnet, which facilitated remote terminal access to host computers via text streams, and the Terminal Interface Processor (TIP) deployed in 1970 to connect up to 63 terminals directly to the network, promoting collaborative text interactions across distant sites.^[15] In the 1980s, standardization efforts solidified text-based interfaces for broader compatibility and functionality in personal and multi-user computing. The American National Standards Institute (ANSI) X3.64 standard, published in 1979 and widely adopted throughout the decade, defined control sequences using escape codes to manage cursor positioning, screen clearing, and text attributes on terminals, enabling consistent text manipulation across diverse hardware.^[16] This facilitated the integration of advanced text displays in systems like Unix workstations and early PCs, paving the way for widespread use in business and academic environments. By the 1990s, the proliferation of graphical user interfaces (GUIs) began to diminish the prominence of text-based interfaces on consumer desktops, though they persisted in server and embedded applications. Microsoft's Windows 3.0, released in 1990, accelerated this shift by providing an accessible GUI layer over MS-DOS, selling millions of copies and making point-and-click interactions the norm for most users, effectively sidelining command-line text operations.^[17] Similarly, the X Window System (X11), standardized in 1987 and dominant on Unix platforms by the early 1990s, supported networked GUIs while retaining text shells, but overall, GUIs like those in Windows 95 (1995) and emerging Linux desktops drove a decline in pure text-based paradigms for general computing.^[18]

Types

Physical Terminals

Physical terminals represent dedicated hardware devices designed specifically for text-based interaction with computer systems, serving as the primary interface for input and output in early computing environments. These devices evolved from mechanical teletypes, which were essentially modified electric typewriters capable of printing text on paper rolls, to more advanced cathode-ray tube (CRT) displays that rendered characters on a phosphor-coated screen. Teletype-style printers, such as the Teletype Model 33 introduced in the 1960s, operated by receiving electrical impulses to strike keys and produce printed output, functioning as both input and output peripherals connected to mainframes via serial lines.^[19] CRT-based terminals, emerging prominently in the 1970s, replaced paper with "glass teletypes" that displayed alphanumeric characters in a grid format, offering faster refresh rates and reduced noise compared to mechanical printers.^[20] Precursors to full raster graphics included vector-based systems like the Tektronix 4010, announced in 1971, which utilized a direct-view storage tube to persist text and simple line drawings without constant refreshing.^[21] Input and output mechanisms in physical terminals centered on integrated keyboards for character entry and serial communication protocols for data exchange with host computers. Keyboards typically featured typewriter-style layouts with additional function keys, directly wired to the terminal's logic board to encode keystrokes into ASCII or similar codes. Connections relied on RS-232 serial interfaces, a standard established in 1960 for asynchronous data transmission between devices, supporting cable lengths up to 15 meters at lower speeds.^[22] Baud rates, measuring bits per second, varied by terminal model but commonly included 110, 300, 1200, or 9600 bps to balance transmission speed with signal integrity over twisted-pair wiring.^[23] The terminal acted as a "dumb" device, sending raw input to the host for processing and receiving formatted text streams for display, without local computation beyond basic rendering.^[19] A seminal example is the Digital Equipment Corporation (DEC) VT100 series, introduced in August 1978, which standardized many terminal features with its 80-column by 24-row character grid displayed on a 14-inch CRT monochrome screen. The VT100 supported text attributes like bold and underline through overstriking techniques, where characters were reprinted in the same position to simulate emphasis, and included a detachable keyboard with 58 keys for efficient data entry.^[24] Operating at baud rates up to 19,200 bps via RS-232, it connected to minicomputers like the PDP-11, enabling remote access for programming and data manipulation.^[25] Despite their reliability, physical terminals had inherent limitations rooted in hardware constraints, including fixed resolutions such as the standard 80 columns that restricted content width without scrolling or reconfiguration. They lacked native support for raster graphics or color, confining output to monochrome text and simple attributes, as rendering was handled entirely by the host system rather than onboard processors. This dependency on remote processing introduced latency in interactive sessions, particularly at lower baud rates, and made terminals bulky, power-intensive units weighing 20-80 pounds.^[20]

Emulated and Virtual Terminals

Emulated terminals are software applications that replicate the functionality of physical text-based terminals within graphical user interfaces (GUIs), allowing users to interact with command-line programs as if using hardware devices. Pioneered in the mid-1980s, xterm serves as the standard terminal emulator for the X Window System, emulating DEC VT102 and VT220 terminals along with Tektronix 4014 graphics capabilities to provide compatibility for legacy and modern text applications.^[26] Similarly, PuTTY, first released in 1999 by Simon Tatham, offers an xterm-style emulation primarily for SSH and Telnet connections on Windows and Unix-like systems, enabling secure remote access to text interfaces.^[27] These emulators abstract hardware limitations by running as processes within window managers, supporting resizeable windows and integration with desktop environments while preserving essential terminal behaviors like cursor control and screen updates. Virtual terminals extend this concept through kernel-level multiplexing, providing multiple independent console sessions on a single physical display and keyboard without requiring a GUI. In Linux, the kernel supports up to 63 virtual consoles, each functioning as a separate text environment that can be switched using key combinations such as Ctrl+Alt+F1 through F6, with the graphical desktop typically occupying one (e.g., F7). This multiplexing allows seamless transitions between sessions, such as logging into different user accounts or booting into recovery modes, and relies on the kernel's console drivers to handle input/output routing.^[28] Unlike emulated terminals tied to GUIs, virtual terminals operate directly on the framebuffer, offering a lightweight alternative for system administration and embedded use cases. Key features of emulated and virtual terminals enhance usability in contemporary systems. Windowing support in emulators like xterm and PuTTY permits multiple instances within a desktop, each configurable for size, position, and transparency, facilitating multitasking.^[29] Copy-paste integration bridges text selection with the host clipboard, often via middle-click or Ctrl+Shift+C/V shortcuts, streamlining data transfer between terminal and GUI applications. Unicode handling ensures support for international characters, with xterm using tools like luit for UTF-8 encoding conversion and PuTTY providing full Unicode for usernames, passwords, and display since version 0.82.^[30]^[27] Performance in these environments hinges on efficient buffer management to handle scrolling and output rendering without lag. Emulators maintain a scrollback buffer—typically thousands of lines—to retain off-screen history, allowing users to review previous commands and outputs via mouse wheel or keyboard navigation, with optimizations like circular buffers preventing excessive memory use. For visual enhancements, support for 256-color extensions, introduced in xterm in 1999 by maintainer Thomas Dickey via patches extending ANSI escape sequences, enables richer text rendering with a palette including 16 standard colors, 216 RGB approximations, and 24 grayscale shades, improving readability in applications like code editors.^[31] These mechanisms ensure responsive operation even under high-output loads, such as log monitoring or compilation processes.

Standardization

ANSI and Escape Sequences

The ANSI X3.64 standard (1979), which adopted the ECMA-48 standard (1st ed. 1976) from the European Computer Manufacturers Association, establishes a protocol for encoded control functions in text terminals, enabling precise manipulation of cursor position, screen content, and display attributes through in-band signaling.^[32]^[33] ECMA-48, first published in 1976 with the 5th edition in 1991, provides the foundational control functions. This standard augments the ASCII code by defining sequences that begin with the Escape character (ESC, ASCII 27, hex 1B), often followed by a Control Sequence Introducer (CSI, represented as ESC [ or the single byte 0x9B in 8-bit environments), numeric parameters separated by semicolons, and a final non-printing character to invoke the function.^[33] For instance, the sequence format for setting foreground color follows the pattern ESC [ n m, where n specifies the color code within the SGR (Select Graphic Rendition) parameters.^[33] Among the most frequently used sequences are those for cursor control and screen editing. Cursor movement employs commands like ESC [ Pn A (Cursor Up by Pn lines, default 1), ESC [ Pn B (Cursor Down), ESC [ Pn C (Cursor Forward), and ESC [ Pn D (Cursor Backward), while absolute positioning uses ESC [ row ; col H to move the cursor to the specified row and column coordinates (origin at 1,1).^[33] Screen clearing is achieved with the Erase in Display (ED) sequence, such as ESC [ 2 J to wipe the entire screen from the cursor to the end, start, or both.^[33] Attribute modifications rely on the versatile SGR sequence ESC [ Ps m, where Ps values include 1 for bold (increased intensity), 5 for slow blink (rate under 150 cycles per minute), 22 to reset intensity to normal, and 25 to stop blinking.^[33] The core standard provides support for a basic 8-color palette in the SGR parameters, assigning foreground colors via ESC [ 30 m (black) through ESC [ 37 m (white) and backgrounds via ESC [ 40 m to ESC [ 47 m, with Ps=0 resetting to default.^[33] This palette was extended in terminal implementations to 16 colors by incorporating high-intensity variants (e.g., ESC [ 90 m to ESC [ 97 m for bright foregrounds), and further to 256 colors using the parameterized form ESC [ 38 ; 5 ; n m for foreground (or 48 for background), where n ranges from 0 to 255 to index an extended palette blending the basic colors with grayscale and RGB approximations.^[34] These color extensions, while not defined in the original ECMA-48 specification, became de facto standards through adoption in emulators like xterm, enabling richer visual feedback in text UIs without deviating from the CSI format.^[34] ANSI X3.64 was withdrawn in 1997, with ISO/IEC 6429 serving as the current international standard.^[35] Non-ANSI terminals pose compatibility challenges, as they may lack support for CSI sequences, resulting in uninterpreted escape codes appearing as literal characters or causing display artifacts.^[33] The VT220 terminal, released by Digital Equipment Corporation in 1983, addressed some limitations by implementing the full ANSI X3.64 set alongside proprietary extensions, such as DEC private modes for features like double-width characters, status line reporting, and enhanced keyboard mappings, thereby broadening applicability for international and advanced text-based interactions.^[36]

Other Protocols and Standards

The VT52 protocol, introduced by Digital Equipment Corporation in 1975, provided basic cursor control and screen management capabilities for early video terminals through a set of proprietary escape sequences, predating standardized approaches and enabling simple text positioning without full ANSI compatibility.^[14] These sequences allowed for operations like moving the cursor to specific coordinates and clearing portions of the screen, serving as a foundational model for subsequent terminal controls.^[14] The Telnet protocol, specified in RFC 854 published in May 1983, enables remote terminal access over networks by establishing a bi-directional, byte-oriented communication channel that negotiates terminal characteristics through option commands like DO, DON'T, WILL, and WON'T, allowing dynamic agreement on features such as echoing and line mode.^[37] This negotiation ensures compatibility between diverse terminal types and hosts, treating the connection as a Network Virtual Terminal (NVT) with seven-bit US-ASCII mapping.^[37] ISO/IEC 6429, first published in 1988 and revised in 1992, serves as the international standard for control functions in coded character sets, specifying encoded representations for operations like cursor movement, screen clearing, and device status reporting in both 7-bit and 8-bit environments, functioning as a global equivalent to ANSI X3.64.^[38] It supports interoperability across systems by defining a core set of functions applicable to text-imaging devices, including extensions for parameterized controls.^[38]

Implementations

Unix-like Systems

In Unix-like systems, text-based user interfaces are fundamentally supported through the kernel's terminal (TTY) subsystem, which manages communication between processes and terminal devices, including virtual consoles and pseudo-terminals (PTYs). The TTY layer handles serial devices and virtual ones like PTYs, providing a unified interface for input/output operations. PTYs consist of a master and slave pair, enabling processes to interact as if connected to a real terminal; the master end is controlled by a program like a shell, while the slave mimics a physical terminal for the process. This setup allows multiple independent sessions on a single physical terminal, crucial for multi-user environments.^[39] The termios API, part of the POSIX standard, governs terminal attributes and line discipline in user space, allowing programs to configure input processing, such as echoing characters or handling special keys like backspace. In the Linux kernel, the N_TTY line discipline implements canonical and non-canonical modes for line editing and raw input, respectively, ensuring efficient handling of text streams without buffering delays in interactive applications. This API is accessed via functions like tcgetattr() and tcsetattr(), which retrieve and set the termios structure defining baud rates, parity, and control characters.^[40]^[41] Command-line shells like Bash, first released in 1989, and Zsh, released in 1990, provide interactive text-based interfaces built atop the TTY subsystem. Bash, the Bourne-Again SHell, integrates the GNU Readline library for line editing, history navigation, and features like tab completion for commands and filenames in text mode. Readline supports Emacs-style key bindings and incremental history search, enhancing usability in terminal environments. Zsh extends similar capabilities natively, offering advanced tab completion with context-aware suggestions and programmable widgets for custom editing behaviors. Both shells rely on the TERM environment variable to adapt their output to the terminal type, ensuring proper rendering of prompts and escapes.^[42]^[43]^[44]^[45] Terminal multiplexers extend TTY functionality by allowing multiple sessions within a single terminal window, facilitating session persistence and splitting. GNU Screen, originating in 1987, creates virtual terminals via PTYs, enabling users to detach and reattach sessions across network interruptions, with support for logging and hardcopy output. Tmux, released in 2007, improves on this with a client-server model using PTYs for each pane and window, offering features like synchronized input across panes and vi/emacs key modes for navigation. These tools are essential for remote administration and development workflows in Unix-like systems.^[46]^[47]^[48] Integration with graphical environments occurs through emulators like xterm, developed for the X Window System (X11), which emulates a text terminal while bridging to desktop sessions. Xterm creates a PTY for shell processes and sets the TERM variable to "xterm" or variants, informing applications of supported capabilities like color and mouse reporting. This allows text UIs to run seamlessly under X11, with escape sequences for cursor control and screen updates.^[49]

DOS and Microsoft Windows

In the DOS era, the command interpreter COMMAND.COM served as the primary text-based user interface shell for MS-DOS, introduced with version 1.0 on August 12, 1981.^[50] This shell operated in a standard 80x25 character text mode, providing a fixed grid for displaying monochrome or color text output on compatible displays like the IBM PC's CGA or later VGA adapters.^[51] To enhance text UI capabilities, the ANSI.SYS device driver was developed in the 1980s, enabling support for ANSI escape sequences that allowed cursor movement, color changes, and screen clearing within the DOS environment when loaded via CONFIG.SYS.^[52] With the advent of Microsoft Windows NT in 1993, the operating system introduced a dedicated console subsystem to handle text-based interfaces, maintaining backward compatibility with DOS applications through a virtual DOS machine while providing native Win32 console APIs.^[53] This subsystem evolved with the introduction of ConHost.exe in Windows 7 (2009), which acts as the host process for console windows, separating console rendering from the client/server runtime subsystem (csrss.exe) for improved security and stability.^[54] The console supports Unicode characters via wide-character APIs like WriteConsoleW, allowing international text display, and includes functions such as SetConsoleTextAttribute for programmatic control of foreground and background colors in the output buffer.^[55] Command shells in Windows further diversified text UI interactions, with cmd.exe debuting in Windows NT 3.1 (1993) as a more robust replacement for COMMAND.COM, supporting batch scripting, environment variables, and redirection while emulating DOS behaviors.^[56] In contrast, Windows PowerShell, released on November 14, 2006, introduced an object-oriented approach to text output, piping .NET objects rather than plain text streams to enable richer scripting and automation beyond traditional line-based interfaces.^[57] A key limitation of the Windows console subsystem has been the absence of native pseudo-terminal (PTY) support, which hindered seamless integration with Unix-like tools requiring virtual terminal emulation; this was addressed with the introduction of the Windows Pseudo Console (ConPTY) API in Windows 10 version 1809 (October 2018), facilitating PTY-like behavior and better interoperability with subsystems like Windows Subsystem for Linux (WSL) by 2019.^[58] Tools such as PuTTY can emulate remote text UIs over SSH by leveraging these console APIs for local rendering.^[54]

Specialized Systems

In specialized operating systems, text-based user interfaces exhibit unique architectural adaptations tailored to their environments. OpenVMS, a multi-user enterprise operating system originally developed by Digital Equipment Corporation, employs the Digital Command Language (DCL) as its primary text-based command interpreter, announced in 1977 and first released in 1978 alongside VMS V1.0 for the VAX-11/780 computer.^[59] DCL provides an English-like syntax for issuing commands, managing processes, and interacting with system resources through a console terminal. Terminal input/output operations in OpenVMS are facilitated by the Record Management Services (RMS), a subsystem that enables record-oriented access to files and unit-record devices, including terminals and printers, with support for legacy DEC terminals such as the VT series through device drivers and control blocks like the File Access Block (FAB) and Record Access Block (RAB).^[60] RMS handles sequential record reads and writes, prompt buffering, and attributes like carriage control and timeouts, ensuring reliable interaction in multi-user time-sharing scenarios.^[61] The Oberon System represents another specialized approach, originating from a late 1980s project at ETH Zurich led by Niklaus Wirth and Jürg Gutknecht.) Its text-based user interface revolves around a tiling window manager composed of "viewers"—rectangular frames displaying editable text that serves dual purposes as documents, source code, and interactive elements, manipulated via mouse selections and keyboard commands embedded directly in the text. This design embeds the UI logic within the Oberon programming language, allowing dynamic modifications without separate configuration files or external tools. In extensions like Active Oberon developed in the late 1990s (1996–1998), the interface incorporates gadget-based components, such as buttons and sliders, embedded as active objects within text windows to enhance interactivity while preserving the text-centric paradigm. A key architectural distinction lies in data handling and integration: OpenVMS relies on RMS for record-oriented files, where data is structured into fixed or variable-length records for efficient I/O across shared resources, contrasting with Oberon's modular approach, where the UI and system services are tightly coupled to the language's object-oriented constructs, enabling persistent, composable text elements without a separate file abstraction layer. OpenVMS has demonstrated longevity through ports to various architectures, including Itanium in 2003 and x86-64 with the first production release (V9.2) in July 2022, supporting modern virtualization environments like VMware and KVM as of 2025, while preserving text console support via serial ports and management interfaces for backward compatibility in enterprise deployments.^[62]^[63] Oberon variants, such as Bluebottle (later A2), continued development into the 2000s, maintaining the text-based interface paradigm.)

Applications

Embedded Systems

In resource-constrained embedded environments, text-based user interfaces prioritize simplicity and efficiency, often interfacing with basic hardware displays limited to character output rather than graphical rendering. Common hardware includes LCD character displays driven by controllers like the HD44780, developed by Hitachi in the 1980s, which supports alphanumeric text on modules such as 16x2 configurations with a 14-pin interface for control and data lines. These displays operate under tight constraints, including adjustable contrast via a bias pin and initialization sequences to set display modes, making them suitable for low-power applications where full pixel manipulation is unnecessary. Alternatively, serial UART interfaces enable text output over asynchronous communication using just two pins (TX and RX), facilitating console-like interactions in microcontrollers without dedicated display hardware.^[64]^[65] On the software side, implementations emphasize minimalism to fit within kilobytes of memory, such as BusyBox, a modular suite originating in the 1990s that bundles a lightweight ash shell alongside stripped-down UNIX utilities into a single executable for embedded Linux systems. This allows interactive command execution in environments with limited RAM and storage, where the ash shell provides POSIX-compliant scripting without the overhead of full-featured alternatives like bash. Custom firmware, typically written in C, further supports text I/O through functions like printf for formatted output to UART or LCD, enabling basic menus and status reporting directly in the application code.^[66] Representative examples illustrate these approaches in practice: the Cisco IOS command-line interface (CLI), a text-based console for router configuration, relies on serial access for operational commands in embedded networking hardware, supporting modes like user EXEC for monitoring and privileged EXEC for deeper control. In IoT devices, MicroPython's REPL (Read-Eval-Print Loop) offers an interactive text prompt over serial or USB, optimized for real-time code evaluation on resource-limited boards like the ESP8266, with features such as auto-completion and interrupt handling to aid development without heavy tooling.^[67]^[68] To address memory limitations, optimizations in text rendering avoid complex terminal emulation, instead employing lightweight techniques like character cell grids overlaid on primitive graphics for UI elements such as menus and dialogs, as demonstrated in toolkits designed for low-tier systems with minimal computing resources. These methods ensure responsive interfaces on devices with under 1 MB of RAM, focusing on object-oriented abstractions that reduce code size while supporting overlapping windows and user interactions without demanding full ANSI compliance.^[69]

Modern and Niche Uses

In the 2010s, web-based text user interfaces emerged as a key enabler for cloud computing and remote development, allowing terminals to run seamlessly within web browsers without native installations. xterm.js, a TypeScript-based front-end component released around 2017, provides fully-featured terminal emulation for web applications, supporting features like true-color rendering and input handling to deliver interactive shell experiences.^[70] It powers in-browser IDEs such as SourceLair, where users access remote shells for coding and debugging directly through the web.^[71] Complementing this, the Eclipse Theia platform, initiated in 2017 as an open-source IDE framework, integrates a built-in terminal emulator leveraging web standards like WebSockets for full command-line access in both cloud and desktop setups.^[72] These tools bridge traditional text UIs with modern web ecosystems, facilitating scalable, browser-native development environments. Text-based user interfaces persist in gaming and social applications, where they offer lightweight, immersive interactions. The libtcod library, developed in the mid-2000s as a C-based toolkit for roguelike games, enables procedural generation of text displays with advanced features like pathfinding and field-of-view algorithms, supporting true-color consoles for enhanced visual depth in ASCII art worlds.^[73] It remains a staple in contemporary roguelike development, as evidenced by ongoing tutorials adapting it for languages like Rust and C++ to create turn-based adventures with dynamic text rendering.^[74] In social platforms, Discord's ecosystem of text bots utilizes command-line-style inputs for interactive experiences, such as text adventure games and role-playing simulations that process user commands in chat channels to drive narrative progression.^[75] Bots like RuneBot exemplify this by emulating text-based MMORPG mechanics, allowing players to issue commands for actions like combat or exploration within Discord servers.^[76] Accessibility applications highlight the enduring value of text UIs for inclusive computing. On Linux systems, the Orca screen reader, a free and open-source tool integrated with the GNOME desktop since the early 2000s, vocalizes text-based content from user interfaces, including terminals and documents, to support visually impaired users through speech synthesis and Braille output.^[77] Orca processes screen elements via accessibility APIs, reading command-line outputs and form interactions aloud to enable navigation and control in text-heavy environments like shells and editors.^[78] Emerging trends in text UIs blend artificial intelligence with command-line efficiency, while retro revivals foster niche creativity. The GitHub Copilot CLI, launched in public preview in September 2025 and expanded in the mid-2020s, integrates AI agents into terminals to generate, explain, and execute commands, aiding developers in tasks like debugging and repository management without leaving the text interface.^[79] This tool uses large language models to interpret natural language queries and output shell-compatible responses, streamlining workflows in resource-constrained or remote setups.^[80] Concurrently, modern revivals of retro computing have renewed interest in text-based adventures, with interactive fiction platforms reimagining 1970s-1980s classics like Zork through web-accessible parsers that emphasize narrative depth over graphics.^[81] These efforts, often powered by emulators and open-source tools, appeal to enthusiasts seeking minimalist, imagination-driven interfaces in digital culture.

References

[1]
[PDF] CS 45, Lecture 5
TUI (Text User Interface) programs. These are programs that display a sort of imitation of a graphical interface using text within a terminal. These are ...
[2]
[PDF] Proper Complex Script Support in Text Terminals. - Unicode
Command-line interface (CLI) and Text-based user interface (TUI) applications play important roles in computer systems, especially for software developers and ...
[3]
Writing Programs with NCURSES - invisible-island.net
Historically, the first ancestor of curses was the routines written to provide screen-handling for the vi editor; these used the termcap database facility (both ...
[4]
Introduction - The Linux Documentation Project
NCURSES not only creates a wrapper over terminal capabilities, but also gives a robust framework to create nice looking UI (User Interface)s in text mode.Missing: definition | Show results with:definition
[5]
Comparing Text-based and Graphic User Interfaces for Novice ... - NIH
Graphic User Interface (GUI) is commonly considered to be superior to Text-based User Interface (TUI). This study compares GUI and TUI in an electronic dental ...Missing: history | Show results with:history
[6]
https://wiki.debian.org/Aptitude
[7]
[PDF] C11: GUI and JavaFX
Mar 7, 2018 · • Text-based user interface (or command-line interface). • Graphical user interface. 3/7/2018. CUNY | Brooklyn College. 12. Page 13. Text-based ...
[8]
Console Virtual Terminal Sequences - Microsoft Learn
Sep 20, 2022 · Virtual terminal sequences are control character sequences that can control cursor movement, console color, and other operations when written to the output ...Missing: characteristics | Show results with:characteristics
[9]
[PDF] 7-bit american national standard code for information interchange (7 ...
This standard is a revision of American National Standard Code for Information Inter- change, ANSI X3 .4-1977, and was developed in parallel with its ...
[10]
http://bitsavers.informatik.uni-stuttgart.de/pdf//ansi/X3/X3.004-1986_7-Bit_ASCII.pdf
[11]
ENIAC - Engineering and Technology History Wiki
Nov 23, 2017 · An IBM card reader and an IBM cardpunch provided input and output. All together there were 18,000 tubes, 70,000 resistors, 10,000 capacitors ...
[12]
REMINISCENCES ON THE HISTORY OF TIME SHARING
This was the first time-sharing system based on display terminals. It was used until 1969 or 1970 for Suppes's work on computer aided instruction.Missing: 1960s | Show results with:1960s
[13]
Digital's Video Terminals - VT100.net
Jun 12, 1999 · The VT05 was the first video terminal manufactured by Digital, introduced in 1970. This was not much more than a video teletype, receiving and transmitting at ...
[14]
Early Surprises - 1969-1970 | History of Computer Communications
The TIP connected up to sixty-three terminals to the network. With the TIP, the ARPANET took-off. The biggest surprise by far, however, was electronic mail ...
[15]
ANSI Art and ASCII Art - Origins in Standards
64-1979. This American National Standard was created by the coding committee X3L2, which collaborated in close cooperation with the European Computer ...Missing: 1980s | Show results with:1980s
[16]
GUIs: The computing revolution that turned us into cranky idiots
Jun 27, 2013 · After Windows 3.0, use of GUIs utterly exploded in computing. Text-based applications made way for graphical-based applications.
[17]
A History of the GUI - Ars Technica
May 4, 2005 · I'll be presenting a brief introduction to the history of the GUI. The topic, as you might expect, is broad, and very deep.
[18]
[PDF] All About CRT Display Terminals - Bitsavers.org
Apr 1, 1974 · In less than a decade, the CRT display terminal has become almost as commonplace as the ubiquitous tele- typewriter and has found its way ...
[19]
[PDF] Alphanumeric Display Terminals - Bitsavers.org
Originally invented as a "glass teletype," an alternative to using teleprinter terminal as a computer operator console, the display termi- nal has evolved to ...
[20]
4010 - TekWiki
Mar 11, 2024 · The Tektronix 4010 is a graphics terminal announced at the Fall Joint Computer Conference in October 1971, based on an 11" direct-view storage tube.Missing: 1968 | Show results with:1968
[21]
Fundamentals of RS-232 Serial Communications - Analog Devices
Mar 29, 2001 · With this in mind, the maximum slew rate allowed is 30V/ms. Additionally, standard defines a maximum data rate of 20kbps , again to reduce the ...
[22]
Ultimate review on RS232 protocol - Serial Port Monitor
Dec 12, 2024 · In the RS232 protocol, baud rates of 110 to 230400 are supported. Baud rates of 1200, 4800, 9600, and 115200 are most commonly seen. The baud ...
[23]
[PDF] DEC VT100 terminal - Bitsavers.org
In. VT52 mode, the VT100 terminal is compatible with previous DIGITAL software using the VT52 video ter- minal. Both ANSI and VT52 modes are outlined in the.
[24]
The DEC VT100 Terminal - Columbia University
Mar 22, 2021 · The Digital Equipment Corporation VT100 was the first ANSI X3.64 compliant terminal and featured lots of innovations including control by an Intel 8085 ...
[25]
XTERM – Terminal emulator for the X Window System
The xterm program is a terminal emulator for the X Window System. It was originally developed in the mid-1980s to provide DEC VT102 and Tektronix 4014 ...
[26]
PuTTY: a free SSH and Telnet client
### Summary of PuTTY History and Features
[27]
Console Drivers - The Linux Kernel documentation
The Linux kernel has 2 general types of console drivers. The first type is assigned by the kernel to all the virtual consoles during the boot process.
[28]
https://docs.kernel.org/driver-api/console.html
[29]
https://invisible-island.net/xterm/xterm.faq.html
[30]
https://invisible-island.net/luit/luit.html
[31]
[PDF] additional controls for use with American national standard code for ...
This standard defines encoded control functions for data interchange with 2D character-imaging devices, augmenting the ASCII standard.
[32]
[PDF] Standard ECMA-48
Jun 13, 1991 · This ECMA Standard defines control functions and their coded representations for use in a 7-bit code, an extended 7-bit code, an 8-bit code or ...
[33]
ctlseqs(ms) - invisible-island.net
ESC SP F 7-bit controls (S7C1T), VT220. This tells the terminal to send C1 control characters as 7-bit sequences, e.g., its responses to queries. DEC VT200 and ...
[34]
[PDF] VT220 Programmer Reference Manual - VT100.net
VT52 Escape Sequences. V. 2-3. 2-5. 2-8. 2-10. 2-11. 2-16. 3-4. 3-4. 3-5. 3-7. 3-9. 4-2. * ... Chapter 3 Transmitted Codes describes the codes that the terminal.
[35]
RFC 854 - Telnet Protocol Specification - IETF Datatracker
The purpose of the TELNET Protocol is to provide a fairly general, bi-directional, eight-bit byte oriented communications facility.
[36]
ISO/IEC 6429:1992 - Control functions for coded character sets
Includes control functions and their coded representations for a 7-bit code, an extended 7-bit code, an 8-bit code or an extended 8-bit code.
[37]
NCURSES — comments on NetBSD curses - invisible-island.net
NetBSD's curses story begins in 1993, using as its starting point the BSD 4.3 curses software. There was at least one port of the BSD curses to Linux in the ...
[38]
NCURSES – New Curses - invisible-island.net
Thomas Dickey is the maintainer/developer of ncurses. This page gives some background and pointers to ncurses resources.Missing: fork | Show results with:fork
[39]
pty(7) - Linux manual page - man7.org
A pseudoterminal (pty) is a pair of virtual character devices providing a bidirectional communication channel, with a master and slave end.
[40]
termios(3) - Linux manual page - man7.org
The termios functions describe a general terminal interface that is provided to control asynchronous communications ports. The termios structure Many of the ...
[41]
N_TTY — The Linux Kernel documentation
The Linux Hardware Timestamping Engine (HTE) · Kernel subsystem documentation · Locking in the kernel · Linux kernel licensing rules · How to write kernel ...
[42]
History Interaction (Bash Reference Manual) - GNU.org
If Readline is being used, and the histreedit shell option is enabled, a failed history expansion is reloaded into the Readline editing buffer for correction.
[43]
Bash - GNU Project - Free Software Foundation
Sep 22, 2020 · <help-bash@gnu.org> (web interface) is used to ask for help about Bash, Bash programming or Bash shell scripting; ... $Date: 2020/09/22 14:25:49 $
[44]
The GNU Readline Library
Jul 1, 2025 · The Readline library includes additional functions to maintain a list of previously-entered command lines, to recall and perhaps reedit those ...
[45]
2 Introduction - zsh
Zsh is a UNIX command interpreter (shell) usable as an interactive login ... Zsh version 5.9, released on May 14, 2022.
[46]
GNU Screen User's Manual
Screen is available under the GNU copyleft. The latest official release of screen available via anonymous ftp from ' prep.ai.mit.edu ', ' nic.funet.fi ' or ...
[47]
GNU screen 5 proves it's still got game even after 37 years
Sep 3, 2024 · GNU screen 5.0.0 is the latest version of a tool that's been around since early 1987. This release has multiple tweaks to its (admittedly basic) user interface.
[48]
tmux(1) - Linux manual page - man7.org
tmux is a terminal multiplexer: it enables a number of terminals to be created, accessed, and controlled from a single screen.
[49]
XTERM(1) manual page - X.Org
The xterm program is a terminal emulator for the X Window System. It provides DEC VT102/VT220 (VTxxx) and Tektronix 4014 compatible terminals.
[50]
https://www.dosdays.co.uk/topics/dos_versions_pt2.php
[51]
VGA Hardware - OSDev Wiki
In a standard text mode, these planes are interleaved into host memory. ... mode 3h (80x25 text mode), mode 12h (640x480 planar 16 color mode), mode 13h ...
[52]
MS-DOS and Windows Command Line Ansi.sys Command
Mar 21, 2025 · An ANSI escape sequence is a sequence of ASCII characters; the first two are the escape character (1Bh) and the left bracket character (5Bh).
[53]
The Evolution of the Windows Command-Line
Jun 27, 2018 · In this post we'll discuss some of the background & history behind the Windows Command-Line. Specifically, we'll explore its humble origins in ...
[54]
Windows Command-Line: Inside the Windows Console
Jul 20, 2018 · Windows mandates that ConHost.exe is the Console app which is connected to Command-Line apps. Windows controls the creation of the ...
[55]
SetConsoleTextAttribute function - Windows Console - Microsoft Learn
Feb 12, 2021 · Sets the attributes of characters written to the console screen buffer by the WriteFile or WriteConsole function, or echoed by the ReadFile or ReadConsole ...
[56]
cmd | Microsoft Learn
May 23, 2025 · Starts a new instance of the command interpreter, Cmd.exe. If used without parameters, cmd displays the version and copyright information of the operating ...
[57]
Release history of modules and cmdlets - PowerShell | Microsoft Learn
Jan 17, 2025 · This article lists the modules and cmdlets that are included in various versions of PowerShell. This is a summary of information found in the release notes.
[58]
Introducing the Windows Pseudo Console (ConPTY)
Aug 2, 2018 · Detecting the ConPTY API. The new ConPTY API will be available for the first time in the Autumn/Fall 2018 release of Windows 10. If you need ...
[59]
[PDF] LCD Starter Guide
Oct 17, 2001 · Nearly every pixel-based alphanumeric LCD module made today uses the Hitachi HD44780 LCD controller chip, or a derivative such as the Seiko- ...
[60]
UART | Embedded systems - DESE Labs
In this article we are going to use a UART module for serial port communication that uses two pins ie RX and TX for data transfer.
[61]
BusyBox
### Summary of BusyBox Use in Embedded Systems
[62]
Chapter: Using the Cisco IOS Command-Line Interface
This user interface allows you to directly and simply execute Cisco IOS commands, whether using a router console or terminal, or using remote access methods.
[63]
The MicroPython Interactive Interpreter Mode (aka REPL)
This section covers some characteristics of the MicroPython Interactive Interpreter Mode. A commonly used term for this is REPL (read-eval-print-loop)Missing: IoT | Show results with:IoT
[64]
A Text-Based User Interface Style Toolkit for Low-Tier Embedded Systems
### Summary of Text-Based UI Approach in Low-Tier Embedded Systems
[65]
xtermjs/xterm.js: A terminal for the web - GitHub
: Xterm.js is really fast, it even includes a GPU-accelerated renderer. Rich Unicode support: Supports CJK, emojis, and IMEs. Self-contained: Requires zero ...Releases 88 · Issues 207 · Pull requests 22 · Actions
[66]
Xterm.js
Xterm. js is used in several world-class applications to provide great terminal experiences. SourceLair: In-browser IDE that provides its users with fully- ...Class: Terminal · Using addons · Documentation
[67]
Eclipse Theia Platform
Theia is built on a modern web technology stack, offering language support via LSP and DAP, hosting VS Code extensions, and providing full terminal access.Learn About The Latest 1.65... · Cloud & Desktop · Contributors & AdoptersMissing: emulator | Show results with:emulator
[68]
libtcod/libtcod: A collection of tools and algorithms for ... - GitHub
libtcod is a free, fast, portable and uncomplicated API for roguelike developers providing a true color console, pathfinding, field-of-view, and a few other ...Missing: games | Show results with:games
[69]
Complete roguelike tutorial using C++ and libtcod - part 1: setting up
Apr 22, 2025 · It is intended for C++ beginners and people who want to learn how to use libtcod to create a simple roguelike video game. It covers both Linux and Windows ...Introduction · Pre-requisites · Installing the compiler · Installing libtcod
[70]
Text Discord Bots and Apps
Never miss a word on Discord! Get accurate transcripts of all messages with Speechify, the ultimate Discord transcription bot.Missing: based | Show results with:based
[71]
RuneBot - A RuneScape text based discord bot. | Rune-Server
May 10, 2021 · Welcome to RuneBot, a Discord Bot Game that intends to provide an enjoyable way to play your favorite MMORPG within a Discord environment.
[72]
Orca Screen Reader
Before You Begin · Getting Started · Reading Documents and Web Pages · Reviewing and Interacting with Screen Contents · Quick Reference · About.Missing: interface | Show results with:interface
[73]
How to use the Orca screen reader in Linux | ZDNET
Jun 25, 2024 · How to use the Orca screen reader in Linux · 1. Open Settings · 2. Enable Orca · 3. Configure Orca · 1. Install Orca · 2. Enable the Screen Reader · 3 ...
[74]
GitHub Copilot CLI
Build, edit, debug, and refactor code locally ... Copilot CLI edits files, runs commands, and helps you iterate fast without ever leaving your local environment.
[75]
GitHub Copilot CLI: How to get started
Oct 13, 2025 · Discover how to use GitHub Copilot directly in the terminal. From cloning a repository to opening a pull request, here's how to streamline ...
[76]
Top 10 Retro Revival Trends in Digital Culture - Retromash
Mar 17, 2025 · Classic text-based adventure games, once the pinnacle of early computer gaming, are experiencing a revival through modern interactive fiction.