Redis vs Dragonfly: Does the New In‑Memory Cache Really Outperform Redis?

Background

Dragonfly is an open‑source in‑memory data cache written in C/C++ and released under the Business Source License. It implements both Memcached and Redis protocols and claims higher throughput and lower memory usage than Redis.

Redis team response

Redis co‑founder Yiftach Shoolman and Redis Labs architects published a blog post “13 years later, does Redis need a new architecture?” presenting Redis 7.0 benchmark results that show Redis achieving 18‑40 % higher throughput than Dragonfly under comparable conditions.

Benchmark methodology

The original comparison used a single‑process Redis instance (single core) versus a multithreaded Dragonfly instance (all cores). To make the test fair, the Redis team re‑tested with a 40‑shard Redis 7.0 cluster on AWS c4gn.16xlarge instances, matching the hardware used by Dragonfly.

Both client and server VMs were AWS c6gn.16xlarge (aarch64, 126 GB RAM, 64 vCPU cores, single NUMA node). The benchmark tool was memtier_benchmark with GET/SET workloads.

Key benchmark commands

Redis: memtier_benchmark --ratio 0:1 -t 24 -c 1 --test-time 180 --distinct-client-seed -d 256 --cluster-mode -s 10.3.1.88 --port 30001 --key-maximum 1000000 --hide-histogram

Dragonfly: memtier_benchmark --ratio 0:1 -t 55 -c 30 -n 200000 --distinct-client-seed -d 256 -s 10.3.1.6 --key-maximum 1000000 --hide-histogram

Variants add --pipeline 30 for 30 parallel GET/SET channels.

Performance results

Single‑GET (latency < 1 ms) : Redis 4.43 M ops/s (0.383 ms avg latency); Dragonfly 3.80 M ops/s (0.390 ms). Redis outperforms by 10 % (claimed) and 18 % (reproduced).

30‑parallel GET : Redis 22.9 M ops/s (2.239 ms); Dragonfly 15.9 M ops/s (3.99 ms). Redis leads by 43 % (claimed) and 52 % (reproduced).

Single‑SET (latency < 1 ms) : Redis 4.74 M ops/s (0.391 ms); Dragonfly 4.00 M ops/s (0.500 ms). Redis ahead by 19 %.

30‑parallel SET : Redis 19.85 M ops/s (2.879 ms); Dragonfly 14.0 M ops/s (4.203 ms). Redis outperforms by 42 % (reproduced) and 99 % (claimed).

Architectural discussion

Redis uses a multi‑process, no‑shared‑memory design that scales horizontally via clustering and Redis Enterprise, offering elasticity, fault tolerance, and cost efficiency. The team notes interesting ideas from Dragonfly—such as io_uring, modern dictionary implementations, and more strategic thread usage—that may be explored in future Redis versions.

Conclusions

Reproduced benchmarks show Redis maintaining superior throughput and latency under the tested scenarios. Dragonfly’s “fastest cache” claim is not substantiated when testing conditions are equalized. Redis’s architecture continues to provide strong performance, scalability, and resilience, especially on nodes with limited per‑core resources.

References

Redis Architecture Blog Post: https://redis.com/blog/redis-architecture-13-years-later/

Reddit discussion: https://www.reddit.com/r/programming/comments/wiztpx/redis_hits_back_at_dragonfly/

Dragonfly GitHub repository: https://github.com/Dragonfly/dragonfly#building-from-source