Top 5 Pine Script Mistakes Beginners Make (And How to Fix Them) — v6 Guide

Every Pine Script developer encounters a set of predictable compile errors and logical bugs when first learning the language. This article systematically documents the five most common mistakes beginners make in Pine Script v6, explains the underlying language rules that cause them, and provides verified, compilable fixes for each one.

🔍 Overview: Why Pine Script Trips Up Beginners

Pine Script is a domain-specific language with a unique bar-by-bar execution model, a strict type qualifier system, and assignment semantics that differ fundamentally from general-purpose languages like Python or JavaScript. Beginners who carry assumptions from those languages into Pine Script will encounter errors that seem cryptic at first but follow precise, learnable rules.

graph TD A[Beginner writes Pine Script] --> B{Which mistake?} B --> C1[Uses = instead of :=] B --> C2[Wrong indentation] B --> C3[Misuses var keyword] B --> C4[Assigns na to bool] B --> C5[series int to simple int param] C1 --> D1[Silent logical bug Variable never updates] C2 --> D2[Compile error or logic runs outside block] C3 --> D3[Counter resets every bar or never updates] C4 --> D4[Compile error bool cannot hold na] C5 --> D5[Compile error ta.ema length type mismatch] D1 --> E1[Fix: use := for reassignment] D2 --> E2[Fix: 4-space indent + auto-formatter] D3 --> E3[Fix: add var for persistence] D4 --> E4[Fix: use int for 3-state logic] D5 --> E5[Fix: use input.int or literal]

❌ Mistake #1 — Using = Instead of := for Reassignment

This is the single most common error for beginners. Pine Script uses two distinct assignment operators with completely different semantics. Confusing them produces either a compile error or a silent logical bug.

Operator Purpose When to Use
= Declare and initialize a variable First time a variable name appears
:= Reassign an already-declared variable Every subsequent assignment to the same name

🔽 [Click to expand] View Full Pine Script Code — Mistake #1 
//@version=6
indicator("Mistake 1 Demo", overlay = true)

// ❌ WRONG: Using = inside a conditional block to "update" a variable.
// This actually declares a NEW local variable scoped to the if-block.
// The outer `myValue` is never updated — a silent logical bug.
var float myValue = 0.0
if close > open
    myValue = close  // ❌ This creates a local variable, not a reassignment

// ✓ CORRECT: Use := to reassign the outer variable declared with var.
var float myValueFixed = 0.0
if close > open
    myValueFixed := close  // ✓ Correctly updates the persistent variable

plot(myValue,      title = "Wrong (always 0)",   color = color.red)
plot(myValueFixed, title = "Correct (updates)",  color = color.green)

Key Rule: The = operator inside a conditional block creates a new local variable that is invisible outside that block. To update a variable declared in an outer scope, you must use :=.

❌ Mistake #2 — Ignoring Pine Script's Indentation Rules

Pine Script uses mandatory indentation (similar to Python) to define code blocks. Unlike C or JavaScript, there are no curly braces {}. A single incorrect indentation level causes a compile error or, worse, moves logic outside the intended block silently.

🔽 [Click to expand] View Full Pine Script Code — Mistake #2 
//@version=6
indicator("Mistake 2 Demo", overlay = true)

// ❌ WRONG: The plot() call is NOT indented under the if block.
// It looks like it belongs to the if block, but it executes on EVERY bar.
var int signalCount = 0
if close > open
    signalCount := signalCount + 1
plot(signalCount, title = "Count (runs every bar)")  // ❌ Outside the if block

// ✓ CORRECT: Consistent 4-space indentation clearly scopes each block.
var int bullBars = 0
var int bearBars = 0

if close > open
    bullBars := bullBars + 1  // ✓ Runs only when close > open
if close < open
    bearBars := bearBars + 1  // ✓ Runs only when close < open

plot(bullBars, title = "Bull Bars", color = color.green)
plot(bearBars, title = "Bear Bars", color = color.red)

Key Rule: Pine Script block scope is defined entirely by indentation. The standard convention is 4 spaces per indentation level. Mixing tabs and spaces, or using inconsistent depths, will produce compile errors. Always use the Pine Editor's built-in formatter (Ctrl+Shift+F) to auto-correct indentation.

❌ Mistake #3 — Misunderstanding var vs. Plain Declaration

Beginners frequently either overuse var (causing values to never update) or omit it (causing values to reset on every bar when persistence is needed). Understanding the difference is fundamental to Pine Script's execution model.

Declaration Initialized Behavior Per Bar Typical Use Case
float x = 0.0 Every bar Resets to 0.0 on each bar Per-bar calculations
var float x = 0.0 Bar 0 only Retains value from previous bar Counters, accumulators, state machines

