eskiuv0.14.1
EN / ES Install 0.14.1
v0.14.1 · open source · MIT Star on GitHub

Write it like a script. Ship it like C.

A self-hosting systems language on LLVM, with explicit memory and direct C interop. One compiler for desktops, the web and phones.

Get started Try it in the browser
Install on macOS or Linux curl -fsSL https://eskiu-lang.org/install.sh | sh

Homebrew: brew install eskiu-lang/eskiu/eskiu · Windows and release archives · VS Code extension

The Eskiu mascot, a grey tabby kitten
stars.esk
#!/usr/bin/env -S eskiuc run
import <io>;
import <fetch>;
import <json>;

let r: Response;
fetch("https://api.github.com/repos/llvm/llvm-project", &r);
*JsonValue repo = Response_json(&r);
printf("%s has %lld stars\n",
       JsonValue_as_cstr(json_get(repo, "full_name")),
       JsonValue_as_int(json_get(repo, "stargazers_count")));
$ ./stars.esk
llvm/llvm-project has 41179 stars
$ eskiuc stars.esk -O2 -o stars && ls -lh stars
-rwxr-xr-x  194K  stars
The file runs as a script, and the same file builds a native program of 194 KB.
What it buildsEverything built with Eskiu
The Tasks app built with ui, on iPhone and AndroiduiNative apps for iOS, Android and the web A sci-fi helmet rendered with the gpu packagegpuPhysically based rendering on WebGPU gpu · Metal45tokens per secondLlama 2 7B on an M4 Pro, in WGSL Self-hosted574programs, the same from both compilersThe compiler is also written in Eskiu and builds itself An Eskiu program running on a Nintendo 3DS32-bit ARMNintendo 3DS homebrew The Eskiu kernel's shell running in QEMUBare metalAn ARM64 kernel in QEMU PackagesOne eskiuc add awayuigpuonnxtflitecompressaudiofontjnindslocationcameranotifications

TargetsmacOS · Linux · Windows · iOS · Android · WebAssembly · 32-bit ARM · bare metal

Why Eskiu

Fast

Native code through LLVM, with memory you manage and no garbage collector. A C library's structs and functions are called as they are, on every target.

C interop and ABIs
Reliable

Sum types checked to the last case, nullable pointers checked before use, defer for cleanup, and bounds, overflow and null checks with --safe.

Ownership and resources
Productive

Run a file like a script, with HTTP, JSON, files and processes in the standard library, packages in one command and an editor that knows your code.

Quickstart
In production

Running inside ViroReact.

ReactVision ships Eskiu in ViroReact: ≈85% less memory in its engine, the tracker behind its AR on the web, and its object detection on iOS and Android.

tinyvio · vision

AR tracking in the browser

ViroReact's visual-inertial tracker runs on an engine written in Eskiu and compiled to WebAssembly. Its computer vision core computes the same bits as the C++ it replaced.

217,582 cases compared bit for bit0 mismatches
The vision package → onnx · jni

One detection core for iOS and Android

Object detection in ViroReact is one Eskiu core over ONNX Runtime on both platforms. On Android its JNI entry points are Eskiu too.

ReactVision case study →
Used by ReactVision The Morrow Digital Digital identity
What you can build

One language, from scripts to silicon.

WebAssembly

Compile for the browser

One flag builds a page, a module, or a library for an existing emscripten project. Exceptions, async code and C interop work there as they do natively, and ViroReact's AR tracking ships to the web this way.

$ eskiuc app.esk --target wasm32-unknown-emscripten -o app.js

Phones

Static libraries for iOS and shared libraries for Android, called from Swift, Kotlin or Objective-C.

GPU and machine learning

WebGPU compute and 3D, ONNX Runtime and TensorFlow Lite, each one package away.

Scripts and command-line tools

eskiuc run or a shebang, with argument parsing, HTTP, JSON and processes built in.

Network services

async HTTP/1.1 and HTTP/2 servers over one event loop on Linux, macOS and Windows.

Bare metal

Freestanding builds with inline assembly and volatile access. An ARM64 kernel boots in QEMU.

Inside a C or C++ codebase

A module with a C header drops into an existing engine, one file at a time. That is how it entered ViroReact.
The language

Familiar on the surface.

C's model of memory and data, with the checks and conveniences of a modern language, at no run-time cost.

Sum types, checked to the last case

An enum carries data per variant. Leave a case out of a match and it does not compile.

match parse_port("8080") {
    Port(p)         -> serve(p);
    InvalidRange(n) -> warn(n);
    NotANumber      -> fail();
}

Maths that reads like maths

Bounded generics are monomorphised; operator overloads resolve by operand type and compile to direct calls.

