DEV Community: PineGen AI

RSI Divergence + EMA Trend Filter

PineGen AI — Wed, 15 Jul 2026 10:02:34 +0000

Divergence is one of the most discussed concepts in technical analysis and one of the most misapplied. The core idea is simple: when price makes a new high but the RSI makes a lower high, momentum is weakening even as price advances. That disconnect between price action and momentum is what divergence measures — and it often precedes reversals before price itself confirms the change in direction.
This strategy formalizes that concept into a rule-based, backtestable system with two components: RSI divergence detection and an EMA trend filter that determines which divergences to act on.

What divergence actually measures

RSI measures the speed and magnitude of price changes. When price reaches a new swing high but RSI fails to reach a correspondingly higher reading, it means the buying pressure behind the new high was weaker than the buying pressure behind the previous high. The market got to a higher price but required less momentum to do it — which suggests the move is losing conviction. Bearish divergence (price higher, RSI lower) signals potential exhaustion in an uptrend. Bullish divergence (price lower, RSI higher) signals potential exhaustion in a downtrend.

Important: divergence is a momentum signal, not a reversal guarantee. Price can continue making new highs with weakening RSI for a significant period before actually reversing. This is why divergence signals work best when combined with a trend filter that identifies the broader market context.

The EMA filter

The 200 EMA defines the dominant trend regime. Bearish divergence signals — where momentum is weakening on the upside — are only acted on when price is below the 200 EMA, meaning the broader trend is already bearish and divergence represents a potential resumption of that trend after a counter-trend bounce. Bullish divergence signals are only acted on when price is above the 200 EMA, where they represent potential continuations of the dominant uptrend after a pullback with improving momentum.

This filter deliberately reduces the total number of signals. Many valid divergences occur against the dominant trend and produce short-lived reversals that reverse again quickly. By requiring trend alignment, the strategy trades fewer setups but acts on the ones with a higher probability of following through.

How divergence is detected

The strategy identifies swing highs and swing lows using a lookback period — the number of bars on each side of a pivot that must be lower (for a high) or higher (for a low) to qualify as a genuine swing point. When two consecutive swing highs show price making a higher high but RSI making a lower high, bearish divergence is flagged. When two consecutive swing lows show price making a lower low but RSI making a higher low, bullish divergence is flagged.
The lookback length is the most important input to tune. A shorter lookback detects more swing points and generates more signals, but many will be minor pivots in the context of noise. A longer lookback requires more significant swing points and generates fewer, higher-quality signals. On daily charts, a lookback of 5 works well. On lower timeframes, 3 to 4 is more appropriate.

Exits

Positions exit at an ATR-based stop-loss and a fixed ATR-based take-profit. The stop is placed beyond the swing point that generated the divergence signal — for a bearish divergence, the stop sits above the swing high; for a bullish divergence, below the swing low. This is intentional: if price breaks through the very level that defined the divergence, the signal is invalidated regardless of what RSI was doing. The take-profit is set at 2x ATR to maintain a positive reward-to-risk ratio across the system.

What to evaluate in backtesting

Look at the signal distribution across different market environments. Divergence strategies tend to perform differently in trending versus ranging markets — in strong trending environments, bearish divergences against the dominant trend will produce many false signals even with the EMA filter. Look at whether the EMA filter is doing real work by temporarily disabling it and comparing signal quality. Check average trade duration — divergence signals that take too long to play out often give back open profit before the take-profit level is reached.

This is not a high-frequency strategy. On daily charts with a 5-bar lookback, signals may appear only a few times per month on a given instrument. That frequency is appropriate — divergence setups require specific conditions to form and should not be forced.

Shared for educational purposes and discussion. This is not investment advice. Backtest on your own instruments and timeframes before drawing conclusions about expected performance.

//@version=6
strategy("RSI Divergence + EMA Trend Filter", overlay=true,
     default_qty_type=strategy.percent_of_equity, default_qty_value=10)

