v0.0.12-alpha · LLVM backend · arm64 + x86-64

C performance.
Go concurrency.
Explicit memory.

Systems programming with C-style syntax, monomorphic templates, and structural interfaces. Compiles to native code via LLVM. You manage memory; the compiler manages nothing else.

Get Started View on GitHub

Why Eskiu exists

One language instead of four.

Compute-intensive backend services commonly reach for C when performance matters, Go for concurrency, C++ for libraries, and Python for everything else. Each adds a separate toolchain, a different set of idioms, and friction at every boundary.

Eskiu is a direct response to that. Phase one: a systems foundation solid enough to handle the work that currently requires C or C++. Phase two: first-class support for the domain types that high-throughput services actually work with — without giving up general systems capability.

Examples

Looks familiar. Works fast.

If you can read C, you can read Eskiu. Pick a tab and see for yourself.

extern int printf(string fmt, ...);

int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(5, 3);
    printf("Hello from Eskiu!\n");
    printf("Result: %d\n", result);
    return 0;
}

interface Drawable { void draw(); }

struct Circle {
    float radius;
    void draw() {
        printf("Circle(r=%f)\n", self.radius);
    }
}

struct Square {
    float side;
    void draw() {
        printf("Square(s=%f)\n", self.side);
    }
}

void render(Drawable d) { d.draw(); }

int main() {
    let c: Circle = Circle { radius: 5.0 };
    render(&c); // auto-boxed to Drawable
    return 0;
}

int apply(fn(int)->int f, int x) {
    return f(x);
}

int main() {
    // anonymous function — same syntax, no name
    let square: fn(int)->int =
        int(int n) { return n * n; };

    printf("%d\n", square(6));         // 36
    printf("%d\n", apply(square, 4));  // 16
    return 0;
}

import "stdlib/result.esk";

Result<int, string> divide(int a, int b) {
    if (b == 0)
        return Err<int, string>("division by zero");
    return Ok<int, string>(a / b);
}

int main() {
    let r = divide(10, 2);
    if (r.ok == 1)
        printf("result = %d\n", r.value);
    else
        printf("error: %s\n", r.error);
    return 0;
}

Why Eskiu

Six decisions that shape how Eskiu works.

Each one was validated against real production code before it shipped.

Native performance

Compiled to machine code via LLVM. Predictable throughput with no runtime surprises.

Familiar syntax

C-style declarations, braces, semicolons. Pick it up in an afternoon if you already know C.

Explicit memory

alloc(T, N) and free(ptr). Heap allocation is visible in the code, not hidden behind a runtime.

Structural interfaces

A struct satisfies an interface by having the right methods. No declarations, no inheritance chain.

C interop

extern declarations give direct access to any C library — OpenSSL, POSIX, CoreGraphics — with no wrapper layer.

IDE tooling

VS Code extension with error squiggles, hover types, and go-to-definition, driven by the compiler directly.

Benchmark

Faster than hand-written C.

A real-world cryptographic pipeline — AES-256-CBC + RSA-8192 decryption, image processing, and structured output — running entirely in Eskiu via extern C interop.

74 ms

Eskiu — end-to-end

189 ms

Reference C — end-to-end

Measured on Apple Silicon (arm64). 2.5× faster than the reference C. The crypto stage matches hand-written C within 0.1 ms.

Stage	Eskiu	Reference C
QR / image extraction	71.7 ms	185.5 ms
Crypto (AES-256-CBC + RSA-8192)	2.8 ms	2.9 ms
Output decode	< 1 ms	0.5 ms
Total	74.4 ms	188.9 ms

News

Latest releases

Eskiu ships frequently. Each release adds language features, fixes compiler bugs, or improves tooling.

Full changelog

Eskiu 0.0.12-alphafeattooling

Lambdas and fn(T)->R function pointer types. VS Code hover types and go-to-definition. switch/case type checking.
Eskiu 0.0.11-alphafeat

727-line real-world port completed. Adjacent string literal concatenation. List<T> auto-resize.
Eskiu 0.0.10-alphafix

8 compiler bugs fixed: pointer subtraction, integer widening, string indexing, store coercion, interface dispatch typed returns.
Eskiu 0.0.9-alphafeat

Global variables, sret convention for large struct returns on arm64, integer argument widening.

CLI

One compiler. Four diagnostic modes.

Each flag stops after a specific phase and prints what was produced. No separate toolchain needed.

$ eskiuc hello.esk -o hello.o && clang hello.o -o hello # compile and link

$ eskiuc hello.esk --test-lexer # dump token stream

$ eskiuc hello.esk --test-parser # dump AST

$ eskiuc hello.esk --test-typechecker # type check only

$ eskiuc hello.esk --test-codegen # dump LLVM IR

$ eskiuc hello.esk --hover-at 8:12 # type at cursor (VS Code)

C performance.Go concurrency.Explicit memory.