About

Encoded data arrives in many numeral systems. A firmware dump yields hexadecimal byte streams. A network packet log shows octal values. A configuration file stores credentials in Base64. Misinterpreting the radix turns valid data into garbage. This converter accepts sequences encoded in Base 2 (binary), 8 (octal), 10 (decimal), 16 (hexadecimal), 32, 36, or 64 and reconstructs the original ASCII/UTF-8 text by parsing each token into its byte value, assembling a byte array, and decoding via the UTF-8 standard. It handles multi-byte Unicode sequences correctly, so codepoints beyond U+007F (such as é or 中) are reconstructed without corruption.

The tool auto-detects common delimiters (space, comma, newline) but allows manual override. Malformed tokens are flagged individually so you can locate errors in large payloads. Note: Base64 mode expects a continuous RFC 4648 string, not delimited numeric tokens. For bases 2 - 36, each delimited token must represent a single byte value in the range 0 - 255. Values outside this range trigger a per-token warning rather than silent truncation.

Formulas

For bases 2 through 36, each delimited token T is a positional numeral representing one byte. The decimal value of a token with digits d_n in base b is computed as:

V = n∑i=0 d_i ⋅ bⁱ

where d_i is the digit at position i (right to left, zero-indexed) and b is the radix. The result V must satisfy 0 ≤ V ≤ 255 to represent a single byte. Multiple bytes are assembled into an array and decoded as UTF-8.

For Base64, the algorithm maps each character to a 6-bit value via the RFC 4648 alphabet:

A - Z → 0 - 25, a - z → 26 - 51, 0 - 9 → 52 - 61, + → 62, / → 63

Every group of 4 Base64 characters produces 3 bytes (24 bits total). Padding characters (=) indicate fewer output bytes in the final group: one = means 2 bytes, two = means 1 byte.

Where V = decimal value of the token, b = base/radix, d_i = digit value at position i, n = number of digits minus one, T = input token string.

Reference Data

Base	Radix	Valid Characters	Byte Range	Example Token → Decimal	Common Use
Binary	2	0, 1	00000000 - 11111111	01001000 → 72	Firmware, digital logic
Octal	8	0 - 7	0 - 377	110 → 72	Unix permissions, legacy systems
Decimal	10	0 - 9	0 - 255	72 → 72	ASCII tables, char codes
Hexadecimal	16	0 - 9, A - F	00 - FF	48 → 72	Memory dumps, color codes, packets
Base32	32	0 - 9, A - V	0 - 7V	28 → 72	Compact encoding, Crockford IDs
Base36	36	0 - 9, A - Z	0 - 73	20 → 72	URL shorteners, compact IDs
Base64	64	A - Z, a - z, 0 - 9, +, /	N/A (stream)	SQ== → "H"	Email (MIME), JWT, data URIs
ASCII Reference (Printable Range)
Space	Dec 32		Hex 20	Bin 00100000	Whitespace separator
!	Dec 33		Hex 21	Bin 00100001	Exclamation mark
0	Dec 48		Hex 30	Bin 00110000	Digit zero
9	Dec 57		Hex 39	Bin 00111001	Digit nine
A	Dec 65		Hex 41	Bin 01000001	Uppercase A
Z	Dec 90		Hex 5A	Bin 01011010	Uppercase Z
a	Dec 97		Hex 61	Bin 01100001	Lowercase a
z	Dec 122		Hex 7A	Bin 01111010	Lowercase z
~	Dec 126		Hex 7E	Bin 01111110	Tilde (last printable)
DEL	Dec 127		Hex 7F	Bin 01111111	Delete control char
Multi-byte UTF-8 Boundaries
1-byte	0 - 127		00 - 7F	Leading bits: 0xxxxxxx	Standard ASCII
2-byte	128 - 2047		C0 - DF lead	Leading bits: 110xxxxx	Latin extended, accented chars
3-byte	2048 - 65535		E0 - EF lead	Leading bits: 1110xxxx	CJK, most world scripts
4-byte	65536 - 1114111		F0 - F7 lead	Leading bits: 11110xxx	Emoji, rare scripts

Frequently Asked Questions

A single byte can only represent values from 0 to 255. If a token parses to a value above 255, the converter flags that token as an error and replaces it with the Unicode replacement character U+FFFD (�) in the output. This prevents silent data corruption. If you are encoding multi-byte characters, each byte of the UTF-8 sequence must be a separate token. For example, the character "é" (U+00E9) is two UTF-8 bytes: 195 and 169 in decimal, which must appear as two separate tokens.

The converter scans the input for three candidate delimiters: space (U+0020), comma (U+002C), and newline (U+000A). It counts occurrences of each and selects the one with the highest frequency. If no delimiter is found (zero occurrences of all three), it falls back to treating the input as a continuous stream, which is appropriate for Base64. For hexadecimal without delimiters (e.g., '48656C6C6F'), select "None (continuous)" and ensure each byte is exactly 2 hex digits. Binary continuous mode expects 8-digit groups.

Base64 operates on a continuous stream, not on individual numeric tokens. The input must be a valid RFC 4648 string containing only characters A - Z, a - z, 0-9, +, /, and trailing = padding. Whitespace and newlines are stripped automatically. If the string length (after stripping) is not a multiple of 4, the converter pads with = characters as a best-effort fix but flags a warning. Common mistakes include pasting URL-safe Base64 (which uses - and _ instead of + and /); this converter handles standard Base64 only.

Yes. The converter assembles all parsed byte values into a Uint8Array and decodes it using the TextDecoder API with UTF-8 encoding. Multi-byte sequences are reconstructed correctly as long as each byte of the sequence is a separate token in the correct order. For example, the Chinese character "中" (U+4E2D) is encoded as three UTF-8 bytes: E4, B8, AD in hex. Entering these three tokens with a space delimiter produces the correct character.

This converter treats Base32 as a positional numeral system with radix 32 (digits 0-9, A - V), where each delimited token represents one byte value. This is distinct from RFC 4648 Base32 encoding (which uses A - Z, 2-7 and operates on 5-bit groups across a byte stream). The use case here is converting individual numeric representations, not decoding a Base32-encoded binary stream. If you need RFC 4648 Base32 stream decoding, use the Base64 mode analogy with appropriate alphabet mapping.

Control characters (bytes 0 - 31) are valid byte values and will be decoded. However, most are non-printable. The converter will display them in the output, but they may appear as blank or be invisible. Tab (decimal 9), newline (decimal 10), and carriage return (decimal 13) will render as whitespace. Others like NUL (decimal 0) or BEL (decimal 7) are shown but have no visual representation in the text output. The byte count in the statistics panel will still reflect their presence.