SimplifyC++ Article

From the “MyLang” Folder to ForgeLang - The story of a dream that began in 2000 and became a real programming language a quarter of a century later

By Ayman AlherakiReads: 3Today: 3

Creating your own programming language is extremely difficult. Even more difficult is bringing it to a level of maturity and reliability that allows you to release it for others to use. The task is not merely about inventing a new syntax for writing commands; it involves building an integrated ecosystem encompassing language design, a compiler, an assembler, a code optimizer, type and memory systems, a standard library, and compatibility with different operating systems and processor architectures.

Nevertheless, creating my own programming language has remained a dream of mine since 2000, although the roots of that dream reach back many years earlier.

The Beginning with GRASP and GLPro

From 1992 until 2000, I worked with a relatively obscure programming language that, to me, was an astonishing tool for rapid software production. That language was GRASP, followed by its successor, GLPro.

It was an interpreted language designed for multimedia applications, offering remarkable simplicity compared with the tools available at the time. Using it, I created numerous programs and projects that I distributed first on 1.44 MB floppy disks and later on compact discs.

To me, GLPro was like a complete software production machine. At a time when developing multimedia applications with mainstream languages demanded tremendous effort and exhausting technical detail, GLPro allowed me to transform ideas into real programs quickly and flexibly.

During that period, I frequently communicated through MSN Messenger with the American programmer John Bridges, the principal developer of GRASP and the sole author of GLPro. I learned a great deal from our discussions about language design and the development of programming tools. He had used C to build his system and advised me to pursue object-oriented programming in C++, which he considered the most suitable path for the future of application development.

But the language I loved suddenly came to an end. Its ownership passed to other companies, the organization responsible for its development eventually shut down, and the language with which I had built an important part of my work and programming life disappeared.

What I felt went far beyond the loss of an ordinary program. It seemed as though an entire creative instrument had been buried forever. I remained deeply saddened by the language’s disappearance for more than a year, and a question began forming within me that never truly left:

Why should I not create my own language, so that no one can bury it or take it away from me again?

A Small Folder Named MyLang

In 2000, I created a new folder on my computer and named it:

MyLang

That folder was the first physical embodiment of the dream. At the time, I did not have the tools or sufficient knowledge to build a complete language, but I began trying. I wrote down ideas and early experiments, studied some of the concepts I had learned from John Bridges, and attempted to imagine what my language might eventually become.

Most of those attempts ended in failure.

The failures were not caused by a lack of desire. Building a real programming language requires an extraordinarily broad body of knowledge: compiler design, lexical, syntactic, and semantic analysis, code representation, machine-code generation, performance optimization, memory management, ABI design, processor architecture, operating systems, and linking tools.

At the time, I did not possess enough knowledge, financial resources, or free time to dedicate myself to a project of such magnitude. Information was not as easily accessible as it is today, and an independent programmer could not quickly obtain the answers, guidance, and technical review needed to move forward.

I later became occupied with other work. I developed websites using PHP, built desktop applications with C++Builder, and continued working with several languages and tools. Yet the MyLang folder remained, and the idea returned to me from time to time.

I would begin a new attempt, reach a point beyond the capabilities and resources available to me, and then stop. The dream remained postponed, but it never died.

Retirement and the Beginning of Serious Attempts

When I retired in 2022, I found myself facing a different opportunity. I had more time, and I realized that if I did not begin working seriously on my dream at that stage of my life, it might remain nothing more than an idea accompanying me for the rest of my years.

I returned to the language project with more serious attempts, but I failed several more times. With each attempt, I discovered that there was another, deeper layer I needed to understand before I could continue. I no longer wanted to create an experimental language or a superficial interface. I wanted to build a genuine systems programming language capable of approaching C and C++ in performance while offering greater simplicity, modern safety, and an integrated development experience.

It became clear to me that the correct path did not begin with the language’s external appearance or syntax, but with the deepest layers of code generation.

In 2024, I therefore began studying LLVM, GNU tools, compiler construction, and language infrastructure. My goal was not to copy LLVM or reproduce it in the same form, but to understand the problems it solves, the layers from which it is built, and the reasons it has become the foundation of so many modern programming languages.

During that study, a different philosophy began to take shape.

Why Did I Begin with the Assembler?

In April 2025, I founded my project to build a collection of low-level programming tools. The vision was to create an infrastructure that might one day perform a role similar to ecosystems such as LLVM, but with a different philosophy—one that begins with the assembler itself as a clear, inspectable, and controllable foundation.

I believed that building a high-performance systems language on tools I did not fully own would leave an important part of the language’s future under the control of other projects and organizations. I therefore decided to begin at the foundation: with an assembler that I would design myself, understanding every stage within it, and then building the rest of the language ecosystem upon it.

I began by using GCC as a practical and educational reference for understanding compilation, performance, and the behavior of generated code, while undertaking an in-depth study of the x86-64 architecture. I studied instruction formats, opcode encoding, addressing modes, registers, flags, executable file formats, and the processes that transform assembly instructions into machine code.

