How We Built the Most Powerful Machine Learning-Powered Trading Platform: The Evolution of MQL and MetaTrader Through Archives, Forums, and Releases

From the First Expert Advisors to the Agentic AI Assistant, MCP, and OpenBLAS: How the MQL Ecosystem Has Evolved.

The history of MQL is the story of its transformation from a simple language for trading strategies into a comprehensive development and analytical environment. Today the ecosystem combines MetaEditor, MQL5, Python, ONNX, the Agentic AI Assistant, Model Context Protocol (MCP), OpenBLAS, and the Algo Forge Git infrastructure.

From the Language of Expert Advisors to an IDE

These days, it's hard to think of MetaEditor as merely a code editor. It includes documentation, a compiler, debugger, profiler, project management, MQL5.COM integration, centralized source code storage, Python integration, ONNX support, an AI Assistant, SQLite database support, and the ability to work with CSV files as editable tables. Yet this evolution did not happen overnight.

From the earliest generations of its platforms, MetaQuotes was moving in one direction: to give traders not just a chart and a trade button, but also the ability to describe a trading idea in code, test it on historical data, and put it to work without human intervention. The history of MQL is the story of how a simple language for Expert Advisors gradually evolved into a full-fledged engineering environment.

The Internet has not preserved everything. Some of the old pages have disappeared entirely; some remain only in the Internet Archive Wayback Machine; and some can be found in old forum archives and news articles. Nevertheless, enough material remains to reveal the main evolutionary path:

Fx Charts → MetaQuotes → MetaTrader → MetaTrader 4 → MetaTrader 5

This distinction is important. The archives contain find various build numbers, internal version designations, and titles of old forum threads. However, the public history of the platform is best understood as a progression of products and ideas rather than a sequence of version numbers. At the heart of this story lies not software releases, but the gradual transformation of a trading terminal into a developer's workspace.

Expert Advisors Came Before the Language

The earliest archive reference to the MetaQuotes website dates back to February 2001. MetaQuotes Software Corp. was officially incorporated on November 27, 2000, but discussions about the future platform and trading automation had begun even earlier. The archive contains a forum post dated November 23, 2000 — four days before the company was formally registered.

What makes this early discovery particularly interesting is neither the appearance of the website nor its technical details. The important point is that MQL did not yet exist, while the idea of Expert Advisors already did. From the beginning, the focus was not just on charts and quotes, but on programming trading systems.

This sets the direction for everything that followed. From day one, MetaQuotes viewed the terminal not as a passive window for monitoring the market, but as an environment where users could formalize a strategy and delegate execution to software.

MetaQuotes and the First Version of MQL

The first notable public mention of MQL appeared in November 2001. That was when MetaQuotes version 1.78 was released, introducing the ability to create custom trading strategies — Expert Advisors — using the platform's internal MetaQuotes Language.

The announcement from that time already outlined the platform's future long-term vision: Expert Advisors were to define trading logic, be tested on historical data, automatically execute operations on the account, and manage open positions without human intervention.

By today's standards, the first MQL looked remarkably modest. Its entire specification fit on a single HTML page. The language had no loops, arrays, or the familiar structure of a full-fledged program. A small set of predefined floating-point variables was used for calculations.

However, judging this milestone solely by its syntax would be wrong. The real breakthrough was not in the expressiveness of the language, but in its level of integration. Expert Advisors ran directly inside the free client terminal, accessed time series and technical indicators, could analyze the market, and send trading orders to the server.

This marked the emergence of a principle that would later become the standard for the entire MQL ecosystem: a trading strategy is not an external signal that must be manually imported into the terminal, but rather an executable program within the trading platform.

MetaTrader: A New Platform, A New Scale

In May 2002, public testing began for the new MetaTrader platform. This was far more than just a cosmetic update — it represented a major redesign of the server and manager components. The announcements mentioned support for hundreds of instruments, including the Forex, CFD, futures, and stock markets, new communication protocols, and the ability to serve thousands of online users.

This stage is important in the history of MQL for two reasons.

First, the terminal became part of a larger ecosystem. Automated trading was no longer intended for a standalone application, but for an integrated system with a server, management tools, large user bases, and different classes of financial instruments.

Second, it became clear that the old language was not enough. If users were expected not merely to run prebuilt Expert Advisors but to actually describe trading logic, the language had to become closer to conventional programming.

MQL II: The Language Begins to Resemble a Real Programming Language

In the fall of 2002, MetaTrader version 2.03 introduced a new version of the language: MQL II.

It could no longer be viewed as merely a set of formulas for building Expert Advisors. The MQL II documentation was about three times longer than that of the original MQL, although it still fit on a single HTML page. The language introduced real, string, and Boolean variables, arrays, for and while loops, and an expanded set of built-in functions. These included the mathematical functions Abs, Ceil, Cos, Exp, Floor, Log, Mod, Pow, Round, Sin, Sqrt, and Tan.

That was a significant step forward. Users still worked within a fairly rigid framework: each source file essentially defined one executable function that was executed when a tick arrived for a financial instrument. Within this framework, however, it was already possible to implement more complex logic and use conditions, loops, arrays, and mathematical calculations.

Later, it became possible to call externally compiled files, partially solving the problem of not having custom functions within a single source file. Internally, the implementation was still far removed from the future MQL4 and MQL5: the code ran on a stack-based machine built around Reverse Polish Notation. For users, however, that wasn't the most important thing. The key point was that a trading strategy was gradually evolving from a set of conditions into a full-fledged program.

In terms of syntax, MQL II resembled Pascal. This, too, was intentional. Pascal had been regarded as one of the most approachable languages for learning programming, and that aligned perfectly with MetaQuotes’ philosophy at the time: every user of the trading terminal should have the opportunity to develop their own trading strategy.

Custom Indicators: MQL Moves Beyond Expert Advisors

In spring 2003, the development of MQL took another important step forward. In March, new built-in indicators and file functions were added to the terminal: FileOpen, FileClose, FileDelete, FileSize, FileTell, FileSeek, FileWrite, FileReadNumber, FileReadString, and others.

But the major turning point came in April 2003: MetaTrader version 3.10 introduced support for custom indicators and functions in MQL.

