Common drawing patterns

This guide provides ready-to-use solutions for common drawing tasks in Indie indicators. Each pattern addresses a specific visualization need with working code examples.

Key Concepts for Drawing in Indie

Before diving into patterns, let’s recall these essential concepts that affect how drawings work in Indie.

Two Execution Phases: History vs Realtime

Indie indicators run in two distinct phases:

History calculation: Each bar is processed once sequentially from left to right. Drawing objects are created and remain stable.
Realtime updates: When new intrabar data arrives, the indicator re-executes for the current bar multiple times.

Code that works perfectly during history calculation can break during realtime updates. Always consider both phases when writing drawing code, and test your indicators on instruments with realtime updates on 1m timeframe for several minutes to ensure runtime stability.

Chart State Rollbacks

During realtime updates, when new intrabar data arrives:

The chart state rolls back to what it was at the beginning of the current bar
Your indicator’s calc() function executes again with updated data

If you created a drawing during an intrabar update, the rollback will remove it. If you erased a drawing during an intrabar update, the rollback will restore it.

When and Why to Use Var for Drawings

The mismatch between chart rollbacks and class field persistence introduces a state synchronization conflict: class fields retain references to drawings that may no longer exist after a rollback. This can lead to runtime errors when trying to erase non-existent objects, or duplicate drawings when modifying and redrawing “ghost” references. Use Var[T] when you need to:

Update the same drawing object across multiple bars
Maintain drawing references during realtime updates
Erase drawings created in previous executions

Simple guidelines:

One-time drawings (labels on conditions): Just create and draw - no special handling
Persistent drawings (info panels): Store in class fields or Var and reuse the object
Erasable drawings (anything you’ll erase): Must use Var for rollback safety

Common Drawing Patterns

Pattern 1: Draw labels when conditions are met

Problem: You want to display labels on specific bars when certain conditions are satisfied, such as price patterns, indicator signals, or periodic intervals. Solution: Use conditional logic to check your criteria and create new label objects when conditions are met. No special object management is required.

Label breakouts and periodic bars

# indie:lang_version = 5
from indie import indicator, color
from indie.drawings import LabelAbs, AbsolutePosition
from indie.algorithms import Highest

@indicator('Conditional Labels', overlay_main_pane=True)
def Main(self):
    # Example 1: Label every 5th bar
    if self.bar_index % 5 == 0:
        self.chart.draw(LabelAbs(
            'Bar ' + str(self.bar_index),
            AbsolutePosition(self.time[0], self.high[0]),
        ))

    # Example 2: Label price breakouts
    highest_20 = Highest.new(self.high, 20)
    if self.close[0] > highest_20[1]:
        self.chart.draw(LabelAbs(
            "BREAKOUT!",
            AbsolutePosition(self.time[0], self.close[0]),
            bg_color=color.BLUE,
        ))

How it works: Labels are created when conditions are met and automatically persist on the chart. During realtime updates, the chart rolls back and re-executes, creating labels again when conditions are still true.

Pattern 2: Display information in fixed screen position

Problem: You want to show live statistics, indicator values, or other information that stays in a fixed position on screen regardless of chart scrolling or zooming. Solution: Create a LabelRel object once and reuse it by updating its text property. Store the label in a class field (for class-based indicators) or use Var (for function-based indicators).

# indie:lang_version = 5
from indie import indicator, Var
from indie.drawings import LabelRel, RelativePosition, vertical_anchor as va, horizontal_anchor as ha

@indicator('Info Panel', overlay_main_pane=True)
def Main(self):
    # Create label once, position it in top-right corner
    info_label_var = Var[LabelRel].new(LabelRel(
        "Initializing...",
        RelativePosition(va.TOP, ha.RIGHT, 0.1, 0.9)
    ))

    # Update content with current data
    info_label_var.get().text = "Price: " + str(self.close[0]) + "\nBar: " + str(self.bar_count)

    # Redraw to update display
    self.chart.draw(info_label_var.get())

# indie:lang_version = 5
from indie import indicator, MainContext
from indie.drawings import LabelRel, RelativePosition, vertical_anchor as va, horizontal_anchor as ha

