A backtest that behaves like the live market
Every backtester deserves two questions. First: how faithfully does it imitate the exchange? And second: what gets lost when you move the strategy from testing to production? Most tools fail both — they test a simplified world, and the strategy has to be rewritten for live deployment anyway. We built our engine so that the answers are: faithful down to individual ticks — and nothing gets lost at all.
Two families of backtesters
Most quick backtesters work vectorized: they take the whole history as a table, compute signals in one pass and multiply them by returns. It is fast and useful for rough exploration — but it is not trading. There are no orders, no queues, no fees, and because formulas see the entire table at once, one subtle mistake lets the strategy quietly “borrow” information from the future.
The second family — event-driven — simulates the market the way it actually flows: event by event. A bar arrives, the strategy reacts, submits an order, the order travels through execution, a fill confirmation comes back, the strategy learns the outcome — and only then does the next event arrive. At every moment the strategy knows only what it would know live. Our engine belongs to this family — we call it real-time like: a simulation that differs from live operation in a single detail, the source of events. Event-driven, precise, fast and scalable.
Zero-delta: one codebase from test to exchange
The most expensive mistakes are not made in tests but between the test and production — when a “validated” strategy gets rewritten for live deployment and a difference slips into the translation. That is why the whole engine is designed around one simple principle: the strategy is one file, and it exists exactly once. In a backtest it is fed historical events; live, it is fed the exchange feed — but the strategy code, the order path and the execution logic are identical. No second version, no rewrite, no translation bugs.
In practice: you test the strategy on years of history, it passes walk-forward and the Monte Carlo exam — and then the same file deploys with one click to any of the ten integrated exchanges and brokers. Stocks, futures, forex, crypto and prediction markets, on one equity curve.
An exchange inside the simulation
Fidelity is decided in the details of execution. These are the ones we insist on:
- Tick by tick, not “somewhere inside the candle”. For fast validation, every bar decomposes into a deterministic sequence of price steps (open → high → low → close) and orders fill at a specific step. For precision testing the engine goes further: it works directly on tick data — individual trades and quotes exactly as they hit the exchange.
- Order book at three levels of detail. From best bid/ask up to full book depth with individual orders — depending on how granular the data for a given market is. Ready for institutional-size volumes, where the depth of liquidity decides the outcome.
- The fill queue. A limit order does not fill just because price touched it — others are ahead of you in the book. The simulation accounts for that with a probabilistic fill-and-slippage model; and because it has its own seed, any run can be reproduced exactly.
- Fees and partial fills. Maker/taker rates per instrument, fills in parts according to available liquidity — the way an exchange does it.
- Latency. An order does not travel in zero time. Simulating the delay between decision and exchange means production will not surprise you.
- Nine order types plus contingent orders. Market, limit, stop-market, stop-limit, market-to-limit, market-if-touched, limit-if-touched and trailing variants — plus linked constructions such as OCO (one-cancels-other). The strategy works with the same arsenal in testing as it does live.
Precise to the last decimal place
Prices, quantities and money are held in fixed-point arithmetic — not floating point, where tiny rounding errors quietly accumulate across millions of operations. When a backtest runs through ten years of data, the last decimal of the equity curve is as trustworthy as the first. On top of that, every order passes through an independent risk layer — pre-trade checks, position limits — in testing and live alike, along the very same path.
Speed and scale: thousands of tests per strategy
The engine's performance core is written in Rust — a compiled systems language where every microsecond counts (you will find it in our stack). A single backtest over years of data is a matter of seconds, and because tests run in parallel, we can afford what makes testing truly meaningful — volume:
- Genetic optimization pushes hundreds of parameter candidates through,
- walk-forward examines every survivor across dozens of rolling windows,
- Monte Carlo adds hundreds of runs on noise-perturbed data.
A single strategy thus passes through thousands of backtests before production is even discussed. Without a fast engine, that discipline would be impractical — with it, it is the standard.
Why we insist on this
Every simplification in a simulation is a difference between the test and reality — and every such difference is a hidden line item the live market will eventually invoice you for. The slippage the test never saw. The fee nobody accounted for. The limit order that “always filled in testing”. A faithful simulation is cheaper than the first live month with an overrated strategy. Add overfitting defences, walk-forward discipline and Monte Carlo distributions to faithful execution, and you get exactly what our engine is: a testing philosophy built on the fact that the market cannot be cheated — so we do not cheat it in the test either.
Want to test your strategy on an engine that behaves like an exchange? Get in touch →