Are you happy with your logging solution? Would you help us out by taking a 30-second survey? Click here


Redis is an in-memory database that persists on disk. The data model is key-value, but many different kind of values are supported: Strings, Lists, Sets, Sorted Sets, Hashes, HyperLogLogs, Bitmaps.

Subscribe to updates I use redis

Statistics on redis

Number of watchers on Github 27877
Number of open issues 1622
Average time to close an issue 6 days
Main language C
Average time to merge a PR 8 days
Open pull requests 316+
Closed pull requests 115+
Last commit over 1 year ago
Repo Created over 10 years ago
Repo Last Updated over 1 year ago
Size 69.8 MB
Organization / Authorantirez
Page Updated
Do you use redis? Leave a review!
View open issues (1622)
View redis activity
View on github
Fresh, new opensource launches πŸš€πŸš€πŸš€
Trendy new open source projects in your inbox! View examples

Subscribe to our mailing list

Evaluating redis for your project? Score Explanation
Commits Score (?)
Issues & PR Score (?)

This README is just a fast quick start document. You can find more detailed documentation at

What is Redis?

Redis is often referred as a data structures server. What this means is that Redis provides access to mutable data structures via a set of commands, which are sent using a server-client model with TCP sockets and a simple protocol. So different processes can query and modify the same data structures in a shared way.

Data structures implemented into Redis have a few special properties:

  • Redis cares to store them on disk, even if they are always served and modified into the server memory. This means that Redis is fast, but that is also non-volatile.
  • Implementation of data structures stress on memory efficiency, so data structures inside Redis will likely use less memory compared to the same data structure modeled using an high level programming language.
  • Redis offers a number of features that are natural to find in a database, like replication, tunable levels of durability, cluster, high availability.

Another good example is to think of Redis as a more complex version of memcached, where the operations are not just SETs and GETs, but operations to work with complex data types like Lists, Sets, ordered data structures, and so forth.

If you want to know more, this is a list of selected starting points:

  • Introduction to Redis data types.
  • Try Redis directly inside your browser.
  • The full list of Redis commands.
  • There is much more inside the Redis official documentation.

Building Redis

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 in Linux, OSX, and *BSD there.

It is as simple as:

% make

You can run a 32 bit Redis binary using:

% make 32bit

After building Redis, it is a good idea to test it using:

% make test

Fixing build problems with dependencies or cached build options

Redis has some dependencies which are included into the deps directory. make does not automatically rebuild dependencies even if something in the source code of dependencies changes.

When you update the source code with git pull or when code inside the dependencies tree is modified in any other way, make sure to use the following command in order to really clean everything and rebuild from scratch:

make distclean

This will clean: jemalloc, lua, hiredis, linenoise.

Also if you force certain build options like 32bit target, no C compiler optimizations (for debugging purposes), and other similar build time options, those options are cached indefinitely until you issue a make distclean command.

Fixing problems building 32 bit binaries

If after building Redis with a 32 bit target you need to rebuild it with a 64 bit target, or the other way around, you need to perform a make distclean in the root directory of the Redis distribution.

In case of build errors when trying to build a 32 bit binary of Redis, try the following steps:

  • Install the packages libc6-dev-i386 (also try g++-multilib).
  • Try using the following command line instead of make 32bit: make CFLAGS="-m32 -march=native" LDFLAGS="-m32"


Selecting a non-default memory allocator when building Redis is done by setting the MALLOC environment variable. Redis is compiled and linked against libc malloc by default, with the exception of jemalloc being the default on Linux systems. This default was picked because jemalloc has proven to have fewer fragmentation problems than libc malloc.

To force compiling against libc malloc, use:

% make MALLOC=libc

To compile against jemalloc on Mac OS X systems, use:

% make MALLOC=jemalloc

Verbose build

Redis will build with a user friendly colorized output by default. If you want to see a more verbose output use the following:

% make V=1

Running Redis

To run Redis with the default configuration just type:

% cd src
% ./redis-server

If you want to provide your redis.conf, you have to run it using an additional parameter (the path of the configuration file):

% cd src
% ./redis-server /path/to/redis.conf

It is possible to alter the Redis configuration by passing parameters directly as options using the command line. Examples:

% ./redis-server --port 9999 --slaveof 6379
% ./redis-server /etc/redis/6379.conf --loglevel debug

All the options in redis.conf are also supported as options using the command line, with exactly the same name.

Playing with Redis

You can use redis-cli to play with Redis. Start a redis-server instance, then in another terminal try the following:

% cd src
% ./redis-cli
redis> ping
redis> set foo bar
redis> get foo
redis> incr mycounter
(integer) 1
redis> incr mycounter
(integer) 2

You can find the list of all the available commands at

Installing Redis

In order to install Redis binaries into /usr/local/bin just use:

% make install

You can use make PREFIX=/some/other/directory install if you wish to use a different destination.

Make install will just install binaries in your system, but will not configure init scripts and configuration files in the appropriate place. This is not needed if you want just to play a bit with Redis, but if you are installing it the proper way for a production system, we have a script doing this for Ubuntu and Debian systems:

% cd utils
% ./

The script will ask you a few questions and will setup everything you need to run Redis properly as a background daemon that will start again on system reboots.

You'll be able to stop and start Redis using the script named /etc/init.d/redis_<portnumber>, for instance /etc/init.d/redis_6379.

Code contributions

Note: by contributing code to the Redis project in any form, including sending a pull request via Github, a code fragment or patch via private email or public discussion groups, you agree to release your code under the terms of the BSD license that you can find in the COPYING file included in the Redis source distribution.

Please see the CONTRIBUTING file in this source distribution for more information.

Redis internals

If you are reading this README you are likely in front of a Github page or you just untarred the Redis distribution tar ball. In both the cases you are basically one step away from the source code, so here we explain the Redis source code layout, what is in each file as a general idea, the most important functions and structures inside the Redis server and so forth. We keep all the discussion at a high level without digging into the details since this document would be huge otherwise and our code base changes continuously, but a general idea should be a good starting point to understand more. Moreover most of the code is heavily commented and easy to follow.

Source code layout

The Redis root directory just contains this README, the Makefile which calls the real Makefile inside the src directory and an example configuration for Redis and Sentinel. You can find a few shell scripts that are used in order to execute the Redis, Redis Cluster and Redis Sentinel unit tests, which are implemented inside the tests directory.

Inside the root are the following important directories:

  • src: contains the Redis implementation, written in C.
  • tests: contains the unit tests, implemented in Tcl.
  • deps: contains libraries Redis uses. Everything needed to compile Redis is inside this directory; your system just needs to provide libc, a POSIX compatible interface and a C compiler. Notably deps contains a copy of jemalloc, which is the default allocator of Redis under Linux. Note that under deps there are also things which started with the Redis project, but for which the main repository is not anitrez/redis. An exception to this rule is deps/geohash-int which is the low level geocoding library used by Redis: it originated from a different project, but at this point it diverged so much that it is developed as a separated entity directly inside the Redis repository.

There are a few more directories but they are not very important for our goals here. We'll focus mostly on src, where the Redis implementation is contained, exploring what there is inside each file. The order in which files are exposed is the logical one to follow in order to disclose different layers of complexity incrementally.

Note: lately Redis was refactored quite a bit. Function names and file names have been changed, so you may find that this documentation reflects the unstable branch more closely. For instance in Redis 3.0 the server.c and server.h files were named to redis.c and redis.h. However the overall structure is the same. Keep in mind that all the new developments and pull requests should be performed against the unstable branch.


The simplest way to understand how a program works is to understand the data structures it uses. So we'll start from the main header file of Redis, which is server.h.

All the server configuration and in general all the shared state is defined in a global structure called server, of type struct redisServer. A few important fields in this structure are:

  • server.db is an array of Redis databases, where data is stored.
  • server.commands is the command table.
  • server.clients is a linked list of clients connected to the server.
  • server.master is a special client, the master, if the instance is a slave.

There are tons of other fields. Most fields are commented directly inside the structure definition.

Another important Redis data structure is the one defining a client. In the past it was called redisClient, now just client. The structure has many fields, here we'll just show the main ones:

struct client {
    int fd;
    sds querybuf;
    int argc;
    robj **argv;
    redisDb *db;
    int flags;
    list *reply;
    ... many other fields ...

The client structure defines a connected client:

  • The fd field is the client socket file descriptor.
  • argc and argv are populated with the command the client is executing, so that functions implementing a given Redis command can read the arguments.
  • querybuf accumulates the requests from the client, which are parsed by the Redis server according to the Redis protocol and executed by calling the implementations of the commands the client is executing.
  • reply and buf are dynamic and static buffers that accumulate the replies the server sends to the client. These buffers are incrementally written to the socket as soon as the file descriptor is writable.

As you can see in the client structure above, arguments in a command are described as robj structures. The following is the full robj structure, which defines a Redis object:

typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:LRU_BITS; /* lru time (relative to server.lruclock) */
    int refcount;
    void *ptr;
} robj;

Basically this structure can represent all the basic Redis data types like strings, lists, sets, sorted sets and so forth. The interesting thing is that it has a type field, so that it is possible to know what type a given object has, and a refcount, so that the same object can be referenced in multiple places without allocating it multiple times. Finally the ptr field points to the actual representation of the object, which might vary even for the same type, depending on the encoding used.

Redis objects are used extensively in the Redis internals, however in order to avoid the overhead of indirect accesses, recently in many places we just use plain dynamic strings not wrapped inside a Redis object.


This is the entry point of the Redis server, where the main() function is defined. The following are the most important steps in order to startup the Redis server.

  • initServerConfig() setups the default values of the server structure.
  • initServer() allocates the data structures needed to operate, setup the listening socket, and so forth.
  • aeMain() starts the event loop which listens for new connections.

There are two special functions called periodically by the event loop:

  1. serverCron() is called periodically (according to server.hz frequency), and performs tasks that must be performed from time to time, like checking for timedout clients.
  2. beforeSleep() is called every time the event loop fired, Redis served a few requests, and is returning back into the event loop.

Inside server.c you can find code that handles other vital things of the Redis server:

  • call() is used in order to call a given command in the context of a given client.
  • activeExpireCycle() handles eviciton of keys with a time to live set via the EXPIRE command.
  • freeMemoryIfNeeded() is called when a new write command should be performed but Redis is out of memory according to the maxmemory directive.
  • The global variable redisCommandTable defines all the Redis commands, specifying the name of the command, the function implementing the command, the number of arguments required, and other properties of each command.


This file defines all the I/O functions with clients, masters and slaves (which in Redis are just special clients):

  • createClient() allocates and initializes a new client.
  • the addReply*() family of functions are used by commands implementations in order to append data to the client structure, that will be transmitted to the client as a reply for a given command executed.
  • writeToClient() transmits the data pending in the output buffers to the client and is called by the writable event handler sendReplyToClient().
  • readQueryFromClient() is the readable event handler and accumulates data from read from the client into the query buffer.
  • processInputBuffer() is the entry point in order to parse the client query buffer according to the Redis protocol. Once commands are ready to be processed, it calls processCommand() which is defined inside server.c in order to actually execute the command.
  • freeClient() deallocates, disconnects and removes a client.

aof.c and rdb.c

As you can guess from the names these files implement the RDB and AOF persistence for Redis. Redis uses a persistence model based on the fork() system call in order to create a thread with the same (shared) memory content of the main Redis thread. This secondary thread dumps the content of the memory on disk. This is used by rdb.c to create the snapshots on disk and by aof.c in order to perform the AOF rewrite when the append only file gets too big.

The implementation inside aof.c has additional functions in order to implement an API that allows commands to append new commands into the AOF file as clients execute them.

The call() function defined inside server.c is responsible to call the functions that in turn will write the commands into the AOF.


Certain Redis commands operate on specific data types, others are general. Examples of generic commands are DEL and EXPIRE. They operate on keys and not on their values specifically. All those generic commands are defined inside db.c.

Moreover db.c implements an API in order to perform certain operations on the Redis dataset without directly accessing the internal data structures.

The most important functions inside db.c which are used in many commands implementations are the following:

  • lookupKeyRead() and lookupKeyWrite() are used in order to get a pointer to the value associated to a given key, or NULL if the key does not exist.
  • dbAdd() and its higher level counterpart setKey() create a new key in a Redis database.
  • dbDelete() removes a key and its associated value.
  • emptyDb() removes an entire single database or all the databases defined.

