MOSAID Articles & Tutorials - vim

The Ultimate Neovim Configuration: A Modular, Reproducible Developer Environment

2026-05-29T12:19:58+00:00

Why “Ultimate”? A Philosophy, Not a Dump of Settings Top

An ultimate Neovim configuration isn’t the one with the most plugins—it’s the one that starts in under 100 ms, behaves identically on any machine, and feels like a custom‑built engineering console rather than a text editor. This article presents the full architecture of the setup I’ve refined over years of daily use: writing LaTeX, Python, shell scripts, HTML, and Markdown. It’s modular, lazy‑loaded, and completely deterministic. Download the included zip file at the end of the article, run :Lazy sync, and every keybinding, colour, and snippet is exactly as intended.

The configuration is split into logical modules—each file has a single responsibility. This article walks through every piece, explaining not just the “what” but the “why”. All file contents are included; copy them directly into your own ~/.config/nvim and you’ll have a fully functional developer environment.

Directory Tree Top

Neovim respects ~/.config/nvim/ and expects Lua modules under lua/. The tree below shows every file that makes up this configuration. Central files are highlighted in bold.

~/.config/nvim/
├── init.lua                         ← entry point
├── lazy-lock.json                   ← pinned plugin versions
├── lua/
│   ├── config/
│   │   ├── lazy.lua                 ← bootstraps lazy.nvim
│   │   ├── colors.lua               ← themes & highlights
│   │   ├── commands.lua             ← user commands
│   │   ├── functions.lua            ← automation utilities
│   │   ├── keymaps.lua              ← global keybindings
│   │   ├── html_markdown_maps.lua   ← shared visual wrappers
│   │   ├── html_snippets.lua        ← HTML / Markdown snippets
│   │   ├── tex_snippets.lua         ← LaTeX snippets
│   │   └── options.lua
│   └── plugins/
│       └── core.lua                 ← plugin specification
└── ftplugin/
    ├── python.lua
    ├── tex.lua
    ├── html.lua
    ├── markdown.lua
    └── lua.lua

Nothing is loaded until it’s needed. Global options live in init.lua; everything else is deferred by lazy.nvim or triggered by filetype events.

The Bootstrapper — init.lua Top

init.lua is the first file Neovim reads. It sets the baseline: leader keys, editor options, persistent history and undo, a fallback colourscheme, and the lazy‑loading schedule.

Here is the complete file.


-- Leader keys
vim.g.mapleader = ","
vim.g.maplocalleader = " "

-- Basic settings
vim.o.number = true
vim.o.relativenumber = true
vim.o.termguicolors = true
vim.o.wrap = true
vim.o.tabstop = 2
vim.o.shiftwidth = 2
vim.o.expandtab = true
vim.o.mouse = "a"
vim.o.cmdheight = 1
vim.opt.ignorecase = true
vim.opt.smartcase = true

-- Disable netrw (we use ranger / telescope)
vim.g.loaded_netrw = 1
vim.g.loaded_netrwPlugin = 1

-- Maximum history and persistent undo
vim.opt.history = 10000
vim.opt.undolevels = 10000
vim.opt.undoreload = 100000
vim.opt.undofile = true
vim.opt.undodir = vim.fn.stdpath("data") .. "/undo"
vim.opt.shadafile = vim.fn.stdpath("data") .. "/shada/main.shada"
vim.opt.shada = "'100000,<1000,s100,h"
vim.cmd("silent! rshada")

-- Fallback colourscheme – editor never looks broken
vim.cmd("colorscheme desert")

-- Bootstrap lazy.nvim, then schedule the rest
require("config.lazy")
vim.schedule(function()
  require("config.colors").setup()
  require("config.keymaps")
  require("config.commands")
end)

