2009 – 2026

Redis Versions

Every release of Redis — the in-memory data-structure store used as a database, cache, and message broker — from Salvatore Sanfilippo's 2009 original through the 8.x line. Redis 8.8 (May 2026) is the current stable release; Redis is open source again under AGPLv3 since 8.0. With ship dates and the headline changes per major — Redis Cluster (3.0), the Modules API (4.0), Streams (5.0), ACLs and RESP3 (6.0), and Functions (7.0) — plus the licensing arc this page exists to explain: fifteen years of BSD, the March 2024 move to source-available licensing, and the May 2025 return to open source.

The question this page answers, version by version

Is Redis open source? The BSD → source-available → AGPL arc.

For its first fifteen years — every release from 1.0 (2009) through 7.2 (2023) — Redis shipped under the permissive BSD-3-Clause license, unambiguously open source. On March 20, 2024, Redis Ltd. relicensed the core, effective with Redis 7.4, to a dual source-available license — the Redis Source Available License v2 (RSALv2) and the Server Side Public License (SSPLv1), neither of which is OSI-approved. The stated goal was to stop cloud providers from selling managed Redis without contributing back. Versions 7.2.x and earlier stay BSD.

The twist: Sanfilippo (“antirez”), Redis's creator, returned in late 2024 and pushed to reopen the source. Redis 8.0 (May 2025) added the OSI-approved AGPLv3 as a third option, making Redis open source again — it is now tri-licensed RSALv2 / SSPLv1 / AGPLv3 at your choice — and folded the former “Redis Stack” modules into core. So the honest answer to “is Redis open source?” depends on the version: yes for ≤ 7.2 (BSD), no for 7.4 (source-available only), and yes again for 8.0+ (AGPLv3). The badges and the two dividers in the table below mark each boundary. Canonical texts: redis.io/legal/licenses.

License era

BSD — 1.0 through 7.2 (2009–2023), permissive open source
Source-available — 7.4 only (RSALv2 / SSPLv1); not OSI open source
AGPL, open again — 8.0+ (tri-licensed RSALv2 / SSPLv1 / AGPLv3)

Redis publishes no formal per-version LTS / EOL matrix. In practice the latest major line gets patches, and Redis also backports critical security fixes to the last widely deployed BSD and source-available lines (7.2, 7.4) and to 6.2 — each of which received patch releases as recently as 2026. The table below lists one row per major / feature minor; the current stable tip (8.8, May 2026) rides on top of the 8.0 line. Per-version release notes live in the GitHub release tags; endoflife.date keeps a support-window view.

Redis version table

Version
Redis 8.0
AGPL / open
May 2025
Open source again — AGPLv3 re-added; the former Redis Stack modules (JSON, Time Series, probabilistic types, the Query Engine, Vector Sets) folded into core; large performance gains. Current stable: 8.8 (May 2026).
  • AGPLv3 re-added — open source again — Redis 8.0 added the OSI-approved AGPLv3 as a third license option alongside RSALv2 and SSPLv1, returning Redis to open source after the 7.4 source-available interlude. Announced May 1, 2025; 8.0 GA'd May 2, 2025. See the license callout and redis.io/legal.
  • Redis Stack folded into core — the capabilities that used to ship as separate modules are now part of Redis itself under the same license: JSON, Time Series, probabilistic data types (Bloom, Cuckoo, Count-Min, Top-K, t-digest), and the Redis Query Engine (secondary indexing and full-text / vector search). RedisJSON, which had not been open source since 2018, is open again under AGPLv3.
  • Vector Sets — a new native data type for vector-similarity search, developed by Sanfilippo after his return; aimed at embeddings / AI-retrieval workloads.
  • Performance — Redis billed 8.0 as its fastest release, citing up to ~87% faster commands on some operations, higher throughput, and faster replication.
  • The 8.x cadence — roughly quarterly feature minors ride on the 8.0 line: 8.2 (Aug 2025), 8.4 (Nov 2025), 8.6 (Feb 2026), and 8.8 (May 2026, current). Confirm the live tip in the GitHub releases.
May 2025 — AGPLv3 re-added at 8.0. The release above this divider (8.0 and later) is tri-licensed RSALv2 / SSPLv1 / AGPLv3 — open source again by the OSI's bar. The 7.4 release below shipped source-available only. See the callout above and the license history.
Version
Redis 7.4
Source-available
Jul 2024
The first source-available release — dropped BSD for the dual RSALv2 / SSPLv1 license (the March 2024 relicensing landed here). Hash-field TTLs; updated query and probabilistic features.
  • The source-available relicensing — announced March 20, 2024 and effective with 7.4 (July 2024): Redis dropped BSD-3-Clause for a dual RSALv2 + SSPLv1 license. Neither is OSI-approved, so 7.4 is “source-available, not open source.” 7.2 and every earlier release remain BSD. See the license callout.
  • Hash-field expiration — TTLs on individual fields within a hash (HEXPIRE, HPEXPIRE, HTTL, and friends), long a top feature request for caching object fields with independent lifetimes.
  • Query and probabilistic updates — 7.4 shipped alongside refreshed versions of the search / query engine and the probabilistic data types that would later fold into core at 8.0.
  • Still patched — 7.4.x continues to receive security backports (latest 7.4.9, May 2026), since it is the last of the source-available 7.x line.