@indicator('Info Panel', overlay_main_pane=True)
class Main(MainContext):
    def __init__(self):
        # Create label once, position it in top-right corner
        self.info_label = LabelRel(
            "Initializing...",
            RelativePosition(va.TOP, ha.RIGHT, 0.1, 0.9)
        )

    def calc(self):
        # Update content with current data
        self.info_label.text = "Price: " + str(self.close[0]) + "\nBar: " + str(self.bar_count)

        # Redraw to update display
        self.chart.draw(self.info_label)

Always reuse the same LabelRel object. Creating new relative-positioned labels on each bar will cause an error “count of relative positioned drawings exceeded the limit 100”.

Pattern 3: Label that follows the current bar

Problem: You want a label that appears only above the most recent bar and moves with it as new bars arrive, displaying current values or active signals. Solution: Create a LabelAbs object once and update both its position and text properties on each bar to follow the current price action.

# indie:lang_version = 5
from indie import indicator, Var
from indie.drawings import LabelAbs, AbsolutePosition

@indicator('Current Bar Tracker', overlay_main_pane=True)
def Main(self):
    # Create label once with dummy position
    tracker_var = Var[LabelAbs].new(LabelAbs("Initializing", AbsolutePosition(0, 0)))

    # Calculate what to display
    price_change = self.close[0] - self.close[1]
    change_pct = (price_change / self.close[1]) * 100

    # Update both text and position
    tracker_var.get().text = str(round(change_pct, 3)) + '%'
    tracker_var.get().position = AbsolutePosition(self.time[0], self.high[0])

    # Redraw at new position
    self.chart.draw(tracker_var.get())

# indie:lang_version = 5
from indie import indicator, MainContext
from indie.drawings import LabelAbs, AbsolutePosition

@indicator('Current Bar Tracker', overlay_main_pane=True)
class Main(MainContext):
    def __init__(self):
        # Create label once with dummy position
        self.tracker = LabelAbs("Initializing", AbsolutePosition(0, 0))

    def calc(self):
        # Calculate what to display
        price_change = self.close[0] - self.close[1]
        change_pct = (price_change / self.close[1]) * 100

        # Update both text and position
        self.tracker.text = str(round(change_pct, 3)) + '%'
        self.tracker.position = AbsolutePosition(self.time[0], self.high[0])

        # Redraw at new position
        self.chart.draw(self.tracker)

Key point: By reusing the same label object and updating its position, you ensure only one label exists at any time, creating a smooth tracking effect.

Pattern 4: Draw polyline connecting specific points

Problem: You want to create connected lines that pass through specific price points (e.g., highs every 5 bars), forming a polyline that updates as new bars arrive. Solution: Maintain only the current active segment using Var. Update the segment’s endpoint between anchor points, and create new segments at anchor points.

# indie:lang_version = 5
from indie import indicator, Var, Optional
from indie.drawings import LineSegment, AbsolutePosition

@indicator('Polyline Pattern', overlay_main_pane=True)
def Main(self):
    # Store current segment in Var for rollback safety
    current_segment = Var[Optional[LineSegment]].new(None)

    # Current point (using high for visibility)
    curr_point = AbsolutePosition(self.time[0], self.high[0])

    # Every 5th bar is an anchor point
    if self.bar_index % 5 == 0:
        start_point = curr_point  # Default for first segment

        # Continue from previous segment's endpoint if it exists
        if current_segment.get() is not None:
            start_point = current_segment.get().value().point_b

        # Create new segment
        current_segment.set(LineSegment(start_point, curr_point))

    # Between anchors: update current segment's endpoint
    elif current_segment.get() is not None:
        current_segment.get().value().point_b = curr_point

    # Draw the active segment
    if current_segment.get() is not None:
        self.chart.draw(current_segment.get().value())

# indie:lang_version = 5
from indie import indicator, Var, Optional, MainContext
from indie.drawings import LineSegment, AbsolutePosition

