Hubbry Logo
search
logo

Text mode

logo
Community Hub0 Subscribers
Read side by side
from Wikipedia

Text mode is a computer display mode in which content is internally represented on a computer screen in terms of characters rather than individual pixels. Typically, the screen consists of a uniform rectangular grid of character cells, each of which contains one of the characters of a character set; at the same time, contrasted to graphics mode or other kinds of computer graphics modes.

Text mode applications communicate with the user by using command-line interfaces and text user interfaces. Many character sets used in text mode applications also contain a limited set of predefined semi-graphical characters usable for drawing boxes and other rudimentary graphics, which can be used to highlight the content or to simulate widget or control interface objects found in GUI programs. A typical example is the IBM code page 437 character set.

An important characteristic of text mode programs is that they assume monospaced fonts, where every character has the same width on screen, which allows them to easily maintain the vertical alignment when displaying semi-graphical characters. This was an analogy of early mechanical printers which had fixed pitch. This way, the output seen on the screen could be sent directly to the printer maintaining the same format.

Depending on the environment, the screen buffer can be directly addressable. Programs that display output on remote video terminals must issue special control sequences to manipulate the screen buffer. The most popular standards for such control sequences are ANSI and VT100.

Programs accessing the screen buffer through control sequences may lose synchronization with the actual display so that many text mode programs have a redisplay everything command, often associated with the Ctrl+L key combination.

History

[edit]

Text mode video rendering came to prominence in the early 1970s, when video-oriented text terminals started to replace teleprinters in the interactive use of computers.

Benefits

[edit]

The advantages of text modes as compared to graphics modes include lower memory consumption and faster screen manipulation.[1] At the time text terminals were beginning to replace teleprinters in the 1970s, the extremely high cost of random-access memory in that period made it exorbitantly expensive to install enough memory for a computer to simultaneously store the current value of every pixel on a screen, to form what would now be called a framebuffer. Early framebuffers were standalone devices which cost tens of thousands of dollars, in addition to the expense of the advanced high-resolution displays to which they were connected.[2] For applications that required simple line graphics but for which the expense of a framebuffer could not be justified, vector displays were a popular workaround. But there were many computer applications (e.g., data entry into a database) for which all that was required was the ability to render ordinary text in a quick and cost-effective fashion to a cathode-ray tube.

Text mode avoids the problem of expensive memory by having dedicated display hardware re-render each line of text from characters into pixels with each scan of the screen by the cathode ray. In turn, the display hardware needs only enough memory to store the pixels equivalent to one line of text (or even less) at a time. Thus, the computer's screen buffer only stores and knows about the underlying text characters (hence the name "text mode") and the only location where the actual pixels representing those characters exist as a single unified image is the screen itself, as viewed by the user (thanks to the phenomenon of persistence of vision).

For example, a screen buffer sufficient to hold a standard grid of 80 by 25 characters requires at least 2,000 bytes.[1] Assuming a monochrome display, 8 bits per byte, and a standard size of 8 times 8 bits for each character, a framebuffer large enough to hold every pixel on the resulting screen would require at least 128,000 bits, 16,000 bytes, or just under 16 kilobytes. By the standards of modern computers, these may seem like trivial amounts of memory, but to put them in context, the original Apple II was released in 1977 with only four kilobytes of memory and a price of $1,300 in U.S. dollars (at a time when the minimum wage in the United States was only $2.30 per hour). Furthermore, from a business perspective, the business case for text terminals made no sense unless they could be produced and operated more cheaply than the paper-hungry teleprinters they were supposed to replace.

Another advantage of text mode is that it has relatively low bandwidth requirements in remote terminal use. Thus, a text mode remote terminal can necessarily update the screen much faster than a graphics mode remote terminal linked to the same amount of bandwidth (and in turn will seem more responsive), since the remote server may only need to transmit a few dozen bytes for each screen update in text mode, as opposed to complex raster graphics remote procedure calls that may require the transmission and rendering of entire bitmaps.

User-defined characters

[edit]

The border between text mode and graphical programs can sometimes be fuzzy, especially on the PC's VGA hardware, because many later text mode programs tried to push the model to the extreme by playing with the video controller. For example, they redefined the character set in order to create custom semi-graphical characters, or even created the appearance of a graphical mouse pointer by redefining the appearance of the characters over which the mouse pointer was shown at a given time.