The rest of the file implements the generic commands exposed to the client.


The robj structure defining Redis objects was already described. Inside object.c there are all the functions that operate with Redis objects at a basic level, like functions to allocate new objects, handle the reference counting and so forth. Notable functions inside this file:

  • incrRefcount() and decrRefCount() are used in order to increment or decrement an object reference count. When it drops to 0 the object is finally freed.
  • createObject() allocates a new object. There are also specialized functions to allocate string objects having a specific content, like createStringObjectFromLongLong() and similar functions.

This file also implements the OBJECT command.


This is one of the most complex files inside Redis, it is recommended to approach it only after getting a bit familiar with the rest of the code base. In this file there is the implementation of both the master and slave role of Redis.

One of the most important functions inside this file is replicationFeedSlaves() that writes commands to the clients representing slave instances connected to our master, so that the slaves can get the writes performed by the clients: this way their data set will remain synchronized with the one in the master.

This file also implements both the SYNC and PSYNC commands that are used in order to perform the first synchronization between masters and slaves, or to continue the replication after a disconnection.

Other C files

  • t_hash.c, t_list.c, t_set.c, t_string.c and t_zset.c contains the implementation of the Redis data types. They implement both an API to access a given data type, and the client commands implementations for these data types.
  • ae.c implements the Redis event loop, it's a self contained library which is simple to read and understand.
  • sds.c is the Redis string library, check for more information.
  • anet.c is a library to use POSIX networking in a simpler way compared to the raw interface exposed by the kernel.
  • dict.c is an implementation of a non-blocking hash table which rehashes incrementally.
  • scripting.c implements Lua scripting. It is completely self contained from the rest of the Redis implementation and is simple enough to understand if you are familar with the Lua API.
  • cluster.c implements the Redis Cluster. Probably a good read only after being very familiar with the rest of the Redis code base. If you want to read cluster.c make sure to read the Redis Cluster specification.

Anatomy of a Redis command

All the Redis commands are defined in the following way:

void foobarCommand(client *c) {
    printf("%s",c->argv[1]->ptr); /* Do something with the argument. */
    addReply(c,shared.ok); /* Reply something to the client. */

The command is then referenced inside server.c in the command table:


In the above example 2 is the number of arguments the command takes, while "rtF" are the command flags, as documented in the command table top comment inside server.c.

After the command operates in some way, it returns a reply to the client, usually using addReply() or a similar function defined inside networking.c.

There are tons of commands implementations inside th Redis source code that can serve as examples of actual commands implementations. To write a few toy commands can be a good exercise to familiarize with the code base.

There are also many other files not described here, but it is useless to cover everything. We want to just help you with the first steps. Eventually you'll find your way inside the Redis code base :-)


redis open issues Ask a question     (View All Issues)
  • almost 3 years Redis Used_memory not free up
  • almost 3 years Redis Master Slave issue
  • almost 3 years compile report errors
  • almost 3 years Redis 3.0.5 crashed by signal: 11
  • almost 3 years Listen on random port
  • almost 3 years Load 5G RDB file cost 40 minute
  • almost 3 years how to store json in redis
  • almost 3 years redis crashed
  • almost 3 years Redis is trying to write to /var/spool/cron
  • almost 3 years INCR: different behaviour on different versions of REDIS
  • almost 3 years how can we cope with data loss in redis-cluster split-brain
  • almost 3 years luaRedisGenericCommand() recursive call detected
  • almost 3 years Redis Sentinel 3.2.5. Cannot bind more than one IP address
  • almost 3 years Feature Request: Array or Hashes or nested hashes.
  • almost 3 years Feature Request: Mruby scripting
  • almost 3 years Does Redis support expiration callback in ASP.Net Core 1 MVC application?
  • almost 3 years Redis3.2.5 using socket UNIX or socket TCP good?
  • almost 3 years Redis master fallback after a failover
  • almost 3 years What's the maximum size of a pubsub message?
  • about 3 years Issue related to #2939
  • about 3 years Memory leak/Problem and how to collect needed data?
  • about 3 years *** FATAL CONFIG FILE ERROR ***
  • about 3 years Feature Request: Get changed key-values after specified time.
  • about 3 years Failing test on Raspberry Pi: Server is able to generate a stack trace on selected systems
  • about 3 years Bad $GCC test in embedded SDK envinment
  • about 3 years Redis crashed
  • about 3 years Latency in latency.{h,c} should be measured in nanoseconds
  • about 3 years Redis on cygwin (Win64)
  • about 3 years Add HdrHistogram support to redis-benchmark
  • about 3 years Add a duration argument to redis-benchmark
redis open pull requests (View All Pulls)
  • Non developer readme contribution
  • Updating sentinel client-reconfig-script state report and sentinel.conf
  • modify README
  • Purpose readme contribution
  • Add SMISMEMBER command
  • Fix for #3076 Reverse redirect address parse
  • 3.0 empty voter config flag
  • 3.0 cant be master config flag
  • return immediately if can not allocate memory
  • list iterator NULL pointer fix(bug #3014 fix)
  • Fix typo in
  • Typo fixes in redis-trib
  • Add config: cluster-slave-no-failover
  • Fixes a typo in the comments
  • bug fixed
  • Β–Perfect annotation:Change ot to not.
  • Fix for Issue##3020
  • Remove privdata in "dict structure.
  • a simple bloomfilter implementation
  • Add cluster-automatic-failover config
  • Fix nanosecond conversion
  • fix linux compile Error zmalloc.c:109: error: invalid lvalue in unary `&'
  • Fix a possible race condition of sdown event detection if sentinel's connection to master/slave/sentinel became disconnected just after the last PONG and before the next PING.
  • compareandset, hcompareandset, scompareandset
  • redis-trib.rb bug fixed
  • Use SOURCE_DATE_EPOCH over unreproducible uname + date calls.
  • Fix commandCommand arity
  • fix undefined variable
  • Typo fixed
  • Add quit to the command table
  • Ensure slots are rechecked on EXEC.
  • 2.8
  • Typo correction: "faield" --> "failed"
  • (Minor) Corrected display message from "Redis Sentinel" to "Redis Cluster"
  • bugfix: fix typo in fixing slots
  • Add travis-ci configuration
  • Remove ascii logo from logs
  • Update README
  • Fixes a typo in comments
  • fix a possible bug that command 'client kill id 0' will kill all the clients except itself
  • 3.2
  • option added to zinterstore / zunionstore (byscore) and aggregation function added
  • [hiredis] It will be better if the return value of redisCommand is tested in exmaple.c
  • Fix redis-trib.rb
  • Release 2.8.19
  • fix typos
  • performance boost by caching hash value in dictEntry
  • Fix README typo
  • Remove useless variable 'o'
  • Refine the comment of dictRehashMilliseconds func
  • fix pidfile in redis.conf
  • Fix typo in top level => s/sever/server/
  • Fixes
  • reduce struct padding by reordering members
  • redis-cli.c: add parse_flag to prevent wrong connection alerts
  • fix typo destryoing->destroying
  • Fix client kill all with id 0 or with skipme
  • Removes a printf that was forgotten
  • redis
  • SLAVECONF->REPLCONF in comment
  • Allow non-interactive execution of install_server
  • adding objectComputeSize, mem-overhead, total_keyname_size facilities…
  • minor fixes - mainly signalModifiedKey, and GEORADIUS
  • fix crash in BITFIELD GET when key is integer encoded
  • Fix hiredis build on OpenBSD
  • build: Add BSDMakefile for !gmake
  • add module list modulename to list commands in a module
  • Change LG_QUANTUM whenever jemalloc is updated
  • allow writable command even aof_last_write_status == C_ERR
  • fix mistake in comment in object.c
  • bitcount bug:return non-zero value when start > end (both negative)
  • Fix modules intro typos.
  • Fail if an invalid memory size is given by redis.conf
  • Sentinel: fix check when can't send the command to the promoted slave
  • Interval sets (again)
  • change argument name for deleteDict() and dictDeleteNoFree() in dict.c
  • fix crash in BITFIELD GET on non existing key or wrong type see #3259
  • localhost
  • fix georadius returns multiple replies
  • CLIENT error message was out of date
  • Update dict.c
  • fix: config set list-max-ziplist-size didn't support negative values
  • Optimize auto memory freed - a more complicated approach
  • Optimized autoMemoryFreed loop
  • add DEBUG LOAD command
  • fix the wrong description of intsetGet().
  • ReplyWithArray markdown formatting for better readability
  • Fixed bitcount bug: when end < -strlen, return non-zero value
  • fix lrange argument in redis-benchmark.c
  • Avoid default port connection when custom port is given in redis-cli. To fix #3314 issue.
  • Add RedisModule_Log() logging API function.
  • Fix for redis_cli printing default DB when select command fails. #3361
  • Add multiple DC support.
  • Add s390x support
  • [Feature Request][WIP] Adding user command acls : Implementing RCP1
  • Add GEORADIUS rand option
  • Fix the firstkey, lastkey, and keystep of moduleCommand
  • [comment issue] Fix outdated comments about redis.c file.
  • Prepend $DESTDIR to $INSTALL_BIN to allow redis binaries to be installed to a different filesystem location
  • 2015 -> 2016, updated copyright year
  • Display the nodes' proper summary once the cluster is created using redis-trib
  • Sentinel Password Authentication Fix #3279
  • Make history file private #3284
  • Minor grammar fix
  • fix some comments
  • Updated to Apple's naming convention
  • Spelling correction in redis-cli.c
  • Redis Module API calls to allow re-use of data type RDB save/load.
  • fix compile warning in gcc 5.3.1 with changing structure members initializer
  • add cluster-pubsub-propagate config (default to yes)
  • Redis Module hooks for global RDB AUX field handling.
  • crash log - add hex dump of function code
  • Fix spelling in documentation and comments
  • Add RM_Publish function to modules API.
  • config requirepass now accepts multiple passwords
  • fix typo elegible->eligible
  • Fixes handling of invalid dbnum from command line
  • Adds the `-u <uri>` option
  • fix #2883, #2857 pipe fds leak when fork() failed on bg aof rw
  • fix tcp binding when IPv6 is unsupported
  • Fix CONFIG SET for client-output-buffer-limit.
  • Fix memory leak in config.
  • fix bug while sh is NULL
  • fixbug: prohibiting infinite aof rewrite when aof size is smaller
  • fixing resource leak
  • #3453 make global function pointers defined in redismodule.h as extern
  • object: remove unnecessary section
  • Forbid the command(cluster setslot) to slave
  • #3438 implement list iterator for redis module
  • 3.2
  • Call va_end to cleanup before returning on error
  • Watch out for memory leak in cases where allocation fails and leaks the original memory that's no longer referred to
  • 3.2.3 update interval sets
  • add str.split(input, seperator) function which is fast than lua emula…
  • Added double formatting in RM_Call.
  • Dynamic adjust the loop events capacity
  • Fixed variable typos in config.c
  • fix typo
  • Fix: clean prerequisites etc file #3472
  • redis-trib.rb: improve master / replicas associations
  • Update README for create-cluster
  • Refactor redis-trib.rb
  • add command: script list [sha1 ...]
  • [Feature-redis-trib] Allow specifying source database for import into cluster
  • Update
  • Remove unused macro
  • simple if condition refactoring for kevent
  • command set add at unixtimestamp eg:set book redis at 1475146322
  • a typo
  • Bringup redis-server if at least 1 ip is up
  • switched autoMemoryFreed and RM_FreeCallReply_Rec
  • Simple change just using slaves instead of server.slaves
  • Un
  • Buffer Over Read in redis-server 3.2.0 and Later
  • Fix different type with int(int) in server.h
  • Fix an article usage
  • Make it possible to call RedisModule_FreeString() without a context.
  • install redis-check-rdb as a symlink instead of duplicating the binary
  • Man page for redis commands and configuration files
  • Typo
  • 2 8
  • bitops.c/bitfieldCommand: update higest_write_offset with check
  • Fix typo in the word "preferences"
  • redis-cli: Don't use hostsock when cluster return redirection
  • Remove Duplicate Processing
  • geo: consistency for hash/pos/dist results for non-existent keys vs elements
  • Adding Geo nautical mile unit conversion
  • log client name in MONITOR
  • language nits
  • cancel redis-cli monitor command with SIGINT
  • allow --pattern to be used along with --bigkeys
  • Modify MIN->MAX
  • 3.2
  • add option 'setproctitle' for proc title set
  • remove : character in host: command
  • Add hostname to INFO SERVER
  • CoW improvement, stop AOFRW before flushing and parsing slave RDB
  • add dbnum checking for replication
  • Add db id and client name to slowlog
  • Fixing typo in the usage of redis-benchmark
  • fix unsigned int overflow in adjustOpenFilesLimit
  • Added unattended option for the create command of redistrib.rb
  • Replication: fix memory leak
  • enlarged buffer given to ld2string
  • added subspace events and management for it...
  • AOF: add config option to load broken aof
  • Added insert to list by index
  • Update copyright year
  • [New Feature] Showing Using Swap Memory in Redis in Info Command Memory Status
  • docs: patch FreeString signature
  • Make RM_OpenKey return a typed handle
  • modules: Add newlen == 0 handling to RM_StringTruncate (#3717)
  • docs: modules: patch link to Automatic Memory Management info
  • fix rare assertion in DEBUG DIGEST
  • Fix infinite loop: redis-cli should not use hostsock when cluster return redirection
  • fix a bug at sds.c,this bug may cause segmentation fault
  • Missing array index
  • Fix typo they->the in helloworld.c
  • Module: add module desc subcommand
  • Add election support of slaves when all master down
  • typo error
  • Remove the call of strlen in serverLogFromHandler()
  • cmd callstats fix when client is in Multi context
  • match comment alignment
  • Updates redis-benchmark usage and report output
  • ZIPLIST_ENTRY_END macros definition quest ?
  • Add raw-output command flag.
  • cli: Only print elapsed time on OUTPUT_STANDARD.
  • cmd callstats fix when client is in Multi context
  • Verify pairs are provided after ZADD's subcommands
  • Add RedisModule_GetKeyNameFromIO()
  • Fix typo (unsupproted => unsupported) in error message
  • ZRANK: Support optional return of score
  • Add uninstall rule.
  • exit activeExpireCycle() and activeDefragCycle() ASAP if variable 'elapsed' appears to be negative
  • Added conversion to nautical miles
  • fix wrong counts for bytes written to clients
  • 3.2
  • Bind to IPv6 localhost in default config
  • Correct typo in tests/unit/hyperloglog.tcl
  • diskless replication on slave side (don't store rdb to file), plus so…
  • Update README
  • fix #3953
  • Fix typo
  • Update jemalloc download url
  • CLI: Fix incorrect arity in derived typeahead for unknown command
  • Changes command stats iteration to being dict-based
  • Implement getKeys procedure for georadius and georadiusbymember commands
  • extract_varient_from_while_loop
  • Change redis URL in ascii logo from http to https
  • log original incrbyfloat and hincrbyfloat command in slowlog
  • Calling getDecodedObject before hashTypeSet to fix RM_Call segfault
  • redis-benchmark crash
  • Changed REDISMODULE_READ to REDISMODULE_WRITE in modules documentation
  • Update sds.c
  • add close(s) when error return
  • Change skip list P value to 1/e, which improves search times
  • remove duplicate fd lookup
  • falure to failure
  • fix typos
  • Fixed log message typo in listenToPort.
  • va_list 'ap' was opened but not closed by va_end()
  • fix typo
  • Grammar fixes in
  • Fix #4008 small typo in comment
  • fix: typos using misspell
  • 4 0
  • redis-check-aof: new option to dump redis commands in oneline.
  • Check that THP is always enabled
  • Implementation of nonblocking data migration.
  • Clean temp AOF file
  • Initialize client->id to CLIENT_ID_AOF in createFakeClient()
  • rename ae_*.c to ae_*.h
  • sds: avoid implicit casting
  • Update kbps -> KBps for info Stats display.
  • Add low-level module PubSub publish command
  • Optimize RM_Call by recycling the client
  • remove double verify
  • hsetnx command lead coding type change
  • Fix typos include two code typos in cluster.c and latency.c
  • Test:Fix invalid cases in hash.tcl and dump.tcl
  • Reduce number of syscalls when unblocking clients in module
  • fix int overflow problem in freeMemoryIfNeeded
  • fix deps/lua compile warning
  • Evicting strategy update
  • Add Query Buffer used memory metric into INFO
  • Update Copyright Year 2018
  • fix typo in
  • Fix typo in valgrind.sup (#4287)
  • add comment to notice the right usage of createStringObjectFromLongLong
  • redis-benchmark: Enforce upper bound to numbers of requests for pipeline
  • Improve lazyfree eviction
  • Fix: Function declaration and definition are inconsistent
  • Standardizes `MEMORY HELP` subcommand
  • repair bug for sds malloc
  • Add redis-cli and redis-benchmark dependencies for test target.
  • Zset int problem
  • Fix use wrong function
  • Adds URI support to redis-benchmark
  • Client list type
  • Expand info & memory command
  • Bug Fixed( directory of script path contains space) in
  • fix some bug about sds and quicklist
  • exclude replication backlog when computing used memory for key eviction
  • 2.6
  • aof rewrite contains lua
  • add list and getluabysha subcommand for script
  • config: handle special configuration "" for auth
  • proto-max-bulk-len should be greater than 512mb
  • Fixes reply of SPOP w/ COUNT when key doesn't exist
  • Update object.c
  • Update object.c
  • Fix comment typo in server.c
  • Fix using shared integers when maxmemory is used with decr/incr
  • Fix zrealloc to behave similarly to je_realloc when size is 0
  • Added a monotonic clock read.
  • Active defrag v2
  • Fix the misleading description of the option repl-ping-slave-period
  • CodeAi fixes: remove dead code, prevent possible null derefs
  • Fix typo in redis.conf
  • Some commands will udpate lfu-counter many times in one call.
  • Better Hyperloglog cardinality estimation algorithm
  • wrong declaration for function "prepareForShutdown" int server.h
  • Fix zlexrangespec mem-leak in genericZrangebylexCommand
  • Optimizing time/space of GEORADIUS COUNT
  • Don't call sdscmp() with shared.maxstring or shared.minstring
  • Fix typo in /deps/
  • Fix typo in readSyncBulkPayload() comment.
  • replication.c comment: run_id -> replid.
  • move getClientsMaxBuffers func into info clients command
  • Refactoring to call aeDeleteFileEvent twice as once
  • Boost up performance for redis PUB-SUB patterns matching
  • Minor list keyspace notifications bugs
  • slave buffers were wasteful and incorrectly counted causing eviction
  • lose stat_fork_rate in stat information
redis questions on Stackoverflow (View All Questions)
  • Redis how to listen changes in 1000 to 10,000 lists using golang?
  • Using redis to emails queue in many servers environment
  • NewsFeed with Redis At Scale Stratagy
  • Redis Sentinel master not downgraded to slave immediately
  • redis and laravel - can't communicate with each other
  • Redis error about return type
  • How to put data in several Redis dump.rdb file together in short time?
  • Redis replication vs AOF persistance on distributed file system
  • How to use zscan in Redis using Node.js.?
  • Express Node.JS - Receiving Redis callback, executing promises
  • Is it possible to get all values for a Redis set in one operation?
  • Nodejs redis query data
  • Chef: Error executing action `run` on resource 'redisio_configure[redis-servers]'
  • shutdown redis-server from command line
  • Issues with hexadecimal characters in redis keys inserted through cache plugins
  • Redis cluster ensure some keys reside on physically different instances
  • Notice unserialize error in CakePHP via Redis
  • How to insert data submitted from an HTML form into a Redis database?
  • redis vs hazelcast
  • Redis failover with StackExchange / Sentinel from C#
  • Fetching data from REDIS with NODE JS and BLUEBIRD
  • How to deal with a large amount of logs and redis?
  • Redis [windows] deletes dump file
  • How fast will a lot of results into redis database?
  • Pushing a JSON payload to redis via Ruby and redis-cli
  • getting trailing bytes error in redis 3.0.6
  • Can I use Yii2 migration without a SQL db component? (I'm using only Redis)
  • rails puma config with heroku redis/pg/sidekiq/activejob
  • How to configure spring-session with spring-boot WITHOUT Redis and without auto configuration to use another db store
  • Using Django Cache with Celery + Redis Causes Celery to Crash
redis list of languages used
Other projects in C