Varip

real_time_candles Introduction 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

Library

by The_Peaceful_Lizard

RSI/Stochastic With Real Time Candle Overlay This indicator provides an alternative way to visualize either RSI or Stochastic values by representing them as candle bars in real time, allowing a more detailed view of momentum shifts within each bar. By default, it displays the standard historical plot of the chosen oscillator in the background, but once you are receiving real-time data (or if you keep your chart open through the close), it begins overlaying candles that track the oscillator’s intrabar movements. These candles only exist for as long as the chart remains open; if you refresh or load the chart anew, there is no stored candle history, although the standard RSI or Stochastic line is still fully retained. These candles offer insight into short-term fluctuations that are otherwise hidden when viewing a single line for RSI or Stochastic. In the settings, there is an option to switch between standard candlesticks and Heiken Ashi. When Heiken Ashi is selected, the indicator uses the Heiken Ashi close once it updates in real time, producing a smoothed view of intrabar price movement for the oscillator. This can help identify trends in RSI or Stochastic by making it easier to spot subtle changes in direction, though some may prefer the unmodified values that come from using regular candles. The combination of these candle styles with an oscillator’s output offers flexibility for different analytical preferences. Traders who use RSI or Stochastic often focus on entry and exit signals derived from crossing certain thresholds, but they are usually limited to a single reading per bar. With this tool, it becomes possible to watch how the oscillator’s value evolves within the bar itself, which can be especially useful for shorter timeframes or for those who prefer a more granular look at momentum shifts. The visual separation between bullish and bearish candle bodies within the indicator can highlight sudden reversals or confirm ongoing trends in the oscillator, aiding in more precise decision-making. Because the candle overlay is cleared as soon as the bar closes, the chart remains uncluttered when scrolling through historical data, ensuring that only the necessary real-time candle information is displayed. Overall, this indicator is intended for users who wish to track intrabar changes in RSI or Stochastic, with the added choice of standard or Heiken Ashi candle representation. The real-time candle overlay clarifies short-lived fluctuations, while the standard line plots maintain the usual clarity of past data. This approach can be beneficial for those who want deeper insights into how oscillator values develop in real time, without permanently altering the simplicity of the chart’s historical view.

Indicator

by The_Peaceful_Lizard

Custom Time Frame (CTF)This indicator allows users to create their own arbitrary time frames for chart analysis. It features a moving average, providing an additional layer of analysis, and offers flexibility through various open settings. In terms of user settings and usage, the indicator provides several options. Users can choose their interval style, opting for either tick-based or time-based intervals. This flexibility allows for a more granular approach to data analysis, catering to different trading strategies and preferences. The number of ticks or the amount of time for each candle can be adjusted, enabling traders to set the granularity of the data to their liking. Color settings are also customizable, with options for setting colors for bullish and bearish indicators, adding a visual dimension to the analysis. The average line parameters are an important aspect of this indicator. Users can adjust the length, ripple, type, color, and line width of the average line. The ripple setting, in particular, impacts the smoothness of the filter. With type II setting, the smoothing is increased, making it suitable for traders who prefer a more smoothed out moving average. Conversely, the type I setting decreases the smoothing, which might be preferred by those who want a more responsive indicator. The use of the Chebyshev filter is a significant feature of this indicator. This filter is chosen for its high-performance smoothing capabilities with minimal data requirements. This ensures that the moving average appears quickly and accurately, which is crucial in real-time chart analysis. An important point to note is that when the moving average is enabled, it decreases the maximum number of candles that can be displayed on the chart. However, this is offset by the enhanced analytical precision provided by the moving average. In summary, this indicator is especially beneficial for traders without access to premium accounts. It offers the capability to create low or custom time frame charts. The flexibility in settings, coupled with the inclusion of a Chebyshev filter for the moving average, makes it a versatile and valuable tool for detailed market analysis. It caters to a wide range of trading styles and strategies, making it a useful addition to any trader's toolkit.

