Bend 2 Editors: VS Code and LSP

Choose a Bend 2 editor by deciding which compiler should check your code. Nuxyel's VS Code extension connects to your installed Bend toolchain and adds proof-oriented workflows. Kbrianps's extension packages a language server with its own compiler snapshot. The standalone server offers another route for editors that speak LSP.

That distinction matters more than a screenshot of colored syntax. An editor can recognize a file without checking it with the compiler you use to build the project.

Sources reviewed October 25, 2026: Nuxyel 1.0.1, kbrianps 0.1.3, published bend2-lsp 0.1.1 and the separate bend2-lsp source update described below. This is a source-and-documentation comparison, not a hands-on compatibility test or a ranking of every Bend extension.

Choose by the work you need to do

The table is a decision aid, not a promise that any particular host works. Check the exact extension ID and release, then the runtime and compiler requirements below. These projects have different settings despite sharing the .bend file extension.

If you are still deciding what to build, start with five Bend 2 projects to explore. This guide addresses the next question: which editing setup fits the way you want to work?

Nuxyel: use your installed toolchain

Nuxyel's Bend 2 extension is the option to examine when you want compiler commands and proof navigation alongside editing. Its documented features include checking, building and running files, plus a Proof Explorer. The extension uses its own language-server implementation; it is not a different skin around don2e4's server.

Its extension ID is nuxyel.bend2-vscode. For compiler-backed operations, Bend must be available in the desktop or remote workspace environment. The 1.0.1 manifest defines the bend2.executablePath setting, which selects the executable or launcher; its default is bend. The separate bend2.executableArgs setting supplies launcher arguments. Those are Nuxyel settings, not configuration for kbrianps.

This makes the installed compiler an explicit part of the setup. It is useful when a repository specifies a toolchain and you want editor operations to call it. It also means that installing the extension alone is not enough to build that repository. Confirm the executable the extension found, especially when a remote workspace has a different environment from your local terminal.

The 1.0.1 support policy declares Bend 2.0.28 or newer within the 2.x major line and VS Code 1.90 or newer. It covers Linux and macOS, with Windows compiler use through WSL or a remote workspace. The documented compiler test matrix names 2.0.28 and 2.0.32. That matrix is narrower than the support policy: it does not establish that every later release was tested.

Compiler diagnostics run on save by default. Parser-backed editing can work in VS Code Web, but compiler, build, execution and process-dependent proof commands require a desktop or remote host. A browser editor opening the file is not evidence that it can launch Bend.

For the project summary and original source, see Bend 2 for VS Code by Nuxyel.

Kbrianps: a packaged editing path

The extension ID is kbrianps.bend2. Its 0.1.3 source manifest declares a dependency on don2e4's bend2-lsp, and its README describes highlighting, diagnostics, hover and formatting through the bundled server. Published metadata is available on Open VSX.

Its appeal is the packaged editing path. You do not need a separate Bend source checkout for that server's diagnostic analysis. But the compiler bundled with the server is a particular source snapshot, not an alias for whichever bend executable your terminal finds. Upgrading your command-line compiler does not, by itself, update the compiler inside the language-server package.

The setting bend.server.path chooses a language-server executable or JavaScript entry point. Leaving it empty uses the extension's bundled server first, then a server on PATH. It does not select the Bend build compiler. Do not paste Nuxyel's executable settings into this extension and expect the same effect.

There is also a runtime boundary worth checking before relying on it. The extension manifest accepts VS Code from 1.82, while the bend2-lsp 0.1.1 manifest declares Node.js 26.9 or newer. We have not tested that combination across editor releases. These declarations alone do not prove that every accepted editor can run the bundled checker, or that installing a newer system Node automatically changes the runtime used inside VS Code.

Evaluate this path for editing feedback, then check the project's build or run separately with the required Bend toolchain. The reviewed extension does not register a standalone application build/run command.

Standalone bend2-lsp: bring your own editor integration

The bend2-lsp project offers the same server outside the kbrianps extension. Its 0.1.1 README includes integration examples for Neovim, Helix and Emacs with Eglot. Those are maintainer examples, not integrations tested for this article.

The standalone package declares Node.js 26.9 or newer. It bundles a Bend compiler and Base library for analysis, so a separate compiler checkout is unnecessary for that purpose. If you already maintain an LSP configuration and want diagnostics, formatting, hover and import navigation without changing editors, this is the route to investigate.

Two limits affect what you should expect. Compiler analysis applies to saved file: documents; an untitled buffer still gets more limited features such as lexical diagnostics and syntax hover. Save the file before judging whether compiler checking is working. Also, the server deliberately does not provide inferred local-variable type hover. Silence over a local variable is not necessarily a broken connection.

Bundled analysis does not mean every project can be checked offline. Missing hash-package imports may be downloaded and cached using the compiler's package configuration. Check that behavior against your environment before opening a project with external package imports. For the package side of that check, follow how to find and check a Bend 2 package import.

Check the server release, not just the repository

As of October 25, npm's latest bend2-lsp is 0.1.1; the repository's 0.2.0 source update is not a published npm release. The npm package metadata and the source manifest at revision ed06027 describe different artifacts. A newer README is not evidence that your installed server includes its changes.

The distinction has a concrete consequence. In issue 4, the extension maintainer reported editor errors for code accepted by Bend 2.0.35: two-argument TCP.listen and UDP.bind calls, plus names absent from the older bundled Base. That report is a reason to compare compiler snapshots before rewriting a working program, not proof that every editor error has this cause.

The October 22 source change vendors Bend 2.0.38 and adds completion, document symbols and folding. Its versioned README also documents named package imports and revised diagnostics. These are source-backed changes, not features we verified in an installed extension. They do not establish that kbrianps 0.1.3 bundles the newer server.

When feedback differs from your terminal:

1. Record the extension version, any custom server path and the compiler version used by the project's own check. Identify which tool produced the first diagnostic.
2. Compare the installed server's package and bundled compiler with the source version you are reading. A repository version bump does not update an installed npm package or VSIX.
3. If evaluating a source build, follow that revision's build instructions and Node.js requirement. Test a small saved file before relying on it. We have not built or installed this source revision for this comparison.

Keep a separately passing terminal check as evidence for that compiler and file. Do not dismiss a real error—or claim the stronger independent --verdict check passed—because a source changelog describes improved diagnostics.

Neovim or a browser: two different starting points

You do not have to configure the standalone language server to edit Bend 2 in Neovim. Nuxyel's native Bend2.nvim plugin is a separate path. Its versioned README describes Lua-based editing without Node.js or a language-server executable. Editing remains available without Bend; compiler-backed checks, builds and proof workflows require an installed Bend 2.0.28 or newer. The documented compiler test matrix covers 2.0.28 and 2.0.32, not every later release.

Choose that path if Neovim is already your editor and you want compiler commands there. The linked profile separates Neovim 0.11 installation options from experimental 0.12+ vim.pack. We reviewed its sources, not a local plugin installation. A native plugin and an LSP client configuration are alternatives to evaluate, not two required installation steps.

If your immediate task is to try Bend 2 without installing a compiler, start with the Bend 2 pocket workshop. Its maintainer README describes a browser editor with the Bend checker, compiler output and proof-hole goals. Our linked profile records the October 30 browser check: a small program returned 42, a wrong type was rejected, and the bundled x + 0 example checked. That dated check is not a test of every later workshop update.

This differs from VS Code Web's parser-backed editing described above: the workshop runs the Bend checker in the page. Its JavaScript execution uses one core, and it cannot run the Lean kernel for the CLI's stronger --verdict check. It is not evidence of native or GPU performance. Follow the profile to its original site, open Examples and try x + 0; the checked path needed no AI key. Optional AI-provider features are separate. Use the project's required local toolchain when you move from a browser exercise to building an application.

Alternative-path sources reviewed November 1, 2026. The VS Code/LSP release comparison above remains the October 25 review; npm's published bend2-lsp was rechecked at 0.1.1 on November 1.

When the editor and terminal disagree

Before changing correct-looking code to satisfy an editor, identify where the message came from. The following is a troubleshooting checklist for your setup, not a claim that we reproduced a failure in these tools.

1. Record the identities. Note the extension publisher, extension version, host mode and project toolchain requirement. “Bend support” is not a precise enough name. Bend 1 and Bend 2 tools may both recognize a .bend filename; the official Bend repository distinguishes the language generations.
2. Identify the checker. With Nuxyel, inspect the selected Bend executable and reported version. With the bundled-server path, inspect the installed server package and its compiler provenance. Do not assume your terminal and editor use the same compiler because both display the word Bend.
3. Use the same saved file. Save your changes, check the project's expected working directory and imports, then compare feedback. An untitled document or unsaved buffer is a different input from the file your terminal reads.
4. Separate editing from execution. Successful formatting demonstrates a formatter response, not a successful build. A missing hover result says little about runtime behavior. Run the project's documented check and build steps separately.

For an initial smoke check, use a small, disposable copy of a file accepted by the project's required compiler. Introduce an obvious syntax error, confirm that diagnostics appear, then restore the file and confirm they clear. This checks that the feedback loop is active; it does not certify complete language compatibility or prove the application correct. Test one extension at a time so competing providers do not obscure the result.

Common questions

Does a Bend 2 language server replace the compiler?

Not for building your application. Don2e4's server bundles a compiler for diagnostic analysis, while Nuxyel calls an installed Bend toolchain for compiler-backed work. Keep the project's own build instructions and compiler requirements as a separate check.

Does a proof explorer guarantee a verified program?

No. A proof interface helps you inspect or invoke proof-related work. Its presence does not establish which checker ran, what properties were stated, or whether every required proof passed. Follow the project's proof procedure and inspect its actual result rather than treating an editor panel as the verdict.

Are these the only Bend 2 editor options?

No. Alongside the two VS Code paths and standalone server, this guide points to a native Neovim plugin and a no-install browser workshop. Browse the developer-tool projects for other editors and integrations, then verify each project's current requirements. Built with Bend is an independent directory, not the vendor of these tools.

How this comparison was checked

We compared release or package metadata with repository documentation and configuration/source wiring. The useful distinction is the path from editor feedback to compiler: installed toolchain versus bundled analysis snapshot. We did not install these extensions, benchmark them, or test the listed host combinations. Links to versioned sources preserve what informed this comparison; upstream requirements can change.

Choose one path, verify it against a small project, then follow the original repository for setup details. If you build another useful Bend 2 tool, submit your project so other developers can find its source.