Pine Script

https://www.tradingview.com/pine-script-docs/
Admin
Pine Script is a domain-specific language for writing custom indicators, strategies, and tools on...
Tokens:883,157
Snippets:4,568
Trust Score:10
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Simple function header example

Source: https://www.tradingview.com/pine-script-docs/language/user-defined-functions

Example of a function header with two parameters, no default values, and no type keywords.

```pine
myFunction(param1, param2) =>
```

--------------------------------

### Pine Script nested if structure for Profiler demo

Source: https://www.tradingview.com/pine-script-docs/writing/profiling-and-optimization

Nested if version of the switch example. Allows the Profiler to report runtime and executions for each condition individually.

```Pine Script
//@version=6
indicator("`switch` and `if...else if` results demo")

//@variable The upper band for oscillator calculation.
var float upperBand = close
//@variable The lower band for oscillator calculation.
var float lowerBand = close

// Update the `upperBand` and `lowerBand` based on the proximity of the `close` to the current band values.
if close > upperBand
    upperBand := close
else
    if close < lowerBand
        lowerBand := close
    else
        if upperBand - close > close - lowerBand
            upperBand := 0.9 * upperBand + 0.1 * close
        else
            if close - lowerBand > upperBand - close
                lowerBand := 0.9 * lowerBand + 0.1 * close

//@variable The ratio of the difference between `close` and `lowerBand` to the band range.
float oscillator = 100.0 * (close - lowerBand) / (upperBand - lowerBand)

// Plot the `oscillator` as columns with a dynamic color.
plot(
     oscillator, "Oscillator", oscillator > 50.0 ? color.teal : color.maroon,
     style = plot.style_columns, histbase = 50.0
 )
```

--------------------------------

### Pine Script Profiling Demo with Dummy Input

Source: https://www.tradingview.com/pine-script-docs/writing/profiling-and-optimization

Example script that queues pseudorandom values in an array and plots the average. Includes a dummy input to allow restarting the script for repetitive profiling. The script uses a fixed seed for math.random() and a fixed-size array.

```Pine Script
//@version=6  
indicator("Repetitive profiling demo")  
  
//@variable An input not connected to script calculations. Changing its value in the "Inputs" tab restarts the script.  
int dummyInput = input.int(0, "Dummy input")  
  
//@variable An array of pseudorandom values.  
var array<float> randValues = array.new<float>(2500, 0.0)  
  
// Push a new `math.random()` value with a fixed `seed` into the `randValues` array and remove the oldest value.  
array.push(randValues, math.random(seed = 12345))  
array.shift(randValues)  
  
// Plot the average of all elements in the `randValues` array.  
plot(array.avg(randValues), "Pseudorandom average")  
```

--------------------------------

### Full script with profiler wrapping

Source: https://www.tradingview.com/pine-script-docs/writing/profiling-and-optimization

Demonstrates how the Profiler wraps an entire Pine Script indicator, adding start time variables and registerPerf() calls around significant code regions. The script calculates pseudorandom series using a user-defined type and method.

```Pine Script
//@version=6
indicator("Profiler's inner workings demo")

int seedInput = input.int(12345, "Seed")

type LCG
    float state

method generate(LCG this, int generations = 1) =>
    float result = 0.0
    for i = 1 to generations
        this.state := 16807 * this.state % 2147483647
        result += this.state / 2147483647
    result / generations

var lcg = LCG.new(seedInput)

var float val0 = 1.0
var float val1 = 1.0
var float val2 = 1.0

if lcg.generate(10) < 0.5
    val0 *= 1.0 + (2.0 * lcg.generate(50) - 1.0) * 0.1
else if lcg.generate(10) < 0.5
    val1 *= 1.0 + (2.0 * lcg.generate(50) - 1.0) * 0.1
else if lcg.generate(10) < 0.5
    val2 *= 1.0 + (2.0 * lcg.generate(50) - 1.0) * 0.1

plot(math.avg(val0, val1, val2), "Average pseudorandom result", color.purple)

```

