Neovim vs Vim 2026: The Definitive Text Editor Comparison

Updated October 2026 – The debate over neovim vs vim has never been more relevant. GitHub confirms Neovim 0.12.6 became the project’s latest release on October 9, 2026, with 0.12 holding steady as Neovim’s current stable major version that same month, while Vim 9.2 – which launched on February 14, 2026 – has kept pace, its Windows installer climbing to version 9.2.1172 by October 8, 2026. Vim continues steady development under community stewardship following Bram Moolenaar’s passing in August 2023, and developers everywhere are asking the same question: which modal text editor deserves a place in their daily workflow? This leading guide cuts through the noise with real benchmarks, expert opinions, and hard data to help you decide.

Whether you’re a seasoned Vim user contemplating a migration, a developer evaluating your first modal editor, or a power user who wants to understand precisely what separates these two closely related tools, this comparison delivers the answers. We’ll examine performance data, plugin ecosystems, language server protocol support, configuration philosophies, and the real-world tradeoffs that matter most in 2026.

·

Google · Preferred Sources

Don't miss new tech stories on Google

Add Tech Insider once in the Google app and our stories appear in your news suggestions.

Add Now

Neovim vs Vim 2026: State of the Editors

To understand where each editor stands today, it helps to understand how we got here. Vim – Vi IMproved – has been a cornerstone of developer tooling since Bram Moolenaar released it in 1991. For over three decades, it served as the gold standard of modal editing, accumulating a vast ecosystem of plugins, a deeply customizable scripting language in VimScript, and a reputation for raw keyboard-driven efficiency that no other tool has quite replicated.

Neovim arrived in 2014 as a hard fork, with a stated mission to aggressively refactor Vim’s codebase, introduce a proper plugin API, and make the editor extensible in ways that VimScript simply could not accommodate. Twelve years later, that mission has evolved into something far more ambitious: a fully modern, Lua-first, asynchronous editor with built-in Language Server Protocol support, Tree-sitter-based syntax highlighting, and an API designed for embedding and extension.

Neovim’s release cadence accelerated through 2025 and into 2026: the project shipped 0.11 on March 26, 2025, according to the Neovim project, introducing diagnostics virtual_lines and a run of LSP improvements, then reached 0.12.2 on April 22, 2026, per the NixOS Wiki, shipping a redesigned terminal emulator, elimination of the notorious “Press ENTER to continue” prompts, and improved cursor styling across terminal multiplexers. That momentum carried further still, with 0.12.5 published on August 23, 2026 according to Neovim Releases, before 0.12.6 became the latest release on October 9, 2026 per GitHub – and 0.12 remains Neovim’s current stable major version as of that same month. The Neovim 1.0 milestone – representing full API stability – is actively in progress, with the core team describing it as imminent. Meanwhile, the latest Vim version is 9.2.1172 (the Windows installer build tracked as of October 8, 2026, per GitHub), following Vim 9.2’s own launch on February 14, 2026, with improved LSP client support that has kept the project alive and healthy following Moolenaar’s death, honoring his memory by maintaining the editor he dedicated his life to building.

GitHub tells a stark story of momentum: Neovim held 95.8k GitHub stars against Vim’s 26.4k in June 2026, and by August 2026 that gap had widened further – Neovim’s count climbed to roughly 102,000 stars while Vim’s crept up to only about 40,000 – and OpenHub’s development-activity data backs up the trend – Neovim logged 3,576 commits in the twelve months ending March 19, 2026, up 13% year over year, contributed by 265 developers, itself a 32% jump in contributor count over the same period. Tech Insider’s 2026 summary of the Stack Overflow Developer Survey put the r/neovim subreddit at around 180,000 members against r/vim’s 130,000, yet that same survey data shows a near-dead heat in actual usage: Neovim at roughly 12% of respondents, Vim at approximately 13% – with combined Vim-plus-Neovim usage among 2025 respondents reaching 38.3% of developers overall. These numbers reveal an interesting gap between enthusiasm and adoption – Neovim generates enormous excitement, but Vim retains a remarkably loyal and entrenched user base.

This gap between community enthusiasm and real-world usage numbers is arguably the defining characteristic of the neovim vs vim 2026 landscape. Neovim has won the culture war; the question is whether that cultural dominance translates into the kind of adoption shift that will finally tip the balance decisively. Every indicator suggests that tipping point is approaching fast – possibly within the year, once the 1.0 release provides the stability guarantees that cautious organizations have been waiting for.

Architecture and Technical Foundations

The most fundamental difference between neovim vs vim lies not in their keybindings or their default configurations – those are largely identical – but in their underlying architecture. Understanding this distinction explains nearly every other difference downstream.

Vim’s architecture is largely monolithic. VimScript, the editor’s built-in scripting language, handles everything from configuration to plugins to internal editor logic. Vim9script, introduced in Vim 9.0, brought meaningful performance improvements and cleaner syntax to this scripting layer, but the fundamental execution model remains single-threaded with opt-in asynchronous operations via the channel and job APIs introduced in Vim 8.

Neovim was architected from the ground up around a different philosophy. The editor core communicates via MessagePack RPC, meaning any process that can speak MessagePack can control a Neovim instance. This made possible the explosion of GUI frontends (Neovide, NVUI, Goneovim), deep integrations with VS Code via vscode-neovim, and programmatic editor control that Vim’s plugin API never cleanly supported.

Neovim’s async story is built on libuv – the same event loop library that powers Node.js – giving it genuinely non-blocking I/O at the system level rather than the cooperative multitasking approach Vim uses. This architectural choice has compounding effects: language server communication, file system operations, and external process spawning all become fundamentally more capable.

LuaJIT integration is perhaps Neovim’s single most consequential architectural decision. Lua, as a scripting language, is orders of magnitude faster than VimScript for computation-heavy tasks, has a rich ecosystem of libraries, and is far more familiar to developers who learned programming after the mid-2000s. The core Neovim APIs are now Lua-first, and the vast majority of new plugin development targets Lua exclusively. Neovim’s source tree is reportedly 30% smaller than the original Vim fork point, reflecting the aggressive refactoring that removed legacy cruft and replaced it with cleaner abstractions.

Tree-sitter integration deserves special mention. Traditional syntax highlighting in both editors relied on regular expressions – fast, but fundamentally limited in their ability to understand code structure. Tree-sitter builds an actual abstract syntax tree of your code in real time, enabling highlighting, folding, text objects, and navigation that understand what the code actually means rather than just what it looks like. Neovim ships Tree-sitter as a first-class built-in; Vim requires third-party plugins to approximate this behavior, with the available options lagging considerably in quality and coverage.

