Imported from KasperChenGH/multicharts-powerlanguage (skills/powerlanguage-syntax/SKILL.md). Install upstream with npx skills add KasperChenGH/multicharts-powerlanguage --skill powerlanguage-syntax. Copyright stays with the author.

PowerLanguage Syntax

Declarations

Every script starts with declarations. Order matters: Inputs: comes before Variables: (or its aliases Vars:, Var:); both come before code.

Inputs:
    Length(20),
    Threshold(0.0);

Variables:
    avgVal(0),
    triggered(False);

Arrays:
    buffer[10](0);

• Inputs — parameters exposed in the script's Format window. Each gets a default value in parentheses. Read-only inside the script.
• Variables / Vars / Var — script state. Each gets an initial value. Persist across bars within the same chart.
• Arrays — fixed-size collections. [size] is the index of the last element (zero-based by default), (initial) initializes every slot.

Pre-declared default variables. PowerLanguage ships with numbered built-ins that don't need a Variables: declaration:

Use them directly: Value1 = Average(Close, 14);, If Condition1 Then Buy ...;. No declaration line required (declaring one just shadows the built-in with an identical local). These are handy for quick scratch values when you don't want to bother naming a variable. For generated code, stay within 0–99 — declare named variables if you need more.

Data types

PowerLanguage is loosely typed but each value is one of:

Type is inferred from initial value in Variables: / Inputs: declarations.

The begin … end rule and semicolons

begin opens a block; end closes it. Every end gets a semicolon EXCEPT when followed by else.

// (pseudocode — real scripts need Variables declarations for all names)
If condition Then Begin
    statement1;
    statement2;
End                     // NO semicolon — else follows
Else Begin
    statement3;
End;                    // semicolon — outer statement boundary

Forgetting a semicolon on a terminal End is the most common compile error new PowerLanguage users hit. The rule is mechanical: if the next token is Else, no semicolon; otherwise yes.

Control flow

// (pseudocode forms — declare all variables in real scripts)
If x > 0 Then Begin ... End;

If x > 0 Then ... Else If x = 0 Then ... Else ... ;

Variables: idx(0), runTotal(0);   // loop counter + accumulator must be declared
For idx = 1 To 10 Begin
    runTotal = runTotal + idx;
End;

While condition Begin ... End;

Switch (n) Begin
    Case 0: Value1 = Value1;   // no-op — empty case body is a compile error
    Case 1: ... ;
    Case 2: ... ;
    Default: ... ;
End;

Every Case body must have at least one statement. An empty case (even with only a comment) is a compile error. Use Value1 = Value1; as a no-op if the case should do nothing.

For / While loop counters must be declared as Variables. PowerLanguage does not auto-declare loop counters. Using an undeclared name gives "Invalid type operation."

Bar references

Close is the close price of the current bar; Close[1] is the close one bar ago; Close[N] is N bars ago. Same indexing for Open, High, Low, Volume, OpenInterest.

Operators

• Arithmetic: +, -, *, /
• Comparison: =, <>, >, <, >=, <=
• Logical: and, or, not (lowercase; and is a keyword, not &&)

Comments

• Line comment: // up to end of line
• Block comment: { braces — can span multiple lines }

The { … } block-comment form is also how PowerLanguage code authors traditionally write file headers.

Built-in trade-state variables (Signal scripts)

Inside a Signal script, these are always available — no declaration needed:

Order syntax (high-level recap)

Buy ("LE") 1 Contract Next Bar at Market;
Sell ("LX") 1 Contract Next Bar at Market;
SellShort ("SE") 1 Contract Next Bar at Market;
BuyToCover ("SX") 1 Contract Next Bar at Market;

Quantities use Contract / Contracts (futures, FX) or Share / Shares (equities). The price-placement keyword (Market, Limit, Stop, This Bar on Close) determines when the fill happens. See powerlanguage-keywords-reference for each order keyword's full signature.

Common built-in functions

