ASCII Table Query

ASCII (American Standard Code for Information Interchange) is a character encoding standard based on the Latin alphabet. Originally developed for telegraph communication in the 1960s, it became the foundation of character encoding in computing. Standard ASCII contains 128 characters (0-127), including 33 control characters and 95 printable characters. Extended ASCII (128-255) adds another 128 characters for symbols and international characters, though encoding varies by region. An ASCII table earns its place during encoding debugging, control-character checks, protocol work, escape-sequence lookup, terminal behavior analysis, and older file-format inspection. Decimal, hexadecimal, and binary values show how a character is actually stored or transmitted. Modern text usually uses Unicode, so ASCII represents only the historical 7-bit core. For international characters, emoji, typography marks, and mixed-language text, Unicode code points and encoding rules still need to be checked separately.

ASCII (American Standard Code for Information Interchange, ANSI X3.4-1968, ISO/IEC 646:1991 IRV) is a 7-bit character encoding that assigns numeric codes 0-127 to 128 characters. The lower 32 codes (0x00-0x1F) plus 0x7F are control characters inherited from teletypes: NUL (0x00), BEL (0x07, the alert beep), LF (0x0A, line feed), CR (0x0D, carriage return), ESC (0x1B), DEL (0x7F), and so on. Codes 0x20-0x7E are printable: space, the digits 0-9 at 0x30-0x39, the uppercase letters A-Z at 0x41-0x5A, the lowercase letters a-z at 0x61-0x7A, and punctuation between them. The encoding has a deliberately regular structure. The digits are clustered: '0' = 0x30, '1' = 0x31, ..., '9' = 0x39. Converting a digit character to its numeric value is `code - 0x30`. The letters are also clustered: 'A' = 0x41, 'B' = 0x42, ..., 'Z' = 0x5A, and 'a' = 0x61, ..., 'z' = 0x7A. The difference between uppercase and lowercase for the same letter is 0x20 (32), which is exactly one bit set in position 5 (1 << 5 = 32). That makes case conversion a single XOR or OR/AND with 0x20: `code ^ 0x20` flips case, `code | 0x20` lowercases, `code & 0x5F` (= `code & ~0x20`) uppercases. This bit-trick is the fastest possible case conversion and shows up in strlen/strcmp implementations for ASCII-only strings. ASCII was designed for 7-bit teletypes and the 5-level Baudot code that preceded it, so it predates 8-bit bytes. The 8-bit 'extended ASCII' range (0x80-0xFF) was never standardised, which is why so many code pages (ISO 8859-1 Latin-1, Windows-1252, MacRoman, KOI8-R, IBM437) competed for the high half. ISO 8859-1 (Latin-1) was the closest thing to a standard, but even it lacked the Euro sign until ISO 8859-15. The C1 control range (0x80-0x9F) was supposed to be reserved (ISO 6429), but Windows-1252 reused some of it for printable characters — a long-running interoperability pain point that UTF-8 finally resolved. UTF-8 (RFC 3629, 2003) was designed by Rob Pike and Ken Thompson in 1992 as a backward-compatible superset: the 128 ASCII codes encode to themselves as single bytes (0x00-0x7F), so any ASCII text is also a valid UTF-8 text. Codes above 0x7F use 2-, 3-, or 4-byte sequences with specific bit patterns (110xxxxx 10xxxxxx, 1110xxxx 10xxxxxx 10xxxxxx, 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx) so a decoder can resync byte-by-byte after an error. EBCDIC, by contrast, was IBM's 8-bit mainframe encoding (8-bit EBCDIC was 8-bit, not 7-bit like ASCII) and assigns letters to non-contiguous code points ('A' = 0xC1, 'I' = 0xC9, 'J' = 0xD1, ..., with gaps that hurt bit-tricks and string algorithms). National variants of ISO 646 replaced a small set of ASCII characters with country-specific letters. For example, the UK variant replaced 0x23 (the American '#') with the pound sign '£', and the German variant replaced some punctuation with umlauts. This is why C's locale settings and POSIX charmap files were historically important — they mapped between the IRV (International Reference Version) and national variants. The escape from this mess is Unicode / UTF-8, which makes the entire 7-bit and 8-bit debate obsolete for any new project.

• ASCII (ANSI X3.4-1968, ISO/IEC 646 IRV) uses 7 bits per character with 128 code points: 33 control characters (0x00-0x1F, 0x7F) and 95 printable characters (0x20-0x7E).
• Control characters (0x00-0x1F, 0x7F) were inherited from teletypes: NUL, BEL (0x07, alert beep), LF (0x0A), CR (0x0D), ESC (0x1B), DEL (0x7F). Modern text still uses LF and CR; the rest are mostly history.
• Printable layout: space (0x20), digits '0'-'9' (0x30-0x39), uppercase 'A'-'Z' (0x41-0x5A), lowercase 'a'-'z' (0x61-0x7A), punctuation in between. Converting '5' to 5 is `code - 0x30`; upper-to-lower is `code | 0x20`.
• Case conversion is a single bit op: XOR 0x20 flips case; OR 0x20 lowercases; AND 0x5F (= `code & ~0x20`) uppercases. This is the fastest case conversion in any language and is how strlen/strcmp work on ASCII-only buffers.
• 8-bit extensions (0x80-0xFF) were never standardised, so Windows-1252, ISO-8859-1, MacRoman, KOI8-R, IBM437 all defined the high half differently. Windows-1252 won on the web and is the de-facto 'extended ASCII' most legacy code uses.
• UTF-8 (RFC 3629, Pike & Thompson 1992) is a strict superset of ASCII: the 128 ASCII code points encode as themselves in 1 byte; code points above U+007F use 2-4 bytes with 110xxxxx 10xxxxxx continuation bytes, so decoders can resync byte-by-byte after errors.
• EBCDIC (IBM, 1960s mainframes) is the 8-bit alternative to ASCII used on IBM z/OS. Letter positions are not contiguous ('A'=0xC1, 'I'=0xC9, 'J'=0xD1), so the ASCII case-conversion trick does not work and bit-shift algorithms like tolower() need table lookups.
• ISO 646 national variants (UK, German, Swedish, etc.) replaced a small set of ASCII characters with country-specific letters: the UK variant swapped '#' for '£' at 0x23, the German variant swapped punctuation for umlauts. Pre-Unicode localisation in a nutshell.