Cedis

A Redis-compatible in-memory data store built from scratch in Rust — entirely generated by AI.

This project is a demonstration of modern AI coding tools. Every line of code — the RESP protocol parser, data structures, persistence engine, Lua scripting integration, replication system, and 220+ command implementations — was written by AI (Claude). Cedis exists to showcase what AI-assisted development can accomplish: a production-grade, wire-compatible Redis implementation built from first principles, without copying from the Redis source code or using any existing Redis/RESP libraries.

Cedis speaks the RESP2 protocol and implements Redis's core data structures along with persistence, pub/sub, transactions, Lua scripting, master-replica replication, and more. All without using any existing Redis or RESP libraries. Wire-compatible with redis-cli, the redis crate (Rust), redis-py (Python), and ioredis (Node.js).

Highlights

220+ commands across strings, lists, hashes, sets, sorted sets, streams (with consumer groups), bitmaps, HyperLogLog, geospatial, pub/sub, transactions, Lua scripting, replication, and server administration
RESP2 protocol with streaming parser/serializer supporting both framed and inline commands
Wire-compatible with any standard Redis client
Master-replica replication with PSYNC protocol, full/partial resync, replication backlog, and command forwarding
Stream consumer groups with pending entry lists, XREADGROUP (blocking), XACK, XCLAIM, XAUTOCLAIM, XPENDING
RDB + AOF persistence with auto-save rules and background rewriting
Pub/Sub with pattern subscriptions
Lua scripting via embedded Lua 5.4 (EVAL/EVALSHA with 60+ commands from Lua)
WATCH/MULTI/EXEC transactions with key-version-based conflict detection
Blocking commands (BLPOP/BRPOP/BLMOVE/BZPOPMIN/BZPOPMAX/XREADGROUP) with async client wake-up
Memory eviction with configurable maxmemory and eviction policies (allkeys-random, volatile-random, volatile-ttl, allkeys-lru, volatile-lru)
Passes 16 of 20 tracked Redis TCL test files in external mode (remaining failures are RESP3, blocking list edge cases, and pub/sub)
Real SLOWLOG tracking with configurable threshold and ring buffer
LRU eviction with per-key last-access tracking and sampled eviction
~23,100 lines of Rust across 47 source files, plus ~2,700 lines of tests and benchmarks
128 tests (49 unit + 79 integration), all passing
85K ops/sec single-client, 371K ops/sec pipelined (redis-benchmark)

Progress Report

Implementation Phase Status

The project follows a 9-phase implementation plan. Here is the current status:

Phase	Description	Status	Notes
Phase 1	Protocol & Echo Server	Complete	RESP2 parser/serializer, async TCP server, PING/ECHO/QUIT, inline commands
Phase 2	Strings & Key Management	Complete	All 23 string commands, key expiration (lazy + active), KEYS/SCAN
Phase 3	Lists & Hashes	Complete	21 list commands (incl. blocking), 17 hash commands, WRONGTYPE enforcement
Phase 4	Sets & Sorted Sets	Complete	17 set commands, 34 sorted set commands with all ZADD flags
Phase 5	Pub/Sub & Transactions	Complete	Channel + pattern subscriptions, MULTI/EXEC/WATCH with version-based conflict detection
Phase 6	RDB Persistence	Complete	RDB save/load, BGSAVE, auto-save rules, startup loading
Phase 7	AOF Persistence	Complete	AOF logging, replay on startup, BGREWRITEAOF, fsync policies (always/everysec/no)
Phase 8	Blocking Commands & Advanced	Complete	BLPOP/BRPOP/BLMOVE/BZPOPMIN/BZPOPMAX, SORT, OBJECT ENCODING, INFO with sections, MONITOR, CONFIG
Phase 9	Completeness & Stretch	Complete	Streams (with consumer groups), Lua scripting, bitmaps, HyperLogLog, geo, ACL basics, memory eviction, master-replica replication with PSYNC

Test Results

All 128 tests pass (as of 2026-02-22):

49 unit tests:

RESP parser: 19 tests (all types, partial reads, nested arrays, null values, inline commands)
Glob pattern matching: 8 tests (wildcards, brackets, ranges, negation, escaping)
Bitmap operations: 10 tests (set/get bit, bitcount ranges, bitop AND/OR/XOR/NOT, bitpos)
HyperLogLog: 7 tests (add, count, merge, hash determinism, duplicates)
Replication backlog: 2 tests (basic operation, circular buffer wraparound)

79 integration tests (using the redis crate as client, validating wire compatibility):

