Article illustration 1

In the rapidly evolving landscape of lightweight databases, a new contender has emerged from the Go ecosystem. ElysianDB, an open-source key-value store developed by Taymour, promises Redis-like simplicity with modern cloud-native DNA. Built entirely in Go 1.23+, it delivers surprising performance numbers while maintaining a remarkably small footprint—a combination that's capturing developer attention.

Engineered for Efficiency

At its core, ElysianDB employs a sharded in-memory architecture controlled by a straightforward YAML configuration:

store:
  folder: /data
  shards: 512                  # power of two recommended
  flushIntervalSeconds: 5      
server:
  http: { enabled: true, host: 0.0.0.0, port: 8089 }
  tcp:  { enabled: true, host: 0.0.0.0, port: 8088 }

The shards parameter (recommended as powers of two) allows tuning for different workload patterns, while the periodic flush mechanism ensures persistence without sacrificing responsiveness. This deliberate simplicity extends to deployment—developers can run it as a single Go binary or leverage prebuilt Docker images for instant cloud integration:

docker run -d --name elysiandb \
  -p 8089:8089 -p 8088:8088 \
  -v elysian-data:/data \
  taymour/elysiandb:latest

Dual Protocol Flexibility

ElysianDB's standout feature is its dual-protocol support, catering to different performance and integration needs:

  1. Redis-Style TCP Protocol:

    • Line-based text protocol with GET/SET/DEL/PING commands
    • Supports TTL via SET TTL=10 <key> <value> syntax
    • Minimal parsing overhead for maximum throughput

  2. RESTful HTTP API:

    • CRUD operations via intuitive endpoints (PUT /kv/{key}, GET /kv/{key})
    • Administrative endpoints for persistence (POST /save) and reset (POST /reset)
    • Built-in health checks at /health

This dual approach lets developers choose between raw speed (TCP) and integration simplicity (HTTP) without maintaining separate data stores.

Performance That Turns Heads

The benchmark numbers reveal ElysianDB's serious performance credentials:

  • TCP Protocol:
    • 361,966 req/s throughput (500 VUs, 16B payloads)
    • p50 latency: 0.84ms, p99: 6.11ms
  • HTTP Protocol:
    • 72,814 req/s with PUT/GET/DEL mix
    • p50 latency: 2.1ms
# Run performance tests
make tcp_benchmark   # Native Go benchmark tool
make http_benchmark  # k6-based HTTP test

The 5x throughput difference between protocols highlights HTTP's inherent overhead—valuable data for architects choosing communication layers. These numbers are particularly impressive considering ElysianDB includes persistence mechanisms absent in many pure in-memory caches.

The Developer Experience Advantage

Beyond raw specs, ElysianDB optimizes for operational simplicity:

  • Zero dependencies beyond Go standard library
  • Single-binary deployment with Docker as first-class citizen
  • Declarative configuration via YAML
  • TTL support for ephemeral data patterns

While currently lacking unit tests (a noted development priority), the project provides production-grade tooling including the built-in elysian_bench load generator—a rarity in nascent database projects.

A New Player in the KV Arena

ElysianDB arrives at an opportune moment. As microservices and serverless architectures demand lean, high-throughput data layers, its combination of Go's concurrency model, protocol flexibility, and minimal operational footprint presents a compelling alternative. The project doesn't aim to replace feature-rich databases, but rather fills the niche for applications needing predictable microsecond response times with zero operational ceremony.

For performance-sensitive Go shops and cloud-native teams, ElysianDB warrants serious consideration—a testament to how focused engineering can yield exceptional results. Its MIT-licensed source invites collaboration, potentially growing into a significant player in the lightweight database ecosystem.

Source: ElysianDB GitHub Repository