export fn main { // Create a buffer of memory on the GPU let b = GBuffer([1.i32, 2.i32, 3.i32, 4.i32]); // Map the values into a new buffer on the GPU let out = b.map(fn (val: gi32) = val + 2); // Read the results back to RAM and print them out.read{i32}.print; } Run

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.