Most AI-generated code is only as trustworthy as the person who reads it. Bend flips that model: instead of relying on humans to inspect AI edits, you codify invariants as machine-checkable laws and force every change to come with a proof that those laws still hold. That makes certain classes of mistakes — e.g., “the sum of balances must stay zero” or “players cannot pass through walls” — provably impossible to ship.
What Sets It Apart
- Laws + proofs workflow: developers declare properties in a LAWS.bend file; editors/agents must produce proofs (PROOF.bend) that the code respects those laws before changes are accepted. This turns behavioral constraints into the type system rather than ad-hoc tests.
- Fast checking and native performance: the typechecker doubles as a proof checker optimized for speed (claims of checking files in under a second), and the compiler emits native binaries that aim to run nearly as fast as C on one core and scale across many cores or GPUs via CUDA/Metal targets.
- Parallel-first design: purity, affine values and a divide-and-conquer execution model let the runtime parallelize workloads across CPU and GPU without user-written threads or kernels, simplifying parallelism for throughput-oriented workloads.
Who It's For and Tradeoffs
Great fit if you need high-assurance backend logic or want to integrate AI agents into a development loop but cannot tolerate certain classes of behavioral regressions. It is useful for developers who can invest in formalizing invariants and writing proofs (or prompting agents to do so) and who target Linux/macOS native or GPU-accelerated deployments. Look elsewhere if you need a mature, batteries-included language ecosystem today: Bend is young, expects verbose annotations, lacks many standard libraries (no TLS/HTTP/JSON out of the box), has no f64 floats, limited editor/debugger tooling, and some backends or the checker kernel are still under active development. Windows is not a first-class target.
Where It Fits
Think of Bend as a hybrid of a proof assistant and a systems language: it trades rapid feature-iteration and ecosystem maturity for enforceable correctness guarantees and built-in parallel execution. Use it when provable behavioral invariants matter more than convenience and when you can accept current platform and library limitations.
