redis/redis

This document serves as both a quick start guide to Redis and a detailed resource for building it from source.

• New to Redis? Start with What is Redis and Getting Started
• Ready to build from source? Jump to Build Redis from Source
• Want to contribute? See the Code contributions section

and CONTRIBUTING.md

• Looking for detailed documentation? Navigate to redis.io/docs

Table of contents

• What is Redis?
• Key use cases
• Why choose Redis?
• What is Redis Open Source?
• Getting started
• Redis starter projects
• Using Redis with client libraries
• Using Redis with redis-cli
• Using Redis with Redis Insight
• Redis data types, processing engines, and capabilities
• Cloud hosted Redis
• Community
• Build Redis from source
• Install dependencies and build
• Building Redis - flags and general notes
• Fixing build problems with dependencies or cached build options
• Fixing problems building 32 bit binaries
• Allocator
• Monotonic clock
• Verbose build
• Running Redis with TLS
• Code contributions
• Redis Trademarks

What is Redis?

For developers, who are building real-time data-driven applications, Redis is the preferred, fastest, and most feature-rich cache, data structure server, and document and vector query engine.

Key use cases

Redis excels in various applications, including:

• Caching: Supports multiple eviction policies, key expiration, and hash-field expiration.
• Distributed Session Store: Offers flexible session data modeling (string, JSON, hash).
• Data Structure Server: Provides low-level data structures (strings, lists, sets, hashes, sorted sets, JSON, etc.) with high-level semantics (counters, queues, leaderboards, rate limiters) and supports transactions & scripting.
• NoSQL Data Store: Key-value, document, and time series data storage.
• Search and Query Engine: Indexing for hash/JSON documents, supporting vector search, full-text search, geospatial queries, ranking, and aggregations via Redis Search.
• Event Store & Message Broker: Implements queues (lists), priority queues (sorted sets), event deduplication (sets), streams, and pub/sub with probabilistic stream processing capabilities.
• Vector Store for GenAI: Integrates with AI applications (e.g. LangGraph, mem0) for short-term memory, long-term memory, LLM response caching (semantic caching), and retrieval augmented generation (RAG).
• Real-Time Analytics: Powers personalization, recommendations, fraud detection, and risk assessment.

Why choose Redis?

Redis is a popular choice for developers worldwide due to its combination of speed, flexibility, and rich feature set. Here's why people choose Redis for:

• Performance: Because Redis keeps data primarily in memory and uses efficient data structures, it achieves extremely low latency (often sub-millisecond) for both read and write operations. This makes it ideal for applications demanding real-time responsiveness.
• Flexibility: Redis isn't just a key-value store, it provides native support for a wide range of data structures and capabilities listed in What is Redis?
• Extensibility: Redis is not limited to the built-in data structures, it has a modules API that makes it possible to extend Redis functionality and rapidly implement new Redis commands
• Simplicity: Redis has a simple, text-based protocol and well-documented command set
• Ubiquity: Redis is battle tested in production workloads at a massive scale. There is a good chance you indirectly interact with Redis several times daily
• Versatility: Redis is the de facto standard for use cases such as:
• Caching: quickly access frequently used data without needing to query your primary database
• Session management: read and write user session data without hurting user experience or slowing down every API call
• Querying, sorting, and analytics: perform deduplication, full text search, and secondary indexing on in-memory data as fast as possible
• Messaging and interservice communication: job queues, message brokering, pub/sub, and streams for communicating between services
• Vector operations: Long-term and short-term LLM memory, RAG content retrieval, semantic caching, semantic routing, and vector similarity search

In summary, Redis provides a powerful, fast, and flexible toolkit for solving a wide variety of data management challenges. If you want to know more, here is a list of starting points:

• Introduction to Redis data types
• The full list of Redis commands
• Redis for AI
• Redis documentation

What is Redis Open Source?

Redis Community Edition (Redis CE) was renamed Redis Open Source with the v8.0 release.

