18th August 2026, 8 min read

Performance Comparison: gzip vs Brotli vs Zstd

This is a continuation of the post Performance Comparison: gzip vs Brotli three years ago. Here we will present measurements for three compression algorithms (gzip, brotli, and zstd) employed on two different hardware architectures (AMD and ARM). The measurements cover all possible compression levels. Input data are all HTML files used on this blog. These were 793 HTML files in total.

1. NGINX and compression

The NGINX web-server offers HTTP compression. The compression algorithms in question are:

1. gzip
2. deflate
3. Brotli
4. Zstd

My current nginx.conf file uses

gzip on;
brotli on;

gzip_comp_level 9;
brotli_comp_level 10;

gzip_min_length 512;
brotli_min_length 512;

2. AMD Ryzen 7 5700G

For the measurements I used below hardware and software:

Running the compression programs for all permissable compression levels on this desktop machine. All files were stored in /tmp, i.e., they were all in a RAM disk. All compressed files were also written to /tmp. So processing time is not distorted by file I/O. In total there were 793 HTML files, with roughly 47 MB of data. The individual HTML files, of course, were smaller.

All runtime is given is seconds.

The above table is depicted graphically below. Size is scaled by 1,000,000 in the graph below so that runtimes and size can be shown in the same graph.

One can clearly see the steep slope for brotli at level 10. At level 15 zstd starts to become noticeably slower.

3. ARM Cortex A720

Next, I used below hardware and software:

Running the compression programs for all permissable compression levels on this smartphone.

Depicted graphically.

Qualitatively the picture is pretty similar to the AMD chart.

4. Automating the measurements

Three years ago I made the measurements in a manual way. This time it was clear I needed a script to run the measurements.

The method is the same as three years ago:

1. Use find to list all HTML files
2. Use wc -c to count characters
3. Run each compression algorithm and iterate over the compression levels
4. Overwrite previous compressed files

Below is the Perl script.

#!/bin/perl -W
# Performance comparison gzip vs. brotli vs zstd

use strict;

use Getopt::Std;
my %opts = ();
getopts('dk:',\%opts);
my $debug = (defined($opts{'d'}) ? 1 : 0);
my $scale = (defined($opts{'k'}) ? $opts{'k'} : 1);


my %C = (
    gzip => { flag => '-', min => 1, max => 9, suffix => '.gz' },
    brotli => { flag => '-q ', min => 0, max => 11, suffix => '.br' },
    zstd => { flag => '-q -', min => 1, max => 19, suffix => '.zst' },
);
my @R;
push(@R,{}) for(0..19);

die("One directory as argument expected") if ($#ARGV < 0);
die("First argument is not a directory") if (! -d $ARGV[0]);
my $html = $debug ? $ARGV[0] . "/blog/index.html" : `find $ARGV[0] -name \*.html`;
$html =~ s/\n/ /g;
$C{'gzip'}{'wc'} = ($html =~ s/\.html/\.html$C{'gzip'}{'suffix'}/gr);
$C{'brotli'}{'wc'} = ($html =~ s/\.html/\.html$C{'brotli'}{'suffix'}/gr);
$C{'zstd'}{'wc'} = ($html =~ s/\.html/\.html$C{'zstd'}{'suffix'}/gr);


sub fmt1000(@) {	# thousand's formating
    # Perl printf to use commas as thousands-separator:
    # stackoverflow.com/questions/33442240 + perlmonks.org?node_id=1035411
    return scalar reverse(join(',', (unpack('(A3)*',reverse $_[0]))));
}


# Measure execution time and size
for my $c (sort keys %C) {
    my ($f,$m,$M) = @{$C{$c}}{'flag','min','max'};
    #printf("%s: f=%s, m=%d, M=%d\n", $c, $f, $m, $M);
    for (my $l=$m; $l<=$M; ++$l) {
        $R[$l]->{$c} = {};
        my $r = \$R[$l]{$c};
        my $cmd = "$c -kf $f$l";
        #printf("\tc=%s, l=%s, cmd=%s\n",$c,$l,$cmd);
        open(RES,"/bin/time -p $cmd $html 2>&1 |") || die("Cannot run $c");
        while (<RES>) {
            my ($type,$time) = ($_ =~ /(\w+) (\d+\.\d+)/);
            $$r->{$type} = $time;
            #print "\t\t(type,time)=($type,$time): $_";
        }
        close(RES) || die("Cannot close $c");
        my ($wc) = (split(' ', `wc -c $C{$c}{'wc'} | tail -1`,2))[0];
        $$r->{'size'} = $wc;
    }
}

# Print Markdown table
my ($wcHtml) = (split(' ', `wc -c $html | tail -1`,2))[0];
$wcHtml = fmt1000($wcHtml);
printf("compr.<br>level | %s <br>size | real | user\n", join('<br>size | real | user |', sort keys %C));
printf("-|%s\n", "-:|-:|-:|" x keys %C);
printf("&nbsp;|%s| | |%s| | |%s\n",$wcHtml,$wcHtml,$wcHtml);
for (my $l=0; $l<=19; ++$l) {
    printf("%d",$l);
    for my $c (sort keys %C) {
        my ($real,$user,$wc) = @{$R[$l]->{$c}}{'real','user','size'};
        printf(" | %s | %s | %s",
            defined($wc) ? sprintf("%s",fmt1000($wc)) : "n/a",
            defined($real) ? sprintf("%.2f",$real) : "n/a",
            defined($user) ? sprintf("%.2f",$user) : "n/a"
        );
    }
    printf("\n");
}

# Print Apache ECharts JSON
print "series: [\n";
for my $c (sort keys %C) {
    for my $name ( ('size','real') ) {
        printf("\t{\n\t\tname: '%s %s',\n\t\ttype: 'line',\n\t\tsmooth: true,\n\t\tdata: [", $c,$name);
        for (my $l=0; $l<=19; ++$l) {
            my $t = $R[$l]->{$c}->{$name};
            if (defined($t)  &&  $name eq 'size') { $t /= $scale; }
            printf(" %s,", defined($t) ? sprintf("%s",$t) : "'n/a'");
        }
        printf(" ]\n\t},\n");
    }
}
print "]\n";

5. Summary

As in the previous post Performance Comparison: gzip vs Brotli three years ago:

1. brotli compresses best. No other method reaches this level.
2. brotli is always faster than gzip when comparing similar compression levels
3. zstd is more than two times faster than gzip
4. zstd has similar speed to brotli for some range of compression level but then falls off
5. Except for compatibility, there is nothing to recommend for gzip

One takeaway is that for my HTML files zstd does offer no real advantage over brotli, which I already support on my web-server.

Further readings.

1. Paul Calvano: Choosing Between gzip, Brotli and zStandard Compression
2. Danila Vershinin: NGINX Zstd Compression: Complete Configuration Guide