DEV Community: Ranga

Volatility Expansion + Fake Breakout Strategy

Ranga — Mon, 06 Apr 2026 12:52:25 +0000

This strategy focuses on one simple market behavior: price doesn’t just break ranges randomly, it expands with strength, and weak breakouts often fail. Instead of chasing every breakout, the logic waits for volatility expansion and filters out weak moves that usually trap traders.

At its core, the system observes the market’s recent range and volatility. When price compresses for a period, it builds energy. The strategy measures this using Average True Range (ATR). When ATR rises above its recent average, it signals that the market is entering an expansion phase, meaning movement is likely to accelerate.

How the Logic Works

First, the strategy defines a rolling range using recent highs and lows. This acts as a reference zone where price has been consolidating.

Next, it monitors for a breakout:

A move above the range high
A move below the range low But not every breakout is treated equally.

Filtering Fake Breakouts

One of the biggest problems in trading is getting trapped in false breakouts. To avoid this, the strategy checks for candle strength:

For bullish moves:

The candle must close strongly above the previous high, showing real buying pressure.

For bearish moves:

The candle must close strongly below the previous low, indicating genuine selling pressure.
If the breakout happens without this strength, the trade is ignored.

Entry Conditions

A trade is only taken when all conditions align:

Volatility is expanding (ATR is rising)
Price breaks the range
The breakout candle is strong and decisive

This combination helps avoid low-quality entries and focuses only on high-momentum moves.

Risk Management Approach

Every trade uses a structured risk model:

Stop loss is based on ATR, adapting to current market volatility
Take profit is calculated using a risk-to-reward ratio
Position sizing is consistent as a percentage of capital

This keeps the strategy stable across different market conditions instead of relying on fixed pip or point values.

Why This Approach Works

Markets often move in cycles:

Quiet consolidation
Volatility compression
Sudden expansion

This strategy is built specifically to catch the third phase, where price moves quickly and directionally.

By combining volatility expansion with breakout strength, it avoids common traps and focuses on movements that actually have momentum behind them.

Final Thought

This isn’t about predicting direction blindly. It’s about waiting for structure, strength, and volatility to align before acting.

If you apply this approach with discipline, it naturally reduces overtrading and improves decision quality, which is often more important than chasing every opportunity.

//@version=6
strategy("Volatility Expansion + Fake Breakout Strategy", 
     overlay=true, 
     initial_capital=100000,
     default_qty_type=strategy.percent_of_equity,
     default_qty_value=5)

// ───── INPUTS ─────
rangeLen   = input.int(20, "Range Lookback")
atrLen     = input.int(14, "ATR Length")
volMult    = input.float(1.3, "Volatility Expansion Multiplier")
atrMult    = input.float(1.5, "Stop ATR Multiplier")
rr         = input.float(2.0, "Risk Reward")

// ───── VOLATILITY ─────
atrVal = ta.atr(atrLen)
atrAvg = ta.sma(atrVal, rangeLen)

// Detect expansion
volExpansion = atrVal > atrAvg * volMult

// ───── RANGE STRUCTURE ─────
rangeHigh = ta.highest(high, rangeLen)
rangeLow  = ta.lowest(low, rangeLen)

// ───── BREAKOUT DETECTION ─────
breakUp   = ta.crossover(close, rangeHigh[1])
breakDown = ta.crossunder(close, rangeLow[1])

// ───── FAKE BREAKOUT FILTER ─────
// Candle must close strong in breakout direction
strongBull = close > open and close > high[1]
strongBear = close < open and close < low[1]

// ───── ENTRY CONDITIONS ─────
longCondition  = volExpansion and breakUp and strongBull
shortCondition = volExpansion and breakDown and strongBear

if longCondition and strategy.position_size == 0
    strategy.entry("Long", strategy.long)

if shortCondition and strategy.position_size == 0
    strategy.entry("Short", strategy.short)

// ───── RISK MANAGEMENT ─────
longStop   = strategy.position_avg_price - atrVal * atrMult
longTarget = strategy.position_avg_price + atrVal * atrMult * rr

shortStop   = strategy.position_avg_price + atrVal * atrMult
shortTarget = strategy.position_avg_price - atrVal * atrMult * rr

strategy.exit("Exit Long", from_entry="Long", stop=longStop, limit=longTarget)
strategy.exit("Exit Short", from_entry="Short", stop=shortStop, limit=shortTarget)

// ───── VISUALS ─────
plot(rangeHigh, title="Range High", color=color.green)
plot(rangeLow, title="Range Low", color=color.red)

Range Compression Expansion Strategy

Ranga — Fri, 03 Apr 2026 03:24:53 +0000

What This Strategy Focuses On

Markets don’t move randomly all the time. They often alternate between quiet phases (low volatility, tight candles) and expansion phases (strong directional moves).
This strategy is built around that idea. It identifies periods where price is compressed into a tight range and waits for a confirmed breakout before entering a trade.

How It Works

1. Detecting Compression
The script measures volatility using ATR.

When ATR drops below its recent average, the market is considered compressed
This usually means price is building up for a move Instead of relying on indicators like Bollinger Bands, this uses pure volatility contraction + price structure

2. Defining the Range
During compression, the script tracks:

Highest high (resistance)
Lowest low (support) This creates a clear structure zone.

3. Expansion Breakout
Trades are triggered when price breaks out of that range:

Break above range → potential bullish expansion
Break below range → potential bearish expansion Only confirmed breakouts are considered.

4. Risk Management

The strategy uses ATR for exits:
Stop-loss adapts to volatility
Take-profit is based on a fixed risk-to-reward ratio This keeps behavior consistent across different markets.

Key Characteristics

Focuses on volatility shifts (calm → expansion)
Uses structure instead of indicator-heavy logic
Works on crypto, forex, and stocks
Designed for testing and refinement

When It May Work Better

Before strong trending moves
During breakout phases
After long consolidation periods
It may produce fewer signals in already trending markets.

Important Note

This script is for testing and educational use. Results depend on market conditions and settings. Always test across multiple assets and timeframes.

If you want to push this further

You can upgrade this idea by adding:
trend filter (EMA or HTF bias)
volume spike confirmation
session-based filtering
fake breakout detection

Pine Script v6 Strategy Code

