KEY-VALUE STORAGE FOR LARGE AI PAYLOADS

Big values.
Full throttle.

The whole payload.
A key to get it back.

Store inference state, tensor batches, and agent memory as large values. Thunder pairs core-local execution with encrypted storage and durable writes.

SELF-HOSTED · BUILT IN RUST · FREE TO RUN ↗

THUNDER ENGINE / 001
An exploded view of the Thunder engineAn isometric processor with independent core tiles sits above storage layers. Orange traces connect the cores to a large data payload. INDEPENDENT CORESDURABLE BY DESIGNFIG. 01 / ENGINE CONCEPT
512 MiB+A SINGLE VALUE. ROOM TO GROW.
LARGE VALUES, FIRST-CLASS CORE-LOCAL REACTORS NATIVE io_uring ENCRYPTED AT REST
01 / THE VALUE IS THE POINT

A tensor batch.
Still just one value.

A serialized tensor can be hundreds of megabytes. A session snapshot can grow with every turn. Store the object your application works with, and retrieve it by key.

THE LITTLE THINGSBytesKeys, metadata, small records
THE BIG PICTURE512 MiB+One key. One large value.
APPLICATION-DEFINED KEYartifacts/encoder-v2/batch-009

The complete serialized object.SHAPE + FORMAT VERSION + PAYLOAD BYTES

For 512 MiB values, configure a 4 GiB arena per reactor. Capacity depends on memory and workload. Sizing guide ↗

02 / DIVIDE THE WORK. OWN THE CORE.[ ARCHITECTURE ]

Every core.
Its own lane.

Work stays with the reactor that owns it. Each reactor has its own arena, shard range, and listening port. The client discovers the layout and routes keys directly.

Explore the architecture
FOLLOW A KEY
YOUR APPLICATIONCRC32C(key) % 1024OWNING REACTOR

The highlighted reactor owns this key’s shard.

8 reactors128 shards / reactor1,024 logical shards. Always.Ports 7380–7387

01 Fixed shard layout.
Flexible reactor ownership.

02 Foreground execution.
Dedicated background work.

03 One starting address.
Client-discovered routing.

SMT ×2 means two hardware threads per physical core. Turn it off to explore a single-thread-per-core CPU. This local illustration uses Thunder’s key hash and uniform CPU topology; actual allocation follows CPU affinity. No data is sent to a database.

03 / THE DATA BEHIND THE MODEL

What will you
put behind a key?

Four ways to use Thunder
in your AI application.

WORKLOAD / INFERENCEILLUSTRATIVE PATTERN

Keep the context you already built.

Store serialized inference state and prompt artifacts by key. Retrieve a previous result when your serving layer decides it can be reused.

EXAMPLE KEYinference/model-v3/prefix-8f2aVALUE → SERIALIZED STATE

Your serving layer manages serialization, reuse, and transfer to the GPU.

Connect your application

From the first model call to the next worker.

Explore the AI workflows
04 / PERFORMANCE IS AN ARCHITECTURE

The decisions
behind the engine.

Written in Rust. Built around local ownership,
asynchronous I/O, and durable writes.

[01]

Let the kernel do the I/O.

Native io_uring for disk and network operations. Asynchronous I/O is part of the engine, from storage to the wire.

[02]

Keep ownership local.

Each reactor serves its own shard range and memory arena. Work is assigned to an owner, with background maintenance alongside it.

[03]

Make room for the whole value.

Large payloads are first-class. Configure memory for your largest writes and measure the mixed workload your application actually runs.

[04]

Acknowledged means journaled.

Writes are journaled to disk before acknowledgement. TLS 1.3 protects the connection; every value is encrypted at rest.

MAKE PERFORMANCE RELEVANT

Start with a verified round trip. Then measure your payload sizes, concurrency, and access patterns on the hardware you will actually run.

Evaluate your workload
05 / CONNECT IN YOUR LANGUAGE

A familiar API.
A different engine.

Set a value. Get it back. The official client discovers the shard layout and routes requests to the right reactor from one starting address.

Connect your first client

Clients for Linux, Windows, and macOS.

PYTHONpip install thunderstrike
AFTER SERVER SETUP · PYTHON
from thunderstrike import Thunderstrike

db = Thunderstrike(
    "127.0.0.1:7380",
    tls_server_name="localhost",
    tls_ca_pem=open("docker/tls/ca.crt").read(),
)

db.set(b"agent:42:state", b'{"step": 4}')
state = db.get(b"agent:42:state")
Official client documentation

THUNDERSTRIKE 0.1.6 / AVAILABLE ON DOCKER HUB

Bring your
heaviest workload.

Run Thunder on your own hardware. Start with the sample, then put your real data through it.

Get started View the image on Docker Hub ↗

LINUX / AMD64 + ARM64 / DOCKER COMPOSE

FROM YOUR CONFIGURED RELEASE KIT
# Start your configured instance
$ docker compose up -d

# Check health, then verify the data
$ docker compose ps
$ docker compose run --rm sample

A FEW GOOD QUESTIONS

The details
that matter.

Is Thunder a vector database?

Thunder is a key-value database. It can hold serialized embeddings, documents, and other AI payloads by key. Similarity search, indexing, and model execution belong in your application or a dedicated retrieval system.

How large can a value be?

The deployment guide covers values of 512 MiB and more. For 512 MiB values, allocate a 4 GiB arena per reactor. A SET needs room for two copies of its value; your memory budget and workload determine practical capacity.

Does one shard mean one CPU core?

Thunder has 1,024 fixed logical shards. Each reactor owns a group of them, one arena, and one port. With two usable hardware threads per physical core, there is one reactor group per core. Without SMT, two physical cores supply one reactor group.

Can I use my existing Redis client?

Use an official Thunder client for Python, Node.js, Go, Rust, .NET, Java, PHP, or C / C++. Thunder uses its own binary protocol over TLS 1.3, so Redis clients cannot connect directly. The official clients handle shard discovery and routing.

What do I need to run it?

Docker with Compose v2, a Linux host kernel of 6.8 or newer, and a supported x86-64 AVX2 or ARM64 v8.2 CPU with Crypto Extensions. Plan at least 4 GiB of arena memory plus overhead for the default allocation. See the full requirements.

Is it open source?

Thunder is proprietary software, distributed as thunderstrike and provided free of charge under its end user license. The license permits use as the database behind your own applications, subject to its terms.