Spedo
SPEDO ENGINE
v0.69.0 PREVIEW
“You don't get an Einstein by committee, nor an F1 car by chaining bicycles together. I choose the relentless focus of a single, tuned engine over the overhead of a deliberating crowd.”

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.

Why Developers & DevOps Choose Spedo

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.

Real-Time State

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
Built-In AI

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
FinOps & Stability

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
Task Queues

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
Auto-Eviction

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
Zero Data Loss

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
< 1µs Speed

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
Zero Code Changes

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
Vision & Architecture

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

Mechanical Sympathy & Philosophy

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

PRODUCTION USE CASES

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 & EMBEDDINGS

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.

VECTOR.SEARCH index [0.04, -0.18, 0.81] TOP_K 5 COSINE
✓ 0.90ms Top-K search · Int8 SQ8 4x density compression
Read AI & RAG Architecture Guide
BLAS LINEAR ALGEBRA

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.

MATRIX.VECMUL weights vec_input · MATRIX.DOT A B
✓ 107k matrix dot ops/s · Zero-copy register computing
Read Matrix & BLAS Architecture Guide
KAFKA-LIKE STREAMING

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.

QCONSUME_GROUP topic:events group:analytics ACK auto
✓ Consumer group load balancing · In-memory stream offsets
Read Kafka Claim-Check Architecture Guide
AIRFLOW-LIKE ORCHESTRATION

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.

QPUSH queue:tasks PRIORITY 0 · QPOP queue:* COUNT 50
✓ 7:2:1 weighted batches · Surplus borrowing · FAMILY rotation
Read the FairShare Guide
SUB-MICROSECOND L1 CACHE

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.

client = SpedoClient(local_cache=True) · 0.8µs local reads
✓ <1µs in-process L1 reads · 446,000 GET/s per application pod
Read Zero-Wire Microservices Guide
FINOPS RAM OPTIMIZATION

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.

used_memory: 1.2GB (4.8GB uncompressed payload) · 0% drops
✓ 4.2x effective RAM capacity · 0% data drop on eviction
Read FinOps & ColdArchive Guide
LIVE ON SPEDO.DEV SUB-MILLISECOND WEB CACHE

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.

✓ < 0.2ms page delivery · 100% disk/CPU offload on cache hits · Instant operator cache purge
|
● LIVE RAM
# 1. Native Spedo client + FastAPI middleware
from spedo import Spedo
spedo = Spedo(host="127.0.0.1", port=6380)
@app.middleware("http")
async def spedo_page_cache_middleware(request, call_next):
if request.method != "GET" or request.url.path.startswith("/admin"):
return await call_next(request) # bypass admin/mutations
# Check Spedo RAM cache (< 0.2ms lookup)
hit = spedo.get(f"cache:{request.url.path}")
if hit: return Response(hit, headers={"X-Cache": "HIT-SPEDO"})
# On MISS: execute route below & store in Spedo RAM (TTL: 300s)
res = await call_next(request)
if res.status_code == 200:
body = b"".join([c async for c in res.body_iterator])
spedo.set(f"cache:{request.url.path}", body, ex=300)
return Response(body, headers={"X-Cache": "MISS-SPEDO"})
return res
# 2. WHERE IT'S USED: Your actual route! (Bypassed on cache hit)
@app.get("/docs/{slug}")
async def view_docs(slug: str):
return HTMLResponse(render_markdown(slug)) # 12ms SSR only on miss!
EXCLUSIVE KILLER FEATURE 3.52M READS/S · 0 NETWORK HOPS 2,350× FASTER THAN REDIS

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.

✓ 3.52M in-process reads/sec · 0 network roundtrips · Instant < 1ms cluster-wide push sync · Zero-polling async/await
| |
● ZERO-WIRE IPC
# 1. Bind remote Spedo key directly into Python process RAM
from spedo import Spedo
spedo = Spedo(host="127.0.0.1", port=6380)
maintenance = spedo.bind_var("flags:maintenance", default=False)
checkout_cfg = spedo.bind_var("config:checkout", default={"provider": "stripe", "max_cart": 50})
@checkout_cfg.on_change
def on_rollout(new_cfg):
print("[push-sync] Real-time rollout pushed to this pod:", new_cfg)
# 2. In hot request path: ZERO NETWORK CALLS (0.0001ms / 3.52M reads/s)!
@app.get("/checkout")
async def handle_checkout(cart):
if maintenance.value: # In-process local pointer read (0.28µs)
return JSONResponse({"error": "Maintenance"}, status_code=503)
return process_order(cart, provider=checkout_cfg.value["provider"])
# 3. Admin updates key -> Spedo pushes to all 100 pods in < 1ms:
checkout_cfg.value = {"provider": "spedo_fast_pay", "max_cart": 100}
EVALUATION FIT

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.

HOT DERIVED STATE

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.

✓ Define the rebuild path before production use
KV/JSON RECOVERY

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.

✓ Verify snapshots, WAL mode, and restore on your production dataset
FULL RESP STANDARD

Drop-in Redis Protocol Compatibility

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

✓ Seamless drop-in integration with redis-py & standard drivers
OUT OF SCOPE

Multi-Region Distributed Quorum

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

✕ Use cloud-managed multi-region engines if required
RELIABILITY & PRODUCT CAPABILITIES

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.

CORE CAPABILITIES

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.

REPRODUCIBLE BENCHMARKS

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.

YCSB Benchmark Suite (5/5 Wins) ↗ Zipfian Skew θ=0.99 (3.8× WOW) ↗ RepoFlow C++ Matrix ↗ Performance Dashboard ↗ Read benchmark method ↗
DEVELOPER QUICKSTART & SDkS

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' spedo/spedo:v0.69.0

2. Install Python SDK

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

pip install spedo==0.69.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

# 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}")
DESIGN-PARTNER EVALUATION

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

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.

Request an evaluation Read the evaluation guide