DEV Community: Ranga

Fair Value Gap (FVG) Continuation Framework

Ranga — Mon, 08 Jun 2026 10:05:14 +0000

Overview

This strategy studies how price interacts with Fair Value Gaps (FVGs), which are areas that can form after strong directional price movement.

The script identifies potential imbalance zones and monitors future price interaction with those areas. Rather than entering immediately after a gap forms, the strategy waits for price to revisit the zone and show signs of continuing in the original direction.

The objective is to explore how imbalance zones may be incorporated into a rules-based trading framework.

What Is a Fair Value Gap?

A Fair Value Gap is commonly described as an area created when price moves rapidly, leaving a gap between portions of surrounding candles.

In this script:

Bullish gaps are identified after upward displacement.
Bearish gaps are identified after downward displacement.

Previously identified zones remain available for future analysis when price revisits them.

Strategy Logic

Gap Identification
The script searches for simple three-candle imbalance patterns that may indicate a Fair Value Gap.

Zone Retest
Once a gap has been identified, the strategy waits for price to return to that area.

Continuation Confirmation
A trade is considered only after price revisits the zone and closes back in the direction of the original move.

Risk Management
Stop-loss and target levels are calculated using ATR, allowing risk parameters to adapt to changing volatility conditions.

Features

Fair Value Gap detection
Retest-based entries
ATR-based risk management
Trend continuation framework
Research and testing focused design

Intended Use
This script is designed as an educational example demonstrating one approach to identifying and testing Fair Value Gap behavior.
It may be used to study:

Price imbalances
Retest behavior
Trend continuation concepts
Volatility-adjusted exits

Users may choose to modify parameters and test the script across different symbols and timeframes.

Notes

Fair Value Gap concepts are interpreted differently by different traders. This script provides one simplified implementation and should not be considered a complete representation of all Fair Value Gap methodologies.

Disclaimer

This script is provided for educational and research purposes only. It demonstrates one method of identifying and testing Fair Value Gap behavior using Pine Script. The script does not predict future market direction and should be evaluated through independent testing before being incorporated into any trading process.

Pine Script Example

//@version=6
strategy("Fair Value Gap Continuation Framework", overlay=true, initial_capital=100000)

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

// Trend Filter
emaTrend = ta.ema(close, trendLen)

// ATR
atrValue = ta.atr(atrLen)

// Fair Value Gap Detection
bullFVG = low > high[2]
bearFVG = high < low[2]

// Store Latest FVG Zones
var float bullTop = na
var float bullBottom = na

var float bearTop = na
var float bearBottom = na

if bullFVG
    bullTop := low
    bullBottom := high[2]

if bearFVG
    bearTop := low[2]
    bearBottom := high

// Retest Logic
bullRetest = not na(bullTop) and low <= bullTop and close > bullTop
bearRetest = not na(bearBottom) and high >= bearBottom and close < bearBottom

// Trend Confirmation
longCondition = bullRetest and close > emaTrend
shortCondition = bearRetest and close < emaTrend

// Entries
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 - atrValue * atrMult
longTarget = strategy.position_avg_price + atrValue * atrMult * rr

shortStop   = strategy.position_avg_price + atrValue * atrMult
shortTarget = strategy.position_avg_price - atrValue * 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(emaTrend, title="Trend EMA", color=color.orange)

plot(bullTop, title="Bullish FVG", color=color.green, linewidth=2)
plot(bearBottom, title="Bearish FVG", color=color.red, linewidth=2)

Why Market Breadth Matters More Than Index Performance

Ranga — Mon, 01 Jun 2026 12:51:03 +0000

Overview

Many traders focus on major indexes such as the S&P 500 or Nasdaq when evaluating market conditions. While indexes show overall price movement, they do not always reflect how broadly that movement is supported across the market.
Market breadth is a way of studying participation. It can help traders understand whether strength or weakness is concentrated in a small group of stocks or spread across a wider portion of the market.
A market move supported by broad participation may provide different context than a move driven by only a few heavily weighted stocks.

Understanding Market Participation

Market breadth generally refers to the number of securities contributing to a market move.

Examples of breadth-related observations include:

The balance between advancing and declining stocks
The number of stocks reaching new highs or lows
The percentage of stocks trading above key moving averages

These measurements can provide additional perspective alongside price action and trend analysis.

Why Traders Monitor Breadth

Participation Matters
Strong participation may indicate that market activity is occurring across a wider group of stocks rather than being concentrated in a few names.

Additional Context
Breadth can be used as a supplementary tool when evaluating trends, momentum, and overall market conditions.

Market Observation
Some traders monitor breadth metrics to better understand changes in participation over time and how those changes compare with index performance.

Strategy Concept
This script uses a simplified breadth-style proxy derived from the chart's relationship to a long-term moving average.
It is important to note that this script does not use actual exchange-wide market breadth data. Instead, it creates a participation-style filter using price behavior on the current chart.

The strategy combines:

Trend identification using moving averages
A breadth-style participation filter
ATR-based risk management

The objective is to demonstrate how participation concepts can be incorporated into a trend-following framework for research and testing purposes.

Important Notes

This script uses a simplified participation-style filter and is not a substitute for exchange-wide breadth indicators.
Results will vary across symbols, timeframes, and market conditions.
The script is intended for educational, research, and testing purposes.

Disclaimer

This script is provided for educational and research purposes only. It demonstrates one way to combine trend analysis with a breadth-style participation filter. It is not financial advice and should be tested across different symbols, market conditions, and timeframes before being used in any trading workflow.

This version avoids performance claims, avoids implying predictive ability, and clearly explains the limitations of the breadth proxy.

Pine Script v6 Strategy

//@version=6
strategy("Market Breadth Trend Strategy", overlay=true, initial_capital=100000)

// Inputs
emaFastLen = input.int(50, "Fast EMA")
emaSlowLen = input.int(200, "Slow EMA")
atrLen = input.int(14, "ATR Length")
atrMult = input.float(1.5, "ATR Stop Multiplier")
rr = input.float(2.0, "Risk Reward")

// Trend
emaFast = ta.ema(close, emaFastLen)
emaSlow = ta.ema(close, emaSlowLen)

trendBull = emaFast > emaSlow
trendBear = emaFast < emaSlow

// Simplified Breadth-Style Proxy
breadthLine = ta.sma(close > emaSlow ? 100 : 0, 20)

strongBreadth = breadthLine > 60
weakBreadth = breadthLine < 40

// Entries
longCondition = trendBull and strongBreadth
shortCondition = trendBear and weakBreadth

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
atrValue = ta.atr(atrLen)

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

shortStop = strategy.position_avg_price + atrValue * atrMult
shortTarget = strategy.position_avg_price - atrValue * 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(emaFast, color=color.orange, title="Fast EMA")
plot(emaSlow, color=color.blue, title="Slow EMA")

Low Volume Node (LVN) Rejection / Acceptance Strategy

Ranga — Tue, 05 May 2026 14:02:55 +0000

Overview

This strategy models low-volume node behavior by identifying low-participation price zones and monitoring how price reacts when revisiting them.
Low-volume nodes often behave as areas where price either:

rejects sharply due to lack of acceptance, or
moves quickly through if accepted The script attempts to capture both reactions using a simplified rolling-volume imbalance model.

Strategy Logic

LVN Approximation
Since Pine Script has limited native volume-profile access in strategy scripts, this model approximates low-volume nodes using:

rolling average price
ATR-based zone width
relative low-volume detection

Rejection Setup

Price enters the LVN zone
Fails to remain there
Closes back outside the zone

Acceptance Setup

Price enters LVN
Holds beyond zone boundary
Signals continuation potential

Risk Management

ATR-based stop-loss
Fixed risk-to-reward targets
Adaptive to volatility conditions

Intended Use

This strategy is designed for:

testing auction-market concepts
studying imbalance zones
experimenting with value/acceptance behavior

Results vary by symbol and timeframe.

Pine Script v6 Strategy Code

//@version=6
strategy("LVN Rejection / Acceptance Strategy", overlay=true, initial_capital=100000, default_qty_type=strategy.percent_of_equity, default_qty_value=5)

// ───── INPUTS ─────
zoneLen    = input.int(40, "LVN Detection Length")
atrLen     = input.int(14, "ATR Length")
zoneWidth  = input.float(0.8, "LVN Width ATR")
stopMult   = input.float(1.5, "Stop ATR Multiplier")
rr         = input.float(2.0, "Risk Reward")

// ───── LVN APPROXIMATION ─────
basis   = ta.sma(close, zoneLen)
atrVal  = ta.atr(atrLen)

lvnUpper = basis + atrVal * zoneWidth
lvnLower = basis - atrVal * zoneWidth

// Relative volume check
avgVol = ta.sma(volume, zoneLen)
lowVol = volume < avgVol * 0.8

// ───── REJECTION / ACCEPTANCE LOGIC ─────
bullReject = low < lvnLower and close > lvnLower and lowVol
bearReject = high > lvnUpper and close < lvnUpper and lowVol

bullAccept = close > lvnUpper and close[1] > lvnUpper
bearAccept = close < lvnLower and close[1] < lvnLower

// ───── ENTRY CONDITIONS ─────
longCondition  = bullReject or bullAccept
shortCondition = bearReject or bearAccept

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 * stopMult
longTarget = strategy.position_avg_price + atrVal * stopMult * rr

shortStop   = strategy.position_avg_price + atrVal * stopMult
shortTarget = strategy.position_avg_price - atrVal * stopMult * 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(basis, title="LVN Mid", color=color.orange)
plot(lvnUpper, title="LVN Upper", color=color.red)
plot(lvnLower, title="LVN Lower", color=color.green)

Value Area Rejection Strategy

Ranga — Mon, 27 Apr 2026 12:06:39 +0000

This strategy identifies an equilibrium zone using a rolling average price range and looks for rejection when price moves into that zone but fails to hold inside it.

The idea is simple:
Markets often rotate around fair value
If price enters value and quickly rejects, it can signal directional intent
The strategy trades the move away from that rejected value area

How It Works

1. Build the Value Area
A rolling average price forms the center of value.
An ATR-based band creates:

Upper Value Boundary
Lower Value Boundary

2. Detect Rejection
A trade is considered when:

Bullish Rejection

Price dips into/below lower value area
Closes back above the lower boundary

Bearish Rejection

Price moves into/above upper value area
Closes back below the upper boundary

3. Risk Management
ATR-based stop-loss and take-profit:

Adaptive to market volatility
Fixed risk-to-reward structure

Logic Summary

A rolling SMA acts as the value midpoint
ATR bands create upper/lower value boundaries
Long entries occur when price rejects below value and closes back inside
Short entries occur when price rejects above value and closes back inside

Risk Handling

ATR-based stop-loss adapts to volatility
Fixed risk/reward target keeps trade structure consistent

Best Use Cases

Rotational markets
Pullback environments
Value-to-imbalance transitions

Notes

This is a simplified value-area model intended for testing and educational use. It approximates equilibrium behavior and is not a replacement for full market profile or exchange volume profile tools.

Pine Script v6 Code

//@version=6
strategy("Value Area Rejection Strategy", overlay=true, initial_capital=100000, default_qty_type=strategy.percent_of_equity, default_qty_value=5)

// ───── INPUTS ─────
valueLen   = input.int(50, "Value Area Length")
atrLen     = input.int(14, "ATR Length")
bandMult   = input.float(1.0, "Value Area Width ATR")
stopMult   = input.float(1.5, "Stop ATR Multiplier")
rr         = input.float(2.0, "Risk Reward")

// ───── VALUE AREA CALCULATION ─────
basis   = ta.sma(close, valueLen)
atrVal  = ta.atr(atrLen)

upperVA = basis + atrVal * bandMult
lowerVA = basis - atrVal * bandMult

// ───── REJECTION LOGIC ─────
bullReject = low < lowerVA and close > lowerVA
bearReject = high > upperVA and close < upperVA

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

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

// ───── EXITS ─────
longStop   = strategy.position_avg_price - atrVal * stopMult
longTarget = strategy.position_avg_price + atrVal * stopMult * rr

shortStop   = strategy.position_avg_price + atrVal * stopMult
shortTarget = strategy.position_avg_price - atrVal * stopMult * 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(basis, title="Value Area Mid", color=color.orange)
plot(upperVA, title="Upper Value Area", color=color.red)
plot(lowerVA, title="Lower Value Area", color=color.green)

Adaptive Risk Regime Strategy (Volatility Switching Model)

Ranga — Mon, 20 Apr 2026 10:01:34 +0000

Why this is trending now

Markets are not behaving the same all the time:

Some periods → slow, sideways, low volatility
Other periods → fast, explosive, high volatility Most strategies fail because they use the same rules in all conditions

So traders are now building strategies that:

detect the current market regime
switch behavior dynamically

This is becoming a big trend in Pine Script strategies

Strategy Idea

Instead of one fixed logic, this uses two modes:

Low Volatility Mode (Range Behavior)

Market is quiet
Trade small reversals
Avoid breakouts

High Volatility Mode (Trend Behavior)

Market is active
Trade breakouts
follow momentum

How It Works

Measure volatility using ATR
Compare current ATR with its average
Decide:

Low volatility → mean reversion
High volatility → breakout trading

Pine Script v6 Strategy Code

//@version=6
strategy("Adaptive Risk Regime Strategy", overlay=true, initial_capital=100000, default_qty_type=strategy.percent_of_equity, default_qty_value=5)


// ───── INPUTS ─────
atrLen   = input.int(14, "ATR Length")
lookback = input.int(50, "Volatility Lookback")


rangeLen = input.int(20, "Range Length")
rr       = input.float(2.0, "Risk Reward")
atrMult  = input.float(1.5, "ATR Stop Multiplier")


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


highVol = atrVal > atrAvg
lowVol  = atrVal < atrAvg


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


// ───── GLOBAL CROSS (fix warnings too) ─────
crossUp   = ta.crossover(close, rangeHigh[1])
crossDown = ta.crossunder(close, rangeLow[1])


// ───── LOGIC ─────
// Low volatility → mean reversion
longRange  = lowVol and close < rangeLow[1]
shortRange = lowVol and close > rangeHigh[1]


// High volatility → breakout
longBreak  = highVol and crossUp
shortBreak = highVol and crossDown


longCondition  = longRange or longBreak
shortCondition = shortRange or shortBreak


// ───── ENTRIES ─────
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, color=color.green, title="Range High")
plot(rangeLow, color=color.red, title="Range Low")

Gap Fill + Opening Range Reaction Strategy

Ranga — Wed, 15 Apr 2026 11:04:16 +0000

Why this is trending now

Right now (especially in US markets):

Markets are opening with large gaps (overnight news, macro tension)
Price often either:
fills the gap
or strongly rejects and trends away

Traders are focusing on:

gap behavior
opening range breakout/reversal
early session volatility

Strategy Idea

This strategy combines:
1. Gap Detection
Today’s open vs yesterday’s close
2. Opening Range (first X minutes)
Define high & low of early session
3. Reaction Logic
Trade:

gap fill (mean reversion)
or breakout (continuation)

//@version=6
strategy("Gap Fill + Opening Range Strategy",
     overlay=true,
     initial_capital=100000,
     default_qty_type=strategy.percent_of_equity,
     default_qty_value=5)

// ───── INPUTS ─────
rangeMinutes = input.int(30, "Opening Range Minutes")
atrLen       = input.int(14, "ATR Length")
atrMult      = input.float(1.5, "Stop ATR Multiplier")
rr           = input.float(2.0, "Risk Reward")

// ───── SESSION TIME ─────
sessionStart = timestamp(year, month, dayofmonth, 9, 30)
inOpening    = time >= sessionStart and time <= sessionStart + rangeMinutes * 60 * 1000

// ───── GAP DETECTION ─────
prevClose = close[1]
gapUp     = open > prevClose
gapDown   = open < prevClose

// ───── OPENING RANGE ─────
var float rangeHigh = na
var float rangeLow  = na

if inOpening
    rangeHigh := na(rangeHigh) ? high : math.max(rangeHigh, high)
    rangeLow  := na(rangeLow)  ? low  : math.min(rangeLow, low)

// Reset each day
if dayofmonth != dayofmonth[1]
    rangeHigh := na
    rangeLow  := na

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

// ───── ENTRY CONDITIONS ─────
// Gap fill (reversal)
longGapFill  = gapDown and close > rangeLow
shortGapFill = gapUp and close < rangeHigh

// Breakout continuation
longBreak  = breakUp
shortBreak = breakDown

longCondition  = (longGapFill or longBreak)
shortCondition = (shortGapFill or shortBreak)

// ───── ATR RISK ─────
atrVal = 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)

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="Opening Range High", color=color.green)
plot(rangeLow, title="Opening Range Low", color=color.red)

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")