I should be upfront that I can't guarantee any EA is genuinely "proven profitable" with a specific profit factor since that depends on real backtesting I haven't run — but I can give them a solid, simple strategy structure like a session/range breakout with ATR filtering that's commonly used on gold, which they can then test themselves. I'll note gold's strong upward trend over recent years could bias trend-following backtests to look artificially good, so I want to flag that risk clearly and encourage them to run their own historical tests across different market conditions before trusting any result. I'm designing the EA around an H1 Donchian breakout confirmed by a 200 EMA trend filter, with ATR-based stop loss and take profit, position sizing tied to account risk percentage, session and spread filters, and ATR trailing stops for exits — using CTrade for order execution and one position per magic number. I'm also weighing a simpler London-session breakout approach (range from early morning hours, pending stop orders placed at the range extremes, closed out by day's end), but that depends too much on broker server time to be reliable across different setups, so I'm leaning toward the trend-following Donchian system as the more robust and explainable choice, especially given gold's strong directional moves in recent years. I'll design something like a Turtle-lite system: EMA 50/200 as trend filter on H1/H4, entries on a 20-bar breakout, stop-loss at 2×ATR, and a chandelier-style trailing stop at 3×ATR — while being careful not to claim specific backtest numbers, just noting this style of logic tends to suit trending markets like gold, with the caveat that actual performance depends on broker data, spread, and time period. Writing the strategy code... Adding more input parameters... Adding magic number and slippage settings, then thinking through spread filtering for gold -- since XAUUSD point values vary by broker digit convention (2 vs 3 decimal pricing), I'm considering expressing max spread in USD terms instead of raw points for consistency. Now I'm setting up the trade object and indicator handles, initializing the EMA and ATR indicators in OnInit... I'm handling deinitialization by releasing the indicator handles, then confirming that CTrade's SetTypeFillingBySymbol method is valid for setting filling policy per symbol. For OnTick, I'm structuring it to call the trailing stop management first, then check for a new bar before running the main strategy logic. Once a new bar is confirmed, I skip further processing if there's already an open position, or if the session/spread filters fail. Then I pull the EMA and ATR values from the prior closed bar, get its close price, and calculate the Donchian channel high/low using the bars just before the signal bar to determine breakout levels. I'm weighing whether to mark the bar as processed before or after the spread check — updating it early means skipping the bar entirely if spread is too wide, while updating it late would let the EA retry on subsequent ticks within the same bar, possibly at a different price. I'll go with the simpler once-per-bar evaluation, since wide spreads often occur right at session opens and skipping the bar is a reasonable trade-off. For the actual signal logic, I'm defining long entries when the prior close breaks above the recent high and stays above the EMA (with longs allowed), and short entries as the mirror condition using the recent low, executing at market price using Ask for buys and Bid for sells. For stop-loss and take-profit placement, I'm computing SL and TP as ATR multiples away from entry, and I'm working through whether the risk distance should be measured from the entry price itself or account for the bid/ask spread since buy positions close on the Bid price, not the Ask. Now I'm writing the lot sizing function that computes position size from account balance risk percentage, tick value, and tick size... I'm weighing whether to skip trades when calculated lots fall below the minimum, or force the minimum lot size and accept exceeding the risk limit—leaning toward using minLot with a warning so testing doesn't silently produce zero trades. Doing the math for a $1000 account with 1% risk ($10) against a typical gold ATR stop-loss (~$30 per 0.01 lot), the required lot size comes out to roughly 0.0033 lots, well under the broker minimum of 0.01, meaning nearly every trade would get skipped under strict risk enforcement. I'll default to enforcing minLot when computed size falls below it, and note in the explanation that testing should use a $10,000+ deposit for risk sizing to stay meaningful — rounding up to minLot at $1000 balance would effectively mean risking 3% instead of 1%. I'm also reconsidering whether hardcoding 2 decimal digits for lot normalization is correct, since brokers with a 0.001 or 0.1 lot step need digits derived from the actual step size rather than assumed. Working through the digit calculation, I verify it handles step sizes of 0.01, 0.1, and 1 correctly, checking for potential floating-point rounding errors in the log10 computation — but confirming these edge cases resolve safely since the value gets floored to the step afterward anyway. I also add a small epsilon to the floor division to avoid floating-point truncation errors, and include an optional margin check using OrderCalcMargin to skip trades when free margin is insufficient. I'm also considering the stops level requirement, checking whether the ATR-based stop distance satisfies the broker's minimum stops level for gold. Now I'm writing a helper function to detect whether an open position already exists for this symbol and magic number by looping through positions and checking their properties. Next I'm starting on the trailing stop management logic that adjusts stops based on ATR distance. Adding trailing stop logic... Writing trailing stop logic... I'm noting a real concern though: modifying the position on every single tick generates excessive server requests, which is acceptable in backtesting but risky for live trading. I should only send a modify request when the SL improvement is meaningful. A better approach would be to update the trailing stop once per new bar using a chandelier-style calculation, where the stop is set relative to the closing price minus a multiple of ATR, only moving in the trade's favor. Given the initial SL at 2 ATR and trailing at 3 ATR, the trailing stop naturally stays looser than the fixed SL until price moves about 1 ATR in profit, at which point it starts tightening in a smooth, natural way—so I don't need a separate breakeven mechanism. Since ATR updates dynamically, the trailing distance adjusts with volatility, while the "only tighten" rule guarantees the stop never loosens. I also need to verify the new stop respects the broker's minimum stop-level distance from price, which should hold automatically since the trail distance exceeds that threshold. Now I'm writing the session filter function that checks whether the current hour falls within the configured trading window, handling both same-day and overnight ranges... I'm considering whether to add a Friday cutoff to avoid weekend gap risk, but since this is a trend-following approach, holding positions over the weekend may actually be part of the edge, so I'll skip that filter for simplicity. I'm now writing a spread filter that compares the current ask-bid spread against a configurable maximum threshold expressed in price units. Writing trade opening logic... Adding margin validation and trade execution... I should also normalize the entry price to the symbol's tick size for safety, and note that passing 0 for price lets CTrade default to the current market rate. Now I'm structuring the OnTick logic: checking for a new bar via iTime, pulling the latest EMA and ATR buffer values, then moving into position management for trailing stops on any open trade. Then for new entries, I skip if there's already an open position, or if session/spread filters fail. Otherwise I locate the recent Donchian channel highs/lows using iHighest/iLowest, then pull the actual high, low, and prior close values to check for a breakout. I'm defining long/short signals based on whether the previous close broke the channel and aligns with the EMA direction, then calling OpenTrade accordingly. I'm also reconsidering whether to use static or dynamic arrays for CopyBuffer -- dynamic arrays are the safer, more conventional choice, so I'll switch to those. I'm also weighing whether re-entries should be allowed right after a stop-out on the same breakout level, versus requiring a "fresh breakout" filter where the prior bar's close hadn't already exceeded the channel boundary. Actually, since trailing stops require a pullback of a couple ATRs before triggering, a subsequent close above the 20-bar high genuinely represents a new breakout to fresh highs, so no additional filter is needed. The extra condition I was considering isn't necessary given how the trailing stop already forces price to retreat before re-entry can occur. Now I'm working out how to compute the trailing stop using ATR from the prior bar, using the current bid price as an approximation for the close, and considering a chandelier-exit style approach based on the highest high since the position was opened, which requires finding the bar shift from the position's open time. That's more complex than needed, so I decide to keep the trailing logic simpler by ratcheting the stop based on the last completed bar's close minus a multiple of ATR, which is more deterministic than using the live bid and avoids weekend gap oddities. For sells, since the SL triggers against Ask while close is based on Bid, the effective trailing distance shifts slightly by the spread—minor enough to ignore. I also need to check that any new stop level is valid relative to current price and skip the modification if a gap would make it invalid. Now I'm turning to backtest settings recommendations: symbol choice (XAUUSD or GOLD variants), timeframe (H1, though the EA's internal InpTF matters more than chart TF), and tick modeling mode, preferring real tick data when available. For the test period, I'd split into in-sample (2018–2022) and out-of-sample (2023–present) with a 10,000 USD deposit, 1:100 leverage, and simulated execution delay. For optimization I'd sweep Donchian period, SL and trailing ATR multipliers, and timeframe, but I want to warn strongly against overfitting—picking a parameter plateau rather than an isolated peak. I should also flag gold's long-term bullish bias, meaning long-only backtests will look artificially strong; shorts need separate testing and comparison against a simple buy-and-hold benchmark. Realistic profit factor expectations for trend systems tend to sit around 1.2–2, not some inflated number. I'm now weighing alternative strategies that might have better odds on gold: Donchian breakout with EMA filter and ATR trailing, Asian range breakout at London open, or an RSI(2) mean-reversion dip-buying approach in an uptrend, each with rough, uncertain profit factor ranges depending on the period tested. Since I can't actually backtest these, the honest path is to hand over a well-built strategy with a rigorous testing procedure and be upfront that I can't certify performance—the real value is in the user validating it themselves rather than trusting claims of a "proven" system. I'm also verifying MQL5 function signatures I'll rely on—iHighest with its ENUM_SERIESMODE parameter, iHigh/iLow/iClose/iTime, and iBarShift—to make sure the code I write compiles correctly. Confirming CTrade class methods next... I should cast position type explicitly to avoid ambiguity, and watch for long-to-int conversion warnings by casting explicitly where needed. I also note OnTester could return a custom optimization criterion if needed. During early bars, EMA200 might not be ready, but since the tester loads history before the start date, CopyBuffer should return valid data once bars are calculated—adding a BarsCalculated check isn't strictly necessary. I also confirm the new-bar detection using iTime works fine even if InpTF differs from the chart timeframe, and note that spread behavior depends on the tester's tick modeling settings. For modeling accuracy, I should recommend "Every tick based on real ticks" for final validation since SL/TP execution and spread are most realistic there, while "1 minute OHLC" is better suited for fast optimization passes despite being less precise about intrabar stop hits. Balance is fine for risk calculation rather than equity. Thinking through gold's typical H1 ATR in the $3000-4000 range (roughly $10-25), a 2×ATR stop lands around $20-50, and a 20-period Donchian on H1 spans about a day, which all seems reasonable. Spreads on gold ECN accounts typically run $0.15-0.60, though they widen in absolute terms as price rises, so I'm considering whether a $1.00 max spread filter still makes sense at these price levels. I'll set the default max spread to 1.0 as a safety margin, noting rollover spikes are already avoided by the session filter. Contract size differences across brokers shouldn't matter since risk sizing via tick value handles it automatically, and I'm working out how the default session window (8-20 server time) aligns with actual London/NY trading hours depending on the broker's GMT offset. I'll default the session filter to enabled, running 9-21 server time to roughly capture London open through mid-NY session, since Asian session breakouts on gold at low liquidity tend to be less reliable, and I'll note this is an assumption users should adjust to their broker's actual time offset. On reflection, I lean toward keeping the Donchian trend-following approach as the core system, since it's the most well-documented and robust concept across decades of futures trading data, including gold, rather than an Asian-range breakout variant. I want to be upfront that no EA is truly "proven" — I haven't backtested this exact code on the user's broker data — but I can offer a transparent system built on a well-established edge, along with clear guidance on how to properly test it themselves. I'm structuring the answer with a brief honest caveat, a summary of the strategy logic, the full code, installation and testing steps, guidance on what to optimize versus what risks overfitting, and warnings about gold's bull bias, spreads, and broker server time — plus fallback suggestions like trying H4 timeframe, longer Donchian periods, or long-only mode if results come back weak. Writing MQL5 strategy code... Adding more input parameters... Now I'm writing the OnInit function, validating inputs and creating the EMA and ATR indicator handles with error checks. I'm setting up trade parameters like magic number and slippage, adding OnDeinit to release indicator handles, and starting the OnTick logic that checks for a new bar before running the main trading logic. On each new bar, I copy EMA and ATR values, manage trailing stops on any open position, and then check session, spread, and existing position conditions before scanning for a Donchian channel breakout entry. I confirm the buy/sell logic checks out - close above the Donchian high with EMA confirmation, correctly using bars 2 through N+1. Now I'm moving to the trailing stop function, calculating a trail distance based on the ATR value. I loop through open positions filtering by symbol and magic number, fetching current bid/ask along with the broker's minimum stop distance, then pull each position's SL, TP, and type to prepare for the trailing calculation. For buy positions, I compute a new stop-loss below the close and only apply it if it improves the current SL and stays a safe distance from the bid. For sell positions, I mirror this logic above the close relative to the ask, though I'm noticing there's a subtlety worth checking in how newSL relates to close1 in that branch. Now I'm defining a price normalization helper that rounds to the symbol's tick size and digit precision, followed by a function to check whether an open position already exists on the current symbol. I'm also adding session and spread filters — one checking if the current hour falls within a configured trading window (handling overnight wraparounds), and another verifying that the bid-ask spread doesn't exceed the allowed maximum. Writing lot sizing logic... I'm rounding the calculated lot size down to the nearest lot step, then checking it against the broker's minimum and maximum allowed lot sizes, skipping the trade if it falls below the minimum. Skipping vs forcing a minimum lot: for honest backtesting, skipping is safer, so I'll print a message instead of forcing a trade. Running the numbers with a $10k account, 1% risk ($100), and a $40 stop loss on XAUUSD (100oz/lot, so $4000 loss per lot), that works out to about 0.025 lots, rounding to 0.02 - fine. But with a $1000 account the same math drops below the minimum lot size. I want to figure out the volume rounding properly so I'm not hardcoding 2 decimal places, since some brokers use a step like 0.05 which would break with simple rounding — I need to handle that edge case for computing the right number of digits from the volume step. Actually, wrapping with MathMax for safety is enough - simpler to just normalize to 2 decimals since most gold brokers use step 0.01, but I'll keep the robust version since it's just one line. Now writing the OpenTrade function that opens a buy/sell order using point size and ATR value... Adding margin check before executing the buy or sell order... I'm double-checking the syntax for error formatting and the ternary logic for order type selection, and confirming that spacing quirks like a space before a parenthesis in function calls don't cause issues in MQL5. I'm also verifying the tick handling logic — that trailing stops execute once per bar, positions reopen properly after being closed by stop-loss, and that using a different timeframe than the chart doesn't break timing consistency in the tester. I could add weekend gap protection for gold, but I'll skip it to keep things simple. Reconsidering default parameters — Donchian 20, EMA 200, ATR 14, SL at 2 ATR, trailing at 3 ATR — I'm working out the math: since trailing distance is looser than the initial stop, the trail only activates once price moves favorably past 1 ATR, after which it locks in a maximum giveback of 3 ATR from the most recent close. For gold on H1 at current prices, that's roughly $45-75 of giveback, giving average trade durations of maybe 1-3 days, which seems reasonable for trend-following. I'll keep 3.0 as the default but note it as an optimization candidate rather than adding breakeven logic or a higher-timeframe trend filter — better to keep things simple. Now I'm starting the testing guide, beginning with installation steps for setting up the expert advisor file in MT5's data folder. Now I'm walking through Strategy Tester setup — symbol, timeframe, date ranges for in-sample vs out-of-sample testing, tick modeling options, deposit and leverage settings — followed by what metrics to check in the report like profit factor, drawdown, and trade count. For robustness, I'd want to run the strategy out-of-sample after optimizing only on earlier data, check that performance holds up when nudging Donchian and stop-loss parameters slightly, and compare long-only versus long-short given gold's massive rally through 2019-2025. I should also test with wider spreads to check for stress in performance—recalling that MT5's tester lets you fix a spread value for certain execution modes, but real-tick mode pulls actual spread from historical ticks instead. I probably shouldn't push too hard on the spread stress-test angle via tester settings. Better to just note that "Every tick based on real ticks" mode uses the broker's actual spread/commission data, and users should verify the Commission column in the report reflects their real trading costs, since MT5's handling of commission in the tester depends on how the broker's account settings pass through. I'd suggest forward testing on demo for 1-3 months, then laying out a small optimization grid covering Donchian period, SL and trailing ATR multiples, timeframe, and session toggle. For the optimization criterion, I'd lean toward "Complex Criterion max" or "Balance + Profit Factor max" rather than optimizing on a single metric alone, since MT5 offers several options like Sharpe Ratio, Recovery Factor, and Drawdown min that can each overfit differently. What "good" actually looks like: out-of-sample profit factor around 1.5+, at least 100 trades, tolerable drawdown, and stable results across neighboring parameter values — a PF over 3 with few trades is a red flag for overfitting rather than a good sign. I also want to be honest that I haven't actually run this and can't hand over real backtest numbers, and I should note that trend-following systems naturally have long losing streaks, so with 1% risk per trade a string of 8-12 losses translates to roughly 10% drawdown, which is normal rather than alarming. I'm framing the response so it's upfront about limitations before giving code: I can't prove profitability, but I can give a simple EA built on a well-documented edge (trend-following breakouts on gold) plus a testing method so the user can verify it themselves. Now I'm mentally checking the MQL5 code for correctness, going through property declarations, includes, and input groupings for the strategy parameters. Writing input parameters... I'll switch InpSlippage to an unsigned type like uint to avoid the sign mismatch warning, since uint converts cleanly to ulong for the deviation parameter. In OnTick, I'm checking for a new bar using iTime, copying the EMA buffer with CopyBuffer, and using iHighest with MODE_HIGH to locate the Donchian channel high over the lookback period. In ManageTrailing, I'm confirming positions match the magic number and casting the position type before applying trailing logic. I'm checking that PositionModify calls, session time checks, and lot size calculations all handle their casts and rounding correctly, and verifying the error printout uses the right format specifiers for the retcode. The code looks like it compiles fine overall. I'm also confirming that MQL5 allows calling functions before their definition in the file, so the forward references in OnTick should work without issue, and that trailing stop logic correctly pulls ATR from the completed bar. Weekend gaps shouldn't cause problems since the session filter naturally excludes Monday's early bars outside trading hours. I'm deciding to skip adding a Friday-close option to keep things simple, and I'm now weighing whether I need a check to prevent entries on stale signals right when the EA starts or immediately after a position closes. Trailing stop pullbacks followed by a fresh breakout to new highs would count as a legitimate re-entry, so that's fine, and blocking new entries while already in a position handles the strong-trend case. The EMA 200 filter stays on H1 for consistency, and I'm skipping an ADX filter for now. I'm writing a custom OnTester function that combines profit factor, trade count, and drawdown into a single optimization score to penalize strategies with too few trades. This risks overengineering things — simpler is better here, so I'll drop the custom criterion and instead just advise using "Complex Criterion max" in the optimizer with a manual filter for trades ≥ 100. I'm also double-checking that I haven't left in unused statistics calls, and now thinking about whether the tester's "Delays" setting needs attention too. The Forward testing feature deserves a mention — setting it to 1/3 splits the run automatically into in-sample and out-of-sample periods, which is a solid tip for avoiding overfitting. I should also flag the symbol naming inconsistency across brokers, and note that session hours are quoted in server time, which is usually GMT+2/+3, so the actual trading window in GMT terms shifts accordingly. Estimating trade frequency for the H1 Donchian breakout setup with EMA and session filters, I'd guess somewhere around 80-150 trades per year given how often 20-hour highs get broken, so over a 5-year backtest that's several hundred trades — plenty for statistical significance, though I won't commit to exact numbers. I'll note in the guidance that if profit factor falls below 1.5 at default settings, switching to H4 timeframe is worth trying. I also want to flag that spread costs on H1 gold are small relative to a typical 2-ATR stop, roughly 1% of risk, which is a good reason to avoid M1/M5 scalping where costs would dominate. And I should warn about a red flag common in marketplace EAs: martingale or grid systems can display impressive profit factors right up until they blow up, whereas this EA's fixed-risk, single-position, hard-stop design avoids that trap entirely. Now I'm writing the full MQL5 source, starting with the file header, property declarations, and trade library include. Adding strategy input parameters... Setting up the trade object and indicator handles, then writing OnInit to validate input parameters and initialize the EMA and ATR indicators. I'm releasing the indicator handles on deinit, then setting up OnTick to trigger once per new bar, copy the EMA and ATR buffer values, and begin managing any open trade based on the ATR value. Next I'm checking for entry conditions—skipping if already in a position, outside session, or spread too wide—then locating the Donchian channel's highest high and lowest low over the lookback period to define breakout levels. I'll trigger a long trade if price closes above the upper band and the EMA, or a short if it closes below the lower band and EMA, then move into the trade-opening function which calculates minimum stop distance and stop-loss size based on the ATR value. Computing lot size and margin requirements... Prints an error message with the failed order's return code and description if the trade request doesn't succeed, then I'm double-checking the margin calculation logic and point-based buffer arithmetic look correct. Now I'm writing the trailing stop management function, which computes the ATR-based trail distance and broker's minimum stop level, then loops through open positions to filter for matching symbol and magic number before applying trailing logic. For buy positions, I move the stop loss up only if the new price is above the current SL and respects the minimum distance from bid; for sell positions, I move the SL down only if it's below the current SL and clears the minimum distance from ask. Now I'm writing a lot-size calculation function that pulls the symbol's min/max/step volume, then computes lots based on either a fixed input or a risk-based calculation using tick value and stop distance... Writing lot sizing logic... I'm double-checking the floating-point edge case where the floor/step multiplication could round just under the minimum lot due to precision errors, potentially rejecting a valid trade. To be safe, I want to subtract a tiny epsilon (1e-9) from minLot in the comparison so rounding artifacts don't wrongly trigger the skip. I also note the tick value calculation for XAUUSD is straightforward on USD accounts, but I should consider how it behaves on non-USD accounts. Now I'm writing a helper function to check whether an open position already exists on the current symbol matching the magic number, followed by a session-time check function that compares the current time against the allowed trading window. Adding spread and price normalization functions... I notice an edge case: if InpStartHour equals InpEndHour, the trading window check always returns false, which I should watch out for. I'm also reconsidering the OnTick ordering — since lastBarTime gets set before checking spread and session conditions, a wide spread on the bar's first tick means we skip the whole bar entirely, which seems like acceptable, documented behavior rather than a bug worth fixing. Now I'm thinking about whether the tester's "every tick" mode could cause the first tick of a new H1 bar to behave differently than expected. Checking through the remaining details — the highest/lowest calculation needs enough historical bars to work correctly, and I'm double-checking that the EMA buffer indexing correctly pulls the prior bar's value into the comparison. Everything looks solid so far, with no deprecated function warnings or input group compile issues to worry about. Thinking through whether the default parameters make sense in practice: a 20-bar H1 breakout with 2 ATR stops and 3 ATR trailing tends to lose on failed breakouts (roughly -2 ATR plus spread) but can ride winners during strong trends, giving a typical win rate around 35-45% with a profit factor somewhere between 1.1 and 1.8, which fits well with gold's strong trending behavior in recent years. I don't have actual backtest data to confirm a real profit factor, so I want to be upfront about that rather than guess a specific number. I should also suggest testing H4 timeframes since gold breakouts there tend to be cleaner, and note that the TP option defaults to off but a fixed 4 ATR target could be worth testing too. I'm putting together a sanity checklist for evaluating results: enough total trades (100-200+), OOS profit factor above 1.5, acceptable max drawdown under 20-25% at 1% risk, a long/short breakdown, and other key metrics to watch. I want to explain MT5's Forward setting for validating optimization results against unseen data, mention that real-tick testing requires downloading tick history which slows the first run, and recommend a 1-3 month demo forward test to confirm live execution matches the backtest before going live. I should also warn that grid/martingale EAs often show inflated profit factors right before blowing up an account, and briefly note how to attach the EA to a XAUUSD chart. On the profit factor claim, I don't want to promise PF>1.5 on the user's own data — instead I should frame realistic expectations: trend-following systems typically win only 35-45% of trades, profits come from a handful of large trend moves, and long losing streaks are normal and expected rather than a sign something's broken. I should also flag backtesting pitfalls specific to gold in MT5, like sparse tick data before 2020 and inconsistent broker symbol setups. But since the EA uses ATR-based distances and tick-value-based lot sizing, it should work regardless of whether the broker quotes gold in 2 or 3 decimals — that's worth highlighting as a strength. For length, I'm aiming for roughly 180 lines of code plus 350-500 words of explanation. I want to open with an honest disclaimer that no backtest guarantees future profit, then introduce the EA as a simple trend-following breakout system (Turtle/CTA style) with no grid, no martingale, and a hard stop on every trade, encouraging the user to verify PF>1.5 themselves. Then I'll lay out the logic starting with the H1 timeframe configuration. Now I'm detailing the entry rules (breakout above 20-bar high plus EMA200 filter, mirrored for sells), the ATR-based stop and trailing exit, 1% risk sizing, single trade at a time, and the London/NY session filter with spread checks. After the code, I plan to cover how to test it, which settings to optimize sparingly, how to judge results, and caveats around bull bias, costs, and forward testing—plus some fallback ideas like switching to H4 with a wider Donchian range or adjusting the trailing ATR multiplier if the default PF disappoints. I'm also weighing tester modeling options in MT5—real ticks vs 1-minute OHLC vs open-prices-only—and noting that open-prices-only mode, while fast for optimization, may execute SL/TP less precisely since it only generates ticks at bar opens. I'll suggest 1 minute OHLC for optimization runs and real ticks for the final verification, and mention random delay could add realism for the final check. I also sanity-checked margin requirements: with $10k deposit, 1:100 leverage, and roughly $30 SL risking 1% of equity, position size comes out around 0.03 lots requiring about $90 margin, which fits comfortably even accounting for brokers that cap gold leverage lower. Now I'm checking the max spread default of $1.00 against typical historical spreads—$0.25-0.50 in 2018, maybe $0.20-0.60 in 2025 on standard accounts, spiking to $1-3 during news—so this setting only filters out abnormal conditions, which is fine. The 50-point slippage setting translates to $0.50 or $0.05 depending on quote precision, a minor detail since market orders fill at requested price in the tester anyway. The magic number default looks fine too. I confirm the ATR-based trailing default of 0 means disabled, per the comment. I also verify the trailing stop logic doesn't need to compare against the open price, and consider whether using the highest high since entry (chandelier-style) would be better than close-based trailing—deciding the current approach is acceptable. I walk through the timing on the bar right after entry to confirm the new stop-loss calculation only triggers correctly when price has moved favorably by more than one ATR, which checks out, then move to reviewing the position/session/spread guard conditions in the entry logic. I run through the remaining code checks—Donchian lowest/highest lookups, slippage and magic number settings on the trade object, position magic number comparisons, and margin calculation calls—confirming each looks syntactically correct for MQL5 compilation. I also consider whether account balance retrieval is appropriate here, which it is, and think about whether to add a description property, deciding it's unnecessary. Now I'm sketching out the testing instructions section: filename `XAU_TrendBreakout.mq5`, steps to open MT5's data folder, create the file in the Experts directory, paste the code, and compile it in MetaEditor to confirm zero errors. I'll format the code block with a `cpp` language tag since markdown renderers often don't recognize mql5 directly, and I'm keeping the explanatory sections concise. For the Strategy Tester setup, I'm specifying symbol and timeframe (H1), tick modelling options (real ticks for final validation, 1-minute OHLC for faster optimization), deposit and leverage settings, random delay, and a broad date range to get enough history. Then I emphasize checking profit factor, trade count (200+), drawdown, and long/short balance, plus stress the importance of out-of-sample validation—optimizing only on the first two-thirds of data and confirming the results hold on the untested forward third—while keeping the parameter ranges for Donchian period and ATR-based stop-loss narrow enough to avoid overfitting. I want to choose a plateau of good parameters rather than a single lucky peak, and specifically test shorts separately since gold's huge bull run from 2019-2025 would make any long-only system look artificially strong. I also need to account for commission costs in the backtest report and confirm H1+ timeframes make sense given spread relative to stop distance, then plan a 1-3 month demo forward test comparing fills to backtest results. Finally, I'm noting realistic expectations for trend-following systems—modest win rates, long losing streaks, and meaningful drawdowns are normal, so a suspiciously smooth equity curve or extremely high profit factor with few trades is a red flag for overfitting. Working through the math confirms it: with a 40% win rate over hundreds of trades, the expected longest losing streak comes out to roughly 10, so citing "8–12" as normal checks out. The overfit flag for a suspiciously high profit factor with a small trade sample also holds up. Checking the gold price claim ($1,285 at start of 2019, surpassing $3,000 by March 2025) matches actual data. I should also note that session hours are relative to broker server time, so users on GMT+0 brokers need to shift the 9–21 window accordingly, or disable session filtering with InpUseSession=false to test independently. Now I'm finalizing the full EA code, making sure formatting and logic stay consistent throughout. Adding more inputs... Now I'm writing OnInit to validate parameters and create the EMA and ATR indicator handles, then configuring trade settings for magic number, slippage, and fill mode. I'm setting up OnDeinit to release the indicator handles, and beginning OnTick with new-bar detection logic. In OnTick I'm copying the EMA and ATR buffer values, then calling ManageTrailing for open positions before checking session and spread conditions, and locating the highest/lowest Donchian channel bars to determine entry levels... I'm now defining the entry condition: a breakout above the upper channel combined with price above EMA triggers a long, while a breakdown below the lower channel with price under EMA triggers a short, each calling OpenTrade. I'm starting OpenTrade by computing the stop-loss distance from ATR while respecting the broker's minimum stop level. Still writing trade execution logic... I'm double-checking the type promotion in the point calculation, confirming long plus int converts to long then multiplies correctly with a double. To be safe I'll just cast explicitly. Checking the trailing stop logic, I see the stops-level cast is already handled correctly, and now I'm writing the trailing management function that calculates trail distance from ATR. Writing trailing stop logic... Now I'm defining the lot size calculation function, starting with fetching the symbol's minimum and maximum volume limits. Still writing lot sizing logic... Now I'm capping lots at the maximum allowed and rounding to the correct volume digits before returning. Then I'm starting a helper function to check whether an open position already exists by scanning through current positions. Next I'm adding session and spread filters: one checks if the current time falls within the configured trading hours (handling windows that cross midnight), and another verifies the current spread is within the allowed maximum. I'm also writing a price normalization function that rounds a price to the nearest tick size and digit precision. Thinking about the minimum-lot warning log — since it only triggers when a signal fires, it shouldn't flood the tester log, so that's fine. I'm also verifying a few smaller MQL5 details: lot capping against the max, position type comparisons compiling correctly, MathLog10 being available, iTime returning zero when no data exists, and CopyBuffer's return semantics. Everything checks out, and I'm now looking at the trailing stop logic for buy positions. Since ATR shrinking after entry could make trailing activate sooner, but that's an acceptable edge case, and I'm confirming buy/sell signals can't trigger simultaneously since a price can't be both above the upper band and below the lower band at once. Running the tester on real ticks across 2018–2025 on H1 will be computationally heavy but should work fine. I recall MT5's tester preloads bar history before the official test start date, so the 200-period EMA will have enough data to calculate properly from the start. Now I just need to structure the final answer, starting with an honest caveat before diving into details. For explaining why this strategy is a reasonable candidate, trend-following breakout systems have decades of public track record in commodities like the Turtle traders and CTA funds, and gold tends to be more trend-prone than many other markets, while the longer H1 timeframe keeps spread costs manageable and the lack of grid/martingale means a solid profit factor actually reflects real edge rather than hidden blow-up risk. Now I'm drafting the actual response, starting with a blunt disclaimer that no backtest can prove future profitability since a profit factor over 1.5 only describes the past. I'm outlining a concrete trend-following breakout EA design instead — H1 timeframe, entry on a close above the 20-bar high plus above EMA 200 (mirrored for sells), with a stop at 2×ATR(14) and a trailing exit rather than a fixed take-profit — paired with a testing procedure so the user can verify profit factor themselves rather than trust anyone's claims. I'm adding risk rules (1% per trade, single position, London/NY session filter, spread checks) and explicitly ruling out grid/martingale approaches, then writing installation steps for MetaTrader — saving the file, compiling, and configuring the Strategy Tester with real-tick modeling, a $10k deposit, and a multi-year date range for realistic backtesting. Now I'm outlining how to validate results aren't just curve-fitting: using a forward out-of-sample split to confirm parameter sets hold up on unseen data, optimizing only a few key parameters while favoring stable plateaus over lucky spikes, requiring a minimum trade count for statistical significance, checking that short trades are also profitable (since gold's long-term uptrend could inflate long-only results), and making sure commission costs are properly reflected in the report. Then I want to stress realistic expectations — trend-following systems usually only win 35-45% of trades and rely on a few big winners, so long losing streaks and meaningful drawdowns are normal, and a suspiciously smooth equity curve with a very high profit factor is a red flag for overfitting or a hidden martingale-style system. I should also offer to help interpret their actual backtest results once they share numbers, and I'm noting to add something about server time when discussing session hours. I'll say win rate is often only 35-45%, and note that strings of 8-10+ losses in a row happen normally, translating to roughly 8-10% drawdown at 1% risk per trade. I'll wrap up with a brief offer to help interpret their backtest report if they share it, and double check some minor details like the delay setting appearing in MT5's options and the note about smaller accounts potentially seeing skips. I also want to verify the forward-optimization split logic before finalizing. Single-test mode without optimization likely doesn't apply forward-splitting the same way, so that's a minor point. On data depth, brokers' real tick history for gold often only goes back several years, which is fine for practical purposes. Reviewing the code once more, I'm checking input group naming, spread comment formatting, and confirming that ignoring the boolean return of TimeToStruct is safe. I'm also verifying that SetTypeFillingBySymbol is supported in current MT5 builds, since it was introduced in an earlier build and should be fine going forward. I skip adding SetAsyncMode since the default false works, confirm trailing logic runs correctly even outside session hours to manage open trades continuously, and verify iHighest safely returns -1 when count exceeds available bars, which is already handled. I'm satisfied with the EA name and ready to compose the final answer with a direct tone and a short, useful caveat. # Gold Trend-Breakout EA for MT5 No one can honestly give you a *proven* profitable EA. A backtest PF above 1.5 describes the past, not the future, and I haven't run this exact code on your broker's data. What I can give you is a simple EA built on a strategy family with a long public track record in commodities: **trend-following breakouts** (Turtle/CTA style). You can then check PF > 1.5 yourself instead of trusting anyone's screenshot. ## Logic - **Timeframe:** H1 by default (you can change it). - **Buy:** the last closed bar closes above the highest high of the previous 20 bars *and* above the 200-period moving average (EMA 200). - **Sell:** the mirror image. - **Exits:** - The initial stop is 2 × ATR(14). ATR (Average True Range) measures typical bar size. - There is no fixed take-profit by default. A 3 × ATR trailing stop lets trends run. - **Risk controls:** - 1% risk per trade, one position at a time. - New trades open only during the London/New York session. - Entries are skipped when the spread is abnormal. - **No grid, no martingale, no averaging down.** ```cpp //+------------------------------------------------------------------+ //| XAU_TrendBreakout.mq5 | //| Donchian breakout + EMA trend filter + ATR stop & trailing stop | //| 1 position at a time, fixed % risk, NO grid / martingale. | //| Educational code - backtest and demo test before going live. | //+------------------------------------------------------------------+ #property copyright "Free to use" #property version "1.00" #include //--- inputs input group "Strategy" input ENUM_TIMEFRAMES InpTF = PERIOD_H1; // Signal timeframe input int InpDonchian = 20; // Breakout lookback (bars) input int InpEMAPeriod = 200; // Trend filter EMA period input int InpATRPeriod = 14; // ATR period input double InpSL_ATR = 2.0; // Initial stop loss (x ATR) input double InpTP_ATR = 0.0; // Take profit (x ATR), 0 = none input double InpTrail_ATR = 3.0; // Trailing stop (x ATR), 0 = off input bool InpAllowLong = true; // Allow buys input bool InpAllowShort = true; // Allow sells input group "Risk" input double InpRiskPct = 1.0; // Risk per trade (% of balance) input double InpFixedLot = 0.0; // Fixed lot (>0 overrides risk %) input double InpMaxSpread = 1.0; // Max spread in price (1.0 = $1), 0 = off input group "Session (broker server time)" input bool InpUseSession = true; // Open trades only inside session input int InpStartHour = 9; // Session start hour input int InpEndHour = 21; // Session end hour input group "Misc" input ulong InpMagic = 777001; // Magic number input ulong InpSlippage = 50; // Max slippage (points) //--- globals CTrade trade; int hEMA = INVALID_HANDLE; int hATR = INVALID_HANDLE; datetime lastBarTime = 0; //+------------------------------------------------------------------+ int OnInit() { if(InpDonchian < 2 || InpEMAPeriod < 1 || InpATRPeriod < 1 || InpSL_ATR <= 0.0) return INIT_PARAMETERS_INCORRECT; hEMA = iMA(_Symbol, InpTF, InpEMAPeriod, 0, MODE_EMA, PRICE_CLOSE); hATR = iATR(_Symbol, InpTF, InpATRPeriod); if(hEMA == INVALID_HANDLE || hATR == INVALID_HANDLE) { Print("Failed to create indicator handles"); return INIT_FAILED; } trade.SetExpertMagicNumber(InpMagic); trade.SetDeviationInPoints(InpSlippage); trade.SetTypeFillingBySymbol(_Symbol); return INIT_SUCCEEDED; } //+------------------------------------------------------------------+ void OnDeinit(const int reason) { if(hEMA != INVALID_HANDLE) IndicatorRelease(hEMA); if(hATR != INVALID_HANDLE) IndicatorRelease(hATR); } //+------------------------------------------------------------------+ void OnTick() { //--- run once per new bar of the signal timeframe datetime barTime = iTime(_Symbol, InpTF, 0); if(barTime == 0 || barTime == lastBarTime) return; double ema[], atr[]; if(CopyBuffer(hEMA, 0, 1, 1, ema) != 1) return; if(CopyBuffer(hATR, 0, 1, 1, atr) != 1) return; lastBarTime = barTime; //--- 1) manage open trade ManageTrailing(atr[0]); //--- 2) look for a new entry if(HasPosition() || !InSession() || !SpreadOK()) return; int hiIdx = iHighest(_Symbol, InpTF, MODE_HIGH, InpDonchian, 2); int loIdx = iLowest (_Symbol, InpTF, MODE_LOW, InpDonchian, 2); if(hiIdx < 0 || loIdx < 0) return; double upper = iHigh (_Symbol, InpTF, hiIdx); // highest high of N bars before signal bar double lower = iLow (_Symbol, InpTF, loIdx); // lowest low of N bars before signal bar double close1 = iClose(_Symbol, InpTF, 1); // signal bar = last closed bar if(InpAllowLong && close1 > upper && close1 > ema[0]) OpenTrade(true, atr[0]); else if(InpAllowShort && close1 < lower && close1 < ema[0]) OpenTrade(false, atr[0]); } //+------------------------------------------------------------------+ void OpenTrade(const bool isBuy, const double atrVal) { double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT); double minGap = (double)(SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL) + 10) * point; double slDist = MathMax(InpSL_ATR * atrVal, minGap); double tpDist = (InpTP_ATR > 0.0) ? MathMax(InpTP_ATR * atrVal, minGap) : 0.0; double price = isBuy ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID); double sl = NormPrice(isBuy ? price - slDist : price + slDist); double tp = (tpDist > 0.0) ? NormPrice(isBuy ? price + tpDist : price - tpDist) : 0.0; double lots = CalcLots(slDist); if(lots <= 0.0) return; double margin = 0.0; if(OrderCalcMargin(isBuy ? ORDER_TYPE_BUY : ORDER_TYPE_SELL, _Symbol, lots, price, margin) && margin > AccountInfoDouble(ACCOUNT_MARGIN_FREE)) { Print("Not enough free margin - trade skipped"); return; } bool ok = isBuy ? trade.Buy (lots, _Symbol, price, sl, tp, "XAU Breakout") : trade.Sell(lots, _Symbol, price, sl, tp, "XAU Breakout"); if(!ok) PrintFormat("Order failed: %u %s", trade.ResultRetcode(), trade.ResultRetcodeDescription()); } //+------------------------------------------------------------------+ void ManageTrailing(const double atrVal) { if(InpTrail_ATR <= 0.0) return; double trail = InpTrail_ATR * atrVal; double close1 = iClose(_Symbol, InpTF, 1); double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT); double minGap = (double)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL) * point; double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID); double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK); for(int i = PositionsTotal() - 1; i >= 0; i--) { ulong ticket = PositionGetTicket(i); if(ticket == 0) continue; if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue; if(PositionGetInteger(POSITION_MAGIC) != (long)InpMagic) continue; double sl = PositionGetDouble(POSITION_SL); double tp = PositionGetDouble(POSITION_TP); if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) { double newSL = NormPrice(close1 - trail); if(newSL > sl + point && newSL < bid - minGap) // only ever move up trade.PositionModify(ticket, newSL, tp); } else { double newSL = NormPrice(close1 + trail); if((sl == 0.0 || newSL < sl - point) && newSL > ask + minGap) // only ever move down trade.PositionModify(ticket, newSL, tp); } } } //+------------------------------------------------------------------+ double CalcLots(const double slDist) { double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN); double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX); double step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP); if(step <= 0.0) step = 0.01; double lots = InpFixedLot; if(lots <= 0.0) { double tickVal = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE); double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE); if(tickVal <= 0.0 || tickSize <= 0.0 || slDist <= 0.0) return 0.0; double riskMoney = AccountInfoDouble(ACCOUNT_BALANCE) * InpRiskPct / 100.0; double lossPerLot = slDist / tickSize * tickVal; // money lost per 1.0 lot if SL hit lots = riskMoney / lossPerLot; } lots = MathFloor(lots / step + 1e-9) * step; if(lots < minLot - 1e-9) { Print("Lot below broker minimum - trade skipped (raise deposit/risk or set a fixed lot)"); return 0.0; } lots = MathMin(lots, maxLot); int volDigits = (int)MathMax(0.0, MathCeil(-MathLog10(step) - 1e-9)); return NormalizeDouble(lots, volDigits); } //+------------------------------------------------------------------+ bool HasPosition() { for(int i = PositionsTotal() - 1; i >= 0; i--) { ulong ticket = PositionGetTicket(i); if(ticket == 0) continue; if(PositionGetString(POSITION_SYMBOL) == _Symbol && PositionGetInteger(POSITION_MAGIC) == (long)InpMagic) return true; } return false; } //+------------------------------------------------------------------+ bool InSession() { if(!InpUseSession) return true; MqlDateTime t; TimeToStruct(TimeCurrent(), t); if(InpStartHour <= InpEndHour) return (t.hour >= InpStartHour && t.hour < InpEndHour); return (t.hour >= InpStartHour || t.hour < InpEndHour); // window crosses midnight } //+------------------------------------------------------------------+ bool SpreadOK() { if(InpMaxSpread <= 0.0) return true; double spread = SymbolInfoDouble(_Symbol, SYMBOL_ASK) - SymbolInfoDouble(_Symbol, SYMBOL_BID); return (spread <= InpMaxSpread); } //+------------------------------------------------------------------+ double NormPrice(const double price) { double tick = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE); double p = (tick > 0.0) ? MathRound(price / tick) * tick : price; return NormalizeDouble(p, (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS)); } //+------------------------------------------------------------------+ ``` **Notes on the code:** - All stop distances are based on ATR, and lot size is calculated from tick value. So it works whether your broker quotes gold with 2 or 3 decimals, and regardless of contract size. - Session hours use **broker server time**. The default 9–21 is roughly London open to mid-New York session for typical GMT+2/+3 brokers. Adjust this for your broker, or test with the session filter off. ## Install & run 1. Save the file: - In MT5, go to File → Open Data Folder → `MQL5\Experts`. - Save the code as `XAU_TrendBreakout.mq5`. - Open it in MetaEditor and compile (F7). You should see 0 errors. 2. Open the Strategy Tester (Ctrl+R) and set: - **Symbol:** your broker's gold symbol (XAUUSD, GOLD, XAUUSDm…). - **Period:** H1. - **Modelling:** *Every tick based on real ticks* for final results. *1 minute OHLC* is fine for faster optimization. - **Deposit:** 10,000 USD. Smaller accounts may see "lot below minimum" skips at 1% risk. - **Delays:** Random delay. - **Dates:** as far back as your broker has good data (e.g., 2018 → today). ## How to tell if the result is real and not luck - **Out-of-sample test:** set *Forward = 1/3* in the tester. The tester optimizes on the first 2/3 of the period and then shows how each setting does on the last 1/3. Trust only parameter sets that still show PF ≥ 1.5 on that unseen part. - **Optimize only a few settings:** | Setting | Range to test | |---|---| | Donchian lookback | 10–60, step 5 | | SL_ATR | 1.5–3.5 | | Trail_ATR | 2–5, step 0.5 | | Timeframe | H1 vs H4 | Pick a *plateau*, where neighbouring values are also profitable, rather than the single best spike. - **Trade count:** ignore any result with fewer than 100–150 trades. - **Long vs short:** gold went from about $1,300 (2019) to over $3,000 (2025), so the long side will flatter any backtest. Check the short-side results in the report. If only longs make money, the "edge" is partly just the bull market. - **Costs:** if your account charges commission, confirm it appears in the report. H1 is used deliberately: the spread is tiny compared with a 2×ATR stop, while most M1/M5 gold scalpers die on costs. - **Demo test:** after that, run it on a demo account for 1–3 months and compare with a backtest over the same period. ## Realistic expectations - Trend systems often win only 35–45% of trades and make their money on a few big runs. - Strings of 8–10+ losses in a row are normal. At 1% risk, that's roughly a 10% drawdown you must be able to sit through. - If you see PF 3+ with a perfectly smooth equity curve, suspect overfitting. - With other people's EAs, a curve like that often means a hidden grid or martingale. Those show beautiful PFs right up until they wipe the account. If you share your backtest results (PF, number of trades, drawdown, long/short split), I can help you interpret them and decide what to test next.

give me a simple yet proven to be profitable on XAUUSD EA fo...