Pine Script to MQL5: the complete translation guide

Bars versus events

A Pine script runs once per bar, from the oldest loaded bar to the newest, then again on every price update of the real-time bar. You write what happens on one bar and Pine does the looping.

MQL5 has no bar loop. The program reacts to events: OnInit() when it starts, OnDeinit() when it stops, and in between either OnCalculate() (a custom indicator, called on every tick with the number of bars and how many were already calculated) or OnTick() (an Expert Advisor, called on every new tick of its symbol). An indicator loops over the bars it hasn't calculated yet; an Expert Advisor reads the bars it needs by index.

The rule of thumb: a Pine indicator() becomes an MQL5 custom indicator, and a Pine strategy() becomes an Expert Advisor.

In practice: barstate.isconfirmed and new bars

Series and indexing: close[1] versus arrays

In Pine, close is the bar being executed and close[1] the bar before; the history operator always counts back from the current bar.

In MQL5 you index arrays yourself, and two conventions coexist. The price arrays passed to OnCalculate() are not series by default: index 0 is the oldest bar and rates_total - 1 the newest, so Pine's close[1] on bar i is close[i - 1]. Functions such as iClose(_Symbol, _Period, shift), CopyBuffer() and arrays flipped with ArraySetAsSeries(arr, true) count the other way: 0 is the newest (forming) bar and 1 the last closed one.

Mixing the two is the most common porting bug: the signal lands one bar off, or reads a bar from the future.

In practice: ta.crossover and ta.crossunder

Repainting: barstate.isconfirmed versus the new-bar check

On historical bars Pine only sees final values; on the real-time bar the values change with every tick, so a condition can turn true and then false before the bar closes. barstate.isconfirmed, or reading [1], keeps signals to closed bars.

MQL5 has the same forming bar: index rates_total - 1 in an indicator, shift 0 in an Expert Advisor. A signal that must not flicker reads rates_total - 2 in an indicator; an Expert Advisor acts on the first tick of a new bar and reads shift 1. The MT5 Strategy Tester's "Open prices only" mode runs only that first tick of each bar, so an EA that reads bar 0 tests one way and trades another, the MT5 version of a repainting Pine backtest.

In practice: barstate.isconfirmed and new bars

Other timeframes: request.security versus iClose and handles

request.security() evaluates an expression on another timeframe or symbol and lines the result up with the chart's bars, and its lookahead argument plus a [1] offset decide whether history can see the future.

In MQL5 every series function takes a symbol and a timeframe: iClose(_Symbol, PERIOD_D1, 1) is yesterday's completed daily close, and an indicator handle can be created on any timeframe, iMA(_Symbol, PERIOD_H4, ...). On historical bars of an indicator, iBarShift() finds which higher-timeframe bar a chart bar belongs to; reading the bar before it is the non-repainting [1] + lookahead_on form. The other timeframe may not be loaded yet: copies then fail (error 4806) and the program tries again on the next tick.

In practice: request.security on a higher timeframe

Strategies: a simulated broker versus real orders

strategy.* calls go to TradingView's broker emulator: by default an order decided on a bar's close fills at the next bar's open, quantities are units or contracts, and the strategy holds one net position, which strategy.entry() reverses when the signal flips.

An Expert Advisor sends real requests through CTrade (from <Trade/Trade.mqh>), in lots, and the trade server can refuse them: volume steps, minimum stop distances, filling modes, margin. Every result has a return code to check. The account type matters too: on a netting account there is one position per symbol, as in Pine; on a hedging account, common with forex brokers, a buy doesn't close an open sell, so a reversal means closing the short yourself. A magic number tells the EA's positions from your manual trades.

In practice: strategy.entry to CTrade

var and varip versus globals and static

A plain Pine variable is recalculated on every bar. var keeps its value from bar to bar, and on the real-time bar Pine rolls it back to the last closed bar's value before each tick, so the forming bar counts once. varip skips the rollback and keeps every tick's change.

MQL5 globals and static locals persist between calls and are never rolled back: they behave like varip. To get var in an indicator, derive each bar's value from the previous bar's buffer element; the forming bar is then recomputed from a fixed starting point on every tick. Anything that must survive a restart of the terminal belongs in the deal history or a terminal global variable, not in a variable.

In practice: var and varip

na versus EMPTY_VALUE

Pine has na for "no value", with na(), nz() and fixnan() to test and replace it.

A double in MQL5 always holds a number. In indicator buffers, EMPTY_VALUE (the largest double) means "draw nothing here", and PLOT_EMPTY_VALUE tells the terminal which value to skip. Functions report failure through their return value (-1, 0, false) and GetLastError(), not through na. Built-in indicators need a warm-up period like Pine's: skip the first bars of their period instead of testing for a special value, and use MathIsValidNumber() to catch the NaN or infinity a division by zero can produce.

plot() versus indicator buffers

plot() draws a series in one call. In MQL5 a custom indicator declares how many buffers (arrays of values) and plots (things drawn) it has with #property indicator_buffers and indicator_plots, binds each array with SetIndexBuffer(), picks a drawing type (DRAW_LINE, DRAW_ARROW, DRAW_FILLING, DRAW_COLOR_LINE, DRAW_HISTOGRAM, DRAW_NONE) and writes one value per bar.

An Expert Advisor has no buffers: it draws chart objects (ObjectCreate()), which is also what label.new(), line.new(), box.new() and table.new() become.

In practice: plot, fill and plotshape

alertcondition() versus Alert() and SendNotification()

TradingView evaluates alerts on its own servers: alertcondition() adds a condition you pick in the "Create alert" dialog, alert() fires from the code, and both keep running with your browser closed.

MetaTrader 5 has no dialog for an indicator's conditions. The program raises the alert itself while it runs in your terminal: Alert() for a pop-up with a sound, SendNotification() for a push to the MetaTrader mobile app, SendMail() for e-mail, and WebRequest() (Expert Advisors only) for a webhook. For alerts around the clock the terminal has to run around the clock, usually on a VPS.

In practice: alertcondition and alert

input.*() versus input variables

input.int(9, "Fast EMA", minval = 1) becomes input int InpFastLen = 9; // Fast EMA: the comment after the declaration is the label in the settings dialog. MQL5 inputs have no minval, maxval or step: check the values in OnInit() and return INIT_PARAMETERS_INCORRECT. A list of options becomes an enum, input.timeframe() an ENUM_TIMEFRAMES input, input.source() an ENUM_APPLIED_PRICE input, and group an input group "Name" line. Inputs are constants: the code can't assign to them.