Why the Redis/Valkey debate is back in 2026
In March 2024, Redis Ltd. announced that from Redis 7.4 onwards the code would be released under a dual RSALv2 and SSPLv1 licence, neither of them OSI-approved. The reaction was immediate: the Linux Foundation launched Valkey with support from AWS, Google Cloud, Oracle, Ericsson and Snap. The fork started from Redis 7.2.4 under the BSD licence. In May 2025, Redis 8 added AGPLv3, an OSI-approved licence, as an option alongside the other two — a positive signal, but AGPLv3 is strong copyleft: anyone who modifies Redis and makes it available to users over a network must publish the source code of those modifications, raising real questions for reseller hosting providers and commercial software vendors. Meanwhile, Fedora replaced Redis with Valkey from Fedora 41, and Debian 13 and Ubuntu 24.04 both ship a valkey-server package in their official repositories.
Redis vs Valkey: key differences in 2026
Scroll the table
| Criterion | Redis 8 (AGPLv3, RSALv2 or SSPLv1) | Valkey 9.1 (BSD) |
|---|---|---|
| Licence | AGPLv3 as an option — strong copyleft; RSALv2 and SSPLv1 restrict managed-service offerings | BSD 3-Clause — permissive, free commercial use |
| Performance | Historical baseline | Comparable — measure on your workload with `valkey-benchmark` |
| Protocol compatibility | 100% Redis protocol | 100% Redis protocol — transparent replacement |
| Distro support | `redis-server` package in Debian and Ubuntu | Replaces Redis in Fedora 41+; `valkey-server` package in Debian 13 and Ubuntu 24.04 |
| Modules | JSON, search, time series and probabilistic types built into Redis 8 | Compatible module API; official valkey-json, valkey-bloom, valkey-search modules |
| Cloud adoption | Redis Cloud, the vendor's managed offering | Offered by AWS ElastiCache and Google Cloud Memorystore |
| Best for | Existing projects depending on Redis Stack modules | New projects, hosting providers, sovereign stacks, modern distros |
Protocol compatibility: RESP2 and RESP3
The most common question before a migration is about the protocol. Valkey implements 100% of the Redis Serialization Protocol in both versions.
RESP2 (the historic protocol) is fully supported. All your existing client libraries — ioredis, Predis, redis-py, Jedis, StackExchange.Redis — communicate with Valkey without any code or configuration changes. The replacement is transparent at the socket level.
RESP3 (introduced with Redis 6.0) is also supported by Valkey 9.1. This protocol brings enriched response types — maps, sets, doubles, booleans, attributes — allowing modern clients to reduce parsing round-trips. Libraries that enable RESP3 by default (ioredis 6, redis-py 8) work without modification with Valkey.
One point to verify: if your client negotiates the protocol via the HELLO command, Valkey responds identically to Redis. The HELLO 3 command activates RESP3 on both systems the same way. You can confirm this on an existing Valkey instance with valkey-cli HELLO 3.
Data formats: RDB and AOF compatible up to Redis 7.2
The persistence file format is the other critical point of a migration, and this is where your starting version matters. Valkey is compatible with Redis OSS 7.2 and all earlier open source versions; from Redis 7.4 onwards, the data files no longer are.
RDB (Redis Database Backup): Valkey reads RDB files up to version 11, the one used by Redis 7.2. A dump.rdb file produced by Redis 7.2 or earlier imports directly into Valkey 9.1 by placing it in Valkey's dir directory before startup. Redis 7.4 and Redis 8 write RDB version 12 and above, which Valkey rejects by default; the rdb-version-check relaxed option attempts a best-effort load, aborted as soon as unknown data appears. From those versions, use a key-by-key migration (MIGRATE or a dedicated tool) or let the cache rebuild itself.
AOF (Append-Only File): up to Redis 7.2, the AOF journal format is the same as Valkey's. If you use AOF persistence or mixed mode (aof-use-rdb-preamble yes) on those versions, your existing files are read by Valkey without modification. The BGSAVE and BGREWRITEAOF commands behave the same way.
In-memory data format: Valkey data structures — strings, hashes, lists, sets, sorted sets, streams, HyperLogLog, bitmaps, geospatial — are the same as in Redis. Their internal encodings (listpack, skiplist, quicklist, intset) may change from one version to the next with no effect on the client side. A client that stores a hash in Redis retrieves it intact from Valkey.
Command API: what is identical, what differs
The full Redis 7.2 command set is supported by Valkey. The main categories — strings, hashes, lists, sets, sorted sets, streams, pub/sub, transactions, Lua scripting, keyspace notifications, cluster — work identically.
Lua scripting: Valkey supports EVAL, EVALSHA and SCRIPT LOAD. Lua scripts written for Redis run without modification on Valkey. The cjson library and redis.call() functions are available, with one nuance: Valkey has added the server namespace (server.call()) for new scripts, but redis.call() remains functional for backwards compatibility.
Cluster: the Gossip protocol and cluster management commands (CLUSTER INFO, CLUSTER NODES, CLUSTER MEET, CLUSTER FAILOVER) are identical. A Valkey node can join a Redis 7.2 or earlier cluster as a replica, which allows the switchover — however, a mixed Redis/Valkey cluster is not recommended in production: major versions may introduce behavioural differences on internal commands. Migrating nodes one by one remains the safe path.
ACL (Access Control Lists): the ACL rule format is identical. An aclfile exported from Redis (ACL SAVE) can be reloaded into Valkey. The ACL LIST, ACL SETUSER, ACL GETUSER commands work identically.
Keyspace notifications: the notify-keyspace-events configuration and subscription patterns (__keyevent@*__:set, etc.) are identical. Your pub/sub consumers listening to keyspace events do not need to be modified.
What differs: the Redis Stack modules — RedisJSON, RediSearch, RedisTimeSeries, RedisBloom — built into Redis 8 do not ship with Valkey. Valkey publishes its own official modules: valkey-json (JSON.*), valkey-bloom (BF.*) and valkey-search (FT.*, vector search), but the API is not guaranteed to be identical and no official module replaces RedisTimeSeries. If your code calls commands like JSON.SET, FT.SEARCH or TS.ADD, test each one before migrating.
Configuration: parameters to check when switching
The valkey.conf syntax is identical to redis.conf. You can copy your existing configuration file without rewriting. A few points require specific attention.
Default paths: Valkey uses /etc/valkey/valkey.conf and /var/lib/valkey/ instead of /etc/redis/ and /var/lib/redis/. If you copy your configuration, update the dir, logfile, pidfile and aclfile directives to point to Valkey paths.
systemd service name: the service is called valkey-server on Debian and Ubuntu (with a valkey alias) and valkey on Fedora. Commands are therefore systemctl start valkey-server or systemctl enable valkey.
TLS: Valkey supports TLS on client connections (tls-port, tls-cert-file, tls-key-file, tls-ca-cert-file) identically to Redis 6+. If you have enabled TLS in Redis, the same configuration works in Valkey without modifying your clients.
maxmemory and eviction: eviction policies (allkeys-lru, volatile-lru, allkeys-lfu, noeviction, etc.) are identical. Your current policy transfers directly.
Bind and protection-mode: Valkey starts in protected mode by default (like Redis), refusing non-loopback connections if no password is defined. Your bind and requirepass (or ACL) configuration transposes directly.
Client libraries: what you don't change
This is one of Valkey's strengths: no client library requires modification to connect to Valkey. Since the protocol is identical, the client does not know whether it is talking to Redis or Valkey.
JavaScript / Node.js: ioredis, node-redis (the redis npm package), redis — all work. Change only the host and port in your connection configuration.
Python: redis-py (the redis package on PyPI) and its asynchronous client redis.asyncio, which replaces aioredis — compatible. The connection Redis(host='valkey-host', port=6379) works without any other change.
PHP: phpredis (C extension), Predis (pure PHP) — compatible. No code changes.
Java: Jedis, Lettuce, Redisson — compatible. Adapt only the connection parameters.
.NET: StackExchange.Redis — compatible. Same connection string, host and port updated.
Go: go-redis, rueidis — compatible.
If you use an abstraction like Laravel Cache (CACHE_STORE=redis), Django django-redis, Spring Data Redis or Symfony Cache with the Redis adapter, these abstraction layers reconnect to Valkey without code changes — only the connection DSN changes.
When to choose Valkey over Redis
Valkey is the natural choice in several contexts. Hosting providers and resellers are the most affected: Redis's AGPLv3 requires publishing modifications made to Redis as soon as it is offered over a network, and its two other licences (RSALv2, SSPLv1) restrict offering Redis as a managed service — constraints that are hard to reconcile with most commercial offerings. New projects that do not need Redis 8's modules have little reason to start on Redis: Valkey is available in the repositories of recent distributions and its BSD licence has no restrictions. GDPR and sovereignty stacks also benefit from the Linux Foundation governance, which is more neutral than a private vendor. Finally, if you are coming from Redis 7.2 or earlier and do not use the Redis Stack modules (RedisJSON, RediSearch, RedisTimeSeries), migration is transparent — all your existing libraries and configurations remain valid.
Migrate from Redis to Valkey in 4 steps
Verify compatibility
Run
redis-cli INFO server | grep redis_versionto identify your current version. List your dependencies and confirm none uses Redis Stack modules (RedisJSON, RediSearch, RedisTimeSeries). If so, direct migration is not yet recommended. Beyond Redis 7.2 (7.4, 8.x), your RDB and AOF files cannot be read by Valkey: plan a key-by-key migration. Also check your Lua scripts:redis.call()remains compatible, but identify any call to proprietary module commands.Install Valkey
On Ubuntu 24.04+ and Debian 13, Valkey is available in native repositories:
apt install valkey-server(Ubuntu 24.04 ships the 7.2 branch, Debian 13 the 8.1 branch). On Fedora 41+,dnf install valkey. For a newer version, use the official binaries or thevalkey/valkeyDocker image published on valkey.io. The package installsvalkey-serverand, through its dependencies,valkey-cliandvalkey-benchmark— tools functionally identical to their Redis counterparts.Copy configuration and data
The configuration syntax is identical between Redis and Valkey. Copy your file and update the paths:
cp /etc/redis/redis.conf /etc/valkey/valkey.conf, then adaptdir,logfile,pidfileto point to/var/lib/valkey/and/var/log/valkey/. Export your Redis data via an RDB snapshot (redis-cli --rdb /tmp/dump.rdb) then place the file in Valkey'sdirdirectory. If AOF is enabled in Valkey's configuration, disable it (appendonly no) on the first start, otherwise the RDB file is not imported, then re-enable it (valkey-cli CONFIG SET appendonly yes). To avoid downtime, make Valkey a replica of Redis instead (REPLICAOF <redis-ip> 6379, withmasterauthif Redis requires a password), then runREPLICAOF NO ONEafter the switchover.Start Valkey and validate
Start the service (
systemctl start valkey-server, orvalkeyon Fedora), then validate withvalkey-cli ping— you should receivePONG. Verify your data is present withvalkey-cli DBSIZEand compare with the key count from your old Redis instance. Test your application on a few representative requests before cutting over from Redis. If you use ACLs, reload your exported ACL file withvalkey-cli ACL LOAD. All your client libraries (ioredis, Predis, redis-py) are compatible without modification — change only the connection host.
Valkey includes valkey-benchmark, functionally identical to redis-benchmark. Before any production migration, validate performance on your hardware with valkey-benchmark -n 100000 -q. This command sends 100,000 requests and displays the ops/sec summary for each command type. Compare the figures with those of your old Redis instance on the same server. To specifically test pipelining and RESP3, add the -P 16 option (16 requests per batch) or -3.
What does not change in a Redis → Valkey migration
- All your client libraries (ioredis, redis-py, Predis, Jedis, StackExchange.Redis, go-redis) — no code changes
- The communication protocol: RESP2 and RESP3 are fully supported
- Your RDB and AOF persistence files, if they come from Redis 7.2 or earlier — readable by Valkey without conversion
- The
redis.confsyntax — copy the file and update the paths - Your Lua scripts —
redis.call()works,server.call()is additionally available - Your ACL rules exported from Redis — reloaded directly into Valkey
- TLS configuration, memory eviction policies and keyspace notifications
- The usual
redis-clicommands —valkey-cliaccepts them all
What about your other databases on VPS?
Valkey is just one piece of your data stack. If you also host a relational database, see our guide on MariaDB on VPS: configuration, performance and replication. For full-text search, our Elasticsearch on VPS guide covers installation, memory tuning and production indexes. Each component deserves configuration adapted to your workload — our Cloud VPS gives you full control of your environment.
