About

Byte-to-character mapping errors cause silent data corruption in serial protocols, file parsers, and network packet inspection. A single off-by-one in a 0x0D0x0A (CR LF) sequence breaks line parsing across platforms. This tool converts raw byte values in decimal (0 - 255), hexadecimal (0x00 - 0xFF), or binary (00000000 - 11111111) to their corresponding ASCII and extended ASCII characters. Non-printable control codes below 0x20 and DEL (0x7F) are rendered with their standard abbreviations (NUL, SOH, STX, etc.) rather than invisible glyphs. The converter handles the full 8-bit range per ISO/IEC 8859-1. Note: bytes above 127 map to extended ASCII and may render differently depending on your system's code page.

Formulas

Each byte B is an unsigned 8-bit integer with valid range:

0 ≤ B ≤ 255

The mapping function from byte to character is:

C = fromCharCode(B)

For hexadecimal input tokens, the decimal value is recovered via base conversion:

B = n−1∑i=0 d_i ⋅ 16ⁱ

where d_i is the i-th hex digit from the right, and n is the total digit count. For binary input, the same formula applies with base 2:

B = 7∑i=0 b_i ⋅ 2ⁱ

where b_i ∈ {0, 1}. Non-printable characters are those where B < 32 or B = 127. These are displayed using their standard control code abbreviations (NUL, SOH, STX, ETX, etc.) per ANSI X3.4-1986.

Reference Data

Dec	Hex	Binary	Char	Description
0	0x00	00000000	NUL	Null character
7	0x07	00000111	BEL	Bell / Alert
8	0x08	00001000	BS	Backspace
9	0x09	00001001	HT	Horizontal Tab
10	0x0A	00001010	LF	Line Feed (Unix newline)
13	0x0D	00001101	CR	Carriage Return
27	0x1B	00011011	ESC	Escape
32	0x20	00100000	SP	Space
48	0x30	00110000	0	Digit zero
57	0x39	00111001	9	Digit nine
65	0x41	01000001	A	Uppercase A
90	0x5A	01011010	Z	Uppercase Z
97	0x61	01100001	a	Lowercase a
122	0x7A	01111010	z	Lowercase z
127	0x7F	01111111	DEL	Delete
128	0x80	10000000	€	Euro sign (Windows-1252)
160	0xA0	10100000	NBSP	Non-breaking space
169	0xA9	10101001	©	Copyright sign
176	0xB0	10110000	°	Degree symbol
181	0xB5	10110101	µ	Micro sign
188	0xBC	10111100	¼	Vulgar fraction one quarter
191	0xBF	10111111	¿	Inverted question mark
192	0xC0	11000000	À	Latin capital A with grave
223	0xDF	11011111	ß	Latin small sharp S (Eszett)
233	0xE9	11101001	é	Latin small E with acute
241	0xF1	11110001	ñ	Latin small N with tilde
252	0xFC	11111100	ü	Latin small U with diaeresis
255	0xFF	11111111	ÿ	Latin small Y with diaeresis

Frequently Asked Questions

Non-printable bytes are rendered using their standard ASCII control code abbreviations: 0 = NUL, 1 = SOH, 2 = STX, through 31 = US, and 127 = DEL. In the detailed byte table view, each non-printable byte is shown with its abbreviation inside a distinct tag so you can identify it at a glance. The plain text output replaces them with the Unicode Control Pictures block (U+2400 - U+2421) where available.

Any token that parses to a value less than 0 or greater than 255 is flagged as invalid. The converter highlights the offending token in the input breakdown table and excludes it from the output string. A single 8-bit byte can only represent 256 distinct values (0x00 through 0xFF). If you need to encode larger code points (e.g., Unicode), you must split them into multi-byte sequences first (UTF-8 encoding uses 1 to 4 bytes per character).

Yes. When the input format is set to Auto-Detect, each token is classified independently. Tokens prefixed with 0x or 0X are parsed as hexadecimal. Tokens consisting solely of 0s and 1s with exactly 8 digits are parsed as binary. All other numeric tokens are parsed as decimal. Ambiguous tokens (e.g., 10 could be decimal ten or binary two) default to decimal unless the 8-digit binary pattern matches. For unambiguous results, select a specific format.

Standard ASCII (ANSI X3.4) defines only 128 characters (bytes 0 - 127). Bytes 128 - 255 fall into the "extended ASCII" region whose interpretation depends on the code page. ISO 8859-1 (Latin-1) maps them to Western European characters. Windows-1252 differs for bytes 128 - 159, placing characters like the Euro sign (€) at 0x80. This tool uses the browser's native Latin-1 mapping via String.fromCharCode, which aligns with ISO 8859-1 for the 0 - 255 range.

The parser accepts spaces, commas, semicolons, tabs, and newlines as delimiters. Multiple consecutive delimiters are treated as one. This means you can paste data from spreadsheet columns, comma-separated logs, or space-delimited hex dumps without reformatting. Brackets and parentheses are stripped automatically to handle array notations like [72, 101, 108, 108, 111].

Binary auto-detection requires exactly 8 digits of 0s and 1s per token. A token like 101 (3 digits) is interpreted as decimal 101 (ASCII 'e'), not binary 5. To force binary parsing, either pad to 8 digits (00000101) or explicitly select the Binary input format. Similarly, 11111111 in binary equals 255 decimal, but in auto-detect mode a number like 11001100 could be misread if it also happens to be a valid decimal (it would be parsed as decimal 11001100, which exceeds 255 and would be flagged as invalid, causing the fallback to binary).