This expanded the role of the language. Until then, MQL was primarily associated with Expert Advisors: the user described a trading strategy, and the terminal executed it on every tick. Custom indicators introduced a different use case: traders could now program not only trading decisions but also their own methods of analyzing the market.

Thus, MQL began to cover two distinct aspects of a trader's work: making trading decisions and building analytical tools. In time, this combination would become standard in MetaTrader 4: Expert Advisors, indicators, scripts, and libraries would be treated as different types of programs within a single environment.

A Transitional Stage: From Simplicity to a Fully-Fledged Language

By mid-2003, it had become clear that the next major platform could not simply be an extension of the existing old architecture. A new product, a new language, and a new environment were needed.

Within the development process, there were transitional solutions that left almost no trace on the public internet. But the direction of the changes was clear. The developers decided to move away from the “one source file = one function” model, stack-based execution, and overly didactic syntax. The future language would be closer to C-like languages, support more complex program structures, and allow users to build not only simple Expert Advisors but also sophisticated trading systems.

This also marked a change in the philosophy. At first, the idea had been roughly this: every trader should be able to program their own strategy. By the time MQL4 was being developed, this idea had become more precise: any skilled user should be able to program a trading strategy of any complexity without leaving the terminal.

At the same time, simplicity remained a priority. Simple strategies were supposed to stay simple. But the complexity ceiling had to be raised dramatically.

MetaTrader 4 and MQL4: The Terminal Becomes an IDE

Development of MetaTrader 4 began in summer 2003. In discussions at the time, the developers gradually revealed its future capabilities: more advanced testing, access to time series for different symbols and timeframes, expanded trading functions, scripts, custom indicators with a large number of indicator buffers, and calls to external functions from DLLs. On February 5, 2004, a sample MQL4 program source code was published for developers to examine.

By early 2004, it had become clear that this was not going to be a minor update. The system was essentially being rewritten from scratch. It took longer than expected, but that was precisely why MetaTrader 4 ultimately became not just a set of improvements, but a new platform.

On November 18, 2004, MetaQuotes announced the upcoming release of the MetaTrader 4 beta. The announcement was significant not only for its trading and analytical functionality. For the first time, a single product brought together a clear model for mass-market algorithmic trading: the terminal, the MetaQuotes Language 4 programming language, the MetaEditor 4 IDE, Expert Advisors, custom indicators, and scripts.

From that point on, MetaTrader was no longer simply a trading terminal with automation capabilities. MetaTrader 4 became a platform that provided developers with a dedicated workspace.

On the MetaQuotes website, the MQL4 documentation was remarkably compact: data types, operations and expressions, statements, functions, variables, the preprocessor, and later, the language syntax. However, the complete reference documentation was built into MetaEditor. This was a fundamental design decision: developers no longer had to switch to a browser every time they needed documentation. The reference, source code, and compilation tools were all available in one place.

MQL4 was already a full-fledged procedural programming language. It introduced user-defined functions, a more familiar program structure, scripts for one-time execution, libraries in the form of EX4 files, and the ability to call functions from external DLLs.

MetaEditor became more than just a text editor. It provided help navigation, syntax highlighting, compilation, support for different MQL program types, and built-in documentation. At this stage, the formula that would make MetaTrader 4 a widely used platform for algorithmic trading was fully established:

TERMINAL + LANGUAGE + EDITOR + HELP + TESTING + COMMUNITY

On July 1, 2005, after a lengthy development process, MetaTrader 4 was released as a complete trading platform. From that point on, the story was no longer just about the evolution of a programming language, but also about the emergence of the ecosystem: a dedicated website for developers, Code Base, articles, trading robot championships, and a huge community of MQL4 users.

That is the subject for the next part.

MQL4.COM: The Language Gets a Community

After the release of MetaTrader 4, it became clear that the platform alone was not enough. If users could write Expert Advisors, indicators, scripts, and libraries, they also needed documentation, examples, discussions, articles, and a place to share code.

On November 8, 2005, a dedicated website for MQL4 developers, MQL4.COM, was launched.

This was an important step: MQL4 was no longer just a language built into the trading terminal. It was becoming the center of a separate developer ecosystem. A forum, documentation, Code Base, and articles appeared on the website. Later, the materials began to be published not only in Russian and English, but also in Chinese.

The Code Base quickly filled up with ready-made programs. Less than a month after its launch, the Code Base already contained more than 50 Expert Advisors, about 200 indicators, 35 scripts, and 17 libraries. Expert Advisors, indicators, scripts, and libraries transformed MQL4 from a language “for insiders” into a practical tool for widespread use. Users could not only write programs from scratch, but also study other people's code, modify existing solutions, ask their authors questions, and gradually find their way into software development.

It is telling that as early as 2006, one of the community's publications featured an Expert Advisor using artificial intelligence — a single-layer neural network. Back then, this was far from mainstream. There was none of today's hype around AI and machine learning. Yet the idea itself was already present within the community: a trading strategy could be built not only around rules and indicators, but also on a trainable model.

This episode helps explain why the subsequent evolution of MQL naturally led to Python, ONNX, AI Assistant, and OpenBLAS. Interest in machine learning did not appear out of nowhere. It simply took time for the platform, the language, and computing capabilities to reach the required level to support it.

Automated Trading Championship: Expert Advisors Take the Stage

The next major milestone was the Automated Trading Championship. The first competition for trading systems written in MQL4 took place in late 2006. It was more than just a contest for prize money. The championship served as a public demonstration of the core concept behind MetaTrader 4: Expert Advisors could trade autonomously, while their performance could be monitored in real time.

A total of 258 developers participated in the 2006 championship. The prize pool was $80,000, and the competition ran for 12 weeks. For the time, this was a strong public statement: automated trading was no longer a subject reserved for a small group of programmers. It had become a spectacle that traders, brokers, and developers could follow.

But even the prizes were not even the most important part. The championship served as a stress test for the entire infrastructure. The organizers prepared server hardware for it, launched numerous terminals, ensured identical operating conditions for the Expert Advisors, and gave viewers the opportunity to monitor the results online.

This practice gave rise to many ideas that later proved useful within the MetaTrader ecosystem: automated Expert Advisor checks, software protection, VPS hosting, lightweight client terminals, web terminals, trading signals, and eventually the application marketplace.

