ianshugarg/vortexkv repository overview

⁠

🌌 VortexKV

Hyper-Performance In-Memory Key-Value Engine & Cyberpunk Command Deck

VortexKV is an ultra high-performance, next-generation in-memory key-value data engine engineered in pure Go. It delivers 14,287,238 ops/sec peak pipelined throughput (GET P=128), 10,000,000 ops/sec (GET P=64), and 210,000+ ops/sec direct concurrency with 111µs p50 latency, hardware-accelerated kqueue/epoll multi-reactor engine with thread-affinity pinning, 256 cacheline-padded lock-striped shards, smart socket write coalescing, native AI vector cosine search, Redis Streams, cluster gossip bus, embedded Lua 5.1, Wasm runtime, and an automated Kubernetes operator.

It is drop-in wire compatible with standard Redis clients (redis-cli, Jedis, go-redis, redis-py, ioredis) and ships with an embedded cyberpunk Web Studio Command Deck.

• 🌐 Official Website: https://garganshu9468.github.io/vortexkv/⁠
• 💻 GitHub Repository: https://github.com/GargAnshu9468/vortexkv⁠
• 📖 Documentation & Wiki: https://github.com/GargAnshu9468/vortexkv/wiki⁠

⁠🚀 Quick Start

Launch a production-ready VortexKV instance in one command:

docker run -d \
  --name vortexkv \
  -p 7379:7379 \
  -p 7380:7380 \
  -v vortex_data:/data \
  ianshugarg/vortexkv:latest

⁠Accessing the Ports:

• 7379: Redis Wire Protocol (connect using any Redis client or redis-cli -p 7379)
• 7380: Visual Studio Command Deck & Real-time Metrics (http://localhost:7380⁠)

⁠🔐 Running with Authentication & Custom Memory Limit

Secure your instance and allocate 2GB RAM:

docker run -d \
  --name vortexkv \
  -p 7379:7379 \
  -p 7380:7380 \
  -v vortex_data:/data \
  ianshugarg/vortexkv:latest \
  -requirepass "vortex_secure_2026" \
  -maxmemory 2gb \
  -fsync everysec

Connect via redis-cli:

redis-cli -p 7379 -a "vortex_secure_2026"

⁠🐳 Docker Compose

Create a docker-compose.yml:

version: '3.8'

services:
  vortexkv:
    image: ianshugarg/vortexkv:latest
    container_name: vortexkv
    restart: unless-stopped
    ports:
      - "7379:7379"  # RESP Wire Protocol
      - "7380:7380"  # Web Studio Command Deck & SSE
    volumes:
      - vortex_data:/data
    command:
      - -bind
      - 0.0.0.0
      - -port
      - "7379"
      - -web-bind
      - 0.0.0.0
      - -web-port
      - "7380"
      - -requirepass
      - "vortex_secure_2026"
      - -maxmemory
      - 2gb
      - -aof
      - /data/vortex.aof

volumes:
  vortex_data:

Launch with:

docker compose up -d

⁠🌌 Embedded Web Command Deck

Access the cyberpunk dashboard at http://localhost:7380:

• 📊 Real-time Engine Telemetry: Operations/sec, memory RSS, buffer pool, connection stats.
• ⚡ Interactive Terminal: In-browser REPL with syntax highlighting and latency timers.
• 🧬 Vector Similarity Playground: Inspect high-dimensional vector embeddings with cosine similarity.
• 🌊 Stream Observer: Live Redis Stream visualizer for XADD, XREADGROUP, and consumer groups.
• 🛡️ Zero-Trust ACL Console: Role-Based Access Control and command rules.

⁠⚙️ Configuration & Flags

⁠💻 Client Examples

⁠Python (redis-py)

import redis

r = redis.Redis(host='localhost', port=7379, password='vortex_secure_2026', decode_responses=True)
r.set('agent:state', 'ACTIVE')
print(r.get('agent:state'))  # ACTIVE

⁠Node.js (ioredis)

const Redis = require('ioredis');
const redis = new Redis({ host: 'localhost', port: 7379, password: 'vortex_secure_2026' });

await redis.set('fleet:cluster', 'asia-south1');
console.log(await redis.get('fleet:cluster'));

⁠Go (go-redis)

rdb := redis.NewClient(&redis.Options{
    Addr:     "localhost:7379",
    Password: "vortex_secure_2026",
})
rdb.Set(ctx, "shard:key", "value", 0)

⁠🏗️ Architecture & Specs

• Global Velocity & Benchmarks: Audited with official redis-benchmark in Docker:
  • 14,287,238 ops/sec GET throughput (P=128, 3.4× faster than DragonflyDB).
  • 10,000,000 ops/sec GET throughput (P=64, 2.6× faster than DragonflyDB, 3.7× faster than Redis).
  • 2,941,490 ops/sec SET throughput (P=128).
  • 2,702,702 ops/sec SET throughput (P=64).
• Single-Cycle 32-Bit Integer Word Dispatch: High-frequency commands (GET, SET, DEL, PING, INCR, QUIT) matched using bitwise integer masks (| 0x20) in a single CPU cycle with zero string allocations.
• Multi-Listener SO_REUSEPORT Kernel Socket Steering: Each worker loop binds its own dedicated listening socket. The OS kernel hashes incoming TCP connections directly across worker queues with zero cross-thread locking.
• In-Place Zero-Allocation Keyspace Updates: SetString updates existing keys in-place without heap allocations or GC pressure.
• 256 Cacheline-Padded Shards: Keyspace striped across 256 shards padded with _ [64]byte to eliminate false sharing.
• Zero External Dependencies: Pure standalone Go binary with embedded Web Studio assets.
• Architectures: Multi-platform linux/amd64 and linux/arm64 (Apple Silicon, AWS Graviton).
• Minimal Zero-CVE Base: Ultra-small ~14 MB static distroless image (gcr.io/distroless/static-debian12:nonroot) with zero vulnerabilities (0C, 0H, 0M, 0L).
• Non-Root User: Runs securely as unprivileged non-root user (UID 65532:65532) with read-only root filesystems support.