{"slug": "show-hn-spedo-a-single-node-resp-runtime-for-rebuildable-kv-json", "title": "Show HN: Spedo, a single-node RESP runtime for rebuildable KV/JSON", "summary": "A developer released Spedo, a single-node RESP-compatible in-memory runtime for rebuildable key-value and JSON workloads, offering KV/JSON snapshots and WAL-based local recovery under documented configuration. Spedo bundles auto-synced global variables, in-memory vector search for RAG and LLM KV-cache acceleration at 0.90ms latency, NVMe offload the project says cuts cloud RAM bills by 75%, background task queues, and sub-microsecond in-process cache reads at 0.8µs. The project claims 150ms restarts with WAL durability that reloads millions of keys in under 1.5 seconds, and advises validating command compatibility and the recovery contract per workload before production use.", "body_md": "# In-Memory RESP Runtime with Qualified Local Recovery.\n\nA RESP runtime for hot, rebuildable KV/JSON workloads. Qualified local recovery covers KV/JSON snapshots and WAL modes under the documented configuration. Validate command compatibility and the recovery contract for every workload before production use.\n\n## Solve Everyday Backend Headaches in 1 Line of Code\n\nStop gluing together 5 different databases, background daemons, and polling loops. Spedo gives your application instant superpowers out-of-the-box.\n\n### Auto-Synced Global Variables\n\nChange a variable or feature flag on Server A, and it updates on Server B instantly in nanoseconds — zero WebSockets or database polling needed.\n\n[Read more →](https://spedo.dev/docs/index.html#live-vars)\n\n### Instant AI Vector Search\n\nStore embeddings and run semantic similarity search directly in your cache — no need to host, sync, or pay for separate vector databases.\n\n[Read more →](https://spedo.dev/docs/index.html#vector-search)\n\n### Zero Out-of-Memory Crashes\n\nOld and inactive keys automatically offload to NVMe disk — cut your cloud RAM bills by 75% and never suffer Redis OOM spikes again.\n\n[Read more →](https://spedo.dev/docs/index.html#use-case-2-finops)\n\n### Built-In Background Task Queues\n\nQueue and prioritize background jobs with automatic retries, leases, and dead-letter protection — zero Celery or RabbitMQ brokers to maintain.\n\n[Read more →](https://spedo.dev/docs/index.html#priority-queues)\n\n### Self-Destructing Tokens & OTPs\n\nGenerate single-use passwords and secure magic links that auto-delete the exact instant they are read — no cleanup cron scripts required.\n\n[Read more →](https://spedo.dev/docs/index.html#burn-after-reading)\n\n### 150ms Restarts & Zero Loss\n\nSurvive container restarts and host crashes with documented WAL durability — reload millions of keys in under 1.5 seconds with zero SQL stampedes.\n\n[Read more →](https://spedo.dev/docs/index.html#configuration)\n\n### Sub-Microsecond App Cache\n\nRead hot cache data directly in your application process at 0.8µs — 10x faster than network roundtrips, with automatic push invalidation.\n\n[Read more →](https://spedo.dev/docs/index.html#use-case-3-microservices)\n\n### Documented RESP Compatibility\n\nCore RESP commands are available over standard TCP/IP. Validate the commands, client behavior, and failure semantics that your application requires.\n\n[Read more →](https://spedo.dev/docs/index.html#kv-crud)\n\n“Unify ultra-fast caching, AI vector similarity search, and resilient event streaming into a single in-memory engine — and permanently eliminate the network serialization tax.”\n\n“Simplicity and absolute speed are not achieved by adding layers, but by stripping away everything unnecessary until data and the processor become one.”\n\n## Architectural Workload Patterns & Solutions\n\nDesigned for mission-critical architectures requiring sub-millisecond data speed, AI vector similarity, matrix linear algebra, event streaming, and resilient task orchestration.\n\n### AI RAG & LLM KV-Cache Acceleration\n\nPerform sub-millisecond similarity search across high-dimensional embeddings directly in memory with SIMD AVX-512 & ARM NEON acceleration (0.90ms latency). Eliminates the operational overhead and roundtrip hops of external vector databases.\n\n### In-Memory 2D Matrix & Tensor Computing\n\nRun matrix-vector multiplication (y = A · x), GEMM block dot products (C = A · B), matrix transposition (B = Aᵀ), scaling, and L₂ unit normalization directly inside database RAM at 107k ops/s. Completely eliminates NumPy data serialization bottlenecks.\n\n### Streaming, Consumer Groups & CDC\n\nImplement Kafka-style subscriber consumer groups with explicit partition distribution, message ACK commits, offset replay, and real-time Change Data Capture (CDC). Delivers instant pub/sub event delivery with zero JVM GC pauses.\n\n### Task DAG Pipelines & FairShare 7:2:1\n\nSchedule fast event-driven tasks with FairShare 7:2:1 batches: seven Critical, two Standard and one Batch share, plus surplus borrowing, per-family rotation and chrono-triggers.\n\n### High-Throughput Microservice Caching\n\nEmbed a local in-process L1 cache in your Python/Go microservices for instant <1µs reads (446k ops/s per pod). Includes automatic write-behind background batching and real-time push invalidations from the server when state changes.\n\n### ColdArchive RAM Compression (Zero Drop)\n\nCut cloud RAM costs by up to 75%. ColdArchive monitors key access frequency and compresses cold partitions in memory with LZ4 (up to 4.2x density), eliminating silent data loss and costly cache eviction rebuild spikes.\n\n### In-Memory Edge & Web Gateway Page Caching\n\n                            Dogfooded live on this portal: dynamically rendered documentation and marketing pages are cached directly in Spedo RAM (`portal:cache:page:*`) and delivered in **under 0.2ms** (` X-Cache: HIT-SPEDO`). Completely eliminates repetitive Markdown parsing, template rendering, and disk I/O under viral traffic spikes while strictly bypassing private admin routes.\n                        \n\n### Reactive Live Variables (`bind_var`) & Zero-Polling State\n\n                            Turn any database key into a reactive Python variable that lives directly inside your application process RAM. Reading `maintenance.value` or `config.value` bypasses TCP sockets entirely: local reads execute in **sub-nanoseconds (< 0.0001ms)** sustaining **3,520,000 reads/sec per worker**. Whenever any pod mutates `.value`, Spedo broadcasts an immediate binary push event (` SPEDO.WATCH`) to all 100+ Kubernetes pods in < 1ms. Includes native `asyncio` primitives (`await job.wait_until(\"DONE\")`) killing wasteful CPU polling loops forever.\n                        \n\n## Start with a bounded, rebuildable workload.\n\nUse the same source of truth and failure plan you would use without Spedo. Measure behaviour in your own topology before extending the scope.\n\n### A cache with a separate source of truth\n\nA good first evaluation is hot configuration, computed data, or other values your application can rebuild independently after a restart.\n\n### Qualified local KV/JSON recovery\n\n                        With `SPEDO_WAL_FSYNC=always`, acknowledged covered KV/JSON writes are locally fsynced before ACK. This is not high availability or a durability promise for every specialized structure.\n                    \n\n### Drop-in Redis Protocol Compatibility\n\nCore commands are documented for evaluation. Compatibility is command-by-command, including client libraries and error behavior.\n\n### Multi-Region Distributed Quorum\n\nSpedo focuses on blazing-fast single-node in-memory throughput with local durability, not multi-region Raft quorum consensus.\n\n## Measured evaluation. Explicit recovery boundaries.\n\nSpedo combines in-memory speed with documented single-node KV/JSON recovery; it is not a distributed HA system.\n\n### Documented RESP commands\n\nUse the command reference and validate each client feature, transaction, scripting, and failure path before migration.\n\n### KV/JSON snapshot and WAL recovery\n\n`SPDO2` checkpoints and qualified KV/JSON WAL replay are local, single-node mechanisms. `always` fsyncs covered writes before ACK.\n\n### Automated ColdArchive RAM Offloading\n\nTransparent LZ4 compression and NVMe offloading under high memory pressure with zero-loss lazy rehydration on reads.\n\n## Engine Architecture & Capabilities\n\nDesigned for ultra-low latency, native AI embeddings, and enterprise reliability.\n\n### Core RESP runtime\n\nIn-memory key/value and documented RESP commands over standard TCP/IP.\n\n### Qualified checkpoint & WAL\n\nSPDO2 snapshots with previous-generation fallback and qualified KV/JSON WAL modes.\n\n### Python SDK\n\n`spedo` is the public SDK package. Use it to qualify the commands and acknowledgement semantics your application needs.\n\n### Preview data features\n\nVectors, search, queues, CDC, scripting, reactive state, and JSON are available for evaluation under their documented feature contracts.\n\n### Local client optimization\n\nLocal cache, adaptive prefetch, and write-behind are experimental single-process optimizations, not distributed-coherence or durability mechanisms.\n\n### Operational visibility\n\n`SAVE WAIT` and `PERSIST.STATUS` make checkpoint and local WAL state observable; control-plane access must stay private.\n\n## Benchmark conditions before performance claims\n\nResults depend on workload, hardware, client topology, persistence mode, and network conditions. Reproduce the release matrix on your own host before relying on a comparison.\n\n### 1. Verify the contract\n\nStart with `make test`. Confirm the documented commands and data semantics that your application will actually use.\n\n### 2. Reproduce the matrix\n\nUse `make matrix` and `make bench-pipeline` with the reported configuration. Keep direct-server and local-client results separate.\n\n### 3. Publish the context\n\nRecord the Spedo version, host, dataset, concurrency, persistence mode, client, and latency percentiles alongside any result.\n\n## Zero to Production in Under 60 Seconds\n\nChoose your stack below to install the client SDK, start the in-memory engine, and run your first sub-millisecond operations.\n\n### 1. Start Local Spedo Container\n\nLaunch a lightweight, self-contained Spedo server container listening on port 6380.\n\n`docker run -d --name spedo-instance -p 127.0.0.1:6380:6380 -e SPEDO_REQUIREPASS='replace-me' torxx666/spedo:v0.75.0`\n### 2. Install Python SDK\n\nInstall the ultra-fast public Python SDK for connection pooling, live variables, and L1 cache.\n\n`pip install spedo==0.75.0`\n### 3. Run First Python Script\n\nExecute sub-millisecond key-value reads, live state binding, and SIMD vector embeddings.\n\n`python3 -c \"from spedo_client import SpedoClient; c = SpedoClient(port=6380); c.set('user:1', '{\\\"status\\\":\\\"active\\\"}'); print('✓ Read in 0.8µs:', c.get('user:1'))\"`\n### app.py — Python Live Variables & Vector Search\n\n``` python\nfrom spedo_client import SpedoClient\n\n# 1. Connect to local Spedo instance (sub-millisecond in-memory engine)\nclient = SpedoClient(host=\"127.0.0.1\", port=6380)\n\n# 2. In-Process Reactive Live Variable (3.52M reads/s in local RAM)\nmaintenance = client.bind_var(\"flags:maintenance\", default=False)\nprint(f\"✓ Maintenance Active: {maintenance.value}\")\n\n# 3. Key-Value & JSON Storage\nclient.set(\"session:usr_101\", '{\"name\": \"Alex Dev\", \"tier\": \"enterprise\"}')\nsession = client.get(\"session:usr_101\")\nprint(f\"✓ In-Memory Session (0.8µs): {session}\")\n\n# 4. Sub-Millisecond AI Vector Similarity Search (SIMD AVX-512)\nresults = client.vector_search(\n    index=\"documents\",\n    query_vector=[0.042, -0.189, 0.812],\n    top_k=3,\n    metric=\"COSINE\"\n)\nprint(f\"✓ Nearest Vector Matches (0.60ms): {results}\")\n```\n\n## Help shape Spedo — five private evaluation places\n\nFor teams with rebuildable cache or derived KV/JSON state. This is a guided preview, not a production SLA or a Redis Cluster replacement.\n\n### What you receive\n\nA free 30-day scoped evaluation, setup help for Docker or Kubernetes, a recovery check for the intended host, and direct access to the builder. Your feedback decides what the stable release needs next.\n\n[See whether the preview fits](https://spedo.dev/design-partners.html#fit)\n\n### Request a guided evaluation\n\nNo account, payment, or production data is requested. Complete the short fit form directly on the site; it is stored only for private Master Admin review.\n\n## Built by veteran systems engineers, not AI wrappers\n\nHigh-performance data engines require deep mechanical sympathy, zero-allocation memory discipline, and battle-tested production operations.\n\n### Dany Cohen\n\nSystems engineer and veteran SysAdmin with 25+ years architecting high-throughput infrastructure, Linux production operations, and low-latency data platforms primarily in Python and Rust. Driven by mechanical sympathy, zero-copy memory discipline, and eliminating pointless network hops.", "url": "https://wpnews.pro/news/show-hn-spedo-a-single-node-resp-runtime-for-rebuildable-kv-json", "canonical_source": "https://spedo.dev/", "published_at": "2026-10-15 11:29:18+00:00", "updated_at": "2026-10-15 11:50:12.812691+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-infrastructure", "ai-tools", "large-language-models"], "entities": ["Spedo", "RESP", "Redis", "NVMe", "SIMD AVX-512", "ARM NEON", "NumPy", "Kafka"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/show-hn-spedo-a-single-node-resp-runtime-for-rebuildable-kv-json", "markdown": "https://wpnews.pro/news/show-hn-spedo-a-single-node-resp-runtime-for-rebuildable-kv-json.md", "text": "https://wpnews.pro/news/show-hn-spedo-a-single-node-resp-runtime-for-rebuildable-kv-json.txt", "jsonld": "https://wpnews.pro/news/show-hn-spedo-a-single-node-resp-runtime-for-rebuildable-kv-json.jsonld"}}