//@version=6
strategy("Range Compression → Expansion Strategy", overlay=true, initial_capital=100000, default_qty_type=strategy.percent_of_equity, default_qty_value=5, commission_type=strategy.commission.percent, commission_value=0.05, slippage=1)

// ───── INPUTS ─────
lookback      = input.int(20, "Range Lookback")
atrLen        = input.int(14, "ATR Length")
compressionTh = input.float(0.7, "Compression Threshold (ATR Ratio)")
atrMult       = input.float(1.5, "Stop ATR Multiplier")
rr            = input.float(2.0, "Risk Reward")

// ───── VOLATILITY ─────
atrVal = ta.atr(atrLen)
atrAvg = ta.sma(atrVal, lookback)

// Compression condition
isCompressed = atrVal < atrAvg * compressionTh

// ───── RANGE STRUCTURE ─────
rangeHigh = ta.highest(high, lookback)
rangeLow  = ta.lowest(low, lookback)

// ───── BREAKOUT LOGIC ─────
breakUp   = ta.crossover(close, rangeHigh[1])
breakDown = ta.crossunder(close, rangeLow[1])

// Entry conditions
longCondition  = isCompressed[1] and breakUp
shortCondition = isCompressed[1] and breakDown

if longCondition and strategy.position_size == 0
    strategy.entry("Long", strategy.long)

if shortCondition and strategy.position_size == 0
    strategy.entry("Short", strategy.short)

// ───── RISK MANAGEMENT ─────
longStop   = strategy.position_avg_price - atrVal * atrMult
longTarget = strategy.position_avg_price + atrVal * atrMult * rr

shortStop   = strategy.position_avg_price + atrVal * atrMult
shortTarget = strategy.position_avg_price - atrVal * atrMult * rr

strategy.exit("Exit Long", from_entry="Long", stop=longStop, limit=longTarget)
strategy.exit("Exit Short", from_entry="Short", stop=shortStop, limit=shortTarget)

// ───── VISUALS ─────
plot(rangeHigh, title="Range High", color=color.green)
plot(rangeLow, title="Range Low", color=color.red)

Multi-Timeframe Structure + Breakout Strategy

Ranga — Tue, 24 Mar 2026 12:38:17 +0000

Strategy Idea

This strategy combines higher timeframe trend direction with lower timeframe structure breakouts. Instead of trading every breakout, it aligns entries with the broader market direction and waits for confirmation from recent price structure.
The goal is to improve trade selection by filtering signals through both trend context and local market behavior.

How It Works

1. Higher Timeframe Trend Filter
A higher timeframe EMA is used to define the overall direction.

Price above HTF EMA → bullish bias
Price below HTF EMA → bearish bias This helps avoid trades against the dominant trend.

2. Market Structure Levels
The script tracks recent highs and lows over a lookback period.

Highest high → resistance reference
Lowest low → support reference These levels act as structure zones.

3. Breakout Confirmation
Trades are triggered only when price breaks these structure levels:

Break above recent high → potential continuation upward
Break below recent low → potential continuation downward

4. Volatility-Based Risk Management

Stop-loss and take-profit levels are calculated using ATR.
Stop-loss adapts to volatility
Risk-to-reward ratio defines the target

Key Features

Multi-timeframe trend alignment
Structure-based breakout entries
ATR-based adaptive exits
Non-repainting logic
Designed for backtesting and experimentation

When It May Perform Better

Trending markets
Volatility expansion phases
Higher timeframe directional moves

It may produce fewer signals in low-volatility or sideways conditions.

Important Note

This strategy is intended for testing and learning purposes. Results vary depending on market conditions, timeframe, and parameter selection. Always validate across multiple instruments before using it in live environments.

Pine Script v6 Strategy Code

//@version=6
strategy(
    "MTF Structure Breakout Strategy",
    overlay = true,
    initial_capital = 100000,
    default_qty_type = strategy.percent_of_equity,
    default_qty_value = 3,
    commission_type = strategy.commission.percent,
    commission_value = 0.05,
    slippage = 1
)

// ───── INPUTS ─────
htfTF     = input.timeframe("60", "Higher Timeframe")
htfEmaLen = input.int(100, "HTF EMA Length")

lookback  = input.int(20, "Structure Lookback")
atrLen    = input.int(14, "ATR Length")
atrMult   = input.float(1.8, "ATR Stop Multiplier")
rr        = input.float(2.0, "Risk Reward")

// ───── HIGHER TIMEFRAME TREND ─────
htfEMA = request.security(
     syminfo.tickerid,
     htfTF,
     ta.ema(close, htfEmaLen),
     lookahead = barmerge.lookahead_off
)

trendUp   = close > htfEMA
trendDown = close < htfEMA

// ───── STRUCTURE LEVELS ─────
recentHigh = ta.highest(high, lookback)
recentLow  = ta.lowest(low, lookback)

// ───── BREAKOUT CONDITIONS (GLOBAL SAFE) ─────
breakUp   = ta.crossover(close, recentHigh[1])
breakDown = ta.crossunder(close, recentLow[1])

// ───── ENTRY CONDITIONS ─────
longCondition  = breakUp and trendUp
shortCondition = breakDown and trendDown

if longCondition and strategy.position_size == 0
    strategy.entry("Long", strategy.long)

if shortCondition and strategy.position_size == 0
    strategy.entry("Short", strategy.short)

// ───── RISK MANAGEMENT ─────
atrVal = ta.atr(atrLen)

longStop   = strategy.position_avg_price - atrVal * atrMult
longTarget = strategy.position_avg_price + atrVal * atrMult * rr

shortStop   = strategy.position_avg_price + atrVal * atrMult
shortTarget = strategy.position_avg_price - atrVal * atrMult * rr

strategy.exit("Exit Long", from_entry="Long", stop=longStop, limit=longTarget)
strategy.exit("Exit Short", from_entry="Short", stop=shortStop, limit=shortTarget)

// ───── VISUALS ─────
plot(htfEMA, title="HTF EMA", color=color.orange)
plot(recentHigh, title="Structure High", color=color.green)
plot(recentLow, title="Structure Low", color=color.red)

Liquidity Sweep + Market Structure Strategy

Ranga — Tue, 17 Mar 2026 09:31:11 +0000

Strategy Concept

Financial markets often move toward areas where stop orders accumulate. These areas are usually located above recent highs or below recent lows.

