Mind-bending new programming language for GPUs just dropped...

A new GPU-focused programming language called Bend is pitching a simple promise: write high-level, Python-like code and get parallel execution “for free,” without manually managing CUDA, blocks, locks, mutexes, or other low-level concurrency details. The pitch matters because parallel computing can turn week-long workloads into shorter runs by spreading work across many CPU cores—or even thousands of GPU cores—but doing that correctly is notoriously hard. Bend’s central claim is that it can automatically run anything that can be parallelized in parallel, avoiding the fragile, error-prone choreography that typically comes with multithreading and GPU programming.

Under the hood, Bend’s approach centers on representing computations as a graph of “interaction combinators,” a structure that organizes the steps of a program into nodes and rewrite rules. When nodes interact, the runtime repeatedly rewrites the computation according to those rules, enabling parts of the work to proceed simultaneously. Once the graph has been fully reduced, results are merged back into the expression returned from the function. This model traces back to interaction combinators research from the 1990s, but Bend wraps it in a higher-level language so developers don’t have to work directly with the underlying runtime.

Bend interfaces with a runtime called the Higher Order Virtual Machine (HVM). The language itself is implemented in Rust and uses syntax described as similar to Python, including a straightforward “Hello World” style example with a main function returning a string. Running code can be done via a command like `bend run`, which—at least by default—uses a Rust interpreter and executes sequentially, like a conventional language.

The performance story shifts when the same algorithm is executed with different backends. Bend reportedly removes the need for explicit loops: instead of a `for` loop, it uses a `fold`, described as a data-type “search and replace” that can consume recursive structures such as lists or trees in parallel. A complementary `bend` keyword is used to construct the recursive data type that `fold` will consume.

In a benchmark-style demonstration, an algorithm that counts and sums values takes more than 10 minutes when run on a single thread. Running the identical code with `bend run-cpu` reportedly uses all 24 CPU threads and drops runtime to about 30 seconds. The same code then reportedly accelerates further on an Nvidia RTX 490 using `bend run-cuda`, reaching roughly 1.5 seconds—without modifying the algorithm. The takeaway is less about a new programming trick and more about a workflow shift: parallelism is treated as a default execution property rather than a manual engineering task.