Frost Script

tradoor's own language for indicators: readable lines that work out a value on every bar and draw it — lines, histograms, levels, marks, shapes, labels and a table, on the chart or in a pane of their own — with settings of every kind and the same numbers as the built-in indicators.

A script reads the chart's candles and gives back what to draw. That is all it can do: it has no word for the network, your account, your browser or the page, so a script someone else wrote can draw wrong lines at worst, and nothing more. See Safety.

Every built-in indicator that can be written in Frost Script shows its own source: open its settings and the Source tab — the EMA ribbon, Ichimoku, the swing map and the key levels among them. Each gives exactly the numbers the built-in does, and they are the best place to start.

Your first script

1. On a chart, open Add an indicator and press New Frost Script. Writing a script needs you signed in with Telegram.
2. The editor opens on a small script. Change it, or start from one of the examples on the left.
3. Under the text it says ✓ Checks, or which line and column a mistake is on — click the message to go there.
4. Save and add to chart. The script is now one of your indicators, in the picker under My scripts, with its own settings, style and source.

// A moving average, and a mark where price crosses above it
input length = 20 min 2 max 500 "Length"
average = ema(close, length)
plot(average, "Average", blue)
mark(crossover(close, average), "Up", below, green)

How a script runs

The script is worked out once for every bar on the chart, from the oldest to the newest, top to bottom. On each bar, close is that bar's close, a variable holds what it was set to on that bar, and plot puts that bar's point on the line.

• It runs over the chart's closed bars, as the built-in indicators do, and again as each new bar closes. The bar still forming is not part of it: the newest closed bar is the last, and islast is true on it.
• It runs in your browser, in tradoor's own engine for Frost Script. Nothing of it runs on the server.

Writing it down

• One statement a line. ; also ends one, so two may share a line. Inside round brackets a statement may run on over several lines.
• // starts a note, to the end of the line.
• Numbers are written 14, 2.5, .5: digits and one point, 15 digits at most. Texts go in double quotes: "RSI"; "\n" is a line break in one.
• Colours are written by name, as #rrggbb, or with rgb(): see Colours.
• Names are letters, digits and _, starting with a letter or _, up to 40 long. Capitals count: Length is not length.
• These words belong to the language: input state if else for to while break continue fn return and or not pane na true false, and so do the bar values, function, colour and style names below. A variable cannot take them.
• What a function is given goes in order, or by name: plot(x, "X", width = 2), line(a, b, c, d, color = red, style = dashed).

Bar values

Settings

input length = 14 min 2 max 500 "Length"
input mult = 2 min 0.1 max 10 step 0.1 "Multiplier"
input showLabels = true "Show labels"
input lineColor = #2962ff "Line colour"
input size = "small" from "tiny", "small", "normal", "large" "Label size"
input start = date(2024, 1, 1) "Range start"

• A setting is a number, a tick (true or false), a colour, a choice of texts, or a moment (date(year, month, day, hour, minute), UTC). Its settings dialog shows a number field, a tick box, a colour picker, a list or a date to match.
• A number takes any of min, max and step. It takes whole numbers when its default is whole and its step, if it has one, is whole too.
• A choice's value is the text chosen: size == "small".
• The label in quotes is what the settings dialog shows; without one it shows the name.
• A setting is the same on every bar: use it anywhere a number goes, and as a length. Up to 32, at the top level.

Variables and state

range = high - low                 // set on every bar
state count = 0                    // starts at 0 the first time…
count = count + 1                  // …and keeps its value from bar to bar

• name = value sets a variable for this bar. A plain variable starts every bar with no value, until a line sets it.
• state name = start starts once, the first time the line is reached, and keeps its value from one bar to the next: a running total, a trend, a stop that trails, the line it drew. Its start is a plain value — a number, a text, a setting, na — not a function over bars.
• A variable holds a number or a text, and keeps to the one it was first set to.
• A variable can be read before the line that sets it, as average[1] in its own definition.
• A variable may share a function's name — sum, label, rising — as a call has brackets; not a bar value's, a colour's or a word of the language's.

Looking back: x[n]

gap = open - close[1]              // from the close a bar ago
climbing = close > close[1] and close[1] > close[2]

• x[n] is what x ended bar n bars ago on. x[0] is x now.
• It works on number variables and on the bar values: close[1], high[i] in a loop. To look back at a sum, name it first.
• n is from 0 to 5,000, and can be worked out: close[length]. Before the first bar there is no value.

Arithmetic and logic

No value: na

A value can be missing: an average before it has enough bars, close[1] on the first bar, a division by zero. Frost Script calls it na, and a line simply has a gap where its value is na.

• Arithmetic with na gives na; so does a division by zero.
• A comparison with na is not true, so an if on it does not run — and x != y is not true where x is na: write isna(x) or x != y.
• max(na, 0) is na, not 0: no value in, no value out.
• isna(x) asks; nz(x) gives 0 for na, nz(x, y) gives y. As a colour, na is none: nothing is drawn.

Texts

tag = close > open ? "Up" : "Down"
line1 = tag + " " + str(round(change(close), 2))
note = "Since " + duration(time - time[10]) + "\nat " + str(close, decimals)

Texts go into titles, labels, the table and settings' choices; a text a script makes is cut at 1,000 characters.

if, for and while

input length = 10 min 1 max 100
if close > open {
  colour = 1
} else if close < open {
  colour = -1
} else {
  colour = 0
}

total = 0
for i = 0 to length - 1 {
  total = total + volume[i]
}
for k = 9 to 0 by -1 {             // down, by any step
  if close[k] > open[k] {
    break
  }
}

• Blocks go in braces. else may start the line after the closing brace.
• for i = a to b counts up from a to b, both included; if b is below a it does not run. by -1 counts down, by 2 in twos.
• while condition { } goes round while the condition holds. break leaves a loop, continue goes on to its next round. One loop goes round 10,000 times at most.
• Inside if, for and while: setting variables, state, maths, texts, lists, shapes, the table's cells, functions of your own. Not there: plots and marks, settings, pane, and the functions over bars below.

Lists

state swings = list()              // kept from bar to bar
ph = pivothigh(5, 5)
if not isna(ph) {
  swings.push(ph)
}
average = swings.avg()
plot(swings.size() > 0 ? swings.last() : na, "Last swing")

• name = list() makes an empty list of numbers; state name = list() keeps it from bar to bar.
• push(v) pop() shift() unshift(v) get(i) set(i, v) insert(i, v) remove(i) clear() size() first() last() sum() avg() min() max() indexof(v) includes(v) sort() reverse(), each written after the list's name: swings.get(0).
• get(-1) is the last. A place outside the list is an error that says so.
• A list holds numbers: lines and labels by the number they are given, a kind by 1 or 0. Up to 5,000 values — pushed when full, its oldest goes — and 32 lists.

Functions of your own

fn middle(length) {
  return (highest(high, length) + lowest(low, length)) / 2
}
fn band(x, width) {
  return x + width, x - width
}
base = middle(26)
upper, lower = band(base, atr(14))

• fn name(a, b) { … } at the top level; return gives back a value, or several: p, q = f(x). One that gives back nothing is called on a line of its own.
• A function's names are its own. It reads the script's names, but setting one inside makes a new one of the function's: to change the script's, give the value back, or keep it in a list.
• Each call has its own state and its own memory for ema() and the rest, as Pine's do. A function may call others, but not itself. Plots, settings and the pane are not inside functions.

Functions over bars

These remember the bars before: an average needs the last length values. So each one is worked out on every bar, which is why they go outside if, for and while — and why both sides of c ? a : b are always worked out. A length is from 1 to 5,000: a number, a setting, or maths on them such as length * 2 or round(length / 2), rounded to a whole number. It cannot be a variable.

An average that meets na starts over after it, as the built-in indicators do.

Maths

These work out a value from what they are given, and go anywhere.

Colours

green lime red orange yellow blue aqua
teal purple pink white gray black silver
maroon navy olive fuchsia

• Any colour: #ff9800, #f90, #ff980080 (its last two the opacity), rgb(255, 152, 0), rgb(255, 152, 0, 0.5).
• alpha(colour, opacity) sets how solid it is, 0 to 1: alpha(blue, 0.2). gradient(value, low, high, colourLow, colourHigh) mixes between two.
• A colour is a value like any other: c = close > open ? green : red, a setting, a list's value. na is no colour.
• A line with no colour takes the next of blue, orange, purple, aqua, red, green, yellow and pink. Every colour can also be changed in the indicator's Style tab.

Plots, marks and shading

These draw along the bars, at the top level, on every bar. Each line needs a title of its own (up to 40 characters): it is what the legend and the Style tab show.

Lines, labels and boxes

state last = na
ph = pivothigh(5, 5)
if not isna(ph) {
  delete(last)
  last = line(bar - 5, ph, bar + 20, ph, color = red, style = dashed)
  tag = label(bar - 5, ph, "High\n" + str(ph, decimals), color = red, place = above)
}

Shapes are drawn anywhere — in if, loops and functions — and stay until they are deleted. A shape's x is a bar's place (bar, bar - 5, bar + 10 ahead of the newest), its y a price. Each is given back as a number to keep, move or delete it by.

Up to 500 lines, 500 labels and 200 boxes: past these, the oldest goes as a new one is drawn.

The table

table("top right")
averageRange = sma(high - low, 20)
if islast {
  cell(0, 0, "Average range", gray)
  cell(1, 0, str(averageRange, decimals), white, alpha(blue, 0.4))
}

• table("top right"), once at the top level, says where the table stands: top middle bottom, then left center right. It may be a choice setting: table(position).
• cell(column, row, text, color, background) sets one cell, anywhere: columns 0 to 3, rows 0 to 15. Set them on the last bar, with if islast.

Examples

The editor's examples are tradoor's built-in indicators written in Frost Script, each giving exactly the built-in's numbers: SMA, EMA, the EMA 12/25 ribbon and EMA 200, Bollinger Bands, Keltner Channels, Ichimoku, RSI, Stochastic RSI, MACD, ATR, VWAP, anchored VWAP, the historical key levels, the swing structure map, trading sessions, moon phases and volume, and a SuperTrend. Open any of them, or any built-in's Source tab, to read it.