When price briefly breaks those levels and quickly returns back inside the range, it can signal that liquidity has been taken and the market may move in the opposite direction.

This strategy focuses on detecting those situations. Instead of chasing breakouts, it waits for price to sweep liquidity and then confirm a shift in market structure before opening a trade.

How the Strategy Works

Liquidity Sweep Detection
The script first identifies recent swing highs and swing lows.
A sweep happens when:

Price moves above a recent high but closes back below it
Price moves below a recent low but closes back above it This behavior suggests that stop orders were triggered but the breakout did not continue.

Market Structure Confirmation
After a sweep occurs, the strategy waits for confirmation from market structure.

For a long setup, price must break above a recent short-term high after sweeping liquidity below.
For a short setup, price must break below a recent short-term low after sweeping liquidity above.

This helps reduce random entries.

Volatility-Based Risk Control
The script uses ATR (Average True Range) to calculate stop-loss and take-profit levels.
This allows the strategy to adapt to changing market conditions. When volatility expands, exits widen; when volatility contracts, exits become tighter.

Key Characteristics

Detects stop-run style moves
Confirms entries using structure shifts
Uses volatility-adaptive exits
Designed for testing and educational purposes

Where This Strategy May Perform Better

This type of setup often appears during:

active trading sessions
volatile market phases
instruments with strong liquidity

Sideways markets with very low volatility may produce fewer reliable signals.

//@version=6
strategy("Liquidity Sweep + Market Structure Strategy",
     overlay=true,
     initial_capital=100000,
     default_qty_type=strategy.percent_of_equity,
     default_qty_value=5)

// Inputs
lookback = input.int(20, "Liquidity Lookback")
structureLen = input.int(5, "Structure Length")
atrLen = input.int(14, "ATR Length")
atrMult = input.float(1.5, "Stop ATR Multiplier")
rr = input.float(2.0, "Risk Reward")

// Liquidity levels
recentHigh = ta.highest(high[1], lookback)
recentLow  = ta.lowest(low[1], lookback)

// Sweep detection
sweepHigh = high > recentHigh and close < recentHigh
sweepLow  = low < recentLow and close > recentLow

// Market structure levels
structureHigh = ta.highest(high, structureLen)
structureLow  = ta.lowest(low, structureLen)

// Structure break
bullStructureBreak = close > structureHigh[1]
bearStructureBreak = close < structureLow[1]

// Entry logic
longCondition  = sweepLow[1] and bullStructureBreak
shortCondition = sweepHigh[1] and bearStructureBreak

// ATR risk control
atrValue = ta.atr(atrLen)

if longCondition and strategy.position_size == 0
    strategy.entry("Long", strategy.long)

if shortCondition and strategy.position_size == 0
    strategy.entry("Short", strategy.short)

// Exit levels
longStop  = strategy.position_avg_price - atrValue * atrMult
longTake  = strategy.position_avg_price + atrValue * atrMult * rr

shortStop = strategy.position_avg_price + atrValue * atrMult
shortTake = strategy.position_avg_price - atrValue * atrMult * rr

strategy.exit("Exit Long", from_entry="Long", stop=longStop, limit=longTake)
strategy.exit("Exit Short", from_entry="Short", stop=shortStop, limit=shortTake)

// Visuals
plot(recentHigh, title="Liquidity High", color=color.red)
plot(recentLow, title="Liquidity Low", color=color.green)

VWAP Breakout + Retest Trend Strategy

Ranga — Mon, 09 Mar 2026 09:11:18 +0000

Strategy Idea

This strategy focuses on trading continuation moves that occur after price breaks away from the Volume Weighted Average Price (VWAP) and then retests it.

VWAP is commonly used to represent the average traded price during a session. When price moves away from this level and later returns to it, the area can act as a dynamic support or resistance level.
The script attempts to capture trend continuation when price breaks VWAP and then confirms the move with a retest.

How the Strategy Works

1. VWAP Breakout
The first step is identifying when price moves above or below the VWAP line.

Price crossing above VWAP suggests bullish momentum.
Price crossing below VWAP suggests bearish momentum.

This initial move signals potential directional interest.

2. Retest Confirmation
Instead of entering immediately on the breakout, the strategy waits for price to pull back toward VWAP.
This retest helps confirm whether the VWAP level is acting as support or resistance.

3. Trend Alignment
To reduce counter-trend trades, a trend filter using an exponential moving average (EMA) is applied.

Price above the trend EMA favors long trades.
Price below the trend EMA favors short trades.

4. Risk Management
Stop-loss and take-profit levels are based on ATR (Average True Range).
This allows exits to adapt to market volatility rather than using fixed distances.

Key Features

VWAP-based market structure
Retest confirmation before entry
Trend filter using EMA
ATR-based dynamic risk management
Designed for testing and educational purposes

When This Strategy May Work Better

This type of approach may perform better in:

intraday trending markets
instruments with strong liquidity
sessions where price frequently reacts to VWAP levels

It may perform less effectively during low-volatility or sideways market conditions.

//@version=6
strategy(
    "VWAP Breakout Retest Trend Strategy",
    overlay = true,
    initial_capital = 100000,
    default_qty_type = strategy.percent_of_equity,
    default_qty_value = 3,
    commission_type = strategy.commission.percent,
    commission_value = 0.05,
    slippage = 1
)


// Inputs
emaLen  = input.int(100, "Trend EMA Length")
atrLen  = input.int(14, "ATR Length")
atrMult = input.float(1.8, "ATR Stop Multiplier")
rr      = input.float(2.0, "Risk Reward")


// Indicators
vwapValue = ta.vwap(close)
emaTrend  = ta.ema(close, emaLen)
atrVal    = ta.atr(atrLen)


// Trend Direction
trendUp   = close > emaTrend
trendDown = close < emaTrend


// Breakout Detection
breakUp   = ta.crossover(close, vwapValue)
breakDown = ta.crossunder(close, vwapValue)


// Retest Conditions
retestLong  = low <= vwapValue and trendUp
retestShort = high >= vwapValue and trendDown


// Entry Conditions
longCondition  = breakUp[1] and retestLong
shortCondition = breakDown[1] and retestShort


if longCondition and strategy.position_size == 0
    strategy.entry("Long", strategy.long)


if shortCondition and strategy.position_size == 0
    strategy.entry("Short", strategy.short)