// ── INPUTS ─────────────────────────────────────────────
rsiLen  = input.int(14,   "RSI Length",         group="RSI")
rsiSrc  = input.source(close, "RSI Source",      group="RSI")
lbLen   = input.int(5,    "Pivot Lookback",      group="Divergence", minval=2)
emaLen  = input.int(200,  "EMA Length",          group="Trend Filter")
atrLen  = input.int(14,   "ATR Length",          group="Risk")
slMult  = input.float(1.5,"SL ATR Multiplier",   group="Risk", step=0.1)
tpMult  = input.float(3.0,"TP ATR Multiplier",   group="Risk", step=0.1)

// ── INDICATORS ──────────────────────────────────────────
rsiVal = ta.rsi(rsiSrc, rsiLen)
emaVal = ta.ema(close, emaLen)
atrVal = ta.atr(atrLen)

// ── PIVOT DETECTION ─────────────────────────────────────
pivotHigh = ta.pivothigh(high, lbLen, lbLen)
pivotLow  = ta.pivotlow(low,   lbLen, lbLen)

// ── RSI AT PIVOTS ───────────────────────────────────────
rsiAtHigh = ta.valuewhen(not na(pivotHigh), rsiVal, 0)
rsiAtLow  = ta.valuewhen(not na(pivotLow),  rsiVal, 0)

prevRsiHigh = ta.valuewhen(not na(pivotHigh), rsiVal, 1)
prevRsiLow  = ta.valuewhen(not na(pivotLow),  rsiVal, 1)

prevPivotHigh = ta.valuewhen(not na(pivotHigh), high, 1)
prevPivotLow  = ta.valuewhen(not na(pivotLow),  low,  1)

// ── DIVERGENCE DETECTION ────────────────────────────────
bearDiv = not na(pivotHigh) and high > prevPivotHigh and rsiAtHigh < prevRsiHigh
bullDiv = not na(pivotLow)  and low  < prevPivotLow  and rsiAtLow  > prevRsiLow

// ── TREND FILTER ────────────────────────────────────────
aboveEma = close > emaVal
belowEma = close < emaVal

// ── ENTRY CONDITIONS ────────────────────────────────────
longCond  = bullDiv and aboveEma and barstate.isconfirmed and strategy.position_size == 0
shortCond = bearDiv and belowEma and barstate.isconfirmed and strategy.position_size == 0

// ── EXECUTION ───────────────────────────────────────────
if longCond
    strategy.entry("Long",  strategy.long,
         alert_message="Bullish divergence — long entry on {{ticker}} @ {{close}}")
    strategy.exit("Long Exit",  "Long",
         stop=low[lbLen]  - atrVal * slMult,
         limit=close      + atrVal * tpMult)

if shortCond
    strategy.entry("Short", strategy.short,
         alert_message="Bearish divergence — short entry on {{ticker}} @ {{close}}")
    strategy.exit("Short Exit", "Short",
         stop=high[lbLen] + atrVal * slMult,
         limit=close      - atrVal * tpMult)

// ── VISUALS ─────────────────────────────────────────────
plot(emaVal, "EMA Trend Filter", color=color.new(color.blue, 50), linewidth=1)

plotshape(longCond,  location=location.belowbar, color=color.green,
     style=shape.triangleup,   size=size.small, text="Bull Div")
plotshape(shortCond, location=location.abovebar, color=color.red,
     style=shape.triangledown, size=size.small, text="Bear Div")

// RSI panel
rsiPlot = plot(rsiVal, "RSI", color=color.purple, display=display.pane)
hline(70, "Overbought", color=color.new(color.red,   50), linestyle=hline.style_dashed)
hline(30, "Oversold",   color=color.new(color.green, 50), linestyle=hline.style_dashed)
hline(50, "Midline",    color=color.new(color.gray,  70), linestyle=hline.style_dotted)

