Record the Geyser stream once. Replay it as many times as you need, through your existing Yellowstone gRPC client, paced to the original wall clock. Apache-2.0.
Sillage speaks the Yellowstone gRPC protocol as a server, unmodified. Anything you've already written against Triton, Helius, or a self-hosted Geyser plugin connects unchanged. Pass a starting slot. The stream begins there.
use yellowstone_grpc_client::GeyserGrpcClient; let mut client = GeyserGrpcClient::build_from_shared( "https://yellowstone.helius-rpc.com", )? .x_token(Some(token))? .connect() .await?; let (_, stream) = client .subscribe_with_request(Some(req)) .await?;
use yellowstone_grpc_client::GeyserGrpcClient; let mut client = GeyserGrpcClient::build_from_shared( "https://replay.sillage.sh", )? .x_token(Some(token))? .connect() .await?; let (_, stream) = client .subscribe_with_request(Some(req.from_slot(312_840_000))) .await?;
use yellowstone_grpc_client::GeyserGrpcClient; let mut client = GeyserGrpcClient::build_from_shared( "https://replay.sillage.sh", )? .x_token(Some(token))? .connect() .await?; let (_, stream) = client .subscribe_with_request(Some(req.from_slot(312_840_000))) .await?;
Yellowstone's pubkey-based filters work unchanged — narrow transactions to specific programs or accounts, narrow account streams to specific owners. Roaring-bitmap indexes resolve the filter before a single compressed byte is decoded.
let req = SubscribeRequest { transactions: hashmap! { "swaps".to_owned() => SubscribeRequestFilterTransactions { vote: Some(false), failed: Some(false), account_include: vec![JUPITER_V6.into()], ..Default::default() }, }, accounts: hashmap! { "pools".to_owned() => SubscribeRequestFilterAccounts { owner: vec![RAYDIUM_AMM.into()], ..Default::default() }, }, ..Default::default() };
Every message carries the timestamp it was received, to 100 microseconds. A transaction that landed 24.3ms into its slot replays 24.3ms into that slot. Intra-slot ordering, propagation gaps, the texture of real network time — all preserved.
Every message your live subscription receives is recorded and replayed identically. No sampling. No summaries. No schema translation.
Every push runs fmt, clippy at -D warnings, and the full suite — including a producer built from the format spec alone.
Processed-commitment messages aren't stored — too ephemeral to be useful at replay time.
Roaring bitmap indexes over programs, accounts, and signatures, resolved before message bytes are touched.
Range-fetchable from persistent storage. A filtered replay reads only the bytes it matches.
The other providers all stream the live chain beautifully. Sillage ships the inverse: the stream as it was delivered, recorded and played back through the same protocol — and you can run the whole thing yourself.
| sillage.sh | Helius LaserStream | Triton Fumarole | QuickNode | |
|---|---|---|---|---|
| Replay window | Whatever you record | 24 hours | 4 days | ~20 min |
| License | Apache-2.0 | Proprietary | Proprietary | Proprietary |
| Protocol | Yellowstone gRPC | Yellowstone gRPC | Yellowstone gRPC | Yellowstone gRPC |
| Timestamp precision | Per message | Slot-level | Slot-level | — |
Replay a recorded window through your strategy. Tune PnL against real mainnet traffic without holding a live subscription open.
More on Solana backtestingBackfill a new index from any slot inside a window you have recorded. No re-sync from snapshot.
Query historical flow patterns. Same Yellowstone protocol, replayed as many times as the question needs.
Replay a window from before the reorg to verify state — no need to keep raw history yourself.
Sillage is Apache-2.0 and self-hostable end to end. Record your own window from any Geyser source, or point an unmodified client at the demo endpoint to see replay working before you set anything up.
Rust stable and a checkout. Point the writer at any Geyser source to record, then serve the result back with the reader.
git clone https://github.com/sunkuu7/sillage
cd sillage && cargo build --releasereplay.sillage.sh serves a recorded mainnet window over TLS. Change the URL in a Yellowstone client you already have and it works unmodified.
new Client("https://replay.sillage.sh", token, {})Published images for the reader and writer, so a replaying endpoint is one command with no toolchain to install.
docker run sillage/readerApache-2.0 · no account, no billing, nothing gated.