```Pine Script
long _startMain = System.timeNow() // Start time for the script's overall execution.

// <Additional internal code executes here>

//@version=6
indicator("Profiler's inner workings demo") // Declaration statements do not require profiling.

int seedInput = input.int(12345, "Seed") // Variable declaration without significant calculation.

type LCG        // Type declarations do not require profiling.
    float state

method generate(LCG this, int generations = 1) => // Function signature does not affect runtime.
    float result = 0.0 // Variable declaration without significant calculation.

    long _start11 = System.timeNow() // Start time for the loop block that begins on line 11.
    for i = 1 to generations // Loop header calculations are not independently wrapped.

        long _start12 = System.timeNow() // Start time for line 12.
        this.state := 16807 * this.state % 2147483647
        registerPerf(System.timeNow() - _start12, line12) // Register performance info for line 12.

        long _start13 = System.timeNow() // Start time for line 13.
        result += this.state / 2147483647
        registerPerf(System.timeNow() - _start13, line13) // Register performance info for line 13.

```

--------------------------------

### Compare box.delete()/box.new() vs box.set*() for updating boxes

Source: https://www.tradingview.com/pine-script-docs/writing/profiling-and-optimization

Use this Pine Script example to see the performance difference between redrawing boxes with box.delete() and box.new() versus updating them with box.set_lefttop() and box.set_rightbottom(). The script creates two arrays of 25 boxes, then on each bar updates one array by redrawing and the other by setting properties. Profiling shows the box.new() call is the heaviest line, taking about double the combined time of the setter calls.

```Pine Script
//@version=6  
indicator("Avoiding redrawing demo")

//@variable An array of `box` IDs deleted with `box.delete()` and redrawn with `box.new()` on each execution.
var array<box> redrawnBoxes = array.new<box>()
//@variable An array of `box` IDs with properties that update across executions update via `box.set*()` functions.
var array<box> updatedBoxes = array.new<box>()

// Populate both arrays with 25 elements on the first bar.  
if barstate.isfirst
    for i = 1 to 25
        array.push(redrawnBoxes, box(na))
        array.push(updatedBoxes, box.new(na, na, na, na))

for i = 0 to 24
    // Calculate coordinates.
    int x = bar_index - i
    float y = close[i + 1] - close
    // Get the `box` ID from each array at the `i` index.
    box redrawnBox = redrawnBoxes.get(i)
    box updatedBox = updatedBoxes.get(i)
    // Delete the `redrawnBox`, create a new `box` ID, and replace that element in the `redrawnboxes` array.
    box.delete(redrawnBox)
    redrawnBox := box.new(x - 1, y, x, 0.0)
    array.set(redrawnBoxes, i, redrawnBox)
    // Update the properties of the `updatedBox` rather than redrawing it.  
    box.set_lefttop(updatedBox, x - 1, y)
    box.set_rightbottom(updatedBox, x, 0.0)

```

--------------------------------

### Alternative for…in loop syntax with index and value

Source: https://www.tradingview.com/pine-script-docs/writing/profiling-and-optimization

This snippet shows the alternative for…in loop syntax that provides the index and value directly, eliminating the need for `array.indexof()`. The source text only shows this line as an example of the improved loop structure.

```Pine Script
for [index, item] in data
```

--------------------------------

### Unoptimized table update loop

Source: https://www.tradingview.com/pine-script-docs/writing/profiling-and-optimization

This Pine Script v6 example creates a table with RSI history and updates it on every bar. The for loop updating the table cells runs excessively across historical bars, which is inefficient since users only see the final result on historical bars.

```Pine Script
//@version=6  
indicator("Reducing drawing updates demo")  
  
//@variable The first offset shown in the paginated table.  
int offsetInput = input.int(0, "Page", 0, 249) * 20  
  
//@variable A table that shows the history of RSI values.  
var table infoTable = table.new(position.top_right, 2, 21, border_color = chart.fg_color, border_width = 1)  
// Initialize the table's cells on the first bar.  
if barstate.isfirst  
    table.cell(infoTable, 0, 0, "Offset", text_color = chart.fg_color)  
    table.cell(infoTable, 1, 0, "RSI", text_color = chart.fg_color)  
    for i = 0 to 19  
        table.cell(infoTable, 0, i + 1, str.tostring(offsetInput + i))  
        table.cell(infoTable, 1, i + 1)  
  
float rsi = ta.rsi(close, 14)  
  
// Update the history shown in the `infoTable` on each bar.  
for i = 0 to 19  
    float historicalRSI = rsi[offsetInput + i]  
    table.cell_set_text(infoTable, 1, i + 1, str.tostring(historicalRSI))  
    table.cell_set_bgcolor(  
         infoTable, 1, i + 1, color.from_gradient(historicalRSI, 30, 70, color.red, color.green)  
     )  
  
plot(rsi, "RSI")  
```