Text mode rendering with user-defined characters has also been useful for 2D computer and video games because the game screen can be manipulated much faster than with pixel-oriented rendering.

Technical basis

[edit]

A video controller implementing a text mode usually uses two distinct areas of memory. Character memory or a pattern table contains a raster font in use, where each character is represented by a dot matrix (a matrix of bits), so the character memory could be considered as a three-dimensional bit array. Display matrix (a text buffer, screen buffer, or nametable) tracks which character is in each cell. In the simple case, the display matrix can be just a matrix of code points (so named character pointer table), but it usually stores for each character position not only a code, but also attributes.

C
L
0
0
0
0
0
0
0
0
0
1
0
0
0
1
0
0
0
0
1
1
0
0
1
0
0
0
0
1
0
1
0
0
1
1
0
0
0
1
1
1
00000000
11111111
00001111
00110011
01010101
11…
00…
00…
00…
01…
00000          
00001        
00010    
00011    
00100    
00101            
00110        
00111                
01000
01001
… … …

A sample of character box and corresponding electronic scheme. The glyph is 8×8 pixels, with 3-bit low parts of scan line and dot counter. The screen is between 20×18 and 32×32 character cells, with 5-bit indices.

In the case of raster scan output, which is the most common for computer monitors, the corresponding video signal is made by the character generator, a special electronic unit similar to devices with the same name used in video technology. The video controller has two registers: scan line counter and dot counter, serving as coordinates in the screen dot matrix. Each of them must be divided by corresponding glyph size to obtain an index in the display matrix; the remainder is an index in glyph matrix. If glyph size equals to 2n, then it is possible just to use n low bits of a binary register as an index in glyph matrix, and the rest of bits as an index in the display matrix — see the scheme.

The character memory resides in read-only memory in some systems. Other systems allow the use of RAM for this purpose, making it possible to redefine the typeface and even the character set for application-specific purposes. The use of RAM-based characters also facilitates some special techniques, such as the implementation of a pixel-graphics frame buffer by reserving some characters for a bitmap and writing pixels directly to their corresponding character memory. In some historical graphics chips, including the TMS9918, the MOS Technology VIC, and the Game Boy graphics hardware, this was actually the canonical way of doing pixel graphics.

Text modes often assign attributes to the displayed characters. For example, the VT100 terminal allows each character to be underlined, brightened, blinking or inverse. Color-supporting devices usually allow the color of each character, and often the background color as well, to be selected from a limited palette of colors. These attributes can either coexist with the character indices or use a different memory area called color memory or attribute memory.[3]

Some text mode implementations also have the concept of line attributes. For example, the VT100-compatible line of text terminals supports the doubling of the width and height of the characters on individual text lines.

PC common text modes

[edit]

Depending on the graphics adapter used, a variety of text modes are available on IBM PC–compatible computers. They are listed on the table below:[4]

Text res. Char. size Graphics res. Colors Adapters
80×25 9×14 720×350 B&W Text MDA, Hercules
40×25 8×8 320×200 16 colors CGA, EGA
80×25 8×8 640×200 16 colors CGA, EGA
80×25 8×14 640×350 16 colors EGA
80×43 8×8 640×350 16 colors EGA
80×25 9×16 720×400 16 colors VGA
80×30 8×16 640×480 16 colors VGA
80×50 9×8 720×400 16 colors VGA
80×60 16 colors VESA-compatible Super VGA
132×25 16 colors VESA-compatible Super VGA
132×43 16 colors VESA-compatible Super VGA
132×50 16 colors VESA-compatible Super VGA
132×60 16 colors VESA-compatible Super VGA

MDA text could be emphasized with bright, underline, reverse and blinking attributes.

Video cards in general are backward compatible, i.e. EGA supports all MDA and CGA modes, VGA supports MDA, CGA and EGA modes.

By far the most common text mode used in DOS environments, and initial Windows consoles, is the default 80 columns by 25 rows, or 80×25, with 16 colors. This mode was available on practically all IBM and compatible personal computers. Several programs, such as terminal emulators, used only 80×24 for the main display and reserved the bottom row for a status bar.

Two other VGA text modes, 80×43 and 80×50, exist but were very rarely used. The 40-column text modes were never very popular outside games and other applications designed for compatibility with television monitors, and were used only for demonstration purposes or with very old hardware.

