Fast compilation. Native performance.
Ownership-based memory.
Garbage collection only where it matters.

// Lazy async futures — doesn't execute until awaited

import rayzor.concurrent.Future;

class Main {
    @:async
    static function compute(x: Int): Int {
        return x * 2;
    }

    static function main() {
        // Basic @:async + await
        var f = compute(21);
        trace(f.await());  // 42

        // Lazy — doesn't execute until await
        var f2 = compute(100);
        trace("not blocked");
        trace(f2.await());  // 200

        // Multiple concurrent
        var a = compute(10);
        var b = compute(20);
        trace(a.await() + b.await());  // 60

        trace("done");
    }
}

// Ownership-based memory — no GC for static types

@:move
class UniqueBuffer {
    var data: haxe.io.Bytes;

    public function new(size: Int) {
        this.data = haxe.io.Bytes.alloc(size);
    }
}

// Ownership transfer — freed at last use, no GC
var buf = new UniqueBuffer(1024);
process(buf);  // buf moves here
// buf is no longer valid — compile-time error if accessed

// Reference-counted when sharing is needed
@:arc
class SharedState {
    var value: Int;
}

// Safe fearless concurrency with Send types

@:derive([Send])
class Message {
    public var value: Int;
    public function new(v: Int) {
        this.value = v;
    }
}

class Main {
    static function main() {
        var msg = new Message(42);
        var handle = rayzor.concurrent.Thread.spawn(() -> {
            return msg.value;
        });
        var result = handle.join();
    }
}

// Message passing with channels

import rayzor.concurrent.Thread;
import rayzor.concurrent.Channel;
import rayzor.concurrent.Arc;

static function main() {
    var channel = new Arc(new Channel(10));
    var threadChannel = channel.clone();

    var sender = Thread.spawn(() -> {
        threadChannel.get().send(42);
        threadChannel.get().send(43);
        threadChannel.get().send(44);
        return 3;
    });

    sender.join();
    var v1 = channel.get().tryReceive();
    var v2 = channel.get().tryReceive();
    var v3 = channel.get().tryReceive();
}

// Rust-like mutex guards for safe shared state

import rayzor.concurrent.Mutex;

@:derive([Send])
class Counter {
    public var value: Int;
    public function new() {
        this.value = 0;
    }
}

static function main() {
    var counter = new Mutex(new Counter());
    var guard = counter.lock();
    var c = guard.get();
    trace(42);
}

// Atomic shared data with Arc and Send+Sync

import rayzor.concurrent.Thread;
import rayzor.concurrent.Arc;

@:derive([Send, Sync])
class SharedData {
    public var value: Int;
    public function new(v: Int) {
        this.value = v;
    }
}

static function main() {
    var shared = new Arc(new SharedData(42));
    var shared_clone = shared.clone();
    var handle = Thread.spawn(() -> {
        return shared_clone.get().value;
    });
    var result = handle.join();
}

// Zero-cost SIMD — maps to native SSE/NEON registers

import rayzor.SIMD4f;
class Main {
    static function main() {
        var a = SIMD4f.splat(1.0);
        var b = SIMD4f.splat(2.0);
        var c = a + b;
        trace(c);
    }
}

// Embed C code directly — call native libraries

@:cInclude(["/opt/homebrew/include"])
class Main {
    static function main() {
        var result = untyped __c__('
            #include <raymath.h>
            long __entry__() {
                Vector2 v = { 3.0f, 4.0f };
                float len = Vector2Length(v);
                float c = Clamp(15.0f, 0.0f, 10.0f);
                float l = Lerp(0.0f, 100.0f, 0.25f);
                return (long)(len * 10000.0f
                    + c * 100.0f + l);
            }
        ');
        trace(result);  // 51025
    }
}