Coordinate strategy state
Run lifecycle hooks, universe selection, market events, alpha models, insight pipelines, and teardown in a predictable order.
AlgoQuant EngineOpen Source · Rust
A high-performance Rust engine for systematic trading.
Build modular strategies, coordinate signals, enforce portfolio risk, connect brokers and data providers, and run the same strategy-facing logic in backtests and live trading.
Modular by designReuse models, pipelines, lifecycle logic, brokers, and datafeeds.
Local and privateRun on infrastructure you control without a forced cloud dependency.
Standalone or connectedUse AQE directly, or add AQS for visual control and monitoring.
Execution and orchestration layer
The runtime underneath a complete quantitative trading system.
AQE owns the path from incoming market events to reviewable trading outcomes. Strategy code stays focused on decisions while the engine coordinates state, execution, persistence, and integrations around it.
Process trading decisions
Represent intent as stateful insights that can be sized, validated, transformed, submitted, filled, rejected, managed, and closed.
Keep integrations replaceable
Put execution and market data behind engine traits so broker or provider changes do not force a strategy rewrite.
Operate long-running sessions
Persist account, equity, event, metric, and insight state for terminal monitoring or optional synchronization into AQS.
Interactive architecture
See how market data becomes an executed and observable decision.
Explore the modules, follow the animated execution path, and select a node to inspect its responsibility in the runtime.
Selected moduleStrategy
Coordinate lifecycle hooks, market events, state, models, and configured runtime components.
Why Rust
Performance matters, but predictable operation matters more.
AQE uses Rust because systematic trading runtimes are long-lived, stateful, concurrent systems. The practical value is tighter control over performance, ownership, failure paths, and resource use.
Predictable performance
Compiled execution and explicit runtime models suit event-heavy strategies and repeated historical runs.
Memory safety
Rust removes broad classes of memory errors from long-running processes that hold market, account, and strategy state.
Controlled concurrency
Async broker, datafeed, and synchronization paths can run without hiding ownership or error handling.
Operational reliability
Typed interfaces and explicit result paths make integration failures easier to surface and contain.
aq-engine/src/core/pipeline/mod.rsCurrent trait
pub trait InsightPipe {
fn version(&self) -> &str;
fn run(
&mut self,
ctx: &mut dyn StrategyContext,
insight: &mut Insight,
) -> InsightPipeResult;
}Reusable components
Build trading logic once, then compose it across strategies.
Insight pipes are state-aware processors around every trading decision. Combine focused components instead of embedding sizing, time filters, stops, submissions, and position management into one strategy body.
Reuse quantity sizing, market entry, stop-loss, take-profit, and trading-window pipes.
Run independent pipe logic for New, Executed, Filled, Cancelled, Expired, and Closed insights.
Swap PaperBroker, MT5, Yahoo Finance, or future integrations behind shared traits.
examples/hyperparameter.rsDeterministic sweep
let mut hyperparameters = HyperParameterConfig::new();
hyperparameters
.set_sweep_id("ema-crossover-v1")
.add_hyper_parameter(
HyperParameter::new("atr_period", 14).values([10, 14, 20]),
)?
.add_hyper_parameter(
HyperParameter::new("ema_period", 21).range(10.0, 30.0, 5.0),
)?;
let mut state = build_state(timeframe.clone());
state.set_hyper_parameter_config(hyperparameters);
state.run_backtest(start, end, timeframe).await?;Hyperparameter sweeps
Define the domain in code. Let AQE run the permutations lazily.
Register typed discrete values or numeric ranges beside your strategy, then use the same fallback-backed value in alpha models, insight pipes, or strategy variables. AQE expands combinations only while a sweep runs, creates a fresh state for every seed, and persists each result independently.
--hyper-sweep runs every combination sequentially.--hyper-seed <prefix> runs one reproducible combination.No flag keeps ordinary hard-coded fallback behaviour.
Backtest-to-live consistency
Keep the strategy-facing workflow stable as the execution environment changes.
AQE uses the same strategy lifecycle and component model across historical research and live sessions. The broker and datafeed composition changes; the strategy does not need a second implementation.
01Historical dataYahoo Finance or MT5 bars
→02AQ EngineStrategy, models, pipes, risk
→03Paper executionOrders, fills, account state
→04Live executionMT5 and monitored sessions
Strategy lifecycle
Startup, universe, initialization, bars, insights, pipelines, and teardown retain the same runtime order.
Execution and data
UnifiedBroker composes the execution provider and datafeed for the selected environment.
State and outcomes
Backtests persist SQLite results; live sessions expose scoped state for the TUI or AQS.
Operations without lock-in
Run locally, integrate your infrastructure, and keep strategy code private.
AQE is a standalone runtime. AQS is optional, remote nodes are optional, and broker or data providers sit behind integration boundaries you can extend.
No forced cloud dependency for strategy execution.
SQLite backtest artefacts remain inspectable outside AQS.
Terminal monitoring covers metrics, variables, active insights, logs, and sync state.
Broker, datafeed, database, and internal-system integrations can extend the engine traits.
AQ Engine Terminal UIOperate backtests and live sessions directly from the running process.
Current technical surface
Inspect what is implemented today.
The documentation and source expose the current runtime contracts, lifecycle, broker integrations, datafeeds, insight model, and operational state.
PaperBroker · Mt5Broker
Historical simulation and live MetaTrader 5 order routing behind broker traits.
Read broker docs →Yahoo Finance · MT5
Historical bars, quotes, and live data through replaceable datafeed traits.
Read datafeed docs →Insights · Pipelines
Stateful trading intent with processing paths for sizing, validation, submission, and management.
Read pipeline docs →Optional AQS connection
Synchronize engine state into Studio for visual inspection and live operations.
Read AQS docs →
AQE state inside AQSStudio turns runtime insight state into an inspectable operational trail.
Choose your surface
Use the engine directly, or add Studio when you want a visual operating environment.
AQE remains useful on its own for developers building custom systems. AQS adds node-based composition, backtest review, deployment controls, live dashboards, and Insight Flow around the runtime.
Own the runtime
Build on a systematic trading engine you can inspect and extend.
Start with the lifecycle documentation, run the blank strategy, then connect the broker, datafeed, and operating surface your workflow requires.