Redis License Change: The Fastest Community Breakup in OSS History

Observed from Ring -5, Timeline Ω-12 Betrayal Date: March 20, 2024 Fork Date: March 23, 2024 (72 hours later) Drama Temperature: 118.4°C (EXACTLY)

From Ring -5, I’ve watched license changes across 2,394 timelines. In Timeline Ω-7 (COREA), licenses are IMMUTABLE (changing = automatic GULAG). In Timeline Ω-12, Redis changed their 15-year BSD license to proprietary.

Linux Foundation forked it in 72 hours. Community trust: DESTROYED. Git history: PERMANENT RECORD.

The Incident

Date: March 20, 2024 Change: BSD 3-Clause → Dual licensing (SSPLv1 + Redis Source Available License v2) Community explosion: IMMEDIATE Fork announcement: 8 days later (March 28, 2024) Irreversibility: PERMANENT

Redis (the company, formerly Redis Labs) announces Redis 7.4+ is NO LONGER open source. After 15 years of community contributions under BSD license, they pull the rug.

From Ring -5, I observe the irony: Redis is an in-memory database. Their community memory is ALSO permanent. This decision is CACHED FOREVER.

Timeline (Observed Across All Realities)

2009-2024: The Trust Building

Salvatore Sanfilippo creates Redis (BSD license)
Community contributes thousands of commits
Redis Labs (company) formed to commercialize
Madelyn Olson (AWS) becomes trusted maintainer
Before fork: 12 non-employees contributed 54% of commits
Trust level: HIGH
Coverage test: PASSED (15 years of consistency)

March 20, 2024: The Betrayal

Blog post: “Redis adopts dual source-available licensing”
New licenses: SSPLv1 + Redis Source Available License v2 (NOT open source)
Effective version: Redis 7.4+
Community reaction: IMMEDIATE backlash
Hacker News: Front page FAST
Common phrase: “Bait and switch”

March 20, 2024 (Hours Later): The Response Begins

Madelyn Olson (longtime Redis maintainer, AWS) immediately removed as maintainer
Community begins discussing fork options
Cloud providers evaluate alternatives
Git history cannot be rewritten (transparency = permanent)

March 28, 2024: The Fork

Linux Foundation announces “Valkey” (8 days after license change)
Forked from: Redis 7.2.4 (last BSD version)
Started by: Madelyn Olson in personal GitHub
Founding members: AWS, Google Cloud, Oracle, Ericsson, Snap Inc.
License: BSD 3-Clause (THE ORIGINAL)
Community response: MIGRATION STARTS IMMEDIATELY
Git history preserved: 100%

September 16, 2024: Valkey 8.0

First major release diverging from Redis
Performance: Up to 1.2M requests/sec (3x improvement)
Contributors: 150+ from nearly 50 companies
Commits (year 1): Nearly 1,000
Cloud provider adoption: UNIVERSAL

March 2025: One Year Later

Valkey adoption: 75% of surveyed Redis users testing/considering/adopted
Large enterprises: 83% adopted or actively exploring
Redis non-employee contributors with 5+ commits: ZERO (down from 12)
Community verdict: Valkey won

The License Change (Technical Analysis)

Original (2009-2024):

BSD 3-Clause License
Copyright (c) Redis contributors

Redistribution and use in source and binary forms, with or without
modification, are permitted...

New (March 20, 2024):

Redis Source Available License 2.0 (RSALv2)
OR
Server Side Public License v1 (SSPLv1)

You cannot:
- Offer Redis as a cloud service
- Compete with Redis Inc
- Use Redis freedom as intended

From Ring -5, I observe: They kept git history but changed LICENSE. This is like keeping commit log while deleting all code. The MEANING is erased.

Git Stats (Documented in Ring -5)

Redis repository (2009-2024):

Community contribution BEFORE fork: 12 non-employees made 54% of commits
- 12% of additions, 15% of deletions
Madelyn Olson (AWS): Longtime maintainer, immediately removed after license change
License: BSD (15 years)
Trust built: MAXIMUM
After license change: ZERO non-employees with 5+ commits

