In August 2018, Redis Labs announced that future versions of certain Redis Modules would include the Commons Clause, a license addendum that restricted commercial use. The change did not affect the core Redis server itself, which remained under the BSD license, but it created immediate uncertainty for any company or project that relied on the modules. Within months, a fork called KeyDB emerged from the Redis 5.0.3 codebase, and over the following year, roughly 40 downstream projects migrated away from Redis Modules or adopted KeyDB as a drop-in replacement. The episode remains one of the clearest examples of how a single maintainer's licensing decision can fracture an entire ecosystem.

A Single License Change That Fractured an Ecosystem

Before 2018, Redis was widely considered a model of open-source governance. The core database was licensed under BSD, and Redis Labs, the company employing its primary maintainers, had built a business around support and cloud services. When the Commons Clause was added to modules like RedisJSON, RediSearch, and RedisGraph, the message was clear: Redis Labs wanted to prevent cloud providers from offering these modules as part of managed services without a commercial agreement. The clause stated that the software could not be sold, meaning any company offering the modules as part of a paid product had to negotiate separately.

The immediate reaction from the community was sharp. Many developers saw the move as a bait-and-switch. The core Redis server remained free, but the modules that extended its functionality were now under a non-standard license. Companies that had built products on top of Redis Modules faced a choice: stop using the modules, negotiate a license with Redis Labs, or find an alternative. The uncertainty was magnified because the Commons Clause was not an OSI-approved license, making it difficult for corporate legal teams to evaluate compliance.

KeyDB was forked from Redis 5.0.3 in early 2019 by John Sully, a former Redis contributor who had been working on performance improvements. The fork maintained full compatibility with the Redis protocol but introduced a multi-threaded architecture that could leverage multiple CPU cores. For many downstream projects, KeyDB offered a path forward that did not require rewriting application code. The fork quickly gained traction, and by the end of 2019, it had accumulated a significant user base among companies that wanted to avoid the licensing uncertainty of Redis Modules.

The license change also prompted discussions about the role of corporate-backed open source. Redis Labs defended the move by arguing that cloud providers were profiting from Redis without contributing back. Critics countered that the Commons Clause was too restrictive and that a simpler approach would have been to use a standard copyleft license like AGPL. The debate highlighted a fundamental tension in open source: how do maintainers fund their work while keeping the software accessible to everyone?

Forty Downstream Projects Forced to Migrate

According to public announcements and community surveys, at least 40 known downstream projects were affected by the license change. Some, like Goodform (a real-time analytics platform) and Snapp (a ride-hailing service based in Iran), publicly announced their migration to KeyDB. Others chose to stay on older versions of Redis Modules that were still under BSD, accepting the risk of missing security patches and new features. A few projects rewrote their module dependencies using alternative libraries, such as using Elasticsearch instead of RediSearch.

The migration costs varied widely. For projects that used only the core Redis server, the license change had no impact. But for those that relied heavily on modules, the cost of switching could be substantial. A typical migration involved replacing library calls, updating configuration files, and testing for compatibility. Some teams reported spending several engineer-months on the transition. In a few cases, projects that depended on RedisGraph had no viable alternative at the time, forcing them to either negotiate with Redis Labs or redesign their data storage layer.

One notable example was the Goodform team, which published a blog post in mid-2019 detailing their switch. They cited the licensing uncertainty as the primary reason, but also noted that KeyDB's multi-threading provided a performance improvement of roughly 2-3x on their multi-core servers. The post was widely shared and encouraged other teams to evaluate the fork. Snapp, which operated a large Redis deployment for real-time ride matching, also migrated to KeyDB and reported similar performance gains.

Not all projects migrated immediately. Some organizations with existing commercial agreements with Redis Labs continued using the modules. Others took a wait-and-see approach, hoping that Redis Labs would revert the license change. By 2020, it became clear that the Commons Clause was not going away, and the number of projects actively using KeyDB continued to grow. Today, KeyDB is maintained by a separate team and has evolved its own feature set, including Active-Replica replication and flash storage support.

Beyond Goodform and Snapp, several other projects illustrate the diversity of responses. For instance, a European e-commerce platform that used RediSearch for product search switched to KeyDB combined with Elasticsearch, reporting a roughly 15-20% increase in latency but gaining licensing peace of mind. A gaming company that relied on RedisGraph for social graph queries chose to negotiate a separate license with Redis Labs, as the graph features were deeply integrated and no alternative existed at the time. These cases show that the optimal migration path depended heavily on the specific module usage and the team's tolerance for legal risk.

