Hypercube: Open-Source Live Multidimensional Analytics

Hypercube is StrategyNet’s open-source engine for low-latency computation and linear algebra over changing multidimensional data. It separates the physical representation of live state from the logical graph that derives new fields. Readers can therefore inspect a stable snapshot without asking every application to reconstruct the same analytical state.

The project is written in Rust, released under Apache-2.0, and published from a deliberately bounded repository. It contains the reusable engine, storage format, examples, architecture notes, and reproducible results. Private service configuration, data-vendor integrations, database writers, hard-coded factor registries, and application-specific rollups remain outside the open-source boundary.

Slice and Hypercube

The system has two distinct layers:

• Slice is the physical live-state plane. Typed, file-backed, memory-mapped vectors share a stable entity layout.
• Hypercube is the logical execution plane. Fields, derived nodes, generations, and entities form a deterministic dependency graph.

A row can represent a financial instrument, sensor, service, experiment, or another member of a stable entity set. This generality is intentional: Hypercube owns analytical state and derivation, but it is not a database, message bus, vendor feed, or order-action system.

The separation is useful when one writer updates a cross-section and many readers need the same current state. Entity alignment is fixed by a layout registry; values are published as typed vectors; and derived nodes consume their declared inputs. A UI, service, model, or monitoring process can then read the same fields without creating its own interpretation of row order.

Deterministic dependency execution

Node declaration order is not execution order. The engine resolves the graph topologically, rejects cycles and absent required inputs, treats missing entity values explicitly, and emits one deterministic snapshot for each strictly increasing generation.

That contract is particularly important for factor systems. A derived score is not merely a formula: it also depends on an entity universe, input availability, observation time, and generation. Making those dimensions explicit gives downstream consumers a shared answer to “what was current?” and exposes an incomplete dependency instead of silently manufacturing a value.

The public Rust API includes field transforms, weighted inputs, linear derived nodes, live and replay execution modes, and snapshot lookup. The Slice API provides aligned f64 vectors as well as fixed-record quote, trade, and quote-at-trade payloads. Readers can take stable vector snapshots, guarded point reads, sums, dot products, and top-absolute scans.

Examples and HTTP endpoints

The repository includes three useful demonstrations:

• an ETF monitor that values synthetic funds from constituent returns and ranks premiums and discounts to basket value;
• a pairs monitor that standardizes simulated log-price residuals against AR(1) models and ranks live dislocations; and
• a synthetic browser service that removes simulated market and sector moves, combines residual rank with normalized log-dollar volume, and publishes the outputs as aligned Slice files.

The browser example exposes GET /api/snapshot and an SSE stream at GET /api/stream. It is intentionally small, but it shows the full path from a changing cross-section through graph evaluation to a live reader.

See the guided tour, architecture boundary, Slice format, and reproducible results for the implementation contracts.

Foundations paper

The 17-page paper Slice + Hypercube: Current analytical state without rebuilding it for every reader develops the architectural argument in full. It covers aligned memory-mapped fields, deterministic graph evaluation, publication and read semantics, and the boundary between a reusable analytical substrate and the services around it.

View the foundations paper or download the PDF directly.

Where it fits in StrategyNet

Hypercube is one of the open components behind StrategyNet’s analytical architecture. Its responsibility is narrow: maintain aligned current fields and evaluate declared dependencies. Scheduling, historical databases, transport, application APIs, and effectful actions are separate concerns.

This boundary also clarifies what a production deployment must add. The current format supports one writer and many readers. Atomic publication across multiple Slice files, replication, cross-language ABI fixtures, and general stateful function cells remain identified future work. The repository states those limits rather than treating a demonstration as a complete distributed system.

Continue with Volt, the open-source options portfolio logic engine, or browse the Hypercube source.