String commands: GET/SET, MGET/MSET, MSETNX, APPEND/STRLEN, INCR/DECR/INCRBYFLOAT, GETRANGE/SETRANGE, GETSET, GETDEL, SET with NX/XX, SETEX/PSETEX
List commands: LPUSH/RPUSH/LPOP/RPOP, LRANGE, LINSERT, RPOPLPUSH, BLPOP/BRPOP (blocking + data-ready + timeout)
Hash commands: HSET/HGET/HDEL/HEXISTS/HLEN, HGETALL/HMGET, HINCRBY/HINCRBYFLOAT
Set commands: SADD/SREM/SISMEMBER, SMEMBERS/SCARD, SUNION/SINTER/SDIFF with STORE variants
Sorted set commands: ZADD/ZRANGE with WITHSCORES, ZINCRBY
Stream commands: XADD/XLEN, XRANGE, XREAD, XTRIM
Key management: DEL/EXISTS, EXPIRE/TTL/PERSIST, TYPE, RENAME, KEYS pattern, SCAN, COPY
Bitmap commands: SETBIT/GETBIT, BITCOUNT, BITOP, BITPOS
HyperLogLog: PFADD/PFCOUNT, PFMERGE
Geospatial: GEOADD/GEOPOS, GEODIST, GEOSEARCH
Pub/Sub: SUBSCRIBE/PUBLISH message delivery
Transactions: MULTI/EXEC, MULTI/DISCARD
Persistence: SAVE, BGSAVE, LASTSAVE
Scripting: EVAL basic, EVAL with redis.call(), EVALSHA + SCRIPT LOAD/EXISTS
Server: PING, ECHO, SELECT, DBSIZE/FLUSHDB/FLUSHALL, INFO, CONFIG GET/SET, TIME, OBJECT ENCODING
Sorting: SORT numeric, SORT ALPHA, SORT with LIMIT
Memory: CONFIG maxmemory
SLOWLOG: SLOWLOG GET/LEN/RESET with real command timing
AUTH: 2-arg form (username + password), 1-arg form
CONFIG SET: multi-parameter support
OBJECT IDLETIME: real idle time tracking
INFO replication: live role/replica/backlog data
Error handling: WRONGTYPE errors, unknown command errors
Concurrency: concurrent client operations

Redis TCL Test Suite (External Mode)

Cedis passes 16 of 20 tracked Redis test files in external mode. Several test files show attach_to_replication_stream exceptions from the TCL harness interacting with our PSYNC handshake — the actual command tests within those files all pass.

Test File	Result	Notes
`unit/auth`	PASS
`unit/quit`	PASS	3/3
`unit/info`	PASS
`unit/bitops`	PASS	55/55
`unit/keyspace`	PASS	58/60 (2 minor edge cases)
`unit/scan`	PASS	25/25
`unit/expire`	PASS	36/36 (repl stream exception only)
`unit/type/string`	PASS	20/20 (repl stream exception only)
`unit/type/set`	PASS	95/95 (repl stream exception only)
`unit/type/hash`	PASS	69/70 (1 RESP3 failure + repl stream exception)
`unit/protocol`	PASS	16/17 (1 RESP3 failure + RESP3 exception)
`unit/multi`	PASS	33/34 (1 OOM-during-queuing edge case + repl stream exception)
`unit/sort`	PASS	31/32 (1 GETKEYS edge case + SORT not exposed to Lua)
`integration/rdb`	PASS
`integration/aof`	PASS
`integration/logging`	PASS	(no tests in external mode)
`unit/type/zset`	Mostly	212/222 (10 RESP3 failures + repl stream exception)
`unit/type/list`	Mostly	79/133 (blocking wake-up edge cases + RESP3)
`unit/pubsub`	Needs work	12/24 (RESP3, unsubscribe edge cases, keyspace notifications)
`integration/replication`	Skipped	(no tests in external mode)

The most common failure patterns are:

RESP3: Cedis implements RESP2 only. Tests requiring RESP3 responses fail.
Replication stream helper: The TCL harness's attach_to_replication_stream doesn't handle our PSYNC handshake, causing exceptions unrelated to the actual command tests.
Blocking list wake-up: BLPOP/BRPOP should not wake when a key is pushed then immediately deleted in a pipeline.
Pub/Sub edge cases: Unsubscribe-without-arguments, CLIENT REPLY interactions, keyspace notifications.

redis-benchmark

Benchmarked with redis-benchmark (50 clients, 100,000 requests):