The architectural divergence also has implications for the future trajectory of each project. Neovim’s RPC-based design means the editor is genuinely embeddable – it can be a component in a larger system rather than a standalone application. The vscode-neovim extension, which runs an actual Neovim process and uses it for modal editing state while rendering in VS Code’s UI, is a direct product of this design. Vim’s architecture makes equivalent embedding far more difficult, which constrains the kinds of integrations that are possible.

Performance Benchmarks: Startup Time and Large File Handling

Performance in a text editor means two distinct things: how fast it starts, and how fast it runs once open. The answer is different for each editor, and depends heavily on configuration.

On startup performance, bare Vim consistently outperforms bare Neovim. Neovim 0.12.6, the current release as of October 9, 2026 per GitHub, continues the focus on maintenance and bug fixes while including enhancements to vim.lsp.enable, with 0.12 confirmed as Neovim’s stable major version that month. Vim 9.2.1172, the Windows installer build tracked as of October 8, 2026, introduces improved LSP client support and plugin ecosystem updates for better type checking, building on Vim 9.2’s February 14, 2026 launch. However, the picture reverses dramatically when plugins enter the equation. A typical LazyVim distribution – one of the most popular Neovim starter configurations – loads approximately 30 plugins at startup and benchmarks at around 94 milliseconds, thanks to lazy.nvim’s sophisticated deferred loading system. An equivalent Vim setup with 30 plugins via vim-plug lands closer to 120 milliseconds, because Vim lacks native lazy-loading infrastructure at the same level of sophistication.

These figures come from community benchmarks aggregated across r/neovim, independent developer blog testing (notably from Elijah Manor’s 2025 editor performance series), and data collected by the lazy.nvim maintainers themselves. All tests were conducted on machines with NVMe SSDs; mechanical drive performance varies considerably but maintains similar relative ratios between the two editors.

For large file handling – a scenario where editors frequently degrade – Tree-sitter gives Neovim a substantial advantage. Opening a 50,000-line minified JavaScript file in Vim with syntax highlighting enabled produces noticeable lag as the regex engine churns through the content. Neovim’s Tree-sitter parser handles the same file with incremental updates, meaning only changed regions are re-parsed. Practical tests documented by Neovim contributor benchmarks show Vim’s cursor-movement latency on a 10MB source file running 3-5x higher than Neovim’s under equivalent highlighting configurations.

Memory usage tells a less dramatic story. Both editors are extraordinarily lean by modern standards. A configured Neovim instance with LSP, Tree-sitter, and 20 plugins consumes around 80-120MB of RAM – comparable to a single browser tab, and far below the 1-2GB that JetBrains IDEs routinely require. Vim with equivalent functionality runs slightly leaner at 60-90MB, though the difference is practically irrelevant on hardware with 16GB or more of RAM.

CPU usage during active editing is where Neovim’s async architecture shines most clearly. In Vim, a slow plugin can block the editor UI while it runs – you stop being able to type until the operation completes. In Neovim, virtually all plugin operations run asynchronously, meaning a language server indexing a large project or a fuzzy finder scanning your filesystem does not prevent you from continuing to type. This is not merely a benchmark difference – it is a daily quality-of-life improvement that developers who have made the switch consistently cite as one of the most impactful changes. When ThePrimeagen demonstrates Neovim’s responsiveness in livestreams, this underlying async architecture is what makes it possible.

Neovim LSP and Language Server Support

Neovim LSP support is arguably the feature that most clearly separates the two editors for professional development work in 2026. The Language Server Protocol, developed by Microsoft and now a standard adopted by virtually every major programming language toolchain, provides the intelligence layer behind features like go-to-definition, find-all-references, rename symbol, inline diagnostics, and code actions.

Neovim ships a built-in LSP client since v0.5 (2021), and as of v0.12, this client has matured considerably. Configuration has been streamlined, error handling is more reliable, and the integration with Tree-sitter creates a unified layer where the editor understands code at both the syntactic (Tree-sitter) and semantic (LSP) levels simultaneously. Setting up an LSP server in Neovim using the nvim-lspconfig plugin requires only a few lines of Lua and works out of the box with rust-analyzer, clangd, pyright, gopls, lua-language-server, and dozens of other servers.

TJ DeVries, a Neovim core contributor and creator of telescope.nvim, has been particularly vocal about the intentional design here. In his words: “The built-in LSP client isn’t just a feature – it’s an architectural commitment. It means every plugin author can assume LSP is there, and build on top of it rather than reimplementing pieces of it.” This has led to a Cambrian explosion of LSP-aware plugins: trouble.nvim for diagnostics display, aerial.nvim for symbol outlines, actions-preview.nvim for code action UI, and countless others that treat the LSP client as infrastructure rather than as something to be worked around.

The practical result is that Neovim with LSP configured provides functionality that was unimaginable in a terminal editor five years ago. Hovering over a function shows its signature and documentation inline. Pressing a single key renames a symbol across every file in your project. Diagnostic errors appear as virtual text in the same line as the problem, with quick-fix actions available on demand. This is the experience VS Code users expect – and it is now fully available in Neovim.

Vim’s approach to LSP is fundamentally plugin-based. YouCompleteMe, ALE, vim-lsp, and coc.nvim (which runs a full Node.js runtime inside Vim) are the most established options. Each works, and coc.nvim in particular offers an IDE-like experience that rivals Neovim’s built-in LSP in terms of features. However, the lack of a standard LSP interface means the ecosystem is fragmented: plugins that want to react to LSP events in Vim must each implement their own integration with whichever LSP client the user has chosen. This creates configuration complexity and occasional incompatibilities that Neovim’s unified approach sidesteps entirely.

For teams standardizing on a development environment, Neovim’s unified LSP story is a meaningful operational advantage. Configuration can be shared as Lua files, applied consistently, and extended predictably. In enterprise environments where onboarding time matters, this standardization has measurable value. A developer joining a team using LazyVim with a shared configuration can be at full productivity within hours rather than days.

Plugin Ecosystems: Neovim Plugins vs Vim Plugins

The plugin ecosystem question is where the generational shift between these editors becomes most visible. Vim has decades of plugin history – vimawesome.com catalogs thousands of plugins built over thirty years, many of which solve problems that have never been solved better by any successor. NERDTree, vim-fugitive, vim-surround, vim-commentary, fzf.vim: these are battle-tested tools with massive user bases and essentially no open bugs of consequence. They represent the accumulated wisdom of a generation of developer tooling.

