Modern distributed software is polyglot. A cloud backend might have microservices written in Go, low-latency data pipelines in Rust, web APIs in TypeScript/Node, iOS clients in Swift, and Android/JVM services in Kotlin.

Yet, when working across different language ecosystems, caching semantics are wildly fragmented:

  • Eviction policies behave differently ($O(1)$ LRU vs probabilistic vs FIFO).
  • Concurrency models handle mutex contention and clock drift inconsistently.
  • Dependency bloat drags dozens of third-party packages into otherwise clean microservices.

To solve this, we engineered KVDock natively across 5 languages with zero external dependencies in core and unified memory/concurrency semantics.

Here is what we learned building high-performance key-value engines across Rust, Go, TypeScript, Swift, and Kotlin.

1. Rust (kvdock-rs): Monotonic Clocks & Zero Lock Contention

In systems programming, relying on wall-clock time (SystemTime) for TTL eviction is dangerous because NTP clock synchronizations or leap seconds can cause erratic cache expirations.

In kvdock-rs, we enforce TTL using monotonic Instant:

use kvdock_rs::{KVDock, MemoryAdapter}; use std::time::Duration; #[tokio::main] async fn main() { let adapter = MemoryAdapter::new(10_000); let dock = KVDock::new(adapter).with_default_ttl(Duration::from_secs(60)); // Single-flight stampede coalescing in Rust let session = dock.get_or_set("user:session:101", || async { fetch_user_from_db().await }).await; }
  • Concurrency: Thread-safe KVDock<A> backed by read-write locks for sub-microsecond concurrent reads.
  • Eviction: True $O(1)$ LRU with doubly-linked intrusive pointers.

2. Go (kvdock-go): Generics & Singleflight Mutexes

Go 1.18+ generics revolutionized type-safe caching without interface{} type assertions:

package main import ( "context" "time" "github.com/zisam-glitch/kvdock-go" ) type UserSession struct { UserID string Role string } func main() { dock := kvdock.New(kvdock.WithMemoryAdapter(10000), kvdock.WithTTL(60 * time.Second)) // Generic type-safe get or set val, err := kvdock.GetOrSet[UserSession](dock, context.Background(), "user:101", func() (UserSession, error) { return queryUserFromDB() }) }
  • Concurrency: Combines atomic operational telemetry with internal single-flight deduplication to ensure concurrent Goroutines requesting the same missing key coalesce into a single execution.

3. TypeScript (kvdock): Zero Dependencies & Universal Runtimes

JavaScript runtimes are now fragmented across Node.js, Bun, Deno, and Cloudflare Workers:

import { KVDock, TieredDock } from "kvdock"; import { MemoryAdapter } from "kvdock/adapters/memory"; import { RedisAdapter } from "kvdock/adapters/redis"; const dock = new TieredDock({ l1: new MemoryAdapter({ maxSize: 10_000 }), // In-memory L1 (< 0.05ms) l2: new RedisAdapter({ url: process.env.REDIS_URL }), // Distributed L2 l1TTL: 15_000 });
  • Key Innovation: Zero runtime dependencies in core. Tree-shakeable dual ESM/CJS exports with single-flight promise coalescing that reduces database stampedes by 99.9%.

4. Swift (kvdock-swift): Swift 6 Concurrency & Actor Isolation

In modern Swift, data races are caught at compile-time using structured concurrency:

import KVDockSwift let dock = await KVDock( adapter: MemoryAdapter(capacity: 10_000), defaultTTL: .seconds(60) ) // Actor-isolated thread-safe access let user = try await dock.getOrSet("user:profile") { try await fetchUserProfile() }
  • Uses ContinuousClock for nanosecond monotonic TTL expiration.

5. Kotlin (kvdock-kt): Access-Order LRU & Coroutines

On the JVM and Android, coroutine compatibility and low memory overhead are paramount:

import com.kvdock.KVDock import com.kvdock.adapters.MemoryAdapter import kotlin.time.Duration.Companion.minutes val dock = KVDock(MemoryAdapter(maxSize = 10_000), defaultTTL = 1.minutes) val order = dock.getOrSet("order:7788") { fetchOrderFromDatabase() }

The Polyglot Ecosystem on GitHub

Explore the source code, benchmarks, and architectures:

⭐ Star the repos & follow @zisam-glitch for deep dives into low-latency systems architecture!