Redis Gets Arrays: WASM Playground Built by Claude Code

Salvatore Sanfilippo, the original creator of Redis, has submitted a pull request introducing a fundamentally new data type — arrays — to the world's most popular in-memory data store. To make the experimental feature immediately accessible, an interactive playground built entirely by Claude Code now lets developers test all 18 new array commands directly in their browser via a WebAssembly-compiled subset of Redis.

The development marks one of the most significant structural additions to Redis in years, and the AI-assisted tooling around it demonstrates how large language models are accelerating the pace of open-source experimentation.

Key Takeaways

• Redis creator Salvatore Sanfilippo has proposed a native array data type via a new pull request
• The PR introduces 18 new commands for array manipulation, from basic CRUD to pattern matching and ring buffer operations
• An interactive WASM-based playground lets developers experiment with the commands in-browser — no installation required
• The playground was built using Claude Code, Anthropic's AI coding agent, showcasing AI-assisted rapid prototyping
• The implementation currently lives in a separate branch and is not yet merged into Redis's main codebase
• This represents Redis's most substantial data type addition since Streams were introduced in version 5.0

18 New Commands Expand Redis's Data Model

The proposed array data type comes with a comprehensive command set that covers everything developers would expect from a first-class Redis citizen. Unlike Redis lists, which are implemented as linked lists optimized for push/pop operations at the ends, arrays appear designed for efficient random access and range-based operations.

Here is the full set of 18 new commands included in the PR:

• ARSET / ARGET — Set and get individual elements by index
• ARMSET / ARMGET — Multi-set and multi-get for batch operations
• ARLEN / ARCOUNT — Get length and count elements matching criteria
• ARINSERT / ARDEL / ARDELRANGE — Insert, delete single elements, and delete ranges
• ARGETRANGE / ARLASTITEMS — Retrieve slices and tail elements
• ARGREP / ARSCAN / ARSEEK / ARNEXT — Pattern matching, scanning, and Cursor-based iteration
• AROP — Perform operations on array elements
• ARRING — Ring buffer functionality for fixed-size circular arrays
• ARINFO — Metadata and introspection for array keys

The breadth of the command set suggests Sanfilippo is thinking about arrays as more than a simple indexed collection. The inclusion of ARGREP for pattern matching and ARRING for ring buffer behavior hints at use cases in logging, time-series data, and stream processing — areas where Redis already competes but often requires workarounds with existing data types.

Claude Code Powers the Browser-Based Playground

Perhaps equally noteworthy as the Redis PR itself is how the accompanying playground was built. Rather than waiting for the feature to be merged and released, a developer used Claude Code — Anthropic's agentic coding tool — to compile a subset of Redis to WebAssembly and wrap it in an interactive web interface.

The result is a fully functional playground that runs a real Redis engine inside the browser tab. Developers can type array commands, see results instantly, and experiment with the new data type without installing anything or spinning up a server. This approach mirrors the growing trend of WASM-based developer tools, similar to how projects like SQLite and PostgreSQL have been compiled to run client-side for educational and prototyping purposes.

The fact that Claude Code could handle this task — compiling C code to WASM, building a web frontend, and wiring up an interactive REPL — underscores how AI coding assistants are moving beyond simple autocomplete into genuine software engineering workflows. Building a WASM compilation pipeline for a complex C project like Redis is non-trivial work that traditionally would require deep expertise in both Emscripten toolchains and Redis internals.

Why Arrays Matter for Redis's Future

Redis currently supports strings, lists, sets, sorted sets, hashes, streams, and several specialized types like HyperLogLog and bitmaps. Each serves a distinct access pattern, and Redis's philosophy has always been to offer purpose-built data structures rather than forcing everything into a generic key-value model.

Arrays fill a gap that has long frustrated developers. Redis lists are implemented as quicklists (a linked list of ziplist nodes), which makes them excellent for queue-like patterns but suboptimal for random access by index. Accessing the 1,000th element in a Redis list is an O(N) operation, while a true array would make it O(1).

This distinction matters enormously for use cases like:

• Leaderboards with positional lookups — retrieving a player's score by rank without scanning
• Time-series buckets — storing fixed-interval samples with direct index access
• Feature vectors for ML — storing and retrieving embedding dimensions efficiently
• Circular buffers — the ARRING command directly supports ring buffer patterns for logging and monitoring
• Batch processing pipelines — ARMGET and ARMSET enable efficient bulk operations

Compared to workarounds using sorted sets or Lua scripting, native arrays would offer cleaner semantics and likely better performance for these patterns.

The Growing Role of AI in Open-Source Development

This project sits at an interesting intersection of two major trends: the evolution of foundational infrastructure software and the integration of AI tools into the development process. The speed at which the playground was created — leveraging Claude Code to handle the complex build pipeline — illustrates a broader shift in how open-source projects can lower barriers to experimentation.

Traditionally, trying out an experimental Redis branch would require cloning the repository, checking out the branch, compiling from source, and running a local server. The WASM playground eliminates all of that friction, making it possible for thousands of developers to test and provide feedback on the new feature immediately.

This pattern — AI-assisted developer tooling for experimental features — could become a standard part of the open-source contribution workflow. Imagine every major PR to a project like Redis, PostgreSQL, or Linux automatically generating an interactive demo environment. Tools like Claude Code, GitHub Copilot, and Cursor are making this increasingly feasible.

What This Means for Developers and Businesses

For application developers, native arrays in Redis could simplify architectures that currently rely on multiple data types or external processing to achieve indexed collection semantics. Teams using Redis for real-time analytics, gaming leaderboards, or ML feature stores should pay close attention to this PR's progress.

For DevOps and platform teams, the WASM playground model offers a template for internal tooling. Compiling server-side infrastructure to run in the browser for testing and training purposes is a powerful pattern that AI coding tools now make accessible to smaller teams.

For the Redis ecosystem broadly, this PR signals that Sanfilippo — who stepped back from day-to-day Redis development several years ago — remains actively engaged in pushing the project's technical boundaries. His involvement lends significant credibility to the array proposal and increases the likelihood of eventual adoption.

Looking Ahead: From Branch to Production

The array data type currently lives in a feature branch and has not been merged into Redis's main codebase. Several important questions remain before it could ship in a stable release:

• Memory efficiency — How do arrays compare to lists and sorted sets in memory consumption?
• Persistence behavior — How are arrays serialized in RDB and AOF formats?
• Cluster compatibility — Do array commands work correctly in Redis Cluster mode?
• Client library support — Major clients in Python, Java, Go, and Node.js would need updates
• Performance benchmarks — Quantitative comparisons against existing workarounds

Developers interested in the feature can explore the interactive playground now and follow the PR for updates. The combination of Sanfilippo's deep Redis expertise and AI-powered rapid prototyping tools like Claude Code suggests this kind of accelerated experimentation cycle will become increasingly common across the open-source landscape.

Whether or not arrays make it into a future Redis release, this project demonstrates a compelling model: propose a feature, build an instant demo with AI assistance, and let the community evaluate it in real time. That workflow alone may prove as influential as the data type itself.