--------------------------------

### Weighted moving average with custom weights

Source: https://www.tradingview.com/pine-script-docs/writing/profiling-and-optimization

Calculates a weighted moving average using a cosine-based window function. The loop computes weights and accumulates sums; the result is plotted. This example is used to profile performance and identify optimization opportunities.

```Pine Script
//@version=6  
indicator("Storing calculated values demo", overlay = true)  
  
//@variable The number of bars in the weighted average calculation.  
int lengthInput = input.int(50, "Length", 1, 5000)  
//@variable Window coefficient.   
float coefInput = input.float(0.5, "Window coefficient", 0.0, 1.0, 0.01)  
  
//@variable The sum of weighted `close` prices.  
float numerator = 0.0  
//@variable The sum of weights.  
float denominator = 0.0  
  
//@variable The angular step in the cosine calculation.  
float step = 2.0 * math.pi / lengthInput  
// Accumulate weighted sums.  
for i = 0 to lengthInput - 1  
    float weight = coefInput - (1 - coefInput) * math.cos(step * i)  
    numerator += close[i] * weight  
    denominator += weight  
  
// Plot the weighted average result.  
plot(numerator / denominator, "Weighted average", color.purple, 3)  
```

--------------------------------

### Unused code demo: Profiler shows no results

Source: https://www.tradingview.com/pine-script-docs/writing/profiling-and-optimization

This Pine Script example demonstrates that when a script's outputs do not depend on certain calculations, the compiler discards them, and the Profiler shows no performance results. The script declares an input and a loop that counts bars in range, but only plots the close price, so the unused code is removed. Note that the input still appears in the script's settings even though it is unused.

```Pine Script
//@version=6  
indicator("Unused code demo")  
  
//@variable The number of historical bars in the calculation.  
int lengthInput = input.int(100, "Length", 1)  
  
//@variable The number of closes over `lengthInput` bars between the current bar's `high` and `low`.  
int barsInRange = 0  
  
for i = 1 to lengthInput  
    //@variable The `close` price from `i` bars ago.  
    float pastClose = close[i]  
    // Add 1 to `barsInRange` if the `pastClose` is between the current bar's `high` and `low`.  
    if pastClose > low and pastClose < high  
        barsInRange += 1  
  
// Plot the `close` price. This is the only output.  
// Since the outputs do not require any of the above calculations, the compiled script will not execute them.  
plot(close)  
```

--------------------------------

### Profiler internal pseudocode for performance measurement

Source: https://www.tradingview.com/pine-script-docs/writing/profiling-and-optimization

This pseudocode outlines the internal calculations the Profiler applies to collect performance data. It is not valid Pine Script and will cause a compilation error if saved in the Pine Editor. The code wraps blocks with start time and registerPerf calls, and notes that the 'Line time' for conditional blocks represents the time for all conditional statements.

```pseudocode
registerPerf(System.timeNow() - _start11, line11, line13) // Register performance info for the block (line 11 - 13).

long _start14 = System.timeNow() // Start time for line 14.
result / generations
registerPerf(System.timeNow() - _start14, line14) // Register performance info for line 14.

long _start16 = System.timeNow() // Start time for line 16.
var lcg = LCG.new(seedInput)
registerPerf(System.timeNow() - _start16, line16) // Register performance info for line 16.

var float val0 = 1.0 // Variable declarations without significant calculations.
var float val1 = 1.0
var float val2 = 1.0

long _start22 = System.timeNow() // Start time for the `if` block that begins on line 22.
if lcg.generate(10) < 0.5 // `if` statement is not independently wrapped.

    long _start23 = System.timeNow() // Start time for line 23.
    val0 *= 1.0 + (2.0 * lcg.generate(50) - 1.0) * 0.1
    registerPerf(System.timeNow() - _start23, line23) // Register performance info for line 23.

else if lcg.generate(10) < 0.5 // `else if` statement is not independently wrapped.

    long _start25 = System.timeNow() // Start time for line 25.
    val1 *= 1.0 + (2.0 * lcg.generate(50) - 1.0) * 0.1
    registerPerf(System.timeNow() - _start25, line25) // Register performance info for line 25.

else if lcg.generate(10) < 0.5 // `else if` statement is not independently wrapped.

    long _start27 = System.timeNow() // Start time for line 27.
    val2 *= 1.0 + (2.0 * lcg.generate(50) - 1.0) * 0.1
    registerPerf(System.timeNow() - _start27, line27) // Register performance info for line 27.

registerPerf(System.timeNow() - _start22, line22, line28) // Register performance info for the block (line 22 - 28).

long _start29 = System.timeNow() // Start time for line 29.
plot(math.avg(val0, val1, val2), "Average pseudorandom result", color.purple)
registerPerf(System.timeNow() - _start29, line29) // Register performance info for line 29.

// <Additional internal code executes here>

registerPerf(System.timeNow() - _startMain, total) // Register the script's overall performance info.
```

