Fact-checked by Grok 2 weeks ago

Deflate

Deflate is a lossless data compression algorithm and associated data format that employs a combination of the LZ77 dictionary algorithm for string matching and Huffman coding for entropy encoding to achieve efficient compression of general-purpose data streams.^[1] Designed by Phil Katz, it processes input data in blocks, supporting fixed or dynamic Huffman codes and uncompressed blocks for non-compressible data, with uncompressed blocks up to 65,535 bytes and dictionary distances up to 32,768 bytes.^[1] The format ensures bounded memory usage during decompression, making it suitable for streaming applications, and it is explicitly defined as patent-free to promote widespread adoption.^[1] Originally developed for integration into PKWARE's PKZIP archiving software starting with version 2.0 in 1993, Deflate quickly became the standard compression method for ZIP files due to its balance of compression ratio, speed, and simplicity. It was formally specified in RFC 1951 in May 1996 by L. Peter Deutsch, providing a precise, interoperable definition that has remained unchanged since version 1.1 of the specification.^[1] Beyond ZIP, Deflate powers compression in diverse formats and libraries, including the gzip utility for Unix-like systems, the zlib library for general-purpose compression, and the PNG image format for lossless image data.^[2]^[3] Its enduring popularity stems from fast decompression speeds—critical for web and file transfer scenarios—and compatibility across platforms, though modern alternatives like Zstandard offer tunable trade-offs in some contexts.

History

Origins and Development

The Deflate compression algorithm was developed by Phil Katz, founder of PKWARE, Inc., starting in 1991 as an enhancement to the compression capabilities of his PKZIP archiving software. Katz aimed to achieve superior compression ratios and efficiency compared to earlier methods employed in PKZIP, such as Shrink—a variant of the LZW algorithm used since the program's initial 1989 release—and Implode, which combined LZ77 with fixed Huffman coding but suffered from limitations like a smaller 8 KB sliding window. By integrating an improved LZ77 variant with dynamic Huffman entropy encoding, Deflate addressed these shortcomings, enabling better handling of diverse data types while supporting streaming compression suitable for archival applications.^[4]^[5] Deflate first appeared in an alpha version of PKZIP 1.93a, released in October 1991, where it was introduced experimentally as a "deflating" method. It was formalized and set as the default compression algorithm in PKZIP 2.04c, released on December 28, 1992, marking a pivotal upgrade that phased out reliance on patented or less efficient predecessors. This version of PKZIP solidified Deflate's role within the ZIP file format, which Katz had placed in the public domain in 1989, facilitating broad interoperability across archiving tools.^[5]^[6] Katz filed for a patent on the core string-searching and compression techniques underlying Deflate on August 21, 1990, which was granted as U.S. Patent 5,051,745 later that year and assigned to PKWARE. Early adoption accelerated in 1992, with the open-source Info-ZIP utilities incorporating Deflate support by August, followed by its integration into the gzip utility by Jean-loup Gailly and Mark Adler in October 1992 as a patent-free alternative to Unix's compress program. By the mid-1990s, Deflate's efficiency and lack of enforced licensing propelled its widespread use in ZIP-compatible archiving software, establishing it as a de facto standard for lossless data compression in personal computing and file transfer.^[7]^[5]^[8]

Patents and Licensing

