Plugin

Renko Bricks

Renko bricks built from bar closes, fixed or start ATR size: direction, last brick level, new bricks this bar, run length and reversals.

IndicatorNo networkDesktop onlyv1.0.0

Get early access Plugin API documentation Built in indicators

About

Renko draws a brick each time price has moved a fixed distance and ignores time. This plugin follows the classic rules. Bricks are built from closes only. The brick size never changes during a run: either a price distance you set, or ATR(atr_period) times atr_mult measured once, at the first bar where the ATR is known (Wilder's ATR, the same as ctx.ind("atr")), and then fixed. The first brick is measured from the close of that bar (the anchor), and every brick edge sits on the grid anchor + k times the size.

A brick in the same direction needs a close one size beyond the last brick's close. A reversal needs two sizes: a close one size beyond the last brick's open (the classic two brick reversal). One bar can add several bricks, all in the same direction.

Parameters

Name	Type	Default	Range or options	Description
`mode`	choice	`"atr"`	atr, fixed	How the brick size is set: "atr" measures ATR(atr_period) times atr_mult once at the start, "fixed" takes `size`.
`size`	float	`0`		The brick size in price units for mode "fixed" (0.0010 is 10 pips on EURUSD). Must be above 0 there; mode "fixed" with 0 is refused and the call returns None.
`atr_period`	int	`14`	min 1, max 500	Bars in Wilder's ATR for mode "atr".
`atr_mult`	float	`1`	min 0.01, max 50	The brick size as a multiple of that ATR, for mode "atr".

Use it in a strategy

pythonrenko = ctx.plugin_indicator("renko_bricks", "renko", {"mode": "fixed", "size": 0.0010})
if renko is not None and renko.value is not None:
    # Long after two up bricks in a row, out on a reversal down.
    if renko.direction == 1 and renko.run >= 2:
        ctx.signal("LONG")
    elif renko.reversal and renko.direction == -1:
        ctx.signal("EXIT")

The indicator library has this as renko: ctx.ind("renko", mode="atr", atr_length=14, atr_mult=1.0) reads the same bricks (brick_close is the value here), and the chart, Blocks, Rust and the Rust core have it too. This template stays as an example of a plugin indicator.

What it provides

`value`Value	The close of the last brick (its far edge in its direction). None until the first brick.
`brick_open`Value	The open of the last brick, one size behind its close. None until the first brick.
`direction`Value	1 when the last brick went up, -1 when it went down. None until the first brick.
`new_bricks`Value	How many bricks this bar added, 0 for none. None while the size is not known yet.
`run`Value	How many bricks in a row point in the current direction, this bar's bricks included. None until the first brick.
`reversal`Value	True on the bar whose bricks turned the direction (not on the very first brick). False otherwise.
`size`Value	The brick size in price units, fixed for the run. None while the ATR warms up.

When values are known

Bricks form at the close of the bar whose close reaches them and never change afterwards. With mode "atr" nothing forms before the ATR is known (atr_period + 1 bars); the bar that fixes the size is the anchor and makes no brick itself.

Limits

Built from bar closes, not ticks: a move that reverses inside one bar leaves no brick, and on a higher timeframe fewer bricks form than on a tick chart.
The ATR size is measured once at the start, so it depends on where the run starts and does not follow later changes in volatility.
Brick levels are not prices that traded at that moment. Orders still fill at the real bid and ask of the next bar.
A plugin indicator is not drawn on the chart and is not available in Blocks, Pine, Rust or C#; it runs on the run's own instrument only.

Preview

json{
  "brick_open": 1.086,
  "direction": 1,
  "new_bricks": 2,
  "reversal": false,
  "run": 5,
  "size": 0.001,
  "value": 1.087
}

A made-up sample that shows the shape of the output. Not vendor data and not a result.

The code

main.py, the file the app installs.

python"""Renko bricks from bar closes, as a streaming indicator.

Renko draws a brick of a fixed size each time price has moved that far, and
ignores time. The classic rules this plugin follows:

- Bricks are built from closes only (not highs and lows, not ticks).
- The brick size is fixed for the whole run: either a price distance you set
  (mode "fixed"), or ATR(atr_period) times atr_mult measured once, at the first
  bar where the ATR is known, and then never changed (mode "atr"). The ATR is
  Wilder's, the engine's own (the same as ctx.ind("atr")).
- The first brick is measured from the close of the bar where the size became
  known: the anchor. Every brick edge sits on the grid anchor + k * size.
- Continuation needs one brick size beyond the last brick's close; a reversal
  needs two (one size beyond the last brick's open): the classic two brick
  reversal. One bar can add several bricks, all in the same direction.

A strategy reads it through
ctx.plugin_indicator("renko_bricks", "renko", {"mode": "atr", "atr_period": 14}).
Everything a bar produces is final at its close and never changes later.
"""

import math

from orionquant_engine.indicators.core import ATR

# A close within this fraction of a brick of a grid edge counts as on the edge.
# Prices are binary floats: 1.1 + 2 * 0.001 is 1.1020000000000001, so without it
# a close of exactly 1.1020 would miss the second brick of a 10 pip chart.
_EDGE = 1e-7


def _close(bar):
    return float(bar["close"] if isinstance(bar, dict) else bar.close)


class Renko:
    """update(bar) then read value (the last brick's close), brick_open,
    direction, new_bricks, run, reversal and size."""

    def __init__(self, mode="atr", size=0.0, atr_period=14, atr_mult=1.0):
        if mode not in ("atr", "fixed"):
            raise ValueError('mode must be "atr" or "fixed"')
        self.mode = mode
        self.atr_mult = float(atr_mult)
        self._atr = ATR(max(1, int(atr_period))) if mode == "atr" else None
        self.size = None
        if mode == "fixed":
            if float(size) <= 0:
                raise ValueError("a fixed brick size must be above 0")
            self._fixed = float(size)
        self._anchor = None
        self._index = 0  # the last brick's close is anchor + index * size

        self.direction = None
        self.new_bricks = None
        self.run = None
        self.reversal = None

    # --- the grid ---------------------------------------------------------------

    def _level(self, k):
        return self._anchor + k * self.size

    def _floor(self, close):
        """The highest grid index whose level is at or below close."""
        return math.floor((close - self._anchor) / self.size + _EDGE)

    def _ceil(self, close):
        """The lowest grid index whose level is at or above close."""
        return math.ceil((close - self._anchor) / self.size - _EDGE)

    # --- one bar ----------------------------------------------------------------------

    def update(self, bar):
        close = _close(bar)
        if self.size is None:
            if not self._start(bar, close):
                return  # warm up: the size is not known yet
            self.new_bricks = 0
            self.reversal = False
            return  # the anchor bar itself makes no brick

        up = self._floor(close)    # the grid level price closed at or above
        down = self._ceil(close)   # the grid level price closed at or below
        d = self.direction
        bricks, new_dir = 0, d
        if d is None:
            if up >= self._index + 1:
                bricks, new_dir = up - self._index, 1
            elif down <= self._index - 1:
                bricks, new_dir = self._index - down, -1
        elif d == 1:
            if up >= self._index + 1:
                bricks = up - self._index
            elif down <= self._index - 2:
                # The first brick down spans from the last brick's open to one size below it.
                bricks, new_dir = self._index - 1 - down, -1
        else:
            if down <= self._index - 1:
                bricks = self._index - down
            elif up >= self._index + 2:
                bricks, new_dir = up - (self._index + 1), 1

        self.new_bricks = bricks
        self.reversal = d is not None and new_dir != d
        if bricks == 0:
            return
        self._index = up if new_dir == 1 else down
        self.run = bricks if new_dir != d else self.run + bricks
        self.direction = new_dir

    def _start(self, bar, close):
        """Fix the brick size and the anchor once. True when they are set."""
        if self.mode == "fixed":
            self.size = self._fixed
        else:
            self._atr.update(bar)
            atr = self._atr.value
            if atr is None or atr <= 0:
                return False
            self.size = atr * self.atr_mult
        self._anchor = close
        return True

    # --- what a strategy reads ------------------------------------------------------------

    @property
    def value(self):
        """The close of the last brick, None before the first brick."""
        return None if self.direction is None else self._level(self._index)

    @property
    def brick_open(self):
        """The open of the last brick: one size behind its close."""
        return None if self.direction is None else self._level(self._index - self.direction)


def make(params):
    params = params or {}
    return Renko(
        mode=params.get("mode", "atr"),
        size=params.get("size", 0.0),
        atr_period=params.get("atr_period", 14),
        atr_mult=params.get("atr_mult", 1.0),
    )


def register(api):
    api.register_indicator(
        "renko",
        "Renko bricks",
        make,
        [
            {"key": "mode", "label": "Brick size", "type": "choice", "default": "atr", "options": ["atr", "fixed"]},
            {"key": "size", "label": "Fixed size (price)", "type": "float", "default": 0.0, "min": 0.0},
            {"key": "atr_period", "label": "ATR period", "type": "int", "default": 14, "min": 1, "max": 500},
            {"key": "atr_mult", "label": "ATR multiple", "type": "float", "default": 1.0, "min": 0.01, "max": 50.0},
        ],
    )
    api.log("Renko bricks indicator registered")