← Script Vault

Strategy & Alerts | Published 2025-11-30

Superior Range Bound Renko

A range-based Renko strategy with volatility-aware filters and built-in risk management. Includes separate versions for backtesting and automation alerts.

Superior Range Bound Renko chart screenshot
Superior Range Bound Renko strategy performance screenshot
Historical backtest screenshot. Past performance doesn't guarantee future results.

Strategy

Superior-Range Bound Renko Strategy with Advanced Risk Management Template

Signal Lynx | Free Scripts supporting Automation for the Night-Shift Nation 🌙

1. Overview

Superior Range Bound Renko (RBR) is a swing-trading system that uses price structure and volatility, along with Signal Lynx's risk-management template.

Instead of relying on static lookbacks (like “14-period RSI”) or plain MA crosses, Superior RBR:

Adapts its range definition to market volatility in real time

Emulates Renko Bricks on a standard, time-based chart (no Renko chart type required)

Uses a stack of Laguerre Filters to detect genuine impulse vs. noise

Adds an Adaptive SuperTrend powered by a small k-means-style clustering routine on volatility

Under the hood, this script also includes the full Signal Lynx Risk Management Engine:

A state machine that separates “Signal” from “Execution”

Layered exit tools: Stop Loss, Trailing Stop, Staged Take Profit, Advanced Adaptive Trailing Stop (AATS), and an RSI-style stop (RSIS)

Designed for non-repainting behavior on closed candles by basing execution-critical logic on previous-bar data

We're publishing this as an open-source template so traders and developers can leverage a professional-grade RM engine while integrating their own signal logic if they wish.

2. Quick Action Guide (TL;DR)

Best Timeframe: 4 Hours (H4) and above. This is a high-conviction swing-trading system, not a scalper.

Best Assets: Volatile instruments that still respect market structure: Bitcoin, Ethereum, Gold (XAUUSD), high-volatility Forex pairs (e.g., GBPJPY), indices with clean ranges.

Strategy Type: Volatility-Adaptive Trend Following + Impulse Detection. It hunts for genuine expansion out of ranges, not tiny mean-reversion nibbles.

Key Feature: Renko Emulation on time-based candles. We mathematically model Renko Bricks and overlay them on your standard chart to define:

“Equilibrium” zones (inside the brick structure)

“Breakout / impulse” zones (when price AND the impulse line depart from the bricks)

Repainting: Designed to be non-repainting on closed candles. All RM execution logic uses confirmed historical data (no future bars, no security() lookahead). Intrabar flicker during formation is allowed, but once a bar closes the engine’s decisions are stable.

Core Toggles & Filters:

Enable Longs and Shorts independently

Optional Weekend filter (block trades on Saturday/Sunday)

Per-module toggles: Stop Loss, Trailing Stop, Staged Take Profits, AATS, RSIS

3. Detailed Report: How It Works A. The Strategy Logic: Superior RBR

Superior RBR builds its entry signal from multiple mathematical layers working together.

1) Adaptive Lookback (Volatility Normalization)

Instead of a fixed 100-bar or 200-bar range, the script:

Computes ATR-based volatility over a user-defined period.

Normalizes that volatility relative to its recent min/max.

Maps the normalized value into a dynamic lookback window between a minimum and maximum (e.g., 4 to 100 bars).

High Volatility: The lookback shrinks, so the system reacts faster to explosive moves.

Low Volatility: The lookback expands, so the system sees a “bigger picture” and filters out chop.

All the core “Range High/Low” and “Range Close High/Low” boundaries are built on top of this adaptive window.

2) Range Construction & Quick Ranges

The engine constructs several nested ranges:

Outer Range:

rangeHighFinal: dynamic highest high

rangeLowFinal: dynamic lowest low

Inner Close Range:

rangeCloseHighFinal: highest close

rangeCloseLowFinal: lowest close

Quick Ranges: “Half-length” variants of those, used to detect more responsive changes in structure and volatility.