--------------------------------

### Start of compound condition debugging example

Source: https://www.tradingview.com/pine-script-docs/writing/debugging

This is the beginning of a Pine Script example that calculates RSI and its median, then defines a compound condition from five singular conditions. The snippet shows the setup for the RSI and median calculations and the first condition (changeNegative).

```Pine Script
//@version=6  
indicator("Plotting and coloring compound conditions demo")  
  
//@variable The length of the RSI and median RSI calculations.  
int lengthInput = input.int(14, "Length", 2)  
  
//@variable The RSI of `close` with a smoothing factor defined by `lengthInput`.  
float rsi = ta.rsi(close, lengthInput)  
//@variable The median of the `rsi` over `lengthInput` bars.  
float median = ta.median(rsi, lengthInput)  
  
//@variable Condition #1: Is `true` when the 1-bar `rsi` change switches from 1 to -1.  
bool changeNegative = ta.change(math.sign(ta.change(rsi))) == -2  

```

--------------------------------

### Strategy with calc_on_order_fills = true

Source: https://www.tradingview.com/pine-script-docs/concepts/strategies

This example uses strategy.entry() to place a 'Buy' entry order when position size is 0 and strategy.exit() to place 'Exit' bracket orders. With calc_on_order_fills = true, the strategy recalculates on each tick where an order fills, allowing immediate updates to stop-loss and take-profit prices based on the updated position average price. The script can repaint on realtime bars because fills on historical bars may occur at different prices than on realtime bars.

```pine
//@version=6
strategy("Executions after order fills demo", overlay = true, calc_on_order_fills = true)

float stopSize = input.float(5.0, "SL %", minval = 0.0) / 100.0
float profitSize = input.float(5.0, "TP %", minval = 0.0) / 100.0

// The condition that triggers the entry order is `true` after each tick where an "Exit"
// order fills.
if strategy.position_size == 0.0
    strategy.entry("Buy", strategy.long)

// After each order fill, the values of these variables update immediately rather
// than only at the bar's closing tick.
float stopLoss = strategy.position_avg_price * (1.0 - stopSize)
float takeProfit = strategy.position_avg_price * (1.0 + profitSize)
strategy.exit("Exit", stop = stopLoss, limit = takeProfit)
```

--------------------------------

### Array example

Source: https://www.tradingview.com/pine-script-docs/release-notes

Shows basic array usage: create a float array, push values in a loop, and plot an element.

```pine
//@version=4
study("My Script")
a = array.new_float(0)
for i = 0 to 5
    array.push(a, close[i] - open[i])
plot(array.get(a, 4))
```

--------------------------------

### Valid and invalid identifier examples

Source: https://www.tradingview.com/pine-script-docs/language/identifiers

Examples of valid and invalid identifiers in Pine Script. Identifiers must start with a letter or underscore, can contain letters, underscores, and digits, and are case-sensitive. The last example, '3barsDown', is invalid because it starts with a digit.

```pine
myVar  
_myVar  
my123Var  
functionName  
MAX_LEN  
max_len  
maxLen  
3barsDown  // NOT VALID!  
```

--------------------------------

### Pyramiding demo with default pyramiding value

Source: https://www.tradingview.com/pine-script-docs/concepts/strategies

This example calls strategy.entry() once every 25 bars, changing direction every 100 bars. With the default pyramiding value of 1, only the first entry order in each 100-bar cycle results in a new trade; subsequent calls are ignored until the position closes.

