From VsCode to Neovim: How It Started

Introduction

For years, VSCode was my go-to editor. Its rich extension ecosystem and user-friendly interface made it a powerhouse for my day-to-day development. But over time, I found myself craving more speed, customization, and keyboard-driven productivity. That’s when I decided to take the plunge into the world of Neovim.

In this blog post, I share my transition from VSCode to Neovim, exploring the reasons behind the switch, including enhanced customization, lightweight performance, and a deeper command-line experience. Discover the challenges I faced, the benefits I gained, and why Neovim has become my go-to editor for coding.

Why Switch?

One of my biggest productivity bottlenecks was constantly reaching for the touchpad or mouse. Even though VSCode can be configured with VIM keybindings through extensions, it never felt quite right—like Vim was just a guest in someone else's house. I wanted the real thing: a truly native Vim experience, not an emulation layered on top of another editor. Below are some more reasons why I decided to switch.

Performance: Neovim is lightning fast, even with many plugins.

Coming from heavier editors like VSCode or IntelliJ, the difference is immediately noticeable. Neovim starts up in milliseconds, not seconds. Even with a dozen plugins running—LSP servers, syntax highlighting, file trees, and fuzzy finders—it remains responsive. The async architecture means heavy operations don't block the UI, and the efficient Lua runtime keeps everything snappy. When you're jumping between files, searching codebases, or running complex operations, that speed compounds into significant time savings throughout the day.

Customization: Every aspect is tweakable, from keybindings to UI.

Unlike traditional editors with fixed interfaces, Neovim is essentially a text editing engine you can build upon. Want to change how tabs work? Modify the behavior. Don't like the default colorscheme? Create your own or choose from thousands. Need a specific workflow for your language or framework? Write custom functions and keybindings. The configuration is code (Lua), which means you can create conditional logic, share configurations, and version control your entire setup. It's not just customization—it's creating your personalized development environment.

Keyboard-Driven Workflow: Modal editing and commands boost productivity.

The modal editing paradigm initially feels foreign, but it's incredibly powerful once internalized. Instead of reaching for the mouse or arrow keys, you think in terms of text objects and motions. "Delete inside quotes," "change the next three words," "select this entire function"—these become single keystrokes. The command mode lets you perform complex operations with precision, like finding and replacing with regex patterns or running shell commands without leaving the editor. Your hands stay on the home row, reducing repetitive strain and increasing speed.

Learning Opportunity: Understanding my tools at a deeper level.

Switching to Neovim forced me to understand concepts I'd previously taken for granted. What exactly is an LSP server? How do different file types get syntax highlighting? What's the difference between a buffer and a window? This deeper understanding makes me more effective with any editor, not just Neovim. Reading other developers' configurations exposed me to new workflows and tools I never knew existed. The process of building my own setup from scratch taught me about Unix philosophy, dotfiles management, and the importance of understanding your development environment.

Initial Setup

Now firstly I must confess, setting up Neovim is like trying to build a spaceship out of Lego pieces while blindfolded: the endless sea of plugins is equal parts thrilling and overwhelming. Arriving at a configuration that doesn't make you want to toss your keyboard out the window? That's a journey of trial, error, and a pinch of masochism.

Setting up Neovim is more involved than installing VSCode, but that’s where the fun begins. I started with Neovim 0.10+ for Lua support, enabling a modern configuration style.

Plugin Management with lazy.nvim

Instead of VSCode extensions, I use lazy.nvim for plugin management. Here’s how I set it up in my init.lua:

local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not (vim.uv or vim.loop).fs_stat(lazypath) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup("plugins", {})

This gives me fine-grained control over plugins, similar to VSCode extensions, but with more transparency and speed.

My Configuration Highlights

General Options

I keep my main options in a separate file, lua/vim-options.lua, for clarity. Some key settings:

vim.o.tabstop = 2       -- Number of spaces per tab
vim.o.expandtab = true  -- Use spaces instead of tabs
vim.o.softtabstop = 2   -- Number of spaces for editing operations
vim.o.shiftwidth = 2    -- Number of spaces for auto-indentation
vim.o.number = true     -- Show line numbers
vim.g.mapleader = " "   -- Space as leader key

Filetype-Specific Settings

One thing I missed in VSCode was easy filetype-specific configuration. With Neovim, I use autocommands for this:

vim.api.nvim_create_augroup("FileTypeSpecificSettings", {clear = true})

-- Blade specific settings
vim.api.nvim_create_autocmd("FileType", {
  group = "FileTypeSpecificSettings",
  pattern = "blade.php",
  callback = function ()
    vim.bo.tabstop = 2
    vim.bo.expandtab = true
    vim.bo.softtabstop = 2
    vim.bo.shiftwidth = 2
  end
})

-- PHP specific settings
vim.api.nvim_create_autocmd("FileType", {
  group = "FileTypeSpecificSettings",
  pattern = "php",
  callback = function ()
    vim.bo.tabstop = 4
    vim.bo.expandtab = false
    vim.bo.softtabstop = 4
    vim.bo.shiftwidth = 4
  end,
})

This level of control is something I never quite achieved in VSCode.

Challenges & Learning Curve

• Initial Overwhelm: The sheer amount of configuration can be daunting.
• Remembering Keybindings: Modal editing and custom mappings take time to master.
• Plugin Discovery: Finding the right plugins for LSP, completion, and file navigation.

Productivity Boosts

• Speed: Instant startup and response times.
• Custom Workflows: Every keybinding and option is tailored to my habits.
• Minimal Distractions: No mouse required—everything is at my fingertips.

Tips for Others

• Start simple. Get a basic config working, then iterate. Consider using a kickstarter configuration like kickstart.nvim to hit the ground running without getting lost in the weeds.
• Use Lua for configuration—it’s powerful and well-documented.
• Explore the Neovim community for plugin recommendations and advice:
  • Check out Neovim discussions on GitHub
  • Join the Neovim community on Reddit for updates and troubleshooting
  • Follow Neovim users on X (formerly Twitter) and other social platforms
• There are a ton of YouTube videos out there that can guide you through the initial setup—these were, of course, an absolutely massive help to me too 👍.

Conclusion

Switching from VSCode to Neovim has been a rewarding journey. While the learning curve is steeper, the payoff in speed, customization, and satisfaction is worth it. If you’re looking to take control of your editor and boost your productivity, give Neovim a try!

Stay tuned for a future article where I’ll dive deep into my current Neovim configuration and share more tips and tricks!

---

Curious about the details? Check out my full Neovim configuration on GitHub: https://github.com/LarryCodes/nvim-config