f(x) = σ(Wx + b)∇loss.backward()model.predict(x)torch.nn.Transformerawait fetch('/api')git rebase -i HEAD~3docker compose up -dconsole.log('here')∫f(x)dx∑(i=0→n)O(log n)fn main() -> Result<>SELECT * FROM userskubectl get pods{ ...state, loading }npm run build && deploypipe(filter, map, reduce)env.PROD=true
Codse logo
  • Services
  • Work
  • OpenClaw
  • Blog
  • Home
  • Services
  • Work
  • OpenClaw
  • Blog

Get in touch

Let's build something

Tell us what you're working on. We'll scope it within 48 hours and propose a sprint or retainer that fits.

Quick links

ServicesWorkAI ReadinessOpenClawBlog

Also find us on

GithubFacebookInstagram
Codse© 2026 Codse
Software · AI Agents
Developer Tools
How-To Guides and Tutorials

Embracing Neovim: Your Daily Code Companion

Bibek Bhattarai
Bibek Bhattarai
May 7, 2024

If you think Vim is an outdated text editor with limited functionality, you haven't used it recently.

Vim is a fast, cross-platform, open-source text editor that's been around for decades and remains popular for good reason. It's keyboard-driven, highly configurable, and available on almost every server you'll SSH into.

Fun fact: I'm writing this blog from Neovim.

Why Vim?

Some developers still prefer a terminal-based text editor over VS Code or JetBrains. Here's why:

  • Keyboard-first editing. Your hands stay on the keyboard. No reaching for the mouse to select text, navigate files, or trigger commands.
  • Intuitive shortcuts. Once you learn the grammar (d for delete, w for word, dw to delete a word), commands compose naturally.
  • Fully customizable. You can remap any shortcut, add language-specific bindings, and configure the editor to match your exact workflow.
  • Available everywhere. Vim comes pre-installed on most Linux servers. When you SSH into a production box at 2am, Vim is already there.

What is Neovim?

Neovim (nvim) is a fork of Vim that modernizes the internals while keeping Vim's editing model. It uses Lua for configuration instead of Vimscript, has better plugin architecture, and ships with built-in LSP support. If Vim is the foundation, Neovim is the version built for how developers work today.

Installing Neovim

Neovim runs on Windows, macOS, and Linux. On Windows, using Ubuntu via WSL is the recommended approach.

Check this guide for setting up Ubuntu on Windows.

Installation by platform (I use arch btw):

# Debian/Ubuntu
sudo apt install neovim

# Arch
sudo pacman -S neovim

# macOS (Homebrew)
brew install neovim

Basic editing

Open a file with:

nvim <filename>

Neovim has four main modes:

  • Normal mode: The default. You navigate and issue commands here.
  • Insert mode: Press i to start typing text. Press Esc to return to normal mode.
  • Visual mode: Press v to select text. Useful for copying blocks.
  • Command-line mode: Press : in normal mode to enter commands.

Vim is my favourite text editor. I've been using it for years… I can't figure out how to exit.

The essentials:

  • :q — quit
  • :w — save
  • :q! — quit without saving
  • :wq — save and quit

Configuration

The default Neovim setup works, but it's bare. Configuration lives in ~/.config/nvim/.

Set up the directory and main config file:

mkdir -p ~/.config/nvim
touch ~/.config/nvim/init.lua
nvim ~/.config/nvim/init.lua

Here's a starting init.lua:

local set = vim.opt

-- line numbers
set.relativenumber = true
set.number = true

-- tabs & indentation
set.tabstop = 2
set.shiftwidth = 2
set.expandtab = true
set.autoindent = true

-- line wrapping
set.wrap = false

-- search settings
set.ignorecase = true
set.smartcase = true

-- cursor line
set.cursorline = true

-- colors
set.termguicolors = true
set.background = "dark"
set.signcolumn = "yes"

-- split windows
set.splitright = true
set.splitbelow = true

Adding plugins with lazy.nvim

Plugins are what turn Neovim from a text editor into a full IDE. lazy.nvim is the most popular plugin manager right now — it's fast and handles lazy-loading well.

Add this to your init.lua:

local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not 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)

Then set up your plugin list below it:

local opts = {}
local plugins = {
  -- add plugins here
}
require("lazy").setup(plugins, opts)

For example, to add the OneDark color scheme (navarasu/onedark.nvim):

local plugins = {
  "navarasu/onedark.nvim",
}
require("lazy").setup(plugins, opts)

Then configure the theme:

require('onedark').setup { style = 'darker' }
require('onedark').load()

Is Neovim worth learning?

Depends on what you value. If you want a terminal-based editor that's fast, composable, and endlessly configurable, Neovim is hard to beat. If you want something that works out of the box with zero setup, VS Code is probably a better starting point.

I use Neovim as my daily driver. The initial setup takes time, but once it's configured the way you want, editing feels faster than anything else I've tried.

Resources

  • Vim Cheat Sheet
  • OneDark theme
  • Neovim from Scratch (video)
  • Tips & Tricks (video)

You can check out my dotfiles on GitHub to see how I've set up Neovim.

linux
neovim
software
technology
vim