Character sizes and graphical resolutions for the extended VESA-compatible Super VGA text modes are manufacturer-dependent. Also on these display adapters, available colors can be halved from 16 to 8 when a second customized character set is employed (giving a total repertoire of 512 —instead the common 256— different graphic characters simultaneously displayed on the screen).

Some cards (e.g. S3) supported custom very large text modes, like 100×37 or even 160×120. In Linux systems, a program called SVGATextMode is often used with SVGA cards to set up very large console text modes, such as for use with split-screen terminal multiplexers.

Modern usage

[edit]

Many modern programs with a graphical interface simulate the display style of text mode programs, notably when it is important to preserve the vertical alignment of text, e.g., during computer programming. There exist also software components to emulate text mode, such as terminal emulators or command line consoles. In Microsoft Windows, the Win32 console usually opens in emulated, graphical window mode. It can be switched to full screen, true text mode and vice versa by pressing the Alt and Enter keys together.[5] This is no longer supported by the WDDM display drivers introduced with Windows Vista.[6]

Linux virtual consoles operate in text mode. Most Linux distributions support several virtual console screens, accessed by pressing Ctrl, Alt and a function key together.

UEFI shell implemented with Simple Text Output Protocol

The AAlib open source library provides programs and routines that specialize in translating standard image and video files, such as PNG and WMV, and displaying them as a collection of ASCII characters. This enables a rudimentary viewing of graphics files on text mode systems, and on text mode web browsers such as Lynx.

UEFI-based systems provide Unicode text mode output support with Simple Text Output Protocol.[7] Minimum supported text resolution is at least 80×25 and minimal recommended character set includes Basic Latin Unicode characters.[8]

See also

[edit]

References

[edit]
[edit]

Further reading

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia
from Grokipedia
Text mode is a fundamental display mode in computing systems where the screen is organized into a grid of character cells, rendering only alphanumeric text characters from a defined character set, such as ASCII, without support for graphical images or pixel-based visuals.[1][2] This mode, also known as character mode or alphanumeric mode, divides the display into rows and columns of fixed-size boxes, each containing a single character, enabling efficient text-based interaction and output.[2] In contrast to graphics mode, which manipulates individual pixels for images and interfaces, text mode prioritizes simplicity and speed for command-line interfaces (CLI) and early software environments.[1] Historically, text mode was the predominant display method in personal computers before the rise of graphical user interfaces (GUIs) in the 1980s and 1990s, serving as the built-in default for systems lacking dedicated graphics hardware.[1] During this era, it facilitated core operations like booting, command execution, and program interaction on platforms such as MS-DOS and early Unix terminals, where graphics modes were optional extensions requiring additional hardware or software support.[1] Common configurations included 80 columns by 25 rows for standard displays, providing a total of 2,000 character cells, which balanced readability with limited memory resources.[3] Technically, text mode often relies on memory-mapped video buffers, as seen in the Video Graphics Array (VGA) standard, where the display memory starts at physical address 0xb8000 and spans 4,000 bytes to accommodate the 80x25 grid.[3] Each cell is defined by two bytes: the first holding the character's ASCII code, and the second specifying attributes like foreground and background colors (e.g., green text on a black background using values 0x2 for green and 0x0 for black).[3] In contemporary computing, text mode persists in console windows, terminal emulators, and text-only web browsers, where users may disable graphics to accelerate loading or focus on content extraction.[2] It also underpins bootloaders, embedded systems, and server environments that favor lightweight, resource-efficient text rendering over full graphical capabilities.[2]

Overview and Fundamentals

Definition and Characteristics

Text mode is a display mode in computing where the screen content is represented as a fixed grid of character cells, commonly organized into 80 columns by 25 rows. Each cell contains a character code that references a predefined pattern stored in a character generator ROM, which converts the code into a dot-matrix bitmap for display; additionally, cells support attributes such as foreground and background colors to enhance readability and visual distinction.[2][4] This approach allows for efficient rendering of textual information without requiring direct pixel manipulation. In contrast to graphics modes, which enable fine-grained control over individual pixels to create images, animations, or vector graphics, text mode restricts output to discrete character cells, making it suitable primarily for alphanumeric content and basic block-based visuals rather than complex illustrations.[5][6] Key characteristics include its fixed resolution grid, which ensures consistent layout across compatible systems, and reliance on standardized character sets such as ASCII for basic Latin letters, digits, and symbols, or IBM Code Page 437 for extended support including line-drawing elements, accented characters, and icons commonly used in early PC environments.[2][7] Text mode plays a foundational role in text user interfaces (TUIs) and command-line environments, where it facilitates direct keyboard input and output for applications like shells, editors, and utilities, prioritizing simplicity and low resource demands over visual sophistication.[6][8]

Technical Basis

Text mode operation in early computing systems, particularly IBM PC-compatible architectures, relies on a dual-layer video memory structure to store both character data and display attributes. The character memory holds ASCII or extended codes for each display cell, requiring 2000 bytes for an 80×25 grid configuration. Adjacent to this is the attribute memory, allocating 1 byte per cell to encode visual properties such as colors and special effects like blinking, resulting in a total of 4000 bytes per display page in color adapters. This interleaved format, with character and attribute bytes paired sequentially, is accessed via memory-mapped I/O at addresses like B800:0000 for color text modes or B000:0000 for monochrome.[9][10][11] Central to the display generation is the video controller, such as the Motorola 6845 Cathode Ray Tube Controller (CRTC) used in IBM PC video adapters. The CRTC manages the scanning process by generating memory addresses to fetch character codes from video RAM and corresponding attribute bytes, while synchronizing horizontal and vertical timing signals to traverse the display grid. It coordinates with the character generator circuitry to produce pixel data for each cell, ensuring the raster scan aligns with monitor refresh rates.[12][13] Attributes are processed through a bit-packed byte structure that defines rendering characteristics for each character. In VGA implementations, the attribute byte uses 4 bits for foreground color selection (spanning 16 palette entries), 3 bits for background color (8 entries), and 1 bit for a blinking flag; a global mode in the attribute controller can repurpose the blink bit for intensity, enabling brighter variants of colors 0–7. Underline and other effects are handled via dedicated bits in the attribute controller registers, which modulate the character bitmap during scanline assembly.[14][11] Font rendering draws from raster patterns stored in read-only memory (ROM) on the video adapter, typically 8×8 or 8×14 pixels per glyph to match common scanline counts. For each character cell, the controller indexes the ROM using the fetched code to retrieve an 8-byte (or equivalent) bitmap, then generates individual scanlines by shifting out bits and applying attribute-based coloring or effects before combining them into the video signal.[11][15] The processed pixel data is output as electrical signals tailored to the adapter type: the Monochrome Display Adapter (MDA) emits TTL-level monochrome signals for video presence and intensity, producing green or amber phosphor illumination on compatible CRTs, while the Color Graphics Adapter (CGA) provides TTL RGB signals for direct color display or an NTSC-compatible composite video output for television monitors.[16][17]

Historical Development

Origins in Early Computing

The emergence of text mode in early computing can be traced to the 1960s and 1970s, when video display terminals (VDTs) began replacing slower teleprinters for interactive computer access, providing immediate visual feedback on cathode-ray tube (CRT) screens.[18] These VDTs transmitted data using standard protocols like ASCII over serial interfaces, enabling efficient text-based communication between users and mainframe systems.[19] A seminal example is the Digital Equipment Corporation (DEC) VT05, introduced in 1970 as DEC's first standalone raster-scan video terminal, featuring a 20-by-72 character display limited to uppercase ASCII characters and connected via RS-232 serial lines at speeds up to 2400 baud.[20][21] This design marked a shift from mechanical printing to electronic text rendering, laying the groundwork for grid-based displays where characters occupied fixed positions on the screen. Mainframe systems further influenced text mode through terminals optimized for high-volume data processing, such as the IBM 3270 family introduced in 1971.[22] The 3270 employed block-mode operation with fixed character grids—typically 24 rows by 80 columns—allowing users to edit fields locally before transmitting entire screens to the host, which minimized communication overhead and improved efficiency in time-sharing environments.[23] This approach supported attribute concepts like highlighting and protection for data fields, enhancing usability without requiring full-screen redraws.[22] A key innovation enabling widespread adoption was the use of CRT displays paired with dedicated character generators, hardware circuits that converted ASCII codes into dot patterns for predefined glyphs, stored in read-only memory.[24] Unlike vector or bitmap graphics systems, which demanded expensive refresh memory and complex deflection logic for arbitrary images, character generators drastically reduced costs by limiting output to a fixed set of symbols, making text terminals affordable for institutional use at under $2,000 per unit by the mid-1970s.[25] This efficiency prioritized textual information display over graphical versatility, establishing text mode as a practical standard for computing interfaces. The transition to microcomputers extended these principles, as seen in the MITS Altair 8800, released in 1975 as the first commercially successful personal computer kit.[26] Lacking built-in video capabilities, the Altair relied on serial text output to external terminals or teletypes via add-on interface boards, such as RS-232 adapters, for user interaction and program debugging.[27] This setup influenced subsequent designs, paving the way for integrated dedicated video boards that rendered text modes directly on affordable CRT monitors, bridging mainframe terminal technology to personal systems.[28]

