Dart ZLibOption

last modified October 18, 2026

The ZLibOption class in Dart provides constants for zlib-based compression and decompression. It's used with the gzip and zlib codecs in the dart:io library.

ZLibOption defines the valid ranges and default values for compression level, strategy, memory level, and window bits. These values balance compression ratio, speed, and memory usage.

Basic Definition

ZLibOption is an abstract final class containing static integer constants. It cannot be instantiated.

The constants include minimum, default, and maximum levels, the supported compression strategies, and the window and memory bit ranges. They are passed directly to GZipCodec, ZLibCodec, and their encoders.

Default Compression

This example shows basic compression using default ZLibOption values.

import 'dart:io';
import 'dart:convert';

void main() {
  var data = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.';
  var compressed = gzip.encode(utf8.encode(data));
  
  print('Original: ${data.length} bytes');
  print('Compressed: ${compressed.length} bytes');
  print('Ratio: ${(compressed.length/data.length*100).toStringAsFixed(1)}%');
}

We compress text using default gzip settings. The default compression level is 6, providing a balance between speed and compression ratio.

$ dart main.dart
Original: 56 bytes
Compressed: 72 bytes
Ratio: 128.6%

Custom Compression Level

This example demonstrates setting a specific compression level.

import 'dart:io';
import 'dart:convert';

void main() {
  var data = List.generate(1000, (i) => 'Line $i\n').join();
  var levels = [1, ZLibOption.defaultLevel, ZLibOption.maxLevel];
  
  for (var level in levels) {
    var compressed = GZipCodec(level: level).encode(utf8.encode(data));
    print('Level $level: ${compressed.length} bytes');
  }
}

We test different compression levels on sample data. Level 1 is fastest, while level 9 uses the most CPU. The resulting size depends on the data, so benchmark before choosing a level.

$ dart main.dart
Level 1: 1903 bytes
Level 6: 1972 bytes
Level 9: 2000 bytes

Compression Strategy

This example shows how to set different compression strategies.

import 'dart:io';
import 'dart:convert';

void main() {
  var data = 'AAAAABBBBBCCCCC' * 100;
  var strategies = {
    'filtered': ZLibOption.strategyFiltered,
    'huffmanOnly': ZLibOption.strategyHuffmanOnly,
    'rle': ZLibOption.strategyRle,
    'fixed': ZLibOption.strategyFixed,
    'default': ZLibOption.strategyDefault,
  };
  
  for (var entry in strategies.entries) {
    var compressed = GZipCodec(strategy: entry.value).encode(utf8.encode(data));
    print('${entry.key}: ${compressed.length} bytes');
  }
}

Different strategies work better for different data patterns. Filtered works well for data produced by a filter or predictor, Huffman-only forces Huffman coding, and RLE limits match distances to one for runs of identical values.

$ dart main.dart
filtered: 46 bytes
huffmanOnly: 407 bytes
rle: 221 bytes
fixed: 43 bytes
default: 43 bytes

Window Bits Configuration

This example demonstrates setting window bits for different memory usage.

import 'dart:io';
import 'dart:convert';

void main() {
  var data = List.generate(10000, (i) => i % 256).join(',');
  var windowBits = [8, 12, 15];
  
  for (var bits in windowBits) {
    var compressed = GZipCodec(windowBits: bits).encode(utf8.encode(data));
    print('Window bits $bits: ${compressed.length} bytes');
  }
}

Window bits control the compression window size (history buffer). Larger windows can find more repetitions but use more memory. Default is 15 (32KB window).

$ dart main.dart
Window bits 8: 14367 bytes
Window bits 12: 648 bytes
Window bits 15: 648 bytes

Combined Options

This example shows combining multiple ZLibOption parameters.

import 'dart:io';
import 'dart:convert';

void main() {
  var data = List.generate(5000, (i) => 'Item ${i % 100}').join('\n');
  var options = {
    '1/rle': GZipCodec(level: 1, strategy: ZLibOption.strategyRle),
    '9/default': GZipCodec(level: ZLibOption.maxLevel, strategy: ZLibOption.strategyDefault),
    '6/window12': GZipCodec(level: ZLibOption.defaultLevel, windowBits: 12, memLevel: 5),
  };
  
  for (var entry in options.entries) {
    var compressed = entry.value.encode(utf8.encode(data));
    print('${entry.key}: ${compressed.length} bytes');
  }
}

We combine level, strategy, and window bits for different compression profiles. This shows how to fine-tune compression for specific requirements.

$ dart main.dart
1/rle: 17773 bytes
9/default: 439 bytes
6/window12: 439 bytes

Best Practices

• Default level: Use level 6 for good balance
• Text data: Try strategyDefault or strategyFiltered
• Binary data: Consider strategyRle for runs
• Memory: Reduce windowBits for constrained environments
• Testing: Benchmark different options for your data

Source

Dart ZLibOption Documentation

This tutorial covered Dart's ZLibOption class with practical examples showing compression configuration, performance tradeoffs, and optimization techniques.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Dart tutorials.