In 2007, the number of participants grew to 603, and in 2008 it reached 705. This was no longer just a one-off event, but an indication of the scale the community had reached. People were writing trading robots, debating algorithms, comparing approaches, studying interviews with other participants, and trying to understand why some systems could survive real-world trading while others broke down after their first few weeks.

It is also worth noting that neural networks continued to appear in the championships. The 2007 winner, Alexander Topchilo, used a neural-network approach in his Expert Advisor, first developing and testing the system in C++ and then porting it to MQL4. Interview with Alexander Topchilo (Better)

In 2008, Leonid Velichkovsky presented an Expert Advisor that used a neural network trained in NeuroShell. Interview with Leonid Velichkovsky (LeoV)

This is an important detail for the entire article. The history of MQL is not just the history of its syntax. It is the story of traders trying to bring increasingly complex ideas into the terminal: from simple indicator-based rules to statistics, optimization, neural networks, and machine learning.

The championship was not held in 2009. MetaQuotes was finalizing the development of its next major platform, MetaTrader 5, along with the new MQL5 language.

MQL5: The New Platform Begins with the Language

Discussions about the future of MQL5 began long before the public launch of MetaTrader 5. As early as 2007, users on MQL4.COM were actively discussing what they wanted from the new language. A search for "MQL5" in October 2007 returned more than 15 pages of links to posts on the MQL4.COM forum. Users were asking for faster performance, a more structured design, new testing capabilities, easier data handling, and a more modern programming model.

Internally, the direction of development was even more radical. The new language was designed to move away from the intermediate representation characteristic of MQL4 and instead generate native code. This meant a different level of performance and a different level of architectural requirements for the language itself.

The first archived mention of the MQL5.COM domain dates back to November 2007. The very fact that a separate domain had emerged showed that this was not just about a new syntax, but about a future ecosystem.

On March 31, 2008, the new MQL5 language was officially announced in an interview discussing the features of the upcoming language. The interview itself has not survived in the public archives, but the date is significant: even before MetaTrader 5 was released, the developers had begun preparing the community for a new programming model.

By summer 2009, the MQL5.COM website was already explicitly promising an imminent launch.

On October 12, 2009, beta testing of MetaTrader 5 began. A month later, on November 18, 2009, the beta version of MQL5.community — a new website for MQL5 developers — was launched.

MQL5.community: Not Just a Forum, but Infrastructure

From the very beginning, MQL5.community was not built as an ordinary forum. From the outset, it was built around the structure of a broader ecosystem: documentation, a forum, Code Base, articles, educational materials, and new services that could be added as the platform evolved.

The developers made an effort to preserve what was already working on MQL4.COM: discussions, Code Base, articles, and the familiar knowledge-sharing model. But the new website was intended to be broader. MQL5 was more complex, MetaTrader 5 was more ambitious, and the community therefore needed a more robust infrastructure.

One important gesture was the migration of accounts from MQL4.COM. Users did not have to start from scratch: they could log in to the new site using their existing accounts. This bridged the two eras and showed that MQL5 did not discard the experience accumulated with MQL4, but built upon it at a new level.

This created a new hub: the language, documentation, articles, code, forum, and future services were all brought together in one place. MQL5.community was no longer an add-on to the terminal but a part of the platform itself.

MetaTrader 5 and MQL5: The Language Becomes an Engineering Tool

On June 1, 2010, the MetaTrader 5 trading platform was released. Unlike the previous generation, it was designed not only for Forex but also for trading on exchange markets. This required changes not only to the terminal but also to the language.

MQL5 was a major step forward compared to MQL4. This was already an object-oriented programming language similar to C++. MQL5 programs were compiled into native x86 or x64 code, providing a new level of performance. At the same time, the core concept of MQL remained unchanged: users should be able to write both simple programs and sophisticated trading systems.

The trading model also became more complex. MetaTrader 5 introduced separate entities for orders, deals, and positions. Trading operations were brought closer to the realities of exchange infrastructure, but for developers this meant more details to manage. Therefore, the standard library developed alongside the language, including trading classes to simplify working with common use cases.

At launch, MQL5 had around 400 built-in functions — roughly the same number as MQL4 had at that time. But the number of functions was not the most important point. What mattered was the direction of development. MQL5 was designed as a language for building large-scale systems: with classes, event handling, a standard library, testing, optimization, and future services built around the platform.

A separate section of the documentation was created for MQL4 users explaining how to migrate to MQL5. This was necessary: the new language was more powerful, but it required a different way of thinking. If MQL4 had made algorithmic trading accessible to a mass audience, MQL5 was intended to make it more engineering-oriented.

MQL5 Championships: The New Platform Faces Public Testing

In 2010, the Automated Trading Championship returned, this time as a competition for MQL5 Expert Advisors. This was a logical step: the new platform needed a public demonstration, and developers needed to see how MQL5 performed not just in examples from the documentation, but in a real three-month race of trading robots.

The 2010 championship registered 314 participants. In 2011, there were 395, and in 2012, 451. These competitions were not only a continuation of the MQL4 championships tradition, but also a showcase for the new platform’s advantages: higher performance, a new Strategy Tester, a more sophisticated trading model, and capabilities for developing large-scale Expert Advisors.

The championships once again served multiple purposes. For traders, they were entertainment and an opportunity to see automated trading in action. For developers, they were a practical proving ground for testing ideas. For MetaQuotes, they generated feedback on the language, the terminal, the Strategy Tester, the infrastructure, and program behavior under real-world conditions. And, of course, they helped popularize the MQL5 language.

New MQL4: the Reverse Influence of MQL5

After the release of MetaTrader 5, it might have seemed that the development of MQL4 would gradually take a back seat. But the opposite happened. MetaTrader 4's massive user base and the code accumulated over the years required a careful update, not a freeze.

In July 2013, major changes to MetaTrader 4 and MQL4 were announced. The idea was unusual: instead of forcing everyone to port their code from MQL4 to MQL5, MetaQuotes would bring as many capabilities of the new technology base as possible into MQL4.

