Two languages in,
native code out.

// frontends

Zia, and a BASIC that isn’t a toy

Zia is the language the platform is built for and built in — Zanna Studio is written in it. BASIC is a second, complete frontend rather than a demo: it has classes, structured control flow, and file I/O, and it lowers to exactly the same IL.

module Hello;

bind Zanna.Terminal as Term;

func start() {
    var total = 0;
    for i in 1..6 {
        total = total + i;
    }
    Term.Say("Zanna says hello");
    Term.SayInt(total);
}

module Counter;

bind Zanna.Terminal as Term;

class Counter {
    expose Integer value;

    expose func init(start: Integer) {
        value = start;
    }

    expose func increment() {
        value = value + 1;
    }
}

func start() {
    var c = new Counter(10);
    c.increment();
    c.increment();
    Term.SayInt(c.value);   // 12
}

module Classify;

bind Zanna.Terminal as Term;

func classify(value: Integer) -> String {
    return match value {
        0 => "zero";
        n if n > 0 => "positive";
        _ => "negative";
    };
}

func start() {
    Term.Say(classify(0));    // zero
    Term.Say(classify(7));    // positive
    Term.Say(classify(-3));   // negative
}

module Combinators;

bind Zanna.Terminal as Term;

func start() {
    var nums = [1, 2, 3, 4, 5];
    var doubled = nums.map((n) => n * 2);
    var evens   = nums.filter((n) => n % 2 == 0);
    var total   = nums.reduce(0, (acc, n) => acc + n);
    Term.SayInt(doubled.get(4));  // 10
    Term.SayInt(evens.count());   // 2
    Term.SayInt(total);            // 15
}

DIM total AS INTEGER = 0
FOR i = 1 TO 5
  total = total + i
NEXT i
PRINT "Zanna says hello"
PRINT total

Every program on this page was compiled and run with the toolchain in the repository. The comments showing results are the output those programs actually produced.

// zanna il 0.3.0

The thin waist

Both frontends compile to one typed intermediate language. Everything downstream — the verifier, the optimizer, the VM, both native backends — only ever sees IL. That is what keeps a new frontend from becoming a fork of the whole toolchain, and it is why the VM and a native binary are required to agree.

The optimizer, shown rather than claimed

mem2reg promotes stack slots to SSA registers. Because the IL uses block parameters, the result is unusually legible: the two stores and the load disappear, and the value arrives at Join as an argument. This is the real output of zanna il-opt before.il -o after.il --passes mem2reg.

il 0.3.0
func @main() -> i64 {
entry:
  %t0 = alloca 8
  %t1 = icmp_eq 0, 0
  cbr %t1, T, F
T:
  store i64, %t0, 2
  br Join
F:
  store i64, %t0, 3
  br Join
Join:
  %t2 = load i64, %t0
  ret %t2
}

il 0.3.0
func @main() -> i64 {
entry:
  %t1 = icmp_eq 0, 0
  cbr %t1, T, F
T:
  br Join(2)
F:
  br Join(3)
Join(%t4:i64):
  ret %t4
}

// passes

One optimizer, shared by both languages

Passes are registered and composable, and you can run any subset by hand with zanna il-opt --passes. This is the default -O1 pipeline as the driver reports it:

simplify-cfg, mem2reg, simplify-cfg, sccp, constfold, peephole, dce,
simplify-cfg, sccp, inline, peephole, dce, simplify-cfg

The registered set is wider than any single pipeline uses — SSA promotion, sparse conditional constant propagation, global value numbering, loop rotation, loop-invariant code motion, induction variable simplification, loop unrolling, early CSE, reassociation, inlining, sibling-recursion elimination, dead store elimination, exception-handling cleanup, peephole rewriting, and CFG simplification.

zanna build defaults to -O1; zanna run defaults to -O0 to keep the edit-run loop fast. -O2 is the release profile.

// execution

A VM and two native backends that must agree

// standard library

The runtime both languages share

One library, reachable from Zia and from BASIC, written in portable C with a stable ABI and no compiler dependencies. The table below is generated from the runtime definition files, so it tracks the code rather than the documentation.

Abridged — the full inventory also covers threads, time, processes, PTYs, diagnostics, functional helpers, options and results. Run zanna --dump-runtime-api for the complete machine-readable contract.

// tooling

Built to be called by programs

Editors, scripts and coding agents are first-class consumers of this toolchain. Diagnostics are structured, exit codes are differentiated so a caller never has to parse prose, and the language servers speak both LSP and MCP.

Type-check without running

$ zanna check broken.zia --diagnostic-format=json

{
  "diagnostics": [{
    "severity": "error",
    "code":     "V-ZIA-UNDEFINED",
    "stage":    "sema",
    "message":  "Undefined identifier: mesage",
    "range": {
      "begin": { "line": 6, "column": 14 },
      "end":   { "line": 6, "column": 20 }
    },
    "source":  "    Term.Say(mesage);",
    "help":    "Declare the symbol, import it, or correct the spelling.",
    "notes":   [],
    "fixits":  []
  }]
}

Pretty-printed here; the tool emits one line, and carries absolute file paths and per-file ids that are trimmed above. Exit code 2 means compile or verification errors.

Evaluate a snippet

$ zanna eval '2 + 3 * 4' --json --type
{"success":true,"trapped":false,"resultType":"Integer","output":"14\n","error":"","type":"Integer"}

Ask the binary what it contains

$ zanna --dump-opcodes | python3 -c 'import json,sys; d=json.load(sys.stdin); print(d["ilVersion"], len(d["opcodes"]))'
0.3.0 84

$ zanna --dump-runtime-api | python3 -c 'import json,sys; d=json.load(sys.stdin); print(len(d["classes"]), len(d["functions"]))'
531 7844

Look up a diagnostic code

$ zanna explain V-ZIA-UNDEFINED
V-ZIA-UNDEFINED (zia-sema)
  Use of an undefined identifier; may include a did-you-mean fix-it

// where it stands

Solid, and rough