About

Binary-to-text decoding maps each group of bits to a character via its code point value. A single flipped bit produces the wrong character or an invalid code point entirely. This converter processes lists of binary strings - separated by spaces, commas, newlines, or tabs - and resolves each token to its decimal value d using positional notation, then maps d to the corresponding Unicode code point via fromCodePoint(d). Invalid tokens are flagged individually without aborting the batch. The tool assumes unsigned integer encoding with no leading-bit sign convention.

Standard ASCII occupies code points 0 - 127 (7-bit), while extended Unicode requires longer binary strings. If your binary values exceed 21 bits, they fall outside the valid Unicode range (max U+10FFFF) and will be rejected. Pro tip: if your source system uses fixed-width encoding (e.g., 8-bit bytes), enable the fixed-width validation option to catch truncated or padded tokens early.

Formulas

Each binary token B of length n bits is converted to its decimal code point d by positional expansion:

d = n−1∑i=0 b_i ⋅ 2ⁱ

where b_i is the bit at position i (counting from the right, starting at 0). The resulting decimal d is then mapped to a character c:

c = fromCodePoint(d)

The valid domain is 0 ≤ d ≤ 1114111 (i.e., 0x10FFFF), the maximum Unicode code point. Additionally, surrogate code points 0xD800 - 0xDFFF are excluded as they are reserved for UTF-16 encoding pairs and do not represent valid characters.

where d = decimal code point, n = number of bits, b_i = bit value at position i, c = resulting character.

Reference Data

Character	Decimal	Binary (8-bit)	Description
NUL	0	00000000	Null character
LF	10	00001010	Line Feed
CR	13	00001101	Carriage Return
SP	32	00100000	Space
!	33	00100001	Exclamation mark
0	48	00110000	Digit zero
9	57	00111001	Digit nine
A	65	01000001	Uppercase A
Z	90	01011010	Uppercase Z
a	97	01100001	Lowercase a
z	122	01111010	Lowercase z
~	126	01111110	Tilde
DEL	127	01111111	Delete control char
Á	193	11000001	Latin A with acute
ß	223	11011111	German sharp s
€	8364	10000010101100	Euro sign (14-bit)
世	19990	100111000010110	CJK character (15-bit)
😀	128512	11111011000000000	Grinning face emoji (17-bit)
💡	128161	11111010010100001	Light bulb emoji (17-bit)
@	64	01000000	At sign
#	35	00100011	Number sign / hash

Frequently Asked Questions

The converter validates each token against the pattern /^[01]+$/. Any token containing letters, digits other than 0/1, or special characters is flagged as invalid in the output table. It does not halt processing of remaining tokens.

Code points 128 - 159 (binary 10000000 - 10011111) are C1 control characters in Unicode. They are non-printable. If your source uses Windows-1252 encoding, those same byte values map to printable characters like curly quotes. This tool decodes strictly as Unicode code points, not Windows-1252.

UTF-8 is a multi-byte encoding where a single character can span 1 to 4 bytes. This tool treats each binary token as a complete code point, not a UTF-8 byte. To decode UTF-8, you must first concatenate the payload bits from each byte according to the UTF-8 continuation pattern (110xxxxx 10xxxxxx for 2-byte, etc.) before conversion.

The maximum valid Unicode code point is U+10FFFF which equals 1114111 in decimal, requiring 21 bits. Binary tokens longer than 21 bits will always exceed this limit and are rejected. Tokens of exactly 21 bits are validated against the 1114111 ceiling.

Auto-detection checks for newlines first, then commas, then tabs, then falls back to spaces. Ambiguity arises if your input uses spaces inside comma-separated values (e.g., 01001000, 01101001). In such cases, select the delimiter manually from the dropdown to override auto-detection.

Code points 0xD800 through 0xDFFF are reserved by the Unicode standard for UTF-16 surrogate pairs. They do not represent standalone characters. JavaScript's String.fromCodePoint throws a RangeError for these values. The converter catches this and flags the token as invalid.