The Deflate compression algorithm is covered by U.S. Patent 5,051,745, titled "String searcher, and compressor using same," granted on September 24, 1991, to inventor Phil Katz and assigned to his company, PKWARE, Inc. The patent specifically protects the combination of a variant of the LZ77 sliding window dictionary method with Huffman coding used in Deflate, focusing on an efficient string matching technique for data compression.^[7] The development of Deflate was influenced by legal challenges faced by Katz and PKWARE. In 1988, Systems Enhancement Associates (SEA), creators of the ARC archiving software, sued PKWARE for copyright and trademark infringement over Katz's earlier PKARC program, which was based on reverse-engineered ARC code. The lawsuit, settled in 1989, required Katz to discontinue PKARC and prompted the creation of the entirely new PKZIP format with proprietary compression methods, including the precursors and eventual implementation of Deflate in PKZIP version 2.0 (1991), designed to avoid further infringement claims.^[9] Initially, Deflate was proprietary to PKWARE, with implementations licensed through their software products like PKZIP. However, in 1996, the algorithm was formally specified in IETF RFC 1951 by L. Peter Deutsch, enabling standardized, royalty-bearing use during the patent term, as PKWARE did not actively enforce licensing fees for compliant implementations in open standards. The patent expired on September 24, 2008, after 17 years from issuance under pre-1995 U.S. patent law, transitioning Deflate to fully royalty-free status worldwide and allowing unrestricted implementation.^[6]^[7] The patent's protection facilitated early commercial adoption, including integration into Windows file compression utilities via PKZIP compatibility, which helped establish ZIP as a de facto standard for archiving. Post-expiration, the royalty-free availability significantly accelerated open-source development, exemplified by the widespread use of libraries like zlib (initiated in 1995 but unconstrained after 2008), boosting Deflate's role in formats such as PNG and gzip without legal barriers.^[6]

Algorithm

LZ77 Sliding Window

The LZ77 sliding window in the Deflate algorithm employs a history buffer of up to 32,768 bytes to identify and reference repeated sequences of data from prior input, enabling the substitution of duplicates with compact back-references rather than full literals.^[10] This window acts as a dictionary, sliding forward as new data is processed, with the encoder maintaining only the most recent 32 KB of uncompressed output to limit memory usage while capturing common redundancies in typical data streams.^[10] During compression, the algorithm advances through the input one byte at a time, searching the sliding window for the longest matching substring starting at the current position. If a match of at least three bytes is found, the encoder outputs a back-reference token consisting of a length-distance pair, where the length indicates the number of bytes to copy and the distance specifies the offset backward from the current position within the window. If no suitable match exists, a literal token representing the unmatched byte is emitted instead. This process continues iteratively, with the window updated by adding the newly processed byte after each step.^[10] Back-reference tokens are encoded using predefined code tables: lengths from 3 to 258 bytes are represented by 5-bit base codes (257–285) plus up to 5 extra bits for precision, while distances from 1 to 32,768 are encoded with 5-bit base codes (0–29) plus 0 to 13 extra bits depending on the range. Literals use 8-bit values for unmatched bytes (0–255). These tokens form the intermediate output stream, which is later entropy-encoded, but the LZ77 phase prioritizes redundancy elimination through these structured representations.^[10] To balance compression ratio and encoding speed, Deflate implementations apply heuristics such as greedy matching, which immediately selects the longest available match at each position, or lazy matching, which tentatively holds a match and checks subsequent positions for potentially longer ones before committing, often truncating the search after a few probes to avoid excessive computation. The maximum match length is capped at 258 bytes to align with code table boundaries, and back-references require a minimum length of three bytes to ensure net compression gain over literals.^[10] For efficient searching within the 32 KB window, encoders typically organize the history buffer using a chained hash table indexed on 3-byte sequences from recent data, prioritizing newer entries and limiting chain lengths to bound lookup time. This structure allows rapid identification of potential match starts without exhaustive scans, adapting to the window's size constraints while supporting real-time compression in resource-limited environments.^[10]

Huffman Entropy Encoding

