Data plotting - lines, columns, etc.

Plot Styles in Indie Language

Currently, Indie supports the following plot styles:

Line – simple lines

Markers – For example, dots, and crosses.

Steps – a line connecting points with horizontal steps

Histogram – bar charts with absolute-width lines

Columns – bar charts with relative widths (0.0 to 1.0 relative to bar spacing)

Background – coloring the chart background based on indicator conditions

Bar Color – changing the color of candlesticks on the chart

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]

Great job! Let’s make the indicator even better.

Markers

Let’s add markers for SMA line crosses. Using the logic established above:

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,
    ),

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 an indicator:

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]

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]

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)

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!

​Plot Styles in Indie Language

​Lines

​Markers

​Columns

​Histograms

​Steps

​Background

​Bar Color