What an ASCII Chart Example Looks Like
The standard ASCII chart is a 128-row reference table that assigns each integer from decimal 0 through decimal 127 to a single character or control abbreviation, displaying every code position in four notations — decimal, two-digit hexadecimal, three-digit octal, and seven-digit binary — alongside a visible glyph, a descriptive name, and a category. A typical ASCII chart example row therefore looks like this: capital letter A appears as decimal 65, hexadecimal 0x41, octal 0o101, and binary 0b1000001, with the printed glyph "A", the name "Latin Capital Letter A", and the category "Uppercase Letter". The chart is built directly from RFC 20 and the Unicode Basic Latin code chart, so the code positions and names agree with both standards while the abbreviations for control positions (such as NUL, HT, LF, CR, DEL) follow the RFC 20 control terminology. Because the table is a single, deterministic list of 128 entries, an ASCII chart example is the same wherever you look at a standards-compliant reference: each integer appears once, with no duplicate rows and no gaps.
An ASCII chart example for a printable symbol includes a visible glyph, while an example for a control position shows the abbreviation and the full descriptive name instead. The chart does not invent empty cells for controls that lack printable glyphs, nor does it map multiple characters to a single decimal value. Each decimal position corresponds to exactly one row, and that row contains all four notations for the same integer. This property is what makes the table usable as a lookup reference for code comments, protocol notes, network traces, and teaching material: you can read any one of the four notations and find the matching row without ambiguity, and you can quote any of the four notations in a documentation comment without converting it first.
Printable Character Examples: Letters, Digits, Punctuation
The printable portion of an ASCII chart example covers decimal 32 through decimal 126, divided into the Space character at 32, punctuation in the lower graphic range, the digits 0 through 9 from decimal 48 through 57, uppercase Latin letters from 65 through 90, and lowercase Latin letters from 97 through 126. The ASCII Table reference on this site shows each of these as a row you can copy directly, but the following small table illustrates the shape of a real ASCII chart example for a few representative entries across categories.
| Glyph | Name | Decimal | Hex | Octal | Binary | Category |
|---|---|---|---|---|---|---|
| " " | Space (SP) | 32 | 0x20 | 0o040 | 0b0100000 | Space |
| "0" | Digit Zero | 48 | 0x30 | 0o060 | 0b0110000 | Digit |
| "?" | Question Mark | 63 | 0x3F | 0o077 | 0b0111111 | Punctuation |
| "A" | Latin Capital Letter A | 65 | 0x41 | 0o101 | 0b1000001 | Uppercase Letter |
| "a" | Latin Small Letter A | 97 | 0x61 | 0o141 | 0b1100001 | Lowercase Letter |
The relationship between an uppercase letter and its lowercase counterpart is one of the most useful properties the chart reveals at a glance: lowercase "a" (97) is exactly 32 more than uppercase "A" (65), which is why toggling case in many languages can be done by adding or subtracting 32 from the decimal code. The same pattern holds for every other Latin letter pair, so the chart example for "Z" (90) sits 32 codes below "z" (122). Recognizing this structure turns the table from a flat list into a compact mental model for ASCII arithmetic, and it explains why simple bitwise and arithmetic tricks work the way they do.
Punctuation entries cluster in the lower graphic range from decimal 33 to 47, then again in the range from 58 to 64, and finally from 91 to 96, with brackets and braces filling out the area between the uppercase and lowercase blocks. Every printable glyph has a fixed-width name taken from the Unicode Basic Latin chart, so the same row shows the same name in any standards-compliant tool. An ASCII chart example for printable entries always pairs the glyph with its full Unicode name, which keeps code comments unambiguous even when the font in use renders the character unusually or when the character is invisible in a terminal.
Control Character Examples: RFC 20 Abbreviations
An ASCII chart example for a control position does not show a printable glyph, because positions decimal 0 through 31 and decimal 127 have no ordinary letter, digit, or symbol. RFC 20 supplies the standard abbreviations and full names for these positions, and the chart displays the abbreviation in the glyph column so the row never appears empty or misleading. The following table is an ASCII chart example for representative control rows drawn from the same 128-entry table.
| Abbr. | Name | Decimal | Hex | Octal | Binary | Category |
|---|---|---|---|---|---|---|
| NUL | Null | 0 | 0x00 | 0o000 | 0b0000000 | Control |
| HT | Horizontal Tabulation | 9 | 0x09 | 0o011 | 0b0001001 | Control |
| LF | Line Feed | 10 | 0x0A | 0o012 | 0b0001010 | Control |
| CR | Carriage Return | 13 | 0x0D | 0o015 | 0b0001101 | Control |
| DEL | Delete | 127 | 0x7F | 0o177 | 0b1111111 | Delete |
Three of these control rows deserve special attention because they affect file formats and network protocols. HT at decimal 9 is the tabulation byte used by tab-separated files, log lines, and many source-code indentations. LF at decimal 10 is the line terminator in Unix, Linux, and modern macOS text files, while CR at decimal 13 is the line terminator in classic Mac OS and a frequent companion to LF inside CRLF sequences on Windows and HTTP. An ASCII chart example that lists HT, LF, and CR side by side is often the quickest way to explain why the same text file can look correct on one platform and look like a single line on another. Decimal 32, the Space character, is shown explicitly as SP and placed in its own category because RFC 20 treats it as a normally non-printing graphic rather than a control, while DEL at decimal 127 is placed in its own Delete category because RFC 20 notes that DEL is not a control character in the strict sense.
How to Look Up Any ASCII Chart Example
- Open the ASCII Table reference in your browser so you can browse, search, and copy rows locally without sending search terms or copied output to a remote service.
- Scroll through all 128 rows in the complete view, or type a value directly into the search box if you already know what you want to look up.
- Choose a category filter — Controls, Punctuation, Digits, Uppercase, Lowercase, Space, or Delete — to narrow the chart to a subset when the full table is too wide for the task at hand.
- Read the row you need. Each row shows the same code in decimal, two-digit hexadecimal, three-digit octal, and seven-digit binary, with the glyph or abbreviation, the descriptive name, and the category.
- Select Copy on the row to write the complete row to your clipboard in a readable text format that includes all four notations. If the browser denies clipboard access, the page reports the failure rather than reporting a successful copy.
Search Syntax Examples: Decimal, Hex, Octal, Binary
The search box in an ASCII chart example tool is more permissive than a strict numeric lookup. Plain digits are interpreted as decimal, so typing 65 finds the row containing capital A at decimal 65, while typing 48 finds the row containing digit zero. To look up an entry by hexadecimal, octal, or binary, prefix the value with 0x, 0o, or 0b respectively, so 0x41, 0o101, and 0b1000001 all return the same capital A row that decimal 65 returns. The prefixed notation is what makes the search match exactly, which prevents 65 from also matching decimal 165 or 650, and prevents 10 from being confused with a binary value.
For a literal character lookup, use the char:value syntax. Typing char:A finds the row whose glyph is the capital letter A, typing char:0 finds the row for digit zero, and typing char:space finds the row at decimal 32 even though space has no ordinary printed glyph. The same syntax works for control abbreviations when needed, and it lets you paste a character you cannot easily type into the search box. Searching for words such as line feed, question mark, or capital letter is also accepted, so an ASCII chart example can be reached by name as well as by number, and the empty result state is shown explicitly rather than leaving stale rows on screen.
Why a Standard ASCII Chart Example Stops at 127
Standard ASCII is a 7-bit coded character set, which means each code position is seven bits wide and can therefore represent at most 128 distinct values. ECMA-6 confirms this 128-character scope, and RFC 20 lists exactly those 128 code positions. As a result, an ASCII chart example never includes decimal 128, 200, or 255, even though those byte values are common in real files. The byte values above 127 belong to other encodings such as ISO-8859-1, Windows code pages, and IBM PC code pages such as CP437, and the same byte can map to different characters depending on which encoding produced it. Calling all of those values "extended ASCII" hides an important ambiguity, which is why a standards-compliant chart stops at decimal 127 and does not combine incompatible 8-bit mappings into a single table.
The practical consequence is that if you encounter a value above 127 in a file, network trace, or string literal, the first step is to identify the actual character encoding that produced it rather than to look it up in a standard ASCII chart example. Choosing the encoding is part of decoding, because the number alone is not enough. Once the encoding is identified, the corresponding table for that encoding can be consulted separately. For pure 7-bit ASCII work — the majority of source code, configuration files, network protocols, and structured text — the 128-entry chart is complete and sufficient, which is why it has remained the standard reference for so long, and why a standards-compliant example never claims to cover bytes that standard ASCII does not actually define.
Related reading: Chmod Calculator Example: Setuid, Sticky, and rwx.
Related reading: Box Shadow Generator Example: From Sliders to CSS.