In the Deflate algorithm, Huffman entropy encoding is applied to the sequence of symbols produced by the LZ77 compression phase, assigning variable-length prefix codes to these symbols to achieve further bit-level compression based on their estimated frequencies. This encoding leverages two primary approaches: static Huffman trees and dynamic Huffman trees. Static trees employ predefined, fixed Huffman codes for the literal/length alphabet (symbols 0-285) and the distance alphabet (symbols 0-29), providing a simple, unchanging mapping that avoids the overhead of transmitting tree definitions.^[11] In contrast, dynamic trees are constructed on a per-block basis, allowing adaptation to the specific frequency distribution of symbols within each block for potentially better compression efficiency.^[11] The symbols encoded by Huffman coding include literals (0-255, representing uncompressed byte values), the end-of-block marker (256), length codes (257-285, which specify match lengths from 3 to 258 when combined with extra bits), and distance codes (0-29, which indicate backward distances from 1 to 32,768 with extra bits). Code assignment follows the Huffman principle of allocating shorter binary codes to more frequent symbols, ensuring that the resulting prefix code set forms an instantaneous uniquely decodable code without ambiguity.^[11] This variable-length encoding minimizes the total bit cost by aligning code lengths inversely with symbol probabilities, typically reducing redundancy in the LZ77 output through optimal bit allocation.^[11] For dynamic Huffman trees, construction begins with tallying frequency counts for all relevant symbols based on their occurrences in the current block's data. These frequencies inform the generation of a canonical Huffman tree, where code lengths are determined via a Huffman-like procedure limited to a maximum of 15 bits per code, ensuring computational efficiency and bounded output size. The detailed process sorts the symbols by descending frequency, iteratively combines the least frequent pairs to build the tree (assigning code lengths accordingly), and then performs linear code assignment: symbols are ordered lexicographically within each code length group, with consecutive integer codes assigned starting from the shortest lengths.^[11] To transmit the tree compactly, the code lengths for the literal/length and distance alphabets are themselves compressed using a separate Huffman code over an alphabet of 19 symbols (0-18), incorporating repeat codes (16 for up to 3 identical lengths, 17 for up to 138 zeros, and 18 for up to 11 zeros) to exploit patterns in the length sequence and further reduce bits.^[11] The encoding process concludes each block with the end-of-block code (symbol 256), which is represented using the literal/length Huffman tree and signals the decoder to halt processing for that block. Any incomplete byte in the resulting bitstream is padded with zero bits to reach a full byte boundary, maintaining alignment for storage or transmission, with bits written in least-significant-bit-first order within each byte.^[11]

Stream Format

Block Structure

The DEFLATE stream consists of a sequence of blocks, each beginning with a 3-bit header that indicates whether it is the final block and specifies the compression method used. The header includes the BFINAL bit (1 bit), which is set to 1 if the block is the last in the stream and 0 otherwise, followed by the BTYPE field (2 bits), which encodes the block type: 00 for an uncompressed block, 01 for a compressed block using fixed Huffman codes, 10 for a compressed block using dynamic Huffman codes, and 11, which is reserved and treated as an error if encountered.^[10] Uncompressed blocks (BTYPE=00) provide a straightforward way to include raw data without compression, starting with LEN, a 16-bit unsigned integer specifying the length of the data (up to 65,535 bytes), immediately followed by NLEN, which is the one's complement negation of LEN for error detection. This is then followed by exactly LEN bytes of uncompressed data, with any remaining bits in the current byte ignored to ensure byte alignment. Such blocks are useful for data that does not compress well or for synchronization purposes, and their fixed maximum size limits the amount of literal data per block.^[10] Compressed blocks (BTYPE=01 or 10) have variable lengths depending on the input data and the Huffman encoding applied, allowing for efficient representation of compressible content using either predefined or dynamically generated code trees. The block structure enables streaming decompression, as each block can be processed independently without requiring knowledge of the entire stream in advance, which supports bounded-memory implementations and facilitates error resilience by allowing resets at block boundaries or mixing of different compression strategies across blocks. Unlike the zlib wrapper format, standard DEFLATE does not include a header for preset dictionaries, though distances in compressed blocks may implicitly refer to data before the stream start if a dictionary was used externally.^[10]

Code Representation

