Convert an MQL5 EA to Python by hand: MQL5 to Forge

Forge API 1Updated 14 Oct 2026

There is no automatic converter, and Oathra does not convert MQL4 or MQL5 code. This page sets what you write in MQL5 beside what you write in Forge's Python, job by job, and says what has no Forge form.

What you write in MQL5, and what you write in Forge instead. 65 names, grouped by what they are for.

What has no Forge form

You write	Why
`OnTesterInit`, `OnTesterPass`, `OnTesterDeinit`	Forge runs the sweep and keeps every pass. A strategy has no hook around the sweep in FORGE_API 1.
`OnChartEvent`	A strategy has no chart events. The chart draws a run's plots and markers.
`OnBookEvent`, `MarketBookAdd`, `MarketBookGet`	Forge runs have no order book depth.
`CTrade.PositionCloseBy`, `PositionCloseBy`, `OrderCloseBy`	Forge closes each position at the market. Closing one position by an opposite one is not simulated.
`CTrade.SetTypeFilling`, `ORDER_FILLING_FOK`, `ORDER_FILLING_IOC`	How orders fill is set for the run, not in the strategy.
`CopyTicks`, `CopyTicksRange`	Strategies decide on closed bars. Ticks drive fills, not decisions.
`IndicatorRelease`	Forge frees indicator arrays itself.
`TesterWithdrawal`, `TesterDeposit`	A run's balance moves only by trades and their costs.
`Every tick based on real ticks`, `1 minute OHLC`, `Open prices only`	How finely a run checks fills between bars is a run setting, not part of the strategy.
`Alert`, `SendNotification`, `SendMail`, `PlaySound`, `WebRequest`	A backtest sends nothing. Log it with ctx.log.
`DatabaseOpen`, `DatabaseExecute`, `the other SQLite functions`	A strategy has no database. A lookup table can ship as a declared asset.
`OnnxCreate`, `OnnxRun`	Model files cannot be assets in FORGE_API 1.
`CAppDialog`, `CCanvas`, `on-chart controls`	A strategy has no on-chart controls.

Name by name

The program's events

You write	In Forge	Note	Trap
`OnInit`	setup(self, ctx). Refuse bad settings with raise fg.InvalidParams(...).fg.InvalidParams
`OnDeinit`	on_end(self, ctx, reason)
`OnTick`	compute(self, d) for signals over whole arrays; on_bar(self, ctx) for logic per bar		Trap
`OnTimer`, `EventSetTimer`	@fg.every(...) on a methodfg.every
`OnTrade`	on_order_event(self, ctx, event)
`OnTradeTransaction`	on_order_accepted, on_fill, on_order_cancelled, on_order_rejected, on_order_expired, then on_position_opened, on_position_changed, on_position_closed
`#include`, `#import`	A Python import of your own library file, which lists its names in __all__	A #import of a DLL has no equivalent: Forge runs Python only.

Settings

You write	In Forge	Note
`input`	param.Int, param.Float, param.Bool, param.Choice, param.Enum, param.Timeframe, param.Symbol, param.Session, param.Time, param.Price on the classfg.param.Int fg.param.Float fg.param.Bool fg.param.Choice
`sinput`	param.Int(..., optimize=False)fg.param.Int	A setting a sweep never changes.
`input group`	group="..." on each settingfg.param.Int
`.set files`	Load MT5 settings on the Tester's strategy card, or program.read_mql5_set(path) in a notebook
`ENUM_MA_METHOD`, `ENUM_TIMEFRAMES`, `ENUM_APPLIED_PRICE`	param.MaMethod, param.Timeframe, param.Sourcefg.param.MaMethod fg.param.Timeframe fg.param.Source

Orders

You write	In Forge	Note	Trap
`CTrade.Buy`, `CTrade.Sell`, `OrderSend`, `OrderSendAsync`, `CTrade.PositionOpen`, `PositionOpen`, `MqlTradeRequest`	long_entry= and short_entry= in fg.Signals, or ctx.buy(size, sl=, tp=, tag=) and ctx.sell(...) in a hookfg.Signals
`CTrade.BuyLimit`, `CTrade.BuyStop`, `CTrade.SellLimit`, `CTrade.SellStop`, `CTrade.OrderOpen`	ctx.order(fg.Order.limit(...)) or ctx.order(fg.Order.stop(...))fg.Order
`CTrade.PositionClose`, `PositionClose`, `OrderClose`	pos.close(), or ctx.close(tag=...)
`CTrade.PositionClosePartial`	pos.close(portion=0.5)
`CTrade.PositionModify`, `PositionModify`	pos.set_stop(price) and pos.set_target(price), or declared fg.Stop and fg.Targetfg.Stop fg.Target
`CTrade.OrderModify`, `OrderModify`	ticket.modify(...) for a pending order; pos.set_stop and pos.set_target for an open trade	MQL4's OrderModify changes both, so check which one the EA meant.
`CTrade.OrderDelete`, `OrderDelete`	ticket.cancel(), or ctx.cancel_all(tag=...)
`CTrade.SetExpertMagicNumber`, `magic numbers`	tag="..." on entries and ordersfg.Signals		Trap
`CTrade.SetDeviationInPoints`	The run's slippage setting
`OrderCheck`, `OrderCalcMargin`, `OrderCalcProfit`	ctx.check(order), ctx.calc.margin(order), ctx.calc.profit(...)
`MqlTradeResult.retcode`, `TRADE_RETCODE_*`	ticket.status and ticket.reject_reason, one of forge.types.RejectReasonfg.types.RejectReason
`ORDER_TIME_GTC`, `ORDER_TIME_DAY`, `ORDER_TIME_SPECIFIED`	tif="gtc", tif="day" or expire_at= on fg.Order.limit and fg.Order.stopfg.Order
`stops and targets in points`	fg.Stop.pips(...), fg.Target.pips(...)fg.Stop fg.Target		Trap

Positions

You write	In Forge	Note
`PositionsTotal`	len(ctx.positions())
`PositionSelect`, `PositionSelectByTicket`, `PositionGetTicket`	ctx.positions(symbol=, tag=), each with pos.id
`PositionGetDouble`	pos.avg_price, pos.stop, pos.target, pos.unrealized, pos.swap, pos.size	POSITION_PRICE_OPEN, POSITION_SL, POSITION_TP, POSITION_PROFIT, POSITION_SWAP and POSITION_VOLUME.
`PositionGetInteger`	pos.side, pos.open_time, pos.tag	POSITION_TYPE, POSITION_TIME and POSITION_MAGIC.
`PositionGetString`	pos.symbol, pos.entry_reason	POSITION_SYMBOL and POSITION_COMMENT.
`CPositionInfo`, `COrderInfo`, `CDealInfo`, `CAccountInfo`, `CSymbolInfo`	The objects above: pos, ticket, ctx.fills, ctx.account, ctx.symbol

Pending orders

You write	In Forge
`OrdersTotal`, `OrderSelect`, `OrderGetTicket`, `OrderGetDouble`, `OrderGetInteger`	ctx.orders(), each a ticket with price, stop_price, status and tag

History

You write	In Forge
`HistorySelect`, `HistoryDealsTotal`, `HistoryDealGetTicket`, `HistoryDealGetDouble`, `HistoryOrderGetInteger`	ctx.fills and ctx.trades: every fill and closed trade of the run so far

The account

You write	In Forge	Note	Trap
`AccountInfoDouble`	ctx.account.balance, equity, margin_used, free_margin, margin_level	ACCOUNT_BALANCE, ACCOUNT_EQUITY, ACCOUNT_MARGIN, ACCOUNT_MARGIN_FREE and ACCOUNT_MARGIN_LEVEL.
`AccountInfoInteger`, `AccountInfoString`	ctx.account.leverage, ctx.account.mode, ctx.account.currency	ACCOUNT_LEVERAGE, ACCOUNT_MARGIN_MODE and ACCOUNT_CURRENCY.	Trap

The symbol

You write	In Forge	Note	Trap
`SymbolInfoDouble`, `_Point`, `_Digits`	ctx.symbol.point, tick_value, tick_size, lot_min, lot_step, lot_max, digits; d.spec in compute()		Trap
`SymbolInfoTick`, `SYMBOL_BID`, `SYMBOL_ASK`	ctx.quote.bid and ctx.quote.ask in a hook; d.bid and d.ask series in compute()
`SymbolInfoInteger`	ctx.quote.spread, ctx.symbol.stops_level	SYMBOL_SPREAD and SYMBOL_TRADE_STOPS_LEVEL.
`SymbolSelect`, `SymbolsTotal`, `SymbolName`	symbols = ["EURUSD", "GBPUSD"] on the class
`SymbolInfoSessionTrade`, `SymbolInfoSessionQuote`	ctx.calendar.is_open() and fg.Filter.session(...)fg.Filter

Time

You write	In Forge	Note	Trap
`TimeCurrent`, `TimeTradeServer`	ctx.broker_time	In an EA under the tester this is simulated server time, and so is ctx.broker_time.	Trap
`TimeGMT`	ctx.time (UTC)
`TimeLocal`	ctx.local(zone) for a named zone	A backtest has no local computer clock.
`TimeToStruct`, `MqlDateTime`	Python datetime from ctx.broker_time or d.time_close

Data

You write	In Forge	Note	Trap
`CopyRates`, `CopyClose`, `CopyOpen`, `CopyHigh`, `CopyLow`, `CopyTime`, `CopyTickVolume`, `CopySpread`, `iClose`, `iOpen`, `iHigh`, `iLow`, `iTime`, `iVolume`	d.close, d.open, d.high, d.low, d.time_close, d.volume, d.spread in compute(); ctx.bars.close.ago(n) or ctx.history("close", n) in a hook		Trap
`ArraySetAsSeries`	Nothing: Forge arrays always run oldest first		Trap
`another symbol or timeframe in CopyClose`	d["GBPUSD"].tf("H4").close	Every other series is written in the file, so Forge loads it before the run.
`iBars`, `Bars`, `iBarShift`	len(d.close), ctx.bar, numpy.searchsorted(d.time_close, t)
`iHighest`, `iLowest`	fg.ta.highest and fg.ta.lowest over d.high and d.lowfg.ta.highest fg.ta.lowest
`EMPTY_VALUE`	NaN		Trap

Indicators

You write	In Forge	Note
`iMA and CopyBuffer`	fg.ta.ma(d.close, period, method=...) and the other fg.ta functions, called once in compute()fg.ta.ma	Each MT5 built-in maps to one fg.ta function: the indicator table lists them with their outputs.
`iCustom`	Put the calculation in a library file and call it in compute()

The tester

You write	In Forge	Note	Trap
`OnTester`	score(self, stats) -> float	It ranks a sweep. Every combination that ran still counts as a trial.
`TesterStatistics`	stats["net_profit"], stats.trade_count ... inside score(); ctx.stats while the run goes	STAT_PROFIT, STAT_TRADES, STAT_PROFIT_FACTOR and the rest.
`TesterStop`, `ExpertRemove`	ctx.stop_run(reason)	The run keeps its results and still counts as a trial.
`MQLInfoInteger(MQL_TESTER)`, `MQL_OPTIMIZATION`	ctx.mode	Reading the mode never changes behaviour. A strategy that trades differently by mode is flagged on its result.
`Modelling quality`, `History quality`	The run's price and fill facts on its run page	MetaTrader's figures count how complete the price history is, not whether fills are right. Forge's data quality score grades a dataset's files and is not a modelling quality either.	Trap

Randomness

You write	In Forge	Note
`MathRand`, `MathSrand`, `rand`, `srand`	ctx.rng, a NumPy generator the run seeds	Never seed it by hand: the run's seed makes every run repeatable.

Side effects

You write	In Forge	Note
`Print`, `PrintFormat`, `Comment`	ctx.log.info(...)
`GlobalVariableSet`, `GlobalVariableGet`	An attribute set in setup(self, ctx)	State lives on the strategy for one run.

Chart and screen

You write	In Forge
`ObjectCreate`, `ObjectSetInteger`, `ChartRedraw`	plots= in fg.Signals, or ctx.plot and ctx.mark in a hookfg.Plot

Files and storage

You write	In Forge	Note
`FileOpen`, `FileRead`, `FileWrite`, `the other file functions`	self.read_asset(path) for a file listed in assets	A strategy reads only the files it declares, and writes none.

Maths and strings

You write	In Forge
`MathAbs`, `MathMax`, `MathPow`, `ArraySort`, `ArrayMaximum`, `StringFind`, `StringSubstr`, `DoubleToString`, `TimeToString`, `the other maths, array, conversion and string built-ins`	Python and numpy: abs, math, numpy reductions, slicing, sorted, bisect, f-strings, str methods and datetime
`CArrayObj`, `CArrayDouble`, `CList`, `CTree`, `CHashMap`, `CString`, `the other Standard Library collections`	Python's list, dict, set, collections.deque, bisect, heapq and str
`matrix`, `vector`, `their methods`	numpy arrays and numpy.linalg