Valkey vs. Redis for Laravel Caching and Queues: What You Need to Know

In March 2024, the Redis project changed its license from the permissive BSD 3-Clause to a dual license combining the Redis Source Available License (RSALv2) and the Server Side Public License (SSPLv1). This licensing change meant that cloud providers and hosting platforms could no longer freely offer Redis as a managed service without a commercial agreement with Redis Ltd.

The response was immediate. The Linux Foundation forked Redis 7.2.4 under the BSD 3-Clause license and named the fork Valkey. Within months, AWS, Google Cloud, Oracle, Ericsson, and dozens of other organizations joined as contributors. By mid-2025, Valkey had established itself as the primary open-source continuation of the Redis codebase, with active development and a growing feature set.

For Laravel developers, this raises practical questions. Is Valkey compatible with existing Redis drivers? Do you need to change your application code? What about performance? This guide answers all of these questions and explains why Deploynix provisions Valkey by default on all new servers.

What Exactly Is Valkey?

Valkey is a fork of Redis 7.2.4, the last version released under the BSD license. It is an in-memory data structure store that functions identically to Redis for the vast majority of use cases: caching, session storage, queue management, real-time pub/sub, and rate limiting.

The name "Valkey" is a portmanteau of "value" and "key," which is about as descriptive as a name can get for a key-value store.

What Valkey Is Not

Valkey is not a new product built from scratch. It is a direct continuation of the Redis codebase with the same data structures, the same protocol (RESP), the same command set, and the same persistence mechanisms. If you know Redis, you know Valkey. If your application works with Redis 7.2, it works with Valkey.

Valkey is also not abandonware. It has a larger active contributor base than Redis did before the license change, backed by major cloud providers who have a vested interest in its continued development.

Compatibility with Laravel

This is the question every Laravel developer asks first, and the answer is straightforward: Valkey is fully compatible with Laravel's Redis integration.

Driver Compatibility

Laravel communicates with Redis (and Valkey) through two PHP extensions: PhpRedis and Predis. Both use the RESP protocol, which Valkey implements identically to Redis. No changes to your Laravel configuration are needed.

Your config/database.php Redis configuration remains exactly the same:

'redis' => [
    'client' => env('REDIS_CLIENT', 'phpredis'),
    'default' => [
        'url' => env('REDIS_URL'),
        'host' => env('REDIS_HOST', '127.0.0.1'),
        'password' => env('REDIS_PASSWORD'),
        'port' => env('REDIS_PORT', '6379'),
        'database' => env('REDIS_DB', '0'),
    ],
    'cache' => [
        'url' => env('REDIS_URL'),
        'host' => env('REDIS_HOST', '127.0.0.1'),
        'password' => env('REDIS_PASSWORD'),
        'port' => env('REDIS_PORT', '6379'),
        'database' => env('REDIS_CACHE_DB', '1'),
    ],
],

Notice that the configuration still says "redis" — and it should. Valkey is protocol-compatible, so Laravel's Redis driver works without any changes to driver names, configuration keys, or environment variables.

Cache Driver

Using Valkey as your Laravel cache driver requires zero code changes:

CACHE_STORE=redis
REDIS_HOST=127.0.0.1

All cache operations — Cache::get(), Cache::put(), Cache::remember(), Cache::tags(), Cache::forget() — work identically.

Queue Driver

Valkey as a queue backend works exactly as Redis did:

QUEUE_CONNECTION=redis

Job dispatching, delayed jobs, job batching, rate limiting, and all of Laravel's queue features work without modification.

Session Driver

Sessions stored in Valkey:

SESSION_DRIVER=redis

No code changes. Session creation, reading, garbage collection, and invalidation all work the same way.

Broadcasting with Reverb

Laravel Reverb uses Redis (Valkey) for pub/sub message distribution in multi-server setups. The Valkey pub/sub implementation is identical to Redis, so Reverb works without any configuration changes.

Horizon

Laravel Horizon, the queue monitoring dashboard, works with Valkey out of the box. Horizon uses the same Redis commands for queue inspection, metrics collection, and worker management.

Performance Comparison

Raw Benchmarks

Valkey 7.2 is performance-identical to Redis 7.2 because it is the same code. Any benchmark differences at this version are within measurement noise.

Where things get interesting is with newer Valkey releases. The Valkey development team has been actively working on performance improvements:

Valkey 8.0 improvements:

• Multi-threaded I/O handling for better utilization of modern multi-core servers
• Improved memory efficiency for certain data structures
• Optimized replication performance

In independent benchmarks, Valkey 8.0 shows 10-20% higher throughput than Redis 7.2 for workloads that benefit from multi-threaded I/O, particularly on servers with 4+ CPU cores. For typical Laravel workloads (cache reads/writes, queue operations), the practical difference is minimal because these operations are already extremely fast (sub-millisecond).

Where Performance Matters

For most Laravel applications, the performance of your key-value store is not the bottleneck. A cache read from Valkey takes 0.1-0.3ms locally and 0.5-1ms over the network. Your database queries, PHP processing, and external API calls take orders of magnitude longer.

Performance differences between Valkey and Redis become relevant when:

• You are processing millions of cache operations per minute
• Your pub/sub system handles thousands of messages per second
• You are using complex data structures (sorted sets, streams) at high volume

For these workloads, Valkey 8.0's multi-threaded improvements provide measurable benefits.

Memory Usage

