How this instrument works
Text on a computer is ultimately stored as binary — strings of 0s and 1s. Group those bits into bytes (8 bits each, for standard ASCII/Latin text) and each byte is really just a number written in base 2 instead of the base 10 you use every day: 01001000 in binary is the same value as 72 in decimal, and 72 is the ASCII code for the capital letter H.
Decoding a binary message is therefore a two-step lookup: first convert each byte from base 2 to its decimal value, then look that decimal value up in the same ASCII/Unicode code-point table an ordinary decimal ASCII converter uses. 01001000 01100101 01101100 01101100 01101111 converts byte-by-byte to 72, 101, 108, 108, 111, which decode to "Hello" — the identical result you'd get typing those decimal codes into a plain ASCII decoder.
Leading zeros in a binary byte don't change its value — 01001000 and 1001000 represent the exact same number — so this instrument accepts bytes typed as plain digit strings without requiring you to pad every byte out to 8 characters. It decodes a list of bytes you already have; it doesn't turn arbitrary free-text into binary, the same one-directional scope every code-based decoder on this site shares.
- Enter each character's binary byte as a string of 0s and 1s typed as a plain number (e.g. type 1001000 to mean the bit pattern 01001000).
- Separate multiple bytes with commas, spaces, or new lines — one byte per character you want decoded.
- Leading zeros can be dropped safely; 1001000 and 01001000 decode identically.
- Read Decoded text for the resulting string, built by converting each byte from base 2 and mapping it through the code-point table.
- Only 0s and 1s are valid digits in a byte — any other digit (2-9) will be rejected, since it can't represent a binary value.
Worked example — decoding 01001000 01100101 01101100 01101100 01101111
Type 1001000, 1100101, 1101100, 1101100, 1101111 (each byte with its leading zero dropped). Converting each from base 2: 1001000 -> 72, 1100101 -> 101, 1101100 -> 108, 1101100 -> 108, 1101111 -> 111. Looking those decimal values up in the ASCII table gives H, e, l, l, o — the decoded text reads "Hello".
A single byte works the same way at any length: 1000001 converts from base 2 to decimal 65, and code point 65 is the capital letter A. Whether you enter one byte or a whole sentence's worth, each one is decoded independently and then joined in order.
Questions
How do I convert a letter to its binary code by hand?
First find the letter's decimal ASCII code from a standard ASCII table (capital A-Z are 65-90, lowercase a-z are 97-122), then convert that decimal number to base 2 by repeated division by 2. For example, A is decimal 65, which is 1000001 in binary. This instrument does the reverse — binary in, text out — so you can check a hand conversion by feeding your binary answer back in and confirming it decodes to the letter you started with.
Why do I type 1001000 instead of 01001000 with the leading zero?
Leading zeros don't change a number's value in any base — 01001000 and 1001000 both equal the same 72 in decimal, exactly the way 007 and 7 are the same number in decimal. Since this instrument reads each entry as a plain number, typing the leading zero is optional and doesn't change the decoded result either way.
What happens if I type a digit other than 0 or 1 in a byte?
It's rejected — binary numbers can only contain the digits 0 and 1, so a value like 1092 (which contains a 9 and a 2) isn't a valid binary byte and can't be decoded. Double-check each byte only uses 0s and 1s; if you meant to enter a decimal ASCII code directly instead of a binary one, use a plain ASCII decoder rather than this binary-specific one.
Does each byte have to be exactly 8 bits?
No — this instrument reads whatever binary digit string you type as a base-2 number, regardless of length, so shorter bytes (with leading zeros implicitly dropped) decode the same as their 8-bit form. Standard ASCII text always fits in 8 bits per character (values 0-255), so in practice every valid byte you enter will be no longer than 8 significant binary digits once leading zeros are accounted for.
Can this decode binary for non-English characters or emoji?
It supports Unicode code points up to 65535, which covers accented Latin letters and many non-Latin scripts beyond plain ASCII, but not the higher-range "astral plane" code points that emoji and some rarer scripts use. For everyday English, European-language, and most alphabetic text, the supported range is more than enough.