If you'd rather skip writing hundreds of lines manually, Try PineGen AI, which converts natural language into Pine Script.

ATR Trailing Stop Strategy with EMA Trend Filter

PineGen AI — Mon, 06 Jul 2026 07:51:09 +0000

Most stop-loss approaches treat risk as a fixed number, a percentage, a dollar amount, a set number of points. The problem with fixed stops is that they ignore the market's actual behavior at any given moment. A 1% stop that makes sense in a low-volatility environment will get hit constantly in a high-volatility one. A wide fixed stop that survives a volatile period is needlessly large when the market quiets down.

ATR-based trailing stops solve this by scaling the stop distance to what the market is actually doing right now. ATR measures average true range, the average distance price moves per bar over a given period, including gaps. When volatility expands, the stop widens to give the trade room to breathe. When volatility contracts, the stop tightens to protect more of the open profit. The stop follows price as it moves in the trade's direction and never moves backward — only trailing further in the profitable direction or holding its level until price reverses through it and the trade closes.

The EMA filter is added for one specific reason: trailing stop systems are naturally reactive rather than predictive, which means without a trend filter they will generate signals in both directions during choppy, range-bound conditions. The 200 EMA acts as a simple regime gate. Long trades are only considered when price is above the 200 EMA, broadly in an uptrend. Short trades are only considered when price is below it. This doesn't eliminate losing trades, but it meaningfully reduces the number of counter-trend entries that trail stop systems would otherwise generate in oscillating markets.

How the trailing stop works:

On each bar, the strategy calculates a long stop level at close - (ATR × multiplier) and a short stop level at close + (ATR × multiplier). When price is in an uptrend, the long stop ratchets upward with price but never moves down, it holds its highest reached level until price closes below it, at which point the trend flips to bearish and the stop becomes a downward-trailing short stop. The opposite applies in a downtrend. A trend flip from bearish to bullish generates a long entry signal if price is above the 200 EMA. A flip from bullish to bearish generates a short entry signal if price is below the 200 EMA.

Parameters worth adjusting:

The ATR multiplier controls the sensitivity of the trailing stop. A lower multiplier (1.5x or below) produces a tighter stop that flips trend direction more frequently, useful on lower timeframes where you want faster reaction but will generate more signals. A higher multiplier (2.5x or above) produces a wider stop that flips less often, better suited for higher timeframes where you want to stay in a trend longer and can tolerate larger drawdowns on individual trades before exit. The ATR length controls how many bars the average is computed over. Shorter lengths react faster to recent volatility changes; longer lengths smooth out volatility spikes.

The EMA length can be adjusted depending on your timeframe. 200 periods is the standard for daily charts. On a 4-hour chart, 100 to 150 periods covers a similar calendar range. On a 1-hour chart, 50 to 100 periods is reasonable. The goal is for the EMA to represent the dominant trend, not a short-term moving average that whipsaws with every swing.

What this is not:

This strategy does not predict market direction. It reacts to price behavior and exits when price reverses by a defined volatility-adjusted distance. It will produce losing trades, every trailing stop system does, and sequences of losses in choppy conditions are expected behavior, not a flaw. The expectation is that winning trades capture significantly more than they risk because the stop trails and locks in profit, while losing trades are cut at a defined ATR-based distance. Evaluate this on your own instruments and timeframes with realistic backtest conditions before drawing any conclusions about expected performance.

Shared for educational purposes. This is not investment advice. Always backtest thoroughly and size positions according to your own risk tolerance.

//@version=6
strategy("ATR Trailing Stop + EMA Filter", overlay=true,
     default_qty_type=strategy.percent_of_equity, default_qty_value=10)

// ── INPUTS ─────────────────────────────────────────────
atrLen  = input.int(14,    "ATR Length",     group="ATR Trailing Stop")
atrMult = input.float(2.0, "ATR Multiplier", group="ATR Trailing Stop", step=0.1)
emaLen  = input.int(200,   "EMA Length",     group="Trend Filter")

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