I did not want merely to use an assembler. I wanted to understand precisely how every instruction written by a programmer becomes bytes executed by the processor.

From this work, ForgeAssembler began to emerge.

From a Raw Assembler to a Language Infrastructure

ForgeAssembler began as a low-level assembly language inspired by the clarity of NASM and its closeness to the processor architecture, but it was never intended to be a copy of NASM.

From the beginning, the plan was for ForgeAssembler to evolve into something broader than a traditional assembler: a tool combining low-level control with the ability to represent higher-level concepts, while enabling the construction of a powerful optimizer capable of understanding the intent of code instead of merely converting instructions into machine language.

I gradually added a higher-level language layer, along with concepts for functions, control flow, types, analysis, and optimization. The goal was for the assembler to become a powerful and transparent intermediate representation upon which higher-level languages could be built, while preserving the ability to observe and control what happens at every stage.

In this way, ForgeAssembler began to differ from tools I had previously used, such as GAS, NASM, MASM, and the Clang assembler. The difference was not merely syntactic; it concerned the role I intended ForgeAssembler to perform within the ecosystem: a real assembler, a low-level representation layer, and a foundation for both code optimization and the programming languages that would be built upon it.

As its development progressed, the outlines of the language I had dreamed about since 2000 began to appear more clearly.

And so ForgeLang was born.

The Birth of ForgeLang

ForgeLang did not begin with the design of an attractive syntax followed by a search for a way to implement it. It emerged from a low-level foundation that I had built and studied myself.

I began with the processor architecture, then machine code, the assembler, and the layers of analysis and optimization, before finally reaching the high-level language. This path taught me to evaluate every new feature according to its real cost: How many instructions will it generate? Will it require memory allocation? Will it introduce hidden layers? Will it affect executable size or execution speed? Can it remain modern and safe without forcing users to pay a cost they cannot see?

ForgeLang is therefore founded upon several essential principles:

Predictable performance close to that of C.
Abstractions without hidden costs.
No mandatory garbage collector or undeclared dynamic allocation.
Clear and safe memory management.
Strong compatibility with the C ABI.
The ability to use the language for systems programming.
Ownership of the essential toolchain without complete dependence on LLVM or GNU.
A powerful, modern standard library that does not sacrifice efficiency.
Clear error diagnostics and an integrated development experience.
Performance tests for every new feature to prevent unacceptable regressions.

I no longer wanted merely to build a language that makes programs easier to write. I wanted a language that could eventually become a serious and modern alternative to C in fields requiring speed, control, and compatibility with different systems and processor architectures.

Artificial Intelligence: The Assistance That Made the Dream Possible

I must be clear and honest: I could not have reached my current stage with ForgeAssembler and ForgeLang without making extensive use of generative artificial intelligence.

Artificial intelligence, however, did not create the dream, choose the project’s philosophy, or live my long history with programming on my behalf. It was an extraordinarily powerful enabling tool that allowed me to transform my ideas and studies into reality at a speed that would not previously have been possible for an independent programmer working alone.

It helped me access information, verify technical details, review designs, discover errors, explore alternatives, write tests, accelerate the implementation of ideas, and examine every stage of the assembler and the language.

It performed the role of a broad team of reviewers, assistants, and specialists. Yet it still required a clear vision, precise questions, engineering decisions, practical testing, and a determination to reject solutions that did not conform to the project’s philosophy.

Before the arrival of these technologies, a project of this scale would have required millions of dollars to employ specialists in compilers, processors, optimization, operating systems, libraries, and development tools. In addition to obtaining such funding, I would have needed to identify people capable of understanding my vision and implementing it as I intended.

Artificial intelligence has given independent programmers a capability they never previously possessed: the ability to summon specialized knowledge when needed, continuously review their ideas, test multiple approaches rapidly, and compress years of research and implementation.

I therefore thank God first for helping and enabling me, and I deeply appreciate this technological revolution, which arrived while I was making what might have been my final attempt to achieve an old dream.

The vision was mine, the study was my responsibility, the engineering decisions were my decisions, and practical tests remained the final judge. Artificial intelligence was the powerful assistant that made implementing all of this possible.

The First Results

ForgeLang is still under development, and I do not claim that it has become a complete language or that it is ready to compete with established languages in every field. Building a trustworthy systems programming language requires rigorous testing, security reviews, broad support for processor architectures and operating systems, a mature standard library, and complete documentation.

Nevertheless, the results achieved so far are highly encouraging.

In current tests, code generated by ForgeLang has approached the performance of C, matching or even surpassing it in some experimental cases. Work is also progressing toward ABI compatibility that will allow direct integration with C libraries and the systems built upon them.

However, a single benchmark—or even a limited collection of benchmarks—is not enough to claim superiority over a language of C’s stature. I will therefore continue building more rigorous and diverse tests covering execution speed, memory consumption, executable size, compilation time, optimization accuracy, and ABI stability.

The goal is not to produce promotional numbers, but to build a language that proves its strength through genuine, demanding tests.

A Quarter of a Century Later

When I look at ForgeLang today, I remember the small folder I created in 2000 and named MyLang.