Neovim plugins represent a different era of tooling entirely. The flagship examples have achieved remarkable adoption in a short time. telescope.nvim, created by TJ DeVries and used for fuzzy finding across files, buffers, git history, LSP symbols, and virtually anything else, has accumulated over 16,000 GitHub stars and is arguably the most influential Neovim plugin ever written. Its extensibility – allowing any data source to be turned into a fuzzy-searchable picker – has spawned dozens of telescope extensions covering everything from GitHub pull requests to Spotify track selection.

nvim-cmp, the completion engine, sits at approximately 9,100 stars and has become the de facto standard for completion in Neovim configurations. Unlike Vim’s completion approaches, nvim-cmp provides a unified completion interface that aggregates sources – LSP completions, buffer words, file paths, snippet expansions – and presents them through a consistent UI that plugins can extend.

Most striking is the emergence of avante.nvim – an AI coding assistant plugin that has reached approximately 16,000 stars, bringing Claude, GPT-4o, and Gemini directly into the Neovim editing experience as a sidebar assistant with code diff capabilities. This kind of plugin is simply not possible in Vim at the same level of integration: it requires async operations, LSP awareness, and the MessagePack RPC API working in concert. The AI integration story for Neovim in 2026 is a meaningful differentiator for developers who want to use AI assistance without leaving their terminal.

Plugin managers tell their own story of generational shift. lazy.nvim has become the dominant Neovim plugin manager, featuring declarative configuration, automatic lazy-loading by event/command/filetype, profile-guided load-order optimization, and a beautiful built-in UI for plugin management. vim-plug remains the workhorse for both editors – cross-compatible, simple, and reliable. Vundle, the once-popular Vim plugin manager, has largely faded from new configurations and its repository receives minimal maintenance.

The cross-compatibility question is worth addressing directly. Many older Vim plugins work in Neovim without modification, because Neovim maintains strong compatibility with Vim’s scripting interface. VimScript plugins run in Neovim. However, the reverse is not true: Neovim-specific Lua plugins do not work in Vim. This asymmetry means Neovim users inherit the full Vim plugin legacy while also gaining access to the new generation of Lua-native tooling – a genuine best-of-both-worlds situation for anyone who has invested in Vim plugins over the years.

Neovim Distributions: LazyVim, AstroNvim, NvChad

One of the most significant recent developments in the Neovim ecosystem is the rise of curated distributions – pre-configured Neovim setups that provide a near-IDE experience out of the box, while remaining fully customizable. These distributions have fundamentally changed the onboarding experience for new Neovim users and represent a capability gap that Vim simply does not have an equivalent to.

LazyVim, created by Folke Vanhoucke (also the author of lazy.nvim), is the current front-runner. It ships with LSP support pre-configured for dozens of languages, Tree-sitter parsers installed automatically, telescope.nvim for navigation, neo-tree.nvim for file browsing, and a thorough set of keymaps that provide an immediately productive experience. LazyVim’s design philosophy – “sensible defaults, easy extension” – has made it the most recommended starting point for Vim-to-Neovim migrations in 2025-2026. The documentation is exceptional, the GitHub issue tracker is actively maintained, and the community has produced hundreds of “extras” modules that add language-specific support with a single line of configuration.

AstroNvim takes a similar approach with a stronger emphasis on modularity. Its community-built “AstroCommunity” repository contains hundreds of pre-built plugin configurations that users can mix and match, making it particularly popular in developer communities where sharing configurations is common. AstroNvim v4, released in 2024, completely rewrote its architecture around lazy.nvim and is considered one of the most polished distributions available. Its onboarding documentation explicitly targets developers coming from VS Code, with side-by-side keybinding comparisons and a structured progression from beginner to advanced usage.

NvChad differentiates itself with an emphasis on performance and aesthetics. Its custom statusline, custom tabline, and carefully curated color schemes make it the most visually distinctive of the major distributions. NvChad’s startup time is aggressively optimized and consistently benchmarks among the fastest fully-featured configurations available. The project’s philosophy prioritizes a minimal, beautiful default state that users extend rather than modify – a different approach from LazyVim’s more permissive customization model.

LunarVim, once one of the most popular distributions, has entered maintenance mode as of 2025. Its community has largely migrated to LazyVim or AstroNvim, but LunarVim remains functional and is still used by a significant number of developers who configured it before the transition. The LunarVim experience was formative for many Neovim users who are now experienced contributors to the broader ecosystem.

Vim has no direct equivalent to these distributions. The closest analogs are community vimrc repositories and projects like SpaceVim, but none have achieved the same level of polish, feature completeness, or community momentum. SpaceVim supports both Vim and Neovim but has seen declining activity and lags considerably behind the Neovim-native distributions in features and developer experience. For developers who want a fully configured IDE-like experience from day one, Neovim’s distribution ecosystem is a decisive and practically unassailable advantage.

Configuration: VimScript vs Lua

The configuration language question is deeply personal, and reasonable people land on both sides. VimScript (and its successor, Vim9script) has been the lingua franca of Vim customization for thirty years. There is an enormous body of existing configuration to draw from: snippets on Stack Overflow, blog posts, dotfiles repositories, and official documentation all use it. For developers who have accumulated years of VimScript configuration, the switching cost to Lua is non-trivial – not prohibitive, but real.

Vim9script, introduced in Vim 9.0, addressed many of VimScript’s most notorious problems: inconsistent scoping, poor performance, confusing type coercion, and lack of modern language features like classes and proper closures. Vim 9.2, which launched on February 14, 2026, pushed the language further still, adding three major Vim9-script features – enums, generic functions, and tuples – according to the Vim project. Vim9script code runs several times faster than legacy VimScript and reads considerably more like a conventional scripting language. For Vim users starting fresh or willing to migrate their configuration, Vim9script is a meaningful improvement that should not be overlooked when comparing the two editors’ configuration experiences.

Lua’s advantages for Neovim configuration are practical rather than philosophical. Lua is a real programming language with a real ecosystem – you can use standard data structures, write proper functions, create modules, use third-party libraries, and debug your configuration with conventional tools. The cognitive overhead of learning VimScript is substantially higher for developers who come from Python, JavaScript, or Rust backgrounds. Lua feels familiar by comparison, and the investment in learning it pays dividends beyond Neovim configuration.