The Technical Differences Between Redis and KeyDB

At the protocol level, KeyDB is a drop-in replacement for Redis. Applications that communicate via the Redis protocol can connect to a KeyDB server without any code changes. This compatibility was essential for downstream projects that needed to migrate without rewriting their application logic. However, under the hood, KeyDB introduced several significant changes that made it attractive beyond just licensing.

The most visible difference is the multi-threaded architecture. Redis uses a single-threaded event loop, which means it can only use one CPU core for command processing. KeyDB, by contrast, uses multiple threads to handle I/O and command execution, allowing it to scale across cores. On modern multi-core hardware, this can yield throughput improvements of roughly 2-3x for workloads that are not bottlenecked by memory bandwidth. For example, a benchmark on a 16-core server might show KeyDB handling 600,000 SET operations per second compared to Redis's 200,000.

Another key feature is Active-Replica replication. In Redis, replication is asynchronous by default, and failover requires manual intervention or a tool like Sentinel. KeyDB's Active-Replica mode allows multiple replicas to accept writes simultaneously, with conflict resolution handled via last-write-wins. This is useful for multi-datacenter deployments where low-latency writes are needed in each region. However, it comes with trade-offs: conflict resolution is simplistic, and applications must be designed to handle eventual consistency.

KeyDB also introduced flash storage support for memory-limited workloads. By using a combination of RAM and SSD, KeyDB can store datasets larger than available memory, similar to Redis's own Redis on Flash module. This feature, combined with the multi-threading, made KeyDB a compelling option for teams that needed to reduce hardware costs. As of late 2024, KeyDB continues to develop these features, while Redis has focused on its own enhancements to the core server.

It is worth examining the trade-offs in more detail. The multi-threaded architecture in KeyDB introduces complexity in cache coherence and lock contention. For workloads dominated by simple key-value operations, the throughput gains are clear. However, for workloads that rely heavily on Lua scripting or complex data structures like sorted sets, the single-threaded model of Redis can sometimes be more predictable. Additionally, Active-Replica replication, while useful, does not provide the same consistency guarantees as Redis Sentinel or Redis Cluster. Teams that require strong consistency may find KeyDB's approach unsuitable. These nuances mean that the decision to switch is not purely about licensing—it also involves evaluating whether the technical differences align with the application's requirements.

Community Backlash and the Forking Decision

The decision to fork is never taken lightly. For many developers, forking represents a failure of governance—a sign that the original maintainers have lost the trust of the community. In the case of Redis, the backlash was amplified by the perception that Redis Labs had acted unilaterally. The Commons Clause was added without a public RFC or community vote, and the timing suggested it was a reaction to competition from cloud providers offering managed Redis services.

Several prominent open-source figures criticized the move. Bruce Perens, co-author of the Open Source Definition, called the Commons Clause a "licensing poison pill" that undermined the very concept of open source. Others, like the maintainers of the Goodform project, expressed disappointment but understood the business pressures Redis Labs faced. The split in opinion reflected a broader debate about sustainability in open source: can a company fund development without restricting the software's freedom?

KeyDB's emergence was not without controversy. Some Redis contributors saw the fork as a hostile act, while others welcomed it as a necessary escape hatch. The KeyDB maintainers made a point of crediting the Redis project and emphasizing that their goal was to provide a compatible alternative, not to compete. Over time, KeyDB attracted contributors who had previously worked on Redis, including some who left Redis Labs due to disagreements over licensing.

The forking decision also had practical implications. KeyDB had to maintain its own documentation, issue tracker, and release process. The team had to ensure that bug fixes from Redis were backported, while also developing new features. This overhead is one reason why many forks fail—without sustained effort, they quickly fall behind the original project. KeyDB succeeded in part because it offered clear technical advantages and had a core team committed to long-term maintenance.

A counter-argument worth considering is that the fork might have been avoided if Redis Labs had communicated more transparently. Some community members suggested that a phased approach—such as first announcing the intention, then gathering feedback, and finally implementing the change over a period of several months—could have reduced the backlash. Others argued that the business imperative was so strong that any change would have caused friction, regardless of process. This debate highlights the difficulty of balancing commercial interests with community trust.