🔽 [Click to expand] View Full Pine Script Code — Mistake #3 
//@version=6
indicator("Mistake 3 Demo", overlay = false)

// ❌ WRONG: Trying to count bullish bars without var.
// `counter` resets to 0 on every bar, so it can only ever be 0 or 1.
float counter = 0.0          // Resets every bar
if close > open
    counter := counter + 1   // At most 1 per bar — never accumulates
plot(counter, title = "Wrong Counter (max 1)", color = color.red)

// ✓ CORRECT: Use var to persist the counter across bars.
var float persistentCounter = 0.0  // Initialized once on bar 0
if close > open
    persistentCounter := persistentCounter + 1  // Accumulates correctly
plot(persistentCounter, title = "Correct Counter (accumulates)", color = color.green)

Key Rule: Use var whenever a variable must remember its value from the previous bar — counters, running totals, state flags, and drawing object references all require var. Omit var when you want a fresh calculation on every bar.

❌ Mistake #4 — Using bool as a Three-State Variable (with na)

Developers coming from Python or JavaScript often assume that an uninitialized boolean can hold a "null" or "undefined" state. In Pine Script v6, bool is strictly binary — it can only be true or false. Attempting to assign na to a bool, or passing a bool to na() or nz(), produces a compile error.

🔽 [Click to expand] View Full Pine Script Code — Mistake #4 
//@version=6
indicator("Mistake 4 Demo", overlay = true)

// ❌ WRONG: Attempting to use bool with na — compile error in v6.
// bool myFlag = na          // CE: bool cannot be na
// if na(myFlag)             // CE: na() does not accept bool
//     myFlag := true

// ❌ WRONG: Implicit int-to-bool cast — removed in v6.
// int myInt = 5
// if myInt                  // CE: int cannot be used as bool directly
//     label.new(bar_index, high, "Signal")

// ✓ CORRECT: bool is strictly true or false. Use explicit comparison.
bool isBullish = close > open  // Evaluates to true or false every bar

if isBullish
    label.new(bar_index, high, "▲",
        color     = color.green,
        textcolor = color.white,
        style     = label.style_label_down,
        size      = size.small)

// ✓ CORRECT: For 3-state logic (true / false / missing), use int instead.
// Convention: 1 = true, 0 = false, na = missing/unknown
int signal = na  // int CAN hold na
if close > open
    signal := 1
else if close < open
    signal := 0
// signal remains na when close == open

plot(signal, title = "3-State Signal (int)", style = plot.style_circles)

Key Rule: In Pine Script v6, bool has exactly two states: true and false. If your logic requires a third "unknown" or "missing" state, use int with the convention 1 = true, 0 = false, na = missing. Never write bool b = na, na(myBool), or nz(myBool, false).

❌ Mistake #5 — Passing a series int to a Function Requiring simple int

This is the most technically subtle mistake on this list. Pine Script's type qualifier system enforces that certain function parameters — particularly length parameters of built-in technical analysis functions — require a simple int value, not a series int. The qualifier hierarchy from weakest to strongest is: const → input → simple → series. A series int cannot be passed where a simple int is required.

The most common trigger is declaring a variable with var and then reassigning it with := inside a conditional block. This forces the variable's qualifier to series, even if the reassignment only happens once.

🔽 [Click to expand] View Full Pine Script Code — Mistake #5 
//@version=6
indicator("Mistake 5 Demo", overlay = true)

// ❌ WRONG: var + := inside a conditional block → series int
// ta.ema() requires simple int for its length parameter.
// This will produce a compile error.
// var int myLength = 20
// if barstate.isfirst
//     myLength := 14          // ← forces myLength to series int qualifier
// plot(ta.ema(close, myLength))  // CE: series int passed to simple int

// ✓ CORRECT Option 1: Use input.int() — returns input int, satisfies simple.
int lengthFromInput = input.int(14, title = "EMA Length", minval = 1)
plot(ta.ema(close, lengthFromInput),
    title = "EMA (input)",
    color = color.blue)

// ✓ CORRECT Option 2: Declare as a plain const int (no var, no reassignment).
// A literal integer constant satisfies the simple int requirement.
int fixedLength = 20  // const int — satisfies simple int
plot(ta.ema(close, fixedLength),
    title = "EMA (const)",
    color = color.orange)

// ✓ CORRECT Option 3: Use math.max() with int() cast when computing length.
// timeframe.multiplier returns float in some contexts — always cast explicitly.
int computedLength = int(math.max(1, 200 / 10))  // safe: const int result
plot(ta.ema(close, computedLength),
    title = "EMA (computed)",
    color = color.purple)