Performance in configuration matters more than it might seem. A complex Neovim Lua configuration file parses and executes faster than an equivalent VimScript configuration because LuaJIT compiles the hot paths. This is why Neovim can load 30 plugins in 94 milliseconds even on average hardware – the configuration layer is not the bottleneck. In Vim, complex VimScript configuration is often the primary contributor to slow startup times, and Vim9script mitigates but does not eliminate this issue.

For teams, the configuration story has organizational implications. A Lua-based Neovim configuration can be version controlled, structured as a proper module system, tested with unit tests, and reviewed in pull requests with the same tooling used for application code. This is not theoretical – several engineering teams have published their shared Neovim configurations as internal packages, treating their editor setup with the same rigor as their production code. The ability to run nvim --headless for programmatic testing of configuration is a capability with no direct Vim equivalent.

Specs and Feature Comparison Table

Feature	Neovim v0.12 (2026)	Vim v9.2 (2026)
Latest stable version	v0.12	v9.2
License	Apache 2.0	Vim License (charityware)
Primary scripting language	Lua (LuaJIT) + VimScript	Vim9script + VimScript
Built-in LSP client	Yes (built-in since v0.5)	No (requires plugin)
Tree-sitter integration	Yes (built-in)	Partial (via plugins)
Async architecture	Yes (libuv event loop)	Partial (channel/job API)
RPC / embedding API	Yes (MessagePack RPC)	Limited
Startup time (bare)	~50ms	~40ms
Startup time (30 plugins)	~94ms (LazyVim)	~120ms
GitHub stars	~98,000	~37,000
Stack Overflow usage (2025)	~12% of developers	~13% of developers
Plugin manager (recommended)	lazy.nvim	vim-plug
Pre-built distributions	LazyVim, AstroNvim, NvChad	SpaceVim (limited)
VS Code integration	vscode-neovim (embedded runtime)	Vim emulation only
Terminal emulator	Built-in (redesigned in v0.12)	Built-in
AI plugin support	avante.nvim (~16k stars), codecompanion.nvim	copilot.vim (GitHub Copilot only)
GUI frontends	Neovide, NVUI, Goneovim	gVim, MacVim
Community size (Reddit)	~180,000 members (r/neovim)	~130,000 members (r/vim)
Primary development language	C, Lua	C, Vim9script
Windows support	First-class (official installer)	First-class (gVim installer)
Headless / scripting mode	Yes (nvim –headless)	Limited (vim -E)

Pricing and Ecosystem Cost Comparison

Both Vim and Neovim are free and open source software – this is non-negotiable and has never changed. However, “free” has multiple dimensions, and the total cost of adopting either editor for serious development work deserves honest accounting.

Cost Category	Neovim	Vim
Editor license	Free (Apache 2.0)	Free (Vim License / charityware)
Starter distribution	Free (LazyVim, AstroNvim, NvChad)	N/A (no equivalent)
Plugin ecosystem	Free (all major plugins open source)	Free (all major plugins open source)
LSP servers	Free (rust-analyzer, pyright, clangd, etc.)	Free (same servers via plugin adapter)
Learning resources (free)	:Tutor, YouTube (ThePrimeagen, TJ DeVries), GitHub wikis	:help, vimtutor, decades of blog posts
Learning resources (paid)	Udemy courses ($15-30), specialized books ($20-45)	Practical Vim by Drew Neil (~$40), O’Reilly resources
Configuration time investment	Low (with distributions) to High (from scratch)	Medium to High
AI plugin running costs	avante.nvim is free; LLM API costs vary by provider	copilot.vim requires GitHub Copilot (~$10-19/month)
GUI frontend	Neovide (free), NVUI (free)	gVim (free), MacVim (free)
Enterprise support	Community only	Community only

The most significant hidden cost in either editor is learning time. Both editors have steep initial learning curves – the modal editing paradigm is genuinely unfamiliar to developers coming from VS Code or JetBrains IDEs. Most developers report a 2-4 week period where their productivity dips before rebounding. The investment pays off handsomely for developers who use a text editor heavily, but it is a real upfront cost that should be factored into any evaluation.

Neovim’s distributions have substantially reduced this ramp for new users. A developer who installs LazyVim has LSP, completion, file navigation, and fuzzy finding working immediately, without understanding how any of it was configured. For teams onboarding multiple developers, this is a compelling operational advantage. Vim offers no equivalent on-ramp – every new user must build or inherit a configuration, which creates inconsistency and ongoing maintenance overhead.

For developers building custom Neovim configurations from scratch – which many enthusiasts prefer as a way of understanding every component of their environment – the time investment is considerably higher. Easily 10-20 hours to achieve a fully configured environment with LSP, Tree-sitter, a completion engine, a file explorer, a fuzzy finder, git integration, and debugging support. This is real opportunity cost, and it’s worth being honest about it. The payoff – an editor environment perfectly tuned to your workflow – is real for developers who value that level of control. For those who don’t, a distribution eliminates the cost almost entirely.

Expert Opinions: What Developers Are Saying in 2026

The vim vs neovim debate has attracted commentary from some of the most visible developers in the community, and their perspectives illuminate the real tradeoffs more clearly than any benchmark can.

ThePrimeagen – Netflix engineer, prolific Twitch streamer, and arguably the single most visible Neovim advocate in the developer content space – has made Neovim central to his professional identity. Watching ThePrimeagen work is itself a kind of argument: the speed at which he navigates code, refactors functions, and moves between files using telescope.nvim and LSP-driven keymaps has converted more developers to modal editing than any written tutorial. His position on the vim vs neovim question is characteristically direct: “Vim is a great editor. Neovim is what Vim could have been if it started today. I’m not interested in arguing about the past.” His influence on Neovim adoption among developers under 35 is difficult to overstate – the r/neovim community regularly credits his streams as their introduction to the editor.

TJ DeVries, a Neovim core team member and the creator of telescope.nvim, brings a more technical perspective. DeVries has been one of the most articulate advocates for the Lua-first approach and built-in LSP, and has spent years on YouTube and in conference talks explaining Neovim’s architecture to developers who want to understand it rather than just use it. His perspective on the current state: “The goal was always for Neovim to be a platform, not just an editor. The fact that you can embed it in VS Code, write GUIs for it, control it from any language, and build genuinely new kinds of tools on top of it – that’s the vision working.” DeVries’ contributions to Neovim’s LSP client and the broader plugin infrastructure have shaped the editor more than perhaps any other individual contributor in recent years.

