Rolling VWAP with SignalsRolling VWAP with Signals
Overview
Rolling VWAP with Signals plots a time-window ("rolling") VWAP with standard deviation bands, and generates filtered buy/sell signals on band breakouts. Unlike a session VWAP, which resets at a fixed anchor such as the start of day or week, this VWAP recalculates continuously over a trailing window that you define, for example the last 10 hours or the last 2 minutes of 3-minute bars. This keeps it adapting on any chart, in any session, in any market, including markets that trade around the clock.
This script is an original extension built on the rolling VWAP concept from Rolling VWAP . It adds standard deviation bands, trend-state coloring, crossover based buy/sell signals, an ATR rising filter, and a VWAP trend-alignment filter, none of which are present in the original.
How It Works
The rolling VWAP is computed by summing price times volume and volume over a trailing time window, then dividing, the standard VWAP formula applied to a moving window instead of a fixed session. The calculation runs on an independent timeframe set by the RVWAP Timeframe input, evaluated with request.security().
Standard deviation bands sit above and below the VWAP at a configurable multiple of the rolling standard deviation, computed with the direct weighted squared deviation method rather than the E minus E ^2 shortcut, which avoids precision loss on high-priced instruments.
smoothedATR = ta.swma(ta.atr(atrLength))
atrRising = not useATRFilter or smoothedATR > smoothedATR
Trend state is bullish when the VWAP is higher than it was one higher-timeframe bar ago and price is above the upper band, and bearish under the mirrored condition. The VWAP line is colored accordingly.
Buy and sell signals fire once, on the bar where price crosses a band, not on every bar price remains outside it:
Buy — close crosses over the upper band
Sell — close crosses under the lower band
Two optional filters narrow signals to higher-conviction setups:
Rising ATR — requires an SWMA-smoothed ATR to be higher than the prior bar, filtering out breakouts occurring while volatility is contracting
RVWAP trend alignment — requires the bullish or bearish trend state described above, so buy only fires in an established uptrend and sell only in an established downtrend
Four alert conditions are available: price above the upper band, price below the lower band, a buy signal, and a sell signal.
Inputs
RVWAP Timeframe — Timeframe the rolling VWAP and standard deviation calculation runs on, independent of the chart timeframe. Default: 1 minute.
RVWAP Time Period (Hours / Minutes) — Length of the trailing window used for the rolling calculation. Shorter windows track faster; longer windows behave more like a session VWAP. Default: 0 hours, 1 minute.
Standard Deviation Multiplier — Distance of the bands from the VWAP, in standard deviations. Lower values give tighter bands and more signals; higher values give wider bands and fewer, stronger signals. Default: 1.618.
Show Standard Deviation Bands — Toggles the band plots and disables buy/sell signals when off, since signals require a band cross. Default: on.
Show Fill Between Bands — Toggles the shaded fill between the upper and lower bands. Default: on.
Smooth VWAP/StdDev — Applies additional smoothing to the VWAP and standard deviation lines for a less-lagged appearance when off, or a smoother, laggier line when on. Default: off.
Require Rising ATR for Signals — Gates buy and sell signals on a rising smoothed ATR. Default: on.
Length — ATR length used by the rising-ATR filter. Default: 14.
Require RVWAP Trend Alignment for Signals — Gates buy signals on a bullish RVWAP trend and sell signals on a bearish RVWAP trend. Default: on.
Upper Band, Lower Band, Fill — Colors for the band lines and the fill between them.
Usage Notes
Requires a data feed that provides volume; the script raises a runtime error if none is available.
The rolling calculation needs a minimum of 10 bars within the window to produce a value; very short windows on sparse data may show gaps.
Rising ATR means the current SWMA-smoothed ATR value is strictly greater than the previous bar's value, a one-bar comparison rather than a multi-bar slope.
Values inside the current, still-forming RVWAP Timeframe bar can update intrabar, as with any request.security() call without a fixed historical offset. Confirmed bars do not repaint.
Disable both signal filters to see every raw band-crossing signal, or enable them independently to trade off signal frequency against signal quality.
Credits
Rolling VWAP methodology adapted from the original Rolling VWAP .
Uses the open-source PineCoders ConditionalAverages library for the windowed total calculations.
Disclaimer
This script is provided for educational and informational purposes only and does not constitute financial advice. Past performance is not indicative of future results. Always do your own research and apply proper risk management before trading.
Indicator
Pymander's EZ VWAPPymander's EZ VWAP
Standard VWAP indicators are great, but let’s be honest—they can be a bit "static." They show you where the price is relative to an average, but they don't tell you the story of the price action. That’s why I built EZ VWAP.
This isn't just a line on your chart; it’s a complete decision-making system designed to help you distinguish between a healthy trend and a trap.
What makes EZ VWAP stand out?
Most VWAPs just give you ±1, ±2, and ±3 standard deviations and call it a day. EZ VWAP is smarter. It classifies the market into logical zones:
The Fair Value Zone (±0.5σ): This is the "Chop Zone." If price is hanging out here, there’s no clear edge. We stay patient.
The Extension Zone (±1σ to ±2σ): This is where the magic happens for mean reversion.
The Exhaustion Zone (Beyond ±3σ): The "Danger Zone" where trends either blow off or reverse violently.
🛠️ Key Features You Won't Find in a Basic VWAP:
Acceptance vs. Rejection Logic: The biggest VWAP trap is shorting a "stretch" only for the price to keep mooning. Our Sweep + Reclaim signals only trigger when the price fails to hold above a band. It asks: "Did price accept the new high, or did it reject it?"
Momentum Dashboard: A quick-glance table in the corner tells you if the VWAP slope is Accelerating (momentum is expanding) or Decelerating (trend is weakening).
Dynamic Slope Coloring: The VWAP line itself changes color based on its "speed." Bright colors for strong trends, and neutral colors for weakening moves—perfect for timing your entries.
Three Modes in One: Whether you want a standard Session reset, a specific Anchored point (like a news event), or a Rolling window for a more responsive feel, we’ve got you covered.
Tailored Entries: Choose between Aggressive, Balanced, or Conservative entry models to match your personal risk tolerance.
How it helps you:
EZ VWAP stops you from "catching falling knives" by waiting for price to actually reclaim a level before signaling an entry. It helps you stay out of the chop and focus on the high-probability "stretch" areas where the big moves happen.
I’d love to hear how it’s working for you! If you have ideas for new features or tweaks, drop some feedback in the comments.
Wishing you all tons of luck and many, many green days!
-Pymander Indicator
RollingWindow█ OVERVIEW
This a Pine Script™ library to create rolling windows with arrays and matrices.
A rolling window is a first-in-first-out algorithm that stores values over chart updates, removing the oldest element as new values are added. Many programmers implement a form of this algorithm into their scripts currently like this:
var window = array.new(size = 10)
window.push(close) // Append `close` as a new element every new bar.
if 10 < window.size() // Maintain a size of 10 elements.
window.shift() // Remove oldest element.
With the RollingWindow library, you can simply call `roll()` to do the same thing like so:
var window = array.new(size = 10)
window.roll(close) // Rolling window of 10 elements updated each bar with `close`.
█ USAGE
Rolling Window Arrays
Import the RollingWindow library into your script.
import joebaus/RollingWindow/1 as rw
Create a rolling window array by calling `roll()` on an array declared with `var` bar persistence.
var window = array.new()
rw.roll(id = window, source = close, size = 3) // Alternatively: window.roll(close, 3)
Using an array with `varip` intrabar persistence lets `roll()` execute on and update elements intrabar.
varip window = array.new() // Updates intrabar.
rw.roll(id = window, source = close, size = 3) // Executes `roll()` every realtime update.
Ensure arrays are declared with `var` or `varip` keywords to store updated elements. Otherwise, applying `roll()` will not store rolled values.
id = array.new() // No `var` or `varip` keyword.
rw.roll(id, close, 3) // Only updates a single element in `id`!
New elements can be added dynamically to empty arrays with the limit set by the `roll(size)` parameter. Once the array is full, every sequential chart update rolls out , removes, the oldest element.
varip id = array.new()
// Dynamically appends up to 3 elements of `timenow`, then rolls elements.
id.roll(source = timenow, size = 3) // Use `roll()` as a method on `id`.
Arrays with initialized values and sizes can be used as a rolling window array.
var array id = array.from("Hello", "World")
string closeString = str.tostring(close, format.mintick)
id.roll(source = closeString, size = 2) // Rolls elements into `id`, up to 2 elements.
The `roll(size)` parameter becomes optional for arrays with an initialized size, because `roll()` will by default use the initialized size of the array provided if `roll(size)` is not set.
var id = array.new(size = 3) // Returns
color gradient = color.from_gradient(close, low, high, color.red, color.green)
id.roll(source = gradient) // Uses the size of `id` as the rolling window size limit.
An array with initialized values can still grow dynamically if `roll(size)` parameter is greater than the array's initial size.
var id = array.new(size = 3) // Returns
chart.point nowPoint = chart.point.now(close)
id.roll(source = nowPoint, size = 4) // Dynamically grows to
The `roll(size)` parameter must always be equal to or greater than the initial size of the array, or else `roll()` will generate a runtime error.
var id = array.new(size = 3)
id.roll(source = close, size = 2) // Generates a runtime error!
// roll(array id, float source, int size):
// `size` (2) must be greater than or equal to the size of `id` (3), or set to `na`!
When the array size and `roll(size)` parameter are both unspecified, `roll()` will dynamically size the array up to the element limit before rolling new elements.
var id = array.new()
id.roll(timenow) // Adds new elements to `id` up to the element limit, then rolls elements.
From within a conditional local scope , `roll()` can operate on arrays in a higher scope.
var id1 = array.new(size = 3)
float sma50 = ta.sma(close, 50)
float sma200 = ta.sma(close, 200)
if ta.cross(sma50, sma200) // Golden Cross condition.
id1.roll(source = str.format_time(time)) // Rolls up to 3 Golden Cross dates into `id1`.
var id2 = array.new()
footprint reqFootprint = request.footprint(100)
if not na(reqFootprint)
id2.roll(source = reqFootprint, size = 3) // Rolls up to 3 footprint objects into `id2`.
`roll()` returns the element removed from the array, allowing scripts to capture values as they are rolled out.
var id = array.new(size = 3)
float removedElement = id.roll(close, 3) // Returns the removed `close` value from the array.
if not na(removedElement)
label.new(bar_index, removedValue, str.tostring(removedValue))
Reverse Rolling Window Arrays
The roll operation can be done in reverse order using the `rollReverse()` library function; new elements are inserted at the beginning of the array instead, and old elements are removed at the end of the array.
var id1 = array.new()
id1.rollReverse(source = close, size = 3) // Dynamically sized reverse rolling window array.
varip id2 = array.new(size = 3)
id2.rollReverse(source = close) // Initialized size reverse rolling window array.
`rollReverse()` returns the element removed from the array, just like `roll()`.
var id = array.new(size = 3)
int removedValue = id.rollReverse(bar_index, 3)
Sorted Rolling Window Arrays
Rolling window arrays created with `roll()` are unsorted. To create ascending sorted rolling window arrays for `float` or `int` types, use the `rollAscendingVar()` or `rollAscendingVarip()` functions for `var` and `varip` keyword arrays respectively.
var id1 = array.new()
// Ascending sorted, dynamically sized `var` rolling window array.
id1.rollAscendingVar(source = close, size = 3)
varip id2 = array.new(size = 3)
// Ascending sorted, initialized size `varip` rolling window array.
id2.rollAscendingVarip(source = bar_index)
To create descending sorted rolling window arrays for `float` or `int` types, use the `rollDescendingVar()` or `rollDescendingVarip()` functions for `var` and `varip` keyword arrays respectively.
var id1 = array.new()
// Descending sorted, dynamically sized `var` rolling window array.
id1.rollDescendingVar(bar_index, 3)
varip id2 = array.new(3)
// Descending sorted, initialized size `varip` rolling window array.
id2.rollDescendingVarip(close)
Just like with the `array.sort()` built-in function, the ascending and descending rolling window functions do not sort `na` values.
float sma = ta.sma(50, close) // First 49 values are `na`.
var id = array.new()
id.rollAscendingVar(sma, 3) // Rolls nothing until `sma` values are not `na`.
The arrays with unsorted values should be sorted in ascending or descending order before calling the respective sorted rolling window library functions.
var array id = array.from(4, 1, 2, 3, 10, 8, 15, 7) // Unsorted initialized array.
id.sort(order.ascending) // Sort it first!
id.rollAscendingVar(bar_index)
The sorted rolling window functions can return the latest element removed from the array.
var id = array.new(size = 3)
float removedElement = id.rollAscendingVar(close, 3)
Rolling Window Matrices
The `roll()` matrix methods store a rolling window of arrays in row-major order. Rows are "rolled" by adding a new row at index `0`, and removing the oldest row at the end of the matrix.
var closeArray = array.new(10) // Array to store in the rolling window matrix.
var closeMatrix = matrix.new()
// Create a rolling window matrix with up to 3 `closeArray` rows and 10 columns (1 per element).
rw.roll(id = closeMatrix, array_id = closeArray, rows = 3)
A matrix with `varip` intrabar persistence lets `roll()` execute and update matrix rows intrabar.
varip closeArray = array.new(size = 10)
rw.roll(id = closeArray, source = time)
varip closeMatrix = matrix.new()
// Create a rolling window matrix with up to 3 `closeArray` rows and 10 elements (columns).
closeMatrix.roll(array_id = closeArray, rows = 3)
The matrix methods of `roll()` will dynamically create the necessary columns to fit all elements of `roll(array_id)` as long as the array size is greater than the number of matrix columns.
var closeArray = array.new(size = 10000)
closeArray.roll(source = close) // Creating a rolling window array.
// Size empty matrices dynamically with `roll(array_id)`.
var closeMatrix = matrix.new()
// Roll up to 100 rows of `closeArray` with 10000 elements (columns) into `closeMatrix`.
rw.roll(id = closeMatrix, array_id = closeArray, rows = 100)
The size of `array_id` can possibly be too large when dynamically adding columns to a rolling window matrix, generating a runtime error when the new column would exceed the 100,000 matrix size limit.
var closeArray = array.new()
closeArray.roll(source = close, size = 1001)
var closeMatrix = matrix.new()
rw.roll(id = closeMatrix, array_id = closeArray, rows = 100) // Generates a runtime error!
// roll(matrix id, array array_id, int rows):
// `array_id` (1001) and `rows` (100) create 100100 matrix elements!"
// Reduce the size of `array_id` or value of `rows` to stay within the 100,000 matrix size limit!
A matrix with initialized rows and columns can also be used with `roll()`. This requires that the array's size used in `roll(array_id)` must be less than or equal to the number of matrix columns.
var closeArray = array.new(100) // Initialized matrix columns require initialized array sizes.
closeArray.roll(close) // Roll 100 `close` elements into `closeArray`.
var closeMatrix = matrix.new(rows = 10, columns = 100) // 100 array elements, 100 columns.
rw.roll(id = closeMatrix, array_id = closeArray, rows = 10)
The `roll(rows)` parameter is also optional: `roll()` will use the number of rows in the initialized matrix when `roll(rows)` is not set. Plus the number of initialized matrix columns does not have to be the same size as `roll(array_id)`.
var closeArray = array.new(10) // Array initialized with 10 elements.
closeArray.roll(close)
var closeMatrix = matrix.new(rows = 10, columns = 100) // Matrix initialized with 100 columns.
closeMatrix.roll(closeArray) // No `rows` parameter, uses the initialized number of matrix rows.
Managing Drawings
An array or matrix of `line`, `linefill`, `label`, `box`, `polyline`, or `table` types can be used with `roll()` to manage the number of drawing on a chart.
var id = array.new()
// Roll a label in `id` after a bullish bar is confirmed.
if close > open and barstate.isconfirmed
chart.point nowPoint = chart.point.now(high)
label newLabel = label.new(nowPoint, "Bullish")
id.roll(newLabel, 5) // Rolls up to 5 labels in `id`, array grows up to a size of 5.
When drawings are rolled out of an array or matrix, they are deleted with the `.delete()` method of the respective type used. The library functions return `void` for drawing types, so no value is returned when an element is removed.
Library
Rolling Midpoint Engine [AGPro Series]Rolling Midpoint Engine
### Overview
Rolling Midpoint Engine is an on-chart study that converts the geometric midpoint of the last N bars' high-low range into a living control line. The midline is tracked through three behavioral states — Accepted Above, Accepted Below, and Fight — and a fourth modifier (Strong) highlights high-conviction acceptance beyond an ATR threshold. The goal is to surface how price behaves around a single dominant reference level, not to predict direction or issue trade signals.
### Unique Edge
Most midpoint tools plot a static line and let the user eyeball whether price accepts or rejects it. Rolling Midpoint Engine formalises that observation into a finite state machine that requires consecutive body-closes on one side of the midline before declaring acceptance. This filters single-bar noise and distinguishes casual tags from genuine commitment. The ATR-based Strong modifier adds a second axis of information — how firmly the current side is being held — without multiplying states or cluttering the chart with additional lines.
### Methodology
The midline is computed as the average of the highest high and the lowest low over a user-defined rolling window. Optional light EMA smoothing reduces visual jitter without materially shifting the level; a Strict Reset mode disables smoothing for pure rolling output.
Acceptance is evaluated through two streak counters tracking consecutive closes (or full bars, if the user prefers a stricter rule) on each side of the midline. When a streak reaches the Acceptance Bars threshold, the state transitions to Accepted Above or Accepted Below. If the running streak is positive but below threshold, the state is Fight. A Strong flag activates whenever the current distance from the midline exceeds a configurable ATR multiple.
All logic uses confirmed bar closes. The script does not repaint historical states once a bar has closed.
### States & Alerts
States:
- Fight — price is oscillating around the midline without sustained commitment
- Accepted Above — body-closes above the midline for the required number of bars
- Accepted Below — body-closes below the midline for the required number of bars
- Strong (modifier) — current Accepted state is held beyond the ATR threshold
Alerts:
- Midline Crossed Up / Down — raw price cross of the midline
- Accepted Above / Below — state transitions into acceptance
- Midline Rejection — state flip between Accepted Above and Accepted Below, or collapse from an Accepted state back to Fight
### Key Inputs
- Rolling Length — number of bars defining the range window
- Strict Reset Mode — toggle between pure rolling midline and lightly smoothed output
- Acceptance Bars — consecutive body-closes required for acceptance
- Use Body Close vs. Full Bar — strictness of the side-determination rule
- Strong Threshold — ATR multiple that qualifies an accepted side as Strong
- Label Style / Size — Edge Only, Edge + Transitions, or Off
- Panel Location / Theme / Font Size — four corners plus Middle Right, Dark / Light / Auto themes
- Color Midline by State — toggle state-coloring on the dominant line
### How to Use
Apply the indicator to any symbol and timeframe. The midline acts as a rolling control level; the state label on the right edge summarises the current behavior. Treat Accepted Above / Below as evidence that the midline is holding as support or resistance on the corresponding side. A transition into Strong indicates the holding is well beyond routine noise. A rejection event — the state flipping or collapsing back to Fight — suggests the prior control has been compromised.
This is a contextual reading tool. It does not produce entries, exits, targets, or stops, and should not be read as a recommendation to transact.
### Limitations & Transparency
The midline reflects past price data only and will adapt as new highs or lows enter the rolling window. On illiquid or very low-timeframe charts, the streak-based acceptance logic can feel slow; increasing Acceptance Bars on noisier instruments or lowering it on cleaner ones is expected tuning. The Strong Threshold is volatility-relative via ATR but still an arbitrary cut — defaults are calibrated for typical liquid markets and may need adjustment for thinly traded symbols.
The script uses confirmed closes and does not alter historical state once a bar has closed. Intrabar, the displayed state can update in line with current price, as with any live indicator.
### Risk Disclosure
This indicator is an analytical study. It is not a strategy, not a signal service, and not financial advice. It does not forecast future prices and does not guarantee any outcome. Past behavior of price around the midline does not imply future behavior. Every trading decision is the sole responsibility of the user. Use appropriate risk management and test the tool in a non-committed environment before incorporating it into any workflow. Indicator
Rolling VWAPs Proximity & Alerts [HYPR-run]DESCRIPTION:
Rolling VWAPs across six time horizons on one chart. See where
volume-weighted fair value sits at chart TF, 7D, 30D, 60D, 90D and 365D
without switching timeframes. Unlike session VWAP that resets daily, rolling
VWAP uses a fixed window that slides forward continuously, giving you
dynamic support/resistance levels that institutional traders watch.
The PROXIMITY filter is the key feature. Turn on all six periods, set a
threshold, and only RVWAPs near current price appear on chart. Far lines
hide automatically; when price approaches, they show up. This keeps charts
clean while making sure you never miss a level that matters.
DISCOVERING EDGE
We have found that the first bounce/reject of a RVWAP is the most reliable and when there is a XO/XU it is a clear sign the boundary is broken. Hence, this indicator has a contextual positioning table of where price is relative to the other lookback periods while highlighting bounces and rejects with XO/XU alert signals.
ROLLING VWAP vs SESSION/ANCHORED VWAP
Session VWAP resets daily and loses all context beyond today.
Anchored VWAP requires picking the "right" date. Rolling VWAP slides
forward continuously across 7D to 365D, showing dynamic fair value
at every institutional time horizon without manual anchoring.
- Proximity filter surfaces only the RVWAPs near current price; far
lines hide automatically and appear as price approaches.
- Events row catches bounces and rejections ranked by period
significance (365D highest); when a key MA and RVWAP sit at the
same price and both bounce, that's institutional-grade confluence.
- Webhook alerts on configurable RVWAP cross with full bar filter;
30D for frequent signals, 90D for swing-level changes, 365D for
the macro signal.
FEATURES
- Six rolling VWAP periods: Chart TF, 7D, 30D, 60D, 90D, 365D
- Proximity filter: only relevant lines appear near price
- Bounce/reject detection at each RVWAP level
- Webhook alerts on selected RVWAP cross (long/short)
- Dashboard: row 1 positioning context (above/below each RVWAP), row 2 live events (bouncing, rejecting, XO, XU)
- Polyline labels with proximity % from price
- Toggle each period independently
- Dashboard dark/light theme toggle for any chart background
HOW IT WORKS
Rolling VWAP calculates cumulative (price x volume) / cumulative volume
over a fixed lookback window. The 30D RVWAP always reflects the last 30
calendar days of volume-weighted price. When price crosses above it, the
market is trading above recent fair value; crossing below means price has
fallen below where volume concentrated. Bounces confirm support holding;
rejects confirm resistance holding.
DASHBOARD
Two-row dynamic dashboard that updates every bar.
- Row 1 (positioning): which RVWAPs price is above or below, grouped with
"&" separators. The 365D RVWAP is separated as the anchor by a pipe.
7-tier color gradient based on how many of the four key RVWAPs
(30d, 60d, 90d, 365d) price is above, with heavyweight distinction
(90d and 365d carry more weight than 30d/60d): bright green (all
four), green (3/4 with both heavyweights), dark green (3/4 missing a
heavyweight), yellow (2/4), dark red (1/4 with a heavyweight), red
(1/4 only lightweight), bright red (none)
- Row 2 (events): up to 3 simultaneous events, most significant period
first (365D → 90D → 60D → 30D → 7D). Bouncing (support holding),
rejecting (resistance holding), XO (crossover), XU (crossunder). Color
intensity maps to event significance. Dark gray when idle
- Runs independently of display toggles; events fire for all periods even
if the line is hidden by the proximity filter
ALERTS
Two alert systems. XO/XU fires when price crosses the selected RVWAP
(default: 30D). Bounce/Reject fires when price wicks into the selected
RVWAP from the correct side and closes confirming support (bounce) or
resistance (reject). Both fire JSON payloads; works with any webhook
receiver.
POSITIONING TABLE (row 1, all 16 configurations)
BADGE COLOR (header, positioning x event combination)
TIMEFRAME RECOMMENDATIONS
- 7D: best on 8hr and below
- 30D: the default, works on most timeframes
- 60D: best on 3-Day and below
- 90D: best on Weekly and below
- 365D: works on Monthly and below
CREDITS
Rolling VWAP calculation: PineCoders/ConditionalAverages library Indicator
Indicator
Indicator
Library
Rolling Correlation BTC vs Hedge AssetsRolling Correlation BTC vs Hedge Assets
Overview
This indicator calculates and plots the rolling correlation between Bitcoin (BTC) returns and several key hedge assets:
• XAUUSD (Gold)
• EURUSD (proxy for DXY, U.S. Dollar Index)
• VIX (Volatility Index)
• TLT (20y U.S. Treasury Bonds ETF)
By monitoring these dynamic correlations, traders can identify whether BTC is moving in sync with risk assets or decoupling as a hedge, and adjust their trading strategy accordingly.
How it works
1. Computes returns for BTC and each asset using percentage change.
2. Uses the rolling correlation function (ta.correlation) over a configurable window length (default = 12 bars).
3. Plots each correlation as a separate colored line (Gold = Yellow, EURUSD = Blue, VIX = Red, TLT = Green).
4. Adds threshold levels at +0.3 and -0.3 to help classify correlation regimes.
How to use it
• High positive correlation (> +0.3): BTC is moving together with the asset (risk-on behavior).
• Near zero (-0.3 to +0.3): BTC is showing little to no correlation — neutral/independent moves.
• Negative correlation (< -0.3): BTC is moving in the opposite direction — potential hedge opportunity.
Practical strategies:
• Watch BTC vs VIX: a spike in volatility (VIX ↑) usually coincides with BTC selling pressure.
• Track BTC vs EURUSD: stronger USD often puts downside pressure on BTC.
• Observe BTC vs Gold: during “flight to safety” events, gold rises while BTC weakens.
• Monitor BTC vs TLT: rising yields (falling TLT) often align with BTC weakness.
Inputs
• Window Length (bars): Number of bars used to calculate rolling correlations (default = 12).
• Comparison Timeframe: Default = 5m. Can be changed to align with your intraday or swing trading style.
Notes
• Works best on intraday charts (1m, 5m, 15m) for scalping and short-term setups.
• Use correlations as context, not standalone signals — combine with volume, VWAP, and price action.
• Correlations are dynamic; they can switch regimes quickly during macro events (CPI, NFP, FOMC).
This tool is designed for traders who want to manage risk exposure by monitoring whether BTC is behaving as a risk-on asset or hedge, and to exploit opportunities during decoupling phases. Indicator
Indicator
Support Resistance UltimateThe "Support Resistance ULTIMATE" indicator is a comprehensive tool for traders on the PulseWire platform, designed to identify key support and resistance levels using two primary techniques: pivot points and volume data. This indicator provides flexibility and customization, allowing traders to adapt it to their specific trading strategies.
KEY FEATURES
Pivot-Based Levels:
This feature calculates support and resistance levels using pivot points, which are derived from the high, low, and close prices of previous trading periods. Pivot points are crucial for forecasting potential market turning points.
Users can customize the pivot calculation by selecting the source type (either 'Close' or 'High/Low') and adjusting the lookback periods for both the left and right sides of the pivot calculation. This flexibility allows traders to adapt the indicator to different market conditions and timeframes.
Volume-Based Levels:
This option focuses on identifying support and resistance levels based on volume data, specifically the Point of Control (POC). The POC represents the price level with the highest traded volume during a specific time period, reflecting a consensus value among market participants.
The indicator includes a rolling POC calculation, allowing traders to dynamically assess areas of significant trading interest that may serve as support or resistance zones.
ADVANTAGES
Customization and Flexibility:
Traders can choose between pivot-based and volume-based levels or use both simultaneously, depending on their analysis needs. This dual approach provides a comprehensive view of market dynamics, accommodating various trading styles.
The indicator offers customizable color settings for support and resistance lines, enhancing chart readability and allowing traders to personalize their visual analysis.
Enhanced Market Insights:
By utilizing pivot points, traders can identify potential reversal or consolidation points, aiding in the prediction of market trends and the establishment of strategic entry and exit points.
Volume-based levels provide insights into market sentiment and participation, highlighting areas of strong support or resistance based on trading volume. This can improve risk management and trade execution by identifying high-probability trading zones.
Importance Scoring:
The indicator calculates the importance of each level based on the number of touches and the duration it holds. This scoring system helps traders assess the strength of support and resistance levels, with thicker lines indicating more significant levels.
This indicator is intended for educational and informational purposes only and should not be considered financial advice. Trading involves significant risk, and you should consult with a financial advisor before making any trading decisions. The performance of this indicator is not guaranteed, and past results do not predict future performance. Use at your own risk. Indicator
VWAP RollingThis indicator, referred to here as "VWAP Rolling," is a technical tool designed to provide insight into the average price at which an asset has traded over a specified rolling period, along with bands that can indicate potential overbought or oversold conditions based on standard deviations from this rolling VWAP.
Purpose and Utility:
The indicator's primary purpose is to track the volume-weighted average price (VWAP) over a specified period, typically 20 bars in this script. The VWAP Rolling is particularly useful in assessing the average price level at which a security has been traded over the recent history, incorporating both price and volume data. This can help traders understand the prevailing market price in relation to trading volume.
Advantages:
1. Dynamic Average: Unlike fixed VWAP indicators that calculate over a specific session, the rolling VWAP adapts to recent price and volume changes, offering a more responsive and dynamic average.
2. Volume Sensitivity: By weighting prices by volume, the rolling VWAP gives more importance to periods with higher trading activity, providing a clearer picture of where significant trading has occurred.
3. Standard Deviation Bands: The inclusion of standard deviation bands (configurable as 1x and 2x deviations in this script) around the rolling VWAP adds a layer of analytical depth. These bands can serve as potential areas of support and resistance, highlighting deviations from the mean price.
Singularization and Interpretation:
The VWAP Rolling indicator is singularized by its ability to adapt to changing market conditions, offering a dynamic representation of the average price level influenced by volume. To use and interpret this indicator effectively:
• Rolling VWAP Line: The main line represents the rolling VWAP. When this line trends upwards, it suggests that recent trading has been occurring at higher prices weighted by volume, indicating potential bullish sentiment. Conversely, a downtrend in the rolling VWAP may indicate bearish sentiment.
• Standard Deviation Bands: The upper and lower bands (configurable as 1x and 2x standard deviations from the rolling VWAP) are used to identify potential overbought or oversold conditions. A price crossing above the upper band may indicate overbought conditions, signaling a potential reversal or correction downwards. Conversely, a price crossing below the lower band may suggest oversold conditions, potentially signaling a bounce or reversal upwards.
• Band Interaction: Watch for interactions between price and these bands. Repeated touches or breaches of the bands can provide clues about the strength of the prevailing trend or potential reversals.
Interpretative Insights:
• Trend Confirmation: The direction of the rolling VWAP can confirm or contradict the prevailing price trend. If the price is above the rolling VWAP and the VWAP is rising, it suggests a strong bullish sentiment. Conversely, a falling rolling VWAP with prices below might indicate a bearish trend.
• ean Reversion Signals: Extreme moves beyond the standard deviation bands may signal potential mean reversion. Traders can look for price to revert back towards the rolling VWAP after such deviations.
In summary, the VWAP Rolling indicator offers traders a flexible tool to gauge average price levels and potential deviations, incorporating both price and volume dynamics. Its adaptability and standard deviation bands provide valuable insights into market sentiment and potential trading opportunities. Indicator
Indicator
Indicator
Indicator
Indicator
Indicator
Indicator
Indicator
Indicator
Volume Profile [LuxAlgo]Displays the estimate of a volume profile, with the option to show a rolling POC (point of control). Users can change the lookback, row size, and various visual aspects of the volume profile.
Settings
Basic:
Lookback: Number of most recent bars to use for the calculation of the volume profile
Row Size: Determines the number of rows used for the calculation of the volume profile
Show Rolling POC: Determines whether to display the rolling POC of the volume profile
Style:
Width (% of the box): Determines the length of the bars relative to the Lookback value
Bar Width: Width of each bar
Flip Histogram: Flips the histogram, when enabled, the histogram base will be located at the most recent candle
Gradient: Allows to color the volume profile bars with a gradient, with a color intensity determined by the length of each bar
Rows Solid Color: Color of each bar when 'Gradient' is disabled
POC Solid Color: Color of the POC when 'Gradient' is disabled
Usage
It is very common to display volume over time in order to visualize the trading activity made over a specific candle, however this is not the only way to display volume and it can be interesting to put it in relation with the price, which is what volume profiles do.
Volume profiles are displayed as price relative histograms showing the accumulated volume within certain price areas, the number of areas are determined by the row size of the volume profile. Knowing which price's area accumulated the most volume allow highlighting areas of interest to market participants.
Most accumulated volume will be encountered in zones of equilibrium between buyers and sellers; that is zones of local price stationarity. These zones are highlighted by high volume nodes in the volume profile. Imbalance between buyers and sellers are highlighted by thinner zones of the volume profile.
The price level with the most accumulated volume is highlighted by the "point of control" (POC), displayed by the dotted line in the indicator.
The POC is often considered an important level, commonly used as support/resistance by traders. One can verify the accuracy of this use case by using the rolling POC (assuming one would use the POC over time as SR).
Indicator Limitations
Volume profiles are calculated using tick data, which is not the case of this estimate, as such you won't have an accurate representation of an actual volume profile.
The rolling POC can introduce time outs in the script computation, use lower lookback and row size value to display it. Indicator
Indicator
Indicator
