The study, published in Frontiers in Computer Science, evaluated LZW, Heatshrink, LZ4, FastLZ, and Miniz on an STM32U575ZI microcontroller running at 160 MHz, a chip equipped with 2 MB of Flash and 786 KB of SRAM. Rather than benchmarking on a desktop computer and extrapolating, the researchers compiled C implementations of each library and executed every compression test on the microcontroller itself, using the Arm DWT cycle counter for timing measurements with a nominal resolution of 6.25 nanoseconds.

The test workload was a 104,067-byte sensor dataset containing repetitive time-series measurements of soil and ambient temperature, humidity, battery voltage, timestamps, and identifiers collected by a wireless sensor network node. Crucially, the team stored this dataset in three different representations: a conventional comma-separated values (CSV) text file at 104,067 bytes, a binary format at 33,576 bytes, and a bit-packed binary format at 26,581 bytes. Each entry shrank from between 63 and 87 bytes in CSV to exactly 24 bytes in binary and 19 bytes (152 bits) in the bit-packed scheme.

The results expose a three-way tug-of-war. Miniz, which implements the DEFLATE algorithm combining LZ77-style back-references with Huffman entropy coding, produced the smallest compressed output of all: just 11,352 bytes when applied to the binary representation, reducing it to 33.81 percent of its original size. But that victory came at a cost. The Miniz configuration also recorded the longest compression time among minimum-output runs at 219 milliseconds and 512 microseconds, and the largest total application RAM requirement at 113,216 bytes once input and output buffers were included consistently.

At the opposite extreme, LZ4 with its acceleration parameter set to 16 delivered the fastest compression of the entire parameter sweep: 9 milliseconds and 437 microseconds on the bit-packed representation, producing a 25,692-byte output. LZ4 achieves this speed through hash-based match finding and a simple byte-aligned token format that minimizes branches and parsing overhead. When the researchers normalized total application RAM across all minimum-output configurations, including the common input and output buffers, algorithm static memory, and maximum stack usage, LZ4 operating on the bit-packed representation required the least memory at 58,496 bytes.

FastLZ emerged as a compelling middle ground. Among configurations selected for minimum compressed output, FastLZ on the binary representation achieved the shortest execution time at 31 milliseconds and 653 microseconds, producing a 17,591-byte output with 74,512 bytes of total application RAM. Heatshrink, an LZSS-style compressor designed specifically for small embedded systems, produced the second-smallest compressed output on the bit-packed representation at 13,941 bytes while requiring 58,740 bytes of RAM and compressing in 113 milliseconds and 335 microseconds.

One of the most striking findings concerns data representation rather than algorithm choice. Converting the CSV file to binary format before compression proved dramatically effective, since text encoding wastes bytes on ASCII characters that binary storage packs more densely. However, the bit-packed representation, despite being the smallest input, actually worsened compression effectiveness compared to ordinary binary. The researchers attribute this to reduced byte alignment and the loss of recurring byte-level patterns that the dictionary-based compressors rely on. When bits are packed across byte boundaries, the repetitive structures that LZ-family algorithms exploit become harder to detect.

The team also observed that Miniz compression levels 1 through 9 produced almost identical output sizes for this dataset, indicating that increased search effort yielded no additional compression on these inputs. LZW revealed an exponential memory curve: static RAM usage rose from 2,560 bytes with 9-bit codes to 327,680 bytes with 16-bit codes, because dictionary capacity grows as 2 raised to the code width. On the bit-packed representation, LZW with 16-bit code storage actually expanded the input, producing a compression ratio of 137.24 percent.

To connect compression to energy savings, the researchers developed a parametric model linking payload size to transmission time and transmit-state energy. Under hypothetical interface parameters of 9,600 bytes per second throughput, 3.3 volts, and 50 milliamperes transmit current, transmitting the original CSV payload would take 10.840 seconds and require 1.789 joules, whereas transmitting the Miniz-compressed binary output would take 1.183 seconds and require 0.195 joules. The model predicts a 66.19 percent reduction in transmission time and energy relative to the uncompressed binary representation, and 89.09 percent relative to the original CSV, though the authors emphasize these are illustrative calculations, not measurements.

