Your Comprehensive Guide to Neovim: From Setup to Productive Editing

Welcome to Neovim, the modern, extensible, and powerful text editor that's taking the developer world by storm! This guide will take you from complete beginner to confidently using Neovim for your daily coding tasks. We'll cover everything from installation and basic setup to core concepts and practical examples.

Why Neovim?

Before we dive in, let's quickly understand why Neovim is so popular and why you might want to learn it:

• Extensibility: Neovim is designed for plugins. Its Lua API makes it incredibly easy for developers to extend its functionality, leading to a rich ecosystem of plugins for everything from language servers to file explorers.
• Speed and Efficiency: Neovim is known for its speed and responsiveness, especially when compared to more resource-intensive IDEs. It's designed to be lightweight and focused on text editing.
• Customization: Neovim is highly customizable. You can tailor every aspect of the editor to perfectly match your workflow, from keybindings to UI elements.
• Community: A vibrant and active community constantly develops plugins, shares configurations, and helps newcomers.
• Modern Features: Neovim incorporates modern features like asynchronous job control, built-in terminal emulation, and Lua configuration, making it a cutting-edge editor.
• Vim Compatibility: Neovim is a fork of Vim and retains strong compatibility. If you're familiar with Vim, you'll feel right at home.

Part 1: Setting Up Neovim - Your Foundation

Let's get Neovim installed and ready to go on your system.

1. Installation

The installation process varies depending on your operating system. Here are common methods:

Linux (Debian/Ubuntu/Similar):

sudo apt update
sudo apt install neovim

Linux (Fedora/CentOS/RHEL/Similar):

sudo dnf install neovim

macOS (Homebrew):

If you don't have Homebrew, install it from https://brew.sh/

brew install neovim

Windows (Chocolatey):

If you don't have Chocolatey, install it from https://chocolatey.org/

choco install neovim

Windows (Scoop):

If you don't have Scoop, install it from https://scoop.sh/

scoop install neovim

From Source (Cross-Platform - Advanced):