These ranges define:

The macro box price is trading inside

Shorter-term “pressure zones” where price is coiling before expansion

3) Renko Emulation (The Bricks)

Rather than using the Renko chart type (which discards time), this script emulates Renko behavior on your normal candles:

A “brick size” is defined either:

As a standard percentage move, or

As a volatility-driven (ATR) brick, optionally inhibited by a minimum standard size

The engine tracks a base value and derives:

brickUpper: top of the emulated brick

brickLower: bottom of the emulated brick

When price moves sufficiently beyond those levels, the brick “shifts”, and the directional memory (renkoDir) updates:

renkoDir = +2 when bricks are advancing upward

renkoDir = -2 when bricks are stepping downward

You can think of this as a synthetic Renko tape overlaid on time-based candles:

Inside the brick: equilibrium / consolidation

Breaking away from the brick: momentum / expansion

4) Impulse Tracking with Laguerre Filters

The script uses multiple Laguerre Filters to smooth price and brick-derived data without traditional lag.

Key filters include:

LagF_1 / LagF_W: Based on brick upper/lower baselines

LagF_Q: Based on HLCC4 (high + low + 2×close)/4

LagF_Y / LagF_P: Complex averages combining brick structures and range averages

LagF_V (Primary Impulse Line): A smooth, high-level impulse line derived from a blend of the above plus the outer ranges

Conceptually:

When the impulse line pushes away from the brick structure and continues in one direction, an impulse move is underway.

When its direction flips and begins to roll over, the impulse is fading, hinting at mean reversion back into the range.

5) Fib-Based Structure & Swaps

The system also layers in Fib levels derived from the adaptive ranges:

Standard levels (12%, 23.6%, 38.2%, 50%, 61%, 76.8%, 88%) from the main range

A secondary “swap” set derived from close-range dynamics (fib12Swap, fib23Swap, etc.)

These Fibs are used to:

Bucket price into structural zones (below 12, between 23 to 38, etc.)

Detect breakouts when price and Laguerre move beyond key Fib thresholds

Drive zSwap logic (where a secondary Fib set becomes the active structure once certain conditions are met)

6) Adaptive SuperTrend with K-Means-Style Volatility Clustering

Under the hood, the script uses a small k-means-style clustering routine on ATR:

ATR is measured over a fixed period

The range of ATR values is split into Low, Medium, High volatility centroids

Current ATR is assigned to the nearest centroid (cluster)

From that, a SuperTrend variant (STK) is computed with dynamic sensitivity:

In quiet markets, SuperTrend can afford to be tighter

In wild markets, it widens appropriately to avoid constant whipsaw

This SuperTrend-based oscillator (LagF_K and its signals) is then combined with the brick and Laguerre stack to confirm valid trend regimes.

7) Final Baseline Signals (+2 / -2)

The “brain” of Superior RBR lives in the Baseline & Signal Generation block:

Two composite signals are built: B1 and B2:

They combine:

Fib breakouts

Renko direction (renkoDir)

Expansion direction (expansionQuickDir)

Multiple Laguerre alignments (LagF_Q, LagF_W, LagF_Y, LagF_Z, LagF_P, LagF_V)

They also factor in whether Fib structures are expanding or contracting.

A user toggle selects the “Baseline” signal:

finalSig = B2 (default) or B1 (alternate baseline)

finalSig is then filtered through the RM state machine and only when everything aligns, we emit:

+2 = Long / Buy signal

-2 = Short / Sell signal

0 = No new trade

Those +2 / -2 values are what feed the Risk Management Engine.

B. The Risk Management (RM) Engine

This script features the Signal Lynx Risk Management Engine, a proprietary state machine built to separate Signal from Execution.

Instead of firing orders directly on indicator conditions, we:

Convert the raw signal into a clean integer (Fin = +2 / -2 / 0)

Feed it into a Trade State Machine that understands:

Are we flat?

Are we in a long or short?

Are we in a closing sequence?

