Redis 8.8: What's New, Release History & Support Lifecycle

What is the new Array data structure in Redis 8.8 and when should you use it?

Redis 8.8 ships a first-class Array data type, contributed by Redis creator Salvatore Sanfilippo (@antirez), giving you ordered, index-accessible sequences as a native value type separate from Lists and Sorted Sets. In practice, Array fills the gap for use cases that need dense, positionally-addressed storage without the overhead of sorted set scores or the FIFO/LIFO semantics of Lists.

This matters if you are storing things like time-bucketed metrics, fixed-width sliding windows, or ordered tuples where random reads by index are the hot path. Lists require O(n) traversal for arbitrary index access; Array is designed to do better. Watch out for memory profiling on large arrays in the initial release and monitor your MEMORY USAGE output before rolling this out at scale.

# Store a fixed-size ordered sequence
ARRAY.SET myarray 0 "alpha"
ARRAY.SET myarray 1 "beta"
ARRAY.SET myarray 2 "gamma"

# Random index access
ARRAY.GET myarray 1
# "beta"

How does INCREX simplify rate limiting in Redis 8.8?

INCREX is a single atomic command that combines counter increment, optional bounds enforcement, and key expiration into one round-trip, replacing the multi-command patterns teams previously had to script with Lua or pipeline manually.

Before Redis 8.8, a typical sliding-window rate limiter required at least a MULTI/EXEC block or a Lua script wrapping INCR, a bounds check, and EXPIRE. With INCREX you express all of that in one command. This matters if you are running high-throughput API gateways where each extra round-trip is latency you cannot afford.

# Increment a counter by 1, cap at 100, expire the key after 60 seconds
# Returns the new value, or an error if the bound would be exceeded
INCREX api:user:42:requests 1 MAX 100 EX 60

# Fractional increments (INCRBYFLOAT semantics) also supported
INCREX score:player:7 0.5 MAX 9999.99 EX 3600

Note the syntax was corrected between RC1 and GA (fix #15237) -- if you evaluated INCREX on the release candidate, re-read the current docs before deploying.

What does XNACK add to Redis Streams and how is it different from XACK?

XNACK lets a consumer explicitly release a pending message back to the stream's pending entry list without acknowledging it, signaling to the group that the message was not processed and should be re-delivered or picked up by another consumer.

Before this command, the only clean escape hatch when a consumer could not process a message was to let the idle time tick up and rely on another consumer calling XAUTOCLAIM or XCLAIM after a timeout. That meant you were always racing against a timer. Most teams that built robust consumer groups had to implement application-level negative acknowledgment with workarounds; XNACK makes this a first-class protocol primitive.

# Consumer reads a message
XREADGROUP GROUP mygroup consumer1 COUNT 1 STREAMS mystream >

# Processing fails -- explicitly release the message back to pending
XNACK mystream mygroup <message-id>

# The message stays pending and can be claimed by another consumer
XAUTOCLAIM mystream mygroup consumer2 0 0-0

What improvements did Redis 8.8 bring to search, JSON, and time series commands?

Redis 8.8 delivers targeted quality-of-life improvements across the search, JSON, and time series modules that reduce the number of commands and round-trips required for common analytical patterns.

• FT.HYBRID KNN shard candidates: You can now pass a per-shard candidate count to FT.HYBRID, giving you a performance knob to trade recall for latency on large clusters. Pair this with FT.PROFILE HYBRID (also new) to measure the impact before tuning production.
• Multiple aggregators per TS.RANGE call: Time series range queries now accept more than one aggregator in a single command (TS.RANGE, TS.REVRANGE, TS.MRANGE, TS.MREVRANGE). In practice this eliminates the pattern of issuing N separate range commands to compute avg, min, and max over the same window.
• JSON.SET FPHA argument: Specify the floating-point representation for homogeneous FP arrays. This is important if you store ML embeddings or sensor readings and care about wire-format precision and memory layout consistency.
• COUNT aggregator for set operations: ZUNION, ZINTER, ZUNIONSTORE, and ZINTERSTORE now support a COUNT aggregator in addition to the existing SUM, MIN, and MAX options.

# Multiple aggregators in a single time series range call
TS.MRANGE - + AGGREGATION avg 60000 AGGREGATION max 60000 FILTER sensor=temp

# Sorted set union with COUNT aggregation
ZUNION 2 zset1 zset2 AGGREGATE COUNT WITHSCORES

How do field-level hash notifications change event-driven architectures on Redis 8.8?

Redis 8.8 introduces subkey notifications for hash fields, allowing clients to subscribe to keyspace or keyevent notifications scoped to individual hash fields rather than only the top-level key.

In a typical event-driven design backed by Redis hashes -- think session objects, user profiles, or feature flag maps -- a field update previously fired a notification on the entire hash key. Any subscriber had to fetch the whole hash and diff it to find what changed. With field-level notifications, a subscriber can react precisely to changes in, for example, user:42 -> status without pulling unrelated fields or doing client-side diffing. This matters if you have high-cardinality hashes and many downstream consumers that only care about a subset of fields.

# Enable keyspace notifications including hash field subkey events
# In redis.conf or via CONFIG SET:
CONFIG SET notify-keyspace-events "Khx"

# Subscribe to field-level events on a specific hash
PSUBSCRIBE __keyevent@0__:hset:user:42:status