One post tagged with "language-design"

You surely know as well as I do that the world does not need another amateur C++/Rust/Zig/Go/Odin clone, so the honest introduction is this: I started building Metel because I wanted to build a programming language.

Here's a taste of what that turned into:

fun main() {
    let name = "Metel";
    let answer: Perhaps<i64> = Perhaps::Some { value: 42 };
    println("${name} says the answer is ${answer.yolo()}");
}

.yolo() is not a typo — more on that name below.

At first, the goal was small and personal: a statically typed, Rust-influenced interpreted language with a garbage collector, built to learn rather than to ship.

That version did not stay small for long. Once the basics existed, I started reading more seriously about memory safety, type systems, ownership, regions, linear capabilities, structural typing, and brand-like identity systems — Federico Bruzzone's A friendly tour of substructural, uniqueness, ownership and capabilities types (and more) was one of the pieces that pushed me deeper in that direction.

What struck me reading that material was how vast it was, and how much of it is already proven out somewhere — region calculus, explicit allocators, branded identity, structural typing, each already shipped in some corner of some language (more on each below). Almost none of the individual ideas is unclaimed.

What is still genuinely open is how much room is left in combining them. Each already solves its own problem well, in its own language; what's still unexplored is whether several of these already-researched concepts can hold together at once, in a single language, rather than each staying in a different one.

There's also a more immediate motivation: mainstream languages are still actively floating new proposals for these exact problems — Rust's own Niko Matsakis has one for view types and, separately, one for a place-based lifetime syntax aimed at teachability. Watching that, I realized I could try my hand at the same problems myself, in a language of my own.

The project slowly stopped being "my small Rust-like interpreter" and became a different question — not "how do I clone Rust" and not "what entirely new idea can I invent," but something in between: what does a language look like that takes several of these already-proven ideas seriously and actually puts them together? That question is what Metel is now.