FLOX C++ trading systems framework with MCP releases

v0.6.0 — polyglot strategies, AI-friendly DX, same code backtest→live

Strategies in Python, Node.js, Codon, and embedded JavaScript run on one C++ core through parity-tested bindings. The same strategy code goes from backtest to live without a rewrite — pre-trade gate, fill hooks, order events all behave the same on both runners. flox-mcp is a Model Context Protocol server that lets coding agents query the same FLOX install you're using: every binding's surface, every indicator, every error code, the live engine's positions and orders, the full doc set.

Highlights

• flox-mcp MCP server. Install with pip install flox-mcp, bootstrap with flox-mcp init. Tools cover symbol lookup across bindings, indicator introspection, scaffolders, full-text doc search, runtime inspection, control-plane order routing, live analytics.
• Same code backtest→live. BacktestRunner now takes the same RiskManager / KillSwitch / OrderValidator / PnLTracker stack as the live Runner. Reduce-only and flatten orders bypass the gate (so you can always exit when caps tighten).
• flox engine sim paper engine in one command. Boots Runner + SimulatedExecutor + ControlServer + a runtime-snapshot writer. Prints the engine URL and a copy-pasteable flox-mcp init --engine-url ... --token ....
• Polyglot parity, all four bindings. Multi-TF alignment helpers, composite-condition DSL, indicator-grid sugar, OrderGroup state machine, MultiFeedClock, .floxrun trace format, latency models, tape diff, portfolio risk, execution algorithms. Cross-binding parity gate in CI.
• Strategy.on_fill / on_order_update hooks across all bindings. Strategies see their own fills and order-lifecycle events.
• .floxlog public spec + replay-equivalence CI gate. The recorded tape format is documented; a CI step blocks any binding change that breaks byte-for-byte replay equivalence.
• AI-DX surface. llms.txt and llms-full.txt published, .pyi + py.typed on PyPI, index.d.ts on npm, structured FloxError with code + help URL, snippet linter that fails when doc examples drift.
• IDL-driven C API codegen. flox_capi_spec.hpp is what generates the C header, the Codon FFI, and the LLMs reference. ABI snapshot gate fails the build on accidental breakage.

What's new

AI / MCP