Indicator

by The_Peaceful_Lizard

OHLC 📕 LIBRARY OHLC 🔷 Introduction This library is a custom library designed to work with real-time bars. It allows to easily calculate OHLC values for any source. Personally, I use this library to accurately display the highest and lowest values on visual indicators such as my progress bars. 🔷 How to Use ◼ 1. Import the OHLC library into your PulseWire script: import cryptolinx/OHLC/1 - or - Instead of the library namespace, you can define a custom namespace as alias. import cryptolinx/OHLC/1 as src ◼ 2. Create a new OHLC source using the `new()` function. varip mySrc = OHLC.new() // It is required to use the `varip` keyword to init your `` - or - If you has set up an alias before. varip mySrc = src.new() === In that case, your `` needs to be `na`, define your object like that varip mySrc = na ◼ 3. Call the `hydrateOHLC()` method on your OHLC source to update its values: Basic float rsi = ta.rsi(close, 14) mySrc.hydrateOHLC(rsi) - or - Inline rsi = ta.rsi(close, 14).hydrateOHLC(mySrc) ◼ 4. The data is accessible under their corresponding names. mySrc.open mySrc.high mySrc.low mySrc.close 🔷 Note: This library only works with real-time bars and will not work with historical bars.

Library

Motion ▮ FEATURES Now as library version :) String-based transition-effects Performance optimization. Reduced memory consumption up to >90% by kicking the output to the "stdout". Use marquee- or loader-effect on any possible string location. Example: UI Price-Ticker ---------------------------------------------------------------------------- Library "Motion" _getStringMono(_len, _str, _sep) Parameters: _len _str _sep marquee(this, _extern, _ws, _subLen, _subStart) Parameters: this _extern _ws _subLen _subStart transition(this, _subLen, _subStart) Parameters: this _subLen _subStart hold(this) Parameters: this keyframe keyframe A keyframe object. Fields: seq intv step length update_no frame_no ltr hold

Library

Education: INDEX This is an INDEX page where educational links/scripts are sorted in the script itself (see below) For example: - where is the link of the 'var' article/idea? -> search in the script comments below for Keywords -> var -> look for the date -> now you will find the link at the date of update

Indicator

Intrabar Price/Volume Change (experimental)This experimental script shows the intrabar progression of price/volume It can only be used with live data, when you switch timeframe or ticker, it will start over again. When you let the script run, you'll get insight of what is going on during the bar progression. On each tick, when the price goes up, a green line will be drawn, if it goes down, a red line is drawn. The higher the difference with previous price, the wider the line. The same with volume (lighter, broader lines), only it will always be drawn in the same direction as price goes. You can set the max width of the lines, when a spike is larger then previous lines, the rest will be adjusted, so the ratio stays the same The center line (position can be changed) has 2 colors (only on second and minute timeframes) -> this makes it easy to see the bar progression, each change in color represents a new bar Lines can be drawn on 2 sides, or at 1 side, also they can be reversed Many thanks to @LonesomeTheBlue and @LucF for their inspiration, help and guidance! Cheers!

Indicator

Bar Percent Complete This is an example script for checking how far the current bar has progressed towards it's completed state. This works for any time frame, eliminating extra logic calls and conversions for each timeframe.period. It is not intended to be a standalone indicator, but rather as a resource for additional logic triggers on the real time bar of a pine script. The main caveat is that pine script calculations occur on a per-tick basis. This means that the completion percentage can exceed the percentage threshold before any logic is executed. This happens when the next tick occurs after the threshold. The relevance then will depend on the activity of the underlying asset. Longer time frames on low activity assets will likely be more relevant than their shorter time frame counterparts.

Indicator

Time and Sales This scrip mimics time and sales window displaying tick by tick data coming from the exchange. It only works when the market is open. And it does not store historical data. Red color when the last price was higher than the new price. Gray when both were same. Green when new price is higher than last price. Please note that I have tested this in India NSE Market Only. If you find anything buggy let me know in the comments, I will try to update it.