Should we permit re-entry now or wait?

Logic Injection / Template Concept:

The RM engine expects a simple integer:

+2 → Buy

-2 → Sell

Everything else (0) is “no new trade”

This makes the script a template:

You can remove the Superior RBR block

Drop in your own logic (RSI, MACD, price action, etc.)

As long as you output +2 or -2 into the same signal channel, the RM engine can drive all exits and state transitions.

Aggressive vs Conservative Modes:

The input AgressiveRM (Aggressive RM) governs how we interpret signals:

Conservative Mode (Aggressive RM = false):

Uses a more filtered internal signal (AF) to open trades

Effectively waits for a clean trend flip / confirmation before new entries

Minimizes whipsaw at the cost of fewer trades

Aggressive Mode (Aggressive RM = true):

Reacts directly to the fresh alert (AO) pulses

Allows faster re-entries in the same direction after RM-based exits

Still respects your pyramiding setting; this script ships with pyramiding = 0 by default, so it will not stack multiple positions unless you change that parameter in the strategy() call.

The state machine enforces discipline on top of your signal logic, reducing double-fires and signal spam.

C. Advanced Exit Protocols (Layered Defense)

The exit side is where this template really shines. Instead of a single “take profit or stop loss,” it uses multiple, cooperating layers.

1) Hard Stop Loss

A classic percentage-based Stop Loss (SL) relative to the entry price.

Acts as a final “catastrophic protection” layer for unexpected moves.

2) Standard Trailing Stop

A percentage-based Trailing Stop (TS) that:

Activates only after price has moved a certain percentage in your favor (tsActivation)

Then trails price by a configurable percentage (ts)

This is a straightforward, battle-tested trailing mechanism.

3) Staged Take Profits (Three Levels)

The script supports three staged Take Profit levels (TP1, TP2, TP3):

Each stage has:

Activation percentage (how far price must move in your favor)

Trailing amount for that stage

Position percentage to close

Example setup:

TP1:

Activate at +10%

Trailing 5%

Close 10% of the position

TP2:

Activate at +20%

Trailing 10%

Close another 10%

TP3:

Activate at +30%

Trailing 5%

Close the remaining 80% (“runner”)

You can tailor these quantities for partial scaling out vs. letting a core position ride.

4) Advanced Adaptive Trailing Stop (AATS)

AATS is a sophisticated volatility- and structure-aware stop:

Uses Hirashima Sugita style levels (HSRS) to model “floors” and “ceilings” of price:

Dungeon → Lower floors → Mid → Upper floors → Penthouse

These levels classify where current price sits within a long-term distribution.

Combines HSRS with Bollinger-style envelopes and EMAs to determine:

Is price extended far into the upper structure?

Is it compressed near the lower ranges?

From this, it computes an adaptive factor that controls how tight or loose the trailing level (aATS / bATS) should be:

High Volatility / Penthouse areas:

Stop loosens to avoid getting wicked out by inevitable spikes.

Low Volatility / compressed structure:

Stop tightens to lock in and protect profit.

AATS is designed to be the “smart last line” that responds to context instead of a single fixed percentage.

5) RSI-Style Stop (RSIS)

On top of AATS, the script includes a RSI-like regime filter:

A McGinley Dynamic mean of price plus ATR bands creates a dynamic channel.

Crosses above the top band and below the lower band change a directional state.

When enabled (UseRSIS):

RSIS can confirm or veto AATS closes:

For longs: A shift to bearish RSIS can force exits sooner.

For shorts: A shift to bullish RSIS can do the same.

This extra layer helps avoid over-reactive stops in strong trends while still respecting a regime change when it happens.

D. Repainting Protection

Many strategies look incredible in the Strategy Tester but fail in live trading because they rely on intrabar values or future-knowledge functions.

This template is built with closed-candle realism in mind:

The Risk Management logic explicitly uses previous bar data (open[1], high[1], low[1], close[1]) for the key decisions on:

Trailing stop updates

TP triggers