@indicator('Polyline Pattern', overlay_main_pane=True)
class Main(MainContext):
    def __init__(self):
        # Store current segment in Var for rollback safety
        self.current_segment = self.new_var(Optional[LineSegment]())

    def calc(self):
        # Current point (using high for visibility)
        curr_point = AbsolutePosition(self.time[0], self.high[0])

        # Every 5th bar is an anchor point
        if self.bar_index % 5 == 0:
            start_point = curr_point  # Default for first segment

            # Continue from previous segment's endpoint if it exists
            if self.current_segment.get() is not None:
                start_point = self.current_segment.get().value().point_b

            # Create new segment
            self.current_segment.set(LineSegment(start_point, curr_point))

        # Between anchors: update current segment's endpoint
        elif self.current_segment.get() is not None:
            self.current_segment.get().value().point_b = curr_point

        # Draw the active segment
        if self.current_segment.get() is not None:
            self.chart.draw(self.current_segment.get().value())

Why Var is essential: During realtime updates on anchor bars, without Var the polyline would break. The segment reference must survive rollbacks to maintain continuity. Note that even if you used a class field to store the segment, you would still need to wrap it in Var[Optional[LineSegment]].

What happens without Var: If you used a regular class field self.current_segment: Optional[LineSegment] instead:

On anchor bar (e.g., bar 10), you create a new segment starting from the previous segment’s endpoint and save it to self.current_segment
An intrabar update arrives, chart rolls back to the start of bar 10
During recalculation, the code tries to create a new LineSegment, but takes its start point from self.current_segment, which was modified during the previous update and wasn’t rolled back
This creates a disconnected polyline - the new segment starts from an incorrect position

Pattern 5: Safely erase drawings created on previous executions

Problem: You need to manually erase drawings that were created during previous bar updates or previous intrabar executions. This is common for temporary overlays, alerts, or any drawings that should appear and disappear based on conditions. Solution: Let’s explore this through a concrete example - creating a blinking line indicator. We’ll work through the challenges step-by-step to understand why proper erasure handling is crucial. First attempt - using class fields:

# indie:lang_version = 5
from indie import indicator, Optional, MainContext
from indie.drawings import LineSegment, AbsolutePosition

@indicator('Blinking Line - Broken', overlay_main_pane=True)
class Main(MainContext):
    def __init__(self):
        self.is_visible = True
        self.line_segment: Optional[LineSegment] = None

    def calc(self):
        self.is_visible = not self.is_visible

        if self.is_visible:
            self.line_segment = LineSegment(
                AbsolutePosition(self.time[1], self.close[1]),
                AbsolutePosition(self.time[0], self.close[0]),
            )
            self.chart.draw(self.line_segment.value())
        elif self.line_segment is not None:
            self.chart.erase(self.line_segment.value())  # Runtime error!

Where it breaks: Consider this scenario:

On the last update of bar N, the line is erased (is_visible was False)
Bar N+1 starts with no line on the chart
First execution: is_visible becomes True, line is drawn
Intrabar update arrives, chart rolls back to start of bar N+1 (no line)
Second execution: is_visible becomes False, tries to erase non-existent line
Runtime error!

This type of error often manifests as “Error: drawing object does not exist” and only appears during realtime, making it hard to catch during development.

Second attempt - using Var for the drawing:

# indie:lang_version = 5
from indie import indicator, Optional, MainContext
from indie.drawings import LineSegment, AbsolutePosition

@indicator('Blinking Line - Still Broken', overlay_main_pane=True)
class Main(MainContext):
    def __init__(self):
        self.is_visible = True
        self.line_segment = self.new_var(Optional[LineSegment]())

    def calc(self):
        self.is_visible = not self.is_visible

        if self.is_visible:
            self.line_segment.set(LineSegment(
                AbsolutePosition(self.time[1], self.high[1]),
                AbsolutePosition(self.time[0], self.close[0]),
            ))
            self.chart.draw(self.line_segment.get().value())
        else:
            if self.line_segment.get() is not None:
                self.chart.erase(self.line_segment.get().value())
            self.line_segment.set(None)

Where it still breaks: Now we hit the opposite problem:

On the last update of bar N, the line is drawn (is_visible was True)
Bar N+1 starts with the line on the chart
First execution: is_visible becomes False, line is erased
Intrabar update arrives, chart rolls back to start of bar N+1 (line is back!)
Second execution: is_visible becomes True, draws another line
Result: Two lines on the chart!

The working solution - always erase first:

# indie:lang_version = 5
from indie import indicator, MainContext, Optional, Var
from indie.drawings import LineSegment, AbsolutePosition

@indicator('Blinking Line', overlay_main_pane=True)
class Main(MainContext):
    def __init__(self):
        self.is_visible = True
        self.line_segment = self.new_var(Optional[LineSegment]())

    def calc(self):
        # Always clean up first - handles all rollback scenarios
        if self.line_segment.get() is not None:
            self.chart.erase(self.line_segment.get().value())
            self.line_segment.set(None)

        # Then conditionally draw
        if self.is_visible:
            self.line_segment.set(LineSegment(
                AbsolutePosition(self.time[1], self.close[1]),
                AbsolutePosition(self.time[0], self.close[0]),
            ))
            self.chart.draw(self.line_segment.get().value())

        # Toggle for next execution
        self.is_visible = not self.is_visible

Why this works: The “erase-first” pattern elegantly handles all rollback scenarios. Whether the chart rolled back with or without the line, we always start fresh. This simple approach avoids complex state tracking and works reliably in both history calculation and realtime updates. Result: The line blinks with each execution - appearing when is_visible is true and disappearing when false. During realtime updates, each intrabar update toggles the visibility, creating a visual heartbeat of market activity.

Pattern 6: Skip redundant draws during history with `is_last_bar`

Problem: You have a drawing that gets updated every bar (e.g., an info panel, a “current price” label) but only the final state matters to the user. During history calculation the runtime tracks every chart.draw() call internally, so redrawing the same object on each of thousands of history bars wastes memory and slows down calculation — even though only the last bar’s state will ever be visible. Solution: Guard the drawing call with self.is_last_bar so that the object is only drawn once — on the most recent bar. During realtime updates is_last_bar is always True, so the drawing updates normally.

# indie:lang_version = 5
from indie import indicator, Var
from indie.drawings import LabelRel, RelativePosition, vertical_anchor as va, horizontal_anchor as ha

@indicator('Efficient Dashboard', overlay_main_pane=True)
def Main(self):
    # Create the label object once via Var
    info_panel = Var[LabelRel].new(LabelRel(
        '',
        RelativePosition(va.TOP, ha.RIGHT, 0.1, 0.9),
    ))

    # All indicator logic runs on every bar as usual
    price_change = self.close[0] - self.close[1]
    change_pct = (price_change / self.close[1]) * 100

    # Only draw on the last bar — skips thousands of redundant draws during history
    if self.is_last_bar:
        info_panel.get().text = 'Change: ' + str(round(change_pct, 3)) + '%'
        self.chart.draw(info_panel.get())

# indie:lang_version = 5
from indie import indicator, MainContext
from indie.drawings import LabelRel, RelativePosition, vertical_anchor as va, horizontal_anchor as ha

@indicator('Efficient Dashboard', overlay_main_pane=True)
class Main(MainContext):
    def __init__(self):
        self.info_panel = LabelRel(
            '',
            RelativePosition(va.TOP, ha.RIGHT, 0.1, 0.9),
        )

    def calc(self):
        # All indicator logic runs on every bar as usual
        price_change = self.close[0] - self.close[1]
        change_pct = (price_change / self.close[1]) * 100

        # Only draw on the last bar — skips thousands of redundant draws during history
        if self.is_last_bar:
            self.info_panel.text = 'Change: ' + str(round(change_pct, 3)) + '%'
            self.chart.draw(self.info_panel)

When to use this pattern: Apply it to any drawing that is redrawn on every bar with only the latest state being meaningful — dashboards, info panels, “current value” trackers, trailing stop lines, etc. Do not use it for drawings that should remain on the chart at their historical positions (e.g., signal labels, trend lines between pivot points).

Pattern 7: Prefer `@level` over a constant plot line