The first attempts inside it were simple and desperate, but they were not without value. They kept the dream alive for a quarter of a century. Every programming experience I went through, every program I wrote, every language I learned, and every attempt in which I failed contributed another part to the vision I am working to realize today.

The dream began with sadness over a language I loved and then watched disappear. From that sadness came the decision to build a language whose vision, tools, and future I could preserve.

I passed through years of work and interruption, serious but unsuccessful attempts, the study of LLVM, GNU, and the x86-64 architecture, the construction of ForgeAssembler, and finally the development of ForgeLang upon it.

The path was neither straight nor easy, and I have not yet reached its end. The greatest difference today is that I am no longer looking at a distant dream or a folder named MyLang. I am looking at a working assembler, an evolving language, source code becoming real programs, and performance results that give me a compelling reason to continue.

What Do I Want ForgeLang to Become?

I do not want to create yet another language to be added to a long list of experimental programming languages, nor do I merely want to prove that I can write a compiler.

I want ForgeLang to become a genuine systems programming language: fast, clear, safe, modern, independent, and capable of full integration with the existing software world. I want it to give programmers the control and power of C while addressing many of the complexities and risks that have accumulated over the decades—without sacrificing performance.

I also want ForgeAssembler and ForgeLang to remain projects that can never suffer the same fate as the language I loved more than a quarter of a century ago: being transferred to a larger organization, shut down, and buried forever.

The Road to the Public Release

When the appropriate time arrives, I will release the project as open source in an official GitHub repository. I want this step, however, to be taken carefully so that it protects the project and helps ensure its continuity, rather than simply publishing the source code in haste.

Before publication, I will complete the study and adoption of the appropriate licenses in cooperation with an international lawyer specializing in intellectual property, technology, and open-source software. The lawyer will review the project’s legal framework, establish its rights, and prepare the licenses and policies required for its release, use, and contribution process.

I will also work to register the project and its associated rights with the Saudi Authority for Intellectual Property, followed by any necessary registrations and legal protections through the appropriate international bodies.

Once these preparations are complete, public distribution and experimental releases of ForgeAssembler and ForgeLang will begin. God willing, I expect this to take place during the first quarter of 2027. This is the timeframe I hope to achieve, while recognizing that quality and legal and technical readiness are more important than committing to a rushed deadline.

I will continue intensive development until that time. During this period, I may also seek the assistance of a limited number of trusted experts and volunteers by providing them with private versions of ForgeAssembler and ForgeLang for experimentation and testing. They may help review the projects’ behavior and performance and identify errors before the experimental releases become publicly available.

The Language Alone Is Not Enough

One of the most important lessons I have learned throughout my programming life is that the strength of a language alone is not enough. I have often struggled with languages that appear excellent in theory but lack the libraries and tools programmers need to produce real applications directly.

For this reason, my goal will not be limited to building a fast compiler or designing modern syntax. I will begin early in the project’s life to create an integrated production ecosystem around ForgeLang. I will personally develop as many of these tools and libraries as I can, and I may cooperate with specialized software companies and development organizations to build some of the larger systems according to ForgeLang’s standards and its philosophy of performance and safety.

I want ForgeLang, even in its early stages, to be a language rich in the tools programmers need—not a project that requires them to build everything from the ground up. Future plans include, among other things:

A powerful, modern, and high-performance standard library.
Simple and integrated build, package, and dependency-management tools.
Advanced libraries for systems programming, networking, files, and databases.
A Game Engine that takes advantage of the language’s low-level performance.
A Big Data system for processing enormous datasets with exceptional speed and efficiency.
Clear and accessible libraries for using multicore processors.
Tools for parallel programming and the safe, structured execution of tasks.
Interfaces that allow programmers to use all available processor cores without burdening them with unnecessary low-level detail.
Analysis, testing, and performance-measurement tools integrated into the development environment.

The fundamental challenge will be to provide these capabilities without abandoning ForgeLang’s principles: no hidden costs, no unexpected memory allocations, and no mandatory locks or runtime layers, while preserving speed, predictability, and complete control.

My ambition is for ForgeLang to provide programmers with more than a powerful language. I want it to offer a practical ecosystem through which they can move rapidly from an idea to a real program—whether they are building an operating system, a game engine, a high-performance server, a scientific application, or a platform for processing enormous datasets.

I have struggled for many years with the gap between possessing a good language and possessing a complete set of production tools. I therefore want closing that gap to be an essential part of ForgeLang from the beginning, not a promise postponed to some distant future.

The Dream That Became a Project

This project is not merely a technical experiment to me. It is an extension of a journey that began decades ago: the journey of a programmer who loved building tools, mourned the loss of a tool he loved, failed many times, yet never abandoned his dream.

I am not merely working to release a new language. I am striving to establish an integrated programming environment that gives developers the speed, power, and simplicity I spent my own programming life seeking.

Today, more than twenty-five years after creating the MyLang folder, I can finally say that the dream is no longer merely an idea.

Its name is now ForgeLang.

What did you think?

Comments

No comments yet.