Custom Monthly Volume Profile [Multi-Timeframe]This indicator renders a high-precision Monthly Volume Profile designed for intraday traders and practitioners of Auction Market Theory. Unlike standard volume profiles, this script utilizes Multi-Timeframe (MTF) data request capability to build the profile from lower timeframe data (e.g., 5-minute bars) while displaying it on your trading timeframe.
This tool is optimized to keep your chart clean while providing critical developing levels (POC, VAH, VAL) and historical context from the previous month.
Key Features:
1. Dynamic "Auto-Scaling" Width One of the biggest issues with monthly profiles is visual clutter.
Early Month: The profile starts wide (default 10% width) so you can clearly see the developing structure when data is scarce.
Late Month: As volume accumulates, the profile automatically shrinks (scales down to 2% width) to prevent the histogram from obscuring price action.
Note: This can be toggled off for a static width.
2. Developing & Static Levels
Current Month: Displays real-time Developing Point of Control (dPOC), Value Area High (dVAH), and Value Area Low (dVAL).
Previous Month: Automatically locks in the levels from the previous month at the close, providing immediate support/resistance references for the new month.
3. Time-Filtered Alerts Avoid waking up to notifications during low-volume overnight sessions. This script includes a Session Filter (Default: 0830-1500).
Alerts for crossing POC, VAH, or VAL will only trigger if the price cross occurs within the user-defined time window.
4. Calculation Precision
Multi-Timeframe Data: The profile is built using lower timeframe data (Input: Calculation Precision) rather than just the current chart bars. This ensures the Volume Profile shape remains accurate even when viewing higher timeframes.
Row Size: Fully adjustable "Tick/Row Size" to control the resolution of the volume buckets.
Settings Overview:
Calculation Precision: Determine the granularity of the data (e.g., "5" for 5-minute data).
Row Size: Controls vertical resolution (Lower = higher detail).
Value Area %: Standard 70% default, fully adjustable.
Auto-Width: Set the Start % (Day 1) and End % (Day 31).
Alerts: Toggle Current or Previous month alerts and define the active time session.
Visual Customization:
Customize colors for the Histogram (Value Area vs. Outer Area).
Customize line width and colors for POC, VAH, and VAL.
Supports Right or Left alignment.
Disclaimer: This tool is for informational purposes only. Past performance and volume levels do not guarantee future price action.
المؤشرات والاستراتيجيات
GVWAP_Core (CalendarSpan + EventSpike)GVWAP Core Indicator
General Description (Public)
GVWAP (Generalized Volume-Weighted Average Price) is an advanced anchoring and averaging framework designed to reveal market structure rather than predict price. Unlike traditional VWAP, GVWAP is not limited to volume weighting or session-based anchoring. It can operate on any input series (price, indicators, transforms) and supports multiple weighting schemes, decay behavior, and structural reset logic.
At its core, GVWAP answers a simple question: “Where is the statistically relevant center of activity since the last meaningful structural event?”
The indicator continuously updates a weighted average of the input series, gradually forgetting older data using exponential decay. The anchor point can reset on calendar boundaries (day, week, month, etc.) or on statistically significant events such as abnormal volume spikes. Robust dispersion bands based on mean absolute deviation (MAD) surround the average, providing context for trend, rotation, and compression regimes.
GVWAP is not a trading signal by itself. It is best used as a structural reference layer or as an intermediate transform feeding other indicators, strategies, or regime filters.
Mathematical Description (Quantitative)
Let x_t be an arbitrary input series and w_t a selectable weight function. GVWAP is defined as a normalized exponentially decayed weighted estimator:
GVWAP_t = N_t / D_t
with recursive updates:
N_t = (1 − α)·N_{t−1} + α·w_t·x_t
D_t = (1 − α)·D_{t−1} + α·w_t
where α = 1 − 2^(−1/H) and H is the decay half-life in bars.
Weights may be defined as:
• w_t = V_t (volume)
• w_t = 1 (equal weight)
• w_t = 1 / ATR_t (volatility-normalized)
• w_t = f(n_t) (time-weighted, where n_t is bars since reset)
The estimator resets when a structural condition R_t is satisfied, at which point:
N_t = w_t·x_t, D_t = w_t
For event-based anchoring, volume surprise is computed using a Student‑t–compressed z‑score:
z_t = (V_t − μ_V) / σ_V
tZ_t = z_t / sqrt(1 + z_t² / ν)
A reset occurs when tZ_t exceeds a threshold τ.
Dispersion is measured via a decayed Mean Absolute Deviation:
MAD_t = (Σ λ^{t−i} w_i |x_i − GVWAP_t|) / (Σ λ^{t−i} w_i)
Bands are defined as GVWAP_t ± k·MAD_t.
GVWAP therefore represents a bounded-memory, robust, non‑Gaussian estimator of the local conditional expectation of x_t under dynamic anchoring and weighting.
Fair Value Gap WindowStupid little toy I made to get my toes back in the water. How does this work?
Detects fair value gaps up to the count you specify in the settings
Plots them on the chart if they are inside of the 2 lines (top and bottom)
If the fair value gap is partially outside of the "window", it will only draw the part of it thats inside the window.
Not really useful but if you wanna take a look at the code for practice for yourself, feel free I guess haha
XAUUSD Session Move Stats (Last 14 Days)This indicator analyzes Gold (XAUUSD) session behavior over the last 14 days and calculates how price typically moves during the Asia, London, and New York sessions.
For each session, it shows:
Average Max Up (%) – how far price moves up from session open
Average Max Down (%) – how far price moves down from session open
Average Net Close (%) – where price typically finishes relative to the session open
The data is calculated session-by-session and displayed in a table, helping traders understand session bias, volatility tendencies, and directional behavior.
Best used on intraday timeframes for session-based analysis and contextual trade planning (signals only, no automated trades).
Single Prints and Poor Highs/Lows [Real-Time]This indicator is designed for traders utilizing Auction Market Theory (AMT) who need real-time visibility into market structure inefficiencies. Unlike standard TPO tools that often wait for closed bars or finished sessions, this script builds a developing TPO profile tick-by-tick to identify Single Prints and Poor Highs/Lows the moment they form.
Key Features:
Real-Time Single Prints: Automatically detects and highlights areas of single-print inefficiencies (buying/selling tails) as they happen. These "ghost" boxes persist on the chart until price repairs (fills) them, acting as immediate targets or support/resistance zones.
Poor High/Low Detection: Strictly implements AMT logic to identify "unfinished" auctions. If a session extreme is formed by two or more TPO blocks (indicating a flat top/bottom rather than a rejection tail), it marks the level with a dotted line.
Repair Logic: Both Single Prints and Poor High/Low lines are dynamic. If price revisits and repairs the structure, the markers automatically vanish to keep your chart clean.
Session Control: Fully customizable RTH (Regular Trading Hours) session input (default 08:30–15:15) to ensure profiles are built on relevant liquidity.
Quantization: Adjustable "Ticks per Block" allowing you to tune the sensitivity of the TPO profile to different assets (ES, NQ, CL, etc.).
How It Works:
TPO Construction: The script breaks the session into 30-minute periods (configurable) and tracks price overlap.
Single Prints: When the market expands rapidly, leaving gaps in the profile (single TPO blocks), a box is drawn. If price trades back through this box, it deletes itself.
Poor Extremes: It monitors the current session High and Low. If the extreme price level has a TPO count of ≥ 2, it is flagged as "Poor." If the extreme is a single print (count = 1), it is considered a valid tail and left unmarked.
Settings:
RTH Session: Define your specific trading session time.
TPO Period: Default is 30 minutes (standard AMT).
Ticks per Block: Controls the vertical resolution of the TPO. (Higher values = coarser profile, Lower values = more precision).
Colors: Fully customizable colors for Live Prints, Historical Prints, and Poor High/Low lines.
Usage:
Use this tool to spot immediate structural targets. A Poor High often acts as a magnet for price to revisit and "repair," while Single Prints often defend as support/resistance on the first retest.
Peter Lynch Value (Dynamic Growth)This indicator implements Peter Lynch's core valuation principle: Fair Price = Earnings Per Share (EPS) * Growth Rate.
It provides a dynamic "fair value" line overlaid on the price chart, allowing traders and investors to quickly assess whether a stock's current price is trading above or below its intrinsic value according to the Lynch method.
Key Features
1. Dynamic Growth Rate Calculation
The indicator uses a custom algorithm to calculate the critical EPS Growth Rate, making it robust against missing data from standard financial fields.
Methodology: It fetches historical TTM Diluted EPS reports (EARNINGS_PER_SHARE_DILUTED, TTM) and calculates the Year-over-Year (YoY) Growth Percentage from the current TTM value versus the TTM value 4 periods prior.
Reliability: This custom calculation ensures the value line appears even when TradingView's pre-calculated growth metrics are unavailable (na).
2. Multiplier Control
P/E Cap: You can enforce a maximum P/E multiplier (maxPE, default 25), preventing the fair value from becoming unrealistically high for extremely fast-growing companies (as Lynch suggested).
Fallback P/E: If insufficient financial history is available to calculate the growth rate, the indicator automatically switches to a user-defined fallbackPE (default 15) and highlights the line in orange as a warning.
3. Smoothing (Optional)
To reduce the volatility often seen in valuation metrics, you can apply an optional Simple Moving Average (SMA) to the Fair Value line. This helps visualize the underlying trend of intrinsic value.
4. Forward Estimate (Optional)
Display an optional projection (circles) based on the analysts' next Fiscal Year EPS Estimate (EARNINGS_ESTIMATE, FY). This shows the potential fair value if the company meets future expectations.
5. Diagnostic Table
A table in the corner provides transparency on the calculation:
Green/Red: Confirms if TTM EPS and Calculated Growth are found.
Final P/E Used: Shows the exact multiplier used (calculated growth or the manual fallback).
Disclaimer: This tool is for informational and educational purposes only and should not be considered financial advice.
Early Momentum Dashboard [Small Caps]Early Momentum Dashboard for Small Caps
A clean, real-time dashboard that detects building momentum before major moves in small-cap stocks.
Features:
• 7 key early-momentum indicators with traffic-light system (🟢 Bullish / 🟡 Neutral / 🔴 Bearish)
• Toggle each indicator on/off via settings
• Momentum Score (e.g., 5/7) – higher = stronger early signal
• Visual markers on chart (VOL, RSI, MACD)
• Includes: Relative Volume Spike, RSI Buildup, MACD, OBV Accumulation, ROC, ATR Volatility, VWAP Proximity
Ideal for scanning low-float or catalyst-driven small caps.
Tip: Look for 4+ green lights as a high-probability early entry signal.
Enjoy!
ATR Trailing StopATR Trailing Stop (Dynamic Volatility Regimes)
==============================================
This indicator implements an adaptive ATR-based trailing stop for long positions. The stop automatically adjusts based on stock volatility, tightening during fast movements and widening during calm periods. It is designed as a trade management tool to help protect profits while staying aligned with strong trends.
How It Works
------------
* Tracks the highest high over a configurable lookback window and ensures this “top” never moves downward.
* Computes the trailing stop as:**Top – ATR × Dynamic Multiplier**
* The ATR multiplier changes depending on volatility:
* Low volatility → Wide stop (slower trailing)
* Medium volatility → Standard trailing
* High volatility → Tight stop (faster trailing)
* The trailing stop only moves upward; it never decreases.
* If price falls significantly below the stop (default: 5%), the system resets and begins trailing from a new top.
* An optional price-scale label displays:
* Current stop value
* Volatility regime (LOW / MID / HIGH)
* ATR percentage and active multiplier
Alerts
------
Two alert conditions are included:
### Trailing Stop – Near
Triggers when price moves within a user-defined percentage above the stop.
### Trailing Stop – Hit
Triggers when price touches or closes below the stop.
How to Use
----------
1. Add the indicator to any chart (daily timeframe recommended).
2. Configure:
* ATR length
* Lookback bars
* Volatility thresholds
* ATR multipliers
3. Set alerts for early warnings or stop-hit events.
4. Use the stop line as a dynamic risk-management tool to guide exit decisions and protect profits.
Notes
-----
* Designed for long-only trailing logic.
* This indicator does not generate entry signals; it is intended for stop management.
Volatility High/Low Projection (PHOD / PLOD)AP Capital – Volatility + High/Low Projection
This indicator is designed to identify high-probability intraday turning points by combining daily range statistics, session behaviour, and volatility context into a single clean framework.
It is built for index, forex, and metals traders who want structure, not noise.
🔹 Core Features
1️⃣ Potential High of Day (PHOD) & Potential Low of Day (PLOD)
The indicator highlights likely intraday extremes based on:
Session timing (Asia, London, New York)
Current day volatility vs historical averages
Prior day expansion or compression behaviour
Each level is displayed with:
A clear label (PHOD / PLOD)
A forward-extending box acting as a live Point of Interest (POI)
Automatic invalidation when price breaks the zone
2️⃣ Volatility & Range Context (Info Panel)
A compact information panel in the top-right corner provides real-time context without cluttering the chart:
20-Day Average Range
% of the average range already used today
Range status (NORMAL / EXHAUSTED)
Average session ranges for:
Asia
London
New York
This allows traders to immediately assess whether price is:
Early in the day with room to trend
Statistically stretched and prone to reversal
Over-extended where breakout chasing is risky
3️⃣ Session-Aware Logic
The model respects how markets behave across the trading day:
Asia favours accumulation and potential lows
London provides expansion
New York often delivers distribution or exhaustion
This prevents random high/low marking and focuses only on structurally meaningful levels.
🧠 How to Use
Use PHOD / PLOD boxes as reaction zones, not blind entries
Combine with your own confirmation (structure break, momentum, volume, EMA reclaim, etc.)
Avoid chasing trades when the Range Status = EXHAUSTED
Particularly effective on 15m – 1h timeframes
⚠️ Important Notes
This indicator does not repaint
It is contextual, not a buy/sell signal generator
Best used as part of a complete trading plan
📈 Suitable Markets
XAUUSD (Gold)
Indices (NASDAQ, S&P 500, DAX)
Major FX pairs
📌 Disclaimer
This indicator is for educational and analytical purposes only.
It does not constitute financial advice. Trading involves risk.
RCI4linesRCI4lines plots four Rank Correlation Index (RCI) lines in a single panel to help you read momentum and trend conditions at a glance.
It shows two short-term RCIs (default: 7 and 9), a middle-term RCI (26), and a long-term RCI (52).
The script also draws shaded threshold zones between +80 to +95 and -80 to -95, making it easier to spot potential overbought / oversold areas and compare short-term moves with the bigger trend.
Useful for scalping to day trading, and for checking whether short-term momentum is aligned with mid/long-term direction.
Hicham tight/wild rangeHere’s a complete Pine Script indicator that draws colored boxes around different types of ranges!
Main features:
📦 Types of ranges detected:
Tight Range (30–60 pips): Gray boxes
Wild Range (80+ pips): Yellow boxes
UK100 London Judas & IFVG SetupUK100 London Judas & IFVG Setup
Overview This indicator is a specialized trading tool designed to automate the ICT Judas Swing strategy specifically for the UK100 (FTSE 100) index during the London Market Open. It combines institutional time-based logic with price action confirmation using Inversion Fair Value Gaps (IFVG) to identify high-probability reversal setups.
How It Works The strategy is based on the concept that the initial move after the London Open is often a "fake-out" (manipulation) designed to trap retail traders and engineer liquidity before the true trend of the day begins.
Session & Opening Price:
The script marks the London Open price (default 09:00 Warsaw / 08:00 London time) with a dashed line.
This serves as the "line in the sand." Prices moving away from this line initially are monitored for manipulation.
Judas Swing (Liquidity Sweep):
If price moves BELOW the open, it is hunting Sell-Side Liquidity (trapping sellers).
If price moves ABOVE the open, it is hunting Buy-Side Liquidity (trapping buyers).
The Entry Trigger: Inversion FVG (IFVG):
The indicator scans for Fair Value Gaps (FVG) created during the manipulation phase.
BUY Signal: The price manipulates lower, creates a Bearish FVG (Red Box), but then aggressively reverses and closes ABOVE that gap. The gap is now "Inverted" (turns Green), acting as support.
SELL Signal: The price manipulates higher, creates a Bullish FVG (Green Box), but then aggressively reverses and closes BELOW that gap. The gap is now "Inverted" (turns Orange), acting as resistance.
Key Features
Automated Pattern Recognition: No need to manually draw gaps. The script detects valid FVG inversions that align with the Judas Swing logic.
Built-in Risk Calculator: The signal labels display the exact Lot Size you should use based on your account balance and risk percentage (default 0.5%). It calculates this dynamically based on the Stop Loss distance.
Institutional Targets: The indicator fetches H1 Fractals (Liquidity) from the 1-hour timeframe and plots them on your 1-minute chart as blue lines. These are your primary Take Profit (TP) levels.
Stop Loss Visualization: Automatically suggests a Stop Loss placement behind the swing high/low of the reversal structure.
How to Use
Timeframe: Set your chart to 1 Minute (1m).
Asset: UK100 (FTSE 100).
Wait: Allow the London session to open. Watch for price to move away from the opening line.
Execute: When a BUY or SELL label appears:
Enter the trade using the Lot Size shown on the label.
Set your Stop Loss at the price shown on the label.
Target the blue H1 Liquidity lines for profit taking.
Settings
Timezone: Set this to your chart/exchange timezone (Default: Europe/Warsaw).
Account Balance: Input your current trading capital (e.g., 100,000) for accurate risk calculations.
Risk Per Trade %: The percentage of your account you are willing to lose if the Stop Loss is hit (Standard: 0.5% - 1.0%).
Contract Size: The value of 1 point movement (Check your broker's specifications. Usually 1 for CFDs).
Alerts You can set a single alert in TradingView to capture all signals. Select the indicator and choose "Any alert() function call". You will receive a notification with the direction (Buy/Sell), Entry Price, and Lot Size.
PCR Put-Call Ratio//@version=5
indicator("PCR Put-Call Ratio", overlay=false, precision=4)
// Input parameters
pcrLength = input(20, "PCR Length", group="Settings")
maLength = input(5, "MA Length", group="Settings")
showOI = input(true, "Use Open Interest", group="Settings")
// Get PCR data from CBOE (requires daily data availability)
pcrData = request.security("CBOE:PC", "D", close)
// Calculate moving average of PCR
pcrMA = ta.sma(pcrData, maLength)
// Levels for interpretation
overbought = 1.2
oversold = 0.6
neutral = 0.9
// Plot PCR value
plot(pcrData, title="PCR Value", color=color.blue, linewidth=2)
plot(pcrMA, title="PCR MA", color=color.orange, linewidth=1)
// Add reference lines
hline(overbought, "Overbought (Bearish)", color.red, linestyle=hline.style_dashed)
hline(neutral, "Neutral", color.gray, linestyle=hline.style_dotted)
hline(oversold, "Oversold (Bullish)", color.green, linestyle=hline.style_dashed)
// Background coloring based on sentiment
bgColor = pcrData > overbought ? color.new(color.red, 80) :
pcrData < oversold ? color.new(color.green, 80) :
color.new(color.gray, 90)
bgcolor(bgColor)
Pro trade by Amit// This work is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC BY-NC-SA 4.0) creativecommons.org
//@version=5
import HeWhoMustNotBeNamed/utils/1 as ut
import Trendoscope/ohlc/1 as o
import Trendoscope/LineWrapper/1 as wr
import Trendoscope/ZigzagLite/2 as zg
import Trendoscope/abstractchartpatterns/5 as p
import Trendoscope/basechartpatterns/6 as bp
indicator("Installing Wait....", "Automatic Chart Pattern", overlay = true, max_lines_count=500, max_labels_count=500, max_polylines_count = 100)
openSource = input.source(open, '', inline='cs', group='Source', display = display.none)
highSource = input.source(high, '', inline='cs', group='Source', display = display.none)
lowSource = input.source(low, '', inline='cs', group='Source', display = display.none)
closeSource = input.source(close, '', inline='cs', group='Source', display = display.none, tooltip = 'Source on which the zigzag and pattern calculation is done')
useZigzag1 = input.bool(true, '', group = 'Zigzag', inline='z1', display = display.none)
zigzagLength1 = input.int(8, step=5, minval=1, title='', group='Zigzag', inline='z1', display=display.none)
depth1 = input.int(55, "", step=25, maxval=500, group='Zigzag', inline='z1', display=display.none, tooltip = 'Enable and set Length and Dept of Zigzag 1')
useZigzag2 = input.bool(false, '', group = 'Zigzag', inline='z2', display = display.none)
zigzagLength2 = input.int(13, step=5, minval=1, title='', group='Zigzag', inline='z2', display=display.none)
depth2 = input.int(34, "", step=25, maxval=500, group='Zigzag', inline='z2', display=display.none, tooltip = 'Enable and set Length and Dept of Zigzag 2')
useZigzag3 = input.bool(false, '', group = 'Zigzag', inline='z3', display = display.none)
zigzagLength3 = input.int(21, step=5, minval=1, title='', group='Zigzag', inline='z3', display=display.none)
depth3 = input.int(21, "", step=25, maxval=500, group='Zigzag', inline='z3', display=display.none, tooltip = 'Enable and set Length and Dept of Zigzag 3')
useZigzag4 = input.bool(false, '', group = 'Zigzag', inline='z4', display = display.none)
zigzagLength4 = input.int(34, step=5, minval=1, title='', group='Zigzag', inline='z4', display=display.none)
depth4 = input.int(13, "", step=25, maxval=500, group='Zigzag', inline='z4', display=display.none, tooltip = 'Enable and set Length and Dept of Zigzag 4')
numberOfPivots = input.int(5, "Number of Pivots", , 'Number of pivots used for pattern identification.', group='Scanning', display = display.none)
errorThresold = input.float(20.0, 'Error Threshold', 0.0, 100, 5, 'Error Threshold for trend line validation', group='Scanning', display = display.none)
flatThreshold = input.float(20.0, 'Flat Threshold', 0.0, 30, 5, 'Ratio threshold to identify the slope of trend lines', group='Scanning', display = display.none)
lastPivotDirection = input.string('both', 'Last Pivot Direction', , 'Filter pattern based on the last pivot direction. '+
'This option is useful while backtesting individual patterns. When custom is selected, then the individual pattern last pivot direction setting is used',
group='Scanning', display=display.none)
checkBarRatio = input.bool(true, 'Verify Bar Ratio ', 'Along with checking the price, also verify if the bars are proportionately placed.', group='Scanning', inline = 'br', display = display.none)
barRatioLimit = input.float(0.382, '', group='Scanning', display = display.none, inline='br')
avoidOverlap = input.bool(true, 'Avoid Overlap', group='Scanning', inline='a', display = display.none)
repaint = input.bool(false, 'Repaint', 'Avoid Overlap - Will not consider the pattern if it starts before the end of an existing pattern '+
'Repaint - Uses real time bars to search for patterns. If unselected, then only use confirmed bars.',
group='Scanning', inline='a', display = display.none)
allowChannels = input.bool(true, 'Channels', group='Pattern Groups - Geometric Shapes', display = display.none, inline='g')
allowWedges = input.bool(true, 'Wedge', group='Pattern Groups - Geometric Shapes', display = display.none, inline='g')
allowTriangles = input.bool(true, 'Triangle', group='Pattern Groups - Geometric Shapes', display = display.none, inline='g',
tooltip = 'Channels - Trend Lines are parralel to each other creating equidistance price channels'+
' \t- Ascending Channel \t- Descending Channel \t- Ranging Channel'+
' Wedges - Trend lines are either converging or diverging from each other and both the trend lines are moving in the same direction'+
' \t- Rising Wedge (Expanding) \t- Rising Wedge (Contracting) \t- Falling Wedge (Expanding) \t- Falling Wedge (Contracting)'+
' Triangles - Trend lines are either converging or diverging from each other and both trend lines are moving in different directions'+
' \t- Converging Triangle \t- Diverging Triangle \t- Ascending Triangle (Contracting) \t- Ascending Triangle (Expanding) \t- Descending Triangle(Contracting) \t- Descending Triangle(Expanding)')
allowRisingPatterns = input.bool(true, 'Rising', group='Pattern Groups - Direction', display = display.none, inline = 'd')
allowFallingPatterns = input.bool(true, 'Falling', group='Pattern Groups - Direction', display = display.none, inline = 'd')
allowNonDirectionalPatterns = input.bool(true, 'Flat/Bi-Directional', group='Pattern Groups - Direction', display = display.none, inline = 'd',
tooltip = 'Rising - Either both trend lines are moving up or one trend line is flat and the other one is moving up.'+
' \t- Ascending Channel \t- Rising Wedge (Expanding) \t- Rising Wedge (Contracting) \t- Ascending Triangle (Expanding) \t- Ascending Triangle (Contracting)'+
' Falling - Either both trend lines are moving down or one trend line is flat and the other one is moving down.'+
' \t- Descending Channel \t- Falling Wedge (Expanding) \t- Falling Wedge (Contracting) \t- Descending Triangle (Expanding) \t- Descending Triangle (Contracting)'+
' Flat/Bi-Directional - Trend Lines move in different directions or both flat.'+
' \t- Ranging Channel \t- Converging Triangle \t- Diverging Triangle')
allowExpandingPatterns = input.bool(true, 'Expanding', group='Pattern Groups - Formation Dynamics', display = display.none, inline = 'f')
allowContractingPatterns = input.bool(true, 'Contracting', group='Pattern Groups - Formation Dynamics', display = display.none, inline='f')
allowParallelChannels = input.bool(true, 'Parallel', group = 'Pattern Groups - Formation Dynamics', display = display.none, inline = 'f',
tooltip = 'Expanding - Trend Lines are diverging from each other.'+
' \t- Rising Wedge (Expanding) \t- Falling Wedge (Expanding) \t- Ascending Triangle (Expanding) \t- Descending Triangle (Expanding) \t- Diverging Triangle'+
' Contracting - Trend Lines are converging towards each other.'+
' \t- Rising Wedge (Contracting) \t- Falling Wedge (Contracting) \t- Ascending Triangle (Contracting) \t- Descending Triangle (Contracting) \t- Converging Triangle'+
' Parallel - Trend Lines are almost parallel to each other.'+
' \t- Ascending Channel \t- Descending Channel \t- Ranging Channel')
allowUptrendChannel = input.bool(true, 'Ascending ', group = 'Price Channels', inline='uc', display = display.none)
upTrendChannelLastPivotDirection = input.string('both', '', , inline='uc', group='Price Channels', display = display.none,
tooltip='Enable Ascending Channel and select the last pivot direction filter. Last pivot direction will only be used if the Generic Last Pivot Direction parameter is set to Custom')
allowDowntrendChannel = input.bool(true, 'Descending', group = 'Price Channels', inline='dc', display = display.none)
downTrendChannelLastPivotDirection = input.string('both', '', , inline='dc', group='Price Channels', display = display.none,
tooltip='Enable Descending Channel and select the last pivot direction filter. Last pivot direction will only be used if the Generic Last Pivot Direction parameter is set to Custom')
allowRangingChannel = input.bool(true, 'Ranging ', group = 'Price Channels', inline='rc', display = display.none)
rangingChannelLastPivotDirection = input.string('both', '', , inline='rc', group='Price Channels', display = display.none,
tooltip='Enable Ranging Channel and select the last pivot direction filter. Last pivot direction will only be used if the Generic Last Pivot Direction parameter is set to Custom')
allowRisingWedgeExpanding = input.bool(true, 'Rising ', inline='rwe', group = 'Expanding Wedges', display = display.none)
risingWedgeExpandingLastPivotDirection = input.string('down', '', , inline='rwe', group='Expanding Wedges', display = display.none,
tooltip='Enable Rising Wedge (Expanding) and select the last pivot direction filter. Last pivot direction will only be used if the Generic Last Pivot Direction parameter is set to Custom')
allowFallingWedgeExpanding = input.bool(true, 'Falling ', inline='fwe', group = 'Expanding Wedges', display = display.none)
fallingWedgeExpandingLastPivotDirection = input.string('up', '', , inline='fwe', group='Expanding Wedges', display = display.none,
tooltip='Enable Falling Wedge (Expanding) and select the last pivot direction filter. Last pivot direction will only be used if the Generic Last Pivot Direction parameter is set to Custom')
allowRisingWedgeContracting = input.bool(true, 'Rising ', inline='rwc', group = 'Contracting Wedges', display = display.none)
risingWedgeContractingLastPivotDirection = input.string('down', '', , inline='rwc', group='Contracting Wedges', display = display.none,
tooltip='Enable Rising Wedge (Contracting) and select the last pivot direction filter. Last pivot direction will only be used if the Generic Last Pivot Direction parameter is set to Custom')
allowFallingWedgeContracting = input.bool(true, 'Falling ', inline='fwc', group = 'Contracting Wedges', display = display.none)
fallingWedgeContractingLastPivotDirection = input.string('up', '', , inline='fwc', group='Contracting Wedges', display = display.none,
tooltip='Enable Falling Wedge (Contracting) and select the last pivot direction filter. Last pivot direction will only be used if the Generic Last Pivot Direction parameter is set to Custom')
allowRisingTriangleExpanding = input.bool(true, 'Ascending ', inline='rte', group = 'Expanding Triangles', display = display.none)
risingTriangleExpandingLastPivotDirection = input.string('up', '', , inline='rte', group='Expanding Triangles', display = display.none,
tooltip='Enable Ascending Triangle (Expanding) and select the last pivot direction filter. Last pivot direction will only be used if the Generic Last Pivot Direction parameter is set to Custom')
allowFallingTriangleExpanding = input.bool(true, 'Descending', inline='fte', group = 'Expanding Triangles', display = display.none)
fallingTriangleExpandingLastPivotDirection = input.string('down', '', , inline='fte', group='Expanding Triangles', display = display.none,
tooltip='Enable Descending Triangle (Expanding) and select the last pivot direction filter. Last pivot direction will only be used if the Generic Last Pivot Direction parameter is set to Custom')
allowExpandingTriangle = input.bool(true, 'Diverging ', inline='dt', group = 'Expanding Triangles', display = display.none)
divergineTriangleLastPivotDirection = input.string('both', '', , inline='dt', group='Expanding Triangles', display = display.none,
tooltip='Enable Diverging Triangle and select the last pivot direction filter. Last pivot direction will only be used if the Generic Last Pivot Direction parameter is set to Custom')
allowRisingTriangleConverging= input.bool(true, 'Ascending ', inline='rtc', group = 'Contracting Triangles', display = display.none)
risingTriangleContractingLastPivotDirection = input.string('up', '', , inline='rtc', group='Contracting Triangles', display = display.none,
tooltip='Enable Ascending Triangle (Contracting) and select the last pivot direction filter. Last pivot direction will only be used if the Generic Last Pivot Direction parameter is set to Custom')
allowFallingTriangleConverging = input.bool(true, 'Descending', inline='ftc', group = 'Contracting Triangles', display = display.none)
fallingTriangleContractingLastPivotDirection = input.string('down', '', , inline='ftc', group='Contracting Triangles', display = display.none,
tooltip='Enable Descending Triangle (Contracting) and select the last pivot direction filter. Last pivot direction will only be used if the Generic Last Pivot Direction parameter is set to Custom')
allowConvergingTriangle = input.bool(true, 'Converging ', inline='ct', group = 'Contracting Triangles', display = display.none)
convergingTriangleLastPivotDirection = input.string('both', '', , inline='ct', group='Contracting Triangles', display = display.none,
tooltip='Enable Converging Triangle and select the last pivot direction filter. Last pivot direction will only be used if the Generic Last Pivot Direction parameter is set to Custom')
allowedPatterns = array.from(
false,
allowUptrendChannel and allowRisingPatterns and allowParallelChannels and allowChannels,
allowDowntrendChannel and allowFallingPatterns and allowParallelChannels and allowChannels,
allowRangingChannel and allowNonDirectionalPatterns and allowParallelChannels and allowChannels,
allowRisingWedgeExpanding and allowRisingPatterns and allowExpandingPatterns and allowWedges,
allowFallingWedgeExpanding and allowFallingPatterns and allowExpandingPatterns and allowWedges,
allowExpandingTriangle and allowNonDirectionalPatterns and allowExpandingPatterns and allowTriangles,
allowRisingTriangleExpanding and allowRisingPatterns and allowExpandingPatterns and allowTriangles,
allowFallingTriangleExpanding and allowFallingPatterns and allowExpandingPatterns and allowTriangles,
allowRisingWedgeContracting and allowRisingPatterns and allowContractingPatterns and allowWedges,
allowFallingWedgeContracting and allowFallingPatterns and allowContractingPatterns and allowWedges,
allowConvergingTriangle and allowNonDirectionalPatterns and allowContractingPatterns and allowTriangles,
allowFallingTriangleConverging and allowFallingPatterns and allowContractingPatterns and allowTriangles,
allowRisingTriangleConverging and allowRisingPatterns and allowContractingPatterns and allowTriangles
)
getLastPivotDirectionInt(lastPivotDirection)=>lastPivotDirection == 'up'? 1 : lastPivotDirection == 'down'? -1 : 0
allowedLastPivotDirections = array.from(
0,
lastPivotDirection == 'custom'? getLastPivotDirectionInt(upTrendChannelLastPivotDirection) : getLastPivotDirectionInt(lastPivotDirection),
lastPivotDirection == 'custom'? getLastPivotDirectionInt(downTrendChannelLastPivotDirection) : getLastPivotDirectionInt(lastPivotDirection),
lastPivotDirection == 'custom'? getLastPivotDirectionInt(rangingChannelLastPivotDirection) : getLastPivotDirectionInt(lastPivotDirection),
lastPivotDirection == 'custom'? getLastPivotDirectionInt(risingWedgeExpandingLastPivotDirection) : getLastPivotDirectionInt(lastPivotDirection),
lastPivotDirection == 'custom'? getLastPivotDirectionInt(fallingWedgeExpandingLastPivotDirection) : getLastPivotDirectionInt(lastPivotDirection),
lastPivotDirection == 'custom'? getLastPivotDirectionInt(divergineTriangleLastPivotDirection) : getLastPivotDirectionInt(lastPivotDirection),
lastPivotDirection == 'custom'? getLastPivotDirectionInt(risingTriangleExpandingLastPivotDirection) : getLastPivotDirectionInt(lastPivotDirection),
lastPivotDirection == 'custom'? getLastPivotDirectionInt(fallingTriangleExpandingLastPivotDirection) : getLastPivotDirectionInt(lastPivotDirection),
lastPivotDirection == 'custom'? getLastPivotDirectionInt(risingWedgeContractingLastPivotDirection) : getLastPivotDirectionInt(lastPivotDirection),
lastPivotDirection == 'custom'? getLastPivotDirectionInt(fallingWedgeContractingLastPivotDirection) : getLastPivotDirectionInt(lastPivotDirection),
lastPivotDirection == 'custom'? getLastPivotDirectionInt(convergingTriangleLastPivotDirection) : getLastPivotDirectionInt(lastPivotDirection),
lastPivotDirection == 'custom'? getLastPivotDirectionInt(fallingTriangleContractingLastPivotDirection) : getLastPivotDirectionInt(lastPivotDirection),
lastPivotDirection == 'custom'? getLastPivotDirectionInt(risingTriangleContractingLastPivotDirection) : getLastPivotDirectionInt(lastPivotDirection)
)
theme = input.string('Dark', title='Theme', options= , group='Display', inline='pc',
tooltip='Chart theme settings. Line and label colors are generted based on the theme settings. If dark theme is selected, '+
'lighter colors are used and if light theme is selected, darker colors are used. '+
'Pattern Line width - to be used for drawing pattern lines', display=display.none)
patternLineWidth = input.int(2, '', minval=1, inline='pc', group = 'Display', display = display.none)
showPatternLabel = input.bool(true, 'Pattern Label', inline='pl1', group = 'Display', display = display.none)
patternLabelSize = input.string(size.normal, '', , inline='pl1', group = 'Display', display = display.none,
tooltip = 'Option to display Pattern Label and select the size')
showPivotLabels = input.bool(true, 'Pivot Labels ', inline='pl2', group = 'Display', display = display.none, tooltip = 'Option to display pivot labels and select the size')
pivotLabelSize = input.string(size.normal, '', , inline='pl2', group = 'Display', display = display.none)
showZigzag = input.bool(true, 'Zigzag', inline='z', group = 'Display', display = display.none)
zigzagColor = input.color(color.blue, '', inline='z', group = 'Display', display = display.none, tooltip = 'Option to display zigzag within pattern and the default zigzag line color')
deleteOldPatterns = input.bool(true, 'Max Patterns', inline='do', group = 'Display', display = display.none)
maxPatterns = input.int(20, '', minval=1, step=5, inline = 'do', group = 'Display', display = display.none, tooltip = 'If selected, only last N patterns will be preserved on the chart.')
errorRatio = errorThresold/100
flatRatio = flatThreshold/100
showLabel = true
offset = 0
type Scanner
bool enabled
string ticker
string timeframe
p.ScanProperties sProperties
p.DrawingProperties dProperties
array patterns
array zigzags
method getZigzagAndPattern(Scanner this, int length, int depth, array ohlcArray, int offset=0)=>
var zg.Zigzag zigzag = zg.Zigzag.new(length, depth, 0)
var map lastDBar = map.new()
zigzag.calculate(array.from(highSource, lowSource))
var validPatterns = 0
mlzigzag = zigzag
if(zigzag.flags.newPivot)
while(mlzigzag.zigzagPivots.size() >= 6+offset)
lastBar = mlzigzag.zigzagPivots.first().point.index
lastDir = int(math.sign(mlzigzag.zigzagPivots.first().dir))
if(lastDBar.contains(mlzigzag.level)? lastDBar.get(mlzigzag.level) < lastBar : true)
lastDBar.put(mlzigzag.level, lastBar)
= mlzigzag.find(this.sProperties, this.dProperties, this.patterns, ohlcArray)
if(valid)
validPatterns+=1
currentPattern.draw()
this.patterns.push(currentPattern, maxPatterns)
alert('New Pattern Alert')
else
break
mlzigzag := mlzigzag.nextlevel()
true
method scan(Scanner this)=>
var array ohlcArray = array.new()
var array patterns = array.new()
ohlcArray.push(o.OHLC.new(openSource, highSource, lowSource, closeSource))
if(useZigzag1)
this.getZigzagAndPattern(zigzagLength1, depth1, ohlcArray)
if(useZigzag2)
this.getZigzagAndPattern(zigzagLength2, depth2, ohlcArray)
if(useZigzag3)
this.getZigzagAndPattern(zigzagLength3, depth3, ohlcArray)
if(useZigzag4)
this.getZigzagAndPattern(zigzagLength4, depth4, ohlcArray)
var scanner = Scanner.new(true, "", "",
p.ScanProperties.new(offset, numberOfPivots, errorRatio, flatRatio, checkBarRatio, barRatioLimit, avoidOverlap, allowedPatterns=allowedPatterns, allowedLastPivotDirections= allowedLastPivotDirections, themeColors = ut.getColors(theme)),
p.DrawingProperties.new(patternLineWidth, showZigzag, 1, zigzagColor, showPatternLabel, patternLabelSize, showPivotLabels, pivotLabelSize, deleteOnPop = deleteOldPatterns),
array.new())
if(barstate.isconfirmed or repaint)
scanner.scan()
Trinity Real Move Detector DashboardRelease Notes (critical)
1. This code "will" require tweaks for different timeframes to the multiplier, do not assume the data in the table is accurate, cross check it with the Trinity Real Move Detector or another ATR tool, to validate the values in the table and ensure you have set the correct values.
2. I mention this below. But please understand that pine code has a limitation in the number of security calls (40 request.security() calls per script). This code is on the limit of that threshold and I would encourage developers to see if they can find a way around this to improve the script and release further updates.
What do we have...
The Trinity Real Move Detector Dashboard is a powerful TradingView indicator designed to scan multiple assets at once and show when each one has genuine short-term volatility "energy" — the kind that makes directional options trades (especially 0DTE or short-dated) have a high probability of follow-through, and can be used for swing trading as well. It combines a simple ATR-based volatility filter with a SuperTrend-style bias to tell you not only if the market is "awake" but also in which direction the momentum is leaning.
At its core, the indicator calculates the current ATR on your chosen timeframe and compares it to a user-defined percentage of the asset's daily ATR. When the short-term ATR spikes above that threshold, it signals "enough energy" — meaning the underlying is moving with real force rather than choppy noise. The SuperTrend logic then determines bullish or bearish bias, so the status shows "BULLISH ENERGY" (green) or "BEARISH ENERGY" (red) when energy is on, or "WAIT" when it's not. It also counts how many bars the energy has been active and shows the current ATR vs threshold for quick visual confirmation.
The dashboard displays all this in a clean table with columns for Symbol, Multiplier, Current ATR, Threshold, Status, Bars Active, and Bias (UP/DOWN). It's perfect for 3-minute charts but works on any timeframe — just adjust the multiplier based on the hints in the settings.
Editing symbols and multipliers is straightforward and user-friendly. In the indicator settings, you'll see numbered inputs like "1. Symbol - NVDA" and "1. Multiplier". To change an asset, simply type the new ticker in the symbol field (e.g., replace "NVDA" with "TSLA", "AVGO", or "ADAUSD"). You can also adjust the multiplier for each asset individually in the corresponding "Multiplier" field to make it more or less sensitive — lower numbers give more signals, higher numbers give stricter, higher-quality ones. This lets you customize the dashboard to your watchlist without any coding. For example, if you switch to a 4-hour chart or a slower-moving stock like AVGO, you may need to raise the multiplier (e.g., to 0.3–0.4) to avoid false "bullish" signals during minor bounces in a larger downtrend.
One important note about the multiplier and timeframes: the default values are optimized for fast intraday charts (like 3-minute or 5-minute). On higher timeframes (15-minute, 1-hour, 4-hour, or daily), the SuperTrend bias can be too sensitive with low multipliers (1.0 default in the code), leading to situations like the AVGO 4-hour example — where price is clearly downtrending, but the dashboard shows "BULLISH ENERGY" because the tight bands flip on small bounces. To fix this, you need to manually increase the multiplier for that asset (or all assets) in the settings. For 4-hour or daily charts, 0.25–0.35 is often better to match smoother SuperTrend indicators like Trinity. Always test on your timeframe and asset — crypto usually needs slightly lower multipliers than stocks due to higher volatility.
TradingView has a hard limit of 40 request.security() calls per script. Each asset in the dashboard requires several calls (current ATR, daily ATR, SuperTrend components, etc.), so with the full ATR-based bias, you can safely monitor about 6–8 assets before hitting the limit. Adding more symbols increases the number of calls and will trigger the "too many securities" error. This is a platform restriction to prevent excessive server load, and there's no official way around it in a single script. Some advanced coders use tricks like caching or lower-timeframe requests to squeeze in a few more, but for reliability, sticking to 6–8 assets is recommended. If you need more, the common workaround is to create two separate indicators (e.g., one for stocks, one for crypto) and add both to the same chart.
Overall, this dashboard gives you a professional-grade multi-asset scanner that filters out low-energy noise and highlights real momentum opportunities across stocks and crypto — all in one glance. It's especially valuable for options traders who want to avoid theta decay on weak moves and only strike when the market has true fuel. By tweaking the per-symbol multipliers in the settings, you can perfectly adapt it to any timeframe or asset behavior, avoiding issues like the AVGO false bullish signal on higher timeframes.
MACD Trend Count ScoreThis indicator aims to confirm trends in an asset's price. This confirmation is achieved by counting the MACD bars in a calculation using the chosen timeframe. Positive and negative bars are considered in the calculation of the strength index, which indicates the current trend of that asset.
This Delta index summarizes the predominance of positive or negative bars in the MACD histogram over weekly, bi-weekly, monthly, bi-monthly, and quarterly periods, and, depending on the timeframe used, its result allows one to indicate the intensity of the current trend, according to the results it shows within the following ranges:
Acima de +60 → Strong Raise.
Entre +20 e +60 → Moderate High.
Entre -20 e +20 → Neutral.
Entre -60 e -20 → Moderate Low.
Abaixo de -60 → Strong Low.
Low Volume Pullback DetectorThis script incorporates the logic of Volume Price Analysis (VPA), identifying potential trend continuations by detecting pullbacks with decreasing volume.
###**Features:**1. **Trend Filtering:** Uses a 50-period EMA to ensure trades align with the dominant market direction.
2. **Structure Identification:** Detects recent highs and lows to confirm that price action is indeed a pullback within a trend.
3. **Volume Analysis:** Checks if the volume during the pullback is below the 20-period average, signaling a lack of conviction from counter-trend traders.
4. **Signal Generation:** Triggers a "Buy" or "Sell" signal when price breaks out of the pullback range, confirming momentum is returning in the direction of the trend.
5. **User Guide:** Detailed comments explaining the strategy, setup, trade execution, and best markets are included directly within the script for easy reference.
###**How to Use:*** **Setup:** Apply the script to a chart (works best on Stocks and Futures).
* **Identify Trend:** Ensure price is above (for Buy) or below (for Sell) the gray 50 EMA line.
* **Wait for Signal:** Look for the **"VOL DRY"** label. This appears when a low-volume pullback is followed by a breakout candle.
* **Execution:** Enter on the close of the signal candle. Set your Stop Loss below/above the pullback swing and target the previous structural high/low.
Pair Creation🙏🏻 The one and only pair construction tech you need, unlike others:
Applies one consistent operation to all the data features (not only prices). Then, the script outputs these, so you can apply other calculations on these outputs.
calculates a very fast and native volatility based hedge ratio, that also takes into account point value (think SPY vs ES) so you can easily use it in position sizing
Has built-in forward pricing aka cost of carry model , so you can de-drift pairs from cost of carry, discover spot price of oil based on futures, and ofc find arbitrage opportunities
Also allows to make a pair as a product of 2 series, useful for triangular arbitrage
This script can make a pair in 2 ways:
Ratio, by dividing leg 1 by leg 2
Product, by multiplying leg 1 by leg 2
The real mathematically right way to construct a pair is a ratio/product (Spreads are in fact = 2 legged portfolio, but I ain't told ya that ok). Why? Because a pair of 2 entities has a mathematically unique beauty, it allows direct comparisons and relationship analysis, smth you can't do directly with 3 and more components.
Multiplication (think inversions like (EURUSD -> USDEUR), and use cases for triangular arbitrage) is useful sometimes too.
...
Quickguide:
First, "Legs" are pair components: make a pair of related assets. Don’t be guided exclusively by clustering, cointegrations, mutual information etc. Common sense and exogenous info can easily made them all Forward pricing model: is useful when u work with spot vs futures pairs. Otherwise: put financing, storage and yield all on zeros, this way u will turn it off and have a pure ratio/product of 2 legs.
Look at the 2 numbers on the script’s status line: the first one would always be 1), and the second one is a variable.
First number (always 1) is multiplier for your position size on leg 1
The second number is the multiplier for your position size on leg 2 in the opposite direction.
If both legs are related, trading your sizes with these multipliers makes you do statistical arbitrage -> trading ~ volatility in risk free mode, while the relationship between the assets is still in place.
Also guys srsly, nobody ‘ever’ made a universal law that somewhy somehow for whatever secret conspiracy reason one shall only trade pairs in mean reverting style xd. You can do whatever you want:
Tilt hedge ratio significantly based on relative strength of legs
Trade the pair in momentum style
Ignore hedge ratio all together
And more and more, the limit is your imagination, e.g.:
Anticipate hedge ratio changes based on exogenous info and act accordingly
Scalp a pair just like any other asset
Make a pair out of 2 pairs
Like I mean it, whatever you desire
About forward pricing model:
It’s applied only to leg 2;
Direct: takes spot price and finds out implied futures price
Inverse: takes futures price and finds out implied spot price (try on oil)
Pls read online how to choose parameters, it’s open access reliable info
About the hedge ratio I use:
You prolly noticed the way I prefer to use inferred volumes vs the “real” ones. In pairs it’s especially meaningful, because real volumes lose sense in pair creation. And while volumes are closely tied to volatility, the inferred volumes ‘Are’ volatility irl (and later can be converted to currency space by using point value, allowing direct comparisons symbol vs symbol).
This hedge ratio is a good example of how discovering the real nature of entities beats making 100s of inventions, why domain knowledge and proper feature engineering beats difficult bulky models, neural networks etc. How simple data understanding & operations on it is all you need.
This script simply does this:
Takes inferred volume delta of both assets, makes a ratio, normalizes it by tick sizes and points values of both legs, calculates a typical value of this series.
That’s it, no step 2, we’re done. No Kalman filters, no TLS regression, no vine copulas, or whatever new fancy keywords you can come up with etc.
...
^^ comparing real ES prices vs theoretical ones by forward-pricing model. Financing: 0.04, yield 0.0175
^^ EURUSD, 6E futures with theoretical futures price calculated with interest rate differential 0.02 (4% USD - 2% EUR interest rates)
^^4 different pairs (RTY/ES, YM/ES, NQ/ES, ES/ZN) each with different plot style (pick one you like in script's Style settings)
^^ YM/RTY pair, each plot represents ratio of different features: ratio of prices, ratio of inferred volume deltas, ratio of inferred volumes, ratio of inferred tick counts (also can be turned on/off in Style settings)
...
How can u upgrade it and make a step forward yourself:
On tradingview missing values are automatically fixed by backfilling, and this never becomes a thing until you hit high frequency data. You can do better and use Kalman filter for filling missing values.
Script contains the functions I use everywhere to calculate inferred volume delta, inferred volume, and inferred tick count.
...
∞
Volume Delta Divergence Candle ColorThis indicator identifies divergences between price action and volume delta, highlighting potential reversal or continuation signals by coloring candles when buyer/seller pressure conflicts with the candle's direction.
**How It Works:**
The indicator analyzes real-time up/down volume data to detect two types of divergences:
🟣 **Seller Divergence (Fuscia)** - Occurs when a candle closes bullish (green) but the volume delta is negative, indicating more selling pressure despite the upward price movement. This suggests weak buying or potential distribution.
🔵 **Buyer Divergence (Cyan)** - Occurs when a candle closes bearish (red) but the volume delta is positive, indicating more buying pressure despite the downward price movement. This suggests weak selling or potential accumulation.
**Features:**
✓ Colors only divergent candles - non-divergent candles maintain your chart's default colors
✓ Uses actual exchange volume delta data (works best with CME futures and other instruments with tick-level data)
✓ Optional triangle markers above/below divergent candles for quick visual identification
✓ Clean, minimal design that doesn't clutter your chart
**Best Used For:**
- Identifying potential reversals or continuations
- Spotting weak price movements that may not follow through
- Confirming price action with underlying volume pressure
- Works on any timeframe with available volume delta data
**Note:** This indicator requires volume data from exchanges that provide tick-level information (CME futures, cryptocurrency exchanges, etc.). Results may vary on instruments with limited volume data.
SPX Master Levels & Correlations [Gemini] (v4.2)This will draw on your chart levels of SPX from other time frames low , high and ES
Weekend Asia High/Low Dots + Trading Window (UTC+1)**Weekend Asia High/Low Dots & Trading Window** is a lightweight TradingView indicator designed to **mark the exact Asia session extremes on weekends (Saturday & Sunday)** and highlight predefined **trading time windows** with maximum clarity and minimal chart clutter.
The indicator focuses on **precision, simplicity, and manual trading workflows**.
---
### 🔍 Key Features
#### 🟢 Asia Session High & Low (Weekend Only)
* Tracks the **Asia session on Saturday and Sunday**
* Marks **exactly two points per session**:
* One dot at the **true wick high**
* One dot at the **true wick low**
* Dots are plotted **only once**, at the **end of the Asia session**
* **No lines, no boxes, no extensions** – just clean reference points
* Ideal for traders who prefer to **draw their own ranges manually**
#### 🟩 Trading Window Highlight
* Customizable **trading time windows** for Saturday and Sunday
* Displayed as a **clean outline box** (no background fill)
* Helps visually separate **range formation** from **active trading hours**
---
### ⏰ Time Handling
* All session times are defined in **UTC+1**
* Uses a **fixed UTC+1 timezone** (`Etc/GMT-1`) for consistent behavior
* Easily adjustable to other timezones if needed
---
### ⚙️ Customizable Inputs
* Asia session times (Saturday & Sunday)
* Trading session times (Saturday & Sunday)
* Optional trading window labels
* Easy point size adjustment directly in the code
---
### 🎯 Use Cases
* Weekend trading (Crypto, Indices, Synthetic markets)
* Asia range analysis
* Manual range drawing & breakout planning
* Clean, distraction-free chart layouts
---
### 🧠 Who Is This Indicator For?
* Price action traders
* Range & session-based traders
* Traders who prefer **manual chart markup**
* Anyone trading **weekends with structured time windows**
---
### 🛠 Technical Details
* Pine Script® **Version 6**
* Overlay indicator
* Optimized for clarity and performance
---
If you want, I can also provide:
* a **short description** (1–2 lines for the TradingView header)
* **tags & keywords** for better discoverability
* or a **version with user-adjustable dot size via Inputs**