You can also build Neovim from source for the latest version or for specific configurations. Refer to the official Neovim GitHub repository (https://github.com/neovim/neovim) for detailed instructions.

Verify Installation:

Once installed, open your terminal and type:

nvim --version

You should see the Neovim version information printed.

2. Configuration File - init.lua

Neovim's configuration is primarily done using Lua files. The main configuration file you'll use is init.lua.

Locate your configuration directory:

• Linux/macOS: ~/.config/nvim/
• Windows: ~\AppData\Local\nvim\ or ~\AppData\Local\nvim-data\ (depending on installation method)

Create init.lua:

If the nvim directory doesn't exist, create it. Inside the nvim directory, create a file named init.lua.

Basic init.lua Example:

Open init.lua with any text editor (even Neovim itself after installation!) and paste the following basic configuration:

-- Basic settings to get started

-- Line numbers and relative line numbers
vim.opt.number = true
vim.opt.relativenumber = true

-- Enable mouse support (optional, but can be helpful initially)
vim.opt.mouse = 'a'

-- Set tab width to 4 spaces and expand tabs to spaces
vim.opt.tabstop = 4
vim.opt.shiftwidth = 4
vim.opt.expandtab = true

-- Enable syntax highlighting
vim.opt.syntax = "on"

-- Set a basic colorscheme (you can change this later)
vim.cmd.colorscheme "default"

-- Example: Map leader key to space (commonly used in Neovim)
vim.g.mapleader = " "
vim.g.maplocalleader = " "

print("Basic Neovim configuration loaded from init.lua!")

Explanation of the Configuration:

• vim.opt.number = true: Enables absolute line numbers.
• vim.opt.relativenumber = true: Enables relative line numbers (numbers relative to the cursor line). This is very helpful for navigation with motions.
• vim.opt.mouse = 'a': Enables mouse support in all modes. While Neovim is primarily keyboard-driven, mouse support can be useful for scrolling and window resizing initially.
• vim.opt.tabstop = 4, vim.opt.shiftwidth = 4, vim.opt.expandtab = true: Configures tabs to be 4 spaces wide and expands tabs to spaces instead of using tab characters. This is generally recommended for code consistency.
• vim.opt.syntax = "on": Enables syntax highlighting, making code more readable.
• vim.cmd.colorscheme "default": Sets the default colorscheme. You can explore other built-in colorschemes later.
• vim.g.mapleader = " ", vim.g.maplocalleader = " ": Sets the leader key to space. The leader key is used as a prefix for custom keybindings. Space is a common and easily accessible leader.
• print("Basic Neovim configuration loaded from init.lua!"): A simple print statement to confirm your init.lua is being loaded when Neovim starts.

Restart Neovim: Close and reopen Neovim (nvim) for these configurations to take effect. You should see "Basic Neovim configuration loaded from init.lua!" printed on startup (you might need to type :messages to see startup messages). You should also see line numbers and the basic colorscheme in place.

Congratulations! You have successfully installed Neovim and set up a basic configuration. Now, let's learn the core concepts.

Part 2: Core Concepts - Mastering the Fundamentals

Neovim (and Vim) are modal editors. This means they operate in different modes, each designed for specific tasks. Understanding modes is absolutely crucial to using Neovim effectively.

1. Modes: The Heart of Neovim

• Normal Mode (Default Mode): This is where you spend most of your time in Neovim. Normal mode is for navigation, commands, and performing actions on text. You cannot directly type text in Normal mode.
  • Entering Normal Mode: Press Esc (Escape key) from any other mode.
• Insert Mode: This mode is for inserting text. This is like a standard text editor mode.
  • Entering Insert Mode: From Normal mode, press i (insert at cursor), a (append after cursor), o (open new line below), O (open new line above), I (insert at beginning of line), A (append at end of line).
  • Exiting Insert Mode: Press Esc.
• Visual Mode: This mode is for selecting text (like highlighting text with your mouse in other editors). You can then perform operations on the selected text (delete, copy, change, etc.).
  • Entering Visual Mode: From Normal mode, press v (character-wise visual), V (line-wise visual), Ctrl+v (block-wise visual).
  • Exiting Visual Mode: Press Esc.
• Command-line Mode: This mode is for entering commands to Neovim. Commands start with a colon :.
  • Entering Command-line Mode: From Normal mode, press :. The cursor will move to the bottom of the screen, and you can type a command.
  • Exiting Command-line Mode: Press Enter to execute the command, or Esc to cancel.

Key Takeaway: Always be aware of which mode you are in. Most actions are performed from Normal mode. New users often struggle because they try to type text in Normal mode. Remember to switch to Insert mode to type text.

2. Basic Navigation (Normal Mode)

Navigation is lightning-fast in Neovim using the keyboard. Learn these fundamental movements:

• Character Movement:
  • h: Move cursor left
  • j: Move cursor down
  • k: Move cursor up
  • l: Move cursor right
  • Mnemonic: Think of hjkl as arrow keys on the home row.
• Word Movement:
  • w: Move to the beginning of the next word.
  • e: Move to the end of the current word.
  • b: Move to the beginning of the previous word.
  • W, E, B: Same as w, e, b but treat words separated by spaces as a single "WORD".
• Line Movement:
  • 0 (zero): Move to the beginning of the current line.
  • ^: Move to the first non-blank character of the current line.
  • $: Move to the end of the current line.
• File Movement:
  • gg: Move to the beginning of the file (first line).
  • G: Move to the end of the file (last line).
  • :number<Enter>: Go to line number number. For example, :50<Enter> goes to line 50.
  • Ctrl+o: Jump back to previous cursor position (after jumps like gg, G, etc.). Ctrl+i jumps forward.
• Scrolling:
  • Ctrl+d: Scroll down half a screen.
  • Ctrl+u: Scroll up half a screen.
  • Ctrl+f: Scroll down a full screen.
  • Ctrl+b: Scroll up a full screen.
• Finding Text:
  • /pattern<Enter>: Search forward for pattern. Press n for next match, N for previous match.
  • ?pattern<Enter>: Search backward for pattern. Press n for next match (backward), N for previous match (forward).

Practice Navigation: Open a text file and practice moving around using these keys in Normal mode. Get comfortable moving without using the arrow keys.

3. Basic Editing (Normal Mode)

Editing in Normal mode is done through commands. Here are essential editing commands:

• Inserting Text (Switch to Insert Mode):
  • i: Insert before the cursor.
  • a: Append after the cursor.
  • o: Open a new line below the current line and enter Insert mode.
  • O: Open a new line above the current line and enter Insert mode.
  • I: Insert at the beginning of the current line.
  • A: Append to the end of the current line.
• Deleting Text:
  • x: Delete the character under the cursor.
  • X: Delete the character before the cursor.
  • dd: Delete the entire current line.
  • dw: Delete word from cursor to word end.
  • db: Delete word from cursor to word start.
  • d$ (d-dollar): Delete from cursor to end of line.
  • d0 (d-zero): Delete from cursor to beginning of line.
• Changing Text (Delete and Insert):
  • c: Change. Similar to d but enters Insert mode after deletion.
  • cc: Change the entire current line (deletes line and enters Insert mode).
  • cw: Change word.
  • c$ (c-dollar): Change from cursor to end of line.
  • c0 (c-zero): Change from cursor to beginning of line.
• Copying and Pasting (Yanking and Putting):
  • yy: Yank (copy) the current line into the default register (clipboard).
  • yw: Yank word.
  • y$ (y-dollar): Yank from cursor to end of line.
  • y0 (y-zero): Yank from cursor to beginning of line.
  • p: Put (paste) the text from the default register after the cursor.
  • P: Put (paste) the text from the default register before the cursor.
• Undoing and Redoing:
  • u: Undo the last change.
  • Ctrl+r: Redo the last undone change.

Combining Motions with Operators:

Many editing commands (like d, c, y) are operators that can be combined with motions (like w, b, $, 0, gg, G). This is incredibly powerful.

For example:

• dw: "delete word" (operator d + motion w)
• c$: "change to end of line" (operator c + motion $)
• yG: "yank to end of file" (operator y + motion G)
• d2j: "delete down 2 lines" (operator d + motion 2j - move down 2 lines)

This combination is what makes Neovim's editing so efficient. You're expressing editing actions as verbs (operators) and nouns (motions/targets).

4. Buffers, Windows, and Tabs - Managing Files

Neovim uses buffers, windows, and tabs to manage files and layouts:

• Buffer: A buffer represents a file loaded into Neovim's memory. A file is always opened in a buffer. You can have multiple buffers open even if they are not visible in windows.
• Window: A window is a viewport onto a buffer. You can split the Neovim screen into multiple windows, each showing a different buffer (or different parts of the same buffer).
• Tab Page: A tab page is a collection of windows. You can think of tab pages as different workspaces within Neovim.

Basic Buffer, Window, and Tab Commands (Command-line Mode):

• Buffers:

  • :ls or :buffers: List all open buffers.
  • :bnext or :bn: Go to the next buffer in the buffer list.
  • :bprev or :bp: Go to the previous buffer in the buffer list.
  • :b <buffername or number>: Switch to buffer by name or number (from :ls). For example, :b main.py or :b 2.
  • :bd <buffername or number>: Buffer delete/unload. Closes the buffer (but doesn't delete the file on disk).
  • :bwipeout <buffername or number>: More forceful buffer delete.

• Windows:

  • :split or :sp: Split the current window horizontally (above and below).
  • :vsplit or :vs: Split the current window vertically (side by side).
  • Ctrl+w w (press Ctrl+w, then w): Switch to the next window (cycle through windows).
  • Ctrl+w h, Ctrl+w j, Ctrl+w k, Ctrl+w l: Move to window left, down, up, right, respectively. (Like hjkl for window navigation).
  • :close or :clo: Close the current window.
  • :only or :on: Close all other windows except the current one.
  • :resize +<number> :resize -<number> :vertical resize +<number> :vertical resize -<number>: Resize windows.

• Tab Pages:

  • :tabnew or :tabn: Create a new tab page.
  • :tabnext or :tabn: Go to the next tab page.
  • :tabprev or :tabp: Go to the previous tab page.
  • :tabfirst or :tabfir: Go to the first tab page.
  • :tablast or :tabl: Go to the last tab page.
  • :tabclose or :tabc: Close the current tab page.
  • :tabonly or :tabo: Close all tab pages except the current one.

Practice File Management: Open multiple files in Neovim (nvim file1.txt file2.py file3.js). Use :ls to see the buffers. Try splitting windows with :sp and :vs, navigate between windows with Ctrl+w w and window directions, and manage buffers with :bn, :bp, and :bd. Experiment with tabs using :tabnew, :tabnext, and :tabclose.

5. The Help System - Your Best Friend

Neovim has excellent built-in help. Learn to use it!

• :help <topic>: Open the help documentation for <topic>. For example:
  • :help motion.txt (Help for motions)
  • :help insert-mode (Help for Insert mode)
  • :help :split (Help for the :split command)
  • :help key-notation (Help for key notation used in documentation, e.g., <C-w> for Ctrl+w)
  • :help index (Top-level help index - good starting point for browsing)

Navigating Help: Help files are opened in a new window. You can navigate them like regular files using all the Normal mode movements. To close the help window, use :close.

Example: Exploring Help

1. Open Neovim.
2. Type :help motions. Press Enter. A help window about motions will open.
3. Use j and k to scroll through the help file.
4. Look for links (often underlined or in a different color). Move your cursor over a link and press Ctrl+] to jump to that linked help section.
5. Press Ctrl+o to jump back to the previous help section.
6. When you are done with the help file, type :close to close the help window.

The help system is invaluable for learning Neovim in depth. Whenever you are unsure about something, use :help.

Part 3: Customization and Plugins - Making Neovim Your Own

Neovim's power truly shines when you start customizing it and adding plugins.

1. Configuration with init.lua (Advanced)

We already created a basic init.lua. Let's expand on it and explore more configuration options.

Common Configuration Options (Add these to your init.lua):

-- More settings in init.lua

-- Indentation settings (already set basics, more control here)
vim.opt.tabstop = 4
vim.opt.softtabstop = 4 -- For better UI feedback with tabs
vim.opt.shiftwidth = 4
vim.opt.expandtab = true
vim.opt.smartindent = true -- Enable smart auto-indenting

-- UI Enhancements
vim.opt.termguicolors = true -- Enable true color support in terminal
vim.opt.cursorline = true     -- Highlight the current line
vim.opt.scrolloff = 8        -- Keep some lines above/below cursor when scrolling vertically
vim.opt.sidescrolloff = 8     -- Keep some columns left/right of cursor when scrolling horizontally

-- Search settings
vim.opt.incsearch = true     -- Incremental search (show matches as you type)
vim.opt.hlsearch = true      -- Highlight search matches

-- Behavior tweaks
vim.opt.clipboard = 'unnamedplus' -- Share clipboard with system (requires +clipboard or +xterm_clipboard feature, check `nvim --version`)
vim.opt.completeopt = 'menuone,noselect' -- Better completion menu behavior

-- Key mappings (we'll cover more later)
-- Example: Map jk to Escape in Insert mode (popular for faster exiting)
vim.keymap.set('i', 'jk', '<Esc>')

-- Example: Reload init.lua quickly (useful during configuration)
vim.keymap.set('n', '<leader>ev', ':luafile %<CR>') -- Leader + ev to edit init.lua
vim.keymap.set('n', '<leader>rv', ':source %<CR>')  -- Leader + rv to reload init.lua

print("Extended Neovim configuration loaded!")

Explanation of Added Options:

• vim.opt.softtabstop: Allows you to use backspace in a more intuitive way when using tabs (even though we are expanding tabs to spaces).
• vim.opt.smartindent: Enables intelligent auto-indenting, which is very helpful for code.
• vim.opt.termguicolors: Enables true color support in the terminal, necessary for many modern colorschemes and plugins.
• vim.opt.cursorline: Highlights the current line with a subtle background.
• vim.opt.scrolloff, vim.opt.sidescrolloff: Keeps a few lines of context above and below/left and right of the cursor when scrolling, making reading code more comfortable.
• vim.opt.incsearch, vim.opt.hlsearch: Enhances search functionality.
• vim.opt.clipboard = 'unnamedplus': Attempts to share the Neovim clipboard with your system clipboard. This often requires Neovim to be compiled with clipboard support.
• vim.opt.completeopt = 'menuone,noselect': Improves the behavior of the built-in completion menu.
• vim.keymap.set('i', 'jk', '<Esc>'): Key mapping (remap). In Insert mode ('i'), when you type jk quickly, it will be replaced with <Esc> (Escape). This is a popular mapping for faster exiting of Insert mode without reaching for the Escape key.
• vim.keymap.set('n', '<leader>ev', ':luafile %<CR>'), vim.keymap.set('n', '<leader>rv', ':source %<CR>'): More key mappings. In Normal mode ('n'), <leader>ev (leader key + ev) will execute the command :luafile %<CR>, which edits the current file as a Lua file (useful for editing init.lua). <leader>rv (leader key + rv) will execute :source %<CR>, which reloads (sources) the current file (reloads init.lua after you save changes). This makes it much faster to edit and test your configuration. Remember, <leader> is space by default in our config.

Reload Configuration: After making changes to init.lua, you can reload it using :source % (from Command-line mode) or using the key mapping we added: <leader>rv (from Normal mode - assuming leader is space).

2. Plugin Managers - Extending Neovim's Power

Plugins are the key to unlocking Neovim's full potential. To manage plugins, you need a plugin manager. Here are a few popular options:

• lazy.nvim: (Lua, modern, fast, recommended for beginners and advanced users) - We'll use this in this guide for its ease of use and performance.
• packer.nvim: (Lua, popular, widely used, robust)
• vim-plug: (Vimscript, simpler, good for basic setups)
• dein.vim: (Vimscript, more complex, powerful)
• paq.nvim: (Lua, minimalist plugin manager)

Using lazy.nvim (Plugin Manager):

1. Install lazy.nvim: Add the following to the very beginning of your init.lua file, before any other configuration:
   

   local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
   if not vim.loop.fs_stat(lazypath) then
     vim.fn.system({
       "git",
       "clone",
       "--depth",
       "1",
       "[https://github.com/folke/lazy.nvim.git](https://github.com/folke/lazy.nvim.git)",
       lazypath,
     })
   end
   vim.opt.rtp:prepend(lazypath)
   

   Explanation: This code snippet checks if lazy.nvim is installed. If not, it clones the lazy.nvim repository into Neovim's data directory. vim.opt.rtp:prepend(lazypath) adds lazy.nvim to Neovim's runtimepath, making it available.

2. Basic lazy.nvim Setup in init.lua: After the installation code, add the following to configure and use lazy.nvim:
   

   require("lazy").setup({
     -- List of plugins will go here
   })
   

   This sets up lazy.nvim. Inside the setup({}) function, you will list your plugins.

3. Installing Plugins: Let's install a simple colorscheme plugin and a file tree plugin for example. Modify your init.lua inside the require("lazy").setup({}) section like this:
   

   require("lazy").setup({
     -- Example plugins:
   
     -- Colorscheme (example: catppuccin)
     { "catppuccin/nvim", name = "catppuccin" },
   
     -- File tree (example: nvim-tree.lua)
     { "nvim-tree/nvim-tree.lua" },
   
     -- More plugins can be added here in the same format
   })
   

   Explanation:

   • We are using a Lua table (list of tables) inside lazy.setup(). Each table represents a plugin.
     • "catppuccin/nvim", name = "catppuccin": Installs the catppuccin/nvim plugin from GitHub. name = "catppuccin" is sometimes needed for colorscheme plugins.
     • "nvim-tree/nvim-tree.lua": Installs the nvim-tree/nvim-tree.lua plugin from GitHub.

4. Install and Update Plugins: After adding plugin configurations to init.lua, restart Neovim. Then, in Neovim, type the command:
   

   :Lazy sync
   

   This command will tell lazy.nvim to download and install the plugins you've listed in your init.lua. You will see progress messages as plugins are installed.

5. Using the Plugins:

• Colorscheme (catppuccin): To activate the catppuccin colorscheme, add this line to your init.lua outside the lazy.setup({}) block, after it:

        vim.cmd.colorscheme "catppuccin"

Reload your config (<leader>rv). Your colorscheme should change to catppuccin.

• File Tree (nvim-tree.lua): To open the nvim-tree file explorer, use the command:

        :NvimTreeToggle

You can also map a keybinding to toggle nvim-tree. For example, add this to your init.lua outside lazy.setup({}):

        vim.keymap.set('n', '<leader>e', ':NvimTreeToggle<CR>') -- Leader + e to toggle nvim-tree

Now, you can press <leader>e (space + e) in Normal mode to toggle the file tree.

Plugin Ecosystem Exploration:

There are thousands of Neovim plugins available. Explore these categories and popular plugins to further extend your Neovim:

• Language Server Protocol (LSP): For code completion, diagnostics, formatting, go-to-definition, etc. (e.g., nvim-lspconfig, mason.nvim, cmp-nvim-lsp). Essential for modern development.
• Treesitter: For more accurate syntax highlighting, code folding, structural editing (e.g., nvim-treesitter/nvim-treesitter). Enhances syntax awareness.
• Completion Framework: For improved auto-completion and suggestion menus (e.g., nvim-cmp).
• Fuzzy Finders: For fast file and buffer searching (e.g., telescope.nvim, fzf.vim).
• Git Integration: For Git status, diffs, blame, etc. (e.g., nvim-fugitive, gitsigns.nvim).
• Themes/Colorschemes: Tons of visually appealing colorschemes (search for "nvim colorscheme" on GitHub).
• Statuslines/Tablines: For enhanced status lines at the bottom and tab lines at the top (e.g., nvim-lualine/lualine.nvim, feline.nvim).
• Linter/Formatter Integration: For automatic code formatting and linting (e.g., null-ls.nvim).
• Snippets: For expanding code snippets (e.g., L3MON4D3/LuaSnip).
• Icons: For adding icons to file tree, statusline, etc. (e.g., nvim-web-devicons).

Finding Plugins:

• GitHub: Search GitHub for "nvim plugin", "neovim plugin", "nvim lua".
• nvim-lua: Awesome Neovim Lua Plugins list.
• vimawesome.com: A large collection of Vim (and mostly Neovim compatible) plugins.

Remember to always read the plugin documentation on its GitHub page to understand how to configure and use it.

Part 4: Easy Examples - Putting It All Together

Let's work through some practical examples to solidify your Neovim skills.

Example 1: Correcting Typos and Basic Editing

1. Open a new file: nvim example.txt

2. Type some text in Insert mode (press i then type):
   

   This is a sentense with some typpos.
   We need to corect them.
   This is a exampl of editing in Neovim.
   

3. Exit Insert mode (Esc). You are now in Normal mode.

4. Navigate to the first typo "sentense": Use hjkl or w to move the cursor to the 't' in "typpos".

5. Correct "typpos" to "typos":

   • Press x twice to delete 'p' and 'p'.
   • Move to the next typo "corect".
   • Press cw to "change word". "corect" will be deleted, and you will enter Insert mode.
   • Type correct.
   • Press Esc to exit Insert mode and return to Normal mode.

6. Correct "exampl" to "example": Use w or l to move to "exampl". Use cw and type example, then Esc.

7. Save the file: :w<Enter>

8. Quit Neovim: :q<Enter>

Example 2: Rearranging Paragraphs using Visual Mode

1. Open a file with multiple paragraphs: Create a file paragraphs.txt and paste in some paragraphs of text. Open it in Neovim: nvim paragraphs.txt.
2. Go to the beginning of the second paragraph: Use navigation to reach the start of the second paragraph.
3. Enter Visual Line mode: Press V. The current line will be selected.
4. Select the entire paragraph: Use j to move down line by line. You will visually select the entire paragraph.
5. Cut (delete and copy) the selected paragraph: Press d. The paragraph is now deleted and copied to the default register.
6. Go to the line where you want to insert the paragraph (e.g., between the first and second paragraph positions in the original order - now between what is the first and second paragraph after deleting).
7. Paste (put) the paragraph: Press p to paste after the current line, or P to paste before the current line.
8. Save the file: :w<Enter>

Example 3: Splitting Windows and Comparing Files

1. Open two files: nvim file1.txt file2.txt
2. Split the window vertically: :vs<Enter> (or :vsplit<Enter>). You now have two windows side-by-side, both showing file1.txt initially.
3. In the right window, switch to the file2.txt buffer: :b file2.txt<Enter>. Now the left window shows file1.txt, and the right window shows file2.txt.
4. Navigate between windows: Ctrl+w w to switch between left and right windows.
5. Compare the files (optional): You can use :diffthis in both windows and then use :diffupdate and :diffget (use :help diff for more details on diff mode, which is useful for visually comparing files). For simple comparison, just visually scan and edit.
6. Close the right window: In the right window, type :close<Enter>. You are back to a single window with file1.txt.

Example 4: Searching and Replacing

1. Open a file with some text: nvim textfile.txt (or use an existing file).
2. Search for a word: /example<Enter>. Neovim will highlight matches for "example". Press n to go to the next match, N for the previous.
3. Replace all occurrences of "example" with "instance":
   • In Command-line mode, type: :s/example/instance/g<Enter>
     • :s - substitute command
     • /example/ - pattern to search for
     • /instance/ - replacement text
     • /g - flag for global replacement (replace all occurrences on the line)
   • To replace all occurrences in the entire file (not just the current line), use :%s/example/instance/g<Enter>
     • :%s - substitute command for the entire file (range %)
4. Undo the replace (if needed): u.

Practice, Practice, Practice!

The key to mastering Neovim is consistent practice. Use Neovim for your daily text editing and coding. Start with simple tasks and gradually incorporate more advanced techniques and plugins as you become comfortable.

Part 5: Further Exploration - Level Up Your Neovim Journey

Congratulations on reaching the end of this guide! You now have a strong foundation in Neovim. Here's how to continue your learning journey:

• Use :help extensively: Whenever you want to learn something new or are unsure how to do something, :help is your first and best resource.
• Explore more plugins: Experiment with different plugin categories and find plugins that enhance your workflow. Start with LSP, Treesitter, and a good completion plugin for coding.
• Read configurations from experienced Neovim users: Look at dotfiles repositories on GitHub (https://dotfiles.github.io/) to see how others configure Neovim. Many users share their init.lua files.
• Join the Neovim community:
  • Reddit: /r/neovim - A great place to ask questions, share configurations, and see what others are doing.
  • Neovim Discourse: https://neovim.discourse.group/ - The official Neovim forum.
  • Matrix/IRC Channels: Find links on the Neovim website.
• Practice Vim Golf: https://vimgolf.com/ - Fun challenges to solve text editing tasks in Vim/Neovim using the fewest keystrokes. A great way to improve efficiency.
• Read articles and watch videos: There are many excellent resources online for learning Neovim, from blog posts to YouTube tutorials.

Enjoy the journey of mastering Neovim! It might seem daunting at first, but with persistence, you'll find it to be an incredibly powerful and efficient tool that can significantly boost your productivity. Happy coding!