DEV Community: Gueta Quant

Algorithmic Risk Management in MT5: ATR Volatility Position Sizing & MQL5 Architecture

Gueta Quant — Wed, 19 Aug 2026 12:30:02 +0000

Algorithmic Risk Management in MT5: Dynamic Position Sizing & MQL5 Architecture

Most retail trading failures stem from static lot sizing. Trading a fixed 1.0 lot on EUR/USD creates vastly different dollar drawdowns compared to 1.0 lot on Gold (XAU/USD) or NASDAQ (NAS100) due to differing point values and underlying volatility regimes.

In professional quantitative finance, position sizing is dynamically governed by the asset's Average True Range (ATR) and a fixed risk budget per trade:

$$\text{Position Size (Lots)} = \frac{\text{Account Balance} \times \text{Risk \%}}{\text{Stop Loss Distance (Points)} \times \text{Tick Value}}$$

In this technical guide, we implement an open-source, production-grade MQL5 risk engine that dynamically computes lot sizes and routes orders with slippage protection.

Original interactive tool and web calculator available at GuetaQuant MT5 Position Sizer.

1. MQL5 Dynamic Lot Calculation Class

//+------------------------------------------------------------------+
//|                                             GQ_RiskEngine.mqh    |
//|                             Copyright 2026, Gueta Quant (AGPLv3) |
//|                                       https://guetaquant.com     |
//+------------------------------------------------------------------+
#property copyright "Gueta Quant"
#property link      "https://guetaquant.com"

class CGQRiskManager
{
private:
   string   m_symbol;
   double   m_risk_pct;

public:
   CGQRiskManager(string symbol, double risk_pct) : m_symbol(symbol), m_risk_pct(risk_pct) {}

   double CalculateLots(double sl_distance_price)
   {
      if (sl_distance_price <= 0) return 0.0;

      double balance     = AccountInfoDouble(ACCOUNT_BALANCE);
      double risk_amount = balance * (m_risk_pct / 100.0);

      double tick_size   = SymbolInfoDouble(m_symbol, SYMBOL_TRADE_TICK_SIZE);
      double tick_value  = SymbolInfoDouble(m_symbol, SYMBOL_TRADE_TICK_VALUE);
      double min_lot     = SymbolInfoDouble(m_symbol, SYMBOL_VOLUME_MIN);
      double max_lot     = SymbolInfoDouble(m_symbol, SYMBOL_VOLUME_MAX);
      double lot_step    = SymbolInfoDouble(m_symbol, SYMBOL_VOLUME_STEP);

      if (tick_size == 0 || tick_value == 0) return 0.0;

      double loss_per_lot = (sl_distance_price / tick_size) * tick_value;
      if (loss_per_lot <= 0) return 0.0;

      double raw_lots = risk_amount / loss_per_lot;

      // Normalize to broker lot step
      double normalized_lots = MathFloor(raw_lots / lot_step) * lot_step;

      if (normalized_lots < min_lot) normalized_lots = min_lot;
      if (normalized_lots > max_lot) normalized_lots = max_lot;

      return normalized_lots;
   }
};

2. ATR Volatility Trailing Stops

Using historical volatility avoids getting stopped out during normal market noise while protecting capital during structural trend shifts:

double GetATRDistance(string symbol, ENUM_TIMEFRAMES tf, int period, double multiplier)
{
   int handle = iATR(symbol, tf, period);
   if (handle == INVALID_HANDLE) return 0.0;

   double atr_val[1];
   if (CopyBuffer(handle, 0, 0, 1, atr_val) <= 0) return 0.0;

   return atr_val[0] * multiplier;
}

3. Open Source Tools Ecosystem

All our quantitative software is published under open-source AGPLv3:

44 Open Source Trading Tools: GitHub Repository
CERN Zenodo DOI Registry: DOI 10.5281/zenodo.22012203
Local-First Trading Journal: GuetaQuant Journal

Compliance: Strictly educational and research material. Does not constitute financial advice. Compliant with Colombian SFC Decreto 2555/2010.

Pine Script v6 in 2026: math.sum, math.tanh, User Defined Types & Risk Management Engine

Gueta Quant — Wed, 19 Aug 2026 11:52:14 +0000

Overview: Pine Script v6 & Institutional Risk Architecture

TradingView's Pine Script v6 introduced critical architectural upgrades for quantitative developers. Moving beyond basic visual scripts, v6 provides strict type enforcement, built-in tensor-like math functions (math.sum(), math.tanh()), User-Defined Types (UDTs), and native webhook JSON formatting for institutional order routing.

In this guide, we break down the most essential v6 syntax upgrades and build a full production-ready risk engine with volatility-adjusted sizing.

