Terminal & External Commands

Vim was born in the Unix world, and it shows. Rather than trying to do everything itself, Vim lets you reach out to the vast ecosystem of command-line tools — sort, awk, jq, grep, curl — and pipe your text through them. This philosophy means you can format JSON, calculate columns of numbers, or sort a list without ever leaving your editor.

Neovim takes this further with a built-in terminal emulator, so you can run a full shell session right inside a split window. Combined with plugins like toggleterm.nvim, the boundary between your editor and your terminal blurs beautifully.

What you'll learn in this chapter:

• Use Neovim's built-in terminal emulator and navigate between terminal and normal modes

• Filter buffer text through external commands like sort, jq, and awk

• Read external command output directly into your buffer with :r !

• Configure toggleterm.nvim for convenient floating and split terminal workflows

• Integrate shell tools like ripgrep, fd, fzf, and zoxide into your editing workflow

Neovim Built-in Terminal

Neovim has a built-in terminal emulator:

:terminal          " Open terminal in current window
:split | terminal  " Open in horizontal split
:vsplit | terminal " Open in vertical split

Note: Terminals open in buffer windows just like any other buffer. You can manage them using standard window navigation (see Buffers, Windows & Tabs).

Terminal Mode

Key	Action
Ctrl+\ Ctrl+n	Exit to Normal mode
i or a	Enter Terminal mode (start typing)
<C-w>h/j/k/l	Navigate to other windows (from Normal mode)

Pasting Registers in Terminal Mode

You can paste from registers while in Terminal mode:

" Paste from clipboard in terminal mode
tnoremap <expr> <C-r> '<C-\><C-n>"' . nr2char(getchar()) . 'pi'

This lets you press Ctrl+r followed by a register letter (e.g., + for clipboard) to paste its content, just like in Insert mode.

Terminal Autocommands

vim.api.nvim_create_autocmd('TermOpen', {
    callback = function()
        vim.opt_local.number = false
        vim.opt_local.relativenumber = false
        vim.cmd('startinsert')
    end,
})

toggleterm.nvim

toggleterm.nvim makes terminals much more convenient:

{
    'akinsho/toggleterm.nvim',
    version = '*',
    keys = {
        { '<C-\\>', desc = 'Toggle terminal' },
    },
    opts = {
        open_mapping = '<C-\\>',
        direction = 'float',     -- 'horizontal', 'vertical', 'tab', 'float'
        float_opts = {
            border = 'rounded',
        },
        size = function(term)
            if term.direction == 'horizontal' then
                return 15
            elseif term.direction == 'vertical' then
                return vim.o.columns * 0.4
            end
        end,
    },
}

Custom Terminal Commands

local Terminal = require('toggleterm.terminal').Terminal

-- Lazygit terminal
local lazygit = Terminal:new({
    cmd = 'lazygit',
    direction = 'float',
    hidden = true,
})

vim.keymap.set('n', '<leader>lg', function()
    lazygit:toggle()
end, { desc = 'Open Lazygit' })

Running External Commands

Reading External Command Output

You can read the output of any shell command directly into your buffer:

" Insert output of a command below the cursor
:r !date
:r !ls -la
:r !curl -s https://api.example.com/status

" Insert at a specific line
:0r !head -5 /etc/passwd

The Filter Command !

The filter command complements Vim's built-in text processing commands like :g (see The Global Command) by letting you leverage external tools.

You can filter text through external commands:

" Filter entire file through sort
:%!sort

" Filter selection through an external command
:'<,'>!sort -u

" Filter paragraph through fmt (text wrapper)
!ip fmt -w 80

" Format JSON with jq
:%!jq .

" Format XML with xmllint
:%!xmllint --format -

The Powerful AWK

AWK is a powerful text-processing language. You can use it from within Vim:

Example: Calculate ages from birth years:

Given a table like:

Stallman   Richard   GNU    1953  USA
Wall       Larry     Perl   1954  USA
Moolenar   Bram      Vim    1961  Netherlands

" Filter through awk to calculate age, then format with column
:%!awk '{$4 = 2026 - $4; print}' | column -t

In AWK, $4 is the 4th field (birth year). We replace it with the current year minus the birth year.

Exchange last two fields:

:%!awk '{tmp=$(NF-1); $(NF-1)=$NF; $NF=tmp; print}'

$NF is the last field, $(NF-1) is the second-to-last.

AWK Ternary Operator — classify values conditionally:

:%!awk '{$(NF-1) = ($(NF-1) > 65) ? "retired" : "working"; print}'

This replaces the second-to-last field with "retired" or "working" depending on whether the value is greater than 65.

Sum the last field:

" With cursor on the last line of data:
:!awk '{sum += $NF} END {print "Total: " sum}'

Print only specific fields (extract columns):

" Print only name and country
:%!awk '{print $2, $NF}'

Tip: Use column -t to align output into neat columns: :%!awk '{print $1, $2}' | column -t

Other Useful External Commands

" Reverse lines in file
:%!tac

" Number all lines
:%!nl

" Remove duplicate lines (file must be sorted)
:%!sort -u

" Convert tabs to spaces
:%!expand -t 4

" Show diff of unsaved changes
:w !diff % -

Using ripgrep (rg) and fd

Modern alternatives to grep and find:

# Install
sudo apt install ripgrep fd-find
# or
brew install ripgrep fd

Use them from Vim:

" Set grepprg to use ripgrep
set grepprg=rg\ --vimgrep\ --smart-case
set grepformat=%f:%l:%c:%m

" Now :grep works with ripgrep
:grep "pattern" **/*.py

Neovim: Telescope uses ripgrep and fd automatically for live_grep and find_files.

Shell Integration

Opening Files from the Shell

# Open at a specific line
vim file.py +42
nvim file.py +42

# Open at a pattern
vim file.py +/function_name

# Open last edited file
alias lvim='vim -c "normal '\''0"'

Clipboard Aliases

# Add to ~/.bashrc or ~/.zshrc
alias pbcopy='xclip -selection clipboard'
alias pbpaste='xclip -selection clipboard -o'

ZSH Auto-Suggestions

zsh-autosuggestions suggests commands as you type. Bind Ctrl+Space to accept:

bindkey '^ ' autosuggest-accept

Open Clipboard Content in Vim (ZSH Widget)

You can create a ZSH widget that opens clipboard content directly in Neovim:

# Add to ~/.zshrc
open-clipboard-in-vim() {
    local tmpfile=$(mktemp /tmp/clipboard-XXXXXX)
    xclip -selection clipboard -o > "$tmpfile" 2>/dev/null || pbpaste > "$tmpfile" 2>/dev/null
    nvim "$tmpfile"
    rm -f "$tmpfile"
}
zle -N open-clipboard-in-vim
bindkey '^x^v' open-clipboard-in-vim

Press Ctrl+x Ctrl+v in ZSH to open clipboard content in Neovim for editing.

Quick File Opening with fzf

# Open a file selected with fzf
function vif() {
    local fname
    fname=$(fzf) || return
    nvim "$fname"
}

Navigate Directories with zoxide

zoxide (modern replacement for z, autojump, and fasd) learns your most-used directories:

# Install: https://github.com/ajeetdsouza/zoxide
# After installing:
z projects    # jump to ~/dev/projects (or wherever you go most)
zi            # interactive selection with fzf

Running Tests from Neovim

vim-test / neotest

neotest runs tests with results shown inline:

{
    'nvim-neotest/neotest',
    dependencies = {
        'nvim-neotest/nvim-nio',
        'nvim-lua/plenary.nvim',
        'nvim-treesitter/nvim-treesitter',
        -- Add adapters for your languages:
        'nvim-neotest/neotest-python',
        'nvim-neotest/neotest-go',
    },
    keys = {
        { '<leader>tt', function() require('neotest').run.run() end, desc = 'Run nearest test' },
        { '<leader>tf', function() require('neotest').run.run(vim.fn.expand('%')) end, desc = 'Run file tests' },
        { '<leader>ts', function() require('neotest').summary.toggle() end, desc = 'Toggle test summary' },
    },
}

Summary

Vim's philosophy of composing small, sharp tools shines through its external command integration. By piping buffer text through shell utilities and using Neovim's built-in terminal, you gain access to the entire Unix ecosystem without leaving your editor. Whether you are formatting JSON with jq, sorting data with awk, or running a full interactive shell in a floating window, these techniques keep you in flow.

Key takeaways:

• The filter command :%! pipes buffer contents through any external command, combining Vim's text manipulation with Unix tool power.

• Neovim's built-in terminal runs inside buffer windows; use <C-\><C-n> to escape to Normal mode and standard window commands to navigate.

• toggleterm.nvim adds floating, horizontal, and vertical terminal modes with a single toggle keymap, plus support for dedicated tool terminals like Lazygit.

• Tools like ripgrep, fd, fzf, and zoxide integrate naturally with Vim's workflows and can be used both from the command line and within the editor.

Exercises

1. Format JSON with an external command -- Paste or create some unformatted JSON in a buffer, then use an external command to pretty-print it.

2. Sort and deduplicate lines -- Create a buffer with several duplicate and unsorted lines, then sort them and remove duplicates using an external command.

3. Read command output into a buffer -- Insert the current date, a directory listing, or the output of a custom script into your buffer at the cursor position.

4. Use AWK to transform tabular data -- Create a simple table of data in your buffer and use AWK to extract specific columns, calculate values, or reformat the output.

5. Toggle a floating terminal and run a project command -- Configure and use toggleterm.nvim to open a floating terminal, run a build or test command, then dismiss it.