Sample ZIP Generator
Generate a genuine ZIP archive in seconds — seven archive types, real DEFLATE compression, real CRC-32 checksums, correct Unicode filenames, and an exact target file size. Runs entirely in your browser.
Quick Tips for the Right Test Archive
Features
A Real Compressor Browsers Already Ship
This generator doesn't implement DEFLATE by hand, and it doesn't need to — the Compression Streams API puts a genuine DEFLATE implementation directly in the browser, the same one used internally for network compression, available to any page that asks for it. That's the same strategy Sample OGG uses for Opus and Sample MP4 uses for H.264: when a browser already ships a real, trustworthy implementation of something this hard to get right, this library reaches for it rather than reimplementing a compression algorithm from scratch.
The proof is in how it behaves on real content. Highly repetitive text compresses down to a small fraction of its original size, while genuinely random bytes barely shrink at all — sometimes coming out a few bytes larger than they went in, exactly the honest, well-known behavior of real DEFLATE encountering data it can't find any redundancy in.
The Other CRC-32
Every entry in a ZIP file carries its own CRC-32 checksum, computed over the uncompressed data, so an extractor can verify a file survived intact. It's worth naming directly that this isn't the same CRC-32 construction as Sample OGG's Ogg pages use — ZIP uses the standard reflected variant, polynomial 0xEDB88320, the same one PNG and gzip rely on, while Ogg's is a distinct non-reflected algorithm. Both are real, correct 32-bit checksums doing the same conceptual job; they simply process bits in a genuinely different order, which is why this generator implements each one separately rather than reusing a single CRC-32 routine everywhere.
A Format Built to Hold Other Formats
Every other generator in this library produces one self-contained stream — one audio track, one video, one document. ZIP is structurally different: it's a container for an arbitrary number of independent entries, each with its own name, timestamp, compression method and checksum, plus a central directory at the end that indexes all of them. Real folder hierarchies, genuinely empty directories, and filenames in whatever script a real user might type are all things a media format never has to think about, but a general-purpose archive format has to get right.
The DOS-era packed date and time stored in every entry is a small, genuine artifact of that history — a 2-second-resolution bitfield format ZIP has carried since long before most of the codecs elsewhere in this library existed, and still what a real unzip tool reads today for a file's modification time.
No Ignorable Bytes, So Padding Has a Name
Matroska has Void, ISO-BMFF has free, RIFF has JUNK — three real, spec-defined chunk types built specifically to be skipped. ZIP has nothing equivalent at the base format level, so growing an archive to an exact bigger target here means adding one real, visible file entry instead, sized precisely against ZIP's own fixed per-entry overhead so the final size lands exactly on target. It shows up in a directory listing like any other file, because that's the honest, available mechanism — the same category of choice Sample CSV and Sample JSON land on for the same underlying reason: no invisible option exists, so the visible one is used honestly.
Mixed Compression Is the Realistic Default, Not the Edge Case
It's tempting to assume a real ZIP either compresses everything or stores everything uniformly, but that's rarely how genuine archives get built. A photo library packed into a ZIP typically stores already-compressed JPEGs as-is — DEFLATE gains nothing squeezing an already-compressed image and can even grow it slightly — while genuinely compressible files like source code or logs get Deflated for real space savings. Mixed Compression here reproduces exactly that realistic pattern deliberately, rather than the artificially uniform case most naive test fixtures reach for.
Code that hardcodes a single expected compression method per archive, instead of reading each entry's own method flag independently, works perfectly against a uniform test file and then fails the moment it meets a real-world archive built the ordinary way. This is precisely the gap Mixed Compression is built to expose before production traffic does.
Who Actually Needs a Real Test ZIP
Backend developers validating an upload pipeline's archive handling need a genuinely compressed, correctly structured ZIP, since a folder of files renamed with a .zip extension fails a real central-directory parse immediately. Teams supporting international users benefit specifically from Unicode Filenames, since a filename encoding bug is often invisible in testing until a real accented or non-Latin name reaches production.
QA teams covering extraction end-to-end get more genuine coverage from working through several archive types deliberately than from one convenient file — a tool that handles Simple Files correctly can still choke on Nested Folders' real directory recursion, or on Empty Files & Folders' zero-byte edge cases, each exercising a different part of a real unzip implementation. Running all seven types through the same pipeline before shipping catches far more real bugs than one archive ever could.
Where This Archive Generator Stops
This generator produces standard ZIP with DEFLATE and Stored entries — the two methods every real ZIP tool supports — not the newer, less universally supported compression methods some archivers add as extensions. It also doesn't encrypt entries or add a password, since that would misrepresent what a plain test archive actually is, and it produces synthetic sample content rather than a bundle of real user files, the same honest scope every content-generation tool in this library shares.
Stating that boundary plainly matters here specifically because ZIP is so often the container of choice for actual malware delivery in the real world — this generator is deliberately nowhere near that territory, producing only clearly labeled, synthetic test content with no executable payloads of any kind.