How do the variants differ, and when should I use each?

All four variants are Base85 encodings, but each uses a different 85-character alphabet and framing, so their output is not interchangeable — always decode with the same variant you encoded with. Adobe Ascii85 — printable ! through u , plus a z shortcut for four zero bytes and optional <~ ~> delimiters. This is the native encoding for PDF and PostScript binary streams. Z85 (ZeroMQ) — an alphabet chosen to avoid characters that break JSON, URLs, and shells. It is the common choice in Go and ZeroMQ message code. RFC 1924 — defined for compact IPv6 address text. It treats the input as one big integer. btoa / Base64 — the web-standard Base64 (33% overhead), included so you can compare sizes side by side.

What does the z character do in Adobe Ascii85?

In Adobe Ascii85, a lowercase z is a compression shortcut that stands for four consecutive zero bytes. Instead of writing !!!!! (the encoding of 0x00000000 ), a single z is used. It shrinks sparse or zero-heavy data even further. This tool emits z automatically when it encounters a zero group and decodes it back correctly — you'll see it called out in the status note when it happens.

Do I need the delimiters?

Only for the Adobe variant. The <~ and ~> markers tell PDF and PostScript parsers where the ASCII85 data begins and ends. Turn on Wrap with <~ ~> when the output will be consumed by a PDF or PostScript tool. When decoding, the tool accepts the delimiters either way — it strips them automatically if present.

Why is RFC 1924 output sometimes shorter than expected?

RFC 1924 encodes the input as one big integer , converting the entire byte sequence to base 85 in a single pass, rather than in fixed 4-byte groups. The result is fine for text and normal data. The one caveat is leading zero bytes: because they don't change the numeric value, they are not preserved when you decode back. This tool warns you when your input begins with a zero byte.

Is ASCII85 encoding free and private?

Yes. All four variants encode and decode locally in your browser, and the size stats are computed on the spot. Your text, files, and URLs never leave your device — no server upload, no logging, no tracking. It is a stateless local conversion.

ASCII85 / Base85 Encode & Decode — Adobe, Z85, RFC 1924 & btoa

Encode or decode across four Base85 variants — Adobe Ascii85 (PDF/PostScript), Z85 (ZeroMQ), RFC 1924 (IPv6) and btoa (Base64 for comparison) — with Base85's ~25% size advantage over Base64, file upload, and live size stats.

Result

InputVariantWrap with <~ ~>

What is ASCII85 / Base85 Encoder & Decoder?

ASCII85 (also known as Base85) is a binary-to-text encoding that represents 4 bytes as 5 printable characters — the most space-efficient common text encoding.

~25% overhead — versus Base64's ~33% and Hex's 100%, so it is the densest widely used option.

Four variants in one — Adobe Ascii85 (PDF/PostScript), Z85 (ZeroMQ), RFC 1924 (IPv6), and btoa (Base64) for a direct size comparison.

z zero-compression (Adobe) — the z character stands for four zero bytes, shrinking sparse data further.

Switchable — encode and decode with the same variant on both ends, or compare sizes across variants.

Zero-Server Tool Data Guarantee

All encoding, decoding, and size math run locally in your browser. Your text and files never leave your device — no server upload, no logging, no tracking.

How to Use

Pick a Variant

Choose Adobe Ascii85, Z85, RFC 1924, or btoa (Base64). The size stats show how much space each encoding uses.

Select Encode or Decode

Encode turns text or a file into the chosen variant; Decode turns it back into readable text.

Enter Input or Drop a File

Type, paste, or drop a text file. The output updates in real time.

Toggle Adobe Markers (optional)

For Adobe, enable '<~ ~>' delimiters to match what PDF and PostScript parsers expect.

Copy

Use the copy button to grab the encoded or decoded result.

Common Use Cases

PDF Binary Content

Encode images and fonts for embedding in PDF and PostScript using the Adobe variant.

ZeroMQ Message Payloads

Represent binary frames as Z85 text in ZMQ applications and Go services.

IPv6 Address Text

Express IPv6 addresses compactly with the RFC 1924 character set.

Size Comparison

Compare Base85's ~25% overhead against Base64's ~33% for the same input.

Compact Data Transfer