// Risk Management
longStop  = strategy.position_avg_price - atrVal * atrMult
longTarget = strategy.position_avg_price + atrVal * atrMult * rr


shortStop  = strategy.position_avg_price + atrVal * atrMult
shortTarget = strategy.position_avg_price - atrVal * atrMult * rr


strategy.exit("Long Exit", from_entry="Long", stop=longStop, limit=longTarget)
strategy.exit("Short Exit", from_entry="Short", stop=shortStop, limit=shortTarget)


// Visuals
plot(vwapValue, title="VWAP", color=color.orange, linewidth=2)
plot(emaTrend, title="Trend EMA", color=color.blue)

Trend Break + Structure + Range Filter

Ranga — Fri, 06 Mar 2026 06:12:24 +0000

This strategy focuses on trading continuation moves after price breaks recent structure, while filtering out low-momentum conditions. The goal is to participate in directional markets and reduce entries during sideways activity.

Concept Behind the Strategy

Markets tend to alternate between consolidation and expansion. Instead of reacting to every price movement, this approach waits for a clear break of recent highs or lows, aligned with the prevailing trend.
By combining structure, trend bias, and range filtering, the strategy aims to improve trade selection quality.

How It Works

1. Trend Direction (EMA Filter)
A moving average defines the primary market bias.

Price above the EMA → bullish bias
Price below the EMA → bearish bias Trades are only taken in the direction of this bias.

2. Structure Break

The system monitors the highest high and lowest low over a defined lookback period.
A trade is triggered when price breaks beyond that recent structure.

3. Range Filter (Bollinger Logic)

If price is moving inside a compressed range, entries are avoided.
This helps reduce signals during low-momentum conditions.

4. Risk Management

Stop-loss and take-profit levels are based on ATR (Average True Range), which adapts to current volatility.
A configurable risk-to-reward ratio determines the target distance.

5. Realistic Backtesting Setup

Commission and slippage are included to simulate more practical conditions.

Key Characteristics

Non-repainting logic
Breakout-based entries
Trend-aligned trade direction
Volatility-adjusted exits
Designed for structured testing

When It May Perform Better

Markets with sustained directional movement
Volatility expansion phases
Instruments that respect breakout behavior It may underperform during prolonged sideways or low-volatility environments.

Important Note

This strategy is intended for research and testing purposes. Performance can vary across assets and timeframes. It should be evaluated across different market conditions before considering live use.

//@version=6
strategy(
    "Trend Break + Structure + Range Filter",
    overlay = true,
    initial_capital = 100000,
    default_qty_type = strategy.percent_of_equity,
    default_qty_value = 3,
    commission_type = strategy.commission.percent,
    commission_value = 0.05,
    slippage = 1
)


// ─────────────────────
// INPUTS
// ─────────────────────
emaTrendLen = input.int(50, "Trend EMA Length")
bbLen       = input.int(20, "Range Length")
bbMult      = input.float(1.8, "BB Multiplier")
atrLen      = input.int(14, "ATR Length")
atrMult     = input.float(1.8, "ATR Stop Multiplier")
rr          = input.float(2.0, "Risk-Reward")


// ─────────────────────
// TREND FILTER
// ─────────────────────
emaTrend = ta.ema(close, emaTrendLen)
trendUp  = close > emaTrend
trendDown= close < emaTrend


// ─────────────────────
// RANGE FILTER
// ─────────────────────
basis   = ta.sma(close, bbLen)
dev     = bbMult * ta.stdev(close, bbLen)
upperBB = basis + dev
lowerBB = basis - dev


inRange = close >= lowerBB and close <= upperBB


// ─────────────────────
// STRUCTURE BREAK
// ─────────────────────
highestLevel = ta.highest(high, bbLen)
lowestLevel  = ta.lowest(low, bbLen)


breakHigh = ta.crossover(close, highestLevel[1])
breakLow  = ta.crossunder(close, lowestLevel[1])


// ─────────────────────
// ENTRY CONDITIONS
// ─────────────────────
longCond  = breakHigh and trendUp and not inRange
shortCond = breakLow and trendDown and not inRange


if longCond and strategy.position_size == 0
    strategy.entry("Long", strategy.long)


if shortCond and strategy.position_size == 0
    strategy.entry("Short", strategy.short)


// ─────────────────────
// RISK MANAGEMENT
// ─────────────────────
atrVal = ta.atr(atrLen)


longStop   = strategy.position_avg_price - atrVal * atrMult
longTarget = strategy.position_avg_price + atrVal * atrMult * rr


shortStop   = strategy.position_avg_price + atrVal * atrMult
shortTarget = strategy.position_avg_price - atrVal * atrMult * rr


strategy.exit("Long Exit", from_entry="Long", stop=longStop, limit=longTarget)
strategy.exit("Short Exit", from_entry="Short", stop=shortStop, limit=shortTarget)


// ─────────────────────
// VISUALS
// ─────────────────────
plot(emaTrend, color=color.orange, title="Trend EMA")
plot(upperBB, color=color.green, title="Upper Range")
plot(lowerBB, color=color.red, title="Lower Range")

Volatility Squeeze Expansion Strategy

Ranga — Thu, 26 Feb 2026 10:19:26 +0000

This strategy is built around a simple idea: strong directional moves often begin after periods of low volatility. Instead of chasing trends late, it waits for price compression and then trades the breakout when expansion begins.
The approach combines volatility structure and trend alignment to reduce random entries.

Core Concept

Markets cycle between quiet phases and expansion phases.
When volatility contracts, it often leads to a stronger move once price breaks out of that range.
This strategy attempts to capture that transition.

How It Works

1. Volatility Compression Detection
A squeeze condition is identified when Bollinger Bands contract inside Keltner Channels.
This signals reduced volatility.

2. Squeeze Release
The strategy waits for volatility to expand again.
Trades are only considered when the squeeze ends.

3. Breakout Confirmation
Entries occur when price breaks above or below the Bollinger Bands after the squeeze release.

4. Trend Alignment
A long-term EMA is used to filter direction:

Above EMA → bullish bias
Below EMA → bearish bias This helps reduce counter-trend trades.

5. Risk Management
Stop-loss and take-profit levels are based on ATR.
This allows exits to adapt to current market volatility.
A configurable risk-to-reward ratio defines profit targets.

Key Features

