type	state	title	shortTitle	description	intro	intended-audience	created	modified
doc	published	The No-Nonsense Neovim Guide	Complete Guide	A structured, no‑nonsense handbook for Neovim 0.12+ that teaches you the editor, Lua, configuration, plugins, troubleshooting, and contributing to plugins and Neovim core.	This isn't another config dump. This is a structured learning path that takes you from zero to hero — teaching you not just what things do, but why they're designed that way, when to use them, and how to build your own.	beginner	2026-05-17T13:35:50-0600	2026-05-29T12:00:00-0600

The No-Nonsense Neovim Guide

• The No-Nonsense Neovim Guide
  • Philosophy
  • Who This Is For
  • Learning Paths
    • Quick Tour (1-2 hours)
    • Foundations (1-2 days)
    • Core Plugins (1 week)
    • Advanced Path (1-2 weeks)
    • Troubleshooting Path (2-4 hours)
    • Contributing Path (ongoing)
    • Vim Compatibility Path (2-4 hours)
  • Quick Navigation Tables
    • All Fourteen Chapters
    • Common Tasks and Where to Find Them
  • Version and API Migration Guide
  • The "Why" Behind Every Choice
  • Common Transitions
    • From VS Code
    • From Vim
    • From Emacs
    • Transition Decision Tree
  • Essential Commands Reference
  • Architecture Diagrams
    • Buffer / Window / Tab Relationship
    • Lua Module Lookup Order
    • LSP Request Flow
  • Teaching Structure
  • The Meta-Question: Why Neovim?
  • Next Steps
  • Directory Structure

Your complete companion to mastering Neovim — from "what's a vi?" to "I just submitted a patch to core."

Target: Neovim 0.12+ (NVIM v0.12.2, LuaJIT 2.1.X). All features covered work on 0.10+; fallback notes are provided where APIs differ.

Migration note: Older examples may still show vim.loop or vim.fn.jobstart(), but new configs should prefer vim.uv and vim.system(). The old APIs remain available for backward compatibility.

Companion Documents

• Neovim Learning Path — A structured learning path from "never opened Neovim" to maintainer-level contributor, with chapter dependencies and estimated completion times.
• Chapter Content and Criteria Map — Maps every learning objective and success criterion to the chapters that teach them, organized by track.

Licensing

• Text and documentation are licensed under CC BY 4.0 (see LICENSE).
• Code samples and configuration snippets are licensed under the MIT License (see LICENSE_CODE).

---

Philosophy

Neovim is not a love-it-or-hate-it editor. It's a tool, and like any tool, it rewards investment.

The first week is humbling. You're slower than your old editor. Commands feel arcane. Everything requires more keystrokes than necessary. This is normal.

By week two, something clicks. You're not just typing — you're editing. By month one, you find yourself instinctively reaching for motions and text objects in other applications. By month three, you've customized something just right, and it feels like the editor was built for you.

This documentation is designed to compress that timeline. We'll show you the cliff notes to the six months of "learning how to learn Neovim" so you can spend that time actually being productive.

Three principles guide this entire handbook:

Principle	Meaning
Teach principles, not recipes	Every config choice is explained. You'll understand why an option exists, not just what to paste.
Build from first concepts	Each section starts with the underlying concept, then builds to practical application.
Debug systematically	Troubleshooting chapters teach you to diagnose root causes, not just apply fixes by rote.

---

Who This Is For

If you...	Then...
Have never used Neovim	Start with Getting Started — zero to survival in one sitting.
Have used Neovim casually but want to go deeper	Start with Lua Programming.
Something is broken and you need to fix it	Jump to Troubleshooting.
Want to understand this specific config	Read the docs in order, or jump to Configuration.
Want to troubleshoot systematically	Read Diagnosis Fundamentals.
Want to understand Vim vs Neovim compatibility	Read Vim Compatibility.
Want to build your own plugins	Read Custom Plugins.
Want to contribute to Neovim or the plugin ecosystem	Check out Contributing to Neovim.
Want to migrate from another editor	See Migrations — dedicated guides for VS Code, Vim, and others.
Just want to browse	The Plugin Guides are a great tour of features.

---

Learning Paths

Quick Tour (1-2 hours)

