Pine Script v5 Complete Guide: Build Indicators & Strategies on TradingView Desktop

Running TradingView on Windows? Get the full PC setup guide at tradingviewdownloadforpc.com — authorized install walkthrough with screenshots.

Last updated: May 2026 | Author: Michael Hannah | Platform: Windows 10 / Windows 11 | Pine Script version: v5

TL;DR

Pine Script v5 is TradingView's built-in scripting language for custom indicators and backtestable strategies. If you already know Python or JavaScript, you can write a working indicator in under 30 minutes. This guide takes you from opening the editor to a production-grade strategy with entry/exit logic, risk management, and a backtest performance report — all running on TradingView Desktop for Windows.

What Is Pine Script?

Pine Script is a domain-specific language (DSL) designed for financial chart analysis on TradingView. First released in 2016 and now on version 5 (v5, released 2021), it is:

• Series-based: every variable is implicitly a time series — close is the closing price of every bar on the chart
• Vectorized by default: code executes once per bar from oldest to newest; no loops required for bar-by-bar logic
• Sandboxed: runs on TradingView's infrastructure, not on your machine, with no external network access
• Full-featured: conditionals, loops, functions, custom types (UDTs), libraries, matrices, and maps in v5

As of 2026, Pine Script has over 100,000 published community scripts in the TradingView public library.

Opening the Pine Script Editor on Windows Desktop

With TradingView installed on your PC (full setup guide):

1. Open any chart
2. Click "Pine Editor" at the bottom panel — or press Alt+P
3. Click "Open new script" to start from a blank file
4. The editor provides syntax highlighting, auto-completion, and inline documentation

The desktop app gives the Pine Editor more vertical real estate than the browser — particularly useful for scripts longer than 100 lines.

Pine Script v5 Language Fundamentals

Key Built-in Series

Essential TA Functions

Building an Indicator: EMA Ribbon

An EMA ribbon overlays multiple exponential moving averages to visualize trend strength and direction. Here's a production-quality version with configurable bands:

//@version=5
indicator("EMA Ribbon", overlay=true, max_lines_count=500)

// --- Inputs
fast  = input.int(8,  "Fast EMA",   minval=1, maxval=50)
mid   = input.int(21, "Mid EMA",    minval=1, maxval=100)
slow  = input.int(55, "Slow EMA",   minval=1, maxval=200)
ultra = input.int(200,"Ultra EMA",  minval=50, maxval=500)

// --- Calculations
e_fast  = ta.ema(close, fast)
e_mid   = ta.ema(close, mid)
e_slow  = ta.ema(close, slow)
e_ultra = ta.ema(close, ultra)

// --- Trend state
bullish = e_fast > e_mid and e_mid > e_slow and e_slow > e_ultra
bearish = e_fast < e_mid and e_mid < e_slow and e_slow < e_ultra

// --- Plots
p_fast  = plot(e_fast,  "Fast ("  + str.tostring(fast)  + ")", color=bullish ? color.green : bearish ? color.red : color.gray, linewidth=1)
p_mid   = plot(e_mid,   "Mid ("   + str.tostring(mid)   + ")", color=bullish ? color.green : bearish ? color.red : color.gray, linewidth=1)
p_slow  = plot(e_slow,  "Slow ("  + str.tostring(slow)  + ")", color=bullish ? color.green : bearish ? color.red : color.gray, linewidth=2)
p_ultra = plot(e_ultra, "Ultra (" + str.tostring(ultra) + ")", color=color.navy, linewidth=3)

// --- Fill between fast and slow for visual clarity
fill(p_fast, p_slow, color=bullish ? color.new(color.green, 85) :
     bearish ? color.new(color.red, 85) : color.new(color.gray, 90))

// --- Alert conditions
alertcondition(ta.crossover(e_fast, e_slow),  "Ribbon Bullish Cross", "EMA ribbon turned bullish on {{ticker}}")
alertcondition(ta.crossunder(e_fast, e_slow), "Ribbon Bearish Cross", "EMA ribbon turned bearish on {{ticker}}")

Building a Strategy: RSI Mean Reversion with ATR Stops

A strategy script replaces indicator() with strategy() and unlocks the Strategy Tester backtest engine. This example implements a classic RSI mean-reversion setup with ATR-based stop loss and take profit:

//@version=5
strategy(
  title            = "RSI Mean Reversion",
  overlay          = true,
  initial_capital  = 10000,
  default_qty_type = strategy.percent_of_equity,
  default_qty_value= 10,           // Risk 10% of equity per trade
  commission_type  = strategy.commission.percent,
  commission_value = 0.1,          // 0.1% per side (typical for crypto spot)
  slippage         = 2             // 2 ticks slippage assumption
)

// --- Inputs
rsiLen    = input.int(14, "RSI Length", minval=2)
oversold  = input.int(30, "Oversold Level", minval=10, maxval=49)
overbought= input.int(70, "Overbought Level", minval=51, maxval=90)
atrLen    = input.int(14, "ATR Length", minval=1)
atrMult   = input.float(2.0, "ATR Stop Multiplier", minval=0.5, step=0.1)
tpMult    = input.float(3.0, "ATR TP Multiplier",   minval=0.5, step=0.1)

// --- Calculations
rsiValue = ta.rsi(close, rsiLen)
atrValue = ta.atr(atrLen)

// --- Entry conditions
longEntry  = ta.crossover(rsiValue, oversold)   // RSI crosses back above oversold
shortEntry = ta.crossunder(rsiValue, overbought) // RSI crosses back below overbought

