From Go

You like short programs that build fast. Rasmalai keeps the build speed and the readability, then removes the stop-the-world pauses and the ceiling on hardware control.

No runtime, no pauses

Go ships a scheduler and a collector with every binary. Rasmalai ships your code: reference counts the compiler inserts, freed at scope ends the source already shows. Worst-case GC pause: 0.00 ms, because there is no collector:

defer stacks exactly like Go's, and print takes multiple arguments like fmt.Println without the format-string ceremony.

let served = 0;
let i = 0;
while i < 1000 {
    served = served + 1;
    i = i + 1;
}
print(served);

Structs and methods

Structs bundle fields with a free memberwise initializer; methods attach directly. No embedded-interface promotion puzzles:

struct Meter {
    let name: String;
    let reading: Int;
}

let m = Meter("heat", 21);
print(m.name, m.reading);

Real SIMD instead of assembly shims

Go reaches the vector unit through assembly stubs or compiler intrinsics. Vec4f is a first-class 128-bit value: no heap, no ARC traffic, plain operators:

import { Vec4f } from "@std/simd";

let a = new Vec4f(1.0, 2.0, 3.0, 4.0);
let b = Vec4f.splat(2.0);
let c = a + b;
print(c.get(3));

Errors without if err != nil

Returning (T, error) on every call litters logic with repetitive guards. Rasmalai marks fallible functions throws and handles them once, at the boundary:

Keep the flat, readable functions. Lose the collector and the error ceremony. Next: the Guide from the top, or the Manual for the threading rules.

fn load(ok: Bool): Int throws {
    if ok { return 42; }
    throw 0;
}

try {
    print(load(true));
} catch (err) {
    print("unreachable");
}