# Redis Open Source: what redis/redis actually ships, and how to start it

> Redis Open Source is the in-memory data structure server maintained at redis/redis. This covers what it is used for, how the server and its modules build, and the limits that decide whether it fits your workload.

**redis/redis** — In-memory data structure server used as a cache, message broker, and document and vector query engine for real-time, data-driven applications.

- Repository: https://github.com/redis/redis
- Website: http://redis.io
- Stars: 76,491 · Forks: 24,824
- Language: C
- License: not declared
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/redis-redis

## The problem Redis Open Source is aimed at

Most application stacks have one slow component: the round trip to durable storage. Redis attacks that by keeping the working set in memory and exposing it through data structures rather than through rows and columns. The README lists the intended uses plainly: caching with multiple eviction policies, key expiration and hash-field expiration; a distributed session store modelled as string, JSON or hash; a data structure server offering strings, lists, sets, hashes, sorted sets and JSON with higher-level semantics such as counters, queues, leaderboards and rate limiters; a key-value, document and time series store; a search and query engine with vector search, full-text search, geospatial queries, ranking and aggregations; and an event store with lists, sorted sets, sets, streams and pub/sub.

That breadth is the point and also the trap. A team that wants a cache gets a server that also persists, replicates, scripts and indexes. The README states that Redis keeps data primarily in memory and uses efficient data structures, which it says yields sub-millisecond read and write latency. Treat that as the design intent, not a guarantee for your hardware or your command mix.

The audience is developers building real-time, data-driven applications. If your queries are analytical scans over cold data, Redis is the wrong shape: the dataset has to fit the memory you are willing to pay for, and the README's own framing puts the value in responsiveness rather than in warehouse-style aggregation.

## How the server, protocol and modules fit together

Redis is a single server process that speaks a text-based protocol. The README calls the protocol simple and text-based, and points to a documented command set as the interface. Clients do not link against a library inside the server; they open a connection, send commands, and read replies. That is why the same server serves Python, Node.js, Spring Boot and .NET clients without a per-language server build.

Around the core sit three extension surfaces visible in the repository layout. The modules/ directory holds module sources and a manifest, and the top-level Makefile includes modules/manifest.mk, which parses a modules.yaml into AVAILABLE_MODULES and shared helpers. The README also describes a modules API that lets you extend functionality and implement new commands. Sentinel, for monitoring and failover, is configured through sentinel.conf at the repository root, and the test harness ships runtest, runtest-cluster, runtest-moduleapi and runtest-sentinel as separate entry points, which tells you clustering and module APIs are treated as distinct operational modes rather than as flags on one test runner.

Configuration lives in redis.conf at the root. TLS has its own document, TLS.md, and the README has a section on running Redis with TLS. The top-level Makefile is deliberately thin: its comment says the real work is in ./src/Makefile and ./modules/Makefile, and that plain make and make build route through scripts/build.sh, which decides per-module inclusion from what is actually cloned under modules/*/src rather than from a build flag. That is an unusual choice worth knowing before you write your own build scripts.

## Installing Redis and running a first command

The README offers several routes that skip compilation. The fastest is the official Docker image, which the README shows mapping the default port:

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

After that container starts, the server is listening on port 6379 on the host. The README also lists Redis Cloud, binary distributions via Snap, Homebrew, RPM and Debian packaging, and quick start guides at redis.io/docs. If you prefer to compile, the README has a Build Redis from Source section with an install-dependencies step, and the repository ships an INSTALL file and a deps/ directory for bundled dependencies.

Once something is running, connect with the CLI. The README points at redis-cli as one of the getting-started paths, and the same section shows the Docker command above as the way to get a server up. The interaction model is one connection, one command, one reply, against the documented command set over the text-based protocol.

If you build from source instead, be aware that the default goal in the top-level Makefile is build, and that goals without an explicit rule recurse only into src/, while make and make build go through scripts/build.sh. The Makefile comment explains one reason for the wrapper: it exports MAKE so recipe shell scripts can read it, because GNU make does not propagate MAKE into plain recipe shells and a PATH lookup could pick up an older system make.

## Where Redis Open Source stops being the right tool

Memory is the first boundary. The README states data is kept primarily in memory, so the practical ceiling on dataset size is the RAM you are prepared to buy, plus the overhead of the structures themselves. If your primary dataset is larger than that, Redis belongs in front of the real store, not in place of it.

Persistence is the second. The README describes Redis as a key-value, document and time series store, and redis.conf carries the persistence settings, but the README does not document rollback, point-in-time recovery guarantees, or a recovery procedure for a corrupted append-only file. If losing the last few seconds of writes is unacceptable, that gap is something you must close with your own testing, not with a paragraph in the README.

The third boundary is query capability. Redis has indexing, full-text search and aggregations, but it is not a relational engine. There are no joins across arbitrary tables and no cost-based planner in the sense a SQL database provides. Workloads that are mostly ad hoc analytical queries with unpredictable shapes will be cheaper on a columnar store.

Finally, the licence. The repository metadata gives no licence identifier, while the file listing shows LICENSE.txt at the root. The README's trademark section and the reference to Redis Ltd. products (Redis Software and Redis Cloud) mean you should read the actual licence file in the tag you deploy rather than assume terms from an older release.

## Redis compared with Memcached and PostgreSQL

Memcached is the closest comparison for the caching use case, and the difference is structural rather than a matter of speed. Memcached stores opaque blobs against string keys. Redis stores typed values and gives you operations on them: list pushes and pops for queues, sorted set scores for leaderboards, set membership for deduplication, hash fields for partial updates, and streams with consumer groups for event delivery. The README's key use cases lean on exactly those semantics. If all you need is get, set and expire, Memcached's narrower surface is a smaller thing to operate; the moment you want a rate limiter or a priority queue without a second system, Redis is the shorter path.

PostgreSQL is the other direction. It is durable by default, has a real query planner and joins, and its data does not have to fit in memory. Redis is faster for point reads and writes because it avoids the disk path and the planner. The README's own positioning supports a layered design: Redis as the fast tier, PostgreSQL as the system of record. Teams that try to collapse both into Redis usually discover the memory bill and the missing recovery story at the same time.

## Maintenance, releases and upgrade cost

The repository is not archived and the last push was on 2026-08-17. Recent releases on that date include 8.10.1, 8.8.2 and 8.6.6, which indicates three maintained lines rather than a single head. The README states that Redis Community Edition was renamed Redis Open Source with the v8.0 release, so documentation written before that rename will use the old name for the same codebase.

The upgrade cost is not in the server binary. It is in the surface around it: redis.conf keys, module versions, and client library expectations. The build system makes this concrete. Because plain make routes through scripts/build.sh and module inclusion is decided by what is cloned under modules/*/src rather than by a flag, a build that worked on one machine can produce a different set of modules on another. The Makefile comment about MAKE being exported exists precisely because recipe shells can resolve a different make binary than the user's interactive shell, which is the kind of difference that shows up as a mysterious build failure rather than as an error message.

