ASCII Reference Table

Search 7-bit US-ASCII (0-127) and Extended Latin-1 (128-255) locally in your browser by decimal, hex, octal, 8-bit binary, escapes, and HTML entities.

No uploadsNo sign-upInstant results
7-Bit ASCII & Latin-1Dec, Hex, Oct, Bin & HTMLText Byte Inspector
Open ASCII Table
Offline engine ready100% private in-browser workspace • Zero cloud uploads
100% Private • Zero Server File Uploads

Why Use Utiliome's Free ASCII Reference Table?

Built from the ground up for strict privacy, instant execution, and zero friction. No subscriptions, paywalls, or account registrations required.

ANSI X3.4 & ISO-8859-1 Complete 0-255 Chart

Covers all 128 standard 7-bit US-ASCII positions (RFC 20 C0 controls and printable characters) alongside Extended 8-bit ISO-8859-1 Latin-1 (128-255) C1 controls and Western European symbols.

Synchronized Multi-Base & Escape Columns

Cross-references decimal (0-255), hexadecimal (0x00-0xFF), 3-digit octal (000-377), padded 8-bit binary, C/JS backslash escapes, terminal caret notation (^@, ^M, ^?), and HTML entities.

Instant Multi-Field Search & Group Filters

Filter all 256 byte rows immediately by typing a printable glyph, control mnemonic such as LF or ESC, hex byte like 0x1B, 8-bit binary pattern, caret sequence, or HTML entity.

Zero-Latency Client-Side Lookup

Performs all filtering, range toggling, and one-click code copying directly in browser memory with zero network round-trips or external dependencies.

Utiliome vs Traditional Cloud Alternatives

Compare our local-first WebAssembly engine against legacy cloud tools.

Feature Utiliome (Local Browser) Legacy Cloud Converters
Character Range Coverage Complete 7-bit US-ASCII (0–127) plus 8-bit Extended (128–255) CP-1252 vs Latin-1 Static image chart of 0–127 only with no extended byte comparison
Radix & Escape Columns Decimal, Hex, Octal, 8-bit Binary, Caret (^C), C escape (\n) & HTML entity Shows Decimal and Hex only without control code caret notation
Interactive Search & Bitwise Filtering Instant filter by hex, decimal, control mnemonic (ACK, LF), or category Non-searchable static HTML table or scanned textbook image
One-Click Code Copying Click any cell to copy its exact hex literal, escape sequence, or symbol Manual text selection across misaligned table columns
How it works

How to Use ASCII Reference Table in 3 Easy Steps

No software installation required. Everything runs directly inside your web browser.

1

Choose an ASCII Range or Control Group

View the complete 0 to 255 byte table or narrow rows to C0 Control Codes (0-31 and 127), Printable 7-bit US-ASCII (32-126), or Extended ISO-8859-1 Latin-1 (128-255).

2

Filter by Base, Mnemonic, Caret, or Escape

Type any character, mnemonic (NUL, CR,LF, DEL), decimal number, hex value (0x0A, 7F), binary byte (01000001), caret shortcut (^C), C/JS escape (\r, \x1b), or HTML entity ( ).

3

Copy Formatted Literals Directly

Click any value in a matching row to copy its hex literal, decimal integer, 8-bit binary string, backslash escape, or HTML entity straight into your parser or source file.

Quick Reference Walkthrough: Control Codes, Printable Glyphs, and Extended Bytes

Quick Answer: Look up any byte value from 0 to 255 to cross-reference its control mnemonic or glyph, decimal, hex, octal, 8-bit binary, C/JavaScript escape, terminal caret notation, and HTML entity—ideal for debugging HTTP CRLF framing, ANSI terminal sequences, and binary wire protocols.

When writing lexers, inspecting TCP packet dumps, or configuring serial and terminal I/O, developers constantly translate between raw byte values and symbolic representations. Below is a reference snapshot of the highest-frequency anchor rows across C0 controls (0–31, 127), printable 7-bit US-ASCII (32–126), and Extended ISO-8859-1 Latin-1 (128–255):