Redis Ltd. also offers Redis Software, a self-managed software with additional compliance, reliability, and resiliency for enterprise scaling, and Redis Cloud, a fully managed service integrated with Google Cloud, Azure, and AWS for production-ready apps.

Read more about the differences between Redis Open Source and Redis here.

Getting started

If you want to get up and running with Redis quickly without needing to build from source, use one of the following methods:

• Redis Cloud
• Official Redis Docker images (Alpine/Debian)

  docker run -d -p 6379:6379 redis:latest
  

• Redis binary distributions
• Snap
• Homebrew
• RPM
• Debian
• Redis quick start guides

If you prefer to build Redis from source - see instructions below.

Redis starter projects

To get started as quickly as possible in your language of choice, use one of the following starter projects:

• Python (redis-py)
• C#/.NET (NRedisStack/StackExchange.Redis)
• Go (go-redis)
• JavaScript (node-redis)
• Java/Spring (Jedis)

Using Redis with client libraries

To connect your application to Redis, you will need a client library. Redis has documented client libraries in most popular languages, with community-supported client libraries in additional languages.

• Python (redis-py)
• Python (RedisVL)
• C#/.NET (NRedisStack/StackExchange.Redis)
• JavaScript (node-redis)
• Java (Jedis)
• Java (Lettuce)
• Go (go-redis)
• PHP (Predis)
• C (hiredis)
• Full list of client libraries

Using Redis with redis-cli

redis-cli is Redis' command line interface. It is available as part of all the binary distributions and when you build Redis from source.

You can start a redis-server instance, and then, in another terminal try the following:

cd src
./redis-cli

redis> ping
PONG
redis> set foo bar
OK
redis> get foo
"bar"
redis> incr mycounter
(integer) 1
redis> incr mycounter
(integer) 2
redis>

Using Redis with Redis Insight

For a more visual and user-friendly experience, use Redis Insight - a tool that lets you explore data, design, develop, and optimize your applications while also serving as a platform for Redis education and onboarding. Redis Insight integrates Redis Copilot, a natural language AI assistant that improves the experience when working with data and commands.

• Redis Insight documentation
• Redis Insight GitHub repository

Redis data types, processing engines, and capabilities

Redis provides a variety of data types, processing engines, and capabilities to support a wide range of use cases:

• String: Sequences of bytes, including text, serialized objects, and binary arrays used for caching, counters, and bitwise operations.
• JSON: Nested JSON documents that are indexed and searchable using JSONPath expressions and with Redis Search
• Array: Sparse, index-addressable collection of string values
• Hash: Field-value maps used to represent basic objects and store groupings of key-value pairs with support for hash field expiration (TTL)
• Redis Search: Use Redis as a document database, a vector database, a secondary index, and a search engine. Define indexes for hash and JSON documents and then use a rich query language for vector search, full-text search, geospatial queries, and aggregations.
• List: Linked lists of string values used as stacks, queues, and for queue management.
• Set: Unordered collection of unique strings used for tracking unique items, relations, and common set operations (intersections, unions, differences).
• Sorted set: Collection of unique strings ordered by an associated score used for leaderboards and rate limiters.
• Vector set (beta): Collection of vector embeddings used for semantic similarity search, semantic caching, semantic routing, and Retrieval Augmented Generation (RAG).
• Geospatial indexes: Coordinates used for finding nearby points within a given radius or bounding box.
• Bitmap: A set of bit-oriented operations defined on the string type used for efficient set representations and object permissions.
• Bitfield: Binary-encoded strings that let you set, increment, and get integer values of arbitrary bit length used for limited-range counters, numeric values, and multi-level object permissions such as role-based access control (RBAC)
• Hyperloglog: A probabilistic data structure for approximating the cardinality of a set used for analytics such as counting unique visits, form fills, etc.
• \*Bloom filter: A probabilistic data structure to check if a given value is present in a set. Used for fraud detection, ad placement, and unique column (i.e. username/email/slug) checks.
• \*Cuckoo filter: A probabilistic data structure for checking if a given value is present in a set while also allowing limited counting and deletions used in targeted advertising and coupon code validation.
• \*t-digest: A probabilistic data structure used for estimating the percentile of a large dataset without having to store and order all the data points. Used for hardware/software monitoring, online gaming, network traffic monitoring, and predictive maintenance.
• \*Top-k: A probabilistic data structure for finding the most frequent values in a data stream used for trend discovery.
• \*Count-min sketch: A probabilistic data structure for estimating how many times a given value appears in a data stream used for sales volume calculations.
• Time series: Data points indexed in time order used for monitoring sensor data, asset