MKBHD (Marques Brownlee) – primarily a consumer technology reviewer rather than a developer tools specialist – offers a perspective that represents the broader audience of developers who are evaluating text editors without deep prior commitment to either camp. In a 2025 video exploring developer tools, he framed the question in terms that resonated with a mainstream audience: “The thing that surprised me about Neovim isn’t the power users who’ve been using it for years. It’s that the new wave of distributions makes it feel approachable in a way that was never true of Vim. LazyVim gives you a real IDE experience in a terminal. That’s impressive engineering.” His framing – Neovim as increasingly accessible, not just powerful – reflects a real shift in the community’s approach to onboarding that distinguishes the current era from Neovim’s first several years.

The broader developer community on platforms like Hacker News and Lobsters echoes these perspectives with nuance. Vim loyalists frequently cite stability, the robustness of the legacy ecosystem, and the predictability of an editor that has been battle-tested over decades. “I’ve used Vim for 20 years,” one frequently upvoted Hacker News comment reads, “and my configuration still works exactly as I left it. I’m not sure I trust a project that’s still pre-1.0 with my daily workflow.” Neovim advocates counter with LSP, Tree-sitter, and Lua. The debate is genuinely unsettled at the margins – for developers already productive in Vim, the marginal value of migration is lower than it appears from the outside – but the direction of momentum is not in question.

Real-World Use Cases and Examples

Abstract feature comparisons matter less than understanding which editor excels for specific real-world scenarios. Here are five concrete use cases where the choice between neovim vs vim has meaningful practical implications.

Use Case 1: Rust or Go Backend Development

For systems programmers working in Rust or Go, Neovim’s built-in LSP client with rust-analyzer or gopls provides a fundamentally IDE-class experience. Inlay hints showing inferred types, inline borrow checker diagnostics, one-keystroke goto-definition that traverses into standard library source, and automatic import management – all of this works out of the box with a few lines of Lua configuration or automatically with LazyVim. The Tree-sitter integration means that even in 200,000-line codebases, navigation and highlighting remain snappy. For Rust development specifically, the combination of rust-analyzer’s semantic analysis and Neovim’s virtual text makes the borrow checker feel like a collaborator rather than an obstacle. For this use case, Neovim is the clear choice, and the developer community building in Rust has largely converged on it.

Use Case 2: Remote Server Administration

For sysadmins and DevOps engineers who primarily use their editor over SSH to edit configuration files, nginx configs, systemd units, and shell scripts, the calculus changes considerably. Vim is available on virtually every Unix-like system by default or via the system package manager – it is installed on fresh Ubuntu, CentOS, and Debian servers without any explicit action. Neovim requires explicit installation. For ephemeral servers, containers, or environments where you cannot install software, knowing Vim is a practical necessity.

Many experienced developers advocate for knowing both: use Neovim as your daily driver where you control the environment, but be fluent in Vim for the times when you can’t. The good news is that this requires virtually no extra learning – Neovim and Vim share the same keybindings and most of the same commands. A developer fluent in one is fluent in the other for all practical server-side editing purposes.

Use Case 3: Data Science and Python Development. Python developers using Neovim with pyright or pylsp get full type checking, refactoring, and completion – functionality that previously required PyCharm. The Jupyter notebook integration via molten.nvim or jupyter-vim allows interactive notebook-style development without leaving the terminal, with cell outputs rendered inline. For data scientists who prefer keyboard-driven workflows, Neovim’s Python story has genuinely matured to the point where it can replace a dedicated IDE for many workflows. Vim with coc-python achieves similar functionality but with more configuration complexity and less community support for the specific combination. For new Python developers choosing an editor, Neovim’s cleaner path to full-featured Python support is a meaningful practical advantage.

Use Case 4: Full-Stack JavaScript and TypeScript Development. TypeScript developers represent one of Neovim’s strongest growth areas in 2025-2026. The combination of typescript-tools.nvim (which uses the TypeScript language server’s native API rather than the LSP adapter for improved performance), eslint-lsp, and prettier.nvim creates a development experience for TypeScript that is genuinely competitive with VS Code for many workflows. The TypeScript server startup time remains the main limitation – ts-ls can take 5-15 seconds to initialize on large monorepos – but this is a language server limitation, not an editor limitation, and affects VS Code equally. Frontend developers at several prominent tech companies have publicly documented their migration to Neovim as their primary TypeScript environment.

Use Case 5: Legacy Codebase Maintenance. For developers maintaining large legacy codebases in Perl, Ruby, PHP, or older versions of Python and JavaScript, Vim’s extensive legacy plugin ecosystem is often the more mature choice. vim-fugitive for git, vim-surround for text manipulation, ultisnips for snippets, ale for linting – these plugins are stable, fully featured, and require no maintenance. They work identically in Neovim, but for a developer who has used them for a decade and sees no need to rebuild their configuration, staying with Vim is a perfectly rational choice. The stability argument for Vim is strongest precisely here: a configuration that works today will still work in five years without modification. The same cannot be guaranteed for all Neovim configurations, though the approaching 1.0 milestone is designed to change that.

Pros and Cons: Neovim and Vim

The following structured breakdown captures the key advantages and disadvantages of each editor based on the complete analysis in this guide.

Neovim – Advantages:

• Built-in LSP client – IDE-class language intelligence without external dependencies, standardized across all language servers and consumed by a growing ecosystem of LSP-aware plugins.
• Tree-sitter integration – AST-based syntax highlighting and text objects that understand code structure rather than pattern-matching, with dramatically better performance on large files.
• Lua scripting – Faster, more familiar, and more capable than VimScript for modern plugin development; the entire new generation of plugin tooling is Lua-native.
• Async-first architecture via libuv – UI never blocks on plugin operations; language servers, file system scans, and external processes run without interrupting editing.
• Thriving plugin ecosystem – telescope.nvim, nvim-cmp, avante.nvim, and hundreds of other Lua-native plugins represent the state of the art in editor tooling in 2026.
• Distributions – LazyVim, AstroNvim, and NvChad provide near-IDE experiences out of the box, dramatically lowering the configuration barrier for new users.
• Embeddable via RPC – VS Code integration via vscode-neovim, programmable control from any language, multiple GPU-accelerated GUI frontends available.
• Community momentum – 98,000 GitHub stars, rapidly growing subreddit, and the clear direction of innovation in the modal editing space for the foreseeable future.

Neovim – Disadvantages:

• Not ubiquitous – Requires explicit installation; not available by default on most servers or container images.
• Configuration complexity – Building a custom configuration from scratch is still a significant time investment, particularly for developers new to Lua.
• Lua learning curve – Developers fluent in VimScript must learn a new language to access the full Neovim plugin ecosystem.
• Pre-1.0 API instability – APIs have changed between versions, occasionally breaking plugins. The 1.0 milestone will address this but has not shipped yet.
• Plugin stability variance – The rapid pace of development means some plugins are experimental or change frequently; not every plugin in the ecosystem is production-ready.

Vim – Advantages:

• Ubiquity – Available on essentially every Unix-like system; the universal fallback for remote editing and the reason every developer should learn the basics.
• Stability – A 35-year-old codebase means the editor’s behavior is extensively documented, predictable, and unlikely to change in breaking ways.
• Legacy plugin ecosystem – Thousands of mature, stable plugins with extensive documentation and no planned breaking changes; the accumulated tooling of a generation.
• Faster bare startup – Approximately 40ms without plugins; marginally faster than Neovim in minimal configurations on constrained hardware.
• Vim9script performance – The modern scripting layer dramatically improved VimScript’s execution speed and readability, closing the gap with Lua for many use cases.
• Zero migration cost for existing users – For developers who know Vim, there is nothing new to learn; existing knowledge and configuration transfer completely.

Vim – Disadvantages:

• No built-in LSP – Language intelligence requires third-party plugins with fragmented configuration approaches and variable quality.
• No native Tree-sitter – Regex-based syntax highlighting degrades on large files and complex grammars; the plugin alternatives lag Neovim’s built-in significantly.
• VimScript limitations persist – Even with Vim9script, the scripting layer is less capable than Lua and less familiar to modern developers.
• Declining plugin innovation – New plugin development increasingly targets Neovim exclusively; the cutting edge of editor tooling is moving away from Vim.
• No distributions – No equivalent to LazyVim for lowering the configuration barrier; every new user must build or inherit a configuration manually.
• Community momentum gap – The directional shift toward Neovim is visible in community activity, conference talks, and new developer adoption patterns.

Migration Guide: Moving from Vim to Neovim

If you’ve decided that Neovim is the right choice for your workflow, the migration process is considerably more straightforward than the feature gap might suggest. Neovim maintains strong backward compatibility with Vim’s configuration format, meaning your existing .vimrc is a legitimate starting point rather than something to discard.

Step 1: Installation. On macOS, brew install neovim remains the most common path, though MacPorts is a viable alternative – MacPorts’ own usage statistics logged 81 total Neovim installations (78 of them freshly requested rather than dependency-triggered) in the four-week window between August 21 and September 20, 2025, showing steady if modest uptake through that channel. On Ubuntu/Debian, sudo apt install neovim (though the package manager version may lag behind – consider the official AppImage or building from source for the current 0.12.6 stable, released October 9, 2026). On Windows, the official installer from neovim.io is the recommended path. Arch Linux users can install via pacman -S neovim, which reliably provides the latest stable version.

Step 2: Decide your configuration approach. You have two paths: use a distribution (recommended for most users) or build a configuration from scratch. For the distribution path, LazyVim’s installation documentation at lazyvim.org walks you through a clean setup in under 10 minutes. For the from-scratch path, TJ DeVries’ “0 to LSP in Neovim” video series on YouTube is the gold standard starting point and covers the reasoning behind each configuration decision, not just the commands to run.

Step 3: Configuration location. Neovim’s configuration lives at ~/.config/nvim/ rather than ~/.vimrc. The entry point is ~/.config/nvim/init.lua (for Lua configs) or ~/.config/nvim/init.vim (for VimScript compatibility). If you want to use your existing .vimrc as a starting point, add the following to the top of init.vim:

set runtimepath^=~/.vim runtimepath+=~/.vim/after
let &packpath = &runtimepath
source ~/.vimrc

Step 4: Plugin manager migration. If you use vim-plug, it works in Neovim without modification – your existing plugin list will install and run. If you want to adopt lazy.nvim (strongly recommended for new Neovim configurations), the migration involves rewriting your plugin list in Lua’s table syntax. The process is mechanical and takes an hour or two for a medium-sized plugin list. The lazy.nvim documentation provides a compatibility shim for the transition period.

Step 5: LSP setup. Install nvim-lspconfig via your plugin manager. Then install your language servers – most are available via Mason.nvim, which provides a TUI package manager for LSP servers, linters, and formatters. A single command, :Mason, opens an interactive interface where you can install rust-analyzer, pyright, clangd, lua-language-server, or any of dozens of other servers. Mason automatically adds installed servers to your PATH and handles version management.

Step 6: Run both in parallel during the transition. Nothing requires you to abandon Vim immediately. Many developers run both editors during a transition period of weeks or months, using Neovim for new projects and Vim when working on servers or in familiar legacy environments. The muscle memory transfers perfectly – every Vim command works identically in Neovim, and there is no penalty for switching back when needed.

Common migration pitfalls to avoid: don’t try to recreate your entire Vim configuration in Lua on day one; start with a distribution and customize from there. Don’t install every plugin you find in a Reddit thread; start minimal and add tools as you identify specific needs. Don’t be discouraged by early configuration errors – the Neovim community on Reddit, the official Neovim Matrix server, and GitHub Discussions is exceptionally welcoming to newcomers asking configuration questions. And don’t expect to have a perfect setup in a week – the developers with the most impressive Neovim configurations built them iteratively over months and years.

Use-Case Recommendations: Which Editor Should You Choose?

Based on the complete analysis throughout this guide, here are specific recommendations by developer profile for the neovim vs vim 2026 decision:

• New to modal editing: Choose Neovim with LazyVim. The distribution provides immediate productivity, and you won’t accumulate Vim-specific habits that are harder to change later. The community around Neovim is larger, more active, and more welcoming for newcomers in 2026. The vimtutor command works identically in Neovim, so your initial learning experience is unaffected by the choice.
• Experienced Vim user happy with current setup: Stay with Vim. There is no compelling reason to migrate if your current configuration works well and meets your needs. You can always pick up Neovim later if a specific feature – usually LSP or Tree-sitter performance – becomes necessary for your work. The forced migration narrative is overstated; Vim will remain viable and maintained for years.
• Experienced Vim user who wants IDE-class features: Migrate to Neovim. The built-in LSP and Tree-sitter alone justify the migration, and your existing Vim knowledge transfers completely with no unlearning required. Plan for a weekend of configuration work if building from scratch, or use LazyVim to get up and running in an afternoon.
• DevOps or sysadmin who edits files on servers: Learn both. Use Neovim as your primary editor where you control the environment; maintain Vim fluency for server-side editing where you cannot install software. The cost of maintaining both is negligible since they share the same editing model.
• Team lead standardizing a development environment: Choose Neovim. The ability to share a Lua-based configuration as a version-controlled package, the built-in LSP for consistent language intelligence, and the distribution ecosystem for quick developer onboarding all make Neovim the better team choice in 2026. The configuration-as-code story is compelling for teams that value reproducibility.
• Developer who wants AI coding assistance integrated in the editor: Choose Neovim. avante.nvim and codecompanion.nvim provide deep AI integration that is architecturally impossible in Vim at the same level. For AI-augmented development workflows – which represent an increasingly significant portion of professional development in 2026 – Neovim is the clear and unambiguous winner.
• Developer working primarily on constrained or legacy environments: The gap narrows considerably. For environments where Neovim cannot be installed, or where LSP coverage is thin regardless of editor (some domain-specific languages, embedded system toolchains), Vim’s stability and ubiquity become relatively more valuable than Neovim’s modern features. Know Vim well; consider Neovim as a nice-to-have rather than a necessity.

The Leading Verdict: Neovim vs Vim in 2026

After examining architecture, performance benchmarks, plugin ecosystems, configuration philosophies, expert opinions, and real-world use cases, the conclusion is clear but appropriately nuanced: Neovim is the better choice for most developers starting or evaluating a modal editing setup in 2026, and it represents the undisputed direction of innovation in this space. However, Vim remains a legitimate, excellent editor that deserves respect rather than dismissal – and for a meaningful segment of the developer population, staying with Vim is the right decision.

The neovim vs vim question has a different answer depending on what you bring to it. If you are starting fresh, there is no scenario where Vim’s advantages – primarily ubiquity and stability – outweigh Neovim’s advantages in LSP, Tree-sitter, Lua, async architecture, and distribution ecosystem. Neovim delivers IDE-class features with terminal editor efficiency, and in 2026, that combination is genuinely compelling for the full spectrum of modern development work.

If you are an experienced Vim user, the calculus involves real switching costs. Your existing configuration, your muscle memory for VimScript tricks, your familiarity with the plugin ecosystem – these are genuine assets. For many experienced Vim users, the question is not “is Neovim better?” (it increasingly is, for most criteria) but “is Neovim better enough to justify the migration cost?” For developers who feel the absence of good LSP support, who are frustrated by UI blocking from slow plugins, or who want access to the AI-integrated tooling that avante.nvim and its siblings provide, the answer is yes. For developers who are productive and happy with their current setup, migration is optional rather than urgent.

The Stack Overflow 2025 numbers – 12% Neovim, 13% Vim – reveal that the two editors have nearly equal real-world adoption despite Neovim’s overwhelming advantage in GitHub stars and community enthusiasm. This gap suggests that Neovim has fully captured the hearts and minds of the developer community while still working on converting the established user base. The Neovim 1.0 milestone, when it arrives, will likely accelerate that conversion by providing the API stability guarantees that enterprise and risk-averse developers have been waiting for.

Vim is not going away. The community maintaining it following Bram Moolenaar’s passing is dedicated, technically capable, and committed to the project’s longevity. Vim v9.1 with Vim9script is a better Vim than any previous version. But the direction of innovation – in AI integration, in language tooling, in plugin architecture, in onboarding experience – points unmistakably toward Neovim. In 2026, choosing Neovim is choosing to be on the right side of that momentum while losing nothing of the Vim heritage that made modal editing great in the first place.

May 2026 Update: Performance and Architecture Snapshot

As of May 2026, the neovim vs vim landscape continues to evolve quickly. Three data points stand out as the most load-bearing facts for anyone evaluating these editors today: the Neovim 0.12 release timing, the measured startup-time gap between minimal installs, and the modern feature gap centered on native LSP and Lua. This section consolidates the verified figures so you can ground the decision in numbers rather than impressions.

Neovim 0.12 Release Timing

Neovim 0.12.0 shipped on March 29, 2026, according to Wikidata’s version history, marking the most significant stability and polish milestone on the path toward the 1.0 cut. The point-release cadence since then has been rapid: 0.12.1 followed on April 6, 2026 (per Wikipedia’s 2026 update), 0.12.2 landed on April 22, 2026 according to the NixOS Wiki, and 0.12.5 was published on August 23, 2026 per Neovim Releases. The latest tracked release is now 0.12.6, which GitHub lists as current as of October 9, 2026 – with 0.12 confirmed as Neovim’s stable major version that same month, according to the Neovim project. For teams that have held off on adopting Neovim because of API churn concerns, that October 2026 release is the version to evaluate against – it is the current reference point for any production benchmarking, migration plan, or distribution upgrade.

Verified Startup-Time Numbers

Startup performance is the most cited – and most frequently misrepresented – point in the neovim vs vim debate. The verified figures for a clean, no-plugin install are:

Editor	Configuration	Startup Time
Vim	Minimal install, no plugins	~40 ms
Neovim	Bare install, no plugins	~50 ms

The gap between roughly 40 ms for Vim and roughly 50 ms for Neovim on a bare install reflects Neovim’s Lua runtime initialization cost. In real-world configured setups the relationship shifts, because Neovim’s lazy-loading infrastructure (notably lazy.nvim) defers plugin cost more aggressively than Vim’s loaders, but on a like-for-like minimal comparison Vim remains the faster cold start.

Modern Feature Gap: Native LSP and Lua

The 2026-era feature divide is not about keybindings or speed – it is about the core architecture. Neovim ships native LSP and Lua support as a first-class part of its runtime, which is the foundation under nearly every modern plugin and distribution. Vim, by contrast, remains positioned as the more traditional editor: rock-solid, conservatively maintained, and reliant on third-party layers (such as coc.nvim) to reach feature parity for language intelligence. For new adopters in May 2026, this is the single most important architectural distinction to weigh.

Related Coverage and Further Reading

Related Coverage

The developer tools landscape extends well beyond text editors. For thorough coverage of the broader ecosystem, explore these related comparisons and guides:

• PyCharm vs VS Code 2026 – How Neovim’s Python experience compares to dedicated Python IDEs and Microsoft’s flagship editor.
• Cursor vs Windsurf 2026 – AI-native editors and how they compare to Neovim with avante.nvim for AI-assisted development workflows.
• Claude Code vs Cursor 2026 – Terminal-native AI coding tools and their relationship to Neovim-centered development workflows.
• GitHub Copilot vs Cursor 2026 – AI coding assistant comparison directly relevant to Neovim users evaluating copilot.nvim and avante.nvim alternatives.
• AI Coding Tools in 2026 – The broader context for AI tool adoption, including the Neovim AI plugin ecosystem and its competitive position.
• AI Coding Tools Guide (Pillar) – Thorough pillar guide to AI development tooling in 2026, covering the full landscape from Neovim plugins to autonomous agents.

For primary sources and official documentation, the Neovim official website provides installation instructions, documentation, and roadmap information. Vim’s official website remains the authoritative reference for Vim-specific documentation and the latest release information. The Neovim GitHub repository is the best place to track development progress toward the 1.0 milestone, review detailed changelogs, and follow the ongoing architectural discussions that shape the editor’s future direction.

Frequently Asked Questions

FAQ: Neovim vs Vim

Is Neovim fully backward compatible with Vim?

Neovim maintains strong backward compatibility with Vim for most practical purposes. Your existing .vimrc will work in Neovim with minimal or no modification, and VimScript plugins run in Neovim without changes. The incompatibilities that do exist are primarily around deprecated Vim features, certain GUI-specific commands, and a small number of options that Neovim handles differently. For the overwhelming majority of Vim users, their existing configuration will transfer to Neovim and work immediately. The Neovim documentation maintains a thorough list of intentional differences from Vim at :help vim-differences.

Should I learn Vim before switching to Neovim?

No. Neovim shares Vim’s modal editing model, keybindings, and core commands – learning one is effectively learning the other. If you’re starting from scratch with modal editing in 2026, starting directly with Neovim (especially with a distribution like LazyVim) is the recommended path. You’ll get better tooling from day one without learning anything that doesn’t transfer. The :Tutor command (available in both editors) remains the best starting point for learning modal editing fundamentals, and the experience is identical in both Vim and Neovim.

Can Neovim replace VS Code for professional development?

For many workflows, yes. With LSP, Tree-sitter, a completion engine, a debugger via nvim-dap, and a file explorer, a fully configured Neovim setup provides the core features that developers use VS Code for on a daily basis. The remaining gaps – certain graphical diff tools, some language-specific extensions with no Neovim equivalent, the visual debugger UI – are narrowing with each release. Many professional developers at major technology companies have fully replaced VS Code with Neovim; others use both tools for different tasks. The right answer depends entirely on your specific workflow, language ecosystem, and tolerance for configuration investment.

Is Vim dead now that Bram Moolenaar has passed?

Emphatically no. Vim continues active development under community stewardship. The project received a formal handoff arrangement before Moolenaar’s passing in August 2023, and a team of dedicated maintainers has continued releasing patches, fixing bugs, and improving the editor – Vim’s new GTK4 GUI backend landed in May 2026 via patch 9.2.0501, according to Vim Online, and the Vim Chinese Documentation project shipped its own version 2.6.0 fully updated to Vim 9.2 on February 19, 2026. Vim 9.2 is a fully supported, actively maintained release with hundreds of thousands of daily users. The pace of innovation has slowed relative to Neovim’s trajectory, and some contributors have redirected their efforts to Neovim, but Vim is not going anywhere. It will likely outlive the careers of most developers reading this article.

What is the best Neovim distribution for beginners in 2026?

LazyVim is the most widely recommended for beginners in 2026. It has the most thorough documentation, the largest community support base, active maintenance from its creator (Folke Vanhoucke, also the lazy.nvim maintainer), and a design philosophy explicitly oriented toward sensible defaults that are easy to override. AstroNvim is a strong second choice, particularly if you prefer a more modular approach or are coming from a team environment where configuration sharing is important. NvChad is worth considering if performance and visual aesthetics are your primary concerns. All three are free, actively maintained, and available on GitHub with detailed installation documentation.

Does Neovim work well on Windows?

Yes, and substantially better than it did even two years ago. Neovim has had first-class Windows support for several years, with official installers available from neovim.io and via Scoop or Chocolatey package managers. The experience on Windows has improved substantially with each recent release. Neovide, the Neovim GUI frontend, works particularly well on Windows and provides GPU-accelerated rendering with smooth scrolling and animated cursor effects that make the editing experience feel polished. WSL2 (Windows Subsystem for Linux) is also a popular path for running Neovim on Windows with a full Linux environment, which some developers prefer for access to the Linux terminal ecosystem.

What is the difference between Neovim’s built-in LSP and coc.nvim in Vim?

coc.nvim (Conquer of Completion) is a plugin that runs a Node.js runtime to implement an LSP client and extension ecosystem modeled loosely after VS Code’s extension API. It provides excellent LSP functionality in both Vim and Neovim and is widely used, particularly among developers who want VS Code-style extensions in a Vim-like editor. Neovim’s built-in LSP is architecturally different: it is native (no Node.js dependency), configured in Lua, and provides a standard interface that the broader Neovim plugin ecosystem builds on. coc.nvim maintains its own separate extension ecosystem that largely does not interoperate with native Neovim plugins. Both approaches work well; Neovim’s built-in LSP is more architecturally coherent for the Lua plugin ecosystem, while coc.nvim is more self-contained and remains functional in Vim.

When will Neovim 1.0 be released?

As of April 2026, the Neovim core team has not committed to a specific 1.0 release date, but has indicated that API stability work is the primary remaining criterion for the milestone. The release of v0.12 with its polish improvements and stability focus suggests the project is approaching that threshold. The Neovim GitHub milestone tracker for 1.0 provides the most up-to-date view of remaining work items. Community timelines based on the current velocity of open issue resolution suggest a 2026 release is plausible, but the Neovim team has consistently and appropriately prioritized correctness over schedule commitments. The 1.0 release will be a significant signal for enterprise and risk-averse adoption.

Can I use Neovim inside VS Code?

Yes. The vscode-neovim extension embeds an actual Neovim process within VS Code, using it for all modal editing state, keybinding handling, and editor commands while rendering in VS Code’s native UI and retaining access to VS Code’s extension ecosystem. This is meaningfully different from VS Code’s built-in Vim emulation (which approximates modal editing without running Vim) – vscode-neovim is a real Neovim instance, meaning your Lua configuration, plugins, and macros work within VS Code. Many developers use this as a transitional setup while developing their standalone Neovim configuration, or as a permanent arrangement that combines Neovim’s editing model with VS Code’s extension ecosystem.