Skip to main content

​
Plot Styles in Indie Language

Currently, Indie supports the following plot styles:
  • Line – simple lines
Line
  • Marker – dots, crosses, etc. on the chart
Marker
  • Steps – a line connecting points with horizontal steps
Steps
  • Histogram – bar charts with absolute-width lines
Histogram
  • Columns – bar charts with relative widths (0.0 to 1.0 relative to bar spacing)
Columns
  • Background – coloring the chart background based on indicator conditions
Background
  • Bar Color – changing the color of candlesticks on the chart
Bar Color To use these styles, you need two tools: a decorator for compile-time description and a class representing the plot value returned by the indicator: 
@line() - Line()
@steps() - Steps()
@histogram() - Histogram()
@columns() - Columns()
@fill() - Fill()
@marker() - Marker()
@background() - Background()
@bar_color() - BarColor()
All these entities are in the indie.plot package. Using them is easy, let’s look at some examples: 
# indie:lang_version = 5
from indie import indicator, plot, color

@indicator('My Indie 1', overlay_main_pane=True)
@plot.steps(color=color.RED)
def Main(self):
    return plot.Steps(self.close[0], offset=-4)
If you don’t need runtime parameter settings (like color or offset), you can return a simple float for most classes (Line, Steps, Histogram, Columns, Marker), and it will be cast automatically: 
# indie:lang_version = 5
from indie import indicator, plot, color

@indicator('My Indie 1', overlay_main_pane=True)
@plot.steps(color=color.RED)
def Main(self):
    return self.close[0]
If your indicator only draws Line plots with default settings, you can skip the decorator for an even simpler code: 
# indie:lang_version = 5
from indie import indicator

@indicator('My Indie 1', overlay_main_pane=True)
def Main(self):
    return self.close[0]
This example is a “Hello World” for indicators. If this is your first indicator, try running it on our platform before moving on.

​
Lines

Lines are the most common plot style and a great starting point. Let’s create a simple SMA Crossing indicator that draws multiple lines. We’ll enhance our previous example by adding two SMA lines:
  • Add @indie.plot.line(...) in the Main function decorator to declare and configure the line.
  • Return two floats with current line values for each bar.
We’ll use the SMA algorithm from Indie’s standard library. More on series data and algorithms can be found in our documentation. Here’s the code: 
# indie:lang_version = 5
from indie import indicator, plot, color
from indie.algorithms import Sma

@indicator('SMA Crossing', overlay_main_pane=True)
@plot.line(color=color.AQUA)
@plot.line(color=color.OLIVE)
def Main(self):
    sma_slow = Sma.new(self.close, 200)
    sma_fast = Sma.new(self.close, 50)
    return sma_slow[0], sma_fast[0]
Let’s move hardcoded constants to indicator parameters for UI adjustments: 
# indie:lang_version = 5
from indie import indicator, plot, color, param
from indie.algorithms import Sma

@indicator('SMA Crossing', overlay_main_pane=True)
@plot.line(color=color.AQUA)
@plot.line(color=color.OLIVE)
@param.int('sma_len_slow', default=200)
@param.int('sma_len_fast', default=50)
def Main(self, sma_len_slow, sma_len_fast):
    sma_slow = Sma.new(self.close, sma_len_slow)
    sma_fast = Sma.new(self.close, sma_len_fast)
    return sma_slow[0], sma_fast[0]
SMA cross Great job! Let’s make the indicator even better.

​
Markers

Let’s add markers for SMA line crosses. The algorithm is already known:
  • Add a @plot.marker decorator,
  • Return an indie.plot.Marker object from Main:
# indie:lang_version = 5
from indie import indicator, plot, color, param
from indie.algorithms import Sma