MultiCharts ships with hundreds of pre-built Functions (.elf and .pla files) that are NOT in the keyword reference. These are the most commonly used ones — get the signatures right or you'll get compile errors.

Moving averages and smoothing

Oscillators and indicators

"No Price parameter" gotcha: These functions take no Price parameter — passing Close as the first arg is a compile error:

• Length-only: CCI, ADX, ADXR, DMI, DMIPlus, DMIMinus, AvgTrueRange, PercentR, MoneyFlow, Volatility, RSquared, AccumDist — call as ADX(14), not ADX(Close, 14).
• Multi-length (no Price): UltimateOscillator(Len1, Len2, Len3), ChaikinOsc(FastLen, SlowLen, SmoothType), MassIndex(SmoothLen, SumLen) — all parameters are lengths/types, not prices.
• Single non-length: Parabolic(AfStep) — takes only an acceleration factor step, e.g. Parabolic(0.02).
• No arguments: EaseOfMovement, SwingIndex, AccumSwingIndex, OBV, PriceVolTrend, LWAccDis — use current bar OHLCV internally.

Stochastic gotcha: It takes 11 parameters, not 3. The last 4 are output ref variables — you must declare Variables for them. The return value is just a status code (1 or -1), not the stochastic value itself. Typical usage:

Variables: fastK(0), fastD(0), slowK(0), slowD(0);
Value1 = Stochastic(High, Low, Close, 14, 3, 3, 1, fastK, fastD, slowK, slowD);
// Use slowK and slowD for signals

Stochastic helper functions

These are convenience wrappers around the full Stochastic function. The default variants use the current bar's High, Low, Close; the Custom variants accept explicit price inputs.

Multi-output functions

These functions populate output ref variables — you must declare Variables for each output parameter.

Volatility and range

Price extremes and Nth

Swing detection

Pivot with variable strength

Like SwingHigh/Low but with independent left and right strength parameters.

Divergence detection

Aggregation and linear regression

| SummationFC | SummationFC(Price, Length) | numeric (fast calculation Summation) |

Date/Time conversion

Multi-period OHLC reference

Access daily, weekly, monthly, or yearly OHLC from any intraday chart. PeriodsAgo = 0 is the current period.

Price calculation shortcuts

These take no arguments — they use the current bar's OHLC automatically.

Counting and occurrence

Volume-based

Statistical

Moving averages extended

Miscellaneous

Custom functions (commonly available)

These ship as f_* function files with many MultiCharts installations. They are not built-in keywords — you must have the corresponding function study (e.g. f_StochRSI) in your PowerLanguage Editor for the call to compile. If missing, create a new function study and paste the implementation from the source below.

Candlestick patterns

These return 1 if the pattern is detected, 0 otherwise. Multi-output variants populate ref variables.

Gotchas

MarketPosition(N), EntryPrice(N), BarsSinceEntry(N) are position history, NOT bar offset

A natural-looking expression like MarketPosition(1) reads as "the market position one bar ago" — but it actually returns the position one trade ago. So MarketPosition(1) on bar 50, when the strategy has been flat for the last 30 bars, returns whatever the previous closed position was (long or short), not 0.

The same trap applies to EntryPrice(N) and BarsSinceEntry(N). EntryPrice(1) returns the entry price of the previous closed position, not the entry price one bar ago. BarsSinceEntry(1) returns the bars-since-entry of the previous position, not the current position minus one.

To detect a position transition between bars (e.g. "did we just enter long?"), store the previous bar's position at the END of each bar:

Variables:
    _prevMP(0);

If MarketPosition <> _prevMP Then Begin
    // transition just happened this bar
    ...
End;

_prevMP = MarketPosition;     // end of bar

This is the canonical pattern. Don't rely on MarketPosition(1) for transition detection.

Bars are labeled by their CLOSE time, not open time

A 60-minute bar covering 15:00–16:00 has Time = 1600, not Time = 1500. A filter like If Time = 1500 Then … will never match that bar.

To check whether the current bar is the first bar of the night session at 15:00, write:

If Time = 1600 Then ...     // for 60-min bars
If Time = 1505 Then ...     // for 5-min bars (first close after 15:00)
If Time = 1501 Then ...     // for 1-min bars

Add one bar's worth of minutes to the session-start clock time.

Variable names must not match built-in function names or reserved letters

PowerLanguage is case-insensitive. If you declare Variables: dmiPlus(0); and then call dmiPlus = DMIPlus(14);, the compiler sees the variable and function as the same identifier — the variable shadows the function and the call fails. This applies to every built-in function: Average, RSI, CCI, ADX, MACD, Stochastic, BollingerBand, Highest, Lowest, etc. Especially dangerous are function names that look like natural variable names: Range, Momentum, Median, Correlation, Sign, Last, Slippage, Margin.

The single-letter data-series aliases are also reserved and cannot be used as variable or loop-counter names: C(Close), D(Date), H(High), I(OpenInterest), L(Low), O(Open), T(Time), V(Volume). Because PL is case-insensitive, i, c, l, v, etc. are all off-limits. This is especially easy to hit with i in For loops.

Use a different name — abbreviate, add a suffix, or prefix:

// WRONG — i is reserved (alias for OpenInterest)
For i = 1 To 10 Begin ... End;

// RIGHT — use ii, idx, cnt, n, etc.
For ii = 1 To 10 Begin ... End;

// WRONG — shadows the built-in DMIPlus function
Variables: dmiPlus(0);
dmiPlus = DMIPlus(14);        // compile error

// RIGHT
Variables: dpVal(0);
dpVal = DMIPlus(14);          // works

Inputs are read-only

You cannot assign to an Input inside a script. If you need a mutable copy, declare a Variable and copy from the Input once.

Variable types are fixed at first assignment

Variables: x(0); makes x numeric for the life of the script. You can't later assign a string to it. Same for True/False initial values (bool) and "" (string).

Many keywords can't appear as values on the right-hand side of =

A common new-user mistake is to write Value1 = SomeKeyword; for a keyword that looks identifier-like in the documentation but is actually a syntactic construct. PowerLanguage will throw "syntax error, unexpected '…'" or "Wrong syntax of '…'" when you do this. Empirically, the following classes never work as RHS values:

Whole keyword classes:

Other rules of thumb:

• A keyword name that contains a space in the official docs (e.g. DateTime bar update, Cancel Alert) cannot be used as a single identifier — PowerLanguage parses only the first word and chokes on the rest.
• Single-letter data-series aliases (C=Close, D=Date, H=High, I=OpenInt, L=Low, O=Open, T=Time, V=Volume) are reserved — using them with parentheses like C(Close) causes "A keyword/variable is used as a function". Use square brackets for barsback: C[1].
• A handful of names in otherwise-value-rich categories are reserved syntactic tokens: Data (used as Close of Data2), Call / Put / Strike (option-context syntax), OptionType, DeltaType, RevSize, BoxSize.
• Procedure keywords like ScrollToBar, PlaceMarketOrder, ChangeMarketPosition, and all PMM action keywords (pmms_strategy_resume, pmms_strategy_pause, pmms_strategy_close_position, pmms_strategy_deny_*, pmms_strategy_allow_*, pmms_strategies_*_all) perform an action and do NOT return a value — assigning them to Value1 causes "Function must have a return value". Call them as standalone statements: ScrollToBar(1, 0);.
• Signal/portfolio-only keywords like Portfolio_CurrencyCode, StrategyCurrencyCode, InitialCapital cause "X is not applicable to this type of study" when used in an Indicator. They only work in Signal studies.
• Drawing-object accessors (any Rectangle*, TL_*, Arw_*, Text_*, or MC_TL_*/MC_Arw_*/etc. function ending in Get/Set/Delete/New/…) take at least one drawing-object ID argument — never use them as bare values.
• Setter keywords (Set*, Portfolio_Set*, pmm_set_*, or any name containing _set_) are statement-shaped — they always require at least one value argument and don't return a value.
• Lowercase-prefix functions (e.g. getTPOinfo, getplotstyle) usually take parameters; the unusual lowercase naming is the signal.
• String-returning keywords like Description, Symbol, GetCurrency, BarType_uid, anything ending in Name / Description / Listed / ToStr — can be assigned only to a string variable, not the numeric Value1.
• Boolean-returning keywords like Is64BitProcess, MouseClickShiftPressed, AlertEnabled, PosTradeIsOpen, PosTradeIsLong, pmms_strategy_is_paused — use them inside an If condition (If Is64BitProcess Then ...); direct assignment to Condition1 sometimes fails because PowerLanguage returns numeric 0/1 instead of TrueFalse for some "logical" functions. Exception: MarketPosition_at_Broker_for_The_Strategy looks boolean but returns numeric 1/0/-1 (market position) — use Value1 = X;, not If X Then.

Quick error → fix lookup

If MultiCharts gives you one of these errors when using a keyword:

When in doubt, look up the keyword in the powerlanguage-keywords-reference skill — the signature line shows whether it's used as KeywordName(args) (callable function) or in a larger construct (then it can't be the whole RHS).

Pre-generation checklist

Before writing any PowerLanguage code, verify every item below. Do not skip steps — each one maps to a real compile error encountered during testing.

1. Script type matches intent. Indicator (plots, no orders), Signal (orders, no plots), or Function (returns a value)?
2. Declarations exist and come first. Inputs: → Variables: → Arrays: → code. Every variable used anywhere — including loop counters — must be declared.
3. No variable-name collisions. Check every name in Variables: against:
   • Built-in functions: Average, RSI, CCI, ADX, MACD, DMIPlus, DMIMinus, Stochastic, BollingerBand, Highest, Lowest, Range, Momentum, Median, Correlation, Volatility, MoneyFlow, Summation, Cum, Sign, Last, Total, etc.
   • Single-letter aliases: C, D, H, I, L, O, T, V (and their lowercase forms — i as a loop counter is the #1 trap).
   • Use suffixed names: rsiVal, atrVal, dpVal, avgVal, runTotal, idx, nn, cnt.
4. Function signatures are correct. Check every function call:
   • Length-only functions (CCI, ADX, DMIPlus, DMIMinus, AvgTrueRange, PercentR, MoneyFlow, Volatility, RSquared, AccumDist) take no Price parameter.
   • Stochastic takes 11 params (4 are output ref vars that must be declared).
   • DirMovement takes 10 params (6 are output ref vars).
   • AdaptiveMovAvg takes 4 params (Price, EffRatioLen, FastAvgLen, SlowAvgLen).
   • Parabolic takes 1 param (AfStep only).
   • If unsure, look it up in the "Common built-in functions" tables above.
5. Order syntax is complete. Every order has: a unique name string, quantity + unit, and the at keyword — Next Bar at Market, Next Bar at <price> Stop, Next Bar at <price> Limit, or This Bar on Close.
6. Order names are unique. No two orders in the same Signal share a name string.
7. Semicolon rule. End before Else → no semicolon. End at statement boundary → semicolon.
8. Study-type restrictions. No Plot in Signals. No Buy/Sell in Indicators. No MarketPosition/EntryPrice in Indicators.

Post-generation self-review

After writing PowerLanguage code, re-read it against this list before presenting it. Fix any issues silently — do not present code that fails these checks.

1. Walk the Variables: block. Read each name aloud — does it match any built-in function or single-letter alias? If yes, rename it.
2. Walk every function call. Count the arguments. Compare to the signature table. Pay special attention to Length-only functions (no Price) and multi-output functions (ref vars declared?).
3. Walk every order line. Is the at keyword present? Is the name string unique within this Signal?
4. Walk every End. Is the next token Else? If yes → no semicolon. Otherwise → semicolon.
5. Walk every For/While. Is the loop counter declared in Variables:?
6. Check type consistency. Numeric functions → Value1 or numeric variable. String functions (anything ending in ToStr, Name, Description) → string variable. Don't assign strings to Value1.