```pine
//@version=6
strategy("Pyramiding demo", overlay = true)

//@variable Represents the direction of the entry orders. A value of 1 means long, and -1 means short.
var int direction = 1

//@variable Is `true` once every 25 bars, and `false` otherwise.
bool entryCondition = bar_index % 25 == 0

// Change the `direction` value on every 100th bar.
if bar_index % 100 == 0
    direction *= -1

// Place a market order based on the current `direction` value when the `entryCondition` value is `true`.
if entryCondition
    strategy.entry("Entry", direction == 1 ? strategy.long : strategy.short)

//@variable When the entry condition occurs, is a blue color if the `direction` is 1 and a red color otherwise.
color bgColor = entryCondition ? (direction == 1 ? color.new(color.blue, 80) : color.new(color.red, 80)) : na

// Highlight the chart's background using the `bgColor` value.
bgcolor(bgColor, title = "Order highlight")
```

--------------------------------

### Style guide identifier naming examples

Source: https://www.tradingview.com/pine-script-docs/language/identifiers

Recommended identifier naming conventions from the Pine Script Style Guide: use uppercase SNAKE_CASE for constants and camelCase for other identifiers. The example includes a constant, a variable, and a function definition.

```pine
GREEN_COLOR = #4CAF50
MAX_LOOKBACK = 100
int fastLength = 7
// Returns 1 if the argument is `true`, 0 if it is `false` or `na`.
zeroOne(boolValue) => boolValue ? 1 : 0
```

--------------------------------

### Pyramiding demo with pyramiding = 4

Source: https://www.tradingview.com/pine-script-docs/concepts/strategies

This example modifies the previous script by setting `pyramiding = 4` in the strategy() declaration, allowing up to four entry orders in the same direction. With this change, all entry orders result in new trades.

```pine
//@version=6
strategy("Pyramiding demo", overlay = true, pyramiding = 4)

//@variable Represents the direction of the entry orders. A value of 1 means long, and -1 means short.
var int direction = 1

//@variable Is `true` once every 25 bars, and `false` otherwise.
bool entryCondition = bar_index % 25 == 0

// Change the `direction` value on every 100th bar.
if bar_index % 100 == 0
    direction *= -1

// Place a market order based on the current `direction` value when the `entryCondition` value is `true`.
if entryCondition
    strategy.entry("Entry", direction == 1 ? strategy.long : strategy.short)

//@variable When the entry condition occurs, is a blue color if the `direction` is 1 and a red color otherwise.
color bgColor = entryCondition ? (direction == 1 ? color.new(color.blue, 80) : color.new(color.red, 80)) : na

// Highlight the chart's background using the `bgColor` value.
bgcolor(bgColor, title = "Order highlight")
```

--------------------------------

### Using request.security_lower_tf() to get first intrabar close

Source: https://www.tradingview.com/pine-script-docs/concepts/other-timeframes-and-data

This example demonstrates how to use request.security_lower_tf() to retrieve an array of intrabar closes and then use array.first() to get the first intrabar close, which helps mitigate repainting. It also highlights realtime bars.

```Pine Script
//@version=6  
indicator("Avoiding LTF repainting demo", overlay = true)  

//@variable The lower timeframe of the requested data.  
string lowerTimeframe = input.timeframe("1", "Timeframe")  

//@variable An array of intrabar `close` values requested from the `lowerTimeframe` on each bar.  
array<float> requestedCloses = request.security_lower_tf(syminfo.tickerid, lowerTimeframe, close)  

//@variable The first intrabar `close` on each bar with available data.  
float firstClose = requestedCloses.size() > 0 ? requestedCloses.first() : na  

// Plot the `firstClose`.  
plot(firstClose, "First intrabar close", linewidth = 3)  
// Highlight the background on realtime bars.  
bgcolor(barstate.isrealtime ? color.new(color.orange, 60) : na, title = "Realtime bar Highlight")  
```

--------------------------------

### Array example with push, shift, and table display

Source: https://www.tradingview.com/pine-script-docs/faq/data-structures

Creates an array of five float values, pushes the current close on each bar, and shifts out the oldest element. Displays the array contents in a table on the last bar.

```pine
//@version=6
indicator("Array example")
// Declare an array with 5 `na` values on the first bar.
var array<float> pricesArray = array.new<float>(5)
// On each bar, add a new value to the end of the array and remove the first (oldest) element.
array.push(pricesArray, close)
array.shift(pricesArray)
// Display the array and its contents in a table.
var table displayTable = table.new(position.middle_right, 1, 1)
if barstate.islast
    table.cell(displayTable, 0, 0, str.tostring(pricesArray), text_color = chart.fg_color)

```