Key Rule: The qualifier hierarchy is const → input → simple → series (weakest to strongest). A parameter requiring simple int accepts const, input, or simple — but not series. The moment you use var with := reassignment inside any conditional block, the variable becomes series. For TA function lengths, always use input.int() or a plain integer literal.

📊 Summary Table: The 5 Mistakes at a Glance

# Mistake Error Type Fix
1 Using = instead of := for reassignment Silent logical bug Use := for all reassignments after first declaration
2 Incorrect indentation Compile error or silent scope bug Use 4-space indentation; use Pine Editor auto-formatter
3 Misusing var (or omitting it) Silent logical bug Use var only for persistent state; omit for per-bar values
4 Assigning na to bool Compile error Use int for 3-state logic; bool is strictly binary
5 Passing series int to simple int parameter Compile error Use input.int() or a plain integer literal for TA lengths

✅ Conclusion

  • Assignment operators are not interchangeable: = declares a new variable in the current scope; := reassigns an existing one. Confusing them is the most common source of silent logical bugs in Pine Script.
  • The type qualifier system is enforced at compile time: The hierarchy const → input → simple → series determines which values can be passed to which parameters. Using var with conditional := reassignment silently promotes a variable to series, breaking compatibility with TA functions that require simple int.
  • Pine Script v6 enforces strict boolean semantics: bool cannot hold na, cannot be passed to na() or nz(), and cannot be implicitly cast from an integer. These are breaking changes from earlier versions and from general-purpose language conventions.

🚀 Ideas for Further Exploration

  1. Build a personal Pine Script linting checklist: Extend the five rules above into a pre-publish checklist (similar to the one in the Anti-Hallucination Prompt) that you run through before adding any script to a live chart. Automate it as a comment template at the top of every new script file.
  2. Explore the varip keyword: Once var is well understood, investigate varip — which initializes once on bar 0 but updates on every real-time tick rather than only on bar close. This is essential for building real-time alert systems and tick-level state machines.

Related Posts

Comments

Post a Comment

Popular posts from this blog

How to Build a Volume Indicator in Pine Script v6: Buying & Selling Pressure Analysis

Image
Volume is one of the most fundamental data points in technical analysis — it tells you how much was traded, not just at what price . In this post, you will learn how to build a complete volume indicator in Pine Script v6 that color-codes bars by buying or selling pressure, detects volume spikes using a dynamic SMA baseline, and annotates those spikes directly on the chart using plotshape() with location.absolute . 1. What Is Volume and Why Does It Matter? Volume represents the total number of contracts or shares exchanged during a given bar. When price moves on high volume , the move is considered more significant. When price moves on low volume , it may lack conviction. The key analytical concepts are: Buying Pressure: Close price is above the open price — bulls dominated the bar. Selling Pressure: Close price is below the open price — bears dominated the bar. Volume Spike: Current volume exceeds a rolling average by a con...
Read more

Pine Script v6 plot() Function: Complete Guide to Lines, Histograms, and Circles

Image
The plot() function is the most fundamental visualization tool in Pine Script v6, enabling developers to render numeric series data directly onto a TradingView chart as lines, histograms, circles, and more. Understanding its styling parameters — including color , linewidth , and style — is essential for building readable, professional-grade indicators. This article provides a rigorous, fact-checked walkthrough of the plot() function based strictly on the official Pine Script v6 Reference Manual. 1. What Does plot() Do? The plot() function renders a series of numeric values as a visual element on the chart pane. It returns a plot object, which can later be used with the fill() function to shade areas between two plots. Every call to plot() creates one persistent visual layer on the chart. Reference: https://www.tradingview.com/pine-script-reference/v6/#fun_plot 2. Core Parameters (Individually Verified) Rather than re...
Read more

SuperTrend Indicator in Pine Script v6: Canonical Formula, Flip Logic, and Non-Repainting Signals

Image
Every trend-following trader eventually faces the same frustration: a moving average that lags too far behind price, generating entries long after the move has started and exits well into the reversal. The SuperTrend indicator was designed to solve exactly this problem — it combines Average True Range (ATR) volatility with a dynamic band-switching mechanism to produce a single, clean line that sits below price in an uptrend and above price in a downtrend. When price closes beyond the opposite band, the line flips, generating a confirmed signal on the closed bar. This post builds a precise, well-defined SuperTrend variant in Pine Script v6 , maps every formula term to its code variable, explains the exact flip conditions, and clarifies non-repainting behavior. What Is SuperTrend? The Mathematical Foundation SuperTrend is built on two components: a midpoint price and an ATR-scaled offset . The midpoint is typically the average of the hig...
Read more