# Bend2 vs Mojo

Last updated 2026-08-04. Canonical: https://bend2.dev/notes/bend2-vs-mojo/

Bend2 and Mojo make the same promise, high-level code that saturates a GPU, from opposite
directions. Mojo is a shipped systems language that gives you explicit control and compiles the
kernels you write to NVIDIA, AMD, and Apple targets. Bend2 is Higher Order Company's unreleased
language that claims to extract parallelism from ordinary recursive code with no kernels at all,
expected around [2026-08-12](/notes/bend2-release-date/). One of these you can benchmark today.

## What Mojo is

Mojo, the shipped side of this Bend2 comparison, is Modular's systems language, designed under
Chris Lattner (LLVM, Swift, MLIR) and built on MLIR compilation. The syntax is deliberately close to Python and interoperates with it, but
the semantics are systems-grade: value ownership and borrowing in the Rust lineage, `struct`
over `class` for performance-critical code, explicit SIMD types, and compile-time
metaprogramming. GPU work is explicit: you write kernels in Mojo against a
[GPU programming model](https://docs.modular.com/mojo/manual/gpu/intro-tutorial/) of grids,
blocks, and device memory, and one kernel source compiles to PTX for NVIDIA, AMDGPU IR for
ROCm, or Metal for Apple hardware. The [repository](https://github.com/modular/modular) carries
mixed licensing: the standard library and kernels have been Apache 2 since
[March 2024](https://www.modular.com/blog/the-next-big-step-in-mojo-open-source), the compiler
remains closed with a stated target of open-sourcing by the end of 2026, and a "Path to Mojo
1.0" was laid out in December 2025. This is a funded company's product with production users;
the flagship consumer is Modular's own MAX inference platform.

## What Bend2 claims

Bend2 keeps none of those control surfaces, per Victor Taelin's public statements. Programs are
ordinary high-level functional code, and the [HVM4 runtime](https://github.com/HigherOrderCO/HVM4)
evaluates them as interaction nets, where reduction steps are two-node-local and
order-independent, so any idle core or warp takes whatever work exists. There is no kernel, no grid, no memory hierarchy in the
programmer's model. Taelin [declared the language done on 2026-07-18](https://x.com/VictorTaelin/status/2078553927268589989)
with Metal and CUDA backends, the CUDA one
[reported](https://x.com/VictorTaelin/status/2078471338755232193) faster than the Metal
reference on RTX, with a claimed floor of roughly 10x parallel C on most programs. His numbers,
not independently verified, on code nobody outside has run.

## The mechanical difference

Bend2 and Mojo differ on one axis that predicts everything else: who finds the parallelism.
Mojo's answer is you. You decide what becomes a kernel, how work maps onto blocks, when memory
moves, where SIMD applies. That is exactly the control that makes dense, regular,
arithmetic-heavy workloads fast, because their performance lives in memory layout and occupancy,
and no runtime discovers a tiling for you. Bend2's answer is the evaluator. Recursion over a
tree fans out because the branches are disjoint subgraphs, not because anyone scheduled it. That
is the only credible route to parallelizing irregular, pointer-heavy, symbolic work, the kind
where nobody can write the static kernel because the shape of the work emerges at runtime. The
cost is a constant factor that never goes away: every step is graph surgery with real memory
traffic. Bend1 demonstrated both halves of this honestly at its
[May 2024 launch](https://news.ycombinator.com/item?id=40390287): thousand-way parallelism from
unannotated code, and single-core throughput far enough behind C that one tuned core kept pace
with the whole GPU.

## Side by side

Bend2 against Mojo as of 2026-08-04; every Bend2 entry is a claim until code lands.

| | Mojo | Bend2 |
| --- | --- | --- |
| Origin | Modular Inc., Lattner | Higher Order Company, Taelin |
| Status 2026-08-04 | Shipped, pre-1.0, production users | Unreleased, expected ≈ 2026-08-12 |
| Parallelism | Explicit: kernels, grids, SIMD | Claimed automatic: interaction-net evaluation |
| Compilation | MLIR → native, PTX, AMDGPU, Metal | HVM4, AOT to C, Metal and CUDA backends |
| Type system | Static, ownership and borrowing | Dependent types, proofs (claimed) |
| Codegen story | AI-assisted kernel authoring | SupGen synthesis from types (claimed) |
| License | Stdlib Apache 2, compiler closed until ~end 2026 | None published |
| Evidence quality | Benchmarks you can run | Posts you can read |

## Where each wins

Against Bend2, Mojo wins today anywhere you could name the kernel: inference serving, image
pipelines, dense linear algebra, HPC stencils. It is a better answer to "I would have written
CUDA" for anyone whose codebase is Python, and its numerics are full-width IEEE with explicit
SIMD. Bend2, if the claims hold, wins where kernels cannot be named: tree transforms, symbolic
rewriting, search, type checking itself, workloads whose parallelism is real but unschedulable
by hand. Bend1 shipped 24-bit numbers because of its node encoding, and whether Bend2 lifts
that is one of the first things to check at release. The honest asymmetry is maturity.
Mojo's claims are falsifiable this afternoon; Bend2's become falsifiable in about a week. This
page will be rewritten against the released compiler, benchmarks included, when that happens.