High Performance.
High Level.

// Hello World & Recursive Math in HP-HL
module hello;

int Factorial(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * Factorial(n - 1);
}

void Main() {
    print("Hello, HP-HL world!\n");

    int x = 42;
    print("Factorial(5) = ");
    print(Factorial(5));
    print("\n");

    // Standard math builtins: sin, cos, sqrt, pow, PI
    float hypotenuse = sqrt(3.0 * 3.0 + 4.0 * 4.0);
    print("Hypotenuse: ");
    print(hypotenuse);
    print("\n");
}

// Multithreading with spawn, channels, and task joining
module parallel_workers;

void Worker(int id, channel<int> ch) {
    int total = 0;
    for (int i = 0; i < 1000000; i++) {
        total += i;
    }
    ch.Send(total);
}

void Main() {
    var ch = new channel<int>();

    // Spawns background worker tasks on thread pool
    spawn Worker(1, ch);
    spawn Worker(2, ch);

    int res1 = ch.Receive();
    int res2 = ch.Receive();

    print("Workers completed: ");
    print(res1 + res2);
    print("\n");
}

// Direct Win32 API Interop via extern
module ffi_win32;

extern "user32" int MessageBoxA(int hwnd, string text, string caption, int type);
extern "kernel32" int GetTickCount();

void Main() {
    int start = GetTickCount();
    
    // Invokes Win32 native dialog directly
    MessageBoxA(0, "Hello from HP-HL Native Win32 FFI!", "HP-HL Engine", 0x40);
    
    int elapsed = GetTickCount() - start;
    print("Dialog interaction elapsed ms: ");
    print(elapsed);
    print("\n");
}

// Value Structs (Stack/Cache friendly) vs Managed Classes
module memory_model;

// Structs are flat, pass-by-value with zero GC tracking
struct Vec3 {
    float x;
    float y;
    float z;
}

// Classes live in GC managed generational heap
class Entity {
    string name;
    Vec3 pos;

    Entity(string n, Vec3 p) {
        this.name = n;
        this.pos = p;
    }
}

void Main() {
    Vec3 v;
    v.x = 10.0; v.y = 20.0; v.z = 30.0;

    var player = new Entity("PlayerOne", v);
    print(player.name);
    print(" at (");
    print(player.pos.x);
    print(")\n");
}

// Raytracer with Phong lighting, shadows, and parallel rendering
module raytracer;

class Vec3 {
    public float<64> X;
    public float<64> Y;
    public float<64> Z;
    Vec3(float<64> x, float<64> y, float<64> z) { X = x; Y = y; Z = z; }

    float<64> Dot(Vec3 o) {
        return X * o.X + Y * o.Y + Z * o.Z;
    }
    Vec3 Norm() {
        float<64> l = sqrt(this.Dot(this));
        return new Vec3(X / l, Y / l, Z / l);
    }
}

class Sphere {
    public Vec3 Center;
    public float<64> Radius;
    public Vec3 Color;

    float<64> Hit(Ray r) {
        Vec3 oc = r.Origin.Sub(Center);
        float<64> disc = oc.Dot(r.Direction) * oc.Dot(r.Direction)
                       - oc.Dot(oc) + Radius * Radius;
        if (disc < 0.0) return -1.0;
        return (-oc.Dot(r.Direction) - sqrt(disc));
    }
}

// Parallel rendering: each scanline runs on a separate thread
parallel foreach (var y in rows) {
    RenderRow(y);  // zero-copy, thread-safe by design
}
img_png_save("cena.png", img, 1280, 720);
print("cena.png ok\n");

// SpaceShooter: complete arcade game with native Win32 FFI
import Win32;
import Vec2;
import CharBuffer;
import Input;
import Collider;
import Particles;

Vec2 shipPos;
float<64>[128] bx;
float<64>[128] by;
int[64] efire;
int nFoes;

void AddShot(float<64> x, float<64> y, float<64> vy, bool foe) {
    if (nShots >= 128) return;
    bx[nShots] = x;
    by[nShots] = y;
    nShots = nShots + 1;
}

void Main() {
    // Console game loop at 60 FPS with direct Win32 FFI
    while (gLives > 0) {
        UpdateShip();
        UpdateBullets();
        SpawnEnemies();
        CheckCollisions();
        Render();
        Sleep(16);  // ~60 FPS
    }
}