This led to a unified compiler for MQL4 and MQL5, a unified MetaEditor, support for new development tools, stronger protection for EX4/EX5 files, and the ability to use the Market for applications in MetaTrader 4.

It was an important decision for the entire ecosystem. MQL4 did not remain an "old-generation language." It now included classes, structures, new data types, event handlers, a more rigorous compilation model, resource support, new graphics capabilities, and the same development toolset as MQL5.

Just one month later, a beta version of the MetaTrader 4 IDE, including a new MQL4 compiler and editor, was released. In late 2013, public testing began for the updated MetaTrader 4 with the new MQL4 and the Market for applications. On February 3, 2014, MetaTrader 4 Client Terminal build 600 was released.

This release effectively divided the history of MQL4 into two eras. The old MQL4 was a simple C-like language well-suited to Expert Advisors and indicators. The new MQL4 became much closer to MQL5: it featured object-oriented programming, a unified MetaEditor, a new compiler, and the ability to create more complex applications.

At the same time, MetaTrader 4 retained its greatest advantage: its vast existing base of users, programs, and knowledge were not discarded. Instead, the old ecosystem was given a new technological foundation.

Thus, MQL4 and MQL5 no longer looked like two completely different worlds. One language grew out of the widespread practice of automated trading, while the other emerged from an effort to build a more rigorous and powerful engineering platform. After build 600, a common layer appeared between them: MetaEditor, the compiler, the development style, program protection, and MQL5.community services.

By this point, the history of MQL had long since moved beyond a "language for Expert Advisors." An entire ecosystem had formed around it: terminals, an editor, documentation, Code Base, articles, championships, the Market, signals, VPS, and a huge community. But the next stage of development would require even more: external data, distributed computing, machine learning, matrices, neural networks, and advanced linear algebra.

This is the subject for the next part.

The Evolution of MQL5: The Language Grows Up

After the launch of MetaTrader 5, the development of MQL5 proceeded along several parallel tracks. One area of focus concerned the language itself: it was becoming more similar to C++ and better suited for large-scale projects. The second concerned runtime environments: MQL5 programs were no longer limited to Expert Advisors and indicators running on charts. The third focused on computation: the Strategy Tester, cloud optimization, OpenCL, matrices, Python, and ONNX gradually expanded the boundaries of what could be done from within the platform.

Viewed individually, these updates may look like a long list of releases. Taken together, however, they reveal a more important transformation: MQL5 was evolving from a language for trading robots into a universal environment for development, computing, data analysis, and integration with external technologies.

The Language Moves Closer to C++

Initially, MQL5 was developed as a more rigorous and faster successor to MQL4. But within its first few years, it became clear that basic object-oriented syntax was not enough. Developers needed tools for larger projects: code reuse, generic algorithms, safer inheritance, namespaces, and support for complex data types.

Resources were introduced on January 19, 2011. MetaTrader 5 Client Terminal build 384. This made it possible to embed images, data, and other auxiliary files directly into a program. Later, resource variables were introduced: OpenCL code, binary data, or text could be included as part of an MQL5 program without turning the project into a collection of external dependencies.

Function templates were introduced on November 16, 2012, with MetaTrader 5 Trading Terminal build 722.

Class templates were introduced on October 23, 2015, with MetaTrader 5 build 1200: tick history and direct payment for services. These were important steps toward generic programming. The same code could be used for different data types without having to rewrite the algorithms manually.

In 2016, the language gained several features familiar to C++ developers:

Abstract classes were introduced on April 1, 2016, with MetaTrader 5 build 1295.

Dynamic type casting with dynamic_cast was introduced in June 2016.

Interfaces were introduced on August 15, 2016.

The final and override modifiers were added on September 16, 2016 — New MetaTrader 5 platform build 1430: Updated Exposure tab.

None of these changes were merely cosmetic. They made it possible to build stricter and safer class hierarchies, explicitly define the developer's intent, and catch certain classes of errors at comp0ile time.

Namespaces were introduced on October 5, 2019, with MetaTrader 5 build 2170: Scopes in MQL5, a major update to the Strategy Tester, and built-in hosting. This is especially important for large projects and third-party libraries: class, function, and variable names no longer conflict with one another, while the code can be organized more cleanly into modules.

The complex data type was added on May 21, 2021, with MetaTrader 5 build 2940: Positioning of MQL5 Services showcases in the workspace and updated design. This was no longer a feature "for Expert Advisors," but a step toward engineering and scientific computing. Complex numbers are used in spectral analysis, linear algebra, signal processing, and a number of numerical methods.

The matrix and vector types were added on January 28, 2022 — MetaTrader 5 build 3180: Vectors and matrices in MQL5 and improved usability. This represented a few more steps toward engineering and scientific computing, laying the groundwork for integration with ONNX and the upcoming use of the OpenBLAS library.

The complexf, vectorcf, and matrixcf data types were added on September 27, 2024. MetaTrader 5 build 4570: Enhancements to the Web version and OpenBLAS integration in MQL5.

MQL5 was gradually acquiring the features of a language suitable not only for writing trading logic, but also for building large libraries, computational modules, model wrappers, and infrastructure code.

The Strategy Tester as a Computing Environment

A separate line of development is related to the Strategy Tester. The Strategy Tester has always been important in MetaTrader: without historical testing, automated trading becomes nothing more than a series of guesses. But in MQL5, the Strategy Tester began to go beyond simply testing an Expert Advisor.

In 2012, the OnTesterInit, OnTesterDeinit, and OnTesterPass event handlers were introduced, along with functions for working with data frames: FrameAdd, FrameFirst, FrameNext, and FrameInputs. This allowed testing agents to send not only a single final result to the terminal, but also arbitrary data.

It is easy to underestimate the importance of this update. In practice, it turned optimization into a more flexible computational process. An Expert Advisor could not only return the optimization criterion, but also pass along a set of intermediate results, statistics, custom metrics, or data for further analysis.

Combined with the MQL5 Cloud Network, this opened the door to distributed computing. Formally, everything remained within the Strategy Tester's infrastructure, but in practice, MQL5 had gained a mechanism for parallel processing of tasks that did not necessarily have to be limited to the conventional parameter sweeps of a trading robot.

This is another example of a general trend: tools originally created for algorithmic trading are gradually proving useful for a wider range of computational scenarios.

