Zero-Lag GARCH Bands | NAL1. Overview
Zero-Lag GARCH Bands | NAL is an adaptive volatility band indicator built from a Zero-Lag EMA baseline and an optimized GARCH-style volatility engine.
The indicator does not use a standard fixed-width channel. Instead, it estimates market variance through a recursive GARCH framework, smooths that volatility with a Zero-Lag EMA, and uses the result to create dynamic upper and lower bands around price structure.
The purpose of the indicator is to identify when price escapes a volatility-adjusted regime boundary, while allowing the band width to adapt to the underlying variance environment.
2. Calculation
The indicator starts by estimating volatility from lagged log returns. These returns are squared to create a variance component, which becomes the foundation of the GARCH model.
GARCH_LogReturn = math.log(close / close )
GARCH_SquaredLogReturn = math.pow(GARCH_LogReturn, 2.0)
GARCH_RealizedVariance = ta.sma(GARCH_SquaredLogReturn, GARCH_Lookback)
The script then searches through possible coefficient weights to find a beta/lambda value that better fits recent realized variance behavior. A second optimization loop is used to estimate gamma, which controls the long-run variance contribution.
These optimized coefficients are combined into a GARCH-style variance model using three components: long-run variance, recent shock variance, and lagged variance.
GARCH_Variance =
GARCH_Gamma * GARCH_LongRunVariance +
GARCH_Alpha * GARCH_SquaredLogReturn +
GARCH_Beta * GARCH_LaggedVariance
After the variance estimate is created, it is smoothed using a Zero-Lag EMA. This gives the volatility engine a faster response while still reducing noise.
GARCH_ProjectedVariance = f_zlema(GARCH_Variance, GARCH_SmoothLen)
GARCH_Volatility = math.sqrt(math.max(GARCH_ProjectedVariance, 0.0))
The baseline is also built with a Zero-Lag EMA, applied after a light EMA pre-smoothing step. This creates the central reference line for the band structure.
The final bands are created by scaling the Zero-Lag GARCH volatility against the selected source and band pressure setting. Higher band pressure creates a tighter band, while lower pressure allows the band structure to expand.
upperBand = baseline + (baseline_src / band_pressure) * GARCH_VolatilityMultiplier
lowerBand = baseline - (baseline_src / band_pressure) * GARCH_VolatilityMultiplier
A bullish state triggers when price closes above the upper band. A bearish state triggers when price closes below the lower band. When price remains inside the bands, the previous regime is held.
3. Key Features
Zero-Lag EMA baseline for reduced-lag price structure.
Optimized GARCH-style volatility engine.
Adaptive variance model using shock, lagged, and long-run components.
Zero-Lag smoothing applied to projected volatility.
Dynamic upper and lower volatility bands.
Band pressure control for adjusting channel tightness.
State-based candle coloring, band coloring, glow effect, and directional fills.
4. Use
Zero-Lag GARCH Bands is designed to identify when price begins escaping its volatility-adjusted structure. A close above the upper band reflects bullish expansion, while a close below the lower band reflects bearish expansion.
The GARCH engine gives the indicator a deeper volatility layer than a standard ATR or deviation channel. Instead of only measuring recent range, it models variance behavior and projects that into the band structure.
This indicator is best used as a specialized module within a complete strategy framework. Its role is to isolate volatility-adjusted regime expansion, where price is evaluated against a dynamic variance boundary rather than a static channel. The full value comes from how this volatility regime signal is integrated into a broader process for timing, structure, and execution.
Indicator
G-Score | NAL1. Overview
G-Score | NAL is a volatility-adjusted Z-Score regime indicator built from two main components: a smoothed price Z-Score and an adaptive GARCH-based volatility Z-Score.
The indicator does not use fixed overbought or oversold levels. Instead, it builds dynamic thresholds from the current volatility structure of the market. Price is then measured against those volatility-derived boundaries to determine whether the market is entering a bullish or bearish statistical regime.
2. Calculation
The indicator starts by estimating volatility through a GARCH-style process. It calculates log returns from the selected source, converts those returns into squared variance, and then compares short-term variance behavior against a realized variance baseline.
GARCH_LogReturn = math.log(src / src )
GARCH_SquaredLogReturn = math.pow(GARCH_LogReturn, 2.0)
GARCH_RealizedVariance = ta.sma(GARCH_SquaredLogReturn, GARCH_Lookback)
The model then searches through possible beta and gamma coefficients to find weights that better fit the recent variance environment. These optimized coefficients are used to build a GARCH variance estimate from three components: long-run variance, recent shock variance, and lagged variance.
GARCH_Variance =
GARCH_Gamma * GARCH_LongRunVariance +
GARCH_Alpha * GARCH_SquaredLogReturn +
GARCH_Beta * GARCH_LaggedVariance
The final GARCH volatility value is created by taking the square root of the projected variance. This produces the volatility engine used later in the threshold system.
The indicator then calculates two separate Z-Scores. The first is a price Z-Score, measuring where price is relative to its own mean and deviation. The second is a volatility Z-Score, measuring where GARCH volatility is relative to its own historical distribution.
Both values are smoothed with a Jurik-style moving average to reduce noise while keeping the response relatively fast.
The volatility Z-Score is then mirrored into positive and negative boundaries. This creates dynamic upper and lower thresholds that expand and contract with the current volatility regime.
The final signal compares the smoothed price Z-Score against those adaptive volatility thresholds. A bullish state triggers when price strength expands above the upper volatility boundary. A bearish state triggers when price weakness falls below the lower volatility boundary. When price remains inside the volatility envelope, the previous regime is held.
3. Key Features
Adaptive GARCH-style volatility engine.
Price Z-Score measured against volatility-derived thresholds.
Dynamic upper and lower boundaries instead of fixed levels.
Jurik-style smoothing for both price and volatility components.
State-based candle coloring, background regime coloring, threshold fills, and transition labels.
Designed to capture statistical expansion when price moves outside its volatility-adjusted structure.
4. Use
G-Score is designed to identify when price begins separating from its normal statistical range after accounting for the current volatility environment. A move above the upper threshold reflects bullish statistical expansion, while a move below the lower threshold reflects bearish statistical expansion.
The strength of the indicator comes from the relationship between price displacement and volatility regime. Rather than treating every Z-Score reading the same, it lets volatility define the boundary that price must break.
This indicator is best used as a specialized module within a complete strategy framework. Its role is to isolate a specific statistical layer of market behavior, where price expansion is evaluated through the lens of adaptive volatility. The full value comes from how this regime signal is integrated into a broader process for timing, structure, and risk.
Indicator
Volatility Halo | NAL1. Overview
Volatility Halo | NAL is an adaptive volatility band indicator built from a Zero-Lag EMA baseline, ATR band structure, and a recursive GARCH-style volatility regime multiplier.
The indicator does not use fixed-width bands. Instead, it starts with ATR-based bands and then adjusts their width using a projected volatility regime model. This allows the bands to respond differently when market volatility is expanding, contracting, or stabilizing.
2. Calculation
The indicator starts by calculating a Zero-Lag EMA baseline from the selected source. This baseline acts as the central trend reference, helping reduce lag compared to a standard EMA while still keeping the structure smooth.
float baseline = f_zlema(src, baseline_len)
float ATR_Value = ta.atr(ATR_Len)
The ATR value is then multiplied by the user-defined ATR multiple. This forms the base volatility distance used for the upper and lower bands.
The more advanced part of the indicator is the recursive GARCH-style regime multiplier. It begins by calculating log returns and converting them into shock variance. A long-run variance estimate is then built from recent shock variance.
GARCH_LogReturn = close > 0.0 and close > 0.0 ? math.log(close / close ) : 0.0
GARCH_ShockVariance = math.pow(GARCH_LogReturn, 2.0)
GARCH_LongRunVariance = ta.ema(GARCH_ShockVariance, GARCH_LongRunLen)
The model recursively updates conditional variance using three components: recent shock variance, long-run variance, and previous conditional variance. When adaptive coefficients are enabled, the script searches for coefficient weights that better fit recent variance behavior.
GARCH_ConditionalVariance :=
GARCH_Gamma * GARCH_LongRunVariance +
GARCH_Alpha * GARCH_ShockVariance +
GARCH_Beta * GARCH_PreviousConditionalVariance
The conditional variance is then projected and converted into a volatility estimate. This volatility is compared against its own regime baseline to create a volatility regime multiplier. The multiplier is clamped between a minimum and maximum value, preventing the bands from becoming too narrow or too wide.
GARCH_Volatility = math.sqrt(math.max(GARCH_ProjectedVariance, 0.0))
GARCH_RegimeMultiplierRaw = GARCH_Volatility / GARCH_RegimeBase
GARCH_RegimeMultiplier = f_clamp(GARCH_RegimeMultiplierSmooth, GARCH_MinMult, GARCH_MaxMult)
The final band width is created by combining ATR with the GARCH regime multiplier. The upper and lower bands are placed around the Zero-Lag EMA baseline.
hybridBandWidth = ATR_Value * ATR_Mult * GARCH_RegimeMultiplier
upperBand = baseline + hybridBandWidth
lowerBand = baseline - hybridBandWidth
A bullish state triggers when price closes above the upper band. A bearish state triggers when price closes below the lower band. When price remains inside the bands, the previous state is held.
3. Key Features
Zero-Lag EMA baseline for reduced-lag trend structure.
ATR-based volatility bands.
Recursive GARCH-style conditional variance model.
Adaptive volatility regime multiplier.
Bands expand or contract based on projected volatility conditions.
State-based candle coloring, band coloring, glow effect, and regime fills.
4. Use
Volatility Halo is designed to identify moments where price begins escaping its volatility-adjusted structure. A close above the upper band reflects bullish expansion, while a close below the lower band reflects bearish expansion.
The adaptive volatility engine allows the bands to shift with the underlying market environment, making the signal more responsive to changes in pressure and regime.
This indicator is best used as a specialized module within a complete strategy framework. Its real strength appears when it is combined with a broader process for reading market behavior, timing, and risk. The full edge comes from how the signal is integrated, not from the signal existing in isolation.
Indicator
Adaptive Regression Channel Fit-Gated & CalibratedAdaptive Regression Channel — Multi-Engine, Fit-Gated & Calibrated
What it is
A regression channel that lets you choose the estimator, measures its own goodness-of-fit, and refuses to be trusted when that fit is poor. Four centerline engines, seven volatility engines for the bands, a kurtosis fat-tail multiplier, an honest √-horizon uncertainty cone, a ride-vs-revert detector, and a past-only calibration tracker that asks whether tagging the band actually precedes reversion on this symbol — measured against an unconditional base rate, in R.
Why these components belong in ONE script (not a stack of indicators)
They are the parts of one estimator, each covering a failure mode of the others:
Centerline engine. OLS is the baseline but lags at the right edge and is fragile to spikes. LOESS fixes the endpoint lag (local-linear, tricube-weighted). Theil-Sen fixes spike fragility (median of pairwise slopes). Kalman removes the window entirely (recursive level + trend). You choose the trade-off.
Adaptive window (Kaufman efficiency ratio). A fixed window is wrong in both trends and chop; the length stretches when price is efficient and contracts when it is noisy, so the channel tracks the live swing.
Volatility engine. The bands are only meaningful if their width reflects the real residual distribution: EWMA (recency), Yang-Zhang (drift-robust OHLC range), GARCH(1,1) (clustering), MAD (spike-resistance), asymmetric semidev (skew), quantile (empirical containment) — plus a kurtosis fat-tail multiplier so the stated containment actually holds.
Fit-quality gate. A channel drawn on a bad fit is noise dressed as structure. The centerline only draws solid and only emits events when it explains at least r2Gate of variance; below that it greys to dashed.
Ride-vs-revert. A band touch is ambiguous. Consecutive closes beyond the band ("walking the band") mark continuation, not reversion — so the channel does not fade a trend that is running.
Calibration. The edges are a hypothesis. Each trusted band tag is resolved forward against an unconditional same-horizon base rate, in R, so you see whether the band adds anything over noise — not a naked win-rate.
The centerline says where the mean is, the volatility engine says how wide the normal range is, the fit gate says whether to believe any of it, ride-vs-revert says fade or follow, and calibration keeps it honest. Remove any layer and the channel loses a check it cannot recover.
How it works (mechanics)
The selected engine fits the centerline in (optionally log) price space, on a window that can be fixed, ER-adaptive, or pivot-anchored to the current segment. Residual dispersion drives the bands through the chosen volatility engine, widened by the fat-tail multiplier. The fit metric is the explained-variance fraction of the residuals; below the gate the channel is shown as untrusted and emits nothing. On a trusted channel, each band tag is queued on bar close and resolved horizon bars later — a win if price moved moveATR·ATR in the reversion direction — and tallied per class (UTAG / LTAG) against the unconditional base rate.
Non-repaint: fits on confirmed closes, pivots confirmed, calibration on bar close. The drawn channel updates live (a rolling regression always does — that is description, not a signal); the calibrated events are confirmed-bar only.
How to use
Read the dashboard: FIT% and TRUSTED / LOW-FIT come first. If the fit is low, treat the channel as description only.
On a trusted channel, a band tag is a reversion hypothesis — the calibration rows tell you whether that class has actually paid on this symbol (Hit% vs Base%, Edge with a 95% star, MFE/MAE in R).
WALK means the band is being ridden (trend) — do not fade it.
The cone is an uncertainty fan (√-horizon growth), not a target.
Everything here is descriptive, probabilistic context — never an instruction.
Use on any market
The Data Source inputs (Close / High / Low) drive the fit, the band tags and the calibration, so the channel runs on any series (standard candles, Heikin-Ashi, etc.) and any market. All thresholds are ATR-relative. Defaults are set for NIFTY index-futures intraday; change the source or lengths for other assets.
Originality
The contribution is the closed loop: a selectable estimator whose fit is measured and gated, bands whose width is chosen from seven rigorous volatility models and fat-tail-corrected, a ride-vs-revert guard, and a per-class forward calibration against an unconditional base rate. Most channels draw a line and a ±σ band and stop; this one tells you whether to believe the line and whether the band has historically meant anything here.
Credits
Least squares & local regression (LOESS) — Gauss / Legendre; W. S. Cleveland
Theil-Sen estimator — H. Theil & P. K. Sen
Recursive level+trend (Kalman) filter — R. E. Kálmán
Efficiency Ratio (adaptive window) — Perry Kaufman
EWMA / RiskMetrics variance — J.P. Morgan
Yang-Zhang OHLC volatility — Dennis Yang & Qiang Zhang
GARCH(1,1) — Engle & Bollerslev
The fit-quality gate, the band-walk ride-vs-revert logic and the forward-calibration framework are the author's original implementation.
Limitations (honest)
The calibration is in-sample, close-to-close at a fixed horizon, with no costs, slippage or stops — a study aid, not a backtest, and not a probability of future results. A rolling regression updates every bar; the drawn channel is descriptive, and only the confirmed-bar tag events are calibrated. Theil-Sen is O(n²) in pairs (capped for speed). Past behaviour does not assure future behaviour.
Disclaimer
Educational / informational study for chart analysis only. NOT financial advice, NOT a strategy, NOT a recommendation. It places no orders and guarantees no outcome. Markets carry risk; do your own research and manage your own risk. Paper-trade before risking real money. Indicator
Options Probabilistic Bounds [InferredSignals]█ OVERVIEW
Options Probabilistic Bounds (OPB) draws a forward price corridor on the daily chart — an upper and a lower band projected over a horizon you choose (1 to 20 trading days) at a confidence level you choose (default 95%).
In plain words: given how this stock has actually been moving, where could the CLOSING price realistically land over the next few days? The corridor is calibrated so that, at each horizon, roughly your chosen percentage of closes finish inside it.
It is built for option sellers — short puts in particular. The lower band is a statistically calibrated reference for where to place a strike. And because the corridor takes no view on direction, OPB adds something most volatility tools don't: a drift readout that tells you which side currently has the wind at its back, so you can see whether puts or calls are the safer leg to sell right now.
No option-chain data is used anywhere — no implied volatility, no greeks, no implied-vol skew. "Options" describes who the tool is for, not what it reads. OPB is a pure statistical model of the underlying's own price history.
█ WHAT MAKES IT ORIGINAL
• Per-symbol MAP-style calibration, entirely in Pine.
Parameters are fitted to each ticker by minimizing a penalized negative log-posterior — Student-t likelihood, Bayesian-style priors, and residual-moment penalties combined in one objective — searched multi-start and coarse-to-fine, with the winner chosen on residual quality, not likelihood alone. The result: less in-sample curve-fitting and a steadier calibration than a plain best-fit vol model.
• Two-component, leverage-aware GJR-GARCH variance.
A slow long-run level plus a faster mean-reverting short-run component, so a volatility shock decays over a few days instead of holding the corridor wide for weeks. Negative-return days get a specific leverage response — downside risk is modeled, not averaged away.
• Filtered historical tails with EVT extension.
The residual body is empirical (Filtered Historical Simulation); each tail is extended with a Generalized Pareto fit whose shape and scale are estimated in closed form by Probability-Weighted Moments (Hosking-Wallis) — more stable than method-of-moments or MLE on the small tail samples you actually get. The shape is floored at zero so equity tails are never assumed bounded, and with too few exceedances it falls back to empirical quantiles rather than overfitting noisy extremes.
• Data-driven downside asymmetry.
The downside leverage increment is routed fully to the lower band; the upper band receives only a data-driven semivariance fraction. The corridor widens below only as far as the symbol's own history justifies.
█ THE DRIFT READOUT — WHICH SIDE TO SELL
The bands are DRIFT-NEUTRAL by design: centered on today's close, never tilted up or down. Over 1–20 days, direction is effectively unestimable from price history — and a wrong directional bet would quietly under-reserve the downside, the worst place to be short a put. So the whole band width is spent on dispersion, none of it gambled on a direction the data can't support.
OPB still measures the recent drift and reports it as a small number next to σ, in :
• ↑ : favors puts — the stock has been drifting up, so the put leg has had a cushion.
• ↓ : favors calls — drifting down, the call leg has had the cushion.
• flat — no meaningful drift.
Practical read: it is usually safer to sell the leg the drift is moving AWAY from — sell puts into an uptrend, calls into a downtrend. The wind at your back.
In the backtest this shows up cleanly: on a strongly trending stock the drift-neutral bands breach the TREND side more often than the nominal rate, while the opposite side stays close to it. This is expected, not miscalibration — the corridor is honestly direction-agnostic, so the band width itself stays unbiased and the extra breaches on the trend side are pure drift. The takeaway matches the readout: the side you should be selling — the one the trend is moving away from — is the side that stays calibrated. One caveat: the drift readout is the RECENT past, never a forecast — a strong reading is often exactly where mean-reversion becomes most likely. The fat-tailed band remains the real safety net.
MU · daily · walk-forward, monthly recals. On this uptrend the trend side (Brch+) runs well above nominal while the put-sell side (Brch−) holds at/below its 2.5% target — the drift asymmetry described above, in numbers.
█ HOW TO USE IT
• Set a horizon (e.g. 5 days) and a confidence level (e.g. 95%).
• Read the upper/lower band at your horizon as a strike-placement reference.
• Glance at the drift readout to pick the safer leg — puts vs calls.
• Turn on the walk-forward backtest and check: Close-in ≈ your confidence level; Brch+ / Brch− near the per-side rate and reasonably balanced; NT dn = how often a lower-band strike was never touched over the whole path — the number that matters for assignment.
• Optional PIT diagnostic: D ≈ 1 well-sized, D < 1 too wide, D > 1 too narrow. Read h = 1 first (least affected by overlapping windows).
• Anchor mode D-1…D-5 freezes the corridor as it looked N days ago, calibrated only on data known then — handy to inspect how past corridors held.
█ SETTINGS
Defaults are robust and research-oriented: Horizon 5d · Confidence 95% · Calibration window 252d · Two-component variance ON · Leverage-asymmetric bands ON · Earnings-gap neutralization ON.
"Long-run half-life" sets how steady the long-run volatility baseline is — a higher value keeps it stiffer after a shock, which (with the two-component model on) reduces post-shock over-widening.
Every input ships with a plain-language tooltip. Daily timeframe only. Calibration runs on the last bar for performance; walk-forward recalibration is monthly, a Pine execution-time constraint.
█ WHAT IT IS NOT
• Not a directional forecast — the corridor is drift-neutral, centered on the anchor close.
• Not a joint path bound — confidence targets the close at each horizon separately; the chance of touching a band along the path is the separate No-Touch figure (see backtest).
• Not an option-pricing model — no implied volatility, greeks, or option-chain data.
• Not a guarantee — the backtest and PIT diagnostics are historical calibration evidence, not a promise of future coverage.
Full methodology, equations, and references are documented section by section in the source code. This is a research and educational tool, not investment advice.
Indicator
GARCH Volumetric Cloud [MarkitTick]💡 The GARCH Volumetric Cloud is a highly advanced, institutional-grade trend-following and volatility-tracking indicator designed to filter market noise and pinpoint high-probability trend reversals. By synergizing a dynamic volatility engine inspired by conditional heteroskedasticity models with the smoothing properties of synthetic Heikin-Ashi price action, this tool offers traders a multi-dimensional perspective on market dynamics. It goes beyond simple price crossovers by mathematically confirming that a structural shift in trend is supported by an underlying surge in market volatility. This dual-verification approach significantly reduces the likelihood of entering false breakouts or getting trapped in ranging, low-momentum environments.
✨ Originality and Utility
Standard technical indicators often rely on a single dimension of market data, such as moving averages for trend or the Average True Range for volatility. This script breaks the mold by calculating a real-time variance proxy based on squared logarithmic returns, effectively bridging the gap between academic quantitative finance and retail charting. The originality lies in its "Volatility Gatekeeper" mechanism. The system only validates trend signals when the market is experiencing a mathematically significant expansion in variance, preventing the underlying Heikin-Ashi cloud from signaling entries during dormant or strictly mean-reverting phases.
Furthermore, the script calculates synthetic Heikin-Ashi values internally without relying on secondary chart inputs or delayed security calls. This ensures seamless integration, zero lookahead bias, and absolute synchronization with the current timeframe. It combines this with a fully integrated JSON webhook alert system, making it an all-in-one solution for both manual discretionary traders and automated systematic execution.
🔬 Methodology and Concepts
The core methodology is divided into two distinct processing engines that operate in parallel and converge to generate actionable signals.
● Volatility Engine
The system first determines the period-over-period return, giving the user the option to utilize logarithmic returns for superior statistical normalization.
These returns are squared to calculate raw variance.
To model volatility clustering (the tendency for volatile periods to cluster together), the script applies an Exponentially Weighted Moving Average (EWMA) to the squared returns.
This EWMA acts as a dynamic variance proxy, prioritizing recent market shocks while retaining a memory of historical data, governed by the Lambda decay factor.
The square root of this variance proxy is taken to return the value to a standard volatility scale.
A localized volatility threshold is established by calculating a Simple Moving Average and Standard Deviation of this volatility proxy. A "High Volatility" state is triggered when the current volatility exceeds the moving average plus a user-defined multiple of the standard deviation.
● Trend Cloud Engine
The script derives mathematical Heikin-Ashi price points (Open, High, Low, Close) independently of the user's primary chart type.
Four distinct Exponential Moving Averages (EMAs) are applied sequentially to the synthetic Heikin-Ashi Close price.
The structural trend state is determined by the relationship between the Fast EMA and the Slow EMA.
When the Fast EMA crosses above the Slow EMA, the internal state shifts to Bullish. When it crosses below, the state shifts to Bearish.
🎨 Visual Guide
The visual interface of the indicator is designed to provide immediate situational awareness through color-coded elements and structural bands.
● Synthetic Heikin-Ashi Candles
The indicator plots custom candles directly on the chart, overriding the standard visual noise.
Bullish Theme: Colored in vivid Cyan (#00E5FF) when the underlying cloud structure is in an upward trend.
Bearish Theme: Colored in distinct Pink/Red (#FF3D71) when the underlying cloud structure shifts downward.
The bodies, borders, and wicks are synchronized to these specific themes to maintain a clean visual hierarchy.
● The Moving Average Cloud
Cloud L1 (Fast): Plotted as a solid line with 40 percent opacity.
Cloud L4 (Slow): Plotted as the foundational boundary line, also at 40 percent opacity.
Cloud Spine: A thicker, central moving average derived from the midpoint of the inner EMAs, drawn at 20 percent opacity to serve as a micro-support/resistance level within the broader cloud structure.
Gradient Fills: The space between the four EMA lines is filled with cascading color opacities (50 percent, 65 percent, and 78 percent), creating a three-dimensional visual depth that expands during strong trends and pinches during consolidation.
📖 How to Use
Applying this indicator requires an understanding of its dual-verification logic. It is not designed to trade every crossover, but rather to isolate structural shifts.
● Identifying Opportunities
A valid Long signal occurs when the Fast EMA crosses above the Slow EMA, but only if the previous candle was mathematically classified as being in a "High Volatility" state by the GARCH engine.
A valid Short signal occurs when the Fast EMA crosses below the Slow EMA under the exact same high-volatility prerequisite.
Visually, traders should look for a color shift in the cloud and candles, accompanied by a sharp widening of the cloud structure.
● Automation and Execution
The script calculates a dynamic Stop Loss based on the lowest low of the last 5 bars for long positions, and the highest high of the last 5 bars for short positions.
The Take Profit is mechanically projected using a strict 1:1.5 risk-to-reward ratio based on the calculated Stop Loss distance.
These parameters are packaged into a JSON payload and fired via webhook at the exact moment the signal bar closes and confirms, ensuring zero repainting and immediate execution for connected bots.
⚙️ Inputs and Settings
The indicator provides deep customization options, allowing traders to tune the engines to specific assets and timeframes.
● GARCH Volume Engine
Use EWMA: Toggles between the exponentially weighted variance model and a simple moving average of variance.
Log Returns: Enables logarithmic return calculations for more accurate financial time-series modeling.
Variance Length: Defines the lookback period for the initial variance baseline.
Threshold Lookback: Sets the window for the standard deviation bands applied to the final volatility proxy.
EWMA Lambda: The decay factor for the weighted average. A standard setting of 0.94 mirrors classic RiskMetrics methodology.
High Volatility Band: The standard deviation multiplier required to trigger a "High Volatility" validation state.
● Cloud & Trend Engine
Cloud Fast Length: The lookback for the primary reactive EMA.
Cloud Mid-Fast Length: The first internal structural EMA.
Cloud Mid-Slow Length: The second internal structural EMA.
Cloud Slow Length: The foundational EMA that determines the overall baseline trend.
● Webhook Actions (Automation)
Action Long: The string identifier sent in the JSON payload when a bullish setup is confirmed.
Action Short: The string identifier sent in the JSON payload when a bearish setup is confirmed.
🔍 Deconstruction of the Underlying Scientific and Academic Framework
The architectural foundation of this script is deeply rooted in quantitative financial theory, specifically drawing from time-series econometrics and signal processing. The volatility engine is a deterministic approximation of the Generalized Autoregressive Conditional Heteroskedasticity (GARCH) model. In standard financial mathematics, asset returns do not exhibit constant variance; instead, they experience periods of clustered turbulence and clustered calm.
By calculating the squared log returns, the script isolates the magnitude of price movement independently of directional drift. The application of an Exponentially Weighted Moving Average (EWMA) to these squared returns serves as the conditional variance estimator. The Lambda parameter acts as the memory decay coefficient. By setting this coefficient high (e.g., 0.94), the model ensures that the volatility proxy reacts aggressively to sudden market shocks (such as a macroeconomic data release or institutional block order) while slowly decaying back to the mean, perfectly mirroring the theoretical decay of implied volatility in options pricing.
Parallel to the econometric variance modeling, the script employs a cascaded digital filter design via the Heikin-Ashi EMA cloud. The Heikin-Ashi transformation modifies the standard Open-High-Low-Close data points to incorporate previous period averages, inherently introducing an autoregressive smoothing effect that diminishes high-frequency market noise. By passing this pre-smoothed data through a series of four Exponential Moving Averages, the system applies a multi-pole low-pass filter. The dispersion between the Fast EMA and Slow EMA represents the momentum vector of the trend. The final gating logic, which demands that a structural moving average crossover must be contemporaneous with a statistically significant deviation in the EWMA variance proxy, is a sophisticated method of reducing Type I errors (false positives) in algorithmic trend-following systems.
⚠️ Disclaimer
All provided scripts and indicators are strictly for educational exploration and must not be interpreted as financial advice or a recommendation to execute trades. I expressly disclaim all liability for any financial losses or damages that may result, directly or indirectly, from the reliance on or application of these tools. Market participation carries inherent risk where past performance never guarantees future returns, leaving all investment decisions and due diligence solely at your own discretion. Indicator
Indicator
Indicator
[SGM GARCH Volatility]I'm excited to share with you a Pine Script™ that I developed to analyze GARCH (Generalized Autoregressive Conditional Heteroskedasticity) volatility. This script allows you to calculate and plot GARCH volatility on PulseWire. Let's see together how it works!
Introduction
Volatility is a key concept in finance that measures the variation in prices of a financial asset. The GARCH model is a statistical method that predicts future volatility based on past volatilities and prediction residuals (errors).
Indicator settings
We define several parameters for our indicator:
length = input.int(20, title="Length")
p = input.int(1, title="Lag order (p)")
q = input.int(1, title="Degree of moving average (q)")
cluster_value = input(0.2,title="cluster value")
length: The period used for the calculations, default 20.
p: The order of the delay for the GARCH model.
q: The degree of the moving average for the GARCH model.
cluster_value: A threshold value used to color the graph.
Calculation of logarithmic returns
We calculate logarithmic returns to capture price changes:
logReturns = math.log(close) - math.log(close )
Initializing arrays
We initialize arrays to store residuals and volatilities:
var float residuals = array.new_float(length, 0)
var float volatilities = array.new_float(length, 0)
We add the new logarithmic returns to the tables and keep their size constant:
array.unshift(residuals, logReturns)
if (array.size(residuals) > length)
array.pop(residuals)
We then calculate the mean and variance of the residuals:
meanResidual = array.avg(residuals)
varianceResidual = array.stdev(residuals, meanResidual)
volatility = math.sqrt(varianceResidual)
We update the volatility table with the new value:
array.unshift(volatilities, volatility)
if (array.size(volatilities) > length)
array.pop(volatilities)
GARCH volatility is calculated from accumulated data:
var float garchVolatility = na
if (array.size(volatilities) >= length and array.size(residuals) >= length)
alpha = 0.1 // Alpha coefficient
beta = 0.85 // Beta coefficient
omega = 0.01 // Omega constant
sumVolatility = 0.0
for i = 0 to p-1
sumVolatility := sumVolatility + beta * math.pow(array.get(volatilities, i), 2)
sumResiduals = 0.0
for j = 0 to q-1
sumResiduals := sumResiduals + alpha * math.pow(array.get(residuals, j), 2)
garchVolatility := math.sqrt(omega + sumVolatility + sumResiduals)
Plot GARCH volatility
We finally plot the GARCH volatility on the chart and add horizontal lines for easier visual analysis:
plt = plot(garchVolatility, title="GARCH Volatility", color=color.rgb(33, 149, 243, 100))
h1 = hline(0.1)
h2 = plot(cluster_value)
h3 = hline(0.3)
colorGarch = garchVolatility > cluster_value ? color.red: color.green
fill(plt, h2, color = colorGarch)
colorGarch: Determines the fill color based on the comparison between garchVolatility and cluster_value.
Using the script in your trading
Incorporating this Pine Script™ into your trading strategy can provide you with a better understanding of market volatility and help you make more informed decisions. Here are some ways to use this script:
Identification of periods of high volatility:
When the GARCH volatility is greater than the cluster value (cluster_value), it indicates a period of high volatility. Traders can use this information to avoid taking large positions or to adjust their risk management strategies.
Anticipation of price movements:
An increase in volatility can often precede significant price movements. By monitoring GARCH volatility spikes, traders can prepare for potential market reversals or accelerations.
Optimization of entry and exit points:
By using GARCH volatility, traders can better identify favorable times to enter or exit a position. For example, entering a position when volatility begins to decrease after a peak can be an effective strategy.
Adjustment of stops and objectives:
Since volatility is an indicator of the magnitude of price fluctuations, traders can adjust their stop-loss and take-profit orders accordingly. Periods of high volatility may require wider stops to avoid being exited from a position prematurely.
That's it for the detailed explanation of this Pine Script™ script. Don’t hesitate to use it, adapt it to your needs and share your feedback! Happy analysis and trading everyone! Indicator
HMA w/ SSE-Dynamic EWMA Volatility Bands [Loxx]This indicator is for educational purposes to lay the groundwork for future closed/open source indicators. Some of thee future indicators will employ parameter estimation methods described below, others will require complex solvers such as the Nelder-Mead algorithm on log likelihood estimations to derive optimal parameter values for omega, gamma, alpha, and beta for GARCH(1,1) MLE and other volatility metrics. For our purposes here, we estimate the rolling lambda (λ) value used to calculate EWMA by minimizing of the sum of the squared errors minus the long-run variance--a rolling window of the one year mean of squared log-returns. In practice, practitioners will use a λ equal to a standardized value put out by institutions such as JP Morgan. Even simpler than this, others use a ratio of (per - 1) / (per + 1) to derive λ where per is the lookback period for EWMA. Due to computation limits in Pine, we'll likely not see a true GARCH(1,1) MLE on Pine for quite some time, but future closed source indicators will contain some very interesting industry hacks to get close by employing modifications to EWMA. Enjoy!
Exponentially weighted volatility and its relationship to GARCH(1,1)
Exponentially weighted volatility--also called exponentially weighted moving average volatility (EWMA)--puts more weight on more recent observations. EWMA is calculated as follows:
σ*2 = λσ(n - 1)^2 + (1 − λ)u(n - 1)^2
The estimate, σn, of the volatility for day n (made at the end of day n − 1) is calculated from σn −1 (the estimate that was made at the end of day n − 2 of the volatility for day n − 1) and u^n−1 (the most recent daily percentage change).
The EWMA approach has the attractive feature that the data storage requirements are modest. At any given time, we need to remember only the current estimate of the variance rate and the most recent observation on the value of the market variable. When we get a new observation on the value of the market variable, we calculate a new daily percentage change to update our estimate of the variance rate. The old estimate of the variance rate and the old value of the market variable can then be discarded.
The EWMA approach is designed to track changes in the volatility. Suppose there is a big move in the market variable on day n − 1 so that u2n−1 is large. This causes our estimate of the current volatility to move upward. The value of λ governs how responsive the estimate of the daily volatility is to the most recent daily percentage change. A low value of λ leads to a great deal of weight being given to the u(n−1)^2 when σn is calculated. In this case, the estimates produced for the volatility on successive days are themselves highly volatile. A high value of λ (i.e., a value close to 1.0) produces estimates of the daily volatility that respond relatively slowly to new information provided by the daily percentage change.
The RiskMetrics database, which was originally created by JPMorgan and made publicly available in 1994, used the EWMA model with λ = 0.94 for updating daily volatility estimates. The company found that, across a range of different market variables, this value of λ gives forecasts of the variance rate that come closest to the realized variance rate. In 2006, RiskMetrics switched to using a long memory model. This is a model where the weights assigned to the u(n -i)^2 as i increases decline less fast than in EWMA.
GARCH(1,1) Model
The EWMA model is a particular case of GARCH(1,1) where γ = 0, α = 1 − λ, and β = λ. The “(1,1)” in GARCH(1,1) indicates that σ^2 is based on the most recent observation of u^2 and the most recent estimate of the variance rate. The more general GARCH(p, q) model calculates σ^2 from the most recent p observations on u2 and the most recent q estimates of the variance rate.7 GARCH(1,1) is by far the most popular of the GARCH models. Setting ω = γVL, the GARCH(1,1) model can also be written:
σ(n)^2 = ω + αu(n-1)^2 + βσ(n-1)^2
What this indicator does
Calculate log returns log(close/close(1))
Calculates Lambda (λ) dynamically by minimizing the sum of squared errors. I've restricted this to the daily timeframe so as to not bloat the code with additional logic required to derive an annualized EWMA historical volatility metric.
After the Lambda is derived, EWMA is calculated one last time and the result is the daily volatility
This daily volatility is multiplied by the source and the multiplier +/- the HMA to create the volatility bands
Finally, daily volatility is multiplied by the square-root of days per year to derive annualized volatility. Years are trading days for the asset, for most everything but crypto, its 252, for crypto is 365.
Indicator
Garch (1,1) ModelThe Garch (General Autoregressive Conditional Heteroskedasticity) model is a non-linear time series model that uses past data to forecast future variance.
The Garch (1,1) formula is:
Garch = (gamma * Long Run Variance) + (alpha * Squared Lagged Returns) + (beta * Lagged Variance)
The gamma, alpha, and beta values are all weights used in the Garch calculations. According to RiskMetrics by JP Morgan, the optimal beta weight is 0.94, but this figure is highly disputed in the academic realm. The biggest problem academics and economists have with the 0.94 figure is that JP Morgan used monthly data to come to this number, meaning it does not take other time frames into account. Because of the disputed nature of what beta should be, this script will automatically calculate the beta weight for you in real time, taking into account the time frame you're using and realized variance, by using the Minimum Sum of Squared Errors Method.
The gamma and alpha weights are also calculated for you.
Even though the Garch formula provides today's projected variance, today's projected deviation is also calculated. This is done by taking the square root of Garch.
Additionally, if you want to project the variance or deviation for as many days forward as you want, you can.
In order to project the variance and deviation beyond just today, these equations are used:
Projected Variance = Long Run Variance + (alpha + beta)^Days Forward * (Garch - Long Run Variance)
Projected Deviation = sqrt(Projected Variance)
How to use this model:
1st. Decide the type of data you want: Projected Variance in % or Projected Deviation in %.
2nd. Decide how many days you want projected forward. If you input 0, you will get projections for today. If you input 1, you will get projections for tomorrow, and etc.
That's it. If you have any further questions, I left detailed comments in the code explaining each step, as best as I could. Indicator
