Why the Pre Beta Version of Wave Is Unstable

Hello, I'm Luna, the creator and lead maintainer of Wave.

Recently, it feels like more and more people are starting to build things with Wave. That's really great, and it makes me very happy. Please make lots of things with Wave!

But as you can see from the title, today's topic is "Why the Pre Beta Version of Wave Is Unstable."

Building something with Wave is a good thing, but there are also some things you should be aware of at the current stage.

Wave is currently in Pre Beta, and at the time of writing, the latest version is v0.2.0-pre-beta.

Wave's development process is divided into six stages.

Pre Alpha → Pre Beta → Alpha → Beta → Release Candidate → Stable

Let me briefly explain each stage.

Pre Alpha

Pre Alpha is the stage where the backend has not been added yet.

In other words, this is the stage where we design and refine the AST, and print the parsed AST.

Pre Beta

This is the stage Wave is currently in.

During Pre Beta, the goal is to complete Wave's frontend under the LLVM backend, including the lexer, parser, and other language features.

New syntax may be added, existing syntax may change, and various bugs found during implementation are fixed.

Alpha

During the Alpha stage, instead of adding new syntax features to the frontend, we start working seriously on the backend.

This is when the Whale toolchain is introduced.

However, LLVM will not be removed immediately. The existing LLVM-based Wave implementation and the Whale-based implementation will coexist, allowing us to compare their results while gradually refining Whale.

Whale is a comprehensive compiler toolchain that includes the tools required for a compiler, such as an IR, assembler, object file generation, linker, and more.

Beta

During Beta, LLVM is finally removed.

This stage focuses on stabilising Whale, fixing bugs, adding missing features, and improving the overall stability of Wave.

Release Candidate

During the Release Candidate stage, or RC, we will begin self-hosting, which means writing Wave in Wave itself.

By implementing the Wave compiler in Wave, we will be able to use the language on a much larger scale and test whether there are any issues with the language's safety or design.

After going through this process, we will finally release the Stable version.

---

So why is the current Pre Beta version unstable?

It's simple.

Because the syntax can still change, and bugs still exist.

Right now, it is completely possible to build an operating system, bootloader, JavaScript runtime, game framework, binding project, or many other things with Wave.

Trying projects like these is not unreasonable at all.

However, it may still be too early to use Wave in a real production environment where long-term stability is required.

Recently, there was a memory-related bug, and today the Import syntax was changed.

In other words, during Pre Beta, new syntax may be added, existing syntax may change, and unexpected bugs may be discovered and fixed.

If you can handle an environment where your code may need some changes as new versions are released, try building all kinds of things with Wave.

You can build an operating system, a runtime, a small library, a tool, or anything else you want.

It will probably be quite fun.

Thank you for using Wave.

And thank you for visiting this site and reading this post.

by Luna.