MQL5 Moves Beyond the Chart

The classic MQL program model was tied to a chart: an Expert Advisor runs on a symbol, an indicator is rendered in a window, and a script performs a one-time action. MQL5 gradually expanded this model.

Support for OpenCL was added on February 3, 2012, with MetaTrader 5 Trading Terminal build 581. This made it possible to use parallel computing on available devices and to accelerate tasks that are well suited to massive data processing.

Functions for working with custom symbols were added on December 20, 2017 — MetaTrader 5 build 1730: projects in MetaEditor and synthetic instruments. Developers gained the ability to create their own symbols, populate them with historical data, update ticks, and build synthetic instruments. This was important for research: ideas could be tested not only on standard broker data, but also on custom time series, aggregated instruments, and specialized quote sets.

Native support for .NET libraries was added on October 26, 2018 — MetaTrader 5 build 1930: Floating chart windows and .NET libraries in MQL5. MetaEditor took over part of the function-import process, giving developers a simpler way to use external code without having to write complex wrappers manually.

A new type of MQL5 program, Services (programs that are not attached to any chart) was introduced on February 21, 2019., with MetaTrader 5 build 2005: Economic Calendar, MQL5 programs as services, and an API for the R language. A service can run in the background, start together with the terminal, and perform infrastructure tasks. This significantly changes the concept of an MQL program: it no longer has to be an Expert Advisor, an indicator, or a script.

Network functions for establishing TCP connections were also added on February 21, 2019, in the MetaTrader 5 build 2005 update. An MQL5 program gained the ability to exchange data with external systems via sockets, provided the relevant addresses were explicitly authorized in the terminal settings. This expanded the range of integration scenarios: custom data sources, local services, external analytics, and data exchange between applications.

Database support and DirectX support were added on December 6, 2019, with MetaTrader 5 build 2265: DirectX functions for 3D visualization in MQL5 and symbol configuration in the Strategy Tester. These updates may appear unrelated, but they share a common idea: MQL5 was no longer limited to trading function calls and indicator buffers. It gained tools for data storage, visualization, external integration, and background processing.

Python: A Bridge to Data Analysis and Machine Learning

On June 14, 2019, Python integration was added to MetaTrader 5: Python integration, support for Market and Signals in Wine (Linux/macOS), and major optimizations to the Strategy Tester in MetaTrader 5 build 2085. It was one of the most important bridges between the trading platform and the wider world of data analysis.

By that point, Python had already become the standard tool for machine learning, statistics, data processing, and visualization. Python support made it possible to retrieve data from MetaTrader 5 and use it in external research workflows: building models, testing hypotheses, preparing datasets, analyzing results, and then feeding insights back into the trading platform.

Once again, the same development logic can be seen. MetaTrader does not attempt to replace the entire outside world. Instead, the platform gives developers a bridge: data and trading infrastructure remain in the terminal, while research and machine-learning workflows can run where a rich ecosystem of libraries already exists for them.

ONNX: Machine Learning Models Come to MQL5

The next step brought machine learning even closer to the platform. On March 10, 2023, MetaTrader 5 added support for ONNX, an open format for exchanging machine learning models — MetaTrader 5 build 3620: Web terminal improvements, ONNX support, and accelerated matrix multiplication in MQL5.

The ONNX concept is well-suited to a platform like MetaTrader. You can train the model outside the terminal — for example, in Python using familiar libraries — and then export it to ONNX and use it within an MQL5 program. This separates two tasks: training the model and applying it in trading logic.

This is a major simplification for developers. There is no need to manually rewrite a neural network in MQL5 or build the entire training infrastructure inside the terminal. External tools can be used to prepare the model, while MQL5 can focus on integrating the model into an Expert Advisor, indicator, or research application.

Thus, the MQL community's long-standing interest in neural networks has taken on a more mature technological form. While neural-network Expert Advisors were isolated experiments by enthusiasts in 2006–2008, ONNX gave developers a standard way to integrate trained models into MQL5.

AI Assistant: From a Prompt to a Full-Fledged Agent

The first version of AI Assistant appeared in MetaEditor on June 14, 2023. It already shortened the path from a question to code: a developer could highlight a snippet, ask for an explanation, receive a function implementation or a fix, and then manually integrate the result into the program. This was useful, but mechanically, it was still an evolution of the traditional chat format: a question, a text response, copying, and verification.

On July 24, 2026, in MetaTrader 5 build 6060, the platform switched to a different model. The terminal and MetaEditor gained built-in support for the Model Context Protocol (MCP) and agentic artificial intelligence. The AI Assistant is no longer limited to generating text: it can plan a sequence of actions and invoke tools provided by the platform — read data, find and modify files, build projects, analyze the trading environment, and return structured results.

The developers described the distinction explicitly: instead of the "question-answer-copy' mode that's becoming outdated, the platform introduced a full-fledged agent capable of performing complex tasks. This represents a significant change in scale. The Assistant is no longer just a generator of MQL5 code snippets; it is becoming a participant in the developer’s and trader’s workflow.

MCP: A Standard Bridge Between AI and MetaTrader

The Model Context Protocol (MCP) is an open standard through which an AI agent connects to application data and functions. For MetaTrader, this means that the terminal and MetaEditor are not just windows with a chat open in them, but providers of specialized tools. Instead of receiving an abstract description of the platform, the model gets a controlled programmatic interface to specific operations.

In MetaEditor, an agent can retrieve information about the workspace, search for files and text, read and edit source code, create new programs, check syntax, compile individual files, and build projects. In the terminal, it has access to market data, open charts, account parameters, positions, orders, and trading history. Individual MCP servers can add external sources, such as public quotes, news, and other data for analysis.

This architecture works in both directions. The built-in AI Assistant uses MetaTrader and MetaEditor MCP tools, but the same servers can be connected to external agentic systems compatible with the protocol, including OpenAI Codex, Claude Code, and other solutions. Users are therefore not tied to a single interface or model: the platform provides the tools, and the agent is selected based on the task at hand.

The system supports users' own API keys for OpenAI, Anthropic, Gemini, DeepSeek, Ollama, and other compatible providers. For users who log in with their MQL5.community account, the free MQL5 Lite plan is automatically enabled: the AI Assistant settings are synchronized between the terminal and MetaEditor.

AI Assistant in the Trading Terminal

The built-in assistant in MetaTrader 5 operates within the context of the terminal itself. It can explain the current situation for a particular instrument, examine historical quotes, view instruments from Market Watch, analyze open positions and deal history, identify risky operations, and generate a report.

With network tools connected, the agent can combine the terminal's internal data with external information. Once scenario demonstrated in the announcement showed the assistant retrieving the latest news about an instrument, examining the material step by step, and comparing it with quotes. This is no longer a single request to a reference source, but a multi-step analysis in which the agent gathers the necessary parts of the context on its own.

Trading operations are subject to separate controls. In the settings, you can completely disable them, allow them, or require manual confirmation. Network requests and command-line operations can also be controlled separately. The assistant's recommendations remain informational: the final decision and responsibility for trading remain with the user.

AI Assistant in MetaEditor

In MetaEditor, the agent can create a new MQL5 program from a natural-language description, analyze an existing project, find errors, suggest fixes, refactor the code, improve code readability, and explain a complex algorithm. The main difference from the first version is that the result is not necessarily limited to text in the chat: the agent can create or modify a file, run compilation, and verify the result.

For large codebases, this is particularly essential. The assistant can search for definitions and uses of identifiers across multiple files, read related include modules, take the project structure into account, and perform the task as a series of operations. The history of requests is saved in the "Chats" tab in the Navigator, so working with the agent becomes part of the project rather than a one-off coding suggestion.

Build 6060 also improved the editor itself: code blocks can now be folded, and all occurrences of a selected identifier are highlighted. These features are not directly related to AI, but they reinforce the same scenario — the analysis and maintenance of large-scale projects.

From Writing Code to the "Develop — Test — Improve" Cycle

The most important area of development relates to the Strategy Tester. Responses in the open testing thread describe the target automated workflow:

1. develop a strategy based on the trader's requirements;
2. run testing and parameter optimization;
3. analyze the report, modify the code or settings, and rerun the test;
4. stop in case of failure or once an acceptable result is achieved;
5. present the final version and a report to the user.

This scenario should be distinguished from the promise that "AI will find a profitable strategy." An agent can automate the engineering cycle and test more hypotheses, but it cannot eliminate overfitting, errors in the source data, market instability, or the need for independent validation. The value of MCP here lies elsewhere: the tester, compiler, project files, and optimization results can be linked into a single controlled sequence of actions.

During beta testing, this workflow was expanded gradually, with individual high-level Strategy Tester tools still being added and configured. Therefore, the fully autonomous cycle described here should be viewed as a direction for the development of the agentic system, rather than as a guarantee that any complex task can already be performed without user intervention.

Security: Giving the Agent Tools, Not an Unrestricted Computer Access

The more actions an agent can perform, the more important clear boundaries become. Access is based on the principle of explicit permissions. The MQL5 working directory is available for operations with source files, while tester and log directories can be restricted to read-only access. Access to the user profile is enabled separately. Trading, network access, and the command line are also controlled by separate settings.

Command-line operations — such as PowerShell, Python, and other external processes — are particularly powerful and potentially dangerous, so they are clearly marked in the interface and can be disabled separately. This mode turns the assistant into a general-purpose agent, but at the same time increases the potential attack surface.

In discussions with traders on the forum, developers have also emphasized the importance of backups and version control. For agentic development, Git is not just a convenience, but a fundamental security mechanism: changes must be visible, comparable, and reversible. Here, the new AI architecture integrates seamlessly with MQL5 Algo Forge.

Project Instructions and Skills

It is not enough for an agent to see the files; it also needs to understand the rules of the specific codebase. For this purpose, instruction files for MetaEditor and MetaTrader are used in the MQL5\Profiles\Agents directory. Users can replace the default instructions with their own to define coding style, naming conventions, validation procedures, and other persistent requirements.

Because these files are located within the MQL5 area, they can be stored together with projects in Algo Forge. The repository can therefore contain not only the source code and README, but also instructions for the AI: how to build the project, which files must not be modified, which tests to run, and in what format the result should be presented.

In forum discussions, the developers also introduced local instructions for individual projects and skills — reusable, specialized procedures for the agent. This shows the direction in which the system is evolving: from a general-purpose chat to a customizable digital project participant that knows the platform's tools and the rules of a particular team.

Matrices and Vectors: Preparing MQL5 for Serious Linear Algebra

For machine learning, statistics, and numerical methods, classes, templates, and external integrations alone are not enough. A convenient way to work with vectors, matrices, and basic linear algebra operations is also essential.

On January 28, 2022, MQL5 introduced the matrix and vector types. This was an important change not only from a syntactic standpoint. Matrices and vectors were designed not as ordinary arrays, but as objects with their own properties and methods.

A vector gained a size, while a matrix gained row and column dimensions, and a separate set of methods began to develop around them. Developers gained a more natural way to write computational code: creating matrices, transposing them, multiplying them, computing decompositions, solving systems of equations, and working with norms, rank, and other numerical characteristics.

By this stage, MQL5 was already noticeably different from the language that had once started with simple Expert Advisor logic on each tick. The language now included structures for mathematical models, while the platform offered links to Python, ONNX, OpenCL, and cloud optimization.

But a true numerical foundation requires more than just a convenient matrix type. It also required a proven linear algebra library that could be relied on when implementing complex methods. That is why the next major step was the integration of OpenBLAS.

This is the subject for the next part.

Why OpenBLAS?

Once matrices, vectors, complex numbers, ONNX, and machine learning scenarios appeared in MQL5, the next question became unavoidable: what mathematical foundation should come next?

You can write individual methods manually. You can add a few fast operations for matrices. You can limit yourself to multiplication, decompositions, and solving systems of equations. But this approach quickly leads to a collection of disparate functions that are difficult to develop, test, and maintain.

A platform like MetaTrader 5 needed more than "just another fast library." It needs a standard foundation for linear algebra: broad, proven, portable, and suitable for gradually expanding MQL5 methods.

Before choosing OpenBLAS, other options were also considered: ALGLIB, LIBXSMM, Eigen, and oneMKL. Each has its strengths, but MQL5's goal was broader than simply speeding up a single operation or covering a single class of algorithms.

ALGLIB is notable as a versatile numerical toolkit: optimization, approximation, linear algebra, statistics, and other algorithms. However, for the role of a foundational layer inside a platform, not only the feature set matters, but also the licensing model, library editions, distribution terms, integration predictability, and long-term support.

LIBXSMM excels at specialized dense and sparse matrix operations, particularly in problems involving small matrices and deep learning primitives. That makes it a useful tool, but a narrower one. It works well in situations where you need to get the most out of a specific class of operations, but it does not replace a broad LAPACK-oriented foundation for a wide range of linear algebra methods.

Eigen is an excellent C++ template library for matrices, vectors, numerical solvers, and related algorithms. But Eigen is fundamentally a C++ approach: a header-only library, templates, expression templates, and close integration with C++ code. For internal MQL5 platform integration, a different focus was needed: a stable computational layer that could serve as a foundation for implementing methods of matrix, matrixf, matrixc, and matrixcf.

oneMKL was also considered. It is a powerful mathematical library with a long history, strong optimization, and a wide range of capabilities. But speed isn't the only thing that matters in a platform product. Key factors include portability, the degree of vendor lock-in, distribution terms, control over integration, and the predictability of behavior across different user configurations.

OpenBLAS proved to be the most suitable compromise. This is an open-source, optimized BLAS library that delivers high performance in basic linear algebra operations and serves as the foundation for more complex methods. For MQL5, the key factor was precisely its coverage of LAPACK tasks: not just a single fast operation, but a broad foundation for SVD, eigenvalues, solving systems of linear equations, least-squares problems, factorizations, and solution refinement.

In other words, the choice of OpenBLAS was an engineering decision, not a decorative one. The goal was to establish a foundation that would allow us to systematically develop mathematical methods for MQL5: from basic matrix operations to increasingly complex numerical algorithms.

OpenBLAS in MQL5: From Matrices to a Full Numerical Foundation

On September 27, 2024, native OpenBLAS integration was introduced in MetaTrader 5 build 4570. At the same time, MQL5 gained new data types to support complex-number computations using float data:

• complexf — a complex number using float data;
• vectorcf — a vector containing elements of type complexf;
• matrixcf — a matrix containing elements of type complexf.

At first glance, this may look like a technical detail. In reality, it is an important layer in the future of MQL5's mathematical capabilities. MQL5 already had matrix, vector, complex numbers, and matrix methods. But OpenBLAS required a more complete set of types: real and complex data, double and float, and different variants of matrices and vectors.

MQL5 therefore gains more than simply "SVD method" or an "Eigenvalue method." It gains a foundation on which families of algorithms can be built for different data types and different numerical problems.

The first OpenBLAS methods in MQL5 were related to singular value decomposition and computing eigenvalues. This was a natural starting point. SVD and eigenvalue problems underlie a vast number of practical algorithms: from stability analysis and dimensionality reduction to machine learning, statistics, signal processing, and model building.

Several algorithmic variants were added for SVD: divide-and-conquer, QR, QR with pivoting, bisection, high-level Jacobi, low-level Jacobi, and methods for bidiagonal matrices. This matters because numerical methods rarely have a single "best" for every situation. A fast method may be less accurate on ill-conditioned data, while a more stable approach may be computationally more expensive. The platform should give developers a choice.

Eigenvalue methods address a different class of problems. They are used for analyzing square matrices, symmetric and Hermitian matrices, system stability, spectral characteristics, and many computational procedures used in statistics, optimization, and modeling.

The OpenBLAS section of the MQL5 documentation has since continued to expand. This is an important point: the integration of OpenBLAS is not a one-off release, but an ongoing direction of development. Matrix and vector methods are gradually gaining more and more capabilities applicable to different matrix types: matrix, matrixf, matrixc, and matrixcf.

The next logical step involves methods for refining solutions, error estimation, improving numerical stability, and additional factorizations. This is exactly how a solid mathematical foundation is built: not by jumping from "nothing" to "everything," but by gradually covering an ever-increasing number of standard LAPACK problems.

Why This Matters to an MQL Developer

To an ordinary trader, OpenBLAS may seem like something distant: a library for mathematicians, engineers, and scientific computing. But within the MQL ecosystem, its arrival has very practical implications.

Developers can build more complex models directly in MQL5. Instead of just calling an indicator, comparing two values, and sending an order, they can work with data as arrays, vectors, and matrices. They can compute decompositions, solve systems of equations, assess stability, and use methods that previously had to be moved to Python, C++, or third-party libraries.

This does not make Python, ONNX, or external tools obsolete. On the contrary, they are beginning to complement one another more effectively. Python is well suited to research, model training, and data preparation. ONNX is convenient for bringing a trained model into the terminal. OpenBLAS provides MQL5 with a robust numerical foundation for cases where calculations need to be performed within the platform.

As a result, MetaTrader 5 is gradually becoming an environment where users can not only trade and test Expert Advisors, but also build a full-fledged computational workflow:

• retrieve market data;
• prepare features and matrices;
• use an ONNX model;
• perform numerical computations using matrix/vector;
• test the idea in the Strategy Tester;
• parallelize the optimization;
• integrate the result into an Expert Advisor, indicator, or service.

This is why OpenBLAS should be considered not in isolation, but in conjunction with the preceding steps: MQL5, MetaEditor, Python, ONNX, matrices, vectors, and AI Assistant.

Agentic AI Assistant, MCP, and OpenBLAS: Three Layers of a Single Engineering Environment

At first glance, the agentic AI Assistant, MCP, and OpenBLAS seem to belong to different parts of the platform. The AI Assistant handles the user's intent, MCP connects the model to tools, and OpenBLAS runs numerical algorithms. Together, however, they form a coherent computational workflow.

The AI Assistant is responsible for formulating and decomposing the task: understanding the request, creating a plan, selecting actions, and interpreting the results. MCP provides the agent with controlled access to the terminal, MetaEditor, projects, the market, trading history, and external data. OpenBLAS, matrix/vector operations, ONNX, and other technologies provide the MQL5 program with the computational power needed to implement the model itself.

