Questions About ASCII

Every modern system uses ASCII indirectly because UTF-8 is a superset of it - the first 128 code points are identical. Network protocols like HTTP, SMTP, and DNS still require ASCII headers. Programming languages use ASCII for keywords and identifiers. You can explore the full ASCII table to see how the original 128 characters map to values 0-127.

Check whether every byte in the file falls within 0x00-0x7F. If any byte exceeds 127, the file uses a different encoding. The Unix file command detects this automatically. A quick way to verify: run xxd filename | grep -v ' ' in a terminal. You can also use our Text to ASCII converter to inspect individual characters, or check the character sets reference to compare encoding ranges.

Each character maps to a 7-bit number between 0 and 127. For example, the letter A is 65 (binary 01000001) and lowercase a is 97 (01100001) - the difference is exactly one bit (bit 5), which makes case conversion trivial with a bitwise OR or AND. The first 32 codes (0-31) plus code 127 are control characters like carriage return and line feed that manage data flow rather than represent visible symbols. Use the base converter to see any character's decimal, hex, octal, and binary representation.

HTTP headers, email envelope data (SMTP), and DNS labels are all restricted to ASCII. Source code in nearly every programming language uses ASCII for syntax - keywords, operators, and variable names. Terminal emulators and command-line shells still process text as streams of ASCII bytes. ASCII art remains popular in code comments and README files. When you see non-ASCII characters on the web, they are typically encoded in UTF-8, which wraps ASCII's 128 characters unchanged and extends from there. Check the HTML symbol entities reference for how special characters get encoded in web pages.

Exactly 95. They span codes 32 through 126 and include uppercase A-Z (26), lowercase a-z (26), digits 0-9 (10), 32 punctuation and symbol characters, and the space character (code 32). The remaining 33 codes (0-31 and 127) are non-printable control characters.

One byte. The original spec uses only 7 bits (values 0-127), but in practice the 8th bit is set to zero, so every ASCII character occupies exactly 1 byte of storage. This is not true for UTF-8 encoded text, where characters outside the ASCII range use 2-4 bytes. You can verify byte sizes with our hex to ASCII tool or look at the binary representations.

128 codes total (2^7), numbered 0 through 127. Of these, 33 are control characters (codes 0-31 and 127), and 95 are printable characters (codes 32-126). The 7-bit constraint was deliberate - it left the 8th bit free for parity checking on noisy teletype lines in the 1960s. See the full ASCII encoding table for all 128 codes with their hex and binary values.

No. "ANSI" in Windows is a misnomer that Microsoft adopted in the 1980s. What Windows calls "ANSI" on a Western European system is actually Windows-1252, but on a Greek system it is Windows-1253, and on a Central European system it is Windows-1250. The ANSI label changes depending on the system locale, which causes silent data corruption when files move between machines. You can compare encodings to see exactly which characters differ between code pages.

Standard ASCII is 7-bit, covering codes 0-127. The term "8-bit ASCII" or "extended ASCII" refers to various incompatible encoding schemes that use codes 128-255 for additional characters. There is no single "8-bit ASCII" standard - CP437 (IBM PC), Windows-1252, and ISO-8859-1 all define different characters in the 128-255 range. This fragmentation is why Unicode was created.

No. ASCII is a character encoding - a lookup table that maps numbers to characters. When you write char c = 'A'; in C, the compiler stores the number 65 because that is A's ASCII value. Programming languages are written using ASCII characters but are entirely separate concepts. You can explore how characters map to numbers in the ASCII table.

Fixed-length. Every character uses exactly 7 bits (one byte in practice). This differs from UTF-8, which is variable-length: ASCII characters (0-127) use 1 byte, but characters beyond that range use 2 to 4 bytes. The fixed-length property makes ASCII fast to index - the Nth character is always at byte offset N, with no need to scan from the beginning. Compare this with the other encoding standards that trade simplicity for broader character coverage.

No. ASCII only covers English letters, Arabic numerals, and basic punctuation. It has no accented characters (like e or n), no CJK ideographs, no Arabic or Cyrillic scripts. The ISO-8859 family added regional coverage - ISO-8859-1 for Western European, ISO-8859-5 for Cyrillic - but each only covers one region. Unicode solved this by assigning a unique code point to every character in every writing system.

The American Standards Association (ASA) published the first ASCII standard in 1963, building on telegraph codes like Baudot and earlier ITA2. Bob Bemer of IBM drove the standardization effort after submitting his initial proposal in 1961. The 1963 version lacked lowercase letters - those were added in the 1967 revision (USAS X3.4-1967). The version most systems use today is ANSI X3.4-1968. Check the full ASCII timeline for the complete history from Morse code through Unicode.

Monospaced fonts work best because every character occupies the same width, which keeps tables and ASCII art aligned correctly. JetBrains Mono, Fira Code, and Cascadia Code are solid modern choices with clear glyph differentiation between similar characters (0/O, 1/l/I). For ASCII art generators, Courier New is the safest choice because it is installed on virtually every system and renders consistently across platforms.

