Quick reference

The wrun kit on one screen, then the parts of it that are easiest to forget: the two hooks, the generated accessors (the p_ / in_ / out_ families plus the cell and string families and the bar's own fields), every declaration signature, the fifteen setting kinds and the block kit, the sources the chart serves and their fields, the TA classes, and the kit modules. This page lists what a wrun indicator declares, because an indicator says what it reads and writes and the chart does the calling.

One screen

The hooks

A file is its declarations at the top, then module state, then one or two plain functions (no export, nothing to import):

Every bar emits a row: an output onBar() does not write is NaN on that bar and draws nothing there, so warm-up is a return before the writes, or a NaN written as it is. There is no fourth function to write: the chart replays the forming bar from a snapshot of the module's memory.

Accessors (generated from your declarations each time the editor compiles, in scope with nothing to import)

Declarations (top-level statements of your file)

Vocabulary the declarations take:

Settings

Fifteen kinds, each a top-level param.<kind>(name, default, options?): the control the dialog draws for it, and the reader onStart() calls (it answers from then on) (Setting kinds).

Every kind takes one options object, every key optional (Options on a setting). The words that lay the dialog out are on Pages, sections, dividers, notes, the named sets of values on Presets, the per-output rows the dialog adds by itself on The Style page, the session zones and the unit codes on Sessions and units, where a pick applies and the 128-setting cap on Picks, lanes, the cap, and every refusal on What the build checks.

Presentation

One kit of seven blocks with two homes: the card the cursor opens (block.<kind>, on a line, its legend entry, a HUD tile, a text or label mark) and a HUD card at one of the nine anchors (tile.<kind>). Every block reads the newest row; outputs and slots are named by a bound handle or by their name as a string (Blocks and tiles).

The hover card is hover: [...] on an output, a render.text or a render.label, or hover(handle, [...]) at the top level (Hover cards); the HUD card is render.hud(name, { position, title?, columns?, tiles }) (HUD cards). The third home, the legend, takes words rather than blocks: legend({ title }) after the indicator's name and render.legend(name, { text?, value?, format?, color?, color_by?, colors? }) per entry, with label, format and legend: false on an output shaping its own entry (Legend). The tooltip templates, the label style words and badges are on Labels, tooltips, badges; glow, corner, opacity, width, line_style, a range's gradient and the color_by and width_by ladders are on Styling.

Sources the chart serves

Ten feeds share the etf_flow rule (served in the browser, and an alert on an indicator that reads one is refused): long_short_ratio, volatility_index, options_oi, options_volume, etf_holdings, etf_premium, ethena_positions, bitfinex_funding, treasury_balance and economic. The kit also declares the tape cells, which the chart does not serve: a file that reads them is refused by name when it runs ("celled source class 'tape' is not served by the browser lane yet").

Pins: symbol and exchange go together (a lone half is refused), in the chart's own ids ({ symbol: "ETHUSDT", exchange: "BINANCE_FUTURES" }). The chart checks every pin before it fetches anything. A secondary ohlcv input may pin another market, read bar by bar at the chart's interval, and an interval coarser than the chart's that is a whole multiple of it, read as of the coarser candle's close; funding and oi may pin a coarser interval on the chart's own market. Everything else is refused by name: a pin on the primary input, a market pin on any other source, a finer interval, and an interval on any other feed (trades, liquidations, implied_volatility, skew, etf_holdings, economic, ...), on time or on a celled input. Two celled inputs are the exception: intrabar and candles require an interval and may pin another market. Multi-timeframe has the views.

Celled classes (abi_version: "wrun-2")

The TA classes (./sdk/ta)

One class per calculation, each fed one bar at a time. Construct in onStart(), .update(...) once per bar in onBar() (it returns the primary value, NaN until warm). update(x) takes one value unless noted.

Multi-output classes return the primary line and carry the rest as fields: Bb, Keltner, Donchian (basis, upper, lower); Macd (macd, signal, hist); Stoch, Stochastic (k, d); Supertrend (line, direction); Adx (adx, plusDi, minusDi); Ichimoku (tenkan, kijun, senkouA, senkouB, chikou); Highest, Lowest (bars, how many bars ago); HighestBars, LowestBars (value, the matching extreme).

Every class allocates in its constructor and restores its just-constructed state on .reset(). Two honest exceptions to bit-exactness: Ichimoku's chikou is the current close (the engine reads a future bar), and Vwap anchors other than none, "day" and a millisecond bucket are unproven. The composite and every convention are in TA library.

Kit modules (./sdk/...)

Ten kits beside the TA classes, every name in scope with nothing to import. Construct their classes in onStart(); each page lists every export with its rules.

Caps

16 boxes, 16 segments, 64 renderers, 64 drawings (8 cards among them, and 32 cards, feeds and meters per pane), 64 polyline points, 16 declared alerts, 64 string slots of at most 4096 bytes, 8 frames of at most 96 KiB, 4 docked profiles, 8 panels, 4 heatmaps, 4 footprints, letter and time-anchored profiles together, 4 matrices, 4 panes, 64 KiB of strings per row, 2 MiB of strings and frames per run, 8 MiB of expanded render result, 2,000 drawings per run, offsets in -500..500, 4 MiB of module memory, 20 seconds per run. Every number, with the refusal it produces, is in Limits.

The four-function form

The module the chart runs exports four functions, init, state, finalize and reset, with exact signatures that Run checks before anything reaches the chart. A file with onBar() gets them from the build; a file may still export the four itself, and it builds the same way (Execution model). How the hooks map onto them:

One export of init, state, finalize or reset makes the whole file the four-function form. The chart replays the live forming bar from a snapshot of the module's memory and globals taken after the last closed bar, so every replay of the forming bar starts from the state that bar left.

Generated accessors

The runtime contract is positional; the accessors are how your source stays name-attached. One function per declared name, regenerated from your declarations each time the editor compiles:

• p_<param>(): f64 (params, readable from onStart() on), plus pb_<param>(): bool on a toggle, p_<range>_lo() / _hi(), p_<list>(): f64[], p_<session>_start() / _end() / _tz() and p_<param>_unit() on the composite settings, and pt_<param>(): string on a text setting
• in_<input>(): f64 (inputs, read in onBar()); the chart's own candle and bar time also read as bar.open(), bar.high(), bar.low(), bar.close(), bar.volume() and bar.time() with no declaration
• out_<output>(value: f64): void (outputs, written in onBar(); the row is emitted when it returns)

A declared name becomes its accessor by lowercasing it and collapsing every run of characters outside [a-z0-9_] to one _: param fast.len becomes p_fast_len(), input btc-close becomes in_btc_close(), output BTC-Ratio becomes out_btc_ratio(). Any name may be written with capitals. Param, input, string-slot and frame names are stored lowercase (param("fastLen", 12) is the setting fastlen), and so is every option that names one ("@lineColor", when: "showBands", a preset's keys) and the name inside a {{fastLen}} placeholder of a legend title, tooltip or HUD title; output names keep their capitals ([A-Za-z0-9][A-Za-z0-9._-]*). The accessor answers to the spelling your file uses: p_fastLen() and p_fastlen() are the same reader, out_BTC_Ratio() and out_btc_ratio() the same writer. Two names in one family that differ only by case (box, segment and alert names excepted: they keep their spelling), or that escape identically, are refused, and so are duplicate param names. Every accessor family gets the same treatment: a string slot summary sends through str_summary() and str_summary_sb(), a celled input profile reads through in_profile_cells() and in_profile_read().

Declarations whose names need escaping, and the source that reads them (the close line stays first because the first input sets the request grid, and bar.close() reads through it; the btc-close input pins BTCUSDT on Binance Futures, which the chart reads bar by bar at its own interval):

param("fast.len", 12, { min: 1, max: 200 });
param("slow.len", 26, { min: 2, max: 400 });
input("close", ohlcv.close);
input("btc-close", ohlcv.close, { symbol: "BTCUSDT", exchange: "BINANCE_FUTURES", description: "Fixed BTC reference market" });
output("spread", line, lower);
output("BTC-Ratio", line, lower);

let fast = new Ema(12);
let slow = new Ema(26);

function onStart(): void {
  fast = new Ema(i32(p_fast_len()));
  slow = new Ema(i32(p_slow_len()));
}

function onBar(): void {
  const close = bar.close();
  const btc = in_btc_close();
  const spread = fast.update(close) - slow.update(close);
  const ratio = btc > 0.0 ? close / btc : NaN;
  if (isNaN(spread) || isNaN(ratio)) return;
  out_spread(spread);
  out_btc_ratio(ratio);
}

Reordering declarations moves the SLOT inside each accessor while your source keeps the NAME, so reordering params or inputs never changes what the module computes; a renamed declaration renames its accessor, and the compiler then points at every stale reader or writer.

Raw positional slot literals (getFloat(0), getInt(0), setOutput(0, ...), wrun_arg_f64(0), wrun_output_f64(0, ...)) are refused before the compiler runs ("Raw slot literal 0 passed to getFloat(): raw positional slots rebind silently when the sheet changes"), because slots silently rebind when declarations change. Variable indexes stay legal: ./sdk/sdk wraps the raw host imports for genuinely dynamic access.

Declarations, in one place

The signatures in the table above are the whole grammar; the rules the editor enforces, each as a named error in the Console:

• Names are string literals; defaults and option values are literals; the code never runs when the editor reads the declarations.
• Names may carry capitals (fastLen). Params, inputs, string slots and frames are stored lowercase, and so is a {{fastLen}} placeholder that names one; outputs keep their spelling. Two names of one family that differ only by case are refused, naming both (boxes, segments and alerts keep their spelling and may differ by case).
• Declarations are top-level statements of your file; one anywhere else is refused with its line. An indicator is one file.
• Indexes follow declaration order: the first input(...) is slot 0, the primary input. The rows are always the chart's own bars and every input aligns to them; reordering declarations reorders slots while the generated accessors keep your source name-attached. A candle field read through bar.*() with no input(...) line is appended after the declared inputs, and a file with no input(...) line gets close as slot 0 whether or not it reads bar.close(); a declared input that reads exactly that feed serves the field instead.
• Box and segment coordinates are output handles bound by a top-level const (let, var, and export const bind too; a handle may be bound below the shape that uses it); the sheet records the output's name, never the handle.
• color_by, width_by, and shape_where name a DIFFERENT declared output; an output cannot color, widen, or gate itself. colors needs at least two entries beside color_by; widths and width_by go together.
• A celled input (<class>.cells) requires max_cells; scalar-feed knobs (side, tenor, ...) are refused on it; book requires block_size.

Run derives the contract from what you declare: a string slot, a renderer, a drawing, or a celled input stamps the derived sheet abi_version: "wrun-2"; a handle, strategy(...) or bar.isLast() stamps "wrun-3"; a frame, a level profile or a panel stamps "wrun-4"; a text setting (param.text) stamps "wrun-5"; a bar.count() read stamps "wrun-6"; scalar-only declarations keep the first contract. range, box, segment and alert are contract-neutral: they never flip the sheet. The derived sheet records generated_from: "declarations" plus a source_digest, and it is derived state: to change it, edit the declaration. The editor has no hand-written sheet to fall back to, so a file that declares nothing is refused ("This indicator declares nothing. Add param(...), input(...), and output(...) statements ..."). A file with onBar() needs at least one output(...); it needs no input(...) line, because the chart's own candle reads through bar.*(). The sheet's fields are on Declarations and the sheet, its pins on Multi-timeframe and Multi-source, odds modes on Data sources; the styling ladders are in Styling.

The cell channel (wrun-2)

Modules on the second contract or later may read celled inputs: a variable-length block of f64 cells per bar (a volume profile's per-price rows, a book snapshot's levels) beside the scalar argument block. A celled input is declared in the source, input(name, <class>.cells, { max_cells }) (the derived sheet records it as cellType: "array" with max_cells), reads a celled source class (Data sources), and receives cells in fixed-width TUPLES per class: volume_profile = [low, high, buy, sell] (4 f64s), book = [price, size, side] (3 f64s), intrabar = [offset_ms, open, high, low, close, volume] (6 f64s), trade_volume_by_size = [bucket, buy_usd, sell_usd, buy_count, sell_count] (5 f64s), options_chain = 10 f64s per contract. max_cells counts tuples.

The editor generates one accessor family per celled input (no scalar accessor: the input's slot in the scalar block holds NaN), read in onBar():

• in_<input>_cells(): i32: f64 cells in this bar's block (tuples x tuple width); 0 for a present, empty block; -1 when the bar carries no block, and before the first bar.
• in_<input>_view(): StaticArray<f64>: the build's own buffer, holding this bar's block with no copy. Only the first in_<input>_cells() values belong to this bar: on an absent or empty bar the buffer still holds the previous block, so bound every loop by the count.
• in_<input>_read(ptr: i32): i32: copies the block into the module's exported memory at ptr, for code that owns its own buffer; returns bytes written, 0 for a zero-cell block, -1 for a missing block.
• in_<input>_max_cells: i32: the declared max_cells (source tuples).
• in_<input>_capacity: i32: the f64 count of the build's buffer (max_cells x the class's tuple width); generated when the class's width is known.

Cells are IEEE 754 f64, little-endian, 8 bytes each, contiguous in block order. max_cells is a contract, not a hint: the build allocates one buffer of max_cells tuples per celled input when the module starts (in_<input>_capacity f64s), reads each bar's block into it once, and a bar whose block exceeds the cap refuses the WHOLE run by name ("... has 1200 cells; max_cells is 1000, so the evaluation is refused (a block is never truncated)"). An out-of-bounds ptr is refused naming the sizes, and a read of an input not declared as celled is refused naming the declared set. Underneath the accessors sit two host imports in the wrun namespace, wrun_arg_len(index) and wrun_arg_bytes(index, ptr); positional literals on them are refused exactly like getFloat(0), so source goes through the accessors. A second-contract module that reads no celled input is legal: such packages may be scalar-only, and scalar behavior is bit-identical across every contract.

Alignment is an exact join, never a fill: each chart bar gets the celled observation with the same bar open, a bar with no observation gets a PRESENT EMPTY block (the module sees 0 cells, not -1), and celled values are never carried forward (a replayed block would double-count volume). Celled inputs never abstain a row: on a bar with no block, leave the output unwritten or return from onBar(). A celled class can never be the primary input (so a scalar input(...) line stays in front of it) and follows the chart's own market (a market pin on it is refused); only intrabar takes an interval, the finer bars it folds.

Summing a bar's volume profile (total volume = buy + sell in every [low, high, buy, sell] tuple):

input("close", ohlcv.close);
// One tuple per price level: an hour of BTCUSDT carries several hundred, so leave room.
input("profile", volume_profile.cells, { max_cells: 8192 });
output("total", line, lower);

function onBar(): void {
  const n = in_profile_cells();
  if (n < 0) return; // this bar carries no block
  let total = 0.0;
  if (n > 0) {
    const cells = in_profile_view();
    for (let i = 0; i + 3 < n; i += 4) {
      total += cells[i + 2] + cells[i + 3]; // buy + sell per [low, high, buy, sell] tuple
    }
  }
  out_total(total);
}

The first contract is frozen: its import allowlist never grows, and a module on it that imports the cell functions is refused naming the way in (a celled input moves the derived sheet to wrun-2). Which celled classes the chart serves is in the table above; an alert on an indicator that reads a source the alerts engine cannot evaluate is refused when you save it (Alerts).

The string channel (wrun-2)

From the second contract on, a file may declare string slots: numbered, named, byte-capped text channels written from onBar(). Slots are NOT outputs: outputs stay numeric; strings exist so renderers and drawing labels can carry text, and they are never outputs.

When the file declares string(...), the editor generates the string family, in scope with nothing to import:

• sb_clear(), sb_text(s), sb_int(value), sb_f64(value, decimals) build one UTF-8 line allocation-free into a shared buffer sized to the largest declared max_bytes (allocated once at module start, so per-bar string work allocates nothing).
• str_<slot>(s: string) encodes and sends s to that slot; str_<slot>_sb() sends the built line. Both pass the REQUIRED byte count, so a line over the slot's max_bytes refuses by name; strings are never truncated.

A slot named debug is also the editor's debug log: each non-empty line prints in the Console as <ISO bar time> <text>, the newest 400 lines kept.

A slot not written that bar is ABSENT, which is distinct from a written empty string: render.text draws every present slot (empty included), render.label keeps the last present NONEMPTY one, and render.table waits for a row where every cell is present. Writing the same slot twice in one onBar() replaces its bytes. The channel belongs to the row being committed, the bar onBar() runs on: the underlying import (wrun_output_str(slot, ptr, len), wrun namespace) traps by phase anywhere else, and positional literals on it are refused like the cell imports (use the generated senders). Caps the chart enforces, each a named refusal: max_bytes per slot (at most 4096), 64 slots per indicator, 64 KiB of string bytes per row, 2 MiB of strings and frames together per run (a live session counts as one run). Bytes must be valid UTF-8; a broken sequence refuses the run instead of landing as a replacement character.

An RSI with two slots: a readout the label renderer keeps on the newest bar, and a zone word written only on bars that are in a zone, so the text mark stays absent everywhere else:

param("period", 14, { min: 2, max: 200 });
output("rsi", line, lower, { color: "#38bdf8" });
output("tag_x", none, lower, { description: "Bar time in epoch seconds, the label's x" });
string("readout", { max_bytes: 32 });
string("zone", { max_bytes: 16 });
// One label, riding the newest bar whose readout slot was written.
render.label("rsi_tag", { x: "tag_x", y: "rsi", text: "readout", color: "#38bdf8", size: 11 });
// One text mark per bar whose zone slot was written; quiet bars leave it absent.
render.text("rsi_zone", { y: "rsi", text: "zone", color: "#f59e0b", size: 10 });

let rsi = new Rsi(14);
let period: i32 = 14;

function onStart(): void {
  period = i32(p_period());
  rsi = new Rsi(period);
}

function onBar(): void {
  const value = rsi.update(bar.close());
  if (isNaN(value)) return;
  out_rsi(value);
  out_tag_x(bar.time());
  sb_clear();
  sb_text("RSI ");
  sb_int(period);
  sb_text(": ");
  sb_f64(value, 1);
  str_readout_sb(); // "RSI 14: 63.2", at most 32 bytes
  if (value >= 70.0) str_zone("overbought");
  else if (value <= 30.0) str_zone("oversold");
}

Renderers and drawings are selected after the run (Plotting and Drawing objects); the worked table example in Declarations and the sheet writes four slots per bar through this module surface.

Language cheat

The file is AssemblyScript: TypeScript syntax over fixed-width numbers, compiled to a module with no filesystem, no network, and no allocation after onStart(). Data types, math, strings, control flow, and user functions take these forms:

A rolling highest-high that shows the shapes above (a buffer sized once, a typed helper function, explicit casts; the high line is kept as the first input, which sets the request grid, and bar.high() reads through it):

param("bars", 20, { min: 1, max: 500, description: "Lookback in bars" });
input("high", ohlcv.high);
output("highest", line, overlay, { color: "#38bdf8" });

const MAX_BARS: i32 = 500; // the param's max: the buffer is sized once, never per bar
const highs = new StaticArray<f64>(MAX_BARS);
let n: i32 = 20;
let cursor: i32 = 0;
let count: i32 = 0;

// A plain function: typed params, a typed return, no closure over locals.
function maxOf(values: StaticArray<f64>, len: i32): f64 {
  let best = -Infinity;
  for (let i = 0; i < len; i++) {
    if (values[i] > best) best = values[i];
  }
  return best;
}

function onStart(): void {
  n = i32(p_bars());
}

function onBar(): void {
  highs[cursor] = bar.high();
  cursor = (cursor + 1) % n;
  if (count < n) count += 1;
  if (count < n) return;
  out_highest(maxOf(highs, n));
}

The sheet Run derives

Run turns your declarations into a sheet, the metadata a published indicator carries; you never write it. Where each of its top-level fields is explained:

The full validation list, every refusal by path, is at the end of Declarations and the sheet; the messages you will actually meet, with their fixes, are in Common errors.