Command	Throughput	Pipelined (P=16)
SET	85,324 req/sec	371,747 req/sec
GET	86,133 req/sec	225,734 req/sec
LPUSH	87,108 req/sec
LPOP	86,580 req/sec
SADD	86,806 req/sec
ZADD	86,505 req/sec
MSET (10 keys)	79,491 req/sec

Client Library Compatibility

Verified working with:

redis-cli (interactive and pipeline modes)
redis crate (Rust)
redis-py (Python)
ioredis (Node.js)

What's Left to Do

The following features from the project spec remain unimplemented or incomplete:

Remaining TCL Test Suite Gaps

unit/type/list: 54 failures — mostly blocking wake-up edge cases (LPUSH + DEL should not wake BLPOP) and RESP3
unit/pubsub: 12 failures — RESP3, unsubscribe-without-arguments, CLIENT REPLY, keyspace notifications
unit/type/zset: 10 failures — all RESP3-related
unit/multi: 1 failure — OOM error detection during MULTI queuing
unit/sort: 1 failure — COMMAND GETKEYS with multiple STORE arguments

Stretch Goals

RESP3 protocol support (would fix ~20 test failures across multiple suites)
Ziplist/listpack encoding optimizations for small hashes/lists/sorted sets
Integer set optimization for sets containing only integers
Keyspace notifications
LATENCY subsystem
Hybrid AOF+RDB format
RDB cross-compatibility with real Redis (format is close but not byte-identical)

Supported Commands

Strings (22)

GET SET (EX/PX/NX/XX/KEEPTTL/GET/EXAT/PXAT) GETEX GETSET MGET MSET MSETNX APPEND STRLEN LCS INCR DECR INCRBY DECRBY INCRBYFLOAT SETNX SETEX PSETEX GETRANGE SUBSTR SETRANGE GETDEL

Lists (22)

LPUSH RPUSH LPUSHX RPUSHX LPOP RPOP LLEN LRANGE LINDEX LSET LINSERT LREM LTRIM RPOPLPUSH LMOVE LPOS LMPOP BLPOP BRPOP BRPOPLPUSH BLMOVE BLMPOP

Hashes (17)

HSET HGET HDEL HEXISTS HLEN HKEYS HVALS HGETALL HMSET HMGET HINCRBY HINCRBYFLOAT HSETNX HRANDFIELD HSCAN HSTRLEN HGETDEL

Sets (17)

SADD SREM SISMEMBER SMISMEMBER SMEMBERS SCARD SPOP SRANDMEMBER SUNION SINTER SDIFF SUNIONSTORE SINTERSTORE SDIFFSTORE SMOVE SSCAN SINTERCARD

Sorted Sets (34)

ZADD (NX/XX/GT/LT/CH/INCR) ZREM ZSCORE ZRANK ZREVRANK ZCARD ZCOUNT ZRANGE (BYSCORE/BYLEX/REV/LIMIT) ZREVRANGE ZRANGEBYSCORE ZREVRANGEBYSCORE ZRANGEBYLEX ZREVRANGEBYLEX ZINCRBY ZUNIONSTORE ZINTERSTORE ZUNION ZINTER ZDIFF ZDIFFSTORE ZRANDMEMBER ZSCAN ZPOPMIN ZPOPMAX ZMSCORE ZLEXCOUNT ZREMRANGEBYSCORE ZREMRANGEBYLEX ZREMRANGEBYRANK ZINTERCARD ZMPOP BZPOPMIN BZPOPMAX BZMPOP

Streams (14)

XADD XLEN XRANGE XREVRANGE XREAD XTRIM XDEL XINFO (STREAM/GROUPS/CONSUMERS) XGROUP (CREATE/DESTROY/CREATECONSUMER/DELCONSUMER/SETID) XREADGROUP (with BLOCK) XACK XCLAIM XAUTOCLAIM XPENDING

Bitmaps (7)

SETBIT GETBIT BITCOUNT (BYTE/BIT range) BITOP (AND/OR/XOR/NOT) BITPOS (BYTE/BIT mode) BITFIELD (GET/SET/INCRBY with OVERFLOW WRAP/SAT/FAIL) BITFIELD_RO

HyperLogLog (3)

PFADD PFCOUNT PFMERGE

Geospatial (9)

GEOADD (NX/XX/CH) GEODIST GEOPOS GEOSEARCH GEORADIUS GEORADIUSBYMEMBER GEOSEARCHSTORE GEOHASH GEOMEMBERS

Keys (26)

