ASCII tabula

What is an ASCII table?

An ASCII table is a complete chart of character codes that maps every letter, digit, punctuation mark, space and control signal to a unique number. ASCII — the American Standard Code for Information Interchange — was published in 1963 and remains the foundation that almost every modern text encoding, including UTF-8, is built on. This ASCII code table lists each character alongside its decimal, hexadecimal, octal and binary values, plus its HTML entity and Unicode code point, so you can look up exactly how any character is represented at the byte level.

Because the whole table is built into the page and runs entirely in your browser, it loads instantly, works offline and never uploads anything you type. It's a fast, private, interactive reference for developers, students, embedded engineers and anyone learning how computers store and transmit text — and it beats the static PDFs and non-interactive pages on sites like asciitable.com or w3schools because you can click to copy any value and search by name, decimal, hex or binary simultaneously.

How to read an ASCII table

Each row represents one character. To read the ASCII table, find the symbol you want in the Char column and scan across to see its number in four different bases: decimal (the everyday value, e.g. 65), hexadecimal (0x41), octal (101) and binary (01000001). The Name column explains non-printing entries — for example code 9 is TAB, code 10 is LF (line feed) and code 13 is CR (carriage return). Knowing these control character codes is essential for parsing files, writing escape sequences and debugging terminal output.

The first 32 codes (0–31) plus 127 are control characters: invisible signals that format text or control devices rather than printing a visible glyph. Codes 32–126 are the printable characters — space, the digits 0–9, uppercase A–Z (65–90), lowercase a–z (97–122) and common punctuation. Memorising a handful of anchor points (A=65, a=97, 0=48, space=32) is enough to navigate the rest of the chart mentally. In Python, ord('A') returns 65 and chr(65) returns 'A'; in C, casting a char to int gives you the code directly.

How many characters are in the ASCII table?

Standard ASCII defines exactly 128 characters, numbered 0 to 127, because it is a 7-bit code (2⁷ = 128). The often-quoted figure of 256 characters refers to extended ASCII, which uses the full 8th bit of a byte to add codes 128–255. Those extra slots aren't part of the original ASCII standard and their meaning depends on the code page; the most common mapping is Latin-1 (ISO-8859-1), which provides accented letters and Western-European symbols. Toggle Show extended to switch between the standard 128-character set and the full 256-character extended view with Latin-1 mappings — a feature not available on static charts.

How does the ASCII table work?

Computers only store numbers, so ASCII gives text a number. The ASCII table works by assigning each character a fixed code that fits in a single byte. The word 'Hi' is stored as the two bytes 72 and 105. When you press a key, your keyboard sends that code to the operating system; when software draws text on screen, it reads the code and renders the matching glyph. Knowing the codes is essential when you're parsing data files, writing escape sequences for terminals, debugging character encoding problems, or converting between number bases in coursework.

ASCII was designed so that letters can be manipulated arithmetically. Uppercase A–Z begin at 65 and lowercase a–z begin at 97, so you can convert any letter between cases by adding or subtracting 32 — a common bit-manipulation trick in C and assembly. Similarly, digit characters '0'–'9' start at 48, so subtracting 48 converts the ASCII character code to the integer value it represents. This arithmetic elegance is a deliberate design choice that made ASCII-based programming efficient even on early 8-bit hardware.

Why this ASCII table beats asciitable.com and w3schools

Most ASCII reference charts online are static images or PDFs from sites like asciitable.com or w3schools.com — you can't search them, can't click to copy a value, and they don't include a text-to-ASCII converter. Asciitable.com serves a fixed table in a small font with no interactivity. W3schools offers a basic HTML table but also lacks click-to-copy, a live search or a built-in text converter. Both require you to visually scan rows of numbers to find what you need.

This interactive tool lets you search by character name, decimal value, hex code or binary pattern — type 'space', '32', '0x20', or '00100000' and it jumps straight to the right row. Click any value to copy it to your clipboard immediately. The built-in two-way converter is the feature no static chart can match: paste any text to get its ASCII codes in decimal, hex or binary, or paste a list of codes to turn them back into text. Developers debugging encoding issues, students completing computer science assignments, and engineers working with serial protocols all get the same instant, private, ad-free experience — with no sign-up and nothing leaving their device.

The ASCII standard and its history

ASCII was formally published in 1963 by the American Standards Association (ASA, later renamed ANSI), the result of a committee effort to unify the incompatible character sets that different computer and teletype manufacturers had each invented independently. Before ASCII, IBM mainframes, Burroughs machines and Teletype terminals all spoke different character codes, making data interchange between systems unreliable and costly. The 1963 version lacked lowercase letters; a significant revision in 1967 added the full lowercase alphabet, producing the 128-character set that every programmer still encounters today. Bell Labs and AT&T were deeply influential in the standardisation process — AT&T's nationwide telephone network was the backbone for most computer-to-computer communication of the era, and Bell engineers understood better than anyone what a common bit-serial character set needed to survive real-world line noise.

The choice of 7 bits (giving 128 code points) was deliberate rather than arbitrary. Early modems and serial links routinely used the 8th bit of every byte as a parity bit — an error-checking mechanism that sets the high bit so that the total number of 1-bits in each byte is always odd (or always even), letting the receiver detect single-bit transmission errors. Reserving bit 7 for parity meant ASCII characters had to fit into the remaining seven bits. As error-correction moved into dedicated hardware and protocol layers, the 8th bit became free — opening the door to extended ASCII and, eventually, Unicode. The long-term legacy of that pragmatic choice is visible in UTF-8: its designers ensured that any ASCII byte (high bit clear) is interpreted identically in UTF-8, making the entire 60-year-old ASCII corpus valid UTF-8 without any conversion at all.

That backward compatibility is not a coincidence — it is the main reason UTF-8 displaced every competing Unicode encoding on the internet. An ASCII plain-text file written in 1971 on a PDP-11 is valid UTF-8 today. Web servers, JSON parsers, XML processors and virtually every network protocol assume that code points 0–127 are ASCII. Understanding the original 128-character table therefore remains a foundational skill regardless of whether you ever work with legacy systems, because the structure it established shapes every text-processing abstraction built on top of it.

Control characters (codes 0–31) and what they originally did

The first 32 ASCII codes are control characters — they do not print a visible glyph but instead signal an action to the device receiving the data. Their names and purposes were inherited directly from teletype machines (mechanical terminals that printed on continuous paper rolls). NUL (0) was a no-operation padding byte for mechanical delays in teletype paper-tape systems; C later repurposed it as the string terminator that ends every null-terminated character array. BEL (7) literally rang a physical bell mounted on the teletype to alert an operator. BS (8 — backspace) moved the print head one position to the left so a character could be overprinted for emphasis. HT (9 — horizontal tab) advanced the carriage to the next preset tab stop, much like a typewriter's tab key. LF (10 — line feed) advanced the paper one line without moving the carriage, and CR (13 — carriage return) moved the carriage back to the leftmost position without advancing the paper.

The distinction between CR and LF explains the line-ending differences that still cause headaches today. On a typewriter, ending a line required two physical operations: return the carriage (CR) and advance the paper (LF). Early software preserved both steps, giving Windows its CR+LF (\r\n) line endings. Unix designers concluded that a single LF was sufficient and adopted LF-only (\n), while old Mac OS used CR-only (\r). When text files cross operating systems, these differences can make scripts fail, corrupt binary file comparisons and trip up line-count tools — all traceable to the mechanical realities of 1960s teletype hardware.