tracking, and predictive analytics

• Pub/sub: A lightweight messaging capability. Publishers send messages to a channel, and subscribers receive messages from that channel.
• Stream: An append-only log with random access capabilities and complex consumption strategies such as consumer groups. Used for event sourcing, sensor monitoring, and notifications.
• Transaction: Allows the execution of a group of commands in a single step. A request sent by another client will never be served in the middle of the execution of a transaction. This guarantees that the commands are executed as a single isolated operation.
• Programmability: Upload and execute Lua scripts on the server. Scripts can employ programmatic control structures and use most of the commands while executing to access the database. Because scripts are executed on the server, reading and writing data from scripts is very efficient.

Cloud hosted Redis

Fully-managed Redis with real-time performance at scale.

Redis Cloud

Community

Redis Community Resources

Build Redis from source

This section refers to building Redis from source. If you want to get up and running with Redis quickly without needing to build from source see the Getting started section.

These instructions apply to Redis 8.10 and above. For versions lower than 8.10, see the 8.8 build instructions.

Configuration files: the build steps below tell you to run

./src/redis-server redis.conf. Release tarballs bake the bundled modules'

loadmodule lines and per-module settings directly into redis.conf during

packaging, so an extracted release tarball is ready to run as-is. When

building from a git checkout instead, that module config lives in the

auto-generated redis-full.conf produced by make modules-update (and

regenerated by make sync-redis-conf) — run `./src/redis-server

redis-full.conf` there. Edit Redis-core settings in

redis.conf. See modules/MODULES.md

for the full config flow.

Install dependencies and build

Building Redis with all data structures (JSON, time series, Bloom / cuckoo / count-min / top-k, t-digest, and the Query Engine) needs a build toolchain plus a few version-sensitive dependencies — GCC/Clang, LLVM 21, CMake 3.25–3.31.6, Rust 1.94, OpenSSL, Python 3, and assorted -dev libraries. Instead of a per-OS package list, the repo installs them for you with make bootstrap, which detects your OS and installs each bundled module's prerequisites.

CMake version range matters. The modules require 3.25 ≤ CMake ≤ 3.31.6 — CMake 4.x is not supported and the build will fail with it. On distros that ship CMake 4.x by default (e.g. Ubuntu 26.04), pin a supported version, e.g. pip3 install 'cmake==3.31.6'. Note make bootstrap only installs CMake when it's missing or too old; it won't downgrade a pre-installed 4.x, so remove/pin that yourself.

1. Get the source

Either works — the release tarball already bundles the module sources; a git checkout needs one extra step to fetch them:

# A) Release tarball (recommended for building/running a release).
Replace  with the release tag — extracts into redis-/:
wget https://github.com/redis/redis/releases/download//redis-full-.tar.gz
tar xvf redis-full-.tar.gz && cd redis-
B) git checkout — clone the bundled modules once:
git clone https://github.com/redis/redis.git && cd redis
make modules-update

Check the release page's Assets for the bundle filename. Older releases, including 8.10.0 and 8.10.2, provide redis-full.tar.gz instead of the versioned filename. For those releases, replace the wget command above with the following; the extraction command stays the same:

wget -O redis-full-.tar.gz https://github.com/redis/redis/releases/download//redis-full.tar.gz

2. Install the build dependencies

Pick whichever option fits your environment:

1. Build inside the Docker build environment — recommended. The repo ships docker/Dockerfile.noble (Ubuntu 24.04) with every prerequisite baked in, so you build inside the container and never touch your host toolchain:

   docker build -f docker/Dockerfile.noble -t redis-build:noble .