Memory usage is identical for the same dataset. Valkey uses the same data encoding and compression strategies as Redis 7.2. A dataset that uses 2GB in Redis will use 2GB in Valkey.

Migration from Redis to Valkey

If You Are Provisioning New Servers

If you are setting up new infrastructure through Deploynix, there is nothing to migrate. Deploynix provisions Valkey by default, and your Laravel application connects to it using the same Redis driver and configuration. You deploy your application, set the REDIS_HOST environment variable, and everything works.

If You Are Migrating Existing Servers

Migrating from Redis to Valkey on an existing server involves replacing the Redis binary with the Valkey binary. The data format is compatible, so your existing data is preserved.

Migration steps:

1. Back up your Redis data. Run BGSAVE to create an RDB snapshot.
2. Stop Redis.

sudo systemctl stop redis

1. Install Valkey. Installation varies by OS. On Ubuntu:

sudo apt-get install valkey-server

1. Copy your Redis configuration. Valkey's configuration file format is compatible with Redis. Copy your redis.conf to valkey.conf and update the relevant paths.
2. Copy the RDB file. Move your Redis dump file to Valkey's data directory.
3. Start Valkey.

sudo systemctl start valkey

1. Verify. Connect with valkey-cli (or redis-cli — both work) and verify your data is present.
2. Update monitoring. If you have monitoring that specifically watches the Redis process, update it to watch Valkey instead.

Important: Your Laravel application requires zero changes. The REDIS_HOST, REDIS_PORT, and REDIS_PASSWORD environment variables stay the same (assuming you use the same host, port, and password). The driver configuration stays as redis. Nothing in your codebase changes.

On Deploynix-Managed Servers

For servers managed by Deploynix, the platform handles Valkey installation and configuration during provisioning. If you have existing servers running Redis and want to migrate, the process is the same as above — or you can provision a new Cache server with Valkey and point your application to it.

Why Deploynix Chose Valkey

The decision to default to Valkey was driven by three factors:

1. Licensing Clarity

Valkey's BSD 3-Clause license is unambiguous. There are no restrictions on how it can be used, deployed, or offered as part of a service. This matters for Deploynix because the platform provisions and manages Valkey servers for customers — a use case that could be problematic under Redis's new license.

For your application, licensing may seem irrelevant. But using software with a clear, permissive license means you never have to worry about license compliance as your business grows or your use case evolves.

2. Community Momentum

The Valkey project has attracted significant contributor activity from major technology companies. AWS, Google Cloud, Oracle, and others are actively contributing code, reviewing changes, and participating in governance. This is not a community fork maintained by a handful of volunteers — it is a well-funded, well-staffed project with a clear roadmap.

3. Feature Development

Valkey's development pace has exceeded Redis's in several areas, particularly around multi-threaded performance, cluster improvements, and observability. As Valkey continues to evolve, Deploynix users benefit from these improvements through server updates.

Common Questions

Can I still use the redis driver name in Laravel?

Yes. Valkey speaks the Redis protocol, so Laravel's redis driver works without changes. There is no need for a valkey driver — the protocol is identical.

Does PhpRedis work with Valkey?

Yes. PhpRedis communicates using the RESP protocol, which Valkey implements. No extension changes needed.

Does Predis work with Valkey?

Yes. Same reason — it uses the RESP protocol.

Will my Redis GUI tools work?

Yes. Tools like RedisInsight, Medis, Another Redis Desktop Manager, and command-line tools like redis-cli all work with Valkey.

What about Redis Sentinel and Redis Cluster?

Valkey supports both Sentinel (for high availability) and Cluster (for horizontal partitioning) with the same configuration as Redis. If you use either of these features, they work identically with Valkey.

Can I use Redis modules with Valkey?

Redis modules (like RediSearch, RedisJSON, RedisTimeSeries) were primarily developed by Redis Ltd. and are not part of the Valkey project. However, Valkey is developing equivalent functionality natively. For most Laravel applications, modules are not used — the core data structures (strings, hashes, lists, sets, sorted sets, streams) cover all common use cases.

What about Redis Stack?

Redis Stack is a Redis Ltd. product that bundles Redis with several modules. It is not available for Valkey. If you depend on Redis Stack features, evaluate whether Valkey's native capabilities (or alternative solutions) meet your needs before migrating.

The Bottom Line for Laravel Developers

If you are starting a new project, use Valkey. Deploynix provisions it by default, it is fully compatible with your existing code and configuration, and it is the future of open-source in-memory data stores.

If you are running Redis on existing servers, there is no urgent need to migrate. Your application will work fine with Redis for the foreseeable future. But when you provision new servers or rebuild your infrastructure, defaulting to Valkey is the pragmatic choice.

The migration is trivial — same protocol, same drivers, same configuration. The only things that change are the binary running on the server and the license it ships under. For your Laravel application, it is a non-event.

Conclusion

The Redis licensing change was a significant moment for the open-source community, but for Laravel developers, the practical impact is minimal. Valkey is a direct, compatible continuation of Redis, maintained by a strong community with clear governance and active development.

Deploynix uses Valkey because it is the right technical and licensing choice for a deployment platform that provisions and manages servers. For your Laravel application, the transition is seamless — your cache, queues, sessions, broadcasting, and any other Redis-dependent feature works identically.

The key takeaway is simple: Valkey is Redis, fork-continued under an open license. If your application uses Redis today, it will use Valkey tomorrow with zero code changes. That is the best kind of migration — the kind where nothing breaks.