Metal-level FP
Zero Runtime.

def choose(): i64 =
    reset {
      let x = shift k {
        k(20) + k(22)
      }
      x + 1
    }

Control is a value, not a hidden runtime bargain.

def store64(ptr: i64, idx: i64, val: i64): *u8 =
    unsafe {
      asm (ptr: rdi, idx: rsi, val: rdx) : (rax) => {
          "mov [rdi + rsi*8], rdx"
          "xor eax, eax"
      }
    }

Registers and return paths stay visible at the source level.

type Slice = { ptr: *u8, len: usize }

def Slice.at(self: Slice, index: usize): u8 =
    unsafe { self.ptr[index] }

def main(): u8 = {
    let s = Slice { ptr: 0x1000, len: 10 }
    s.at(3)
}

Methods are resolved statically, without object tax.

def x_of(point: {r | x: i64}): i64 =
    point.x

def move_right(point: {r | x: i64}, dx: i64): {r | x: i64} =
    {point | x: point.x + dx}

Functions can ask for a shape without naming the whole record.

data Option[T] { Some(T), None }

def unwrap_or(value: Option[T], fallback: T): T =
    match value {
      Some(x) => x
      None => fallback
    }

Data constructors destructure directly inside expression arms.

def normalize(name: String): String =
    name |>
      trim() |>
      lowercase() |>
      replace("_", "-") |>
      intern()

Dataflow reads forward while calls stay ordinary.