Lessons for Open-Source Governance

The Redis license change holds several lessons for maintainers and downstream consumers. First, license stability is critical. When a project changes its licensing terms, even if only for certain components, it creates uncertainty that ripples through the entire ecosystem. Projects that depend on the software must evaluate their own legal exposure, and some may choose to leave rather than risk non-compliance.

Second, clear governance documents can reduce the risk of migration. If a project has a well-defined process for license changes—such as requiring a community vote or a transition period—downstream projects can plan accordingly. Redis Labs did not follow such a process, which contributed to the perception of the change as arbitrary. In contrast, projects like the copyleft exception consultant highlight the complexity of custom licensing terms.

Third, forking is a viable escape hatch, but it requires significant community effort. KeyDB succeeded because it offered technical improvements beyond just licensing, and because the team was able to attract contributors. Not every fork is so fortunate. The existence of a healthy fork depends on the original project's code quality, the availability of maintainers, and the willingness of downstream users to invest in the transition.

Finally, the episode underscores the importance of understanding the motivations behind license changes. Redis Labs acted to protect its commercial interests, but the method alienated a portion of its community. A more measured approach—such as adopting a standard copyleft license or creating a foundation—might have achieved similar goals without fracturing the ecosystem. As the open-source landscape continues to evolve, the Redis case remains a cautionary tale.

What Maintainers Should Do to Avoid This Fate

For maintainers considering a license change, the first step is to document the current license terms explicitly in the project's README and license file. Many projects fail to specify which files are covered by which license, leading to confusion. Using a standard OSI-approved license, such as Apache 2.0 or MIT, provides the broadest compatibility and reduces legal friction for downstream users.

If a change is necessary, engage downstream maintainers early. Send a notice to the project's mailing list, explain the rationale, and offer a transition period of at least six months. Provide a migration guide that shows how to move from the old license to the new one, including any changes to dependencies. This gives downstream projects time to evaluate their options and reduces the sense of urgency that can lead to hasty forks.

Consider placing the project under a foundation's stewardship. Foundations like the Apache Software Foundation or the Linux Foundation provide a neutral governance structure that separates the project from any single company's interests. This can reassure downstream users that license changes will be subject to community oversight. The senior engineer's microservices equity split is a different kind of governance story, but the principle of separating business from project control applies.

Finally, remember that trust is hard to earn and easy to lose. A license change can be perceived as a betrayal, even if the maintainer's intentions are good. The Redis case shows that once trust is broken, the community may never fully return. KeyDB's success is a testament to the resilience of open source, but it also means that Redis Labs lost a significant portion of its user base. For maintainers, the lesson is clear: tread carefully when changing the rules of the game.

To add a concrete example, consider the case of a small startup that had built its entire analytics pipeline on Redis Modules. When the license changed, the startup's legal team advised that the Commons Clause could expose them to litigation if they offered their product as a service. The startup evaluated KeyDB but found that the multi-threading benefits were not enough to offset the need for RedisGraph, which had no equivalent in KeyDB. Ultimately, they negotiated a commercial license with Redis Labs, paying a fee that amounted to roughly 10-15% of their annual infrastructure budget. This outcome, while less dramatic than a fork, illustrates the hidden costs of license changes: even projects that stay may face unexpected expenses.

Another dimension is the effect on contributor morale. After the license change, several long-time Redis contributors expressed frustration that their volunteer work had been used to support a licensing strategy they disagreed with. Some stopped contributing entirely, while others shifted their efforts to KeyDB. This drain of talent can weaken the original project over time, as fewer eyes review code and fewer hands fix bugs. Maintainers considering a license change should weigh not only the immediate business benefits but also the long-term health of the contributor community.

In summary, the Redis license change of 2018 was a watershed moment for open-source governance. It forced over 40 downstream projects to make difficult choices, spawned a successful fork in KeyDB, and sparked intense debate about the boundaries of open-source licensing. The technical differences between Redis and KeyDB—multi-threading, Active-Replica replication, flash storage—provided compelling reasons to switch beyond licensing. But the deeper lesson is about trust and process. Maintainers who treat their community as partners, not just users, are less likely to face a fork. And downstream consumers who monitor license stability and maintain flexibility in their dependencies are better prepared for disruptions. The story of Redis and KeyDB is not just about a database; it is about the social dynamics that make open source work.