// ── ATR TRAILING STOP ───────────────────────────────────
var float trail   = na
var bool  upTrend = true

longStop  = close - atrVal * atrMult
shortStop = close + atrVal * atrMult

if na(trail)
    trail   := longStop
    upTrend := true
else
    if upTrend[1]
        trail   := close < trail[1] ? shortStop : math.max(trail[1], longStop)
    else
        trail   := close > trail[1] ? longStop  : math.min(trail[1], shortStop)
    upTrend := close >= trail

// ── TREND FILTER ────────────────────────────────────────
emaLong  = close > emaVal
emaShort = close < emaVal

// ── FLIP DETECTION ──────────────────────────────────────
flipToLong  = upTrend  and not upTrend[1]
flipToShort = not upTrend and upTrend[1]

// ── ENTRY CONDITIONS ────────────────────────────────────
longCond  = flipToLong  and emaLong  and strategy.position_size <= 0
shortCond = flipToShort and emaShort and strategy.position_size >= 0

// ── EXECUTION ───────────────────────────────────────────
if longCond
    strategy.entry("Long",  strategy.long,
         alert_message="ATR Trail flip to long — {{ticker}} @ {{close}}")

if shortCond
    strategy.entry("Short", strategy.short,
         alert_message="ATR Trail flip to short — {{ticker}} @ {{close}}")

// ── VISUALS ─────────────────────────────────────────────
plot(trail,  "ATR Trailing Stop", color=upTrend ? color.green : color.red, linewidth=2)
plot(emaVal, "EMA Trend Filter",  color=color.new(color.blue, 50), linewidth=1)

plotshape(longCond,  location=location.belowbar, color=color.green,
     style=shape.triangleup,   size=size.small, text="L")
plotshape(shortCond, location=location.abovebar, color=color.red,
     style=shape.triangledown, size=size.small, text="S")

If you'd rather skip writing hundreds of lines manually, Try PineGen AI, which converts natural language into Pine Script.

Bollinger Band Squeeze Breakout with Volume Confirmation

PineGen AI — Tue, 30 Jun 2026 06:36:35 +0000

A volatility contraction often precedes a volatility expansion. When Bollinger Bands narrow significantly, it signals that the market has entered a period of low energy, and low energy rarely lasts. This strategy is built around that principle: it waits for a genuine squeeze, then enters only when price breaks out of the bands with volume confirming that the move has real participation behind it, not just noise.

The logic

A squeeze is identified when the Bollinger Band width (the distance between the upper and lower bands relative to price) falls below its own recent average,meaning volatility is unusually compressed compared to the recent past. Once that condition is met, the strategy watches for price to close outside either band. A long entry triggers when price closes above the upper band during a squeeze, confirmed by volume exceeding its 20-period average. A short entry triggers under the mirrored condition on the lower band. Stops and targets are based on ATR, since the appropriate distance for both should scale with the market's actual movement at the time of entry, not a fixed number.

This approach tends to filter out the false breakouts that occur during already-volatile, choppy conditions, since the entry only fires after a genuine period of compression, which is when breakouts have historically had more follow-through.

Notes on use

The squeeze threshold and lookback length are the two inputs worth tuning per instrument, a 50-period lookback works reasonably well on daily and 4-hour charts, but lower timeframes may benefit from a shorter lookback to react faster to genuine volatility shifts. As with any breakout strategy, backtest across both trending and range-bound periods before drawing conclusions, since this approach is built specifically to perform during regime transitions and may underperform in markets that stay range-bound for extended periods without ever truly compressing.

This is shared for educational and discussion purposes. As always, backtest thoroughly on your own instruments and timeframes, and treat this as a starting framework rather than a finished system. Feedback and variations are welcome in the comments.

PineScript Version 6 Strategy

