Question 1

What's the difference between ASCII and Unicode / UTF-8?

Accepted Answer

**ASCII** is a 7-bit encoding (0–127) covering English letters, digits, punctuation, and control codes. Every ASCII character fits in one byte. **Unicode** is a character SET, over 150,000 code points covering every script on Earth, emoji, math symbols, etc. **UTF-8** is the most common Unicode ENCODING: it represents code points U+0000–U+007F (ASCII range) as 1 byte (identical to ASCII), and higher code points as 2, 3, or 4 bytes using bit patterns. **So ASCII text encoded as UTF-8 is byte-identical to ASCII**. The difference matters when your input contains anything outside ASCII, "café" is 4 characters but 5 UTF-8 bytes (é = U+00E9 = 0xC3 0xA9). The tool encodes Unicode text as UTF-8 bytes by default; pure-ASCII input gives identical output either way.

Question 2

Why is binary always 8 bits per character?

Accepted Answer

**Bytes are the unit of storage**, modern computers address memory in 8-bit chunks. Even though ASCII fits in 7 bits, it's stored in 8-bit bytes with the high bit as 0 (or repurposed for extensions like Latin-1, code page 437, etc.). When you see binary like `01001000 01101001`, the spaces separate bytes. **UTF-8 byte counts vary**: ASCII chars = 1 byte; Latin/Greek/Cyrillic = 2; CJK = 3; emoji and rare scripts = 4. So "Hi" = 2 bytes = 16 bits; "😀" = 4 bytes = 32 bits. The tool shows the actual byte stream. If you only want 7-bit ASCII visualizations, strip the leading 0, but you'll break parsers expecting byte-aligned input.

Question 3

What are the non-printable ASCII codes (0–31, 127) for?

Accepted Answer

**Control characters** from the teletype era, most are obsolete but a few are everywhere. **0 NUL** terminates C strings. **7 BEL** rang a physical bell (now often a beep or silent). **8 BS** backspace. **9 HT** tab. **10 LF** newline (Unix line ending). **13 CR** carriage return (Windows uses CR+LF; old Mac used CR alone). **27 ESC** escape, prefix for ANSI escape sequences that color terminal text. **127 DEL** delete (originally the rubout character on punched tape, all-bits-set 0x7F). Most of 1–31 are unused in modern text; some terminals interpret them as commands. If you paste text with control characters into a UI input, results are unpredictable; most apps strip or display them as `^X` notation.

Question 4

What's the difference between `
`, `
`, and `` line endings?

Accepted Answer

**LF (`
`, byte 10)**: Unix, Linux, macOS (since OS X). Single character. **CRLF (`
`, bytes 13 + 10)**: Windows, HTTP headers, SMTP/email, many internet protocols. Two characters. **CR (``, byte 13)**: classic Mac OS pre-2001; obsolete except in legacy files. The convention difference comes from teletypes: CR returned the print head to the left margin, LF advanced the paper. Unix decided one byte was enough; Windows kept both. **Practical impact**: copying text between Windows and Unix can mangle line breaks. Git can auto-convert (`core.autocrlf`). For binary protocols (HTTP, SMTP), CRLF is mandatory, sending bare LF can confuse parsers. The tool shows the actual bytes, so you can see which convention your input uses.

Question 5

How can I tell if a byte stream is binary, hex, or something else?

Accepted Answer

**Binary** input: only `0` and `1`, length divisible by 8 (per character), optional separators (spaces, dashes). **Hex** input: only `0-9` and `a-fA-F`, length even, optional separators or `0x` prefix. **Octal** input: only `0-7`, often 3 digits per char (ASCII fits in 3 octal digits since 0–177). **Decimal**: digits 0-9, usually space-separated. **Base64** (different tool): `A-Z`, `a-z`, `0-9`, `+`, `/`, `=` padding; length divisible by 4. The tool's auto-detect uses these signatures. Ambiguous case: `1010` could be binary (= 10 = LF) or decimal (= 1010 = no ASCII match). When ambiguous, the tool defaults to the explicit mode you set or shows both interpretations.

Question 6

Is my text sent anywhere when I convert?

Accepted Answer

No. Conversion is pure JavaScript: `charCodeAt()` (or `TextEncoder` for UTF-8) → `.toString(2 | 8 | 16)` for each byte, joined with your chosen separator. The reverse: parse the digits → `String.fromCharCode` (or `TextDecoder`). All in the browser. Open DevTools Network during use: zero outbound requests. Text often contains secrets being inspected at the byte level (passwords with weird characters, suspect log fragments, copy-pasted error messages with embedded control codes); a tool that uploaded would be leaking those bytes by definition. Stays in your tab.

Question 7

What standards does Text to Binary / ASCII Codes validate against?

Accepted Answer

Text to Binary / ASCII Codes checks compliance with ASCII (ANSI X3.4), UTF-8 (RFC 3629).

Question 8

What are the limitations of Text to Binary / ASCII Codes?

Accepted Answer

UTF-8 multi-byte characters produce longer binary strings Does not support UTF-16 or UTF-32 encoding

Radix Name	Base	Digits / Byte	Example ('H')
Binary	2	8 bits	`01001000`
Octal	8	3 digits	`110`
Decimal	10	~3 digits	`72`
Hexadecimal	16	2 digits	`48`

Text to Binary / ASCII Codes

What is Text to Binary / ASCII Codes?

Frequently Asked Questions

Technical Deep Dive