The repository ships runtest, runtest-cluster, runtest-moduleapi and runtest-sentinel, so you can run the project's own suites against your build before you promote it. That is a cheaper check than waiting for a staging incident.

On licensing: the repository metadata does not declare a licence, and LICENSE.txt is present at the root. The README also carries a Redis Trademarks section and distinguishes Redis Open Source from Redis Software and Redis Cloud. Read LICENSE.txt in the exact tag you deploy and get your own legal review; nothing here is legal advice.

## Conclusion

Adopt Redis Open Source when your workload is latency-bound and fits in memory: caching, sessions, leaderboards, queues, streams, rate limiting, or vector retrieval in front of a slower store. Do not adopt it as your only copy of data you cannot rebuild, and do not adopt it if you need SQL joins, multi-statement transactions or a query planner, since the README positions it as a key-value, document and time series store rather than a relational engine. Before committing, verify three things against your own build: whether the LICENSE.txt in the tarball you fetched still carries the licence you expect, since the repository metadata does not state one; whether your eviction and persistence settings survive a restart of the specific version you installed; and whether the module you depend on is present in your build, because the top-level Makefile routes through scripts/build.sh and includes modules per what is cloned under modules/*/src rather than from a build flag.

## FAQ

### What is Redis used for?

The README lists caching with eviction policies and key expiration, distributed session storage, a data structure server for counters, queues, leaderboards and rate limiters, a key-value, document and time series store, search and query with vector and full-text search, and an event store using lists, sorted sets, sets, streams and pub/sub.

### Is Redis a cache or a database?

The README describes it as both. It covers caching, key expiration and hash-field expiration, and it also calls Redis a NoSQL data store for key-value, document and time series data, with persistence configured in redis.conf.

### Is Redis a SQL or NoSQL database?

The README places Redis in the NoSQL category, listing key-value, document and time series storage, and describing search and query as indexing for hash and JSON documents. It does not present a SQL interface.

### Is Redis backend or frontend?

It is backend infrastructure. The README frames Redis as a data structure server, cache and query engine that applications connect to, with client libraries and redis-cli as the access paths, and it keeps data primarily in memory on the server side.

### How to install Redis?

The README lists Redis Cloud, official Docker images with the command docker run -d -p 6379:6379 redis:latest, and binary distributions through Snap, Homebrew, RPM and Debian. Building from source is documented in the Build Redis from Source section, with INSTALL and the deps/ directory in the repository.

### How to use Redis with redis-cli?

The README lists redis-cli as one of the getting-started paths alongside client libraries and Redis Insight. You connect to a running server, which listens on port 6379 in the Docker example, and issue commands against the documented command set over the text-based protocol.

## Sources

- [Official documentation](http://redis.io)
- [Official README](https://github.com/redis/redis#readme)
- [Project repository](https://github.com/redis/redis)
- [Release notes](https://github.com/redis/redis/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/redis-redis