How to Identify Your EX4 File's MT4 Build Version (And Why It Matters)
How to Identify Your EX4 File's MT4 Build Version (And Why It Matters)
Table of Contents
- Why the Build Version Changes Everything
- What an MT4 Build Version Actually Is
- Pre-600 vs Post-600: The Critical Divide
- How to Check Build Version from the MT4 Terminal
- Reading Build Information from the EX4 File Itself
- What Different Build Ranges Mean in Practice
- What Your Build Version Means for Decompilation
When someone submits an EX4 file to a decompilation tool and gets garbage output or an empty result, the most common reason is a mismatch between the file's build version and what the tool can handle. The MT4 build version that compiled the EX4 is not just a number — it determines the entire bytecode format the file uses, and that format is what a decompiler must understand to reconstruct source code. Getting an accurate read on the build version before you choose a decompilation approach is the most useful diagnostic step you can take.
Why the Build Version Changes Everything
MetaQuotes has released hundreds of MT4 terminal builds since the platform launched, and the compiler that generates EX4 files has changed meaningfully across that history. These changes are not superficial tweaks. Several major compiler revisions — most notably the shift around build 600 and further revisions in the 2020s — altered the internal bytecode format that EX4 files use to represent the compiled program.
A decompilation tool works by parsing this bytecode according to a set of rules about what each byte sequence means. When the bytecode format changes, the rules that worked for the old format produce incorrect or meaningless output when applied to the new format. This is why a tool that successfully decompiled EX4 files in 2015 may return completely unreadable output for an EX4 file compiled in 2022. The tool has not broken — the target has changed around it.
Professional Ex4decompiler.com maintain their parsing rules to keep pace with MetaQuotes compiler updates. Free tools do not. This single difference explains most of the quality gap between professional output and free tool output in 2026.
What an MT4 Build Version Actually Is
The MT4 "build" number is MetaQuotes' internal version identifier for the MT4 terminal and its associated tools, including MetaEditor. When a developer compiles an MQ4 source file in MetaEditor, the resulting EX4 file is stamped with information about the compiler that produced it. This information includes the build number of the MetaEditor version that performed the compilation.
The build number is not the same as the MetaTrader 4 version number visible in the terminal's about window. The build increments with every release, including minor updates that change nothing visible to traders. However, certain build ranges correspond to significant compiler changes that matter for decompilation:
- Builds below 600: The original MT4 compiler format, used for most files compiled before roughly 2014-2015
- Builds 600-799: The first major format revision, introducing changes to bytecode structure that broke most pre-existing decompilation tools
- Builds 800-999: Further refinements with additional bytecode changes, particularly affecting how certain function call types are encoded
- Builds 1000+: Current generation builds, including the compiler revisions from 2020 onward
These ranges are approximations — the exact threshold where each format change occurred is documented by the professional services that track these changes as part of maintaining their tooling. The practical point is that "build 600+" covers the overwhelming majority of EX4 files traders are working with today, because MT4 build 600+ has been the standard terminal installation for well over a decade.
Pre-600 vs Post-600: The Critical Divide
The build 600 transition is the single most important divide in EX4 decompilation history. Before build 600, the bytecode format was consistent enough that several independently developed tools could produce reasonable output. After build 600, MetaQuotes introduced format changes significant enough to break all of those tools simultaneously.
The nature of the post-600 changes included:
- Reorganization of the bytecode instruction set, changing which opcodes correspond to which operations
- Changes to how variables and their types are represented in the compiled binary
- Modifications to how function calls, including built-in MQL4 API calls, are encoded
- Different handling of string literals and their storage in the compiled file
For a decompilation tool built to handle pre-600 files, applying its parsing rules to a post-600 file does not produce a recognizable error — it produces output that looks like MQL4 but has incorrect logic, wrong variable types, and misidentified function calls. This is why free tool output on modern files is particularly dangerous: it is plausible-looking but wrong, which can mislead someone who does not know what to look for.
Files compiled before build 600 are almost always files from before 2015. If someone is trying to recover the source code of an EA that was actively traded and updated through the 2010s and 2020s, the file is almost certainly post-600. The free tool approach only makes sense as a starting point if there is specific reason to believe the file predates the format change.
How to Check Build Version from the MT4 Terminal
The most reliable method for identifying what build compiled a specific EX4 file is to identify the MT4 terminal installation that was used when the file was compiled. If you have access to the terminal where the file was compiled, or can ask the original developer which terminal build they used, this gives you a definitive answer.
In the MT4 terminal, the build number is visible in the Help menu under "About MetaTrader 4". This shows the current terminal's build. MetaEditor's build, which is what actually compiles files, is typically identical to the terminal build or within one or two builds of it.
For files received from third parties where the compilation environment is unknown, the terminal method is not useful since you do not have access to where the file was compiled. In those cases, you need to extract the build information from the file itself.
Reading Build Information from the EX4 File Itself
EX4 files contain a header section that includes metadata about the file, including the build version of the compiler that produced it. This header is part of the file's binary structure, not visible to human readers in a text editor, but readable with the right tools.
The practical approaches for extracting build information from an EX4 file:
Hex editor examination
Opening an EX4 file in a hex editor and examining the first 100-200 bytes will show the file header. The build number is stored as a 16-bit integer at a specific offset in the header. The exact offset varies depending on the file format version, but anyone familiar with the EX4 binary structure can locate it. The value will be a number like 509, 600, 745, 1174, etc. corresponding to the MetaEditor build that compiled the file.
MetaEditor analysis
Loading an EX4 file into MetaEditor (File > Open, or dragging the file into the editor) will show some metadata about the file in the Properties view. Depending on the MetaEditor version, this may or may not explicitly display the source build version, but the behavior of the editor when attempting to open or analyze the file often implicitly reveals compatibility.
Professional service inquiry
When submitting a file to a professional decompilation service, they perform build version identification as part of their initial file assessment. Most services can tell you the build version of a submitted file as part of their evaluation, even before the decompilation work begins. This is often the most practical approach for a non-technical user — rather than attempting hex editor analysis, submit the file and ask for the build report as part of the inquiry.
The article on ex4decompiler.com rovides more technical detail on the specific format differences between build ranges and why they break free tools so completely.
What Different Build Ranges Mean in Practice
Understanding which range your file falls into helps set accurate expectations for what decompilation will and will not achieve:
Pre-build 600 files
These are older files, typically compiled before 2015. The free tool route has the best (though still imperfect) chance of producing usable output on these files. The site's own free decompiler tool is designed specifically for this category. Variable names are generally not recoverable, but the trading logic — indicators, entry/exit conditions, order management — can usually be reconstructed in compilable form. If the file is from this era and has practical value, it is worth trying the free tool as a first step before committing to professional service fees.
Build 600 to roughly build 900
Files from the mid-to-late 2010s. Free tools fail completely on these files. Professional services handle them well, with success rates matching or exceeding the overall 96% average. Variable name recovery is limited by build version but logic recovery is strong. Expect clean, compilable output with generic variable names that an experienced MQL4 developer can work with without difficulty.
Build 900 and above (current generation)
Files compiled in recent years. Only professional services with maintained, up-to-date tooling handle these files reliably. The output quality from leading services on current-build files has improved significantly in 2025-2026, with AI-assisted naming producing substantially better variable names than earlier tool versions. These files benefit the most from the quality gap between professional services and any alternative approach.
What Your Build Version Means for Decompilation
The practical decision framework based on build version:
If you have a file that you know or suspect is pre-build 600, start with the free tool on this site. If the output is clean and compilable, you are done. If the output is garbled or fails to compile after minor cleanup, the file may have additional complications that warrant professional service submission even for older builds.
If you have a file compiled in the last five to ten years, skip the free tool route and go directly to a professional service. The time cost of attempting free tools that will not work on your file format is not worth it, and the failed output from a free tool on a post-600 file does not give you useful information about what the original code looked like.
If you do not know the build version, assume it is post-600. Statistically, any EX4 file from an actively traded EA is almost certainly a modern-build file. The pre-600 universe of actively used EAs has shrunk considerably as traders and developers have updated their systems over the years.
For the complete current picture of which services handle which build versions and how output quality compares across the options available in ex4decompiler.com covers the testing results across all major approaches with build version breakdowns included in the methodology.
Frequently Asked Questions About MT4 Build Versions
Can the same EX4 file contain code from multiple build versions?
No. An EX4 file is compiled as a single unit at a single point in time using a specific MetaEditor build. The entire file uses one bytecode format corresponding to that compiler version. It is possible for a developer to recompile source code with a newer MetaEditor, producing a new EX4 file with a newer build version — but that is a different file, not the original one with a mix of formats.
Does a higher build number always mean better decompilation results?
Not exactly. Higher build numbers correspond to newer compiler versions, and newer compiler versions have been harder to handle with unmaintained free tools. With a professional service that maintains current tooling, newer files can actually produce better output than very old files in some cases, because the more recent compiler revisions retained more recoverable metadata than certain intermediate formats.
If I recompile the decompiled MQ4 output, will the new EX4 match the original?
The recompiled EX4 should behave identically to the original when trading, but the binary files will not be byte-for-byte identical. The bytecode the new compiler generates from the reconstructed source will differ in representation while being functionally equivalent. Professional services verify this equivalence using backtesting comparison rather than binary comparison, which is the meaningful test for trading applications.
What if I cannot determine the build version of my file before submitting?
Professional services identify the build version as part of their intake process and can tell you before work begins. The build version identification does not affect whether you can submit the file — it affects the service's internal tooling selection and helps set expectations for the customer. If you submit a file without knowing the build version, the service will determine it and communicate what that means for your specific file.