ESC (27) was defined simply as an escape character — a prefix signalling that the bytes following it should be interpreted as a command rather than printable text. This is the basis of ANSI escape sequences, the codes that terminal emulators still use for setting text colour, moving the cursor, clearing the screen and hundreds of other operations. Prefix ESC with a '[' and follow it with numeric parameters to produce sequences like \033[31m (red text) or \033[2J (clear screen). Finally, DEL (127) sits at the very end of the 7-bit range, not in the control block, but it behaves like one: on paper tape, you could erase a mistake by punching all seven holes across the tape, setting every bit to 1 — the bit pattern for 127. Many Unix systems still map the backspace key to DEL (127) rather than BS (8), a convention inherited from terminals that treated DEL as the destructive-erase character.

Printable ASCII (codes 32–126) and its arithmetic structure

The 95 printable ASCII characters occupy codes 32 through 126. Code 32 is the space character — the only invisible printable, and the lowest code that a font renders as a glyph rather than a device command. Punctuation is scattered in three clusters: codes 33–47 contain ! " # $ % & ' ( ) * + , - . /, codes 58–64 hold : ; < = > ? @, and codes 91–96 and 123–126 hold the bracket pairs, backslash, caret, underscore, backtick, pipe, tilde and braces. The digits 0–9 map to codes 48–57 — and the offset is clean: subtract 48 (hex 0x30) from any digit character's code and you get the integer value directly, which made ASCII well-suited for BCD (binary-coded decimal) arithmetic on early hardware. Uppercase A–Z run from 65 to 90 and lowercase a–z from 97 to 122, a gap of exactly 32.

That gap of 32 between upper- and lowercase is not accidental — it is a deliberate design choice that enables simple bitwise case conversion. Because 32 is a power of two (2⁵), toggling bit 5 of any letter flips its case. In C: c | 0x20 converts any uppercase ASCII letter to lowercase, and c & ~0x20 converts it back to uppercase. This works because the only bit that differs between 'A' (01000001) and 'a' (01100001) is bit 5. Programmers have used this trick since the 1960s for fast case-insensitive comparisons and case-folding routines in assembly and C, and it remains a common interview question and a practical optimisation in parsing-intensive code paths today.

Knowing the boundaries of the printable ranges also underpins input validation idioms that appear in virtually every codebase. Checking whether a char is a digit is expressed as c >= '0' && c <= '9' (codes 48–57), testing for uppercase as c >= 'A' && c <= 'Z' (65–90), and for lowercase as c >= 'a' && c <= 'z' (97–122). These comparisons rely on the contiguous, ordered layout of ASCII — letters and digits appear in runs with no gaps, so a range check is both correct and efficient. When any of these checks appears in security-critical code (parsers, tokenisers, URL validators), understanding the exact ASCII boundaries prevents off-by-one vulnerabilities where an attacker can sneak in a character just outside the expected range.

Extended ASCII, code pages and the road to Unicode

Once 8-bit bytes became standard hardware, the question of what to do with codes 128–255 had no single answer. Extended ASCII is a loose term for any encoding that re-uses the ASCII 0–127 block and fills the upper half with additional characters — but every vendor filled that upper half differently, producing dozens of incompatible code pages. IBM's Code Page 437, shipped with the original IBM PC and MS-DOS, filled codes 128–255 with box-drawing characters (─ │ ┌ ┐ └ ┘ and their double-line variants), mathematical symbols (≈ ≤ ≥ ÷ ∞ √), Greek letters and a handful of accented European characters. Those box-drawing characters powered the entire visual aesthetic of MS-DOS applications, from Borland's Turbo Pascal IDE to early spreadsheet programs — all drawn with pure ASCII art at the byte level.

Windows-1252 (informally called the 'Western European' code page) later became the dominant encoding for Windows documents and the implicit default encoding of most HTML pages on the early web. It diverges from ISO-8859-1 (Latin-1) — the international standard for Western European languages — specifically in the range 128–159. ISO-8859-1 left those 32 codes as control characters (a carry-over from the ISO-646 standard); Windows-1252 instead used them for useful printable characters including the Euro sign (€, 0x80), opening and closing typographic quotes (" " ' '), the ellipsis (…) and the en and em dashes (– —). This difference caused years of mojibake — garbled text where a document authored in Windows-1252 was decoded as Latin-1, turning € into an undefined control character and smart quotes into garbage.

The only correct long-term answer was Unicode, a single encoding space that assigns a unique code point to every character in every writing system on Earth. UTF-8, the web's dominant encoding since around 2008, achieves this while preserving full backward compatibility: any byte below 128 is an ASCII character, byte-for-byte identical to the original 1963 standard. Multi-byte sequences (using the high bit to signal continuation bytes) handle code points 128 and above. The practical consequence is that understanding the original ASCII table remains just as relevant in a UTF-8 world: the first 128 code points are exactly the same, control characters have the same meanings, and the printable-range arithmetic (digit offset 48, case-flip bit 5) still applies without modification to any byte in a UTF-8 string that falls in the ASCII range.