445 Bytes Is All It Takes to Draw the World

A developer just fit a recognizable map of the entire planet into less data than this sentence will take up. Iwo Kadziela, working with OpenAI’s Codex, built a credible ASCII world map from only 445 bytes of data, according to Simon Willison, who flagged the trick on his blog this week. That’s not a typo. Under half a kilobyte, and you get continents you can actually pick out.

What stands out here isn’t just the size. It’s how little code it takes to unpack it in a browser, using tools that are already built in.

🗺️ How it works

The magic comes down to two moves working together.

First, compression. Kadziela ran the map data through deflate, a standard compression algorithm that’s been around for decades and ships in basically everything. Squeezing an ASCII map down to 445 bytes is exactly the kind of repetitive, predictable data that deflate eats for breakfast.

Second, the delivery. The compressed bytes get embedded straight into the page as a base64 data URI, so there’s no separate file to fetch from a server. Then a short snippet of JavaScript pulls it apart on the fly:

• fetch() reads the data: URI directly, no network request needed
• The response body gets piped through DecompressionStream('deflate-raw'), a browser API that inflates the data
• The result is turned back into text and dropped into a <pre> block, styled with a tiny font so the whole map fits

The part that surprised even Willison: you can hand fetch() a data: URI and stream it through a decompression pipe like this. “I didn’t know you could use fetch() with data: URIs like this,” he wrote. That’s a working developer with deep browser knowledge learning a new trick from a 445-byte demo.

⚙️ Why it matters

This is a small hack, but it points at something bigger. DecompressionStream is a native browser API. No library, no npm install, no build step. If your app ships large blocks of text or predictable structured data, you can compress it, inline it, and let the browser inflate it at runtime for close to zero cost.

A few practical takeaways you can use right now:

• Inline compressed assets. For static data that doesn’t change often (lookup tables, ASCII art, config, sample datasets), deflate plus a base64 data URI removes an entire network round trip.
• Lean on native streams. DecompressionStream and CompressionStream are supported across modern browsers. You probably don’t need a JavaScript decompression library for common formats.
• Rethink your byte budget. If a whole world map fits in 445 bytes, the “it’s too big to inline” instinct is worth questioning more often.

There’s also a quieter story here about how the thing got built. Kadziela did this “assisted by Codex,” OpenAI’s coding model. This is the shape of a lot of small, clever engineering now: a person with a sharp idea, a model to grind through the fiddly parts, and a result compact enough to explain in a paragraph.

🔎 The fine print

Keep expectations calibrated. This is a demo, not a mapping library. 445 bytes buys you a rough ASCII outline, not accurate borders, labels, or anything you’d navigate with. The compression numbers work because ASCII map data is highly repetitive, so don’t assume the same ratio for arbitrary content. And data URIs have their own tradeoffs around caching and page weight if you overuse them.

Still, the lesson lands. The tools to do this have been sitting in the browser the whole time. Sometimes the interesting work is just wiring together pieces that were already there, and noticing what they can do.

You can find the full snippet and Willison’s notes at the original source.