In the Deflate compressed data format, the payload within a block consists of a sequence of Huffman-coded symbols that represent either literal byte values or length-distance pairs derived from LZ77 matching. These symbols are drawn from a combined literal/length alphabet of 286 possible codes (0 through 285), where codes 0-255 directly encode literal byte values, and code 256 signals the end of the block.^[10] Codes 257-285 encode match lengths ranging from 3 to 258 bytes, each potentially augmented by 0 to 5 extra bits to specify the precise length within a range; for instance, code 257 represents a length of 3 with no extra bits, while code 285 represents a length of 258 with no extra bits.^[10] Distance codes form a separate alphabet of 30 symbols (0 through 29), encoding backward distances from 1 to 32,768 positions in the uncompressed data, with 0 to 13 extra bits providing the exact offset within broader ranges. For example, code 0 denotes a distance of 1 with no extra bits, whereas code 29 covers distances from 24,577 to 32,768, requiring 13 extra bits.^[10] These extra bits follow immediately after the Huffman code for the length or distance symbol and are read as unsigned integers.^[10] For dynamic Huffman blocks, the block payload begins with a header specifying the structure of the literal/length and distance trees: 5 bits for HLIT (indicating 257 to 286 literal/length codes used), followed by 5 bits for HDIST (1 to 32 distance codes), and 4 bits for HCLEN (4 to 19 codes in the code length alphabet).^[10] This header is followed by the code lengths for a fixed-order set of 19 code length symbols (0-18), which define a temporary Huffman tree used to decode the subsequent literal/length and distance tree descriptions.^[10] The code length alphabet includes symbols 0-15 for direct bit lengths (0-15 bits), with symbols 16-18 serving as repeat codes: 16 repeats the prior length 3-6 times (2 extra bits), 17 repeats zero 3-10 times (3 extra bits), and 18 repeats zero 11-138 times (7 extra bits).^[10] The literal/length and distance code lengths are then encoded using this temporary tree, in the predefined order for the 19 code lengths: 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15.^[10] The Deflate bitstream is packed into bytes with bits aligned from left to right, where each byte's least significant bit (bit 0) is the first bit of the stream, and the most significant bit (bit 7) is the last.^[10] Huffman codes are read starting from the most significant bit position, while non-Huffman elements like extra bits and block headers use least-significant-bit-first ordering within their fields.^[10] No explicit bit counts are stored beyond the block header fields, and the decoder processes the stream until the end-of-block code (256) is encountered.^[10]

Implementations

Software Libraries

The zlib library, developed in 1995 by Jean-loup Gailly and Mark Adler, serves as the reference implementation for the DEFLATE compressed data format specified in RFC 1951 and the zlib format in RFC 1950.^[12]^[10] It provides both compression and decompression functions, supporting nine compression levels from 0 (no compression) to 9 (maximum compression), allowing users to balance speed and compression ratio.^[13] Widely adopted, zlib is integral to image formats like PNG, where it handles DEFLATE compression for pixel data, and to web protocols such as HTTP, enabling gzip and deflate content encoding for efficient data transfer.^[12] PKZIP version 2.0, released by PKWARE in 1993, introduced the proprietary implementation of the DEFLATE algorithm as part of the ZIP file format for archiving and compression.^[14] While PKZIP remains a commercial tool from PKWARE, offering advanced features like encryption and large file support, the core DEFLATE specification has been publicly documented since 1993, and following the expiration of related patents in the early 2000s, open-source components and compatible encoders have proliferated.^[15]^[16] For high-performance applications, libdeflate, created by Eric Biggers in 2016, offers a heavily optimized DEFLATE, zlib, and gzip library that leverages SIMD instructions on x86 and ARM processors.^[17] It significantly outperforms zlib in both compression and decompression speeds—often by 2-3 times for decompression—while maintaining or improving compression ratios, particularly for single-buffer operations on modern CPUs.^[17] The library uses runtime CPU detection for architecture-specific code paths, making it suitable for compute-intensive tasks without zlib's API compatibility overhead.^[17] Specialized inflate-only libraries prioritize decompression efficiency for resource-constrained environments. Miniz, a single-file C library implementing zlib and DEFLATE standards, includes a compact decompressor (tinfl) designed for high speed and low memory use, commonly employed in game engines and embedded systems where quick asset loading is critical.^[18] Similarly, tinf provides a minimal inflate library for DEFLATE streams in zlib and gzip wrappers, adding only about 2 KB to program size and focusing on in-memory decompression for portable applications.^[19] As of 2025, the zlib-ng fork enhances zlib's performance for next-generation systems through CPU intrinsics like AVX2 and NEON, enabling better throughput in multi-core scenarios when paired with parallel tools like pigz for multithreaded compression.^[20]^[21] It maintains full compatibility with RFC 1951 while incorporating optimizations from prior forks, achieving up to 12% faster compression on x86_64 processors in recent releases. All these libraries adhere to the DEFLATE standard in RFC 1951, with many adding wrappers for zlib (RFC 1950) or gzip (RFC 1952) formats to ensure interoperability across tools and protocols.^[10]

