PROVIDER Β· Multi-threaded Redis-compatible in-memory database
Dragonfly
Dragonfly is a multi-threaded Redis and Memcached compatible in-memory database whose single instance saturates many cores and hundreds of gigabytes, delivering the same cache capacity on fewer machines.
3.9pts
Pros
Cons
Product Information
Detailed Notes
Overview
Dragonfly was released in 2022 by Israeli team DragonflyDB, rewriting the in-memory database in C++ with a shared-nothing architecture that speaks Redis and Memcached protocols, claiming up to 25 times Redis throughput per machine while using multiple cores and hundreds of gigabytes in one instance.
For Backend & Database work the pitch is more cache per machine, since a single instance saturates all cores and removes Redis Cluster shard operations, forkless snapshots avoid write stalls on large memory instances, and P99 latency stays flatter for large session, leaderboard, and hot-data tiers.
Watch maturity and edges, because Redis command coverage is high but not complete, some modules and Lua scripting behave differently so command-level regression is required before migrating, enterprise capabilities like clustering and multi-tenancy are commercial, and the community is smaller than Redis or Valkey.
Core Strengths
- A multi-threaded shared-nothing design saturates all cores per instance for far higher throughput than single-threaded Redis
- One instance holds hundreds of gigabytes, cutting shard count and cluster operations
- Forkless snapshots and incremental persistence avoid write stalls on large instances
- Both Redis and Memcached protocols work with existing clients
Product Ecosystem
Protocol compatibility
Supports common Redis structures such as strings, hashes, sets, sorted sets, and streams plus the Memcached text protocol.
Persistence and replication
Snapshots and AOF-style incremental persistence with replication, while clustering is a commercial feature.
Managed and cloud
Dragonfly Cloud offers managed hosting, with self-managed deployment and a Kubernetes operator on AWS and GCP.
Drawbacks
- Redis commands and Lua scripts are not fully identical, requiring item-by-item regression
- Clustering and multi-tenancy are commercial, bounding open source capability
- The community and third-party tooling are far smaller than Redis or Valkey
- Limited local regions and support, with compliance and data residency to confirm
Use Cases
- Cutting cost on large memory caches (β β β β β ) - One machine replaces several shards
- High-throughput sessions and leaderboards (β β β β ) - Multi-threading raises QPS
- Migrating from Memcached (β β β β ) - Protocol compatible
- Heavy reliance on Redis modules (β β ) - Verify feature coverage
Pricing
| Plan | Price | Scope |
|---|---|---|
| Open source | $0 | Enterprise features limited, self-managed |
| Commercial | Annual per node | Clustering, multi-tenancy, support |
| Dragonfly Cloud | Monthly per instance size | Managed with backup and monitoring |
The open source edition is free for single-instance caching with cost tracking memory, and fewer machines deliver the same capacity versus Redis to cut rack or cloud spend, with value depending on accepting feature limits and migration testing.
FAQ
-
Is it a drop-in Redis replacement? Most common commands work so a connection string swap is enough to trial, while Lua scripts, modules, and cluster behaviour need compatibility testing first.
-
Why is per-instance throughput so much higher? Redis processes commands effectively single-threaded while Dragonfly uses a shared-nothing multi-threaded design where threads own shards, using all cores.
-
Is persistence reliable? Snapshots and incremental persistence exist and forkless design avoids write stalls, though semantics differ in detail from RDB and AOF and must follow vendor tuning guidance.