//@version=6
strategy("Bollinger Squeeze Breakout + Volume", overlay=true,
     default_qty_type=strategy.percent_of_equity, default_qty_value=10)

// ── INPUTS ─────────────────────────────────────────────
bbLen      = input.int(20,    "BB Length",            group="Bollinger Bands")
bbMult     = input.float(2.0, "BB StdDev Multiplier",  group="Bollinger Bands", step=0.1)
squeezeLen = input.int(50,    "Squeeze Lookback",      group="Squeeze")
squeezePct = input.float(0.8, "Squeeze Threshold (x avg width)", group="Squeeze", step=0.05)
volLen     = input.int(20,    "Volume MA Length",      group="Volume")
atrLen     = input.int(14,    "ATR Length",            group="Risk")
slMult     = input.float(1.5, "Stop ATR Multiplier",   group="Risk", step=0.1)
tpMult     = input.float(3.0, "Target ATR Multiplier", group="Risk", step=0.1)

// ── BOLLINGER BANDS ─────────────────────────────────────
[bbMid, bbUpper, bbLower] = ta.bb(close, bbLen, bbMult)
bbWidth   = (bbUpper - bbLower) / bbMid
avgWidth  = ta.sma(bbWidth, squeezeLen)
inSqueeze = bbWidth < (avgWidth * squeezePct)

// ── VOLUME & VOLATILITY ─────────────────────────────────
volPass = volume > ta.sma(volume, volLen)
atrVal  = ta.atr(atrLen)

// ── ENTRY CONDITIONS ─────────────────────────────────────
wasSqueezed = inSqueeze[1]
longCond  = wasSqueezed and ta.crossover(close, bbUpper)  and volPass and strategy.position_size == 0
shortCond = wasSqueezed and ta.crossunder(close, bbLower) and volPass and strategy.position_size == 0

// ── RISK LEVELS ──────────────────────────────────────────
longSL  = close - atrVal * slMult
longTP  = close + atrVal * tpMult
shortSL = close + atrVal * slMult
shortTP = close - atrVal * tpMult

// ── EXECUTION ────────────────────────────────────────────
if longCond
    strategy.entry("Long", strategy.long)
    strategy.exit("Long Exit", "Long", stop=longSL, limit=longTP)

if shortCond
    strategy.entry("Short", strategy.short)
    strategy.exit("Short Exit", "Short", stop=shortSL, limit=shortTP)

// ── VISUALS ──────────────────────────────────────────────
plot(bbUpper, "Upper Band", color=color.gray)
plot(bbLower, "Lower Band", color=color.gray)
plot(bbMid,   "Basis",      color=color.new(color.gray, 50))

bgcolor(inSqueeze ? color.new(color.yellow, 90) : na)

plotshape(longCond,  location=location.belowbar, color=color.green,
     style=shape.triangleup,   size=size.small, text="Squeeze↑")
plotshape(shortCond, location=location.abovebar, color=color.red,
     style=shape.triangledown, size=size.small, text="Squeeze↓")

// ── ALERTS ───────────────────────────────────────────────
alertcondition(longCond,  "Squeeze Breakout Long",  "Bollinger squeeze breakout — long entry on {{ticker}} @ {{close}}")
alertcondition(shortCond, "Squeeze Breakout Short", "Bollinger squeeze breakout — short entry on {{ticker}} @ {{close}}")

If you'd rather skip writing hundreds of lines manually, Try PineGen AI, which converts natural language into Pine Script.

Trend Persistence Analysis Framework (PineGen AI)

PineGen AI — Mon, 22 Jun 2026 13:56:34 +0000

Overview

Many trend-based strategies focus on identifying direction. This framework takes a different approach by studying how long a trend remains intact before signs of deterioration appear.

Rather than asking whether a market is moving up or down, the objective is to measure trend persistence and evaluate whether the current trend continues to maintain its structure over time.

