Fracture

Determinism first

Fracture is a zero-copy Rust crypto trading engine built for absolute execution determinism on AWS colocation nodes. Every architectural decision answers to one metric: hot-path determinism under 10ms p95 with jitter under 50µs — because in this domain, variance is the bug.

Exchange priority is Hyperliquid (primary — the hardened deterministic execution path), with MEXC scaffolded. Training data is dollar bars from Binance; live signal is the Hyperliquid L2 order book.

The hot path

The engine operates entirely within the colocation perimeter — no internet-bound sidecars adding network jitter. WebSocket streams feed a wait-free SPSC ring buffer, and the hot-path thread processes market events without mutex contention:

1. Ingestion — raw NIC packets, rkyv zero-copy cast straight to structs at memory speed
2. Feature compute — SIMD-accelerated, 64-dim vector, zero-alloc
3. Signal — Hummingbird-compiled GBDT, FP16 TensorRT
4. Policy — OFQL, one deterministic forward pass
5. Sentinel — Qwen3.5-0.8B (INT8), logit-space risk scaling
6. Gate — stack-only risk veto engine
7. Execution — OrderCommand dispatch

Zero-copy data path. Serde-style serialize/deserialize creates unacceptable jitter through heap allocation. rkyv lets the hot path cast network buffers directly to Rust structs — deserialization at memcpy cost, nanosecond scale.

Hummingbird GBDT signals. Transformers scale quadratically on limit order book features. Hummingbird compiles gradient-boosted decision trees into tensor math that runs directly on TensorRT — frontier-grade alpha generation at sub-microsecond inference latency. The right model for the hardware, not the fashionable one.

OFQL: one-step flow Q-learning

The problem with IQL-style expectile regression in crypto is sensitivity to extreme variance — token unlocks, cascade liquidations, the kind of multi-modal reward landscape that breaks single-distribution assumptions. Iterative approaches (diffusion policies, multi-step integration) buy expressiveness with latency the hot path can’t afford.

OFQL — One-Step Flow Q-Learning — models that multi-modal landscape deterministically in a single forward pass, collapsing probability mass onto optimal trajectories without iterative denoising. Sampling is event-driven: volume-weighted dollar bars (in the López de Prado sense) instead of time bars — signal over noise, with decision triggers on threshold crossings.

The risk sentinel

The policy never reaches the exchange ungated. A Qwen3.5-0.8B sentinel — small enough to run INT8 on the same GPU without disturbing the hot path — reads the state and emits a logit-space risk scalar: not a chat completion, not parsed text, a calibrated number read straight off the output distribution. The veto engine is stack-only, fully deterministic, and the action vector is gated by that scalar before any order dispatches. A hardcoded DETERMINISTIC_NOISE tensor keeps policy inference reproducible across runs — replayability is a hard requirement for post-trade forensics.

Performance targets

Metric	Target	Status
Hot-path determinism	< 10 ms p95, < 50 µs jitter	Validated
Serialization	Zero-copy (rkyv)	Validated
Feature compute	SIMD, 64-dim, zero-alloc	Validated
Signal inference	FP16 TensorRT (Hummingbird GBDT)	Validated
OFQL policy	One-step forward pass	Open
Sentinel	Qwen3.5-0.8B INT8, logit-space	Open

Inference is compiled per colocation hardware target — the same FP16 engine runs 0.82ms on an RTX 5090 tier, 3.1ms on a 4090, 9.2ms on a 4080 Mobile. The engine knows its hardware budget the way the risk gate knows its scalar: measured, pinned, and enforced.