Building Multi-Stage ATR Trailing Stops in Pine Script v6 (Complete Guide)

Static stop losses are one of the primary reasons systematic trend-following strategies suffer from large drawdowns and give back accrued profits. In volatile asset classes like Crypto, Forex, and Indices, volatility expands and contracts dynamically across market sessions.

A static 1% or 20-pip stop either gets hunted prematurely during high-volatility sweeps or allows the market to retrace 80% of an impulse wave before closing the trade. The institutional solution is a Multi-Stage Adaptive ATR Trailing Stop.

The Three Stages of Algorithmic Risk Management

In quantitative system design, trade management is split into three distinct mechanical phases:

Initial Risk Definition (Stage 0): Placed below the structural low or at Entry - (1.5 * ATR).
Breakeven Transition (Stage 1): Triggered automatically when price reaches Take Profit 1 (1.0R / 1.5R). The stop moves to Entry + Spread Buffer.
Dynamic Volatility Trailing (Stage 2): Ratchets upward candle-by-candle using a tightening ATR multiplier (e.g., 2.0x ATR scaling down to 1.2x ATR) to lock in exponential run-ups.

SmartCat Algo Multi-Stage ATR Execution on 5-Minute Chart

Figure 1: SmartCat Algo executing dynamic TP1, TP2, and Trailing Stop protection on a live 5M setup.

Pine Script v6 Zero-Repaint Implementation

In Pine Script v6, trailing stops must maintain state across historical bars using persistent variables (var keyword) to prevent look-ahead bias and repainting.

//@version=6
indicator("Multi-Stage ATR Trailing Stop Engine", overlay=true)

// 1. Inputs & Volatility Calculation
atrLength  = input.int(14, "ATR Length")
atrMult    = input.float(1.8, "Initial ATR Multiplier")
trailMult  = input.float(1.2, "Trailing ATR Multiplier")
atrVal     = ta.atr(atrLength)

// 2. State Tracking Variables
var float entryPrice = na
var float activeStop = na
var int   stage      = 0 // 0: Neutral, 1: Active, 2: Trailing

// 3. Execution Logic Example (Long Side)
buySignal = ta.crossover(ta.ema(close, 9), ta.ema(close, 21))

if buySignal and stage == 0
    entryPrice := close
    activeStop := close - (atrMult * atrVal)
    stage      := 1

// Transition to Trailing after 1.5R gain
if stage == 1 and high >= entryPrice + (1.5 * (entryPrice - activeStop))
    stage := 2

// Stage 2: Ratchet Stop Upwards
if stage == 2
    newStop = close - (trailMult * atrVal)
    activeStop := math.max(activeStop, newStop)

// Stop Exit Condition
if stage > 0 and close < activeStop
    stage := 0
    activeStop := na
    

Why math.max() is Critical for Long Trailing Stops

A true trailing stop must be a ratchet — it can only move higher in a long trade, never down. Using math.max(activeStop, newStop) guarantees that during sudden intraday volatility spikes, the protected profit baseline is never expanded.

Avoiding Common Trailing Stop Pitfalls

When deploying trailing stops on TradingView charts, algorithmic developers frequently run into two major failure modes:

Intrabar Wicks vs Bar Close: Evaluating trailing stop breaches on close prevents premature stop-outs from flash wicks, but exposes the position to slippage on massive momentum bars. Professional architectures use dual-threshold evaluation.
Session Gaps: When trading index futures (NQ, ES) or Forex over weekend opens, gaps can jump over your stop line. Your algorithm must calculate slippage bounds dynamically.

Get the Production-Ready Engine

Skip weeks of debugging Pine Script v6 syntax. SmartCat Algo includes this complete Multi-Stage ATR risk engine, Neural Volatility Clustering, and Order Block detection with 100% open source code access.

Get SmartCat Algo (8 One-Time)