Hardware Support

Dedicated hardware implementations of the Deflate algorithm have been developed primarily as application-specific integrated circuits (ASICs) and field-programmable gate array (FPGA) cores to accelerate compression and decompression in high-throughput environments such as networking and storage systems.^[22] One prominent example is Intel's QuickAssist Technology (QAT), integrated into Xeon Scalable processors starting from the 2nd generation in the 2010s, which provides on-chip acceleration for Deflate-based compression in network processing applications.^[22] QAT achieves up to 7.6 GB/s decompression throughput for Deflate at 4 KB block sizes on PCIe-based adapters like the QAT 8970, significantly outperforming software equivalents in latency and power efficiency.^[23] FPGA-based Deflate cores, such as those from AMD (formerly Xilinx), enable customizable acceleration for inline data compression in data center workloads.^[24] The Xilinx Gzip Compression IP core, which implements Deflate with LZ77 and Huffman stages, delivers up to 5.3 GB/s total compression throughput across eight cores on Alveo U50 FPGAs, supporting both gzip and zlib formats for containerized deployments.^[24] These cores are optimized for parallel processing in storage and networking pipelines, offering flexibility for high-volume data reduction without custom silicon redesign.^[24] Hardware decoders for Deflate are commonly integrated into storage controllers, particularly in solid-state drives (SSDs), to enable on-the-fly decompression and improve I/O efficiency by reducing data transfer volumes.^[25] For instance, enterprise SSD firmware often incorporates Deflate-compatible accelerators to handle compressed data streams directly, minimizing latency in read operations compared to host-side processing.^[25] This approach is prevalent in systems where compression ratios around 40-45% can be achieved at low overhead, enhancing overall storage bandwidth.^[23] Deflate encoders present greater hardware complexity due to the LZ77 stage's requirement for extensive string matching within a sliding window, often addressed through parallelization using multiple match finders to scan for redundancies concurrently.^[26] This parallel architecture mitigates the sequential search bottleneck, enabling pipelined operation in ASICs and FPGAs, though it increases resource utilization compared to simpler decompression paths.^[26] As of 2025, hardware Deflate decoders routinely achieve throughputs up to 10 GB/s in optimized configurations, such as in-storage ASICs, while multi-threaded software implementations on high-end multi-core CPUs can achieve total throughputs of around 13.6 GB/s for decompression using 88 threads (approximately 0.15 GB/s per thread).^[23] In mobile system-on-chips (SoCs) based on ARM architectures, Deflate extensions appear in dedicated accelerators for file archiving tasks, as seen in embedded processors integrating LZ77 and Huffman hardware to offload compression from the CPU cores.^[27]

Variants and Extensions

Deflate64