SL hits

RM state transitions

No security() lookahead or future-bar access is used.

This means:

Backtest behavior is designed to match what you can actually get with TradingView alerts and live automation.

Signals may “flicker” intrabar while the candle is forming (as with any strategy), but on closed candles, the RM decisions are stable and non-repainting.

4. For Developers & Modders

We strongly encourage you to mod this script.

To plug your own strategy into the RM engine:

Look for the section titled: // BASELINE & SIGNAL GENERATION

You'll see composite logic building B1 and B2, and then selecting:

baseSig = B2 altSig = B1 finalSig = sigSwap ? baseSig : altSig

You can replace the content used to generate baseSig / altSig with your own logic, for example:

RSI crosses

MACD histogram flips

Candle pattern detectors

External condition flags

Requirements are simple:

Your final logic must output:

2 → Buy signal

-2 → Sell signal

0 → No new trade

That output flows into the RM engine via finalSig → AlertOpen → state machine → Fin.

Once you wire your signals into finalSig, the entire Risk Management system (Stops, TPs, AATS, RSIS, re-entry logic, weekend filters, long/short toggles) becomes available for your custom strategy without re-inventing the wheel.

This makes Superior RBR not just a strategy, but a reference architecture for serious Pine dev work.

5. About Signal Lynx

Automation for the Night-Shift Nation 🌙

Signal Lynx focuses on helping traders and developers bridge the gap between indicator logic and real-world automation. The same RM engine you see here powers multiple internal systems and templates, including other public scripts like the Super-AO Strategy with Advanced Risk Management.

We share this code under the Mozilla Public License 2.0 (MPL-2.0) because we want to:

Demonstrate how Adaptive Logic and structured Risk Management can outperform static, one-layer indicators

Give Pine Script users a battle-tested RM backbone they can reuse, remix, and extend

If you're looking to automate TradingView strategies, route signals to exchanges, or improve your risk-management setup, check out Signal Lynx.

License: Mozilla Public License 2.0 (Open Source). If you make beneficial modifications, please consider releasing them back to the community so everyone can benefit.

Alerts

Superior Range Bound Renko Alerts Edition with Advanced Risk Management

Signal Lynx | Free Scripts supporting Automation for the Night-Shift Nation 🌙

1. Overview

This is the Alerts & Indicator Edition of Superior-Range Bound Renko (RBR).

The Strategy version is built for backtesting inside TradingView.

This Alerts version is built for automation: it emits clean, discrete alert events that you can route into webhooks, bots, or relay engines (including your own Signal Lynx-style infrastructure).

Under the hood, this script contains the same core engine as the strategy:

Adaptive Range Bounding based on volatility

Renko Brick Emulation on standard candles

A stack of Laguerre Filters for impulse detection

K-Means-style Adaptive SuperTrend for trend confirmation

The full Signal Lynx Risk Management Engine (state machine, layered exits, AATS, RSIS, etc.)

The difference is in what we output:

Instead of placing historical trades, this version:

Plots the entry and RM signals in a separate pane (overlay = false)

Exposes alertconditions for:

Long Entry

Short Entry

Close Long

Close Short

TP1, TP2, TP3 hits (Staged Take Profit)

This makes it ideal as the signal source for automated execution via TradingView Alerts + Webhooks.

2. Quick Action Guide (TL;DR)

Best Timeframe: 4H and above. This is a swing-trading / position-trading style engine, not a micro-scalper.

Best Assets: Volatile but structured markets, e.g.: BTC, ETH, XAUUSD (Gold), GBPJPY, and similar high-volatility majors or indices.

Script Type: indicator(): Alerts & Visualization Only

No built-in order placement

All “orders” are emitted as alerts for your external bot or manual handling

Strategy Type: Volatility-Adaptive Trend Following + Impulse Detection using Renko-like structure and multi-layer Laguerre filters.