This framework combines trend direction, trend duration, and volatility-based risk management into a rules-based testing model.

Core Idea

A trend often develops through a series of higher highs and higher lows during an uptrend, or lower highs and lower lows during a downtrend.

The framework tracks whether the trend remains intact and only considers opportunities when persistence conditions continue to be met.

The goal is to study periods where market direction remains consistent over multiple bars rather than reacting to every short-term fluctuation.

Strategy Logic

Trend Identification
The framework uses a combination of fast and slow moving averages to establish market direction.

Persistence Measurement
A trend is considered persistent when:

The fast moving average remains above the slow moving average during an uptrend.
The fast moving average remains below the slow moving average during a downtrend.
Trend alignment remains intact for a minimum number of bars.

Entry Conditions

Long opportunities are evaluated when:

Uptrend conditions exist.
Trend persistence exceeds the minimum threshold. Short opportunities are evaluated when:
Downtrend conditions exist.
Trend persistence exceeds the minimum threshold.

Risk Management

The strategy uses ATR-based stop-loss and target levels to adapt to changing market volatility.

Why Study Trend Persistence?

Market Context
Trend persistence can provide additional information about the stability of a move.
Reduced Noise
By requiring trends to remain intact for a period of time, the framework avoids reacting to every short-term change in direction.
Research and Testing
The model provides a structured way to analyze trend behavior across different symbols and timeframes.

Notes

This framework is intended as an educational example demonstrating one approach to studying trend duration and trend quality.
Trend persistence does not predict future price movement and should be evaluated across different market environments.

Disclaimer

This script is provided for educational and research purposes only. It demonstrates one way to study trend persistence using Pine Script. Results will vary across symbols, timeframes, and market conditions. Independent testing is recommended before incorporating any methodology into a trading workflow.

Pine Script v6 Strategy

