The Alan Programming Language

export fn main {
  // Start a "window" inside of a canvas element
  window(fn (win: Mut{Window}) {
    // Use the canvas named "render"
    win.canvas("render");
    // Disable the normal cursor when over the canvas
    win.cursorInvisible;
  }, fn (win: Mut{Window}) = [
    // On each frame, create a context buffer consisting of the width, height, current run time, and mouse position
    win.width, win.height, win.runtime, win.mouseX, win.mouseY
  ], fn (frame: Frame) {
    // On each frame in the GPU, get the current pixel to render and extract the context
    let id = frame.pixel;
    let width = frame.context[0];
    let height = frame.context[1];
    let time = frame.context[2].asF32;
    let mouseX = frame.context[3];
    let mouseY = frame.context[4];
    // Compute a value that cycles cleanly over 10 seconds of time
    let per10sec = time / 10.0;
    let cycle = 2.0 * abs(per10sec - floor(per10sec) - 0.5);
    // Determine how "bright" the light the mouse "shines" on the current pixel
    let light = 1.0 / gvec2f(abs(mouseX.gi32 - id.x).gf32, abs(mouseY.gi32 - id.y).gf32).magnitude;
    // Compute the RGBA values for the current pixel
    let red = min(1.0, light + cycle * gf32(id.x) / gf32(width));
    let green = min(1.0, light + 1.0 - red);
    let blue = min(1.0, light + gf32(id.y) / gf32(height));
    let alpha = 1.0;
    // Compute the memory location in the framebuffer for the current pixel
    let loc = id.x + (frame.framebuffer.len / height) * id.y;
    // Pack the color values into a single 32-bit integer and store them in the correct location
    // returning this as the only GPU operation to run per frame
    return [frame.framebuffer[loc].store(pack4x8unorm(gvec4f(blue, green, red, alpha))).build];
  });
}

Click "Run" to compile and run the application

GPGPU for the Rest of Us

Alan includes a set of types representing GPU data and a set of GPU functions to work with these types reducing the barrier to entry for general purpose GPU compute.

Most Runtime Errors Impossible

Alan is a statically-typed language founded on the Curry-Howard correspondence used in other solid type systems like Rust or Haskell, but inferred outside of function arguments so it doesn't get in your way.

Clear Code, Traceable Extension

Alan has a syntax with a minimized number of concepts to be as regular as possible, but also allows most syntax to be extended by the developer such that it is explicitly declared in any file that uses it.

Typescript-inspired type syntax but with more solid Rust-like foundations.
Types are just data, functions work on that data. Those are the two foundational parts of the language. The rest is derived from this.
Functions can share the same name, which is called depends on the types of the variables given to it.
Method calls are just a different syntax for function calls.
Properties are just function calls with a single argument.
Operators are just aliases to functions. + is add, for example.
You can declare new operators and their precedence, but only within the current module scope.
Typescript-style operators in the type system are similarly just aliases to generic types. + is Add, for example.
You can declare new type operators and their precedence, similarly limited to the current module scope.
The type system is where compile-time computation happens, so binding platform (Rust or Javascript) types and functions is done in the type system, and so is importing from other modules.
You don't need to ever declare the type of a variable, it will figure it out. But if you do declare the type and it differs from what the compiler thinks it should be, that will cause a compile-time error, so it can still be good to do so to prevent unexpected API changes.