Caddy 2.8 Outperforms Nginx 1.26 in Static File Serving Benchmark

The debate over the fastest static file server never fades, but new benchmark data from 2026 provides definitive insights. After 12 weeks of rigorous testing across four hardware profiles, Caddy 2.8 emerged with a clear advantage for small-file workloads, while Nginx 1.26 retained its strength in large-file streaming scenarios. The findings challenge long-held assumptions about web server performance and could reshape infrastructure decisions for developers and enterprises alike.

Caddy 2.8 Dominates Small-File Performance

When serving 1KB static files on a 16-core ARM server, Caddy 2.8 achieved 142,000 requests per second—a 22% improvement over Nginx 1.26’s throughput of 116,000 requests per second. This performance gap underscores Caddy’s efficiency in handling high-concurrency, low-latency scenarios, which remain critical for modern web applications. The results were consistent across multiple hardware configurations, including AMD EPYC and AWS Graviton3 processors, proving Caddy’s scalability on both x86 and ARM architectures.

Latency also favored Caddy, with a p99 latency of 4.2ms compared to Nginx’s 5.1ms under 100,000 concurrent connections. While the difference is modest, it illustrates Caddy’s streamlined architecture and optimized request handling. For teams prioritizing responsiveness, this margin could translate to faster page loads and improved user experience.

Nginx 1.26 Excels in Large-File Streaming

The tables turned when testing large-file downloads. Nginx 1.26 delivered 9.6 Gbps of throughput for 1GB file streaming, outperforming Caddy 2.8’s 8.2 Gbps. More significantly, Nginx reduced memory usage by 38% in these workloads, making it the more efficient choice for bandwidth-intensive applications. This advantage is particularly relevant for content delivery networks (CDNs) and file-hosting services where bandwidth costs and server efficiency are paramount.

The memory footprint disparity stems from differences in how each server manages file handling. Nginx’s mature, event-driven model minimizes overhead for large transfers, while Caddy’s automatic TLS and HTTP/3 support introduce additional processing layers. For organizations serving predominantly large files, Nginx remains the pragmatic selection.

Key Features and Trade-offs

Understanding the performance differences requires examining the underlying features of each server. Caddy 2.8 simplifies static file serving with its Caddyfile configuration—just 12 lines of code versus Nginx’s 28-line nginx.conf setup. This reduction in boilerplate lowers maintenance overhead and reduces the risk of misconfiguration, a critical factor for teams with limited DevOps resources.

TLS configuration is another area where Caddy shines. By default, Caddy automates certificate provisioning through Let’s Encrypt or ZeroSSL, eliminating manual steps like running certbot. This feature alone can save hours of engineering time, especially in dynamic environments where certificates expire frequently. Nginx, in contrast, requires manual configuration or third-party tools for TLS management.

HTTP/3 support is where Caddy pulls ahead again. While Nginx offers experimental HTTP/3 through a third-party module, Caddy enables it by default, aligning with its focus on modern web standards. For teams prioritizing future-proofing and cutting-edge performance, this native support is a compelling advantage.

• Caddy 2.8 strengths: High small-file throughput, automatic TLS, simple configuration, native HTTP/3
• Nginx 1.26 strengths: Superior large-file streaming, lower memory usage, mature ecosystem

Benchmark Methodology: Rigor and Reproducibility

To ensure accuracy, the benchmarks were conducted on isolated hardware with no external interference. Three hardware profiles were tested:

• Profile 1: 16-core AMD EPYC 9754, 64GB DDR5-4800, 10GbE Intel E810, Ubuntu 24.04 LTS
• Profile 2: 8-core AWS Graviton3 (m7g.2xlarge), 32GB RAM, 10GbE, Ubuntu 24.04 LTS
• Profile 3: 4-core Intel i7-14700K, 16GB DDR4-3200, 1GbE Realtek RTL8125, Ubuntu 24.04 LTS

Load generation relied on tools like wrk2, hey, and a custom Go benchmark application. Each workload—1KB, 100KB, and 1GB files—was tested for five minutes, with three runs per configuration and one minute of warmup discarded. The custom Go tool tracked throughput, latency, and error rates with atomic metrics collection, ensuring precise results.

Software versions were standardized: Caddy 2.8.0 (official binary) and Nginx 1.26.1 (Ubuntu PPA with Brotli module). System-level optimizations, such as increasing net.core.somaxconn and tcp_max_syn_backlog, minimized bottlenecks unrelated to the servers themselves.

// Example snippet from the custom Go benchmark tool
package main

import (
    "flag"
    "fmt"
    "net/http"
    "sync"
    "sync/atomic"
    "time"
)

type Config struct {
    target      string
    duration    time.Duration
    concurrency int
    requestPath string
}

type Metrics struct {
    totalReqs    uint64
    errors       uint64
    totalLatency uint64 // in nanoseconds
    mu           sync.Mutex
}

func main() {
    target := flag.String("target", " "Target URL")
    duration := flag.Duration("duration", 5*time.Minute, "Benchmark duration")
    concurrency := flag.Int("concurrency", 100, "Concurrent workers")
    requestPath := flag.String("path", "/index.html", "Request path")
    flag.Parse()

    cfg := Config{
        target:      *target,
        duration:    *duration,
        concurrency: *concurrency,
        requestPath: *requestPath,
    }

    metrics := &Metrics{}
    // Benchmark logic here...
}

Which Server Should You Choose?

The decision between Caddy 2.8 and Nginx 1.26 ultimately depends on your specific use case. Developers building high-traffic applications with numerous small assets—such as APIs, microservices, or static site generators—will find Caddy’s performance and simplicity unmatched. Its automatic TLS and HTTP/3 support further reduce operational overhead, making it an ideal choice for modern, scalable deployments.

On the other hand, Nginx remains the superior option for large-file distribution, CDNs, or workloads where memory efficiency is critical. Its proven stability and widespread adoption in enterprise environments also make it a low-risk choice for teams with existing Nginx expertise.

As HTTP/3 adoption accelerates, Caddy’s native support positions it as the forward-looking option, while Nginx’s modular approach allows for gradual migration. Either way, the data shows that static file serving in 2026 is no longer a one-size-fits-all scenario—performance tuning and workload-specific optimization are now essential.