What Is Valkey? A Practical Introduction and Valkey vs. Redis Comparison

If you use Redis for caching, sessions, queues, rate limiting, or fast application state, there is another name you should know: Valkey.

Valkey started in 2024 as a fork of Redis 7.2.4, but describing it simply as a “Redis fork” is becoming increasingly inaccurate. It is now an independently developed, Linux Foundation-backed key-value datastore with its own releases, roadmap, maintainers, performance work, and new features.

As of September 2026, Valkey has reached version 9.1.2. Redis, meanwhile, continues independently with Redis 8.10.

The result is that a technology decision that used to be simply “Should I use Redis?” has changed.

For new projects, the more useful question may now be:

Should I use Redis or Valkey?

Let's look at what Valkey is, why it exists, how compatible it really is with Redis, and where the two projects differ today.

What Is Valkey?

Valkey is an open-source, in-memory key-value datastore designed for workloads such as:

• Application caching
• Session storage
• Rate limiting
• Leaderboards
• Queues
• Pub/Sub messaging
• Real-time counters
• Distributed application state
• Primary key-value storage

If you have worked with Redis before, Valkey will look immediately familiar.

Commands such as:

SET user:42 "John"
GET user:42

HSET user:42 name "John" role "admin"
HGETALL user:42

LPUSH jobs "send-email"
RPOP jobs

work exactly as you would expect.

That is not accidental.

Valkey began from the Redis 7.2.4 codebase and continues to use the Redis Serialization Protocol, or RESP. It supports both RESP2 and RESP3, which means existing Redis client libraries can generally connect to Valkey without application-level changes.

But understanding why that fork happened is important.

Why Does Valkey Exist?

For many years, Redis was released under the permissive BSD 3-Clause license.

That changed in March 2024.

Redis moved releases after Redis 7.2 away from BSD licensing and adopted the Redis Source Available License v2 (RSALv2) and Server Side Public License v1 (SSPLv1).

Neither license is an OSI-approved open-source license.

Redis 7.2 and earlier remained under BSD-3-Clause, while Redis 7.4 used the new dual-license model. Redis later changed its licensing strategy again: starting with Redis 8, users can also choose the OSI-approved AGPLv3 license.

The original 2024 change led developers and several large technology companies to continue development from the last BSD-licensed Redis branch.

Valkey was the result.

Because the fork occurred at Redis 7.2.4, Valkey did not begin as a reimplementation or compatibility layer.

It began as the Redis codebase itself.

Since then, however, the two projects have continued development independently.

Valkey Is No Longer Just Redis 7.2 With Another Name

This distinction matters.

If Valkey had simply frozen the Redis 7.2 codebase and applied security patches, it would mostly be interesting as a compatibility project.

That is not what happened.

Valkey has continued through the 8.x and 9.x releases, with Valkey 9.1 becoming the current major release line in 2026.

Valkey 9.1 includes improvements around security, observability, memory efficiency, threading, clustering, and new commands.

For example, Valkey 9.1 introduced:

• Database-level access controls
• JSON-formatted server logs
• Improved TLS certificate handling
• A redesigned I/O threading model
• Reduced memory consumption for common data types
• HGETDEL for atomically reading and deleting hash fields
• MSETEX for setting multiple values with expiration
• CLUSTERSCAN for scanning keys across an entire cluster

The project reports that its new I/O threading design improves throughput for several workloads, while other optimizations reduce memory consumption for strings and sorted sets.

So while Valkey and Redis share a common ancestor, they are increasingly becoming separate products.

Who Controls Valkey?

One of the biggest differences between Redis and Valkey is not a command or benchmark.

It is governance.

Valkey is hosted by the Linux Foundation and managed through a Technical Steering Committee composed of project maintainers.

As of 2026, its steering committee includes engineers affiliated with organizations including:

• AWS
• Google Cloud
• Apple
• Oracle
• Ericsson
• Alibaba
• Tencent
• Percona

This does not automatically make Valkey technically better than Redis.

It does, however, create a substantially different governance model.

Redis development is centered around Redis Ltd., while Valkey is designed as a vendor-neutral open-source project with development shared between multiple organizations.

That distinction can matter for infrastructure that an organization expects to operate for many years.

Valkey vs. Redis

At first glance, Redis and Valkey remain extremely similar.

Underneath that compatibility, however, their development models are beginning to diverge.

The important distinction here is not that one project has features and the other does not.

Both are actively developing.

The differences are increasingly about licensing, governance, packaging, compatibility, and how each project chooses to extend the original Redis architecture.

Redis 8 Has Changed the Comparison

It would be misleading to compare modern Valkey only against Redis 7.

Redis has also changed significantly since the fork.

Redis 8 combines functionality that previously existed in Redis Stack directly into Redis Open Source.

That includes:

• Redis Search
• JSON
• Time series
• Bloom filters
• Cuckoo filters
• Count-min sketch
• Top-k
• t-digest
• Vector-related functionality

