Strategies and alerts across languages

Simulated orders, positions and results, and notifications. Each row maps one concept from Lipi to the other languages; the word in a cell is the relation, explained in the language map overview.

Concept	Lipi	MQL4	MQL5	NinjaScript	Pine Script	thinkScript
Enter a position	`strategy.entry`	Differs	Differs	Caveat	Caveat	Caveat
Place an order	`strategy.order`	Caveat	Caveat	Caveat	Caveat	Caveat
Exit with stop or target	`strategy.exit`	Caveat	Caveat	Composite	Caveat	Composite
Close a position	`strategy.close`, `strategy.close_all`	Composite	Composite	Caveat	Caveat	Caveat
Cancel pending orders	`strategy.cancel`, `strategy.cancel_all`	Caveat	Caveat	Caveat	Exact	Absent
Current position	`strategy.position_size`, `strategy.position_avg_price`	Composite	Differs	Caveat	Caveat	Caveat
Strategy results	`strategy.equity`, `strategy.netprofit`, `strategy.max_drawdown`, `strategy.closedtrades`, `strategy.wintrades`	Composite	Composite	Composite	Caveat	Caveat
Details of each trade	`strategy.closedtrades_profit`, `strategy.closedtrades_entry_price`, `strategy.opentrades_profit`	Caveat	Composite	Caveat	Caveat	Absent
Simulation settings	`strategy`	Absent	Absent	Composite	Caveat	Absent
Raise an alert from code	`alert`	Caveat	Caveat	Caveat	Caveat	Caveat
Declare an alert condition	`alertcondition`	Absent	Absent	Absent	Caveat	Absent
Send to a webhook	`alert`	Differs	Differs	Absent	Caveat	Absent

Each section below gives the Lipi construct first, then the construct in each language, with a note wherever behaviour differs. The language name links to the documentation the row was checked against.

Enter a position

Opening or adding to a simulated long or short position. In Lipi: strategy.entry. direction is strategy.long or strategy.short. No trail_points, qty_percent or alert_message. A market order fills at the next bar’s open.

Language	Construct	Relation	Note
MQL4	OrderSend(symbol, OP_BUY or OP_SELL, volume, price, slippage, stoploss, takeprofit, …)	Looks alike, behaves differently	Each call returns one ticket for one order; the caller supplies the Bid or Ask price, slippage, stop loss and take profit. State and side effects: Each market order is separately ticketed; closing an opposite order is its own call (OrderClose or OrderCloseBy).
MQL5	`OrderSend with TRADE_ACTION_DEAL`	Looks alike, behaves differently	A real trade request: true means only basic acceptance, so check result.retcode; netting accounts hold one position per symbol. State and side effects: Orders hit the live account, and OrderSend is barred in indicators.
NinjaScript	`EnterLong() / EnterShort()`	Equivalent, with a caveat	Direction is in the method name and signalName replaces the id. The opposite entry reverses the position, as in Lipi. State and side effects: Managed orders not resubmitted are cancelled at the end of the bar; quantity 0 becomes 1.
Pine Script	`strategy.entry()`	Equivalent, with a caveat	Pine adds alert_message and disable_alert for per-order alerts; Lipi’s strategy.entry lacks both.
thinkScript	`AddOrder(OrderType.BUY_AUTO / SELL_AUTO, condition)`	Equivalent, with a caveat	BUY_AUTO and SELL_AUTO open or close; the order lands on the next bar at open[-1] by default; no order id, limit or stop arguments.

Place an order

Placing a simulated order that does not reverse an existing position. In Lipi: strategy.order. A raw net order with no pyramiding check: it can open, add, reduce, close or reverse.

Language	Construct	Relation	Note
MQL4	`OrderSend with OP_BUYLIMIT, OP_SELLLIMIT, OP_BUYSTOP, OP_SELLSTOP`	Equivalent, with a caveat	Pending orders are limit or stop types only; price must keep the MODE_STOPLEVEL distance from market, and an expiration time is optional.
MQL5	`OrderSend with TRADE_ACTION_PENDING`	Equivalent, with a caveat	Pending orders use TRADE_ACTION_PENDING with an ENUM_ORDER_TYPE and a price; stoplimit sets the trigger for stop-limit orders.
NinjaScript	`SubmitOrderUnmanaged()`	Equivalent, with a caveat	Direction and type are OrderAction and OrderType arguments. Managed Enter* calls reverse positions, so they are not strategy.order.
Pine Script	`strategy.order()`	Equivalent, with a caveat	Pine adds alert_message and disable_alert for per-order alerts; Lipi’s strategy.order lacks both.
thinkScript	`AddOrder(OrderType.BUY_TO_OPEN / SELL_TO_OPEN, condition)`	Equivalent, with a caveat	TO_OPEN and TO_CLOSE types only open or only close, the nearest thing to a non-reversing order; there is no separate order function.

Exit with stop or target

Closing a simulated position with a stop-loss, take-profit or trailing stop. In Lipi: strategy.exit. No trailing-stop arguments. profit and loss are distances in ticks of syminfo.minmove. With no limit, stop, profit or loss the call is ignored.

Language	Construct	Relation	Note
MQL4	stoploss and takeprofit arguments; OrderModify	Equivalent, with a caveat	Stop and target are stored on the order, set at send or by OrderModify; no trailing option is documented, so trail by modifying each tick.
MQL5	MqlTradeRequest sl and tp fields; TRADE_ACTION_SLTP	Equivalent, with a caveat	Stop and target are absolute prices on the request, set at entry or later by TRADE_ACTION_SLTP; the structure has no trailing-stop field.
NinjaScript	SetStopLoss(), SetProfitTarget(), SetTrailStop(), or ExitLongStopMarket() / ExitLongLimit()	Built from several Lipi constructs	Set* methods attach stop and target to an entry’s fills (call before entering; modes Ticks, Price, Percent and others); Exit* methods submit explicit orders.
Pine Script	`strategy.exit()`	Equivalent, with a caveat	Pine adds qty_percent, trail_price, trail_points, trail_offset and alert arguments that Lipi lacks. profit and loss are tick distances, limit and stop are prices, in both.
thinkScript	AddOrder(OrderType.SELL_TO_CLOSE, close > EntryPrice() + t or close < EntryPrice() - s)	Built from several Lipi constructs	No stop or target arguments: write the exit condition against EntryPrice() and send a TO_CLOSE order; it is a close-based condition.

Close a position

Closing a simulated position, or all of them, at market. In Lipi: strategy.close, strategy.close_all. strategy.close(id) does nothing when that entry is not open. close_all closes the position.

Language	Construct	Relation	Note
MQL4	`OrderClose(ticket, lots, price, slippage, arrow_color)`	Built from several Lipi constructs	Closes one order by ticket, in whole or by lots; closing everything means looping OrdersTotal with OrderSelect and OrderClose.
MQL5	TRADE_ACTION_DEAL with the position ticket; TRADE_ACTION_CLOSE_BY	Built from several Lipi constructs	Closing sends an opposite-direction deal naming the position ticket, or TRADE_ACTION_CLOSE_BY against an opposite position.
NinjaScript	`ExitLong() / ExitShort()`	Equivalent, with a caveat	Market exits, ignored when no such position exists. For close_all call both. Avoid CloseStrategy(), which also disables the strategy.
Pine Script	`strategy.close(), strategy.close_all()`	Equivalent, with a caveat	Pine orders the arguments close(id, comment, qty, …); Lipi orders close(id, qty, comment). Pine adds qty_percent and immediately.
thinkScript	`AddOrder(OrderType.SELL_TO_CLOSE / BUY_TO_CLOSE, condition)`	Equivalent, with a caveat	Closes an open position on the next bar by default; no entry-id argument exists to choose which entry to close.

Cancel pending orders

Cancelling simulated orders that have not filled. In Lipi: strategy.cancel, strategy.cancel_all. cancel(id) removes every queued order with that id and does nothing when none exists; cancel_all removes all.

Language	Construct	Relation	Note
MQL4	`OrderDelete(ticket)`	Equivalent, with a caveat	Deletes one pending order by ticket; cancelling all means looping over orders.
MQL5	`TRADE_ACTION_REMOVE`	Equivalent, with a caveat	Each pending order is removed by its own ticket in a request; the action list has no cancel-all.
NinjaScript	`CancelOrder(Order order)`	Equivalent, with a caveat	Takes the Order object returned by the entry call, not a string id. The managed page documents no strategy-wide cancel-all method. State and side effects: Resubmitting an order each bar keeps it alive; stopping resubmission cancels it.
Pine Script	`strategy.cancel(), strategy.cancel_all()`	Exact
thinkScript		Not in thinkScript	No pending-order concept is documented: each order is added for the next bar by its condition, with nothing to cancel.

Current position

The size and average price of the open simulated position. In Lipi: strategy.position_size, strategy.position_avg_price. position_size is signed: negative for a short.

Language	Construct	Relation	Note
MQL4	`OrdersTotal, OrderSelect, OrderLots, OrderOpenPrice, OrderType`	Built from several Lipi constructs	There is no single net position; loop open orders by symbol and magic number, sum signed OrderLots and weight OrderOpenPrice for the average.
MQL5	PositionSelect; PositionGetDouble(POSITION_VOLUME, POSITION_PRICE_OPEN)	Looks alike, behaves differently	Volume is separate from direction (POSITION_TYPE buy or sell), and a position must be selected before its properties are read. State and side effects: Under netting only one open position per symbol exists.
NinjaScript	`Position.Quantity, Position.AveragePrice, Position.MarketPosition`	Equivalent, with a caveat	Size and direction are separate: Quantity is an int and direction comes from MarketPosition (Flat, Long, Short); Lipi position_size is one signed number.
Pine Script	`strategy.position_size, strategy.position_avg_price`	Equivalent, with a caveat	With a flat position strategy.position_avg_price is 0 in Lipi but na (NaN) in Pine.
thinkScript	`EntryPrice()`	Equivalent, with a caveat	Only the average entry price of the held position is available; no simulated position-size function is documented.

Strategy results

Running totals of the simulation: equity, net profit, drawdown, and counts of trades. In Lipi: strategy.equity, strategy.netprofit, strategy.max_drawdown, strategy.closedtrades, strategy.wintrades. equity = initial_capital + netprofit + openprofit. netprofit is realized and net of commission; unrealized profit is openprofit.

Language	Construct	Relation	Note
MQL4	`AccountEquity(), AccountBalance(), AccountProfit(), TesterStatistics(id)`	Built from several Lipi constructs	Equity, balance and open profit are account functions; net profit, drawdown and trade counts come from TesterStatistics, only inside OnTester or OnDeinit in the tester.
MQL5	AccountInfoDouble(ACCOUNT_EQUITY, ACCOUNT_BALANCE, ACCOUNT_PROFIT); TesterStatistics	Built from several Lipi constructs	Live equity comes from account properties; tester totals (profit, trade counts) come from TesterStatistics, callable only in OnTester or OnDeinit during testing.
NinjaScript	`SystemPerformance.AllTrades.TradesPerformance.Currency.CumProfit and related`	Built from several Lipi constructs	Totals sit in nested performance objects (CumProfit, Drawdown, trade counts via Count) and need IncludeTradeHistoryInBacktest; no equity variable is listed.
Pine Script	`strategy.equity, netprofit, max_drawdown, closedtrades, wintrades`	Equivalent, with a caveat	Lipi netprofit falls by the entry commission when a trade opens; Pine netprofit counts only completed trades. Equity totals still match.
thinkScript	`FPL()`	Equivalent, with a caveat	Only FPL() floating profit/loss is documented as a scriptable strategy result; no equity, drawdown or trade-count function is listed.

Details of each trade

The entry, exit, size and profit of each closed or open simulated trade. In Lipi: strategy.closedtrades_profit, strategy.closedtrades_entry_price, strategy.opentrades_profit. Accessors are flat functions with zero-based trade numbers, such as strategy.closedtrades_profit(0). closedtrades_exit_bar_index always returns 0.

Language	Construct	Relation	Note
MQL4	OrderSelect(i, SELECT_BY_POS, MODE_HISTORY), OrderProfit(), OrderOpenPrice(), OrderClosePrice(), OrderLots()	Equivalent, with a caveat	Select an order first, then call accessors that read the selected one; OrderSelect returns false for a bad index. History holds closed and deleted orders. State and side effects: Hidden selected-order context: accessors read whichever order was selected last.
MQL5	HistorySelect; HistoryDealsTotal; HistoryDealGetTicket; HistoryDealGetDouble(DEAL_PROFIT, DEAL_PRICE)	Built from several Lipi constructs	Select a history range, then read each deal by ticket and property; Lipi-style indexed trade accessors do not exist.
NinjaScript	`SystemPerformance.AllTrades[i] (Trade.Entry, Trade.Exit, Quantity, ProfitCurrency)`	Equivalent, with a caveat	Zero-based, oldest first, as in Lipi. A Trade holds Entry and Exit Execution objects plus profit properties, and covers completed trades.
Pine Script	`strategy.closedtrades.profit(), .entry_price(), strategy.opentrades.profit()`	Equivalent, with a caveat	Pine uses dotted names (strategy.closedtrades.profit(i)); Lipi uses strategy.closedtrades_profit(i). Lipi’s closed-trade exit bar index and run-up and drawdown always read 0.
thinkScript		Not in thinkScript	No per-trade accessors are documented; trade details appear only in the strategy report window.

Simulation settings

Starting capital, order size, commission, pyramiding and when orders fill. In Lipi: strategy. Percent commission is notional x value / 100, charged on open and on close. Entries beyond pyramiding are ignored silently.

Language	Construct	Relation	Note
MQL4		Not in MQL4	No in-code setting for capital, order size, commission or pyramiding; the #property list has none, and orders carry explicit volume.
MQL5		Not in MQL5	No #property or call sets capital, commission or pyramiding; order volume is the volume field of each trade request.
NinjaScript	`EntriesPerDirection, EntryHandling, DefaultQuantity, Slippage, IncludeCommission, OrderFillResolution`	Built from several Lipi constructs	Spread across separate strategy properties; a starting-capital property is not in the strategy property list.
Pine Script	strategy() arguments: initial_capital, default_qty_type, default_qty_value, commission_type, commission_value, pyramiding, process_orders_on_close	Equivalent, with a caveat	Defaults differ: Pine uses 100 percent of equity, 100000 capital, pyramiding 0; Lipi uses 1 unit, 1000000, pyramiding 1. Constant names are dotted (strategy.oca.cancel). State and side effects: A strategy without explicit settings trades much larger positions in Pine (percent of equity) than in Lipi (one unit).
thinkScript		Not in thinkScript	Order size and similar settings live in the Strategy Global Settings window; AddOrder’s tradeSize only overrides size per call.

Raise an alert from code

Sending a notification with a message the script builds, when the script decides. In Lipi: alert. Fires only on realtime bars, only in alert mode, at most once per bar. One string argument; no frequency argument.

Language	Construct	Relation	Note
MQL4	`Alert(...), SendNotification(text), SendMail, PlaySound`	Equivalent, with a caveat	Alert takes up to 64 comma-separated values and opens a message window; arrays cannot be passed, so output elements one by one.
MQL5	Alert; SendNotification; SendMail; PlaySound	Equivalent, with a caveat	Alert shows a dialog; SendNotification pushes to mobile (maximum 255 characters, rate-limited); neither works in the Strategy Tester.
NinjaScript	`Alert()`	Equivalent, with a caveat	Needs an id and a rearmSeconds window instead of Lipi’s once-per-bar limit. Works only in State.Realtime and writes to the Alerts Log.
Pine Script	`alert(message, freq)`	Equivalent, with a caveat	Pine alert has a freq argument (alert.freq_once_per_bar, once_per_bar_close, all); Lipi’s takes only the message. A Pine strategy fires alerts at bar close unless calc_on_every_tick. Bar timing: Pine strategies without calc_on_every_tick fire alert() only at bar close, whatever freq says; the default frequency is once per bar.
thinkScript	`Alert`	Equivalent, with a caveat	Takes the condition itself plus ONCE/BAR/TICK frequency and a sound; Lipi’s alert has only a message and fires at most once per bar. Bar timing: ONCE fires once after adding the study and TICK on every tick; Lipi fires at most once per bar, in realtime only.

Declare an alert condition

Declaring a condition the chart user can turn into an alert. In Lipi: alertcondition. Top level only. title and message must be const strings; the condition must be a boolean series.

Language	Construct	Relation	Note
MQL4		Not in MQL4	No declaration of user-pickable alert conditions; common functions are call style only (Alert, SendMail, SendNotification, PlaySound).
MQL5		Not in MQL5	No declare-a-condition function exists; raise alerts from your own code with Alert or SendNotification.
NinjaScript		Not in NinjaScript	No script-level alert-condition declaration is in the language reference index; alerts are built in the Alerts window from conditions on chart objects.
Pine Script	`alertcondition()`	Equivalent, with a caveat	Pine’s alertcondition works only in indicators, must start at column zero, and its const message may hold {{placeholders}} such as {{close}} for dynamic values.
thinkScript		Not in thinkScript	No declare-a-condition form for users to pick: alerts are scripted with Alert() and described as local alerts.

Send to a webhook

Delivering an alert’s message to an outside address. In Lipi: alert. The script only builds the message string (write JSON in single quotes); no argument sets a webhook address.

//@lipi=2
indicator("Alert message", overlay=true)
if barstate.isconfirmed and close > open {
    alert('{"event":"up","price":' + str.tostring(close) + '}')
}

Language	Construct	Relation	Note
MQL4	WebRequest(method, url, headers, timeout, data[], result[], result_headers)	Looks alike, behaves differently	WebRequest posts HTTP from code to an allow-listed URL and fails in indicators. In Lipi, alert() builds the message; delivery is set outside the script.
MQL5	`WebRequest`	Looks alike, behaves differently	WebRequest posts HTTP from code to an allow-listed URL, blocks until the reply, and fails in indicators. In Lipi, alert() builds the message only.
NinjaScript		Not in NinjaScript	Alert actions are Play Sound, Share, Pop Up Dialog and Submit Order; no webhook action is documented. Share sends to configured share services.
Pine Script	Webhook URL option in the Create Alert dialog; message text from alert() or alert_message	Equivalent, with a caveat	The script supplies only the message; the URL is set when the alert is created. A JSON-valid message is sent with a JSON content type.
thinkScript		Not in thinkScript	Alerts are local (message text and sound); the reference documents no outbound delivery to an address.

Manual

Use Lipi with AI

Reference

Strategies and alerts across languages

Enter a position

Place an order

Exit with stop or target

Close a position

Cancel pending orders

Current position

Strategy results

Details of each trade

Simulation settings

Raise an alert from code

Declare an alert condition

Send to a webhook

​Enter a position

​Place an order

​Exit with stop or target

​Close a position

​Cancel pending orders

​Current position

​Strategy results

​Details of each trade

​Simulation settings

​Raise an alert from code

​Declare an alert condition

​Send to a webhook

Enter a position

Place an order

Exit with stop or target

Close a position

Cancel pending orders

Current position

Strategy results

Details of each trade

Simulation settings

Raise an alert from code

Declare an alert condition

Send to a webhook