Deflate64 is a proprietary extension of the Deflate algorithm developed by PKWARE, Inc., designated as compression method 9 in the ZIP file format specification. It enhances the standard Deflate by expanding the LZ77 sliding window from 32 KB to 64 KB, enabling the capture of longer-range redundancies in data for improved compression efficiency on larger or more repetitive files. This variant maintains the core combination of LZ77 dictionary matching and Huffman coding but adjusts the distance representation to accommodate the doubled window size.^[28] The primary changes in Deflate64 involve extending distance codes to support up to 13 bits, allowing maximum match distances of 65,535 bytes. In the standard Deflate, distance codes range from 1 to 32,768 using up to 30 codes with 5 base bits plus extra bits; Deflate64 repurposes previously unused codes 30 and 31 for distances from 32,768 to 64,000 and adds extra bits (up to 13 for codes 28 and 29) to cover the full range precisely. Additional code lengths are defined for these extended distances in the Huffman tree construction. The stream format retains the same block structure as Deflate— including uncompressed, fixed Huffman, and dynamic Huffman blocks— but supports up to 32 distance codes (HDIST field) instead of 30, ensuring backward compatibility with standard Deflate decoders when extended features are not utilized.^[29]^[28] Deflate64 finds application in compressing large files, such as databases or archives with extensive repetitive structures, where the larger window yields modest compression ratio gains of around 1-5% over standard Deflate on suitable data. Microsoft Windows uses Deflate64 for ZIP compression when the uncompressed file size exceeds approximately 2 GB (2 × 1024³ bytes). Implementations are restricted primarily to PKWARE's tools, including PKZIP and the PKWARE Data Compression Library (DCL), with limited adoption in certain enterprise software for ZIP-based workflows; it lacks support in widely used open-source libraries like zlib or image formats such as PNG, due to its proprietary nature.^[30]^[31]^[32] Despite these benefits, Deflate64 incurs drawbacks including higher memory usage—requiring approximately 128 KB for the expanded history buffer and lookahead—and slower encoding times stemming from the larger search space during LZ77 matching.^[33]

Enhanced Deflate Methods

Enhanced Deflate methods encompass unofficial and experimental extensions to the core Deflate algorithm, primarily targeting improvements in compression ratio, speed, or adaptability for specific use cases like big data processing. These approaches often modify the LZ77 sliding window or Huffman entropy encoding stages while aiming to maintain compatibility with standard Deflate decoders where possible. Post-patent expiration in the late 2000s, such innovations proliferated, including optimized search strategies and integration with modern computational techniques.^[10] One prominent example is Google's Zopfli compressor, released in 2013, which enhances the LZ77 phase through exhaustive search over possible match lengths and distances, exploring a larger state space than standard implementations. This results in 3–8% better compression ratios on average compared to zlib at maximum level, though at the cost of significantly slower encoding times—up to 100 times slower for some inputs. Zopfli produces fully compatible Deflate streams, making it suitable for static content like web assets. Libdeflate, an open-source library developed since 2016, introduces software optimizations to both compression and decompression, including advanced hash chaining for faster LZ77 matching and SIMD instructions for Huffman coding acceleration. It achieves up to 2.5× faster decompression than zlib on x86 processors for certain workloads, while supporting tuned parameters like reduced window sizes for speed gains in real-time applications. These tweaks prioritize performance over maximal compression, with benchmarks showing 1.7–2.0× speedups in gzip decompression on large files. However, extending beyond the standard 32 KB window in non-standard modes risks decoder incompatibility.^[17] Research on LZ77 enhancements has explored adaptive techniques for big data, such as prefix-free parsing in PFP-LZ77 (2023), which builds a dictionary of unique substrings to improve parsing efficiency for genomic sequences, achieving linear time and space complexity. Similarly, external memory adaptations like SE_KKP enable LZ77 compression on datasets exceeding RAM, with I/O complexity of O(n/B) for disk-based processing, though practical disk usage can reach hundreds of GB for repetitive data like multiple genome copies. These methods, while not directly integrated into Deflate, inform experimental variants for handling post-2020 big data challenges. Modern experimental tweaks include SIMD-accelerated Huffman encoding in software, as proposed in a 2023 implementation using 512-bit AVX-512 instructions to parallelize code table lookups and bit merging, yielding up to 4× speedup in encoding throughput on Intel processors compared to scalar versions. Another frontier involves neural prediction for symbol frequencies, exemplified by AlphaZip (2024), which prepends transformer-based rank predictions to input data before standard Gzip (Deflate-based) compression, improving ratios by 57% over baselines on text corpora through better redundancy capture. Such neural integrations remain experimental as of 2025, limited by computational overhead. In production environments, Apache HTTP Server's mod_deflate module allows tuning of Deflate parameters, such as compression level (1–9), memory level (1–9), and window size (up to 15 bits, or 32 KB), enabling 20–70% bandwidth reductions for dynamic content with optimized settings. Post-patent innovations like Google's Brotli (2015), while distinct with its 256 KB window and context modeling, draw inspiration from Deflate's LZ77-Huffman foundation to achieve 20–26% better ratios on web content. Non-standard enhancements, however, pose interoperability risks; for instance, extended code lengths or windows beyond 32 KB may fail decoding in basic inflate implementations compliant with RFC 1951.^[34]^[35]^[10]