March 2024 — BSD → source-available. Redis 7.4 (above) was the first release under the dual RSALv2 / SSPLv1 source-available license. Redis 7.2 and every release below it — back through 1.0 — shipped under the permissive BSD-3-Clause license. See the callout above and the license history.
Version
Redis 7.2
BSD
Aug 2023
The last BSD-licensed major. Scalable, auto-vectorized functions; performance and memory work; the unified “Redis 7.2” source build. 7.2.4 is the last BSD release.
  • The last BSD major — every release from 1.0 through 7.2 shipped under BSD-3-Clause; the relicensing hit at 7.4. Redis 7.2.4 is the final BSD-licensed build.
  • Performance and internals — faster replication and reduced memory overhead; improvements to the underlying data-structure implementations; refinements to Functions and to keyspace behaviors introduced in 7.0.
  • Still patched — 7.2.x remains widely deployed and receives security backports (latest 7.2.14, May 2026).
Version
Redis 7.0
BSD
Apr 2022
Redis Functions; sharded pub/sub for Cluster; ACL v2 with key-pattern selectors; multi-part AOF; command introspection.
  • Redis Functions — server-side logic loaded as named, replicated libraries (FUNCTION LOAD), a durable successor to ad-hoc EVAL Lua scripts that are part of the dataset and survive restarts and failovers.
  • Sharded pub/sub — SPUBLISH / SSUBSCRIBE keep publish/subscribe traffic local to a Cluster shard instead of broadcasting cluster-wide.
  • ACL v2 — selectors and fine-grained key-pattern / command-category permissions on top of the 6.0 ACL system.
  • Multi-part AOF — the append-only file split into a base snapshot plus incremental files in a manifest, for faster and safer rewrites; command introspection via COMMAND DOCS / COMMAND INFO.
Version
Redis 6.2
BSD
Feb 2021
A broad command-surface expansion — GETEX, GETDEL, COPY, SMISMEMBER, ZDIFF / ZRANGESTORE, LMPOP; RESET; client eviction controls.
  • Command breadth — dozens of additions and refinements: GETEX / GETDEL, COPY, SMISMEMBER, ZDIFF / ZINTER / ZUNION and ZRANGESTORE, LMPOP / ZMPOP, and expanded EXPIRE options (NX / XX / GT / LT).
  • RESET — return a connection to its just-connected state in one command; client no-evict and per-client memory controls.
  • Operational polish — better replication (disk-less loading), progress reporting, and RESP3 refinements building on 6.0. The most-used stable line before 7.0.
Version
Redis 6.0
BSD
Apr 2020
ACLs; the RESP3 protocol; TLS; threaded I/O; client-side caching; diskless replication.
  • Access Control Lists (ACLs) — Redis's first real user/permission system: named users, per-command and per-key-pattern rules, replacing the single shared requirepass password.
  • RESP3 protocol — a richer wire protocol with native map, set, double, and big-number reply types (opt-in via HELLO 3), the foundation for client-side caching and clearer client semantics.
  • Threaded I/O — socket reads and writes offloaded to threads for higher throughput on multi-core hosts. Command execution stays single-threaded, preserving Redis's atomicity guarantees.
  • TLS support in core; client-side caching (server-assisted key tracking); disk-less replication improvements and better diagnostics.
Version
Redis 5.0
BSD
Oct 2018
The Streams data type — an append-only log with consumer groups; new sorted-set commands; RDB v9; cluster management folded into redis-cli.
  • Streams — a persistent, append-only log data type (XADD / XREAD) with consumer groups (XREADGROUP / XACK) for at-least-once fan-out to competing workers. Redis's answer to log / queue workloads people had been approximating with lists and pub/sub.
  • Sorted-set additions — ZPOPMIN / ZPOPMAX and the blocking BZPOPMIN / BZPOPMAX, making priority-queue patterns first-class.
  • Cluster tooling — the old redis-trib.rb Ruby helper was reimplemented inside redis-cli --cluster; new RDB version 9; better memory reporting and defragmentation.
Version
Redis 4.0
BSD
Jul 2017
The Modules API; PSYNC2 improved replication; LFU eviction; asynchronous UNLINK / FLUSH; mixed RDB-AOF persistence.
  • The Modules API — load compiled C modules to add commands and whole new data types without forking Redis. This is the seed of everything that later became Redis Stack — RediSearch, RedisJSON, RedisTimeSeries, RedisBloom — and that folded back into core at 8.0.
  • PSYNC2 — a rewritten replication handshake that can partial-resync across restarts and primary failovers, avoiding full resyncs.
  • LFU eviction — a least-frequently-used eviction policy alongside LRU; asynchronous deletion (UNLINK, FLUSHALL ASYNC) to free large keys off the main thread.
  • Mixed RDB-AOF persistence — an AOF rewrite that prepends an RDB snapshot for faster loads; memory-command introspection (MEMORY USAGE / DOCTOR).
Version
Redis 3.2
BSD
May 2016
Geospatial commands (GEOADD / GEORADIUS); BITFIELD; Lua-script effects replication; memory optimizations for small aggregate types.
  • Geospatial indexing — GEOADD, GEORADIUS, GEODIST and friends, storing lat/long in a sorted set and querying by radius. Location features without a separate spatial database.
  • BITFIELD — treat a string as an array of arbitrary-width integers for compact counters and bitmap tricks.
  • Effects replication for Lua scripts (replicate the resulting writes rather than the script) and memory optimizations for small lists/hashes/sets. A quenchless-list quicklist encoding reduced list memory substantially.
Version
Redis 3.0
BSD
Apr 2015
Redis Cluster — automatic sharding and failover across nodes. The modern-era boundary; also a faster replication protocol and improved persistence.
  • Redis Cluster (GA) — data automatically sharded across up to 16,384 hash slots spread over master nodes, with replica promotion on failure and no external proxy. The feature Sanfilippo spent several years building, and the reason 3.0 is the boundary between early and modern Redis.
  • Replication and persistence — a faster, more robust replication path and improvements to RDB / AOF handling.
  • The modern-era boundary — releases before 3.0 (1.x and 2.x) are folded into the pre-3.0 collapsible below; they predate Cluster and are not what you would deploy today.
Version
Pre-3.0 (1.x – 2.x)
BSD
2009 – 2013
The early lineage: 1.0 (2009) through 2.8 (2013). Core data structures, both persistence models (RDB and AOF), scripting, and Sentinel all land here. Included for completeness.

Salvatore Sanfilippo (“antirez”) created Redis in 2009 for his own startup and released it under BSD. These releases predate the Redis Cluster / modern-era boundary at 3.0 and are listed here rather than as full rows:

  • 1.0 (2009) — the first release: an in-memory key-value store with core data structures (strings, lists, sets) and RDB snapshot persistence.
  • 2.0 (Sep 2010) — a major expansion: hashes, the append-only file (AOF) persistence mode, MULTI/EXEC transactions, and publish/subscribe.
  • 2.4 (2011) — performance and memory improvements; consolidation of the 2.x line.
  • 2.6 (2012) — Lua scripting (EVAL), millisecond-precision expiration, and bitmap commands (BITCOUNT / BITOP).
  • 2.8 (Nov 2013) — Redis Sentinel for high availability, keyspace notifications, partial resynchronization (PSYNC), and the cursor-based SCAN family.

All of the above shipped under BSD. None receives updates; nothing here is what you would install today. The 2009 origin and the antirez lineage are covered in the history below.

Click any row to expand. Each row has a stable id for sharing — e.g. /software/redis/versions/#redis-8-0, #redis-7-4, #redis-pre-3-0. Per-version release notes live in the GitHub release tags; the license texts are at redis.io/legal/licenses.

The 2009 origin and the antirez lineage

Redis began in 2009 as a project by the Italian developer Salvatore Sanfilippo, known online as antirez. He built it to scale the real-time analytics of his own startup, needing an in-memory store with richer values than a plain cache — not just strings, but lists, sets, and hashes as first-class server-side data structures. He open-sourced it under the permissive BSD license, and the name is a contraction of “REmote DIctionary Server.”

Commercial stewardship passed through several hands while the project stayed BSD and Sanfilippo stayed lead maintainer: VMware sponsored his full-time work on Redis from 2010, then Pivotal, and from 2015 the company Redis Labs — later renamed Redis Ltd. (and now Redis Inc.) — became the primary sponsor and trademark holder. Sanfilippo led development until 2020, when he stepped back from day-to-day maintenance and handed the project to a core team.

Redis grew into one of the most widely deployed pieces of infrastructure on the internet — a default choice for caching, session storage, rate limiting, queues, leaderboards, and pub/sub. Its single-threaded command execution (I/O was threaded only in 6.0) is a deliberate design choice: every command is atomic, which makes reasoning about concurrency simple and is a large part of why Redis is fast and predictable.

