Indicators Lab

The Indicators Lab is the workspace where you browse, author, test, and manage the indicators that power your strategies. This page is a complete reference: the workspace, the formula language, every built-in function, the schema, and worked examples.

The Workspace

Open the lab at /indicators. It has three tabs:

A right-hand chart panel previews any selected indicator on real candles with per-output statistics.

Two Ways to Author an Indicator

Generate it with AI

In the Custom tab, describe the indicator in plain language. The model writes a complete indicator — inputs, outputs, and logic — and the server executes it on real candles to verify it runs, automatically correcting itself if the engine reports an error. Generation runs server-side and survives a page refresh. The result loads into the editor for review.

Write it in the formula language

You can also author an indicator directly in the editor using the lab's purpose-built formula language, documented in full below. The editor provides syntax highlighting, line numbers, and validation on save.

The Formula Language

The formula language is a declarative, vectorized, single-pass language for time series. You do not write loops over bars — every expression operates on the entire price series at once, and the engine evaluates it efficiently in one pass. This makes indicators concise and fast.

An indicator has three parts:

1. Inputs — the tunable parameters (lengths, multipliers, thresholds, source).
2. Outputs — the series, levels, and events the indicator produces.
3. Source — the formula that computes the outputs from price.

Statements

The source is a list of statements, one per line:

let NAME = EXPRESSION        // declare a reusable series or value
plot("OUTPUT_KEY", EXPRESSION)        // emit a numeric series output
event("OUTPUT_KEY", BOOLEAN_EXPRESSION)   // emit a boolean signal output

• let binds a name to an expression so you can reuse it. Declare a name before you use it.
• plot(...) emits a numeric series. Its OUTPUT_KEY must be declared as a series or level output.
• event(...) emits a boolean event (a signal). Its OUTPUT_KEY must be declared as an event output.
• Comments start with //.

Price Series (always in scope)

These series are available without declaration:

You can also select a source dynamically with src("close"), src("hl2"), etc. — useful when "source" is an input.

Operators

Arithmetic and comparison operators work element-wise across the series:

• Arithmetic: + - * /
• Comparison (produce a boolean series): > >= < <= == !=

For example, close > ema(close, 50) produces a boolean series that is true on every bar where the close is above its 50-period EMA.

Function Reference

Every function operates element-wise over the full series. x, a, b are series or values; len, n are integers.

Moving Averages & Regression

Momentum & Oscillators

Volatility

Range, Extremes & Stats

Volume

Series Logic & Timing

Conditional & Math

Boolean

Use only the functions and series above. The engine validates this when you save — an unknown name or function is rejected with a clear message, so an indicator that saves is an indicator that runs.

Inputs Schema

inputs_schema exposes every tunable parameter:

{
  "version": 1,
  "inputs": [
    { "key": "len", "label": "Length", "type": "int", "default": 14, "min": 1, "max": 500, "step": 1, "required": true, "ui": { "control": "stepper", "group": "Parameters" } },
    { "key": "src", "label": "Source", "type": "source", "default": "close", "options": ["open","high","low","close","hl2","hlc3","ohlc4"] }
  ]
}

Reference any input by its key directly in the source (an input with key len is used as len).

Outputs Schema

outputs_schema declares everything the indicator produces:

{
  "version": 1,
  "outputs": [
    { "key": "value", "label": "Value", "kind": "series", "data_type": "number", "plot": { "style": "line", "pane": "sub", "line_width": 2 } },
    { "key": "buy", "label": "Buy", "kind": "event", "data_type": "boolean" }
  ]
}

Every plot("key", …) and event("key", …) must reference a declared output key.

Worked Examples

1. RSI with bands and crossover signals

Inputs: len (int, 14), ob (int, 70), os (int, 30), src (source, close). Outputs: rsi (series, sub), buy (event), sell (event).

let r = rsi(src(src), len)
plot("rsi", r)
event("buy", crossover(r, os))
event("sell", crossunder(r, ob))

2. Bollinger Bands with a squeeze event

Inputs: len (int, 20), mult (float, 2). Outputs: upper (series, main), basis (series, main), lower (series, main), squeeze (event).

let basis = sma(close, len)
let band = stdev(close, len) * mult
plot("upper", basis + band)
plot("basis", basis)
plot("lower", basis - band)
event("squeeze", band < median(band, 50) * 0.6)

3. Adaptive RSI (length tightens with volatility)

Uses zscore and clamp to shorten the RSI length when volatility expands.

let vol = zscore(atr(14), 50)
let adaptiveLen = round(clamp(len - vol * 4, 5, 40))
let r = rsi(close, adaptiveLen)
plot("rsi", r)
plot("signal", ema(r, 5))
event("bull", crossover(r, ema(r, 5)))

4. Volume-pressure / relative volume

Inputs: len (int, 20), spike (float, 2). Outputs: rvol (series, sub), vol_ma (series, sub), high_volume (event).

let vavg = sma(volume, len)
let rvol = volume / vavg
plot("rvol", rvol)
plot("vol_ma", vavg)
event("high_volume", rvol > spike)

5. Trend strength via regression slope

let s = slope(close, 50)
plot("slope", s)
event("trend_up", s > 0 and rising(s, 3))
event("trend_down", s < 0 and falling(s, 3))

Preview, Customize, and Use

• Preview / Test: select a symbol, timeframe, and candle window, then render candles with your indicator overlaid, plus per-output statistics (min, max, last value, signal counts).
• Customize a built-in: built-in indicators are shared and read-only; the Customize action creates your own editable copy, saved to your profile only — it never affects the built-in or other users.
• Use in a strategy: reference your indicator by name in text-to-strategy, add the Custom Indicator block in the simple builder, or wire its custom node in the blueprint builder.

Custom indicators are strictly per-user: you can only edit your own, and nothing you do affects the shared library or anyone else's work.

Next Steps

• Generate an indicator with AI
• The Indicators Lab — complete guide
• Create your first blueprint