Indicator

[CLX][#01] Animation - Price Ticker (Marquee)This indicator displays a classic animated price ticker overlaid on the user’s current chart. It is possible to fully customize it or to select one of the predefined styles. A detailed description will follow in the next few days. Used Pinescript technics: - varip (view/animation) - tulip instance (config/codestructur) - table (view/position) By the way, for me, one of the coolest animated effects is by Duyck We hope you enjoy it! 🎉 CRYPTOLINX - jango_blockchained 😊👍 Disclaimer: Trading success is all about following your trading strategy and the indicators should fit within your trading strategy, and not to be traded upon solely. The script is for informational and educational purposes only. Use of the script does not constitute professional and/or financial advice. You alone have the sole responsibility of evaluating the script output and risks associated with the use of the script. In exchange for using the script, you agree not to hold dgtrd PulseWire user liable for any possible claim for damages arising from any decision you make based on use of the script.

Indicator

Tick Data Detailed Hello All, After Tick Chart and Tick Chart RSI scripts, this is Tick Data Detailed script. Like other tick scrips this one only works on real-time bars too. it creates two tables: the table at the right shows the detailed data for Current Bar and the table at the left shows the detailed data for all calculated bars (cumulative). the script checks the volume on each tick and add the tick and volume to the specified level (you can set/change levels) The volume is multiplied by close price to calculate real volume .There are 7 levels/zones and the default levels are: 0 - 10.000 10.000 - 20.000 20.000 - 50.000 50.000 - 100.000 100.000 - 200.000 200.000 - 400.000 > 400.000 With this info, you will get number of ticks and total volumes on each levels. The idea to separate this levels is in order to know which type of traders trade at that moment. for example volume of whale moves are probably greater than 400.000 or at least 100.000. Or volume of small traders is less than 10.000 or between 20.000-50.000. You will get info if there is anomaly on each candle as well. what is anomaly definition? Current candle is green but Sell volume is greater than Buy volume or current candle is red but Buy volume is greater than Sell volume . it is shown as (!). you should think/search why/how this anomaly occurs. You can see screenshot about it below. also "TOTAL" text color changes automatically. if Buy volume is greater than Sell volume then its color becomes Green, if Sell volume is greater than Buy volume then its color becomes Red (or any color you set) Optionally you can change background and text colors as shown in the example below. Explanation: How anomaly is shown: You can enable coloring background and set the colors as you wish: And Thanks to @Duyck for letting me use the special characters from his great script. Enjoy!

Indicator

by LonesomeTheBlue

Using `varip` variables [PineCoders]█ OVERVIEW The new varip keyword in Pine can be used to declare variables that escape the rollback process, which is explained in the Pine User Manual's page on the execution model . This publication explains how Pine coders can use variables declared with varip to implement logic that was impossible to code in Pine before, such as timing events during the realtime bar, or keeping track of sequences of events that occur during successive realtime updates. We present code that allows you to calculate for how much time a given condition is true during a realtime bar, and show how this can be used to generate alerts. █ WARNINGS 1. varip is an advanced feature which should only be used by coders already familiar with Pine's execution model and bar states . 2. Because varip only affects the behavior of your code in the realtime bar, it follows that backtest results on strategies built using logic based on varip will be meaningless, as varip behavior cannot be simulated on historical bars. This also entails that plots on historical bars will not be able to reproduce the script's behavior in realtime. 3. Authors publishing scripts that behave differently in realtime and on historical bars should imperatively explain this to traders. █ CONCEPTS Escaping the rollback process Whereas scripts only execute once at the close of historical bars, when a script is running in realtime, it executes every time the chart's feed detects a price or volume update. At every realtime update, Pine's runtime normally resets the values of a script's variables to their last committed value, i.e., the value they held when the previous bar closed. This is generally handy, as each realtime script execution starts from a known state, which simplifies script logic. Sometimes, however, script logic requires code to be able to save states between different executions in the realtime bar. Declaring variables with varip now makes that possible. The "ip" in varip stands for "intrabar persist". Let's look at the following code, which does not use varip : //@version=4 study("") int updateNo = na if barstate.isnew updateNo := 1 else updateNo := updateNo + 1 plot(updateNo, style = plot.style_circles) On historical bars, barstate.isnew is always true, so the plot shows a value of "1". On realtime bars, barstate.isnew is only true when the script first executes on the bar's opening. The plot will then briefly display "1" until subsequent executions occur. On the next executions during the realtime bar, the second branch of the if statement is executed because barstate.isnew is no longer true. Since `updateNo` is initialized to `na` at each execution, the `updateNo + 1` expression yields `na`, so nothing is plotted on further realtime executions of the script. If we now use varip to declare the `updateNo` variable, the script behaves very differently: //@version=4 study("") varip int updateNo = na if barstate.isnew updateNo := 1 else updateNo := updateNo + 1 plot(updateNo, style = plot.style_circles) The difference now is that `updateNo` tracks the number of realtime updates that occur on each realtime bar. This can happen because the varip declaration allows the value of `updateNo` to be preserved between realtime updates; it is no longer rolled back at each realtime execution of the script. The test on barstate.isnew allows us to reset the update count when a new realtime bar comes in. █ OUR SCRIPT Let's move on to our script. It has three parts: — Part 1 demonstrates how to generate alerts on timed conditions. — Part 2 calculates the average of realtime update prices using a varip array. — Part 3 presents a function to calculate the up/down/neutral volume by looking at price and volume variations between realtime bar updates. Something we could not do in Pine before varip was to time the duration for which a condition is continuously true in the realtime bar. This was not possible because we could not save the beginning time of the first occurrence of the true condition. One use case for this is a strategy where the system modeler wants to exit before the end of the realtime bar, but only if the exit condition occurs for a specific amount of time. One can thus design a strategy running on a 1H timeframe but able to exit if the exit condition persists for 15 minutes, for example. REMINDER: Using such logic in strategies will make backtesting their complete logic impossible, and backtest results useless, as historical behavior will not match the strategy's behavior in realtime, just as using `calc_on_every_tick = true` will do. Using `calc_on_every_tick = true` is necessary, by the way, when using varip in a strategy, as you want the strategy to run like a study in realtime, i.e., executing on each price or volume update. Our script presents an `f_secondsSince(_cond, _resetCond)` function to calculate the time for which a condition is continuously true during, or even across multiple realtime bars. It only works in realtime. The abundant comments in the script hopefully provide enough information to understand the details of what it's doing. If you have questions, feel free to ask in the Comments section. Features The script's inputs allow you to: • Specify the number of seconds the tested conditions must last before an alert is triggered (the default is 20 seconds). • Determine if you want the duration to reset on new realtime bars. • Require the direction of alerts (up or down) to alternate, which minimizes the number of alerts the script generates. The inputs showcase the new `tooltip` parameter, which allows additional information to be displayed for each input by hovering over the "i" icon next to it. The script only displays useful information on realtime bars. This information includes: • The MA against which the current price is compared to determine the bull or bear conditions. • A dash which prints on the chart when the bull or bear condition is true. • An up or down triangle that prints when an alert is generated. The triangle will only appear on the update where the alert is triggered, and unless that happens to be on the last execution of the realtime bar, it will not persist on the chart. • The log of all triggered alerts to the right of the realtime bar. • A gray square on top of the elapsed realtime bars where one or more alerts were generated. The square's tooltip displays the alert log for that bar. • A yellow dot corresponding to the average price of all realtime bar updates, which is calculated using a varip array in "Part 2" of the script. • Various key values in the Data Window for each parts of the script. Note that the directional volume information calculated in Part 3 of the script is not plotted on the chart—only in the Data Window. Using the script You can try running the script on an open market with a 30sec timeframe. Because the default settings reset the duration on new realtime bars and require a 20 second delay, a reasonable amount of alerts will trigger. Creating an alert on the script You can create a script alert on the script. Keep in mind that when you create an alert from this script, the duration calculated by the instance of the script running the alert will not necessarily match that of the instance running on your chart, as both started their calculations at different times. Note that we use alert.freq_all in our alert() calls, so that alerts will trigger on all instances where the associated condition is met. If your alert is being paused because it reaches the maximum of 15 triggers in 3 minutes, you can configure the script's inputs so that up/down alerts must alternate. Also keep in mind that alerts run a distinct instance of your script on different servers, so discrepancies between the behavior of scripts running on charts and alerts can occur, especially if they trigger very often. Challenges Events detected in realtime using variables declared with varip can be transient and not leave visible traces at the close of the realtime bar, as is the case with our script, which can trigger multiple alerts during the same realtime bar, when the script's inputs allow for this. In such cases, elapsed realtime bars will be of no use in detecting past realtime bar events unless dedicated code is used to save traces of events, as we do with our alert log in this script, which we display as a tooltip on elapsed realtime bars. █ NOTES Realtime updates We have no control over when realtime updates occur. A realtime bar can open, and then no realtime updates can occur until the open of the next realtime bar. The time between updates can vary considerably. Past values There is no mechanism to refer to past values of a varip variable across realtime executions in the same bar. Using the history-referencing operator will, as usual, return the variable's committed value on previous bars. If you want to preserve past values of a varip variable, they must be saved in other variables or in an array . Resetting variables Because varip variables not only preserve their values across realtime updates, but also across bars, you will typically need to plan conditions that will at some point reset their values to a known state. Testing on barstate.isnew , as we do, is a good way to achieve that. Repainting The fact that a script uses varip does not make it necessarily repainting. A script could conceivably use varip to calculate values saved when the realtime bar closes, and then use confirmed values of those calculations from the previous bar to trigger alerts or display plots, avoiding repaint. timenow resolution Although the variable is expressed in milliseconds it has an actual resolution of seconds, so it only increments in multiples of 1000 milliseconds. Warn script users When using varip to implement logic that cannot be replicated on historical bars, it's really important to explain this to traders in published script descriptions, even if you publish open-source. Remember that most PulseWireers do not know Pine. New Pine features used in this script This script uses three new Pine features: • varip • The `tooltip` parameter in input() . • The new += assignment operator. See these also: -= , *= , /= and %= . Example scripts These are other scripts by PineCoders that use varip : • Tick Delta Volume , by RicadoSantos . • Tick Chart and Volume Info from Lower Time Frames by LonesomeTheBlue . Thanks Thanks to the PineCoders who helped improve this publication—especially to bmistiaen . Look first. Then leap.

Indicator

Volume Info from Lower Time Frames Hello Traders, We are now able to get info from lower time frames, Many Thanks to Pine Team .This script gets volume info from lower time frames and give alert if there is extreme volumes on last X lower time frame candles (if last X volumes are higher than volume moving average). so that if you set alerts on different securities then you will be able get alert if there is extreme volume moves and you can check the chart immediately. The options: Timeframe in Seconds : you can set lower time frames in seconds. by default it's 5 seconds. if you set it 60 then it will show 1min volumes, if you set it 1 then it will show 1 seconds volumes MA Length : The script draws simple moving average using this length info. by default it's 20. Number of Bars to Check for Alert : by default it's 5. meaning that if last 5 candles is greater than moving average and if you set alert then you get the alert "Extreme Volume" Other options are for colors and line width. As you can see in following example, chart time frame is 1 hour and the script shows volume info of 5 seconds candles: Enjoy!

Indicator

by LonesomeTheBlue

In-depth global business and economic analysis Comprehensive trading education and market insights