@indicator('SMA Crossing', overlay_main_pane=True)
@plot.line(id='sma_slow', color=color.AQUA)
@plot.line(id='sma_fast', color=color.OLIVE)
@plot.fill('sma_slow', 'sma_fast', color=color.NAVY(0.3))
@plot.marker(style=plot.marker_style.CIRCLE,
    position=plot.marker_position.CENTER, size=7,
    display_options=plot.MarkerDisplayOptions(
        pane=True, status_line=False, price_label=False,
    ),
)
@param.int('sma_len_slow', default=200)
@param.int('sma_len_fast', default=50)
def Main(self, sma_len_slow, sma_len_fast):
    sma_slow = Sma.new(self.close, sma_len_slow)
    sma_fast = Sma.new(self.close, sma_len_fast)

    fill_color = color.GREEN(0.3)
    if sma_fast[0] > sma_slow[0]:
        fill_color = color.RED(0.3)

    marker_color = color.rgba(0, 0, 0, 0)
    if sma_fast[0] >= sma_slow[0] and sma_fast[1] < sma_slow[1]:
        marker_color = color.RED
    if sma_fast[0] <= sma_slow[0] and sma_fast[1] > sma_slow[1]:
        marker_color = color.GREEN

    return (sma_slow[0], sma_fast[0],
           plot.Fill(color=fill_color),
           plot.Marker(value=sma_slow[0], color=marker_color))
Notice the display_options parameter - this allows you to hide the marker values from the “pill” and from the ordinate axis: 
    display_options=plot.MarkerDisplayOptions(
        pane=True, status_line=False, price_label=False,
    ),
SMA cross with markers Now it is much easier to detect line crosses, even if the crosses are very weak.

​
Columns

We created an SMA Crossing indicator. To highlight crossovers visually, let’s build a supporting indicator with columns in a separate pane. An indicator by mustermann84 on our marketplace is free: Simple Crossover Signal Bars. Here’s its code: 
# indie:lang_version = 5
from indie import indicator, plot, color, MutSeriesF, level, line_style, param
from indie.algorithms import Sma

@indicator('Simple Crossover Signal Bars', overlay_main_pane=False)
@param.int('fast_ma_length', default=50, min=1, title='Fast MA Length')
@param.int('slow_ma_length', default=200, min=1, title='Slow MA Length')
@plot.columns(title='Crossover Signal')
@level(
    value=0, title='Zero', line_color=color.GRAY,
    line_style=line_style.DASHED, line_width=1,
)
def Main(self, fast_ma_length, slow_ma_length):
    # SMA calculating
    fast_ma = Sma.new(self.close, fast_ma_length)
    slow_ma = Sma.new(self.close, slow_ma_length)

    # Signal logic: 1 for bull сrossover, -1 for bear сrossover
    signal_value = MutSeriesF.new(init=0)

    if fast_ma[0] > slow_ma[0] and fast_ma[1] <= slow_ma[1]:
        signal_value[0] = 1  # Bull Signal
    elif fast_ma[0] < slow_ma[0] and fast_ma[1] >= slow_ma[1]:
        signal_value[0] = -1  # Bear Signal
    else:
        signal_value[0] = 0  # No signal

    # Different signals have different colors
    plot_color = (
        color.GREEN if signal_value[0] == 1
        else color.RED if signal_value[0] == -1
        else color.rgba(0, 0, 0, 0)  # Transparent, no signal
    )

    return plot.Columns(value=signal_value[0], color=plot_color)
It is much easier to search for line crosses with such indicator: SMA Cross with columns

​
Histograms

Histograms in Indie are similar to columns but will gain more features in the future. Use histograms for data distributions or value differences, e.g., SMI Ergodic Oscillator shows the difference between TSI and its smoothed version: 
# indie:lang_version = 5
from indie import indicator, format, param, plot, color
from indie.algorithms import Tsi, Ema

@indicator('SMIO', format=format.PRICE, precision=4)  # SMI Ergodic Oscillator
@param.int('long_len', default=20, min=1, title='Long Length')
@param.int('short_len', default=5, min=1, title='Short Length')
@param.int('signal_len', default=5, min=1, title='Signal Length')
@plot.histogram(color=color.RED)
def Main(self, long_len, short_len, signal_len):
    tsi = Tsi.new(self.close, long_len, short_len)
    return tsi[0] - Ema.new(tsi, signal_len)[0]
