Free through lesson 3

Neovim, fish & tmux for Beginners

From installation through configuring fish with its completions, functions and prompt, Neovim motions, Lua config, LSP and plugins, tmux sessions and copy mode, and finally the Lua language itself. Forty lessons that take you to the point where the three work as one environment you can carry around in your dotfiles, and where you can write whatever is missing in Lua yourself. Every command and its output was produced by actually running it.

Start from lesson 1 Unlock every course

Curriculum

The 40 lessons are grouped into seven chapters. Working through them in order is the best way, but you are welcome to dip into whatever interests you. Note: config files and key bindings cannot be exercised inside the browser, so install fish, Neovim and tmux and follow along in your own terminal. Chapter 7 (lessons 31–40) is an advanced chapter on the Lua language itself, which underpins the config you build up to lesson 30.

Chapter 1 — Starting with fish (lessons 1–5)

You dispose of the POSIX-incompatibility worry by measuring it, then cover the foundations: config load order, variables and scope, completions and history. By the end, the suggestion is on screen before you finish typing.

The big picture of fish, Neovim and tmux

Settling the question of whether POSIX incompatibility will hurt, first. Getting clear on what each of the three tools does, then installing them and checking the versions.

Free

The order configuration files are loaded in

conf.d is read before config.fish. There is no separate login-shell file as in zsh, so you guard interactive-only work yourself.

Free

Variables, scope and PATH

Everything goes through set — no = and no export. The three scopes, PATH as a real list, and the three accidents fish_add_path prevents.

Free

How completion works, and writing your own

Tracing where those completions with descriptions come from, and giving your own commands the same quality of completion. Including when to use -f and -n.

History and autosuggestions

Right arrow takes all of it, Alt-f takes one word. When history merge is needed, the search that drops duplicates automatically, and what to do when you have typed a token.

Chapter 2 — Making fish your own (lessons 6–11)

You build the parts you touch daily with your own hands: abbreviations, functions, control flow, the prompt and plugins. Finally, fzf and zoxide make moving between directories and finding files noticeably faster.

abbr and alias

abbr expands to the real command the moment you type it. The expansion is what appears on screen and in history, and you can edit it there. Including the storage change in fish 4.

Functions and autoloading

One function per file and it is loaded when you need it. $argv and argparse, and where funced and funcsave fit.

Control flow and string

Every block ends with end. Command substitution needs no $. And the string command dramatically cuts how often you call sed or awk.

Building a prompt

A prompt is just a function. set_color and prompt_pwd, the bundled fish_git_prompt, and why you save $status on the very first line.

Plugin management and key bindings

fisher does nothing but copy files according to a convention. Writing binds, fish_key_reader, and vi mode with a mode indicator.

fzf and moving between directories

There are two ways to install fzf and you pick one. or return when you build it into your own function, and fish's built-in prevd alongside zoxide.

Chapter 3 — Working in Neovim (lessons 12–16)

You learn the grammar — motions and text objects — then automate editing with registers, macros and search-and-replace. This chapter gets plain Neovim into your fingers before a single plugin goes in.

Starting Neovim, and modes

Trying it with NVIM_APPNAME without breaking your existing config. Confirming what plain Neovim gives you, and learning the modes and the way out.

Motions and text objects

Every edit is an operator plus a motion or text object. Learn to decode them rather than memorise them.

Registers and macros

The cause of "what I deleted got pasted", and the answer: "0p. Then four ways to apply the same edit across dozens of lines.

Search and replace

Add \v and the regular expressions become nearly the same as every other language. When to use each flag, and what to do before a multi-file replace.

Buffers, windows and tabs

What corresponds to a VS Code tab is a buffer. Understand the three levels and it becomes clear why :q does not quit and why :bd closes a split.

Chapter 4 — Neovim as a development environment (lessons 17–23)

You write your config in Lua and layer on lazy.nvim, Treesitter, LSP, completion and a fuzzy finder. Git integration and a formatter finish the setup off for real work.

Options and key maps

When to use vim.opt versus vim.o, four options worth setting, key maps with desc, and splitting your config into lua/config/.

Splitting your config, and lazy.nvim

From the bootstrap to a lua/plugins/ layout. When to use event, cmd, keys and ft, the difference between opts and config, and what lazy-lock.json means.

Treesitter

Treating code as a syntax tree. Incremental selection and folding by syntax, and using the fish parser to highlight your own shell config accurately.

