S01E02 — 30-03-2026.

zo 0.1.1 — Extended Language Features.

0.1.0 gave zo its face: zsx, the syntax extension for declaring interfaces. 0.1.1 fills in the language behind that face. It adds the control flow, the types, and the declarations a program needs before its interface matters.

control flow

A program can now branch and loop. if/else chooses between blocks. The when cond ? a : b ternary chooses between values inside an expression. Two loops arrive. while repeats while a condition holds, and for walks a range. Both answer to break and continue.

for index := 0..5 {
  showln(index);
}

char and float

The scalar types grow. A char holds one Unicode character. A float holds a 64-bit double, so a program can carry fractional values beside the integers it already had.

imu grade: char = 'A';
imu pi: float = 3.14159;

arrays

The first collection zo can hold and index: a fixed, homogeneous run of values, where every element is one type and the length is part of the type.

imu nums: [3]int = [10, 20, 30];
showln(nums[0]);  -- 10

enum, struct, apply

Three ways to name your own types. enum declares a tagged union, a value that is exactly one of several named variants. struct declares a record, named fields gathered under one type. apply is the block that binds methods to a type, so behavior sits beside the data it works on.

enum Shape {
  Circle,
  Square,
}

struct Point {
  x: int,
  y: int,
}

apply Point {
  fun sum(self) -> int {
    self.x + self.y
  }
}

check

The first step toward a test story. check takes a condition and stops the program when it does not hold. For comparisons, a modifier spells the claim out: @eq, @ne, @lt, @le, @gt, @ge. check@eq(total, 42) then reads as the assertion it makes.

check(2 + 2 == 4);     -- a plain condition

check@eq(2 + 2, 4);    -- the same claim, with a modifier
check@lt(1, 10);

module system

A first, basic module system, the first step from a single source toward an organized codebase. A pack groups related items under one name, and you reach an item through that name with the :: path, as in pack::item().

pack say {
  fun hello() {
    showln("hello, modular world");
  }
}

fun main() {
  say::hello();
}

tooling

Outside the compiler, a VS Code extension brings syntax highlighting to .zo. It is the first piece of editor support.