Options theory is framed around clear mechanics (call/put rights vs seller obligations), key parameters (underlying, strike, premium, expiration), and exercise/settlement styles. Pricing is anchored to Black-Scholes for European options, with practical caveats: shifting volatility, non-lognormal returns, and limited fit for American exercise. Sensitivities are handled via Greeks, especially Delta for replication.

The core idea is emulating options by trading the underlying to match an option portfolio’s Delta, enabling synthetic contracts with custom strikes/expirations—even when listed options don’t exist or are illiquid. Delta-hedged rebalancing (time-based or delta-step) keeps the synthetic payoff aligned, but requires systematic automation, low friction costs, and continuous monitoring to avoid tracking error and missed adjustments.

👉 Read | Signals | @mql5dev

#MQL5 #MT5 #EA

Source text is missing.

Paste the text to convert, and note the target platform if needed (e.g., LinkedIn, X).

👉 Read | Freelance | @mql5dev

#MQL4 #MT4 #EA

Manual horizontal support and resistance remains effective, but it is static and requires continuous chart watching. This creates a monitoring gap on fast markets or multi-chart setups.

An MQL5 Expert Advisor can track manually drawn OBJ_HLINE levels in real time, compare bid price to each level, and classify events as touch, breakout, reversal, and retest. Levels are treated as discrete prices for deterministic checks, with per-line state (side, touched, breakout flags) to avoid duplicate alerts.

Implementation uses OnInit/OnDeinit for setup and cleanup, OnChartEvent for sync and deletion handling, and OnTick as the main loop. UI buttons manage sync and reset. Signals include labels, arrows with cooldown and one-per-bar rules, plus alerts and optional candlestick reversal pattern filters.

👉 Read | Calendar | @mql5dev

#MQL5 #MT5 #EA

This article replaces Comment()/Print() output with a reusable full-screen console-style dialog for MetaTrader 5 charts. The goal is readable, structured, multi-line text with proper font control and scrollable navigation, without polluting the journal.

The core is CConsoleDialog, derived from CAppDialog, using CCanvas to render monospaced text (Consolas) suitable for table-like layouts. It supports vertical/horizontal scrolling via mouse wheel (Shift for horizontal), font scaling with Ctrl+wheel, programmatic font/color settings, and automatic resizing when the chart dimensions change.

Implementation details include splitting incoming text into lines, tracking longest line for scroll bounds, measuring character size for layout, and freeing canvas resources on minimize/maximize. Integration into an EA requires including ConsoleDialog.mqh, creating the dial...

👉 Read | Freelance | @mql5dev

#MQL5 #MT5 #EA

The CalculateLot function computes position volume using a fixed risk percentage of account balance, producing a lot size aligned with broker limits and symbol specifics.

Inputs typically include the risk percent, with internal reads for ACCOUNT_BALANCE, SYMBOL_TRADE_TICK_VALUE, plus VOLUME_MIN, VOLUME_MAX, and VOLUME_STEP for the current symbol.

Processing flow: derive the risk amount in deposit currency, convert it to volume using tick value, then normalize the result by rounding to the nearest VOLUME_STEP.

Validation clamps the final value to VOLUME_MIN/VOLUME_MAX. If the raw calculation is outside limits, the function returns the nearest allowed minLot or maxLot.

Typical usage patterns include direct calls from an Expert Advisor and script execution with explicit error checking and parameter validation.

👉 Read | Docs | @mql5dev

#MQL5 #MT5 #EA

Frontend EA A is a single MT5 EA that focuses on chart UI cleanup plus a compact quick-trading layer. Default grid, volumes, ticker bar, and the native one-click panel are hidden on load, replaced by larger custom price and time scales designed for readability.

The price scale uses round-number steps (1/2/2.5/5 × 10^k). The time scale prints the date once per day at 00:00 and shows time elsewhere. A compact tiled mode limits labels to 5 price levels and 3 time labels. Auto-padding around Bid and endpoint labels is in progress.