// --- Dynamic stop loss & take profit
longStop  = close - atrValue * atrMult
longTP    = close + atrValue * tpMult
shortStop = close + atrValue * atrMult
shortTP   = close - atrValue * tpMult

// --- Orders
if longEntry
    strategy.entry("Long", strategy.long)
    strategy.exit("Long Exit", "Long", stop=longStop, limit=longTP)

if shortEntry
    strategy.entry("Short", strategy.short)
    strategy.exit("Short Exit", "Short", stop=shortStop, limit=shortTP)

// --- Visuals
rsiColor = rsiValue < oversold ? color.green : rsiValue > overbought ? color.red : color.gray
bgcolor(longEntry ? color.new(color.green, 90) : shortEntry ? color.new(color.red, 90) : na)

plotshape(longEntry,  "Long Signal",  shape.triangleup,   location.belowbar, color.green, size=size.small)
plotshape(shortEntry, "Short Signal", shape.triangledown, location.abovebar, color.red,   size=size.small)

Reading Backtest Results

After clicking "Add to chart", open the "Strategy Tester" tab. Key metrics to evaluate:

Important: Backtests are susceptible to overfitting. A strategy that performs exceptionally on historical data often degrades on live data. Use walk-forward testing and out-of-sample periods to validate.

Multi-Timeframe Analysis (MTF)

Pull data from a higher timeframe into your current chart using request.security():

//@version=5
indicator("MTF Trend Filter", overlay=false)

// Current timeframe RSI
rsiLen   = input.int(14, "RSI Length")
htf      = input.timeframe("D", "Higher Timeframe")

currentRsi = ta.rsi(close, rsiLen)
htfClose   = request.security(syminfo.tickerid, htf, close)
htfRsi     = ta.rsi(htfClose, rsiLen)

// Plots
plot(currentRsi, "RSI (Current TF)", color=color.purple, linewidth=2)
plot(htfRsi,     "RSI (" + htf + ")", color=color.orange, linewidth=2)
hline(70, "Overbought", color=color.red,   linestyle=hline.style_dashed)
hline(50, "Midline",    color=color.gray,  linestyle=hline.style_dotted)
hline(30, "Oversold",   color=color.green, linestyle=hline.style_dashed)

// Trend alignment signal
bullAlignment = currentRsi > 50 and htfRsi > 50
bearAlignment = currentRsi < 50 and htfRsi < 50
bgcolor(bullAlignment ? color.new(color.green, 93) : bearAlignment ? color.new(color.red, 93) : na)

Code Organization Best Practices

For scripts longer than 50 lines, structure them consistently:

//@version=5
indicator("My Script", overlay=true)

// ════════════════════════════════════════
// 1. INPUTS
// ════════════════════════════════════════
length = input.int(20, "Period")

// ════════════════════════════════════════
// 2. CALCULATIONS
// ════════════════════════════════════════
sma = ta.sma(close, length)
dev = ta.stdev(close, length)

// ════════════════════════════════════════
// 3. CONDITIONS
// ════════════════════════════════════════
aboveSma = close > sma

// ════════════════════════════════════════
// 4. PLOTS & ALERTS
// ════════════════════════════════════════
plot(sma, "SMA", color=aboveSma ? color.green : color.red)
alertcondition(ta.crossover(close, sma), "Price crossed above SMA")

Publishing Your Script

To share a script with the TradingView community:

1. Click the "Publish script" button in the Pine Editor
2. Choose "Open source" (visible to all) or "Invite-only"
3. Add a title, description, and relevant tags
4. Published scripts appear in the Community Scripts library

Scripts gain visibility through likes, comments, and usage metrics. High-quality scripts with clear documentation are frequently featured in TradingView's editorial picks.

Frequently Asked Questions

Q: What version of Pine Script should I use in 2026?
Always use Pine Script v5, the current stable version as of 2026. Start every script with //@version=5. Previous versions (v3, v4) are still supported for legacy scripts but should not be used for new development. The Pine Script team has stated that v5 is the long-term supported version.

Q: Can Pine Script access external APIs or data?
No. Pine Script runs in a sandboxed environment on TradingView's servers and cannot make outbound HTTP requests. To integrate with external APIs, use TradingView's alert webhook system — Pine Script fires the alert, and your external server handles the API call.

Q: What is the maximum number of bars Pine Script can look back?
The default historical data limit is 5,000 bars on free accounts and up to 20,000 bars on paid plans. You can check the available bar count with bar_index + 1 on the last bar.

Q: Is there a Pine Script IDE or local development environment?
Pine Script has no official local IDE — it runs exclusively in TradingView's browser or desktop editor. However, third-party tools like @kaigouthro's syntax highlighter for VS Code exist for editing locally and pasting into the TradingView editor.

Q: Can Pine Script strategies execute real trades?
Not directly. Pine Script strategies are simulation-only. To execute real trades, connect TradingView alerts to a broker integration (e.g., Interactive Brokers via TradeStation, or a custom webhook receiver that calls your broker's API).

Q: What is the performance difference between indicators and strategies?
strategy() scripts are significantly heavier than indicator() scripts because they simulate order fills, track open P&L, and calculate the full performance report on every bar recalculation. Expect ~3–5x longer load times for strategy scripts on the same chart.

Resources

• Pine Script v5 Reference Manual — complete function and keyword reference
• Pine Script v5 User Manual — conceptual guide with examples
• TradingView PC Setup Guide — install TradingView on Windows

By Michael Hannah — trading software analyst and Pine Script developer. Updated May 2026.