Wyckoff Smart Signals (Long + Short)- Wycoff Smart signals made by Melik
Using Wycoff fundamentals and volume confirmation to form a bias
Penunjuk dan strategi
Volatility Flow X – MACD + Ichimoku Hybrid Trail🌥️ Volatility Flow X – Hybrid Ichimoku Cloud Explained
This strategy combines Ichimoku’s cloud structure with real-time price position.
Unlike standard Ichimoku coloring, the cloud here reflects both trend direction and price behavior.
🔍 What the Cloud Colors Mean
🟢 Green Cloud
Senkou A > Senkou B
Price is above the cloud
→ Indicates strong uptrend; suitable for long entries
🔴 Red Cloud
Senkou A < Senkou B
Price is below the cloud
→ Indicates strong downtrend; suitable for short entries
⚪ Gray Cloud
Price contradicts trend, or price is inside the cloud
→ Represents indecision, low momentum; best to avoid entries
⚙️ Technical Features
Ichimoku Components: Tenkan-sen, Kijun-sen, Senkou Span A & B, Chikou Span
Cloud Transparency: 30%
MACD Filter: Optional momentum confirmation (customizable)
Trailing Stop: Optional dynamic trailing stop after trigger level
Directional Control: Long and short trailing rules can be set independently
📚 References
Ichimoku Charts – Nicole Elliott
Algorithmic Trading – Ernie Chan
TradingView Pine Script and hybrid trend models
⚠️ Disclaimer
This strategy is for educational and backtesting purposes only.
It is not financial advice. Always test thoroughly before applying to real trades.
Position Size CalculatorIt calculates the risk per trade using two methods: Margin-Based (percentage of total Account Balance) or Equity-Based (percentage of Total Balance minus minimum balance). Displayed as a compact, customizable label on the main chart, it’s perfect for traders seeking quick, precise risk calculations.
Key Features
Two Calculation Options:
Margin-Based: Risk as a percentage (0-5%) of your total account balance.
Equity-Based: Risk as a percentage (0-50%) of (Total balance - Minimum balance).
Flexible Risk Input: Manually enter any risk percentage with 0.01% precision (e.g., 1.75%).
Customizable Display:
Repositionable table (9 positions, e.g., top-right, middle-center).
Four table sizes (XL, L, M, S) with text scaling (large, normal, small, tiny).
Adjustable cell color, text color, and transparency
Margin-Based Risk Calculation:
Set “Total Margin” (e.g., $10,000).
Enter “Risk Percentage (%)” (0 to 5%, e.g., 1.75%).
Equity-Based Risk Calculation:
Set “Total Equity” (e.g., $15,000).
Set “Minimum Balance” (e.g., $5,000).
Enter “Equity Risk Percentage (%)” (0 to 50%, e.g., 1.75%).
Display Settings:
Choose “Calculation Method” (Margin-Based or Equity-Based).
Select “Table Position” (e.g., top_right).
Select “Table Size” (XL, L, M, S; default M).
Customize “Table Cell Color”, “Table Text Color”, and “Table Cell Transparency”.
MVWAP 5/21/50 + LWMA 400Moving vwap de 5,21,50 y media movil ponderada de 400
se puede utilizar con cruces
Gattsreal EMASummary
The Gattsreal EMA indicator is a complete technical analysis tool designed to provide a clear and immediate view of the market trend and momentum across multiple timeframes. It combines long-term Exponential Moving Averages (EMAs) with a short-term EMA "ribbon," allowing traders to quickly identify the direction of the main trend and the strength of short-term movements.
Indicator Components
The Gattsreal EMA is composed of two main elements, both fully customizable:
Long-Term EMAs (Thick Lines):
EMA 200 (White): Considered the definitive line between a bull market and a bear market. Prices above the 200 EMA are generally considered to be in a long-term uptrend.
EMA 50 (Blue): An important medium-term trend line, often used as a dynamic level of support or resistance.
Short-Term EMA Ribbon:
Consists of a set of 9 EMAs (periods 9, 10, 15, 20, 25, 30, 35, 40, and 45).
The "ribbon" expands when volatility increases and contracts when volatility decreases.
The color of the ribbon's fill changes to indicate short-term momentum:
Green: The ribbon is in an uptrend (fastest EMA above the slowest), suggesting buying pressure.
Red: The ribbon is in a downtrend (fastest EMA below the slowest), suggesting selling pressure.
How to Use the Indicator
The Gattsreal EMA can be used in various ways to enhance your analysis and decision-making:
Main Trend Identification: The price's position relative to the 200 and 50 EMAs helps define your operational bias. It is preferable to trade in the direction of the main trend.
Entry and Exit Signals: The crossing of the price through the EMA ribbon can be used as a signal. For example, when the price crosses and closes above the entire ribbon and it turns green, it can be a buy signal.
Momentum Confirmation: The color and expansion of the ribbon serve as excellent confirmation of the strength of a move. A green and expanding ribbon confirms strong bullish momentum.
Dynamic Support and Resistance: All 11 EMAs can act as dynamic levels of support (in an uptrend) or resistance (in a downtrend).
This indicator is a powerful tool for traders of all levels looking for a visual and effective way to analyze market trends.
Alım Algoritması (EMA + RSI + MACD + ATR + Pozisyon Takibi)//@version=5
indicator("Alım Algoritması (EMA + RSI + MACD + ATR + Pozisyon Takibi)", overlay=true)
// === INPUTS ===
ema1_len = input.int(21, title="EMA 1")
ema2_len = input.int(50, title="EMA 2")
ema3_len = input.int(100, title="EMA 3")
rsi_len = input.int(14, title="RSI Length")
atr_len = input.int(14, title="ATR Length")
macd_fast = input.int(12, title="MACD Fast")
macd_slow = input.int(26, title="MACD Slow")
macd_signal = input.int(9, title="MACD Signal")
max_distance_pct = input.float(5.0, title="Max EMA Distance %", step=0.1)
// === CALCULATIONS ===
ema1 = ta.ema(close, ema1_len)
ema2 = ta.ema(close, ema2_len)
ema3 = ta.ema(close, ema3_len)
avg_ema = (ema1 + ema2 + ema3) / 3
distance_pct = math.abs(close - avg_ema) / avg_ema * 100
ema_near = distance_pct <= max_distance_pct
basis = ta.sma(close, 20)
dev = ta.stdev(close, 20)
upper = basis + 2 * dev
lower = basis - 2 * dev
width = (upper - lower) / basis
is_range = width < 0.12 // %5'ten dar bant
rsi = ta.rsi(close, rsi_len)
rsi_trend = ta.sma(rsi, 5)
rsi_up = rsi > rsi_trend
= ta.macd(close, macd_fast, macd_slow, macd_signal)
ema1_cross = ta.crossover(close, ema1) or ta.crossover(close, ema2) or ta.crossover(close, ema3)
ema_recent_cross = ta.barssince(ema1_cross) < 5
// === BUY SIGNAL ===
//buy_signal = ema_near and ema_recent_cross and
// macdLine > signalLine and hist > 0 and
// rsi > 45 and rsi < 65 and rsi_up
buy_signal = not is_range and ema_near and ema_recent_cross and
macdLine > signalLine and hist > 0 and
rsi > 45 and rsi < 65 and rsi_up
//buy_signal = not is_range and ema_near and ema_recent_cross and
// macdLine > signalLine and hist > 0 and
// rsi > 45 and rsi < 65 and rsi_up
// === POSITION LOGIC ===
var bool in_position = false
var float entry_price = na
var float stop_loss = na
var float take_profit_1 = na
var float take_profit_2 = na
atr = ta.atr(atr_len)
// Koşullar
new_buy = buy_signal and not in_position
// SL ve TP seviyeleri hesaplama
new_sl = close - 1.5 * atr
new_tp1 = close + 2.0 * atr
new_tp2 = close + 3.5 * atr
// Pozisyon açma
if new_buy
in_position := true
entry_price := close
stop_loss := new_sl
take_profit_1 := new_tp1
take_profit_2 := new_tp2
label.new(bar_index, low, "BUY", style=label.style_label_up, color=color.green, textcolor=color.white)
sl_hit = in_position and low <= stop_loss
tp1_hit = in_position and high >= take_profit_1
tp2_hit = in_position and high >= take_profit_2
// Pozisyon kapama sinyali
if sl_hit
in_position := false
//label.new(bar_index, low, "SL", style=label.style_label_down, color=color.red, textcolor=color.white)
if tp2_hit
in_position := false
//label.new(bar_index, high, "TP2", style=label.style_label_down, color=color.rgb(209, 34, 222), textcolor=color.white)
else if tp1_hit
in_position := false
//label.new(bar_index, high, "TP1", style=label.style_label_down, color=color.rgb(209, 34, 222), textcolor=color.white)
// === PLOT ===
// Sadece BUY, SL ve TP seviyeleri çizilir
plot(in_position ? stop_loss : na, title="Stop Loss", color=color.red, style=plot.style_linebr)
//plot(in_position ? take_profit_1 : na, title="TP1", color=color.rgb(209, 34, 222), style=plot.style_linebr)
//plot(in_position ? take_profit_2 : na, title="TP2", color=color.rgb(209, 34, 222), style=plot.style_linebr)
Volatility Flow X | Dual Trend Strategy [VWMA+SMA+ADX]📌 Strategy Title
Volatility Flow X | Dual Trend Strategy
🧾 Description
🚀 Strategy Overview
Volatility Flow X is a dual-directional trading strategy that combines Volume-Weighted MA (VWMA) for momentum, Simple MA (SMA) for trend direction, ADX for trend strength filtering, and ATR-based volatility cloud for dynamic support/resistance zones.
It is designed specifically for high-volatility assets like BTC/USD on intraday timeframes such as 15 min, 30 min, and 1 hour — offering both breakout and trend-following opportunities.
🔬 Technical Components and Sources
1. VWMA (Volume-Weighted Moving Average)
Captures volume-weighted momentum shifts.
📚 Kirkpatrick & Dahlquist (2010) — “Technical Analysis”
2. SMA (Simple Moving Average)
Used as a baseline trend direction validator.
📚 Ernie Chan — “Algorithmic Trading” (2013)
3. ADX (Average Directional Index)
Filters out low-conviction signals based on trend strength.
📚 J. Welles Wilder (1978) — ADX in directional movement systems
4. ATR Cloud (Volatility Envelope)
Creates upper and lower dynamic bands using ATR to visualize trend pressure.
📚 Zunino et al. (2017) — Fractal volatility behavior in Bitcoin markets
🧠 Key Features
✅ 3 configurable Long signal modes
✅ 3 configurable Short signal modes
✅ Manually switchable signals for flexibility
✅ Auto-calculated TP/SL using ATR and risk/reward ratio
✅ ADX filter to avoid choppy trends
✅ Visual cloud overlay for support/resistance
✅ Suitable for scalping and short-term swing trading
⚙️ Recommended Settings (for BTC/USDT – 30min)
VWMA Length = 18
SMA Length = 50
ATR Length = 14, Multiplier = 2.5
Risk-Reward Ratio = 1.5
ADX Length = 14, Threshold = 18, Lookback = 4
⚠️ Disclaimer
This strategy is not financial advice. Please backtest and understand the risks before using it in live markets.
LiliALHUNTERSystemLibrary "LiliALHUNTERSystem"
HUNTER System Library - Powerful target management for Pine Script
ema_calc(len, source)
Parameters:
len (simple int)
source (float)
rma_calc(len, source)
Parameters:
len (simple int)
source (float)
supertrend_calc(length, factor)
Parameters:
length (simple int)
factor (float)
createTargets(config, state, source1A, source1B, source2A, source2B)
Parameters:
config (TargetConfig)
state (TargetState)
source1A (float)
source1B (float)
source2A (float)
source2B (float)
showDashboard(state, dashLoc, textSize)
Parameters:
state (TargetState)
dashLoc (string)
textSize (string)
TargetConfig
Fields:
enableTarget1 (series bool)
enableTarget2 (series bool)
isLong1 (series bool)
isLong2 (series bool)
target1Condition (series string)
target2Condition (series string)
target1Color (series color)
target2Color (series color)
target1Style (series string)
target2Style (series string)
distTarget1 (series float)
distTarget2 (series float)
distOptions1 (series string)
distOptions2 (series string)
showLabels (series bool)
showDash (series bool)
TargetState
Fields:
target1LineV (series line)
target1LineH (series line)
target2LineV (series line)
target2LineH (series line)
target1Lbl (series label)
target2Lbl (series label)
target1Active (series bool)
target2Active (series bool)
target1Value (series float)
target2Value (series float)
countTargets1 (series int)
countTgReached1 (series int)
countTargets2 (series int)
countTgReached2 (series int)
BOS INDICATOR )This indicator is used to mark out breaks of structures to the upside and the downside. It's used to easily determine which direction the market is breaking structure towards.
Relative Volume Strategy📈 Relative Volume Strategy by GabrielAmadeusLau
This Pine Script strategy combines volume-based momentum analysis with price action filtering, breakout detection, and dynamic stop-loss/take-profit logic, allowing for highly adaptable long and short entries. It is particularly suited for traders looking to identify reversals or continuation setups based on relative volume spikes and candle behavior.
🧠 Core Concept
At its core, this strategy uses a Relative Volume %R oscillator, comparing the current volume to its historical range using a Williams %R-like calculation. The oscillator is paired with dual moving average filters (Fast & Slow) to identify when volume is expanding or contracting.
Entries are further refined using a configurable price action filter based on the structure of bullish or bearish candles:
Simple: Basic up/down bar
Filtered: Range-based strength confirmation
Aggressive: Momentum-based breakout
Inside: Reversal bar patterns
Combinations of the above can be toggled for both long and short entries.
⚙️ Configurable Features
Trade Direction Control: Choose between Long Only, Short Only, or Both.
Directional Bar Modes: Set different conditions for long and short bar types (Simple, Filtered, Aggressive, Inside).
Breakout Filter: Optional filter to exclude trades near 5-bar highs/lows to avoid poor R/R trades.
Stop Loss & Take Profit System:
ATR-based dynamic SL/TP.
Configurable multipliers for both SL and TP.
Timed Exit: Optional bar-based exit after a fixed number of candles.
Custom Volume MA Smoothing: Choose from various smoothing algorithms (SMA, EMA, JMA, T3, Super Smoother, etc.) for both fast and slow volume trends.
Relative Volume Threshold: Minimum %R level for trade filtering.
📊 Technical Indicators Used
Relative Volume %R: A modified version of Williams %R, calculated on volume.
Dual Volume MAs: Fast and Slow MAs for volume trends using user-selected smoothing.
ATR: Average True Range for dynamic SL/TP calculation.
Breakout High/Low: 5-bar breakout thresholds to avoid late entries.
🚀 Trade Logic
Long Entry:
Volume > Fast MA > Slow MA
Relative Volume %R > Threshold
Price passes long directional filter
Optional: below recent breakout high
Short Entry:
Volume < Fast MA < Slow MA
Relative Volume %R < 100 - Threshold
Price passes short directional filter
Optional: above recent breakout low
Exits:
After N bars (configurable)
ATR-based Stop Loss / Take Profit if enabled
📈 Visualization
Orange Columns: Relative Volume %R
Green Line: Fast Volume MA
Red Line: Slow Volume MA
💡 Use Case
Ideal for:
Reversal traders catching capitulation or accumulation spikes
Momentum traders looking for volume-confirmed trends
Quantitative strategy developers wanting modular MA and price action filter logic
Intraday scalpers or swing traders using relative volume dynamics
Created by: GabrielAmadeusLau
License: Mozilla Public License 2.0
🔗 mozilla.org
Holy GrailThis is a long-only educational strategy that simulates what happens if you keep adding to a position during pullbacks and only exit when the asset hits a new All-Time High (ATH). It is intended for learning purposes only — not for live trading.
🧠 How it works:
The strategy identifies pullbacks using a simple moving average (MA).
When price dips below the MA, it begins monitoring for the first green candle (close > open).
That green candle signals a potential bottom, so it adds to the position.
If price goes lower, it waits for the next green candle and adds again.
The exit happens after ATH — it sells on each red candle (close < open) once a new ATH is reached.
You can adjust:
MA length (defines what’s considered a pullback)
Initial buy % (how much to pre-fill before signals start)
Buy % per signal (after pullback green candle)
Exit % per red candle after ATH
📊 Intended assets & timeframes:
This strategy is designed for broad market indices and long-term appreciating assets, such as:
SPY, NASDAQ, DAX, FTSE
Use it only on 1D or higher timeframes — it’s not meant for scalping or short-term trading.
⚠️ Important Limitations:
Long-only: The script does not short. It assumes the asset will eventually recover to a new ATH.
Not for all assets: It won't work on assets that may never recover (e.g., single stocks or speculative tokens).
Slow capital deployment: Entries happen gradually and may take a long time to close.
Not optimized for returns: Buy & hold can outperform this strategy.
No slippage, fees, or funding costs included.
This is not a performance strategy. It’s a teaching tool to show that:
High win rate ≠ high profitability
Patience can be deceiving
Many signals = long capital lock-in
🎓 Why it exists:
The purpose of this strategy is to demonstrate market psychology and risk overconfidence. Traders often chase strategies with high win rates without considering holding time, drawdowns, or opportunity cost.
This script helps visualize that phenomenon.
SymFlex Band No1. - Momentum Weighted Volatility BandsSymFlex Band No1 – Momentum-Weighted Adaptive Volatility Band
Overview
The SymFlex Band No1 is a custom-built volatility band that fuses momentum and volatility into a flexible, asymmetric envelope.
It adapts dynamically to market conditions using RSI-based momentum weighting and a selection of smoothing algorithms, making it responsive to both trend shifts and volatility expansions.
Key Features
📊 Momentum-Weighted Width
The band expands or contracts based on RSI momentum. When the RSI is above 50, the upper band becomes more sensitive; when below 50, the lower band responds more dynamically.
🔁 Asymmetric Adaptation
Unlike traditional Bollinger Bands or Keltner Channels, the upper and lower bands of the SymFlex system are independently adjusted based on momentum conditions, creating a non-linear envelope structure.
⚙️ Selectable Smoothing Methods
You can choose among the following methods to control the volatility smoothing:
EMA (Exponential Moving Average)
TEMA (Triple Exponential Moving Average)
ZeroLag EMA v0 (double EMA difference method)
ZeroLag EMA v1 (lag-compensated input)
🛠 Fully Customizable Inputs
RSI Length
Band Multiplier
Band Length
Smoothing Type
How It Works
RSI is calculated over a defined length and normalized to a weight between -1 and +1.
Standard deviation (volatility) of the close price is computed and smoothed.
The band centerline is a Simple Moving Average (SMA).
The band boundaries are then:
Upper = Middle + (1 + momentum_weight) × multiplier × smoothed_volatility
Lower = Middle - (1 + momentum_weight) × multiplier × smoothed_volatility
Use Cases
Detect momentum-driven breakouts
Spot compressions before expansions
Adapt to volatile or trending markets more effectively than fixed bands
Disclaimer
This script is for educational and research purposes only. It is not financial advice. Use with discretion and always validate with additional signals and proper risk management.
Crypto Pulse Strategy ActiveCrypto Pulse Strategy Active
Short-term crypto strategy for 1h-4h charts. Uses RSI, Bollinger Bands, and VWAP to spot buy/sell signals. Buy above VWAP with low BB or RSI < 25; sell below VWAP with high BB or RSI > 75. Risks 1% per trade with 1.5% stop-loss and 1.5x profit. Test on BTC/ETH first!
Chaikin Money Flow (CMF) [ParadoxAlgo]OVERVIEW
This indicator implements the Chaikin Money Flow oscillator as an overlay on the price chart, designed to help traders identify institutional money flow patterns. The Chaikin Money Flow combines price and volume data to measure the flow of money into and out of a security, making it particularly useful for detecting accumulation and distribution phases.
WHAT IS CHAIKIN MONEY FLOW?
Chaikin Money Flow was developed by Marc Chaikin and measures the amount of Money Flow Volume over a specific period. The indicator oscillates between +1 and -1, where:
Positive values indicate money flowing into the security (accumulation)
Negative values indicate money flowing out of the security (distribution)
Values near zero suggest equilibrium between buying and selling pressure
CALCULATION METHOD
Money Flow Multiplier = ((Close - Low) - (High - Close)) / (High - Low)
Money Flow Volume = Money Flow Multiplier × Volume
CMF = Sum of Money Flow Volume over N periods / Sum of Volume over N periods
KEY FEATURES
Big Money Detection:
Identifies significant institutional activity when CMF exceeds user-defined thresholds
Requires volume confirmation (volume above average) to validate signals
Uses battery icon (🔋) for institutional buying and lightning icon (⚡) for institutional selling
Visual Elements:
Background coloring based on money flow direction
Support and resistance levels calculated using Average True Range
Real-time dashboard showing current CMF value, volume strength, and signal status
Customizable Parameters:
CMF Period: Calculation period for the money flow (default: 20)
Signal Smoothing: EMA smoothing applied to reduce noise (default: 5)
Big Money Threshold: CMF level required to trigger institutional signals (default: 0.15)
Volume Threshold: Volume multiplier required for signal confirmation (default: 1.5x)
INTERPRETATION
Signal Types:
🔋 (Battery): Indicates strong institutional buying when CMF > threshold with high volume
⚡ (Lightning): Indicates strong institutional selling when CMF < -threshold with high volume
Background color: Green tint for positive money flow, red tint for negative money flow
Dashboard Information:
CMF Value: Current Chaikin Money Flow reading
Volume: Current volume as a multiple of 20-period average
Big Money: Status of institutional activity (BUYING/SELLING/QUIET)
Signal: Strength assessment (STRONG/MEDIUM/WEAK)
TRADING APPLICATIONS
Trend Confirmation: Use CMF direction to confirm price trends
Divergence Analysis: Look for divergences between price and money flow
Volume Validation: Confirm breakouts with corresponding money flow
Accumulation/Distribution: Identify phases of institutional activity
PARAMETER RECOMMENDATIONS
Day Trading: CMF Period 14-21, higher sensitivity settings
Swing Trading: CMF Period 20-30, moderate sensitivity
Position Trading: CMF Period 30-50, lower sensitivity for major trends
ALERTS
Optional alert system notifies users when:
Big money buying is detected (CMF above threshold with volume confirmation)
Big money selling is detected (CMF below negative threshold with volume confirmation)
LIMITATIONS
May generate false signals in low-volume conditions
Best used in conjunction with other technical analysis tools
Effectiveness varies across different market conditions and timeframes
EDUCATIONAL PURPOSE
This open-source indicator is provided for educational purposes to help traders understand money flow analysis. It demonstrates the practical application of the Chaikin Money Flow concept with visual enhancements for easier interpretation.
TECHNICAL SPECIFICATIONS
Overlay indicator (displays on price chart)
No repainting - all calculations are based on closed bar data
Suitable for all timeframes and asset classes
Minimal resource usage for optimal performance
DISCLAIMER
This indicator is for educational and informational purposes only. Past performance does not guarantee future results. Always conduct your own analysis and consider risk management before making trading decisions.
Machine Learning Key Levels [AlgoAlpha]🟠 OVERVIEW
This script plots Machine Learning Key Levels on your chart by detecting historical pivot points and grouping them using agglomerative clustering to highlight price levels with the most past reactions. It combines a pivot detection, hierarchical clustering logic, and an optional silhouette method to automatically select the optimal number of key levels, giving you an adaptive way to visualize price zones where activity concentrated over time.
🟠 CONCEPTS
Agglomerative clustering is a bottom-up method that starts by treating each pivot as its own cluster, then repeatedly merges the two closest clusters based on the average distance between their members until only the desired number of clusters remain. This process creates a hierarchy of groupings that can flexibly describe patterns in how price reacts around certain levels. This offers an advantage over K-means clustering, since the number of clusters does not need to be predefined. In this script, it uses an average linkage approach, where distance between clusters is computed as the average pairwise distance of all contained points.
The script finds pivot highs and lows over a set lookback period and saves them in a buffer controlled by the Pivot Memory setting. When there are at least two pivots, it groups them using agglomerative clustering: it starts with each pivot as its own group and keeps merging the closest pairs based on their average distance until the desired number of clusters is left. This number can be fixed or chosen automatically with the silhouette method, which checks how well each point fits in its cluster compared to others (higher scores mean cleaner separation). Once clustering finishes, the script takes the average price of each cluster to create key levels, sorts them, and draws horizontal lines with labels and colors showing their strength. A metrics table can also display details about the clusters to help you understand how the levels were calculated.
🟠 FEATURES
Agglomerative clustering engine with average linkage to merge pivots into level groups.
Dynamic lines showing each cluster’s price level for clarity.
Labels indicating level strength either as percent of all pivots or raw counts.
A metrics table displaying pivot count, cluster count, silhouette score, and cluster size data.
Optional silhouette-based auto-selection of cluster count to adaptively find the best fit.
🟠 USAGE
Add the indicator to any chart. Choose how far back to detect pivots using Pivot Length and set Pivot Memory to control how many are kept for clustering (more pivots give smoother levels but can slow performance). If you want the script to pick the number of levels automatically, enable Auto No. Levels ; otherwise, set Number of Levels . The colored horizontal lines represent the calculated key levels, and circles show where pivots occurred colored by which cluster they belong to. The labels beside each level indicate its strength, so you can see which levels are supported by more pivots. If Show Metrics Table is enabled, you will see statistics about the clustering in the corner you selected. Use this tool to spot areas where price often reacts and to plan entries or exits around levels that have been significant over time. Adjust settings to better match volatility and history depth of your instrument.
Unified ATR LevelsThis is a unified ATR-based band plotting indicator.
It allows you to display:
Default ATR (on current timeframe)
Preset ATR (mapped to higher timeframe logic)
User-defined ATR (on any custom timeframe)
✳️ Features:
Configurable multipliers, colors, and line widths
Smart label positioning (left, middle, right)
Clean visuals with adjustable label size
Ideal for multi-timeframe analysis and volatility zones
📌 All feedback welcome!
Tags:
volatility, ATR, multi-timeframe, support-and-resistance, custom-indicator
Hybrid candles by Marian BWill plot normal candles with the Heikin-Ashi colors.
You must bring the visiual order to front.
log.info() - 5 Exampleslog.info() is one of the most powerful tools in Pine Script that no one knows about. Whenever you code, you want to be able to debug, or find out why something isn’t working. The log.info() command will help you do that. Without it, creating more complex Pine Scripts becomes exponentially more difficult.
The first thing to note is that log.info() only displays strings. So, if you have a variable that is not a string, you must turn it into a string in order for log.info() to work. The way you do that is with the str.tostring() command. And remember, it's all lower case! You can throw in any numeric value (float, int, timestamp) into str.string() and it should work.
Next, in order to make your output intelligible, you may want to identify whatever value you are logging. For example, if an RSI value is 50, you don’t want a bunch of lines that just say “50”. You may want it to say “RSI = 50”.
To do that, you’ll have to use the concatenation operator. For example, if you have a variable called “rsi”, and its value is 50, then you would use the “+” concatenation symbol.
EXAMPLE 1
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
//@version=6
indicator("log.info()")
rsi = ta.rsi(close,14)
log.info(“RSI= ” + str.tostring(rsi))
Example Output =>
RSI= 50
Here, we use double quotes to create a string that contains the name of the variable, in this case “RSI = “, then we concatenate it with a stringified version of the variable, rsi.
Now that you know how to write a log, where do you view them? There isn’t a lot of documentation on it, and the link is not conveniently located.
Open up the “Pine Editor” tab at the bottom of any chart view, and you’ll see a “3 dot” button at the top right of the pane. Click that, and right above the “Help” menu item you’ll see “Pine logs”. Clicking that will open that to open a pane on the right of your browser - replacing whatever was in the right pane area before. This is where your log output will show up.
But, because you’re dealing with time series data, using the log.info() command without some type of condition will give you a fast moving stream of numbers that will be difficult to interpret. So, you may only want the output to show up once per bar, or only under specific conditions.
To have the output show up only after all computations have completed, you’ll need to use the barState.islast command. Remember, barState is camelCase, but islast is not!
EXAMPLE 2
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
//@version=6
indicator("log.info()")
rsi = ta.rsi(close,14)
if barState.islast
log.info("RSI=" + str.tostring(rsi))
plot(rsi)
However, this can be less than ideal, because you may want the value of the rsi variable on a particular bar, at a particular time, or under a specific chart condition. Let’s hit these one at a time.
In each of these cases, the built-in bar_index variable will come in handy. When debugging, I typically like to assign a variable “bix” to represent bar_index, and include it in the output.
So, if I want to see the rsi value when RSI crosses above 0.5, then I would have something like
EXAMPLE 3
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
//@version=6
indicator("log.info()")
rsi = ta.rsi(close,14)
bix = bar_index
rsiCrossedOver = ta.crossover(rsi,0.5)
if rsiCrossedOver
log.info("bix=" + str.tostring(bix) + " - RSI=" + str.tostring(rsi))
plot(rsi)
Example Output =>
bix=19964 - RSI=51.8449459867
bix=19972 - RSI=50.0975830828
bix=19983 - RSI=53.3529808079
bix=19985 - RSI=53.1595745146
bix=19999 - RSI=66.6466337654
bix=20001 - RSI=52.2191767466
Here, we see that the output only appears when the condition is met.
A useful thing to know is that if you want to limit the number of decimal places, then you would use the command str.tostring(rsi,”#.##”), which tells the interpreter that the format of the number should only be 2 decimal places. Or you could round the rsi variable with a command like rsi2 = math.round(rsi*100)/100 . In either case you’re output would look like:
bix=19964 - RSI=51.84
bix=19972 - RSI=50.1
bix=19983 - RSI=53.35
bix=19985 - RSI=53.16
bix=19999 - RSI=66.65
bix=20001 - RSI=52.22
This would decrease the amount of memory that’s being used to display your variable’s values, which can become a limitation for the log.info() command. It only allows 4096 characters per line, so when you get to trying to output arrays (which is another cool feature), you’ll have to keep that in mind.
Another thing to note is that log output is always preceded by a timestamp, but for the sake of brevity, I’m not including those in the output examples.
If you wanted to only output a value after the chart was fully loaded, that’s when barState.islast command comes in. Under this condition, only one line of output is created per tick update — AFTER the chart has finished loading. For example, if you only want to see what the the current bar_index and rsi values are, without filling up your log window with everything that happens before, then you could use the following code:
EXAMPLE 4
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
//@version=6
indicator("log.info()")
rsi = ta.rsi(close,14)
bix = bar_index
if barstate.islast
log.info("bix=" + str.tostring(bix) + " - RSI=" + str.tostring(rsi))
Example Output =>
bix=20203 - RSI=53.1103309071
This value would keep updating after every new bar tick.
The log.info() command is a huge help in creating new scripts, however, it does have its limitations. As mentioned earlier, only 4096 characters are allowed per line. So, although you can use log.info() to output arrays, you have to be aware of how many characters that array will use.
The following code DOES NOT WORK! And, the only way you can find out why will be the red exclamation point next to the name of the indicator. That, and nothing will show up on the chart, or in the logs.
// CODE DOESN’T WORK
//@version=6
indicator("MW - log.info()")
var array rsi_arr = array.new()
rsi = ta.rsi(close,14)
bix = bar_index
rsiCrossedOver = ta.crossover(rsi,50)
if rsiCrossedOver
array.push(rsi_arr, rsi)
if barstate.islast
log.info("rsi_arr:" + str.tostring(rsi_arr))
log.info("bix=" + str.tostring(bix) + " - RSI=" + str.tostring(rsi))
plot(rsi)
// No code errors, but will not compile because too much is being written to the logs.
However, after putting some time restrictions in with the i_startTime and i_endTime user input variables, and creating a dateFilter variable to use in the conditions, I can limit the size of the final array. So, the following code does work.
EXAMPLE 5
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// CODE DOES WORK
//@version=6
indicator("MW - log.info()")
i_startTime = input.time(title="Start", defval=timestamp("01 Jan 2025 13:30 +0000"))
i_endTime = input.time(title="End", defval=timestamp("1 Jan 2099 19:30 +0000"))
var array rsi_arr = array.new()
dateFilter = time >= i_startTime and time <= i_endTime
rsi = ta.rsi(close,14)
bix = bar_index
rsiCrossedOver = ta.crossover(rsi,50) and dateFilter // <== The dateFilter condition keeps the array from getting too big
if rsiCrossedOver
array.push(rsi_arr, rsi)
if barstate.islast
log.info("rsi_arr:" + str.tostring(rsi_arr))
log.info("bix=" + str.tostring(bix) + " - RSI=" + str.tostring(rsi))
plot(rsi)
Example Output =>
rsi_arr:
bix=20210 - RSI=56.9030578034
Of course, if you restrict the decimal places by using the rounding the rsi value with something like rsiRounded = math.round(rsi * 100) / 100 , then you can further reduce the size of your array. In this case the output may look something like:
Example Output =>
rsi_arr:
bix=20210 - RSI=55.6947486019
This will give your code a little breathing room.
In a nutshell, I was coding for over a year trying to debug by pushing output to labels, tables, and using libraries that cluttered up my code. Once I was able to debug with log.info() it was a game changer. I was able to start building much more advanced scripts. Hopefully, this will help you on your journey as well.
Dynamic VWAP: Fair Value & Divergence SuiteDynamic VWAP: Fair Value & Divergence Suite
Dynamic VWAP: Fair Value & Divergence Suite is a comprehensive tool for tracking contextual valuation, overextension, and potential reversal signals in trending markets. Unlike traditional VWAP that anchors to the start of a session or a fixed period, this indicator dynamically resets the VWAP anchor to the most recent swing low. This design allows you to monitor how far price has extended from the most recent significant low, helping identify zones of potential profit-taking or reversion.
Deviation bands (standard deviations above the anchored VWAP) provide a clear visual framework to assess whether price is in a fair value zone (±1σ), moderately extended (+2σ), or in zones of extreme extension (+3σ to +5σ). The indicator also highlights contextual divergence signals, including slope deceleration, weak-volume retests, and deviation failures—giving you actionable confluence around potential reversal points.
Because the anchor updates dynamically, this tool is particularly well suited for trend-following assets like BTC or stocks in sustained moves, where price rarely returns to deep negative deviation zones. For this reason, the indicator focuses on upside extension rather than symmetrical reversion to a long-term mean.
🎯 Key Features
✅ Dynamic Swing Low Anchoring
Continuously re-anchors VWAP to the most recent swing low based on your chosen lookback period.
Provides context for trend progression and overextension relative to structural lows.
✅ Standard Deviation Bands
Plots up to +5σ deviation bands to visualize levels of overextension.
Extended bands (+3σ to +5σ) can be toggled for simplicity.
✅ Conditional Zone Fills
Colored background fills show when price is inside each valuation zone.
Helps you immediately see if price is in fair value, moderately extended, or highly stretched territory.
✅ Divergence Detection
VWAP Slope Divergence: Flags when price makes a higher high but VWAP slope decelerates.
Low Volume Retest: Highlights weak re-tests of VWAP on low volume.
Deviation Failure: Identifies when price reverts back inside +1σ after closing beyond +3σ.
✅ Volume Fallback
If volume is unavailable, uses high-low range as a proxy.
✅ Highly Customizable
Adjust lookbacks, show/hide extended bands, toggle fills, and enable or disable divergences.
🛠️ How to Use
Identify Buy and Sell Zones
Price in the fair value band (±1σ) suggests equilibrium.
Reaching +2σ to +3σ signals increasing overextension and potential areas to take profits.
+4σ to +5σ zones can be used to watch for exhaustion or mean-reversion setups.
Monitor Divergence Signals
Use slope divergence and deviation failures to look for confluence with overextension.
Low volume retests can flag rallies lacking conviction.
Adapt Swing Lookback
30–50 bars: Faster re-anchoring for swing trading.
75–100 bars: More stable anchors for longer-term trends.
🧭 Best Practices
Combine the anchored VWAP with higher timeframe structure.
Confirm signals with other tools (momentum, volume profiles, or trend filters).
Use extended deviation zones as context, not as standalone signals.
⚠️ Disclaimer
This script is for educational and informational purposes only. It does not constitute financial advice or a recommendation to buy or sell any security or asset. Always do your own research and consult a qualified financial professional before making any trading decisions. Past performance does not guarantee future results.
RSI Cảnh Báo Vùng 20/80 by TTVRSI 8 tín hiệu B khi đạt 20 và Sell khi đạt 80, có thể cài đặt khi đạt đến ngưỡng này
AI Score Indicator//@version=5
indicator("AI Score Indicator", overlay=true)
// Eingaben
length = input.int(14, title="RSI Length")
smaLength = input.int(50, title="SMA Length")
bbLength = input.int(20, title="Bollinger Band Length")
stdDev = input.float(2.0, title="Standard Deviation")
// Indikatoren
rsi = ta.rsi(close, length)
sma = ta.sma(close, smaLength)
= ta.bb(close, bbLength, stdDev)
// Scoring (simuliert ein KI-System mit gewichteten Bedingungen)
score = 0
score := rsi < 30 ? score + 1 : score
score := close < sma ? score + 1 : score
score := close < bb_lower ? score + 1 : score
score := ta.crossover(close, sma) ? score + 1 : score
// Buy-/Sell-Signale auf Basis des Scores
buySignal = score >= 3
sellSignal = rsi > 70 and close > sma
// Signale anzeigen
plotshape(buySignal, title="Buy", location=location.belowbar, color=color.green, style=shape.labelup, text="BUY")
plotshape(sellSignal, title="Sell", location=location.abovebar, color=color.red, style=shape.labeldown, text="SELL")
// Score visualisieren (debugging)
plot(score, title="AI Score", color=color.orange)
