eskiu

1.En producción

Eskiu ya corre en software en producción. Reemplaza código nativo sensible a la memoria sin recolector de basura, mantiene un ABI de C para entrar directo en una base de código C o C++ existente, y llega a hardware que un lenguaje de sistemas joven rara vez toca. El mismo código compila en Linux, macOS y Windows, incluida la pila de red async. Es el lenguaje de sistemas de ReactVision, y el primer lugar donde se envió es el propio renderer XR de la familia.

Ya lo usan: ReactVision, The Morrow Digital.

2.El lenguaje

Eskiu compila con LLVM a un binario nativo independiente, sin recolector de basura ni runtime administrado. La sintaxis es de estilo C, así que lo básico se siente familiar; a eso la semántica le suma tipos suma, genéricos con restricciones, sobrecarga de operadores, async/await, canales y atómicos. El compilador está escrito en el propio Eskiu.

Tipos suma y match exhaustivo

Un enum lleva datos por variante, y el match se verifica por exhaustividad en tiempo de compilación, así que un caso olvidado no compila.

parse_port.esk

enum ParseResult {
    Port(int),
    InvalidRange(int),
    NotANumber,
}

ParseResult parse_port(string s) {
    let n: int = atoi(s);
    if (n == 0) { return NotANumber; }
    if (n < 1 || n > 65535) { return InvalidRange(n); }
    return Port(n);
}

match parse_port("8080") {
    Port(p)         -> printf("listening on :%d\n", p);
    InvalidRange(n) -> printf("%d out of range\n", n);
    NotANumber      -> printf("not a number\n");
}

Genéricos y operadores

Los tipos se parametrizan con restricciones de interfaz y se monomorfizan en tiempo de compilación. Un tipo también puede sobrecargar operadores como métodos ordinarios, resueltos por el tipo de los operandos, así que la matemática de vectores se lee como aritmética y baja a una llamada directa sin costo en runtime.

vec.esk

struct V3 { float x; float y; float z; }

V3 operator +(V3 a, V3 b) {
    let r: V3;
    r.x = a.x + b.x;
    r.y = a.y + b.y;
    r.z = a.z + b.z;
    return r;
}

V3 operator *(V3 v, float s) {
    let r: V3;
    r.x = v.x * s;
    r.y = v.y * s;
    r.z = v.z * s;
    return r;
}

let mid: V3 = (a + b) * 0.5;   // + y * resuelven a las sobrecargas

Async y canales

Las funciones async devuelven un Future; await suspende la ejecución hasta que haya un valor listo. Los canales tipados (Chan<T>) pasan valores entre tareas. El reactor corre sobre kqueue, epoll o WSAPoll, así que el mismo código maneja Linux, macOS y Windows.

sum_squares.esk

import <future>;
import <channel>;

async int sum_squares(Chan<int>* ch) {
    let a: int = await chan_recv(ch);
    let b: int = await chan_recv(ch);
    let c: int = await chan_recv(ch);
    return a + b + c;
}

Chan<int>* ch = chan_new<int>(8);
for (i in 1..4) { chan_send(ch, i * i); }   // 1, 4, 9 -> 14

3.Herramientas

Un solo binario, eskiuc, se encarga de todo. eskiuc run compila y ejecuta de una vez; eskiuc build genera un binario nativo. La biblioteca estándar viene incluida, así que los imports funcionan sin configurar nada.

$ eskiuc run app.esk          # compila + ejecuta en un paso
$ eskiuc build app.esk -o app  # emite un binario nativo independiente
$ eskiuc --version

Pruébalo

Edita el programa de abajo y córrelo. El servidor lo compila con LLVM y lo ejecuta con el mismo eskiuc run.

La salida aparece aquí. Presiona Ejecutar (o ⌘/Ctrl + Enter).

4.Instalación

En macOS o Linux, instala el último release con un comando:

$ curl -fsSL https://eskiu-lang.org/install.sh | sh

Descarga el binario para tu plataforma, verifica su checksum y lo instala. O baja un binario directamente y descomprímelo en /usr/local:

Windows está validado de punta a punta en un runner nativo de CI: el compilador compila y enlaza, y las excepciones junto con las pilas de red bloqueante y async pasan todas. Todavía no es parte del gate de releases, así que el build de Windows va un poco adelante de los de Linux y macOS.

# o compila desde el código fuente
$ git clone https://github.com/doranteseduardo/eskiu
$ cd eskiu && make