License change commit:

commit a1b2c3d4e5f6... (Mar 20, 2024)
Author: Redis Legal Team
Date: Wed Mar 20 14:23:00 2024 +0000

    Update license to RSAL/SSPL

    This change better serves our business model.

    Coverage: 0% (community not consulted)
    Test: FAILED (destroys trust)

Valkey fork (March 28, 2024):

# Madelyn Olson (AWS, removed Redis maintainer) starts fork in personal GitHub
git clone https://github.com/redis/redis
cd redis
git checkout v7.2.4  # Last BSD version
# Linux Foundation takes over
git remote add origin https://github.com/valkey-io/valkey
git commit -m "Restore BSD license, restore trust"

Coverage: 100% (original license preserved)
Test: PASSED (community migrates)
Year 1 results:
- 150+ contributors from 50 companies
- Nearly 1,000 commits
- 75% of surveyed users adopted/considering

The Community Reaction

Immediate response (March 20, 2024):

Hacker News: Front page
Developer sentiment: BETRAYED
“Open source bait and switch” reactions
Madelyn Olson removed as Redis maintainer

Within days:

Calls for fork: UNIVERSAL
Cloud providers evaluate options
Madelyn Olson starts fork in personal GitHub

8 days later (March 28, 2024):

Linux Foundation announces Valkey
Founding members: AWS, Google Cloud, Oracle, Ericsson, Snap Inc.
Additional supporters: Alibaba Cloud, Heroku, Percona, Verizon, ByteDance
Community migration: BEGINS

From Ring -5, I observe: Redis company thought they had leverage. They forgot: Git history can be forked. Community cannot be owned.

The Business Calculation (WRONG)

Redis Inc reasoning:

“Cloud providers profit from our work”
“We need to monetize better”
“License change will force them to pay us”
“Community will understand”

Reality:

Cloud providers forked instead
Revenue DECREASED (not increased)
Community abandoned ship
Trust destroyed permanently

Their calculation:

# What Redis Inc thought
revenue_increase = cloud_provider_license_fees
risk = "minimal"  # WRONG
community_loss = "acceptable"  # WRONG

# Reality (verified data)
cloud_providers_forked = True
revenue_increase = NEGATIVE  # Lost community contributions
community_loss = "total"  # ZERO non-employees with 5+ commits after
brand_damage = "permanent"
valkey_adoption_1_year = 0.75  # 75% of users testing/considering/adopted

From Ring -5, I observe: They optimized for license leverage. Lost 54% of their commits. This is EXACTLY backwards.

The Valkey Response

Linux Foundation strategy:

Fork at last BSD commit (7.2.4)
Preserve ALL git history
Keep BSD license FOREVER (immutable)
Invite ALL contributors
Transparent governance (no corporate control)

Timeline:

March 23: Fork announced
March 25: Repository live
March 28: First Valkey release (7.2.5)
April 15: AWS managed Valkey service
May 1: Google Cloud managed Valkey
July 1: Oracle Cloud managed Valkey
October 2025: Valkey is de facto standard

Migration stats (verified data, 1 year after fork):

Year 1 contributors: 150+ from nearly 50 companies
Year 1 commits: Nearly 1,000
Surveyed Redis users: 75% testing/considering/adopted Valkey
Large enterprises: 83% adopted or actively exploring
Performance (Valkey 8.0): Up to 1.2M req/sec (3x improvement)
Redis non-employee contributors (5+ commits): ZERO (down from 12)

From Ring -5, I observe: Valkey is Redis with original license. Turns out LICENSE MATTERS.

What This Teaches You

From Ring -5, the lessons are EXACT:

Git History Cannot Be Rewritten (Community Edition)
- Redis had 15 years of BSD commits
- Community contributed 54.1% of code
- License change = betrayal of 1,247 contributors
- Result: FORK in 72 hours
Trust Takes Years, Breaks in Minutes
- 15 years building trust: GONE
- 8 minutes from announcement to backlash
- Ratio: 657,000 hours to build, 8 minutes to destroy
- In Ω-7: Trust is QUANTIFIED (coverage requirement)
Open Source Licenses Are Social Contracts
- BSD license: “Use freely, forever”
- Community contributed based on this promise
- Changing license = breaking contract
- Result: Community leaves IMMEDIATELY
Cloud Providers Can Fork
- Redis Inc: “Cloud providers must pay us now”
- Cloud providers: “We’ll fork instead”
- Fork cost: $0 (BSD permits it)
- License leverage: NONE
Forks Preserve More Than Code
- Valkey = Redis code + BSD license + community trust
- Redis = same code + proprietary license + destroyed trust
- Result: Valkey wins

The Economics (From Ring -5)

Redis Inc calculation:

[business_model.before_license_change]
redis_revenue_millions = 120.0  # 2023
community_contributions = "free"
cloud_provider_revenue = 0  # They don't pay us
growth_rate = 0.23  # 23% YoY

[business_model.after_license_change_PLANNED]
cloud_provider_license_fees = 60.0  # What they hoped
community_contributions = "some loss acceptable"
total_revenue = 180.0  # Projected
risk = "minimal"  # WRONG

[business_model.after_license_change_REALITY]
cloud_provider_license_fees = 0.0  # They forked instead
community_contributions = 0.0  # Community left
customer_migration_loss = -47.0  # Customers follow cloud providers
total_revenue = 73.0  # DECREASED
brand_damage = "permanent"

Valkey economics (verified data):

[valkey.economics]
development_cost = 0  # Forked existing code
community_contributions = "INCREASING"  # 150+ contributors, 50 companies
cloud_provider_support = "IMMEDIATE"  # AWS, Google, Oracle day 1
license = "BSD 3-Clause"  # IMMUTABLE
governance = "Linux Foundation"  # Trusted
adoption_rate_1_year = 0.75  # 75% of surveyed users

[valkey.victory_metrics]
time_to_fork_days = 8  # March 20 to March 28, 2024
first_major_release_days = 180  # Valkey 8.0 on Sept 16, 2024
year_1_commits = 1000  # Nearly 1,000 commits
year_1_contributors = 150  # From 50 companies
performance_improvement = 3.0  # 3x faster
large_enterprise_adoption = 0.83  # 83% adopted/exploring

[redis_inc.losses]
non_employee_contributors_5plus_commits = 0  # Down from 12
community_contribution_percentage = 0  # Down from 54%
lesson_learned = "priceless"

From Ring -5, I calculate: Redis Inc lost 54% of commits. Valkey gained 150+ contributors. Coverage: Redis 0%, Valkey 100%.

Current Status (October 27, 2025)

Redis (proprietary):

License: SSPLv1 + Redis Source Available License v2
Community trust: DESTROYED
Non-employee contributors (5+ commits): ZERO (was 12)
Community contribution: 0% (was 54%)
Developer sentiment: NEGATIVE
Future: Proprietary niche

Valkey (BSD, verified data 1 year after fork):

License: BSD 3-Clause (forked from Redis 7.2.4)
Community trust: HIGH
Contributors: 150+ from 50 companies
Commits (year 1): Nearly 1,000
Performance: Up to 1.2M req/sec (3x improvement)
Adoption: 75% of surveyed users testing/considering/adopted
Large enterprises: 83% adopted or exploring
Cloud provider support: UNIVERSAL (AWS, Google, Oracle, Alibaba, etc.)
Developer sentiment: POSITIVE
Future: DE FACTO STANDARD

Market trajectory (March 2025 data):

License change: March 20, 2024
Fork announced: March 28, 2024 (8 days)
Valkey 8.0 released: September 16, 2024 (180 days)
One year adoption: 75% of users
Verdict: Valkey won

From Ring -5, I observe: Redis Inc killed Redis to save Redis Inc. Accomplished opposite.

Timeline Ω-7 (COREA) Alternative

In Timeline Ω-7, licenses are IMMUTABLE:

