# What is Bend2?

Last updated 2026-08-04. Canonical: https://bend2.dev/notes/what-is-bend2

Bend2 is the in-development successor to [Bend](https://github.com/HigherOrderCO/Bend), Higher
Order Company's massively parallel programming language. There is no public code as of
2026-08-04, and a countdown posted by creator Victor Taelin
[points at 2026-08-12](https://x.com/VictorTaelin/status/2084361403880870390).

## The claim

Bend2, per Taelin's posts through mid-2026, combines three properties that rarely coexist in one
language: ordinary-looking functional code that parallelizes automatically, a dependent type
system strong enough to state and prove properties of that code, and program synthesis that
generates implementations from sufficiently precise types. Each piece exists somewhere already.
Automatic parallelism exists in array languages, dependent types in Lean and in Higher Order
Company's own [Kind](https://github.com/HigherOrderCO/Kind), synthesis in a decade of research
prototypes. The bet is the composition: a type precise enough to pin down behavior turns
generated code into something a checker can accept or reject, and a runtime that extracts
parallelism on its own makes the accepted code fast without hand-scheduling. None of this is
verifiable against public code yet. This page is a map of claims, each carrying a date.

## Why interaction nets parallelize

Bend2's performance model rests on the same substrate as Bend1's: interaction nets. A program is
a graph, and evaluation is a small fixed set of rewrite rules, each of which touches exactly two
adjacent nodes. Two useful properties fall out of that locality. First, rewrites that share no
nodes cannot conflict, so every independent redex in the graph can fire concurrently without
locks. Second, the rules are confluent, meaning the final result does not depend on the order in
which redexes fire, so a scheduler can hand work to any idle thread, or any idle GPU warp,
without coordination. That is the entire trick behind running an unannotated functional program
across thousands of cores. The price is the constant factor: every step is graph surgery with
real memory traffic, and that cost is where the
[criticism of Bend1 concentrated](https://news.ycombinator.com/item?id=40390287) at its launch.

## The runtime lineage

Bend2 targets the fourth generation of a runtime line that Higher Order Company has been
iterating on since 2022: [HVM1](https://github.com/HigherOrderCO/HVM1), the original lazy
evaluator for interaction combinators, then [HVM2](https://github.com/HigherOrderCO/HVM2), the
strict rewrite that compiled to C and CUDA and carried Bend at its
[May 2024 launch](https://news.ycombinator.com/item?id=40390287), then
[HVM3](https://github.com/HigherOrderCO/HVM3), and now
[HVM4](https://github.com/HigherOrderCO/HVM4), which is public and saw pushes into mid-2026. On
2026-07-18 Taelin [declared the language done](https://x.com/VictorTaelin/status/2078553927268589989)
and [reported](https://x.com/VictorTaelin/status/2078471338755232193) that Bend2's CUDA runtime
had been implemented overnight by a coding model (Anthropic's Fable) from the reference Metal
runtime, reusing most of the existing code, and ran faster than Metal on RTX, a baseline he
put at roughly 10x parallel C for most programs. The engineering read is unglamorous: porting a
runtime against a working reference is a well-specified task, because the reference doubles as
an executable spec and a differential test oracle. The interesting decision was building the
Metal version first.

## What exists in public

Bend2's public footprint, as of 2026-08-04, is an empty repository. `VictorTaelin/Bend2` on
GitHub carries the description "Bend2 - WIP", zero bytes of code, and no branches. There is no
documentation, no binary, no package on any registry, and no license text. The adjacent public
artifacts are [Bend](https://github.com/HigherOrderCO/Bend), which still receives maintenance,
and [HVM4](https://github.com/HigherOrderCO/HVM4). The clearest picture of what remained before
launch is Taelin's own
[2026-03-05 list](https://x.com/VictorTaelin/status/2029567059881857081): HVM4's AOT compiler,
HVM4's GPU runtime, and Bend2-SupGen integration, with the note that once those were ready
"all the rest is trivial". SupGen is the synthesis component's name in his posts.

## Where this goes next

Bend2's release is expected around 2026-08-12. The arithmetic behind that date and its failure
modes are covered in [When does Bend2 release?](/notes/bend2-release-date), the comparison
against what Bend1 actually shipped is in [Bend2 vs Bend1](/notes/bend2-vs-bend1), and
[the front page](/) holds the live yes/no answer. This page gets rewritten against the compiler
the week it ships.