avante.nvim: a Cursor-shaped layer over Neovim, with a Rust core

A Lua plugin that needs a Rust toolchain to run

The repository description is one line: use Neovim like the Cursor AI IDE. The language badge says Lua, and the Lua is the user-facing surface, but the tree tells a longer story. Alongside `lua/`, `plugin/`, `autoload/` and `ftplugin/` there are `crates/`, `Cargo.toml`, `Cargo.lock`, `build.sh`, `Build.ps1`, a `Makefile` and `.cargo/`. There is also a `py/` directory, `ruff.toml` and `pyrightconfig.json`, which belong to the RAG service rather than to the plugin.

The `Cargo.toml` is the clearest statement of what those crates are for. The workspace is edition 2024 with `rust-version` 1.94, and its members are path dependencies on `avante-tokenizers`, `avante-templates`, `avante-repo-map` and `avante-html2md`. Read the dependency list and the jobs fall out: `tiktoken-rs` at 0.12.0 and `tokenizers` at 0.23.2 for token counting and chunking, `minijinja` at 2.24.0 for templates, `mlua` at 0.12.1 to expose the Rust side to Lua, and `serde` for the plumbing.

That last one, `mlua`, is the hinge of the whole design. The plugin is not calling a local HTTP service for its core editing behaviour, it is loading shared libraries into the Neovim process. The `Makefile` confirms it, building one library per crate and per Lua runtime:

LUA_VERSIONS := luajit lua51

So the cost of this plugin is that it needs a compiler at install time and a matching Rust version, and the cost of skipping the build is that features quietly go missing.

Zen Mode and ACP, which is where the agent actually comes from

The feature list names AI-powered code assistance, one-click application of suggestions, project instruction files, ACP support, many providers, and an optional local RAG. The most interesting entry is ACP, the Agent Client Protocol, listed with codex and gemini as examples.

That single word reframes the project. Avante Zen Mode is described as launching avante so it looks like a typical vibe coding agent CLI while being Neovim underneath, and the README's own argument for it is that by leveraging ACP it has the capabilities of claude code, gemini-cli and codex. In other words the agent loop can be someone else's binary, and avante.nvim supplies the editor surface around it.

The practical consequence is architectural rather than cosmetic. If you point ACP at codex, you get that agent's planning and tool use with Avante's buffers, diffs and apply behaviour. If you configure a provider directly instead, openai, anthropic, mistral, deepseek, ollama and llama-cpp among them, you are running the loop yourself and Avante is doing the prompting and the editing. Two quite different systems sit behind one plugin, and the README does not draw the line between them clearly.

The Zen Mode entry point is also unusually simple: install `contrib/avante` in your PATH, or make an equivalent alias, then type `avante`. Whether that is a good trade depends on how much you care about working inside Neovim's window system.

avante.md as the cheapest feature with the largest effect

Project instruction files get a full section of the README, and they deserve it. A markdown file called `avante.md` by default, placed in the project root, is referenced automatically during interactions, and the filename is configurable.

The README offers a template with a role section and a mission section, and this is what the role half looks like:

### your role

you are an expert senior software engineer specializing in [technology stack]. you have deep knowledge of [specific frameworks/tools] and understand best practices for [domain/industry]. you write clean, maintainable, and well-documented code. you prioritize code quality, performance, and security in all your recommendations.

The recommended mission section is a bulleted list: suggestions that follow established patterns, help debugging by analysis, refactoring for readability, optimisations for performance and scalability, security guidelines, and comprehensive tests. The additional sections suggested are project context, technology stack, coding standards, architecture guidelines, testing requirements and security considerations.

Read as engineering advice, this is competent and slightly generic: it is the kind of file that makes a model behave predictably and will not by itself make it good at your codebase. The honest framing is that `avante.md` gives you a stable place to state the rules you would otherwise retype, and it is the only feature in this repository that requires no build step, no API key and no Rust toolchain to be useful.

Fast Apply, RAG, MCP and the rest of the surface

Beyond the headline items the table of contents runs long: Fast Apply, ACP Support, RAG Service, Web Search Engines, Custom Tools, MCP, Integrations, key bindings, commands and highlight groups. Each has its own section on the project site, which is the right place for detail. What the tree tells you is how much is native.