-- Autocommands
-- Remove trailing whitespace on save
vim.api.nvim_create_autocmd("BufWritePre", {
  pattern = "*",
  callback = function()
    vim.cmd([[%s/\s\+$//e]])
  end
})

-- Remember last cursor position
vim.api.nvim_create_autocmd("BufReadPost", {
  pattern = "*",
  callback = function()
    local last_pos = vim.fn.line([['"]])
    if last_pos > 1 and last_pos <= vim.fn.line("$") then
      vim.cmd("normal! g`\"")
    end
  end,
})

-- Automatically set filetype for .tex files
vim.api.nvim_create_autocmd({"BufEnter", "BufNew", "BufNewFile", "BufRead"}, {
  pattern = "*.tex",
  callback = function()
    vim.bo.filetype = "tex"
  end
})

-- Change current directory to the directory of the current file (except /tmp)
vim.api.nvim_create_autocmd("BufReadPost", {
  callback = function()
    local dir = vim.fn.expand("%:p:h")
    if dir ~= "" and not dir:match("^/tmp") then
      vim.cmd("silent! lcd " .. dir)
    end
  end,
})

-- Briefly highlight yanked text
vim.api.nvim_create_autocmd("TextYankPost", {
  pattern = "*",
  callback = function()
    vim.highlight.on_yank({
      higroup = "IncSearch",
      timeout = 500,
    })
  end,
})

Leader keys – , for global, Space for local – keep custom mappings under the left hand.
Persistent state – undo files and shada (command/search history, marks) are stored in Neovim’s data directory and set to very high limits so nothing is ever lost.
Fallback colourscheme – desert is set synchronously to eliminate any flash of unstyled text. The real theme loads later.
Scheduled callback – vim.schedule() defers the remaining setup until after plugins are loaded, preventing “module not found” errors.
Autocommands – small infrastructure pieces that keep diffs clean, restore cursor position, auto‑detect .tex files, and provide instant yank feedback.

Lazy Loading with lazy.nvim Top

lua/config/lazy.lua is the only file that touches plugin management. It clones lazy.nvim if missing, then loads the plugin specification from lua/plugins/core.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", lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup({
  spec = { { import = "plugins" } },
  ui = { border = "rounded" },
})

The companion lazy-lock.json (included in the zip file at the end of the article) pins every plugin commit, making the whole plugin set reproducible.

The Visual Stack — colors.lua Top

lua/config/colors.lua applies the chosen theme (Nordic), sets custom highlights, makes most UI elements transparent, and re‑applies critical highlights after every colour scheme change.


local M = {}
function M.setup()
  vim.o.background = "dark"
  local ok, err = pcall(vim.cmd, "colorscheme nordic")
  if not ok then
    vim.cmd("colorscheme desert")
    vim.notify("Warning: Falling back to 'desert'. " .. tostring(err), vim.log.levels.WARN)
  end
  vim.wo.cursorline = true

  -- Explicit hex colours (independent of theme palette)
  vim.api.nvim_set_hl(0, "CursorLine",   { bg = "#3b4261", bold = true })
  vim.api.nvim_set_hl(0, "Cursor",       { bg = "#434C5E", fg = "#ECEFF4", blend = 60 })
  vim.api.nvim_set_hl(0, "StatusLine",   { bg = "#1f2335", fg = "#c0caf5", bold = true })
  vim.api.nvim_set_hl(0, "Visual",       { bg = "#FFD966", fg = "black" })
  vim.api.nvim_set_hl(0, "Search",       { bg = "#ff9e64", fg = "black", bold = true })
  vim.api.nvim_set_hl(0, "LineNr",       { fg = "#FFFF00" })
  vim.api.nvim_set_hl(0, "CursorLineNr", { fg = "#c0caf5", bold = true })
  -- … plus many more (see the full file)

  -- Transparency: structural UI gets no background
  local transparent = {
    "Normal", "NormalNC", "NormalFloat", "SignColumn", "MsgArea",
    "TelescopeNormal", "TelescopeBorder", "StatusLine", "StatusLineNC",
    "BufferLineFill", "BufferLineBackground", "LineNr", "CursorLineNr",
    "FloatBorder",
  }
  for _, grp in ipairs(transparent) do
    vim.api.nvim_set_hl(0, grp, { bg = "none" })
  end

  -- Re‑apply matching bracket highlights after every theme change
  vim.api.nvim_create_autocmd({ "ColorScheme", "User" }, {
    pattern = { "LazyDone", "VeryLazy" },
    callback = function()
      vim.api.nvim_set_hl(0, "MatchParen",    { bg = "#ff33aa", fg = "#000000", bold = true })
      vim.api.nvim_set_hl(0, "MatchParenCur", { bg = "#ff33aa", fg = "#000000", bold = true })
      vim.api.nvim_set_hl(0, "MatchWord",     { bg = "#5555ff", fg = "#000000" })
    end,
  })
end
return M

By using raw hex codes, the highlights stay identical whether you run Nordic, Tokyonight, or the fallback Desert. The autocommand on ColorScheme ensures that even if a plugin reloads the theme, your custom highlights survive.

Global Keymaps & User Commands Top

lua/config/keymaps.lua and lua/config/commands.lua form a unified toolbelt. Every keybinding has a corresponding user command, and every command delegates to a single function. This makes the system auditable, remappable, and self‑documenting.

keymaps.lua


local opts = { noremap = true, silent = true }
local functions = require("config.functions")

-- Clipboard
vim.keymap.set("n", "cc", 'gg"+yG', opts)
vim.keymap.set("v", "<C-c>", '"+y', opts)
vim.keymap.set("i", "<C-v>", '<C-r>+', opts)

-- Buffer / window navigation
vim.keymap.set("n", "<Tab>", ":bn<CR>", opts)
vim.keymap.set("n", "<S-Tab>", ":bp<CR>", opts)
vim.keymap.set("n", "<C-h>", "<C-w>h", opts)
vim.keymap.set("n", "<C-j>", "<C-w>j", opts)
vim.keymap.set("n", "<C-k>", "<C-w>k", opts)
vim.keymap.set("n", "<C-l>", "<C-w>l", opts)

-- Automation tools
vim.keymap.set("n", "<leader>wc",    functions.word_count, opts)
vim.keymap.set("n", "<leader>cc",    functions.command_history_explorer, opts)
vim.keymap.set("n", "<leader>rr",    functions.output_regs, opts)
vim.keymap.set("n", "<leader>hh",    functions.wrap_code_in_buffer, opts)
vim.keymap.set("n", "<leader>ranger",functions.ranger_chooser, opts)
vim.keymap.set("n", "<leader>mm",    functions.output_old_files, opts)

-- etc. (see the full file)

commands.lua


local functions = require("config.functions")

vim.api.nvim_create_user_command("WC", functions.word_count, {})
vim.api.nvim_create_user_command("Mm", functions.output_old_files, {})
vim.api.nvim_create_user_command("Cc", functions.command_history_explorer, {})
vim.api.nvim_create_user_command("Ss", functions.search_command_history, {})
vim.api.nvim_create_user_command("Rr", functions.output_regs, {})
vim.api.nvim_create_user_command("HH", functions.wrap_code_in_buffer, {})
vim.api.nvim_create_user_command("RangerChooser", functions.ranger_chooser, {})
vim.api.nvim_create_user_command("SaveVimInfo", functions.save_vim_bindings_and_functions, {})
vim.api.nvim_create_user_command("EngType", functions.eng_type, {})
vim.api.nvim_create_user_command("FrType", functions.fr_type, {})

Mnemonic prefixes make the system self‑documenting: <leader>wc → word count, <leader>cc → command history, etc.

Automation Functions — functions.lua Top

lua/config/functions.lua is the heart of the automation layer. It provides async Python/LaTeX runners, a searchable command history, a register inspector, an “old files” browser, a ranger file‑chooser, buffer‑wrapping utilities, and more. All are written in pure Lua with no plugin dependencies.

Asynchronous Python Execution


function M.run_python_selection()
  local mode = vim.fn.mode()
  if mode ~= 'v' and mode ~= 'V' then return end
  local save_reg = vim.fn.getreg('"')
  vim.cmd('normal! gvy')
  local code = vim.fn.getreg('"')
  vim.fn.setreg('"', save_reg)
  code = "from math import *\n" .. code:gsub('^%s*', ''):gsub('%s*$', '')
  local output = vim.fn.system({'python3', '-c', code})
  vim.cmd('enew')
  vim.api.nvim_buf_set_lines(0, 0, -1, false, vim.split(output, "\n"))
  vim.bo.buftype = 'nofile'
  vim.bo.bufhidden = 'wipe'
end

Command History Explorer


function M.command_history_explorer()
  local history = {}
  for i = vim.fn.histnr(':'), 1, -1 do
    local cmd = vim.fn.histget(':', i)
    if cmd ~= "" then table.insert(history, cmd) end
  end
  vim.cmd('enew')
  local buf = vim.api.nvim_get_current_buf()
  vim.api.nvim_buf_set_lines(buf, 0, -1, false, history)
  vim.bo[buf].buftype = 'nofile'
  vim.bo[buf].modifiable = false
  vim.keymap.set('n', '<CR>', function()
    local cmd = vim.fn.getline('.')
    vim.cmd('bd! ' .. buf)
    vim.cmd(cmd)
  end, { buffer = buf })
  vim.cmd('normal! gg')
end

Register Inspector


function M.output_regs()
  vim.cmd('enew')
  local content = {}
  for reg = string.byte('a'), string.byte('z') do
    local ch = string.char(reg)
    local val = vim.fn.getreg(ch)
    if val ~= '' then
      table.insert(content, ch .. ":")
      table.insert(content, val)
      table.insert(content, "")
    end
  end
  vim.api.nvim_buf_set_lines(0, 0, -1, false, content)
  vim.bo.buftype = 'nofile'
  vim.bo.bufhidden = 'wipe'
  vim.cmd('normal! gg')
end

The file also contains run_python_and_replace, output_old_files, ranger_chooser, wrap_code_in_buffer, word_count, select_inside_any_pair, and several language‑specific helpers. You can find the complete source in the included zip file at the end of the article.

Per‑Filetype Engines — ftplugin Top

Filetype‑specific behaviour lives in ftplugin/. Each file sets buffer‑local options and defines insert‑mode expansions. Visual‑mode wrappers for HTML and Markdown are centralised in a shared module to avoid duplication.

Python ftplugin


-- ftplugin/python.lua
vim.bo.tabstop = 4
vim.bo.shiftwidth = 4
vim.bo.expandtab = true
vim.bo.textwidth = 88

-- Run buffer asynchronously (full function omitted for brevity)
vim.keymap.set('n', '<leader>c', run_python_buffer, { buffer = true })

-- Insert-mode expansions
local imaps = {
  ['if']    = 'if :<++><ESC>F:a',
  ['for']   = 'for in :<++><ESC>F:i',
  ['def']   = 'def ():<++><ESC>F(a',
  ['class'] = 'class :<++><ESC>F:a',
  ['imp']   = 'import ',
  ['from']  = 'from import <++><ESC>F:i',
  -- … many more
}
for lhs, rhs in pairs(imaps) do
  vim.keymap.set('i', lhs, rhs, { buffer = true })
end

LaTeX ftplugin


-- ftplugin/tex.lua (excerpt)
vim.bo.tabstop = 2
vim.bo.shiftwidth = 2

-- Async compilation and PDF viewer
vim.keymap.set('n', '<leader>c', run_tex,  { buffer = true })
vim.keymap.set('n', '<leader>o', view_tex, { buffer = true })
vim.keymap.set('n', '<leader>w', wrap_buffer_in_html_tags, { buffer = true })

-- Insert-mode shortcuts for commands, environments, and symbols
local imaps = {
  ['!'] = '\\',
  ['qq'] = '\\quad ',
  [',bf'] = '\\textbf{}<++><ESC>F{a',
  [',u']  = '\\underline{}<++><ESC>F{a',
  -- … dozens more
}
for lhs, rhs in pairs(imaps) do
  vim.keymap.set('i', lhs, rhs, { buffer = true })
end

HTML & Markdown ftplugins


-- ftplugin/html.lua
vim.bo.tabstop = 2
vim.bo.shiftwidth = 2
local imaps = {
  ['!'] = '<!--  --><++><Esc>F i',
  ['<'] = '<><++><Esc>F>a',
}
for lhs, rhs in pairs(imaps) do
  vim.keymap.set('i', lhs, rhs, { buffer = true })
end
require("config.html_markdown_maps")()

-- ftplugin/markdown.lua
vim.bo.tabstop = 2
vim.bo.shiftwidth = 2
require("config.html_markdown_maps")()

Shared Visual Wrappers — html_markdown_maps.lua

This module registers visual‑mode mappings that work identically in HTML and Markdown buffers. It uses a pure‑Lua wrap_visual_text function that handles linewise, characterwise, and blockwise selections.


-- lua/config/html_markdown_maps.lua (core wrapping function)
local function wrap_visual_text(open_tag, close_tag)
  local mode = vim.fn.visualmode()
  -- … normalises start/end, gets the visual selection,
  -- and wraps it with open_tag .. text .. close_tag
  -- (full implementation in the included zip file at the end of the article)
end

return function()
  vim.keymap.set('v', '<leader>pp', function() wrap_visual_text('<p>', '</p>') end)
  vim.keymap.set('v', '<leader>hh', function() wrap_visual_text('<h2>', '</h2>') end)
  -- … and many more wrapping / escaping shortcuts
end

Additionally, the file defines a set of number‑prefixed visual maps (1–9) for common transformations: escaping symbols, wrapping in code blocks, URL‑encoding, and more. See the included zip file at the end of the article for the full content.

Snippets as Code — LuaSnip Integration Top

Snippets are defined in two files: tex_snippets.lua and html_snippets.lua. They use LuaSnip’s function nodes for dynamic behaviour, read legacy snippet files on demand, and auto‑number LaTeX exercises based on buffer content.

LaTeX Snippets


-- tex_snippets.lua (excerpt)
local ls = require("luasnip")
local s = ls.snippet
local i = ls.insert_node
local t = ls.text_node
local f = ls.function_node

-- Auto‑numbered exercise environment
s("exe", {
  t("\\begin{exe}{"), i(1, "<++>"), t("}"),
  t({"", "    "}), f(function()
    local count = 0
    for _, line in ipairs(vim.api.nvim_buf_get_lines(0, 0, -1, false)) do
      if line:match("\\begin{exe}") then count = count + 1 end
    end
    return tostring(count)
  end),
  t({"", "    <++>", "\\end{exe}"}),
})

The file also wraps legacy snippet files from ~/.vim/snippets/latex/ so they appear as native LuaSnip snippets, and exports functions that can be called directly from insert‑mode mappings (e.g., ,tcb in the LaTeX ftplugin).

HTML / Markdown Snippets


-- html_snippets.lua
local snippets = {
  s("fig", {
    t("<figure>"),
    t({ "", "    " }),
    t('<img src="/theme/images/articles/'), i(1, "image.png"),
    t('" alt="'), i(2, "description"), t('" style="max-width:100%;height:auto;" >'),
    t({ "", "    " }),
    t("<figcaption>"), i(3, "caption"), t("</figcaption>"),
    t({ "", "</figure>" }),
    i(0),
  }),
  -- … anchor link, code block with raw tags, etc.
}
ls.add_snippets("html", snippets)
ls.add_snippets("markdown", snippets)

The Plugin Dashboard — core.lua Top

lua/plugins/core.lua lists every plugin. Each one lazy‑loads on an event, command, or filetype. The full specification is shown below.


return {
  -- Themes (loaded immediately)
  { "AlexvZyl/nordic.nvim",          lazy = false, priority = 1000 },
  { "folke/tokyonight.nvim",         lazy = false, priority = 1000 },

  -- Telescope (fuzzy finder)
  {
    "nvim-telescope/telescope.nvim",
    dependencies = { "nvim-lua/plenary.nvim" },
    cmd = "Telescope",
    config = function()
      local builtin = require("telescope.builtin")
      vim.keymap.set("n", "<leader>ff", builtin.find_files)
      vim.keymap.set("n", "<leader>fg", builtin.live_grep)
      vim.keymap.set("n", "<leader>fb", builtin.buffers)
      vim.keymap.set("n", "<leader>fh", builtin.help_tags)
    end,
  },

  -- Treesitter (syntax highlighting and indentation)
  {
    "nvim-treesitter/nvim-treesitter",
    build = ":TSUpdate",
    event = { "BufReadPost", "BufNewFile" },
    config = function()
      require("nvim-treesitter.configs").setup({
        ensure_installed = {
          "lua", "python", "javascript", "html", "css", "bash", "c", "cpp", "json", "yaml",
        },
        highlight = { enable = true },
        indent = { enable = true },
      })
    end,
  },

  -- Mason (LSP/DAP/linter manager)
  {
    "williamboman/mason.nvim",
    build = ":MasonUpdate",
    config = function() require("mason").setup() end,
  },

  -- nvim-cmp + LuaSnip (completion & snippets)
  {
    "hrsh7th/nvim-cmp",
    dependencies = {
      "hrsh7th/cmp-nvim-lsp",
      "hrsh7th/cmp-buffer",
      "hrsh7th/cmp-path",
      "saadparwaiz1/cmp_luasnip",
      "L3MON4D3/LuaSnip",
    },
    event = "InsertEnter",
    config = function()
      local cmp = require("cmp")
      local luasnip = require("luasnip")
      vim.o.completeopt = "menu,menuone,noselect"
      cmp.setup({
        snippet = {
          expand = function(args) luasnip.lsp_expand(args.body) end,
        },
        mapping = cmp.mapping.preset.insert({
          ['<C-Space>'] = cmp.mapping.complete(),
          ['<CR>'] = cmp.mapping.confirm({ select = true }),
          ['<Tab>'] = cmp.mapping(function(fallback)
            if cmp.visible() then cmp.select_next_item()
            elseif luasnip.expand_or_jumpable() then luasnip.expand_or_jump()
            else fallback() end
          end, { "i", "s" }),
          ['<S-Tab>'] = cmp.mapping(function(fallback)
            if cmp.visible() then cmp.select_prev_item()
            elseif luasnip.jumpable(-1) then luasnip.jump(-1)
            else fallback() end
          end, { "i", "s" }),
        }),
        sources = cmp.config.sources({
          { name = 'nvim_lsp' },
          { name = 'luasnip' },
          { name = 'buffer' },
          { name = 'path' },
        }),
      })
      -- Load our custom snippets
      require("config.tex_snippets")
      require("config.html_snippets")
    end,
  },

  -- Minimal bufferline
  {
    "akinsho/bufferline.nvim",
    version = "*",
    config = function()
      require("bufferline").setup({
        options = {
          mode = "buffers",
          show_buffer_close_icons = false,
          show_close_icon = false,
          truncate_names = false,
          diagnostics = false,
          separator_style = { "|", "|" },
          always_show_bufferline = true,
          numbers = "none",
        },
      })
    end,
  },
}

Equally important is what’s not included: no file‑tree plugin (ranger and Telescope cover navigation), no statusline plugin (the built‑in one plus custom highlights suffice), and no AI‑powered completion. Every plugin must justify its presence.

Putting It All Together Top

When you start Neovim:

init.lua sets options, loads lazy.nvim, and schedules the colour setup.
Lazy.nvim parses plugins/core.lua and begins loading plugins by their lazy‑load triggers.
The scheduled callback applies the theme, defines global keymaps and commands.
When a buffer is opened, Treesitter attaches, the appropriate ftplugin fires, and snippets register for that filetype.
On InsertEnter, nvim‑cmp activates with all snippet and LSP sources ready.

At no point does the user wait for a progress bar. The entire plugin set, once cached, starts in under 100 milliseconds.

Reproducibility & Final Thoughts Top

This configuration is a build artifact. The lazy-lock.json pins every plugin version, the colours are hard‑coded hex values, and every snippet and function is defined in Lua. To replicate the environment on a new machine, you only need:

📥 Download neovim full config 2026


    # extract the zip file and
    cp nvim ~/.config/nvim
    nvim --headless "+Lazy sync" +qa

After that, your editor will start in under 100 ms and behave exactly as it does today.

The seven companion articles dive deeper into each subsystem: the bootstrapping layer, filetype engines, custom functions, snippets, colours, keymaps/commands, and the plugin ecosystem. But the article you’ve just read contains the complete source and the reasoning you need to build your own ultimate Neovim setup.

The Developer’s Dashboard: Completion, Treesitter, and the Plugin Ecosystem

2026-05-15T18:03:11+00:00

Plugins with Purpose

A Neovim configuration can easily drown in plugins. This setup takes the opposite approach: every plugin must solve a problem that cannot be addressed with a few lines of Lua. The result is a lean dashboard where Treesitter provides structural understanding, nvim‑cmp offers intelligent completion, LuaSnip gives programmable snippets, and bufferline keeps tabs visible without visual clutter.

In this final article we open lua/plugins/core.lua – the single file that defines the entire plugin set. We’ll examine why each plugin was chosen, how it’s configured, and how it integrates with the custom functions and snippets we’ve built throughout the series.

The Complete Plugin Specification

Below is the full plugins/core.lua file, broken into sections for discussion.

Themes: Nordic and Tokyonight

Two themes are loaded with lazy = false and high priority, ensuring they are available when colors.lua runs its scheduled setup. Both are configured with transparent backgrounds – Nordic via its transparent option, Tokyonight via transparent = true. The fallback logic (Article #5) means the editor is never without a colourscheme.


{
  "AlexvZyl/nordic.nvim",
  lazy = false,
  priority = 1000,
  config = function()
    require("nordic").setup({
      transparent = {
        bg = true,
        float = true,
      },
    })
    require("nordic").load()
  end,
},

{
  "folke/tokyonight.nvim",
  lazy = false,
  priority = 1000,
  opts = {
    style = "storm",
    transparent = true,
    styles = {
      comments = { italic = true },
      keywords = { italic = true },
    },
  },
},

Telescope: Fuzzy Everything

Telescope is loaded on the Telescope command (not at startup) and provides three essential fuzzy finders: files, live grep, and buffers. The keymaps (<leader>ff, <leader>fg, <leader>fb) are defined in its config callback.


{
  "nvim-telescope/telescope.nvim",
  dependencies = { "nvim-lua/plenary.nvim" },
  cmd = "Telescope",
  config = function()
    local builtin = require("telescope.builtin")
    vim.keymap.set("n", "ff", builtin.find_files)
    vim.keymap.set("n", "fg", builtin.live_grep)
    vim.keymap.set("n", "fb", builtin.buffers)
    vim.keymap.set("n", "fh", builtin.help_tags)
  end,
},

Treesitter: The Backbone

Treesitter provides structural syntax highlighting and indentation. It’s loaded on BufReadPost and BufNewFile – never at startup – and a minimal set of parsers is installed. The highlight and indent modules are enabled; both are non‑negotiable for accurate editing.


{
  "nvim-treesitter/nvim-treesitter",
  build = ":TSUpdate",
  event = { "BufReadPost", "BufNewFile" },
  config = function()
    require("nvim-treesitter.configs").setup({
      ensure_installed = {
        "lua", "python", "javascript", "html", "css", "bash", "c", "cpp", "json", "yaml",
      },
      highlight = { enable = true },
      indent = { enable = true },
    })
  end,
},

nvim-cmp and LuaSnip: The Completion Engine

Completion is the most complex subsystem. nvim-cmp is loaded on InsertEnter and configured with four sources: LSP, LuaSnip, buffer text, and file paths. The snippet expansion is handled by LuaSnip; the Tab key is overloaded to both cycle completion items and expand/advance snippets.

Critically, after cmp.setup(), the configuration loads the snippet files we analysed in Article #4 – config.tex_snippets and config.html_snippets – ensuring snippets are registered before the user starts typing.


{
  "hrsh7th/nvim-cmp",
  dependencies = {
    "hrsh7th/cmp-nvim-lsp",
    "hrsh7th/cmp-buffer",
    "hrsh7th/cmp-path",
    "saadparwaiz1/cmp_luasnip",
    "L3MON4D3/LuaSnip",
  },
  event = "InsertEnter",
  config = function()
    local cmp = require("cmp")
    local luasnip = require("luasnip")

    vim.o.completeopt = "menu,menuone,noselect"

    cmp.setup({
      snippet = {
        expand = function(args)
          luasnip.lsp_expand(args.body)
        end,
      },
      mapping = cmp.mapping.preset.insert({
        [''] = cmp.mapping.complete(),
        [''] = cmp.mapping.confirm({ select = true }),
        [''] = cmp.mapping(function(fallback)
          if cmp.visible() then
            cmp.select_next_item()
          elseif luasnip.expand_or_jumpable() then
            luasnip.expand_or_jump()
          else
            fallback()
          end
        end, { "i", "s" }),
        [''] = cmp.mapping(function(fallback)
          if cmp.visible() then
            cmp.select_prev_item()
          elseif luasnip.jumpable(-1) then
            luasnip.jump(-1)
          else
            fallback()
          end
        end, { "i", "s" }),
      }),
      sources = cmp.config.sources({
        { name = 'nvim_lsp' },
        { name = 'luasnip' },
        { name = 'buffer' },
        { name = 'path' },
      }),
    })

    -- Load LaTeX snippets
    require("config.tex_snippets")
    -- Load HTML snippets
    require("config.html_snippets")
  end,
},

Mason: LSP Without the Pain

Mason manages LSP servers, linters, and formatters. It’s loaded with build = ":MasonUpdate" to ensure the registry is up‑to‑date. The configuration is minimal – just require("mason").setup(). The LSP servers are currently commented out in this configuration, but the infrastructure is ready to be uncommented when needed. Keeping Mason in the plugin list even without active LSP servers means :MasonInstall is always available.


{
  "williamboman/mason.nvim",
  build = ":MasonUpdate",
  config = function() require("mason").setup() end,
},

Bufferline: Visible Tabs, Minimalist

Bufferline shows open buffers as tabs. It’s configured to be as minimal as possible: no close icons, no diagnostics, no numbers, just separator characters between buffer names. always_show_bufferline = true prevents it from disappearing when only one buffer is open.


{
  "akinsho/bufferline.nvim",
  version = "*",
  config = function()
    require("bufferline").setup({
      options = {
        mode = "buffers",
        show_buffer_close_icons = false,
        show_close_icon = false,
        show_tab_indicators = false,
        truncate_names = false,
        diagnostics = false,
        indicator = { style = "none" },
        separator_style = { "|", "|" },
        always_show_bufferline = true,
        numbers = "none",
      },
    })
  end,
},

The Plugin Philosophy: What’s Missing

Equally important is what’s not in this configuration:

No file‑tree plugin – ranger (Article #6) and Telescope cover file navigation without a permanent sidebar.
No statusline plugin – Neovim’s built‑in statusline is sufficient, and custom highlights keep it readable.
No Git gutter – Git operations are handled in the terminal, keeping the editor free of constant change‑tracking visual noise.
No AI completion – completion is limited to deterministic sources: LSP, snippets, buffer words, and file paths.

Every omission is a deliberate choice. Each plugin that is included must justify itself every time the editor starts, and none is loaded until needed.

How the Dashboard Comes Together

When Neovim starts:

init.lua sets options, loads lazy.nvim, and schedules the colour setup.
Lazy.nvim parses plugins/core.lua and begins loading plugins by their lazy‑load triggers (events, commands, keys).
The scheduled callback applies the theme, defines global keymaps and commands.
When a buffer is opened, Treesitter attaches, the appropriate ftplugin fires, and snippets register for that filetype.
On InsertEnter, nvim‑cmp activates with all snippet and LSP sources ready.

At no point does the user wait for a progress bar. The entire plugin set, once cached, starts in under 100 milliseconds. The dashboard is ready before you can think about it.

Closing the Series

Over seven articles, we’ve dissected a Neovim configuration from the bootstrapping layer through filetype engines, automation functions, snippet systems, visual theming, keymaps, and finally the plugin ecosystem. The configuration is fully reproducible: clone the repository, run :Lazy sync, and every file, every function, and every colour is exactly as intended.

The real takeaway is not the specific keybindings or colours, but the engineering mindset: treat your editor as a programmable platform, not a settings file. Build functions, not just mappings. Prefer determinism over convenience defaults. And always be able to explain why every plugin is there.

This configuration will continue to evolve, but the principles documented here are timeless. Happy engineering.

The Toolbelt: Keymaps, User Commands, and File‑Operation Pipelines

2026-05-15T17:39:04+00:00

Turning Functions Into a Control Surface

Custom functions (covered in Article #3) are the engine; keymaps and user commands are the steering wheel and dashboard. A well‑designed Neovim configuration makes the most frequent operations available without a thought – and the less frequent ones discoverable through muscle‑memory shortcuts or short colon commands.

This article opens lua/config/keymaps.lua and lua/config/commands.lua and shows how they form a unified toolbelt. Every mapping is intentionally chosen; every command mirrors a function but adds a discoverability layer. We’ll also examine the ranger file‑chooser integration and the buffer‑wrapping utilities that bridge the editor to external workflows.

The Keymaps Layer

The file lua/config/keymaps.lua is loaded in the scheduled callback of init.lua, after plugins and functions are available. It defines global keybindings that never depend on a specific filetype – filetype‑specific mappings live in ftplugin/ (Article #2). This separation keeps the global mapset clean and predictable.

The complete keymaps file:


local opts = { noremap = true, silent = true }
local functions = require("config.functions")

-- Copy whole file to system clipboard
vim.keymap.set("n", "cc", 'gg"+yG', opts)
vim.keymap.set("v", "", '"+y', opts)
vim.keymap.set("v", "7", '"+y', opts)
vim.keymap.set("i", "", '+', opts)

-- Toggle line numbers
vim.keymap.set("n", "l", ":set number! relativenumber!", opts)

-- redo
vim.keymap.set("n", "r", '', opts)

-- Buffer navigation
vim.keymap.set("n", "", ":bn", opts)
vim.keymap.set("n", "", ":bp", opts)

-- Window movements
vim.keymap.set("n", "", "", opts)
vim.keymap.set("n", "", "", opts)

-- Python selection execution (Visual mode)
vim.keymap.set("v", "c", functions.run_python_selection, { noremap = true })
vim.keymap.set("v", "r", functions.run_python_and_replace, { noremap = true })

-- Run scripts on files/selection
vim.keymap.set("n", "rf", functions.run_scripts_on_files, opts)
vim.keymap.set("v", "rs", functions.run_scripts_on_select, { noremap = true })

-- Basic file commands
vim.keymap.set("n", "w", ":w", opts)
vim.keymap.set("n", "q", ":q", opts)
vim.keymap.set("n", "h", ":nohlsearch", opts)

-- Window navigation using Ctrl + hjkl
vim.keymap.set("n", "", "h", opts)
vim.keymap.set("n", "", "j", opts)
vim.keymap.set("n", "", "k", opts)
vim.keymap.set("n", "", "l", opts)

-- Selection and utility commands
vim.keymap.set("n", "v", functions.select_inside_any_pair, opts)
vim.keymap.set("n", "wc", functions.word_count, opts)
vim.keymap.set("n", "mm", functions.output_old_files, opts)
vim.keymap.set("n", "cc", functions.command_history_explorer, opts)
vim.keymap.set("n", "rr", functions.output_regs, opts)
vim.keymap.set("n", "hh", functions.wrap_code_in_buffer, opts)
vim.keymap.set("n", "ranger", functions.ranger_chooser, opts)


vim.keymap.set("n", "ì", "^", opts)
vim.keymap.set("o", "ì", "^", opts)

local ls = require("luasnip")


-- Forward jump to <++> (now using Ctrl+L)
vim.cmd([[
  inoremap  /<++>"_c4l
  nnoremap  /<++>"_c4l
]])

-- Backward jump to <++> (now using Ctrl+H)
vim.cmd([[
  inoremap  ?<++>"_c4l
  nnoremap  ?<++>"_c4l
]])

-- LuaSnip forward/backward jumps with Ctrl+J / Ctrl+K
vim.keymap.set("i", "", function() require("luasnip").jump(1) end, { silent = true })
vim.keymap.set("i", "", function() require("luasnip").jump(-1) end, { silent = true })

Several design patterns stand out:

Mnemonic leader prefixes: <leader>wc for word count, <leader>cc for command history, <leader>rr for registers. The leader key is , so these are fast two‑stroke combos.
Buffer and window movement: Tab/Shift‑Tab for buffer switching, Ctrl‑hjkl for window navigation. No arrow‑key dependency, minimal finger travel.
Placeholder jumping: Ctrl‑L and Ctrl‑H jump to the next/previous <++> placeholder – a convention used throughout snippets and insert‑mode expansions. This is separate from LuaSnip’s Ctrl‑J/Ctrl‑K for snippet node jumps.
Clipboard shortcuts: cc in normal mode copies the entire file. Ctrl‑c in visual mode copies selection. Ctrl‑v in insert mode pastes.

User Commands: The Discoverable Layer

Keymaps are fast but invisible. User commands (the : interface) serve as the discoverable, self‑documenting counterpart. The file lua/config/commands.lua creates one command per major function:


local functions = require("config.functions")

-- Create user commands
vim.api.nvim_create_user_command("WC", functions.word_count, {})
vim.api.nvim_create_user_command("Mm", functions.output_old_files, {})
vim.api.nvim_create_user_command("MM", functions.output_old_files, {})
vim.api.nvim_create_user_command("Cc", functions.command_history_explorer, {})
vim.api.nvim_create_user_command("CC", functions.command_history_explorer, {})
vim.api.nvim_create_user_command("Ss", functions.search_command_history, {})
vim.api.nvim_create_user_command("SS", functions.search_command_history, {})
vim.api.nvim_create_user_command("Rr", functions.output_regs, {})
vim.api.nvim_create_user_command("RR", functions.output_regs, {})
vim.api.nvim_create_user_command("HH", functions.wrap_code_in_buffer, {})
vim.api.nvim_create_user_command("RangerChooser", functions.ranger_chooser, {})
vim.api.nvim_create_user_command("SaveVimInfo", functions.save_vim_bindings_and_functions, {})
vim.api.nvim_create_user_command("EngType", functions.eng_type, {})
vim.api.nvim_create_user_command("FrType", functions.fr_type, {})

Commands are kept short (often two or three uppercase letters) to minimise typing. A few have dual‑case variants (e.g., :Mm and :MM) – the uppercase version is a deliberate redundancy, ensuring the command still works if Caps Lock is on.

Every command mirrors a function from functions.lua but requires no modifier key. This makes the toolbelt accessible from both muscle‑memory (keymap) and conscious recall (command palette / command history).

The Ranger Chooser: External Tool Integration

The ranger_chooser() function (and its :RangerChooser command) launches the ranger terminal file manager and opens all selected files as Neovim arguments. It detects whether Neovim is running in a GUI or terminal and adapts:


function M.ranger_chooser()
  local temp = vim.fn.tempname()
  if vim.fn.has('gui_running') == 1 then
    vim.fn.system('xterm -e ranger --choosefiles=' .. vim.fn.shellescape(temp))
  else
    vim.fn.system('ranger --choosefiles=' .. vim.fn.shellescape(temp))
  end

  if vim.fn.filereadable(temp) == 0 then
    vim.cmd('redraw!')
    return
  end

  local names = vim.fn.readfile(temp)
  if #names == 0 then
    vim.cmd('redraw!')
    return
  end

  vim.cmd('edit ' .. vim.fn.fnameescape(names[1]))
  for i = 2, #names do
    vim.cmd('argadd ' .. vim.fn.fnameescape(names[i]))
  end
  vim.cmd('redraw!')
end

This is the Unix philosophy in action: let ranger do what it does best (file navigation) and let Neovim do what it does best (editing). The integration is a thin glue layer – a temporary file is used to pass the selected paths back, and Neovim’s argument list (:args) is populated so you can navigate between the chosen files with :next and :prev.

The HH Wrapper: Format Conversion on Demand

The wrap_code_in_buffer() function (bound to <leader>hh and :HH) takes the current buffer’s content and wraps it in <pre><code> tags, opening the result in a new buffer with HTML filetype. This is used constantly when writing articles that embed code blocks.


function M.wrap_code_in_buffer()
  local save_cursor = vim.fn.getpos('.')
  local buffer_text = vim.api.nvim_buf_get_lines(0, 0, -1, false)

  vim.cmd('enew')
  vim.bo.buftype = 'nofile'
  vim.bo.bufhidden = 'wipe'
  vim.bo.swapfile = false
  vim.wo.wrap = false
  vim.bo.filetype = 'html'

  local content = '\n' ..
                  table.concat(buffer_text, "\n") ..
                  '\n'

  vim.api.nvim_buf_set_lines(0, 0, -1, false, vim.split(content, "\n"))
  vim.fn.setpos('.', save_cursor)
end

A similar wrapper exists in the LaTeX ftplugin (Article #2), but this global version works on any buffer. Together they form a small but powerful content pipeline: write in your preferred language, hit a key, get a properly escaped HTML code block ready for the blog.

Composability and Consistency

The keymaps and commands layer follows a strict rule: every keybinding has a corresponding user command, and every command delegates to a single function. There are no inline Vimscript hacks, no copy‑pasted logic. This makes the system:

Auditable: you can trace any action from keypress to function in seconds.
Remappable: changing a keybinding never breaks the command‑line interface, and vice versa.
Documentable: the user commands themselves serve as living documentation.

The toolbelt doesn’t try to do everything – it focuses on operations that are too frequent to type out manually but too specific for a general‑purpose plugin. Combined with the filetype‑specific maps (Article #2) and the snippet system (Article #4), the editor becomes a personalised engineering console.

In the final article, we’ll survey the plugin ecosystem – Treesitter, completion, LSP, and bufferline – and how they complete the developer dashboard.

The Visual Stack: Deterministic Themes, Transparency, and Custom Highlights

2026-05-15T16:43:50+00:00

When the Editor Must Look the Same Everywhere

A developer’s editor is a visual environment. Inconsistent colours, jarring flash‑of‑white on startup, or missing highlights break concentration. This configuration treats the visual layer as a deterministic build step: a fallback colourscheme is set immediately, the real theme loads asynchronously, and a series of overrides applies custom highlights that survive theme updates.

This article walks through lua/config/colors.lua – the single module that governs everything visual. We’ll see how it selects between Nordic and Tokyonight, how it makes almost every UI element transparent, and how it re‑applies critical highlights after every ColorScheme event.

The Fallback Strategy

Inside init.lua, right after the basic options, we call vim.cmd("colorscheme desert"). This is not the final theme – it is a bullet‑proof fallback. If the later scheduled call to colors.setup() fails (for example, because the Nordic plugin is missing or broken), the editor still has a working, readable colourscheme.

The fallback also eliminates the “flash of unstyled text” during startup. By setting desert synchronously, Neovim never renders a completely unstyled buffer before the real theme arrives.

The colors.lua Module

The module is structured as a single setup() function that:

Enables true‑colour support (vim.o.termguicolors = true).
Sets background = "dark".
Attempts to load nordic (the preferred theme). If that fails, it falls back to desert and logs a warning.
Restores number and cursorline settings (some themes override them).
Applies dozens of custom highlight groups for cursor, statusline, search, folds, spelling, line numbers, bufferline, and more.

The entire file is reproduced below. Note how every highlight uses explicit colours (no reference to theme palette variables). This is deliberate: it ensures the highlights look identical whether Nordic or Tokyonight is active.


-- lua/config/colors.lua
-- Colors and highlights configuration (safe + explicit)
local M = {}

function M.setup()
  -- Ensure true color support
  vim.o.termguicolors = true

  -- Preferred background
  vim.o.background = "dark"

  -- Try to load the tokyonight colorscheme safely
  local ok, err = pcall(vim.cmd, "colorscheme nordic")
  if not ok then
    -- Fallback to desert and warn the user in :messages
    vim.cmd("colorscheme desert")
    vim.notify("Warning: Falling back to 'desert'. Error: " .. tostring(err), vim.log.levels.WARN)
  end

  -- Ensure line numbers and cursorline are enabled (set after colorscheme to avoid overrides)
  vim.wo.number = true
  vim.wo.relativenumber = true
  vim.wo.cursorline = true

  -- Then set custom highlight groups
  -- Cursor line / column
  vim.api.nvim_set_hl(0, "CursorLine", { bg = "#3b4261", bold = true })
  vim.api.nvim_set_hl(0, "CursorColumn", { bg = "#3b4261", blend = 80 })
  vim.api.nvim_set_hl(0, "Cursor", { bg = "#2a2e38", fg = "#ffffff", blend = 70 })
  -- Perfect cursor for Nordic: subtle blue, visible, does not obscure text
  vim.api.nvim_set_hl(0, "Cursor", {
    bg = "#434C5E",  -- softer Nordic blue
    fg = "#ECEFF4",  -- visible over any code
    blend = 60       -- transparency so text stays readable underneath
  })

  -- Status line and visual selection
  vim.api.nvim_set_hl(0, "StatusLine", { bg = "#1f2335", fg = "#c0caf5", bold = true })
  vim.api.nvim_set_hl(0, "Visual", { bg = "#FFD966", fg = "black" })

  -- Fold / Search
  vim.api.nvim_set_hl(0, "Folded", { bg = "none", fg = "#737aa2", italic = true })
  vim.api.nvim_set_hl(0, "Search", { bg = "#ff9e64", fg = "black", bold = true })

  -- Spell checking highlights
  vim.api.nvim_set_hl(0, "SpellBad", { underline = true, sp = "#db4b4b" })
  vim.api.nvim_set_hl(0, "SpellLocal", { underline = true, sp = "#0db9d7" })
  vim.api.nvim_set_hl(0, "SpellRare", { underline = true, sp = "#bb9af7" })
  vim.api.nvim_set_hl(0, "SpellCap", { underline = true, sp = "#e0af68" })

  -- Line number colors
  vim.api.nvim_set_hl(0, "LineNr", { fg = "#FFFF00" })
  vim.api.nvim_set_hl(0, "CursorLineNr", { fg = "#c0caf5", bold = true })

  -- BufferLine colors
  vim.api.nvim_set_hl(0, "BufferLineBufferSelected", { bold = true, fg = "#ffca00" })
  vim.api.nvim_set_hl(0, "BufferLineModifiedSelected", { fg = "#ff9e64" })
end

-- Final transparency patch (works for all themes)
local transparent_groups = {
  "Normal", "NormalNC", "NormalFloat",
  "SignColumn", "MsgArea",
  "TelescopeNormal", "TelescopeBorder",
  "StatusLine", "StatusLineNC",
  "BufferLineFill", "BufferLineBackground",
  "LineNr", "CursorLineNr",
  "FloatBorder",
}

for _, group in ipairs(transparent_groups) do
  vim.api.nvim_set_hl(0, group, { bg = "none" })
end

-- Reapply custom highlight after everything is loaded
vim.api.nvim_create_autocmd({"ColorScheme", "User"}, {
  pattern = {"LazyDone", "VeryLazy"},
  callback = function()
    vim.api.nvim_set_hl(0, "MatchParen", { bg = "#ff33aa", fg = "#000000", bold = true })
    vim.api.nvim_set_hl(0, "MatchParenCur", { bg = "#ff33aa", fg = "#000000", bold = true })
    vim.api.nvim_set_hl(0, "MatchWord",  { bg = "#5555ff", fg = "#000000" })
  end,
})

return M

Transparency as a Design Decision

The bottom half of the file sets bg = "none" on a carefully chosen set of highlight groups. Groups like Normal, SignColumn, FloatBorder, and BufferLineBackground become transparent, letting the terminal background show through. This creates a clean, borderless look that works with any terminal colour scheme.

Groups that must remain opaque (e.g., CursorLine, Visual, Search) are explicitly given backgrounds, so readability is never compromised. The separation is deliberate: structural UI elements become transparent, content‑focused elements keep their solid backgrounds.

The Autocommand That Fixes Everything

Some plugin managers or theme reloads can reset highlight groups. To combat this, the file registers an autocommand on ColorScheme and User events (specifically LazyDone and VeryLazy) that re‑applies a set of critical highlights:

MatchParen and MatchParenCur – a bright pink background that makes matching brackets unmistakable.
MatchWord – a blue background for the word under cursor when using * or #.

By re‑applying these after every theme change, the configuration guarantees that your most important visual cues never disappear.

Why Not Just Use a Theme’s Variables?

Many colour configurations use theme palette variables (e.g., colors.blue) so that highlight groups automatically adapt to the current theme. This configuration intentionally avoids that. By using raw hex codes, it decouples the custom highlights from any particular theme’s palette. Whether you’re running Nordic, Tokyonight, or fallback Desert, the cursor line is always #3b4261, the search highlight is always #ff9e64, and matching brackets always explode in pink.

The tradeoff is that you must choose colours that work across multiple themes. The benefit is absolute determinism – the visual experience does not shift when you change or update a theme.

The Full Picture

Together, the fallback colourscheme, the scheduled theme application, the transparent UI groups, and the autocommand re‑application create a visual stack that is:

Resilient: the editor always starts with a functional theme.
Consistent: custom highlights never depend on which theme loads.
Clean: transparency removes visual noise.
Reproducible: the same hex values produce the same pixels on any machine.

In the next article, we’ll explore the keymaps and commands that wire all these subsystems together into a unified user interface.

Snippets as Code: LuaSnip, Dynamic Expansion, and File‑Based Snippet Injection

2026-05-15T16:33:12+00:00

Snippets Should Be Logic, Not Just Text

Most snippet systems treat expansions as static templates: you type a trigger, you get a fixed block of text. LuaSnip in Neovim allows something far more powerful – snippets can run Lua functions, read external files, and adapt to the current file or directory. This turns snippet expansion into a programmable, context‑aware automation layer.

In this article we open the two snippet configuration files that power LaTeX, HTML, and Markdown editing: lua/config/tex_snippets.lua and lua/config/html_snippets.lua. We’ll examine how they replace a legacy directory of static snippet files, how they integrate with nvim-cmp, and how they enable everything from auto‑numbered exercises to inline HTML figure injection.

The Legacy Problem

Before LuaSnip, Neovim relied on snippet engines like UltiSnips or external files stored in ~/.vim/snippets/. Those files were plain text, loaded once, and had no runtime intelligence. This configuration migrated to LuaSnip for three reasons:

Reproducibility: everything lives in Lua, no external directories to sync.
Dynamic behaviour: snippets can count existing environments, query the current directory, and insert content based on context.
Integration with native completion: LuaSnip plugs directly into nvim-cmp as a source, so snippets appear in the autocompletion menu.

The old snippet files still exist (in ~/.vim/snippets/latex/) but are now consumed by LuaSnip functions that read their content on demand, preserving the original text blocks while adding programmability.

The html_snippets.lua: Straightforward but Complete

HTML and Markdown share three core snippets: anchor links, figure/image blocks, and code blocks. Each is defined using LuaSnip’s node types: s() for the snippet, i() for insert‑node placeholders, t() for text, and f() for function nodes that compute values at expansion time.

The code block snippet is particularly clever: it uses a function node to duplicate the language name so it appears both in the <pre class="language-…"> and the <code class="language-…"> tags, avoiding manual repetition. The snippet also wraps the body in … tags – a nod to Jinja2 templates used in static site generation – to prevent Liquid/Jinja syntax from being parsed inside code blocks.


local ls = require("luasnip")
local s = ls.snippet
local i = ls.insert_node
local t = ls.text_node
local f = ls.function_node

-- Define snippets once
local snippets = {
  -- Anchor link
  s("a", {
    t(''), i(2, "link text"), t(""), i(0),
  }),

  -- Figure with img and figcaption
  s("fig", {
    t(""),
    t({ "", "    " }),
    t(''),
    t({ "", "    " }),
    t(""), i(3, "caption"), t(""),
    t({ "", "" }),
    i(0),
  }),

-- Enable for both HTML and Markdown files
ls.add_snippets("html", snippets)
ls.add_snippets("markdown", snippets)

The tex_snippets.lua: A Snippet Engine for LaTeX

LaTeX editing demands a much richer set of snippets. The tex_snippets.lua file exports two things: a table of functions for direct insertion (called by the LaTeX ftplugin), and a collection of LuaSnip snippet definitions. It uses three design patterns:

Environment snippets with auto‑closing: env_snip() creates a snippet that inserts \begin{…} and \end{…} with the environment name mirrored via a function node.
Auto‑numbered exercises: the exe snippet counts how many \begin{exe} environments already exist in the buffer and inserts the next number automatically.
External file injection: file_snippet() reads a file from ~/.vim/snippets/latex/ and inserts its content as the snippet body, bridging the legacy snippet directory.

The curr_file_base_name() helper reads the numeric prefix of the current working directory, used by cse and similar snippets to auto‑label sections (e.g., \csection[01-exer]{…}). This is a deterministic system: the same directory always produces the same numbering.


local ls = require("luasnip")
local s = ls.snippet
local i = ls.insert_node
local t = ls.text_node
local f = ls.function_node

local M = {}

-- Helper to create environment snippet with jumpable placeholder
local function env_snip(trigger, default_env)
  return s(trigger, {
    t({"\\begin{"}), i(1, default_env), t({"}", "    <++>"}),  -- insert <++> as literal text
    t({"", "\\end{"}), f(function(args) return args[1][1] end, {1}), t("}")
  })
end

-- Helper to get the first part of current directory name
local function curr_file_base_name()
  local cwd = vim.fn.system("basename $(pwd) | cut -d'-' -f1")
  return cwd:gsub("\n", "")
end

-- =============================
-- Native LuaSnip LaTeX snippets
-- =============================
ls.add_snippets("tex", {
  env_snip("beg", "tabular"),
  env_snip("eq", "equation"),
  env_snip("mat", "bmatrix"),

  -- Sections
  s("sec", { t("\\section{"), i(1,"Title"), t({"", "    <++>"}), t("}") }),
  s("ssec", { t("\\subsection{"), i(1,"Subtitle"), t({"", "    <++>"}), t("}") }),

  -- Items and math
  s("itm", { t("\\item "), t("<++>") }),
  s("dollar", { t("$"), t("<++>"), t("$") }),
  s("frac", {
     t("\\frac{"), i(1), t("}{"), i(2), t("}"), i(0)
  }),
  s("sum", { t("\\sum_{"), t("<++>"), t("}^{"), t("<++>"), t("} "), t("<++>") }),

  -- =============================
  -- Exercise environment with auto-number
  -- =============================
  s("exe", {
    t("\\begin{exe}{"), i(1, "<++>"), t("}"),
    t({"", "    "}), f(function()
      local count = 0
      for _, line in ipairs(vim.api.nvim_buf_get_lines(0, 0, -1, false)) do
        if line:match("\\begin{exe}") then count = count + 1 end
      end
      return tostring(count)
    end, {}),
    t({"", "    <++>", "\\end{exe}"}),
  }),

  -- Sexe environment
  s("sex", {
    t({"\\begin{sexe}{", ""}), i(1, "<++>"), t({"", "    <++>", "\\end{sexe}"})
  }),

  -- Minipage snippet
  s("mini", {
    t({"\\begin{minipage}[t]{"}), i(1, "<++>"), t("\\textwidth}"), t({"", "    <++>", "\\end{minipage}", "\\hspace*{0.1cm}", "\\vl{0}{5}", "\\hspace*{0.1cm}", "\\begin{minipage}[t]{"}),
    i(2, "<++>"), t("\\textwidth}"), t({"", "    <++>", "\\end{minipage}"})
  }),

  -- Standalone document
  s("stand", {
    t({"\\documentclass{standalone}", "\\standaloneconfig{margin=5mm}"})
  }),
})

-- Section snippets using the directory prefix
ls.add_snippets("tex", {
  -- csection
  s("cse", {
    t({"\\vspace*{0.3cm}", "\\csection["}),
    t(curr_file_base_name() .. "-"), i(1, "exer"),
    t({"]{"}),
    f(function(args) return args[1] end, {1}),
    t({"}\\\\", "\\vspace*{0.3cm}"})
  }),

  -- cssection
  s("csse", {
    t({"\\vspace*{0.3cm}", "\\cssection["}),
    t(curr_file_base_name() .. "-"), i(1, "exer"),
    t({"]{"}),
    f(function(args) return args[1] end, {1}),
    t({"}\\\\", "\\vspace*{0.3cm}"})
  }),

  -- csssection
  s("cssse", {
    t({"\\vspace*{0.3cm}", "\\csssection["}),
    t(curr_file_base_name() .. "-"), i(1, "exer"),
    t({"]{"}),
    f(function(args) return args[1] end, {1}),
    t({"}\\\\", "\\vspace*{0.3cm}"})
  }),
})

-- =============================
-- Helper to load old snippet files dynamically
-- =============================
local function read_file(path)
  local lines = {}
  for line in io.lines(path) do
    table.insert(lines, line)
  end
  return lines
end

local function file_snippet(trigger, filepath)
  return s(trigger, f(function() return read_file(filepath) end, {}))
end

-- =============================
-- Old external snippet files as LuaSnip snippets
-- =============================
ls.add_snippets("tex", {
  file_snippet("tcb", "/home/mosaid/.vim/snippets/latex/tcb"),
  file_snippet("ds",  "/home/mosaid/.vim/snippets/latex/ds"),
  file_snippet("st",  "/home/mosaid/.vim/snippets/latex/st"),
  file_snippet("ar",  "/home/mosaid/.vim/snippets/latex/ar"),
  file_snippet("gg",  "/home/mosaid/.vim/snippets/latex/gg"),
  file_snippet("mtab","/home/mosaid/.vim/snippets/latex/mtab"),
  file_snippet("d1",  "/home/mosaid/.vim/snippets/latex/d1"),
  file_snippet("li",  "/home/mosaid/.vim/snippets/latex/li"),
  file_snippet("tight","/home/mosaid/.vim/snippets/latex/tight"),
  file_snippet("enum","/home/mosaid/.vim/snippets/latex/enum"),
})

-- Define the functions that tex.lua is trying to call
M.tcb = function()
  local lines = read_file("/home/mosaid/.vim/snippets/latex/tcb")
  local cursor = vim.api.nvim_win_get_cursor(0)
  vim.api.nvim_buf_set_lines(0, cursor[1] - 1, cursor[1] - 1, false, lines)
end

M.ds = function()
  local lines = read_file("/home/mosaid/.vim/snippets/latex/ds")
  local cursor = vim.api.nvim_win_get_cursor(0)
  vim.api.nvim_buf_set_lines(0, cursor[1] - 1, cursor[1] - 1, false, lines)
end

M.st = function()
  local lines = read_file("/home/mosaid/.vim/snippets/latex/st")
  local cursor = vim.api.nvim_win_get_cursor(0)
  vim.api.nvim_buf_set_lines(0, cursor[1] - 1, cursor[1] - 1, false, lines)
end

M.ar = function()
  local lines = read_file("/home/mosaid/.vim/snippets/latex/ar")
  local cursor = vim.api.nvim_win_get_cursor(0)
  vim.api.nvim_buf_set_lines(0, cursor[1] - 1, cursor[1] - 1, false, lines)
end

M.gg = function()
  local lines = read_file("/home/mosaid/.vim/snippets/latex/gg")
  local cursor = vim.api.nvim_win_get_cursor(0)
  vim.api.nvim_buf_set_lines(0, cursor[1] - 1, cursor[1] - 1, false, lines)
end

M.mtab = function()
  local lines = read_file("/home/mosaid/.vim/snippets/latex/mtab")
  local cursor = vim.api.nvim_win_get_cursor(0)
  vim.api.nvim_buf_set_lines(0, cursor[1] - 1, cursor[1] - 1, false, lines)
end

M.d1 = function()
  local lines = read_file("/home/mosaid/.vim/snippets/latex/d1")
  local cursor = vim.api.nvim_win_get_cursor(0)
  vim.api.nvim_buf_set_lines(0, cursor[1] - 1, cursor[1] - 1, false, lines)
end

M.li = function()
  local lines = read_file("/home/mosaid/.vim/snippets/latex/li")
  local cursor = vim.api.nvim_win_get_cursor(0)
  vim.api.nvim_buf_set_lines(0, cursor[1] - 1, cursor[1] - 1, false, lines)
end

M.tight = function()
  local lines = read_file("/home/mosaid/.vim/snippets/latex/tight")
  local cursor = vim.api.nvim_win_get_cursor(0)
  vim.api.nvim_buf_set_lines(0, cursor[1] - 1, cursor[1] - 1, false, lines)
end

return M

The Dual Nature: Snippets and Functions

Notice that tex_snippets.lua defines both LuaSnip snippets and a set of functions (M.tcb(), M.ds(), etc.). The LaTeX ftplugin (from Article #2) calls these functions directly via insert‑mode mappings like <ESC>:lua require("config.tex_snippets").tcb()<CR>. This hybrid approach gives the user two ways to trigger an expansion:

Through the built‑in completion menu (LuaSnip integration with nvim-cmp).
Through muscle‑memory insert‑mode shortcuts that bypass the completion menu entirely.

The external file snippets are loaded lazily – they aren’t read from disk until the trigger is activated, keeping startup fast. The file_snippet() wrapper ensures that the content stays up‑to‑date with any external edits, making the transition from static snippet files seamless.

Integration with nvim-cmp

Snippets are useless without a good completion interface. The plugins/core.lua configures nvim-cmp to use luasnip as a source:


sources = cmp.config.sources({
  { name = 'nvim_lsp' },
  { name = 'luasnip' },
  { name = 'buffer' },
  { name = 'path' },
}),

The luasnip source is automatically populated with all snippets defined for the current filetype. Additionally, the cmp mapping for <Tab> prioritises snippet expansion over completion navigation – if a snippet is expandable, it expands; otherwise it cycles to the next completion item.

This design ensures that snippets feel like a native part of the editor, not an external bolted‑on feature.

Determinism and Portability

Every snippet in this configuration is defined in Lua, with no external dependencies except the legacy snippet files (which are themselves plain text). The auto‑numbering relies on scanning the current buffer, not on any global state. The directory‑based prefix uses a shell command that is explicitly deterministic.

This means you can clone the Neovim configuration to a new machine, run :Lazy sync, and immediately have the same snippet behaviour. No manual copying of snippet directories, no version mismatches.

In the next article, we’ll examine the visual stack: how themes, transparency, and custom highlights are applied with the same deterministic philosophy.

Automation, Not Just Shortcuts: Custom Functions that Think Like an IDE

2026-05-15T15:54:31+00:00

Beyond Keymaps: Functions as First‑Class Tools

Most Neovim users start by remapping keys. That’s fine, but it stops short of turning the editor into a programmable environment. The real power comes from custom Lua functions that do things no plugin can anticipate: running code asynchronously, replacing visual selections with computed results, exploring your command history like a file, or inspecting registers at a glance.

In this article we open lua/config/functions.lua – the heart of the automation layer – and walk through every major utility. You’ll see the full source for each function, understand why it was built, and learn how to wire it into your own workflow.

Architecture Overview

The file lua/config/functions.lua exports a table of functions. These are called from keymaps (defined in keymaps.lua) and user commands (defined in commands.lua). The module is loaded once during startup and reused everywhere.

The directory structure relevant to this article:


lua/config/
├── functions.lua     <-- all custom logic
├── keymaps.lua       <-- maps keys to functions
└── commands.lua      <-- creates :UserCommands

1. Async Python and LaTeX Runners

Two of the most frequently used functions are run_python_selection() and run_python_and_replace(). The first executes the visually selected Python code in a non‑blocking job, appending its output to a scratch buffer. The second does the same, but replaces the selection with the output – ideal for quick calculations directly in your code or prose.

Both functions use vim.fn.jobstart to avoid freezing the UI, and they automatically handle buffer cleanup when the job finishes or the user presses Enter. A similar async pattern is used in the LaTeX ftplugin (covered in Article #2), but the core helper functions are general enough to be reused for any language.


function M.run_python_selection()
  -- Check if in visual mode
  local mode = vim.fn.mode()
  if mode ~= 'v' and mode ~= 'V' then
    print("No visual selection")
    return
  end

  -- Save current register
  local save_reg = vim.fn.getreg('"')
  local save_regtype = vim.fn.getregtype('"')

  -- Yank selection into default register
  vim.cmd('normal! gvy')
  local code = vim.fn.getreg('"')

  -- Restore original register
  vim.fn.setreg('"', save_reg, save_regtype)

  -- Trim whitespace and prepend math import
  code = code:gsub('^%s*', ''):gsub('%s*$', '')
  code = "from math import *\n" .. code

  -- Execute Python code safely
  local ok, output = pcall(vim.fn.system, {'python3', '-c', code})
  if not ok then
    print("Error executing Python code")
    return
  end

  -- Open scratch buffer
  vim.cmd('enew')
  vim.api.nvim_buf_set_lines(0, 0, -1, false, vim.split(output, "\n"))

  -- Configure buffer
  vim.bo.buftype = 'nofile'
  vim.bo.bufhidden = 'wipe'
  vim.bo.swapfile = false
  vim.wo.wrap = false
end

The run_python_and_replace() variant handles single‑line selections specially: it wraps the expression in a print() so that the output replaces the expression inline. This is useful for evaluating math expressions inside Markdown or LaTeX documents.


function M.run_python_and_replace()
  local save_reg = vim.fn.getreg('"')
  local save_regtype = vim.fn.getregtype('"')
  vim.cmd('normal! ""gvy')
  local code = vim.fn.getreg('"')
  vim.fn.setreg('"', save_reg, save_regtype)

  code = code:gsub('^%s*', ''):gsub('%s*$', '')

  local start_line = vim.fn.line("'<")
  local end_line = vim.fn.line("'>")
  if start_line == end_line then
    code = 'print(' .. code .. ')'
  end

  code = "from math import *\n" .. code
  local output = vim.fn.system('python3 -c ' .. vim.fn.shellescape(code))
  output = output:gsub('\n+$', '')

  vim.cmd('normal! gv"_c' .. output)
end

2. Command History Explorer

The command‑line history in Vim is powerful but invisible. My command_history_explorer() function dumps the entire history (newest first) into a temporary buffer. You can navigate it with j/k or arrow keys, and pressing Enter executes the command under the cursor. Pressing q or Tab closes the buffer.

This effectively gives you a “command palette” with zero dependencies. Because the buffer is non‑modifiable and immediately searchable with /, you can filter through hundreds of past commands in seconds.


function M.command_history_explorer()
  local history = {}
  local count = vim.fn.histnr(':') -- number of commands in history

  -- Collect commands from newest to oldest
  for i = count, 1, -1 do
    local cmd = vim.fn.histget(':', i)
    if cmd ~= "" then
      table.insert(history, cmd)
    end
  end

  -- Create new buffer
  vim.cmd('enew')
  local buf = vim.api.nvim_get_current_buf()

  vim.api.nvim_buf_set_lines(buf, 0, -1, false, history)

  -- Buffer options
  vim.bo[buf].buftype = 'nofile'
  vim.bo[buf].bufhidden = 'wipe'
  vim.bo[buf].swapfile = false
  vim.bo[buf].modifiable = false
  vim.wo.wrap = false

  local opts = { buffer = buf, noremap = true, silent = true }

  -- Map arrow keys (raw sequences)
  vim.keymap.set('n', "\27[B", 'j', opts) -- Down
  vim.keymap.set('n', "\27[A", 'k', opts) -- Up

  -- Also allow hjkl
  vim.keymap.set('n', 'j', 'j', opts)
  vim.keymap.set('n', 'k', 'k', opts)

  -- Quit buffer quickly
  vim.keymap.set('n', 'q', function() vim.cmd('bd! ' .. buf) end, opts)

  -- Execute the command under cursor
  vim.keymap.set('n', '', function()
    local cmd = vim.fn.getline('.')
    vim.cmd('bd! ' .. buf) -- close history buffer
    vim.cmd(cmd)           -- execute command
  end, opts)

  -- Start at the top
  vim.cmd('normal! gg')
end

A variant, search_command_history(), opens a modifiable buffer so that incsearch can highlight matches. This is useful when you want to interactively search without closing the buffer.

3. Register Inspector

Registers are one of Vim’s most powerful features, yet most users never know what’s stored in them. The output_regs() function prints the contents of registers a through z into a scratch buffer, labelled clearly. It’s a simple idea, but it turns registers into a visible, reviewable tool.


function M.output_regs()
  vim.cmd('enew')
  vim.bo.buftype = 'nofile'
  vim.bo.bufhidden = 'wipe'
  vim.bo.swapfile = false
  vim.wo.wrap = false

  local content = {}
  for reg = string.byte('a'), string.byte('z') do
    local reg_char = string.char(reg)
    local reg_content = vim.fn.getreg(reg_char)
    if reg_content ~= '' then
      table.insert(content, reg_char .. ":")
      table.insert(content, reg_content)
      table.insert(content, "")
    end
  end

  vim.api.nvim_buf_set_lines(0, 0, -1, false, content)
  vim.cmd('normal! gg')
  print("Contents of registers a to z")
end

4. Select Inside Any Pair

Vi’s i{, i(, etc. are great, but they require you to think about which delimiter you’re inside. select_inside_any_pair() tries every common pair ({}, [], (), $...$ , quotes) and selects the innermost one that surrounds the cursor. If nothing matches, it falls back to selecting the current line.


function M.select_inside_any_pair()
  local savepos = vim.fn.getpos('.')
  local pairs = {
    {'{', '}'},
    {'[', ']'},
    {'(', ')'},
    {'$', '$'},
    {'"', '"'},
    {"'", "'"}
  }

  for _, pair in ipairs(pairs) do
    local open, close = pair[1], pair[2]
    local start, finish

    if open == close then
      start = vim.fn.searchpos('\\V' .. open, 'bnW')
      finish = vim.fn.searchpos('\\V' .. close, 'nW')
    else
      start = vim.fn.searchpairpos('\\V' .. open, '', '\\V' .. close, 'bnW')
      finish = vim.fn.searchpairpos('\\V' .. open, '', '\\V' .. close, 'nW')
    end

    if start[1] > 0 and finish[1] > 0 then
      local cur = vim.fn.getpos('.')
      local start_before_cursor = (start[1] < cur[2]) or (start[1] == cur[2] and start[2] <= cur[3])
      local finish_after_cursor = (finish[1] > cur[2]) or (finish[1] == cur[2] and finish[2] >= cur[3])

      if start_before_cursor and finish_after_cursor then
        vim.fn.setpos('.', {0, start[1], start[2] + 1, 0})
        vim.cmd('normal! v')
        vim.fn.setpos('.', {0, finish[1], finish[2], 0})
        vim.cmd('normal! h')
        return
      end
    end
  end

  -- Fallback: select current line
  local lnum = vim.fn.line('.')
  local line = vim.fn.getline(lnum)
  local end_col = #line
  if end_col > 0 and line:sub(-1) == '$' then
    end_col = end_col - 1
  end

  vim.fn.setpos('.', {0, lnum, 1, 0})
  vim.cmd('normal! v')
  vim.fn.setpos('.', {0, lnum, end_col, 0})
end

5. Old Files Browser and Ranger Chooser

Vim stores recently opened files in vim.v.oldfiles. output_old_files() dumps them into a buffer, making each entry a link you can press Enter on to open. This is a lightweight alternative to Telescope for quickly revisiting files without fuzzy matching.

The ranger_chooser() function integrates the ranger file manager directly into the editor: it runs ranger --choosefiles in a terminal (or XTerm if a GUI is detected) and opens all selected files as arguments. This fits the philosophy of using external, best‑in‑class tools while keeping the editor as the central hub.


function M.output_old_files()
  vim.cmd('enew')
  vim.api.nvim_buf_set_lines(0, 0, -1, false, vim.v.oldfiles)
  vim.bo.buftype = 'nofile'
  vim.bo.bufhidden = 'wipe'
  vim.bo.swapfile = false
  vim.wo.wrap = false

  vim.keymap.set('n', '', function()
    local line = vim.fn.getline('.')
    vim.cmd('e ' .. line)
  end, { buffer = true })

  local buf = vim.api.nvim_get_current_buf()
  vim.keymap.set('n', 'q', function() vim.cmd('bd! ' .. buf) end, { buffer = buf, noremap = true, silent = true })
  vim.keymap.set('n', '', function() vim.cmd('bd! ' .. buf) end, { buffer = buf, noremap = true, silent = true })
  vim.cmd('normal! gg')
end

6. Word Count, URL Maker, and Directory Prefix

Several smaller utilities fill in the gaps:

word_count() – runs detex on a LaTeX file and pipes it through wc -w to count plain‑text words (ignoring markup).
make_url(word) – replaces every occurrence of a word with an HTML link pointing to https://word.com. Useful for quickly linking to domains in blog articles.
get_dir_number() – extracts the leading numeric prefix of the current working directory, used in LaTeX snippet auto‑numbering.

7. Save Bindings and Functions

save_vim_bindings_and_functions() captures all current key mappings and function definitions into a buffer. This is invaluable for debugging or documenting your setup. It uses Vim’s :redir mechanism to capture the output of :map and :function and writes them into a scratch buffer.

Integration: Keymaps and Commands

These functions are exposed through two files:


-- keymaps.lua (excerpt)
vim.keymap.set("v", "c", functions.run_python_selection, { noremap = true })
vim.keymap.set("v", "r", functions.run_python_and_replace, { noremap = true })
vim.keymap.set("n", "wc", functions.word_count, opts)
vim.keymap.set("n", "mm", functions.output_old_files, opts)
vim.keymap.set("n", "cc", functions.command_history_explorer, opts)
vim.keymap.set("n", "rr", functions.output_regs, opts)
vim.keymap.set("n", "ranger", functions.ranger_chooser, opts)


-- commands.lua (excerpt)
vim.api.nvim_create_user_command("WC", functions.word_count, {})
vim.api.nvim_create_user_command("Mm", functions.output_old_files, {})
vim.api.nvim_create_user_command("Cc", functions.command_history_explorer, {})
vim.api.nvim_create_user_command("Ss", functions.search_command_history, {})
vim.api.nvim_create_user_command("Rr", functions.output_regs, {})
vim.api.nvim_create_user_command("HH", functions.wrap_code_in_buffer, {})
vim.api.nvim_create_user_command("RangerChooser", functions.ranger_chooser, {})
vim.api.nvim_create_user_command("EngType", functions.eng_type, {})
vim.api.nvim_create_user_command("FrType", functions.fr_type, {})

User commands (e.g., :WC, :Cc) are intentionally uppercase and short to minimise typing. Keymaps are mnemonic: <leader>cc for command history, <leader>rr for registers, etc.

Design Philosophy: Functions as Infrastructure

The unifying principle behind these utilities is that they treat Neovim as a programmable platform, not just a text editor. Each function solves a concrete, recurring need in the developer’s daily workflow:

Async execution – never block the UI.
Scratch buffers – temporary, non‑file buffers that clean up after themselves.
Explicit buffer management – every function that opens a buffer also defines how to close it (q or bd!).
Pure Lua, no plugin dependencies – everything runs on the built‑in API, making the config portable.

The result is an editor that behaves like an IDE, but without the weight. In the next article, we’ll see how snippets push this automation even further, turning tiny triggers into large, context‑aware code blocks.

Per‑Filetype Engineering: Tailoring Neovim for Python, LaTeX, HTML, and Markdown

2026-05-15T15:31:53+00:00

Context is Everything

A general‑purpose editor can only take you so far. The moment you switch from a Python script to a LaTeX document, your brain expects different indentation, different macros, and different ways to manipulate the text. A well‑engineered Neovim configuration reacts to filetypes not as an afterthought, but as a first‑class design principle.

In this second article of the series, we open the ftplugin/ directory and the shared mapping modules that give each language its own personality – without duplicating logic. We'll walk through the full source of every relevant file, explaining the reasoning behind each buffer‑local option, each insert‑mode expansion, and each visual‑mode wrapping command.

The ftplugin Mechanism

Neovim automatically sources Lua files in ~/.config/nvim/ftplugin/ when a buffer's filetype matches the filename (e.g., python.lua for Python files). This is the official way to inject buffer‑local settings without polluting global configuration. Everything we set in these files is scoped to the current buffer, so you can have 2‑space indentation for HTML and 4‑space for Python simultaneously.

Our ftplugin files do three things:

Set buffer‑local options (tabstop, shiftwidth, textwidth, etc.).
Define insert‑mode keymaps that expand into larger code constructs (e.g., typing if becomes if :<++> in Python).
Call shared mapping modules to apply visual‑mode wrappers and other common utilities.

This last point is crucial: HTML and Markdown share a large set of visual mappings (wrapping text in <p>, <h2>, etc.), so we centralise that logic in lua/config/html_markdown_maps.lua and require it from both ftplugins. No duplication, no drift.

Python: 4‑Space Indentation and Quick Constructs

The Python ftplugin sets tabstop=4, shiftwidth=4, and textwidth=88 (PEP 8 line length). It also defines two normal‑mode mappings: <leader>c to run the buffer asynchronously in a scratch buffer, and <leader>i to open an interactive REPL in a vertical split.

The insert‑mode mappings are a collection of shorthand triggers: typing if expands to if :<++> with the cursor placed after the colon, def expands to def ():<++>, and so on. The <++> placeholders are jump targets (navigated with Ctrl‑L / Ctrl‑H) that appear in many languages throughout the config. This gives a consistent, muscle‑memory‑based editing flow.


-- Python-specific settings
vim.bo.tabstop = 4
vim.bo.shiftwidth = 4
vim.bo.expandtab = true
vim.bo.textwidth = 88  -- PEP 8 line length

-- Run Python code and display output in a scratch buffer
local function run_python_buffer()
  local current_file = vim.fn.expand("%")

  -- Create scratch buffer
  vim.cmd("enew")
  local buf = vim.api.nvim_get_current_buf()

  -- Buffer settings
  vim.bo[buf].buftype = "nofile"
  vim.bo[buf].bufhidden = "wipe"
  vim.bo[buf].swapfile = false
  vim.bo[buf].filetype = "python"

  vim.wo.wrap = false
  vim.wo.number = true
  vim.wo.relativenumber = true

  vim.api.nvim_buf_set_lines(buf, 0, -1, false, {
    "Running Python script...",
    "File: " .. current_file,
    ""
  })

  local function append_lines(lines)
    if vim.api.nvim_buf_is_valid(buf) and lines then
      vim.api.nvim_buf_set_lines(buf, -1, -1, false, lines)
      -- Scroll to bottom
      local last = vim.api.nvim_buf_line_count(buf)
      vim.api.nvim_win_set_cursor(0, { last, 0 })
    end
  end

  -- Start async job
  local job_id
  job_id = vim.fn.jobstart({ "python3", current_file }, {
    stdout_buffered = false,
    stderr_buffered = false,

    on_stdout = function(_, data)
      append_lines(data)
    end,

    on_stderr = function(_, data)
      append_lines(data)
    end,

    on_exit = function(_, exit_code)
      append_lines({
        "",
        "Execution finished (exit code: " .. exit_code .. ")",
      })

      -- Only set keymap if buffer still exists
      if vim.api.nvim_buf_is_valid(buf) then
        vim.keymap.set("n", "<CR>", function()
          if job_id then vim.fn.jobstop(job_id) end
          if vim.api.nvim_buf_is_valid(buf) then
            vim.cmd("bd!")
          end
        end, { buffer = buf })
      end
    end,
  })

  -- Kill job if buffer is wiped
  vim.api.nvim_create_autocmd("BufWipeout", {
    buffer = buf,
    once = true,
    callback = function()
      if job_id then vim.fn.jobstop(job_id) end
    end,
  })
end

-- Normal mode mappings for Python
vim.keymap.set('n', '<leader>c', run_python_buffer, { buffer = true, desc = "Run Python buffer" })
vim.keymap.set('n', '<leader>i', function()
  vim.cmd('TermExec cmd="python3 -i %" direction=vertical size=60')
end, { buffer = true, desc = "Interactive Python REPL" })

-- Insert mode mappings for Python
local insert_maps = {
  ['if'] = 'if :<++><ESC>F:a',
  ['for'] = 'for in :<++><ESC>F:i',
  ['def'] = 'def ():<++><ESC>F(a',
  ['class'] = 'class :<++><ESC>F:a',
  ['imp'] = 'import ',
  ['from'] = 'from import <++><ESC>F:i',
  ['try'] = 'try:<CR><++><CR>except:<CR><++><ESC>kkk0f:a',
  ['print'] = 'print()<++><ESC>F(a',
  ['main'] = 'if __name__ == "__main__":<CR><++><ESC>k0f:a',
  [';dv'] = '"""<CR><CR>"""<ESC>kA',
}

for lhs, rhs in pairs(insert_maps) do
  vim.keymap.set('i', lhs, rhs, { buffer = true })
end

LaTeX: Compilation Pipeline and Rich Snippets

The LaTeX ftplugin is the largest of the set. It sets 2‑space indentation and provides normal‑mode mappings to compile with xelatex (<leader>c), open the resulting PDF (<leader>o), and wrap the entire buffer in <pre><code> tags for blog post inclusion (<leader>w). The compilation runs asynchronously in a scratch buffer, outputting both stdout and stderr.

Insert‑mode mappings cover everything from single‑character overrides (e.g., ! inserts a backslash) to complex environment expansions (e.g., ,tcb inserts a custom tcb environment by calling a Lua function). Visual‑mode mappings allow wrapping selected text in \textbf, \underline, math mode, and custom colour boxes – all through muscle‑memory shortcuts.

Note the use of a helper to extract the current directory's numeric prefix: this is used to auto‑number exercises in LaTeX snippets defined elsewhere (we'll cover snippet design in article #4). For now, the important insight is that ftplugin files can access shared helper modules and even call Lua functions from snippet libraries.



-- LaTeX-specific settings
vim.bo.tabstop = 2
vim.bo.shiftwidth = 2
vim.bo.expandtab = true

-- Set global variable with filename
local get_curr_file_base_name = function()
  local handle = io.popen("basename $(pwd) | cut -d'-' -f1")
  local result = handle:read("*a")
  handle:close()
  return result:gsub('\n', '')
end

vim.g.curr_file_base_name = get_curr_file_base_name()

-- Run LaTeX compilation asynchronously in a scratch buffer
local function run_tex()
  local current_file = vim.fn.expand("%")
  local pdf_file = vim.fn.expand("%:p:r") .. ".pdf"

  -- Create scratch buffer
  vim.cmd("enew")
  local buf = vim.api.nvim_get_current_buf()

  -- Buffer settings
  vim.bo[buf].buftype = "nofile"
  vim.bo[buf].bufhidden = "wipe"
  vim.bo[buf].swapfile = false
  vim.bo[buf].filetype = "texlog"

  vim.wo.wrap = false
  vim.wo.number = true
  vim.wo.relativenumber = true

  vim.api.nvim_buf_set_lines(buf, 0, -1, false, {
    "Compiling with xelatex, please wait...",
    ""
  })

  local function append_lines(lines)
    if vim.api.nvim_buf_is_valid(buf) and lines then
      vim.api.nvim_buf_set_lines(buf, -1, -1, false, lines)
      -- Scroll to bottom
      local last = vim.api.nvim_buf_line_count(buf)
      vim.api.nvim_win_set_cursor(0, { last, 0 })
    end
  end

  -- Start async job
  local job_id
  job_id = vim.fn.jobstart({ "xelatex", current_file }, {
    stdout_buffered = false,
    stderr_buffered = false,

    on_stdout = function(_, data)
      append_lines(data)
    end,

    on_stderr = function(_, data)
      append_lines(data)
    end,

    on_exit = function(_, exit_code)
      append_lines({
        "",
        "Compilation Finished (exit code: " .. exit_code .. ")",
        pdf_file,
      })

      -- Only set keymap if buffer still exists
      if vim.api.nvim_buf_is_valid(buf) then
        vim.keymap.set("n", "<CR>", function()
          if job_id then vim.fn.jobstop(job_id) end
          if vim.api.nvim_buf_is_valid(buf) then
            vim.cmd("bd!")
          end
        end, { buffer = buf })
      end
    end,
  })

  -- Kill job if buffer is wiped
  vim.api.nvim_create_autocmd("BufWipeout", {
    buffer = buf,
    once = true,
    callback = function()
      if job_id then vim.fn.jobstop(job_id) end
    end,
  })
end

-- View PDF
local function view_tex()
  local pdf = vim.fn.expand('%:p'):gsub('%.tex$', '.pdf')
  vim.fn.execute('!nohup evince ' .. vim.fn.shellescape(pdf) .. ' >/dev/null 2>&1 &')
  vim.cmd('redraw!')
end

-- Wrap buffer in HTML tags
local function wrap_buffer_in_html_tags()
  -- Yank the entire buffer content
  vim.cmd('normal! ggVGy')

  -- Replace special characters in the yanked content
  local content = vim.fn.getreg('0')
  content = content:gsub('&', '&amp;')
  content = content:gsub('<', '&lt;')
  content = content:gsub('>', '&gt;')
  vim.fn.setreg('0', content)

  -- Get current filename and append .html
  local current_filename = vim.fn.expand('%:t:r') .. ".html"

  -- Open new buffer with HTML syntax
  vim.cmd('enew')
  vim.bo.filetype = 'html'
  vim.cmd('file ' .. current_filename)

  -- Insert opening tags
  vim.api.nvim_buf_set_lines(0, 0, -1, false, {
    '<pre class="language-latex">',
    '<code class="language-latex">'
  })

  -- Paste the content
  vim.cmd('normal! 2Go')
  vim.cmd('normal! "0p')

  -- Insert closing tags
  vim.api.nvim_buf_set_lines(0, -1, -1, false, {
    '</code>',
    '</pre>'
  })

  -- Move cursor to top
  vim.cmd('normal! gg')
end

-- Normal mode mappings
vim.keymap.set('n', '<leader>c', run_tex, { buffer = true })
vim.keymap.set('n', '<leader>o', view_tex, { buffer = true })
vim.keymap.set('n', '<leader>w', wrap_buffer_in_html_tags, { buffer = true })

-- Insert mode mappings
local insert_maps = {
  ['!'] = '\\',
  ['§'] = '!',
  ['qq'] = '\\quad ',
  ['tt'] = '~\\text{}~<++><ESC>F{a',
  [',hs'] = '\\hspace*{cm}<++><ESC>F{a',
  [',vs'] = '\\vspace*{cm}<++><ESC>F{a',
  [',bf'] = '\\textbf{}<++><ESC>F{a',
  [',u'] = '\\underline{}<++><ESC>F{a',
  [',tcb'] = '<ESC>:lua require("config.tex_snippets").tcb()<CR>',
  [',nn'] = '<ESC>:lua require("config.tex_snippets").d1()<CR>',
  [',ds'] = '<ESC>:lua require("config.tex_snippets").ds()<CR>',
  [',st'] = '<ESC>:lua require("config.tex_snippets").st()<CR>',
  [',ar'] = '<ESC>:lua require("config.tex_snippets").ar()<CR>',
  [',gg'] = '<ESC>:lua require("config.tex_snippets").gg()<CR>',
  [',mt'] = '<ESC>:lua require("config.tex_snippets").mtab()<CR>',
  [',dd'] = '<ESC>:lua require("config.tex_snippets").d1()<CR>',
  [',li'] = '<ESC>:lua require("config.tex_snippets").li()<CR>',
  [',ti'] = '<ESC>:lua require("config.tex_snippets").tight()<CR>',
  [',mm'] = '\\usepackage{amsmath, amsfonts, amssymb, amsthm}\n\\usepackage{mathrsfs}',
  [',ig'] = '\\includegraphics[width=<++>cm]{<++>}',
  [',bm'] = '\\def\\bottommsg{{\\normalsize{ \\vskip 3pt \\hrule height 3pt \\vskip 5pt \\RL{\\arabicfont <++> }}}}',
  [',o'] = '$(O; \\vec i, \\vec j)$',
  ['$$'] = '~$$~<++><Esc>F$i',
  ['['] = '[]<++><Esc>F]i',
  ['{'] = '{}<++><Esc>F}i',
  ['('] = '()<++><Esc>F)i',
  [',no'] = '\\noindent',
  ['...'] = '\\cdots',
  ['>='] = '\\ge',
  ['<='] = '\\le',
  [',xx'] = '\\times',
  ['°'] = '$',
  ['ł'] = '{}<Esc>F{a',
  ['ĸ'] = '&'
}

for lhs, rhs in pairs(insert_maps) do
  vim.keymap.set('i', lhs, rhs, { buffer = true })
end

-- Visual mode mappings
local visual_maps = {
  ['<leader>$'] = 's~$<C-r>"$~<++><Esc>',
  ['<leader>u'] = 'c\\underline{<C-r>"}<++>',
  ['<leader>b'] = 'c\\textbf{<C-r>"}<++>',
  ['<leader>i'] = 'c\\textit{<C-r>"}<++>',
  ['<leader>cc'] = 'c\\textcolor{}{<C-r>"}<++><Esc>2F{a',
  ['1'] = 'c\\bm{\\textcolor{}{<C-r>"}}<++><Esc>2F{a',
  ['2'] = 'c\\bbox{<C-r>"}<Esc>',
  ['3'] = 'c\\rbox{<C-r>"}<Esc>',
  ['4'] = 'c\\obox{<C-r>"}<Esc>',
  ['5'] = 'c~$<C-r>"$~<Esc>',
  ['6'] = '<Esc><cmd>\'<,\'>s/\\\\\\[/\\~\\(/e<CR><cmd>\'<,\'>s/\\\\\\]/\\\\)\\~/e<CR>',
  ['9'] = '<Esc><cmd>\\<,>s/\\\\(/\\~$/eg<CR><cmd>\\<,>s/\\\\)/\\$\\~/eg<CR>'
}

for lhs, rhs in pairs(visual_maps) do
  vim.keymap.set('v', lhs, rhs, { buffer = true })
end

-- Operator-pending mode mapping
vim.keymap.set('o', 'à', '$', { buffer = true })

HTML & Markdown: Shared Wrappers and Insert Maps

HTML and Markdown share the same visual wrapping commands, so their ftplugin files are minimal: each sets 2‑space indentation and then calls require("config.html_markdown_maps")(). The HTML ftplugin also defines a few insert‑mode mappings for comments and tag pairs.


-- ftplugin/html.lua
vim.bo.tabstop = 2
vim.bo.shiftwidth = 2
vim.bo.expandtab = true

-- Insert mode mappings (like your tex ones)
local insert_maps = {
  ['!'] = '<!--  --><++><Esc>F i',          -- HTML comment
  ['<'] = '<><++><Esc>F>a',                  -- open/close tag
  -- add other quick expansions
}
for lhs, rhs in pairs(insert_maps) do
  vim.keymap.set('i', lhs, rhs, { buffer = true })
end

-- Load shared mappings
require("config.html_markdown_maps")()


-- ftplugin/markdown.lua
vim.bo.tabstop = 2
vim.bo.shiftwidth = 2
vim.bo.expandtab = true

require("config.html_markdown_maps")()

The Shared Mapping Module: html_markdown_maps.lua

This module is a Lua function that, when called, registers visual‑mode mappings for both HTML and Markdown buffers. It uses a pure‑Lua wrap_visual_text function that handles linewise, characterwise, and blockwise selections correctly – no shelling out, no edge‑case failures. It also provides a ulify_selection function to convert a block of text into an HTML unordered list.

Because this logic is centralised, any improvement to visual wrapping (e.g., supporting additional selection modes) benefits both HTML and Markdown immediately.


-- lua/config/html_markdown_maps.lua
-- Shared visual/insert mappings for HTML and Markdown
-- All wraps use a pure‑Lua function – no shell, no gv, no E488.

-- ----------------------------------------------------------------------
-- Pure‑Lua wrapper that mimics your sed replacements
--   v/V/Ctrl‑v   → wraps each selected line (or each block fragment)
--   v (charwise) → wraps only the selected text inside the line
-- ----------------------------------------------------------------------
local function wrap_visual_text(open_tag, close_tag)
  local mode = vim.fn.visualmode()
  local start_pos = vim.fn.getpos("v")
  local end_pos   = vim.fn.getpos(".")

  -- Normalise order: start before end
  if start_pos[2] > end_pos[2] or (start_pos[2] == end_pos[2] and start_pos[3] > end_pos[3]) then
    start_pos, end_pos = end_pos, start_pos
  end

  local buf = vim.api.nvim_get_current_buf()
  local sr = start_pos[2] - 1   -- start row (0‑based)
  local sc = start_pos[3] - 1   -- start col (0‑based)
  local er = end_pos[2] - 1     -- end row
  local ec = end_pos[3]         -- end col (exclusive for nvim_buf_get_text)

  if mode == 'V' then
    -- Linewise: wrap each full line individually
    local lines = vim.api.nvim_buf_get_lines(buf, sr, er + 1, false)
    local result = {}
    for _, line in ipairs(lines) do
      local trimmed = vim.trim(line)
      if trimmed ~= "" then
        table.insert(result, open_tag .. trimmed .. close_tag)
      else
        table.insert(result, line)   -- keep empty lines as-is
      end
    end
    vim.api.nvim_buf_set_lines(buf, sr, er + 1, false, result)
  else
    -- Character‑ or blockwise: get the exact selection
    local region = vim.api.nvim_buf_get_text(buf, sr, sc, er, ec, {})
    local text = table.concat(region, '\n')
    local wrapped = open_tag .. text .. close_tag
    local new_lines = vim.split(wrapped, '\n')
    vim.api.nvim_buf_set_text(buf, sr, sc, er, ec, new_lines)
  end
end

-- ----------------------------------------------------------------------
-- Your original ulify_selection (unchanged)
-- ----------------------------------------------------------------------
local function ulify_selection()
  local start_line = vim.fn.line("'<")
  local end_line   = vim.fn.line("'>")
  local lines = vim.api.nvim_buf_get_lines(0, start_line - 1, end_line, false)

  local result_lines = {}
  for _, line in ipairs(lines) do
    local trimmed = vim.trim(line)
    if trimmed ~= "" then
      local replaced = trimmed:gsub("%*%*(.-)%*%*", "<strong>%1</strong>")
      table.insert(result_lines, "  <li>" .. replaced .. "</li>")
    end
  end

  local final = { "<ul>" }
  for _, li in ipairs(result_lines) do
    table.insert(final, li)
  end
  table.insert(final, "</ul>")

  vim.api.nvim_buf_set_lines(0, start_line - 1, end_line, false, final)
end

-- ----------------------------------------------------------------------
-- Setup mappings
-- ----------------------------------------------------------------------
return function()
  local opts = { buffer = true, silent = true, noremap = true }

  -- ====================================================
  -- Visual surrounds (all unified, pure Lua)
  -- ====================================================
  vim.keymap.set('v', '<leader>ss', function()
    wrap_visual_text('<strong style="color: #000000;">', '</strong>')
  end, opts)

  vim.keymap.set('v', '<leader>pp', function()
    wrap_visual_text('<p>', '</p>')
  end, opts)

  vim.keymap.set('v', '<leader>hh', function()
    wrap_visual_text('<h2>', '</h2>')
  end, opts)

  vim.keymap.set('v', '<leader>aa', function()
    wrap_visual_text('<a href="<++>" target="_blank">', '</a>')
  end, opts)

  -- ====================================================
  -- Other mappings (unchanged)
  -- ====================================================
  vim.keymap.set('v', '<leader>cc',
    'x<Esc>i<pre class="language-bash" ><Enter>   <code class="language-bash" ><Esc>po    </code><Enter></pre><Enter><br><Esc>',
    opts)

  vim.keymap.set('i', '<leader>ff',
    '<Esc>:r ~/.vim/snippets/html/fig<CR>', opts)

  vim.keymap.set('i', '<<', '&lt;', opts)
  vim.keymap.set('i', '>>', '&gt;', opts)

  vim.keymap.set('v', '<leader>ul', ulify_selection, opts)
end

Design Lessons

The ftplugin architecture demonstrates a key principle: context should be handled as close to the buffer as possible. Global configuration sets the baseline; filetype‑specific modules add the personality. Shared logic lives in a separate module and is required only where needed – no conditional checks based on filetype inside global keymaps.

In the next article, we'll explore the custom functions that power the normal‑mode utilities – async execution, register inspection, command history navigation – and how they transform Neovim into a programmable engineering dashboard.

Engineering a Developer‑Grade Neovim Environment: The Foundation

2026-05-15T12:52:37+00:00

Why the First 100 Milliseconds Matter

A Neovim configuration that starts fast and behaves predictably isn’t an accident – it’s a designed system. When you open an editor dozens of times a day across different machines, the difference between a 80 ms cold start and a 400 ms one is the difference between an invisible tool and a constant reminder that something is loading. This article lays out the foundation of my daily driver: a fully modular, lazy‑loaded, deterministic Neovim setup that I’ve used for years to write LaTeX, Python, shell scripts, Markdown, and more.

We’ll start with the directory tree, then walk through every line of init.lua and the lazy‑bootstrapping module, explaining the engineering decisions – not just the “what”, but the “why”. The complete file contents are included so you can rebuild this foundation yourself or adapt it to your own toolchain.

Directory Tree

Below is the entire configuration tree at the time of writing. Files that are central to this article are highlighted in bold:


~/.config/nvim/
├── init.lua                       <-- entry point
├── lazy-lock.json                 <-- pinned plugin versions
├── lua/
│   ├── config/
│   │   ├── lazy.lua               <-- bootstraps lazy.nvim
│   │   ├── colors.lua
│   │   ├── commands.lua
│   │   ├── functions.lua
│   │   ├── html_markdown_maps.lua
│   │   ├── html_snippets.lua
│   │   ├── keymaps.lua
│   │   ├── options.lua
│   │   └── tex_snippets.lua
│   └── plugins/
│       └── core.lua
└── ftplugin/
    ├── html.lua
    ├── lua.lua
    ├── markdown.lua
    ├── python.lua
    └── tex.lua

The tree follows the standard Neovim convention: init.lua in the root, lua/ for modules, ftplugin/ for filetype‑specific settings. The entire configuration is lazy‑loaded, meaning no plugin is sourced until it is actually needed (filetype, command, or event).

The Entry Point: init.lua

The entry point sets global options, defines the leader keys, configures persistent state, and schedules the later loading of plugins and UI. Every choice is deliberate:

Leader keys: , as mapleader, Space as local leader – keeps custom mappings comfortably under the left hand.
Basic settings: line numbers, relative numbers, mouse support, 2‑space tabs, smart case – a sane baseline that individual filetypes can override.
Persistent history & undo: shada and undofile are pushed to stdpath('data'). The shada file stores command history and marks; the undo tree survives restarts. Both are set to very high limits to never lose context.
Fallback colourscheme: desert is set immediately so the editor never looks broken, then require('config.lazy') is called to pull in plugins. After plugins load, a scheduled callback applies the real theme and custom highlights.
Autocommands: trailing whitespace stripping on save, restoring cursor position, setting filetype for .tex files, auto‑lcd to file directory, and yank highlighting.

Here is the complete init.lua:


-- Modern Neovim by MOSAID

-- Leader
vim.g.mapleader = ","
vim.g.maplocalleader = " "

-- Basic settings (keep your existing ones)
vim.o.number = true
vim.o.relativenumber = true
vim.o.termguicolors = true
vim.o.wrap = true
vim.o.tabstop = 2
vim.o.shiftwidth = 2
vim.o.expandtab = true
vim.o.mouse = "a"
vim.o.cmdheight = 1
vim.opt.ignorecase = true
vim.opt.smartcase = true


vim.g.loaded_netrw = 1
vim.g.loaded_netrwPlugin = 1

-- History, undo, backup
-- vim.opt.undofile = true
-- vim.opt.undodir = vim.fn.stdpath("data") .. "/undo"
-- vim.opt.undolevels = 1000
-- vim.opt.undoreload = 10000
-- vim.opt.backup = true
-- vim.opt.backupdir = vim.fn.stdpath("data") .. "/backup"
-- vim.opt.directory = vim.fn.stdpath("data") .. "/backup"
-- vim.opt.history = 10000

-- Maximum history
vim.opt.history = 10000          -- command and search history
vim.opt.undolevels = 10000        -- undo steps
vim.opt.undoreload = 100000       -- undo for this many lines

-- Persistent undo
vim.opt.undofile = true
vim.opt.undodir = vim.fn.stdpath("data") .. "/undo"

-- Persistent command/search history
vim.opt.shadafile = vim.fn.stdpath("data") .. "/shada/main.shada"
vim.opt.shada = "'100000,<1000,s100,h"
vim.cmd("silent! rshada")  -- load at startup


-- Set a basic colorscheme immediately
vim.cmd("colorscheme desert")  -- Fallback colorscheme

-- Load modules in correct order
require("config.lazy")  -- This loads plugins first

-- After plugins are loaded, set up our colors
vim.schedule(function()
  require("config.colors").setup()  -- This sets tokyonight and custom highlights
  require("config.keymaps")
  require("config.commands")
end)


-- Auto-command to remove trailing whitespace
vim.api.nvim_create_autocmd("BufWritePre", {
  pattern = "*",
  callback = function()
    vim.cmd([[%s/\s\+$//e]])
  end
})


-- Remember last cursor position when reopening a file
vim.api.nvim_create_autocmd("BufReadPost", {
  pattern = "*",
  callback = function()
    local last_pos = vim.fn.line([['"]])
    if last_pos > 1 and last_pos <= vim.fn.line("$") then
      vim.cmd("normal! g`\"")
    end
  end,
})


-- Filetype detection autocmds
vim.api.nvim_create_autocmd({"BufEnter", "BufNew", "BufNewFile", "BufRead"}, {
  pattern = "*.tex",
  callback = function()
    vim.bo.filetype = "tex"
  end
})

-- Set current directory to directory of the current file, except /tmp
vim.api.nvim_create_autocmd("BufReadPost", {
  callback = function()
    local dir = vim.fn.expand("%:p:h")
    if dir ~= "" and not dir:match("^/tmp") then
      vim.cmd("silent! lcd " .. dir)
    end
  end,
})

-- Briefly highlight yanked text
vim.api.nvim_create_autocmd("TextYankPost", {
  pattern = "*",
  callback = function()
    vim.highlight.on_yank({
      higroup = "IncSearch",  -- or "Visual", "Search", etc.
      timeout = 500,          -- highlight duration in milliseconds
    })
  end,
})

Bootstrapping lazy.nvim

The require("config.lazy") call inside init.lua delegates to lua/config/lazy.lua, which is the only file that touches plugin management. It clones lazy.nvim itself if missing, then loads the plugin specification from lua/plugins/core.lua.

This file is intentionally minimal – it does not configure any plugins, only wires the package manager. The border = "rounded" setting is purely cosmetic. Every plugin is listed in core.lua and lazy‑loaded by event, command, or filetype. The lazy-lock.json file pins exact commits so the environment is fully reproducible across machines.


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",
    lazypath,
  })
end

vim.opt.rtp:prepend(lazypath)

require("lazy").setup({
  spec = {
    { import = "plugins" },
  },
  ui = {
    border = "rounded"
  }
})

The lazy-lock.json file (not shown in full here, but available in the configuration repository) records the exact commit of every plugin. This guarantees that lazy.sync() always restores the same plugin set, making the environment truly deterministic.

Ordering and the Scheduled Callback

The line vim.schedule(function() ... end) after loading lazy.nvim is critical. It defers the remaining setup until after the UI has been entered and plugins have been loaded (but not necessarily after they are all configured – lazy.nvim’s config keys run during the setup() call). This prevents race conditions where a colourscheme or highlight group is set before the plugin that defines it has been sourced.

Inside the scheduled callback we call:

require("config.colors").setup() – applies the chosen theme (Nordic) and sets custom highlight groups. A fallback to desert is already in place, so the editor is always readable.
require("config.keymaps") – defines global keybindings that rely on functions from config.functions.
require("config.commands") – creates user commands (like :WC, :Cc, etc.) that also depend on those utility functions.

Because everything after plugins is scheduled, the editor remains responsive during startup and never throws “module not found” errors even if a plugin fails to load.

Early Fallback Colourscheme

Immediately after the basic options, we call vim.cmd("colorscheme desert"). This is the ultimate safety net: if the later scheduled colors.setup() fails (for example, because the Tokyonight plugin is missing), the editor still has a functioning colourscheme. It also eliminates the “flash of unstyled text” that occurs when Neovim starts with no theme and then asynchronously loads one. The fallback is always overridden by the scheduled callback, so users never see desert once the real theme kicks in.

Autocommands as Infrastructure

The autocommands defined in init.lua are small pieces of infrastructure that would be annoying to lose:

Trailing whitespace removal on save – keeps diffs clean without manual clean‑up.
Cursor position restoration – when you reopen a file you left the day before, you’re exactly where you stopped.
Automatic filetype for .tex – some systems don’t recognise .tex as LaTeX without this explicit mapping.
Auto‑lcd to file directory – makes :Telescope find_files and relative imports work out of the box.
Yank highlight – provides instant visual feedback that the yank succeeded, a subtle but powerful usability improvement.

Reproducibility from the Ground Up

Every line in these two files serves a purpose: there are no boilerplate copies from other people’s dotfiles, no unused settings, and every module is loaded lazily only when required. The lazy-lock.json ensures that even plugin versions are frozen, turning the entire configuration into a build artifact that can be checked out and expected to work identically on any Neovim 0.9+ installation.

In the next article we’ll dive into the filetype‑specific engines – how ftplugin/*.lua and shared mapping modules create a context‑aware editor that feels custom‑built for Python, LaTeX, HTML, and Markdown.

Engineering a Modal Text Object Engine in Vim: Custom Motions and Operator-Pending Grammars

2026-05-13T20:50:06+00:00

Vim’s built‑in text objects—iw, i(, at—are powerful, but they stop short of domain‑specific structures. What if you could select an indented block with ii, a function argument with ia, or a column of a Markdown table with ic? For advanced users, the real magic lies in creating custom objects that compose seamlessly with any operator—dii, cia, yic—turning Vim into a structured editing engine tailored to your exact filetypes.

This article documents a system that generalises custom text objects into a declarative grammar, built entirely from Vim’s native operator‑pending mode and a handful of helper functions. It is not a plugin; it is a pattern you can integrate directly into your .vimrc or ftplugin files, giving you deterministic, composable selections without external dependencies.

Architecture of Operator‑Pending Mode

To build new objects, you must first understand the state machine behind every d} or cib.

•Operator‑pending mode is entered after an operator key (d, c, y, g~, etc.). Vim then waits for a motion or a text object to define the range.

•Text objects are special mappings that define two boundaries: a start and an end. They can be character‑wise, line‑wise, or block‑wise.

•The omap and xmap commands allow you to define mappings that only apply in operator‑pending or visual mode, respectively. This is the key to making custom objects operator‑agnostic.

The engine we design will leverage omap mappings that call functions to calculate a region, and then set the '[ and '] marks appropriately so the pending operator acts on exactly the right span.

Core Engine: The Object Factory

Declaring a Text Object

Instead of hand‑writing a dozen nearly identical functions, we define a small specification language. Each object is described by a dictionary containing:

•name: a unique label (used for debugging and documentation).

•selector: a Vimscript expression that returns a pair of positions—start and end (inclusive). It receives a boolean inner to distinguish i from a variants.

•mode: 'char', 'line', or 'block'. This determines how the operator applies (e.g., d uses line‑wise if the object is line‑wise).

We then register this specification with the engine:


call textobj#register({
    \ 'name': 'indent',
    \ 'selector': 'textobj#indent#select(inner)',
    \ 'mode': 'line'
    \})

The textobj#indent#select function scans for lines with the same indentation, wrapping the inner or outer block. The engine handles the rest: creating the omap entries for both ii and ai, setting marks, and respecting the pending operator.

Engine Implementation


function! textobj#register(object) abort
    let s:objects[a:object.name] = a:object

    " inner variant: i + name (e.g., ii)
    execute 'onoremap <silent> i' . a:object.name
        \ . ' :<C-u>call textobj#apply('
        \ . string(a:object.name) . ', 1)<CR>'

    " a variant: a + name (e.g., ai)
    execute 'onoremap <silent> a' . a:object.name
        \ . ' :<C-u>call textobj#apply('
        \ . string(a:object.name) . ', 0)<CR>'
endfunction

function! textobj#apply(name, inner) abort
    let obj = s:objects[a:name]
    let [l:start, l:end] = call(obj.selector, [a:inner])
    if l:start == 0 || l:end == 0 | return | endif

    " Set the '[' and ']' marks; Vim uses these for the operator range
    call setpos("'[", [0, l:start, 1, 0])
    call setpos("']", [0, l:end, 1, 0])

    " Force the operator to use the correct mode
    if obj.mode ==# 'line'
        normal! V
    elseif obj.mode ==# 'char'
        normal! v
    elseif obj.mode ==# 'block'
        " blockwise needs visual block – handled with special marks
        normal! <C-v>
    endif
endfunction

This is the entire engine—under 30 lines of Vimscript. It is deterministic, transparent, and composable. Every custom object you create from this point forward is just a selector function and a registration call.

Building Real Objects

Indentation Block (`ii` / `ai`)


function! textobj#indent#select(inner) abort
    let indent = indent(line('.'))
    let start = line('.')
    let end = line('.')

    " search upward for a line with less indent (outer boundary)
    while start > 1 && indent(start - 1) >= indent
        let start -= 1
    endwhile

    " search downward for a line with less indent
    while end < line('$') && indent(end + 1) >= indent
        let end += 1
    endwhile

    if a:inner
        " inner: exclude the first and last line if they are blank
        if getline(start) =~# '^\s*$' | let start += 1 | endif
        if getline(end) =~# '^\s*$' | let end -= 1 | endif
    endif

    return [start, end]
endfunction

Now dii deletes the current indented block, yii yanks it, and >ii increases its indentation. The object definition stays clean because the engine separates the selection logic from the operator handling.

Function Arguments (`ia` / `aa`)

A more ambitious selector that parses the current line for a comma‑separated argument list. The inner version (ia) selects the argument text excluding optional surrounding whitespace; the outer version includes trailing commas and spaces.


function! textobj#arg#select(inner) abort
    let line = getline('.')
    let col = col('.') - 1  " 0-indexed

    " Find argument boundaries: commas or parentheses
    let pattern = '[,()]'
    let start = 0
    let end = len(line)

    " search backward for opening delimiter
    let idx = col
    while idx > 0
        if line[idx] =~# pattern
            let start = idx + 1
            break
        endif
        let idx -= 1
    endwhile

    " search forward for closing delimiter
    let idx = col
    while idx < len(line) - 1
        if line[idx] =~# pattern
            let end = idx
            break
        endif
        let idx += 1
    endwhile

    if a:inner
        " trim whitespace from both ends
        while start < end && line[start] =~# '\s'
            let start += 1
        endwhile
        while end > start && line[end - 1] =~# '\s'
            let end -= 1
        endwhile
    endif

    " Return line positions; the engine will convert to mark positions
    return [line('.'), line('.')]   " both on the same line – set marks manually
    " For same‑line object we need to adjust col in marks:
    " We'll do this inside a wrapper that returns [lnum, col] pairs.
    " (Full implementation omitted for brevity – see repo.)
endfunction

Because the engine supports only line‑wise marks by default, same‑line objects require a slight extension: the selector can return a list of [line, col] pairs, and textobj#apply sets setpos("'[", [0, l:line, l:col, 0]) accordingly. This is a small modification that makes the engine handle all mode types uniformly.

Markdown Table Cell (`ic` / `ac`)

Another selector that navigates the vertical bar | separators in a GitHub‑flavoured Markdown table. The inner object selects the cell content; the outer includes the pipe characters. Thanks to the engine, cic clears a cell and leaves you in insert mode—as if Vim knew about Markdown tables natively.

Composition with Operators: The Power of Grammar

Because every custom object is exposed as an operator‑pending mapping, they automatically compose with any built‑in operator, and even with custom operators from other plugins (e.g., commentary’s gc). You can chain them with counts, repeat them with . (if the operator is repeatable), and use them from visual mode if you add xmap equivalents. The engine provides a textobj#visual helper that does exactly that:


function! textobj#visual(name, inner) abort
    call textobj#apply(a:name, a:inner)
    " Already in visual mode from the apply()
    " Remap i/a within visual mode to keep extending
    execute 'xnoremap <buffer> i' . a:name . ' :<C-u>call textobj#apply('
        \ . string(a:name) . ', 1)<CR>'
    execute 'xnoremap <buffer> a' . a:name . ' :<C-u>call textobj#apply('
        \ . string(a:name) . ', 0)<CR>'
endfunction

Now vii selects an indented block, and pressing ii again extends the selection to the next outer block—a true modal grammar.

Performance and Edge Cases

Text objects must be fast because they are invoked hundreds of times during a typical editing session. Selector functions should avoid external processes and prefer built‑in functions like search(), indent(), and getline(). The registration overhead is negligible; omap definitions are stored once.

Some edge cases to handle:

•Empty buffer/line: Selectors should return [0,0] to abort the operation gracefully.

•Nested structures: Indentation selectors need a clear definition of “same indent or deeper”. The provided textobj#indent#select treats all lines with indent ≥ current as part of the block, which works well for Python but may need tuning for languages with free‑form indentation.

•Blockwise operations: Vim’s blockwise mode requires special care: after setting marks with setpos, you must start a blockwise visual selection (gv) so the operator can interpret the marks as a block. Our engine does this conditionally.

Integration with Your Existing Workflow

The engine is a file you can drop into ~/.vim/autoload/textobj.vim and source from your .vimrc. Individual selectors become small autoload files (textobj/indent.vim, textobj/arg.vim) that are loaded on demand. This keeps startup time minimal and allows you to version‑control them independently.

For users who already use plugins like vim-textobj-user by Kana Natsuno, this engine offers a compatible but simpler alternative. You can even wrap the popular plugin’s API into our registration function to avoid duplication.

Tradeoffs

•No built‑in visual feedback: Unlike some plugins, our engine doesn’t flash a highlight when an object is selected (you can add that with :redraw and matchadd). We prioritised minimalism.

•Selector functions must be designed carefully: They receive only an inner flag, not the full operator context. If you need to behave differently for c vs d, you can inspect v:operator within the selector, but this couples the two layers.

•Same‑line objects demand extra mark handling: The engine’s base version returns line numbers; the extended version that handles column positions adds complexity. The design documented here can be refined to accept either format seamlessly.

Future Directions

This engine can grow into a full domain‑specific language for structured editing:

Add tree‑sitter integration: a selector that uses the syntax tree to define objects like functions, classes, or loops, making the engine filetype‑aware without per‑language rules.
GUI selection manager: a picker (via fzf or Vim’s inputlist()) that lets you compose objects interactively.
Visual mode combinators: extend the grammar so vii} means “select inner indent block, then extend to the next paragraph”, merging two objects.

The foundational pattern—separating registration, mapping, and selection logic—is what makes this extensible. Every new object is just a function that sees the buffer and returns two points.

Final Thoughts

Building a custom text object engine is not about reinventing plugins; it’s about understanding Vim’s modal architecture so deeply that you can bend it to your will. With a tiny amount of Vimscript, you can unlock editing paradigms that feel like they were always part of the editor. This engine is now a permanent part of my ~/.vim tree, and I suspect it will become one in yours as well.

Engineering a Vim-based LaTeX IDE: Custom Mappings, Snippets, and Compilation Workflow

2026-05-13T20:50:06+00:00

Problem Statement

LaTeX editing is powerful but repetitive. Every new document demands the same boilerplate: preamble setup, package inclusion, math shortcuts, and environment scaffolding. While dedicated LaTeX IDEs exist, they often feel slow, lack the composability of the terminal, and force a mouse-driven workflow. For engineers and power users who live in Vim, the ideal solution is to build a custom, deterministic editing environment that automates the boring parts without sacrificing control.

This article dissects a real-world Vim configuration for LaTeX editing, evolved over years of daily use. It lives at ~/.vim/after/ftplugin/tex.vim and leverages filetype-specific autocommands, a collection of snippet files, and custom functions that tie together compilation, PDF viewing, and even HTML export for static site generators like Pelican.

Architecture Overview

The system is a single Vim ftplugin file plus a directory of snippet templates. When a .tex file is opened, Vim automatically sources the ftplugin, which:

•Sets local buffer options (indentation, expansion).

•Defines compilation and viewer functions that capture xelatex output in a new buffer and open the resulting PDF in Evince.

•Creates insert-mode mappings that expand short keystrokes into full LaTeX commands or import snippet files.

•Provides visual-mode wrappers to quickly surround selected text with formatting commands like \textbf or inline math.

•Exports the current buffer to an HTML code block suitable for pasting into Pelican articles, bridging the gap between local authoring and static site publishing.

The snippets themselves are independent .tex files stored under ~/.vim/snippets/latex/ and inserted via :read commands bound to easy-to-type sequences like ;ds (exam template) or ;tcb (tcolorbox exercise).

Core Configuration

The ftplugin starts with the fundamentals:


autocmd FileType tex setlocal tabstop=2 shiftwidth=2 expandtab

LaTeX benefits from consistent two-space indentation. The expandtab setting ensures that all tabs are converted to spaces, which prevents formatting chaos when collaborating or sharing code.

Compilation Workflow

Running xelatex and Capturing Output

The RunTex() function embraces the Unix philosophy: it compiles the current .tex file with xelatex, discarding the need for a separate terminal window, and presents the output in a temporary buffer.


function! RunTex()
    let s:current_file = expand("%")
    enew | silent execute ".!xelatex " . shellescape(s:current_file, 1)
    setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
    if &number == 0
        set number
    endif
    set relativenumber
    normal! G
    nnoremap <buffer> <CR> :bd!<CR>
endfunction

Key design decisions:

Full log capture: Using enew followed by .!xelatex ... reads the command output into a new buffer, preserving all warnings and errors.
Non-file buffer: The buffer is set to nofile and nowrap, preventing accidental saves while keeping the log readable.
Quick dismissal: Pressing <CR> in the output buffer deletes it with :bd!, returning you instantly to the source.

Mapping <leader>c invokes this function, turning compilation into a single, muscle-memorised keystroke.

Viewing the PDF

Once compiled, ViewTex() opens the corresponding PDF in Evince without blocking Vim:


function! ViewTex() abort
    let pdf = substitute(expand('%:p'), '\.tex$', '.pdf', '')
    silent! execute '!nohup evince ' . shellescape(pdf) . ' >/dev/null 2>&1 &'
    redraw!
endfunction

Using nohup ensures the viewer persists even if the terminal closes, and the silent redraw avoids screen flicker. Bound to <leader>o, it closes the edit‑compile‑view loop seamlessly.

Exporting LaTeX as HTML for Static Sites

The most unconventional part of this setup is the WrapBufferInHTMLTags() function. It yanks the entire buffer, escapes HTML entities, and wraps the result in <pre><code> blocks with a language class. The new buffer is then given a .html filename and filetype.


function! WrapBufferInHTMLTags()
    execute 'normal! ggVGy'
    let l:content = getreg('0')
    let l:content = substitute(l:content, '&', '\&amp;', 'g')
    let l:content = substitute(l:content, '<', '\&lt;', 'g')
    let l:content = substitute(l:content, '>', '\&gt;', 'g')
    call setreg('0', l:content)
    let l:current_filename = expand('%:t:r') . ".html"
    execute 'enew'
    setlocal filetype=html
    execute 'file ' . l:current_filename
    call setline(1, '<pre class="language-latex">')
    call append(1, '<code class="language-latex">')
    execute 'normal! Go'
    execute 'normal! "0p'
    call append(line('$'), '</code></pre>')
    execute 'normal! gg'
endfunction

This function targets a specific pain point: publishing LaTeX source code in a Pelican-powered static site. Instead of manually escaping characters and adding HTML tags, a single mapping (<leader>w) produces a correctly formatted code block ready to be inserted into an body.html file. It is a perfect example of merging local tooling with an automated publishing pipeline.

Insert Mode Mappings: From Keystrokes to Content

A large portion of the ftplugin is devoted to insert-mode mappings that make typing LaTeX faster and more consistent.

Symbol Shortcuts and Structural Commands

Several mappings re-purpose keys that are rarely used in LaTeX but easily reachable:

•! → \ and § → !: swaps backslash and exclamation mark, since the backslash is the most frequent LaTeX character and ! is seldom needed.

•qq → \quad: inserts a quad space, used constantly in math environments.

•tt → ~\text{}~<++>: wraps text inside math mode with a tilde-protected space, placing the cursor ready to type the text and then jump to the placeholder.

•;hs, ;vs: horizontal and vertical space commands with a placeholder for the length.

•;bf, ;u: bold text and underline.

The <++> placeholder and the <C-j> mapping (both in insert and normal modes) implement a simple jump-to-next-placeholder mechanism. After inserting a template like \textbf{}, the cursor lands inside the braces; pressing <C-j> deletes the placeholder and moves to the next edit point, keeping hands on the home row.

Snippet Insertion System

The brunt of the automation comes from a collection of snippet files, each stored as a standalone .tex file inside ~/.vim/snippets/latex/. Insert mode mappings read these files directly into the buffer:


inoremap ;ds <ESC>:0r /home/mosaid/.vim/snippets/latex/ds<CR>
inoremap ;st <ESC>:0r /home/mosaid/.vim/snippets/latex/st<CR>
inoremap ;ar <ESC>:r /home/mosaid/.vim/snippets/latex/ar<CR>

The files are plain TeX, allowing direct editing without any special format. Below is a summary of the available snippets:

Keystroke	File	Purpose
;dd	d1	Minimal article document skeleton (12pt, a4paper)
;ds	ds	Full exam class with custom borders, TikZ stamps, and bilingual (French/Arabic) support
;st	st	Standalone TikZ picture class for generating PNG graphics
;ar	ar	Arabic language preamble (polyglossia, Amiri font)
;gg	gg	Tight geometry: 1 cm margins on all sides
;tcb	tcb	tcolorbox exercise environment with red frame, gray background, and counter
;mt	mtab	Math-mode tabular environment for alignments
;li	li	Custom tight enumerate list (compact spacing)
;ti	tight	Enumitem key that makes any list tight
—	enum	Standard enumerate wrapper (no default mapping; users can add their own)

Each snippet is a complete, self-contained piece of LaTeX that can be inserted either at the top of the file (:0r) or at the cursor (:r). The exam template (ds) alone is over 6 kB and includes a custom \stamp, \luck, and \borders system—showcasing how deeply tailored these templates can become.

Additional inline mappings complement the snippets:

•;mm: inserts \usepackage{amsmath, amsfonts, amssymb, amsthm} in one go.

•;ig: \includegraphics[width=<++>cm]{<++>} with placeholders.

•;bm: defines a \bottommsg macro used in certain document styles.

All of these shortcuts follow a consistent pattern: they reduce multi-step actions to a short, memorable sequence, often using the semicolon as a namespace leader to avoid conflicts with normal typing.

Visual Mode Wrapping: Metaprogramming Text

Visual mode mappings allow applying formatting to existing text without manual cursor navigation:

•<leader>$: surrounds selected text with ~$...$~, converting a region to inline math.

•<leader>u, <leader>b, <leader>i: underline, boldface, italic.

•<leader>cc: wraps text in \textcolor{}{...}, prompting for the colour.

•1, 2, 3, 4, 5: a series of single-key visual mappings for \bm{\textcolor{}{...}}, \bbox, \rbox, \obox, and inline math respectively.

•6, 9: convert \[...\] and $...$ delimiters to the Vim author’s preferred ~$...$~ syntax, using a clever search-and-replace on the visual selection.

These mappings treat the document like a programmable structure, allowing restructuring and enhancement without ever leaving the editor or reaching for the mouse.

Tradeoffs and Limitations

Every engineering decision involves tradeoffs. This setup is no exception:

•Hard-coded paths: Snippet file paths are absolute (/home/mosaid/.vim/snippets/latex/). This works well on a single machine but breaks portability. A more robust solution would use environment variables or Vim’s ~/.vim relative paths (e.g., :r ~/.vim/snippets/latex/ds).

•Synchronous compilation: RunTex() runs xelatex synchronously, freezing Vim during compilation—fine for small documents, noticeable on 50+ page manuscripts. Integrating an async job via job_start() or :terminal would modernise it.

•Tight coupling to Evince: The viewer function assumes Evince is installed. While easily swapped, it’s not platform-agnostic.

•Snippet maintenance: Keeping the snippet library consistent and up-to-date is a manual process. A snippet engine like UltiSnips could provide more flexibility (placeholders, transforms), but the current approach is deliberately simple and transparent—just files on disk.

•Key conflict potential: Mappings like 1 in visual mode shadow Vim’s default behaviour. This is intentional; the author has internalised these overrides, but they may confuse new adopters.

Workflow Integration

This ftplugin does not exist in isolation. It is part of a larger pipeline that often includes:

A Makefile or latexmk continuous build script for multi-file projects.
A Pelican static site generator: the WrapBufferInHTMLTags() function directly feeds the blogging engine with syntax-highlighted LaTeX code blocks.
A Git repository that versions both the ftplugin and the snippet files, ensuring reproducibility across machines.
Terminal multiplexers (tmux) or modern terminal emulators that allow a side-by-side layout: Vim on the left, Evince on the right, and a compilation watcher in a third pane.

The system shines when you treat your LaTeX authoring as a software project: deterministic, automated, and continuously compiled.

Future Improvements

The current setup has evolved organically. For a more polished, distributable version, several enhancements are worth considering:

•Async compilation: Replace RunTex() with Vim’s job_start() and populate a quickfix list from the log, enabling :copen navigation.

•Portable snippet paths: Use expand('~/.vim/snippets/latex') instead of hard-coded /home/mosaid.

•UltiSnips or LuaSnip bridging: Keep the file‑based repository but generate snippet definitions dynamically, gaining visual placeholders and tab‑stops without abandoning the file system.

•LSP integration: Combine this custom tooling with a LaTeX language server (e.g., TexLab) for diagnostics, references, and hover information.

•Theme-aware PDF rendering: Adapt the ViewTex() function to work with other viewers (Zathura, Okular) or even inline PDF previews in modern Vim terminals.

Final Thoughts

This Vim configuration is a testament to the power of incremental customisation. What began as a few insert-mode shortcuts grew into a full-blown LaTeX editing environment that eliminates boilerplate, reduces cognitive load, and bridges the gap between document authoring and web publishing. It does not attempt to replace dedicated LaTeX IDEs; instead, it layers deterministic automation on top of an editor that the user already trusts.

The approach is reproducible, composable, and deeply personal—exactly what makes Vim a lasting tool for engineers. If you also live in Vim and write LaTeX, consider adopting (and adapting) these patterns to match your own workflow. The entire configuration is just a single ftplugin file and a folder of snippets—easy to version, easy to tweak, and easy to forget about once muscle memory takes over.

From Plain Text to HTML in Vim – Using Python Filters for Instant Markup

2026-05-13T20:50:06+00:00

If you write a lot of HTML by hand – documentation, blog posts, static site templates – you know how tedious it is to wrap lines in <p> tags, convert bullet lists into <li> blocks with proper classes, or build <select> menus from scratch. With the RunScriptFilter workflow introduced in the previous article, we can turn any visual selection into the output of a Python script. This article focuses entirely on Vim text to HTML transformations: instant, composable, and custom‑tailored to your markup needs.

The Core Filter (Recap)

The foundation is a Vim function that pipes selected text to an external command and replaces the selection with the command’s output. Here’s the production‑ready version we’ll use in every example:


function! RunScriptFilter(cmd) range
    let l:save_reg = getreg('"')
    let l:save_regtype = getregtype('"')
    normal! ""gvy
    let l:text = getreg('"')
    call setreg('"', l:save_reg, l:save_regtype)

    let l:tmp = tempname()
    call writefile(split(l:text, "\n", 1), l:tmp)
    let l:out = system(a:cmd . ' < ' . shellescape(l:tmp))
    call delete(l:tmp)

    if v:shell_error
        echohl ErrorMsg
        echo "Filter error:\n" . l:out
        echohl None
        return
    endif
    let l:out = substitute(l:out, '\n\+$', '', '')
    execute "normal! gv\"_c" . l:out
endfunction

Any external tool that reads stdin now becomes a Vim HTML filter. Let’s put it to work.

1. Instant Paragraph Wrapping

Select a block of text and turn each non‑empty line into a <p> element. The Python script is trivial:


import sys

for line in sys.stdin:
    stripped = line.strip()
    if stripped:
        print(f"<p>{stripped}</p>")
    else:
        print()   # preserve blank lines

Map it:


xnoremap <leader>hp :call RunScriptFilter('python3 -c "
import sys
for l in sys.stdin:
    s = l.strip()
    print(f\"<p>{s}</p>\" if s else \"\")
"')<CR>

Select several paragraphs, hit <leader>hp, and they’re wrapped instantly. No more manually typing <p> and </p>.

2. Headings from Plain Lines

A slightly smarter filter can detect heading levels. Here, lines starting with # are converted to <h1> through <h4> based on the number of #:


import sys, re

for line in sys.stdin:
    line = line.rstrip('\n')
    m = re.match(r'^(#{1,4})\s+(.*)', line)
    if m:
        level = len(m.group(1))
        print(f"<h{level}>{m.group(2)}</h{level}>")
    else:
        print(f"<p>{line}</p>")

Map: xnoremap <leader>hh :call RunScriptFilter('python3 heading_filter.py')<CR>. Now you can write a quick outline, select it, and get semantic HTML headings and paragraphs.

3. Markdown‑Style Lists to Styled HTML Lists

Here’s where external scripts really shine. Suppose you write a list like:


1 *foo* bar
2 *foo* baz
3 *foo* qux

You want this to become:


<ol>
<li><strong style="color:#b5bd68;">foo</strong> bar</li>
<li><strong style="color:#b5bd68;">foo</strong> baz</li>
<li><strong style="color:#b5bd68;">foo</strong> qux</li>
</ol>

A small Python script handles it:


import sys, re

lines = [l.rstrip('\n') for l in sys.stdin if l.strip()]
if not lines:
    sys.exit(0)

print("<ol>")
for line in lines:
    # Extract index, bold part, rest
    m = re.match(r'^\d+\s+\*(.+?)\*\s*(.*)', line)
    if m:
        bold = m.group(1)
        rest = m.group(2)
        print(f'  <li><strong style="color:#b5bd68;">{bold}</strong> {rest}</li>')
    else:
        print(f'  <li>{line}</li>')
print("</ol>")

Map: xnoremap <leader>hl :call RunScriptFilter('python3 mdlist2html.py')<CR>. The same pattern works for unordered lists: just switch to <ul> and adjust the regex.

4. Generate <select> Menus from a List

Turn this:


Volvo
Saab
Mercedes
Audi

into:


<select name="cars">
  <option value="0">Volvo</option>
  <option value="1">Saab</option>
  <option value="2">Mercedes</option>
  <option value="3">Audi</option>
</select>

Python script:


import sys

lines = [l.strip() for l in sys.stdin if l.strip()]
if not lines:
    sys.exit(0)

print('<select name="items">')
for i, item in enumerate(lines):
    print(f'  <option value="{i}">{item}</option>')
print('</select>')

Map: xnoremap <leader>hs :call RunScriptFilter('python3 select_filter.py')<CR>. Now any list becomes a dropdown in one keystroke.

5. CSV to HTML Table

When you have comma‑separated data, generate a full HTML table with proper escaping:


import sys, csv
from html import escape

reader = csv.reader(sys.stdin)
rows = list(reader)
if not rows:
    sys.exit(0)

print('<table>')
for i, row in enumerate(rows):
    tag = 'th' if i == 0 else 'td'
    cells = ''.join(f'<{tag}>{escape(cell)}</{tag}>' for cell in row)
    print(f'  <tr>{cells}</tr>')
print('</table>')

Map: xnoremap <leader>ht :call RunScriptFilter('python3 csv2table.py')<CR>. This alone saves minutes of repetitive tag writing when you embed tables in blog posts.

6. Custom Inline Styles Based on Content

The sky is the limit. For instance, you can write a filter that detects numbers and wraps them in <span style="color:red;">, or that automatically creates hyperlinks from URLs. Here’s a simple one that bolds any word that starts with a capital letter:


import sys, re

def bold_caps(text):
    return re.sub(r'\b([A-Z][a-z]+)\b', r'<strong>\1</strong>', text)

for line in sys.stdin:
    print(bold_caps(line.rstrip('\n')))

Map it and select any block – proper names are automatically emphasised.

7. Full‑Document Conversion with Pandoc

Sometimes you want to convert an entire Markdown buffer to HTML without leaving Vim. Using the buffer‑wide variant of our filter:


command! -nargs=1 FilterBuffer call RunBufferFilter(<q-args>)
nnoremap <leader>mdh :FilterBuffer pandoc -f markdown -t html<CR>

This turns a Markdown document into a full HTML page, perfect for previewing or pasting into a CMS.

Workflow and Safety

Undo‑friendly: The replacement is a single change – u brings back the original text instantly.
Error‑safe: If the script fails (non‑zero exit), the selection remains untouched and the error is displayed.
No escaping headaches: Using temporary files avoids shell‑injection and quoting nightmares.
Composable: You can pipe the output of one filter directly into another by running them sequentially – or chain them in a single shell pipeline inside the filter command.

Building Your HTML Editing Toolkit

I keep a handful of Python scripts in ~/bin/html-filters/ and load the corresponding Vim maps in a file that’s sourced automatically. The consistent interface – select, press a leader key, done – means I never have to think about the underlying mechanics. Whether I’m preparing a blog post, editing a static page template, or documenting an API, these Vim HTML filters have eliminated hundreds of repetitive keystrokes per week.

The real power of this approach isn’t any single script – it’s the mindset that your editor can become a programmable HTML generator whenever you need it. Start with one filter that solves a real annoyance in your current project, and the rest will follow naturally.

Vim Text Filters: Replacing Macros with Python & Shell Scripts for LaTeX, Code, and Data

2026-05-13T20:50:06+00:00

Vim’s macro system is a classic power tool, but when you need real computation—parsing JSON, evaluating maths, formatting data—macros quickly hit their limits. Instead of recording a sequence of keystrokes, I use external scripts as Vim text filters. This Vim Python workflow replaces a visual selection (or an entire buffer) with the output of any command-line tool, turning your editor into a programmable text transformation pipeline.

Why Use Python Scripts Instead of Vim Macros?

Vim macros are perfect for one‑off, linear edits, but they become fragile when you need:

Arithmetic or symbolic math (e.g., evaluating LaTeX expressions)
Structured data processing (JSON, CSV, HTML tables)
External API calls
Linting or formatting with dedicated tools

By piping text to a script and replacing it with the script’s output, you gain the full expressiveness of Python, jq, pandoc, or any Unix filter – all while staying in normal mode. This Vim text filter approach is reusable, composable, and far easier to debug than a complex macro.

The Core Vim Text Filter Function

The foundation is a Vim function that yanks the current visual selection, sends it to a command via stdin, and overwrites the selection with the result. Here is a refined, production‑ready version I use every day, designed to handle multi‑line selections safely and to report errors without losing your original text.


function! RunScriptFilter(cmd) range
    " Save the current register and selection type
    let l:save_reg = getreg('"')
    let l:save_regtype = getregtype('"')

    " Yank the visual selection
    normal! ""gvy
    let l:text = getreg('"')

    " Restore the register immediately
    call setreg('"', l:save_reg, l:save_regtype)

    " Write the text to a temporary file to avoid shell escaping problems
    let l:tmp = tempname()
    call writefile(split(l:text, "\n", 1), l:tmp)
    let l:out = system(a:cmd . ' < ' . shellescape(l:tmp))
    call delete(l:tmp)

    " Show errors in a popup if the command failed
    if v:shell_error
        echohl ErrorMsg
        echo "Filter error:\n" . l:out
        echohl None
        return
    endif

    " Remove a trailing newline so we don't introduce blank lines
    let l:out = substitute(l:out, '\n\+$', '', '')

    " Replace the selection with the filtered output
    execute "normal! gv\"_c" . l:out
endfunction

" Example: format JSON with jq
xnoremap <silent> <leader>jq :<C-u>call RunScriptFilter('jq .')<CR>

With this generic filter, any command that reads from stdin becomes a Vim text filter. No more escaping nightmares, and errors are shown without destroying your buffer.

Practical Vim Filter Examples for LaTeX, Code, and Data

1. Live Math Evaluation in LaTeX Documents

When writing technical articles, I often need to compute a value for a table or verify a formula. By selecting an expression and running a Vim Python filter, I get the result instantly. A small Python script handles the math:


# Save as ~/bin/vim-math-filter
python3 -c "from math import *; import sys; print(eval(sys.stdin.read()))"

Map it in Vim:


xnoremap <leader>m :call RunScriptFilter('vim-math-filter')<CR>

Now sqrt(2)*3.14 becomes 4.4403135525488 with a single keystroke.

2. Formatting CSVs into Markdown Tables

Data in CSV format can be transformed into a neatly aligned Markdown table using a quick Python script. This is a classic automate repetitive edits in Vim use case.


# ~/bin/csv2md-table
python3 << 'PYEOF'
import csv, sys
rows = list(csv.reader(sys.stdin))
if not rows: sys.exit(0)
widths = [max(len(str(row[i])) for row in rows) for i in range(len(rows[0]))]
for i, row in enumerate(rows):
    print('| ' + ' | '.join(f"{str(row[j]):{widths[j]}}" for j in range(len(row))) + ' |')
    if i == 0:
        print('|' + '|'.join(f"{'-'*(w+2)}" for w in widths) + '|')
PYEOF

Map it: xnoremap <leader>tb :call RunScriptFilter('csv2md-table')<CR>. Select any CSV block, hit the map, and you get a perfectly formatted table – no manual alignment required.

3. JSON Prettification and Data Extraction

For quick JSON processing inside Vim, jq is unbeatable. These mappings turn selections into pretty‑printed JSON, or extract a single field:


xnoremap <leader>jp :call RunScriptFilter('jq .')<CR>
xnoremap <leader>jn :call RunScriptFilter('jq -r .name')<CR>
xnoremap <leader>jc :call RunScriptFilter('jq -c .')<CR>

It’s an order of magnitude faster than trying to reformat JSON with a macro.

4. Linting and Auto‑formatting Code Blocks

Use your favourite linter as a Vim text filter. For example, run black on a visually selected Python snippet inside a Markdown fenced block:


xnoremap <leader>bl :call RunScriptFilter('black -q -')<CR>

No need to leave Vim or copy‑paste – the formatted code replaces your selection instantly.

5. Whole‑Buffer Transformations with Pandoc

The same concept extends to the entire file. A slight modification of the function lets you pipe the whole buffer through any tool:


function! RunBufferFilter(cmd)
    let l:tmp = tempname()
    execute 'write !cat > ' . l:tmp
    let l:out = system(a:cmd . ' < ' . shellescape(l:tmp))
    call delete(l:tmp)
    if v:shell_error
        echohl ErrorMsg | echo l:out | echohl None
        return
    endif
    %delete
    put =l:out
    1delete _
endfunction

command! -nargs=1 FilterBuffer call RunBufferFilter(<q-args>)

Now you can use :FilterBuffer pandoc -f markdown -t plain to strip all Markdown formatting, or :FilterBuffer figlet for instant ASCII art.

Integrating the Filter into Your Vim and LaTeX Workflow

For those working heavily with Vim and LaTeX, these filters become a natural extension of your editing toolbelt. Examples from my own workflow include:

Aligning LaTeX tables – pipe a selection through a Python script that aligns columns on &.
Generating TikZ diagrams – select a numeric specification and use a filter to output the full TikZ code.
Cleaning up BibTeX entries – run bibtool --pretty on a selection to normalise formatting.
Spell‑checking a paragraph – use textidote --check en as a filter and see suggestions inline.

The pattern is always the same: select, map, transform. This Vim automation mindset turns your editor into a composable toolchain.

Performance, Safety, and Edge Cases

•Temporary files: Always preferred over shellescape() for multi‑line text because they avoid escaping bugs.
•Error handling: Never replace the selection if the command fails – the original text remains intact.
•Undo friendliness: The replacement is a single change, so a quick u restores everything.
•Blocking concerns: The examples are synchronous; for heavy scripts (>1s), use Neovim’s job‑control or Vim’s job_start() to keep the UI responsive.
•Security: Avoid running arbitrary shell input – always use fixed commands with controlled arguments. Never interpolate user text directly into a command string.

Customise the Vim Text Filter for Your Own Workflow

The real power comes when you build a small library of filters that match your daily tasks. I keep mine in ~/bin and in a dedicated Vim plugin file, with leader mappings grouped by topic: <leader>m for math, <leader>t for tables, <leader>j for JSON. Because the filter command is external, you can write it in Python, Ruby, Node.js, or even a compiled binary – Vim only cares about stdin and stdout.

This Vim + Python text transformation approach has replaced dozens of ad‑hoc macros in my setup and has become the backbone of how I edit code, documents, and data. Once you experience a single keystroke that computes a formula or formats a table, you’ll wonder why you ever recorded a macro for those tasks.

Boosting LaTeX Editing with Custom Vim Mappings

2025-11-23T23:46:56+00:00

Introduction

As someone who writes mathematical documents regularly, I've always found LaTeX editing to be a constant dance between content creation and formatting struggles. The back-and-forth typing of verbose commands like \textbf{} and \underline{} constantly interrupted my creative flow. That's when I decided to supercharge my Vim setup with custom mappings specifically designed for LaTeX - and the results have been transformative for my productivity.

Basic Settings

Before diving into the fancy mappings, let's start with the foundation. I prefer 2-space indentation for LaTeX files as it strikes the perfect balance between readability and efficient use of screen space:

autocmd FileType tex setlocal tabstop=2 shiftwidth=2 expandtab

Compiling and Viewing LaTeX

One of the most common tasks in LaTeX editing is compiling and previewing. Instead of constantly switching to the terminal, I've created seamless workflows right within Vim.

•Instant Compilation: Pressing <leader>c compiles the current file and shows me the output right in a Vim buffer - no context switching needed:

    
function! RunTex()
    let s:current_file = expand("%")
    enew | silent execute ".!xelatex " . shellescape(s:current_file, 1)
    setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
    if &number == 0
        set number
    endif
    set relativenumber
    normal! G
    nnoremap <buffer> <CR> :bd!<CR>
endfunction
nnoremap <leader>c :call RunTex()<CR>

•Quick PDF Preview: When I need to see the actual PDF, <leader>o opens it in Evince without leaving Vim:

    
function! ViewTex() abort
    let pdf = substitute(expand('%:p'), '\.tex$', '.pdf', '')
    silent! execute '!nohup evince ' . shellescape(pdf) . ' >/dev/null 2>&1 &'
    redraw!
endfunction
nnoremap <leader>o :call ViewTex()<CR>

Smart Insert Mode Shortcuts

These are the real workhorses of my LaTeX workflow - they let me insert common elements with minimal keystrokes while keeping me in the flow.

•Mathematical Spacing: Instead of typing \quad every time, I just type qq in insert mode and it expands automatically.

•Text Wrapping: Need text in a math environment? tt wraps my text with proper formatting and even positions my cursor inside the braces.

•Formatting Commands: Bold and underline become second nature with ;bf for \textbf{} and ;u for \underline{}.

•Template Loading: This is where the real magic happens. I have pre-written templates for common elements:

;tcb inserts a beautiful tcolorbox environment with proper styling
;ds loads my document structure template with title, author, and sections pre-filled

    
inoremap qq \quad
inoremap tt ~\text{}~<++><ESC>F{a
inoremap ;bf \textbf{}<++><ESC>F{a
inoremap ;u \underline{}<++><ESC>F{a
inoremap ;tcb <ESC>:r /home/mosaid/.vim/snippets/latex/tcb<CR>
inoremap ;ds <ESC>:0r /home/mosaid/.vim/snippets/latex/ds<CR>

Visual Mode Power Tools

When working with existing text, these visual mode mappings are absolute lifesavers:

•Quick Formatting: Select text and use <leader>b for bold or <leader>u for underline - it wraps your selection perfectly.

•Math Mode Magic: My personal favorites include:

5 on selected text wraps it with math mode delimiters
6 converts display math \[ \] to inline math $ $
9 transforms  math notation to the cleaner $ $ syntax

    
vnoremap <leader>$ s~$<C-r>"$~<++><Esc>
vnoremap <leader>u c\underline{<C-r>"}<++>
vnoremap <leader>b c\textbf{<C-r>"}<++>
vnoremap 5 c~$<C-r>"$~<Esc>
vnoremap 6 <Esc>:'<,'>s/\\\[/\~$/e<CR>:'<,'>s/\\\]/\$\~/e<CR>
vnoremap 9 <Esc>:'<,'>s/\\(/\~$/eg<CR>:'<,'>s/\\)/\$\~/eg<CR>

Mathematical Efficiency Boosters

These small but mighty mappings handle the repetitive mathematical notation that used to slow me down:

    
inoremap ;o $(O; \vec i, \vec j)$
inoremap $$ ~$$~<++><Esc>F$i
inoremap [ []<++><Esc>F]i

The ;o mapping is particularly useful for coordinate systems, while $$ and [ handle the common cases of creating math environments and brackets with proper cursor placement.

Conclusion

What started as a simple attempt to reduce typing has evolved into a comprehensive LaTeX editing system that feels almost like having a personal assistant. The beauty of these mappings isn't just in the time saved - it's in the uninterrupted flow state they enable. I no longer break my mathematical reasoning to remember LaTeX syntax; the commands have become extensions of my thought process. Whether you're a student writing homework, a researcher drafting papers, or anyone who frequently works with LaTeX, I highly recommend investing time in building your own Vim mappings - the productivity payoff is absolutely worth it.

Automating Code Transformations in Vim with RunScriptsOnSelect

2025-11-23T18:54:13+00:00

Streamlining Code Processing in Vim

When I work with multiple programming languages, I often need to process code snippets through external tools. Manually handling this became tedious, so I created a Vim function that automates the entire workflow. The RunScriptsOnSelect function detects code type from visual selections and routes them to appropriate Python processors automatically.

How RunScriptsOnSelect Works

The function operates in visual mode and follows this intelligent workflow:

•Selection Capture: It captures the visually selected text range including line numbers

•Type Detection: Uses the first line as a type indicator for processing

•Validation: Checks against allowed processors to prevent errors

•Routing: Sends content to the appropriate Python script

•Replacement: Cleanly replaces selection with processed output

The Complete Implementation

Here is the complete Vim function that makes this automation possible:

    
function! RunScriptsOnSelect()
    " Get selection range
    let l:start_line = line("'<")
    let l:end_line = line("'>")

    " Get selected lines
    let l:lines = getline(l:start_line, l:end_line)

    " First line = type
    let l:type_line = tolower(trim(l:lines[0]))

    " Allowed types
    let l:allowed_types = ['tex', 'html', 'py', 'vim']

    " Validate first line
    if index(l:allowed_types, l:type_line) == -1
        let l:reminder = ["Make the first line of your selection as tex, html, py or md"]
        call setline(l:start_line, l:reminder)
        " Delete the rest of selection
        if l:end_line > l:start_line
            call deletebufline('%', l:start_line + 1, l:end_line)
        endif
        return
    endif

    " Actual content to process = selection except first line
    let l:selected_text = join(l:lines[1:], "\n")

    " Script locations
    let l:script_base_dir = '~/bin/python'
    let l:script_map = {
    \ 'tex':  l:script_base_dir . '/change-tex.py',
    \ 'vim':  l:script_base_dir . '/change-vim.py',
    \ 'py':   l:script_base_dir . '/change-python.py',
    \ 'html': l:script_base_dir . '/change-html.py',
    \ }

    " Run script
    let l:output = system('python3 ' . l:script_map[l:type_line], l:selected_text)
    let l:output_lines = split(l:output, "\n")

    " ---- SIMPLE & SAFE REPLACEMENT ----
    " 1) Delete entire selection
    call deletebufline('%', l:start_line, l:end_line)

    " 2) Insert type line + script output
    call append(l:start_line - 1, [l:type_line] + l:output_lines)
endfunction

vnoremap <leader>rs :<C-U>call RunScriptsOnSelect()<CR>

Robust Type Validation

By checking against the allowed_types list, we ensure only supported processors are used. If someone tries an unsupported type, they get immediate feedback with clear instructions.

Flexible Script Mapping

The script_map dictionary makes it incredibly easy to extend functionality. When I want to add support for a new language, I simply add another entry to the mapping - no need to modify the core function logic.

Clean Output Replacement

This was the trickiest part to get right. The function handles cases where processed output might be longer or shorter than the original selection, ensuring clean replacement without leaving orphaned lines or missing content.

Example Processor Script

Here is a sample Python script that demonstrates how to process Vim script content. This particular example escapes HTML and wraps Vim code in proper pre and code tags:

    
import sys
import html

def process_text(content):
    """Escape LaTeX and wrap in <pre><code>."""
    escaped_content = html.escape(content)
    wrapped_content = f"""<pre class="language-vim">
    <code class="language-vim">
{escaped_content}
    </code>
</pre>
"""
    return wrapped_content

if __name__ == "__main__":
    if len(sys.argv) > 1:
        # Read content from file if a path is provided
        file_path = sys.argv[1]
        try:
            with open(file_path, 'r') as f:
                content = f.read()
        except Exception as e:
            print(f"Error processing file: {e}")
            sys.exit(1)
    else:
        # Otherwise, read content from stdin
        content = sys.stdin.read()

    print(process_text(content))

To use this function in your daily workflow, follow these steps:

1. Enter visual mode and select your code block

2. Make sure the first line indicates the processor type

3. Press your leader key followed by rs

For example, to process Vim script, your selection would look like this:

    
vim
function! ExampleFunction()
    echo "This will be processed as Vim script"
endfunction

Customization Opportunities

•Extended Language Support: Add more types to the allowed_types list for additional languages

•Custom Script Locations: Modify the script_base_dir to point to your preferred script locations

•Error Handling: Add more robust error handling for missing script files or processing failures

•Preview Functionality: Implement a preview mode that shows changes before applying them

•Multiple Processors: Allow chaining multiple processors for complex transformations

This Vim function demonstrates how we can combine Vim's powerful extensibility with Python's processing capabilities. It creates a seamless workflow that adapts to multiple programming languages while maintaining the efficiency and speed that makes Vim such a powerful editor.

The beauty of this approach is its simplicity and extensibility. Once you have the core function working, adding support for new languages or processors becomes trivial. I have found this particularly useful when working with documentation, code samples, and automated formatting tasks.

Improving TeX Editing in Vim with a Smart 'Select Inside Any Pair' Function

2025-11-23T18:14:02+00:00

Improving Your TeX Workflow in Vim with a Smart “Select Inside Any Pair” Function

One of the reasons I love working in Vim is how easily I can extend it to match the way I write and edit. When dealing with LaTeX files—especially long derivations, nested parentheses, or math environments—I often need to quickly select the text inside {…}, (…), or even inside $…$ blocks. Doing this manually wastes time, interrupts my flow, and becomes frustrating when there are many levels of nesting.

To fix this, I wrote a custom function that intelligently selects whatever “pair” I am currently inside: curly braces, brackets, parentheses, math mode, quotes—anything. This small function has massively improved how I work inside TeX files.

Why This Function Matters

•Instant selection in TeX math: When working between $…$ , a single keystroke selects the content cleanly—even in long expressions.

•Nested structures handled automatically: For { { ( … ) } }, the function detects the correct level around the cursor instead of selecting the wrong one.

•Works across all common pairs: Parentheses, brackets, braces, math mode, quotes, and even symmetric delimiters are supported.

•Better than built-in text objects: Vim’s default vi( and friends work only when your cursor is right next to the delimiter. This custom function works even if you're deep inside the content.

The Function That Does the Magic

    
function! SelectInsideAnyPair()
    let l:savepos = getpos('.')

    let l:pairs = [
    \ ['{', '}'],
    \ ['[', ']'],
    \ ['(', ')'],
    \ ['$', '$'],
    \ ['"', '"'],
    \ ["'", "'"]
    \ ]

    for l:pair in l:pairs
        let l:open  = l:pair[0]
        let l:close = l:pair[1]

        if l:open ==# l:close
            " symmetric delimiters
            let l:start = searchpos('\V' . l:open, 'bnW')
            let l:end   = searchpos('\V' . l:close, 'nW')
        else
            " asymmetric pairs (handles nesting)
            let l:start = searchpairpos('\V' . l:open, '', '\V' . l:close, 'bnW')
            let l:end   = searchpairpos('\V' . l:open, '', '\V' . l:close, 'nW')
        endif

        if l:start[0] > 0 && l:end[0] > 0
            let l:cur = getpos('.')
            let l:start_before_cursor = (l:start[0] < l:cur[1]) || (l:start[0] == l:cur[1] && l:start[1] <= l:cur[2])
            let l:end_after_cursor   = (l:end[0]   > l:cur[1]) || (l:end[0]   == l:cur[1] && l:end[1]   >= l:cur[2])

            if l:start_before_cursor && l:end_after_cursor
                " start just after opening delimiter
                call setpos('.', [0, l:start[0], l:start[1] + 1, 0])
                normal! v
                " end just before closing delimiter
                call setpos('.', [0, l:end[0], l:end[1], 0])
                normal! h
                return
            endif
        endif
    endfor

    " --- fallback: select whole line (without trailing $) ---
    let l:lnum = line('.')
    let l:line = getline(l:lnum)

    " compute start and end columns
    let l:start_col = 1
    let l:end_col   = len(l:line)

    " if line ends with $, exclude it
    if l:end_col > 0 && l:line[-1:] ==# '$'
        let l:end_col -= 1
    endif

    if l:end_col >= l:start_col
        call setpos('.', [0, l:lnum, l:start_col, 0])
        normal! v
        call setpos('.', [0, l:lnum, l:end_col, 0])
    else
        call setpos('.', l:savepos)
        echo "Nothing to select"
    endif
endfunction

nnoremap <silent> <leader>v :call SelectInsideAnyPair()<CR>

This tiny Vim function eliminates the repetitive hassle of manually selecting content inside brackets, quotes, or math delimiters. For LaTeX-heavy workflows, it’s a real productivity booster.

How I Use Vim to Do Quick Calculations While Writing LaTeX

2025-09-28T13:48:54+00:00

Supercharging Vim: Running Python Code Directly from Your Editor

Running python directly in vim

I've always loved Vim for its speed, simplicity, and ability to stay entirely in the terminal while doing serious work. But recently, I added a layer of magic that completely changed how I use it — running Python code directly from Vim without leaving the editor. This has been a game-changer, especially when editing LaTeX documents or writing technical content that needs quick calculations on the fly.

Imagine this: I'm writing an article and need to calculate a percentage or quickly check a value before putting it into my text. Instead of switching to a Python REPL or using a calculator, I just visually select the code, hit a keybinding, and Vim either shows me the result in a scratch buffer or replaces the selected text with the computed value. It's seamless, and it's awesome.

The Magic Behind It

Here’s what makes this possible — two small but powerful Vimscript functions that I added to my configuration. The first one runs any visually selected Python code and shows me the output in a new scratch buffer:

    
function! RunPythonSelection() range
    " Save current register and selection type
    let l:save_reg = getreg('"')
    let l:save_regtype = getregtype('"')

    " Yank the visually selected text into the default register
    normal! ""gvy
    let l:code = getreg('"')

    " Restore register
    call setreg('"', l:save_reg, l:save_regtype)

    " Trim leading/trailing whitespace
    let l:code = substitute(l:code, '^\s*', '', '')
    let l:code = substitute(l:code, '\s*$', '', '')

    " Run the exact selected text as Python code
    let l:output = system('python3 -c ' . shellescape(l:code))

    " Open a scratch buffer and display the output
    enew
    call setline(1, split(l:output, "\n"))
    setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
endfunction


xnoremap  <leader>c :<C-u>call RunPythonSelection()<CR>

This function is brilliant for experimentation. I just highlight a few lines of Python, press <leader>c, and I get a temporary buffer with the result — no clutter in my main file, no switching windows.

But Wait, It Gets Better

Sometimes I don't just want to see the result, I want to replace the selected text with the result. That's where the second function comes in:

    
function! RunPythonAndReplace() range
    " Save current register and selection type
    let l:save_reg = getreg('"')
    let l:save_regtype = getregtype('"')

    " Yank visually selected text into the default register
    normal! ""gvy
    let l:code = getreg('"')

    " Restore register contents
    call setreg('"', l:save_reg, l:save_regtype)

    " Trim whitespace
    let l:code = substitute(l:code, '^\s*', '', '')
    let l:code = substitute(l:code, '\s*$', '', '')

    " Detect if selection is a single line
    if line("'<") == line("'>")
        let l:code = 'print(' . l:code . ')'
    endif

    " add some imports
    let l:code = 'from math import *;' . l:code

    " Run the code through Python
    let l:output = system('python3 -c ' . shellescape(l:code))

    " Remove trailing newline from output
    let l:output = substitute(l:output, '\n\+$', '', '')

    " Replace the selection with the output
    execute "normal! gv\"_c" . l:output
endfunction

xnoremap  <leader>r :<C-u>call RunPythonAndReplace()<CR>

This one is my favorite. Let's say I'm writing a LaTeX file and I have:

    
The success rate is $ (45/60)*100 $ \%.

I can just visually select (45/60)*100, hit <leader>r, and boom — it’s replaced with 75.0. This keeps me focused and lets me write accurate numbers without ever leaving my editor.

Running python directly in vim

Why This Matters

•Context Switching is the Enemy: Leaving Vim to open a calculator or REPL breaks flow. This solves that.

•Perfect for Technical Writing: I use this trick while editing LaTeX code, which often requires quick math or unit conversions.

•Great for Learning: You can experiment with Python right inside Vim, which is fantastic if you're learning to code or testing snippets.

•Completely Customizable: These functions are just Vimscript — you can extend them, add error handling, or even log outputs to a file.

My Verdict

Vim was already my favorite editor, but these little functions make it feel like a true integrated environment. Whether I'm writing articles, preparing lecture notes, or hacking on LaTeX, I now have instant Python execution at my fingertips. And honestly, it feels like cheating — but in the best possible way.

If you use Vim and write technical documents or code, give these functions a try. They’ll make your workflow smoother, faster, and more fun.

Efficiently Yank and Select Content Between Characters in Vim

2025-01-03T20:00:21+00:00

Efficient Editing Between Characters in Vim

Editing content between specific characters is a frequent task, especially in structured formats like code or LaTeX files. Vim's built-in commands allow you to yank, delete, or visually select text between or around certain characters. Here’s a closer look at some of these commands and how you can extend their functionality.

Understanding Vim's Built-in Commands

Vim provides a set of intuitive commands for working with text between or around specific characters. Let’s break down a few examples:

•yit (Yank Inner Tag): This command yanks the content inside the nearest tag pair, such as <div>this text will be yanked</div>. For example, with the cursor inside:

Running yit copies "this text will be yanked" to the clipboard.

•vit (Visual Select Inner Tag): This highlights the content inside a tag pair for further operations like deleting or copying.

•yi" (Yank Inner Quotes): Copies the text inside quotes, like:

    

"This is a string"

Running yi" yanks "This is a string". Similarly, vi" selects it visually.

•yi(, yi[, yi{: These commands work for parentheses, brackets, and braces, yanking the content inside them.

Why Extend Vim's Pair Handling?

While Vim supports common delimiters by default, specific workflows often demand custom character pairs. For instance, in LaTeX files, mathematical content is often enclosed within dollar signs ( $...$ ). Copying or editing such content with precision is essential for efficiency. This need prompted me to extend Vim's functionality to handle additional characters like $.

Adding Custom Pair Support

Here’s how you can extend Vim to handle additional characters like underscores, dollar signs, or even special delimiters. Add the following script to your .vimrc file:

    

for s:char in [ '_', '.', ':', ',', ';', '', '/', '', '*', '+', '%', '$' ]
  execute 'xnoremap i' . s:char . ' :normal! T' . s:char . 'vt' . s:char . ''
  execute 'onoremap i' . s:char . ' :normal vi' . s:char . ''
  execute 'xnoremap a' . s:char . ' :normal! F' . s:char . 'vf' . s:char . ''
  execute 'onoremap a' . s:char . ' :normal va' . s:char . ''
endfor

With this script, you can:

•yi$: Yank content inside dollar signs, such as math expressions in LaTeX.

•vi_: Visual select text inside underscores.

•va.: Select content and the enclosing dot.

Conclusion

Customizing Vim to support additional characters boosts productivity, especially for domain-specific tasks like LaTeX editing. By combining Vim’s flexibility with your workflow needs, you can streamline text editing and enhance efficiency.

Hidden Gems of Vim: Tricks for Efficient Text Editing

2025-01-01T11:41:48+00:00

Unlocking Vim's Hidden Potential: Tricks and Gems for Power Users

Vim is more than just a text editor; it's a powerhouse of efficiency. While many users are familiar with its basics, countless hidden features can transform your workflow. Let’s dive into some advanced Vim tricks and hidden gems that you might not know!

1. Working with Numbers Like a Pro

•Increment and Decrement Across a Block: Visual mode isn’t just for selecting text; it can handle numbers too. Select a block of numbers, then use g<C-a> to increment or g<C-x> to decrement them sequentially. Perfect for creating numbered lists or adjusting configurations.

•Smart Increment: Want to increment all numbers in a file? Use :%s/\\d\\+/\\=submatch(0) + 1/g. This substitution command handles it beautifully.

2. Mastering Text Manipulation

•Seamless Line Joining: Use gJ to join lines without inserting a space. Ideal for cleaning up code or text.

•Duplicate Lines in a Snap: Duplicate the current line with :t.. Efficient and straightforward!

•Remove Blank Lines: Clean up your document by removing blank lines with :g/^$/d.

3. Unlocking the Power of Registers

•Preserve the Clipboard: Use the black hole register "_d to delete text without affecting your clipboard. Say goodbye to accidental overwrites!

•Direct Register Input: Need to add text to a register quickly? Use :let @"="your text" to assign text to the unnamed register.

4. Smart Navigation with Marks

•Jump to Last Edit: Quickly return to the last modified position with `.. Never lose track of your edits again.

•Start and End of Changes: Use `[ and `] to jump to the start and end of the last change.

5. Advanced Search and Replace

•Pattern-Based Increments: Increment all numbers matching a pattern with :g/pattern/exe "normal <C-a>".

•Add Prefixes and Suffixes: Transform every line by adding a prefix and suffix using :%s/^\$.*\$$/Prefix \\1 Suffix/.

6. Making the Most of Visual Mode

•Reselect Your Last Selection: Press gv to reselect the previous visual selection effortlessly.

•Execute Macros in a Range: Select a block and execute a macro over it with :'<,'>normal @q.

7. Enhancing Buffers and Tabs

•Vertical Diff Splits: Use :vert diffsplit {file} to compare files side by side with a vertical split.

•Tabs in Control: Reorganize your tabs with :tabm {n} and execute commands across all tabs using :tabdo {cmd}.

8. Uncommon Editing Features

•Insert Shell Output: Bring external command results into Vim with :read !ls.

•Batch Edit Lines: Append a semicolon to all lines with :normal! A;.

9. Miscellaneous Gems

•ASCII and Unicode Insight: Know exactly what character you’re dealing with using ga.

•Quick File Navigation: Open the file path under your cursor in a new buffer with gf.

•Session Management: Save and restore your session with :mksession mysession.vim and :source mysession.vim.

Conclusion

Vim’s true power lies in its depth and versatility. Mastering these hidden gems can significantly enhance your productivity. Try them out and incorporate them into your daily workflow—you’ll wonder how you ever lived without them!

The Ultimate Vim Setup (My 2024 vimrc ) : Essential Commands, Configurations, and Plugin Tips

2024-04-12T18:04:14+00:00

Are you ready to level up your text editing game? If you're a Linux or Windows user looking to harness the power of Vim, you're in the right place. Vim is a highly customizable text editor known for its efficiency and versatility. However, it can be intimidating for beginners. Fear not! In this guide, we'll walk you through the process of setting up Vim for the first time, catering to both Linux and Windows users.

Installing Vim
For Linux Users
For Windows Users
Essential Vim Commands
Configuring Vim
1: Vimrc File
2: Vim Plugins
4: History, Undo, Redo
5: More Settings
6: Color Highlighting
7: Search and Additional Settings
8: Custom Functions for File and Command History Management
Plugin Configurations
1: FZF Settings
2: Completion and YouCompleteMe
Filetype Specific Configurations
Conclusion

Installing Vim

For Linux Users:

Installing Vim on Linux is a breeze. Simply open your terminal and enter the following command:



# debian based distributions
sudo apt-get install vim

# Arch based distributions
sudo pacman -S vim

For Windows Users:

Windows users can download Vim from its official website (https://www.vim.org/download.php) or use package managers like Chocolatey (https://chocolatey.org/packages/vim).

Essential Vim Commands

One of the most distinctive features that sets Vim apart from other text editors is its powerful and efficient text manipulation capabilities, primarily driven by Vim motions. These commands streamline the editing process, allowing users to navigate, edit, and manipulate text with remarkable speed and precision.

i: Enter insert mode

Esc: Exit insert mode

:w: Save changes

:q: Quit Vim

:wq: Save and quit

h, j, k, l: Navigate left, down, up, right respectively

yy: Copy current line

dd: Delete current line

p: Paste copied/deleted text

Mastering these essential Vim commands is the first step towards becoming proficient with this powerful text editor. With practice, users can harness the efficiency and flexibility of Vim motions to edit text swiftly and effectively.

Configuring Vim

1: Vimrc File

The .vimrc file is a key component for configuring Vim according to your preferences. It contains settings, key mappings, and customizations to tailor Vim to your workflow.

On Linux systems, including Ubuntu, Debian, Fedora, and others, the .vimrc file is typically located in the user's home directory. You can access it using a text editor or via the command line. Here's the path:



/home/your_username/.vimrc

Replace your_username with your actual username.

For Windows users, the location of the .vimrc file may vary depending on the Vim installation method:

•If you installed Vim using the installer, the .vimrc file is usually located in the user's home directory:



C:\Users\YourUsername\_vimrc

•If you are using the Vim distribution called "Cream," the _vimrc file may be located in:



C:\Program Files\Vim\_vimrc

Remember to use a text editor or the command line to edit the .vimrc file and add your desired configurations.

2: Vim Plugins

Vim plugins enhance the functionality of the editor by adding features, customizations, and themes. They allow users to tailor Vim to their specific needs and preferences.

Vim-Plug is a popular plugin manager for Vim that simplifies the process of installing and managing plugins. Here's how to set it up:

Download Vim-Plug: Visit the Vim-Plug GitHub repository at https://github.com/junegunn/vim-plug.
Copy Vim-Plug: Depending on your operating system:

For Windows: Download the plug.vim file from the Vim-Plug GitHub repository. Then, copy the downloaded file to the %USERPROFILE%\vimfiles\autoload directory.
For Linux: Download the plug.vim file from the Vim-Plug GitHub repository. Then, copy the downloaded file to the ~/.vim/autoload directory.

With Vim-Plug installed, you're ready to start adding and managing plugins for your Vim editor.

Below is an example of configuring Vim plugins using Vim-Plug:



" enable syntax highlighting and filetype detection
syntax on
filetype plugin indent on

" Specify a directory for plugins.
call plug#begin('~/.vim/bundle')

" Gruvbox theme.
Plug 'gruvbox-community/gruvbox'

" fzf
Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
Plug 'junegunn/fzf.vim'

" Briefly highlight which text was yanked.
Plug 'machakann/vim-highlightedyank'

" Modify * to also work with visual selections.
Plug 'nelstrom/vim-visual-star-search'

" Better display unwanted whitespace.
Plug 'ntpeters/vim-better-whitespace'

" A bunch of useful language related snippets (ultisnips is the engine).
Plug 'SirVer/ultisnips' | Plug 'honza/vim-snippets'

"C family languages completion
Plug 'Valloric/YouCompleteMe'

" IDE-like bar
Plug 'bagrat/vim-buffet'

"
"Plug 'lervag/vimtex'

call plug#end()

In the example above, the Vim-Plug plugin manager is used to manage plugins. Each Plug command specifies a plugin to install or manage. After adding the desired plugins to your .vimrc file, save it and reload Vim to apply the changes. You can then install the plugins by running :PlugInstall command within Vim.

For Windows users, ensure that you name the bundle directory appropriately. In the example above, the directory is named bundle. However, on Windows systems, the directory separator is typically a backslash (\) instead of a forward slash (/). Therefore, you should name the directory bundle or bundle\ accordingly to avoid any path-related issues.

Experiment with different plugins to discover ones that best suit your workflow and enhance your Vim experience.

For the plugin "YouCompleteMe," additional steps are required for both Linux and Windows users. Firstly, ensure that Python is installed and added to the system's PATH environment variable. This step is necessary because YouCompleteMe relies on Python for its functionality. Additionally, Git should also be installed and added to the PATH, as YouCompleteMe requires Git for fetching and updating its dependencies.

After running :PlugInstall to install the plugins, users need to navigate to the YouCompleteMe plugin directory and execute the installation script manually. This is typically located in the .vim/bundle/YouCompleteMe directory. Follow the instructions provided in the plugin's documentation or README file to complete the installation process.

General settings in Vim allow users to customize various aspects of the editor's behavior and appearance to suit their preferences. These settings cover a wide range of functionalities, from enabling features like backspace navigation in insert mode and cursor line highlighting to configuring auto-reading of files changed outside of Vim. Users can also adjust settings related to cursor behavior, encoding, syntax highlighting, and more to create a personalized editing environment. Experimenting with these settings can significantly enhance productivity and streamline the editing experience in Vim.

In Vim, the "leader" key serves as a customizable prefix for creating custom key mappings. By default, the backslash (\) key is designated as the leader key, but users can redefine it to any other key of their choice. The leader key is often used in combination with other keys to create shortcuts for frequently used commands or custom functions. This allows users to streamline their workflow and increase efficiency by assigning intuitive and memorable key combinations for specific tasks. Utilizing the leader key effectively can significantly enhance productivity and make Vim usage more ergonomic and tailored to individual preferences.

    


" leader
" -----------------------------------------------------------------------------

let mapleader=";"
noremap cc :gg"+yG    " copy the entire document to system clipboard
noremap y yiW

" General Config
" -----------------------------------------------------------------------------

set backspace=indent,eol,start  "Allow backspace in insert mode
set showcmd                     "Show incomplete cmds down the bottom
set showmode                    "Show current mode down the bottom
set gcr=a:blinkon0              "Disable cursor blink
set visualbell                  "No sounds
set autoread                    "Reload files changed outside vim
set hidden
set cursorline
set modeline
set mouse=n
set encoding=utf-8
set isfname+=32
set showmatch                   "highlight matching [{{{()}}}]
set lazyredraw
set tw=100
set complete+=kspell
"set colorcolumn=100
set formatoptions=tcqrn1
set matchpairs+=<:>             " Use % to jump between pairs
set nocompatible
set noerrorbells visualbell t_vb=
set noshiftround
"set nospell
set nostartofline
set regexpengine=1
set ruler
set ttimeout
set whichwrap=b,s,<,>
set t_Co=256
set title titlestring=
set completeopt-=preview
set splitbelow
set splitright
set formatoptions-=tc       " turn off breaking long lines
set showtabline=0
set wildoptions=pum

4: History, Undo, Redo

In Vim, managing history, undo, and redo functionalities is crucial for efficient editing and reverting changes. By adjusting settings related to history, undo, and redo, users can customize Vim to suit their workflow and preferences.

Below are some settings commonly used to configure history, undo, and redo in Vim:




" history, undo, redo and backup
" -----------------------------------------------------------------------------
set history=10000
set undofile
set undodir=~/.vim/undo
set undolevels=1000
set undoreload=10000
set backupdir=~/.vim/backup
set directory=~/.vim/backup
set viminfo='1000000

"redo
nnoremap r <C-r>

In the provided configuration, Vim is set to maintain a history of 10,000 commands. Undo information is saved to a file using the undofile option, with the directory specified as ~/.vim/undo. Additionally, Vim is configured to maintain a high level of undo information with 1,000 levels and to reload undo files up to 10,000 bytes in size. Backup files are stored in ~/.vim/backup, and the viminfo option is set to a large value for storing various information about the editing session.

Furthermore, a mapping is created to allow for easy redoing of changes using the r key combined with Ctrl+r.

Customizing these settings enables users to effectively manage history, undo, and redo operations in Vim, enhancing productivity and providing greater control over the editing process. It's worth noting that Vim's history and undo/redo functionalities persist even after closing and reopening documents. With settings configured to retain thousands of history actions, users can seamlessly navigate through the editing history of their documents, ensuring a comprehensive and efficient editing experience.

5: More Settings

Additional settings in Vim allow users to further customize their editing environment and workflow. These settings can range from defining custom key mappings for specific tasks to configuring autocmds and functions to automate certain actions.

Below are some additional settings commonly used to enhance the Vim experience:




" more settings
" -----------------------------------------------------------------------------
"
nnoremap <silent><leader>l :set number! relativenumber!<CR>
autocmd FocusGained * !terminal_transparency set 90

function! EngType()
  " To switch back from Arabic
  set spell
  set spelllang=en_us
  set spellcapcheck
endfunction

function! FrType()
  set spell
  set spelllang=fr
  set spellfile+=~/.vim/spell/fr.utf-8.add
endfunction

" cycle through buffers
nnoremap <Tab> :bnext<CR>

"window mouvements
nnoremap <down>   <C-W><C-J>
nnoremap <up>     <C-W><C-K>
nnoremap <right>  <C-W><C-L>
nnoremap <left>   <C-W><C-H>

In the provided configuration, custom key mappings are defined to toggle line numbers and relative line numbers using <leader>l, and to cycle through buffers using <Tab>. Autocommands are utilized to adjust terminal transparency upon regaining focus, and functions are defined to switch between English and French spell checking modes. Additionally, custom mappings are set for window movements using <down>, <up>, <right>, and <left> keys.

These additional settings offer users greater flexibility and efficiency in their editing tasks, allowing for a more personalized and streamlined Vim experience.

6: Color Highlighting

Color highlighting in Vim plays a significant role in enhancing readability and visual appeal, making it easier for users to distinguish between different elements within the editor. By configuring color schemes and defining custom highlight groups, users can customize the appearance of various components such as the cursor, cursor line, status line, search results, and more.

Below are some settings commonly used to configure color highlighting in Vim:



" highlighting and cursor
" -----------------------------------------------------------------------------
"
colorscheme gruvbox

hi CursorLine       ctermbg=darkgrey  ctermfg=none    term=bold cterm=bold
hi CursorColumn     ctermbg=darkred   ctermfg=white    term=bold cterm=bold
hi StatusLine       ctermbg=darkred   ctermfg=white    term=bold cterm=bold
hi Normal           ctermbg=black     ctermfg=none     term=bold cterm=bold
hi Visual           ctermbg=lightred  ctermfg=black    term=bold cterm=bold
hi Folded           ctermbg=black     ctermfg=red      term=bold cterm=bold
hi FoldColumn       ctermbg=green     ctermfg=yellow   term=bold cterm=bold
hi Search           ctermbg=yellow    ctermfg=black    term=bold cterm=bold
hi Cursor           ctermbg=yellow    ctermfg=yellow   term=bold cterm=bold
hi iCursor          ctermbg=yellow    ctermfg=yellow   term=bold cterm=bold

hi SpellBad         cterm=underline   ctermfg=black    ctermbg=red
hi SpellLocal       cterm=underline   ctermfg=black    ctermbg=red
hi SpellRare        cterm=underline   ctermfg=black    ctermbg=red
hi SpellCap         cterm=underline   ctermfg=black    ctermbg=green

"make block cursor
let &t_ti.="\e[1 q"
let &t_SI.="\e[5 q"
let &t_EI.="\e[1 q"
let &t_te.="\e[0 q"

In the provided configuration, the Gruvbox color scheme is used to define various highlight groups for different elements such as the cursor line, cursor column, status line, search results, and more. Additionally, custom mappings are set to make the cursor block-shaped.

Customizing color highlighting settings allows users to create a visually appealing and personalized editing environment in Vim, enhancing readability and productivity.

7: Search and Additional Settings

Search functionality in Vim is essential for navigating through documents and finding specific text patterns efficiently. By configuring search settings, users can enhance their searching experience and streamline their workflow. Additionally, there are various other settings that can further customize Vim to suit individual preferences and automate certain tasks.

Below are some search-related settings and additional configurations commonly used in Vim:



" Search
set incsearch       " Find the next match as we type the search
set hlsearch        " Highlight searches by default
set ignorecase      " Ignore case when searching...
set smartcase       " ...unless we type a capital

" even more settings
" -----------------------------------------------------------------------------
"
" Automatically deletes all trailing whitespace on save.
autocmd BufWritePre * %s/\s\+$//e
" remember last position
if has("autocmd")
  au BufReadPost * if line("'\"") > 1 && line("'\"") <= line("$") | exe "normal! g'\"" | endif
endif

" set current directory to the directory of the current file
autocmd BufEnter * if expand("%:p:h") !~ '^/tmp' | silent! lcd %:p:h | endif


" IDE BAR
nnoremap <silent><leader>k :execute 'set showtabline=' . (&showtabline ==# 2 ? 0 : 2)<CR>

" wordcount
function! WC()
    let filename = expand("%")
    let cmd = "detex " . filename . " | wc -w | tr -d '[:space:]'"
    let result = system(cmd)
    echo result . " words"
endfunction

command WC call WC()

In the provided configuration, search settings such as incsearch and hlsearch are enabled to enhance the search experience by highlighting matches and displaying search results as you type. Additionally, settings like ignorecase and smartcase are configured to ignore case when searching, except when typing capital letters.

Furthermore, additional settings are applied to automate tasks such as deleting trailing whitespace on save and remembering the last cursor position when reopening files.

Customizing these settings allows users to optimize their searching experience and tailor Vim to their specific preferences and workflow.

8: Custom Functions for File and Command History Management

In Vim, custom functions provide a powerful way to automate tasks and enhance productivity. Below are three custom functions designed to streamline file and command history management:

    

" this function is a great way to open old files
function! Output()
  enew | 0put =v:oldfiles| nnoremap <buffer> <CR> :e <C-r>=getline('.')<CR><CR>|normal gg<CR>
  setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
  nnoremap <buffer> <down> j
  nnoremap <buffer> <up> k
endfunction
:command! Mm     call Output()
:command! MM     call Output()

function! OutputCommands()
  let history = []
  for i in range(histnr(':'), 1, -1)
    call add(history, histget(':', i))
  endfor
  enew
  call append(0, history)
  normal gg
  setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
  "nnoremap <buffer> <CR> :call setreg('+', getline('.'))<CR>
  nnoremap <buffer> <CR> :let command = getline('.') | bnext | execute command<CR>
  nnoremap <buffer> <down> j
  nnoremap <buffer> <up> k
endfunction

:command! Cc     call OutputCommands()
:command! CC     call OutputCommands()

function! OutputRegs()
    " Create a new buffer
    enew
    setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
    " Append content of non-empty registers a to z
    for reg in range(char2nr('a'), char2nr('z'))
        let reg_char = nr2char(reg)
        let reg_content = getreg(reg_char)
        if !empty(reg_content)
            call append(line('$'), [reg_char .":" , reg_content])
            call append(line('$'), "")
        endif
    endfor
    " Move the cursor to the beginning of the buffer
    normal gg
    " Output message
    echo "Contents of registers a to z "
endfunction

:command! Rr     call OutputRegs()
:command! RR     call OutputRegs()

•Output: This function opens a new buffer to display a list of old files, allowing easy navigation and reopening of previous documents.

•OutputCommands: This function creates a new buffer to display the command history, enabling users to review and execute previous commands.

•OutputRegs: This function generates a new buffer to display the contents of registers a to z, providing a convenient way to access and manage stored text snippets.

These custom functions offer efficient ways to handle file and command history, as well as manage text snippets stored in registers. For detailed explanations and usage examples of each function, refer to the following articles:

•Exploring the Output Function For a Better Vim Old Files

•Mastering OutputCommands for Command History Management

•Understanding Vim Registers and Advanced Usage

•Deep Dive into OutputRegs for Register Management

By incorporating these custom functions into your Vim workflow, you can optimize your editing experience and maximize efficiency.

Plugin Configurations

1: FZF Settings

FZF is a powerful command-line fuzzy finder that integrates seamlessly with Vim, providing quick and efficient file and buffer navigation. Below are some configurations commonly used to enhance the FZF experience:



" fzf settings
" -----------------------------------------------------------------------------
"
" Map a few common things to do with FZF.
nnoremap <silent> <Leader>, :Buffers<CR>
nnoremap <silent> <Leader>s :Files<CR>
nnoremap <silent> <Leader>j :Lines<CR>
nnoremap <silent> <Leader>h :Commands<CR>
nnoremap <silent> <Leader><leader> :History<CR>

" set filetypes

autocmd BufEnter,BufNew,BufNewFile,BufRead *.tex set ft=tex
autocmd BufEnter,BufNew,BufNewFile,BufRead *.cpp set ft=cpp
autocmd BufEnter,BufNew,BufNewFile,BufRead *.c set ft=c

In the provided configuration, key mappings are defined to quickly access FZF functionality for navigating buffers, files, lines, and command history. Additionally, filetypes are set automatically for specific file extensions to ensure proper syntax highlighting and formatting in Vim.

These configurations streamline the usage of FZF within Vim, enabling faster and more intuitive navigation through buffers and files.

2: Completion and YouCompleteMe

Completion in Vim is essential for enhancing productivity by providing suggestions and auto-completion for commands, keywords, and file paths. YouCompleteMe (YCM) is a popular plugin that offers intelligent code completion capabilities in Vim. Below are configurations commonly used to optimize completion settings and integrate YouCompleteMe:



" Completion
" .............................................................................

set wildmode=list:longest
set wildmenu                "enable ctrl-n and ctrl-p to scroll thru matches
set wildignore=*.o,*.obj,*~ "stuff to ignore when tab completing
set wildignore+=*vim/backups*
set wildignore+=*sass-cache*
set wildignore+=*DS_Store*
set wildignore+=vendor/rails/**
set wildignore+=vendor/cache/**
set wildignore+=*.gem
set wildignore+=log/**
set wildignore+=tmp/**
set wildignore+=*.png,*.jpg,*.gif

" YouCompleteMe
" .............................................................................

let g:ycm_global_ycm_extra_conf = '~/.vim/bundle/YouCompleteMe/.ycm_extra_conf.py'
let g:ycm_add_preview_to_completeopt = 0
"let g:ycm_autoclose_preview_window_after_insertion = 1
"let g:ycm_autoclose_preview_window_after_completion = 1
let g:ycm_collect_identifiers_from_tags_files = 1
"set tags+=~/.vim/tags/testtags

let g:ycm_key_list_select_completion = ['<Down>']
let g:ycm_key_list_previous_completion = ['<C-k>', '<Up>']
let g:ycm_key_list_accept_completion = ['<C-y>']

" Additional YouCompleteMe config.
let g:ycm_complete_in_comments = 1
let g:ycm_collect_identifiers_from_comments_and_strings = 1
let g:ycm_seed_identifiers_with_syntax = 1

let g:ycm_server_python_interpreter='python3'
map <leader>g :YcmCompleter GoToDefinitionElseDeclaration<CR>

In the provided configuration, completion settings such as wildmode and wildmenu are adjusted to enable enhanced tab completion behavior and ignore certain file patterns. YouCompleteMe integration settings are also defined to customize key mappings and enable additional completion features.

By configuring completion settings and integrating YouCompleteMe, Vim users can enjoy enhanced code completion capabilities and improved productivity in their editing workflows.

Filetype Specific Configurations

Filetype-specific configurations in Vim allow users to customize editor behavior and settings based on the type of file being edited. By organizing configurations into directories such as .vim/after/ftplugin and .vim/ftplugin, users can maintain clean and structured configuration files tailored to specific filetypes.

In the .vim/after/ftplugin directory, users can place configuration files that are sourced after the default filetype plugins. This allows for overriding or extending settings specific to certain filetypes, such as "C" and "C++". Similarly, the .vim/ftplugin directory contains filetype-specific configuration files that are sourced when editing files of corresponding types. For example, configuration files for filetypes like "tex", "php", "sh", "html", and others can be organized here.

Additionally, users can create a .vim/mysnippets folder to store filetype-specific code snippets. These snippets can be quickly inserted into files while editing, providing shortcuts for commonly used code patterns or structures.

If you're interested in delving deeper into each of these filetype-specific configurations, we invite you to keep an eye on this article. We'll continue updating it with more content and detailed explanations, ensuring you have access to the latest insights and configurations for optimizing your Vim experience.

•Exploring Vim Configuration for C and C++ Files (Pending)

•Mastering Vim Configuration for Tex Files (Pending)

•Advanced Vim Configuration for PHP Files (Pending)

•Customizing Vim Configuration for Shell Scripts (Pending)

•Optimizing Vim Configuration for HTML Files (Pending)

Conclusion

In conclusion, Vim is a powerful and versatile text editor that offers extensive customization options to suit individual preferences and workflows. By mastering essential commands, configuring plugins, and leveraging filetype-specific settings, users can optimize their Vim experience for maximum productivity.

Whether you're a seasoned Vim user or just getting started, exploring and experimenting with different configurations can help you tailor Vim to your specific needs and enhance your editing efficiency.

Remember, Vim is more than just a text editor—it's a customizable toolkit that adapts to your workflow and empowers you to edit text like a pro.

Thank you for joining us on this journey through Vim customization. Happy editing!

Vim Register Magic: What They Are and How to Use Them

2024-04-07T09:27:17+00:00

Introduction:

Vim, the venerable text editor, offers a wide array of features to enhance productivity and efficiency for its users. Among these features are registers, which serve as storage locations for text or other data. Understanding registers and how to utilize them effectively can significantly boost your productivity when working with Vim. In this article, we will explore what registers are, their types, and how to use them efficiently in your Vim workflow.

What are Registers?

Registers in Vim are like variables that store text or other data. They can hold a variety of information, including text snippets, numbers, and even operations such as macros. Vim provides numerous registers, each identified by a single letter or symbol. These registers can be accessed and manipulated to store, retrieve, and manipulate data during editing sessions.

Types of Registers:

Vim categorizes registers into different types based on their functionality and scope. Here are the main types of registers:

1. The Unnamed Register: it is the default register in Vim and is represented by the double quote " symbol. Whenever you delete or yank (copy) text, it gets stored in the unnamed register by default. The doube quote " symbol is also used to invoke the registers in vim.

2. Numbered Registers: Vim maintains a history of your recent deletions and yanks in numbered registers, numbered from 0 to 9. Register "0 contains the most recent yank or delete operation, while registers "1 through "9 store older entries, with register "1 being the second most recent.

3. Named Registers: Vim allows you to assign specific names to registers using any letter or symbol (except whitespace) as identifiers. Named registers provide a convenient way to store text snippets or other data for later use.

4. Special Registers: Vim includes several special-purpose registers, such as the expression register "=, which allows you to evaluate expressions, and the clipboard registers "* and "+, which interact with the system clipboard.

Expression Register `"=` :

The expression register, denoted by "= , allows you to evaluate expressions within Vim. This can be particularly useful for performing calculations or transformations on text. To use the expression register, enter insert mode (press i or a ) and then press Ctrl + r followed by = followed by the expression you want to evaluate, you will notice that you are writing at the bottom of vim window. Once you've entered the expression, press Enter to insert the result of the expression into your document.

For example, to calculate the square root of 7 and insert the result into your document, you would type in insert mode Ctrl r =sqrt(7) then press enter, this will insert 2.645751 in your document

Clipboard Registers ( `"*` and `"+` ):

Vim provides two special registers, "* , and "+ , which interact with the system clipboard. These registers allow you to copy text from Vim to the system clipboard or paste text from the system clipboard into Vim.

To copy text to the system clipboard, visually select the desired text in Vim and then type "+y. This command yanks the selected text into the system clipboard. To paste text from the system clipboard into Vim, type "+p at the desired insertion point. Similarly, you can use "*y to copy to the primary selection (usually the same as the clipboard) and "*p to paste from it.

Using these clipboard registers, you can seamlessly transfer text between Vim and other applications, enhancing your workflow and productivity.

Using Registers in Vim:

Now that we've covered the types of registers in Vim, let's explore how to use them effectively:

• Yanking and Pasting: To yank text into a register, use the register name followed by the yank y command. For example, to yank text into register "a , use "ay . Similarly, to paste text from a register, use the "p" command. For instance, "ap pastes the contents of register "a .

• Deleting and Cutting: To delete text into a register, use the "d" command. For example, "da deletes text into register "a". Similarly, to cut text into a register, use the "xa

• Accessing Numbered Registers: You can access numbered registers by prefixing the command with a number. For example, "2p pastes the contents of the second most recent yank or delete operation.

Conclusion:

Registers in Vim are powerful tools that allow you to store, retrieve, and manipulate text and data efficiently. By understanding the various types of registers and how to use them effectively, you can streamline your editing workflow and increase productivity in Vim. Experiment with registers in your daily editing tasks to discover their full potential and take your Vim skills to the next level.

How To Manage Vim Registers and Retrieve Stored Text Snippets

2024-04-06T18:51:41+00:00

Introduction

Vim, a powerful text editor, offers a plethora of features designed to enhance productivity. One such feature is its registers, which allow users to store and recall text snippets for later use. However, as you accumulate more and more text snippets in different registers, it can become challenging to remember where you stored a particular piece of text. In this guide, we'll explore how to efficiently manage Vim registers and effortlessly retrieve stored snippets using a custom Vim function.

Understanding Vim Registers

Vim provides 26 named registers, labeled from "a" to "z". These registers can store text snippets of varying lengths, making them invaluable for storing commonly used phrases, code snippets, or any other frequently used text. for more details about vim registers, their types and usages check out this article : Vim Register Magic: What They Are and How to Use Them

Managing Vim Registers

To effectively manage Vim registers, it's essential to have a system in place for organizing and retrieving stored snippets. One approach is to maintain a mental note of which register contains which text snippet. However, this method becomes impractical as the number of stored snippets increases.

A more efficient approach is to leverage Vim's scripting capabilities to create a function that displays the contents of all registers containing text snippets. The provided Vim function, OutputRegs(), achieves precisely that.

    

function! OutputRegs()
    " Create a new buffer
    enew
    setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
    " Append content of non-empty registers a to z
    for reg in range(char2nr('a'), char2nr('z'))
        let reg_char = nr2char(reg)
        let reg_content = getreg(reg_char)
        if !empty(reg_content)
            call append(line('$'), [reg_char .":" , reg_content])
            call append(line('$'), "")
        endif
    endfor
    " Move the cursor to the beginning of the buffer
    normal gg
    " Output message
    echo "Contents of registers a to z "
endfunction

:command! Rr     call OutputRegs()
:command! RR     call OutputRegs()

Let's break down how it works:

1.Creating a New Buffer: The function begins by creating a new buffer where the contents of the registers will be displayed. This ensures a clean workspace for viewing the register contents without cluttering the current buffer.

2.Iterating Through Registers: Next, the function iterates through each register from "a" to "z" using a for loop. For each register, it retrieves the contents and checks if the register is empty.

3.Appending Content to Buffer: If a register contains text, the function appends the register name along with its content to the new buffer. It also adds an empty line for clarity between each register's content.

4.Moving Cursor to the Beginning: Once all register contents are appended to the buffer, the function moves the cursor to the beginning of the buffer using the gg command.

5.Outputting Message: Finally, the function displays a message indicating that the contents of the registers have been successfully displayed.

Using the Custom Function

To utilize the custom function, simply execute the Rr or RR command within Vim. This will trigger the OutputRegs() function, which will create a new buffer displaying the contents of all non-empty registers from "a" to "z".

Conclusion

Efficiently managing Vim registers is crucial for maintaining productivity during editing sessions. By leveraging custom functions like OutputRegs(), users can effortlessly retrieve stored text snippets without the need to remember which register contains which text. Incorporating such tools into your Vim workflow can streamline your editing process and enhance overall efficiency.

Unlock Vim's Power: Advanced Text Manipulation with Search and Replace

2024-04-05T17:23:03+00:00

Mastering Vim: Essential Search and Replace Commands

Vim, the versatile text editor, is renowned for its efficiency in handling text manipulation tasks. Among its plethora of features, the search and replace functionality stands out as one of the most powerful tools for editing text swiftly. In this article, we'll delve into some essential Vim search and replace commands that can streamline your editing workflow.

Basic Substitution with `:substitute`

The :substitute command, often abbreviated as :s, allows you to search for a pattern within a file and replace it with another pattern. Here are some commonly used variations:

Replace the first match on the current line only:
:s/foo/bar/
This command will replace the first occurrence of 'foo' with 'bar' on the current line where the cursor is positioned.

Replace all matches on the current line only:
:s/foo/bar/g
The g flag at the end of the command signifies a global substitution, replacing all occurrences of 'foo' with 'bar' on the current line.

Replace all matches in the entire file:
:%s/foo/bar/g
Using % as a range specifies that the substitution should be applied to the entire file.

Interactive substitution with manual confirmation:
:%s/foo/bar/gc
The c flag prompts Vim to confirm each substitution, allowing you to review and confirm or skip each instance individually.

Substitute within specific HTML tags:



:%s/<pre><code>/<pre class="language-bash" >\r<code class="language-bash">\r/

This command targets <pre><code> tags and replaces them with HTML syntax highlighting classes suitable for Bash code.

Add emphasis to a specific term:



:%s/VIM Editor/<strong style="color: #000000;">VIM Editor</strong>/g

Here, the command adds emphasis by wrapping instances of 'VIM Editor' in strong tags with custom styling.

Advanced Text Formatting

Vim's search and replace functionality extend beyond mere text substitution. Here are a few advanced techniques for text formatting:

Format CSS file:
:%s/[{;}]/&\r/g|norm! =gg
This command formats a CSS file by inserting line breaks (\r) after each opening brace, closing brace, or semicolon, and then applies indentation using the = command.

Insert line numbers:
:%s/^/\=printf('%-4d', line('.'))/
This command inserts line numbers at the beginning of each line, formatted with a width of 4 characters.

Delete empty lines:
:g/^\s*$/d
Using the :global command with a regular expression pattern, this command deletes all lines that contain only whitespace.

Leveraging `:global` Command

The :global command, abbreviated as :g, allows you to execute commands on lines that match a specific pattern.

Insert line numbers using nl command:
:%!nl -ba -w1 -s' '
This command uses the nl command-line utility to insert line numbers, with options for formatting width and separator.

Insert line numbers directly with Vim script:
:%s/^/\=line('.').' '/
By leveraging Vim's scripting capabilities, this command inserts line numbers directly using Vim script, utilizing the line() function to retrieve the current line number.

Conclusion

Mastering Vim's search and replace commands can significantly enhance your text editing proficiency. By incorporating these techniques into your workflow, you can efficiently manipulate text and streamline your editing tasks. Whether it's correcting spelling errors, refactoring code, or formatting documents, Vim offers a plethora of tools to expedite your editing process.

Stay tuned for more Vim tips and tricks in future articles!

Vim Tips: Simplify Command Execution with OutputCommands Function

2024-04-04T22:25:13+00:00

Introduction:

Vim, the venerable text editor, offers a myriad of features and customization options that can enhance productivity for its users. One such feature is the ability to execute old commands quickly within the current file. In this article, we will delve into a custom Vim function that I called OutputCommands, which streamlines the process of executing previous commands effortlessly.

The function:

Add the followng to your .vimrc file :

    

function! OutputCommands()
  let history = []
  for i in range(histnr(':'), 1, -1)
    call add(history, histget(':', i))
  endfor
  enew
  call append(0, history)
  normal gg
  setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
  "nnoremap <buffer> <CR> :call setreg('+', getline('.'))<CR>
  nnoremap <buffer> <CR> :let command = getline('.') \| bnext \| execute command<CR>
  nnoremap <buffer> <down> j
  nnoremap <buffer> <up> k
endfunction

:command! Cc     call OutputCommands()
:command! CC     call OutputCommands()

Understanding OutputCommands:

The OutputCommands function is a custom Vim function designed to simplify the execution of historical commands within the context of the current file being edited. Let's break down how this function works:

Gathering Command History:
The function starts by creating an empty list named "history". It then iterates through the command history using a for loop, starting from the most recent command (histnr(':')) and moving backwards. For each iteration, it retrieves the command using histget(':') and adds it to the "history" list.

Creating a New Buffer:
After collecting the command history, the function opens a new empty buffer using the "enew" command.

Populating the Buffer:
The collected command history is appended to the newly created buffer using the "append()" function. This effectively displays the command history in the newly created buffer.

Setting Buffer Options:
Several buffer-local options are set using the "setlocal" command to ensure proper behavior. These options include "buftype=nofile" (indicating that the buffer is not associated with a file), "bufhidden=wipe" (ensuring the buffer is wiped when it's no longer in use), "noswapfile" (disabling swap file creation), and "nowrap" (preventing line wrapping).

Mapping Key Bindings:
Key bindings are mapped to facilitate navigation and command execution within the buffer. The "nnoremap" command is used to define mappings for the Enter key ("<CR>"), the Down arrow key ("<down>"), and the Up arrow key ("<up>"). These mappings allow users to navigate through the command history and execute commands easily.

Command Execution:
The most crucial mapping is for the Enter key ("<CR>"). When pressed, it retrieves the command from the current line using "getline('.')", stores it in a variable named "command", switches to the next buffer using "bnext", and executes the stored command using "execute command".

Usage:

To utilize the OutputCommands function, users can simply invoke it by typing ":Cc" or ":CC" in normal mode, depending on their preference. This will open a new buffer containing the command history, allowing them to navigate through previous commands and execute them with ease.

Conclusion:

The OutputCommands function offers a convenient way to access and execute historical commands within Vim, streamlining the editing process and enhancing productivity. By understanding its implementation and usage, Vim users can leverage this functionality to make their editing experience more efficient and enjoyable.

Vim old files: A better way

2024-02-29T20:29:15+00:00

Vim, the versatile text editor beloved by developers and writers alike, offers a multitude of features to enhance productivity and streamline workflows. In this article I will present to you a simple yet pwoerful function that simplifies the process of accessing old files within the editor.

When invoked, this function opens a new buffer containing a list of recently accessed files (v:oldfiles). This list is invaluable for users who frequently navigate between various documents during their editing sessions, providing a quick and efficient method for recalling and reopening previous documents.

The function:



" this function is a great way to open old files
function! Output()
  enew | 0put =v:oldfiles| nnoremap   :e =getline('.')|normal gg
  setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
  nnoremap   j
  nnoremap   k
endfunction
:command! Mm     call Output()
:command! MM     call Output()

Usage:

To utilize this function, users can simply execute the associated custom commands, such as :Mm or :MM, which are defined to call the function.

:command! Mm call Output()

:command! MM call Output()

Functionality:

Opening Old Files: Upon execution, the function creates a new buffer and populates it with the list of old files. Users can then navigate through this list and press <CR> (Enter) to open the selected file.
Buffer Configuration: The function sets specific buffer-local options (buftype, bufhidden, swapfile, nowrap) to ensure a seamless experience without interference with the user's editing environment.
Enhanced Navigation: For improved usability, the function defines key mappings (<down> and <up>) within the buffer to facilitate easy navigation through the list of old files.

This custom function provides a convenient solution for managing and accessing old files within Vim. By centralizing the list of previous documents and offering intuitive navigation options, it enhances the editing experience for Vim users, contributing to increased efficiency and productivity.

Whether you're a seasoned Vim enthusiast or a newcomer exploring its capabilities, incorporating this custom function into your workflow can streamline your file management tasks and elevate your editing experience.

How to Compile and Run C++, Python, and LaTeX Files in Vim

2023-04-03T17:59:49+00:00

Hello everyone,

As a programmer, I have been using Vim as my primary text editor for various programming languages, including C++, Python, and LaTeX. but it gets tiresome to siwtch back and forth between your code in vim and the terminal to compile it. So I started exploring options to compile and run C++ code directly within Vim. And, I found a fantastic solution that I think you would love too.

To start with, I created a function in Vim called RunCPP which compiles the current file name using g++ and runs the executable file. This has been a real-time saver for me, as I no longer have to switch between Vim and terminal continuously.

   


function! RunCPP()
    let s:current_file = expand("%")
    enew|silent execute ".!g++ " . shellescape(s:current_file, 1) . " -o " . shellescape(s:current_file, 1) . ".out && ./" . shellescape(s:current_file, 1) . ".out"
    setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
endfunction

To use this function, I created a Vim mapping that calls the function when triggered with a keyboard shortcut, such as the leader key followed by the letter 'c.' This way, I can compile and run C++ code with just a couple of keystrokes.

And the good news is, similar to C++, I have done the same to compile and run Python scripts and generate PDFs from LaTeX files within Vim itself.

   

function! RunPython()
    let s:current_file = expand("%")
    enew|silent execute ".!python " . shellescape(s:current_file, 1)
    setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
endfunction

Now, moving on to LaTeX, I have two Vim functions: RunTex and ViewTex. The "RunTex" function compiles the current LaTeX file using the "xelatex" command, while the "ViewTex" function generates a PDF from the LaTeX file using the "okular" command and opens it in a new buffer within Vim. Both these functions are mapped to specific keyboard shortcuts for easy access.

   


function! RunTex()
    let s:current_file = expand("%")
    enew|silent execute ".!xelatex " . shellescape(s:current_file, 1)
    setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
    normal! G
    nnoremap   :bd!
endfunction

function! ViewTex()
    let s:current_file = expand("%")
    let s:pdf_file = substitute(s:current_file, '\.tex$', '.pdf', '')
    enew
    silent execute "!nohup okular  " . shellescape(s:pdf_file, 1) . "  </dev/null >/dev/null 2>&1 & "
    setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
    nnoremap   :bd!
endfunction

to use these functions, just create these files in the ~/.vim/after/ftplugin directory. and put them in the files accordingly

   

~/.vim/after/ftplugin/python.vim
~/.vim/after/ftplugin/cpp.vim
~/.vim/after/ftplugin/tex.vim

By setting up these mappings, I have been able to streamline my workflow and avoid switching between Vim and the terminal. These functions and mappings save time, making it easier to focus on programming without any distractions. those ftplugin files contain specific settings for each file type so feel free to add your own configurations to them

I hope this tutorial helps you in running C++, Python and LaTeX files within Vim as it did for me. Give it a try and let me know how it goes!

Vim Editor Techniques for Effortless HTML File Editing

2023-03-08T15:31:52+00:00

Vim is a great text editor once you overcome its steep learning curve, and understand how to configure it to your liking. You will find out how flexible and smooth it is to work with it. Often times I find myself writing my articles in simple HTML files format, usually just paragraphs and headers and The occasional code or list. In this article I will show you how in just a few keyboard strokes, I can create my HTML files.

Making a paragraph

All The following actions can be performed by just two keyboard key combinations: 1. Select The entire paragraph, 2 go to The beginning and insert The <p> tag, 3. Go to The end of The paragraph and add </p> tag.
In any other editor this can become tiresome especially if repeated. But with vim: in NORMAL just type V (shift v) to select The entire line (our paragraph in HTML can be written in a single line if vim is correctly configured to line wrap). Then I type ;pp and that's it. The semi colon ";" is my defined leader in my .vimrc file. The ;pp is a mapped key combination I created using the following line:

    

vnoremap <leader>pp y<Esc>`>a</p><Esc>`<i<p><Esc>

In the above line we use vnoremap to define the keyboard mapping in the VISUAL mode.

<leader>pp: the mapping.
y<Esc> : yank (copy) the visually selected text, even though we don't need it, it serves a purpose. This selected text will be known to vim by > and < symbols.
>a is an instruction to insert at the end of the select text, what follows is the inserted text, in our case the end of paragraph tag </p> then <Esc> to go back to NORMAL mode.

<i<p><Esc>: same as before, we insert at the beginning of the selected text ( ie : < and the inserted text is the paragraph tag <p>. Again this inserted text can be any string of text. and finally we <Esc>.

This is just one of the many small things I use when editing my files. As always here is my entire ~/.vim/ftplugin/html.vim file in which I define all the mappings associated with HTML files

    

vnoremap <leader>ss y<Esc>`>a</strong><Esc>`<i<strong style="color: #000000;"><Esc>
vnoremap <leader>pp y<Esc>`>a</p><Esc>`<i<p><Esc>
vnoremap <leader>hh y<Esc>`>a</h2><Esc>`<i<h2><Esc>

:set wrap
:set linebreak
:set textwidth=0
:set wrapmargin=0

inoremap ;bb <ESC>:0r ~/.vim/mysnippets/php/b1<CR>
inoremap ;flex <ESC>:$r ~/.vim/mysnippets/html/flex<CR>
inoremap ;xx <ESC>:r ~/.vim/mysnippets/html/code<CR>
inoremap ;ff <ESC>:r ~/.vim/mysnippets/html/figure<CR>
inoremap ;b <b></b><Space><++><Esc>FbT>i
inoremap ;it <em></em><Space><++><Esc>FeT>i
inoremap ;1 <h1></h1><Enter><Enter><++><Esc>2kf<i
                inoremap ;2 <h2></h2><Enter><Enter><++><Esc>2kf<i
                                inoremap ;3 <h3></h3><Enter><Enter><++><Esc>2kf<i
                                                inoremap ;p <p></p><Enter><Enter><++><Esc>02kf>a
inoremap ;a <a<Space>href=""><++></a><Space><++><Esc>14hi
inoremap ;e <a<Space>target="_blank"<Space>href=""><++></a><Space><++><Esc>14hi
inoremap ;ul <ul><Enter><li></li><Enter></ul><Enter><Enter><++><Esc>03kf<i
                 inoremap ;li <Esc>o<li></li><Esc>F>a
inoremap ;ol <ol><Enter><li></li><Enter></ol><Enter><Enter><++><Esc>03kf<i
                 inoremap ;im <img src="" alt="<++>"><++><esc>Fcf"a
inoremap ;td <td></td><++><Esc>Fdcit
inoremap ;tr <tr></tr><Enter><++><Esc>kf<i
                 inoremap ;th <th></th><++><Esc>Fhcit
inoremap ;tab <table><Enter></table><Esc>O
inoremap ;gr <font color="green"></font><Esc>F>a
inoremap ;rd <font color="red"></font><Esc>F>a
inoremap ;yl <font color="yellow"></font><Esc>F>a
inoremap ;dt <dt></dt><Enter><dd><++></dd><Enter><++><esc>2kcit
inoremap ;dl <dl><Enter><Enter></dl><enter><enter><++><esc>3kcc
inoremap &<space> &<space>
inoremap á á
inoremap é é
inoremap í í
inoremap ó ó
inoremap ú ú
inoremap ä ä
inoremap ë ë
inoremap ï ï
inoremap ö ö
inoremap ü ü
inoremap ã ã
inoremap ẽ &etilde;
inoremap ĩ ĩ
inoremap õ õ
inoremap ũ ũ
inoremap ñ ñ
inoremap à à
inoremap è è
inoremap ì ì
inoremap ò ò
inoremap ù ù
" vim: set ts=8 sts=4 sw=4 expandtab :

There are some mappings involving some small files in the "mysnippets" folder. Those are files containing small code snippets as well, like the "figure" file which contains a figure tag with its img and caption tags

Vim editing becomes an enjoyable experience once you combine it with your knowledge of other things like regular expressions. it is in this area where vim excels.

This article was formatted with html tags in under 2 minutes using just a few repeated commands. It could have been automated further using vim macros. and a bonus mapping that allows me to surround code snippets as shown in the video bellow:

   

vnoremap <leader>cc x<Esc>i<pre class="language-bash" ><Enter>   <code class="language-bash" ><Esc>po    </code><Enter></pre><Enter><br><Esc>

Vim Text Editor tricks : Spell Checking

2023-03-07T10:31:38+00:00

vim is a great text editor. I use it most of the time, And most of the time I write in English. But sometimes I need to write in french. And I had to always keep reading And re-reading my text document to check for spelling mistakes. This is when I got to search if vim can deal with this. And it does

I found out that Vim comes with built-in spell checking capabilities that can be customized to meet specific language requirements. In this article, we will focus on spell checking in Vim for French text. But it should be the same for any other language

Before we begin, it is important to note that spell checking in Vim relies on external dictionaries. In the case of French spell checking, we will use the French dictionary provided by the system's spell checking library. On most Linux systems, this library is called Hunspell.

To enable spell checking in Vim for French text, we need to follow these steps:

Ensure that Hunspell is installed on your system. On most Linux distributions, Hunspell can be installed using the package manager. For example, on Ubuntu, you can install Hunspell by running the following command in the terminal:

    

sudo apt install hunspell

Set the spell checking language in Vim to French. This can be done by adding the following line to your .vimrc file:

    

set spelllang=fr
" or
set spelllang+=fr

Enable spell checking in Vim by adding the following line to your .vimrc file:

    

set spell

With these settings in place, Vim will highlight any spelling mistakes in your text as you type. To correct a spelling mistake, move the cursor to the misspelled word And type the z= command. Vim will display a list of suggested corrections, And you can choose the correct spelling by typing the corresponding number.

If you encounter a word that is not recognized by the French dictionary, you can add it to Vim's custom dictionary. To do this, move the cursor to the word And type the zg command. Vim will add the word to the custom dictionary, And it will no longer be flagged as a spelling mistake.

In addition to the z= And zg commands, Vim provides other useful commands for spell checking. For example, you can use the ]s command to jump to the next spelling mistake, or the [s command to jump to the previous spelling mistake.

Here is the relevant parts of my vimrc file about the spell checking

    

" Switch to English - function
function! EngType()
  set spell
  set spelllang=en
endfunction

function! FrType()
  set spell
  set spelllang=fr
endfunction

" highlighting colors
hi SpellBad cterm=underline ctermfg=black ctermbg=red
hi SpellLocal cterm=underline ctermfg=black ctermbg=red
hi SpellRare cterm=underline ctermfg=black ctermbg=red
hi SpellCap cterm=underline ctermfg=black ctermbg=green

Here is an example of the highlighting

Spell checking in vim text editor

In conclusion, spell checking in Vim for French text is easy to set up And use. By following the steps outlined in this article, you can ensure that your French text is free from spelling mistakes, And you can improve your writing skills in the process.

Vim Text Editor: ftplugin and snippets

2023-02-12T22:32:44+00:00

Vim is a highly efficient and versatile text editor that has been around for over two decades. It is widely used by developers, sysadmins, and power users for its unique features and capabilities. Vim offers a rich set of features for editing text, programming, and automation that make it a favorite among users who want to get more done with fewer keystrokes.

History of Vim

Vim was originally created as a clone of the original Vi text editor, which was written in the 1970s. Since its initial release, Vim has undergone many improvements and modifications, making it a highly advanced text editor that is widely used today. Vim was written by Bram Moolenaar in 1991 and is free and open-source software.

Features of Vim

Modal Editing: Vim uses a modal editing system, which allows users to switch between different modes, such as normal mode, insert mode, and visual mode. This feature provides users with more control over their text and helps them to perform editing tasks more efficiently.
Command Line Interface: Vim offers a powerful command line interface that makes it easy for users to perform complex editing tasks with just a few keystrokes. This interface allows users to automate editing tasks, making it a great tool for repetitive or complex editing tasks.
Customizability: Vim is highly customizable, allowing users to tailor the editor to their specific needs. Vim users can create custom macros, key bindings, and plugins that make the editor work exactly the way they want it to.
Support for Multiple Languages: Vim supports a wide range of programming languages, making it an ideal choice for developers who need to work with multiple languages in a single text editor.

here are some of my personal configs for vim

1. ftplugins

create a directory named "ftplugin" inside your .vim directory and create the following files in it . ftplugin stands for file type plugin, ie a set of commands that will be available for specific filetypes. vim reads the contents of this directory on startup so no need to config anything else

sh.vim

    

" filename sh.vim
" the following function will run the shell script code in another
" buffer, I use it a lot when making tutorials about shell scripting
" as the next line after endfunction is a keybinding to run the script
" <tab> takes me to and back from the script and its output

" the last line is to <ESC> escape to NORMAL mode, ":0r"
" means read the file given by its fullpath into the first line of the script file
" the file simply contains the shabang that is written on top of bash scripts
" #!/bin/bash

function! RunBash()
    let s:current_file = expand("%")
    enew|silent execute ".!bash " . shellescape(s:current_file, 1)
    setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
endfunction

nnoremap <Leader>c :call RunBash()<CR>
inoremap ;sh <ESC>:0r ~/.vim/mysnippets/bash/shabang<CR>

cpp.vim

    

" the same principle
" this one is for cpp files
" the function will compile the code, execute and show the output, or errors


function! RunCPP()
    let s:current_file = expand("%")
    enew|silent execute ".!g++ " . shellescape(s:current_file, 1) . " -o " . shellescape(s:current_file, 1) . ".out && ./" . shellescape(s:current_file, 1) . ".out"
    setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
endfunction


nnoremap <Leader>c :call RunCPP()<CR>

" the following keybindings work in insert mode, for example typing ;io
" will insert the directive #include<iostream> and go to the next line
" the code snippets are the entire main function

inoremap ;io #include<iostream><enter>
inoremap ;st using namespace std;<enter><enter>
inoremap ;li #include<stdlib.h><enter>
inoremap ;mm #include<math.h><enter>
inoremap ;ma <ESC>:0r ~/.vim/mysnippets/cpp/main<CR>
inoremap ;maa <ESC>:0r ~/.vim/mysnippets/cpp/main1<CR>
inoremap ;mz <ESC>:0r ~/.vim/mysnippets/cpp/main1<CR>

an example of using c++ snippets and compiling and running c++ code from vim

Conclusion

Vim is a powerful and versatile text editor that is widely used by developers, sysadmins, and power users for its unique features and capabilities. Whether you are a beginner or an experienced user, Vim offers something for everyone. So, if you're looking for a text editor that can help you get more done with fewer keystrokes, give Vim a try!

How can Python help you edit your files even faster with vim

2020-07-19T23:41:13+00:00

Often times when we are editing our files, we need a faster way to produce hundreds, even thousands of lines with repetitive content or lines that have some variables that change on every line and it would be tedious to write them manually. Here comes Python.

lets say I wanted to tag 29 articles in my website with the same 8 tags; that's 232 instructions. I could go about them one by one and add 8 tags to each one but that would be extremely tiresome and quite frankly boring and it would take me half a day to complete. so instead I'll make text file lets call it mytable.sql and in it I'll put the mysql instructions to add those tags. First we write this line:

    
insert into mytable (id,tagid) values

And then in another vim buffer we write in a file lets call it a.py these 3 lines of code:

    
for i in range(1,30):
    for j in range(1,9):
        print("(",i,",",j,"),")

All I have to do now is to type ";c" with ";" being my vim leader in my vimrc file and ";c" is a keymap to execute the Python code above to produce the 232 lines I need to add my tags Once Python code was executed I'll copy the output from the buffer (an easy task with vim, just another keymap in my vimrc file) and copy it to my first file. The result will be like this:

    
insert into mytable (id,tagid) values
( 1 , 1 ),
( 1 , 2 ),
( 1 , 3 ),
( 1 , 4 ),
( 1 , 5 ),
( 1 , 6 ),
( 1 , 7 ),
( 1 , 8 ),
( 2 , 1 ),
( 2 , 2 ),
( 2 , 3 ),
( 2 , 4 ),
( 2 , 5 ),
( 2 , 6 ),
( 2 , 7 ),
( 2 , 8 ),
( 3 , 1 ),
( 3 , 2 ),
( 3 , 3 ),
( 3 , 4 ),
( 3 , 5 ),
( 3 , 6 ),
( 3 , 7 ),
( 3 , 8 ),
( 4 , 1 ),
( 4 , 2 ),
( 4 , 3 ),
( 4 , 4 ),
( 4 , 5 ),
( 4 , 6 ),
( 4 , 7 ),
( 4 , 8 ),
( 5 , 1 ),
( 5 , 2 ),
( 5 , 3 ),
( 5 , 4 ),
( 5 , 5 ),
( 5 , 6 ),
( 5 , 7 ),
( 5 , 8 ),
( 6 , 1 ),
( 6 , 2 ),
( 6 , 3 ),
( 6 , 4 ),
( 6 , 5 ),
( 6 , 6 ),
( 6 , 7 ),
( 6 , 8 ),
( 7 , 1 ),
( 7 , 2 ),
( 7 , 3 ),
( 7 , 4 ),
( 7 , 5 ),
( 7 , 6 ),
( 7 , 7 ),
( 7 , 8 ),
( 8 , 1 ),
( 8 , 2 ),
( 8 , 3 ),
( 8 , 4 ),
( 8 , 5 ),
( 8 , 6 ),
( 8 , 7 ),
( 8 , 8 ),
( 9 , 1 ),
( 9 , 2 ),
( 9 , 3 ),
( 9 , 4 ),
( 9 , 5 ),
( 9 , 6 ),
( 9 , 7 ),
( 9 , 8 ),
( 10 , 1 ),
( 10 , 2 ),
( 10 , 3 ),
( 10 , 4 ),
( 10 , 5 ),
( 10 , 6 ),
( 10 , 7 ),
( 10 , 8 ),
( 11 , 1 ),
( 11 , 2 ),
( 11 , 3 ),
( 11 , 4 ),
( 11 , 5 ),
( 11 , 6 ),
( 11 , 7 ),
( 11 , 8 ),
( 12 , 1 ),
( 12 , 2 ),
( 12 , 3 ),
( 12 , 4 ),
( 12 , 5 ),
( 12 , 6 ),
( 12 , 7 ),
( 12 , 8 ),
( 13 , 1 ),
( 13 , 2 ),
( 13 , 3 ),
( 13 , 4 ),
( 13 , 5 ),
( 13 , 6 ),
( 13 , 7 ),
( 13 , 8 ),
( 14 , 1 ),
( 14 , 2 ),
( 14 , 3 ),
( 14 , 4 ),
( 14 , 5 ),
( 14 , 6 ),
( 14 , 7 ),
( 14 , 8 ),
( 15 , 1 ),
( 15 , 2 ),
( 15 , 3 ),
( 15 , 4 ),
( 15 , 5 ),
( 15 , 6 ),
( 15 , 7 ),
( 15 , 8 ),
( 16 , 1 ),
( 16 , 2 ),
( 16 , 3 ),
( 16 , 4 ),
( 16 , 5 ),
( 16 , 6 ),
( 16 , 7 ),
( 16 , 8 ),
( 17 , 1 ),
( 17 , 2 ),
( 17 , 3 ),
( 17 , 4 ),
( 17 , 5 ),
( 17 , 6 ),
( 17 , 7 ),
( 17 , 8 ),
( 18 , 1 ),
( 18 , 2 ),
( 18 , 3 ),
( 18 , 4 ),
( 18 , 5 ),
( 18 , 6 ),
( 18 , 7 ),
( 18 , 8 ),
( 19 , 1 ),
( 19 , 2 ),
( 19 , 3 ),
( 19 , 4 ),
( 19 , 5 ),
( 19 , 6 ),
( 19 , 7 ),
( 19 , 8 ),
( 20 , 1 ),
( 20 , 2 ),
( 20 , 3 ),
( 20 , 4 ),
( 20 , 5 ),
( 20 , 6 ),
( 20 , 7 ),
( 20 , 8 ),
( 21 , 1 ),
( 21 , 2 ),
( 21 , 3 ),
( 21 , 4 ),
( 21 , 5 ),
( 21 , 6 ),
( 21 , 7 ),
( 21 , 8 ),
( 22 , 1 ),
( 22 , 2 ),
( 22 , 3 ),
( 22 , 4 ),
( 22 , 5 ),
( 22 , 6 ),
( 22 , 7 ),
( 22 , 8 ),
( 23 , 1 ),
( 23 , 2 ),
( 23 , 3 ),
( 23 , 4 ),
( 23 , 5 ),
( 23 , 6 ),
( 23 , 7 ),
( 23 , 8 ),
( 24 , 1 ),
( 24 , 2 ),
( 24 , 3 ),
( 24 , 4 ),
( 24 , 5 ),
( 24 , 6 ),
( 24 , 7 ),
( 24 , 8 ),
( 25 , 1 ),
( 25 , 2 ),
( 25 , 3 ),
( 25 , 4 ),
( 25 , 5 ),
( 25 , 6 ),
( 25 , 7 ),
( 25 , 8 ),
( 26 , 1 ),
( 26 , 2 ),
( 26 , 3 ),
( 26 , 4 ),
( 26 , 5 ),
( 26 , 6 ),
( 26 , 7 ),
( 26 , 8 ),
( 27 , 1 ),
( 27 , 2 ),
( 27 , 3 ),
( 27 , 4 ),
( 27 , 5 ),
( 27 , 6 ),
( 27 , 7 ),
( 27 , 8 ),
( 28 , 1 ),
( 28 , 2 ),
( 28 , 3 ),
( 28 , 4 ),
( 28 , 5 ),
( 28 , 6 ),
( 28 , 7 ),
( 28 , 8 ),
( 29 , 1 ),
( 29 , 2 ),
( 29 , 3 ),
( 29 , 4 ),
( 29 , 5 ),
( 29 , 6 ),
( 29 , 7 ),
( 29 , 8 );

And now mytable.sql is ready to be executed by mysql server and the tags to be addedd into mytable. I should point out that the numbers 1 to 29 are the unique ids of my articles and 1 to 8 are the unique ids of my tags

Now its time to show you the relevant part of my vimrc file and the vim magic to do this:
we go to the ~/.vim/ftplugin folder or create it if it does not exist.
we create a file: python.vim
and we put this vim code in it:

    
"file : ~/.vim/ftplugin/python.vim

function! RunPython()
    let s:current_file = expand("%")
    enew|silent execute ".!python " . shellescape(s:current_file, 1)
    setlocal buftype=nofile bufhidden=wipe noswapfile nowrap
endfunction

setlocal foldmethod=indent
setlocal foldnestmax=1
setlocal colorcolumn=0
setlocal completeopt-=preview

nnoremap <Leader>c :call RunPython()<CR>

And that's it. and you can do the same with all the scripting languages like shell scripting .

Advanced vim macros: Vim recursive macros

2020-07-06T17:28:45+00:00

Text editors are an important part of any operating system, learning how to use them and mastering them is must have skill for anyone who wants to use a computer, especially if you want to do some programming and code writing.

Vim comes at the top of all other text editors, even though it takes some time to learn how to use it, but its worth it, for when you do , editing texts becomes an art and a real fun activity . for programmers; what would take hours to write in other text editors can take minutes with vim and in this area where vim really excels . one of the features of vim is macros . vim macros can make editing semi automatic, you simply make some editing changes/commands to change a part of your text, and instruct vim to record them. after that you can use the same changes/commands to the rest of your text for as long as you want

So how to record a vim macro ?

In vim Normal mode we type "q" and then another letter, this letter represents the register in which our macro will be recorded, lets say we chose "a", now a message will show in the bottom of the window that says: "recording @a" which means that from now on every action we make, every insertion or deletion will be recorded in register "a" untill we hit "q" once again to finish recording our macro
from now on everytime we hit "@a" , the instructions recorded in our macro will be executed.
to make our macro a recursive macro, ie a macro that executes itself . we paste the content of register "a" by hitting : "ap (doublequote included) and then we append : "@a" at the end of the line, and then we copy the text once again to the register "a" , by hitting : "ayy (doublequote included).
the video bellow explains all this in details: