Why does my Base100 decode fail with an "invalid symbol" error?

Strict decoding only recognizes the 256 code points from U+1F3F7 through U+1F4F6. The most common reason a decode fails is that the copied stream contains a variation selector (U+FE0F), a space, a line break, or an emoji outside the Base100 range — all of which chat apps, mobile keyboards, and rich-text editors can insert without changing how the stream looks on screen.

Can I format Base100 output with spaces or line breaks for readability?

No. The original Base100 format has no framing syntax — spaces, line breaks, and punctuation are not part of the encoding, and a conformant decoder rejects them rather than silently skipping them. If you need a human-readable Base100-style output, the only safe option is to copy the unbroken stream and apply your own formatting purely on the display side.

Why does one character in my input produce several emoji symbols?

Base100 maps UTF-8 bytes, not characters. A single ASCII character is one byte and produces one symbol, but non-ASCII characters require multiple UTF-8 bytes — accented letters typically use two, CJK characters and most emoji use three or four — and each byte becomes its own code point in the output.

Is Base100 a secure way to send a password?

No. Base100 is a reversible byte encoding with a public mapping documented in the original project repository. Anyone who receives the stream and knows the formula can recover the original bytes, and there is no checksum inside the stream to detect tampering. Use reviewed encryption and authenticated formats for any secrecy or integrity requirement.

What happens if I paste more than 500,000 bytes or symbols?

The tool enforces a 500,000-symbol or 500,000-byte cap on both encoding and decoding so that an accidental huge paste does not freeze the browser tab. Inputs at or below the cap process normally; larger inputs are rejected before conversion begins.

Base100 Encode Tips: Stop the Mistakes That Break Decoding

Base100 encoding maps each byte of UTF-8 text to exactly one Unicode code point in the range U+1F3F7 through U+1F4F6, where the output code point equals U+1F3F7 plus the byte value. This means byte 0 becomes U+1F3F7, byte 65 (the ASCII letter 'A') becomes U+1F438, and byte 255 becomes U+1F4F6 — one emoji-range symbol per input byte, with no padding, no delimiter, no checksum, and no semantic translation. Because the mapping is a pure byte-to-symbol substitution defined by the original Base100 project by Adam Niederer, any conformant decoder can reverse the stream into the original bytes and then into the original UTF-8 text. Most encode failures and silent decode errors come from a handful of recurring mistakes — pasted variation selectors, unflagged character-count assumptions, and confusion between bytes and user-perceived characters — all of which the strict Base100 Encoder / Decoder rejects rather than papering over with replacement characters.

base100 encode tips and common mistakes — Base100 Encode Tips: Stop the Mistakes That Break Decoding

How the Byte-to-Symbol Mapping Works

Base100 is a 256-symbol alphabet: every possible byte value from 0 through 255 has its own dedicated code point in the Unicode supplementary plane. The conversion is mechanical and has two stages. First, the encoder takes the input and converts it to UTF-8 bytes, because Base100 operates on bytes rather than on Unicode characters. Second, each byte b is mapped to the code point U+1F3F7 + b. The numeric formula is the whole algorithm; there is no lookup table, no key, and no transform beyond adding a constant offset.

Working through one example confirms the pattern. The ASCII letter 'A' is byte 65 in UTF-8, and 65 in decimal is 0x41. Adding that to U+1F3F7 (127,991 decimal) gives code point 128,056, which is U+1F438. Decoding the same symbol subtracts U+1F3F7 and recovers byte 65, then runs the bytes through a strict UTF-8 interpreter to get the letter 'A' back. Because the inverse is subtraction followed by fatal UTF-8 decoding, even a single out-of-range code point or an extra byte is enough to abort the conversion with an explicit error instead of returning a wrong character. The original Base100 reference implementation documents this same offset formula, and the WHATWG Encoding Standard defines the browser-side UTF-8 behavior at the text boundary.

Practical Tips for Clean Base100 Encoding

Six habits consistently produce output that decodes on the first try.

Encode from the original source. Re-encoding an already-encoded Base100 stream produces nonsense, because each symbol of the previous output is itself a multi-byte UTF-8 sequence that gets re-mapped rather than skipped.
Copy symbols as raw code points. Select the output with a tool that copies the exact Unicode code points rather than a screenshot or OCR pass, because every emoji-range symbol must remain in the U+1F3F7–U+1F4F6 range with nothing attached.
Keep track of bytes, not characters. A 100-character ASCII message becomes 100 symbols; a 100-character Chinese message becomes roughly 300 symbols because UTF-8 uses three bytes per CJK code point.
Treat the stream as opaque. Do not edit it by hand to "fix" what looks like an off symbol, because the visual appearance on your device may not match the underlying code point.
Stay within the 500,000-symbol limit. The tool enforces this on both directions to prevent the browser tab from freezing on accidental huge pastes.
Run encoding and decoding in the same tool when possible. The Base100 Encoder / Decoder uses the exact offset formula and fatal UTF-8 validation, which removes the drift that happens when you mix custom scripts and online converters.

Common Mistakes That Break Decoding

Most failed decodes are not mysterious — they fall into a small set of well-understood mistakes. Recognizing them before pasting saves a round trip and prevents a false sense of security from a stream that decodes to garbage text.

Mistake	What it looks like	How strict decoding responds
Variation selector (U+FE0F) inserted by a keyboard	Stream that renders identically but is one code point longer per symbol	Rejected: U+FE0F is outside the 256-symbol range
Spaces, line breaks, or punctuation added for readability	Stream grouped into lines of 10 or 20 symbols	Rejected: whitespace is not framing syntax in Base100
Code points outside U+1F3F7–U+1F4F6 pasted from a remix	Mixed set including U+1F600 or other emoji	Rejected: byte value would be negative or larger than 255
Treating it as encryption and "salting" the output	Symbols reordered, swapped, or substituted	Accepted syntactically but produces wrong text; no checksum warns you
Decoding a stream that was re-encoded mid-pipeline	Output looks emoji-ish but recovers garbage text	Rejected: the tool reports an error for invalid UTF-8 bytes instead of silently inserting replacement characters

The first three rows are by far the most common. Chat apps, mobile keyboards, and rich-text editors commonly append U+FE0F to colorize emoji-range symbols, and the resulting stream looks identical to the eye. A conformant decoder subtracts U+1F3F7 from every code point it reads, and U+FE0F is not in the table — so the conversion halts with an explicit error rather than producing a corrupted string. The same logic applies to a stray space, a line break pasted in from a code block, or any punctuation that did not exist in the original output. Empty input is rejected for the same reason: there are no bytes to map, and silently returning an empty result would hide the failure mode.

How to Encode and Decode With the Tool

The tool keeps both directions in one page so you do not have to flip between separate sites or maintain a local script.

Open the Base100 Encoder / Decoder in any modern browser — the conversion runs locally, so nothing is uploaded.
Choose Text to Base100, paste the UTF-8 text you want to encode, and run the encoder. Every UTF-8 byte is mapped to one symbol, and the output is a single continuous stream of code points in the U+1F3F7–U+1F4F6 range.
Copy the result with a plain-text copy action. Do not add spaces, line breaks, or variation selectors while copying; the mapping has no framing syntax, and the decoder will reject anything outside the 256-symbol alphabet.
To decode, switch to Base100 to text, paste the unmodified symbol stream, and run the decoder. Each code point must fall strictly inside U+1F3F7–U+1F4F6, the bytes are reconstructed by subtracting the offset, and a strict UTF-8 decoder rebuilds the original text.
If the decoder reports an error, the most common cause is a copied symbol whose code point is not in range — usually a variation selector from a chat app or a stray space from a formatted paste. Re-copy from the source stream and try again before assuming the original encoding was bad.

When Base100 Is the Wrong Tool

Base100 is good at one job, and recognizing when to reach for a different encoding matters as much as using it correctly. If the destination channel is ASCII-only — some legacy email systems, certain configuration fields, or URL forms that get percent-encoded by intermediaries — the emoji-range output will not survive transport intact, because intermediaries often escape or strip characters outside ASCII. For those cases, Base64, Base32, Base58, or hexadecimal is a better fit and will round-trip without emoji-range codepoints in the channel.

Base100 is also the wrong tool for any secrecy or integrity requirement. The mapping is public, documented in the original project repository, and reversible by anyone. There is no checksum inside a Base100 stream, so a syntactically valid reordering or substitution produces a different byte sequence with no warning at decode time. For passwords, tokens, or tamper detection, use reviewed encryption and authenticated formats such as the AES-256-GCM workflow or an HMAC digest alongside the encoded payload.

Cross-Platform Rendering and Copy Pitfalls

The mapping is mathematical and unaffected by how the symbols are drawn, but the path between "rendered glyph" and "preserved code point" is where most silent corruption begins. A given code point can appear as a colorful pictograph on one platform, a monochrome outline on another, and a tofu box on a third; in every case the underlying scalar value is the same, and a conformant decoder will still produce the correct byte. The risk is not rendering — it is the transformation that some apps perform during copy, save, or normalize steps.

iMessage, WhatsApp, Slack, and several mobile keyboards quietly append a variation selector (U+FE0F) to emoji-range symbols to force color rendering. Discord and certain Markdown editors wrap symbols in zero-width joiners or replace them with shortcodes. None of these decorations are part of Base100, and the strict decoder flags them as out-of-range code points rather than guessing. Treat any copied stream as suspicious until you have decoded it once successfully, and re-export from the original source whenever a decode fails for no obvious reason. A byte-exact walkthrough of that workflow is laid out in the Base100 Encode Safe: A Byte-Exact Workflow guide.

If you're weighing options, A Reliable Base64 Encode/Decode Alternative for Real Text covers this in detail.