Classes, generics, and pattern matching —
compiled straight to C.

Explicitly-sized integers, a float, bool, and a text char/char* string — fixed arrays are T[N]; growable ones are Vector<T> from the standard library, not a built-in array type.

Bindings are type-inferred or explicitly annotated; a later let may shadow an earlier one in the same scope. Functions take default parameter values, a trailing variadic parameter, and overload by parameter shape.

let count = 0                     // inferred as i64
const MAX: i64 = 100
volatile let ready: bool = false    // never cached in a register

func greet(name: char*, loud: bool = false) -> char* { ... }
func total(values: i64...) -> i64 { ... }

x |> f desugars to f(x), and x |> f(a, b) to f(x, a, b) — the piped-in value always lands as the first argument. Chains read left to right, and it binds looser than every other operator, so a + b |> f is f(a + b), not a + f(b).

func double_it(x: i64) -> i64 { return x * 2 }
func add_one(x: i64) -> i64 { return x + 1 }
func add(a: i64, b: i64) -> i64 { return a + b }

let piped: i64 = 5 |> double_it |> add_one   // (5*2)+1 = 11
let with_args: i64 = 5 |> add(10)          // add(5, 10) = 15
let precedence: i64 = 2 + 3 |> double_it   // (2+3) |> double_it = 10

A class is always heap-allocated and reference-counted, with overloadable constructors and a destructor. A struct is a plain value type — no ref-counting, optionally packed for an exact C layout. A union overlaps its fields the same way C's does.

class Counter {
    private let value: i64

    constructor(start: i64) { self.value = start }
    destructor() {}

    func increment() { self.value = self.value + 1 }
    static func zero() -> Counter { return new Counter(0) }
}

packed struct Header {
    let magic: u32
    let version: u8
}

Classes, structs, and functions all take type parameters, optionally bounded by a trait — a compile-time-only contract satisfied by an impl block elsewhere.

trait Hashable {
    func hash() -> u64
    func equals(other: Self) -> bool
}

class HashSet<T: Hashable> { ... }

impl Hashable for i64 {
    func hash() -> u64 { return self as u64 }
    func equals(other: i64) -> bool { return self == other }
}

A tagged enum variant carries its own fields and is constructed by calling it, e.g. Shape.Circle(3). match destructures a variant's fields directly into fresh bindings; a plain match on tuples and structs works the same way.

// enum Shape { Circle(radius: i64), Square(side: i64), Point }
match shape {
    case Shape.Circle(radius) => { ... }
    case Shape.Square(side) => { ... }
    default => { ... }
}

match point {
    case (0, 0) => puts("origin")
    case (x, y) => print_int("x", x)
}

expr? unwraps an Optional<T>/Result<T,E> on success, or returns a matching empty/error value straight out of the enclosing function. Wrapped in try, that same early-exit is redirected to catch instead — plain generated control flow, not stack unwinding.

try {
    let x: i64 = safe_div(10, 0)?
} catch (e) {
    print_int("caught", e)
} finally {
    puts("always runs")
}

A lambda's captures are listed explicitly — copied by value at creation time, or by reference with &. for x in y works over a fixed array or anything implementing the two-method Iterator<T> protocol.

func make_adder(n: i64) -> (i64) -> i64 {
    return func[n](x: i64) -> i64 { return x + n }
}

for item in my_vector {
    puts(item)
}

Beyond the usual if/while/for: a trailing unless modifier reads as a guard clause, and defer schedules a statement to run when its enclosing scope exits, in reverse order for multiple defers.

log("skipped") unless is_valid   // if !is_valid { log(...) }

func read_all() {
    let f = open_file()
    defer f.close()             // runs on every exit path
    ...
}

A bare, dotted import resolves to a file path (drivers.serial → drivers/serial.llpl); a quoted one is for paths that aren't valid identifiers. using namespace brings a namespace's names into scope unqualified; $LLPL_HOME lets stdlib/... imports resolve the same way regardless of where the importing file lives.

import stdlib.collections.hashmap
import "weird-path.llpl"          // quoted, for names that aren't valid identifiers

using namespace std.collections
alias Map = EnhancedHashMap<String, i64>

A hygienic macro quotes ordinary LLPL syntax and splices arguments in with unquote — the quoted body is parsed with the same grammar as everything else, not a separate template language.

macro assert_positive(x) {
    quote {
        if unquote(x) < 0 {
            llpl_panic("expected a positive value")
        }
    }
}

Covered up top — an ANTLR-style grammar block compiled into a real recursive-descent parser at build time. Direct left recursion becomes a precedence-climbing loop automatically; every decision point is checked for ambiguity at compile time, never guessed at runtime. Name(text) is sugar for constructing the generated class and calling its first rule; every match becomes a walkable ParseNode.

A class instance's lifetime is reference-counted automatically. Weak<T> holds a non-owning reference for exactly the cases where two objects would otherwise keep each other alive forever. Manual allocation is still available underneath for anything managing its own memory by hand.

let a: MyClass = new MyClass()               // ref-counted
let w: Weak<MyClass> = new Weak<MyClass>(a)  // doesn't keep it alive

let raw: char* = llpl_alloc(64)                // manual buffer
llpl_free(raw)

Binding a C library is an extern func declaration plus a #link directive; a bare-metal target adds interrupt handlers, inline assembly, and placement attributes for linker sections and alignment.

#link "SDL3"
extern func SDL_Init(flags: u32) -> i64

interrupt func isr_divide_by_zero() { ... }

@section(".boot")
@align(16)
let boot_stack: u8[4096]