Futhark Blog

Functional programming can be a great way to handle parallel programming in a sane way. See the Futhark language [1], for example, that accepts high-level constructs like map and reduce, then converts them to the appropriate machine code, either on the CPU or the GPU. [1] https://futhark-lang.org/

There is also the embedded functional language futhark [0], which compiles numerical kernels to optimized c, ispc, opencl and cuda code. Parallelism is explicit using known constructs (map, reduce,...). Documentation is excellent and there is also a SML style type system, hence you can rely on strong abstractions. [0] https://futhark-lang.org/

A combination of both. This work targets multicore, but execution on the GPU is definitely possible. It's just a different line of research. I'd highly recommend taking a look at Futhark (https://futhark-lang.org/), which has a similar programming model (purely functional and parallel), but targets GPU. The compilation strategy is quite a bit different!

This looks really lovely, I look forward to following the maturation of Ante in the future. I've often thought that the niche of a general purpose low-level FP language was a promising space. The only other langs that fit in there are ATS[1], which is notoriously complex/difficult-to-learn, and Futhark[2], which is more GPGPU/scientific-computing specific. We've got Rust, which is essentially a C-style lang that steals all kinds of goodies from the ML family; it's nice to see Ante as a kind of inverse to this: i.e. an ML style lang that borrows some of the nice bits from traditional imperative langs (and hopefully maintains their performance characteristics). Looking through the language tour there already seem to be a plethora of very sensible/ergonomic design decisions here. The 'loop' and 'recur' keywords are a great feature, making a nice little functional nod towards while loops. As a long-time Haskell user the explicit currying initially turned me off, but after seeing a couple examples I can see how it's actually a very reasonable solution, and moreover the ability to curry out of order is really nice instead of having to use 'flip' or similar combinators (as a side note, the explicit currying reminds me a bit of APL's α and ω arguments in dfns, a feature I'd love to see pop up more). The paired tuples also seem like they'd be a pleasure to use; certainly a bit more flexible than tuples in other ML style langs. Making '.' the pipeline operator is also a smart bit of…

For similar languages / compilers in this area: 1. ISPC [1], the Intel® Implicit SPMD Program Compiler also compiles SIMD programs with branches and other control flow efficiently using predication/masking etc. 2. Futhark [2] compiles nice-looking functional programs into efficent parallel GPU/CPU code. [1]: https://github.com/ispc/ispc [2]: https://futhark-lang.org/

I wondered why https://futhark-lang.org/ would have gone NIM?

There's a niche out there where this kind of technology is appreciated. I can even appreciate the technical challenges in making an array language interpreter run fast! However, unfortunately, the notation is so terse that I can't imagine spending the time to learn this. This looks write-only. Is there an obvious reason to prefer a k-like language like Klong, over e.g. Futhark[0] or Accelerate[1]? [0]: https://futhark-lang.org/ [1]: https://hackage.haskell.org/package/accelerate

Not exactly the approach your describing, but Futhark[0] offers an alternative to CPU execution, it compiles to CUDA or OpenCL to run on GPU (or multi-threaded CPU). [0] https://futhark-lang.org/

Location: US & Europe Remote: No preference Willing to relocate: Yes Technologies: Functional programming, type systems, language design, compilers, parallel programming languages, GPU programming, Haskell. Résumé/CV: See https://rschenck.com Email: See https://rschenck.com I'm a soon-to-be-graduating PhD student at the University of Copenhagen looking for either an industry job or a postdoc. My PhD work has been on the functional array programming language Futhark (https://futhark-lang.org/), including work on the type system (sum types, rank polymorphism) and automatic differentiation. I'm broadly interested in all things type systems/functional programming/compilers/language design. I can work in both the US and the EU without a visa.

The best answer is that you probably don't want to use Futhark for that - it's a specialised, rather restricted language. There are ways to encode irregular arrays, but it's not even remotely as ergonomic as in other languages (it can be plenty fast, however). For a particularly simple example, see https://futhark-lang.org/examples/triangular.html In the future, or in a future similar language, one might well imagine an ability to "box" arrays, like in APL, which would allow true "arrays of arrays" with no restrictions on sizes.

Not for mixed CPU/GPU, but there is the concept of a superoptimizer, that basically brute forces for the most optimal correct code. But it is not practical, besides using for very very short program snippets (and they are usually CPU-only, though there is nothing fundamental why it couldn’t utilize the GPU as well). There is also https://futhark-lang.org/ , though I haven’t tried it, just heard about it.

Futhark (https://futhark-lang.org) is an example of a functional language specifically designed for writing "normal" high-level functional code that compiles to parallel execution.

You might want to look into Futhark https://futhark-lang.org/

Shameless plug for Futhark[0], which you can use to write your computational kernels. The idea is to use functional constructs like map and reduce to express parallel code and let the compiler handle the generation of low-level OpenCL or CUDA. Disclaimer: I've recently finished a PhD focused on memory optimizations in Futhark. [0]: https://futhark-lang.org/ Edit: They do actually mention stuff like Julia and NumPy.

Eh. Most functional languages actually serialize operations pretty linearly in their default evaluation model, which is why they have explicit constructs for parallelism and concurrency. There are some languages that are intended to parallelize implicitly, though. They tend to use keywords like "data-parallel" and "array language" to describe themselves. Futhark is a good example: https://futhark-lang.org/

Probably possible, but you would really need some more concrete information. For some easy experimentation with GPUs I would advise looking at Futhark. It's super easy to setup and get started. https://futhark-lang.org/

I think Futhark[0] is close to that, no? Or what about Co-DFNS[1]? [0]: https://futhark-lang.org/ [1]: https://github.com/Co-dfns/Co-dfns

https://futhark-lang.org/ Is the closest you'll get to that, I think. It took a whole team of big brains to make it, and the author stated it was highly non-trivial to make something like that.

In case anyone else wonders what Futhark means in this context – it’s a programming language: https://futhark-lang.org/ As someone who grew up in Sweden, Futhark to me is a runic alphabet :) https://en.wikipedia.org/wiki/Elder_Futhark

This exact view is why https://futhark-lang.org/ is exciting to me; it's currently designed mainly for GPUs, but a lower-level CPU bytecode could be a new backend for it if CPU developers ever decide to expose it.

At this point Python/Numpy is really the array processing language I prefer to use. You can even use libraries like Cupy to switch the backend from BLAS/LAPACK to Nvidia CUDA libraries, which makes it lightning fast, often improving performance by 100x. And the requirement for arcane runes in Numpy is much less than APL or J. Also the various libraries and functionalities that plug into Numpy is countless and extremely powerful. There's also https://futhark-lang.org/ which might be an improvement in writing array processing kernels.

I wonder is this something that Futhark [0] could be used for? [0] https://futhark-lang.org/ EDIT pleased to discover that the native `bpftrace` language is based on awk!

There's a research language that supports compile-time checking of array dimensions: futhark [1]. It's an interesting language that compiles to CUDA or OpenCL. However it's probably not ready for production (not sure if there's even good linear algebra implementations yet). It does feature interesting optimizations to account for the possible size ranges of the arrays (the development blog is very instructive in that respect). [1] https://futhark-lang.org/

In case anyone is wondering about why this project puts so much importance on things being inlineable, GPUs often don't support function calls or have an extremely shallow return stack. In this way it reminds me of http://futhark-lang.org/ somewhat, though Futhark is explicitly targeted at producing extremely efficient GPU code.

No experience, and not APL; but [0] pops up on my radar now and then. [0] https://futhark-lang.org/

The Futhark language is the closest thing to "APL for the GPU" I'm aware of. https://futhark-lang.org/

There are some attempts, like http://futhark-lang.org/ One problem is that you have to codegen to meager intermediate languages that are fragmented & buggy (OpenCL or GLSL), or go proprietary with just one set of bugs and features (CUDA) but with much limited user base. Also GPU software stacks are very crashy, have roots in the culture of testing all shaders for driver bugs before shipping in apps ("your game/app is buggy and poorly qa'd if user pc crashes") and only recently has been slightly exposed to dynamic workloads by WebGL (which is only a OpenGL ES 2 subset, impls invest major engineering effort to work around driver bugs, and still had/has big crash problems).

Makes me think of http://futhark-lang.org/ in terms of semantics.

You might be interested in https://futhark-lang.org