Bend2 vs Mojo

Last updated 2026-08-04.

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. 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 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 carries mixed licensing: the standard library and kernels have been Apache 2 since March 2024, 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 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 with Metal and CUDA backends, the CUDA one reported 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: 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.

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.