Dec  Hex   Oct  Binary    Glyph / Mnemonic  Caret  C / JS Escape  HTML Entity
---  ----  ---  --------  ----------------  -----  -------------  -----------
0    0x00  000  00000000  <NUL> (Null)      ^@     \0             &#0;
9    0x09  011  00001001  <HT>  (Tab)       ^I     \t             &#9;
10   0x0A  012  00001010  <LF>  (Line Feed) ^J     \n             &#10;
13   0x0D  015  00001101  <CR>  (Return)    ^M     \r             &#13;
27   0x1B  033  00011011  <ESC> (Escape)    ^[     \x1B           &#27;
32   0x20  040  00100000  <SP>  (Space)     -      " "            &#32;
48   0x30  060  00110000  0                 -      0              &#48;
65   0x41  101  01000001  A                 -      A              &#65;
97   0x61  141  01100001  a                 -      a              &#97;
126  0x7E  176  01111110  ~                 -      ~              &#126;
127  0x7F  177  01111111  <DEL> (Delete)    ^?     \x7F           &#127;
160  0xA0  240  10100000  <NBSP>            -      \xA0           &nbsp;
169  0xA9  251  10101001  ©                 -      \xA9           &copy;
255  0xFF  377  11111111  ÿ                 -      \xFF           &yuml;

Practical Protocol Lookup Examples

Mapping raw wire bytes against the table immediately clarifies protocol framing and terminal control sequences:

1. HTTP/1.1 Header Terminator (RFC 9112):
   Hex bytes:  0D 0A 0D 0A
   Mnemonics:  <CR><LF><CR><LF>
   Escapes:    "\r\n\r\n" (Decimal: 13, 10, 13, 10)

2. ANSI CSI Green Terminal Prompt:
   Hex bytes:  1B 5B 33 32 6D
   Decoded:    <ESC> (0x1B / ^[) + '[' (0x5B) + '3' (0x33) + '2' (0x32) + 'm' (0x6D)
   JS literal: "\x1b[32m"

7-Bit US-ASCII Bitwise Layout, Caret Arithmetic, and Extended 8-Bit Nuances

Quick Answer: Standard US-ASCII (ANSI X3.4 / ISO/IEC 646 / RFC 20) arranges 128 characters across 7 bits (0x00 to 0x7F) so case conversion, digit parsing, and caret notation reduce to single-bit operations, whereas extended bytes 0x80 to 0xFF differ fundamentally across ISO-8859-1, Windows-1252, and UTF-8.

Mathematical Bit Layout of 7-Bit US-ASCII (ANSI X3.4 / RFC 20)

The 7-bit US-ASCII grid (b6 b5 b4 b3 b2 b1 b0, spanning 0x00 to 0x7F) was engineered intentionally so hardware circuits and low-level parsers could classify and transform characters using single bitwise instructions without lookup tables:

  • Bit 5 (0x20, decimal 32) Case Folding: Uppercase letters A–Z occupy 0x41–0x5A (01000001–01011010), while lowercase letters a–z occupy 0x61–0x7A (01100001–01111010). Every uppercase/lowercase pair differs exclusively in bit 5. Folding an ASCII letter to lowercase is byte | 0x20, converting to uppercase is byte & ~0x20, and toggling case is byte ^ 0x20.
  • Low-Nibble BCD Digit Alignment: Numerals 0–9 occupy 0x30–0x39 (00110000–00111001). Stripping the upper 0011 nibble via byte & 0x0F (or subtracting 0x30) yields the binary-coded integer 0 through 9 directly.
  • Bit 6 (0x40, decimal 64) Caret Notation & Ctrl Key Mapping: Terminal drivers translate Ctrl chords and display C0 control codes (0x00–0x1F) plus <DEL> (0x7F) by flipping bit 6 (byte ^ 0x40). Consequently, <NUL> (0x00 ^ 0x40 = 0x40) renders as ^@, <ETX> (0x03 ^ 0x40 = 0x43) renders as ^C (SIGINT), <LF> (0x0A ^ 0x40 = 0x4A) renders as ^J, <CR> (0x0D ^ 0x40 = 0x4D) renders as ^M, <ESC> (0x1B ^ 0x40 = 0x5B) renders as ^[, and <DEL> (0x7F ^ 0x40 = 0x3F) renders as ^?.

The 128–255 Extended Byte Trap: ISO-8859-1 vs Windows-1252 vs UTF-8

Because US-ASCII leaves the 8th bit (b7, 0x80) unset, incompatible 8-bit extensions emerged for values 128 through 255 (0x80–0xFF). Confusing them is the root cause of classic text corruption (mojibake):

  1. ISO-8859-1 (Latin-1): Reserves 128–159 (0x80–0x9F) for C1 control codes (such as <PAD>, <NEL>, and <CSI>) and assigns 160–255 (0xA0–0xFF) to Western European punctuation, currency symbols, and accented letters starting with <NBSP> (0xA0). Crucially, Unicode adopted ISO-8859-1 as its U+0080–U+00FF Latin-1 Supplement block, so ISO-8859-1 byte values match Unicode code point numbers 1:1.
  2. Windows-1252 (CP1252): Reassigns 27 of the 32 0x80–0x9F C1 control positions to printable glyphs—including € (0x80, which in Unicode is U+20AC), — (0x97, U+2014), and curly quotes (0x91–0x94). Per the WHATWG Encoding Standard, web browsers treat HTML charset=iso-8859-1 declarations as windows-1252.
  3. UTF-8: Shares exact single-byte compatibility with 7-bit US-ASCII (0x00–0x7F only). In UTF-8, raw bytes 0x80–0xFF are never valid single-byte Latin-1 characters: values U+0080–U+00FF require a 2-byte UTF-8 sequence (0xC2 0x80 through 0xC3 0xBF). Passing a raw Latin-1 byte like 0xE9 (é) into a UTF-8 parser triggers a decoding error (U+FFFD), while reading UTF-8 0xC3 0xA9 as ISO-8859-1 produces the two-character mojibake string é.

ASCII Reference Table vs Character Inspector and Hex Decoders

Quick Answer: Use ASCII Reference Table to look up static 0 to 255 byte mappings, control mnemonics, caret shortcuts, and escapes. Use Unicode Character Inspector to audit arbitrary pasted strings for hidden Unicode or UTF-8 bytes, or Hex to Text Converter to encode and decode full hexadecimal payloads.

Select the specialized tool that matches whether you need a byte-level reference chart, string-level Unicode diagnostics, bulk hexadecimal payload conversion, or formatted text tables:

Capability ASCII Reference Table Unicode Character Inspector Hex to Text Converter ASCII, Unicode & Plain Text Table Formatter
Primary Purpose Searchable 0–255 lookup table for US-ASCII & ISO-8859-1 Per-character Unicode diagnostic & hidden-char detector Bulk conversion between hex byte strings and readable text Drawing aligned ASCII +---+ and Unicode box-drawing tables
Character Scope 256 single-byte codes (0x00–0x7F + Latin-1 0x80–0xFF) All 1,112,064 Unicode scalar values (U+0000–U+10FFFF) Arbitrary multi-byte UTF-8 or ASCII byte streams Arbitrary tabular data from CSV, TSV, JSON, or Markdown
Control & Caret Info Full C0/C1 mnemonics (<NUL>–<DEL>), caret (^M), octal, binary Flags embedded <ZWSP>, <BOM>, <NBSP>, and bidi overrides Decodes or encodes raw hex bytes (48 65 6C 6C 6F) Not an encoding lookup tool
Best Use Case Checking hex/binary/escape codes while writing parsers Debugging why a pasted string fails regex, JSON, or equality Translating packet captures or hex dumps to/from text Formatting CLI output, README docs, and SQL-style ASCII grids
  • Open the Unicode Character Inspector whenever you have a real string or file with multi-byte UTF-8 emojis, zero-width spaces, or confusable homoglyphs beyond byte 255.
  • Use the Hex to Text Converter to decode long hexadecimal byte dumps (0D 0A streams, Wireshark payloads, or hex-encoded logs) directly into UTF-8 text or vice versa.
  • If you are looking to generate aligned plain-text +---+---+ or Unicode ┌───┐ data grids for documentation or code comments rather than looking up character codes, use the ASCII, Unicode & Plain Text Table Formatter, or visit the Unicode Converter for batch U+XXXX code point transformations.
FAQ

ASCII Reference Table FAQ and Technical Guide

Everything you need to know about using Utiliome's free online ascii table.

What is the difference between 7-bit US-ASCII (0-127) and Extended ASCII (128-255)?

Standard US-ASCII (ANSI X3.4 / RFC 20) strictly defines 128 code positions using 7 bits (0 to 127, or 0x00 to 0x7F): 33 non-printing control codes (0 to 31 plus 127 <DEL>) and 95 printable glyphs (32 <SP> through 126 ~). Codes 128 to 255 (0x80 to 0xFF) set the 8th bit and depend on the chosen 8-bit character encoding. This reference uses ISO-8859-1 (Latin-1) for 128 to 255 because its numeric code values map identically to Unicode scalar values U+0080 through U+00FF.

Why do Windows and HTTP use CRLF (13, 10) while Unix and Linux use LF (10)?

Electromechanical teletypes required two distinct physical actions to start a new line: Carriage Return (<CR>, decimal 13, 0x0D, \r) returned the print carriage to the left margin, and Line Feed (<LF>, decimal 10, 0x0A, \n) rolled the paper platen up one line. Internet protocols including HTTP/1.1, SMTP, and FTP—along with CP/M, DOS, and Windows—standardized on the two-byte <CR><LF> (0D 0A) sequence, whereas Multics, Unix, Linux, and modern macOS adopted single-byte <LF> (0A) as an implicit newline.

Are Extended Latin-1 bytes (128-255) byte-identical to UTF-8?

No. Only 7-bit US-ASCII values 0 through 127 (0x00 to 0x7F) share identical single-byte encodings in UTF-8. Although ISO-8859-1 bytes 128 to 255 have the exact same code point numbers as Unicode U+0080 to U+00FF, UTF-8 encodes that range as two-byte sequences starting with lead byte 0xC2 or 0xC3. For example, © is single byte 0xA9 (decimal 169) in ISO-8859-1, but two bytes 0xC2 0xA9 in UTF-8.

How is terminal caret notation (^C, ^M, ^[, ^?) calculated from ASCII codes?

Caret notation converts non-printing C0 control bytes (0x00 to 0x1F) and <DEL> (0x7F) into printable ASCII characters by toggling bit 6 via bitwise XOR with 0x40 (decimal 64). XORing <ETX> (0x03) with 0x40 produces 0x43 ('C'), written as ^C. Likewise, <CR> (0x0D ^ 0x40 = 0x4D) becomes ^M, <ESC> (0x1B ^ 0x40 = 0x5B) becomes ^[, and <DEL> (0x7F ^ 0x40 = 0x3F) becomes ^?.

Why is DEL assigned to 127 instead of grouped with control characters 0 to 31?

On 7-track punched paper tape, code 0 (<NUL>, binary 0000000) meant no holes punched, while code 127 (<DEL>, binary 1111111) meant all seven holes punched. Because physical holes could not be unpunched after a typing mistake, operators backed up the tape and punched all seven holes over the erroneous character to turn it into 127 (<DEL>), which hardware tape readers skipped automatically.