Pine Script v6: A Getting-Started Guide for Indicator Developers (2026)

What Pine Script is, briefly

Pine Script is TradingView's domain-specific language for writing custom technical indicators and strategies that run inside TradingView's chart engine. It is not a general-purpose programming language — every script runs once per bar across the chart's history, with state managed implicitly through the bar series. If you've never used it before, the mental model takes about a day; the gotchas take about a year.

Version 6, released in 2025, is the current production version. Versions 4 and 5 still work but are no longer the default for new scripts.

Setting up — your first v6 script

Every Pine Script starts with a version directive on line 1. To create a v6 indicator:

//@version=6
indicator("My First v6 Indicator", overlay=true)

// Plot the close price as a line on the chart
plot(close, color=color.new(color.aqua, 0), linewidth=2)

Save this in TradingView's Pine Editor and add it to the chart. You'll see the close price plotted as a cyan line. Three things to notice: the //@version=6 directive is mandatory and must be the first non-empty line; indicator() is the declaration that defines whether your script is an indicator (overlay or pane) or a strategy (with simulated trades); and overlay=true means the script draws on top of the price chart rather than in a separate pane below.

What changed from v5 to v6

1. Stricter type system

The single biggest change. v6 enforces type checking that v5 either ignored or handled silently. The most common case: v5 would let you pass a series int where a simple int was expected and silently demote it. v6 will throw an error at compile time.

Practical consequence: when you migrate a v5 script and it suddenly won't compile, the error is almost always a type mismatch in a function argument. The fix is usually to wrap the value in int(), float(), or use the appropriate built-in to coerce types explicitly.

2. Faster runtime

v6 introduced compiler optimizations that materially improve execution speed for most scripts. The improvements are most visible on scripts with heavy request.security() usage (multi-timeframe analysis), array manipulation, or matrix operations. Simple plot-and-color scripts won't see a meaningful difference.

3. Improved request.security() behavior

The function for requesting data from a different timeframe got cleaner argument handling and better protection against the historical "lookahead bias" footgun. The classic v4/v5 mistake — using lookahead=barmerge.lookahead_on without understanding the consequences — now triggers a clearer warning when the script is published.

4. New built-in functions

Several utility functions that previously required manual implementation are now built in. Notable additions: improved string formatting, better matrix slicing, and convenience methods on the array type that reduce boilerplate.

The patterns that matter for SMC indicators

If you're writing Smart Money Concepts indicators (order blocks, FVGs, BOS detection, liquidity sweeps), three Pine Script patterns come up constantly. Master these and you can build most of what's in commercial SMC suites.

Pattern 1: detecting swing highs and lows

The foundation of every market-structure indicator. Use ta.pivothigh() and ta.pivotlow() with a left/right bar window:

//@version=6
indicator("Swing Detection", overlay=true)

length = input.int(5, "Pivot Length", minval=1)

ph = ta.pivothigh(high, length, length)
pl = ta.pivotlow(low, length, length)

// Plot circles at confirmed swing points
plotshape(not na(ph), location=location.abovebar,
          style=shape.circle, color=color.red, size=size.tiny)
plotshape(not na(pl), location=location.belowbar,
          style=shape.circle, color=color.green, size=size.tiny)

Note: pivots are confirmed length bars after they form. This is a non-repainting confirmation — once printed, the pivot doesn't move. The trade-off is latency: you only know the pivot exists 5 bars later (with length=5).

Pattern 2: drawing zones (boxes for order blocks and FVGs)

Use the box.new() built-in to draw rectangles. Boxes can be updated, extended right as new bars print, or deleted when invalidated:

//@version=6
indicator("Bullish FVG Detector", overlay=true, max_boxes_count=500)

// Bullish FVG: low of current bar > high of bar 2 ago
fvg_top = low
fvg_bot = high[2]
isFVG = fvg_top > fvg_bot

if isFVG
    box.new(left=bar_index[2], top=fvg_top, right=bar_index, bottom=fvg_bot,
            bgcolor=color.new(color.green, 80),
            border_color=color.new(color.green, 50))

Two things bite first-time developers here. First, max_boxes_count defaults to 50 — bump it for any indicator that draws zones across long histories. Second, boxes are drawn at compile time per bar; if you draw a box on every bar without conditional logic, you'll exhaust the limit fast.

Pattern 3: tracking state across bars (the var keyword)

Pine Script runs your code once per bar, but you often need state that persists. The var keyword declares a variable that initializes once and persists across bar executions:

//@version=6
indicator("BOS Tracker", overlay=true)

// Persistent state: track the last confirmed swing high
var float lastSwingHigh = na

// Update when a new pivot high is confirmed
ph = ta.pivothigh(high, 5, 5)
if not na(ph)
    lastSwingHigh := ph

// Detect BOS: close above the last swing high
isBOS = not na(lastSwingHigh) and close > lastSwingHigh

if isBOS
    label.new(bar_index, high, "BOS",
              color=color.new(color.green, 0), textcolor=color.white)

Without var, the variable would reset on every bar. With var, the value persists. This is the foundational pattern for any indicator that needs memory of past events — every BOS detector, MSS detector, mitigation tracker, and order-block aging system uses this pattern under the hood.

Common pitfalls that bite first-time developers

Publishing on TradingView

Once your script works, you can publish it to TradingView's Public Library — either as open-source (anyone can read and copy the code) or invite-only (you control access). Both options reach TradingView's user base; open-source publications are reviewed against the House Rules and ranked in the Editors' Picks pipeline if quality is high.

Three House Rules that catch new authors most often: don't include external promotional links in script titles or descriptions, don't use repainting techniques without disclosing them, and don't reference your brand inside the chart output (no logos, no watermark labels). The first two are technical; the third is enforcement-focused and trips up commercial publishers regularly.

Frequently asked questions