# Show HN: Spedo, a single-node RESP runtime for rebuildable KV/JSON

> Source: <https://spedo.dev/>
> Published: 2026-10-15 11:29:18+00:00

# In-Memory RESP Runtime with Qualified Local Recovery.

A 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.

## Solve Everyday Backend Headaches in 1 Line of Code

Stop gluing together 5 different databases, background daemons, and polling loops. Spedo gives your application instant superpowers out-of-the-box.

### Auto-Synced Global Variables

Change a variable or feature flag on Server A, and it updates on Server B instantly in nanoseconds — zero WebSockets or database polling needed.

[Read more →](https://spedo.dev/docs/index.html#live-vars)

### Instant AI Vector Search

Store embeddings and run semantic similarity search directly in your cache — no need to host, sync, or pay for separate vector databases.

[Read more →](https://spedo.dev/docs/index.html#vector-search)

### Zero Out-of-Memory Crashes

Old and inactive keys automatically offload to NVMe disk — cut your cloud RAM bills by 75% and never suffer Redis OOM spikes again.

[Read more →](https://spedo.dev/docs/index.html#use-case-2-finops)

### Built-In Background Task Queues

Queue and prioritize background jobs with automatic retries, leases, and dead-letter protection — zero Celery or RabbitMQ brokers to maintain.

[Read more →](https://spedo.dev/docs/index.html#priority-queues)

### Self-Destructing Tokens & OTPs

Generate single-use passwords and secure magic links that auto-delete the exact instant they are read — no cleanup cron scripts required.

[Read more →](https://spedo.dev/docs/index.html#burn-after-reading)

### 150ms Restarts & Zero Loss

Survive container restarts and host crashes with documented WAL durability — reload millions of keys in under 1.5 seconds with zero SQL stampedes.

[Read more →](https://spedo.dev/docs/index.html#configuration)

### Sub-Microsecond App Cache

Read hot cache data directly in your application process at 0.8µs — 10x faster than network roundtrips, with automatic push invalidation.

[Read more →](https://spedo.dev/docs/index.html#use-case-3-microservices)

### Documented RESP Compatibility

Core RESP commands are available over standard TCP/IP. Validate the commands, client behavior, and failure semantics that your application requires.

[Read more →](https://spedo.dev/docs/index.html#kv-crud)

“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.”

“Simplicity and absolute speed are not achieved by adding layers, but by stripping away everything unnecessary until data and the processor become one.”

## Architectural Workload Patterns & Solutions

Designed for mission-critical architectures requiring sub-millisecond data speed, AI vector similarity, matrix linear algebra, event streaming, and resilient task orchestration.

### AI RAG & LLM KV-Cache Acceleration

Perform 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.

### In-Memory 2D Matrix & Tensor Computing

Run 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.

### Streaming, Consumer Groups & CDC

Implement 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.

### Task DAG Pipelines & FairShare 7:2:1

Schedule 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.

### High-Throughput Microservice Caching

Embed 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.

### ColdArchive RAM Compression (Zero Drop)

Cut 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.

### In-Memory Edge & Web Gateway Page Caching

                            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.
                        

### Reactive Live Variables (`bind_var`) & Zero-Polling State

                            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.
                        

## Start with a bounded, rebuildable workload.

Use the same source of truth and failure plan you would use without Spedo. Measure behaviour in your own topology before extending the scope.

### A cache with a separate source of truth

A good first evaluation is hot configuration, computed data, or other values your application can rebuild independently after a restart.

### Qualified local KV/JSON recovery

                        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.
                    

### Drop-in Redis Protocol Compatibility

Core commands are documented for evaluation. Compatibility is command-by-command, including client libraries and error behavior.

### Multi-Region Distributed Quorum

Spedo focuses on blazing-fast single-node in-memory throughput with local durability, not multi-region Raft quorum consensus.

## Measured evaluation. Explicit recovery boundaries.

Spedo combines in-memory speed with documented single-node KV/JSON recovery; it is not a distributed HA system.

### Documented RESP commands

Use the command reference and validate each client feature, transaction, scripting, and failure path before migration.

### KV/JSON snapshot and WAL recovery

`SPDO2` checkpoints and qualified KV/JSON WAL replay are local, single-node mechanisms. `always` fsyncs covered writes before ACK.

### Automated ColdArchive RAM Offloading

Transparent LZ4 compression and NVMe offloading under high memory pressure with zero-loss lazy rehydration on reads.

## Engine Architecture & Capabilities

Designed for ultra-low latency, native AI embeddings, and enterprise reliability.

### Core RESP runtime

In-memory key/value and documented RESP commands over standard TCP/IP.

### Qualified checkpoint & WAL

SPDO2 snapshots with previous-generation fallback and qualified KV/JSON WAL modes.

### Python SDK

`spedo` is the public SDK package. Use it to qualify the commands and acknowledgement semantics your application needs.

### Preview data features

Vectors, search, queues, CDC, scripting, reactive state, and JSON are available for evaluation under their documented feature contracts.

### Local client optimization

Local cache, adaptive prefetch, and write-behind are experimental single-process optimizations, not distributed-coherence or durability mechanisms.

### Operational visibility

`SAVE WAIT` and `PERSIST.STATUS` make checkpoint and local WAL state observable; control-plane access must stay private.

## Benchmark conditions before performance claims

Results depend on workload, hardware, client topology, persistence mode, and network conditions. Reproduce the release matrix on your own host before relying on a comparison.

### 1. Verify the contract

Start with `make test`. Confirm the documented commands and data semantics that your application will actually use.

### 2. Reproduce the matrix

Use `make matrix` and `make bench-pipeline` with the reported configuration. Keep direct-server and local-client results separate.

### 3. Publish the context

Record the Spedo version, host, dataset, concurrency, persistence mode, client, and latency percentiles alongside any result.

## Zero to Production in Under 60 Seconds

Choose your stack below to install the client SDK, start the in-memory engine, and run your first sub-millisecond operations.

### 1. Start Local Spedo Container

Launch a lightweight, self-contained Spedo server container listening on port 6380.

`docker run -d --name spedo-instance -p 127.0.0.1:6380:6380 -e SPEDO_REQUIREPASS='replace-me' torxx666/spedo:v0.75.0`
### 2. Install Python SDK

Install the ultra-fast public Python SDK for connection pooling, live variables, and L1 cache.

`pip install spedo==0.75.0`
### 3. Run First Python Script

Execute sub-millisecond key-value reads, live state binding, and SIMD vector embeddings.

`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'))"`
### app.py — Python Live Variables & Vector Search

``` python
from spedo_client import SpedoClient

# 1. Connect to local Spedo instance (sub-millisecond in-memory engine)
client = SpedoClient(host="127.0.0.1", port=6380)

# 2. In-Process Reactive Live Variable (3.52M reads/s in local RAM)
maintenance = client.bind_var("flags:maintenance", default=False)
print(f"✓ Maintenance Active: {maintenance.value}")

# 3. Key-Value & JSON Storage
client.set("session:usr_101", '{"name": "Alex Dev", "tier": "enterprise"}')
session = client.get("session:usr_101")
print(f"✓ In-Memory Session (0.8µs): {session}")

# 4. Sub-Millisecond AI Vector Similarity Search (SIMD AVX-512)
results = client.vector_search(
    index="documents",
    query_vector=[0.042, -0.189, 0.812],
    top_k=3,
    metric="COSINE"
)
print(f"✓ Nearest Vector Matches (0.60ms): {results}")
```

## Help shape Spedo — five private evaluation places

For teams with rebuildable cache or derived KV/JSON state. This is a guided preview, not a production SLA or a Redis Cluster replacement.

### What you receive

A 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.

[See whether the preview fits](https://spedo.dev/design-partners.html#fit)

### Request a guided evaluation

No 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.

## Built by veteran systems engineers, not AI wrappers

High-performance data engines require deep mechanical sympathy, zero-allocation memory discipline, and battle-tested production operations.

### Dany Cohen

Systems 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.