MQL5 Code Formatting in MetaEditor: Auto-Indent & Refactor

Why Clean Code Matters in MQL5 Development

If you've ever opened an Expert Advisor you wrote six months ago and spent twenty minutes just figuring out where one loop ends and another begins, you already know the pain. MQL5 code formatting isn't about aesthetics — it's about maintainability. A well-structured EA or indicator saves you hours when you need to tweak parameters, fix bugs, or hand it off to another developer.

MetaEditor, the built-in IDE for MetaTrader 5, includes several tools that most traders never touch. The auto-indent feature, code beautifier, and refactoring utilities can transform a messy script into something you can actually read. This guide walks through each tool step by step, with exact menu paths and settings you can apply right now.

I've seen too many traders treat formatting as an afterthought — they write 500 lines of OnTick() with no indentation, then wonder why the Strategy Tester crashes on a simple logic error. Clean formatting isn't just about looking professional; it's about catching bugs before they cost you money. A missing closing brace or misaligned if-else block can silently corrupt your trade logic, and you'll spend hours debugging something that proper indentation would have revealed in seconds.

What You'll Need Before Starting

These steps work with MetaTrader 5 build 2000 or newer. You don't need a demo account or any special permissions — just the MetaEditor application that ships with MT5. If you're on MT4, the same tools exist in MetaEditor 4 with slightly different menu names. I'll call out differences where they matter.

You should have at least one MQL5 file open in MetaEditor — an EA, indicator, script, or even a blank file. If you don't have code to practice on, create a new file from File > New > Expert Advisor and accept the default template. That template intentionally has inconsistent formatting, perfect for testing the tools.

One thing most people miss: the template EA that MetaEditor generates uses tabs by default, not spaces. If you're working with other developers or planning to share code on forums like MQL5.com, tabs will cause alignment headaches. I recommend converting everything to spaces early — more on that in Step 1.

Step 1: Enable Auto-Indent and Set Your Style

Auto-indent is the single most impactful formatting feature in MetaEditor. When enabled, it automatically adds or removes indentation as you type — hitting Enter after an opening brace indents the next line, and typing a closing brace shifts back. This keeps your code tree structured without manual tab-pressing.

To turn it on and configure it:

1. Open MetaEditor (Tools > MetaQuotes Language Editor in MT5, or press F4 from the main platform).
2. Go to Tools > Options.
3. Click the Editor tab.
4. Under Auto-indent, check the box "Enable auto-indent".
5. Set Indent size to 3 (my preference — 2 is too tight, 4 eats horizontal space on wide monitors).
6. Choose Indent type: Spaces (tabs cause alignment issues when code is viewed on different editors).
7. Check "Auto-close braces" — when you type {, MetaEditor inserts } and positions the cursor between them.

Once enabled, every new line you type inside a function or conditional block will automatically indent. Existing code won't change until you explicitly reformat it (step 2).

MT4 difference: In MetaEditor 4, the same options are under Tools > Options > Editor, but the tab is labeled "General" and the indent type setting is in a dropdown rather than radio buttons.

A quick tip: after setting indent size to 3 spaces, run Edit > Advanced > Convert Tabs to Spaces on any existing file. This normalizes the entire document so you don't end up with a mix of tabs and spaces — a common source of formatting weirdness.

Step 2: Run the Code Beautifier (Auto-Format)

The beautifier — officially called Format Document — reformats your entire file in one shot. It adjusts indentation, adds spaces around operators, aligns braces, and normalizes line breaks. This is the tool you run before saving any file you plan to share or reuse.

To use it:

1. With your MQL5 file open and active, go to Edit > Format Document (or press Ctrl+Shift+F).
2. MetaEditor processes the entire file. You'll see indentation snap into place, braces align, and spacing clean up.
3. If you only want to format a selection, highlight the code block and use Edit > Format Selection (Ctrl+Shift+S).

The beautifier follows the indentation rules you set in Options. It also applies these standard MQL5 conventions:

• Spaces around binary operators (+, -, *, /, &&, ||)
• No space between function name and opening parenthesis for declarations
• One space between keywords like if, for, while and the opening parenthesis
• Opening brace on the same line for functions, on a new line for control structures (configurable — see tip below)

Real example: Before formatting, a common EA template looks like this:

int OnInit()
{
Comment("EA started");
if(IsTesting())
Print("Running in tester");
return(INIT_SUCCEEDED);
}

After Format Document, it becomes:

int OnInit()
  {
   Comment("EA started");
   if(IsTesting())
      Print("Running in tester");
   return(INIT_SUCCEEDED);
  }

Notice the consistent three-space indentation and the aligned braces. The beautifier also handles nested blocks inside if statements, loops, and switch cases. For example, a nested for loop inside an if block will be indented correctly, with inner braces aligned to their respective levels.

Edge case — preprocessor directives: The beautifier sometimes struggles with #ifdef/#endif blocks. If you have conditional compilation sections, the formatter might misalign them. The fix is to manually indent those blocks after formatting, or use a separate include file for platform-specific code.

Step 3: Refactoring Tools — Rename, Extract, and Reorder

Refactoring means restructuring code without changing its behavior. MetaEditor offers several refactoring operations that save you from manual find-and-replace disasters.

Rename Symbol

When you need to rename a variable, function, or class, never do it by hand. Use Refactor > Rename Symbol (Ctrl+R, R).

1. Place your cursor on the symbol name you want to rename.
2. Press Ctrl+R, R or right-click and choose Refactor > Rename Symbol.
3. A dialog appears showing the current name. Type the new name.
4. Check "Preview changes" to see every occurrence that will change.
5. Click Apply.

This updates all references — including in other files within the same project — without touching variable names that happen to match in unrelated contexts. I've used this to rename a poorly named int a to int fastMAPeriod across a 2000-line EA in two seconds.

Gotcha: Rename Symbol won't update string literals or comments. If you have Print("a = ", a);, the string "a = " stays unchanged. You'll need to update those manually. Also, the tool only works on symbols that are properly declared — if a variable is used before it's declared (which MQL5 doesn't allow anyway), it won't be found.

Extract Function

When a block of code inside OnTick() or OnCalculate() grows past 20 lines, it's time to extract it into its own function. MetaEditor can do this automatically:

1. Select the lines you want to extract.
2. Right-click > Refactor > Extract Function (or Ctrl+R, F).
3. Name the new function and choose its return type (default is void).
4. MetaEditor creates the function definition, moves the selected code into it, and replaces the original block with a function call.

This is brilliant for breaking monolithic EAs into manageable pieces. The tool even detects which variables from the outer scope are used inside the extracted block and passes them as parameters. For example, if you extract a block that uses closePrice and stopLoss, it'll generate a function like void CheckExit(double closePrice, double stopLoss) automatically.

Limitation: Extract Function doesn't handle global variables well. If your selected code modifies a global variable, the tool might not capture that correctly — you'll end up with a parameter passed by value instead of by reference. Always double-check the generated function signature.

Reorder Parameters

If you've ever written a function with parameters in the wrong order, Refactor > Reorder Parameters (Ctrl+R, O) lets you drag parameters up or down. All calls to that function are updated automatically.

This is especially useful when you're standardizing function signatures across an EA. Say you have void CalculatePosition(double sl, double tp, double lotSize) and decide lotSize should come first — drag it to the top, and every call to CalculatePosition() gets reordered instantly.

Step 4: Code Cleanup with the Navigation Bar

The navigation bar at the top of the MetaEditor window (below the toolbar) shows a dropdown of all functions, classes, and global variables in your file. Click any entry to jump directly to its definition. This isn't formatting per se, but it makes navigating large files much faster.

To enable it if you don't see it: View > Navigation Bar.

Combine this with Ctrl+Shift+F (find in files) and Ctrl+G (go to line) for rapid code navigation without scrolling. I also use Ctrl+Tab to switch between open files — it's faster than clicking tabs.

For really large projects (50+ files), consider using the Project Explorer (View > Project Explorer) to organize your files into folders. This doesn't affect formatting, but having a clean project structure complements your clean code.

Tips and Best Practices from Experience

Here's what I've learned after formatting hundreds of MQL5 files:

Run Format Document before every commit. If you use version control (and you should — even just local Git), always format before committing. This prevents formatting changes from cluttering your diffs. I've seen pull requests where 80% of the diff was just whitespace changes because someone forgot to format before.

Set brace style early. MetaEditor lets you choose between "Java style" (opening brace on same line) and "Allman style" (opening brace on new line). In Tools > Options > Editor, under Brace style, pick whichever you prefer. I use Allman for functions and Java style for control structures — a hybrid that MetaEditor supports if you manually set it and run Format Document. Here's how that looks:

// Allman for functions
int OnInit()
  {
   // Java style for control structures
   if(condition) {
      // code
   }
  }

Use Ctrl+Shift+S for selective formatting. When you paste code from a forum or another source, it often has different indentation. Select the pasted block and run Format Selection instead of the whole file. This avoids accidentally reformatting parts you didn't touch.

Comment style matters too. MetaEditor doesn't reformat comments, so adopt a consistent style manually. I use // for single-line notes and /* */ for block comments that explain complex logic. Avoid inline comments that push code past 120 characters — they wrap badly on smaller screens. For example, this is bad:

double ma = iMA(_Symbol, _Period, 14, 0, MODE_SMA, PRICE_CLOSE); // Moving average calculation for entry signal based on 14-period SMA

Better to put the explanation above:

// Calculate 14-period SMA for entry signal
double ma = iMA(_Symbol, _Period, 14, 0, MODE_SMA, PRICE_CLOSE);

Create a template with your formatting already applied. Save a clean, formatted Expert Advisor.mq5 template in MetaEditor\Templates\. Every new EA you create from File > New will inherit your formatting standards. To do this:

1. Create a new EA from the default template.
2. Run Format Document.
3. Delete the boilerplate code you don't need.
4. Save it as MyTemplate.mq5 in %APPDATA%\MetaQuotes\Terminal\<instance>\MQL5\MetaEditor\Templates\.
5. Restart MetaEditor, and your template appears in File > New.

Common Mistakes and Troubleshooting