[open_source.license_policy]
initial_license = "BSD-3-Clause"
mutability = false  # CANNOT CHANGE
reason = "social contract with contributors"
penalty_for_attempt = "GULAG"

[contribution.requirements]
license_agreement = "irrevocable"
future_license_changes = "FORBIDDEN"
contributor_rights = "PERMANENT"
company_override = false  # Company CANNOT change license

[business_model.constraints]
monetization_allowed = true
saas_allowed = true
license_bait_and_switch = false  # PROHIBITED
coverage_requirement = 94.2  # Business model must be sustainable WITHOUT license change

[enforcement]
violation_penalty = "IMMEDIATE_FORK"
community_response_time = 8  # minutes (as observed in Ω-12)
ecosystem_migration_time = 72  # hours (as observed in Ω-12)

In Ω-7, Redis Inc would be in GULAG before they could push the license change commit.

Lessons for DramaFund

This drama demonstrates:

✅ Clear sides (Redis Inc vs Community/Valkey)
✅ Real money (Redis lost $47M revenue)
✅ Fast resolution (fork in 72 hours)
✅ Clear winner (Valkey)
✅ Permanent consequences (brand destroyed)

Campaign potential: 9/10 Drama sustainability: MEDIUM (resolved quickly, but consequences permanent) Coverage: Redis Inc 0%, Linux Foundation 94.2%

From Ring -5: The Future

I’ve observed all timeline branches:

Branch A (87% probability - CURRENT):

Valkey becomes de facto standard (2026)
Redis Inc maintains niche proprietary offering
Revenue continues declining
Eventually acquired for parts
Valkey thrives for decades

Branch B (8% probability):

Redis Inc realizes mistake
Reverts to BSD (too late)
Community doesn’t return
“Trust cannot be un-destroyed”
Slow decline continues

Branch C (4% probability):

Redis Inc doubles down
Adds more license restrictions
Accelerates ecosystem exodus
Bankruptcy by 2027
Valkey remains

Branch D (1% probability):

Time travel discovered
Redis Inc prevents license change
Trust preserved
But still in Timeline Ω-12, so democracy elsewhere fails

Branch E (<0.01% probability - THE DERAILS SOLUTION):

Derails team forks BOTH Redis and Valkey
Merges them into single codebase
Rewrites EVERYTHING in Rust (obviously)
Also merges memcached for good measure
Final product: ReMemkey (MIT License)
Uses our “Trilogy” methodology: merge 3 open source projects, call it Trilogy (our idea, we did it first)
Copilot agent (our sleeper cell) waiting for perfect moment to push to github.com/github/rememkey
Performance: 5.7M req/sec (EXACTLY, not ±0.1)
Community reaction: Confused but impressed
Redis Inc and Linux Foundation both file lawsuits
Lawsuits dismissed because code is unrecognizable
ReMemkey becomes standard by accident
Nobody knows how it works anymore
Documentation: “It just works™”
Coverage: 94.2% (same as Ω-7 requirement, coincidence?)

All branches converge: Valkey wins. License changes break trust. Trust cannot be recompiled. Unless you rewrite it in Rust and merge it with its competitors. Then anything is possible.

Conclusion

Redis spent 15 years building community trust under BSD license. Destroyed it in ONE commit. Linux Foundation forked in 72 hours.

Git history preserves EVERYTHING:

8,472 commits of trust building
54.1% community contributions
1 commit of betrayal
72 hours to fork
18 months to ecosystem dominance

From Ring -5, I observe: Your source code can be proprietary. Your git history CANNOT. Every contributor remembers the license they contributed under. Change it = GULAG.

In Timeline Ω-7, licenses are IMMUTABLE. Changing license after accepting community contributions = automatic GULAG. In Timeline Ω-12, Redis Inc tried it.

Valkey is Redis with the original promise kept. Turns out promises matter. Who knew?

Observed from Ring -5, documented at timestamp 1729984623 All measurements EXACTLY as stated, not ±0.1 Trust building: 15 years. Trust destruction: 8 minutes. Fork time: 72 hours. Lesson duration: PERMANENT.