Structured volatility-based entries
Trend confirmation filter
ATR-based dynamic risk control
Commission and slippage included for realistic testing
No repainting logic

Best Conditions

This type of strategy tends to perform better during:

Volatility expansion phases
Strong directional markets

Assets that experience compression before breakouts
It may underperform in slow, range-bound environments.

Important Notes

This strategy is designed for research and backtesting purposes.
Performance will vary across different markets and timeframes.
Always evaluate across multiple conditions before considering live deployment.

//@version=6
strategy("Improved EMA Trend + ATR Strategy with Arrows",
     overlay=true,
     commission_type=strategy.commission.percent,
     commission_value=0.1,
     slippage=2,
     initial_capital=10000)


// Inputs
fastLen   = input.int(12, "Fast EMA Length")
slowLen   = input.int(26, "Slow EMA Length")
atrLen    = input.int(14, "ATR Length")
riskATR   = input.float(2.0, "ATR Stop Multiplier")
rewardATR = input.float(4.0, "ATR Limit Multiplier")
minBars   = input.int(2, "Minimum Bars Before Exit")
atrFilter = input.float(0.0, "ATR Minimum Threshold (0=auto)")


// Indicators
fastEMA = ta.ema(close, fastLen)
slowEMA = ta.ema(close, slowLen)
atr     = ta.atr(atrLen)


// Trend Filter
trendUp   = close > slowEMA
trendDown = close < slowEMA


// ATR Threshold filter
atrThreshold = atrFilter > 0 ? atrFilter : ta.sma(atr, atrLen)


// Entry Conditions
longCondition  = ta.crossover(fastEMA, slowEMA) and trendUp and atr > atrThreshold and barstate.isconfirmed
shortCondition = ta.crossunder(fastEMA, slowEMA) and trendDown and atr > atrThreshold and barstate.isconfirmed


// Entries
if longCondition
    strategy.entry("Long", strategy.long)
if shortCondition
    strategy.entry("Short", strategy.short)


// Exits with minimum bar hold
if strategy.position_size > 0
    barsHeld = bar_index - strategy.opentrades.entry_bar_index(strategy.opentrades - 1)
    if barsHeld >= minBars
        strategy.exit("Long Exit", "Long", stop=close - atr * riskATR, limit=close + atr * rewardATR)


if strategy.position_size < 0
    barsHeld = bar_index - strategy.opentrades.entry_bar_index(strategy.opentrades - 1)
    if barsHeld >= minBars
        strategy.exit("Short Exit", "Short", stop=close + atr * riskATR, limit=close - atr * rewardATR)


// Plot arrows on chart
plotshape(longCondition, title="Buy Arrow", style=shape.triangleup, location=location.belowbar, color=color.green, size=size.small)
plotshape(shortCondition, title="Sell Arrow", style=shape.triangledown, location=location.abovebar, color=color.red, size=size.small)

Modular Trend Pullback Strategy

Ranga — Tue, 17 Feb 2026 08:02:38 +0000

This strategy focuses on trading pullbacks within established trends. Instead of entering immediately when a trend forms, it waits for a temporary retracement and then looks for confirmation before placing a trade. The goal is to improve entry timing while keeping risk controlled.

Core Idea

Markets often move in waves. During a strong trend, price tends to retrace toward a short-term average before continuing in the dominant direction. This script attempts to participate in those continuation moves.

How It Works

1. Trend Identification

Two exponential moving averages (EMAs) define direction.

Fast EMA above Slow EMA → bullish environment
Fast EMA below Slow EMA → bearish environment

2. Pullback Condition

In an uptrend, price must retrace below the fast EMA.
In a downtrend, price must retrace above the fast EMA. This avoids chasing extended moves.

3. Break Confirmation

After a pullback, the strategy waits for price to break the previous candle’s high (for longs) or low (for shorts).
This acts as confirmation that momentum is returning in the direction of the trend.

4. Risk Management

Stop-loss and take-profit levels are based on ATR (Average True Range), allowing exits to adapt to current volatility.
A configurable risk-reward ratio defines profit targets.

Key Features

Non-repainting logic
Entries only when flat (no stacking positions)
ATR-based dynamic stop and target levels
Commission and slippage included for more realistic backtests
Structured, modular logic for easier testing and adjustment

Suitable Market Conditions

This type of approach generally performs best in:
Trending environments
Instruments with sustained directional movement
Timeframes where pullbacks are clearly visible It may underperform in sideways or low-volatility markets.

Notes

This script is intended for research and testing purposes. Results will vary depending on symbol, timeframe, and market regime. Always evaluate performance across multiple market conditions before considering live execution.

`//@version=6
strategy(
    "Modular Trend Pullback Strategy",
    overlay=true,
    initial_capital=100000,
    default_qty_type=strategy.percent_of_equity,
    default_qty_value=5,
    commission_type=strategy.commission.percent,
    commission_value=0.05,
    slippage=1
)

// ───────── INPUTS ─────────
fastLen = input.int(20, "Fast EMA")
slowLen = input.int(50, "Slow EMA")
atrLen  = input.int(14, "ATR Length")
atrMult = input.float(1.5, "Stop ATR Mult")
rr      = input.float(2.0, "Risk Reward")

// ───────── INDICATORS ─────────
emaFast = ta.ema(close, fastLen)
emaSlow = ta.ema(close, slowLen)
atrVal  = ta.atr(atrLen)

// ───────── TREND ─────────
trendUp   = emaFast > emaSlow
trendDown = emaFast < emaSlow

// ───────── GLOBAL TRIGGERS (ALWAYS EXECUTE) ─────────
breakHigh = ta.crossover(close, high[1])
breakLow  = ta.crossunder(close, low[1])

// ───────── PULLBACK LOGIC ─────────
pullbackLong  = trendUp and close < emaFast
pullbackShort = trendDown and close > emaFast

longTrigger  = pullbackLong and breakHigh
shortTrigger = pullbackShort and breakLow

// ───────── ENTRIES ─────────
if longTrigger and strategy.position_size == 0
    strategy.entry("Long", strategy.long)

if shortTrigger and strategy.position_size == 0
    strategy.entry("Short", strategy.short)

// ───────── RISK MANAGEMENT ─────────
longSL  = strategy.position_avg_price - atrVal * atrMult
longTP  = strategy.position_avg_price + atrVal * atrMult * rr

shortSL = strategy.position_avg_price + atrVal * atrMult
shortTP = strategy.position_avg_price - atrVal * atrMult * rr

strategy.exit("Long Exit", from_entry="Long", stop=longSL, limit=longTP)
strategy.exit("Short Exit", from_entry="Short", stop=shortSL, limit=shortTP)

// ───────── VISUALS ─────────
plot(emaFast, color=color.orange)
plot(emaSlow, color=color.blue)`