Repainting: Designed to be non-repainting on closed candles. The underlying Risk Management engine is built around previous-bar data (close[1], high[1], low[1]) for execution-critical logic. Intrabar values can move while the bar is forming (normal for any advanced signal), but once a bar closes, the alert logic is stable.

Recommended Alert Settings:

Condition: one of the built-in signals (see section 3.B)

Options: “Once Per Bar Close” is strongly recommended for automation

Message: JSON, CSV, or simple tokens, depending on what your webhook or relay expects

3. Detailed Report: How the Alerts Edition Works A. Relationship to the Strategy Version

The Alerts Edition shares the same internal logic as the strategy version:

Same Adaptive Lookback and volatility normalization

Same Range and Close Range construction

Same Renko Brick Emulator and directional memory (renkoDir)

Same Fib structures, Laguerre stack, K-Means SuperTrend, and Baseline signals (B1, B2)

Same Risk Management Engine and layered exits

In the strategy script, these signals are wired into strategy.entry, strategy.exit, and strategy.close.

In the alerts script:

We still compute the final entry/exit signals (Fin, CloseEmAll, TakeProfit1Plot, etc.)

Instead of placing trades, we:

Plot them for visual inspection

Expose them via alertcondition(...) so that TradingView can fire alerts.

This ensures that:

If you use the same settings on the same symbol/timeframe, the Alerts Edition and Strategy Edition agree on where entries and exits occur. (Subject only to normal intrabar vs. bar-close differences.)

B. Signals & Alert Conditions

The alerts script focuses on discrete, automation-friendly events.

Internally, the main signals are:

Fin: Final entry decision from the RM engine

CloseEmAll: RM-driven “hard close” signal (for full-position exits)

TakeProfit1Plot / 2Plot / 3Plot: One-time event markers when each TP stage is hit

On the chart (in the separate indicator pane), you get:

plot(Fin): where:

+2 = Long Entry event

-2 = Short Entry event

plot(CloseEmAll): where:

+1 = “Close Long” event

-1 = “Close Short” event

plot(TP1/TP2/TP3) (if Staged TP is enabled): integer tags for TP hits:

+1 / +2 / +3 = TP1 / TP2 / TP3 for Longs

-1 / -2 / -3 = TP1 / TP2 / TP3 for Shorts

The corresponding alertconditions are:

Long Entry

alertcondition(Fin == 2, title="Long Entry", message="Long Entry Triggered")

Fire this to open/scale a long position in your bot.

Short Entry

alertcondition(Fin == -2, title="Short Entry", message="Short Entry Triggered")

Fire this to open/scale a short position.

Close Long

alertcondition(CloseEmAll == 1, title="Close Long", message="Close Long Triggered")

Fire this to fully exit a long position.

Close Short

alertcondition(CloseEmAll == -1, title="Close Short", message="Close Short Triggered")

Fire this to fully exit a short position.

TP 1 Hit

alertcondition(TakeProfit1Plot != 0, title="TP 1 Hit", message="TP 1 Level Reached")

First staged take profit hit (either long or short). Your bot can interpret the direction based on position state or message tags.

TP 2 Hit

alertcondition(TakeProfit2Plot != 0, title="TP 2 Hit", message="TP 2 Level Reached")

TP 3 Hit

alertcondition(TakeProfit3Plot != 0, title="TP 3 Hit", message="TP 3 Level Reached")

Together, these give you a complete trade lifecycle:

Open Long / Short

Optionally scale out via TP1/TP2/TP3

Close remaining via Close Long / Close Short

All while the Risk Management Engine enforces the same logic as the strategy version.

C. Using This Script for Automation

This Alerts Edition is designed for:

Webhook-based bots

Execution relays (e.g., your own Lynx-Relay-style engine)

Dedicated external trade managers

Typical setup flow:

Add the script to your chart

Same symbol, timeframe, and settings you use in the Strategy Edition backtests.

Configure Inputs:

Longs / Shorts enabled

Risk Management toggles (SL, TS, Staged TP, AATS, RSIS)