//@version=6
strategy("Trend Persistence Analysis Framework", 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")
minTrendBars = input.int(10, "Minimum Trend Duration")
atrLen = input.int(14, "ATR Length")
atrMult = input.float(1.5, "Stop ATR Multiplier")
rr = input.float(2.0, "Risk Reward")

// Trend Calculation
fastEMA = ta.ema(close, fastLen)
slowEMA = ta.ema(close, slowLen)

// Trend State
bullTrend = fastEMA > slowEMA
bearTrend = fastEMA < slowEMA

// Persistence Counters
var int bullBars = 0
var int bearBars = 0

bullBars := bullTrend ? bullBars + 1 : 0
bearBars := bearTrend ? bearBars + 1 : 0

// Entry Conditions
longCondition = bullTrend and bullBars >= minTrendBars
shortCondition = bearTrend and bearBars >= minTrendBars

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

// ATR 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(fastEMA, title="Fast EMA", color=color.orange)
plot(slowEMA, title="Slow EMA", color=color.blue)

What Is the Best AI for Pine Script?

PineGen AI — Thu, 18 Jun 2026 11:13:50 +0000

What Is the Best AI for Pine Script?

The best AI for Pine Script is not always the most popular chatbot or code assistant—it’s the one that understands TradingView scripting deeply and delivers results tailored to traders' needs. While some developers use ChatGPT or GitHub Copilot, these tools often fall short when it comes to Pine Script's structure, strategy requirements, and version compatibility.

Instead, developers are gravitating toward dedicated Pine Script AI generators. These tools are specifically trained to handle Pine Script syntax, logic, and real-world use cases—enabling you to go from strategy idea to working code in seconds.

Why Is AI Becoming Popular for Pine Script Development?

Pine Script is powerful but not always beginner-friendly. Whether you're building a simple RSI-based indicator or a multi-timeframe strategy, even small coding mistakes can throw off your logic—or worse, your trade execution.

That’s why AI-based Pine Script generators are gaining traction. These platforms allow you to:

Quickly test new ideas without manually coding
Generate working strategies from natural language
Reduce the trial-and-error phase
Accelerate backtesting and refinement

Three Types of AI Tools People Use for Pine Script

Not all AI tools are created equal. Here’s how they break down:

1. General-Purpose AI Chatbots

Models like ChatGPT can assist with Pine Script if prompted carefully, but they aren't trained exclusively on Pine Script. While helpful for learning, their output often includes errors, outdated syntax, or long-winded explanations rather than usable code.

2. Code-Centric Assistants

GitHub Copilot and similar tools can autocomplete code but lack contextual understanding of Pine Script. Their usefulness drops significantly when trying to generate complex strategy logic or combine indicators.

3. Pine Script–Specific AI Tools (e.g., PineGen AI)

Tools like PineGen AI are built exclusively for Pine Script v6. Instead of trying to serve every use case, these platforms focus on one thing: turning trading ideas into Pine Script code.

Why PineGen AI Stands Out Among Pine Script Tools

One of the standout solutions in this space is PineGen AI, a dedicated code generator that accepts plain English prompts and returns ready-to-use Pine Script.

With PineGen AI, you don’t need to understand ta.ema(), strategy.exit() parameters, or how to combine plotshape() with logical conditions. You simply describe your idea, such as:

“Build a strategy using 20 EMA crossover above 50 EMA with 1.5% stop loss and RSI confirmation below 70.”

And receive clean, copy-pasteable code in return.

It’s designed specifically for:

✅ Strategy generation

✅ Custom indicators

✅ Alert scripts

✅ Risk management logic

✅ Multi-timeframe compatibility

And most importantly—it generates code only. It doesn’t try to write articles, generate financial advice, or drift into unrelated domains. That focus on Pine Script code generation is what makes it so effective.

Use Case: From Prompt to Pine Script in Seconds

Prompt:

“Create a simple momentum-based long strategy using RSI crossing above 30 and price above the 50 EMA. Add a 2% take profit and 1% stop loss.”

Output from a specialized AI like PineGen AI:

//@version=6

strategy("RSI Momentum Strategy", overlay=true)

rsi = ta.rsi(close, 14)

ema50 = ta.ema(close, 50)

longCondition = rsi > 30 and close > ema50

if (longCondition)

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

strategy.exit("Exit", from_entry="Long", stop=close * 0.99, limit=close * 1.02)

plot(ema50, color=color.orange)

This type of precision and usability is hard to get with general-purpose AI tools.

What Should You Look for in a Pine Script AI Tool?

If you're evaluating your options, here are key features that define a great Pine Script generator:

⚡ Fast response time

🧠 Understands trading logic clearly

✅ Outputs error-free Pine Script v5 code

📊 Handles both indicators and strategies

✍️ Clean formatting and comments

🔒 No fluff—just code

PineGen AI checks all these boxes by design, helping both beginner traders and seasoned coders get more done in less time.

Benefits of Using PineGen AI (and Similar Tools)

Time-efficient: Skip boilerplate code and go straight to testing.

Customizable: Tweak prompts for different assets, timeframes, or setups.

No coding required: Ideal for traders who want to automate without learning a full language.

Backtest-ready: Easily load code into TradingView’s Strategy Tester.

Focused: Doesn’t try to blog, summarize, or chat—just generates Pine Script.

Final Thoughts: Choose Tools That Specialize in Pine Script

With so many AI tools on the market, it’s easy to get overwhelmed. But if your goal is to write or test Pine Script code—don’t settle for general-purpose AI.

Tools like PineGen AI represent a new wave of highly specialized, results-driven AI that aligns perfectly with the needs of modern traders and script developers.

The next time you have a strategy idea, skip the blank editor. Just type your prompt into PineGen AI and get to testing.

Multi-Timeframe Trend Alignment Framework (PineGen AI)

PineGen AI — Mon, 15 Jun 2026 07:50:54 +0000

Overview

Markets can look completely different depending on the timeframe being analyzed. A trend that appears strong on a 15-minute chart may simply be a pullback on a 4-hour chart.

This framework explores how multiple timeframes can be combined to provide additional market context. Instead of relying on a single chart, the approach examines higher-timeframe direction while using the current timeframe for trade identification.

The goal is to create a structured process for studying trend alignment across different market conditions.

Core Idea

The framework separates market analysis into different layers:

Higher Timeframe
The higher timeframe is used to establish the broader market direction.
Examples:

Daily trend
4-Hour trend
1-Hour trend This helps identify whether the market is generally moving upward, downward, or sideways.

Current Timeframe
The current timeframe is used to identify opportunities that align with the broader trend.
Rather than treating every signal equally, the framework studies signals that occur in the same direction as the higher-timeframe trend.

Lower Timeframe (Optional)
Some traders use lower timeframes for additional timing and execution analysis.
The lower timeframe does not determine market direction but may provide additional detail about short-term price behavior.

Framework Logic

Step 1: Define Trend Direction
A moving average or other trend measure is used to identify the direction of the higher timeframe.

Step 2: Confirm Alignment
The current timeframe is compared against the higher timeframe.
When both point in the same direction, the market is considered aligned.

Step 3: Evaluate Opportunities
Signals are evaluated only when alignment exists between the selected timeframes.

Step 4: Manage Risk
Risk parameters should be defined independently of trend direction and adjusted according to market volatility.

Why Traders Study Trend Alignment

Additional Market Context
Multiple timeframes can provide a broader view of market structure.

Structured Decision-Making
The framework encourages consistency by defining market direction before evaluating potential entries.

Cross-Market Application
The concept can be applied to:

Stocks
Forex
Cryptocurrencies
Indexes
Commodities

Notes

Trend alignment does not guarantee future price movement. Different markets and timeframes may behave differently, and alignment can change as new price data becomes available.
This framework is intended as a research and educational tool for studying multi-timeframe trend behavior.

Disclaimer

This framework is provided for educational and research purposes only. It demonstrates one way to analyze trend relationships across multiple timeframes and should be independently tested before being incorporated into any trading workflow.

Pine Script Strategy (version 6)

//@version=6
strategy("Multi-Timeframe Trend Alignment Framework", overlay=true, initial_capital=100000, default_qty_type=strategy.percent_of_equity, default_qty_value=5)

// Inputs
higherTF = input.timeframe("240", "Higher Timeframe")
fastLen = input.int(20, "Fast EMA")
slowLen = input.int(50, "Slow EMA")
htfLen = input.int(200, "Higher TF EMA")
atrLen = input.int(14, "ATR Length")
atrMult = input.float(1.5, "Stop ATR Multiplier")
rr = input.float(2.0, "Risk Reward")

// Current Timeframe EMAs
fastEMA = ta.ema(close, fastLen)
slowEMA = ta.ema(close, slowLen)

// Higher Timeframe Trend
htfEMA = request.security(
     syminfo.tickerid,
     higherTF,
     ta.ema(close, htfLen),
     lookahead = barmerge.lookahead_off
)

// Trend Alignment
bullTrend = close > htfEMA
bearTrend = close < htfEMA

// Cross Signals
bullCross = ta.crossover(fastEMA, slowEMA)
bearCross = ta.crossunder(fastEMA, slowEMA)

// Entry Conditions
longCondition = bullTrend and bullCross
shortCondition = bearTrend and bearCross

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

// ATR 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(fastEMA, color=color.orange, title="Fast EMA")
plot(slowEMA, color=color.blue, title="Slow EMA")
plot(htfEMA, color=color.green, title="Higher Timeframe EMA", linewidth=2)

Fair Value Gap (FVG) Continuation Framework

PineGen AI — 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

PineGen AI — 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

PineGen AI — 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

PineGen AI — 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)

PineGen AI — 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

PineGen AI — 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)