Evolution in Personal Computers

The introduction of the IBM Personal Computer in 1981 marked a pivotal shift in text mode usage for personal computing, with the Monochrome Display Adapter (MDA) providing an 80x25 character monochrome text display optimized for high-clarity business applications. This adapter, paired with a green- or amber-phosphor monitor, emphasized sharp text rendering without graphics capabilities, reflecting the era's focus on productivity over visual entertainment. In the same year, IBM released the Color Graphics Adapter (CGA), which extended text mode to support color while maintaining compatibility with the MDA's text standards, allowing 80x25 text in 16 colors for broader appeal in home and educational settings. By 1984, the Enhanced Graphics Adapter (EGA) advanced this further, introducing higher-resolution text modes with up to 640x350 resolution and support for 16 simultaneous colors from a palette of 64, enabling finer character definition and smoother display transitions. The 1987 Video Graphics Array (VGA) standard, debuted with the IBM PS/2 line, solidified these improvements by standardizing 16-color text modes using 9x16 pixel fonts, which became the de facto benchmark for PC text rendering across compatible hardware.[29] Standardization accelerated through the BIOS interrupt 10h (INT 10h), an integral part of the original IBM PC firmware that enabled software to switch video modes, query capabilities, and manage text attributes uniformly across adapters from MDA onward.[30] In the 1990s, the Video Electronics Standards Association (VESA) extended this via BIOS Extensions (VBE), adding support for higher-resolution text modes like 132-column displays while preserving backward compatibility with legacy systems.[31] Building on earlier terminal influences, these developments transformed text mode from a basic output mechanism into a versatile, hardware-agnostic interface for PC applications. The rise of graphics acceleration in the mid-1990s, driven by dedicated 2D/3D video cards and graphical user interfaces like Windows 95, diminished reliance on pure text modes for everyday computing, as accelerated rendering favored bitmap graphics over character-based displays. Nonetheless, text modes persisted in bootloaders, DOS environments, and diagnostic tools, ensuring their utility in low-level system operations well into the decade.[29]

Features and Capabilities

Benefits and Performance Advantages

Text mode offers significant memory efficiency compared to graphical modes, requiring only 4 KB of video memory for an 80×25 color display, where each character cell uses 2 bytes—one for the ASCII code and one for color attributes—versus 64 KB for a comparable low-resolution graphics framebuffer such as VGA mode 13h (320×200 pixels with 256 colors).[32][33] This compact representation stems from storing symbolic character data rather than pixel bitmaps, allowing the hardware to generate the visual output on demand.[3] In remote access scenarios, text mode provides substantial bandwidth savings by transmitting compact character codes (typically 1 byte per character) along with attribute bytes, in contrast to graphical protocols that send full bitmap data for screen updates.[34] For instance, in Telnet sessions, only textual content and control sequences are exchanged, minimizing data volume and enabling reliable operation over low-bandwidth connections like early dial-up networks.[35] This efficiency is particularly evident when compared to remote desktop protocols such as RDP, where even optimized graphical transmission consumes far more bandwidth for equivalent information display.[34] Processing speed in text mode benefits from dedicated hardware acceleration through components like the Cathode Ray Tube Controller (CRTC), which handles timing, scanning, and synchronization independently of the CPU, thereby reducing the processor's involvement to simple memory writes for character placement.[36] The integrated character generator ROM further offloads pixel pattern creation from software, avoiding the CPU-intensive bitmap rendering required in graphics modes without equivalent hardware support.[3] As a result, text mode operations, such as screen updates or scrolling, impose minimal CPU load, making it suitable for resource-constrained systems where graphics rendering would otherwise bottleneck performance.[36] Text mode's simplicity enhances accessibility in low-resource environments, such as embedded systems or bootloaders, by relying on straightforward memory-mapped I/O without the overhead of graphical APIs or drivers.[37] This design facilitates rapid text processing and output, proving invaluable for debugging, logging, and system monitoring where graphical interfaces would demand excessive resources.[37] Its hardware-direct approach also supports consistent operation across diverse hardware, aiding developers in early-stage software verification without specialized rendering tools.[3]