SuperTrend, with a mark at each turn

input length = 10 min 1 max 1000 "ATR length"
input mult = 3 min 0.1 max 10 step 0.1 "Multiplier"
band = mult * atr(length)
state trend = 1
state stop = na
if trend == 1 {
  stop = isna(stop) ? hl2 - band : max(hl2 - band, stop)
  if close < stop {
    trend = -1
    stop = hl2 + band
  }
} else {
  stop = isna(stop) ? hl2 + band : min(hl2 + band, stop)
  if close > stop {
    trend = 1
    stop = hl2 - band
  }
}
turned = changed(trend)
plot(stop, "Stop", trend == 1 ? green : red)
mark(turned and trend == 1, "Buy", below, green)
mark(turned and trend == -1, "Sell", above, red)

The day's range so far, labelled at its high

state dayHigh = na
state dayLow = na
state tag = na
if changed(day) or isna(dayHigh) {
  dayHigh = high
  dayLow = low
} else {
  dayHigh = max(dayHigh, high)
  dayLow = min(dayLow, low)
}
plot(dayHigh, "Day high", green, 1, steps)
plot(dayLow, "Day low", red, 1, steps)
if islast {
  tag = label(bar, dayHigh, "Range " + str(dayHigh - dayLow, decimals), color = alpha(gray, 0.6), place = above, size = small)
}

From Pine Script, with an AI

An indicator written in TradingView's Pine Script v6 can be turned into Frost Script by an AI chat — Claude, ChatGPT, Gemini or another. The instructions below teach it the whole language and how each part of Pine Script maps onto it: its arrays, functions, lines, labels, boxes and tables included.

1. Copy the instructions: the button below, or Pine Script → Frost: copy AI instructions in the Frost Script editor.
2. Paste them into the AI chat, and then the Pine Script v6 source of the indicator.
3. Paste the script it answers with into the editor. It is checked at once: if a line is wrong, give the AI the message and the line, and ask it to put it right.
4. Before you rely on it, put it on a chart beside the original and compare the numbers on a few bars.

Loading…

Mistakes and messages

A script is checked as it is typed. A mistake says its line and column and what is wrong, and the line's number turns red. Some you will meet:

A script that runs into a problem on the chart says so in the chart's legend, beside its name.

Limits

Every script ends, and quickly. One that asks for more than these stops with a message saying where.

Safety

Frost Script is safe by what it is, not by what it forbids. A script is read and worked out by tradoor's own engine for it, written in Rust. It is never turned into JavaScript or any other code a browser runs.

• Nothing to reach. The language has no word for the network, storage, your account, your browser, the page or the clock. In the browser it runs in a module that imports nothing at all: it is given candles and gives back numbers and short texts — what to draw, and where.
• It always ends. Every limit is held, so a script cannot freeze a chart.
• Checked twice. The server checks a script with the same engine when it is saved; your browser checks it again before it runs.
• Text is text. Titles, labels and mark text are shown as plain text, never as page code.
• Moderated. Scripts are looked after by tradoor's moderator, who can remove one that misleads. A removed script runs for no one, its author is told why, and it can be restored.

Your scripts and your account

• Writing and keeping scripts needs you signed in with Telegram: Settings, Account. Signed out, you can read the examples and every built-in's source.
• Your scripts are kept on tradoor's server with your account, so they follow you to every device you sign in on. Up to 100.
• A script on a chart is part of that chart's layout, with its settings and style, like any indicator.
• Deleting a script takes it off the charts of the layout you are in, and it draws on no chart anywhere after.
• A script the moderator removed shows in your list with the reason. It runs for no one and cannot be changed, but you can still read and delete it.

Public scripts and the Community

The indicator picker has three tabs: Built-in, tradoor's own; Community, the scripts their authors made public; and My scripts. One search runs through all three, and each tab says how many it matches.

• A script is private until you make it public: yours alone, on your charts.
• Set it to Public beside its name in the editor, write its description — what it shows, and how to read it, in 30 characters at least — and save. It is listed in the Community under your username, for anyone to add to a chart, signed in or not, and the chart's legend shows it beside the script's name. A public script must check.
• Every public script is on the Community showcase, a page of its own with a link for each to share. Its chart there is drawn live by tradoor's engine, on the market and timeframe of the chart you shared it from, with your settings: open the editor from that chart before you save. No picture is kept.
• Your username is yours to choose, in place of your Telegram name, so you can stay anonymous: Settings, Account, or the editor the first time you share. It is 3 to 20 letters a to z, digits and _, starting with a letter, and one no one else has. You choose it once: it can never be changed, and stays with your Telegram account, so a name on a script always means the same author.
• A change you save to a public script reaches every chart it is on.
• Set it back to Private, or delete it, and it leaves the Community and draws on no one else's chart.
• On a Community script, Copy opens a copy of your own in the editor, to read or to change. Its Source tab shows its text on the chart, too.
• The moderator can remove a public script that misleads: it then runs for no one, and its author is told why.