There is no official "256-character ASCII" - the real ASCII standard has exactly 128 characters (0-127). The 256-character sets people call "extended ASCII" are actually separate encodings like CP437, Windows-1252, or ISO-8859-1 that reuse ASCII for codes 0-127 and define their own characters for 128-255. This distinction matters because the same byte value (say, 0x80) displays as C in Windows-1252 but as a box-drawing character in CP437. Use the encoding comparison tool to see exactly where they diverge.

Codes 128-255 are not part of ASCII at all - they belong to various 8-bit encodings that extend ASCII. Which character you get depends entirely on the encoding. Code 128 is C in Windows-1252, but a box-drawing corner in CP437, and undefined in ISO-8859-1. This inconsistency between character sets is the root cause of mojibake - garbled text that appears when a file is read with the wrong encoding. Compare encodings side by side to see all the differences.

ASCII (American Standard Code for Information Interchange) maps 128 characters to the numbers 0-127. Uppercase A is 65, lowercase a is 97, the digit 0 is 48, and space is 32. The encoding was designed so that alphabetical sorting matches numeric sorting - letters appear in order, and uppercase comes before lowercase. The full mapping is in the ASCII table. Convert any text to its ASCII codes with the text to ASCII converter.

A reference chart showing all 128 ASCII characters alongside their decimal, hexadecimal, and binary code values. The standard ASCII table is organized into three sections: control characters (0-31 and 127), printable characters (32-126), and sometimes extended characters (128-255) from encodings like Windows-1252. You can also view the table in different formats: 16x16 chart, compact view, or periodic-table grid.

A character encoding published in 1963 that maps 128 characters - 26 uppercase letters, 26 lowercase, 10 digits, 33 control codes, and 33 punctuation/symbol characters - to the numbers 0 through 127. It became the foundation of all modern text encoding: UTF-8, the dominant encoding on the web, is fully backward-compatible with ASCII for its first 128 code points. Browse the complete ASCII table or read the beginner's guide for more depth.

A defined mapping between numbers and characters that a computer uses to store and display text. ASCII maps 128 characters; ISO-8859-1 maps 256 for Western European languages; Unicode maps over 154,000 characters covering every modern script. The term "code page" usually refers to the vendor-specific 8-bit extensions like Microsoft's Windows code pages (CP1250-CP1258). See the full character sets reference for a comparison of all major encodings.

7 bits per character in the original spec, stored as 1 byte in practice (the 8th bit is zero). This makes ASCII the most compact text encoding possible for English - every character is exactly 1 byte. Compare that to UTF-8, where a Chinese character takes 3 bytes, or UTF-16, where even an ASCII 'A' costs 2 bytes. You can inspect exact byte values using the hex converter or binary converter.

The 33 non-printable codes at positions 0-31 and 127 that control data transmission and device behavior rather than display text. LF (10) creates a new line, CR (13) returns the cursor to column zero, TAB (9) advances to the next tab stop, and NULL (0) terminates strings in C. Many were designed for physical teletypes - BEL (7) literally rang a bell. See the full list at the control characters reference.

An informal term for any 8-bit encoding that uses codes 0-127 for standard ASCII and codes 128-255 for additional characters. There is no single "extended ASCII" standard - CP437 added box-drawing characters for DOS, Windows-1252 added Western European letters, and ISO-8859-1 followed the ISO standard. The same byte value produces different characters depending on which encoding is in use. This incompatibility is exactly why the Unicode consortium created a unified standard. Compare encodings to see the differences.

Characters that do not produce visible output when rendered. In ASCII, these are the 33 control characters (codes 0-31 and 127) plus whitespace characters like tab and space that affect layout without drawing glyphs. Common examples: NULL (0) terminates C strings, LF (10) ends lines on Unix, and ESC (27) starts terminal escape sequences for colors and cursor movement. You can see their Unicode control pictures on each character's detail page.

The 128-character encoding defined by ANSI X3.4-1968, covering uppercase and lowercase English letters, digits 0-9, punctuation and symbols, and 33 control characters. The character ordering was carefully designed: digits (48-57) sort before uppercase (65-90), which sorts before lowercase (97-122). This lets simple byte comparison produce correct alphabetical order for English text. View it in the full table or the 16x16 chart format.

Digits 1 through 9 have ASCII values 49 through 57. Digit 0 is at position 48. A useful trick: subtract 48 (0x30) from any digit's ASCII value to get its numeric value, since the digits are laid out consecutively. In code: int n = ascii_value - '0';. Use the text to ASCII converter to verify any character's code.

Uppercase A-Z runs from 65 to 90. Lowercase a-z runs from 97 to 122. The offset between upper and lower is exactly 32 (0x20), which corresponds to a single bit flip (bit 5). To convert uppercase to lowercase in code, OR with 0x20; to go the other way, AND with 0xDF. Check individual letters with the text to ASCII converter.

ASCII does not represent negative numbers - its code points range from 0 to 127 only. When programmers store negative values as text, each character (the minus sign, each digit) has its own ASCII code. The minus sign is code 45, so the string "-42" is stored as three bytes: 45, 52, 50. Converting between text representations and actual numeric values requires parsing. Try it with the text to ASCII converter.