SMI Ergodic Oscillator This built-in indicator is free for all users.

​
Steps

Steps displays data as step lines, ideal for discrete changes or support/resistance levels: 
# indie:lang_version = 5
from indie import indicator, plot
from indie.algorithms import Lowest, Highest

@indicator('Support-Resistance', overlay_main_pane=True)
@plot.steps('support')
@plot.steps('resistance')
def Main(self):
    support_level = Lowest.new(self.low, 20)
    resistance_level = Highest.new(self.high, 20)
    return support_level[0], resistance_level[0]
Support-Resistance with steps

​
Background

Background allows you to color the chart background based on conditions in your indicator. This is useful for highlighting specific market sessions, zones, or trading conditions. To use background coloring:
  • Add @plot.background(...) decorator
  • Return a plot.Background(...) object from the Main function
  • Set the color parameter to control the background color
  • Optionally use outline_left and outline_right to draw vertical lines at the edges
A great example is the built-in Trading Sessions indicator, which colors the pre-market and after-hours sessions: 
# indie:lang_version = 5
from math import isnan
from indie import indicator, plot, color, TimeFrame, time_frame_unit


@indicator('Trading Sessions', overlay_main_pane=True)
@plot.background(color=color.YELLOW(0.07), title='Pre-market session')
@plot.background(color=color.BLUE(0.07), outline_color=color.BLUE, title='Post-market session')
def Main(self):
    if self.time_frame >= TimeFrame(1, time_frame_unit.DAY):
        return plot.Background(color=color.TRANSPARENT), plot.Background(color=color.TRANSPARENT)

    pre_market_background = plot.Background()
    if self.time[0] not in self.trading_session.pre_market:
        pre_market_background.color = color.TRANSPARENT

    after_hours_background = plot.Background()
    if self.time[0] not in self.trading_session.after_hours:
        after_hours_background.color = color.TRANSPARENT

    after_hours_background.outline_left = (
        not isnan(self.time[1]) and
        not self.trading_session.is_same_period(self.time[0], self.time[1])
    )

    return pre_market_background, after_hours_background
In this example:
  • Two background plots are declared for pre-market and after-hours sessions
  • Each session gets its own color with transparency
  • color.TRANSPARENT is used when a bar is outside the session
  • The outline_left property draws a vertical line at session boundaries

​
Bar Color

Bar color allows you to change the color of candlesticks on the chart based on your indicator’s logic. This is perfect for highlighting unusual market activity or specific conditions. To use bar coloring:
  • Add @plot.bar_color() decorator
  • Return a plot.BarColor(...) object from the Main function
  • Set the color parameter to control the candlestick color
Let’s create an indicator that colors bars with unusually high volume, adapting the “Volume Spike Marker” example: 
# indie:lang_version = 5
from indie import indicator, param, plot, color
from indie.algorithms import Sma


@indicator('Volume Spike Bar Color', overlay_main_pane=True)
@param.int('volume_ma_len', default=20, min=1, title='Volume MA Length')
@param.float('spike_coef', default=2.0, min=1.0, max=1000.0, title='Spike coefficient')
@plot.bar_color(title='Bar Color')
def Main(self, volume_ma_len, spike_coef):
    volume_ma = Sma.new(self.volume, volume_ma_len)
    spike = self.volume[0] > volume_ma[0] * spike_coef

    # Color bars with high volume in yellow, others use default coloring
    return plot.BarColor(color.YELLOW if spike else None)
Bar color example In this example:
  • The indicator calculates a moving average of volume
  • When current volume exceeds the average by spike_coef times, the bar is colored yellow
  • None allows the bar to use default coloring when there’s no spike
  • The colored bars make it easy to spot unusual volume activity at a glance
You can combine bar coloring with other conditions, such as:
  • Price breakouts or breakdowns
  • Overbought/oversold conditions from oscillators
  • Pattern recognition results
  • Trend changes
We hope this guide helps you make the most of Indie’s plot styles when creating indicators. Experiment, build, and share your work with the community!