Data Engine Products

A ticker-addressed OHLCV engine, reachable from any language over one Unix-socket protocol.

A small, documented wire protocol — no linking, no client library, nothing to build against.

Reamer Stream ingests OHLCV data under a ticker name — from a vendor API, an in-house pipeline, or a CSV export — and serves it back over reamer-stream, a Unix-socket server any tool can talk to without linking C++. A Databento connector, an Alpaca connector, an in-house research engine, and reamer_py's own backtest engine all reach that same data the same way.

Ingest once, under a ticker name, from a CSV or from already-structured bars. Query it back — by ticker, by time range, unbounded — from any connected caller, or several at once, all reading the same files.

One engine, one socket

┌─────────────────────────┐ │ StreamEngine │ │ (ticker-addressed .bin │ │ index, query + ingest) │ └────────────┬─────────────┘ │ reamer-stream (the server) Unix domain socket, PROTOCOL.md │ length-prefixed binary frames │ Databento/Alpaca connectors · custom research engines · reamer_py's own backtest engine · anything that opens a socket

One binary, one protocol, one data directory — every connected caller reads and writes the same files, so an ingest from one connection is immediately queryable from any other.

Built for any language

01

One Binary, One Protocol

Download reamer-stream, run it, connect to the socket — no client library, no symlinking, no separate pieces to place. PROTOCOL.md is the entire interop contract.

02

A Same-Machine Transport, Not a Network Stack

A Unix domain socket, not a TCP port — no listening address, no network hop for a packet to traverse, and no TLS handshake to pay for on every query.

03

Any Language, No Vendor Lock-In

A bespoke, fully documented wire protocol — write a client in Rust, Go, Java, or anything that can open a socket, without waiting for an official binding or linking C++ yourself.

04

Real-Time Pub/Sub

Any socket connection can subscribe to a named stream; any other can publish to it. Subscribers get pushed the record the moment it's published — no polling, no relationship to what's stored on disk unless you choose to reuse the same name.

05

Ingest Any Bar Type

OhlcvBar is sampling-agnostic — time bars, tick bars, volume bars, dollar bars, or imbalance bars all fit the same 64-byte record. Reamer Stream ingests whatever your own pipeline already builds; constructing the bars themselves stays your pipeline's job.

06

Built-In Auth and Permissions

0600 socket permissions by default, plus an optional shared-secret token for same-user process isolation — a stated, documented trust model for same-machine IPC, not an afterthought bolted onto a network protocol that assumed a different threat model.

07

Full Audit Trail

Every query and ingest is logged — ticker, byte count, success or failure — for compliance review and debugging, on by default, not an opt-in you have to remember to turn on.

Real measurements, not extrapolations

Every number below comes from an actual run against a live reamer-stream subprocess on this session's own machine (Intel i5-8250U, 16GB — the same machine reamer_py's own benchmark page uses). See the full benchmark page for methodology.

Socket round-trip
19.1µs avg
Socket throughput
~52,500 queries/s

Socket round-trip: 19.1µs average, ~52,500 queries/sec for a real AF_UNIX round trip through reamer-stream — wire encoding and epoll dispatch fully included, the actual product experience, not an in-process shortcut.

Single connection at a time: reamer-stream is single-threaded by design (see the Concurrency semantics section of the protocol docs), so these numbers measure one client, not concurrent multi-client load.

From reamer_py

import reamer_py

# Ingest into Reamer Stream under a ticker name (auto-detects CSV format)
reamer_py.load_csv("aapl.csv", "AAPL")

# Query it back — from this same process, or from any other tool
# connected to reamer-stream over the same data directory
result = reamer_py.run_backtest(data=["AAPL"], strategy=MyStrategy())

From any other language

A plain socket connection, stdlib only — the same path any other language's client takes:

import socket, struct

def pack_str(s):
    b = s.encode(); return struct.pack(">H", len(b)) + b

sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.connect("/tmp/reamer-stream.sock")

# QueryHistorical: type 0x00, ticker, no time bounds
payload = b"\x00" + pack_str("AAPL") + b"\x00" + b"\x00"*8 + b"\x00" + b"\x00"*8
sock.sendall(struct.pack(">BI", 1, len(payload)) + payload)
# HistoricalResponse comes back the same way — full framing in PROTOCOL.md

Scope & fit

Designed for: any tool that needs ticker-addressed OHLCV history — a data pipeline feeding it directly, a backtest engine (reamer_py or another), a vendor API connector, or a research notebook querying historical bars directly without going through a full backtest run.
Not designed for: a general-purpose time-series database for non-OHLCV data, a durable message queue (pub/sub has no persistence — a subscriber not listening at publish time never sees that record), or a remote/multi-machine deployment (same-machine only, no TCP/remote transport in this version).

One license activates everything.

A single Reamer Labs license activates a machine — reamer-stream checks for that active license at startup (activate it with reamer-stream activate <key>, or python -m reamer_py activate on a machine that also runs reamer_py — either one covers both products). Contact us for pricing and multi-seat/invoicing terms.