User-Defined Characters and Customization

In VGA text modes, the character set can be redefined by loading custom glyphs into the video RAM, enabling up to 256 user-defined 8x16 pixel characters stored in display memory plane 2.[14] This process overrides the default fonts typically sourced from the VGA ROM, allowing flexible modification without altering hardware firmware.[14] The VGA supports eight 8KB font banks, with each glyph defined by a 32-byte bitmap—eight bits per scan line across 16 lines—aligned on 32-byte boundaries and accessed via standard video memory addressing in read/write mode 0.[14] Redefinition is commonly performed using BIOS interrupt INT 10h (AH=11h, AL=00h), which copies a block of user-supplied font data directly to the character generator tables in video RAM.[38] Key parameters include BH for character height in scan lines (e.g., 16 for standard 8x16 glyphs), BL for the target font block (0-7 on VGA), CX for the number of characters to redefine, DX for the starting ASCII code (0-255), and ES:BP pointing to the font data array (height × CX bytes total).[38] For direct low-level access, programmers can write to the font memory at segment A000h, segment offset calculated as (character code × 32) + (bank × 8192), though this requires precise control of VGA registers like the sequencer for plane selection.[14] In programming environments like BASIC, custom fonts can be loaded via BIOS calls using statements such as CALL INTERRUPT in QBASIC or GW-BASIC to invoke INT 10h, or by POKE commands to directly manipulate video memory addresses for simpler glyph overrides.[39] Dedicated utilities facilitate this process; for instance, TSR programs can upload fonts into RAM at boot, while tools like romfontr allow extraction and replacement of ROM-based fonts by modifying BIOS images and recalculating checksums before reflashing.[40] These features enable practical applications such as semi-graphics in games, where custom block characters simulate borders, tiles, or simple shapes without switching to full graphics modes—for example, redefining codes 176-223 for filled and outlined blocks akin to extended ASCII line drawing.[14] They also support international symbols by remapping unused codes to glyphs for non-Latin scripts, enhancing text display in DOS applications.[38] However, customization is hardware-dependent, requiring EGA or VGA-compatible adapters, and demands adjustments to CRTC registers (e.g., maximum scan lines) for proper rendering—failure to do so may cause truncated or corrupted displays.[38] Direct memory writes risk instability if not aligned correctly, potentially leading to garbled text or mode incompatibilities with software expecting standard ROM fonts.[41]

Specific Implementations

Common PC Text Modes