• flox-mcp Model Context Protocol server (#141)
• Polyglot tools: lookup_symbol, list_bindings over bundled cross-binding data (#166)
• Runtime tools: run_backtest, compute_indicator, suggest_indicator (#168)
• Read-only positions inspection (#174)
• Mutating control-plane tools with capability scopes + token security model (#178)
• Live analytics: read-only introspection over the control plane (#179)
• Lookahead-bias detector tool (#181)
• lookup_symbol surfaces curated semantic gotchas (#229)
• record_data tool wraps the canonical recording paths (#228)
• init_project thin wrapper around flox new (#225)
• flox-mcp init — bootstrap .mcp.json in one command (#233)
• Tier-4 read tools fail-graceful when no runtime snapshot exists (#232)
• docs_search AND-matches multi-word queries (#221)
• run_backtest routes by strategy kind (#222)
• suggest_indicator covers mean-reversion / stddev / z-score (#223)
• Friendlier no-engine error for runtime tools (#224)
• Surface canonical paths instead of building parallel ones (#219)

Strategy & backtest

• BacktestRunner pre-trade gate parity with live Runner (#235)
• Strategy.on_fill / on_order_update hooks — engine + pybind11 (#226)
• BacktestRunner.run_tape(path) for .floxlog replay (#227)
• Wire MultiModePositionTracker into Strategy (silent zero-trade fix) (#220)
• Strategy hot-reload without dropping connections (#192)
• Multi-TF alignment helpers on Strategy (#196)
• Strategy.on_bar callback + run_bars (#123)
• RL environment over a .floxlog tape, Gymnasium-compatible (#186)
• Execution algorithms: TWAP / VWAP / Iceberg / POV slicers (#185)
• PaperBroker: live-data sandbox / paper trading mode (#175)

Polyglot parity

• Cross-binding parity gate in CI (#149)
• TypeScript strategy authoring with decorators (#187)
• Latency models, tape diff, portfolio risk, execution algos — C++ core with binding parity (#188, #189, #190, #191)
• .floxrun strategy-trace format with cross-binding parity (#194)
• Composite-condition DSL for multi-symbol multi-TF strategies (#197)
• Indicator-grid sugar on top of composite DSL (#198)
• Latency-aware MultiFeedClock (#200)
• Multi-leg OrderGroup helper, BestEffort policy (#199)
• Multi-TF alignment helpers in QuickJS + Codon (#204)
• Composite DSL ported to NAPI / QuickJS / Codon (#205)
• Indicator-grid sugar ported to NAPI / QuickJS / Codon (#206)
• OrderGroup state machine across all four bindings (#207)
• MultiFeedClock state machine across all four bindings (#208)
• Runner cross-binding .floxrun parity gate (#212)
• Strategy.on_fill / on_order_update parity for NAPI / QuickJS / Codon (#230)
• BacktestRunner.runTape — NAPI / Codon parity (#231)

Tooling & CLIs

• flox engine sim — paper engine in one command (#234)
• flox tape CLI: record / replay / inspect (#173)
• flox bundle: reproducibility bundle format (#176)
• flox tape diff: trade-by-trade comparison of two tapes (#182)
• flox lint lookahead (#181)
• flox new CLI scaffolder (#158)
• CcxtBroker live broker adapter (#157)
• Notebook variant of the research scaffold (#160)
• Live-trading template via flox new --template=live (#162)
• Indicator-library scaffolder (#165)

Indicators & analytics

• Forward-looking targets distinct from indicators (#115)
• ADF stationarity test (#116)
• AutoCorrelation indicator (#117)
• IndicatorGraph (batch) (#118)
• Streaming step()-based IndicatorGraph for live trading (#119)
• Single source of truth for indicators and DAG (#122)
• HTML backtest report + equity_curve / trades accessors (#161)
• Walk-forward + type-erased grid search across bindings (#163)
• Heatmap HTML renderer across all bindings (#164)
• MLflow integration for FLOX backtests (#167)
• White's reality check across all bindings (#169)
• Latency models for backtest realism (#184)
• MVP web replay viewer for tape and run artifacts (#195)

Replay / tape format

• Public specification of the .floxlog binary tape format (#180)
• Replay-equivalence CI gate (#177)
• Delta-book compression in the tape format (#193)
• Live-tail safety + book-update reads (#120)
• Mid-stream _from seek across all bindings (#126)
• LZ4 link in the Node binding so compressed segments read on every platform (#127)
• TraceSignalHandler / TraceExecutionListener adapters for .floxrun (#201)
• flox bundle ships expected.floxrun alongside expected_output.json (#202)
• Runner attaches a TraceRecorder for one-call signal auto-capture (#209)
• Trace order events and fills through the attached recorder (#210)
• OrderGroup auto-dispatches recommended actions through the executor (#211)
• OrderGroup basket-level risk gate before submission (#215)
• OneSided pair-latency budget on leg-A ack (#216)
• Bar-close dispatch ordering cross-binding parity test (#217)

Errors, typing, docs

• llms.txt and llms-full.txt published for AI agents (#128)
• .pyi stubs + py.typed for typed PyPI distribution (#129)
• index.d.ts for typed npm distribution (#130)
• Structured FloxError with code + help URL (#138)
• Auto-generated Python API index from .pyi (#139)
• Snippet linter + ratchet allowlist (#140)
• Top-20 throw sites migrated to FloxError (#154)
• Cross-binding FloxError surface in Node (#155)
• Snippet coverage ratchet enforcement (#156)
• First-backtest tutorial with real BTC sample (#159)
• Architecture + contributor guide (#152)
• Cross-symbol pairing for two-input indicators (Correlation, AutoCorrelation) (#237)
• mcp/README.md flox-mcp init quickstart (#238)
• README hero — polyglot + AI-friendly + same-code backtest-to-live (#240)
• Python + Node package READMEs refreshed (#241)
• pre-commit hook auto-regens .pyi / llms.txt / mcp data (#239)

C-API / IDL codegen

• IDL-driven C API codegen — slice prototype (#131)
• Full-coverage spec + enums/aliases + bootstrapper (#132)
• emit-codon + emit-llms emitters (#133)
• ABI snapshot CI gate (#135)
• RiskManager pre-trade hook (#136)
• KillSwitch + OrderValidator pre-trade hooks (#137)
• Logger callback hook for binding-side log redirection (#144)
• Post-emission observer hooks: PnLTracker, StorageSink (#145)
• MarketDataRecorder hook (#146)
• ReplaySource hook for binding-supplied event streams (#147)
• Executor + ExecutionListener hooks (#148)
• pybind11 wrappers for extension hooks (#150)
• NAPI wrappers for extension hooks (#151)
• Pointer-variant create exports unblocking pure-Codon strategies (#213)

Connectors / build

• Native connectors merged into flox under FLOX_BUILD_CONNECTORS (#171)
• CMake feature flags: FLOX_ENABLE_* → FLOX_BUILD_* split + CI flag matrix (#172)

Full changelog: https://github.com/FLOX-Foundation/flox/compare/v0.5.6...v0.6.0

What's Changed

• fix(python): handle non-contiguous arrays in raw→double converters by @eeiaao in https://github.com/FLOX-Foundation/flox/pull/113
• ci: dedicated Release workflow + fix publish job skip on tag push by @eeiaao in https://github.com/FLOX-Foundation/flox/pull/114

Full Changelog: https://github.com/FLOX-Foundation/flox/compare/v0.5.5...v0.5.6

Same scope as a v0.5.4. This is a Python package hot fix release

New statistical indicators: Correlation, Kurtosis, Skewness, ParkinsonVol, RogersSatchellVol, RollingZScore, ShannonEntropy — available in Python, Node, Codon, QuickJS.

BinaryLogReader.forEach now guarantees monotonic exchange_ts_ns ordering. Out-of-order trades from exchange WS batches are no longer a problem. New segments stream at O(1) memory; legacy segments are auto-sorted on read.

flox-py wheels now bundle LZ4. Compressed .floxlog files read correctly out of the box — previously DataReader silently returned 0 trades.

Fixed-point helpers exposed to Python. Use flox_py.PRICE_SCALE / prices_to_double(raw) instead of hardcoding 1e8.

Python ≥ 3.10 required (docs aligned with pyproject.toml).

What's Changed

• Backtest: slippage, queue simulation, advanced metrics by @eeiaao in https://github.com/FLOX-Foundation/flox/pull/98
• Language bindings improvements: Node.js, Python, Codon, QuickJS + docs by @eeiaao in https://github.com/FLOX-Foundation/flox/pull/103

Full Changelog: https://github.com/FLOX-Foundation/flox/compare/v0.5.2...v0.5.3

This release is focused on language bindings & C API

Starting this release FLOX provides 3 ways to write trading strategies: Python, Codon (compiled Python), and JavaScript.

C API is a flat C interface (flox_capi) bridging the C++ engine to all language bindings. Covers strategy lifecycle, order emission, indicators, order books, backtesting, position tracking, profiling, and statistics.

Python bindings (pip install flox-py) - pybind11 module with strategy classes, indicators (batch via numpy + streaming), order books, simulated executor, bar aggregation, position tracking, market/volume/footprint profiles, data replay, and segment operations.

Codon bindings - same strategy API compiled to native code via Codon. Indicators, order books, backtesting, position tracking, and profiling available through C FFI.
JavaScript bindings - embedded QuickJS engine for JS strategies. Ergonomic API with string symbol names, options objects for orders, TypeScript declarations. Includes indicators, order books, backtesting, position tracking, and profiling.

Strategy DX
• String symbol names ("BTCUSDT" instead of numeric IDs) across all bindings
• Keyword arguments / options objects for orders (market_buy(qty=1.0), this.limitBuy({ price: 50000, qty: 0.1 }))
• Callback data enriched with string symbol and side
• Unified indicator classes — .update() for per-tick, .compute() for batch

This release adds L3 order book, position aggregator, technical analysis framework and Python bindings. Also includes stability improvements and bug fixes in the core engine.

New features

L3 order book with individual order tracking, fixed capacity and snapshot support. Thanks @AsherValentini for the contribution.

Position aggregator with three tracking modes: net (auto open/close/flip), per-side (separate long/short), grouped (per-order with tag-based grouping for OCO/OTO). Includes exchange position reconciliation, atomic snapshots with unrealized PnL, and position change callbacks. Thanks @sirinath for the original idea and requirements.

Technical analysis framework with vectorized indicators (EMA, RSI, MACD, ATR, Bollinger, etc). TA-Lib compatible output, dependency graph for caching. Thanks @sirinath for the original idea and requirements.

Python bindings for most of the framework: backtest engine, order books, bar aggregation, indicators, position tracking, replay.
pip install flox-py, see the Python API reference for details.

FLOX v0.4.0 release announcement

This release focuses on backtesting infrastructure and multi-exchange trading capabilities, bringing FLOX closer to a complete quantitative trading framework.

With v0.4.0, users can now validate strategies against historical data using the new backtesting engine, run strategies across multiple symbols and exchanges simultaneously, and leverage advanced order types including OCO (One-Cancels-Other) for more sophisticated execution logic.

Backtesting Framework
Complete backtesting infrastructure for strategy validation
Interactive backtest mode - step through execution with real-time control
Mmap-based grid search for efficient parameter optimization

Multi-Asset & Cross-Exchange Trading
Multi-symbol strategies support
Cross-exchange coordination components
Exchange ID in binary format for CEX replay

Order Management
Advanced order types with OCO support
Enhanced order tracking and position queries
Improved position management stability

Market Data
Heikin-Ashi bars with nanosecond resolution
Flexible tick aggregators
NLevelOrderBook: type-safe consume, Decimal 10^8 precision, cross-type operations

Infrastructure
Rate limiter for API calls
BinaryLog rotation callback
RELAXED/ADAPTIVE backoff modes for reduced CPU usage
Multi-compiler support (GCC, Clang, MSVC)

FLOX v0.3.0

This release focuses on market data recording/replay infrastructure and a major EventBus overhaul.

Highlights

Binary Log Replay System

A complete subsystem for recording and replaying tick data in a custom binary format. Features time and symbol indexing, filtered reads, and CRC32 integrity validation. This lays the groundwork for the upcoming backtest engine.

EventBus Disruptor Refactor

The event bus has been rewritten following the LMAX Disruptor pattern: multicast ring buffer with sequence-based coordination, required/optional consumer gating for flexible backpressure, and a new tryPublish API with timeout support. Race conditions fixed, thread safety improved.

Other Changes

• NLevelOrderBook: Anchoring for consistent book state
• Tracy integration: Profiler support for hot path analysis
• BusyBackoff: Adaptive backoff strategy
• Extended timestamps: Improved event timing precision
• SymbolRegistry: Centralized symbol management
• Documentation: Restructured following Diataxis methodology

New Contributors

Welcome @AsherValentini who made their first contribution with SPSCQ capacity validation fix (#45)!

This release introduces several infrastructure improvements across the core engine and connectors module.

Within the core flox engine, new abstractions were added, including a generic IWebSocketClient interface, an asynchronous HTTP ITransport, and a low-level OrderTracker for maintaining local order state. The IExecutionTracker interface was extended to capture the full order lifecycle, including submission, acknowledgments, fills, cancels, and rejections. The engine also gained support for differentiating instrument types (spot, futures, options), CPU affinity configuration for performance tuning (thanks to @ErakhtinB), and a new logging system based on lightweight macros (FLOX_INFO, FLOX_WARN, etc.) designed for high-performance environments.

An architectural experiment was conducted to replace virtual interfaces with a concept- and trait-based polymorphism model using Ref handles and custom vtables. This work, described in this article (EN) and this article (RU), was ultimately reverted due to worse performance in benchmarks. Modern compilers were able to better optimize virtual dispatch in this context.

In parallel, the first release of the flox-connectors module was published. It includes a production-ready exchange connector for Bybit with WebSocket-based market data handling (order book and trades), as well as a fully integrated order executor that processes execution events via the private WebSocket channel. Both components are wired into the event bus system and support both live trading and data collection scenarios.

The first version of Flox (v0.1.0) is an initial release of a C++ framework for building trading systems. Key features:

• Modular architecture with clean interfaces and explicit component lifetimes. Connectors, strategies, and auxiliary subsystems can be registered via IEngineBuilder.
• Unified MarketDataBus and dedicated buses for quotes, trades, and candles. Each bus supports synchronous or asynchronous delivery modes. Events propagate through EventBus and lock-free SPSCQueue structures for minimal latency.
• High-performance Order Books: includes a full-depth book (FullOrderBook) and an optimized windowed version (WindowedOrderBook). Performance benchmarks are included in the documentation.
• CandleAggregator: aggregates trade streams into OHLCV candles and publishes them to subscribers.
• Subsystem design and utilities, including KillSwitch, RiskManager, PositionManager, ExecutionTracker, and more.
• Demo application showcases the engine in action using synthetic connectors, a simple strategy, and basic execution components.
• Tests and benchmarks are implemented using GoogleTest and Google Benchmark to verify correctness and performance.
• MIT License

This release lays the foundation for further system development and serves as a starting point for experimentation, customization, and integration of new components.