References

[1]
RFC 1951 DEFLATE Compressed Data Format Specification ver 1.3
This specification defines a lossless compressed data format that compresses data using a combination of the LZ77 algorithm and Huffman coding.
[2]
An Explanation of the `Deflate' Algorithm - Zlib
Apr 13, 2002 · The Deflate algorithm uses Huffman coding and LZ77 compression, which finds repeated sequences of data, to compress data.
[3]
PNG Specification: Deflate/Inflate Compression - libpng.org
Deflate compression is an LZ77 derivative used in zip, gzip, pkzip, and related programs. Extensive research has been done supporting its patent-free status.
[4]
Shrink, Reduce, and Implode: The Legacy Zip Compression Methods
Mar 12, 2021 · The original PKZip compression method is an LZW variant which Katz called Shrink. It was first released in a beta version, PKZip 0.80, and then ...
[5]
Zip Files: History, Explanation and Implementation - hanshq.net
Feb 26, 2020 · Deflate, introduced with PKZip 2.04c in 1993, is the default compression method in modern Zip files. It is also the compression method used in ...
[6]
History of Lossless Data Compression Algorithms
Jan 22, 2019 · DEFLATE was invented by Phil Katz in 1993 and is the basis for the majority of compression tasks today. It simply combines an LZ77 or LZSS ...
[7]
US5051745A - String searcher, and compressor using same
Methods and apparatus for string searching and data compression. In the string search method and apparatus pointers to the string to be searched are indexed ...
[8]
The gzip home page
Jul 27, 2003 · gzip was written by Jean-loup Gailly (jloup@gzip.org), and Mark Adler for the decompression code. gzip produces files with a .gz extension.
[9]
SEA vs. PKWARE - The BBS Documentary Library
During this time, Phil Katz created a new compression program, which was named for him by his friend Bob Mahoney (sysop of EXEC-PC BBS), who suggested "ZIP", ...
[10]
RFC 1951 - DEFLATE Compressed Data Format Specification ...
This specification defines a lossless compressed data format that compresses data using a combination of the LZ77 algorithm and Huffman coding.Missing: window | Show results with:window
[11]
RFC 1951 DEFLATE Compressed Data Format Specification - IETF
This specification is intended for use by implementors of software to compress data into "deflate" format and/or decompress data from "deflate" format. The text ...Missing: PKWARE licensing
[12]
zlib Home Site
May 4, 2025 · zlib was written by Jean-loup Gailly (compression) and Mark Adler (decompression). Jean-loup is also the primary author of gzip(1), the author ...Index of /fossils · Usage Example · Zlib 1.3.1 Manual · License
[13]
https://zlib.net/manual.html
[14]
Our History - PKWARE®
### Summary of PKZIP and Deflate History and Proprietary Status
[15]
PKWARE's APPNOTE.TXT - .ZIP File Format Specification
1.4.3 Certain technological components provided in this document are the patented proprietary technology of PKWARE and as such require a separate, executed ...
[16]
ZIP File Format (PKWARE) - Library of Congress
Nov 13, 2024 · The original version of the format was developed by Phil Katz (hence the "PK" in PKWARE). ZIP_PK combines data compression, file management, and ...
[17]
ebiggers/libdeflate: Heavily optimized library for DEFLATE/zlib/gzip ...
libdeflate is heavily optimized. It is significantly faster than the zlib library, both for compression and decompression, and especially on x86 and ARM ...Missing: Eric Biggers 2016 SIMD
[18]
richgel999/miniz: miniz: Single C source file zlib ... - GitHub
Miniz is a lossless, high performance data compression library in a single source file that implements the zlib (RFC 1950) and Deflate (RFC 1951) compressed ...Missing: decompression | Show results with:decompression
[19]
jibsen/tinf: Tiny inflate library (inflate, gzip, zlib) - GitHub
tinf is a small library implementing the decompression algorithm for the deflate compressed data format (called 'inflate'). Deflate compression is used in ...
[20]
zlib replacement with optimizations for "next generation" systems.
I decided to make a fork, merge all the Intel optimizations, some of the Cloudflare optimizations, plus a couple other smaller patches. Then started cleaning ...Zlib-ng · Minizip-ng · Issues 38 · SecurityMissing: multithreading throughput
[21]
zlib-ng/pigzbench: Test of parallel compression acceleration - GitHub
Parallel compression can use multiple cores available with modern computers to rapidly compress data. This technique can be combined with the CloudFlare ...Missing: throughput | Show results with:throughput
[22]
None
### Summary of Intel QAT Support for Deflate, Performance Metrics in GB/s, and Integration in Processors
[23]
ASIC-based Compression Accelerators for Storage Systems - arXiv
Sep 28, 2025 · The system integrates four distinct hardware compression architectures: two embedded Intel QAT-4xxx accelerators (one per CPU socket), an Intel ...
[24]
[PDF] Xilinx Gzip Compression User Guide | AMD
Xilinx Gzip compression application is a lossless data compression, based on the standard gzip application which is based on the DEFLATE algorithm, which is a ...
[25]
[PDF] Compression and SSD: Where and How? - USENIX
Compression is widely used in storage systems to reduce the amount of data that is written to physical storage de- vices, in order to improve both bandwidth ...
[26]
[PDF] Open-Source Parameterized Low-Latency Aggressive Hardware ...
May 11, 2021 · Deflate is a combination of LZ77 and Huffman encoding [17]. First, byte-aligned LZ77 compression is performed on the input data. Next, this ...
[27]
Lossless Decompression Accelerator for Embedded Processor with ...
In this paper, we propose a lossless decompression accelerator for an embedded processor, which supports LZ77 decompression and static Huffman decoding for an ...
[28]
APPNOTE.TXT - .ZIP File Format Specification - NET
Refer to the section in this document entitled "Incorporating PKWARE Proprietary Technology into Your Product" for more information. 4.3.10 Archive decryption ...Missing: 1999 | Show results with:1999
[29]
appnote.iz.txt - Unix-AG
- The sliding window size is 64k. - The previously unused distance codes 30 and 31 are now used to describe match distances from 32k-48k and 48k-64k. Extra Code ...
[30]
DCL - PKWARE Support
Best of breed data compression algorithms including: DCL IMPLODE, DEFLATE, and DEFLATE64. Highly optimized code and C interface for superior performance.
[31]
Frequently Asked Questions about zlib
Feb 7, 2024 · Does zlib support the new "Deflate64" format introduced by PKWare? I'm having a problem with the zip functions in zlib, can you help? The match.
[32]
How Windows decide whether to use Deflate or Deflate64 for ...
Sep 7, 2022 · Use the Deflate compression method. This is the standard compression and decompression algorithm used by the PKZIP 2.04g format.
[33]
mod_deflate - Apache HTTP Server Version 2.4
The mod_deflate module provides the DEFLATE output filter that allows output from your server to be compressed before being sent to the client over the network.Missing: enhanced parameters
[34]
google/brotli: Brotli compression format - GitHub
It is similar in speed with deflate but offers more dense compression. The specification of the Brotli Compressed Data Format is defined in RFC 7932. Brotli ...Releases 22 · Issues 61 · Pull requests 12 · Actions