LSP

In 0.11 the key maps are predefined and configuration moves to vim.lsp.config and enable. How to confirm it attached, and grn (rename), the feature you will value most.

Completion

First see how far the built-in completion gets you. You need a plugin when you want fuzzy matching and multiple sources — and that is where blink.cmp comes in.

Fuzzy finders

fzf-lua uses the same fzf binary as your shell, so files, full-text search, buffers, help and diagnostics are all found the same way. From Ctrl-q to :cdo.

Git integration and formatting

Hunk-level staging with gitsigns, and format-on-save with conform. Wiring in fish_indent so your own shell config is formatted automatically too.

Chapter 5 — Health checks and tmux basics (lessons 24–27)

You clear up the compatibility problems that only appear under fish, and inspect your config with :checkhealth and start-up timing. Then straight into tmux: sessions, windows, panes and .tmux.conf.

Compatibility problems between Neovim and fish

Once the shell option is fish, plugins that call system() break. Reproducing the cause, fixing it in one line, and putting only :terminal back to fish.

:checkhealth and start-up time

Sorting warnings into "must fix" and "safe to ignore". How to measure start-up time, and how to work through a broken config.

tmux basics

The three levels of session, window and pane, and the configuration for opening fish. The idea behind the prefix, and controlling it from outside.

Writing .tmux.conf

Changing the prefix, split keys, inheriting the current directory, and the default-terminal and focus-events settings that get Neovim's colours right.

Chapter 6 — Tying the three together and taking them with you (lessons 28–30)

You sort out copy mode and the clipboard, and make key bindings and colours consistent across all three tools. Finally you collect it all into dotfiles so you can recreate the same environment on a new machine.

Copy mode and the clipboard

Setting mode-keys vi does not make y work. The configuration that matches Vim, and two routes to the system clipboard.

Tying the three together

Moving between Neovim splits and tmux panes with Ctrl-hjkl alone. Detecting external changes with focus-events, and launching a layout automatically from a fish function.

Managing dotfiles, and wrapping up

Keeping only what you wrote under Git. The trap of fish's universal variables, and the steps to reproduce everything on a new machine.

Chapter 7 — Writing your config in Lua (lessons 31–40)

Up to lesson 30 you used Lua as a set of recipes. Now you'll revisit it as a language. You'll cover tables, closures, and modules, then vim.api, autocmds, and async work, and finish by writing a small plugin of your own and making your config crash-proof.

Lua inside Neovim

Check the LuaJIT (Lua 5.1) built into Neovim. The three entry points :lua, :=, and nvim -l, plus vim.print, the "0 is true" trap, and forgetting local.

Tables and vim.tbl_*

Your config is all nested tables. The # trap, assignment vs. copying, the force / keep / error modes of vim.tbl_deep_extend, and the Option object vim.opt returns.

Functions, closures and varargs

How to pass functions to keymaps and commands. Calling vs. passing, closures that hold state and the loop trap, and what ... and self really are.

Modules and runtimepath

require searches lua/ along the runtimepath. A module runs only once and is shared, and you can reload it by clearing package.loaded.

Where vim.api, vim.fn and vim.opt differ

Three ways to touch the editor. 0-based vs. 1-based indexes, type conversion and the 0 trap in vim.fn, the Vimscript left in vim.cmd, and option scopes.

autocmd and augroup in Lua

Read the args an nvim_create_autocmd callback receives. Avoid duplicates with clear = true, set lifetimes with once and buffer, and pass values via data.

Keymaps and user commands

expr and buffer in vim.keymap.set; nargs, complete, bang, and range in nvim_create_user_command. Inspect the table each callback actually receives.

vim.uv and vim.system

Run external commands without freezing the screen. Sync and async vim.system, why callbacks can't call the API and vim.schedule, and a real example: getting the branch name.

Turning it into a plugin

Extract part of your config into a small plugin, tally.nvim. The setup(opts) convention, plugin/ vs. lua/, a health.lua for :checkhealth, and loading it with lazy.nvim.

A config that doesn't break

Keep one error from stopping the rest of your config. pcall and vim.notify, a recap of Lua pitfalls, :checkhealth for your own config, and a startup check before committing.

Once you have finished all 40 lessons, take on the tool you will use every day in this environment with Git & GitHub, or move to the server side with Linux. Membership unlocks every course.