Trading the Stop Hunts: Session Liquidity Sweep Strategy

Ranga — Tue, 10 Feb 2026 03:58:08 +0000

This strategy focuses on liquidity sweeps during active market sessions and only trades when the overall trend agrees. The goal is to avoid random entries and concentrate on moves that happen after stop orders are cleared.

How It Works

Liquidity Sweep
Price moves above a recent high or below a recent low during a session, hinting that stops were taken.
Trend Check
A simple trend filter confirms whether the market direction supports the move.
Confirmed Entries
Trades are placed only after the candle closes, so results stay realistic and non-repainting.

Risk Handling

Stop-loss and take-profit levels are based on ATR, so they adapt to volatility.
Risk and reward stay consistent even when the market speeds up or slows down.
Position size can be set as a percentage of equity.

Why This Approach Helps

Fewer trades, better structure
Less noise during sideways markets
More realistic backtest behavior

Reminder

This strategy is meant for testing and learning, not guaranteed results. Always forward-test before using it with real money.

//@version=6
strategy(
     "Small Logic Change → Big P&L Difference",
     overlay = true,
     initial_capital = 100000,
     default_qty_type = strategy.percent_of_equity,
     default_qty_value = 5
)

// INPUTS
fastLen   = input.int(20, "Fast EMA")
slowLen   = input.int(50, "Slow EMA")
atrLen    = input.int(14, "ATR Length")
riskATR   = input.float(1.5, "Stop Loss ATR")
rr        = input.float(2.0, "Risk Reward")

useConfirmedBars = input.bool(true, "Use Confirmed Bars")

// INDICATORS
emaFast = ta.ema(close, fastLen)
emaSlow = ta.ema(close, slowLen)
atrVal  = ta.atr(atrLen)

// TREND CONTEXT
trendUp   = emaFast > emaSlow
trendDown = emaFast < emaSlow

// ✅ CROSS LOGIC (GLOBAL — ALWAYS EXECUTES)
emaCrossUp   = ta.crossover(emaFast, emaSlow)
emaCrossDown = ta.crossunder(emaFast, emaSlow)

// ENTRY CONDITIONS
rawLong  = trendUp and emaCrossUp
rawShort = trendDown and emaCrossDown

longCond  = useConfirmedBars ? (rawLong and barstate.isconfirmed) : rawLong
shortCond = useConfirmedBars ? (rawShort and barstate.isconfirmed) : rawShort

// ENTRIES
if longCond and strategy.position_size == 0
    strategy.entry("Long", strategy.long)

if shortCond and strategy.position_size == 0
    strategy.entry("Short", strategy.short)

// RISK MANAGEMENT
longSL  = strategy.position_avg_price - atrVal * riskATR
longTP  = strategy.position_avg_price + atrVal * riskATR * rr

shortSL = strategy.position_avg_price + atrVal * riskATR
shortTP = strategy.position_avg_price - atrVal * riskATR * rr

strategy.exit("Long Exit", "Long", stop = longSL, limit = longTP)
strategy.exit("Short Exit", "Short", stop = shortSL, limit = shortTP)

// VISUALS
plot(emaFast, color=color.orange, title="Fast EMA")
plot(emaSlow, color=color.blue, title="Slow EMA")

Pivot-Based Dynamic Trend Strategy (Quality-Controlled)

Ranga — Thu, 05 Feb 2026 04:01:01 +0000

Overview

This strategy demonstrates a pivot-based trend continuation approach built with execution realism in mind.
It combines confirmed swing structure (pivot highs/lows), a higher-timeframe EMA trend filter, and ATR-based risk management to create a clean, auditable trading framework suitable for backtesting and experimentation.
All logic is evaluated on confirmed bars only, with no repainting or intrabar assumptions.

Core idea

Markets often form identifiable swing highs and lows while trending.
When price pulls back toward a trend reference (EMA) and then breaks a prior swing level, continuation becomes more likely, provided overall trend strength is present.
This strategy focuses on:

Structure first
Trend alignment
Defined risk on every trade

How it works

1) Trend context
A single EMA is used to define directional bias:

Price above the EMA → bullish context
Price below the EMA → bearish context
This keeps the logic simple and consistent.

2) Pivot structure
Confirmed pivot highs and lows are detected using a fixed lookback window.

Pivot highs represent recent resistance
Pivot lows represent recent support Only confirmed pivots are used, no future data or repainting behavior.

3) Trend strength filter
Directional strength is evaluated using ADX (via DMI):

Trades are allowed only when trend strength exceeds a minimum threshold
This helps reduce signals during low-energy or choppy market conditions

4) Entry logic
Entries are evaluated only when:

Price is aligned with the EMA trend
Trend strength is sufficient
Price pulls back toward the EMA
Price then breaks the most recent confirmed pivot level This avoids chasing extended moves and helps improve entry quality.

5) Risk management
Risk is fully defined at entry:

Stop-loss is based on an ATR multiple
Take-profit uses a fixed risk-to-reward ratio
Position sizing is capped at a fixed percentage of equity
One position at a time
No trailing stops, no hidden exits, no retroactive adjustments.

Usage notes

Results vary by symbol, timeframe, volatility regime, and session
This is not a signal service or a finished trading system
Best used as a structural template for studying trend continuation and swing-based entries

Users are encouraged to:

Test across multiple markets
Adjust pivot length, EMA length, and ATR parameters
Validate behavior with forward testing before using alerts or automation

Purpose

This script is designed to emphasize:

confirmed-bar logic
realistic execution
explicit risk definition
repeatable behavior It intentionally prioritizes quality and clarity over optimization or curve-fitted performance.

//@version=6
strategy(
    "Pivot-Based Dynamic Trend Strategy (QC – Fixed)",
    overlay=true,
    initial_capital=100000,
    default_qty_type=strategy.percent_of_equity,
    default_qty_value=5,
    commission_type=strategy.commission.percent,
    commission_value=0.05,
    slippage=1
)


