A simple binary decoder
Paste whitespace-separated binary numbers, get characters back. Each space-separated group is parsed as a base-2 integer and mapped to a character; newlines in the input become newlines in the output, so one line of binary gives one line of text.
Groups do not have to be 8-bit bytes - 5-bit teaching examples or 16-bit values work too. `01001000` decodes to `H`; `101` decodes to character 5 (a non-printing control char); `0100000` decodes to a space.
Values `0-127` give plain ASCII. Values `128-255` map into the Latin-1 Supplement block (`é`, `ñ`, `©`, etc.). Values above 255 continue into the rest of the Basic Multilingual Plane (`Ā`, `中`, and so on). `€` (U+20AC = 8364) is above 255 and needs more than 8 bits.
One thing the decoder does NOT do: assemble UTF-8 byte sequences. A group like `11000011 10101001` (UTF-8 for `é`) decodes as two separate Latin-1 characters (`é`), not as one `é`. For UTF-8 round-trips, decode the bytes elsewhere first. Invalid or partial input - like `01010101xyz` - is parsed up to the first non-binary character, so you get `U` (from `01010101`). A fully non-binary group may decode to an invisible character or be dropped by whatever renders the output; either way, there is no error banner.
How to use convert a binary list to text
- 1Paste your binary data into the input panel - one logical string per line, groups separated by whitespace
- 2Output updates live; each input line becomes one decoded output line
- 3Copy the decoded text or download it as a .txt file from the output panel
- 4To re-encode text back to binary, use the text-to-binary tool
Keyboard shortcuts
Drive ListShift without touching the mouse.
What this decoder actually does
No options - paste binary, get characters back.
Any-length bit groups accepted
No 8-bit enforcement. `101` decodes to character 5; `0100000` to a space; `01001000` to `H`. Useful for textbook examples with 5- or 6-bit groupings, not just canonical bytes.
Whitespace separates groups; newlines separate rows
Any run of spaces or tabs between groups counts as one separator. Newlines are structural - each input line produces exactly one output line.
UTF-8 multi-byte sequences are not assembled
Each group decodes to one character. `11000011 10101001` gives two separate characters (`Ã`, `©`), not one `é`. For UTF-8 round-trips, decode the bytes elsewhere first.
Invalid input is parsed permissively
`01010101xyz` decodes to `U` (the `01010101` part). A fully non-binary group may decode to an invisible character or be dropped in the output. Either way, no error is shown - invalid input quietly produces odd results.
Runs in your browser
Decoding is client-side JavaScript. The binary never leaves your device - matters when decoding something from logs, memory dumps, or CTF challenges.
Worked example
Two lines of whitespace-separated bytes decode to two lines of text.
01001000 01100101 01101100 01101100 01101111 01010111 01101111 01110010 01101100 01100100
Hello World
Behavior reference
There are no user-adjustable options. These are the fixed rules the decoder applies.
| Rule | What it does | Example |
|---|---|---|
| Group splitting | Any whitespace (space, tab, multiple spaces) separates groups within a line | `01001000 01100101` decodes the same as `01001000 01100101` |
| Group length | No 8-bit enforcement; any length of binary digits is accepted | `101` → character 5; `0100000` → space |
| Row separation | Newlines separate output rows - one input line always yields one output line | Two lines of bytes produce two lines of text |
| Character mapping | Each integer becomes one character (values 0-255 cover ASCII + Latin-1) | `11100100` (228) → `ä`; `100111000101101` (20013) → `中` |
| Partial-match parse | Parsing stops at the first non-binary character | `01010101xyz` → `U` (only `01010101` was used) |
| Fully non-binary group | Quietly produces an invalid/invisible character, no error banner | `zzzz` → typically nothing visible in the output |
| Multi-byte UTF-8 sequences | Not assembled - each group is one character regardless of byte-pair patterns | `11000011 10101001` → `é` (two chars), not `é` (one char) |