Common text modes on IBM PC-compatible systems were standardized through BIOS interrupts and hardware adapters like the Monochrome Display Adapter (MDA), Color Graphics Adapter (CGA), Enhanced Graphics Adapter (EGA), and Video Graphics Array (VGA), enabling consistent display capabilities across compatible hardware. These modes primarily supported character-based rendering in the video memory segments B000:0000 for monochrome or B800:0000 for color, with each character occupying two bytes: one for the ASCII code and one for attributes such as foreground/background color or intensity.[42][43] Mode 03h, the standard color text mode introduced with the CGA and fully supported by EGA and VGA adapters, operates at 80 columns by 25 rows, rendering a 640x200 pixel display using 8x8 pixel fonts and a palette of 16 colors defined by attribute bytes. This mode allows for programmable character attributes including foreground and background colors from the 16-color set, blinking text, and up to eight display pages for rapid switching in applications. On VGA hardware, it can utilize taller 9x16 fonts for a 720x400 pixel resolution while maintaining the 80x25 character grid, providing sharper text at the cost of vertical spacing.[44][42][43] Mode 07h, the monochrome text mode from the MDA standard and emulated on later adapters like EGA and VGA, also provides 80x25 characters but at a higher 720x350 pixel resolution using 9x14 pixel fonts, with no color support and limited attributes to intensity (normal or highlighted) and underline, excluding text blinking capabilities. This mode prioritizes clarity for text-heavy tasks like word processing, displaying on green- or amber-phosphor monitors without cursor blinking, though a visible cursor is supported via attribute bit manipulation. It uses a fixed 256-character ROM set, non-redefinable on original MDA hardware.[44][42][43] Higher-resolution text modes extended these standards on EGA and VGA. The EGA-supported 80x43 mode achieves denser text display at 640x350 pixels using 8x8 fonts in an interlaced scan, compatible with color monitors and supporting the full 16-color attribute set, though requiring specific adapter configuration for non-standard line counts. Similarly, VGA's 80x50 mode renders 80 columns by 50 rows at 640x400 pixels with 8x8 fonts, enabling more content per screen while retaining 16 colors and attribute features, often set alongside mode 03h for enhanced productivity in text interfaces.[42][43][44] These modes are switched via BIOS interrupt 10h (INT 10h) with function 00h: load AH=00h and AL with the mode number (e.g., 03h or 07h), then execute the interrupt to initialize the video controller and clear the screen. For higher-resolution variants like 80x43 or 80x50, additional calls to INT 10h function 11h load the appropriate 8x8 font set (e.g., AL=12h for EGA 80x43 or AL=14h for VGA 80x50, with BL=00h), followed by setting mode 03h to apply the changes. VGA adapters support the full range of legacy modes from 00h to 13h, including text and mixed text-graphics operations, ensuring backward compatibility.[42][43][44]
ModeAdapter SupportCharacter ResolutionPixel ResolutionColors/AttributesFont Size
03hCGA, EGA, VGA80x25640x200 (CGA); 720x400 (VGA)16 colors, blink8x8 (default); 9x16 (VGA)
07hMDA, EGA, VGA80x25720x350Monochrome, underline/intensity (no blink)9x14
80x43EGA80x43640x350 (interlaced)16 colors, blink8x8
80x50VGA80x50640x40016 colors, blink8x8

Text Modes in Other Systems

Text modes in non-PC systems often adapted hardware constraints and design philosophies to support character-based displays, emphasizing platform-specific character sets and resolutions tailored to their ecosystems. The Apple II series implemented text modes through soft switches that allowed switching between 40-column by 24-row and 80-column by 24-row displays, utilizing 7x8 pixel fonts stored in character ROM for efficient rendering on its 1 MHz 6502 processor. These modes supported inverse video and flashing text via hardware attributes, enabling applications like word processors to operate without graphics overhead.[45] In the Commodore 64, text mode operated at a fixed 40-column by 25-row resolution, employing the PETSCII character set derived from earlier Commodore systems, which included 128 printable characters with support for colored attributes using a 16-color palette. In standard mode, each character has a programmable foreground color, with a global background; extended modes allowed per-character background colors. This allowed for visually distinctive output, such as border graphics and reversed characters, enhancing user interfaces in games and productivity software while interfacing directly with the VIC-II video chip.[46] The Amiga platform rendered text in its bitmapped graphics modes using the Intuition library, which provided API calls for customizable fonts and smooth scrolling, leveraging the Agnus and Denise chips for blitter-accelerated rendering. Console windows typically displayed 80 columns of text, with around 25 rows depending on the font size (e.g., 8x8 pixels) and screen resolution (e.g., 640x200 or 640x400), allowing developers to load variable-width fonts and adjust character spacing programmatically for professional applications like document editing from the Amiga 1000 onward.[47][48] Mainframe terminals, such as those using the IBM 5250 protocol, featured text modes with extended widths like 132 columns by 27 rows to accommodate business data displays, relying on twinax cabling and EBCDIC encoding for high-reliability character transmission. These configurations prioritized tabular data presentation in environments like AS/400 systems, with attributes for field protection and highlighting to support legacy enterprise applications.[49][50]

Modern and Contemporary Usage

In Operating Systems and Virtual Terminals