Not ready to commit? Get a feel for what's possible.

1. First Steps — Launch Neovim and survive your first session
2. Installation & Verification — Make sure everything works
3. Directory Structure — See how this config is organized
4. Keymap Fundamentals — Learn the keymap system
5. Lualine — See how the status bar works (it's just Lua!)

TRY THIS: Open Neovim and type :Telescope find_files then press <CR>. Type a few characters of any filename in this project. That's fuzzy finding — powered by ripgrep and Lua, no index needed.

Foundations (1-2 days)

Essential knowledge for anyone customizing Neovim.

1. What Is Vi? — The lineage and philosophy
2. The Modes — Normal, Insert, Visual, and more
3. Essential Commands — The survival kit
4. Startup Flow — Understand how Neovim initializes
5. Lua Programming — Learn Lua (it's easier than you think)
6. Configuration Files — Understand each config file's role
7. Options — Global editor settings explained
8. Autocmds — Event-driven automation

TRY THIS: Run nvim --startuptime /tmp/startup.log then open the log. Every millisecond of startup is accounted for. Now run :checkhealth — Neovim diagnoses itself. These two commands alone will save you hours of guesswork.

Core Plugins (1 week)

The bread and butter of Neovim customization.

1. Treesitter — Grammar-based parsing
2. LSP & Mason — Language server integration
3. Completion — nvim-cmp deep dive
4. Telescope — Fuzzy finding everything
5. Gitsigns — Git integration in the gutter
6. Oil — File explorer done right

TRY THIS: In a git repo, open any file with uncommitted changes. Look at the sign column. Run :Gitsigns blame_line on any line. That's gitsigns — zero-config git awareness.

Advanced Path (1-2 weeks)

For when you want to go beyond configuration.

1. Advanced Overview — What advanced means in Neovim
2. Custom Plugins — Build your own tools
3. Custom Autocmds — Event hooks that do real work
4. LSP Configuration — Beyond the defaults
5. Completion Sources — Extend nvim-cmp
6. Treesitter Queries — Custom syntax highlighting
7. Performance — Profiling and optimization
8. Status Line — Build your own from scratch
9. Advanced Colorschemes — Custom highlight groups

Troubleshooting Path (2-4 hours)

Everything you need to diagnose and fix problems — from "never heard of vi" to "I can debug any issue."

1. Troubleshooting Overview — The complete learning path
2. Getting Started — From zero to survival
3. Diagnosis Fundamentals — Systematic debugging
4. Understanding Architecture — How Neovim works internally
5. Problems by Category — Deep dives into specific issues
6. Community Help — Where and how to ask for help
7. Debugging Tools — :checkhealth, :messages, logging
8. Performance Troubleshooting — Startup time, LSP lag

Contributing Path (ongoing)

Give back to the ecosystem.

1. Motivation — Why contribute?
2. Contributing Overview — Where to start
3. Getting Started — First steps into contributing
4. Learning Path — From beginner to expert
5. Plugin Development — Build, publish, extend
6. Core Development — Contribute to Neovim itself
7. Community — Find help, give help, belong

Vim Compatibility Path (2-4 hours)

For users who work with both Vim and Neovim.

1. Differences — Core technical differences
2. Plugin Compatibility — Which plugins work where
3. Configuration Sharing — Share config between Vim and Neovim

---

Quick Navigation Tables

All Fourteen Chapters

#	Chapter	What You'll Learn	Start Here
01	Getting Started	Installation, first steps, startup flow, verification	README
02	Lua Programming	Lua from scratch through advanced FFI and metatables	README
03	Configuration	Every config file, options, autocmds, lazy-loading	README
04	Keymaps	Modes, leader keys, remapping, plugin keymaps	README
05	Plugins	Lazy.nvim, LSP, Treesitter, Telescope, completion	README
06	Languages	Language-specific configuration and tooling	README
07	Workflows	Daily workflows and development patterns	01-daily.md
08	VimScript	VimScript fundamentals for legacy compatibility	README
09	Vim	Vim vs Neovim differences and compatibility	README
10	Advanced	Custom plugins, LSP config, Treesitter queries, performance	README
11	Troubleshooting	Systematic debugging, common problems, community help	README
12	Contributing	From motivation to submitting PRs to core	README
13	Quick Reference	Command reference and motion cheat sheets	Commands
14	Migrations	VS Code, Vim, and other editor transition guides	VS Code

Common Tasks and Where to Find Them

I want to...	Go here
Install Neovim from scratch	Installation
Understand what each config file does	Configuration Overview
Change a setting (tab width, line numbers, etc.)	Options Overview
Add a new keybinding	Keymap Syntax
Install a plugin	Lazy.nvim Guide
Set up autocompletion for a new language	LSP Guide
Fix a plugin that won't load	Plugin Not Loading
Debug a Lua error	Lua Errors
Write a custom colorscheme	Advanced Colors
Profile Neovim startup time	Config Performance
Write my own plugin	Building Plugins
Submit a bug report to Neovim core	Bug Reports
Move from VS Code to Neovim	VS Code Migration
Learn Lua for the first time	Lua Beginner

---

Version and API Migration Guide

Target version: Neovim 0.12+ (NVIM v0.12.2, LuaJIT 2.1.X)

This guide targets Neovim 0.12 as the baseline. All features work on 0.10+, and sections that require specific versions are clearly marked.

API	Pre-0.10	0.10+	0.12+ (Recommended)
Event loop	vim.loop	vim.uv	vim.uv
Job control	vim.fn.jobstart()	vim.system()	vim.system()
Iteration	vim.tbl_map()	vim.iter()	vim.iter()
In-process LSP	Manual handlers	vim.lsp.client()	Built-in + vim.lsp.config()
Terminal	vim.fn.termopen()	vim.fn.termopen()	vim.system() for one-shots
TUI	Legacy :terminal	:terminal improved	Full kitty/image protocol

Rule of thumb: If you see vim.loop in code, replace it with vim.uv. If you see vim.fn.jobstart(), prefer vim.system() for new code. Both old APIs remain functional — this is forward-looking guidance, not a breaking change.

---

The "Why" Behind Every Choice

This config isn't just "plugins I like." Every decision has reasoning.

Choice	Why	When to Change
space-vim-dark theme	Minimal, readable, consistent with terminal aesthetic	Switch to any Nerd Font-compatible theme
Telescope over fzf-lua	More pickers out of the box, simpler config	Use fzf-lua if you prefer fzf over ripgrep
oil.nvim over nvim-tree	Lower resource usage, better integration	Use nvim-tree if you prefer a sidebar
nvim-cmp over coq_nvim	More configurable, no background processes	Use coq_nvim for zero-config completion
Neovim's built-in LSP over coq/lsp	Native integration, no extra dependencies	No reason to change
relative line numbers	Essential for vertical navigation	Use nonu if it bothers you in the terminal
Lua over VimScript for config	Type-checked, faster, better tooling	None — VimScript is still supported for one-liners

---

Common Transitions

From VS Code

VS Code Concept	Neovim Equivalent	Learn More
Extensions	lazy.nvim plugins	Plugin Management
IntelliSense	LSP + nvim-cmp	LSP
Command Palette	Telescope	Telescope
GitLens	gitsigns.nvim	Gitsigns
Live Server	markdown-preview.nvim	Markdown
Settings JSON	init.lua, options.lua	Configuration

TRY THIS: Former VS Code user? Open the command palette (<leader>ff or :Telescope commands) and search for anything you used to do with Ctrl+Shift+P. Nearly everything has a Telescope picker equivalent.

From Vim

Vim Concept	Neovim Enhancement	Learn More
.vimrc	init.lua	Startup Flow
vim-plug	lazy.nvim	Plugin Management
YouCompleteMe	nvim-cmp + LSP	Completion
ALE	LSP + none-ls	LSP
Netrw	oil.nvim	Oil
Want to use both?	Compatible plugins, shared config	Vim Compatibility

TRY THIS: If you have an existing .vimrc, run :scriptnames to see what's loaded, then check the Differences page to translate VimScript patterns to Lua equivalents.

From Emacs

Emacs Concept	Neovim Equivalent	Learn More
Evil mode	Neovim IS the modal editor	Keymaps
package.el	lazy.nvim	Plugin Management
Org mode	taskpaper.nvim / custom	Custom Plugins
Magit	gitsigns + vim-fugitive	Gitsigns
IDE features	LSP + Treesitter	LSP

Transition Decision Tree

Starting editor?
  |
  |- Never used a terminal editor?
  |     `- Start with: 11-troubleshooting/01-getting-started/
  |         1. What Is Vi
  |         2. The Modes
  |         3. Essential Commands
  |         4. The Help System
  |         5. Common First Struggles
  |     `- Then: 01-getting-started/ for installation and setup
  |
  |- Coming from VS Code / JetBrains?
  |     `- 14-migrations/01-vscode.md for concept mapping
  |     `- 04-keymaps/ for the modal mindset shift
  |     `- 05-plugins/guides/ for IDE feature equivalents
  |
  |- Coming from Vim?
  |     `- 09-vim/02-differences/ for what changed
  |     `- 03-configuration/ for the Lua way
  |     `- 05-plugins/getting-started/02-lazy.md for plugin manager migration
  |
  `- Coming from Emacs?
        `- 14-migrations/03-other-editors.md for concept mapping
        `- 04-keymaps/ to formalize modal editing habits
        `- 10-advanced/ for DIY extensibility

---

Essential Commands Reference

Command	What It Does
:Lazy	Open lazy.nvim plugin manager UI
:Lazy sync	Install, update, and clean all plugins
:Mason	Open Mason LSP server manager
:checkhealth	Run all diagnostic checks
:checkhealth <plugin>	Run diagnostics for a specific plugin
:Telescope find_files	Fuzzy-find files in the project
:Telescope live_grep	Full-text search across project
:Telescope buffers	Switch between open buffers
:Telescope help_tags	Search Neovim's built-in help
:InspectTree	View Treesitter syntax tree at cursor
:messages	View recent messages and errors
:LspInfo	Show attached LSP clients and capabilities
:TSInstall <lang>	Install Treesitter parser for a language
:nmap <leader>	List all leader key mappings
:verbose map <key>	Show what set a particular mapping
:scriptnames	List all sourced script files in order
<leader>ff	Find files (Telescope)
<leader>fg	Live grep (Telescope)
<leader>fb	Switch buffers (Telescope)
<leader>fh	Search help (Telescope)

---

Architecture Diagrams

Buffer / Window / Tab Relationship

.---------------------------- Tab Page 1 ----------------------------.
|                                                                    |
|  .---------------- Window 1 -----------------.  .-- Window 2 --.   |
|  |                                           |  |              |   |
|  |  Buffer A (file1.lua)                     |  |  Buffer B    |   |
|  |  .---------------------------------------.|  |  (file2.lua) |   |
|  |  |local M = {}                           ||  |              |   |
|  |  |M.setup = function() ... end           ||  |              |   |
|  |  |return M                               ||  |              |   |
|  |  `---------------------------------------'|  |              |   |
|  |                                           |  |              |   |
|  `-------------------------------------------'  `--------------'   |
|                                                                    |
| Statusline: file1.lua          LSP: active    Git: +2 -1           |
`--------------------------------------------------------------------'

Buffers are in-memory representations of files.
Windows are viewports into buffers (a buffer can be shown in multiple windows).
Tab Pages are collections of window layouts.

Lua Module Lookup Order

require("config.options")
  |
  |- 1. package.preload["config.options"]     -- preloaded?
  |
  |- 2. ~/.config/nvim/lua/config/options.lua -- check rtp paths
  |     `- rtp entries searched in order:
  |          ~/.config/nvim/
  |          /usr/share/nvim/runtime/
  |          ... (all 'paths' in :set rtp?)
  |
  |- 3. ~/.config/nvim/lua/config/options/init.lua
  |     `- directory-as-module pattern
  |
  `- 4. ERROR: module 'config.options' not found

Key takeaway: `require("foo.bar")` maps to `lua/foo/bar.lua` or `lua/foo/bar/init.lua`
on your runtime path. No symlinks, no magic — just filesystem convention.

LSP Request Flow

   User types "."              LSP Server (e.g., pyright)
        |                              |
        ▼                              |
.---------------.                      |
| nvim-cmp      |  textDocument/       |
| (completion   |  completion request  |
|  engine)      |--------------------► |
|               |                      |
|  .---------.  |                      |
|  | sources |  |  completion response |
|  | .-----. |  |◄-------------------- |
|  | | LSP | |  |                      |
|  | | path| |  |   ▲                  |
|  | | buf | |  |   |                  |
|  | | etc | |  |   | debounce/throttle|
|  | `-----' |  |   | (150ms default)  |
|  `---------'  |                      |
|        |      |                      |
|        ▼      |                      |
|  .---------.  |                      |
|  | popup   |  |                      |
|  | menu    |  |                      |
|  `---------'  |                      |
`---------------'                      |

Request path:
  Type trigger -> nvim-cmp collects -> LSP source sends to server
  -> Server responds -> nvim-cmp deduplicates -> popup menu renders

---

Teaching Structure

Every section page follows a consistent pedagogy:

Section	Purpose
Concept	What this thing is, at a high level
Why it matters	When you need it and what problems it solves
Minimal example	The smallest working code that demonstrates the concept
Common mistakes	Pitfalls, anti-patterns, and how to avoid them
Practice exercise	Something to try in your own config right now
Next steps	Where to go after you understand this topic

Sections marked with > TRY THIS: blocks contain exact commands with expected output — run them alongside the reading for the fastest path to mastery.

---

The Meta-Question: Why Neovim?

You could use VS Code, Sublime, JetBrains, or any number of editors that "just work." Why Neovim?

The honest answer: Because you want to.

There's no pragmatic case for Neovim over VS Code for most users. The learning curve is real. The configuration is manual. Plugins can break. Debugging can be arcane.

But.

You want to understand your tools deeply. You want to customize without limits. You want an editor that's 30 years mature but still evolving. You want something that runs in a terminal, on a server, in a container, anywhere. You want to be able to read and modify your entire configuration.

You want motions that express intent — ci" to change inside quotes, dap to delete a paragraph, :%s/foo/bar/g to replace globally — rather than Ctrl+Shift+Right x 12, Backspace, retype.

Or maybe you just heard vim motions are really efficient and want to see what the fuss is about.

Whatever your reason: welcome. This handbook exists to get you productive faster than you would on your own. Let's build something good.

---

Next Steps

• Get Started — Installation and your first session
• Learn Lua — From zero to module author
• Explore Plugins — The plugin ecosystem
• Plugin Guides — Deep dive into each plugin
• Troubleshoot — When things go wrong
• Contribute — Give back to the ecosystem
• Quick Reference — Command and motion cheat sheets

---

Directory Structure

docs/
|-- README.md
|-- 01-getting-started/
|   |-- README.md
|   |-- 01-directory-structure.md
|   |-- 02-first-steps.md
|   |-- 03-installation.md
|   |-- 04-requirements.md
|   |-- 05-startup-flow.md
|   `-- 06-verification.md
|-- 02-lua-programming/
|   |-- README.md
|   |-- 01-beginner/
|   |   |-- README.md
|   |   |-- 01-what-is-lua/
|   |   |   `-- README.md
|   |   |-- 02-first-lua/
|   |   |   `-- README.md
|   |   |-- 03-tables/
|   |   |   `-- README.md
|   |   |-- 04-functions/
|   |   |   `-- README.md
|   |   |-- 05-control-flow/
|   |   |   `-- README.md
|   |   `-- 06-your-first-config/
|   |       `-- README.md
|   |-- 02-intermediate/
|   |   |-- README.md
|   |   |-- 01-modules/
|   |   |   `-- README.md
|   |   |-- 02-neovim-api/
|   |   |   `-- README.md
|   |   |-- 03-writing-plugins/
|   |   |   `-- README.md
|   |   |-- 04-api-deep-dive/
|   |   |   `-- README.md
|   |   |-- 05-lsp-and-treesitter/
|   |   |   `-- README.md
|   |   `-- 06-testing/
|   |       `-- README.md
|   |-- 03-advanced/
|   |   |-- README.md
|   |   |-- 01-metatables/
|   |   |   `-- README.md
|   |   |-- 02-ffi-and-c/
|   |   |   `-- README.md
|   |   |-- 03-event-loop/
|   |   |   `-- README.md
|   |   |-- 04-testing-advanced/
|   |   |   `-- README.md
|   |   |-- 05-performance/
|   |   |   `-- README.md
|   |   `-- 06-new-language-features/
|   |       `-- README.md
|   |-- 04-reference/
|   |   |-- README.md
|   |   |-- 01-vim-namespace/
|   |   |   `-- README.md
|   |   |-- 02-api-reference/
|   |   |   `-- README.md
|   |   |-- 03-patterns/
|   |   |   `-- README.md
|   |   |-- 04-troubleshooting/
|   |   |   `-- README.md
|   |   `-- 05-glossary/
|   |       `-- README.md
|   |-- 05-contributing/
|   |   |-- README.md
|   |   |-- 01-community/
|   |   |   `-- README.md
|   |   |-- 02-bug-reports/
|   |   |   `-- README.md
|   |   |-- 03-submitting-prs/
|   |   |   `-- README.md
|   |   |-- 04-understanding-core/
|   |   |   `-- README.md
|   |   `-- 05-architecture/
|   |       `-- README.md
|   `-- 06-plugins/
|       |-- README.md
|       |-- 01-why-plugins/
|       |   `-- README.md
|       |-- 02-finding-plugins/
|       |   `-- README.md
|       |-- 03-popular-plugins/
|       |   `-- README.md
|       |-- 04-plugin-comparisons/
|       |   `-- README.md
|       |-- 05-assessing-plugins/
|       |   `-- README.md
|       `-- 06-other-interesting-plugins/
|           `-- README.md
|-- 03-configuration/
|   |-- README.md
|   |-- 01-autocmds/
|   |   |-- 01-autocmds-overview.md
|   |   `-- 02-autocmds-advanced.md
|   |-- 02-customization/
|   |   |-- 01-customization-overview.md
|   |   `-- 02-practical.md
|   |-- 03-debugging/
|   |   |-- 01-debugging-overview.md
|   |   `-- 02-debugging-advanced.md
|   |-- 04-init/
|   |   |-- 01-init-entry-point.md
|   |   `-- 02-init-advanced.md
|   |-- 05-keymaps/
|   |   |-- 01-keymaps-overview.md
|   |   `-- 02-keymaps-advanced.md
|   |-- 06-lazy/
|   |   |-- 01-lazy-plugin-management.md
|   |   `-- 02-lazy-advanced.md
|   |-- 07-options/
|   |   |-- 01-options-overview.md
|   |   |-- 02-display.md
|   |   |-- 03-behavior.md
|   |   |-- 04-indentation.md
|   |   |-- 05-search.md
|   |   `-- 06-options-performance.md
|   |-- 08-patterns/
|   |   |-- 01-patterns-overview.md
|   |   `-- 02-examples.md
|   `-- 09-utils/
|       `-- 01-utils-readme.md
|-- 04-keymaps/
|   |-- README.md
|   |-- 01-keymaps-overview.md
|   |-- 02-syntax.md
|   |-- 03-modes.md
|   |-- 04-leader-keys.md
|   |-- 05-common-patterns.md
|   |-- 06-plugin-keymaps.md
|   `-- 07-remapping.md
|-- 05-plugins/
|   |-- README.md
|   |-- ecosystem/
|   |   |-- README.md
|   |   |-- 01-applications.md
|   |   |-- 02-vs-builtin-loading.md
|   |   |-- 03-creation.md
|   |   |-- 04-extension.md
|   |   `-- 05-other-plugins.md
|   |-- getting-started/
|   |   |-- 01-what-are-plugins.md
|   |   `-- 02-lazy.md
|   |-- guides/
|   |   |-- README.md
|   |   |-- 01-completion.md
|   |   |-- 02-gitsigns.md
|   |   |-- 03-lsp.md
|   |   |-- 04-lualine.md
|   |   |-- 05-plugin-colors.md
|   |   |-- 06-markdown.md
|   |   |-- 07-oil.md
|   |   |-- 08-telescope.md
|   |   `-- 09-treesitter.md
|   `-- spec/
|       |-- README.md
|       |-- 01-loading.md
|       |-- 02-dependencies.md
|       |-- 03-configuration.md
|       `-- 04-spec-internals.md
|-- 06-languages/
|   |-- README.md
|   |-- 01-ios-macos/
|   |   `-- README.md
|   |-- 02-python/
|   |   `-- README.md
|   |-- 03-typescript/
|   |   `-- README.md
|   |-- 04-rust/
|   |   `-- README.md
|   |-- 05-go/
|   |   `-- README.md
|   |-- 06-c-cpp/
|   |   `-- README.md
|   |-- 07-java-kotlin/
|   |   `-- README.md
|   |-- 08-web/
|   |   `-- README.md
|   `-- 09-other-languages/
|       `-- README.md
|-- 07-workflows/
|   |-- 01-daily.md
|   `-- 02-development.md
|-- 08-vimscript/
|   |-- README.md
|   |-- 01-introduction/
|   |   `-- README.md
|   |-- 02-syntax-basics/
|   |   `-- README.md
|   |-- 03-variables-and-types/
|   |   `-- README.md
|   |-- 04-control-flow/
|   |   `-- README.md
|   |-- 05-functions/
|   |   `-- README.md
|   |-- 06-lists-and-dictionaries/
|   |   `-- README.md
|   |-- 07-autocommands/
|   |   `-- README.md
|   |-- 08-mappings-and-commands/
|   |   `-- README.md
|   |-- 09-options-and-variables/
|   |   `-- README.md
|   |-- 10-windows-and-buffers/
|   |   `-- README.md
|   |-- 11-scripting-patterns/
|   |   `-- README.md
|   |-- 12-interop-with-lua/
|   |   `-- README.md
|   |-- 13-migration-guide/
|   |   `-- README.md
|   `-- 14-reference/
|       `-- README.md
|-- 09-vim/
|   |-- README.md
|   |-- 01-configuration/
|   |   `-- README.md
|   |-- 02-differences/
|   |   `-- README.md
|   `-- 03-plugins/
|       `-- README.md
|-- 10-advanced/
|   |-- README.md
|   |-- 01-custom-plugins.md
|   |-- 02-advanced-autocmds.md
|   |-- 03-lsp-config.md
|   |-- 04-completion-sources.md
|   |-- 05-treesitter-queries.md
|   |-- 06-statusline.md
|   |-- 07-advanced-colors.md
|   |-- 08-advanced-overview.md
|   `-- 09-performance.md
|-- 11-troubleshooting/
|   |-- README.md
|   |-- 01-getting-started/
|   |   |-- README.md
|   |   |-- 01-what-is-vi.md
|   |   |-- 02-the-modes.md
|   |   |-- 03-essential-commands.md
|   |   |-- 04-the-help-system.md
|   |   `-- 05-common-first-struggles.md
|   |-- 02-diagnosis-fundamentals/
|   |   `-- README.md
|   |-- 03-understanding-neovim/
|   |   `-- README.md
|   |-- 04-problems-by-category/
|   |   |-- README.md
|   |   |-- 01-startup-issues.md
|   |   |-- 02-lua-errors.md
|   |   `-- 03-plugin-not-loading.md
|   |-- 05-community-help/
|   |   `-- README.md
|   |-- 06-debugging.md
|   |-- 07-troubleshooting-performance.md
|   `-- plugins/
|       |-- README.md
|       |-- 01-interesting-plugins.md
|       `-- 02-troubleshooting-comparisons.md
|-- 12-contributing/
|   |-- README.md
|   |-- 01-motivation.md
|   |-- 02-community/
|   |   `-- README.md
|   |-- 03-core/
|   |   `-- README.md
|   |-- 04-getting-started/
|   |   `-- README.md
|   |-- 05-learning/
|   |   `-- README.md
|   `-- plugins/
|       |-- README.md
|       |-- 01-anatomy.md
|       |-- 02-building.md
|       |-- 03-publishing.md
|       |-- 04-choosing.md
|       |-- 05-extending.md
|       |-- 06-plugin-comparisons.md
|       `-- 07-plugins-overview.md
|-- 13-quick-reference/
|   |-- 01-commands.md
|   `-- 02-motions.md
`-- 14-migrations/
    |-- 01-vscode.md
    |-- 02-vim.md
    `-- 03-other-editors.md