The researchers have released their complete benchmarking framework publicly on GitHub, written in C, allowing other developers to evaluate the same five algorithms on their own application-specific datasets. Their conclusion is unambiguous: no single compression configuration wins on all three evaluated properties, so the algorithm and parameter setting must be chosen based on whether an application prioritizes smallest storage, fastest execution, or lowest memory footprint. The results are strongly dataset-dependent, and the team recommends that anyone building an embedded data-logging or transmission system run these tests on their own expected data structure before committing to a compressor.

Subject of Research: An experimental study evaluating LZW, Heatshrink, LZ4, FastLZ, and Miniz compression algorithms on an STM32U575ZI microcontroller across CSV, binary, and bit-packed data representations, measuring compression ratio, execution time, and total RAM consumption.

Article Title: Experimental evaluation of compression algorithms for memory-constrained embedded systems

Article References: Bača, T., Formanek, L., Ševčík, P., & Karpiš, O. (2026). Experimental evaluation of compression algorithms for memory-constrained embedded systems. Frontiers in Computer Science, 8, Article 1925314. https://doi.org/10.3389/fcomp.2026.1925314

Image Credits: AI Generated

DOI: 10.3389/fcomp.2026.1925314

Keywords: embedded systems, data compression, microcontrollers, LZ4, Miniz, DEFLATE, LZW, Heatshrink, FastLZ, STM32, Arm Cortex-M33, RAM usage

The central idea behind the research is deceptively simple: instead of relying on a single compression algorithm, chain two complementary techniques so that each one exploits the weaknesses left behind by the other. The first stage of both proposed schemes is a technique called Rounding Intensity Followed by Dividing, or RIFD, which was previously introduced by the same author in 2016. RIFD is a lossy operation that reduces the bit depth of an image by rounding pixel intensity values and then dividing them, which collapses many nearly identical gray levels into single representative values. This deliberate quantization shrinks the alphabet of symbols that the subsequent lossless coder has to handle, and it simultaneously reshapes the statistical distribution of those symbols, creating strong redundancies that entropy coders can harvest efficiently.

The two schemes differ in what happens after RIFD has done its work. The first, designated HLL1, feeds the preprocessed image into the Lossless Method of Decomposing Huffman Trees, abbreviated LM-DH, a technique first described by Alkhalayleh and Otair in 2015. Classical Huffman coding, invented by David Huffman in 1952, assigns shorter binary codes to more frequent symbols, but building and storing a single large Huffman tree for an image with many distinct intensity values can itself consume considerable space. LM-DH addresses this by decomposing the Huffman tree into smaller subtrees, which reduces the overhead of transmitting the coding table and improves the overall compression ratio. The second scheme, HLL2, pairs RIFD with the Lempel-Ziv-Welch algorithm, or LZW, the dictionary-based coder that Terry Welch derived from the foundational 1977 work of Jacob Ziv and Abraham Lempel and published in 1984. LZW builds a dictionary of recurring symbol sequences on the fly, so it needs no explicit code table to be sent alongside the compressed data.

To evaluate the two pipelines, the author ran experiments on a dataset of 20 standard test images spanning three common formats: 8-bit grayscale, 16-bit grayscale, and 24-bit RGB color. All processing was performed in MATLAB R2021b, a standard environment for image processing research, and the benchmark images were drawn from widely used public collections, including the CLIC dataset from the Challenge on Learned Image Compression, the USC-SIPI Image Database, the Kodak True Color Image Suite, and the Set11 collection of grayscale images used in reconstruction and compression studies. Using established public benchmarks matters, because it allows other researchers to reproduce the numbers and compare the new schemes directly against both classical baselines and modern learned codecs.

The headline result concerns how much better the hybrid schemes perform than their own lossless components alone. HLL1 produced an average improvement in compression ratio, measured as an ICR value, of 0.20 over the RIFD plus Huffman baseline, meaning that decomposing the Huffman tree into subtrees consistently squeezed out additional savings beyond what conventional Huffman coding could achieve on the same preprocessed data. HLL2 delivered an even more striking figure on the 8-bit grayscale datasets, where pairing RIFD with LZW yielded an average improvement of 73 percent. The author attributes this to the way RIFD’s bit-depth reduction creates long runs of repeated intensity values, precisely the kind of repetitive structure that dictionary-based LZW coding converts into short dictionary references.

Just as important as the size reductions is what the schemes do not cost in quality. Because the second stage of each pipeline is strictly lossless, it introduces no additional distortion whatsoever beyond the RIFD preprocessing step. In other words, once the image has been rounded and divided, every subsequent operation is perfectly reversible, so the decoded image is an exact replica of the preprocessed version. The perceptual integrity of the image is therefore determined entirely by how aggressive the RIFD quantization is, giving practitioners a single, tunable knob for balancing file size against visual fidelity. The study reports that the proposed techniques dramatically shrink file sizes without sacrificing perceptual quality, which makes them candidates for bandwidth-constrained and storage-limited environments where every kilobyte counts.

The work situates itself within a long tradition of hybrid compression research. Earlier studies have combined the discrete wavelet transform with set partitioning techniques and Huffman encoding, and medical imaging researchers have stacked linear predictive coding, wavelet transforms, and Huffman coding to compress clinical scans. More recently, the field has been transformed by learned compression, in which neural networks are trained end to end to transform and entropy-code images, with systems such as variational models with scale hyperpriors, discretized Gaussian mixture likelihoods with attention modules, unevenly grouped space-channel contextual adaptive coding, and latent diffusion approaches for compression all pushing the state of the art. Against this backdrop, the appeal of the new schemes is their computational simplicity: RIFD, Huffman tree decomposition, and LZW all involve elementary arithmetic and table lookups rather than deep network inference, which makes them attractive for hardware with tight power and processing budgets.

The technical logic of why the hybrids work is worth unpacking. Lossless entropy coders are bounded by the entropy of their input: the more skewed and repetitive the symbol distribution, the fewer bits per symbol they need. A raw 8-bit grayscale image often uses most of its 256 possible values with a relatively flat distribution, which limits any lossless coder working alone. RIFD deliberately flattens fine distinctions between neighboring intensities, concentrating probability mass on a smaller set of representative values. For Huffman-style coding, this means shorter average code lengths and, with LM-DH, a smaller tree structure to serialize. For dictionary coding, it means the same intensity values recur in predictable spatial patterns, so the LZW dictionary fills with long, frequently reused phrases. The lossy step thus acts as an amplifier for the lossless stage, and the two designs test two different ways of cashing in that amplification.

The practical implications reach across several domains. Telemedicine systems transmitting diagnostic images over rural networks, remote sensing platforms downlinking satellite imagery, digital archives preserving vast image collections, and consumer services serving billions of photos all face the same trade-off between bandwidth, storage cost, and image fidelity. A method that can be tuned by adjusting a single quantization parameter, that runs quickly on ordinary hardware, and that guarantees no hidden loss beyond the explicitly chosen quantization offers a predictable and auditable alternative to opaque neural codecs. The fact that the study used only public datasets, including CLIC, USC-SIPI, Kodak, and Set11, and performed all experiments in a widely available MATLAB release further lowers the barrier for independent verification and adoption.

There are, of course, boundaries to what the study claims. The reported gains are averages over 20 standard test images in three bit-depth formats, and performance on any particular image class, such as noisy medical scans or highly textured natural photographs, would need separate validation. The comparison baselines are the author’s own RIFD plus Huffman configuration rather than the newest learned codecs, so the schemes should be understood as an efficient classical alternative rather than a replacement for state-of-the-art neural compression at the very highest performance frontier. Nevertheless, the paper demonstrates a clear and reproducible principle: a carefully designed lossy preprocessing step can unlock substantial extra performance from decades-old lossless algorithms, and the choice of the lossless partner, whether a decomposed Huffman tree or an adaptive LZW dictionary, meaningfully shapes where the biggest wins appear. As image volumes continue to explode, such pragmatic hybrids may prove that some of the best new tools for an old problem are clever recombinations of proven ones.

Subject of Research: Hybrid lossy-lossless image compression using RIFD preprocessing with Huffman tree decomposition and LZW coding

Article Title: Hybrid image compression techniques based on RIFD with LM-DH and LZW

Article References: Otair, M. (2026). Hybrid image compression techniques based on RIFD with LM-DH and LZW. Multimedia Tools and Applications, 85(9), Article 741. https://doi.org/10.1007/s11042-026-21902-6

Image Credits: AI Generated

DOI: 10.1007/s11042-026-21902-6

Keywords: image compression, hybrid compression, RIFD, Huffman coding, LM-DH, LZW, lossless coding, lossy compression, entropy coding, MATLAB, grayscale images, Multimedia Tools and Applications