Weekend filter (if you don't want weekend trades)

RBR-specific knobs (Adaptive Lookback, Brick type, ATR vs Standard Brick, etc.)

Create Alerts for Each Event Type You Need:

Long Entry

Short Entry

Close Long

Close Short

TP1 / TP2 / TP3 (optional, if your bot handles partial closes)

For each:

Condition: the corresponding alertcondition

Option: “Once Per Bar Close” is strongly recommended

Message:

You can use structured JSON or a simple token set like: {"side":"long","event":"entry","symbol":"{{ticker}}","time":"{{timenow}}"}

or a simpler text for manual trading like: LONG ENTRY | {{ticker}} | {{interval}}

Wire Up Your Bot / Relay:

Point TradingView’s webhook URL to your execution engine

Parse the messages and map them into:

Exchange

Symbol

Side (long/short)

Action (open/close/partial)

Size and risk model (this script doesn't position-size for you; it only signals when, not how much.)

Because the alerts come from a non-repainting, RM-backed engine that you’ve already validated via the Strategy Edition, you get a much cleaner automation pipeline.

D. Repainting Protection (Alerts Edition)

The same protections as the Strategy Edition apply here:

Execution-critical logic (trailing stop, TP triggers, SL, RM state changes) uses previous bar OHLC:

open[1], high[1], low[1], close[1]

No security() with lookahead or future-bar dependencies.

This means:

Alerts are designed to fire on states that would have been visible at bar close, not on hypothetical “future history.”

Important practical note:

Intrabar: While a bar is forming, internal conditions can oscillate.

Bar Close: With “Once Per Bar Close” alerts, the fired signal corresponds to the final state of the engine for that candle, matching your Strategy Edition expectations.

4. For Developers & Modders

You can treat this Alerts script as an ”RM + Alert Framework” and inject any signal logic you want.

Where to plug in:

Find the section: // BASELINE & SIGNAL GENERATION

You’ll see how B1 and B2 are built from the RBR stack and then combined:

baseSig = B2 altSig = B1 finalSig = sigSwap ? baseSig : altSig

To use your own logic:

Replace or wrap the code that sets baseSig / altSig with your own conditions:

e.g., RSI, MACD, Heikin Ashi filters, candle patterns, volume filters, etc.

Make sure your final decision is still:

2 → Long / Buy signal

-2 → Short / Sell signal

0 → No trade

finalSig is then passed into the RM engine and eventually becomes Fin, which:

Drives the Long/Short Entry alerts

Interacts with the RM state machine to integrate properly with AATS, SL, TS, TP, etc.

Because this script already exposes alertconditions for key trade events, you don't need to rewire alerts each time. Just make sure your logic feeds into finalSig correctly.

This lets you use the Signal Lynx Risk Management Engine + Alerts wrapper as a drop-in chassis for your own strategies.

5. About Signal Lynx

Automation for the Night-Shift Nation 🌙

Signal Lynx builds tools and templates that help traders move from:

“I have an indicator” → “I have a structured, automatable strategy with real risk management.”

The Superior Range Bound Renko Alerts Edition is the automation companion to the strategy version. It’s designed for:

Traders who backtest with the Strategy version

Then deploy live signals with this Alerts version via webhooks or bots

While relying on the same non-repainting, RM-driven logic

We release this code under the Mozilla Public License 2.0 (MPL-2.0) to support the Pine community with:

Transparent, inspectable logic

A reusable Risk Management template

A reference implementation of advanced adaptive logic + alerts

If you're exploring full-stack automation (TradingView → Webhooks → Exchange / VPS), keep Signal Lynx in your search.

License: Mozilla Public License 2.0 (Open Source). If you build improvements or helpful variants, please consider sharing them back with the community.

Get the Pine Code

Copy the full Pine code or download the .pine file. You don't need an account.

Alerts (Pine Script v6)

Strategy (Pine Script v6)

The source files include their author credits and license notices. Please follow those terms when you reuse the code.