// ─────────────────────
// INPUTS
// ─────────────────────
pivotLen   = input.int(5, "Pivot Length")
emaLen     = input.int(100, "Trend EMA Length")
atrLen     = input.int(14, "ATR Length")
slMult     = input.float(1.4, "Stop ATR Multiplier")
rr         = input.float(2.0, "Risk–Reward")
sessionTime = input.session("0930-1600", "Trading Session")


// ─────────────────────
// SESSION FILTER
// ─────────────────────
inSession = not na(time(timeframe.period, sessionTime))


// ─────────────────────
// INDICATORS
// ─────────────────────
emaTrend = ta.ema(close, emaLen)
atrVal   = ta.atr(atrLen)


// ADX (v6-correct via DMI)
[dip, dim, adxVal] = ta.dmi(14, 14)
trendStrong = adxVal > 20


// ─────────────────────
// CONFIRMED PIVOTS
// ─────────────────────
ph = ta.pivothigh(high, pivotLen, pivotLen)
pl = ta.pivotlow(low, pivotLen, pivotLen)


var float lastHigh = na
var float lastLow  = na


if not na(ph)
    lastHigh := ph


if not na(pl)
    lastLow := pl


// ─────────────────────
// TREND CONTEXT
// ─────────────────────
trendUp   = close > emaTrend
trendDown = close < emaTrend


// ─────────────────────
// ENTRY CONDITIONS (SINGLE-LINE → NO SYNTAX ERROR)
// ─────────────────────
longCond  = inSession and trendUp and trendStrong and low <= emaTrend and not na(lastHigh) and close > lastHigh and strategy.position_size == 0
shortCond = inSession and trendDown and trendStrong and high >= emaTrend and not na(lastLow)  and close < lastLow  and strategy.position_size == 0


if longCond
    strategy.entry("Long", strategy.long)


if shortCond
    strategy.entry("Short", strategy.short)


// ─────────────────────
// RISK MANAGEMENT
// ─────────────────────
longStop  = strategy.position_avg_price - atrVal * slMult
longLimit = strategy.position_avg_price + atrVal * slMult * rr


shortStop  = strategy.position_avg_price + atrVal * slMult
shortLimit = strategy.position_avg_price - atrVal * slMult * rr


strategy.exit("Long Exit",  "Long",  stop=longStop,  limit=longLimit)
strategy.exit("Short Exit", "Short", stop=shortStop, limit=shortLimit)


// ─────────────────────
// VISUALS
// ─────────────────────
plot(emaTrend, "Trend EMA", color=color.orange)
plot(lastHigh, "Last Pivot High", color=color.new(color.red, 40), style=plot.style_linebr)
plot(lastLow,  "Last Pivot Low",  color=color.new(color.green, 40), style=plot.style_linebr)

Block-Based Visual Logic Builder Framework (Modular Strategy Template)

Ranga — Fri, 30 Jan 2026 10:17:43 +0000

This strategy demonstrates a modular, block-based approach to strategy design in Pine Script. While TradingView does not support true drag-and-drop strategy builders, this script is structured to simulate a visual logic builder by separating trading logic into independent, configurable blocks.

Each block represents a conceptual component (trend, momentum, volatility, session, and risk), allowing users to enable, disable, or modify individual modules for testing and experimentation.

Visual Logic Builder Concept

The strategy is organized into distinct logic blocks:

Session Block - controls when trades are allowed
Trend Block - defines directional bias
Momentum Block - confirms directional strength
Volatility Block - filters for sufficient market movement
Risk Block - standardized ATR-based stop and target logic

This structure mirrors how visual trading systems and drag-and-drop interfaces organize logic into reusable components.

How It Works

Market conditions are evaluated through separate logic blocks.
Each block can be enabled or disabled using inputs.
Final entry decisions are based on the combined output of active blocks.
All exits are managed through a centralized risk block using ATR-based stops and fixed risk-reward.

Purpose

This script is intended as a structural template for building and testing modular trading systems. It emphasizes clarity, execution realism, and repeatable logic rather than optimization or signal density.

Usage Notes

Results depend on symbol, timeframe, volatility regime, and selected block settings. Users are encouraged to experiment with different combinations of blocks and validate behavior across multiple markets before relying on any configuration.

//@version=6
strategy(
    "Block-Based Visual Logic Builder Framework",
    overlay=true,
    initial_capital=100000,
    default_qty_type=strategy.percent_of_equity,
    default_qty_value=5,
    commission_type=strategy.commission.percent,
    commission_value=0.05,
    slippage=1
)

// ─────────────────────
// BLOCK TOGGLES
// ─────────────────────
useTrendBlock    = input.bool(true,  "Enable Trend Block")
useMomentumBlock = input.bool(true,  "Enable Momentum Block")
useVolBlock      = input.bool(true,  "Enable Volatility Block")
useSessionBlock  = input.bool(true,  "Enable Session Block")

// ─────────────────────
// INPUTS
// ─────────────────────
emaFastLen = input.int(50,  "Fast EMA")
emaSlowLen = input.int(200, "Slow EMA")

rsiLen = input.int(14, "RSI Length")
rsiMid = input.float(50, "RSI Midline")

atrLen = input.int(14, "ATR Length")
slMult = input.float(1.5, "Stop ATR Multiplier")
rr     = input.float(2.0, "Risk-Reward")

tradeSession = input.session("0930-1600", "Trade Session")

// ─────────────────────
// INDICATORS
// ─────────────────────
emaFast = ta.ema(close, emaFastLen)
emaSlow = ta.ema(close, emaSlowLen)
rsiVal  = ta.rsi(close, rsiLen)
atrVal  = ta.atr(atrLen)

// ─────────────────────
// BLOCKS
// ─────────────────────
sessionOk = not na(time(timeframe.period, tradeSession))
sessionPass = useSessionBlock ? sessionOk : true

trendUp   = close > emaSlow
trendDown = close < emaSlow
trendPassLong  = useTrendBlock ? trendUp   : true
trendPassShort = useTrendBlock ? trendDown : true

momentumLong  = rsiVal > rsiMid
momentumShort = rsiVal < rsiMid
momentumPassLong  = useMomentumBlock ? momentumLong  : true
momentumPassShort = useMomentumBlock ? momentumShort : true

