MQL4 vs MQL5: What Every Algorithmic Trader Must Know Before Building

By Viprasol Tech Team | Trading Software Development

---

A trader asked us to "port" his MT4 EA to MT5 last year. Simple enough request — same strategy, new platform. What arrived in our hands was 1,400 lines of MQL4 with nested OrderSelect() loops, global arrays acting as makeshift class members, and indicator values being read directly from iMA() on every tick.

The "port" took two weeks and produced about 800 lines of MQL5. Not because we cut features, but because MQL5 has the right abstractions for what the code was trying to do. The result ran 40% faster in the Strategy Tester and had two fewer edge-case bugs than the original.

If you're deciding between MQL4 and MQL5 for a new project, or you're evaluating what a migration actually involves, this is the practical breakdown — not the marketing comparison, but the code-level differences that affect your EA's reliability, testability, and maintainability.

---

The Core Difference: Scripting Language vs Programming Language

MQL4 was designed as a scripting language for individual traders in the early 2000s. It's procedural, flat, and approachable. A motivated trader with basic programming knowledge can write a simple MQL4 EA in a weekend.

MQL5 was rebuilt from the ground up, borrowing heavily from C++. It's object-oriented, supports templates and inheritance, has a proper standard library, and has multi-threading through job pools. The tradeoff: it takes longer to get comfortable with, but it produces software that's far more maintainable at anything beyond trivial complexity.

This distinction matters for every project decision. A simple single-pair EMA crossover EA? MQL4 works. A multi-currency basket manager with coordinated risk, multiple strategy modes, and a Telegram reporting system? You want MQL5.

---

Order Management: The Biggest Practical Difference

This is where most MQL4-to-MQL5 migrations get stuck. The order management model is fundamentally different.

MQL4 order model: everything lives in OrdersTotal() — pending orders and open positions are in the same pool. You iterate through all of them using OrderSelect():

// MQL4: close all buy positions
for(int i = OrdersTotal()-1; i >= 0; i--)
{
   if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
   if(OrderType() != OP_BUY)    continue;
   if(OrderSymbol() != Symbol()) continue;
   if(OrderMagicNumber() != Magic) continue;
   
   OrderClose(OrderTicket(), OrderLots(), Bid, 3, clrNONE);
}

This works, but it's fragile. The SELECT_BY_POS index shifts when orders are closed mid-loop — which is why the loop runs backwards (i--), a non-obvious convention that trips up junior developers constantly.

MQL5 order model: positions, orders, and deals are three separate concepts. Positions are open trades. Orders are pending instructions. Deals are the historical record of fills. Each has its own function set:

// MQL5: close all buy positions — clean, explicit
CTrade trade;
trade.SetExpertMagicNumber(Magic);

for(int i = PositionsTotal()-1; i >= 0; i--)
{
   ulong ticket = PositionGetTicket(i);
   if(!PositionSelectByTicket(ticket)) continue;
   if(PositionGetString(POSITION_SYMBOL)       != _Symbol) continue;
   if(PositionGetInteger(POSITION_MAGIC)        != Magic)   continue;
   if(PositionGetInteger(POSITION_TYPE)         != POSITION_TYPE_BUY) continue;
   
   trade.PositionClose(ticket);
}

More explicit. You know exactly what you're iterating over. The MQL5 CTrade documentation is comprehensive and the class handles the edge cases (minimum stop distance, broker rejection, requote handling) that you'd otherwise need to write yourself.

---

Indicator Handles: A Better Model With One Gotcha

MQL4 calculates indicator values inline, on every tick:

// MQL4: recalculates the entire MA buffer on every tick
double maValue = iMA(Symbol(), Period(), 20, 0, MODE_EMA, PRICE_CLOSE, 0);

This works but is inefficient — every tick recalculates a buffer that hasn't changed. For simple EAs it doesn't matter. For an EA checking 10 indicators across 5 timeframes, the performance hit is real.

MQL5 uses a handle model. You create an indicator handle once in OnInit(), then copy the values you need in OnTick():

// MQL5: create once
int emaHandle = iMA(_Symbol, _Period, 20, 0, MODE_EMA, PRICE_CLOSE);

// OnTick(): copy only what you need
double ema[3];
ArraySetAsSeries(ema, true);
CopyBuffer(emaHandle, 0, 0, 3, ema);
// ema[0] = current forming bar
// ema[1] = confirmed previous bar (use this for signals)
// ema[2] = two bars ago

The gotcha: always use ema[1] (or higher index) for signal logic, never ema[0]. Index 0 is the still-forming current bar. A signal that reads as "EMA crossed up" on index 0 may disappear when the bar closes. We've seen entire strategies fail in live testing for exactly this reason, after passing backtests where the distinction didn't surface.

Always release handles in OnDeinit():

void OnDeinit(const int reason)
{
   IndicatorRelease(emaHandle);
   IndicatorRelease(rsiHandle);
   IndicatorRelease(atrHandle);
}

Leaked handles consume memory. On a VPS running for months, uneleased handles add up.

---

Object-Oriented Programming: When It Actually Matters

For simple EAs — one pair, one strategy, fixed logic — the MQL5 OOP architecture is optional overhead. You can write MQL5 procedurally just like MQL4.

For anything more complex, MQL5's class system changes what's possible. Here's a pattern we use for EAs that need to run multiple strategies or multiple instruments from a single codebase:

// Base class: defines the interface all strategies must implement
class CStrategyBase
{
protected:
   string          m_symbol;
   ENUM_TIMEFRAMES m_timeframe;
   CTrade          m_trade;
   double          m_riskPercent;
   
public:
   CStrategyBase(string symbol, ENUM_TIMEFRAMES tf, double risk)
      : m_symbol(symbol), m_timeframe(tf), m_riskPercent(risk) {}
   
   virtual bool ShouldEnterLong()  = 0;   // must be implemented by each strategy
   virtual bool ShouldEnterShort() = 0;
   virtual void ManageOpenTrades() = 0;
   virtual void OnNewBar()         = 0;
};

// One concrete strategy
class CEMABreakout : public CStrategyBase
{
private:
   int m_fastHandle, m_slowHandle, m_atrHandle;
   
public:
   CEMABreakout(string sym, ENUM_TIMEFRAMES tf, double risk,
                int fastPeriod, int slowPeriod)
      : CStrategyBase(sym, tf, risk)
   {
      m_fastHandle = iMA(sym, tf, fastPeriod, 0, MODE_EMA, PRICE_CLOSE);
      m_slowHandle = iMA(sym, tf, slowPeriod, 0, MODE_EMA, PRICE_CLOSE);
      m_atrHandle  = iATR(sym, tf, 14);
   }
   
   bool ShouldEnterLong()  override { /* EMA crossover logic */ return false; }
   bool ShouldEnterShort() override { /* EMA crossover logic */ return false; }
   void ManageOpenTrades() override { /* trailing stop logic  */ }
   void OnNewBar()         override
   {
      if(ShouldEnterLong())  /* open buy  */;
      if(ShouldEnterShort()) /* open sell */;
      ManageOpenTrades();
   }
};

The main EA file then holds an array of CStrategyBase* pointers — one for each symbol/strategy pair — and calls OnNewBar() on all of them from OnTick(). Adding a new strategy means writing a new class; none of the existing code changes.

This is the standard OOP approach documented in MQL5's language guides. In MQL4, achieving the same thing means global arrays, naming conventions, and manual dispatch — all of which break in non-obvious ways as complexity grows.

---

Multi-Symbol Access

MQL4's architecture ties an EA to the chart it's attached to. Accessing another symbol's data requires that symbol to be open in a separate chart window, with an indicator attached to communicate data — a fragile workaround.

MQL5 makes cross-symbol access a first-class feature:

// MQL5: read 30 days of GBPUSD daily data from any EA
MqlRates gbpusdDaily[];
int copied = CopyRates("GBPUSD", PERIOD_D1, 0, 30, gbpusdDaily);

if(copied > 0)
{
   double correlation = CalculateCorrelation("EURUSD", "GBPUSD", 20);
   // Use correlation as a trade filter
}

This enables an entire category of EA that's impractical on MT4: correlation-based entries, cross-pair confirmation, multi-currency portfolio risk management. We built a basket hedging EA for a client that simultaneously manages 8 currency pairs, calculates net USD exposure across the portfolio, and adjusts individual position sizes to maintain a target exposure profile. That architecture simply isn't feasible in MQL4.

---

The Strategy Tester Gap

From a backtesting standpoint, the comparison is significant enough to have changed client decisions. MT4's Strategy Tester simulates ticks between OHLCV bar data using an interpolation algorithm. MT5's Strategy Tester can replay actual historical ticks.

For a daily-chart trend strategy where you only trade at bar opens, this distinction is irrelevant. For a scalping EA with 5-pip stops, it's everything. The simulated ticks in MT4 don't model the actual price path, spread behavior during volatility, or the timing of intrabar stop hits.

We had a client with an MT4 backtest showing a 2.2 profit factor on their scalping EA. The same parameters on MT5 with real-tick data showed 1.1. Still profitable — but the MT4 backtest was hiding the full picture of execution quality. The MT5 test drove a strategy refinement that brought the live-equivalent backtest up to 1.6.

For more on the tester modes and what they mean, the MQL5 backtesting article is detailed.

---

Migration: What It Actually Takes

When we migrate an MT4 EA to MT5, the rough process:

1. Audit first. Understand what the EA is doing conceptually before touching code. What's the signal logic? How does it manage positions? What are the edge cases the original developer handled?

2. Rewrite order management. Every OrderSelect() loop becomes PositionSelectByTicket(). Every OrderSend() becomes a CTrade call. This is not a search-and-replace — the logic around what to do on fill, on rejection, and on requote changes.

3. Replace inline indicator calls. Convert iMA(), iRSI(), etc. to handle creation in OnInit() and CopyBuffer() in OnTick(). Verify the buffer indexing (always [1] for signals on completed bars).

4. Test carefully. Run the MT5 version through the real-tick strategy tester for the same period as the original MT4 backtest. Differences are expected — the MT5 tester is more accurate — but dramatic differences signal a bug in the migration.

A simple single-pair EA migration: 2–3 days. A complex multi-pair EA with custom indicators and inter-position logic: 7–12 days, including testing.

---

Which Should You Choose?

The honest answer we give every client:

Choose MQL5 for any new project. Better language, better tester, better long-term support, necessary for prop firm accounts and multi-asset strategies.

Stay on MQL4 only if you have an existing, profitable, live MT4 EA you don't want to risk breaking — or if your broker has no MT5 offering.

If you're unsure about your specific situation, we're happy to give a direct opinion. Bring your EA, your use case, and your broker — we'll tell you what makes sense, not what's easiest to sell.

---

See also: MT4 vs MT5 — Which Platform Should Your EA Target? · Building Your First MT5 EA in MQL5

Sources: MQL5 Language Basics · MQL5 Trading Functions · MQL5 Backtesting Guide