In modern operating systems, text mode persists primarily through software emulation and virtual terminal support, adapting legacy hardware concepts to contemporary graphical environments. Linux maintains robust native support for text consoles via the framebuffer console (fbcon), which renders text directly on the framebuffer device, providing standard console functionality with enhancements like variable font sizes and screen rotation. Fbcon supports UTF-8 encoding as the default for character display, enabling multilingual text rendering in grids typically starting at 80x24 characters or larger, configurable through kernel parameters.[51][52] Linux further implements virtual terminals (VTs) at the kernel level, offering up to 63 independent text-based sessions multiplexed on a single physical display, with the first six (VT1 through VT6) commonly used for console logins accessible via keyboard shortcuts like Ctrl+Alt+F1 to F6. These VTs integrate with fbcon for rendering, allowing seamless switching between text sessions without graphical overhead, and support essential input/output operations defined in the kernel's VT subsystem.[53] In Windows, legacy text mode support is limited to emulation layers for compatibility. The NT Virtual DOS Machine (NTVDM) subsystem enables running 16-bit DOS applications, including those relying on text modes, within a virtualized DOS environment in 32-bit x86 versions of Windows up to and including Windows 10. It has always been unavailable on 64-bit or ARM versions, and Windows 11, which is 64-bit only, does not support it.[54] Following the introduction of the Windows Display Driver Model (WDDM) in Windows Vista, the console host (conhost.exe) shifted to fully emulated text rendering using software APIs rather than direct hardware text modes, ensuring compatibility with modern GPUs while forgoing native VGA-style operations. For text user interfaces (TUIs), tools like PowerShell ISE provide a graphical scripting environment that can incorporate TUI elements through console output emulation, though primary TUI development occurs in the standard terminal.[55] macOS relies entirely on emulated text modes in user space, with no direct hardware text mode support since the transition from PowerPC processors in the mid-2000s. The built-in Terminal.app application emulates VT100 and ANSI escape sequences for cursor control, color, and formatting, while providing full Unicode support for international characters via the underlying Core Text framework. This emulation allows developers to build TUIs using standard terminal protocols, integrated with macOS's graphical compositor for seamless operation in a windowed environment.[56] During system initialization, the Unified Extensible Firmware Interface (UEFI) utilizes the Simple Text Output Protocol to deliver boot-time text output in a basic 80x25 character grid, facilitating power-on self-test (POST) messages and early bootloader interactions before handing off to the operating system. This protocol defines a minimal text console interface, including string output, attribute setting for foreground/background colors, and mode queries, ensuring compatibility across diverse hardware without requiring graphical capabilities.[57]

In Embedded Systems and Specialized Environments

In embedded systems, text mode remains essential for resource-constrained environments where graphical interfaces are impractical due to limited processing power or display capabilities. For instance, Embedded Linux distributions on devices like the Raspberry Pi utilize minimal text consoles during boot processes and for debugging tasks. These consoles output kernel messages and shell prompts via serial UART interfaces, allowing developers to monitor system initialization without a full graphical stack. The Raspberry Pi's configuration options enable serial port access for shell and kernel messages, facilitating headless operation in industrial or IoT applications.[58] In Internet of Things (IoT) devices, microcontrollers such as the ESP32 employ text mode over serial connections for configuration and monitoring. The ESP32's UART interfaces connect to host computers via USB-to-UART bridges, where terminal emulators implementing VT100 escape sequences render interactive text-based interfaces for firmware flashing, parameter adjustment, and runtime debugging. This approach leverages the microcontroller's built-in serial capabilities without requiring additional hardware, making it suitable for low-power, battery-operated sensors and actuators. Espressif's development framework recommends terminal programs supporting standard serial protocols to interact with the ESP32, ensuring compatibility with text-mode tools for embedded programming.[59] Cloud computing environments extend text mode's utility through remote access protocols like SSH, where terminals render server-side text consoles on client devices. Tools such as tmux, a terminal multiplexer, enable session persistence and window splitting within these SSH connections, allowing administrators to manage multiple command-line tasks on virtual machines or containers without disrupting workflows during network interruptions. Tmux operates by creating pseudo-terminals that emulate standard text interfaces, supporting features like pane division and session detachment, which are critical for long-running processes in cloud infrastructures. The tmux utility's design facilitates control of multiple terminals from a single screen, enhancing productivity in remote server administration.[60] Specialized applications further demonstrate text mode's adaptability in constrained settings. The ASCII Art library (AAlib) converts graphical content into ASCII representations for output on text-only displays, enabling legacy or low-bandwidth systems to visualize images and animations through character-based rendering. AAlib's renderer processes input formats like PNG or video streams into dense ASCII patterns, supporting dithering and brightness mapping to approximate visuals on terminals or printers. In firmware contexts, UEFI implementations for servers provide text-mode consoles via the Simple Text Output protocol, which handles character-based I/O during pre-boot environments. This protocol ensures 80-column text support on console devices, aiding setup, diagnostics, and boot menu navigation in headless server deployments.[61][57]

References

User Avatar
No comments yet.