--------------------------------

### Using array.sort_indices() to get sorted indices without modifying the original array

Source: https://www.tradingview.com/pine-script-docs/language/arrays

This example demonstrates how to use array.sort_indices() to get an array of indices that represent the sorted order of the original array's elements without modifying the original array. It queues close values into a persistent array, sorts the indices on the last historical bar, and displays the sorted values along with their original and sorted positions in a label.

```Pine Script
//@version=6  
indicator("Getting sorted indices demo")

//@variable References a persistent array that stores the last 10 `close` values.
var array<float> prices = array.new<float>(10)
// Push a new value to the end of the array, and remove the oldest (first) element.
prices.push(close)
prices.shift()

if barstate.islastconfirmedhistory
    //@variable References an "int" array containing the `prices` array indices in ascending order by element value.  
    //          The `array.sort_indices()` call maps sorted positions in the array without modifying it.
    array<int> indices = prices.sort_indices()
    //@variable A formatted string to display in a label.
    string displayStr = str.format("Prices: {0}\n\nSorted indices: {1}\n\nSort results:", prices, indices)

    // Loop through the `indices` array.
    // The `i` variable stores the current index of the `indices` array's element.
    // The `index` variable stores that element's value (the index for one of the `prices` array's elements).
    // Using `index` to retrieve `prices` array's elements accesses those elements in ascending order.
    for [i, index] in indices
        // Concatenate the `displayStr` value with a string representing the sorted `prices` array element,  
        // the original position (index) of the element, and the sorted position of that element.  
        displayStr += str.format(
            "\nPrice: {0,number,0.000}, Original position: {1} -> Sorted position: {2}",  
            prices.get(index), index, i
        )
    // Display the final string's text in a label.
    label.new(
        bar_index, 0, displayStr, style = label.style_label_center, size = 20,  
        textalign = text.align_left, text_font_family = font.family_monospace
    )
```

--------------------------------

### strategy.exit() qty_percent example

Source: https://www.tradingview.com/pine-script-docs/release-notes

Shows the new behavior of the qty_percent parameter in strategy.exit(). With this script, 20% of the initial position is closed on each strategy.exit() call, rather than 20% of the remaining position as before.

```pine
//@version=5
strategy("strategy.exit() example", overlay = true)
strategy.entry("Long", strategy.long, qty = 100)
strategy.exit("Exit Long1", "Long", trail_points = 50, trail_offset = 0, qty_percent = 20)
strategy.exit("Exit Long2", "Long", trail_points = 100, trail_offset = 0, qty_percent = 20)
```

--------------------------------

### Accumulate volume with `var` keyword in Pine Script

Source: https://www.tradingview.com/pine-script-docs/faq/variables-and-operators

Shows how to use the `var` keyword to create a persistent variable that retains its value across bars, while a normal variable is reset on each bar. The example accumulates volume in `a` and `b`, resetting both at the start of each day, and plots them with different styles and colors.

```pine
//@version=6
indicator("Var keyword example")

// Declare and initialize a persistent variable by using `var`.
var float a = 0
// Declare and initialize a normal float variable.
float b = 0

// Reset the values of a and b whenever a new day begins.
if timeframe.change("D")
    a := 0
    b := 0

// Add the current volume to both a and b.
a += volume
b += volume

// Plot the values of `a` and `b`. The value of `a` accumulates over time; `b` is reinitialized at every bar.
plot(a, "a", close > open ? #089981 : #f23645, style = plot.style_columns)
plot(b, "b", color.yellow)
```

--------------------------------

### Initialize array with array.unshift()

Source: https://www.tradingview.com/pine-script-docs/language/arrays

Creates an empty array and inserts elements at the beginning using array.unshift() on the first bar. This is equivalent to the array.push() example but prepends elements instead of appending.

```Pine Script
// Declare array and set its values on the first bar only.  
var fillColors = array.new<color>(0)  
if barstate.isfirst  
    // Initialize the array elements with progressively lighter shades of the fill color.  
    array.unshift(fillColors, color.new(FILL_COLOR, 90))  
    array.unshift(fillColors, color.new(FILL_COLOR, 85))  
    array.unshift(fillColors, color.new(FILL_COLOR, 80))  
    array.unshift(fillColors, color.new(FILL_COLOR, 75))  
    array.unshift(fillColors, color.new(FILL_COLOR, 70))  

```
Tokens:
Raw