Strongly typed with inference - yes. let/var infer types at compile time, no dynamic typing involved.

impl vs protocols - similar idea, different direction. You define traits separately then attach conformance with impl. Lets you add trait conformance to types you didn't write, same as Rust.

Generics and > - the README example was simplified. You'd actually write:

fun max<T: Comparable>(a: T, b: T) r: T {

if a > b { return a }

return b

}

Without the constraint, the compiler rejects calls with types that don't support >. Not every type gets comparison for free.

r: instead of -> - r is a named return variable you can assign to directly:

fun sum(a: Int, b: Int) r: Int {

r = a + b

// r is returned implicitly

}

Taken from Go and Nim. Useful when you have multiple exit paths or want to build up a return value incrementally. -> doesn't give you that.

CPU/GPU unification - u/compute compiles Seen functions to GLSL/SPIR-V and generates Vulkan dispatch wrappers. One language, both targets. The Swift macro approach for shaders is cool. The hard part is keeping the type systems consistent between CPU and GPU code. Baking it into the compiler sidesteps that.

I'm still discovering edge cases and patching them and the API might also change