The build-out — from key-value cache to data platform

The version history reads as a steady widening of what Redis is. It started as an in-memory store for a handful of data structures with snapshot persistence, and each major added a capability that moved it further from “just a cache.” Redis Cluster (3.0) made it horizontally scalable with automatic sharding and failover. The Modules API (4.0) let third parties bolt on whole new data types — search, JSON, time series, probabilistic structures — which grew into the “Redis Stack” distribution.

Streams (5.0) added a persistent log with consumer groups, pulling queue and event-sourcing workloads onto Redis. 6.0 brought the plumbing a serious data platform needs — ACLs, the RESP3 protocol, TLS, threaded I/O, and client-side caching — and Functions (7.0) replaced ad-hoc Lua scripts with named, replicated server-side libraries that are part of the dataset.

That arc closed a loop at 8.0: the Stack modules that started as external add-ons in 4.0 — JSON, Time Series, probabilistic types, the Query Engine, and the new Vector Sets — folded back into core Redis. What began as a key-value cache in 2009 is now a multi-model data platform that also does documents, search, vectors, and time series in one process.

Is Redis open source? The 2024 relicensing and the 2025 return

Redis was BSD-licensed open source for its entire first fifteen years — every release from 1.0 through 7.2. By the early 2020s, Redis Ltd.'s commercial concern was the same one MongoDB, Elastic, and HashiCorp had already acted on: cloud providers offering managed Redis as a service and capturing much of the revenue without contributing back to the project.

On March 20, 2024, Redis Ltd. relicensed the core, effective with Redis 7.4, from BSD to a dual source-available model: the Redis Source Available License v2 (RSALv2) and the Server Side Public License (SSPLv1). Neither is approved by the Open Source Initiative — RSALv2 forbids offering the software as a competing managed service, and SSPL's service-source-disclosure condition has never been OSI-certified — so by the OSI's bar, Redis 7.4 is “source-available, not open source.” Versions 7.2.x and earlier remain BSD. The move prompted a community fork of the last BSD release, Valkey.

The direction reversed within a year. Sanfilippo returned to Redis in late 2024 and, by his own account, argued internally for reopening the source. Redis 8.0 (May 2025) added the OSI-approved AGPLv3 as a third license option, so Redis is once again open source — now tri-licensed RSALv2 / SSPLv1 / AGPLv3, with users free to choose the AGPL and treat Redis as OSI open source. The same release folded the former Redis Stack modules into core under the same license.

The fair summary is that the “is Redis open source?” question has a different answer for each of three periods, which is exactly why the badges and dividers in the table above are keyed to license rather than to features: BSD open source through 7.2, source-available at 7.4, and AGPLv3 open source again from 8.0. Sanfilippo has framed the reopening as a return to Redis's roots; critics have argued it came only after the fork cost Redis momentum. This page states what changed and when, and points to the primary texts — the Redis license page and antirez's own blog — rather than adjudicating who was right.

Find your version — in the shell or redis-cli

The browser cannot detect what version of Redis you're running — there's no header or fingerprint that exposes it. Run one of these in your shell or in redis-cli to see your real install.

What's running?

Print the server version, the CLI version, or ask a running server directly.

$ redis-server --version          # server version + build
$ redis-cli --version             # CLI version

# Ask a running server directly:
$ redis-cli INFO server | grep redis_version   # e.g. redis_version:8.8.0

# Inside redis-cli:
127.0.0.1:6379> INFO server            # look for the redis_version: field

Pin a project to a specific Redis

Most projects pin via the official Docker image tag; the major (8) floats minors and patches, an exact tag (8.8.0) freezes them.

# docker-compose.yml
services:
  cache:
    image: "redis:8"                    # floats the 8.x line
    image: "redis:8.8"                  # floats patches of 8.8
    image: "redis:8.8.0"                # pinned exact

# One-off container:
$ docker run -d -p 6379:6379 redis:8

Install or upgrade a version

Redis 8 is open source again (AGPLv3), so it's back in Homebrew core and the official Docker library image.

# macOS (Homebrew core)
$ brew install redis
$ brew services start redis

# Debian / Ubuntu
$ sudo apt-get install -y redis

# Fedora / RHEL
$ sudo dnf install -y redis

# Docker (no repo setup needed)
$ docker run -d -p 6379:6379 redis:8

# Or download / build from source:
#   https://redis.io/downloads/

Sources: redis.io/docs; github.com/redis/redis releases; redis.io/legal/licenses; antirez's blog; the Open Source Initiative; endoflife.date/redis; and per-version release notes cited inline. Last updated July 2026.

Mungomash LLC · More software pages

Last refreshed 2026-07-04 by Hyperion — new page.