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.
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.
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.
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.
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.
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.
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.
Documented RESP Compatibility
Core RESP commands are available over standard TCP/IP. Validate the commands, client behavior, and failure semantics that your application requires.
“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 s.
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 Off
Transparent LZ4 compression and NVMe off 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
from spedo_client import SpedoClient
client = SpedoClient(host="127.0.0.1", port=6380)
maintenance = client.bind_var("flags:maintenance", default=False)
print(f"✓ Maintenance Active: {maintenance.value}")
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}")
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.
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.