DEL UNLINK EXISTS EXPIRE PEXPIRE EXPIREAT PEXPIREAT EXPIRETIME PEXPIRETIME TTL PTTL PERSIST TYPE RENAME RENAMENX KEYS SCAN RANDOMKEY OBJECT (ENCODING/REFCOUNT/IDLETIME/FREQ/HELP) DUMP RESTORE SORT SORT_RO COPY MOVE TOUCH

Pub/Sub (6)

SUBSCRIBE UNSUBSCRIBE PUBLISH PSUBSCRIBE PUNSUBSCRIBE PUBSUB (CHANNELS/NUMSUB/NUMPAT)

Transactions (5)

MULTI EXEC DISCARD WATCH UNWATCH

Scripting (3)

EVAL EVALSHA SCRIPT (LOAD/EXISTS/FLUSH)

Replication (5)

REPLICAOF SLAVEOF REPLCONF PSYNC WAIT

Server & Connection (25+)

PING ECHO QUIT SELECT AUTH HELLO RESET DBSIZE FLUSHDB FLUSHALL SWAPDB INFO CONFIG (GET/SET/RESETSTAT) TIME COMMAND CLIENT (SETNAME/GETNAME/ID/LIST/INFO) DEBUG (SLEEP/SET-ACTIVE-EXPIRE) MONITOR SLOWLOG SAVE BGSAVE BGREWRITEAOF LASTSAVE MEMORY (USAGE) ACL (WHOAMI/LIST/USERS/GETUSER/SETUSER/DELUSER/CAT/LOG) LATENCY

Getting Started

Build

cargo build --release

Run the server

# Default: listens on 127.0.0.1:6379
./target/release/cedis

# Custom port and bind address
./target/release/cedis --port 6380 --bind 0.0.0.0

# With password
./target/release/cedis --requirepass mysecretpassword

# With AOF persistence
./target/release/cedis --appendonly yes

# As a replica of another Redis/Cedis server
./target/release/cedis --port 6380 --replicaof 127.0.0.1 6379

Connect with any Redis client

# With redis-cli
redis-cli -p 6379

# Or use the bundled CLI
cargo run --release --bin cedis-cli

Run the tests

# All tests (49 unit + 79 integration)
cargo test

# Unit tests only
cargo test --lib

# Integration tests
cargo test --test integration_test

Architecture

src/
  main.rs              Entry point, CLI arg parsing
  server.rs            Async TCP server (tokio), per-connection tasks, AOF logging
  resp.rs              RESP2 streaming parser/serializer with inline command support
  config.rs            Runtime configuration with CLI flags and CONFIG GET/SET
  connection.rs        Per-client state (db index, auth, transaction queue)
  scripting.rs         Lua scripting engine (redis.call/redis.pcall, 60+ commands)
  pubsub.rs            Pub/Sub message broker with pattern matching
  keywatcher.rs        Async notification for BLPOP/BRPOP wake-up
  slowlog.rs           Slow query log ring buffer with real timing
  glob.rs              Redis-style glob pattern matching
  store/
    mod.rs             Multi-database store with lazy + active expiration
    entry.rs           Key entry with TTL metadata
  types/
    rstring.rs         Binary-safe string with integer optimization
    list.rs            VecDeque-backed list
    hash.rs            HashMap-backed hash
    set.rs             HashSet-backed set with intset detection
    sorted_set.rs      BTreeMap + HashMap sorted set with f64 ordering
    stream.rs          Append-only stream with ID generation
    bitmap.rs          Bit array with BITFIELD support and range operations
    hyperloglog.rs     Probabilistic cardinality estimator
    geo.rs             Geospatial index with haversine distance
  command/
    mod.rs             Central dispatch (220+ commands)
    string.rs          String command handlers
    list.rs            List command handlers
    hash.rs            Hash command handlers
    set.rs             Set command handlers
    sorted_set.rs      Sorted set command handlers
    stream.rs          Stream command handlers
    bitmap.rs          Bitmap/BITFIELD command handlers
    hyperloglog.rs     HyperLogLog command handlers
    geo.rs             Geo command handlers
    key.rs             Key management commands
    server_cmd.rs      Server/connection commands
    pubsub.rs          Pub/Sub commands
    transaction.rs     MULTI/EXEC/WATCH
    scripting.rs       EVAL/EVALSHA/SCRIPT
  persistence/
    rdb.rs             RDB snapshot save/load (file + in-memory for replication)
    aof.rs             AOF append/rewrite/replay
  replication/
    mod.rs             ReplicationState, role tracking, replica registry
    backlog.rs         Circular replication backlog buffer for partial resync
    master.rs          PSYNC handler, RDB transfer, command streaming to replicas
    replica.rs         Connect to master, receive RDB, apply command stream
  bin/
    cedis-cli.rs       Minimal interactive CLI client