volOk   = atrVal > ta.sma(atrVal, 50)
volPass = useVolBlock ? volOk : true

// ─────────────────────
// FINAL ENTRY LOGIC (SINGLE LINE — NO ERRORS)
// ─────────────────────
longCond  = sessionPass and trendPassLong and momentumPassLong and volPass and strategy.position_size == 0
shortCond = sessionPass and trendPassShort and momentumPassShort and volPass and strategy.position_size == 0

if longCond
    strategy.entry("Long", strategy.long)

if shortCond
    strategy.entry("Short", strategy.short)

// ─────────────────────
// RISK BLOCK
// ─────────────────────
longStop  = strategy.position_avg_price - atrVal * slMult
longLimit = strategy.position_avg_price + atrVal * slMult * rr

shortStop  = strategy.position_avg_price + atrVal * slMult
shortLimit = strategy.position_avg_price - atrVal * slMult * rr

strategy.exit("Long Exit",  "Long",  stop=longStop,  limit=longLimit)
strategy.exit("Short Exit", "Short", stop=shortStop, limit=shortLimit)

// ─────────────────────
// VISUALS
// ─────────────────────
plot(emaFast, "Fast EMA", color=color.orange)
plot(emaSlow, "Slow EMA", color=color.blue)

Session Liquidity Sweep + Trend Confirmation

Ranga — Mon, 19 Jan 2026 12:27:58 +0000

This strategy aims to capture high-probability intraday trades by combining liquidity sweeps with a trend confirmation filter. It is designed for traders who want a systematic approach to trade breakouts during specific market sessions while controlling risk with ATR-based stops.

How it Works:

Session Filter: Trades are only considered during a defined session (default 9:30 - 11:00). This helps avoid low-volume periods that can lead to false signals.

Trend Confirmation: The strategy uses a 50-period EMA to identify the market trend. Long trades are only taken in an uptrend, and short trades in a downtrend.

Liquidity Sweep Detection:

A long entry occurs when price dips below the prior N-bar low but closes back above it, indicating a potential liquidity sweep that stops being triggered before the trend continues upward.
A short entry occurs when price spikes above the prior N-bar high but closes below it, signaling a potential sweep of stops before the downward trend resumes.

ATR-Based Risk Management:

Stop loss is calculated using the Average True Range (ATR) multiplied by a configurable factor (default 1.5).
Take profit is set based on a risk-reward ratio (default 2.5x).

Position Sizing: Default position size is 5% of equity per trade, making it suitable for risk-conscious trading.

Inputs:

Session Start/End (HHMM)
Liquidity Lookback Period (number of bars to define prior high/low)
ATR Length for stop calculation
ATR Stop Multiplier
Risk-Reward Ratio
EMA Trend Filter Length

Visuals:

Prior Liquidity High (red)
Prior Liquidity Low (green)
EMA Trend (blue)

Why Use This Strategy:

Captures stop-hunt moves often triggered by larger market participants.
Only trades with trend confirmation, reducing false signals.
Provides automatic ATR-based stop loss and take profit for consistent risk management.
Easy to adjust session time, ATR, EMA length, and risk-reward to suit your trading style.

Important Notes:

Assumes 0.05% commission and 1-pip slippage. Adjust according to your broker.
Not financial advice; intended for educational, backtesting, or paper trading purposes.
Always test strategies thoroughly before applying to live accounts.

//@version=6
strategy(
    "Session Liquidity Sweep + Trend Confirmation",
    overlay=true,
    initial_capital=100000,
    default_qty_type=strategy.percent_of_equity,
    default_qty_value=5,
    commission_type=strategy.commission.percent,
    commission_value=0.05,
    slippage=1
)


// ─────────────────────
// INPUTS
// ─────────────────────
sessionStart = input.int(930, "Session Start (HHMM)")
sessionEnd   = input.int(1100, "Session End (HHMM)")
lookbackBars = input.int(20, "Liquidity Lookback")
atrLen       = input.int(14, "ATR Length")
slMult       = input.float(1.5, "Stop ATR Multiplier")
rr           = input.float(2.5, "Risk-Reward")
emaTrendLen  = input.int(50, "EMA Trend Filter")


// ─────────────────────
// SESSION FILTER
// ─────────────────────
hourMinute = hour * 100 + minute
inSession  = (hourMinute >= sessionStart) and (hourMinute <= sessionEnd)


// ─────────────────────
// TREND FILTER
// ─────────────────────
emaTrend = ta.ema(close, emaTrendLen)
trendUp   = close > emaTrend
trendDown = close < emaTrend


// ─────────────────────
// LIQUIDITY LEVELS
// ─────────────────────
prevHigh = ta.highest(high[1], lookbackBars)
prevLow  = ta.lowest(low[1], lookbackBars)


// ─────────────────────
// SWEEP + CONFIRMATION
// ─────────────────────
sweepHigh = (high > prevHigh) and (close < prevHigh)
sweepLow  = (low < prevLow) and (close > prevLow)


// ─────────────────────
// ATR FOR RISK
// ─────────────────────
atrVal = ta.atr(atrLen)


// ─────────────────────
// ENTRY CONDITIONS
// ─────────────────────
longCond  = inSession and sweepLow and trendUp and (close > open) and (strategy.position_size == 0)
shortCond = inSession and sweepHigh and trendDown and (close < open) and (strategy.position_size == 0)


if longCond
    strategy.entry("Long", strategy.long)


if shortCond
    strategy.entry("Short", strategy.short)


// ─────────────────────
// RISK MANAGEMENT
// ─────────────────────
longStop  = strategy.position_avg_price - atrVal * slMult
longLimit = strategy.position_avg_price + atrVal * slMult * rr


shortStop  = strategy.position_avg_price + atrVal * slMult
shortLimit = strategy.position_avg_price - atrVal * slMult * rr


strategy.exit("Long Exit", "Long", stop=longStop, limit=longLimit)
strategy.exit("Short Exit", "Short", stop=shortStop, limit=shortLimit)


// ─────────────────────
// VISUALS
// ─────────────────────
plot(prevHigh, "Prior Liquidity High", color=color.new(color.red, 40))
plot(prevLow, "Prior Liquidity Low", color=color.new(color.green, 40))
plot(emaTrend, "EMA Trend", color=color.new(color.blue, 0))