ASCII Table

The ASCII table: how 128 numbers became the foundation of text

ASCII, short for the American Standard Code for Information Interchange, is the encoding that taught computers to agree on what a letter is. Published in 1963 and refined through the 1960s, it maps every basic character of English text, the digits, and a handful of control signals onto numbers a machine can store and transmit. When you press the key for a capital A, your computer does not store a shape, it stores the number 65. ASCII is the lookup table that makes that number mean A everywhere it travels.

The standard is famously compact. ASCII is a 7-bit code, which means each character fits inside seven binary digits and the whole repertoire spans exactly 2 to the power of 7, or 128 distinct code points numbered 0 through 127. That economy was deliberate. Early teletypes and modems were slow and expensive, so every bit counted. Seven bits were enough to cover uppercase and lowercase Latin letters, the ten digits, common punctuation, and the signaling characters that kept devices in sync, with one bit left over that many systems used for error checking.

Two halves: control characters and printable characters

The table splits cleanly into two regions. Codes 0 through 31, plus code 127 (DEL), are the control characters. These do not print a glyph on screen. Instead they instruct a device to do something: code 9 is a horizontal tab, code 10 is the line feed that moves to a new line, code 13 is the carriage return, and code 7 is the bell that once made a terminal chime audibly. Thirty-three of these signaling codes exist in total, and although many are now historical curiosities, line feed, carriage return, and tab remain essential to how text files are formatted today.

Codes 32 through 126 are the printable characters, ninety-five of them in all. Code 32 is the space, which counts as printable because it advances the cursor even though it shows nothing. From there you get the punctuation and symbols, the digits 0 through 9 at codes 48 to 57, the uppercase letters A to Z at 65 to 90, and the lowercase letters a to z at 97 to 122. A neat property falls out of this layout: lowercase and uppercase versions of the same letter differ by exactly 32, which is why flipping a single bit converts case. These regularities are not accidents, they were engineered so that sorting and case conversion could be done with simple arithmetic.

Decimal, hexadecimal, and binary: three views of one number

Every ASCII code is just a number, and you will see it written three ways. Decimal is the everyday base-10 form, so A is 65. Hexadecimal, base 16, is the form programmers reach for because it lines up with bytes: A is 0x41, and the printable range runs from 0x20 to 0x7E. Binary, base 2, is the form the hardware actually stores, so A is 1000001 across its seven bits. The same character, three notations, and being fluent in moving between them is a core skill when you are reading memory dumps or network traffic. If you work with these conversions often, the broader set of reference tables on speedor.net keeps the mappings one click away.

Where ASCII still matters

It would be a mistake to file ASCII under history. It is alive in the daily work of anyone who touches code. Programming languages treat string literals, source files, and protocol keywords as ASCII at the byte level. Network protocols such as HTTP headers, SMTP, and many configuration formats are defined in ASCII so they stay human-readable. When a string looks corrupted, developers reach for a hex viewer and read the raw bytes against the ASCII table to spot a stray control character or a wrong line ending. URL encoding, Base64, and escape sequences all build on ASCII values. For anyone debugging encoding bugs, a quick reference next to your developer tools turns a mystery byte into an obvious answer.

From ASCII to Unicode and UTF-8

ASCII handled English beautifully and almost nothing else. A 128-character ceiling cannot hold accented letters, Cyrillic, Chinese, Arabic, or emoji. Unicode answered that by assigning a unique number, called a code point, to every character in every writing system, now well over one hundred thousand of them. Crucially, Unicode is a catalogue of characters, not a storage format, so it needs an encoding to turn those code points into bytes.

UTF-8 is that encoding, and it is the reason ASCII never really went away. UTF-8 uses one to four bytes per character, and it was designed so that code points 0 through 127, the entire ASCII range, are stored in a single byte identical to plain ASCII. That makes UTF-8 perfectly backward compatible: any valid ASCII file is already a valid UTF-8 file. Characters above 127 use additional bytes. This elegant compatibility is a big reason UTF-8 now powers the overwhelming majority of the web. In short, ASCII is the original 128-character core, Unicode is the universal catalogue that contains it, and UTF-8 is the encoding that carries both while keeping ASCII text byte-for-byte unchanged.

Frequently asked questions