V3 operator +(V3 a, V3 b) { ... }
V3 operator *(V3 v, float s) { ... }

let mid: V3 = (a + b) * 0.5;

async, await and typed channels

One reactor on kqueue, epoll or WSAPoll: the same networking code runs on Linux, macOS and Windows.

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

A standard library for scripts

Fetch over HTTPS, walk a directory, run a command, read JSON and CSV, with modules that ship with the compiler.

let r: Response;
fetch("https://api.github.com/repos/x/y", &r);
defer Response_free(&r);
println(JsonValue_as_cstr(json_get(
    Response_json(&r), "owner.login")));

The compiler is written in Eskiu too: the whole pipeline rebuilds itself to the same output through a three-stage bootstrap. How it bootstraps →

How it compares

Close to C, with what C is missing.

Eskiu keeps C's model of memory and calls, and adds the parts people reach for other languages to get. It is younger than all of these, and says so.

EskiuCZigRustGo
MemoryManual, with deferManualManual, with deferOwnership, checkedGarbage collected
Calling Cextern, structs by value in each target's ABINative@cImportextern "C", bindgencgo
GenericsMonomorphized, interface boundsMacroscomptimeTraitsType parameters
Sum types, exhaustive matchYesNoTagged unionsYesNo
Null safetyOpt-in ?*TNoOptionalsOptionNo
Run a file as a scripteskiuc run, shebangNozig runThrough Cargogo run
async / awaitYesNoThrough std.Io, no keywordsYesGoroutines
Age0.14, youngDecadesPre-1.0Stable since 2015Stable since 2012
Packages

One eskiuc add away.

GPU compute and 3D, machine learning, compression, audio, fonts and JNI. A package that binds a C library brings it along: the first build downloads it and checks its SHA-256, so there is nothing else to install.

Browse the packages → 
$ eskiuc add onnx --git https://github.com/eskiu-lang/onnx --rev v0.1.0
added onnx (commit 550e8aba4d22)
$ eskiuc run            # src/main.esk imports <onnx>
fetching onnxruntime for onnx from https://github.com/microsoft/...
1.31.0
Playground

Try it in the browser.

Edit the program and run it. The server compiles it with LLVM through the same eskiuc run.

⌘/Ctrl + Enter to run
STDOUT

Sandboxed: no network, time- and memory-limited, output capped.

Get started

Three steps to a running program.

  1. 1

    Install

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

    Or brew install eskiu-lang/eskiu/eskiu, or a release archive for Windows.

  2. 2

    Write hello.esk

    import <io>;

println("Hello, Eskiu!");

    A file with statements at the top level runs as a script; larger programs have a main.

  3. 3

    Run it

    $ eskiuc run hello.esk
Hello, Eskiu!

    eskiuc hello.esk -o hello builds a native executable instead.

Read the Book of Eskiu Quickstart

Free and online, from Hello, Eskiu to async and bare metal. Code that compiles with 0.14.0 keeps compiling in every 0.14.x (stability policy).

Labs

How far down it goes.

Experiments with what comes next, and with unusual hardware. Not products, and not all of them serious.

The same Eskiu task app on iOS and Android: a progress card, filters and a list of tasks

One UI for every screen

A reactive UI framework in Eskiu: the same components draw UIKit on iOS, native views on Android and the DOM through WebAssembly. Navigation, motion, overlays, the phone's services and native code, with each change on screen in a third of a second. In preview for 0.13.

Overview →
A New Nintendo 3DS showing a 3D model over the live camera feed

AR on a Nintendo 3DS

A camera-and-gyroscope AR demo on the 3DS's 32-bit ARM11, its logic in Eskiu and its rendering through ViroCore. Built for fun.

Case study →
The Eskiu kernel's shell in QEMU, listing its tasks

A bare-metal ARM64 kernel

Timer interrupts, a scheduler, a heap and a shell, booted in QEMU. A few lines of assembly set up the stack; the rest is Eskiu.

Source →
A note from the developer

A note from the developer

I learned to program with Ruby, but the more I built, the more I found C underneath everything, Ruby and Python included. I came to love its simplicity. Rust and Zig are well made, but for my work they always felt more complicated than they needed to be.

So I wrote the language I wanted: the simplicity of C, with the conveniences I kept reaching for in other languages. Today it builds itself and runs in production at ReactVision. If you build something with it, I would like to hear about it.

I made Eskiu with love and care, and I hope you enjoy it as much as I have enjoyed building it.

Eduardo Dorantes

Eduardo DorantesCreator of Eskiu

The Eskiu mascot, drawn Tiny, a grey tabby cat, with its paws on a table
The mascot

Meet Tiny.

The kitten on every page is drawn from Tiny, the real one: paws on the table, watching what you type.