Hypercube: Open-Source Live Multidimensional Analytics

Hypercube is a Rust library for maintaining changing multidimensional data and the calculations derived from it. Applications read stable snapshots of that state, allowing screens and services to work from a consistent view as new observations arrive.

This article explains the state model, calculation graph, and snapshot behavior, with links to the architecture and reproducible examples. The reusable engine and storage format are released under Apache-2.0. Data-vendor integrations, private configuration, and application-specific registries remain in the systems that deploy the library.

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. Hypercube maintains the analytical state and derivations for that set, while databases, message buses, vendor feeds, and order services continue to perform their own jobs around it.

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

The engine derives execution order from each node’s dependencies rather than from the order in which nodes were declared. It 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 because a derived score combines its formula with an entity universe, input availability, observation time, and generation. Recording those dimensions 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 contract, Slice format, and reproducible results for the implementation contracts.

Noise-aware stat-arb study

The pairs monitor builds each signal from the preceding residual observations. The reproducible study keeps that signal and its mean-reversion direction, then uses LightGBM or CatBoost to rank candidate trades with point, Huber, quantile, or calibrated three-way triple-barrier targets.

The evaluation moves forward through training, validation, forecast calibration, policy selection, and a final test period. Between those stages it leaves enough time for every open trade to finish, preventing the outcome from appearing in two stages. Across five deterministic seeds, rolling-z remained best on average in the homogeneous stationary control, while CatBoost Huber improved the descriptive trade-return t-statistic from 6.626 to 7.290 under observable regime shifts and heavy-tailed noise, winning all five comparisons. The figures describe normalized synthetic events; annualized portfolio performance and live profitability require a market-data study with executable costs.

Read the full protocol, mathematics, calibration contract, and artifacts.

Technical papers

Core foundations

The 23-page paper Hypercube Core: Memory-Mapped Real-Time Factors develops the architectural argument in full. It covers aligned memory-mapped fields, deterministic graph evaluation, publication and read semantics, noise-aware stat-arb selection, and the division of responsibility between a reusable analytical substrate and the services around it. Open the local PDF or view the source on GitHub.

Stateful circuits and replay

The 15-page paper Hypercube Circuits: Real-Time Linear Algebra with Stateful Triggers and Replay extends the generation engine with callbacks that retain qualifying and active state across updates. It covers persistent entry and exit thresholds, bounded ordered handoff, JSON Lines recording, deterministic replay, explicit overload behavior, and the separation of current state from externally authorized effects. Open the local PDF or view the source on GitHub.

Where it fits in StrategyNet

Within StrategyNet’s analytical architecture, Hypercube maintains aligned current fields and evaluates their declared dependencies. Scheduling, historical databases, transport, application APIs, and authorized actions are provided by the surrounding services. A production deployment then adds atomic publication across multiple Slice files, replication, cross-language ABI fixtures, and general stateful function cells as those capabilities mature.

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