About

Binary-to-text conversion maps sequences of 0s and 1s back to human-readable characters using a specific encoding table. A single misaligned bit shifts every subsequent byte, producing garbage output or silent data corruption. This tool parses raw binary input, auto-detects delimiters (space, comma, tab, or fixed-width), and decodes each 8-bit (or 16-bit) group into its corresponding code point using ASCII, UTF-8 multi-byte logic, or UTF-16 surrogate pair handling. It validates each byte boundary and flags malformed sequences rather than silently dropping them.

Manual conversion is error-prone past a few bytes. A single transposition in a 64-character binary string corrupts 8 characters of output. This converter processes inputs up to 1 MB with real-time feedback and highlights invalid bit groups individually. Note: the tool assumes big-endian byte order. If your source data uses little-endian encoding, reverse each 8-bit group before pasting.

Formulas

Each binary group is converted to a decimal code point, then mapped to its character representation.

char = fromCodePoint(parseInt(binaryString, 2))

For ASCII and single-byte encodings, each 8-bit group maps directly to one character. The decimal value d of an n-bit binary number is computed as:

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

where b_i is the bit at position i (counted from the right, starting at 0).

UTF-8 multi-byte detection follows these leading-bit patterns:

{

0xxxxxxx → 1 byte (ASCII, code points 0 - 127)110xxxxx 10xxxxxx → 2 bytes (code points 128 - 2047)1110xxxx 10xxxxxx 10xxxxxx → 3 bytes (code points 2048 - 65535)11110xxx 10xxxxxx 10xxxxxx 10xxxxxx → 4 bytes (code points 65536 - 1114111)

Where b_i = individual bit value, d = decimal code point, n = number of bits in the group, and x = payload data bits extracted from the multi-byte frame.

Reference Data

Character	ASCII Code	Binary (8-bit)	Hex	Description
NUL	0	00000000	0x00	Null character
TAB	9	00001001	0x09	Horizontal tab
LF	10	00001010	0x0A	Line feed (newline)
CR	13	00001101	0x0D	Carriage return
Space	32	00100000	0x20	Space character
!	33	00100001	0x21	Exclamation mark
0	48	00110000	0x30	Digit zero
9	57	00111001	0x39	Digit nine
A	65	01000001	0x41	Uppercase A
Z	90	01011010	0x5A	Uppercase Z
a	97	01100001	0x61	Lowercase a
z	122	01111010	0x7A	Lowercase z
~	126	01111110	0x7E	Tilde
DEL	127	01111111	0x7F	Delete control char
©	169	10101001	0xA9	Copyright sign (Latin-1)
€	8364	11100010 10000010 10101100	0x20AC	Euro sign (UTF-8: 3 bytes)
£	163	11000010 10100011	0xA3	Pound sign (UTF-8: 2 bytes)
¥	165	11000010 10100101	0xA5	Yen sign (UTF-8: 2 bytes)
@	64	01000000	0x40	At sign
#	35	00100011	0x23	Hash / Number sign
.	46	00101110	0x2E	Period / Full stop
,	44	00101100	0x2C	Comma
?	63	00111111	0x3F	Question mark
+	43	00101011	0x2B	Plus sign
=	61	00111101	0x3D	Equals sign
/	47	00101111	0x2F	Forward slash
\	92	01011100	0x5C	Backslash
{	123	01111011	0x7B	Left curly brace
}	125	01111101	0x7D	Right curly brace
[	91	01011011	0x5B	Left square bracket
]	93	01011101	0x5D	Right square bracket

Frequently Asked Questions

If the total bit count is not divisible by 8, the tool left-pads the final group with leading zeros to complete the byte. For example, the input 1000001 (7 bits) becomes 01000001, which decodes to the character "A" (ASCII 65). This matches the convention that a leading zero does not change the value. If you suspect the padding changes your intended meaning, verify the source data alignment.

The converter scans the input for spaces, commas, or tab characters. If any are found between binary groups, it splits on that delimiter. If no delimiters are detected, it assumes a continuous stream and splits into fixed 8-bit chunks (or 16-bit for UTF-16 mode). Override the auto-detection when your input uses an unusual separator like pipes or semicolons. In that case, pre-process the input to replace your delimiter with spaces before pasting.

ASCII mode treats every 8-bit group as an independent character with a code point between 0 and 127. Bytes with the high bit set (values 128 - 255) are decoded as Latin-1 extended characters. UTF-8 mode inspects the leading bits of each byte to determine if it is a single-byte character or the start of a multi-byte sequence (2, 3, or 4 bytes). Use UTF-8 when your source data contains non-Latin characters such as Cyrillic, CJK ideographs, or emoji.

Yes. Control characters (code points 0 - 31 and 127) are decoded and displayed using their standard abbreviations (NUL, SOH, STX, ETX, BEL, BS, TAB, LF, CR, ESC, DEL) inside labeled badges in the output. They are not rendered as invisible characters, which would make the output appear shorter than expected. The raw character is still present if you copy the output to clipboard.

This typically occurs when the encoding mode does not match the source data. If you paste UTF-8 encoded binary but the converter is set to ASCII mode, multi-byte lead bytes (e.g., 11000010) are interpreted as standalone Latin-1 characters instead of UTF-8 sequence starters. Switch to UTF-8 mode. Also verify byte order: this tool uses big-endian (most significant bit first). Little-endian sources require each 8-bit byte to be reversed before input.

The tool handles inputs up to approximately 1 MB of binary text (roughly 125,000 decoded characters). Conversion is O(n) where n is the number of bits. Inputs above 500 KB trigger a brief processing indicator. Beyond 1 MB, browser memory constraints on string manipulation may cause lag. For very large datasets, consider splitting the binary into chunks.