Scale and design. ASCII defines 128 characters using 7 bits - enough for English only. Unicode defines over 154,000 characters across 168 scripts using up to 21 bits per code point. ASCII is a single fixed encoding; Unicode has multiple encoding forms (UTF-8, UTF-16, UTF-32) with different space-time tradeoffs. The first 128 Unicode code points match ASCII exactly, so valid ASCII text is automatically valid UTF-8. Compare encoding tables to see how they map differently in the 128-255 range.

127, which is the DEL (Delete) character - a control character, not a printable one. The largest printable ASCII value is 126, the tilde (~). In 7-bit binary, 127 is 1111111 - all bits set. On paper tape systems, punching all holes in a row marked that position as deleted, which is why DEL sits at 127 rather than with the other control characters at 0-31.

255 for standard 8-bit extended ASCII encodings like Windows-1252, CP437, and ISO-8859-1 (since 2^8 = 256 values, numbered 0-255). The specific character at position 255 varies by encoding: it is a non-breaking space (NBSP) in ISO-8859-1, y with diaeresis (y) in Windows-1252, and the same NBSP in CP437. Check the character sets reference for details on each encoding's range.

Only 128 characters - nowhere near enough for the world's writing systems. ASCII has no accented letters (French, German, Spanish), no CJK characters (Chinese, Japanese, Korean), no Arabic, Hebrew, Cyrillic, or Devanagari. The 8-bit extensions (ISO-8859-1, Windows-1252) each added 128 more characters, but they are mutually incompatible - the same byte produces different characters in different encodings. This fragmentation causes mojibake (garbled text) and is the main reason Unicode replaced them. See the character sets reference for the full landscape.

Windows-1252 is Microsoft's 8-bit encoding for Western European languages. It covers ASCII (0-127) identically, then adds accented letters, typographic quotes, the euro sign, and other Western European characters in the 128-255 range. It is the most widely used Windows code page. A common bug: HTML pages declared as ISO-8859-1 often contain Windows-1252 characters (like smart quotes at 0x93-0x94), which technically violates the spec but browsers handle it silently. View the full Windows-1252 table.

The Baudot code, invented in 1874 by Emile Baudot. It used only 5 bits (32 values), so it employed a SHIFT mechanism to switch between letter and figure modes - similar to how Caps Lock works today. IBM's EBCDIC (1964) was a competing 8-bit encoding used on mainframes. ASCII won on smaller systems because its 7-bit design was more efficient for the teletype hardware of the 1960s. Read the full encoding timeline for the progression from telegraph codes to Unicode.

ASCII values are stored as bytes in RAM, disk files, network packets - anywhere digital data exists. When you save a text file as ASCII, each character becomes one byte on disk. In memory, a C string like "Hi" occupies 3 bytes: 72 (H), 105 (i), and 0 (NULL terminator). You can inspect the raw bytes in any file with a hex editor or our hex to ASCII tool.

Bob Bemer of IBM is credited as the "father of ASCII" for driving the standardization effort. He submitted the initial proposal to the ASA (American Standards Association) in 1961. The standard was a committee effort involving representatives from telecom companies, computer manufacturers, and the US government. The first version was published in 1963 as ASA X3.4-1963, revised significantly in 1967, and finalized as ANSI X3.4-1968. See the ASCII timeline for the full history and the facts page for more details.

It does not - standard ASCII uses 7 bits. The confusion arises because modern computers address memory in 8-bit bytes. When storing ASCII, the 8th bit was originally used for parity checking on noisy communication lines, or simply set to zero. IBM's PC (1981) repurposed that 8th bit for CP437, doubling the character set to 256 with box-drawing symbols and accented letters. Other vendors created their own 8-bit extensions (Windows-1252, ISO-8859-1), all incompatible with each other. Check the character sets reference for all variants.

Standard ASCII is limited to 128 characters (7 bits), not 256. The 256-character limit applies to 8-bit encodings like CP437 and Windows-1252 that extend ASCII. With 8 bits, you get 2^8 = 256 possible values, and that is a hard physical limit of one byte. Even 256 characters fell far short of global needs - Chinese alone has over 50,000 commonly used characters. That constraint drove the creation of Unicode, which uses up to 21 bits and supports over 154,000 characters.

ASCII solved a real interoperability problem - before 1963, every computer manufacturer used a different encoding, making data exchange between systems nearly impossible. President Johnson mandated its use across all federal systems in 1968. Its design choices persist everywhere: UTF-8 keeps ASCII's first 128 values unchanged, HTTP and SMTP headers are ASCII-only, and every programming language uses ASCII for its syntax. The ASCII table remains the single most referenced encoding chart in computing. Read more in the beginner's guide to ASCII.

Unicode covers 154,000+ characters across 168 scripts versus ASCII's 128 English-only characters. ASCII cannot represent a single accented character, emoji, or non-Latin letter. Unicode's UTF-8 encoding stays efficient for English text (1 byte per ASCII character) while scaling to 4 bytes for rare characters. The tradeoff: UTF-8 strings cannot be indexed by position in O(1) like ASCII can, because characters have variable width. For most applications, this tradeoff is worth it. Compare the ASCII table with the broader character encoding landscape.