# Multi-arch (requires docker buildx configured):
   docker buildx build --platform linux/amd64,linux/arm64 \
       -f docker/Dockerfile.noble -t redis-build:noble .
# Build with the working tree mounted:
   docker run --rm -it -v "$PWD":/workspace -w /workspace redis-build:noble \
       bash -lc 'make -j"$(nproc)" && make run'
   

2. Install everything on a fresh machine or container. On a clean environment (for example a throwaway ubuntu:24.04 container), let bootstrap install every prerequisite for Redis core and all cloned modules:

   make bootstrap
   

> ⚠️ make bootstrap installs system packages and may override existing versions of shared tools (compiler, CMake, LLVM, …). Prefer option 1, or run it in a disposable container, if that matters on your machine.

3. See only what's missing. To inspect which prerequisites are absent before installing anything, print one deduped list across Redis core and all modules:

   make bootstrap list
   

Then install just the reported packages yourself. (Version-gated deps are shown as name (>= X); optional test/coverage deps are listed separately and don't fail the check.)

4. Get the exact install commands to copy-paste. To run exactly what make bootstrap would, but only for the missing dependencies, use dry-run — it prints the precise install command for each missing dependency and installs nothing:

   make bootstrap dry-run
   

The commands are printed per module, so a dependency shared by several modules appears once for each. Work through them iteratively:

1. Copy-paste the commands for a module to install its dependencies. 2. Re-run make bootstrap dry-run — the deps you just installed no longer show, so you now see only what's still missing for the remaining modules. 3. Repeat until make bootstrap dry-run prints no install commands.

Manual, per-OS install (no Docker, and you'd rather not let make bootstrap touch your host): follow the per-OS dependency instructions in the 8.8 README, which still lists them explicitly — .

3. Build and run

export BUILD_TLS=yes            # optional — TLS support (needs OpenSSL dev libs)
make -j "$(nproc)"
Release tarball (module config is baked into redis.conf):
./src/redis-server redis.conf
From a git checkout, use the auto-generated module config instead:
./src/redis-server redis-full.conf

make (same as make build / make all) builds whatever is cloned under modules/*/src alongside Redis core. To build just the core data structures — even with modules cloned — use make build redis.

redis-server won't start: "Error loading the extension" / can't open a

.so. The config still lists modules that weren't built successfully — a

release tarball's redis.conf carries loadmodule lines for every bundled

module, and a module whose build failed leaves no .so behind. Either build

them (make bootstrap && make, or make build for the one that failed), or

comment out everything that isn't Redis core in the config you pass: the

loadmodule lines and that module's own settings below them (e.g.

search-, ts-, bf-, json-). Core-only alternative: ./src/redis-server

with no config file, or make build redis && ./src/redis-server redis.conf

from a git checkout, where redis.conf has no module block at all.

4. Install

make install PREFIX=/usr/local          # core binaries + every built module
sudo make install                       # same, into the default /usr/local
make uninstall PREFIX=/usr/local        # removes exactly what install placed

install is an alias for deploy: it builds first (nothing already up to date is recompiled), copies redis-server, redis-cli and redis-benchmark plus the three redis-server symlinks to $PREFIX/bin, each module's .so to $PREFIX/lib/redis/modules, and rewrites the loadmodule paths in the generated config to point there. DESTDIR= stages the files for packaging without changing the paths written to the config, and PROG_SUFFIX= installs suffixed program names (redis-server-alt, …).

To install without building at all, use SKIP_BUILD=1:

sudo make install SKIP_BUILD=1

Building Redis - flags and general notes

Redis can be compiled and used on Linux, OSX, OpenBSD, NetBSD, FreeBSD. We support big endian and little endian architectures, and both 32 bit and 64-bit systems.

It may compile on Solaris derived systems (for instance SmartOS) but our support for this platform is _best effort_ and Redis is not guaranteed to work as well as on Linux, OSX, and \*BSD