Platform Atlas
One map of the whole platform.
Everything here moves along one line: a signal is found, filtered, shaped into an order, and managed as a live position. From there it branches — prove it in backtests, compile it into a MetaTrader robot or indicator, or sell it on the marketplace. Pick any stop on the map to jump to its section.
Select a stop to jump to its section
- Build
- Build
- Prove
- Prove
- Robot lane
- Robot lane
- Indicator lane
- Indicator lane
- Market loop
- Market loop
Start here
From empty canvas to running robot
Six steps, each one building on the last. The first four are guided lessons with a live practice canvas; the last two happen in the real editors.
- Step 1StartMeet the canvasNodes, wires, and configuration — how a graph computes something on every bar.
- Step 2StartGate signals with filtersBuild a filter document and learn how strict and non-strict categories decide cancel versus hold.
- Step 3StartShape the orderWire take-profit, stop-loss and confidence into the order exit.
- Step 4StartAssemble a strategyDrop your documents into the composer, order the filter chain, and publish a version.
- Step 5OpenProve it on historyRun a backtest, read the equity curve and trade list, then optimize and check the robustness score.
- Step 6OpenShip it or sell itCompile the published version into a MetaTrader robot, or list your work on the marketplace.
Four ways to learn
Choose the door that fits the moment
Guided, hands-on tracks with a practice canvas built in. The right door on day one.
Open LearnCopyable starting points for common setups — open one, paste it into an editor, adapt it.
Browse recipesPrecise, scannable catalogs: every tool, every wire type, every chart pattern.
Tool AtlasData TypesPatternsThe ideas underneath: the pipeline, the honesty rules, the version model. Explained on this page.
Jump to conceptsThe build line
Four stages, four documents
A strategy is not one file — it is four documents, each authored on its own canvas and validated on its own terms. The composer snaps them together.
- Search SignalFinds the moment
Decides buy or sell on every bar. Its exit takes two booleans — raising both emits two independent signals.
- FiltersGuard the gate
A chain of filter documents interrogates each signal. Every filter answers with one boolean: pass, or stop it here.
- Create OrderShapes the trade
Turns a surviving signal into price levels: one or more take-profits, one or more stop-losses, and an optional confidence that scales position size.
- Deal StageManages the position
After execution: qualification models decide whether a management suggestion is allowed, sizing models decide how big. Prop-firm presets included.
Composition and publishing
The composer references one Search Signal, an ordered filter chain, one Create Order and a Deal Stage configuration. Publishing freezes the whole assembly into a numbered, immutable version — runs and compiles always execute a version, never your live draft.
What a filter can say
- Go next
- The signal advances to the next state.
- Hold
- Not yet — try again on the next bar.
- Cancel
- Discard the signal entirely.
The five filter categories
Inside a state, categories evaluate in a fixed order. Strict families cancel; non-strict families hold.
- Data miningObserves and records. Never affects the signal.
- StrictAll must pass, or the signal is cancelled.
- Strict weightedThe weighted score must reach the threshold, or the signal is cancelled.
- Non-strictAt least one must pass, or the signal holds for the next bar.
- Non-strict weightedThe weighted score must reach the threshold, or the signal holds.
The instrument
Everything is a node on a canvas
Each stage document is a graph: tool nodes joined by typed wires, flowing into the stage exit. The type system does the safety work for you.
Tools are the atoms
A tool is one unit of computation — an indicator, a comparison, a piece of arithmetic, a drawing. Drop it on the canvas, configure it in the inspector, wire its output onward. Many tools carry modes: one node, several behaviours.
Interpretors turn numbers into meaning
An oscillator gives you a curve; an interpretor reads it and answers a semantic question — overbought? trending? diverging? They are the bridge between raw indicator output and a decision, and the concept newcomers miss most often.
Wires carry types
A connection only forms when the types agree. When they almost agree, the canvas offers an adapter to bridge the gap — so a mistake is caught at drag time, not at run time.
- Buffer
- A value for every bar — the shape indicators speak.
- Scalar
- One number for the current evaluation, like a price level.
- Boolean
- True or false — what exits and conditions consume.
- Enum
- One choice from a named set.
- Multi-enum
- Several choices from a named set.
- Event list
- Discrete happenings with bar positions, like detected patterns.
- Bundle
- A structured record — tap a single field when you need just one part.
The honesty rule
At decision time a graph cannot read the current bar's close — the engine raises an error if it tries. Repainting tools are re-evaluated bar by bar, seeing only what was known at that moment. What you backtest is what a live terminal would have seen.
The tool catalog
The palette you build from
Counts below are read live from the catalog — they update the moment a tool ships.
- Market—Indicators and detectors that read price, volume and time: averages, oscillators, market structure, volume profiles, patterns, Fibonacci, Gann, Elliott, astronomy.
- Interpretors—Semantic readers that turn raw output into verdicts.
- Calculation—Geometry and math over series: crosses, Fibonacci levels, wave and channel construction.
- Sinks—Indicator-lane terminals: plots, alerts, and chart objects.
- Conditions—Threshold and comparison gates that answer true or false.
- Constants—Fixed numbers, booleans and choices to wire anywhere.
- Math—Arithmetic and reductions over wires.
- Logic—Boolean combinators for composing conditions.
Market data
The bars underneath
Every run replays real historical bars. Browse what is available, and study any symbol on the chart workspace with catalog tools overlaid.
The prove line
Backtest, optimize, validate
A published version replays against history. Progress streams live; results are equity curves, trade records and per-node chart series.
Three fidelity modes — bar-by-bar, simulated intra-bar ticks, or real ticks — plus a fast vectorized engine for strategies without deal-stage management.
Sweep parameter ranges across trials, walk-forward included. Every trial is a full backtest with its own record.
After optimization, six independent analyzers interrogate the result — overfitting probability, deflated Sharpe, Monte Carlo stress, reality checks, walk-forward degradation, return diagnostics — and compose one robustness score from 0 to 100.
The compile lanes
From document to MetaTrader file
Two lanes leave the platform. Both end in a real file you download and drop into a terminal.
A published strategy version compiles into an Expert Advisor for MetaTrader 5 or 4. The generated code runs the same pipeline your backtest proved.
- Publish a version
- Compile
- Download and attach
The indicator designer is its own document family: the graph ends in sinks — plots, alerts, and chart objects covering every MetaTrader object type — instead of a signal exit. Compile it into a custom indicator, with your own alert sounds bundled in.
Plot and alert sinks draw and notify; object sinks place markers, lines, channels, Fibonacci, Gann and Elliott figures on the chart.
Licensing
Every compile is recorded in a licence ledger. An indicator can ship open, licence-checked offline, or online — phoning home from the terminal for a signed verdict you can revoke at any time.
Build faster
Shortcuts that stay yours
Three accelerators feed the same pipeline — nothing here bypasses versions, validation or ownership.
Describe the strategy in plain language; a session drafts the documents. Accepting materializes a real draft in your workspace — you review, edit and publish like anything hand-built.
Need a tool the catalog lacks? Describe it, answer questions in a thread, and the approved build is delivered to your account.
Share any document by link — the token works once and can grant clone rights. Publish to the public library under your name, browse other builders, and keep reusable fragments as cells and saved settings.
The market loop
Sell your work, buy a head start
Strategies, modules, indicators, tools and saved settings can be listed. Every listing passes review before it goes live.
- ListDraft a listing and submit it for review.
- Browse or negotiateBuyers purchase at list price or open an offer thread.
- DeliverThe buyer gets access; your earnings ledger matures toward payout.
Compute is metered in prepaid credits: backtests by bars processed, optimizations by trials, previews, AI generation and data downloads by use. A run places a worst-case hold first and settles to actual cost on completion — you always see the estimate before confirming.
A service without a price shows as unavailable — never as free.
Under the hood
For readers who want the machinery
The corrected deep dive — how the engine actually works today.
The runtime, in one paragraph
Editors produce JSON documents. The composer assembles them; publishing freezes an immutable version stamped with the exact tool versions it was built against. Runs load the version, replay bars through the four stages, and stream progress events. Compiles lower the same graph to MQL source and hand it to the compile service, which returns the finished terminal file.
Entry money management
Four steps between an order and the broker: a gate that can refuse entry, a sizing model, a confidence mapping that scales size by the order's confidence value, and a final risk guard that clamps the result.
Temporal gating
Static time-window rules that block, reduce or force-close; DST-aware market sessions; a news ceasefire around scheduled events; and a live-learning heatmap by day and hour.
Engines and fidelity
Bar-by-bar is fast and coarse; tick-simulated interpolates intra-bar movement; real ticks replays recorded ticks. The vectorized engine runs the signal pipeline sequentially and hands execution to a fast vector backend — deal-stage management requires the reference engine.
Look-ahead and repainting
Inside the decision scope, reading the current bar raises an error — the guard is structural, not advisory. Tools that repaint are re-evaluated under a moving cursor so each bar sees only its own past; assembly flags any repainting tool in the build report.
Journey data
An optional per-signal data bus. The search signal declares the schema; filters and the order stage read and write. A write becomes readable from the next state onward — never within the same state — so information always flows forward.
Drafts and versions
Every document family keeps one mutable draft per author and a chain of immutable published versions. Version numbers only move forward; diffs are first-class; runs and compiles pin to versions, so nothing you run can change under you.
Glossary
The vocabulary, in one place
Short definitions, consistent with what every editor and label calls things.
Tool
The smallest unit of computation — one canvas node type from the catalog.
Mode
A named variant of one tool, chosen in its configuration — one node, several behaviours.
Wire
A typed connection between two ports. Types must agree, or an adapter bridges them.
Interpretor
A tool that reads raw indicator output and answers a semantic question with a verdict.
Document
One authored artifact — a search signal, filter, create order, deal stage or indicator — stored as a graph or typed configuration.
Draft
Your single mutable working copy of a document. Publishing turns it into a version.
Version
An immutable published snapshot of a document. Runs and compiles always execute versions.
Search signal
The stage document that decides buy or sell on every bar.
Filter
A stage document that gates signals with one boolean answer; its category decides cancel versus hold.
Create order
The stage document that shapes a signal into take-profit, stop-loss and confidence.
Deal stage
The post-execution stage: qualification and sizing models managing the open position.
Strategy
The composed assembly of the four stages, published as a version.
Run
One backtest or optimization executing a published version against history.
Robustness score
A 0–100 composite from six validation analyzers, computed after every optimization.
Robot
A compiled Expert Advisor file produced from a strategy version.
Indicator document
The document family that compiles to a custom MetaTrader indicator; its graph ends in sinks.
Sink
A terminal indicator-lane node: a plot, an alert, or a chart object.
Cell
A reusable sub-graph, shared by link and referenced inside filters.
Journey data
The per-signal data bus stages use to pass values forward.
Credits
The prepaid balance that meters compute. Runs hold a worst-case amount, then settle to actual.
Entitlement
What a marketplace purchase grants: run access to a sealed product, or a private clone of an open one.
Repainting
When a tool's past values change as new bars arrive. The engine re-evaluates such tools bar by bar so backtests stay honest.