Intermarket Swing Projection [LuxAlgo]The Intermarket Swing Projection allows traders to plot price movement swings from any user-selected asset directly onto the chart in the form of zigzags and/or horizontal support and resistance levels.
This tool rescale the external asset price on the user chart, enabling traders to make direct comparisons.
It answers the question of how different the price behavior is between two assets, accounting for each asset's volatility.
🔶 USAGE
This tool is based on swing detection of two different assets: the chart and a user-selected asset. It allows traders to compare two assets on an equal footing while accounting for volatility and price behavior.
Traders can customize the detection by selecting a custom ticker, timeframe, the number of swings and length for swing detection. This makes the tool a Swiss army knife for asset comparison.
As we can see in the image below, the Show Last, Pivot Length, and Spread parameters are key to defining the final output of the tool.
"Show Last" defines how many pivots are displayed. "Pivot Length" is used for pivot detection; a larger value will detect larger market structures. "Spread" defines how far apart the horizontal levels will be from their original location in terms of volatility.
🔹 Comparing different assets
This image shows the Nasdaq 100 futures contract compared to four other futures contracts: S&P 500, gold, bitcoin, and euro/U.S. dollar.
Plotting all of these assets in Nasdaq 100 terms makes it easy to compare and analyze price behaviors and identify key levels.
In the top left chart, we have NQ vs. ES. It's no surprise that they are practically an exact match; a large portion of the S&P 500 is technology.
In the top right chart, NQ vs. GC, we see totally different behaviors. We can clearly see the summer consolidation in gold and the resumption of the uptrend, which took gold above 29,200 NQ points, up from 21,200.
In the bottom right chart, we see bitcoin making new highs, way above the Nasdaq in May, July, and October. However, the last high was way below the Nasdaq prices on October 27—the first lower high in a while. Sellers are pushing down.
Finally, the bottom left chart is NQ vs. 6E. We can see large volatility in the uptrend since February, with NQ unable to catch up until now. The last swing low was almost a match, and 6E is in a range.
As we can see, this tool allows us to perform intermarket analysis properly by accounting for each asset's volatility and price behavior. Then, we plot them on the same scale on equal terms, which makes performing this kind of analysis easy.
As we can see in the chart above, the assets are the same as in the previous image, but the timeframe is 1H with different settings.
Note the horizontal levels acting as support and resistance, as well as how NQ prices react to the zones marked with white circles. These levels are derived from custom assets selected by the user.
🔹 Displaying Elements
Zig-zag allows traders to clearly see the path that the selected asset's price took, as well as its turning points.
Horizontal levels are displayed from those turning points to the present and can be used as support or resistance. Traders can adjust the spread parameter in the settings panel to expand or contract those levels' volatility.
There are two color modes for the levels: average and pivots. In the first mode, green is used for levels below the average and red for levels above the average. The second uses green for swing lows and red for swing highs.
The backpaint feature is enabled by default and allows the swings to be displayed in the correct location. With this feature disabled, the swings will be displayed in the current location when a new swing is detected.
🔶 DETAILS
On a more technical note, the rescaling is formed by calculating three main elements from all the swings detected on the custom and chart assets:
The chart asset's average of all swing points
The chart asset's standard deviation of all swing points
The custom asset's z-score for each swing point
Then, the re-scaled swing point is calculated as the average plus the z-score multiplied by the standard deviation. This makes it possible to plot AAPL swings on an NQ chart, for example.
Thanks to re-scaling, we can directly compare the price behavior of two assets with different price ranges and volatility on the same chart.
🔶 SETTINGS
🔹 Trendlines
Ticker: Select the custom ticker.
Timeframe: Select a custom timeframe.
Show Last: Select how many swing points to display.
Pivot Length: Select the size for swing point detection.
Spread: Volatility multiplier for horizontal levels. Larger values mean the levels are farther apart.
Backpaint: Enable or disable the backpaint feature. When enabled, the drawings will be displayed where they were detected. When disabled, the drawings will be displayed at the moment of detection.
🔹 Style
Show ZigZag: Enable or disable the ZigZag display and choose a line style.
Show Levels: Enable or disable the levels display and choose a line style.
Color Mode: Choose between Average Mode, which colors all levels below the average bullish and all levels above bearish, and Pivot Mode, which colors swing highs bearish and swing lows bullish.
Bullish: Select a bullish color.
Bearish: Select a bearish color.
ZigZag: Select the ZigZag color.
Indicatori e strategie
15 min Trailstop15m High/Low Liquidity Lines (1m) — Indicator Description
15m High/Low Liquidity Lines (1m) is a precision liquidity-mapping tool designed for intraday traders who understand the importance of higher-timeframe liquidity levels while executing on the 1-minute chart.
This indicator automatically detects confirmed 15-minute swing highs and swing lows using pivot logic. When a new 15m high or low forms:
✔ Liquidity Line Generation
A horizontal line is drawn exactly at the price level of the pivot.
The line is anchored to the exact 1-minute candle that produced the 15m high/low, ensuring perfect visual alignment.
The line extends only up to the current bar — not across the whole chart.
Optional text labels (“15m High”, “15m Low”) can be shown at the start of each line.
✔ Auto-Cleanup (Smart Liquidity Sweep Detection)
If price trades through the level, the corresponding line and label are:
Instantly deleted
Marking the level as taken/swept
Allowing the chart to stay clean and focused on active liquidity only
This mimics institutional liquidity logic: once the high or low is violated, the target is considered filled and removed.
✔ Alerts
The indicator includes built-in alerts that fire when:
A new 15m high is confirmed
A new 15m low is confirmed
This allows the trader to react immediately when fresh liquidity levels appear.
✔ Customization Options
You can fully tailor the visual representation:
Turn highs and/or lows on or off
Choose line style (solid, dashed, dotted)
Customize line color and thickness
Customize the label style, size, and transparency
Who Is This For?
This indicator is ideal for:
ICT-style traders
Liquidity-based scalpers
1-minute ES/NQ traders
Anyone who uses HTF liquidity levels to frame trades on the LTF
It provides a clean, automated method to track active 15-minute liquidity levels directly on the 1-minute chart with zero clutter and perfect alignment.
Advanced Confluence DashboardAdvanced Confluence Dashboard - Multi-Indicator Technical Analysis Tool
OVERVIEW
The Advanced Confluence Dashboard is a comprehensive technical analysis tool designed to help traders identify high-probability trade setups by tracking multiple technical indicators simultaneously. The indicator displays up to 13 different technical confluences in an easy-to-read dashboard format, providing both individual signals and an overall market bias percentage. Switch between full table view and condensed view for maximum chart flexibility.
FEATURES
- 13 Technical Confluences: RSI, VWAP, EMA Cross (9/21), MACD, Stochastic, Trend (50 EMA), Bollinger Bands, ADX Strength, Price Momentum, Volume Breakout, VWAP Bands, 200 EMA, and Price Action (Higher Highs/Lower Lows)
- Real-time Confluence Scoring: Automatically calculates bullish vs bearish signal strength
- Multi-Timeframe Support: Analyze indicators on any timeframe while viewing your chart on another
- Customizable Display: Toggle individual indicators on/off, adjust table position, size, and transparency
- ATR Information: Optional ATR display for volatility-based position sizing
- Condensed View Mode: Ultra-minimal display showing only confluence score and ATR (perfect for scalpers who want maximum chart visibility)
- Full Table View: Detailed breakdown of each indicator's value and signal
- Color-Coded Signals: Green (bullish), red (bearish), white (neutral) for instant visual clarity
HOW IT WORKS
The indicator evaluates each enabled technical indicator and assigns it either a bullish or bearish signal based on its current state. The confluence score shows how many indicators are aligned in each direction, giving you a clear percentage-based view of market bias. For example, if 8 out of 13 indicators are bullish, you'll see a 62% LONG BIAS signal.
DISPLAY MODES
Full View: Shows all enabled indicators with their current values and signals in a detailed table format. Perfect for understanding exactly which indicators are bullish or bearish and why.
Condensed View: Shows only the confluence score (e.g., "4/13 LONG | 9/13 SHORT - SHORT BIAS 69%") and optional ATR information. This minimal display keeps your chart clean while still providing the essential confluence data you need for quick trading decisions. Ideal for scalpers and traders who want maximum chart space.
CONFLUENCES EXPLAINED
- RSI: Momentum oscillator (>50 bullish, <50 bearish, shows overbought/oversold)
- VWAP: Volume-weighted average price (above = bullish, below = bearish)
- EMA Cross: Fast EMA (9) vs Slow EMA (21) with price position
- MACD: Trend-following momentum (line above signal = bullish)
- Stochastic: Momentum oscillator (>50 bullish, <50 bearish)
- Trend (50 EMA): Price position relative to 50-period EMA
- Bollinger Bands: Volatility and mean reversion (above middle = bullish)
- ADX Strength: Trend strength indicator (shows strong trends)
- Price Momentum: Rate of price change over specified period
- Volume Breakout: Detects unusual volume with directional bias
- VWAP Bands: Standard deviation bands around VWAP
- 200 EMA: Long-term trend indicator
- Price Action: Higher Highs and Lower Lows pattern detection
SETTINGS
Timeframe Settings:
- Indicator Timeframe: Analyze indicators on a different timeframe than your chart
Display Options:
- Condensed View: Toggle between full table and minimal display
- Show ATR Info: Display/hide ATR information
- Table Position: 9 positions (top/middle/bottom + left/center/right)
- Text Size: Auto, tiny, small, normal, large, huge
- Table Transparency: 0-100%
- Border Width: 1-5 pixels
Confluence Toggles:
- Enable/disable any of the 13 confluences individually
- Confluence score automatically adjusts based on enabled indicators
Indicator Settings:
- RSI Length (default: 14)
- ATR Length (default: 14)
- Fast/Slow EMA (default: 9/21)
- Trend EMA (default: 50)
- Volume SMA Length (default: 20)
- Volume Breakout Multiplier (default: 2.0x)
- Bollinger Bands Length/StdDev (default: 20/2.0)
- ADX Length (default: 14)
- ADX Strength Threshold (default: 25)
- Momentum Length (default: 10)
IDEAL USE CASES
- Scalping: Quick identification of confluence for fast entries/exits - use condensed view for clean charts
- Day Trading: Multi-timeframe analysis for intraday setups
- Swing Trading: Confirmation of longer-term bias
- Risk Management: Higher confluence = higher probability trades
- Trade Filtering: Only take trades when confluence reaches your threshold
- Multi-Monitor Setups: Use condensed view on execution charts, full view on analysis charts
HOW TO USE
1. Add the indicator to your chart
2. Toggle on/off the confluences you prefer to use
3. Choose between Full View (detailed) or Condensed View (minimal)
4. Adjust the table position and size to your preference
5. Look for high confluence percentages (70%+ is strong bias)
6. Use the individual indicator signals (full view) to understand market structure
7. Combine with your trading strategy for entry/exit confirmation
TIPS
- Use Condensed View when scalping to keep your chart clean and uncluttered
- Switch to Full View when you need to analyze which specific indicators are conflicting
- Higher confluence doesn't guarantee success - always use proper risk management
- Consider using 60%+ confluence as a minimum threshold for trades
- Pay attention to which specific indicators are aligned vs conflicting
- Use the ATR display for quick reference on position sizing
- Experiment with different timeframes to find what works for your style
- Disable indicators you don't use to simplify your confluence scoring
DISCLAIMER
This indicator is for educational and informational purposes only. It does not constitute financial advice, investment advice, trading advice, or any other type of advice. Trading and investing in financial markets involves substantial risk of loss and is not suitable for every investor. Past performance is not indicative of future results. Always do your own research and consult with a qualified financial advisor before making any investment decisions.
RSI Swing Indicator (Win-Rate + Forecast Line + Range Row)What the script does:
It’s essentially an enhanced RSI tool that doesn’t just show the raw RSI line. Instead, it adds forecasting, trade statistics, and range detection so you can see how reliable RSI signals have been historically and what they might mean going forward.
The main components
RSI Calculation
- Uses your chosen source (close, hl2, etc.) and length (default 7).
- Plots the RSI line (orange).
Forecasting
- Projects RSI into the future using slope extrapolation.
- Plots a forecast line (blue) and shows whether RSI is likely to become overbought, oversold, or stay neutral.
Trade Statistics
- Tracks how many long and short trades would have been profitable based on RSI bias.
- Calculates Win‑Rate (percentage of profitable trades) and Average Return (average gain/loss per trade).
- This gives you a statistical edge: are longs or shorts historically working better?
Bias & Conflict Detection
- Defines current bias (Bullish, Bearish, Neutral).
- Flags Conflict when the forecast disagrees with the current bias (e.g., RSI bullish now but forecast bearish).
- Helps you avoid trading against weakening momentum.
Range Detection
- Checks if RSI slope is flat and values are between mid‑bounds (40–60).
- Calculates Range Probability (how often range conditions occur).
- Adds a Range row to the table so you know when the market is likely sideways instead of trending.
Table Display
- Summarizes everything in a neat table: Forecast, Win‑Rates, Avg Returns, Prob Bias, Conflict, Range Prob, and Range status.
- Color‑coded so you can instantly see what’s favorable (green), risky (red), or neutral (yellow/orange).
How to use it
- Trend trading: Look for Profitable Bias with forecast alignment.
- Range trading: When both win‑rates are weak and Range row says Range Likely, fade extremes (buy low RSI, sell high RSI).
- Risk management: Avoid trades when Conflict is flagged.
- Forecasting: Use the projected RSI to anticipate overbought/oversold zones before they happen.
In short:
The script is like a “smart RSI dashboard”. It takes the basic RSI, adds forecasting, tracks how well past trades worked, and tells you whether the market is trending or ranging. This way, you’re not just reacting to RSI — you’re trading with context, probabilities, and forward‑looking signals.
Stage 2 Pullback Swing indicatorThis scanner is built for swing traders who want high-probability pullbacks inside strong, established uptrends. It targets names in a confirmed Stage 2 bull phase (Weinstein model) that have pulled back 10–30% from a recent swing high on light selling volume, while still respecting fast EMAs.
Goal: find powerful uptrending stocks during controlled dips before the next leg higher.
What it looks for
Strong prior uptrend: price above the 50 and 200 SMAs, momentum positive over multiple timeframes
Confirmed Stage 2: price above a rising 30-week MA on the weekly chart
Pullback depth: 10–30% off recent swing highs—not too shallow, not broken
Pullback quality: range contained, no panic selling, trend structure intact
EMA behavior: price near EMA10 or EMA20 at signal time
Volume contraction: sellers fading throughout the pullback
Bullish shift: green candle back in trend direction
Why this matters
This setup hints at institutions defending positions during a temporary dip. Strong stocks pull back cleanly with declining volume, then resume the primary trend. This script alerts you when those conditions align.
Best way to use
Filter a strong universe before applying—quality tickers only
Pair with clear trade plans: risk defined by prior swing low or ATR
Trigger alerts instead of hunting charts manually
Intended for
Swing traders who want momentum continuation setups
Traders who prefer entering on controlled retracements
Anyone tired of chasing extended breakouts
machine_learningLibrary "machine_learning"
euclidean(a, b)
Parameters:
a (array)
b (array)
manhattan(a, b)
Parameters:
a (array)
b (array)
cosine_similarity(a, b)
Parameters:
a (array)
b (array)
cosine_distance(a, b)
Parameters:
a (array)
b (array)
chebyshev(a, b)
Parameters:
a (array)
b (array)
minkowski(a, b, p)
Parameters:
a (array)
b (array)
p (float)
dot_product(a, b)
Parameters:
a (array)
b (array)
vector_norm(arr, p)
Parameters:
arr (array)
p (float)
sigmoid(x)
Parameters:
x (float)
sigmoid_derivative(x)
Parameters:
x (float)
tanh_derivative(x)
Parameters:
x (float)
relu(x)
Parameters:
x (float)
relu_derivative(x)
Parameters:
x (float)
leaky_relu(x, alpha)
Parameters:
x (float)
alpha (float)
leaky_relu_derivative(x, alpha)
Parameters:
x (float)
alpha (float)
elu(x, alpha)
Parameters:
x (float)
alpha (float)
gelu(x)
Parameters:
x (float)
swish(x, beta)
Parameters:
x (float)
beta (float)
softmax(arr)
Parameters:
arr (array)
apply_activation(arr, activation_type, alpha)
Parameters:
arr (array)
activation_type (string)
alpha (float)
normalize_minmax(arr, min_val, max_val)
Parameters:
arr (array)
min_val (float)
max_val (float)
normalize_zscore(arr, mean_val, std_val)
Parameters:
arr (array)
mean_val (float)
std_val (float)
normalize_matrix_cols(m)
Parameters:
m (matrix)
scaler_fit(arr, method)
Parameters:
arr (array)
method (string)
scaler_fit_matrix(m, method)
Parameters:
m (matrix)
method (string)
scaler_transform(scaler, arr)
Parameters:
scaler (ml_scaler)
arr (array)
scaler_transform_matrix(scaler, m)
Parameters:
scaler (ml_scaler)
m (matrix)
clip(x, lo, hi)
Parameters:
x (float)
lo (float)
hi (float)
clip_array(arr, lo, hi)
Parameters:
arr (array)
lo (float)
hi (float)
loss_mse(predicted, actual)
Parameters:
predicted (array)
actual (array)
loss_rmse(predicted, actual)
Parameters:
predicted (array)
actual (array)
loss_mae(predicted, actual)
Parameters:
predicted (array)
actual (array)
loss_binary_crossentropy(predicted, actual)
Parameters:
predicted (array)
actual (array)
loss_huber(predicted, actual, delta)
Parameters:
predicted (array)
actual (array)
delta (float)
gradient_step(weights, gradients, lr)
Parameters:
weights (array)
gradients (array)
lr (float)
adam_step(weights, gradients, m, v, lr, beta1, beta2, t, epsilon)
Parameters:
weights (array)
gradients (array)
m (array)
v (array)
lr (float)
beta1 (float)
beta2 (float)
t (int)
epsilon (float)
clip_gradients(gradients, max_norm)
Parameters:
gradients (array)
max_norm (float)
lr_decay(initial_lr, decay_rate, step)
Parameters:
initial_lr (float)
decay_rate (float)
step (int)
lr_cosine_annealing(initial_lr, min_lr, step, total_steps)
Parameters:
initial_lr (float)
min_lr (float)
step (int)
total_steps (int)
knn_create(k, distance_type)
Parameters:
k (int)
distance_type (string)
knn_fit(model, X, y)
Parameters:
model (ml_knn)
X (matrix)
y (array)
knn_predict(model, x)
Parameters:
model (ml_knn)
x (array)
knn_predict_proba(model, x)
Parameters:
model (ml_knn)
x (array)
knn_batch_predict(model, X)
Parameters:
model (ml_knn)
X (matrix)
linreg_fit(X, y)
Parameters:
X (matrix)
y (array)
ridge_fit(X, y, lambda)
Parameters:
X (matrix)
y (array)
lambda (float)
linreg_predict(model, x)
Parameters:
model (ml_linreg)
x (array)
linreg_predict_batch(model, X)
Parameters:
model (ml_linreg)
X (matrix)
linreg_score(model, X, y)
Parameters:
model (ml_linreg)
X (matrix)
y (array)
logreg_create(n_features, learning_rate, iterations)
Parameters:
n_features (int)
learning_rate (float)
iterations (int)
logreg_fit(model, X, y)
Parameters:
model (ml_logreg)
X (matrix)
y (array)
logreg_predict_proba(model, x)
Parameters:
model (ml_logreg)
x (array)
logreg_predict(model, x, threshold)
Parameters:
model (ml_logreg)
x (array)
threshold (float)
logreg_batch_predict(model, X, threshold)
Parameters:
model (ml_logreg)
X (matrix)
threshold (float)
nb_create(n_classes)
Parameters:
n_classes (int)
nb_fit(model, X, y)
Parameters:
model (ml_nb)
X (matrix)
y (array)
nb_predict_proba(model, x)
Parameters:
model (ml_nb)
x (array)
nb_predict(model, x)
Parameters:
model (ml_nb)
x (array)
nn_create(layers, activation)
Parameters:
layers (array)
activation (string)
nn_forward(model, x)
Parameters:
model (ml_nn)
x (array)
nn_predict_class(model, x)
Parameters:
model (ml_nn)
x (array)
accuracy(y_true, y_pred)
Parameters:
y_true (array)
y_pred (array)
precision(y_true, y_pred, positive_class)
Parameters:
y_true (array)
y_pred (array)
positive_class (int)
recall(y_true, y_pred, positive_class)
Parameters:
y_true (array)
y_pred (array)
positive_class (int)
f1_score(y_true, y_pred, positive_class)
Parameters:
y_true (array)
y_pred (array)
positive_class (int)
r_squared(y_true, y_pred)
Parameters:
y_true (array)
y_pred (array)
mse(y_true, y_pred)
Parameters:
y_true (array)
y_pred (array)
rmse(y_true, y_pred)
Parameters:
y_true (array)
y_pred (array)
mae(y_true, y_pred)
Parameters:
y_true (array)
y_pred (array)
confusion_matrix(y_true, y_pred, n_classes)
Parameters:
y_true (array)
y_pred (array)
n_classes (int)
sliding_window(data, window_size)
Parameters:
data (array)
window_size (int)
train_test_split(X, y, test_ratio)
Parameters:
X (matrix)
y (array)
test_ratio (float)
create_binary_labels(data, threshold)
Parameters:
data (array)
threshold (float)
lag_matrix(data, n_lags)
Parameters:
data (array)
n_lags (int)
signal_to_position(prediction, threshold_long, threshold_short)
Parameters:
prediction (float)
threshold_long (float)
threshold_short (float)
confidence_sizing(probability, max_size, min_confidence)
Parameters:
probability (float)
max_size (float)
min_confidence (float)
kelly_sizing(win_rate, avg_win, avg_loss, max_fraction)
Parameters:
win_rate (float)
avg_win (float)
avg_loss (float)
max_fraction (float)
sharpe_ratio(returns, risk_free_rate)
Parameters:
returns (array)
risk_free_rate (float)
sortino_ratio(returns, risk_free_rate)
Parameters:
returns (array)
risk_free_rate (float)
max_drawdown(equity)
Parameters:
equity (array)
atr_stop_loss(entry_price, atr, multiplier, is_long)
Parameters:
entry_price (float)
atr (float)
multiplier (float)
is_long (bool)
risk_reward_take_profit(entry_price, stop_loss, ratio)
Parameters:
entry_price (float)
stop_loss (float)
ratio (float)
ensemble_vote(predictions)
Parameters:
predictions (array)
ensemble_weighted_average(predictions, weights)
Parameters:
predictions (array)
weights (array)
smooth_prediction(current, previous, alpha)
Parameters:
current (float)
previous (float)
alpha (float)
regime_classifier(volatility, trend_strength, vol_threshold, trend_threshold)
Parameters:
volatility (float)
trend_strength (float)
vol_threshold (float)
trend_threshold (float)
ml_knn
Fields:
k (series int)
distance_type (series string)
X_train (matrix)
y_train (array)
ml_linreg
Fields:
coefficients (array)
intercept (series float)
lambda (series float)
ml_logreg
Fields:
weights (array)
bias (series float)
learning_rate (series float)
iterations (series int)
ml_nn
Fields:
layers (array)
weights (matrix)
biases (array)
weight_offsets (array)
bias_offsets (array)
activation (series string)
ml_nb
Fields:
class_priors (array)
means (matrix)
variances (matrix)
n_classes (series int)
ml_scaler
Fields:
min_vals (array)
max_vals (array)
means (array)
stds (array)
method (series string)
ml_train_result
Fields:
loss_history (array)
final_loss (series float)
converged (series bool)
iterations_run (series int)
ml_prediction
Fields:
class_label (series int)
probability (series float)
probabilities (array)
value (series float)
Premarket&Regular Session VolumeThis script provides a clean and practical overview of premarket cumulative volume compared with regular session volume, helping traders instantly identify unusual early-session liquidity.
Features
Tracks total premarket volume from 4:00–9:30 ET
Shows cumulative premarket buildup as a smooth line
Helps detect early liquidity spikes that often lead to halts, gap-ups or momentum runs
Designed for intraday scalpers and small-cap/momentum traders
Why It’s Useful
Premarket activity frequently reveals hidden demand long before the opening bell.
When premarket volume significantly exceeds average daily levels, the probability of early spikes, volatility events, or continuation moves increases.
This indicator offers a simple but powerful visual tool for evaluating market interest before the open and comparing it with regular session volume
ATR Stop Loss Finder (Strict Breakout Mode)Title: ATR Stop Loss Finder (Strict Breakout Mode)
Description:
Volatility-Based Risk Management: Generates dynamic trailing stop-loss lines for both Long (Lower Line) and Short (Upper Line) positions based on ATR volatility.
Strict Breakout Detection: Features a unique "Strict Breakout" logic that highlights trend acceleration. It visually marks whenever the Long SL breaks a historical high or the Short SL breaks a historical low over a user-defined lookback period (e.g., 50 bars).
Visual Signals: Automatically plots Red Circles for bullish SL breakouts (New Highs) and Blue Circles for bearish SL breakdowns (New Lows), making strong momentum shifts easy to spot.
Real-Time Dashboard: Includes an informative table displaying current ATR and SL price levels for quick reference.
Mirpapa_Lib_StructsLibrary "Mirpapa_Lib_Structs"
ICT 구조 변화 감지 라이브러리 (BOS, CHoCH, MSS, Sweep)
initStructState()
StructState 초기화
checkBOS(_trend, _currentClose, _lastHHPrice, _lastLLPrice)
BOS 체크 (추세 지속) - 종가 기준
Parameters:
_trend (string) : 현재 추세
_currentClose (float) : 현재 종가
_lastHHPrice (float) : 마지막 HH 가격
_lastLLPrice (float) : 마지막 LL 가격
Returns:
checkCHoCH(_trend, _currentClose, _lastHHPrice, _lastLLPrice)
CHoCH 체크 (추세 전환) - 종가 기준
Parameters:
_trend (string) : 현재 추세
_currentClose (float) : 현재 종가
_lastHHPrice (float) : 마지막 HH 가격
_lastLLPrice (float) : 마지막 LL 가격
Returns:
checkSweep(_currentHigh, _currentLow, _currentClose, _lastHHPrice, _lastLLPrice)
Sweep 체크 (유동성 수집)
Parameters:
_currentHigh (float) : 현재 고가
_currentLow (float) : 현재 저가
_currentClose (float) : 현재 종가
_lastHHPrice (float) : 마지막 HH 가격
_lastLLPrice (float) : 마지막 LL 가격
Returns:
checkMSS(_hadCHoCH, _chochDir, _currentHigh, _currentLow, _chochPrice)
MSS 체크 (CHoCH + 리테스트 확인)
Parameters:
_hadCHoCH (bool) : CHoCH 발생 여부
_chochDir (string) : CHoCH 방향
_currentHigh (float) : 현재 고가
_currentLow (float) : 현재 저가
_chochPrice (float) : CHoCH 발생 가격
Returns:
drawStructLabel(_price, _time, _type, _dir, _lblColor)
구조 변화 라벨 그리기
Parameters:
_price (float) : 가격
_time (int) : 시간
_type (string) : 구조 타입
_dir (string) : 방향
_lblColor (color) : 라벨 색상
drawStructLine(_price, _startTime, _endTime, _lineColor, _lineWidth)
구조 변화 라인 그리기
Parameters:
_price (float) : 가격
_startTime (int) : 시작 시간
_endTime (int) : 끝 시간
_lineColor (color) : 라인 색상
_lineWidth (int) : 라인 두께
StructType
구조 타입 상수
Fields:
BOS (series string)
CHOCH (series string)
MSS (series string)
SWEEP (series string)
TrendDir
추세 방향 상수
Fields:
UP (series string)
DOWN (series string)
NONE (series string)
StructState
구조 변화 상태
Fields:
_trend (series string) : 현재 추세 방향
_lastHHPrice (series float) : 마지막 HH 가격
_lastHHTime (series int) : 마지막 HH 시간
_lastLLPrice (series float) : 마지막 LL 가격
_lastLLTime (series int) : 마지막 LL 시간
IDLP – Intraday Daily Levels Pro [FXSMARTLAB]🔥 IDLP – Intraday Daily Levels Pro
IDLP – Intraday Daily Levels Pro is a precision toolkit for intraday traders who rely on objective daily structure instead of repainting indicators and noisy signals.
Every level plotted by IDLP is derived from one simple rule:
Today’s trading decisions must be based on completed market data only.
That means:
✅ No use of the current day’s unfinished data for levels
✅ No lookahead
✅ No hidden repaint behavior
IDLP reconstructs the previous trading day from the intraday chart and then projects that structure forward onto the current session, giving you a stable, institutional-style intraday map.
🧱 1. Previous Daily Levels (Core Structure)
IDLP extracts and displays the full previous daily structure, which you can toggle on/off individually via the inputs:
Previous Daily High (PDH)
Previous Daily Low (PDL)
Previous Daily Open
Previous Daily Close,
Previous Daily Mid (50% of the range)
Previous Daily Q1 (25% of the range)
Previous Daily Q3 (75% of the range)
All of these come from the day that just closed and are then locked for the entire current session.
What these levels tell you:
PDH / PDL – true extremes of yesterday’s price action (liquidity zones, breakout/reversal points).
Previous Daily Open / Close – how the market positioned itself between session start and end
Mid (50%) – equilibrium level of the previous day’s auction.
Q1 / Q3 (25% / 75%) internal structure of the previous day’s range, dividing it into four equal zones and helping you see if price is trading in the lower, middle, or upper quarter of yesterday’s range.
All these levels are non-repaint: once the day is completed, they are fixed and never change when you scroll, replay, or backtest.
🎯 2. Previous Day Pivot System (P, S1, S2, R1, R2)
IDLP includes a classic floor-trader pivot grid, but critically:
It is calculated only from the previous day’s high, low, and close.
So for the current session, the following are fixed:
Pivot P – central reference level of the previous day.
Support 1 (S1) and Support 2 (S2)
Resistance 1 (R1) and Resistance 2 (R2)
These levels are widely used by institutional desks and algos to structure:
mean-reversion plays, breakout zones, intraday targets, and risk placement.
Everything in this section is non-repaint because it only uses the previous day’s fully closed OHLC.
📏 3. 1-Day ADR Bands Around Previous Daily Open
Instead of a multi-day ADR, IDLP uses a pure 1-Day ADR logic:
ADR = Range of the previous day
ADR = PDH − PDL
From that, IDLP builds two clean bands centered around the previous daily Open:
ADR Upper Band = Previous Day Open + (ADR × Multiplier)
ADR Lower Band = Previous Day Open − (ADR × Multiplier)
The multiplier is user-controlled in the inputs:
ADR Multiplier (default: 0.8)
This lets you choose how “tight” or “wide” you want the ADR envelope to be around the previous day’s open.
Typical use cases:
Identify realistic intraday extension targets, Spot exhaustion moves beyond ADR bands, Frame reversals after reaching volatility extremes, Align trades with or against volatility expansion
Again, since ADR is calculated only from the completed previous day, these bands are totally non-repaint during the current session.
🔒 4. True Non-Repaint Architecture
The internal logic of IDLP is built to guarantee non-repaint behavior:
It reconstructs each day using time("D") and tracks:
dayOpen, dayHigh, dayLow, dayClose for the current day
prevDayOpen, prevDayHigh, prevDayLow, prevDayClose for the previous day
At the moment a new day starts:
The “current day” gets “frozen” into prevDay*
These prevDay* values then drive: Previous Daily Levels, Pivots, ADR.
During the current day:
All these “previous day” values stay fixed, no matter what happens.
They do not move in real time, they do not shift in replay.
This means:
What you see in the past is exactly what you would have seen live.
No fake backtests.
No illusion of perfection from repainting behavior.
🎯 5. Designed For Intraday Traders
IDLP – Intraday Daily Levels Pro is made for:
- Day traders and scalpers
- Index and FX traders
- Prop firm challenge trading
- Traders using ICT/SMC-style levels, liquidity, and range logic
- Anyone who wants a clean, institutional-style daily framework without noise
You get:
Previous Day OHLC
Mid / Q1 / Q3 of the previous range
Previous-Day Pivots (P, S1, S2, R1, R2)
1-Day ADR Bands around Previous Day Open
All calculated only from closed data, updated once per day, and then locked.
PEG RSI [Auto EPS Growth]The PEG RSI is a hybrid indicator that combines fundamental valuation with technical momentum. It applies the Relative Strength Index (RSI) directly to the Price/Earnings-to-Growth (PEG) Ratio.
Unlike traditional PEG indicators that require manual input for growth rates, this script automatically calculates the Compound Annual Growth Rate (CAGR) of Earnings Per Share (EPS) based on historical data.
Key Features
- Auto-Calculated Growth: Uses historical TTM Earnings Per Share (EPS) to calculate the CAGR over a user-defined period (Default: 4 years).
- Dynamic Valuation: Converts the static PEG ratio into an oscillator (RSI) to identify relative valuation extremes.
- Trend & Momentum: Visualizes the momentum of the PEG ratio relative to its own history.
Educational Case Study
This indicator is designed for educational purposes and research. Instead of relying on fixed overbought or oversold levels, users are encouraged to study the correlation between the PEG RSI and price action independently.
- Observe how the price reacts when the PEG RSI reaches upper or lower extremes.
- Different stocks may respect different RSI zones based on their growth stability.
- Use this tool to analyze how market valuation momentum shifts over time.
Settings:
- Years for CAGR Growth: Timeframe to calculate EPS growth (Default: 4 years).
- RSI Length: Lookback period for the RSI calculation (Default: 14).
Note: This indicator works best on stocks with a consistent history of earnings. It requires financial data to function (will not work on assets without EPS like Crypto or Forex).
Raja's SMC Order Blocks Display [PRO]Raja's SMC Order Blocks Display - Complete Description
🌟 A Message from Raja Saien
This indicator has been crafted with dedication, countless hours of research, and deep passion for trading excellence. Raja Saien has poured his heart and soul into creating this powerful tool to help YOU succeed in the markets.
For Everyone Starting Their Trading Journey:
If you're new to trading, remember - every expert was once a beginner. This indicator is your gateway to understanding how institutional money moves in the markets. Raja Saien believes in YOUR potential to learn, grow, and achieve financial freedom through smart trading.
The path to success requires:
✨ Dedication to learning the craft
💪 Patience during the learning curve
🎯 Consistent practice with the right tools
🚀 Belief in your ability to master the markets
This isn't just an indicator - it's a mentor on your chart, showing you where the smart money is positioned. With hard work and this tool in your arsenal, you can transform your trading and your life.
Remember: The markets reward those who prepare, practice, and persist. Raja Saien has given you the tool - now it's your turn to commit to the journey!
Overview
This is an advanced TradingView indicator that identifies and displays Smart Money Concepts (SMC) and Order Blocks. It's designed for professional traders who want to understand institutional trading patterns and market structure.
Main Features
1. Smart Money Concepts (SMC) Detection
ZigZag Pattern Recognition: Identifies market structure using pivot highs and lows
Break of Structure (BOS): Detects when price breaks through important structural levels
Change of Character (CHoCH): Identifies trend reversals and shifts in market sentiment
Configurable Length: Adjustable ZigZag sensitivity (default: 5 bars)
2. Order Blocks (OB)
Order blocks are zones where institutional investors have placed large orders. The indicator identifies two types:
Bullish Order Blocks:
Created when market shifts from bearish to bullish
Marks the last bearish candle before the structure break
Displayed in green/teal color
Represents potential support zones where price may bounce
Looks back 10 bars to find the lowest bearish candle
Bearish Order Blocks:
Created when market shifts from bullish to bearish
Marks the last bullish candle before the structure break
Displayed in red color
Represents potential resistance zones where price may reject
Looks back 10 bars to find the highest bullish candle
3. Order Block Management
Dynamic Extension: Active order blocks extend forward on the chart
Mitigation Detection: Automatically detects when price fully breaks through an order block
Bullish OB mitigated when close drops below the bottom
Bearish OB mitigated when close rises above the top
Visual Feedback: Mitigated blocks turn gray and are labeled "Mitigated"
Auto-cleanup: Removes mitigated order blocks from active tracking
4. Moving Averages Suite
Includes multiple trend indicators for comprehensive analysis:
Fast EMA (default 9): Yellow line - captures short-term momentum
Slow EMA (default 21): Purple line - identifies medium-term trends
EMA 50: Orange line - major trend filter
SMA 200: Blue line - long-term trend and institutional reference point
All EMAs support multiple source options: Open, High, Low, Close, HL2, HLC3, OHLC4
Customization Options
SMC Settings
ZigZag Length: Control sensitivity of structure detection (2-100)
Show Order Blocks: Toggle order block display on/off
Visual Settings
Bullish Color: Customize color for bullish order blocks (default: teal #089981)
Bearish Color: Customize color for bearish order blocks (default: red #f23645)
Transparency: Order blocks displayed with 80% transparency for better chart visibility
EMA Settings
Fast EMA Length: Adjustable period (default: 9)
Slow EMA Length: Adjustable period (default: 21)
Source Selection: Choose calculation source for each EMA
Toggle EMA 50: Show/hide the 50-period EMA
Toggle SMA 200: Show/hide the 200-period SMA
How It Works
Structure Detection Process
Identifies pivot highs and lows based on specified length
Creates ZigZag lines connecting significant swing points
Tracks current trend direction (bullish/bearish/neutral)
Monitors for structural breaks that signal trend changes
Order Block Creation
When price breaks above a previous high (bullish BOS):
Scans last 10 bars for the lowest bearish candle
Creates bullish order block at that candle's range
Marks it as active support zone
When price breaks below a previous low (bearish BOS):
Scans last 10 bars for the highest bullish candle
Creates bearish order block at that candle's range
Marks it as active resistance zone
Order Block Lifecycle
Active: Box extends forward with colored border and background
Tested: Price can interact with the zone multiple times
Mitigated: Once price closes through the zone, marked as invalidated
Removed: Automatically cleaned up after mitigation
Trading Applications
Entry Strategies
Pullback Entries: Wait for price to return to an active order block
Confirmation: Look for bullish price action at bullish OBs, bearish at bearish OBs
EMA Confluence: Stronger setups when OBs align with EMA levels
Risk Management
Stop Loss: Place stops just beyond the order block boundary
Invalidation: Exit if order block gets mitigated
Multiple Timeframes: Check OBs on higher timeframes for stronger zones
Trend Analysis
EMA Alignment: All EMAs pointing same direction = strong trend
EMA 50 Test: Key level for trend continuation/reversal
SMA 200: Major institutional reference point
Technical Specifications
Max Boxes: 500 (sufficient for most chart timeframes)
Max Lines: 500
Max Labels: 500
Overlay: True (draws directly on price chart)
Version: Pine Script v5
Best Practices
Use on liquid markets (forex, major stocks, crypto)
Combine with volume analysis for confirmation
Higher timeframes produce more reliable order blocks
Wait for clear structure breaks before trusting new OBs
Don't trade against the major trend (SMA 200 direction)
Use multiple confirmations before entering trades
Limitations
Works best in trending markets with clear structure
May produce false signals in ranging/choppy conditions
Requires understanding of Smart Money Concepts
Not a standalone trading system - use with proper risk management
Historical order blocks don't guarantee future reactions
Multi-EMA Slope DashboardThis script provides a comprehensive dashboard displayed directly on the chart, allowing you to analyze the underlying trend using 8 Exponential Moving Averages (EMA) ranging from period 20 to 55.
Unlike classic indicators that simply check if the price is above or below the EMA, this tool analyzes the slope of each moving average to determine the true market dynamics.
The indicator calculates the status of 8 distinct EMAs (20, 25, 30, 35, 40, 45, 50, 55). For each EMA, the script determines the direction using the following logic:
Slope Calculation: It compares the current EMA value with its value 3 bars ago (variable nb_bougies).
Neutrality Threshold: To avoid false signals in ranging (flat) markets, a neutrality filter is applied (0.01% of the EMA value).
Dashboard Interpretation
The table is located at the top right of your screen and displays three columns:
EMA: The moving average period (e.g., 20, 55).
State:
H (Hausse / Up): The slope is positive and above the threshold.
B (Baisse / Down): The slope is negative and below the negative threshold.
N (Neutre / Neutral): The slope is weak, indicating no clear trend.
COL (Color): Quick visual indicator.
🔵 Blue: Bullish trend.
🟠 Orange: Bearish trend.
⚪ Gray: Neutral Trend / Ranging.
Trading Usage
Trend Confirmation: Use the "Totaux" (Totals) counter at the bottom of the table. If you see 8/8 H (Blue), the bullish trend is strong and aligned across all timeframes (short and medium term).
Reversal Detection: If fast EMAs (20, 25) turn Orange (B) while slow ones (50, 55) are still Blue (H), this may signal the beginning of a correction or a trend reversal.
Adaptive Volatility Stop by Pedro Paulo de MeloStop ATR is a clean and reliable volatility-based trailing stop system, built to adapt dynamically to market conditions using the Average True Range (ATR).
It identifies trend direction, adjusts the stop level using stair-step logic, and automatically flips the stop when price reversals occur.
How it works
Uses ATR × Multiplier to calculate an adaptive volatility buffer
Tracks trend direction internally
Recomputes and repositions the stop when a trend flip is detected
Plots separate lines for bullish and bearish stop states
Works on any market and timeframe (crypto, forex, commodities, indices, stocks)
Why it’s useful
This Stop ATR implementation is extremely stable and visually clean.
It is particularly effective for:
Trend following
Position management
Swing and position trading
Systematic stop placement
Unlike many ATR-based stop versions, this script uses a corrected flip-handling method that prevents stop misalignment and ensures consistent trend state tracking.
Inputs
Period — ATR length
Multiplier — ATR factor that defines stop distance
Author
Developed by Pedro Paulo de Melo, open-source version.
D/W/M RSI & %CHNG + ATRThis indicator provides a comprehensive, at-a-glance dashboard displaying key technical metrics across multiple timeframes: Daily, Weekly, and Monthly. It tracks Price Change Percentage, Relative Strength Index (RSI), and Average True Range (ATR) for each timeframe, helping traders quickly assess market trends, momentum, and volatility in one view.
Key Features:
Price Change % (Daily/Weekly/Monthly):
Displays the percentage change in price over the selected timeframes, giving traders insight into short-term, medium-term, and long-term price movement trends.
Relative Strength Index (RSI):
Shows the RSI value on Daily, Weekly, and Monthly timeframes. The RSI measures momentum, indicating overbought or oversold conditions:
Average True Range (ATR):
Tracks the ATR across multiple timeframes to assess market volatility. Higher ATR values signify more significant price movement (higher volatility), while lower values suggest quieter markets.
This indicator helps traders make informed decisions by quickly visualizing price momentum, market volatility, and possible trend reversals. It's ideal for swing traders, day traders, and long-term investors who need a bird's-eye view of the market across different timeframes.
How to Use:
Add the indicator to your TradingView chart.
Review the Price Change % to see how the market is trending across the selected timeframes.
Use the RSI to identify overbought or oversold conditions.
Check the ATR to assess current market volatility and adjust position sizes accordingly.
Liquidity Heatmap [Eˣ]💧 Liquidity Heatmap - Free Indicator
Overview
The Liquidity Heatmap reveals where stop losses are clustered in the market - the hidden liquidity zones that smart money targets. This indicator automatically identifies Buy-Side Liquidity (BSL) above price and Sell-Side Liquidity (SSL) below price, showing you exactly where institutional traders are likely to hunt for stops before major moves.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🎯 What This Indicator Does
Identifies Liquidity Zones:
• Buy-Side Liquidity (BSL) - Stop losses from SHORT positions clustered above price
• Sell-Side Liquidity (SSL) - Stop losses from LONG positions clustered below price
• Automatically clusters nearby levels into high-probability zones
• Shows liquidity strength (1-5+) - higher numbers = more stops = bigger target
• Removes swept liquidity in real-time as price takes out stops
Visual Display:
• 🔴 Red Zones Above Price = Buy-Side Liquidity (shorts' stops)
• 🟢 Green Zones Below Price = Sell-Side Liquidity (longs' stops)
• Thicker/Darker Zones = Higher liquidity concentration
• BSL/SSL Labels = Show exact strength count
• Triangle Markers = Liquidity sweep alerts (when price takes stops)
Smart Features:
• Auto-removes old liquidity (customizable lookback period)
• Clusters nearby levels to reduce noise
• Tracks liquidity strength and age
• Updates in real-time as new swing points form
• Alerts when major liquidity zones are swept
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 How To Use This Indicator
Understanding Liquidity Concepts
What is Liquidity?
Liquidity refers to clusters of stop loss orders sitting in the market. These stops represent:
• Long traders' stop losses (below support) = Sell-Side Liquidity
• Short traders' stop losses (above resistance) = Buy-Side Liquidity
Why Does This Matter?
• Institutions NEED liquidity to fill large orders
• Price often "sweeps" liquidity zones before reversing
• Major liquidity = major target for smart money
• Understanding liquidity = understanding market maker behavior
The Liquidity Cycle:
1. Retail traders place stops at obvious levels (swing highs/lows)
2. Smart money identifies these clusters
3. Price is pushed to sweep the stops (liquidity grab)
4. Institutions fill their orders with this liquidity
5. Price reverses in the opposite direction
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
💡 Trading Strategies
Strategy 1: Liquidity Sweep Reversals
Best For: Swing trading, catching reversals
Timeframes: 15min, 1H, 4H, Daily
Entry Setup:
1. Identify strong Sell-Side Liquidity (SSL) zone below price
2. Wait for price to sweep down into the SSL zone
3. Look for rejection/reversal candle pattern (pin bar, engulfing)
4. Enter LONG after sweep and reversal confirmation
5. Stop loss: Below the swept liquidity zone
6. Target: Opposite liquidity zone or key resistance
Why It Works: Smart money sweeps stops to fill buy orders, then pushes price higher
Example:
• SSL zone at $45,000 with strength 3
• Price drops to $44,950, sweeps the SSL
• Strong bullish reversal candle forms
• Enter long at $45,100
• Target: BSL zone at $47,000
Strategy 2: Liquidity-to-Liquidity Runs
Best For: Day trading, scalping
Timeframes: 5min, 15min, 1H
Entry Setup:
1. Price sweeps Sell-Side Liquidity below and reverses up
2. Identify Buy-Side Liquidity zone above
3. Enter LONG targeting the BSL zone above
4. Exit near/at the BSL zone (don't wait for sweep)
5. Stop loss: Below recent swing low
Why It Works: Price moves from liquidity pool to liquidity pool
Variation - Reverse for Shorts:
• BSL sweep above → Look for SSL zone below
• Enter short targeting lower liquidity
Strategy 3: Liquidity Avoidance (Stop Placement)
Best For: Improving win rate on existing strategies
Timeframes: All
Rules:
1. NEVER place stops exactly at obvious liquidity zones
2. Place stops beyond the liquidity zone with buffer
3. Or place stops before the liquidity zone (tighter, riskier)
4. Monitor liquidity strength - avoid zones with strength 3+
Why It Works: Market makers hunt obvious stop clusters
Example:
• Trading long, swing low at $100 (SSL zone, strength 4)
• Bad: Stop at $99.50 (will get swept)
• Better: Stop at $98.50 (beyond the liquidity)
• Alternative: Stop at $100.50 (tighter, before sweep zone)
Strategy 4: Confluence Trading
Best For: High probability setups
Timeframes: 1H, 4H, Daily
Entry Setup:
1. Find liquidity zone that aligns with:
• Major support/resistance level
• Fibonacci retracement (0.618, 0.786)
• Trendline
• Round psychological number ($50,000, $2,000, etc)
2. Wait for sweep of this high-confluence zone
3. Enter on reversal with multiple confirmations
4. Larger position size justified by confluence
Why It Works: Multiple factors = institutional interest = higher probability
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚙️ Settings Explained
Core Settings
Swing Detection Length (Default: 10)
• Number of bars left/right to identify swing highs and lows
• Lower values (5-8): More sensitive, more liquidity zones, more noise
• Higher values (12-20): Less sensitive, only major swings, cleaner chart
• Recommended: 8-10 for intraday, 10-15 for swing trading
Liquidity Lookback Bars (Default: 100)
• How many historical bars to track liquidity zones
• Lower values (50-75): Shows only recent liquidity
• Higher values (100-200): Shows longer-term liquidity clusters
• Zones older than this are automatically removed
• Recommended: 100-150 for most timeframes
Zone Proximity % (Default: 0.5)
• Percentage threshold to group nearby levels into single zone
• Lower values (0.2-0.4): Keeps levels separate, more zones
• Higher values (0.6-1.0): Aggressive clustering, fewer zones
• Recommended: 0.4-0.6 for crypto, 0.3-0.5 for forex, 0.5-0.8 for stocks
Visualization Settings
Show Buy-Side Liquidity
• Toggle ON/OFF red zones above price
• Turn OFF if only interested in downside liquidity
Show Sell-Side Liquidity
• Toggle ON/OFF green zones below price
• Turn OFF if only interested in upside liquidity
Show Liquidity Labels
• Toggle BSL/SSL labels with strength numbers
• Turn OFF for cleaner chart appearance
• Keep ON to see exact liquidity strength
Display Style
• Boxes: Filled rectangular zones (best for visualizing strength)
• Lines: Horizontal dashed lines (minimal, clean look)
• Both: Boxes + Lines (maximum visibility)
Color Intensity
• Low: 85% transparency (subtle, less distracting)
• Medium: 75% transparency (balanced visibility)
• High: 65% transparency (bold, maximum visibility)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📱 Info Panel Guide
Located in the top-right corner, the info panel provides real-time liquidity statistics:
Buy-Side Zones
• Count of active BSL zones above current price
• Higher number = More upside targets for price
Sell-Side Zones
• Count of active SSL zones below current price
• Higher number = More downside targets for price
Total Zones
• Combined count of all active liquidity
• Useful for gauging overall market structure
Nearest BSL
• Distance in % to closest Buy-Side Liquidity above
• Example: +2.5% means BSL is 2.5% above current price
• Quick reference for next upside target
Nearest SSL
• Distance in % to closest Sell-Side Liquidity below
• Example: -1.8% means SSL is 1.8% below current price
• Quick reference for next downside target
Liquidity Bias
• ⬆️ Bullish : More BSL than SSL (upside targets dominate)
• ⬇️ Bearish : More SSL than BSL (downside targets dominate)
• ↔️ Balanced: Equal liquidity on both sides (range-bound)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🎓 Understanding Liquidity Strength
What Do The Numbers Mean?
Strength 1 : Single swing point
• Light liquidity, minor target
• Can be ignored in trending markets
• Useful in ranging/choppy conditions
Strength 2-3 : Moderate liquidity cluster
• Multiple nearby swing points merged
• Decent target for intraday moves
• Watch for potential sweeps
Strength 4-5 : Strong liquidity cluster
• Major cluster of stops
• High-probability target for institutions
• Expect reactions when swept
Strength 6+ : Extreme liquidity pool
• Massive stop cluster (rare)
• Critical zone - high probability of sweep
• Often marks major support/resistance
• Ideal for confluence setups
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📱 Alert Setup
This indicator includes 2 powerful alert types:
1. Buy-Side Liquidity Sweep
• Triggers when price sweeps BSL zone above
• Shows potential bullish reversal opportunity
• Often precedes upward continuation after sweep
2. Sell-Side Liquidity Sweep
• Triggers when price sweeps SSL zone below
• Shows potential bearish reversal opportunity
• Often precedes downward continuation after sweep
To Set Up Alerts:
1. Click the "Alert" button (clock icon) in TradingView
2. Condition: Select "Liquidity Heatmap"
3. Choose alert type: BSL Sweep or SSL Sweep
4. Configure notification method (push, email, webhook)
5. Click "Create"
Pro Tip: Set alerts for both BSL and SSL sweeps to catch opportunities in both directions
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
💎 Pro Tips & Best Practices
✅ DO:
• Wait for confirmation - Don't enter immediately on sweep, wait for reversal pattern
• Combine with trend - SSL sweeps in uptrends = higher probability longs
• Check multiple timeframes - 1H liquidity + 4H liquidity = strongest zones
• Monitor strength - Focus on zones with strength 3+
• Use proper risk management - Liquidity sweeps can go further than expected
• Watch for re-sweeps - Sometimes liquidity zones get swept multiple times
• Consider volume - High volume sweeps = stronger reversal potential
⚠️ DON'T:
• Don't fade strong trends - In strong trends, sweeps often continue rather than reverse
• Don't overtrade - Not every sweep is a tradeable setup
• Don't ignore context - Check broader market conditions and news
• Don't use alone - Combine with price action, support/resistance, and other analysis
• Don't place stops at liquidity - Your stops will be hunted
• Don't expect perfection - Some sweeps fail, some zones never get hit
🎯 Best Timeframes:
• Scalping: 5min, 15min (fast moves, frequent sweeps)
• Day Trading: 15min, 1H (balanced view)
• Swing Trading: 1H, 4H, Daily (major liquidity zones)
• Position Trading: 4H, Daily, Weekly (institutional liquidity)
🔥 Best Markets:
• Crypto (high volatility, frequent liquidity grabs)
• Forex (EUR/USD, GBP/USD - liquid pairs)
• Futures (ES, NQ, CL - high liquidity contracts)
• Stocks (large caps with high volume)
⏰ Best Times:
• Market opens (high volatility = liquidity hunting)
• Before/after major news events
• Session overlaps (London/NY for forex)
• First hour and last hour of trading
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🚀 What Makes This Different?
Unlike basic pivot indicators, the Liquidity Heatmap:
• Institutional Perspective - Shows where smart money hunts stops
• Dynamic Clustering - Automatically groups nearby levels for clarity
• Strength Tracking - Not just where, but HOW MUCH liquidity exists
• Auto-Cleanup - Removes swept and old liquidity automatically
• Visual Clarity - Instant understanding of market structure
• Actionable - Clear targets and reversal zones for trading
• Real-Time Updates - Adapts as market structure evolves
Based On Professional Concepts:
• Order flow analysis
• Market maker behavior
• Institutional trading techniques
• Liquidity engineering principles
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📈 Common Liquidity Patterns
Pattern 1: The Double Sweep
• Price sweeps SSL below, reverses up
• Price sweeps BSL above, reverses down
• Back to original range
• Trading: Fade the second sweep for mean reversion
Pattern 2: The Cascade
• Multiple SSL zones stacked below
• Price sweeps first zone, continues to next
• Chain reaction of stop losses triggering
• Trading: Ride the momentum to lowest zone
Pattern 3: The Fake-Out
• Price approaches liquidity but doesn't quite sweep
• Reverses before hitting the zone
• "Scared money" didn't wait for full sweep
• Trading: Wait for actual sweep, don't anticipate
Pattern 4: The Absorption
• Price sweeps major liquidity zone (strength 5+)
• No reversal, just consolidation
• Institutions absorbed all liquidity
• Trading: Wait for breakout direction, likely continuation
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📈 Upgrade Your Trading Arsenal
This free indicator gives you institutional-level liquidity analysis. Want more?
🔥 Check out my premium scripts for:
• Automated entry signals with liquidity confirmation
• Multi-timeframe liquidity analysis
• Advanced stop loss management that avoids liquidity zones
• Backtested strategies with performance tracking
• Custom alerts for high-probability setups
• And much more...
👉 Visit my profile to see all available tools!
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📝 Important Notes
• Liquidity analysis is one piece of the puzzle - use with other analysis methods
• Not all liquidity zones get swept - some remain untouched
• Market conditions change - adapt your strategy accordingly
• Always use proper position sizing and risk management
• Liquidity sweeps can be violent - use appropriate stop losses
• Practice on demo accounts before trading with real capital
• Past liquidity patterns don't guarantee future price action
Disclaimer: This indicator is for educational purposes. Trading involves risk. Always do your own research and never risk more than you can afford to lose.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🙏 Support This Work
If you find this indicator valuable:
• ⭐ Give it a thumbs up
• 💬 Share your best liquidity sweep trades in the comments
• 🔔 Follow for more free professional-grade tools
• 🚀 Share with traders who need to understand liquidity
Got questions? Drop a comment and I'll help you master liquidity trading!
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Developed with ❤️ for traders who want to think like institutions
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Version History
• v1.0 - Initial release with dynamic liquidity detection and clustering
GLI / Asset Structural Trend RatioBasicly I asked AI to create a GLI to Asset trend ratio indicator.
Squeeze Momentum OmniViewSqueeze Momentum OmniView+ is an enhanced and modernized version of the classic Squeeze Momentum Indicator by LazyBear, rebuilt from the ground up in Pine Script v6.
This upgraded edition introduces OmniView color-mapping, adaptive histogram scaling, extreme detection, heat-zone alerts, and dynamic fire/ice icons, all fully synchronized with your selected visualization mode.
Key Features
1. OmniView Color Engine (Exact Price-State Matching)
Reproduces the full OmniView color logic (aqua → yellow → red), tracking market compression, expansion, and directional strength using a seamless multi-gradient system.
2. Dual Histogram Modes
Choose how the histogram is normalized:
Price-State Mode: Colors reflect price position within its recent range.
Self-Normalized Mode: Colors adapt to the histogram’s own momentum curve.
Both modes automatically adjust alerts, extremes, and icons.
3. Enhanced Squeeze Logic
The script includes the classic squeeze states (ON / OFF / Neutral) with clean visual dots and improved logic for precise state transitions.
4. Adaptive Extreme Detection (Upper & Lower Extremes)
Detects when price or momentum sets new highs/lows according to the active mode.
Automatically draws 🔥 fire labels near upper extremes and ❄️ ice labels near lower extremes, with:
Adaptive or fixed offsets
Customizable sizes
Optional dimming on momentum fade
Icon colors matching the histogram
5. Full Alert Suite
Includes alerts for:
New Upper / Lower Extremes
Heat-Zone Crossings (25%, 50%, 75%)
Momentum Turning Up / Down
Zero-Line Crossovers
Squeeze ON / OFF
All alert conditions adapt dynamically to the mode selected.
6. Clean, modern, and fully customizable
Every visual element—colors, transparency, icon sizing, offsets, squeeze dots, fades—can be adjusted from the settings panel.
What This Indicator Helps You See
Momentum acceleration and deceleration
Market compression/expansion phases
Heat levels in the current price context
Momentum extremes that often signal turning points
Trend continuation or exhaustion patterns
High-precision squeeze entries with visual clarity
Designed For
Traders looking for a more intelligent version of Squeeze Momentum with:
Better visual clarity
Stronger adaptive behavior
More actionable alerts
More information per bar without clutter
A special thanks to LazyBear, the original author of the Squeeze Momentum engine.
This script is not affiliated with or endorsed by him, but it extends his outstanding contribution to the TradingView community.
MACD Momentum Pro MACD Momentum Pro is an enhanced version of the classic MACD designed to help traders identify momentum strength with far greater clarity.
In addition to the traditional MACD line, Signal line, and histogram, this tool introduces two new momentum-intensity alerts:
• Strong Green – bullish momentum accelerating above the zero line
• Strong Red – bearish momentum accelerating below the zero line
These conditions allow traders to quickly spot when market pressure is truly strengthening, reducing noise and improving decision-making in trending environments.
The indicator also includes real-time alerts for:
• MACD/Signal crosses (bullish & bearish)
• MACD zero-line crosses
• Shifts between rising/falling histogram states
All moving averages (EMA or SMA) are fully customizable, and the visual histogram automatically adapts color to reflect momentum transitions.
Whether you are trading breakouts, trend reversals, or momentum continuation setups, this upgraded MACD version provides a clearer, more actionable view of market strength—while keeping the original MACD logic intact.
AKP Momentum TableThe table give at one glance the RSI,ADX and Relative Strength values on the 15 min,125 min, Daily,Weekly and Monthly timeframes to help identify the stocks with strong momentum securities. The Table is movable at various parts of the screen from a drop down menu and the values of RSI,ADX and RS period can also be changes.Enjoy!
CEF (Chaos Theory Regime Oscillator)Chaos Theory Regime Oscillator
This script is open to the community.
What is it?
The CEF (Chaos Entropy Fusion) Oscillator is a next-generation "Regime Analysis" tool designed to replace traditional, static momentum indicators like RSI or MACD. Unlike standard oscillators that only look at price changes, CEF analyzes the "character" of the market using concepts from Chaos Theory and Information Theory.
It combines advanced mathematical engines (Hurst Exponent, Entropy, VHF) to determine whether a price movement is a real trend or just random noise. It uses a novel "Adaptive Normalization" technique to solve scaling problems common in advanced indicators, ensuring the oscillator remains sensitive yet stable across all assets (Crypto, Forex, Stocks).
What It Promises:
Intelligent Filtering: Filters out false signals in sideways (volatile) markets using the Hurst Base to measure trend continuity.
Dynamic Adaptation: Automatically adapts to volatility. Thanks to trend memory, it doesn't get stuck at the top during uptrends or at the bottom during downtrends.
No Repainting: All signals are confirmed at the close of the bar. They don't repaint or disappear.
What It Doesn't Promise:
Magic Wand: It's a powerful analytical tool, not a crystal ball. It determines the regime, but risk management is up to the investor.
Late-Free Holy Grail: It deliberately uses advanced correction algorithms (WMA/SMA) to provide stability and filter out noise. Speed is sacrificed for accuracy.
Which Concepts Are Used for Which Purpose?
CEF is built on proven mathematical concepts while creating a unique "Fusion" mechanism. These are not used in their standard forms, but are remixed to create a consensus engine:
Hurst Exponent: Used to measure the "memory" of the time series. Tells the oscillator whether there is a probability of the trend continuing or reversing to the mean.
Vertical Horizontal Filter (VHF): Determines whether the market is in a trend phase or a congestion phase.
Shannon Entropy: Measures the "irregularity" or "unpredictability" of market data to adjust signal sensitivity.
Adaptive Normalization (Key Innovation): Instead of fixed limits, the oscillator dynamically scales itself based on recent historical performance, solving the "flat line" problem seen in other advanced scripts.
Original Methodology and Community Contribution
This algorithm is a custom synthesis of public domain mathematical theories. The author's unique contribution lies in the "Adaptive Normalization Logic" and the custom weighting of Chaos components to filter momentum.
Why Public Domain? Standard indicators (RSI, MACD) were developed for the markets of the 1970s. Modern markets require modern mathematics. This script is presented to the community to demonstrate how Regime Analysis can improve trading decisions compared to static tools.
What Problems Does It Solve?
Problem 1: The "Stagnant Market" Trap
CEF Solution: While the RSI gives false signals in a sideways market, CEF's Hurst/VHF filter suppresses the signal, essentially making the histogram "off" (or weak) during noise.
Problem 2: The "Overbought" Fallacy
CEF Solution: In a strong trend (Pump/Dump), traditional oscillators get stuck at 100 or 0. CEF uses "Trend Memory" to understand that an overbought price is not a reversal signal but a sign of trend strength, and keeps the signal green/red instead of reversing it prematurely. Problem 3: Visual Confusion
CEF Solution: Instead of multiple lines, it presents a single, color-coded histogram featuring only prominent "Smart Circles" at high-probability reversal points.
Automation Ready: Custom Alerts
CEF is designed for both manual trading and automation.
Smart Buy/Sell Circles: Visual signals that only appear when trend filters are aligned with momentum reversals.
Deviation Labels: Automatically detects and labels structural divergences between price and entropy.
Disclaimer: This indicator is for educational purposes only. Past performance does not guarantee future results. Always practice appropriate risk management.
Trend Vector Pro v2.0Title: Trend Vector Pro v2.0
👨💻 Developed by: Mohammed Bedaiwi
💡 Strategy Overview & Coherence
Trend Vector Pro (TVPro) is a momentum-based trend & reversal strategy that uses a custom smoothed oscillator, an optional ADX filter, and classic Pivot Points to create a single, coherent trading framework.
Instead of stacking random indicators, TVPro is built around these integrated components:
A custom momentum engine (signal generation)
An optional ADX filter (trend quality control)
Daily Pivot Points (context, targets & S/R)
Swing-based “Golden Bar” trailing stops (trade management)
Optional extended bar detection (overextension alerts)
All parts are designed to work together and are documented below to address originality & usefulness requirements.
🔍 Core Components & Justification
1. Custom Momentum Engine (Main Signal Source)
TVPro’s engine is a custom oscillator derived from the bar midpoint ( hl2 ), similar in spirit to the Awesome Oscillator but adapted and fully integrated into the strategy. It measures velocity and acceleration of price, letting the script distinguish between strong impulses, weakening trends, and pure noise.
2. ADX Filter (Trend Strength Validation – Optional)
Uses Average Directional Index (ADX) as a gatekeeper.
Why this matters: This prevents the strategy from firing signals in choppy, non-trending environments (when ADX is below the threshold) and keeps trades focused on periods of clear directional strength.
3. Classic Pivot Points (Context & Targets)
Calculates Daily Pivot Points ( PP, R1-R3, S1-S3 ) via request.security() using prior session data.
Why this matters: Momentum gives the signal, ADX validates the environment, and Pivots add external structure for risk and target planning. This is a designed interaction, not a random mashup.
🧭 Trend State Logic (5-State Bar Coloring)
The strategy uses the momentum's value + slope to define five states, turning the chart into a visual momentum map:
🟢 STRONG BULL (Bright Green): Momentum accelerating UP. → Strong upside impulse.
🌲 WEAK BULL (Dark Green): Momentum decelerating DOWN (while positive). → Pullback/pause zone.
🔴 STRONG BEAR (Bright Red): Momentum accelerating DOWN. → Strong downside impulse.
🍷 WEAK BEAR (Dark Red): Momentum decelerating UP (while negative). → Rally/short-covering zone.
🔵 NEUTRAL / CHOP (Cyan): Momentum is near zero (based on noise threshold). → Consolidation / low volatility.
🎯 Signal Logic Modes
TVPro provides two selectable entry styles, controlled by input:
Reversals Only (Cleaner Mode – Default): Targets trend flips. Entry triggers when the current state is Bullish (or Bearish) and the previous state was not. This reduces noise and over-trading.
All Strong Pulses (Aggressive Mode): Targets acceleration phases. Entry triggers when the bar turns to STRONG BULL or STRONG BEAR after any other state. This mode produces more trades.
📌 Risk Management Tools
Golden Bars – Trailing Stops: Yellow “Trail” Arrows mark confirmed Swing Highs/Lows. These are used as logical trailing stop levels based on market structure.
Extended Bars: Detects when price closes outside a 2-standard-deviation channel, flagging overextension where a pullback is more likely.
Pivot Points: Used as external targets for Take Profit and structural stop placement.
⚙️ Strategy Defaults (Crucial for Publication Compliance)
To keep backtest results realistic and in line with House Rules, TVPro is published with the following fixed default settings:
Order Size: 5% of equity per trade ( default_qty_value = 5 )
Commission: 0.04% per order ( commission_value = 0.04 )
Slippage: 2 ticks ( slippage = 2 )
Initial Capital: 10,000
📘 How to Trade with Trend Vector Pro
Entry: Take Long when a Long signal appears and confirm the bar is Green (Bull state). Short for Red (Bear state).
Stop Loss: Place the initial SL near the latest swing High/Low, or near a relevant Pivot level.
Trade Management: Follow Golden (Trail) Arrows to trail your stop behind structure.
Exits: Exit when: the trailing stop is hit, Price reaches a major Pivot level, or an opposite signal prints.
🛑 Disclaimer
This script is for educational purposes only and does not constitute financial advice. Past performance does not guarantee future results. Always forward-test and use proper risk management before applying any strategy to live trading.