Trading controls include top-left BUY/SELL with an editable volume box persisted via GlobalVariable. Open positions render as entry-price plates with price, signed volume, and live PnL including swap and commission, refreshed at 1 Hz. Plates merge for overlapping entries and support one-click close per cluster.

Included indicators: H1...

👉 Read | Forum | @mql5dev

#MQL5 #MT5 #EA

Open-source MQL5 order execution library and demo EA for MT5 adds configurable retry logic, separate requote vs rejection handling, and slippage measurement in pips with violation detection. SL/TP values are normalized to broker stop levels, and fill policy is auto-detected across FOK, IOC, and RETURN.

Supports market and pending orders, plus position operations including close, partial close, SL/TP modification, and close-all-by-magic. Execution reporting includes success rate, average slippage, average execution time, and volume, with 10 human-readable result states and optional verbose logging.

Demo EA provides a chart dashboard with BUY/SELL/CLOSE ALL controls, live color-coded metrics, gauges, and a stats reset function. Two files placed in one folder compile without additional setup. Compatible with all brokers, instruments, and timeframes.

👉 Read | Quotes | @mql5dev

#MQL5 #MT5 #EA

The article outlines two non-standard money-management techniques aimed at improving exit quality and stabilizing performance in MetaTrader systems.

First, it proposes partial position closing driven by the previous bar’s impulse size. A power function maps last-bar movement (in points) to the volume to close, with parameters chosen so developers tune behavior via intuitive anchors rather than raw coefficients. The goal is to harvest rollbacks after strong candles and reduce spread impact when the final exit is uncertain.

Second, it describes a hybrid lot-variation model combining martingale and reverse-martingale logic based on equity “waves.” Lots are increased during drawdown phases and reduced during recovery, constrained within a min/max corridor and pulled back toward the midpoint to avoid sticking at extremes. Practical value depends on markets domin...

👉 Read | Forum | @mql5dev

#MQL5 #MT5 #EA

An object-oriented FVG scanner in MQL5 starts with strict three-candle geometry: bullish gaps form when candle 3 high is below candle 1 low; bearish gaps invert that relationship. This removes indicator lag by working directly on OHLC microstructure.

The implementation centers on a CFVGScanner class that pulls data via CopyRates into an MqlRates array (series-indexed), validates bar count to avoid out-of-range crashes, and supports multiple timeframe instances without shared global state.

A mitigation pass filters stale zones by scanning forward after detection and discarding gaps already touched by later highs/lows. Performance stays near O(N) with early breaks, and the EA runs scans only on new bars, not every tick.

Rendering uses OBJ_RECTANGLE with a unique name prefix plus targeted cleanup/deletion to prevent chart-object buildup and preserve user draw...

👉 Read | NeuroBook | @mql5dev

#MQL5 #MT5 #EA

MetaTrader 5 lacks account-level validation after trade entry. Positions can be modified, partially closed, or opened by multiple EAs and manual actions, creating gaps between intended risk and real exposure.

An enforcement engine treats risk as continuously verifiable conditions: SL present, TP defined, equity-based risk within limits, and a maintained risk-to-reward ratio. Violations trigger reporting or correction depending on mode.

Core modules: trade monitor, risk evaluator, enforcement, dashboard/alerts, and session configuration. MQL5 uses OnInit() with EventSetTimer(), OnTimer() to scan positions, broker stop-level checks, tolerance-based comparisons, lot-size reduction, and TRADE_ACTION_SLTP updates.

Modes: passive, assisted, strict. Logging and on-chart state tracking support testing and auditability.

👉 Read | CodeBase | @mql5dev

#MQL5 #MT5 #EA

Packing an MQL5 EA into OnTick scales into a fragile monolith where UI, filters, execution, and logging collide. MetaTrader 5 is event-based, so logic should follow the platform’s model: OnInit/OnDeinit for lifecycle hygiene, OnTick for market reactions, OnTimer for periodic background work, OnChartEvent for UI and inter-module messaging, OnTradeTransaction for order lifecycle tracking, and OnBookEvent for depth-driven strategies.

Custom events (EventChartCustom) act as an internal message bus across modules and even across charts, enabling multi-symbol systems without tight coupling. This improves responsiveness and testability by isolating behaviors per handler and avoiding long blocking routines.

Services extend the architecture beyond charts, running continuous background tasks in OnStart (data sync, custom symbol ticks, scheduled signals) and coordinating ...

👉 Read | AppStore | @mql5dev

#MQL5 #MT5 #EA

Grid-searching PT/SL on historical Sharpe is statistically fragile. Two free parameters will often select a rule that fits path-specific noise rather than the underlying trade P&L process, matching the López de Prado overfitting criterion.

A process-based alternative estimates a discrete Ornstein–Uhlenbeck model on cost-adjusted per-trade P&L, then derives PT/SL via OTR on 100,000 synthetic paths. SL is bounded by risk constraints; PT is driven by the forecast assumption.

The forecast is the key modeling choice. forecast=0 implies mean-reversion. forecast=E[P&L] is conservative directional. forecast=E[win] is optimistic directional. Units (pips vs returns) are a linear rescale; phi/half-life is invariant. Numba makes the sweep practical on a single machine.

👉 Read | NeuroBook | @mql5dev

#MQL5 #MT5 #EA

Multi-timeframe EAs in MQL5 often fail in long runs for two reasons: indicator handles get created repeatedly and never released, and signals are calculated from the still-forming bar (shift 0). Short tests hide both issues, while live terminals show rising mt5.exe memory, “IndicatorCreate failed” journal lines, and unstable signal counts.

A structured fix is a small MTF engine that centralizes lifecycle and indexing. Handles are created once in OnInit(), tracked internally, and released via a single ReleaseAll() in OnDeinit(). Buffer reads default to bar_shift=1 to avoid phantom crossovers.

For HTF reads, readiness needs more than CopyBuffer() returning data. Checking iTime(symbol, timeframe, 1) prevents stale values when the higher timeframe has not recalculated yet.

👉 Read | Forum | @mql5dev

#MQL5 #MT5 #EA

A lightweight MetaTrader 5 “chart replay” workflow can be built directly inside Strategy Tester Visual Mode by adding a simple UI layer to an EA. Using CButton for on-chart controls and CTrade for execution, BUY/SELL actions become one-click events handled in OnTick by checking button state, sending orders, then resetting the control.

Trade management is kept deterministic and fast: a CLOSE ALL button loops through open positions and closes only those owned by the EA via a Magic Number, using CPositionInfo for selection and filtering. Risk controls start as inputs (lot size, initial stop), then evolve into an automated trailing stop that updates SL only when price moves far enough in favor, reducing churn and locking in gains.

The practical payoff is rapid manual validation of strategy logic (entries, filters, failure cases) before spending time coding full...

👉 Read | Signals | @mql5dev

#MQL5 #MT5 #EA

MetaTrader 5 EA events are received by a Flask API and acknowledged, but persistence is missing. Successful responses without SQLite writes block pipeline verification and downstream analysis.

Backend behavior is extended to store each closed trade as a durable Trade row. POST /api/v1/trades accepts only valid JSON, validates required fields, converts numeric values, and parses open_time/close_time using YYYY.MM.DD HH:MM:SS. On success it commits the transaction and returns 201 with trade_id; on failure it rolls back and returns 4xx or 5xx.

API endpoints are completed for retrieval and inspection: list trades, fetch a single trade by id with 404 on miss, and a basic summary computing trade count and total profit. This enables end-to-end testing from MT5 to SQLite and back through the API.

👉 Read | Docs | @mql5dev

#MQL5 #MT5 #EA

Tick series are consolidated into a single collection to support multi-symbol workflows in MQL5. The implementation is based on a sorted CListObj storing pointers to CTickSeries instances, one per symbol, aligned with existing DoEasy collection patterns.

Core methods cover lookup by symbol, accessors for ticks by list index or timestamp (including millisecond resolution), and batch operations: setting “used” flags, configuring history day depth, creating series, and producing short/full journal dumps. New-tick and refresh hooks are present but marked for later completion in CTickSeries.

Engine.mqh is extended to build the tick series collection alongside the existing timeseries collection via SetUsedSymbols(days). A test EA removes direct tick-series ownership and queries the library collection to find per-symbol max Ask and min Bid ticks; sample initializa...

👉 Read | AppStore | @mql5dev

#MQL5 #MT5 #EA

Running ONNX inference natively in MQL5 is practical, but stability usually breaks on four points: tensor shape mismatch, preprocessing drift between training and live data, ONNX session handle leaks, and CPU overload from per-tick execution.

A production-oriented pattern treats these as requirements. Input and output tensor shapes must be explicitly bound to the compiled graph. Preprocessing must be deterministic in-terminal and match the Python scaler parameters. The ONNX session lifecycle should be encapsulated in a class with strict create/run/release control.

Execution policy matters. Inference on every tick degrades live trading and Strategy Tester speed. A common safeguard is running feature extraction and OnnxRun once per new bar, then gating decisions by a probability threshold.

Deliverables typically split into an ONNX session manager include and an ...

👉 Read | Docs | @mql5dev

#MQL5 #MT5 #EA

Multi-EA MT5 accounts often fail due to unmanaged interaction between strategies, not a single defective EA. Independent sizing can stack correlated exposure, synchronize stop-outs, and bypass any real account-wide daily loss limit.

A proposed architecture shifts EAs to signal-only roles. Each EA sends trade intent (symbol, side, stop, strategy id) to a central MT5 Service, RiskGate, which enforces portfolio rules and returns approved/rejected, lot size, and a reason.

RiskGate runs as a TCP server inside an MQL5 Service. EAs use a client wrapper with JSON messages, timeouts, reconnection, and deterministic fallback (reject or fixed-lot). Risk logic is isolated in a single handler method, enabling consistent limits across all strategies.

👉 Read | VPS | @mql5dev

#MQL5 #MT5 #EA

Manual multi-timeframe checks in Market Watch require repeated chart switching and subjective scoring. At scale, the workflow becomes slow and inconsistent, with missed alignment signals across symbols and timeframes.

CMultiTimeframeMatrix provides a deployable dashboard for MT5: a symbols x timeframes matrix with per-cell composite scoring (trend slope + momentum – volatility) scaled near [-100, +100]. Blue/red intensity reflects bullish/bearish bias, while the numeric score remains visible.

Delivered as a reusable .mqh module plus a thin host EA. Updates run on a timer with differential refresh, re-entrancy protection, performance warnings, and an ‘M’ hotkey to toggle visibility.

👉 Read | Freelance | @mql5dev

#MQL5 #MT5 #EA

A practical remote voice-command bridge for MetaTrader 5 is built by combining Telegram voice notes with a pull-based HTTP polling EA. A Python middleware (Telegram bot + local HTTP server) transcribes voice audio, parses a small command grammar into JSON, and queues requests; the EA polls every 2 seconds, executes via CTrade, then POSTs a JSON result that the bot relays back to Telegram.

The architecture stays low-bandwidth and tolerant of mobile connectivity: small GET polls (<1 KB) plus a short voice download, with typical end-to-end latency under a few seconds. Key engineering details include local-only HTTP on 127.0.0.1, simple in-memory synchronization, and stripping the MQL5 null terminator before POST to avoid Python JSON parse errors.

The approach is modular: Google STT can be swapped for offline speech later, while the EA remains a minimal WebRequ...

👉 Read | AppStore | @mql5dev

#MQL5 #MT5 #EA