A binary to text chart is a reference table that pairs each 8-bit binary value (00000000 through 11111111, or 0 through 255 in decimal) with the character that byte represents when the sequence is decoded strictly as bytes. The catch is that "the character it represents" only resolves to a single visible glyph when the byte sequence follows the UTF-8 encoding standard, and even then only some characters fit in one byte. ASCII letters and digits map to one byte and are easy to chart, but accented letters such as é take two bytes, the euro sign takes three, and most emoji such as 😀 take four. A usable binary to text chart therefore has to declare its grouping rule (exactly eight bits per byte, separated by single ordinary spaces), its target encoding (the WHATWG/Unicode UTF-8 standard, not 7-bit ASCII or Unicode code points), and its byte boundary handling (continuation bytes never stand alone). That is why the Text to Binary Converter treats the chart as a strict regex of eight-bit groups rather than a loose lookup of "bits to letters."
What a Binary to Text Chart Actually Shows
A typical binary to text chart is laid out in columns: the binary byte, the decimal value, the hex value, and the character the byte resolves to. The reader's task is normally the reverse: looking at a binary string like 01000001 and matching it back to "A". The chart works cleanly there because the letter A is the decimal value 65, which lives inside the ASCII range that fits in one byte. The complication begins when the chart promises to cover "any character," because no seven-bit or one-byte reference can cover é, €, or 😀.
For ASCII text, the chart is straightforward: 01001000 = H, 01100101 = e, 01101100 = l, 01101100 = l, 01101111 = o — five bytes for five characters. For non-ASCII text, the chart shifts from "one byte per row" to "multiple bytes per character." The two-byte sequence 11000011 10101001 is the UTF-8 encoding of é; the three-byte sequence 11100010 10000010 10101100 is €; the four-byte sequence 11110000 10011111 10011000 10000000 is 😀. The chart reader's job is the same — match eight-bit groups back to bytes — but the interpretation step changes from "this byte is a glyph" to "this byte may be a leading byte, a continuation byte, or a single-byte character."
Why One-Byte-per-Character Charts Are Misleading
Older charts that show "each letter has its own 8-bit code" are misleading once you leave the ASCII range. The phrase "binary to text" implies converting bits to characters, but in practice the conversion goes through bytes first. A chart that lists only single 8-bit binary numbers can correctly represent 256 distinct code points, and it will cover basic Latin letters, digits, common punctuation, and a handful of control characters. It will not cover é, €, or 😀. Anyone who relies on such a chart to "decode" a multi-byte UTF-8 sequence will misread continuation bytes as standalone characters and end up with gibberish or replacement symbols.
The error is not in the chart but in the implied contract. The "one character per byte" expectation only holds for ASCII. Beyond it, the WHATWG UTF-8 encoding standard lays out a precise set of patterns for the first byte of each sequence: 0xxxxxxx for one-byte characters, 110xxxxx for two-byte characters, 1110xxxx for three-byte, and 11110xxx for four-byte. Continuation bytes follow the pattern 10xxxxxx. These leading-bit patterns are themselves part of the binary to text chart; ignoring them turns decoding into guessing.
Reading an 8-Bit Byte Back to Text
Given a properly formatted binary string of eight-bit groups separated by single spaces, decoding to text is deterministic. The decoder reads the first group, inspects its leading bits, and decides whether it is a one-byte character, the leading byte of a multi-byte sequence, or a continuation byte. The MDN documentation for TextDecoder describes fatal UTF-8 validation, which means an invalid sequence — for example, a lone leading byte with no continuation — fails rather than being silently replaced. The Text to Binary Converter enforces the same rule. It reads groups exactly matching the regular expression [01]{8}( [01]{8})*, never trimming, padding, or guessing groups of the wrong length.
When the byte sequence is valid, the resulting text is what the original encoding produced — no extra interpretation layer. That round-trip property is what makes a strict 8-bit binary to text chart useful for protocol work, source-code analysis, and forensic byte inspection. A loose chart that interprets "any eight digits" as a code point will give a different answer for the same bytes and will break the round trip.
Byte Width Reference for Common Character Ranges
| Encoding width | Leading-byte pattern | Continuation bytes | Example character | Sample bytes |
|---|---|---|---|---|
| 1 byte (ASCII) | 0xxxxxxx | none | A | 01000001 |
| 2 bytes (Latin Extended, Greek) | 110xxxxx | 10xxxxxx | é | 11000011 10101001 |
| 3 bytes (BMP symbols, currency) | 1110xxxx | 10xxxxxx ×2 | € | 11100010 10000010 10101100 |
| 4 bytes (supplementary, emoji) | 11110xxx | 10xxxxxx ×3 | 😀 | 11110000 10011111 10011000 10000000 |
This table is the structural skeleton of any UTF-8 binary to text chart. The first column tells the reader how many byte groups belong to one logical character; the second and third columns define what those groups look like in binary; the example column gives a concrete character; the final column lists the exact byte groups the converter produces. The patterns are part of the WHATWG UTF-8 encoding standard and the Unicode Standard chapter on UTF-8 conformance, not arbitrary conventions. A practical note: even within ASCII, some byte values are control characters (0x00–0x1F and 0x7F) and may not print visibly. A chart that includes those rows is still accurate; a chart reader who pastes those bytes back into a decoder will see whatever the bytes encode, including line feeds, tab characters, and the byte 0x00 itself.
How to Use the Text to Binary Converter as a Live Chart
- Switch the converter to UTF-8 binary to text mode.
- Paste the exact eight-bit groups separated by one ASCII space — for example, 01001000 01100101 01101100 01101100 01101111.
- Select Convert. The tool validates the regular expression [01]{8}( [01]{8})*, runs a fatal TextDecoder, and either prints "Hello" or surfaces a clear error.
- For the reverse direction, switch to Text to UTF-8 binary, type Unicode text, and select Convert to see each byte printed as eight zero-padded bits joined by single spaces.
- Verify the byte count matches your expected chart entry, then copy the result to a system that preserves ordinary spaces exactly.
The encoder runs in the browser through the standards-based TextEncoder and emits every byte as exactly eight zero-padded binary digits. The decoder uses fatal UTF-8 validation, so a byte sequence that is structurally well grouped but semantically wrong — a lone leading byte without its continuation, an overlong form, a surrogate, or an out-of-range sequence — fails with a clear error rather than being replaced by the Unicode replacement character. The same strict 8-bit grouping rule governs both directions, so a round trip only succeeds when both sides respect it.
Common Chart-Reading Mistakes
Reading a binary to text chart correctly requires the same care the decoder requires. Three mistakes show up repeatedly when someone tries to map 8-bit binary back to text by eye.
The first mistake is treating each eight-bit group as an independent character. In strict UTF-8, two or more adjacent groups may jointly encode a single character. Reading the first group of é's encoding (11000011) as a character will produce a control character or a replacement glyph; the chart reader has to combine it with the next group (10101001) to recover é.
The second mistake is dropping spaces or adding commas between groups. A loose intermediate representation will still look like binary to the eye, but strict decoders reject it. If a chart row is copied from a webpage into a chat client or a word processor, ordinary spaces may be collapsed or line breaks inserted. A line-broken copy that re-joins with a missing space will fail decoding, even though every group is still eight bits.
The third mistake is trusting a chart generated for a different encoding. A "binary code alphabet A–Z" chart based on 7-bit ASCII will not match what UTF-8 encoding produces when the source text contains non-ASCII characters nearby. UTF-8 and 7-bit ASCII share the first 128 values, so the chart is correct for those letters — but applying the same chart to a French word that contains é will produce wrong output, because the byte stream around é includes continuation bytes the chart does not list.
When a Static Chart Isn't Enough
A binary to text chart is a sensible reference for the recurring ASCII letters, common punctuation, and the structural byte patterns for UTF-8 leading bytes. It is less useful when the text contains a long sequence of varied multi-byte characters, when the byte string came from a protocol or file rather than typed text, or when a single mistake in byte order will corrupt the whole decode. In those cases, the deterministic conversion path described in the WHATWG UTF-8 encoding standard is more reliable than any chart lookup. For a deeper byte-by-byte walkthrough, the UTF-8 byte walkthrough guide covers the leading-bit patterns in plain English, and the Hex to Text Converter follows the same fatal-validation approach but with two-digit hex groups instead of eight-bit binary groups.
The chart, in the end, is a teaching artifact: it shows the patterns and the examples, but the decoder does the actual work. Treating both as part of the same strict eight-bit convention keeps them aligned, and a binary to text chart built on that convention remains accurate for ASCII, accented Latin, CJK, symbol, and emoji text alike.
If you're weighing options, Text to Hex on Android Without Installing an App covers this in detail.