Fast Apply is the editing primitive: applying a model's suggested changes without hand-merging a diff, and the RAG service is the retrieval layer, described in the README as needing extra configuration to run locally. The Makefile pins how that service is delivered:

RAG_SERVICE_VERSION ?= 0.0.11
RAG_SERVICE_IMAGE := quay.io/yetoneful/avante-rag-service:$(RAG_SERVICE_VERSION)

That is a separately versioned container image, which is worth noticing. RAG is not a Lua table you configure; it is another piece of software with its own version number, pulled by tag. The `py/` directory, `ruff.toml` and `pyrightconfig.json` are how that component is developed and linted, and the v0.2.1 release notes record the RAG work being converted into a uv project.

MCP support and custom tools mean the plugin can reach outside the editor, and web search engines are listed as a provider of external information. Both add failure modes that have nothing to do with Neovim. Worth noting too: the v0.2.1 notes are mostly CI and lint churn, including a change to follow agent locations on `tool_call_update`, which is the kind of detail that only matters if you are watching an ACP agent move through a plan.

Where the README stops and the release cadence starts

The README in this repository is an index with a strong opening. It states the goal, lists features, explains `avante.md` at length, and then links out for installation, usage, key bindings, commands, MCP and integration guides. The actual install instructions, provider configuration keys and the full option list live on the project's documentation site, not in the repository.

What the repository does settle is its engineering standards, and they are unusually strict for a plugin. The workspace lints set `unsafe_code` to warn and `unreachable_pub` to warn at the crate level, and the clippy configuration enables `pedantic` at warn priority with about fifteen pedantic lints explicitly allowed and a block of restriction lints turned on, including `print_stdout`, `print_stderr`, `dbg_macro`, `exit` and `unwrap`-adjacent rules. There is a `.pre-commit-config.yaml`, `stylua.toml`, `.luacheckrc`, `.busted` and a `tests/` directory, plus separate Rust and Lua CI workflows.

The version numbers deserve attention because they are honest about maturity. The releases are `v0.2.1`, `v0.2.2` and `v0.2.3`, the last two published within an hour of each other on 2026-08-27, while the crate workspace declares version 0.2.0. A plugin at 0.2.x with 18,168 stars, 850 forks and 46 open issues, last pushed on 2026-09-19, is popular and young, and the README says as much in its own way with a note that the project is undergoing rapid iterations and that many features will be added successively.

What avante.nvim is not

It is not a language server, and it does not do completion or diagnostics in the LSP sense. The README's list is about conversation, suggestions, applying changes, retrieval and tools. If your problem is that a large Lua codebase has no type information, this plugin will not fix it, and `pyrightconfig.json` in the tree is there for the Python service, not for your code.

It is also not self-contained. Providers are external by definition, ACP means an external agent binary, the RAG path means an external container, and MCP means external tools. A fully local setup exists, with ollama and llama-cpp named as providers and the RAG service as a local image, but even that is several moving parts, and the tokenizers crate means text is chunked locally rather than shipped to a provider for counting.

Against Cursor the comparison is not quite fair, and the README knows it. Cursor is a fork with proprietary model integration and an indexer it controls; avante.nvim borrows an editor and a model you already have. Against other Neovim AI plugins the differentiator is that this one carries real native code and an agent protocol rather than only assembling HTTP calls, which is why the build step exists at all. That bet pays off if you want the ACP route and frustrates you if you wanted a single `require` line.

Editorial conclusion

avante.nvim is a good fit for someone who already lives in Neovim and wants agent-style editing without leaving the editor, particularly because the ACP path lets it defer to codex or gemini rather than owning the agent loop itself. The cost is that it is not a Lua plugin in any light sense: `build.sh`, `Cargo.toml`, a tokenizers crate and a separately versioned RAG container image at `quay.io/yetoneful/avante-rag-service:0.0.11` all have to be present, and the four `libAvante*.so` files are what the plugin actually calls into. If your build must stay pure Lua, or you cannot fetch a Rust toolchain at version 1.94 or newer, this is the wrong plugin. Otherwise start with the `avante.md` file in your project root, since that is the cheapest feature and the one that most changes how the model answers, then decide later whether you want the local RAG service at all.

Frequently asked questions

Official sources

1. avante-corp/avante.nvim on GitHub
2. Issues
3. License: Apache-2.0
4. README
5. Releases