tests/
    integration_test.rs  79 integration tests using the redis crate

Design Decisions

No Redis/RESP library dependencies — the RESP parser, serializer, data structures, and command handlers are all implemented from scratch. Only general-purpose crates are used (tokio, bytes, mlua, thiserror, rand, tracing).
Single shared store behind Arc<RwLock> — simple concurrency model that matches Redis's single-threaded semantics. Each connection gets its own ClientState for per-client data (selected DB, transaction queue, auth status).
Lazy + active expiration — keys are lazily expired on access, plus a background task samples keys periodically to proactively reclaim memory.
Streaming RESP parser — handles partial TCP reads and command pipelining naturally. Returns Ok(None) when more data is needed, allowing the server loop to read more and retry.
Embedded Lua 5.4 — full redis.call() / redis.pcall() implementation supporting 60+ Redis commands from within Lua scripts, with proper error handling and RESP value conversion.
Key-version-based WATCH — each key tracks a monotonic version number. WATCH records versions at watch time and compares them at EXEC time, providing correct optimistic locking without per-key subscription overhead.
PSYNC-based replication — masters generate a 40-char replication ID and maintain a circular backlog buffer. Replicas connect, perform a PING/REPLCONF/PSYNC handshake, receive a full RDB for initial sync (or partial data from the backlog for resync), then enter a streaming loop where write commands are forwarded in real-time via per-replica mpsc channels.
Sampled LRU eviction — each key tracks its last access time. When memory limit is reached, the eviction loop samples 5 random keys and evicts the least recently used, matching Redis's approximated LRU algorithm.
Real SLOWLOG — every command is timed and commands exceeding the configurable slowlog-log-slower-than threshold (default 10ms) are recorded in a bounded ring buffer, queryable via SLOWLOG GET/LEN/RESET.

Configuration

Flag	Default	Description
`--port`	`6379`	TCP port
`--bind`	`127.0.0.1`	Bind address
`--databases`	`16`	Number of databases
`--requirepass`	(none)	Password for AUTH
`--timeout`	`0`	Client idle timeout (seconds, 0 = disabled)
`--hz`	`10`	Background task frequency
`--loglevel`	`notice`	Log level
`--appendonly`	`no`	Enable AOF persistence
`--appendfsync`	`everysec`	AOF fsync policy (always/everysec/no)
`--dbfilename`	`dump.rdb`	RDB filename
`--dir`	`.`	Working directory for persistence files
`--maxmemory`	`0`	Memory limit in bytes (0 = unlimited)
`--maxmemory-policy`	`noeviction`	Eviction policy (noeviction/allkeys-random/volatile-random/volatile-ttl/allkeys-lru/volatile-lru)
`--replicaof`	(none)	Replicate from master (host port)
`--repl-backlog-size`	`1048576`	Replication backlog size in bytes
`--save`	`3600 1 300 100 60 10000`	Auto-save rules (seconds changes)
`--slowlog-log-slower-than`	`10000`	Slowlog threshold in microseconds (-1 = disabled)
`--slowlog-max-len`	`128`	Maximum slowlog entries

All configurable parameters are also available via CONFIG GET/CONFIG SET at runtime.

License

MIT

Name		Name	Last commit message	Last commit date
Latest commit History 26 Commits
.githooks		.githooks
.github/workflows		.github/workflows
benches		benches
src		src
tests		tests
.gitignore		.gitignore
CLAUDE.md		CLAUDE.md
Cargo.lock		Cargo.lock
Cargo.toml		Cargo.toml
README.md		README.md
TODO.md		TODO.md

jonwiggins/cedis

Folders and files

Latest commit

History

Repository files navigation

Cedis

Highlights

Progress Report

Implementation Phase Status

Test Results

Redis TCL Test Suite (External Mode)

redis-benchmark

Client Library Compatibility

What's Left to Do

Supported Commands

Strings (22)

Lists (22)

Hashes (17)

Sets (17)

Sorted Sets (34)

Streams (14)

Bitmaps (7)

HyperLogLog (3)

Geospatial (9)

Keys (26)

Pub/Sub (6)

Transactions (5)

Scripting (3)

Replication (5)

Server & Connection (25+)

Getting Started

Build

Run the server

Connect with any Redis client

Run the tests

Architecture

Design Decisions

Configuration

License

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages