Per-character binary encoder
Each character in each non-blank line becomes a binary number of at least 8 bits, space-separated within a line. Lines stay on their own lines so the output lines up one-to-one with the input. `a` (97) becomes `01100001`; a space (32) becomes `00100000`. Code points above 255 produce more than 8 bits (see next paragraph).
ASCII characters (0-127) fit cleanly in 8 bits. Latin-1 characters (128-255) also fit in 8 bits - `é` (233) becomes `11101001`. Above 255 - CJK characters like `中` (20013), mathematical symbols, most emoji - the binary is wider than 8 bits to fit the bigger number. The 8-bit padding is a minimum; it never truncates.
The encoding is per-character, not per-byte - `中` produces the raw binary of its code point (15 bits), not its UTF-8 byte sequence (3 bytes = 24 bits). For a byte-exact encoding, you need to UTF-8-encode the text first in another tool, then run the bytes through here.
How to use convert a text list to binary
- 1Paste your text into the input panel, one string per line
- 2Each character becomes at least 8 binary digits (wider for characters above code point 255), space-separated within a line
- 3Each input line stays on its own line - so one string per row stays paired up
- 4Copy the binary, or download it as a .txt file from the output panel
- 5Reverse the direction with Convert binary to text
Keyboard shortcuts
Drive ListShift without touching the mouse.
What this encoder actually does
No options - paste text, get binary per character (at least 8 bits, wider for characters above code point 255).
8-bit output for ASCII and Latin-1
Every character with code point 0-255 produces exactly 8 binary digits, left-padded with zeros where needed. `a` → `01100001`; space → `00100000`; `é` → `11101001`.
Wider output for higher code points
Characters above 255 (CJK, most emoji, mathematical symbols) produce as many bits as needed for their code point - no truncation. `中` → 15 bits. If exact 8-bit bytes matter, UTF-8-encode the text first.
Per-character, not per-byte
`中` is emitted as the raw binary of its code point (20013 → 15 bits), NOT its UTF-8 byte sequence (`11100100 10111000 10101101`). For byte-accurate UTF-8 binary, encode to bytes elsewhere first.
Line-preserving layout
Groups within a line are space-separated; newlines between input lines stay as newlines. Three input lines produce three output lines - keeps the decoder round-trip unambiguous.
Blank lines dropped
Empty and whitespace-only input lines do not produce empty output rows. A trailing blank in the paste does not leave a dangling empty line.
Worked example
Each character of each line becomes at least 8 binary digits (all sample characters are ASCII, so they fit in exactly 8); characters separated by spaces, lines preserved. Characters above code point 255 would produce wider groups.
apple banana cherry
01100001 01110000 01110000 01101100 01100101 01100010 01100001 01101110 01100001 01101110 01100001 01100011 01101000 01100101 01110010 01110010 01111001
Behavior reference
No user options. These are the fixed rules the encoder applies.
| Rule | What it does | Example |
|---|---|---|
| Per-character encoding | Each character becomes one binary group (8 bits minimum) | `a` (97) → `01100001` |
| 8-bit minimum padding | Values below 256 are padded with leading zeros to reach 8 digits | `\n` (10) → `00001010`, not `1010` |
| Non-Latin-1 widening | Values above 255 produce more than 8 digits (padding is a minimum, not a cap) | `中` (20013) → `100111000101101` (15 bits) |
| Group separator | Space between every encoded character within a line | `ab` → `01100001 01100010` |
| Line separator | Newlines between input lines are preserved in the output | Two input lines always produce two output lines |
| Blank lines (automatic) | Empty and whitespace-only input lines are skipped | Trailing blank line produces no extra output row |