Original in-depth research published at GuetaQuant.

1. Key Mathematical Upgrades in Pine Script v6

In previous versions (v5), performing mathematical reductions across arrays or custom series required cumbersome loops. Pine Script v6 optimizes computational performance by executing core vector operations natively in C++:

`math.sum()` & `math.tanh()`

//@version=6
indicator("Pine Script v6 Math & Non-Linear Activation", overlay=false)

// Native vector sum across an array of returns
var float[] log_returns = array.new_float(0)
float current_return = math.log(close / close[1])
array.push(log_returns, current_return)
if array.size(log_returns) > 50
    array.shift(log_returns)

// Hyperbolic tangent non-linear activation (useful for signal bounding [-1.0, 1.0])
float normalized_zscore = (close - ta.sma(close, 20)) / ta.stdev(close, 20)
float bounded_signal = math.tanh(normalized_zscore)

plot(bounded_signal, "Tanh Signal", color=color.emerald)
hline(0.8, "Upper Bound", color=color.gray)
hline(-0.8, "Lower Bound", color=color.gray)

2. Object-Oriented Architecture with User-Defined Types (UDTs)

Pine Script v6 fully embraces struct-like User-Defined Types. This allows you to encapsulate complete trade contexts (entry, stop loss, risk budget, target) into a single object:

//@version=6
indicator("GQ Trade Context Engine", overlay=true)

type TradeRiskContext
    string symbol
    float entryPrice
    float stopLossPrice
    float lotSize
    float riskAmountUSD

// Factory method to calculate ATR-based risk
fn_create_context(float risk_pct, int atr_len, float atr_mult) =>
    float atr_val = ta.atr(atr_len)
    float sl_distance = atr_val * atr_mult
    float sl_price = close - sl_distance
    float risk_dollars = (strategy.equity * risk_pct) / 100.0
    float calculated_lots = risk_dollars / (sl_distance * 10.0) // 10 USD per pip standard

    TradeRiskContext.new(syminfo.ticker, close, sl_price, calculated_lots, risk_dollars)

var TradeRiskContext active_trade = na
if ta.crossover(ta.ema(close, 9), ta.ema(close, 21))
    active_trade := fn_create_context(1.0, 14, 2.5)

3. Webhook JSON Alert Formatting for Automated Execution

Routing alerts to MetaTrader 5 (MT5), cTrader, or custom Python execution servers requires strictly formatted JSON payloads:

//@version=6
strategy("GQ Webhook Strategy - Pine v6", overlay=true, initial_capital=10000)

fn_build_order_json(string action, float size, float sl_price) =>
    '{"action":"' + action + '","symbol":"' + syminfo.ticker + '","lots":' + str.tostring(size) + ',"sl":' + str.tostring(sl_price) + '}'

if ta.crossover(ta.sma(close, 20), ta.sma(close, 50))
    string payload = fn_build_order_json("BUY", 0.50, close - 2.5 * ta.atr(14))
    strategy.entry("Long", strategy.long, alert_message=payload)

4. Explore More Open-Source Tools

All our MQL5 EAs, cTrader cBots, and Pine Script v6 indicators are open-source under AGPLv3:

44 Open Source Quantitative Tools: GitHub Repository
Interactive MT5 Lot Size Calculator: GuetaQuant MT5 Position Sizer
Local-First Quantitative Trading Journal: GuetaQuant Journal

Disclaimer: Educational research only. Does not constitute investment advice. Compliance with SFC Colombia Decreto 2555/2010.

Pine Script v6 in 2026: math.sum, math.tanh, User Defined Types & Risk Management Engine

Gueta Quant — Wed, 19 Aug 2026 11:44:24 +0000

Liquid syntax error: Unknown tag 'endraw'

DEV Community: Gueta Quant

Algorithmic Risk Management in MT5: ATR Volatility Position Sizing & MQL5 Architecture

Algorithmic Risk Management in MT5: Dynamic Position Sizing & MQL5 Architecture

1. MQL5 Dynamic Lot Calculation Class

2. ATR Volatility Trailing Stops

3. Open Source Tools Ecosystem

Pine Script v6 in 2026: math.sum, math.tanh, User Defined Types & Risk Management Engine

Overview: Pine Script v6 & Institutional Risk Architecture

1. Key Mathematical Upgrades in Pine Script v6

math.sum() & math.tanh()

2. Object-Oriented Architecture with User-Defined Types (UDTs)

3. Webhook JSON Alert Formatting for Automated Execution

4. Explore More Open-Source Tools

Pine Script v6 in 2026: math.sum, math.tanh, User Defined Types & Risk Management Engine

`math.sum()` & `math.tanh()`