Problem: You need a fixed horizontal line at a known value — an overbought threshold, a zero line, a target price. It is tempting to reach for @plot.line and return the constant on every bar, but that is the wrong tool for a static value. Solution: Use the @level decorator. It is a purely static, compile-time decorator: it takes no return value and occupies no slot in the return tuple. The line is described once, at compile time, from a single constant.

# indie:lang_version = 5
from indie import indicator, plot, level, color
from indie.algorithms import Rsi

@indicator('RSI with level')
@plot.line('rsi')
@level(70, line_color=color.RED)
def Main(self):
    return Rsi.new(self.close, 14)[0]

# indie:lang_version = 5
from indie import indicator, plot, color
from indie.algorithms import Rsi

@indicator('RSI with const line')
@plot.line('rsi')
@plot.line('ob', color=color.RED)
def Main(self):
    # 70.0 is re-evaluated, stored, and streamed on EVERY bar
    return Rsi.new(self.close, 14)[0], 70.0

Why @level is faster and leaner: A value returned from @plot.line is treated as a full time series. The runtime evaluates it, stores it, and streams it to the chart on every one of the thousands of history bars — even though the number never changes. @level carries a single constant: nothing is computed or stored per bar. Same visual result, a fraction of the memory and compute.

Pattern 8: Prefer `@band` over two lines with a fill

Problem: You want a shaded zone between two fixed values — a neutral RSI zone, a value area, a no-trade corridor. The manual approach is two @plot.line decorators plus a @plot.fill, returning both constants and a plot.Fill() every bar. Solution: Use the @band decorator. Like @level, it is static and compile-time: two constant edges and a fill described once, with no return value and no output slots to feed.

# indie:lang_version = 5
from indie import indicator, plot, band, color
from indie.algorithms import Rsi

@indicator('RSI with band')
@plot.line('rsi')
@band(70, 30, fill_color=color.GRAY(0.1))
def Main(self):
    return Rsi.new(self.close, 14)[0]

# indie:lang_version = 5
from indie import indicator, plot, color
from indie.algorithms import Rsi

@indicator('RSI with two lines and fill')
@plot.line('rsi')
@plot.line('ob', color=color.GRAY)
@plot.line('os', color=color.GRAY)
@plot.fill('ob', 'os', color=color.GRAY(0.1))
def Main(self):
    # Two constants and a Fill returned on EVERY bar
    return Rsi.new(self.close, 14)[0], 70.0, 30.0, plot.Fill()

Why @band is faster and leaner: The manual version occupies three extra output slots — two constant lines and a fill — each tracked as its own per-bar series across the entire history. @band replaces all three with a single static declaration that carries two constants. Fewer output slots, no per-bar evaluation, less data streamed to the chart.

Rule of thumb: whenever a horizontal line or zone sits at a value that is known at compile time and never changes during the run, use @level or @band. Reach for a constant @plot.line (and @plot.fill) only when the value is genuinely dynamic — computed at runtime or changing bar-to-bar (e.g., a volatility-adjusted threshold). In that case the value really is a series, and a plot is the right tool.

​Key Concepts for Drawing in Indie

​Two Execution Phases: History vs Realtime

​Chart State Rollbacks

​When and Why to Use Var for Drawings

​Common Drawing Patterns

​Pattern 1: Draw labels when conditions are met

​Pattern 2: Display information in fixed screen position

​Pattern 3: Label that follows the current bar

​Pattern 4: Draw polyline connecting specific points

​Pattern 5: Safely erase drawings created on previous executions

​Pattern 6: Skip redundant draws during history with is_last_bar

​Pattern 7: Prefer @level over a constant plot line

​Pattern 8: Prefer @band over two lines with a fill

Key Concepts for Drawing in Indie

Two Execution Phases: History vs Realtime

Chart State Rollbacks

When and Why to Use Var for Drawings

Common Drawing Patterns

Pattern 1: Draw labels when conditions are met

Pattern 2: Display information in fixed screen position

Pattern 3: Label that follows the current bar

Pattern 4: Draw polyline connecting specific points

Pattern 5: Safely erase drawings created on previous executions

Pattern 6: Skip redundant draws during history with `is_last_bar`

Pattern 7: Prefer `@level` over a constant plot line

Pattern 8: Prefer `@band` over two lines with a fill