Universal Renko Bars by SiddWolfUniversal Renko Bars or UniRenko Bars is an overlay indicator that applies the logic of Renko charting directly onto a standard candlestick chart. It generates a sequence of price-driven bricks, where each new brick is formed only when the price moves a specific amount, regardless of time. This provides a clean, price-action-focused visualization of the market's trend.
WHAT IS UNIVERSAL RENKO BARS?
For years, traders have faced a stark choice: the clean, noise-free world of Renko charts, or the rich, time-based context of Candlesticks. Choosing Renko meant giving up your favorite moving averages, volume profiles, and the fundamental sense of time. Choosing Candlesticks meant enduring the market noise that often clouds true price action.
But what if you didn't have to choose?
Universal Renko Bars is a revolutionary indicator that ends this dilemma. It's not just another charting tool; it's a powerful synthesis that overlays the pure, price-driven logic of Renko bricks directly onto your standard candlestick chart. This hybrid approach gives you the best of both worlds:
❖ The Clarity of Renko: By filtering out the insignificant noise of time, Universal Renko reveals the underlying trend with unparalleled clarity. Up trends are clean successions of green bricks; down trends are clear red bricks. No more guesswork.
❖ The Context of Candlesticks: Because the Renko logic is an overlay, you retain your time axis, your volume data, and full compatibility with every other time-based indicator in your arsenal (RSI, MACD, Moving Averages, etc.).
The true magic, however, lies in its live, Unconfirmed Renko brick. This semi-transparent box is your window into the current bar's real-time struggle. It grows, shrinks, and changes color with every tick, showing you exactly how close the price is to confirming the trend or forcing a reversal. It’s no longer a lagging indicator; it’s a live look at the current battle between buyers and sellers.
Universal Renko Bars unifies these two powerful charting methods, transforming your chart into a more intelligent, noise-free, and predictive analytical canvas.
HOW TO USE
To get the most out of Universal Renko Bars, here are a few tips and a full breakdown of the settings.
Initial Setup for the Best Experience
For the cleanest possible view, it's highly recommended that you hide the body of your standard candlesticks, that shows only the skelton of the candle. This allows the Renko bricks to become the primary focus of your chart.
→ Double click on the candles and uncheck the body checkbox.
Settings Breakdown
The indicator is designed to be powerful yet intuitive. The settings are grouped to make customization easy.
First, What is a "Tick"?
Before we dive in, it's important to understand the concept of a "Tick." In Universal Renko, a Tick is not the same as a market tick. It's a fundamental unit of price movement that you define. For example, if you set the Tick Size to $0.50, then a price move of $1.00 is equal to 2 Ticks. This is the core building block for all Renko bricks. Tick size here is dynamically determined by the settings provided in the indicator.
❖ Calculation Method (The "Tick Size" Engine)
This section determines the monetary value of a single "Tick."
`Calculation Method` : Choose your preferred engine for defining the Tick Size.
`ATR Based` (Default): The Tick Size becomes dynamic, based on market volatility (Average True Range). Bricks will get larger in volatile markets and smaller in quiet ones. Use the `ATR 14 Multiplier` to control the sensitivity.
`Percentage` : The Tick Size is a simple percentage of the current asset price, controlled by the `Percent Size (%)` input.
`Auto` : The "set it and forget it" mode. The script intelligently calculates a Tick Size based on the asset's price. Use the `Auto Sensitivity` slider to make these automatically calculated bricks thicker (value > 1.0) or thinner (value < 1.0).
❖ Parameters (The Core Renko Engine)
This group controls how the bricks are constructed based on the Tick Size.
`Tick Trend` : The number of "Ticks" the price must move in the same direction to print a new continuation brick. A smaller value means bricks form more easily.
`Tick Reversal` : The number of "Ticks" the price must move in the opposite direction to print a new reversal brick. This is typically set higher than `Tick Trend` (e.g., double) to filter out minor pullbacks and market noise.
`Open Offset` : Controls the visual overlap of the bricks. A value of `0` creates gapless bricks that start where the last one ended. A value of `2` (with a `Tick Reversal` of 4) creates the classic 50% overlap look.
❖ Visuals (Controlling What You See)
This is where you tailor the chart to your visual preference.
`Show Confirmed Renko` : Toggles the solid-colored, historical bricks. These are finalized and will never change. They represent the confirmed past trend.
`Show Unconfirmed Renko` : This is the most powerful visual feature. It toggles the live, semi-transparent box that represents the developing brick. It shows you exactly where the price is right now in relation to the levels needed to form the next brick.
`Show Max/Min Levels` : Toggles the horizontal "finish lines" on your chart. The green line is the price target for a bullish brick, and the red line is the target for a bearish brick. These are excellent for spotting breakouts.
`Show Info Label` : Toggles the on-chart label that provides key real-time stats:
🧱 Bricks: The total count of confirmed bricks.
⏳ Live: How many chart bars the current live brick has been forming. These bars forms the Renko bricks that aren't confirmed yet. Live = 0 means the latest renko brick is confirmed.
🌲 Tick Size: The current calculated value of a single Tick.
Hover over the label for a tooltip with live RSI(14), MFI(14), and CCI(20) data for additional confirmation.
TRADING STRATEGIES & IDEAS
Universal Renko Bars isn't just a visual tool; it's a foundation for building robust trading strategies.
Trend Confirmation: The primary use is to instantly identify the trend. A series of green bricks indicates a strong uptrend; a series of red bricks indicates a strong downtrend. Use this to filter out trades that go against the primary momentum.
Reversal Spotting: Pay close attention to the Unconfirmed Brick . When a strong trend is in place and the live brick starts to fight against it—changing color and growing larger—it can be an early warning that a reversal is imminent. Wait for the brick to be confirmed for a higher probability entry.
Breakout Trading: The `Max/Min Levels` are your dynamic breakout zones. A long entry can be considered when the price breaks and closes above the green Max Level, confirming a new bullish brick. A short entry can be taken when price breaks below the red Min Level.
Confluence & Indicator Synergy: This is where Universal Renko truly shines. Overlay a moving average (e.g., 20 EMA). Only take long trades when the green bricks are forming above the EMA. Combine it with RSI or MACD; a bearish reversal brick forming while the RSI shows bearish divergence is a very powerful signal.
A FINAL WORD
Universal Renko Bars was designed to solve a fundamental problem in technical analysis. It brings together the best elements of two powerful methodologies to give you a clearer, more actionable view of the market. By filtering noise while retaining context, it empowers you to make decisions with greater confidence.
Add Universal Renko Bars to your chart today and elevate your analysis. We welcome your feedback and suggestions for future updates!
Follow me to get notified when I publish New Indicator.
~ SiddWolf
Candles
UT Bot + LinReg Candles (Dual Sensitivity)
Script Description:
This indicator combines the popular UT Bot Alerts system with Linear Regression Candles (open source) for enhanced trend detection and trading signals in one singel script. The UT Bot features independent, then 2 x ATR sensitivity and periods controls for buy and sell signals, allowing you to fine-tune entries and exits to match your strategy. The script also overlays colored Linear Regression Candles with an optional signal line, helping you visually identify trend strength and direction. All calculations are performed on standard chart prices (no Heikin Ashi). Suitable for all asset classes and timeframes.
Eample setting for usdjpy 5 min chart for repeated buy and sell singnals based on trend:
BUY ATR period 300 multiplier 1
SELL ATR period 1 multiplier 2
Disclaimer:
This script is for informational and educational purposes only. It is not financial advice. Use at your own risk; the author assumes no responsibility for any trading results or losses.
Credits goes to to Ugurvu for linreg candles and quantnomad for UT Bot alerts that make this script possible.
Author: Patrick
Smart Bar Counter with Alerts🚀 Smart Bar Counter with Alerts 🚀
-----------------------------------------------------
Overview
-----------------------------------------------------
Ever wanted to count a specific number of bars from a key point on your chart—such as after a Break of Structure (BOS), the start of a new trading session, or from any point of interest— without having to stare at the screen?
This "Smart Bar Counter" indicator was created to solve this exact problem. It's a simple yet powerful tool that allows you to define a custom "Start Point" and a "Target Bar Count." Once the target count is reached, it can trigger an Alert to notify you immediately.
-----------------------------------------------------
Key Features
-----------------------------------------------------
• Manual Start Point: Precisely select the date and time from which you want the count to begin, offering maximum flexibility in your analysis.
• Custom Bar Target: Define exactly how many bars you want to count, whether it's 50, 100, or 200 bars.
• On-Chart Display: A running count is displayed on each bar after the start time, allowing you to visually track the progress.
• Automatic Alerts: Set up alerts to be notified via TradingView's various channels (pop-up, mobile app, email) once the target count is reached.
-----------------------------------------------------
How to Use
-----------------------------------------------------
1. Add this indicator to your chart.
2. Go to the indicator's Settings (Gear Icon ⚙️).
- Select Start Time: Set the date and time you wish to begin counting.
- Number of Bars to Count: Input your target number.
3. Set up the Alert ( Very Important! ).
- Right-click on the chart > Select " Add alert ."
- In the " Condition " dropdown, select this indicator: Smart Bar Counter with Alerts .
- In the next dropdown, choose the available alert condition.
- Set " Options " to Once Per Bar Close .
- Choose your desired notification methods under " Alert Actions ."
- Click " Create ."
-----------------------------------------------------
Use Cases
-----------------------------------------------------
• Post-Event Analysis: Count bars after a key event like a Break of Structure (BOS) or Change of Character (CHoCH) to observe subsequent price action.
• Time-based Analysis: Use it to count bars after a market open for a specific session (e.g., London, New York).
• Strategy Backtesting: Useful for testing trading rules that are based on time or a specific number of bars.
-----------------------------------------------------
Final Words
-----------------------------------------------------
Hope you find this indicator useful for your analysis and trading strategies! Feel free to leave comments or suggestions below.
LRCLRC (Linear Regression Candle)
Overview
The LRC (Linear Regression Candle) indicator applies linear regression to the open, high, low, and close prices, creating smoothed "candles" that help filter market noise. It provides trend-confirmation signals and highlights potential reversal points based on regression crossovers.
Key Features
Smoothed Candles: Uses linear regression to calculate synthetic OHLC values, reducing noise.
Multi-Timeframe Support: Optional higher timeframe analysis for better trend confirmation.
Visual Signals: Color-coded candles and labels highlight bullish/bearish control zones.
Customizable Settings: Adjustable regression length, colors, and timeframe options.
How to Use
Signals & Interpretation
🟢 Bullish Signal (BUY): When the regression open crosses above the regression close (green candle).
🔴 Bearish Signal (SELL): When the regression open crosses below the regression close (red candle).
Control Zones:
Strong Bullish (Controlbull): Confirmed uptrend (bright green).
Bullish (Bull): Regular uptrend (light green).
Strong Bearish (Controlbear): Confirmed downtrend (dark red).
Bearish (Bear): Regular downtrend (orange).
Neutral (Gray): No clear trend.
Recommended Settings
Linear Regression Length: Default 8 (adjust for sensitivity).
Timeframe: Default current chart, but can switch to higher timeframes (e.g., 1D, 1W).
Bar Colors: Toggle on/off for visual clarity.
Labels: Displays "Control" markers at key reversal points.
Example Use Cases
Trend Confirmation: Use higher timeframe LRC to validate the primary trend.
Reversal Signals: Watch for BUY/SELL crossovers with strong color confirmation.
Noise Reduction: Helps avoid false breakouts in choppy markets.
Hybrid Heikin Ashi OverlayHybrid Heikin Ashi Overlay
I personally like Heikin Ashi for its simplicity in showing clean trends. However, it tends to smooth out price action so much that we sometimes miss key signals from the actual candles.
This indicator overlays Heikin Ashi-style background colors while keeping regular candles intact — giving you the best of both worlds:
• Smoother trend visibility
• No loss of execution precision
• Customizable colors & transparency
🔹 No repainting
🔹 No strategy logic — purely visual
🔹 Designed to reduce clutter and help traders stay focused on structure
Created by: @yug_and_her
Strong/Weak Candle FinderStrong/Weak Candle Finder (SWCF)
Overview:
The Strong/Weak Candle Finder (SWCF) is a versatile TradingView indicator designed to help traders identify statistically significant candles based on their size relative to recent historical price action. By analyzing a lookback period, the indicator dynamically calculates a threshold to classify candles as either "strong" (larger than the threshold) or "weak" (smaller than the threshold), providing visual cues directly on your chart.
This tool can be invaluable for traders looking to:
Spot potential momentum breakouts or high volatility (Strong Candles).
Identify periods of consolidation or low volatility (Weak Candles).
Gauge shifts in market sentiment based on candle body or range dynamics.
How It Works:
Candle Size Calculation: You choose how candle size is measured from four methods:
High - Low: The full range of the candle.
High - Close: The distance from the high to the close.
Open - Close: The size of the candle body.
Low - Open: The distance from the low to the open.
Historical Analysis: The indicator looks back over a user-defined LookBack Period to collect candle sizes.
Grouping & Precision: To smooth the distribution, candle sizes are grouped based on the Group Precision Size. This parameter divides the observed range of candle sizes into a set number of "bins," and individual candle sizes are rounded to the nearest representative value of these bins.
Percentile Threshold: A dynamic Outlier Pip Value is calculated based on the Outlier Percentile you set.
If Display Mode is "Strong Candles," this threshold represents the Nth percentile of the largest candle sizes (e.g., the 80th percentile if Outlier Percentile is 20%). Candles larger than this are marked as "Strong."
If Display Mode is "Weak Candles," this threshold represents the Nth percentile of the smallest candle sizes (e.g., the 20th percentile). Candles smaller than this are marked as "Weak."
Visual Markers: When a current candle meets the criteria (strong or weak based on your display mode), a configurable shape is plotted above (for strong) or below (for weak) the candle.
Resampling: The historical distribution and outlier threshold are recalculated every Resample Period (number of bars) to adapt to changing market conditions.
Key Features:
Dynamic Thresholds: Adapts to market volatility instead of using fixed pip values.
Customizable Candle Definition: Choose from four methods to define what "candle size" means to your strategy.
Flexible Display Modes: Focus on either identifying exceptionally strong candles or unusually weak ones.
Adjustable Sensitivity: Fine-tune the rarity of signals with Outlier Percentile and Group Precision Size.
Visual Chart Markers: Clear, customizable shapes (arrow, circle, etc.) for easy identification.
Periodic Recalculation: Ensures the indicator remains relevant as market dynamics evolve.
Parameters:
Display Mode:
Strong Candles: Highlights candles larger than the upper percentile threshold.
Weak Candles: Highlights candles smaller than the lower percentile threshold.
Resample Period (Candles): How often (in bars) to recalculate the historical distribution and outlier threshold.
LookBack Period (Candles): The number of past candles to analyze for the historical distribution. (Note: Plots will only begin after this many bars have loaded on the chart).
Group Precision Size: Number of groups to divide the candle size range into for rounding historical sizes. Higher values mean finer precision (less rounding).
Outlier Percentile (%): The percentile used to define the threshold for strong/weak candles.
Candle Size Method: (High-Low, High-Close, Open-Close, Low-Open).
Visuals:
Strong Shape: Choose the icon style for strong candles.
Weak Shape: Choose the icon style for weak candles.
Shape Size: Adjust the size of the plotted icons.
How to Use:
Strong Candles:
May indicate increased momentum, potential breakout confirmations, or high conviction moves.
Consider using in trending markets or as a filter for entry signals.
Weak Candles:
May signal market indecision, low volatility, consolidation phases, or potential exhaustion of a prior move.
Can be useful for identifying range-bound conditions or periods to be cautious.
Experimentation: Adjust the LookBack Period, Outlier Percentile, and Group Precision Size to match your trading style and the characteristics of the asset you are trading. What constitutes "strong" or "weak" can vary significantly.
Confirmation Tool: Use in conjunction with other indicators (e.g., moving averages, RSI, volume) for more robust trading decisions.
Important Notes:
The indicator requires sufficient historical data (LookBack Period) to initialize. You may not see plots on the chart immediately if there aren't enough bars loaded.
Like all indicators, the SWCF is not a standalone trading system and should not be used as the sole basis for financial decisions.
Past performance is not indicative of future results. Always use appropriate risk management.
We hope you find the Strong/Weak Candle Finder a valuable addition to your trading toolkit!
MestreDoFOMO Future Projection BoxMestreDoFOMO Future Projection Box - Description & How to Use
Description
The "MestreDoFOMO Future Projection Box" is a TradingView indicator tailored for crypto traders (e.g., BTC/USDT on 1H, 4H, or 1D timeframes). It visualizes current price ranges, projects future levels, and confirms trends using semi-transparent boxes. With labeled price levels and built-in alerts, it’s a simple yet powerful tool for identifying support, resistance, and potential price targets.
How It Works
Blue Box (Current Channel): Shows the recent price range over the last 10 bars (adjustable). The top is the highest high plus an ATR buffer, and the bottom is the lowest low minus the buffer. Labels display exact levels (e.g., "Top: 114000", "Bottom: 102600").
Green Box (Future Projection): Projects the price range 10 bars ahead (adjustable) based on the trend slope of the moving average. Labels show "Proj Top" and "Proj Bottom" for future targets.
Orange Box (Moving Average): Traces a 50-period EMA (adjustable) to confirm the trend. An upward slope signals a bullish trend; a downward slope signals a bearish trend. A label shows the current MA value (e.g., "MA: 105000").
Alerts: Triggers when the price nears the projected top or bottom, helping you catch breakouts or retracements.
How to Use
Add the Indicator: Apply "MestreDoFOMO Future Projection Box" to your chart in TradingView.
Interpret the Trend: Check the orange box’s slope—upward for bullish, downward for bearish.
Identify Key Levels: Use the blue box’s top as resistance and bottom as support. On a 4H chart, if the top is 114,000, expect resistance; if the bottom is 102,600, expect support.
Plan Targets: Use the green box for future targets—top for profit-taking (e.g., 114,000), bottom for stop-loss or buying (e.g., 102,600).
Set Alerts: Enable alerts for "Near Upper Projection" or "Near Lower Projection" to get notified when the price hits key levels.
Trade Examples:
Bullish: If the price breaks above the blue box top (e.g., 114,000), buy with a target at the green box top. Set a stop-loss below the green box bottom.
Bearish: If the price rejects at the blue box top and drops below the orange MA, short with a target at the blue box bottom.
Customize: Adjust the lookback period, projection bars, ATR multiplier, and MA length in the settings to fit your trading style.
Tips
Use on 1H for short-term trades, 4H for swing trades, or 1D for long-term trends.
Combine with volume or RSI to confirm signals.
Validate levels with market structure (e.g., candlestick patterns).
MestreDoFOMO Renko Underground v4.0Description:
The "MestreDoFOMO Renko Underground v4.0" is a custom indicator for TradingView that creates a dynamic Renko chart to help identify trends and reversal points in the market. Unlike traditional candlestick charts, Renko focuses solely on significant price movements, ignoring time and market noise. This script includes advanced features like support and resistance channels, moving averages, and alerts to assist with your trading decisions.
How It Works:
Dynamic Renko Bricks:
The brick size (price units to form each "box" on the chart) is calculated automatically using the ATR (Average True Range) with an adjustable multiplier. This means the size adapts to the asset's volatility (e.g., BTC/USDT). When the price moves up or down by the brick size, a new brick is created (green for up, red for down).
Reversal Signals:
Green triangles (🔼) appear below bars when the trend shifts to bullish, and red triangles (🔽) appear above when it shifts to bearish. These signals only appear on direction changes, reducing false signals.
Renko Channel:
The script draws two lines (green for resistance and red for support) based on the highs and lows of the last 10 bricks (or the value you set). This helps identify key price zones.
Moving Average on Bricks:
An orange line shows the moving average (EMA or SMA, your choice) of the last 20 bricks, helping confirm the overall trend.
Alerts:
You can set up alerts in TradingView to be notified when the trend shifts to bullish or bearish, perfect for active trading.
Visualization:
A gray dashed line shows the level of the last brick, providing a clear reference for the next expected move.
How to Use:
Add the indicator to your chart (e.g., BTC/USDT 1D).
Adjust parameters like the ATR multiplier, channel length, and moving average type in the settings menu.
Watch the bricks and signals to identify trends, and use the channels and moving average to plan entries and exits.
Enable alerts to receive real-time notifications.
Tip:
Test on different timeframes (1H, 4H, 1D) and adjust the ATR multiplier to match the volatility of the asset you're trading. Combine with other indicators (like RSI) for better results!
Inside Bar (Body-based) Ind/AlertDescription:
This indicator detects Inside Bar patterns based strictly on the candle body (open/close range) of the mother candle, rather than the traditional high/low wick method. An inside bar is highlighted when the current candle’s entire body is contained within the body of the previous candle.
It can be useful for traders who want a more conservative and reliable definition of inside bars, focusing on true consolidation periods and filtering out signals caused by extended wicks.
Features:
Body-based Inside Bar detection:
The indicator colors and marks candles where the current bar’s body is fully within the previous bar’s body.
Bullish/Bearish identification:
Bullish inside bars are marked in green, bearish in red.
Double Inside Bar Detection:
An optional feature marks when two consecutive candles’ bodies are inside the same mother bar body—potentially indicating stronger consolidation.
Alerts:
Set alerts for single or double inside bars for automated monitoring.
How to Use:
Add the indicator to your chart.
Look for colored bars or plotted shapes for inside bar signals based on candle bodies.
Use alerts to get notified in real time when inside bar patterns appear.
Note:
This script uses only the candle body (open and close) for inside bar calculations, which may help filter out less reliable signals found with wick-based approaches.
Consecutive Green Candles + 20% Move ScreenerConsecutive Green Candles Momentum Tracker
This indicator identifies powerful bullish momentum streaks in stocks, highlighting opportunities where consistent buying pressure has driven significant price increases.
The script tracks sequences of consecutive green (bullish) candles that collectively move a stock's price by more than 20%. It marks both the beginning of such streaks with a green label and their conclusion with a red arrow when price momentum finally reverses.
Perfect for traders looking to:
- Identify stocks experiencing strong directional momentum
- Spot potential reversal points after extended rallies
- Screen for securities with recent bullish strength
- Understand the magnitude of recent price runs
Simply adjust the minimum number of candles and percentage threshold to match your preferred momentum criteria.
Candle SequenceLooking to easily identify moments of strong market conviction? "Racha Velas" (or your chosen English name like "Consecutive Candles Streak") allows you to visualize clearly and directly sequences of consecutive bullish and bearish candles.
**Key Features:**
* **Real-time Counting:** Displays the number of consecutive candles directly on the chart.
* **Visual Customization:** Adjust the text size and color for optimal visualization.
* **Vertical Offset:** Control the position of the counter to avoid obstructions.
* **Maximum Streaks Table (Optional):** Visualize the largest bullish and bearish streaks found in the chart's history, useful for understanding volatility and price behavior.
* **Easy to Use:** Simply add the indicator to your chart and start analyzing.
This indicator is a valuable tool for traders looking to confirm trends, identify potential exhaustion points, or simply understand price dynamics at a glance. Give it a try and discover the market's streaks!
*****************************************************************************************************
¿Buscas identificar momentos de fuerte convicción del mercado? "Racha Velas" te permite visualizar de forma clara y directa las secuencias de velas consecutivas alcistas y bajistas.
**Características principales:**
* **Conteo en Tiempo Real:** Muestra el número de velas consecutivas directamente en el gráfico.
* **Personalización Visual:** Ajusta el tamaño y color del texto para una visualización óptima.
* **Offset Vertical:** Controla la posición del contador para evitar obstrucciones.
* **Tabla de Rachas Máximas (Opcional):** Visualiza las mayores rachas alcistas y bajistas encontradas en el historial del gráfico, útil para entender la volatilidad y el comportamiento del precio.
* **Fácil de Usar:** Simplemente añade el indicador a tu gráfico y comienza a analizar.
Este indicador es una herramienta valiosa para traders que buscan confirmar tendencias, identificar posibles agotamientos o simplemente entender la dinámica del precio en un vistazo. ¡Pruébalo y descubre las rachas del mercado!
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
DynamicHeikin-Ashi-RKDynamic Heikin-Ashi RK is an advanced Heikin-Ashi candle indicator with a unique ATR-based offset mechanism. This script refines traditional Heikin-Ashi calculations while dynamically shifting the candles using ATR multipliers, helping traders visualize market trends with greater clarity.
🔹 Features:
✔ Customizable Heikin-Ashi colors
✔ ATR-based dynamic candle offset
✔ Enhanced trend visualization
This tool is ideal for traders looking for a smoother trend representation while incorporating volatility-based adjustments. 🚀
Customizations Available in Dynamic Heikin-Ashi RK
This indicator allows several customizations to suit different trading styles:
🔹 Heikin-Ashi Candle Display: Toggle the visibility of Heikin-Ashi candles.
🔹 Custom Colors: Choose custom colors for bullish and bearish Heikin-Ashi candles.
🔹 ATR-Based Dynamic Offset: Adjust the ATR multiplier to control the offset of Heikin-Ashi candles, helping fine-tune trend visualization.
🔹 Refined Heikin-Ashi Calculation: Uses a smoother formula for Heikin-Ashi candles, enhancing clarity.
With these options, traders can personalize the indicator for better trend detection and volatility analysis. 🚀
HTF Candle Volume Thermometer [ChartPrime]The HTF Candle Volume Thermometer is a powerful volume heatmap tool that visualizes higher timeframe candle volume distributions directly on the chart. It helps traders identify key price levels where liquidity is concentrated, allowing for more informed trading decisions.
⯁ KEY FEATURES
Higher Timeframe Volume Mapping
Uses higher timeframe (HTF) candles to create a heatmap of volume distribution within each candle.
Dynamic Volume Heatmap
Colors each HTF candle background green for bullish and red for bearish, with a gradient heat overlay highlighting volume concentration.
Max Volume Point Identification
Marks the level within each HTF candle where the highest volume was recorded, using red for the most significant volume area.
Fully Customizable Display
Users can adjust the HTF timeframe, color settings, and resolution to tailor the indicator to their trading preferences.
Segmented Volume Distribution
Each HTF candle is divided into smaller levels, allowing traders to see volume changes within the range of each candle.
Key Level Detection
Max volume points often act as key support and resistance levels where price is likely to react, helping traders refine their strategies.
⯁ HOW TO USE
Identify Liquidity Zones
Use the max volume levels to determine areas where price is likely to find support or resistance.
Assess Trend Strength
Compare volume distribution between bullish and bearish HTF candles to gauge market momentum.
Optimize Trade Entries & Exits
Look for price reactions at high-volume areas to refine stop-loss and take-profit levels.
Adjust Heatmap Resolution
Customize the resolution setting to get a more detailed or broader view of volume segmentation within HTF candles.
⯁ CONCLUSION
The HTF Candle Volume Thermometer is a must-have tool for traders who want to integrate volume analysis with higher timeframe structures. By visualizing volume heatmaps within each HTF candle, this indicator helps traders pinpoint critical liquidity zones and key price levels.
Triangular Hull Moving Average + Volatility [BigBeluga]This indicator combines the Triangular Hull Moving Average (THMA) with a volatility overlay to provide a smoother trend-following tool while dynamically visualizing market volatility.
🔵 Key Features:
THMA-Based Trend Detection: The indicator applies a Triangular Hull Moving Average (THMA) to smooth price data, reducing lag while maintaining responsiveness to trend changes.
// THMA
thma(_src, _length) =>
ta.wma(ta.wma(_src,_length / 3) * 3 - ta.wma(_src, _length / 2) - ta.wma(_src, _length), _length)
Dynamic Volatility Bands: When enabled, the indicator displays wicks extending from the THMA-based candles. These bands expand and contract based on price volatility.
Trend Reversal Signals The indicator marks trend shifts using triangle-shaped signals:
- Upward triangles appear when the THMA trend shifts to bullish.
- Downward triangles appear when the THMA trend shifts to bearish.
Customizable Settings: Users can adjust the THMA length, volatility calculation period, and colors for up/down trends to fit their trading style.
Informative Dashboard: The bottom-right corner displays the current trend direction and volatility percentage, helping traders quickly assess market conditions.
🔵 Usage:
Trend Trading: The colored candles indicate whether the market is trending up or down. Traders can follow the trend direction and use trend reversals for entry or exit points.
Volatility Monitoring: When the volatility feature is enabled, the expanding or contracting wicks help visualize market momentum and potential breakout strength.
Signal Confirmation: The triangle signals can be used to confirm potential entry points when the trend shifts.
This tool is ideal for traders who want a responsive moving average with volatility insights to enhance their trend-following strategies.
Volume Zones Internal Visualizer [LuxAlgo]The Volume Zones Internal Visualizer is an alternate candle type intended to reveal lower timeframe volume activity while on a higher timeframe chart.
It displays the candle's range, the highest and lowest zones of accumulated volume throughout the candle, and the Lower Timeframe (LTF) candle close, which contained the most volume in the session (Candle Session).
🔶 USAGE
The indicator is intended to be used as its own independent candle type. It is not a replacement for traditional candlesticks; however, it is recommended that you hide the chart's display when using this indicator. Another option is to display this indicator in an additional pane alongside the normal chart, as displayed above.
The display consists of candle ranges represented by outlined boxes, within the ranges you will notice a transparent-colored zone, a solid-colored zone, and a line.
Each of these displays different points of volume-related information from an analysis of LTF data.
In addition to this analysis, the indicator also locates the LTF candle with the highest volume, and displays its close represented by the line. This line is considered as the "Peak Activity Level" (PAL), since throughout the (HTF) candle session, this candle's close is the outcome of the most volume transacted at the time.
We are further tracking these PALs by continuing to extend them into the future, looking towards them for potential further interaction. Once a PAL is crossed, we are removing it from display as it has been mitigated.
🔶 DETAILS
The indicator aggregates the volume data from each LTF candle and creates a volume profile from it; the number of rows in the profile is determined by the "Row Size" setting.
With this profile, it locates and displays the highest (solid area) and lowest (transparent area) volume zones from the profile created.
🔶 SETTINGS
Row Size: Sets the number of rows used for the calculation of the volume profile based on LTF data.
Intrabar Timeframe: Sets the Lower Timeframe to use for calculations.
Show Last Unmitigated PALs: Choose how many Unmitigated PALs to extend.
Style: Toggle on and off features, as well as adjust colors for each.
Average Candle Size (Points)ATR but with the ability to add threshold lines (UP TO 3) that help gauge how volatile the market is. Also, note that the default threshold values are set up for NQ Futures so you will need to change your values to your specific needs.
Candle Emotion Index (CEI) StrategyThe Candle Emotion Index (CEI) Strategy is an innovative sentiment-based trading approach designed to help traders identify and capitalize on market psychology. By analyzing candlestick patterns and combining them into a unified metric, the CEI Strategy provides clear entry and exit signals while dynamically managing risk. This strategy is ideal for traders looking to leverage market sentiment to identify high-probability trading opportunities.
How It Works
The CEI Strategy is built around three core oscillators that reflect key emotional states in the market:
Indecision Oscillator . Measures market uncertainty using patterns like Doji and Spinning Tops. High values indicate hesitation, signaling potential turning points.
Fear Oscillator . Tracks bearish sentiment through patterns like Shooting Star, Hanging Man, and Bearish Engulfing. Helps identify moments of intense selling pressure.
Greed Oscillator . Detects bullish sentiment using patterns like Marubozu, Hammer, Bullish Engulfing, and Three White Soldiers. Highlights periods of strong buying interest.
These oscillators are averaged into the Candle Emotion Index (CEI):
CEI = (Indecision + Fear + Greed) / 3
This single value quantifies overall market sentiment and drives the strategy’s trading decisions.
Key Features
Sentiment-Based Trading Signals . Long Entry: Triggered when the CEI crosses above a lower threshold (e.g., 0.1), indicating increasing bullish sentiment. Short Entry: Triggered when the CEI crosses above a higher threshold (e.g., 0.2), signaling rising bearish sentiment.
Volume Confirmation . Trades are validated only if volume exceeds a user-defined multiplier of the average volume over the lookback period. This ensures entries are backed by significant market activity.
Break-Even Recovery Mechanism . If a trade moves into a loss, the strategy attempts to recover to break-even instead of immediately exiting at a loss. This feature provides flexibility, allowing the market to recover while maintaining disciplined risk management.
Dynamic Risk Management . Maximum Holding Period: Trades are closed after a user-defined number of candles to avoid overexposure to prolonged uncertainty. Profit-Taking Conditions: Positions are exited when favorable price moves are confirmed by increased volume, locking in gains. Loss Threshold: Trades are exited early if the price moves unfavorably beyond a set percentage of the entry price, limiting potential losses.
Cooldown Period . After a trade is closed, a cooldown period prevents immediate re-entry, reducing overtrading and improving signal quality.
Why Use This Strategy?
The CEI Strategy combines advanced sentiment analysis with robust trade management, making it a powerful tool for traders seeking to understand market psychology and identify high-probability setups. Its unique features, such as the break-even recovery mechanism and volume confirmation, add an extra layer of discipline and reliability to trading decisions.
Best Practices
Combine with Other Indicators . Use trend-following tools (e.g., moving averages, ADX) and momentum oscillators (e.g., RSI, MACD) to confirm signals.
Align with Key Levels . Incorporate support and resistance levels for refined entries and exits.
Multi-Market Compatibility . Apply this strategy to forex, crypto, stocks, or any asset class with strong volume and price action.
Last Candle Close Above/Below AlertHow it works:
The script calculates whether the close of each candle is above or below the close of the previous candle, same as the initial code.
isLastBar is checked and the last candle to be created is the only one that will receive the condition from this variable.
If a highlight is needed it will use this criteria and apply the correct color for the last candle only, and any other candle will not be colored.
If alerts are enabled they will only work for the last bar too.
How to Use:
Add this script to your TradingView chart.
Use the inputs to set the desired timeframe to analyze, whether you want an alert for candles closing above or closing below and the background colors.
The last candle will highlight yellow when the close is higher or lower than the previous candle.
Alerts will be triggered on the last candle if you enable the alert conditions.
Key Features:
Timeframe Selection: You can choose a different timeframe in the settings.
Candle Highlight: Candles that close above or below the previous candle are highlighted in yellow.
Alerts: Alerts are configurable to trigger for "Close Above" or "Close Below" conditions, based on your selection in the settings.
Candle Emotion Index (CEI)The Candle Emotion Index (CEI) is a comprehensive sentiment analysis indicator that combines three sub-oscillators—Indecision Oscillator, Fear Oscillator, and Greed Oscillator—to provide a single, unified measure of market sentiment. By analyzing bullish, bearish, and indecisive candlestick patterns, the CEI delivers a holistic view of market emotions and helps traders identify key turning points.
How It Works
Indecision Oscillator: Measures market uncertainty using Doji and Spinning Top candlestick patterns. Scores their presence and normalizes the results over a user-defined lookback period.
Fear Oscillator: Measures bearish sentiment using Shooting Star, Hanging Man, and Bearish Engulfing candlestick patterns. Scores their presence and normalizes the results over a user-defined lookback period.
Greed Oscillator: Measures bullish sentiment using Marubozu, Bullish Engulfing, Hammer, and Three White Soldiers candlestick patterns. Scores their presence and normalizes the results over a user-defined lookback period.
Candle Emotion Index Calculation: The CEI is calculated as the average of the Indecision, Fear, and Greed Oscillators: CEI = (Indecision Oscillator + Fear Oscillator + Greed Oscillator) / 3
Plotting: The CEI is plotted as a single line on the chart, representing overall market sentiment.
Reference lines are added to indicate Low Emotion, Neutral, and High Emotion levels.
The Candle Emotion Index provides a unified perspective on market sentiment by blending indecision, fear, and greed into one easy-to-interpret metric. It serves as a powerful tool for traders seeking to gauge market psychology and identify high-probability trading opportunities. For best results, use the CEI in conjunction with other technical indicators to confirm signals.
CANDLE RANGE THEORY (H1 Only)Hello traders.
This indicator identifies CRT candles
-Each candle is a range.
-Each candle has its own po3.
-Focus on specific times of the day. By recognizing the importance of time and price, we can capture high-quality trades. Together with HTF PD array, Look for 4-hour candles forming at specific times of the day. (1am - 5am - 9am EST)
-After the 1st candle, wait for the 2nd candle to clear the high/low of the 1st candle and then close inside the 1st candle range at a specific time (1-5-9) and look for entries in the LTF
Why choose 1 5 9 hours EST?
### **1. 1:00 AM (EST)**
- **Trading Session:** This is the time between the Tokyo (Asian) session and the Sydney (Australian) session. The Asian market is very active.
- **Characteristics:**
- Liquidity: Moderate, as only the Asian market is active.
- Volatility: Pairs involving JPY (Japanese Yen), AUD (Australian Dollar), and NZD (New Zealand Dollar) tend to have higher volatility.
- Trading Opportunities: Suitable for traders who like to trade trends or news in the Asian region.
- **Note:** Volatility may be lower than the London or New York session.
### **2. 5:00 AM (EST)**
- **Trading Session:** This is the time near the end of the Tokyo session and the London (European) session is about to open.
- **Characteristics:**
- Liquidity: Starts to increase due to the preparation of the European market.
- Volatility: This is the time between two trading sessions, there can be strong fluctuations, especially in major currency pairs such as EUR/USD, GBP/USD.
- Trading opportunities: Suitable for breakout trading strategies when liquidity increases.
- **Note:** The overlap between Tokyo and London can cause sudden fluctuations.
### **3. 9:00 AM (EST)**
- **Trading sessions:** This time is within the London session and near the beginning of the New York session.
- **Characteristics:**
- Liquidity: Very high, as this is the period between the two largest sessions – London and New York.
- Volatility: Extremely strong, especially for major currency pairs such as EUR/USD, GBP/USD, USD/JPY.
- Trading opportunities: Suitable for both news trading and trend trading, as this is the time when a lot of economic data is released (usually from the US or the European region).
- **Note:** High volatility can bring big profits, but also comes with high risks.
### **Summary of effects:**
- **1 AM (EST):** Moderate volatility, focusing on Asian currency pairs.
- **5 AM (EST):** Increased liquidity and volatility, suitable for breakout trading.
- **9 AM (EST):** High volatility and high liquidity, the best time for Forex trading.
==> How to trade, when the high/low of CRT is swept, move to LTF to wait for confirmation to enter the order
Only sell at high level and buy at discount price.
Find CE at specific important time. Trading CRT with HTF direction has better win rate.
The more inside bars, the higher the probability.
Place a partial and Move breakeven at 50% range.
Do a backtest and post your chart.
HTF CandlesHTF Candles, Plot of a Higher/Lower Timeframe Candles on any chart.
This HTF / LTF candle plot displays the previous 3 daily candles with the current update of the price with reference to a lower time frame.
Candles includes 3 Candles of HTF
last HTF candle includes 4 previous candles from LTF
Candle High Low Open Close are plotted.
these OHLC values act as Support and Resistance With reference to current Price.
very useful in making HTF and LTF analysis with reference to current timeframe.
Candle % Close with Bullish/Bearish EvaluationI created the indicator to more quickly define the polarity of candles. For a large number of candles, it is straightforward to determine whether a candle is bullish or bearish. However, candles with long wicks often appear, making it uncertain whether the candle is bullish or bearish from a price action perspective. It is not a rule that a red candle is bearish and a green candle is bullish.
From a more advanced price action standpoint, how these candles close is important. Therefore, I created the 'Percent range' input. By default, it is set to 50% (high-low)/2. This way, the indicator precisely determines 50% of the candle's entire range. This allows us to determine whether a bearish candle truly closed below 50% of its range. If not, such a candle is considered bullish, even if it is a negative candle. The same applies to bullish candles, but conversely. If a positive candle closes below 50% of its range, from a price action perspective, it is considered a bearish candle.
Since in price action it is common for the price to return to 50% of the previous candle and, after filling, to continue in the established trend, I added the line extension option. Whatever high value you enter, the line extension follows the current candle. This option works only when the stop line checkbox is enabled. This way, you can plot 50% of the candle's range that the market has historically not returned to due to a strong trend. Often, this line is plotted on a candle where there is also an FVG, which can help you more easily find a point of interest.
Stop line extension : Ensures the interruption of line plotting when the candle is touched by the body or wick.
