Engineered with a hardware-accelerated kqueue/epoll multi-reactor engine, 64 lock-striped shards, 111µs p50 latency, native AI vector search, Redis Streams, cluster gossip bus, embedded Lua 5.1, Wasm runtime, and an automated K8s operator. Drop-in compatible with standard Redis clients.
Run commands against a client-side in-memory simulator with real-time vector cosine calculations, streams, and cluster topology. No installation required.
Audited with official redis-benchmark across concurrent client connections, latency percentiles, and multi-core scalability.
redis-benchmark -h 127.0.0.1 -p 7379 -c 50 -n 100000 -t get,set -q
How VortexKV balances ultra-low latency, pure Go memory safety, native AI vectors, and zero-CVE containers.
| Dimension / Feature |
RECOMMENDED
⚡ VortexKV
Pure Go Engine
|
Redis 7.2 / Valkey | DragonflyDB | Microsoft Garnet | KeyDB |
|---|---|---|---|---|---|
| Core Architecture | 64-Shard Lock-Striped Concurrency | Single-Threaded Event Loop + I/O Threads | Thread-per-core (Fibers + io_uring) | Tsavorite Cache + Vectorized Network | Multi-Threaded Event Loop |
| Language & Runtime | Pure Go (Zero CGO) | C | C++ | C# (.NET 8 Runtime) | C++ |
| Container Security & Footprint | Zero CVEs (0C 0H 0M 0L) • 14MB Distroless | Requires full OS / libc (~50MB) | C++ Runtime (~85MB) | .NET Runtime (~115MB) | C++ dependencies (~65MB) |
| Native AI Vector Search | Built-in Core (HNSW, Cosine, L2) | Requires separate Redis Stack module | Experimental / Plugin | None | None |
| Visual Command Deck / Studio | Built-in Port 7380 Cyberpunk UI | Requires separate RedisInsight | None (Third-party GUI) | None | None |
| Redis Streams & Consumer Groups | Full Native (XADD, XREADGROUP, PEL, XACK) | Full Support | Full Support | No Streams Support | Full Support |
| Scripting Engine | Dual: Lua 5.1 & WebAssembly (Wasm) | Lua 5.1 only | Lua 5.1 only | C# Raw Fast-Procs | Lua 5.1 only |
| Cluster & Auto-Failover | Autonomous Gossip Bus (Zero External Sentinel) | Redis Sentinel / Redis Cluster | Redis Cluster compatible | Cluster compatible | Active-Replica Mode |
| Direct Concurrency (50 conns, Local)* | 210,970 ops/s | ~112,000 ops/s | ~205,000 ops/s | ~195,000 ops/s | ~162,000 ops/s |
| p50 Latency (50 Conns, Local) | 111 µs | 340 µs | ~150 µs | ~140 µs | 215 µs |
| Peak Pipelined Ops/Sec (Multi-Core) | 6,872,852 ops/s | ~950k ops/s | ~3.8M ops/s | ~3.5M ops/s | ~1.2M ops/s |
* Direct (non-pipelined) throughput is governed by Little's Law (Throughput = Concurrency / Latency). With 50 concurrent connections on a single machine, 210,970 ops/s represents sub-240µs end-to-end round-trip execution. Published multi-million non-pipelined figures for Dragonfly/Garnet were achieved using 1,000+ concurrent connections distributed across dedicated 64-core enterprise cloud instances.
How VortexKV's foundational architecture delivers bare-metal peak throughput with memory-safe pure Go:
Dedicated event-driven reactor engine with OS-thread pinned sub-workers and contiguous zero-alloc circular ring buffers, maximizing L1/L2 CPU cache residency.
Eliminates global single-thread bottlenecks with 64 independent cacheline-padded hash shards and zero-alloc inlined FNV-1a hashing running at 27 ns/op.
Inlined zero-copy wire serializers and smart socket write coalescing batch pipelined responses into consolidated kernel writes, slashing 95% of syscalls.
Designed from the ground up in Go with zero external dependencies and memory safety.
Eliminates the single-thread global mutex bottleneck. Each key hashes to one of 64 independent shards for parallel CPU core utilization.
Store embeddings and perform nearest-neighbor searches (VADD, VSEARCH, VSIM) right inside the KV store with HNSW skip-graphs without heavy vector DB plugins.
High-throughput event streaming with consumer groups, automatic Pending Entries List (PEL) tracking, zero-CPU blocking reads, and 1-click XACK.
16,384 CRC16 hash slots with dedicated binary heartbeat bus on port 17379, autonomous PFAIL/FAIL consensus, and instant replica election without human intervention.
Native CLI tool (vortex-cli cluster rebalance --auto) calculating minimal migration diffs and automating live slot migrations across masters with zero downtime.
Sub-millisecond atomic scripts (EVAL, EVALSHA, SCRIPT LOAD) in pure Go with SHA1 caching, redis.call/pcall bridge, and 5-second runaway execution protection.
Pure-Go WebAssembly runtime powered by wazero (zero CGO) executing compiled Rust, Go, or C modules with direct keyspace bindings (vortex_get, vortex_set).
Declarative CustomResourceDefinition (kind: VortexCluster) and Go controller managing automated pod lifecycle, slot partitioning, and dynamic scale-out on K8s.
Standard REDIS0009 point-in-time binary snapshots (SAVE, BGSAVE) with 64-bit CRC64 checksums alongside Append-Only File (AOF) durability with fsync policies.
Redis 6+ compatible PSYNC, REPLCONF, and REPLICAOF for horizontal read scaling, live command streaming, and instant failover (REPLICAOF NO ONE).
Single self-contained binary includes a rich cyberpunk command deck (port 7380) with 2D/3D force-directed galaxy visualization and real-time slowlog stream.
Standard /metrics text exporter and Kubernetes /healthz liveness/readiness probes built in for seamless Datadog, Grafana, and K8s integration.
Redis 6+ ACL wire protocol with key namespace restrictions (~cache:*, ~orders:*), roles (admin, readwrite, readonly), and visual user management.
Listens on dedicated ports 7379 (wire) and 7380 (deck), allowing VortexKV to run alongside existing Redis instances without collision.
Everything you need to know about VortexKV architecture, Redis drop-in compatibility, AI vector indexing, and cloud-native clustering.
VortexKV is an ultra-fast, open-source in-memory key-value database and AI vector engine written in Go. It delivers wire-level protocol compatibility with Redis, meaning you can connect directly using standard client libraries (redis-cli, redis-py, ioredis, go-redis, Jedis) without rewriting application logic, while leveraging modern 64-shard lock-striped concurrency and an integrated visual command deck.
VortexKV achieves world-record velocity through four core architectural pillars: (1) a hardware-accelerated Multi-Reactor engine with OS thread pinning on kqueue (macOS) and epoll (Linux), (2) zero-allocation circular ring buffers and inlined zero-copy wire serializers (435M ops/sec), (3) a 64-way cacheline-padded lock-striped keyspace with zero-alloc FNV-1a hashing (75.9M lookups/sec), and (4) smart socket pipeline coalescing that batches hundreds of pipelined responses into single consolidated kernel writes.
Yes. VortexKV natively implements Redis Streams specifications including XADD, XREAD, XREADGROUP, XGROUP CREATE, XACK, and XPENDING. It tracks millisecond-sequence stream IDs, per-consumer group Pending Entries Lists (PEL), and consumer message acknowledgment state for reliable distributed event streaming.
VortexKV features first-class AI vector indexing via VADD, VSEARCH, VDEL, and VLIST commands. It supports Cosine Similarity, Euclidean (L2) distance, and Dot Product calculations directly in memory. You can store embeddings for LLM context retrieval, semantic document search, or recommender systems without maintaining a separate external vector database.
VortexKV incorporates an automated peer-to-peer gossip protocol across 16,384 cluster hash slots. Nodes continuously exchange heartbeats and state on port 7379+10000. It supports dynamic slot reassignment (CLUSTER ADDSLOTS, CLUSTER NODES), asynchronous master-replica replication (PSYNC, REPLCONF), and automated failover (REPLICAOF NO ONE).
Yes. Production multi-architecture Docker containers are distributed on Docker Hub (ianshugarg/vortexkv:latest) and GitHub Container Registry (GHCR) with zero vulnerabilities (CVE-free distroless runtime). For Kubernetes, VortexKV offers an official Helm chart and a custom Go Kubernetes Operator (kind: VortexCluster) that automates pod provisioning, slot rebalancing, and rolling upgrades.
Yes. VortexKV includes a built-in Lua 5.1 interpreter supporting EVAL, EVALSHA, and SCRIPT LOAD with atomic redis.call() bindings. Furthermore, it embeds a pure-Go WebAssembly runtime powered by wazero (zero CGO) capable of running precompiled Rust, Go, or C Wasm binaries for high-compute custom transforms directly within the storage engine.
VortexKV supports dual enterprise persistence modes: real-time Append-Only File (AOF) logging with configurable fsync policies (always, everysec, no), and asynchronous point-in-time binary RDB snapshots (SAVE, BGSAVE) matching the official REDIS0009 specification with 64-bit CRC64 integrity verification.
Download the pre-compiled binary or launch the Docker container in under 30 seconds.