In the past, developers would manually switch between the editor, the help documentation, the forum, the Strategy Tester, a Python notebook, and external libraries. Now, some of these context switches can be described as a single task: examine the project, modify the code, compile the program, prepare the data, run the analysis, and produce a report. The agent does not replace the compiler, the Strategy Tester, or the math library — it connects them.

That is why MCP is no less important than the language model itself. Without specialized tools, even a powerful model remains a conversational partner. With MCP, it gains the ability to act within the platform, while remaining within the permissions set by the user.

Algo Forge: Code Becomes a Project

A modern engineering environment needs another layer that is essential to any serious development effort: version control, change history, collaboration, and publishing the project as a living repository. Within the MQL ecosystem, MQL5 Algo Forge has gradually taken on this role.

The predecessor to Algo Forge was MQL5 Storage — an online repository for MQL4/MQL5 source code built into MetaEditor. It already served an important problem: developers could store their code in a secure repository, view the change history, revert to previous versions, and work on team projects directly from the editor.

However, the previous repository was based on Subversion and had become obsolete. Its logic worked well for storing and synchronizing source code, but modern development requires more: a local history, fast operations, branches for experimentation, merging changes, offline work, and transparent collaboration among multiple developers on a single project.

On June 6, 2025, MetaTrader 5 build 5100 introduced a completely redesigned source code repository: MQL5 Storage switched from Subversion to Git, and at the same time a new portal for online project management — MQL5 Algo Forge — was launched.

This is an important turning point. While Code Base answered the question "Where can I find a ready-made example?", Algo Forge answers a different question: "How do I manage an evolving project?" A complex Expert Advisor or library already is no longer just a single MQ5 file. It may have include files, test configurations, parameter sets, models, documentation, a README, support scripts, a history of experiments, and several development branches.

Git changes the way you work with this kind of code. A developer can create a separate branch for a new idea, test it in the Strategy Tester, compare changes, revert to a previous state, merge a successful experiment into the main version, and push the result to a cloud repository. The project history is no longer kept in the author's memory or in folders with names like “final_new_2.” It becomes part of the IDE itself.

Algo Forge adds a social layer to this. Developers can explore public projects, follow authors, create teams, fork projects, clone repositories, view files, commits, and branches, prepare documentation, and share projects online. For the MQL ecosystem, this means a shift from sharing individual source code files to a full-fledged culture of collaborative development.

This is especially important for articles and educational materials. Code from an article should not live only in an archive or an attached set of files. It can be set up as a project in Algo Forge, with a clear structure, a README.md file, preserving the change history and giving readers not just text, but a working entry point. The article explains the concept, and the repository demonstrates it in action.

Thus, MetaEditor is once again expanding its role. It began as a place to write and compile code. Then came documentation, projects, debugging, profiling, the AI Assistant, and integrations. Now, a full-fledged Git workflow is part of the picture as well: history, branches, commits, synchronization, and collaboration.

In this logic, Algo Forge is not a separate "side service" but a continuation of the same line of development. An MQL program has evolved from a simple Expert Advisor on a single chart into an engineering project that can be versioned, discussed, developed by a team, published, and maintained for years.

From Expert Advisors to an Engineering Environment

Looking at the entire history, the evolution of MQL appears remarkably consistent.

First came Expert Advisors, even before a full-fledged programming language existed. Then came the first MQL: a short documentation page, a few variables, and the ability to run a trading strategy directly in the terminal. MQL II followed with loops, arrays, data types, and mathematical functions. Custom indicators expanded the language beyond Expert Advisors.

MetaTrader 4 brought all of this together into a mass-market model: the terminal, MQL4, MetaEditor, documentation, Expert Advisors, indicators, scripts, libraries, and testing. MQL4.COM added the community, Code Base, and articles. The championships demonstrated that automated trading could be public, competitive, and large-scale.

MetaTrader 5 and MQL5 raised the ceiling of complexity. Object-oriented programming, native code, the standard library, a new trading model, an enhanced Strategy Tester, cloud optimization, and MQL5.community transformed the language into a more rigorous engineering tool.

Then MQL5 influenced the evolution of MQL4 in return: a unified compiler, a unified MetaEditor, a new language, program protection, and the Market for applications. The established mass-market product received a new technological foundation.

MQL5 then began to move beyond the traditional Expert Advisor: OpenCL, custom symbols, .NET, services, network functions, SQLite, DirectX, Python, ONNX, matrices, and vectors. All of this gradually broadened the notion of what an MQL program could be.

Agentic AI Assistant, Model Context Protocol (MCP), and OpenBLAS are not random additions to this story. They are its logical continuation, because they build on the same principle that was already evident back in 2001: giving users more autonomy within the platform.

Back then, autonomy meant the ability to write an Expert Advisor and send a trade operation without human intervention. Today, it means much more: giving an agent a task in natural language, granting it controlled access to tools via MCP, writing and building code, using an external machine learning model, performing numerical linear algebra, testing the system on historical data, and launching it in the MetaTrader infrastructure.

Not a History of Versions, but a History of an Idea

It is easy to turn the history of MQL into a long list of dates, build numbers, and function names. But that misses the main point.

This is not a story about how one syntax replaced another. Nor is it a story about how more and more menu items were gradually added to the terminal.

It is a story about how the trading platform gradually brought more and more of a developer's work inside itself. First came Expert Advisor execution. Then the language. Then the editor. Then documentation, testing, Code Base, articles, championships, Market, cloud optimization, external integrations, machine learning, AI Assistant, numerical linear algebra, and project management through Algo Forge.

In this sense, the modern MetaEditor is not simply the descendant of an old Expert Advisor editing window. It is the integration point for the entire MQL ecosystem: the language, documentation, projects, debugging, profiling, models, mathematical methods, agentic assistance, MCP tools, and Git infrastructure for collaborative development.

That is why the journey from the first Expert Advisors to the agentic AI Assistant, MCP, and OpenBLAS looks not like a collection of isolated events, but like one continuous development line. From the very beginning, MetaQuotes has been building not just a terminal for watching the market, but an environment in which a trading idea becomes a program, and a program becomes a manageable engineering process.

That idea continues to drive the evolution of MQL.