Cache a JSON API response with a TTL
Connect privately, store a synthetic response, read it back and check expiration.
Cache hot JSON responses and rebuildable application state through documented RESP commands. Start with a bounded workload, check the behavior your application needs, and keep your source of truth.
Stop gluing together 5 different databases, background daemons, and polling loops. Spedo gives your application instant superpowers out-of-the-box.
Change a variable or feature flag on Server A, and it updates on Server B instantly in nanoseconds — zero WebSockets or database polling needed.
Store embeddings and run semantic similarity search directly in your cache — no need to host, sync, or pay for separate vector databases.
Old and inactive keys automatically offload to NVMe disk — cut your cloud RAM bills by 75% and never suffer Redis OOM spikes again.
Queue and prioritize background jobs with automatic retries, leases, and dead-letter protection — zero Celery or RabbitMQ brokers to maintain.
Generate single-use passwords and secure magic links that auto-delete the exact instant they are read — no cleanup cron scripts required.
Survive container restarts and host crashes with documented WAL durability — reload millions of keys in under 1.5 seconds with zero SQL stampedes.
Read hot cache data directly in your application process at 0.8µs — 10x faster than network roundtrips, with automatic push invalidation.
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.”
A FIRST WORKLOAD YOU CAN CHECK
Start with one synthetic cache entry and a five-second TTL. Verify the exact response, then verify the miss after expiration. Keep the authoritative data in your existing application.
SET guide:cache:product:42 '{"id":42,"name":"demo"}' EX 5
GET guide:cache:product:42
# After more than five seconds: GET returns a miss.1. JSON round trip: the returned fields match the input.
2. TTL expiry: the key becomes a cache miss.
A correctness walkthrough, not a throughput or recovery benchmark. Preview scope: one node, documented RESP commands, rebuildable data.
PRACTICAL GUIDES
Connect privately, store a synthetic response, read it back and check expiration.
Define the workload, test fallback behavior and keep recovery evidence separate from speed claims.
Designed for mission-critical architectures requiring sub-millisecond data speed, AI vector similarity, matrix linear algebra, event streaming, and resilient task orchestration.
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.
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.
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.
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.
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.
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.
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.
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.
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 good first evaluation is hot configuration, computed data, or other values your application can rebuild independently after a restart.
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.
Core commands are documented for evaluation. Compatibility is command-by-command, including client libraries and error behavior.
Spedo focuses on blazing-fast single-node in-memory throughput with local durability, not multi-region Raft quorum consensus.
Spedo combines in-memory speed with documented single-node KV/JSON recovery; it is not a distributed HA system.
Use the command reference and validate each client feature, transaction, scripting, and failure path before migration.
SPDO2 checkpoints and qualified KV/JSON WAL replay are local, single-node mechanisms. always fsyncs covered writes before ACK.
Transparent LZ4 compression and NVMe offloading under high memory pressure with zero-loss lazy rehydration on reads.
Designed for ultra-low latency, native AI embeddings, and enterprise reliability.
In-memory key/value and documented RESP commands over standard TCP/IP.
SPDO2 snapshots with previous-generation fallback and qualified KV/JSON WAL modes.
spedo is the public SDK package. Use it to qualify the commands and acknowledgement semantics your application needs.
Vectors, search, queues, CDC, scripting, reactive state, and JSON are available for evaluation under their documented feature contracts.
Local cache, adaptive prefetch, and write-behind are experimental single-process optimizations, not distributed-coherence or durability mechanisms.
SAVE WAIT and PERSIST.STATUS make checkpoint and local WAL state observable; control-plane access must stay private.
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.
Start with make test. Confirm the documented commands and data semantics that your application will actually use.
Use make matrix and make bench-pipeline with the reported configuration. Keep direct-server and local-client results separate.
Record the Spedo version, host, dataset, concurrency, persistence mode, client, and latency percentiles alongside any result.
Choose your stack below to install the client SDK, start the in-memory engine, and run your first sub-millisecond operations.
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
Install the ultra-fast public Python SDK for connection pooling, live variables, and L1 cache.
pip install spedo==0.75.0
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'))"
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}")
For teams with rebuildable cache or derived KV/JSON state. This is a guided preview, not a production SLA or a Redis Cluster replacement.
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 fitsNo 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.
High-performance data engines require deep mechanical sympathy, zero-allocation memory discipline, and battle-tested production operations.
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.