Global M2 Money Supply Top20 + Offset & WaveThe M2 Top20 is a global aggregation of the M2 money supply from the 20 largest economies in the world , providing a comprehensive view of the total liquidity in the global financial system. It is expressed in trillions of USD.
This script calculates and visualizes the M2 Money Supply of the Top 20 Global Economies, adjusted to various timeframes (4H, 1D, 1W, 1M) with customizable offset adjustments (in days) from -1000 days to +1000 days. This indicator includes data from the Americas, Europe, Africa, and the Asia Middle East , offering a diverse and balanced representation of major economic regions. The M2 of each country has been converted to USD.
Additionally, the user can set a minimum and maximum offset to create a wave around the main offset and expand the comparison.
Combining these options, this indicator enables users to visualize a range of the global money supply, making it useful for market analysis, economic forecasting, and understanding macroeconomic trends. This indicator is particularly valuable for traders and analysts interested in understanding the dynamics of global monetary systems and their potential impact on financial markets.
Key Features:
Global M2 Money Supply calculation from the Top 20 Economies.
Adjustable Offset: Adjust the offset to align the indicator with the best bar. Adjustment in days, usable on different timeframes (1D, 1W, 4H, 1M).
Wave Projection: Displays a "probability cloud"—a smoothed area that shows the probable path of Bitcoin, derived from shifts in global liquidity.
Min/Max Offset Adjustments: Customizable offsets allow you to determine the range of future windows, helping to shape the wave and better identify liquidity-driven turning points.
Use Cases:
Economic Forecasting: Identify trends in global money supply and their potential market impact (e.g., historically leads Bitcoin price by +/- 78 days to +/-108 days).
Market Analysis: Track the growth or contraction of money supply across key economies.
Macro-Economic Analysis: Understand the relationship between monetary policies and market performance.
How to use:
Add the indicator to your chart.
Set the timeframe to 1D to customize the offset.
Set the Offset (in days).
Set the Offset Range Minimum and Maximum.
Show/Hide the Range Wave
.
Use offset = 0 to have the indicator align directly with the current data, without any shift, providing a baseline for comparison with the most recent market conditions.
Countries included in the M2 Top20:
China (CN), Japan (JP), South Korea (KR), Hong Kong (HK), Taiwan (TW), India (IN), Saudi Arabia (SA), Thailand (TH), Vietnam (VN), United Arab Emirates (AE), Malawi (MW) – Africa, United States (US), Canada (CA), Brazil (BR), Mexico (MX), Eurozone (EU), United Kingdom (GB), Russia (RU), Poland (PL), Switzerland (CH).
These countries were selected from the ranking of the World Economy Indicator of Trading View .
Cari dalam skrip untuk "如何用wind搜索股票的发行价和份数"
Gabriel's Adaptive MA📜 Gabriel's Adaptive MA — Indicator Description
Gabriel's Adaptive Moving Average (GAMA) is a dynamic trend-following indicator that intelligently adjusts its smoothing based on both trend strength and market volatility.
It is designed to provide faster responsiveness during strong moves while maintaining stability during choppy or consolidating periods.
🧠 What it does:
This indicator plots a custom-built, highly dynamic Moving Average that adapts itself intelligently based on:
Trend Strength (via Perry Kaufman's Efficiency Ratio)
Market Volatility (via Tushar Chande's Volatility Ratio)
It reacts faster when the market is trending strongly and/or highly volatile,
and it smooths out and slows down when the market is choppy or calm.
🔍 How it works (step-by-step):
1. User Inputs:
length: (default 14)
How many bars to look back for calculations.
fastSC: Fastest possible smoothing constant (hardcoded as 2 / (2+1))
slowSC: Slowest possible smoothing constant (hardcoded as 2 / (30+1))
(These are used to control how fast/slow the KAMA can react.)
2. Calculate Trendiness — Kaufman Efficiency Ratio (ER):
Net Change = Absolute difference between current close and close from length bars ago.
Sum of Absolute Changes = Sum of absolute price changes between every bar inside the length window.
Efficiency Ratio (ER) = Net Change divided by Sum of Changes.
✅ If ER is close to 1 → Smooth, trending market.
✅ If ER is close to 0 → Choppy, sideways market.
3. Calculate Bumpiness — Volatility Ratio (VR):
Short-Term Volatility = Standard deviation of close over length.
Long-Term Volatility = Standard deviation of close over length * 2.
Volatility Ratio (VR) = Short-Term Volatility divided by Long-Term Volatility.
✅ If VR is >1 → Market is becoming more volatile recently.
✅ If VR is <1 → Market is calming down.
4. Create the Hybrid Alpha:
Multiply ER × VR.
Then square the result (math.pow(..., 2)).
This hybrid alpha decides how aggressive the MA should be based on both trend and volatility.
If ER and VR are both strong → big alpha → fast movement.
If ER and/or VR are weak → small alpha → slow movement.
5. Calculate the Final Adaptive Smoothing Constant (hybridSC):
hybridSC = slowSC + hybridAlpha × (fastSC - slowSC)
This smoothly interpolates between the slowest and fastest smoothing depending on market conditions.
6. Calculate and Plot the Adaptive MA:
The moving average is manually calculated:
hybridMA := na(hybridMA ) ? close : hybridMA + hybridSC * (close - hybridMA )
It behaves like an EMA but with dynamic smoothing, not a fixed alpha.
✅ If hybridSC is high → MA hugs the price closely.
✅ If hybridSC is low → MA stays smooth and resists noise.
Finally, it plots this Adaptive MA on the chart in blue color.
📊 Visual Summary
Market Type What Happens to GAMA
Trending hard + volatile Follows price quickly
Trending hard + calm Follows steadily but carefully
Sideways + volatile Reacts carefully (won't chase noise)
Sideways + calm Smooths heavily (avoids fakeouts)
✨ Main Strengths:
Adapts automatically without you tuning settings manually every time market changes.
Responds smartly to both trend quality (ER) and market energy (VR).
Reduces lag during real moves.
Filters out false signals during choppy mess.
🧪 Key Innovation compared to normal MAs:
Traditional MA Gabriel's Adaptive MA
Same smoothing every bar Dynamic smoothing every bar
Slow during fast moves Adapts fast during real moves
No understanding of volatility or trendiness Full market sensitivity
⚡ **Simple One-Line Description:**
"Gabriel's Adaptive MA is a dynamic, trend-and-volatility-sensitive moving average that intelligently adjusts its speed to match market conditions."
Weekday Colors with Time Highlighting by NabojeetThis script is a Pine Script (version 6) indicator called "Weekday Colors with Time Highlighting" designed for TradingView charts. It has several key functions:
1. **Weekday Color Coding**:
- Assigns different background colors to each trading day (Monday through Friday)
- Allows users to customize the color for each day
- Includes toggles to enable/disable colors for specific days
2. **Time Range Highlighting**:
- Highlights a specific time period (e.g., 18:15-18:30) on every trading day
- Uses a custom color that can be adjusted by the user
- The time range is specified in HHMM-HHMM format
3. **High/Low Line Drawing**:
- Automatically identifies the highest high and lowest low points within the specified time range
- Draws horizontal lines at these levels when the time period ends
- Lines extend forward in time to serve as support/resistance references
- Users can customize the line color, width, and style (solid, dotted, or dashed)
The script is organized into logical sections with input parameters grouped by function (Weekday Colors, Weekday Display, Time Highlighting, and Horizontal Lines). Each section's inputs are customizable through the indicator settings panel.
This indicator would be particularly useful for traders who:
- Want visual distinction between different trading days
- Focus on specific time periods each day (like market opens, closes, or specific sessions)
- Use intraday support/resistance levels from key time periods
- Want to quickly identify session highs and lows
The implementation resets tracking variables at the beginning of each new time range and draws the lines once the time period ends, ensuring accurate high/low marking for each day's specified time window.
Author - Nabojeet
PH Night Session HighlightTraders who want to visually separate the night session on their charts. It highlights the period from 8:01 PM to 7:59 AM (Philippine Time), making it easy to distinguish off-hours or pre-market activity, especially when analyzing crypto or 24/7 markets.
The script automatically adjusts server time (UTC) to Philippine Time (UTC+8) and overlays a soft blue background during the specified time window.
SuperZweig thrust (<= 30 dias)SuperZweig Thrust (≤ 30-day breadth trigger)
This study tracks the classic Zweig Breadth Thrust pattern, but restricts valid signals to a 30-bar (≈ 30-trading-day) window.
---
What it plots
| Plot | Meaning |
|------|---------|
| **Blue line** – `EMA10` | 10-bar exponential moving average of the _breadth ratio_:`advancing issues / (advancing + declining)` |
| **Red h-line 0.35** | Oversold threshold ( < 0.35 ) |
| **Green h-line 0.64** | Overbought threshold ( > 0.64 ) |
| **Red “×”** | The moment EMA10 crosses **down** through 0.35 |
| **Green “●”** | The moment EMA10 crosses **up** through 0.64 |
| **Green “BUY” label** | Complete Super-Zweig thrust: red × followed by green ● **within 30 daily bars** |
Signal logic
1. **Trigger phase** – when EMA10 drops below 0.35
*Script starts a 30-bar countdown.*
2. **Confirmation phase** – if, while the countdown is active, EMA10 rises above 0.64:
*A single “BUY” label is plotted beneath that bar.*
3. **Expiry** – if 30 bars elapse without the 0.64 cross, the cycle resets; no signal is produced.
4. After any valid “BUY” the cycle also resets, so a new signal requires a fresh cross < 0.35.
Inputs
* **EMA length** – default 10.
* **Advancing / Declining symbols** – default `ADVS` / `DECS` (NYSE issues); can be pointed to any Exchange-specific or custom breadth tickers.
Typical use
Apply on a **daily chart** of a broad index (e.g., S&P; 500).
A printed “BUY” indicates a historically rare surge in market breadth often associated with durable rallies. Combine with other risk-management and trend filters before trading.
SynchroTrend Oscillator (STO) [PhenLabs]📊 SynchroTrend Oscillator
Version: PineScript™ v5
📌 Description
The SynchroTrend Oscillator (STO) is a multi-timeframe synchronization tool that combines trend information from three distinct timeframes into a single, easy-to-interpret oscillator ranging from -100 to +100.
This indicator solves the common problem of having to analyze multiple timeframe charts separately by consolidating trend direction and strength across different time horizons. The STO helps traders identify when markets are truly synchronized across timeframes, potentially indicating stronger trend conditions and higher probability trading opportunities.
Using either Moving Average crossovers or RSI analysis as the trend definition metric, the STO provides a comprehensive view of market structure that adapts to various trading strategies and market conditions.
🚀 Points of Innovation
Triple-timeframe synchronization in a single view eliminates chart switching
Dual trend detection methods (MA vs Price or RSI) for flexibility across different markets
Dynamic color intensity that automatically increases with signal strength
Scaled oscillator format (-100 to +100) for intuitive trend strength interpretation
Customizable signal thresholds to match your risk tolerance and trading style
Visual alerts when markets reach full synchronization states
🔧 Core Components
Trend Scoring System: Calculates a binary score (+1, -1, or 0) for each timeframe based on selected metrics, providing clear trend direction
Multi-Timeframe Synchronization: Combines and scales trend scores from all three timeframes into a single oscillator
Dynamic Visualization: Adjusts color transparency based on signal strength, creating an intuitive visual guide
Threshold System: Provides customizable levels for identifying potentially significant trading opportunities
🔥 Key Features
Triple Timeframe Analysis: Synchronizes three user-defined timeframes (default: 60min, 15min, 5min) into one view
Dual Trend Detection Methods: Choose between Moving Average vs Price or RSI-based trend determination
Adjustable Signal Smoothing: Apply EMA, SMA, or no smoothing to the oscillator output for your preferred signal responsiveness
Dynamic Color Intensity: Colors become more vibrant as signal strength increases, helping identify strongest setups
Customizable Thresholds: Set your own buy/sell threshold levels to match your trading strategy
Comprehensive Alerts: Six different alert conditions for crossing thresholds, zero line, and full synchronization states
🎨 Visualization
Oscillator Line: The main line showing the synchronized trend value from -100 to +100
Dynamic Fill: Area between oscillator and zero line changes transparency based on signal strength
Threshold Lines: Optional dotted lines indicating buy/sell thresholds for visual reference
Color Coding: Green for bullish synchronization, red for bearish synchronization
📖 Usage Guidelines
Timeframe Settings
Timeframe 1: Default: 60 (1 hour) - Primary higher timeframe for trend definition
Timeframe 2: Default: 15 (15 minutes) - Intermediate timeframe for trend definition
Timeframe 3: Default: 5 (5 minutes) - Lower timeframe for trend definition
Trend Calculation Settings
Trend Definition Metric: Default: “MA vs Price” - Method used to determine trend on each timeframe
MA Type: Default: EMA - Moving Average type when using MA vs Price method
MA Length: Default: 21 - Moving Average period when using MA vs Price method
RSI Length: Default: 14 - RSI period when using RSI method
RSI Source: Default: close - Price data source for RSI calculation
Oscillator Settings
Smoothing Type: Default: SMA - Applies smoothing to the final oscillator
Smoothing Length: Default: 5 - Period for the smoothing function
Visual & Threshold Settings
Up/Down Colors: Customize colors for bullish and bearish signals
Transparency Range: Control how transparency changes with signal strength
Line Width: Adjust oscillator line thickness
Buy/Sell Thresholds: Set levels for potential entry/exit signals
✅ Best Use Cases
Trend confirmation across multiple timeframes
Finding high-probability entry points when all timeframes align
Early detection of potential trend reversals
Filtering trade signals from other indicators
Market structure analysis
Identifying potential divergences between timeframes
⚠️ Limitations
Like all indicators, can produce false signals during choppy or ranging markets
Works best in trending market conditions
Should not be used in isolation for trading decisions
Past performance is not indicative of future results
May require different settings for different markets or instruments
💡 What Makes This Unique
Combines three timeframes in a single visualization without requiring multiple chart windows
Dynamic transparency feature that automatically emphasizes stronger signals
Flexible trend definition methods suitable for different market conditions
Visual system that makes multi-timeframe analysis intuitive and accessible
🔬 How It Works
1. Trend Evaluation:
For each timeframe, the indicator calculates a trend score (+1, -1, or 0) using either:
MA vs Price: Comparing close price to a moving average
RSI: Determining if RSI is above or below 50
2. Score Aggregation:
The three trend scores are combined and then scaled to a range of -100 to +100
A value of +100 indicates all timeframes show bullish conditions
A value of -100 indicates all timeframes show bearish conditions
Values in between indicate varying degrees of alignment
3. Signal Processing:
The raw oscillator value can be smoothed using EMA, SMA, or left unsmoothed
The final value determines line color, fill color, and transparency settings
Threshold levels are applied to identify potential trading opportunities
💡 Note:
The SynchroTrend Oscillator is most effective when used as part of a comprehensive trading strategy that includes proper risk management techniques. For best results, consider using the oscillator in conjunction with support/resistance levels, price action analysis, and other complementary indicators that align with your trading style.
M2 Liqudity WaveGlobal Liquidity Wave Indicator (M2-Based)
The Global Liquidity Wave Indicator is designed to track and visualize the impact of global M2 liquidity on risk assets—especially those highly correlated to monetary expansion, like Bitcoin, MSTR, and other macro-sensitive equities.
Key features include:
Leading Signal: Historically leads Bitcoin price action by approximately 70 days, offering traders and analysts a forward-looking edge.
Wave-Based Projection: Visualizes a "probability cloud"—a smoothed band representing the most likely trajectory for Bitcoin based on changes in global liquidity.
Min/Max Offset Controls: Adjustable offsets let you define the range of lookahead windows to shape the wave and better capture liquidity-driven inflection points.
Explicit Offset Visualization: Option to manually specify an exact offset to fine-tune the overlay, ideal for testing hypotheses or aligning with macro narratives.
Macro Alignment: Particularly effective for assets with high sensitivity to global monetary policy and liquidity cycles.
This tool is not just a chart overlay—it's a lens into the liquidity engine behind the market, helping anticipate directional bias in advance of price moves.
How to use?
- Enable the indicator for BTCUSD.
- Set Offset Range Start and End to 70 and 115 days
- Set Specific Offset to 78 days (this can change so you'll need to play around)
FAQ
Why a global liquidity wave?
The global liquidity wave accounts for variability in how much global liquidity affects an underlying asset. Think of the Global Liquidity Wave as an area that tracks the most probable path of Bitcoin, MSTR, etc. based on the total global liquidity.
Why the offset?
Global liquidity takes time to make its way into assets such as #Bitcoin, Strategy, etc. and there can be many reasons for that. It's never a specific number of days of offset, which is why a global liquidity wave is helpful in tracking probable paths for highly correlated risk assets.
Planting & Harvesting SeasonsHello all,
as a commodity trader, I use a lot of seasonal patterns in my analysis. Some time ago, I came up with the idea to develop a simple script that visually overlays the typical planting and harvesting periods for key agricultural futures directly on the chart.
This script automatically detects the underlying commodity based on the symbol (e.g. ZC, ZW, ZS, CT) and displays color-coded zones for each seasonal window. These zones are based on historical crop calendars and help identify when planting or harvesting typically takes place. The goal is to better align technical setups with fundamental seasonal factors.
This is a basic version and meant as a visual aid — not a trading signal in itself.
Hope you enjoy it and any feedback is highly appreciated!
TDO & Hit Rates by Weekday (5 min)Purpose
Tracks how often the next NY session “hits” the previous day’s True Day Open (TDO) level, separately for sessions that open above vs. below TDO, and breaks the statistics down by weekday (Mon–Fri) plus an overall summary.
Key Features
True Day Open (TDO) Plot
Captures the prior day’s 23:00 CT close price as the TDO.
Plots it as a continuous yellow line across your chart.
Session Labeling
At the end of each NY session (08:30–15:00 CT), places a small “TDO” label at the TDO price to confirm visually where it lay during that day.
Hit‑Count Logic
For each 5 min bar in the NY session, checks if the bar’s high ≥ TDO ≥ low (i.e. the TDO level was “hit”).
Classifies each session by whether its opening price (first 5 min bar) was above or below the TDO.
Weekday Statistics Table
Displays in the bottom‑left of your main chart window.
Rows: Header, Mon, Tue, Wed, Thu, Fri, All.
Columns:
% Hit Above: % of “above‑TDO” sessions that saw at least one hit
% Hit Below: % of “below‑TDO” sessions that saw at least one hit
Automatically updates in real time as new sessions complete.
Inputs & Settings
Data Resolution: Default = 5 min; use any intraday timeframe you like (1, 3, 15 min, etc.).
Extended Hours: Make sure your chart’s Extended Session (overnight) is enabled so the 23:00 CT bar exists.
Overlay: Draws directly on your price chart (no separate pane).
How to Use
Add to Chart: Paste the Pine v5 code into TradingView’s editor and apply to your ES (or other) futures chart.
Enable Overnight Bars: In Chart Settings → Symbol/Session → include Extended Hours.
Select Timeframe: Set the chart (or the indicator’s “Data Resolution” input) to 5 min (or your preferred intraday).
Read the Table:
Each weekday row shows how reliable TDO touches have been historically, separately for “above” and “below” opens.
The bottom “All” row summarizes combined performance.
What You Learn
Edge Analysis: Do sessions opening above TDO tend to test that level more often than those opening below (or vice versa)?
Day‑of‑Week Bias: Are certain weekdays more prone to TDO retests?
Overall Confidence: The “All” row lets you see your full-sample hit‑rate on both sides.
RSI+Stoch Band Oscillator📈 RSI + Stochastic Band Oscillator
Overview:
The RSI + Stochastic Band Oscillator is a technical indicator that combines the strengths of both the Relative Strength Index (RSI) and the Stochastic Oscillator. Instead of using static thresholds, this indicator dynamically constructs upper and lower bands based on the RSI and Stochastic overbought/oversold zones. It then measures the relative position of the current price within this adaptive range, effectively producing a normalized oscillator.
Key Components:
RSI-Based Dynamic Bands:
Using RSI values and exponential moving averages of price changes, upper and lower dynamic bands are constructed.
These bands adjust based on overbought and oversold levels, offering a more responsive framework than fixed RSI thresholds.
Stochastic-Based Dynamic Bands:
Similarly, Stochastic %K and %D values are used to construct dynamic bands.
These adapt to overbought and oversold levels by recalculating potential high/low values within the lookback window.
Oscillator Calculation:
The oscillator (osc) is computed as the relative position of the current close within the combined upper and lower bands of both RSI and Stochastic.
This value is normalized between 0 and 100, allowing clear identification of extreme conditions.
Visual Features:
The oscillator is plotted as a line between 0 and 100.
Color-filled areas highlight when the oscillator enters extreme zones:
Above 100 with falling momentum: Red zone (potential reversal).
Below 0 with rising momentum: Green zone (potential reversal).
Additional trend conditions (falling/rising RSI, %K, and %D) are used to strengthen reversal signals by confirming momentum shifts.
HG StdDevThe HG StdDev indicator provides a dynamic view of market volatility by calculating the standard deviation of a selected price source over a customizable period. Additionally, it plots a threshold line representing the highest standard deviation over a secondary lookback window.
Red Line: Current standard deviation (volatility) of the price.
Gray Line: Highest standard deviation value within the lookback range, serving as a reference for recent peak volatility.
Use this tool to identify periods of increasing or extreme volatility, potential breakout zones, or to filter signals based on volatility thresholds.
[blackcat] L2 Ehlers Autocorrelation Periodogram V2OVERVIEW
The Ehlers Autocorrelation Periodogram is a sophisticated technical analysis tool that identifies market cycles and their dominant frequencies using autocorrelation and spectral analysis techniques.
BACKGROUND
Developed by John F. Ehlers and detailed in his book "Cycle Analytics for Traders" (2013), this indicator combines autocorrelation functions with discrete Fourier transforms to extract cyclic information from price data.
FUNCTION
The indicator works through these key steps:
Calculates autocorrelation using minimum three-bar averaging
Applies discrete Fourier transform to extract cyclic information
Uses center-of-gravity algorithm to determine dominant cycle
ADVANTAGES
• Rapid response within half-cycle periods
• Accurate relative cyclic power estimation over time
• Correlation constraints between -1 and +1 eliminate amplitude compensation needs
• High resolution independent of windowing functions
HOW TO USE
Add the indicator to your chart
Adjust AvgLength input parameter:
• Default: 3 bars
• Higher values increase smoothing
• Lower values increase sensitivity
Interpret the results:
• Colored bars represent spectral power
• Red to yellow spectrum indicates cycle strength
• White line shows dominant cycle period
INTERPRETATION
• Strong colors indicate significant cyclic activity
• Sharp color transitions suggest potential cycle changes
• Dominant cycle line helps identify primary market rhythm
LIMITATIONS
• Requires sufficient historical data
• Performance may vary in non-cyclical markets
• Results depend on proper parameter settings
NOTES
• Uses highpass and super smoother filtering techniques
• Spectral estimates are normalized between 0 and 1
• Color intensity varies based on spectral power
THANKS
This implementation is based on Ehlers' original work and has been adapted for TradingView's Pine Script platform.
StonkGame Major Market Open/ClosePlots vertical lines for Tokyo, London, and New York session opens and closes — auto-adjusted to your chart's timezone.
Open lines = lighter, dashed style.
Close lines = solid, full-color style.
Helps identify key liquidity windows, session-driven volatility, and clean market structure — without chart clutter.
Fully customizable colors and line styles for a professional, minimal look.
RSI and CCICombined RSI and CCI Indicator for MetaTrader
The Combined RSI and CCI Indicator is a powerful hybrid momentum oscillator designed to merge the strengths of two popular indicators—the Relative Strength Index (RSI) and the Commodity Channel Index (CCI)—into a single, visually intuitive chart window. This tool enhances traders’ ability to identify overbought and oversold conditions, divergences, trend strength, and potential reversal zones with improved precision.
Purpose
By integrating RSI and CCI, this indicator helps filter out false signals that often occur when using each tool independently. It is especially useful for swing trading, trend confirmation, and spotting high-probability entry/exit zones. This dual-oscillator approach combines RSI’s relative momentum insights with CCI’s deviation-based analysis to produce a more reliable signal structure.
Key Features
Dual Oscillator Display: Plots both RSI and CCI on the same subwindow for easy comparison and correlation analysis.
Customizable Parameters:
RSI Period and Level (default: 14)
CCI Period and Typical Price Type (default: 20, TP)
Overbought/Oversold Levels for both indicators
Color-Coded Zones:
Background highlights when both RSI and CCI enter overbought/oversold territory, signaling high potential reversal zones.
Combined Signal Logic (Optional Feature):
Buy Signal: RSI < 30 and CCI < -100
Sell Signal: RSI > 70 and CCI > 100
These can be visualized as arrows or plotted as signal markers.
Trend Filter Overlay (Optional):
Can be combined with a moving average or price action filter to confirm trend direction before accepting signals.
Divergence Detection (Advanced Option):
Optional plotting of bullish or bearish divergence where both indicators diverge from price action.
Multi-Timeframe Compatibility:
Allows the use of higher timeframe RSI/CCI values to confirm signals on lower timeframes.
Benefits
Improved Signal Accuracy: Using both RSI and CCI together helps avoid false breakouts and whipsaws.
More Informed Decision-Making: Correlating momentum (RSI) with deviation (CCI) provides a well-rounded picture of market behavior.
Efficient Charting: Saves screen space and cognitive load by combining two indicators into one clean panel.
Scalable Strategy Integration: Can be used in discretionary trading or coded into automated strategies/alerts.
Use Case Example
In a ranging market, the indicator highlights zones where both RSI and CCI are oversold, alerting traders to potential bounce opportunities.
In trending markets, it confirms trend strength when RSI and CCI are both aligned with trend direction.
When RSI is diverging from price but CCI isn’t, it can be a clue of weakening momentum, helping traders scale out or avoid traps.
This combined indicator offers a versatile, high-performance toolset for traders looking to elevate their technical analysis by leveraging multiple momentum perspectives simultaneously.
Timed Reversion Markers (Custom Session Alerts)This script plots vertical histogram markers at specific intraday time points defined by the user. It is designed for traders who follow time-based reversion or breakout setups tied to predictable market behavior at key clock times, such as institutional opening moves, midday reversals, or end-of-day volatility.
Unlike traditional price-action indicators, this tool focuses purely on time-based triggers, a technique often used in time cycle analysis, market internals, and volume-timing strategies.
The indicator includes eight fully customizable time inputs, allowing users to mark any intraday minute with precision using a decimal hour format (for example, 9.55 for 9:55 AM). Each input is automatically converted into hour and minute format, and a visual histogram marker is plotted once per day at that exact time.
Example use cases:
Mark institutional session opens (e.g., 9:30, 10:00, 15:30)
Time-based mean reversion or volatility windows
Backtest recurring time-based reactions
Highlight algorithmic spike zones
The vertical plots serve as non-intrusive, high-contrast visual markers for scalping setups, session analysis, and decision-making checkpoints. All markers are displayed at the top of the chart without interfering with price candles.
Advanced OHLC ExporterThis Pine Script indicator provides one-click export of candlestick data (OHLC + Volume) from any TradingView chart. It displays the current candle's values in a clean table while ensuring all visible historical data is available for export in CSV format.
Key Features
📊 Visual Data Display
Real-time OHLC table in the top-right corner.
Color-coded values for quick analysis (green=high, red=low).
Volume shown in standardized formatting.
Data Export Ready
All plotted values appear in TradingView's Data Window.
Right-click → "Export Data" to save:
Open, High, Low, Close (OHLC) prices
Trading volume
Timestamps for each candle
⚙️ Customizable Output
Works on any timeframe (1m to 1M)
Compatible with: Forex, Stocks, Crypto, Futures
How Traders Use This
Technical Analysts - Export clean datasets for external analysis.
Backtesters - Quickly gather historical price data for strategy development.
Researchers - Study candlestick patterns with precise numerical data.
Session Coloring Bar with ICT Macro [dani]The Session Coloring Bar is customizable Pine Script indicator designed to visually enhance your charts by applying unique colors to specific trading sessions or timeframes. This tool allows traders to easily identify and differentiate between macro sessions (e.g., 24-hour cycles) and custom-defined sessions (e.g., Session A, Session B), making it ideal for analyzing market activity during specific periods.
In the context of trading, the term "ICT Macro" , as discussed by Michael J. Huddleston (ICT), refers to specific timeframes or "windows" where market behavior often follows predictable patterns. Traders typically focus on the last 10 minutes of an hour and the first 10 minutes of the next hour (e.g., 0150-0210 , 0050-0110 , or 0950-1010 ) to identify key price movements, liquidity shifts, or market inefficiencies.
This script highlights these macro timeframes, enabling traders to visually analyze price action during these critical periods. Use this tool to support your strategy, but always combine it with your own analysis and risk management.
With this indicator, you can:
Highlight Macro Sessions : Automatically color bars based on predefined 24-hour macro sessions.
Customize Session Settings : Define up to three custom sessions (A & B) with individual start/end times, visibility toggles, and unique bar colors.
Timeframe Filtering : Hide session coloring above a specified timeframe to avoid clutter on higher timeframes.
Personal Notes : Add comments to each session for better organization and quick reference.
Dynamic Color Logic : Bars are colored based on their direction (up, down, or neutral) within the active session.
How to Use:
Enable/Disable Sessions :
Use the Show Coloring toggle to enable or disable session coloring for Macro, Session A, Session B, or Session C.
Set Session Times :
Define the start and end times for each session in the format HHMM-HHMM (e.g., 1600-0930 for an overnight session).
Choose Colors :
Assign unique colors for upward (Bar Up) and downward (Bar Down) bars within each session.
Adjust Timeframe Visibility :
Use the Hide above this TF input to specify the maximum timeframe where session coloring will be visible.
Add Notes :
Use the Comment field to add personal notes or labels for each session.
Example Use Cases:
Overnight Sessions :
Highlight overnight trading hours (e.g., 1600-0930) to analyze price action during low liquidity periods.
Asian/European/US Sessions : Define separate sessions for major trading regions to track regional market behavior.
Macro Analysis : Use the predefined 24-hour macro sessions to study hourly price movements across a full trading day.
Disclaimer:
The Session Coloring Bar is not a trading signal generator and does not predict market direction or provide buy/sell signals. Instead, it is a visualization tool designed to help you identify and analyze specific trading sessions or timeframes on your chart. By highlighting key sessions and their corresponding price movements, this indicator enables you to focus on periods of interest and make more informed trading decisions.
Thank you for choosing this indicator! I hope it becomes a valuable part of your trading toolkit. Remember, trading is a journey, and having the right tools can make all the difference. Whether you're a seasoned trader or just starting out, this indicator is designed to help you stay organized and focused on what matters most—price action. Happy trading, and may your charts be ever in your favor! 😊
Daily ProtractorDaily Protractor Indicator
Overview
The Daily Protractor is a visually intuitive tool designed for traders who want to analyze price action through angular measurements on a 5-minute chart. By overlaying a protractor on the chart, this indicator helps identify potential support, resistance, and trend directions based on angular relationships from the first 5-minute candle of each day. It’s particularly useful for intraday traders looking to incorporate geometric analysis into their strategies for spot or strike charts.
Key Features
Dynamic Protractor Overlay: Draws a protractor centered on the low of the first 5-minute candle of each day, with customizable radius in both bars (horizontal) and price units (vertical).
Angular Measurements: Displays angles in 5-degree increments, covering a full 360° circle or a 105° to -105° (91° to 269°) half-circle, depending on user preference.
Customizable Display:
Adjust the number of days to display protractors (up to 5 days).
Customize line colors for different angle ranges (0° to 180°, 180° to 360°, and 0° specifically).
Modify line thickness, label size, and label colors for better visibility.
Center Point Highlight: Marks the center of each protractor with a labeled point for easy reference.
Efficient Design:
Optimized with max_lines_count, max_labels_count, and max_bars_back to ensure smooth performance on TradingView.
How It Works
The indicator identifies the first 5-minute candle of each day and uses its low price as the center point for a protractor. It then draws lines at 5-degree intervals, radiating from the center, with each line representing an angle from 0° to 360°. Labels at the end of each line display the angle in degrees, with negative values shown for angles between 195° and 345° (e.g., 270° is displayed as -90°). The protractor’s radius can be adjusted in both time (bars) and price units, allowing traders to scale the tool to their chart’s characteristics.
Usage Instructions
Add to Chart:
Apply the indicator to a 5-minute chart of your chosen instrument (e.g., spot or strike charts).
Interpret the Protractor:
Use the angular lines to identify potential price levels or trend directions.
The 0° line (horizontal) can act as a reference for horizontal support/resistance.
Angles between 0° and 180° (upper half) and 180° and 360° (lower half) are color-coded for quick identification.
Customize Settings:
Toggle the Show 105° to -105° option to display a half-circle (91° to 269°) instead of a full 360° protractor.
Adjust the Radius in Bars and Radius in Price Units to scale the protractor to your chart.
Set the Maximum Days to Display to control how many daily protractors are shown.
Modify line thickness, colors, and label settings to suit your visual preferences.
Customization Options
Protractor Settings:
Show 105° to -105° (91° to 269°): Toggle between a full circle or a half-circle protractor.
Radius in Bars: Set the horizontal span of the protractor (default: 75 bars).
Radius in Price Units: Set the vertical span in price units (default: 1000.0).
Maximum Days to Display: Limit the number of protractors shown (default: 5 days).
Line Settings:
Line Thickness: Adjust the thickness of the protractor lines (1 or 2).
Line Color (0° to 180°): Color for the upper half (default: light blue).
Line Color (180° to 360°): Color for the lower half (default: light red).
Line Color (0°): Color for the 0° line (default: black).
Label Settings:
Label Size: Choose between small, normal, or large labels.
Label Color (0° to 180°): Color for labels in the upper half (default: red).
Label Color (180° to 360°): Color for labels in the lower half (default: green).
Notes
The indicator was designed with the help of Grok3 for use on 5-minute charts only, as it relies on the first 5-minute candle of the day to set the protractor’s center.
For best results, adjust the radius settings to match the volatility and price scale of your instrument. However, where the price is in single digits it is advised to switch off the labels or I would suggest not to use the same.
The protractor can be used alongside other technical tools to confirm trends, reversals, or key price levels.
Limitations: This cannot be used on instruments that trade for more than 75 candles with a timeframe of 5 minutes as the angles would not cover the entire trading window. I am working coming up with a script to address this limitation.
Feedback
I’d love to hear your thoughts! If you find the Daily Protractor helpful or have suggestions for improvements, please leave a comment or reach out. Happy trading!
ZRK 30m This TradingView indicator draws alternating 30-minute boxes aligned precisely to real clock times (e.g., 10:00, 10:30, 11:00), helping traders visually segment intraday price action. It highlights every other 30-minute block with customizable colors, line styles, and opacity, allowing users to clearly differentiate between trading intervals. The boxes automatically adjust based on the chart’s timeframe, maintaining accuracy on 1-minute to 60-minute charts. Optional time labels can also be displayed for additional context. This tool is useful for identifying patterns, measuring volatility, or applying breakout strategies based on defined, consistent time windows across global trading sessions.
Trendline Breaks with Multi Fibonacci Supertrend StrategyTMFS Strategy: Advanced Trendline Breakouts with Multi-Fibonacci Supertrend
Elevate your algorithmic trading with institutional-grade signal confluence
Strategy Genesis & Evolution
This advanced trading system represents the culmination of a personal research journey, evolving from my custom " Multi Fibonacci Supertrend with Signals " indicator into a comprehensive trading strategy. Built upon the exceptional trendline detection methodology pioneered by LuxAlgo in their " Trendlines with Breaks " indicator, I've engineered a systematic framework that integrates multiple technical factors into a cohesive trading system.
Core Fibonacci Principles
At the heart of this strategy lies the Fibonacci sequence application to volatility measurement:
// Fibonacci-based factors for multiple Supertrend calculations
factor1 = input.float(0.618, 'Factor 1 (Weak/Fibonacci)', minval = 0.01, step = 0.01)
factor2 = input.float(1.618, 'Factor 2 (Medium/Golden Ratio)', minval = 0.01, step = 0.01)
factor3 = input.float(2.618, 'Factor 3 (Strong/Extended Fib)', minval = 0.01, step = 0.01)
These precise Fibonacci ratios create a dynamic volatility envelope that adapts to changing market conditions while maintaining mathematical harmony with natural price movements.
Dynamic Trendline Detection
The strategy incorporates LuxAlgo's pioneering approach to trendline detection:
// Pivotal swing detection (inspired by LuxAlgo)
pivot_high = ta.pivothigh(swing_length, swing_length)
pivot_low = ta.pivotlow(swing_length, swing_length)
// Dynamic slope calculation using ATR
slope = atr_value / swing_length * atr_multiplier
// Update trendlines based on pivot detection
if bool(pivot_high)
upper_slope := slope
upper_trendline := pivot_high
else
upper_trendline := nz(upper_trendline) - nz(upper_slope)
This adaptive trendline approach automatically identifies key structural market boundaries, adjusting in real-time to evolving chart patterns.
Breakout State Management
The strategy implements sophisticated state tracking for breakout detection:
// Track breakouts with state variables
var int upper_breakout_state = 0
var int lower_breakout_state = 0
// Update breakout state when price crosses trendlines
upper_breakout_state := bool(pivot_high) ? 0 : close > upper_trendline ? 1 : upper_breakout_state
lower_breakout_state := bool(pivot_low) ? 0 : close < lower_trendline ? 1 : lower_breakout_state
// Detect new breakouts (state transitions)
bool new_upper_breakout = upper_breakout_state > upper_breakout_state
bool new_lower_breakout = lower_breakout_state > lower_breakout_state
This state-based approach enables precise identification of the exact moment when price breaks through a significant trendline.
Multi-Factor Signal Confluence
Entry signals require confirmation from multiple technical factors:
// Define entry conditions with multi-factor confluence
long_entry_condition = enable_long_positions and
upper_breakout_state > upper_breakout_state and // New trendline breakout
di_plus > di_minus and // Bullish DMI confirmation
close > smoothed_trend // Price above Supertrend envelope
// Execute trades only with full confirmation
if long_entry_condition
strategy.entry('L', strategy.long, comment = "LONG")
This strict requirement for confluence significantly reduces false signals and improves the quality of trade entries.
Advanced Risk Management
The strategy includes sophisticated risk controls with multiple methodologies:
// Calculate stop loss based on selected method
get_long_stop_loss_price(base_price) =>
switch stop_loss_method
'PERC' => base_price * (1 - long_stop_loss_percent)
'ATR' => base_price - long_stop_loss_atr_multiplier * entry_atr
'RR' => base_price - (get_long_take_profit_price() - base_price) / long_risk_reward_ratio
=> na
// Implement trailing functionality
strategy.exit(
id = 'Long Take Profit / Stop Loss',
from_entry = 'L',
qty_percent = take_profit_quantity_percent,
limit = trailing_take_profit_enabled ? na : long_take_profit_price,
stop = long_stop_loss_price,
trail_price = trailing_take_profit_enabled ? long_take_profit_price : na,
trail_offset = trailing_take_profit_enabled ? long_trailing_tp_step_ticks : na,
comment = "TP/SL Triggered"
)
This flexible approach adapts to varying market conditions while providing comprehensive downside protection.
Performance Characteristics
Rigorous backtesting demonstrates exceptional capital appreciation potential with impressive risk-adjusted metrics:
Remarkable total return profile (1,517%+)
Strong Sortino ratio (3.691) indicating superior downside risk control
Profit factor of 1.924 across all trades (2.153 for long positions)
Win rate exceeding 35% with balanced distribution across varied market conditions
Institutional Considerations
The strategy architecture addresses execution complexities faced by institutional participants with temporal filtering and date-range capabilities:
// Time Filter settings with flexible timezone support
import jason5480/time_filters/5 as time_filter
src_timezone = input.string(defval = 'Exchange', title = 'Source Timezone')
dst_timezone = input.string(defval = 'Exchange', title = 'Destination Timezone')
// Date range filtering for precise execution windows
use_from_date = input.bool(defval = true, title = 'Enable Start Date')
from_date = input.time(defval = timestamp('01 Jan 2022 00:00'), title = 'Start Date')
// Validate trading permission based on temporal constraints
date_filter_approved = time_filter.is_in_date_range(
use_from_date, from_date, use_to_date, to_date, src_timezone, dst_timezone
)
These capabilities enable precise execution timing and market session optimization critical for larger market participants.
Acknowledgments
Special thanks to LuxAlgo for the pioneering work on trendline detection and breakout identification that inspired elements of this strategy. Their innovative approach to technical analysis provided a valuable foundation upon which I could build my Fibonacci-based methodology.
This strategy is shared under the same Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) license as LuxAlgo's original work.
Past performance is not indicative of future results. Conduct thorough analysis before implementing any algorithmic strategy.
Hourly Volatility Explorer📊 Hourly Volatility Explorer: Master The Market's Pulse
Unlock the hidden rhythms of price action with this sophisticated volatility analysis tool. The Hourly Volatility Explorer reveals the most potent trading hours across multiple time zones, giving you a strategic edge in timing your trades.
🌟 Key Features:
⏰ Multi-Timezone Analysis
• GMT (UTC+0)
• EST (UTC-5) - New York
• BST (UTC+1) - London
• JST (UTC+9) - Tokyo
• AEST (UTC+10) - Sydney
Perfect for tracking major market sessions and their overlaps!
📈 Dynamic Visualization
• Color-gradient hourly bars for instant pattern recognition
• Real-time volatility comparison
• Interactive data table with comprehensive statistics
• Automatic highlighting of peak volatility periods
🎯 Strategic Applications:
Day Trading:
• Identify optimal trading windows
• Avoid low-liquidity periods
• Capitalize on session overlaps
• Fine-tune entry/exit timing
Risk Management:
• Set appropriate stop losses based on hourly volatility
• Adjust position sizes for different market hours
• Optimize risk-reward ratios
• Plan around high-impact hours
Global Market Analysis:
• Track volatility across all major sessions
• Spot institutional trading patterns
• Identify quiet vs. active periods
• Monitor 24/7 market dynamics
💡 Perfect For:
• Forex traders navigating global sessions
• Crypto traders in 24/7 markets
• Day traders optimizing execution times
• Algorithmic traders fine-tuning strategies
• Risk managers calibrating exposure
📊 Advanced Features:
• Rolling 3-month analysis for reliable patterns
• Precise pip movement calculations
• Sample size tracking for statistical validity
• Real-time current hour comparison
• Color-coded visual system for instant insights
⚡ Pro Trading Tips:
• Use during major session overlaps for maximum opportunity
• Compare patterns across different instruments
• Combine with volume analysis for deeper insights
• Track seasonal variations in hourly patterns
• Build trading schedules around peak hours
🎓 Educational Value:
• Understand market microstructure
• Learn global market dynamics
• Master timezone relationships
• Develop timing intuition
🛠️ Customization:
• Adjustable lookback period
• Flexible pip multiplier
• Multiple timezone options
• Visual preference settings
Whether you're scalping the 1-minute chart or managing longer-term positions, the Hourly Volatility Explorer provides the precise timing intelligence needed for today's global markets.
Transform your trading schedule from guesswork to science. Know exactly when markets move, why they move, and how to position yourself for maximum opportunity.
#TechnicalAnalysis #Trading #Volatility #MarketTiming #DayTrading #Forex #Crypto #TradingView #PineScript #MarketAnalysis #TradingStrategy #RiskManagement #GlobalMarkets #FinancialMarkets #TradingTools #MarketStructure #PriceAction #Scalping #SwingTrading #AlgoTrading
real_time_candlesIntroduction
The Real-Time Candles Library provides comprehensive tools for creating, manipulating, and visualizing custom timeframe candles in Pine Script. Unlike standard indicators that only update at bar close, this library enables real-time visualization of price action and indicators within the current bar, offering traders unprecedented insight into market dynamics as they unfold.
This library addresses a fundamental limitation in traditional technical analysis: the inability to see how indicators evolve between bar closes. By implementing sophisticated real-time data processing techniques, traders can now observe indicator movements, divergences, and trend changes as they develop, potentially identifying trading opportunities much earlier than with conventional approaches.
Key Features
The library supports two primary candle generation approaches:
Chart-Time Candles: Generate real-time OHLC data for any variable (like RSI, MACD, etc.) while maintaining synchronization with chart bars.
Custom Timeframe (CTF) Candles: Create candles with custom time intervals or tick counts completely independent of the chart's native timeframe.
Both approaches support traditional candlestick and Heikin-Ashi visualization styles, with options for moving average overlays to smooth the data.
Configuration Requirements
For optimal performance with this library:
Set max_bars_back = 5000 in your script settings
When using CTF drawing functions, set max_lines_count = 500, max_boxes_count = 500, and max_labels_count = 500
These settings ensure that you will be able to draw correctly and will avoid any runtime errors.
Usage Examples
Basic Chart-Time Candle Visualization
// Create real-time candles for RSI
float rsi = ta.rsi(close, 14)
Candle rsi_candle = candle_series(rsi, CandleType.candlestick)
// Plot the candles using Pine's built-in function
plotcandle(rsi_candle.Open, rsi_candle.High, rsi_candle.Low, rsi_candle.Close,
"RSI Candles", rsi_candle.candle_color, rsi_candle.candle_color)
Multiple Access Patterns
The library provides three ways to access candle data, accommodating different programming styles:
// 1. Array-based access for collection operations
Candle candles = candle_array(source)
// 2. Object-oriented access for single entity manipulation
Candle candle = candle_series(source)
float value = candle.source(Source.HLC3)
// 3. Tuple-based access for functional programming styles
= candle_tuple(source)
Custom Timeframe Examples
// Create 20-second candles with EMA overlay
plot_ctf_candles(
source = close,
candle_type = CandleType.candlestick,
sample_type = SampleType.Time,
number_of_seconds = 20,
timezone = -5,
tied_open = true,
ema_period = 9,
enable_ema = true
)
// Create tick-based candles (new candle every 15 ticks)
plot_ctf_tick_candles(
source = close,
candle_type = CandleType.heikin_ashi,
number_of_ticks = 15,
timezone = -5,
tied_open = true
)
Advanced Usage with Custom Visualization
// Get custom timeframe candles without automatic plotting
CandleCTF my_candles = ctf_candles_array(
source = close,
candle_type = CandleType.candlestick,
sample_type = SampleType.Time,
number_of_seconds = 30
)
// Apply custom logic to the candles
float ema_values = my_candles.ctf_ema(14)
// Draw candles and EMA using time-based coordinates
my_candles.draw_ctf_candles_time()
ema_values.draw_ctf_line_time(line_color = #FF6D00)
Library Components
Data Types
Candle: Structure representing chart-time candles with OHLC, polarity, and visualization properties
CandleCTF: Extended candle structure with additional time metadata for custom timeframes
TickData: Structure for individual price updates with time deltas
Enumerations
CandleType: Specifies visualization style (candlestick or Heikin-Ashi)
Source: Defines price components for calculations (Open, High, Low, Close, HL2, etc.)
SampleType: Sets sampling method (Time-based or Tick-based)
Core Functions
get_tick(): Captures current price as a tick data point
candle_array(): Creates an array of candles from price updates
candle_series(): Provides a single candle based on latest data
candle_tuple(): Returns OHLC values as a tuple
ctf_candles_array(): Creates custom timeframe candles without rendering
Visualization Functions
source(): Extracts specific price components from candles
candle_ctf_to_float(): Converts candle data to float arrays
ctf_ema(): Calculates exponential moving averages for candle arrays
draw_ctf_candles_time(): Renders candles using time coordinates
draw_ctf_candles_index(): Renders candles using bar index coordinates
draw_ctf_line_time(): Renders lines using time coordinates
draw_ctf_line_index(): Renders lines using bar index coordinates
Technical Implementation Notes
This library leverages Pine Script's varip variables for state management, creating a sophisticated real-time data processing system. The implementation includes:
Efficient tick capturing: Samples price at every execution, maintaining temporal tracking with time deltas
Smart state management: Uses a hybrid approach with mutable updates at index 0 and historical preservation at index 1+
Temporal synchronization: Manages two time domains (chart time and custom timeframe)
The tooltip implementation provides crucial temporal context for custom timeframe visualizations, allowing users to understand exactly when each candle formed regardless of chart timeframe.
Limitations
Custom timeframe candles cannot be backtested due to Pine Script's limitations with historical tick data
Real-time visualization is only available during live chart updates
Maximum history is constrained by Pine Script's array size limits
Applications
Indicator visualization: See how RSI, MACD, or other indicators evolve in real-time
Volume analysis: Create custom volume profiles independent of chart timeframe
Scalping strategies: Identify short-term patterns with precisely defined time windows
Volatility measurement: Track price movement characteristics within bars
Custom signal generation: Create entry/exit signals based on custom timeframe patterns
Conclusion
The Real-Time Candles Library bridges the gap between traditional technical analysis (based on discrete OHLC bars) and the continuous nature of market movement. By making indicators more responsive to real-time price action, it gives traders a significant edge in timing and decision-making, particularly in fast-moving markets where waiting for bar close could mean missing important opportunities.
Whether you're building custom indicators, researching price patterns, or developing trading strategies, this library provides the foundation for sophisticated real-time analysis in Pine Script.
Implementation Details & Advanced Guide
Core Implementation Concepts
The Real-Time Candles Library implements a sophisticated event-driven architecture within Pine Script's constraints. At its heart, the library creates what's essentially a reactive programming framework handling continuous data streams.
Tick Processing System
The foundation of the library is the get_tick() function, which captures price updates as they occur:
export get_tick(series float source = close, series float na_replace = na)=>
varip float price = na
varip int series_index = -1
varip int old_time = 0
varip int new_time = na
varip float time_delta = 0
// ...
This function:
Samples the current price
Calculates time elapsed since last update
Maintains a sequential index to track updates
The resulting TickData structure serves as the fundamental building block for all candle generation.
State Management Architecture
The library employs a sophisticated state management system using varip variables, which persist across executions within the same bar. This creates a hybrid programming paradigm that's different from standard Pine Script's bar-by-bar model.
For chart-time candles, the core state transition logic is:
// Real-time update of current candle
candle_data := Candle.new(Open, High, Low, Close, polarity, series_index, candle_color)
candles.set(0, candle_data)
// When a new bar starts, preserve the previous candle
if clear_state
candles.insert(1, candle_data)
price.clear()
// Reset state for new candle
Open := Close
price.push(Open)
series_index += 1
This pattern of updating index 0 in real-time while inserting completed candles at index 1 creates an elegant solution for maintaining both current state and historical data.
Custom Timeframe Implementation
The custom timeframe system manages its own time boundaries independent of chart bars:
bool clear_state = switch settings.sample_type
SampleType.Ticks => cumulative_series_idx >= settings.number_of_ticks
SampleType.Time => cumulative_time_delta >= settings.number_of_seconds
This dual-clock system synchronizes two time domains:
Pine's execution clock (bar-by-bar processing)
The custom timeframe clock (tick or time-based)
The library carefully handles temporal discontinuities, ensuring candle formation remains accurate despite irregular tick arrival or market gaps.
Advanced Usage Techniques
1. Creating Custom Indicators with Real-Time Candles
To develop indicators that process real-time data within the current bar:
// Get real-time candles for your data
Candle rsi_candles = candle_array(ta.rsi(close, 14))
// Calculate indicator values based on candle properties
float signal = ta.ema(rsi_candles.first().source(Source.Close), 9)
// Detect patterns that occur within the bar
bool divergence = close > close and rsi_candles.first().Close < rsi_candles.get(1).Close
2. Working with Custom Timeframes and Plotting
For maximum flexibility when visualizing custom timeframe data:
// Create custom timeframe candles
CandleCTF volume_candles = ctf_candles_array(
source = volume,
candle_type = CandleType.candlestick,
sample_type = SampleType.Time,
number_of_seconds = 60
)
// Convert specific candle properties to float arrays
float volume_closes = volume_candles.candle_ctf_to_float(Source.Close)
// Calculate derived values
float volume_ema = volume_candles.ctf_ema(14)
// Create custom visualization
volume_candles.draw_ctf_candles_time()
volume_ema.draw_ctf_line_time(line_color = color.orange)
3. Creating Hybrid Timeframe Analysis
One powerful application is comparing indicators across multiple timeframes:
// Standard chart timeframe RSI
float chart_rsi = ta.rsi(close, 14)
// Custom 5-second timeframe RSI
CandleCTF ctf_candles = ctf_candles_array(
source = close,
candle_type = CandleType.candlestick,
sample_type = SampleType.Time,
number_of_seconds = 5
)
float fast_rsi_array = ctf_candles.candle_ctf_to_float(Source.Close)
float fast_rsi = fast_rsi_array.first()
// Generate signals based on divergence between timeframes
bool entry_signal = chart_rsi < 30 and fast_rsi > fast_rsi_array.get(1)
Final Notes
This library represents an advanced implementation of real-time data processing within Pine Script's constraints. By creating a reactive programming framework for handling continuous data streams, it enables sophisticated analysis typically only available in dedicated trading platforms.
The design principles employed—including state management, temporal processing, and object-oriented architecture—can serve as patterns for other advanced Pine Script development beyond this specific application.
------------------------
Library "real_time_candles"
A comprehensive library for creating real-time candles with customizable timeframes and sampling methods.
Supports both chart-time and custom-time candles with options for candlestick and Heikin-Ashi visualization.
Allows for tick-based or time-based sampling with moving average overlay capabilities.
get_tick(source, na_replace)
Captures the current price as a tick data point
Parameters:
source (float) : Optional - Price source to sample (defaults to close)
na_replace (float) : Optional - Value to use when source is na
Returns: TickData structure containing price, time since last update, and sequential index
candle_array(source, candle_type, sync_start, bullish_color, bearish_color)
Creates an array of candles based on price updates
Parameters:
source (float) : Optional - Price source to sample (defaults to close)
candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)
sync_start (simple bool) : Optional - Whether to synchronize with the start of a new bar
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
Returns: Array of Candle objects ordered with most recent at index 0
candle_series(source, candle_type, wait_for_sync, bullish_color, bearish_color)
Provides a single candle based on the latest price data
Parameters:
source (float) : Optional - Price source to sample (defaults to close)
candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)
wait_for_sync (simple bool) : Optional - Whether to wait for a new bar before starting
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
Returns: A single Candle object representing the current state
candle_tuple(source, candle_type, wait_for_sync, bullish_color, bearish_color)
Provides candle data as a tuple of OHLC values
Parameters:
source (float) : Optional - Price source to sample (defaults to close)
candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)
wait_for_sync (simple bool) : Optional - Whether to wait for a new bar before starting
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
Returns: Tuple representing current candle values
method source(self, source, na_replace)
Extracts a specific price component from a Candle
Namespace types: Candle
Parameters:
self (Candle)
source (series Source) : Type of price data to extract (Open, High, Low, Close, or composite values)
na_replace (float) : Optional - Value to use when source value is na
Returns: The requested price value from the candle
method source(self, source)
Extracts a specific price component from a CandleCTF
Namespace types: CandleCTF
Parameters:
self (CandleCTF)
source (simple Source) : Type of price data to extract (Open, High, Low, Close, or composite values)
Returns: The requested price value from the candle as a varip
method candle_ctf_to_float(self, source)
Converts a specific price component from each CandleCTF to a float array
Namespace types: array
Parameters:
self (array)
source (simple Source) : Optional - Type of price data to extract (defaults to Close)
Returns: Array of float values extracted from the candles, ordered with most recent at index 0
method ctf_ema(self, ema_period)
Calculates an Exponential Moving Average for a CandleCTF array
Namespace types: array
Parameters:
self (array)
ema_period (simple float) : Period for the EMA calculation
Returns: Array of float values representing the EMA of the candle data, ordered with most recent at index 0
method draw_ctf_candles_time(self, sample_type, number_of_ticks, number_of_seconds, timezone)
Renders custom timeframe candles using bar time coordinates
Namespace types: array
Parameters:
self (array)
sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks), used for tooltips
number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks), used for tooltips
number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time), used for tooltips
timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12), used for tooltips
Returns: void - Renders candles on the chart using time-based x-coordinates
method draw_ctf_candles_index(self, sample_type, number_of_ticks, number_of_seconds, timezone)
Renders custom timeframe candles using bar index coordinates
Namespace types: array
Parameters:
self (array)
sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks), used for tooltips
number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks), used for tooltips
number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time), used for tooltips
timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12), used for tooltips
Returns: void - Renders candles on the chart using index-based x-coordinates
method draw_ctf_line_time(self, source, line_size, line_color)
Renders a line representing a price component from the candles using time coordinates
Namespace types: array
Parameters:
self (array)
source (simple Source) : Optional - Type of price data to extract (defaults to Close)
line_size (simple int) : Optional - Width of the line
line_color (simple color) : Optional - Color of the line
Returns: void - Renders a connected line on the chart using time-based x-coordinates
method draw_ctf_line_time(self, line_size, line_color)
Renders a line from a varip float array using time coordinates
Namespace types: array
Parameters:
self (array)
line_size (simple int) : Optional - Width of the line, defaults to 2
line_color (simple color) : Optional - Color of the line
Returns: void - Renders a connected line on the chart using time-based x-coordinates
method draw_ctf_line_index(self, source, line_size, line_color)
Renders a line representing a price component from the candles using index coordinates
Namespace types: array
Parameters:
self (array)
source (simple Source) : Optional - Type of price data to extract (defaults to Close)
line_size (simple int) : Optional - Width of the line
line_color (simple color) : Optional - Color of the line
Returns: void - Renders a connected line on the chart using index-based x-coordinates
method draw_ctf_line_index(self, line_size, line_color)
Renders a line from a varip float array using index coordinates
Namespace types: array
Parameters:
self (array)
line_size (simple int) : Optional - Width of the line, defaults to 2
line_color (simple color) : Optional - Color of the line
Returns: void - Renders a connected line on the chart using index-based x-coordinates
plot_ctf_tick_candles(source, candle_type, number_of_ticks, timezone, tied_open, ema_period, bullish_color, bearish_color, line_width, ema_color, use_time_indexing)
Plots tick-based candles with moving average
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to display
number_of_ticks (simple int) : Number of ticks per candle
timezone (simple int) : Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Whether to tie open price to close of previous candle
ema_period (simple float) : Period for the exponential moving average
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
line_width (simple int) : Optional - Width of the moving average line, defaults to 2
ema_color (color) : Optional - Color of the moving average line
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart with EMA overlay
plot_ctf_tick_candles(source, candle_type, number_of_ticks, timezone, tied_open, bullish_color, bearish_color, use_time_indexing)
Plots tick-based candles without moving average
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to display
number_of_ticks (simple int) : Number of ticks per candle
timezone (simple int) : Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Whether to tie open price to close of previous candle
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart without moving average
plot_ctf_time_candles(source, candle_type, number_of_seconds, timezone, tied_open, ema_period, bullish_color, bearish_color, line_width, ema_color, use_time_indexing)
Plots time-based candles with moving average
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to display
number_of_seconds (simple float) : Time duration per candle in seconds
timezone (simple int) : Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Whether to tie open price to close of previous candle
ema_period (simple float) : Period for the exponential moving average
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
line_width (simple int) : Optional - Width of the moving average line, defaults to 2
ema_color (color) : Optional - Color of the moving average line
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart with EMA overlay
plot_ctf_time_candles(source, candle_type, number_of_seconds, timezone, tied_open, bullish_color, bearish_color, use_time_indexing)
Plots time-based candles without moving average
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to display
number_of_seconds (simple float) : Time duration per candle in seconds
timezone (simple int) : Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Whether to tie open price to close of previous candle
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart without moving average
plot_ctf_candles(source, candle_type, sample_type, number_of_ticks, number_of_seconds, timezone, tied_open, ema_period, bullish_color, bearish_color, enable_ema, line_width, ema_color, use_time_indexing)
Unified function for plotting candles with comprehensive options
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Optional - Type of candle chart to display
sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks)
number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks)
number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time)
timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Optional - Whether to tie open price to close of previous candle
ema_period (simple float) : Optional - Period for the exponential moving average
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
enable_ema (bool) : Optional - Whether to display the EMA overlay
line_width (simple int) : Optional - Width of the moving average line, defaults to 2
ema_color (color) : Optional - Color of the moving average line
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart with optional EMA overlay
ctf_candles_array(source, candle_type, sample_type, number_of_ticks, number_of_seconds, tied_open, bullish_color, bearish_color)
Creates an array of custom timeframe candles without rendering them
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to create (candlestick or Heikin-Ashi)
sample_type (simple SampleType) : Method for sampling data (Time or Ticks)
number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks)
number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time)
tied_open (simple bool) : Optional - Whether to tie open price to close of previous candle
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
Returns: Array of CandleCTF objects ordered with most recent at index 0
Candle
Structure representing a complete candle with price data and display properties
Fields:
Open (series float) : Opening price of the candle
High (series float) : Highest price of the candle
Low (series float) : Lowest price of the candle
Close (series float) : Closing price of the candle
polarity (series bool) : Boolean indicating if candle is bullish (true) or bearish (false)
series_index (series int) : Sequential index identifying the candle in the series
candle_color (series color) : Color to use when rendering the candle
ready (series bool) : Boolean indicating if candle data is valid and ready for use
TickData
Structure for storing individual price updates
Fields:
price (series float) : The price value at this tick
time_delta (series float) : Time elapsed since the previous tick in milliseconds
series_index (series int) : Sequential index identifying this tick
CandleCTF
Structure representing a custom timeframe candle with additional time metadata
Fields:
Open (series float) : Opening price of the candle
High (series float) : Highest price of the candle
Low (series float) : Lowest price of the candle
Close (series float) : Closing price of the candle
polarity (series bool) : Boolean indicating if candle is bullish (true) or bearish (false)
series_index (series int) : Sequential index identifying the candle in the series
open_time (series int) : Timestamp marking when the candle was opened (in Unix time)
time_delta (series float) : Duration of the candle in milliseconds
candle_color (series color) : Color to use when rendering the candle
UT Bot Alerts – Time Filtered with ExitsThis indicator combines several technical approaches to generate precise entry and exit signals, while incorporating time filters that ensure signals are sent only during desired time windows and with defined cooldown periods. It is based on the original idea by QuantNomad.
Main Components:
ATR-based Trailing Stop:
Using the Average True Range (ATR) and an adjustable multiplier ("Key Value"), a dynamic trailing stop is calculated that adapts to the current price. This trailing stop forms the basis for the signal generation.
EMA-based Entry Signals:
A very short exponential moving average (EMA, period 1) is used in combination with the trailing stop to identify clear buy (long) and sell (short) signals via crossovers. An additional buffer zone helps reduce false signals.
Persistent Trade State:
The current state (long, short, or neutral) is maintained so that the system remains in the trend until a new signal is generated.
Linear Regression as Reference:
A linear regression line computed over a defined period serves as a reference for determining exit levels.
Exit Signals with Delay:
Exit signals are generated when the price deviates from the linear regression line by a defined percentage (Exit Signal Deviation) and the condition persists for at least a specified number of bars (Exit Signal Delay). Only one exit signal is issued per trade to avoid excessive exits.
Time Filters and Cooldown:
Session Filter: A user-defined session (e.g., "2200-0500") can disable signals during specified periods.
Cooldown Period: After a signal is triggered, a cooldown phase (in minutes) can be set during which no new signals are sent.
Visual Display and Alerts:
Entry Signals: Buy and sell signals are displayed as labels (green for long, red for short).
Exit Signals: Exit signals appear as triangles, with the exit long signal text displayed in white.
Reference Lines:
The upper exit level (Exit Short Level) is drawn as a solid line in turquoise (color.aqua).
The lower exit level (Exit Long Level) is drawn as a solid line in yellow.
Additionally, the ATR trailing stop and the linear regression line are clearly plotted on the chart.
Alerts can be configured for all signal types.
In Summary:
The indicator delivers precise entry signals based on an ATR trailing stop and a short EMA, supplemented by dynamic exit levels determined via linear regression. With integrated time filters (session and cooldown) and a flexible exit mechanism, this indicator offers controlled trade management—ideal for traders who wish to receive signals only during desired time periods.
Original Author: QuantNomad