Minimal.
Native. Hackable.

type
  Point = record
    x: int32;
    y: int32;
  end;

  // Record inheritance
  Point3D = record(Point)
    z: int32;
  end;

  // Packed -- no padding between fields
  Header = record packed
    magic:   uint32;
    version: uint16;
    flags:   uint8;
  end;

  // Bit fields
  Flags = record packed
    active: uint8 : 1;
    mode:   uint8 : 3;
    level:  uint8 : 4;
  end;

var
  p: Point3D;

begin
  p.x := 10;  p.y := 20;  p.z := 30;
  println("({}, {}, {})", p.x, p.y, p.z);
end.

type
  TAnimal = object
    Name_: string;

    method Init(AName: string);
    begin
      self.Name_ := AName;
    end;

    method Speak();
    begin
      println("{} says: ...", self.Name_);
    end;
  end;

  TDog = object(TAnimal)
    // Override -- virtual dispatch
    method Speak();
    begin
      println("{} says: Woof!", self.Name_);
    end;
  end;

var
  dog: pointer to TDog;
  base: pointer to TAnimal;

begin
  create(dog);
  dog.Init("Buddy");

  // Dispatch through base pointer
  base := pointer to TAnimal(dog);
  base.Speak();  // calls TDog.Speak()
  destroy(dog);
end.

routine getZero(): int32;
begin
  return 0;
end;

var
  x: int32;

begin
  // Software exception
  guard
    raiseexception("Something went wrong");
  except
    println("Caught: {}", getexceptionmessage());
  end;

  // With error code and finally
  guard
    raiseexceptioncode(42, "Custom error");
  except
    println("Code: {}", getexceptioncode());
  finally
    println("Always runs");
  end;

  // Hardware exception (div-by-zero)
  guard
    x := 10 div getZero();
  except
    println("HW exception: {}", getexceptionmessage());
  end;
end.

// User-defined variadic routine
routine sumInts(...): int32;
var
  i: int32;
  sum: int32;
  arg: int32;
begin
  sum := 0;
  for i := 0 to varargs.count - 1 do
    arg := varargs.next(int32);
    sum := sum + arg;
  end;
  return sum;
end;

begin
  println("sum = {}", sumInts(10, 20, 30));   // 60
  println("sum = {}", sumInts(1, 2, 3, 4, 5)); // 15
  println("sum = {}", sumInts());             // 0
end.

var
  s1: set;
  s2: set;
  s3: set;

begin
  s1 := [1, 3, 5];     // bit positions 1, 3, 5
  s2 := [3, 5, 10];

  // Set arithmetic
  s3 := s1 + s2;  // union: [1,3,5,10]
  s3 := s1 * s2;  // intersection: [3,5]
  s3 := s1 - s2;  // difference: [1]

  // Membership test
  if 1 in s1 then
    println("1 is in s1");
  end;

  // Range literal
  s1 := [1..5];   // bits 1 through 5
end.

module exe ffi_demo;

// Per-target library paths -- TARGET_* is defined by the compiler
@ifdef TARGET_LINUX64
@copydll "output/zig-out/lib/libmathlib.so";
@librarypath "output/zig-out/lib";
@elseif TARGET_WIN64
@librarypath "output/zig-out/bin";
@endif

@linklibrary "mathlib";

// clink = C linkage (extern "C", unmangled). cpplink is the default.
routine clink add(const a: int32; const b: int32): int32; external "mathlib";
routine clink quadruple(const x: int32): int32; external "mathlib";

// Variables can be imported too
var version: int32; external "mathlib";

var
  r: int32;

begin
  r := add(3, 5);
  println("add(3, 5) = {}", r);
  println("quadruple(4) = {}", quadruple(4));
  println("lib version = {}", version);
end.

module exe mixed;

// C++ headers pass through verbatim
#include <cmath>
#include <string>
#include <vector>

var
  LS: std::string;
  LV: std::vector<int32_t>*;

begin
  // C++ functions in Myra expressions
  println("sqrt(16) = {}", std::sqrt(16.0));

  // C++ types as Myra variables
  LS := "hello from C++";
  println("len = {}", LS.length());

  // C++ new/delete alongside Myra
  LV := new std::vector<int32_t>();
  LV->push_back(42);
  println("size = {}", LV->size());
  delete LV;
end.