Wave Language v0.1.8-pre-beta: Building the Foundations of Systems Programming

The Wave Language Team is proud to announce the release of v0.1.8-pre-beta. This update marks a definitive turning point, evolving Wave from an experimental project into a robust and modern systems programming language.

From Generics and Pattern Matching to explicit type casting, this release delivers the expressiveness and safety features our developers have been waiting for. Let’s dive into the major changes.

1. The Dawn of Generics: Revolutionizing Code Reuse

The foundational infrastructure for Generics is now live. You can now write highly reusable code by using type parameters in functions and structs. The compiler handles this via a Monomorphization pass, generating optimized machine code for each concrete type used.

New Syntax Example:

struct Pair<A, B> {
    first: A;
    second: B;
}

fun make_pair<A, B>(a: A, b: B) -> Pair<A, B> {
    var p: Pair<A, B>;
    p.first = a;
    p.second = b;
    return p;
}

fun main() i32 {
    var p = make_pair<i32, str>(1, "Wave");
}

The standard library has already begun utilizing this feature, introducing powerful structures like TypedBuffer<T>.

2. Pattern Matching (match): Elegant Control Flow

Wave now supports the match statement, providing a significant readability boost over long if-else chains. Behind the scenes, the backend lowers these matches into efficient LLVM switch instructions to ensure high performance.

New Syntax Example:

enum Status -> i32 { Ready = 0, Busy = 1, Error = 2 }

fun handle_status(s: Status) {
    match (s) {
        Status::Ready => { println("System is ready."); }
        Status::Busy  => { println("System is busy..."); }
        _             => { println("An error occurred."); } // Wildcard support
    }
}

3. Explicit Casting (as) and Static Globals (static)

In systems programming, control over memory and types is non-negotiable. We have introduced the as operator for explicit type conversions, replacing previous implicit narrowing behaviors to prevent accidental data loss. Additionally, the new static keyword allows for global variables that persist throughout the entire program lifetime.

New Syntax Example:

static GLOBAL_COUNTER: i64 = 0;

fun main() {
    var large_val: i64 = 5000;
    var small_val: i32 = large_val as i32; // Explicit casting required

    GLOBAL_COUNTER = GLOBAL_COUNTER + 1;
}

4. Conditional Compilation (#[target]): True Portability

To facilitate cross-platform development, we’ve introduced the #[target(os="...")] attribute. This allows developers to write OS-specific implementations within a single source file, which is now extensively used in our standard library to dispatch platform-agnostic paths like std::sys::fs.

Usage Example:

#[target(os="linux")]
import("std::sys::linux::fs");

#[target(os="macos")]
import("std::sys::macos::fs");

5. Backend Modernization: LLVM 21 & Opaque Pointers

Internally, the compiler backend has undergone a major upgrade to LLVM 21. We have fully transitioned to the Opaque Pointers system, which modernizes our IR generation and aligns Wave with the future of the LLVM ecosystem. We’ve also implemented a new PassBuilder to support modern optimization pipelines.

6. Improved Developer Experience: Rust-style Diagnostics

Error messages are no longer just text; they are a diagnostic tool. The new system provides colorized source code snippets, caret (^) markers, and unique error codes (e.g., E1001). This allows developers to pinpoint and fix syntax or semantic issues faster than ever before.

Conclusion

The v0.1.8-pre-beta release is a testament to Wave's goal: staying close to the hardware while providing modern language ergonomics. With the standard library refactored and infrastructure stabilized, Wave is now capable of handling complex projects—even a fully functional Doom demo!.

We invite you to download the new toolchain and start building the next generation of systems software with Wave.

The Wave Foundation Team