Redis 8.10 continues this direction with compact hashes, additional JSONPath functionality, backup and restore improvements, new List and Set operations, and improvements across Search, JSON, Streams, and Time Series.

This makes modern Redis broader than the Redis many developers remember simply as an in-memory cache.

Valkey is expanding in similar directions, but the packaging is different.

For example, Valkey provides official modules for JSON, Bloom filters, LDAP, and Search. The Valkey Bundle provides a container with those supported modules preloaded.

So the comparison is no longer:

Redis has features; Valkey is just the old Redis.

Instead, both projects are independently adding capabilities on top of their shared foundation.

How Compatible Is Valkey With Redis?

This is probably the most important practical question.

For applications based on Redis OSS 7.2 or earlier, compatibility is strong.

Valkey's migration documentation states that Redis OSS versions through 7.2 can migrate to Valkey using compatible:

• Protocols
• Configuration
• RDB files
• AOF files

Existing Redis client libraries can also connect to Valkey because both use RESP. Even redis-cli can connect to a Valkey server.

For many applications, that means code such as:

import redis

client = redis.Redis(
    host="localhost",
    port=6379,
    decode_responses=True
)

client.set("hello", "world")
print(client.get("hello"))

does not care whether the server listening on port 6379 is Redis OSS or Valkey.

That compatibility is one of Valkey's strongest advantages.

There is, however, an important warning.

Redis 7.4+ Is a Different Migration Story

You should not assume that modern Redis and Valkey can always exchange data files.

According to Valkey's migration documentation, RDB and AOF files produced by Redis Community Edition 7.4 and later are not directly compatible with Valkey.

That means moving from old Redis OSS 7.2 to Valkey can effectively behave like an upgrade, while migrating from newer Redis releases may require a different data migration strategy.

This distinction becomes increasingly important as Redis and Valkey evolve separately.

Protocol compatibility does not mean that the two projects will remain identical forever.

Trying Valkey Locally

The easiest way to understand how familiar Valkey feels is to run it.

With Docker:

docker run --name valkey \
  -p 6379:6379 \
  -d valkey/valkey:9.1.2

Valkey 9.1.2 is the current release as of September 2026.

Open the CLI:

docker exec -it valkey valkey-cli

Then try a few commands:

127.0.0.1:6379> SET framework valkey
OK

127.0.0.1:6379> GET framework
"valkey"

127.0.0.1:6379> INCR requests
(integer) 1

127.0.0.1:6379> INCR requests
(integer) 2

If you already know Redis, there is almost nothing new to learn at this level.

And that is exactly the point.

Valkey preserves much of the developer experience that made Redis successful while developing independently underneath it.

Valkey Is Also Becoming a Cloud Default

Another reason Valkey deserves attention is its adoption by infrastructure providers.

AWS supports Valkey through Amazon ElastiCache and currently describes it as the recommended engine on ElastiCache. AWS also supports migration from ElastiCache for Redis OSS to Valkey.

That is significant because infrastructure projects are often adopted through defaults rather than explicit technology migrations.

A developer may continue thinking in terms of a “Redis cache” while the actual managed datastore behind the application is Valkey.

That is likely to make the distinction between the Redis API and ecosystem and the Redis product itself increasingly important.

When Does Valkey Make Sense?

Valkey is worth serious consideration when:

• You are starting a new cache or key-value datastore deployment.
• You want a permissive BSD-licensed project.
• Vendor-neutral governance matters to your organization.
• You already operate Redis OSS 7.2 or earlier.
• Your application primarily relies on standard Redis data structures and commands.
• Your infrastructure provider has strong managed Valkey support.
• You want to stay close to the traditional open-source Redis ecosystem.

Redis may make more sense when:

• You specifically want functionality available in modern Redis.
• You rely heavily on the integrated Search, JSON, Time Series, or probabilistic capabilities in Redis 8.
• Your infrastructure is already built around current Redis versions or Redis Cloud.
• You have already validated Redis's licensing options for your use case.
• Migrating an existing production system would introduce more risk than benefit.

Neither decision should be based solely on benchmark numbers.

For infrastructure, operational support, compatibility, licensing, ecosystem maturity, upgrade paths, and long-term governance can be just as important as raw throughput.

Valkey Is Becoming Its Own Project

The simplest way to understand Valkey is this:

It started as the continuation of Redis OSS 7.2, but it is no longer simply an archive of the old Redis codebase.

Valkey now has its own maintainers, major releases, features, performance optimizations, cloud support, modules, and roadmap.

At the same time, Redis remains actively developed. Redis 8 restored an OSI-approved licensing option through AGPLv3 and has continued adding substantial functionality.

That makes the Redis/Valkey story more interesting than a typical open-source fork.

Neither project disappeared.

Instead, one ecosystem became two.

If you already know Redis, learning Valkey requires very little effort. But understanding why Valkey exists—and where the two projects are heading—is increasingly important when designing new infrastructure.

The next time an architecture diagram contains a box labeled simply Redis, it may be worth asking one more question:

Redis, or Valkey?