High-performance Zstandard compression for Node.js and browsers with zero external dependencies
- 🚀 Universal compatibility - Works seamlessly in Node.js 18+ and modern browsers
- 📦 Zero external assets - All WebAssembly code bundled internally, works out of the box
- 🌊 True streaming support - Handle multi-GB files with minimal memory footprint
- ⚡ Backpressure handling - Efficient memory management prevents overflow
- 🎯 Client-side optimization - Reduce server load by compressing/decompressing in the browser
- 🔧 ESM-first - Modern ECMAScript modules with full TypeScript support
- 📊 Progress tracking - Monitor compression/decompression in real-time
Built on the latest Zstandard v2 compression algorithm, zstd-stream is one of the only packages that embeds all WASM code internally, eliminating asset management headaches and enabling true plug-and-play compression.
npm install zstd-streamimport { compress, decompress } from "zstd-stream";
// Compress text
const text = "Hello, world!";
const input = new TextEncoder().encode(text);
const compressed = await compress(input, { level: 3 });
// Decompress
const decompressed = await decompress(compressed);
const output = new TextDecoder().decode(decompressed);
console.log(output); // "Hello, world!"✅ Use this for large files - Processes data in chunks with constant memory usage.
import { compressStream, decompressStream } from "zstd-stream";
// Compress a stream
const textStream = new ReadableStream({
start(controller) {
controller.enqueue(new TextEncoder().encode("Large text data..."));
controller.close();
},
});
const compressedStream = await compressStream(textStream, { level: 5 });
// Decompress a stream
const decompressedStream = await decompressStream(compressedStream);
// Read the result
const reader = decompressedStream.getReader();
let result = "";
while (true) {
const { done, value } = await reader.read();
if (done) break;
result += new TextDecoder().decode(value);
}
console.log(result);import { compressStream } from "zstd-stream";
import streamSaver from "streamsaver";
// User selects a file
const file = document.querySelector('input[type="file"]').files[0];
const fileStream = file.stream();
// Compress the file
const compressed = await compressStream(fileStream, {
level: 9,
onProgress: (bytes) => {
console.log(`Compressed: ${(bytes / 1024 / 1024).toFixed(2)} MB`);
},
});
// Save to disk as .zst
const fileWriteStream = streamSaver.createWriteStream(`${file.name}.zst`);
const writer = fileWriteStream.getWriter();
const reader = compressed.getReader();
while (true) {
const { done, value } = await reader.read();
if (done) break;
await writer.write(value);
}
await writer.close();import { compressStream } from "zstd-stream";
// Get file from user input
const file = document.querySelector('input[type="file"]').files[0];
const fileStream = file.stream();
// Compress and upload
const compressed = await compressStream(fileStream, { level: 6 });
const response = await fetch("https://api.example.com/upload", {
method: "POST",
headers: {
"Content-Type": "application/zstd",
"Content-Encoding": "zstd",
},
body: compressed,
duplex: "half", // Required for streaming request bodies
});
if (response.ok) {
console.log("Upload complete!");
}Compress data in one operation. Best for small files.
Parameters:
input: Uint8Array- Data to compressoptions?: CompressOptionslevel?: number- Compression level (1-19, default: 3)onProgress?: (bytesWritten: number) => void- Progress callback
Returns: Promise<Uint8Array>
const compressed = await compress(data, { level: 9 });Compress a readable stream. Best for large files.
Parameters:
input: ReadableStream<Uint8Array>- Stream to compressoptions?: CompressOptionslevel?: number- Compression level (1-19, default: 3)onProgress?: (bytesWritten: number) => void- Progress callback
Returns: Promise<ReadableStream<Uint8Array>>
const compressed = await compressStream(fileStream, { level: 5 });Decompress data in one operation.
Parameters:
input: Uint8Array- Compressed dataoptions?: DecompressOptionsonProgress?: (bytesWritten: number) => void- Progress callback
Returns: Promise<Uint8Array>
const decompressed = await decompress(compressed);Decompress a readable stream with backpressure support.
Parameters:
input: ReadableStream<Uint8Array>- Compressed streamoptions?: DecompressOptionsonProgress?: (bytesWritten: number) => void- Progress callback
Returns: Promise<ReadableStream<Uint8Array>>
const decompressed = await decompressStream(compressedStream);Pre-initialize the WASM module (optional). Call during app startup to avoid initialization delay on first use.
Returns: Promise<void>
await initialize();Levels 1-19 are supported. Higher levels provide diminishing returns.
| Level | Speed | Ratio | Use Case |
|---|---|---|---|
| 1-3 | Fast | Lower | Real-time, network streaming |
| 3-7 | Medium | Balanced | General purpose (recommended) |
| 8-15 | Slow | Better | File storage, archival |
| 16-19 | Very slow | Maximum | One-time compression, cold storage |
Default level: 3 (optimal balance of speed and compression)
- Chrome/Edge 80+
- Firefox 113+
- Safari 16.4+
- Node.js 18+
Requires WebAssembly and ES2022 support.
Full type definitions included:
import type { CompressOptions, DecompressOptions } from "zstd-stream";
const options: CompressOptions = {
level: 9,
onProgress: (bytes) => console.log(`Progress: ${bytes}`),
};MIT
Built with Zstandard by Meta, compiled using Emscripten SDK.
WebAssembly module embedded internally for zero-dependency deployment.