Export targets and known limits

The compiled targets come from one pass over the intermediate tree, so a change in the tree reaches the 6 files at once. What each line above claims is measured. Two of them are settled by execution: the Python file is imported and called, the C++ file is compiled with a local toolchain and run, and both are compared entry by entry against the engine.

Pine and MQL5 are checked without execution. The check verifies that each called identifier is defined in the file, with comments removed first, so a name mentioned in a comment does not count as defined. That property catches a file that cannot compile, and it is weaker than a compilation in MetaEditor.

The product proof registry currently marks Rust as not measured. Separate native validation can compile and run generated Rust files, but that result is not inferred dynamically by the exporter. Source rendering alone is not execution.

FASTEXPR delivers the alpha expression as a .txt file for WorldQuant BRAIN. It contains the underlying continuous score used by the rule, oriented in the signal's direction. Entry and exit logic and the Boolean trigger are excluded.

Each FASTEXPR export lists translation gaps and reports whether its alpha expression has a known gap. This does not mean that the file reproduces the complete strategy. An unsupported operator or a rule with no continuous score is refused by name.

The engine executes the original kernel. The translated rule is replayed on the same bars. Two regimes follow from the kernel, and the file states which one produced its number.

Coverage applies to the executed and transcribed targets. It is the share of the engine's entries the exported rule also flags, with a two-bar tolerance, and extra signals carry no penalty. It measures recall on the engine's entries, and it states no equivalence.

Four synthetic price paths are measured (two shapes, two seeds). The published number is the lowest of them, and the line in the header counts how many of those paths produced engine activity.

Below 0.8, the file is still written. What changes is the report: verified turns false, and not_verified_because names the measured coverage against the threshold. The reservation travels with the file, so the number that failed reaches the person who asked for the file, beside the file it describes.

fidelity   : <coverage> over <n> engine entries (direction <d>), on ONE synthetic
             price path (2-bar tolerance, extra signals not penalised). Read it
             as: the share of the engine's entries this rule also flags - not an
             equivalence claim, and not a measurement on your own data.

A kernel falling under the threshold fails export validation. The build carries the same threshold as the app, so a translation that degrades is caught before a release.

ok                    the file was produced
verified              the SIGNAL matched, by measurement or by identity
fidelity_basis        measurement | identity
fidelity              measured coverage, when the measurement ran
not_verified_because  the reason, when verified is false
complete_strategy     the whole GRAPH is in the file, filters and costs included

The report also lists each node's export status and reason.

Signal agreement is not complete-strategy parity. An exact strategy export would also have to preserve any stop, trailing rule, position size, loss limit, filter or cost that changes later trades. The current report names omitted graph blocks; its signal result alone must not be read as proof of those behaviours.

A custom Python node is a third case, and it is exact by identity: the file carries your own code verbatim, so no line is translated, no gap is measured, fidelity_basis reads identity and no translation took place. For Pine and MQL5, a Custom strategy signal can be translated when its Python code fits the compiler's bounded expression vocabulary. Unsupported syntax produces a refusal naming the construction; arbitrary Python files are outside this path.

// GENERATED BY STOCHASTLY - do not edit by hand, re-export.
// kernel     : <kernel>
// parameters : <params, JSON, sorted>
// direction  : <LS | L | S>
// fidelity   : <coverage> over <n> engine entries, on ONE synthetic price
//              path (2-bar tolerance, extra signals not penalised)

The same header states, kernel by kernel, what the file does with each entry. For the five engine kernels (EMA cross, Bollinger, Donchian, RSI mean reversion, z-score) the file carries the engine’s position machine: the stop in ATR, the target, the timeout, the forced close, and the phantom position a Direction node implies. It is measured trade for trade against the engine’s own trade table. For the signal kernels the header records what the backtest did: the position is held while the signal lasts, with no stop and no target, because the engine defines none for them.

EXECUTION, exactly as the engine ran it (`trades()` below replays it trade for trade):
  - a signal at the close of bar i opens at the OPEN of bar i+1;
  - stop  = 1.5 x ATR(14) of the signal bar, checked on each bar's low/high (stop FIRST, then target), booked as -1 R;
  - target = 3 x ATR (rr = 2), booked as +2 R;
  - sizing is one unit per trade and the R is GROSS: your broker's cost applies instead of the engine's cost model.

signal() returns one value per bar; trades() returns the trades the engine would book. A filter node that has no measured translation blocks the export instead of producing a file that trades on other bars.

The header lists omitted graph nodes by name, with their role and the reason for omission. If no nodes were omitted, it states that under the same heading.

When the measurement itself fails, the fidelity line carries NOT MEASURED with the reason, which is a different statement from a low score.

An exported file skips a number of bars before its first decision, and that number comes from the depth of the expression tree. A nested indicator gets the longer warm-up its depth requires: a triple exponential average needs three times the run-in of a single one.

A rate read without that mechanism made one target look like it was drifting while it was warming up. The distribution of disagreements over the series separates the two cases, and it is published under the export fidelity campaign with the run that produced it.

What an exported file reproduces →

A path handed to the export is resolved to an absolute path, traversal is rejected, and an existing file is left alone unless the caller asked for a replacement. An RPC method reachable from the interface that overwrote any file on the machine was the state before those rules.

bollinger · bollinger_band_pin_bar_reversal · donchian · ema_cross · engulfing_bullish_at_support · hookreversal_brooks · ichimoku_cloud_breakdown_bearish · ichimoku_cloud_breakout_bullish · ichimoku_tenkan_kijun_cross_bearish · ichimoku_tenkan_kijun_cross_bullish · pin_bar_bearish_rejection · rsi_mean_reversion · trix_zero_line_cross · ttm_squeeze_release_long · ttm_squeeze_release_short · vsa_no_demand · vsa_no_supply · zscore_mr. A graph built on a different kernel produces a refusal naming that kernel, and the export writes no file in that case.

Machine-learning nodes are outside this list for a structural reason: their features are cross-sectional percentile ranks computed across the universe of the run, which a single-symbol target cannot compute.

Pine Script® is a registered trademark of TradingView, Inc. MQL5® and MetaTrader® are registered trademarks of MetaQuotes Ltd. WorldQuant and BRAIN are trademarks of WorldQuant, LLC. Stochastly is an independent product, not affiliated with or endorsed by them, and the generated file carries the same notice so that it travels with the file. The full wording is on the legal notice.

Pine Script backtest validation

MQL5 Expert Advisor robustness testing

Export a supported Python strategy to MQL5