Squeeze binary into the smallest text form when bandwidth or storage matters.

Implementation Examples

JavaScriptAdobe Ascii85 (native, no library)

// Adobe Ascii85: 4 bytes -> 5 chars (~25% overhead); 'z' = 4 zero bytes
function adobeEncode(bytes) {
  const out = [];
  for (let i = 0; i < bytes.length; i += 4) {
    const chunk = bytes.slice(i, i + 4);
    let num = 0;
    for (let j = 0; j < 4; j++) num = (num * 256 + (chunk[j] || 0)) >>> 0;
    if (chunk.length === 4 && num === 0) { out.push('z'); continue; }
    const digits = [];
    for (let k = 0; k < 5; k++) { digits.unshift(num % 85); num = Math.floor(num / 85); }
    for (let k = 0; k < chunk.length + 1; k++) out.push(String.fromCharCode(digits[k] + 33));
  }
  return '<~' + out.join('') + '~>';
}

console.log(adobeEncode(new TextEncoder().encode('hello world')));
// "<~BOu!rD]j7BEbo7~>"

Base85 variants vs Base64

Encoding	Alphabet	Overhead	Primary Use
Adobe Ascii85	! to u + z	~25%	PDF, PostScript
Z85	0-9 a-z A-Z + 23 symbols	~25%	ZeroMQ, Go
RFC 1924	0-9 A-Z a-z + 23 symbols	~25%	IPv6 addresses
btoa (Base64)	A-Z a-z 0-9 + /	~33%	Web, email, APIs

Production Best Practices & Security

Use Adobe for PDF and PostScript — it is the native ASCII85 filter in these formats. Why:PDF viewers and PostScript interpreters expect the Adobe alphabet, the <~ ~> delimiters, and the z shortcut; other variants are not understood by them.

Use Z85 in Go and ZeroMQ apps — Z85 was designed to avoid characters that break JSON, URLs, and shells. Why:Its alphabet excludes ' and " and most unsafe punctuation, so Z85 strings fit cleanly into config files, JSON fields, and source code without escaping.

Use RFC 1924 for IPv6 address text — it was specified for compact IPv6 representation. Why:It treats the input as one big integer, so it is only truly lossless when leading zero bytes are absent; text and typical data round-trip cleanly.

Match the variant on both ends — the four variants use different alphabets. Why:Encoding with Adobe and decoding as Z85 produces completely wrong bytes; pick one variant and use it everywhere.

Prefer Base64 for broad compatibility — Base64 is built into every language and web platform. Why:ASCII85 needs a library in most languages and its punctuation must be escaped in strings; Base64 wins when interop matters more than the ~6% size saving.

Frequently Asked Questions

ASCII85 (also called Base85) is a binary-to-text encoding that turns 4 bytes into 5 printable characters. Because five base-85 digits can represent every 32-bit value, it only adds about 25% overhead for full blocks — the most space-efficient of the common text encodings.

By contrast, Base64 adds ~33% and hex doubles the size. The trade-off is that ASCII85 needs an 85-character alphabet and, depending on the variant, punctuation that may need escaping in source code.

All four variants are Base85 encodings, but each uses a different 85-character alphabet and framing, so their output is not interchangeable — always decode with the same variant you encoded with.

Adobe Ascii85 — printable ! through u, plus a z shortcut for four zero bytes and optional <~ ~> delimiters. This is the native encoding for PDF and PostScript binary streams.
Z85 (ZeroMQ) — an alphabet chosen to avoid characters that break JSON, URLs, and shells. It is the common choice in Go and ZeroMQ message code.
RFC 1924 — defined for compact IPv6 address text. It treats the input as one big integer.
btoa / Base64 — the web-standard Base64 (33% overhead), included so you can compare sizes side by side.

ASCII85 is more compact. It adds roughly 25% overhead versus Base64's ~33% — about 6% less for full blocks of data.

For a 10 MB binary file, ASCII85 produces about 12.5 MB of text versus Base64's 13.3 MB. The gap is modest per item but adds up for large PDFs, fonts, and embedded payloads, which is why Adobe chose ASCII85 for its document formats.

This tool's size stats show the exact overhead for your input, and the btoa variant lets you compare Base64 directly.