A Quiet Milestone That Almost Nobody Noticed
Sometimes the most significant technical milestones happen in silence. Since Sprint 4 in May 2025, ForgeIL's SMS compiler has been self-hosting — meaning the compiler compiles itself — with 62 tests passing and a clean LLVM IR emission pipeline. It has been sitting there, functional and proven, and almost no one in the developer community has picked it up yet.
That is not a story about failure. It is a story about a genuinely interesting piece of technology that has not yet found its audience. If you work in systems programming, multiplatform development, or compiler design, that audience might be you. This article is an honest look at what ForgeIL is, what it has already achieved, and why it deserves more attention than it has received so far.
What Is ForgeIL?
ForgeIL is the language family that powers the Forge ecosystem developed by CrowdWare. Rather than being a single monolithic language, it is designed as two complementary tools with a unified purpose: giving developers a clean, fast, and dependency-light way to describe both the structure and behavior of multiplatform applications.
The two languages in the family are:
- SML (Simple Markup Language) — handles structure. This is the declarative layer: UI layout, application shape, and content organization. Think of it as the skeleton of any Forge-based application.
- SMS (Simple Multiplatform Script) — handles behavior. This is where logic lives. SMS is compiled ahead of time through LLVM to native machine code, without a virtual machine and without a garbage collector in the picture.
Together, SML and SMS aim to do what many modern toolchains struggle to do cleanly: give you a high-level authoring experience while producing output that behaves like natively compiled code at runtime.
Why the Self-Hosting Milestone Actually Matters
In compiler development, self-hosting is one of the most meaningful benchmarks a language can hit. It means the language is expressive enough, stable enough, and correct enough to implement itself. When the lexer, parser, and LLVM IR emitter of the SMS compiler are all written in SMS and all proven to compile successfully, that is not a gimmick — it is a statement about the language's maturity.
As of Sprint 4, ForgeIL has cleared that bar. The SMS compiler compiles itself. Sixty-two tests pass. No C++ toolchain is required to bootstrap the system. That puts ForgeIL in a category occupied by relatively few experimental or independent language projects, and it is worth recognizing for what it is: a genuine engineering achievement from an independent team.
For developers who have watched dozens of language projects promise self-hosting and quietly abandon that goal, the fact that ForgeIL actually got there — and did so without significant community fanfare — is noteworthy.
The Performance Story: 4.6 Nanoseconds and What It Means
Performance claims in language ecosystems are often slippery, so it is worth being precise about what ForgeIL has actually benchmarked. In earlier tests, SMS event dispatch measured at 4.6 nanoseconds. That figure puts it ahead of C++, C#, and Kotlin Native in that specific benchmark, with only Kotlin JVM's JIT-compiled performance still ahead of it.
The reason for this speed is architectural rather than incidental. Events in SMS resolve at compile time. There is no runtime dispatcher working through a chain of registered listeners or virtual method tables at execution time. The decision about what happens when an event fires is made during compilation, and the native code that runs reflects that decision directly. This is the kind of design choice that looks obvious in hindsight but requires real discipline to commit to early in a language's development.
No virtual machine means no VM startup overhead, no JIT warm-up period, and no unpredictable pauses from a garbage collector. For applications where latency matters — embedded systems, UI responsiveness, event-driven architectures — these are not minor concerns. They are the difference between a tool that fits the use case and one that does not.
The Forge Ecosystem Context
ForgeIL does not exist in isolation. It is the language layer beneath the broader Forge ecosystem at CrowdWare, which targets multiplatform application development. The combination of SML for structure and SMS for behavior is designed to give teams a consistent authoring model regardless of the target platform, while the LLVM backend ensures that the compiled output is genuinely native wherever it runs.
This positions ForgeIL in an interesting space in the current development landscape. It is not trying to compete with JavaScript frameworks for web-first projects. It is not trying to replicate what Flutter or React Native do. Instead, it occupies the territory where you want native performance, minimal runtime dependencies, and a clean separation between your UI description and your application logic — all from a single language family that you do not have to swap out depending on which platform you are targeting.
Who Should Be Paying Attention Right Now
If you are working on any of the following, ForgeIL is worth exploring today:
- Systems or embedded developers looking for a higher-level scripting layer that compiles to native code without carrying a runtime.
- Compiler enthusiasts and language designers who want to study or contribute to a working, self-hosting LLVM-based compiler built outside of academia or a major corporate lab.
- Multiplatform application developers who want a unified structure-plus-behavior model with genuine native performance targets.
- Open source contributors looking for an active project that is early enough that meaningful contributions are still possible at every layer.
An Honest Invitation
The creator of ForgeIL has been clear that this post is not announcing a new technical milestone. The milestone happened in May. This is the reminder that it happened and the invitation to come look at it properly.
That kind of honesty is refreshing in a space where developer tools are often over-marketed before they are ready. ForgeIL is not over-marketed. It is, if anything, under-noticed. Sixty-two passing tests, a self-hosting compiler, sub-5-nanosecond event dispatch, and no C++ bootstrap requirement. That is a real foundation, built quietly, by a team that was also moving cities, starting bands, and living life while the compiler kept compiling itself.
The project exists. It works. Now it just needs to be found.