Essay

ACH-NEOVIM: My Neovim Configuration for macOS

October 12, 2026112 min read

How I set up Neovim on my Mac: installing it, every key, every plugin with its code, and every language, written from the configuration's own source.

01.Getting Started

ACH-NEOVIM is my Neovim configuration for macOS. Neovim is a text editor that runs inside a terminal and is driven from the keyboard, and a configuration is the set of files that tells it which plugins to load, what each key does and how each language is handled. I wrote this one from scratch on lazy.nvim, the plugin manager, and it lives at github.com/anirbanchakraborty-dev/ACH-NEOVIM under the MIT licence.

Why I built it. I wanted one editor that already knows every language I work in: C and C++, Python, Rust, SystemVerilog and Verilog, VHDL, LaTeX and Markdown, with the rest of about ninety languages there when I need them. I did not want it to fill my disk with tools for languages I never open, so nothing for a language installs until I open a file in it. I wanted it to start fast, too. It starts within 10% of stock LazyVim's time, and its own test suite fails any change that makes it take more than one and a half times as long to start as it did when I first timed it. LazyVim showed me what a well-made Neovim setup looks like. I took its ideas and built my own, small enough that I can read every line of it and keep it working, and the few files that adapt a LazyVim function say so in their first lines and name LazyVim's Apache-2.0 licence.

Who it is for. It is for someone on a Mac who writes code and technical documents in many languages, works from the keyboard, and would rather set things up properly once than tinker forever.

My favourite part. I never install a language's tools by hand. I open a file in a language I have not touched in months, and while I read the first screen, its highlighting, completion and formatter install in the background and switch on. A close second is having Claude Code right inside the editor, on Space a c, looking at the same file I am.

02.Installation

Installing takes one Homebrew session, one clone and one first start. Every command below is typed in a terminal, in the order given.

Install Homebrew. Homebrew is the Mac's package manager, and everything else comes from it. If brew --version prints nothing, follow the one command on brew.sh.

Install the programs. Neovim itself, git, ripgrep and fd for searching, lazygit for git, the tree-sitter command-line program, ImageMagick for pictures, Ghostty, and the font:

Bash

brew install neovim git ripgrep fd lazygit tree-sitter-cli imagemagick
brew install --cask ghostty font-jetbrains-mono-nerd-font
xcode-select --install

ACH-NEOVIM needs Neovim 0.12.4 or later, and nvim --version prints the version on its first line. The tree-sitter program builds each language's parser, the part that reads its syntax, with the compiler from Apple's Command Line Tools, which is what the last line installs.

Back up what you have. The clone goes exactly where a Neovim configuration lives, so move yours aside first, with the folders Neovim keeps its data, its state and its cache in:

Bash

mv ~/.config/nvim ~/.config/nvim.bak
mv ~/.local/share/nvim ~/.local/share/nvim.bak
mv ~/.local/state/nvim ~/.local/state/nvim.bak
mv ~/.cache/nvim ~/.cache/nvim.bak

A line whose folder does not exist only prints an error, so run all four.

Clone the configuration.

Bash

git clone https://github.com/anirbanchakraborty-dev/ACH-NEOVIM ~/.config/nvim

Link Ghostty's settings. The repository carries Ghostty's settings in ghostty/config.ghostty: the font at 15 points, the navy background, the left Option key working as Alt, and the sixteen colours Neovim's own terminal uses. Link the file to where Ghostty reads it:

Bash

mkdir -p ~/.config/ghostty
ln -s ~/.config/nvim/ghostty/config.ghostty ~/.config/ghostty/config.ghostty

Start Neovim.

Bash

nvim

The first start installs every plugin at the commit pinned in lazy-lock.json, so you get the versions I test. Let it finish before you open anything.

Check what is missing. Inside Neovim, type this and press Enter:

Plain Text

:checkhealth ach

Read what it says. It lists each program the configuration uses, installed or not, and gives each missing one the single command that installs it.

Open a file. The first time you open a file in a language, its parser, its language server, its formatter and its linter install by themselves in the background, without asking, and switch on when they are ready. A language that needs a compiler or runtime only Homebrew provides, such as Haskell's GHC or Julia, asks first, once, in one line that names it and its rough size. Say yes, and Homebrew installs it in the background while you keep editing. Say no, and it does not ask again until you next start Neovim.

Add the programs some keys use. A key whose program is missing prints the line that installs it instead of running, and :checkhealth ach lists the same programs:

Program	What it is for	Install
`lazygit`	Lazygit on `Space g g` and `Space g G`	`brew install lazygit`
`gh`	GitHub issues and pull requests on `Space g i` and `Space g p`	`brew install gh`, then `gh auth login`
`claude`	the Claude Code panel on `Space a`	`brew install --cask claude-code`
`latexmk`	building LaTeX documents on `Space c b`	`brew install --cask mactex`
`displayline`	showing LaTeX PDFs in Skim and jumping between them and the source	`brew install --cask skim`
`magick`	turning pictures and formulas into images the terminal can show	`brew install imagemagick`
`pdflatex`	typesetting the formulas in Markdown files	`brew install --cask mactex`
`gs`	letting ImageMagick read the PDF a formula is typeset into	`brew install ghostscript`
`pdftotext`	reading Intel's manual to find each instruction's page	`brew install poppler`
`newsboat`	the feed reader on `Space N`	`brew install newsboat`

03.What's New

Here is what ACH-NEOVIM does beyond editing text, area by area. Each area's keys are in the Keymaps section below.

Git. Change bars in the margin show what changed since the last commit, and ] h and [ h move between the changes. Lazygit opens on Space g g. Neogit, git's status page inside Neovim, opens on Space g n, and diffview shows every uncommitted change side by side on Space g D. GitHub's issues and pull requests are on Space g i and Space g p, through gh. A git key pressed on a file outside every repository says so and opens nothing, and a link copied to the current line never carries a user name or a token from the remote's address.

Claude Code. Space a c opens Claude Code in a panel on the right, 40 percent of the screen wide. It sees the file and the selection I am on, and a change it proposes opens side by side, to accept with Space a a or reject with Space a d. Its server listens only on this Mac, refuses a connection without the token in its lock file, and never starts when Neovim has no window.

LaTeX. VimTeX builds the document on Space c b, with latexmk or with a command the project sets, and shows the PDF in Skim, and I can jump from a line of the source to its place in the PDF and back. The build's own files are kept outside the repository.

Markdown. Headings, lists and tables are drawn in place while I write, formulas and pictures are drawn as images inside the editor, and Space c p opens a preview in the browser that keeps up with the file as it changes. The preview's server listens only on this Mac and serves nothing outside the folder it was started for.

Intel's manual. Space c x opens Intel's x86 manual in Skim at the page for the instruction under the cursor, and on any other word lists every instruction to pick one. The manual is Intel's to publish, so it is not in the repository.

News. Space N opens newsboat, a feed reader, in a window floating over the editor.

Ghostty. The repository carries Ghostty's settings: JetBrains Mono at 15 points, the same navy background as the editor, the left Option key working as Alt, and the sixteen colours Neovim's own terminal uses.

Startup. It starts within 10% of stock LazyVim's time, the two timed side by side over thirty starts each, and the test suite fails any change that makes it take more than one and a half times as long to start as it did when first timed.

Updates. scripts/update updates every plugin and Mason package, runs the full test suite, and commits both lock files when it passes, or puts everything back when it does not.

Upgrade check. The first time a new Neovim release starts on a screen, the fast test suite runs in the background, and the release is recorded once it passes.

Key card. docs/key-card.md is one page of keys to keep beside the keyboard, and a test fails whenever it disagrees with the keys the configuration sets.

This page. scripts/docs writes this page from the configuration's own source, so a plugin, a key or a language added to the configuration shows here the next time it runs.

04.Keymaps

Every key this configuration sets, with the description the menus show for it and the modes it works in, grouped the way the key card in docs/key-card.md groups them. A key is written the way it is pressed: Space f f is Space, then f, then f, and Ctrl-h is h pressed while Ctrl is held.

The Mode column uses Neovim's one-letter names. n is normal mode, where keys move and edit. x is visual mode, after selecting text with v. s is select mode, which snippets use for the parts to fill in. o is operator-pending mode, after an operator such as d and before the motion that says what it acts on. i is insert mode, for typing. c is the command line, after :. t is a terminal window.

Inside Neovim each key also shows an icon. This page leaves the icons out, because they come from the JetBrains Mono Nerd Font and this website does not load that font, so each would draw as an empty box. Keys a plugin sets only inside its own window, and text objects such as i ( in d i (, are not listed here. Inside Neovim, Space s k searches every key, those included.

Files and buffers

Key	Description	Mode
`Space Space`	Find Files (Root Dir)	n
`Space f r`	Recent	n
`Space f n`	New File	n
`Space e`	File Tree (project)	n
`Space f o`	Open Folder as Text (oil)	n
`Space ,`	Buffers	n
`Shift-h`	Prev Buffer	n
`Shift-l`	Next Buffer	n
`Space b d`	Delete Buffer	n
`Ctrl-s`	Save File	n, x, s, i
`Ctrl-s`	Toggle Flash in Search	c
`Space q s`	Restore Session for This Folder	n
`Space q q`	Quit All	n
`Space E`	File Tree (working folder)	n
`Space b D`	Delete Buffer and Window	n
`Space b b`	Switch to Other Buffer	n
`Space b o`	Delete Other Buffers	n
`Space f E`	File Tree (working folder)	n
`Space f F`	Find Files (cwd)	n
`Space f R`	Recent (cwd)	n
`Space f T`	Terminal (cwd)	n
`Space f b`	Buffers	n
`Space f c`	Find Config File	n
`Space f e`	File Tree (project)	n
`Space f f`	Find Files (Root Dir)	n
`Space f g`	Find Files (git-files)	n
`Space f p`	Projects	n
`Space f t`	Terminal (Root Dir)	n
`Space f y`	Copy File Path	n
`Space q S`	Pick a Session	n
`Space q d`	Don't Save This Session	n
`Space q l`	Restore Last Session	n

Search and moving

Key	Description	Mode
`Space /`	Grep (Root Dir)	n
`Space s b`	Buffer Lines	n
`Space s r`	Search and Replace	n, x
`Space s h`	Help Pages	n
`Space s k`	Keymaps	n
`Space s R`	Resume	n
`s`	Flash Jump	n, x, o
`S`	Flash Select by Syntax	n, x, o
`Space :`	Command History	n
`Space s "`	Registers	n
`Space s /`	Search History	n
`Space s B`	Grep Open Buffers	n
`Space s C`	Commands	n
`Space s D`	Buffer Diagnostics	n
`Space s G`	Grep (cwd)	n
`Space s H`	Highlights	n
`Space s M`	Man Pages	n
`Space s S`	LSP Workspace Symbols	n
`Space s T`	TODO and FIX Comments	n
`Space s W`	Selection or Word (cwd)	n, x
`Space s a`	Autocmds	n
`Space s c`	Command History	n
`Space s d`	Diagnostics	n
`Space s g`	Grep (Root Dir)	n
`Space s i`	Icons	n
`Space s j`	Jumps	n
`Space s l`	Location List	n
`Space s m`	Marks	n
`Space s p`	Search for Plugin Spec	n
`Space s q`	Quickfix List	n
`Space s s`	LSP Symbols	n
`Space s t`	TODO Comments	n
`Space s u`	Undo History	n
`Space s w`	Selection or Word (Root Dir)	n, x
`[ H`	First Hunk	n
`[ b`	Prev Buffer	n
`[ t`	Previous TODO Comment	n
`] H`	Last Hunk	n
`] b`	Next Buffer	n
`] t`	Next TODO Comment	n

Code

Key	Description	Mode
`g d`	Goto Definition	n
`g r r`	References	n
`K`	Hover	n
`Space c a`	Code Action	n, x
`Space c r`	Rename	n
`Space c f`	Format	n, x
`Space c d`	Line Diagnostics	n
`] d`	Next Diagnostic	n
`Space x x`	Problems (Trouble)	n
`Space c m`	Mason	n
`Space c x`	x86 Manual	n
`Space c b`	Build Document	n
`Space c p`	Markdown Preview	n
`Space c A`	Source Action	n
`Space c C`	Toggle Codelens	n
`Space c F`	Format Injected Langs	n, x
`Space c R`	Rename File	n
`Space c S`	Definitions and References (Trouble)	n
`Space c c`	Run Codelens	n, x
`Space c l`	Lsp Info	n
`Space c o`	Organize Imports	n
`Space c s`	Symbols (Trouble)	n
`Space x L`	Location List (Trouble)	n
`Space x Q`	Quickfix List (Trouble)	n
`Space x T`	TODO and FIX Comments (Trouble)	n
`Space x X`	Problems in This Buffer (Trouble)	n
`Space x l`	Location List	n
`Space x q`	Quickfix List	n
`Space x t`	TODO Comments (Trouble)	n
`[ [`	Prev Reference	n
`[ d`	Prev Diagnostic	n
`[ e`	Prev Error	n
`[ q`	Previous Problem or Quickfix Entry	n
`[ w`	Prev Warning	n
`] ]`	Next Reference	n
`] e`	Next Error	n
`] q`	Next Problem or Quickfix Entry	n
`] w`	Next Warning	n
`g D`	Goto Declaration	n
`g a i`	Incoming Calls	n
`g a o`	Outgoing Calls	n
`g r i`	Goto Implementation	n
`g r t`	Goto Type Definition	n

Git

Key	Description	Mode
`Space g g`	Lazygit (Root Dir)	n
`Space g n`	Neogit (Root Dir)	n
`] h`	Next Hunk	n
`Space g h p`	Preview Hunk Inline	n
`Space g h s`	Stage or Unstage Hunk	n, x
`Space g h r`	Reset Hunk	n, x
`Space g D`	Diff View (Root Dir)	n
`Space u b`	Toggle Git Blame Line	n
`Space g B`	Git Browse (open)	n, x
`Space g p`	GitHub Pull Requests	n
`Space g F`	File History (Diff View)	n
`Space g G`	Lazygit (cwd)	n
`Space g L`	Git Log (cwd)	n
`Space g S`	Git Stash	n
`Space g Y`	Git Browse (copy link)	n, x
`Space g b`	Git Line History	n
`Space g c`	Git Branches	n
`Space g d`	Git Diff (hunks)	n
`Space g f`	Git File History	n
`Space g h B`	Blame Buffer	n
`Space g h D`	Diff This ~	n
`Space g h R`	Reset Buffer	n
`Space g h S`	Stage Buffer	n
`Space g h b`	Blame Line	n
`Space g h d`	Diff This	n
`Space g i`	GitHub Issues	n
`Space g l`	Git Log (Root Dir)	n
`Space g s`	Git Status	n
`[ h`	Prev Hunk	n

Claude Code

Key	Description	Mode
`Space a c`	Toggle Claude	n
`Space a b`	Add Buffer to Claude	n
`Space a s`	Add File to Claude	n
`Space a s`	Send to Claude	x
`Space a a`	Accept Diff	n
`Space a d`	Deny Diff	n
`Space a r`	Resume Claude	n
`Space a C`	Continue Claude	n
`Space a f`	Focus Claude	n
`Space a m`	Select Claude Model	n

Debugging

Key	Description	Mode
`Space d b`	Toggle Breakpoint	n
`Space d c`	Start or Continue	n
`Space d O`	Step Over	n
`Space d i`	Step Into	n
`Space d o`	Step Out	n
`Space d t`	Stop Debugging	n
`Space d u`	Debug Interface	n
`Space d B`	Conditional Breakpoint	n
`Space d C`	Run to Cursor	n
`Space d L`	Log Point	n
`Space d M`	Debug Test Class	n
`Space d P`	Pause Debugging	n
`Space d R`	Restart Debugging	n
`Space d a`	Start with Arguments	n
`Space d e`	Evaluate Expression	n, x
`Space d g`	Jump to Line Without Running	n
`Space d j`	Frame Down	n
`Space d k`	Frame Up	n
`Space d l`	Rerun Last Debug	n
`Space d m`	Debug Nearest Test	n
`Space d r`	Debug Console	n
`Space d s`	Debug Sessions	n
`Space d w`	Inspect Value	n

Windows and toggles

Key	Description	Mode
`Ctrl-h`	Go to Left Window	n
`Space -`	Split Window Below	n
`Space \|`	Split Window Right	n
`Space w d`	Delete Window	n
`Space u f`	Toggle Format on Save (all buffers)	n
`Space u F`	Toggle Format on Save (this buffer)	n
`Space u w`	Toggle Wrap	n
`Space u s`	Toggle Spelling	n
`Space u z`	Toggle Zen Mode	n
`Space u u`	Undo Tree	n
`Ctrl-k`	Go to Upper Window	n
`Ctrl-l`	Go to Right Window	n
`Space Tab Tab`	New Tab	n
`Space Tab [`	Previous Tab	n
`Space Tab ]`	Next Tab	n
`Space Tab d`	Close Tab	n
`Space Tab f`	First Tab	n
`Space Tab l`	Last Tab	n
`Space Tab o`	Close Other Tabs	n
`Space u D`	Toggle Dimming	n
`Space u E`	Pick a Docked Pane	n
`Space u G`	Toggle Git Signs	n
`Space u I`	Inspect Tree	n
`Space u L`	Toggle Relative Number	n
`Space u T`	Toggle Treesitter Highlight	n
`Space u Z`	Toggle Zoom Mode	n
`Space u c`	Toggle Conceal	n
`Space u d`	Toggle Diagnostics	n
`Space u e`	Toggle Docked Panes	n
`Space u g`	Toggle Indent Guides	n
`Space u h`	Toggle Inlay Hints	n
`Space u i`	Inspect Pos	n
`Space u l`	Toggle Line Numbers	n
`Space u r`	Redraw / Clear hlsearch	n
`Space w m`	Toggle Zoom Mode	n

Outside the menus

Key	Description	Mode
`Esc`	Escape and Clear hlsearch	n, s, i
`Ctrl-/`	Terminal (Root Dir)	n, t
`Alt-j`	Move Down	n, x, s, i
`Ctrl-Space`	Grow Selection by Syntax	n, x, o
`Alt-Down`	Add Cursor Below	n, x
`Space n`	Notification History	n
`Space N`	News	n
`Space l`	Lazy	n
`Space ?`	Buffer Keymaps (which-key)	n
`Ctrl-Down`	Decrease Window Height	n
`Ctrl-Left`	Decrease Window Width	n
`Ctrl-Right`	Increase Window Width	n
`Ctrl-Up`	Increase Window Height	n
`Ctrl-w Space`	Window Hydra Mode (which-key)	n
`Down`	Down	n, x
`Alt-Up`	Add Cursor Above	n, x
`Alt-k`	Move Up	n, x, s, i
`NL`	Go to Lower Window	n
Space `	Switch to Other Buffer	n
`Space m A`	Add Cursors at Every Match	n, x
`Space m N`	Add Cursor at Previous Match	n, x
`Space m S`	Skip to Previous Match	n, x
`Space m a`	Align Cursors	n
`Space m n`	Add Cursor at Next Match	n, x
`Space m s`	Skip to Next Match	n, x
`Space m x`	Add or Remove a Cursor Here	n, x
`Up`	Up	n, x
`<`	Indent Left	x
`>`	Indent Right	x
`N`	Prev Search Result	n, x, o
`R`	Flash Search by Syntax	x, o
`g K`	Signature Help	n
`g c O`	Add Comment Above	n
`g c o`	Add Comment Below	n
`i h`	Select Hunk	x, o
`j`	Down	n, x
`k`	Up	n, x
`n`	Next Search Result	n, x, o
`r`	Flash Remote	o

05.Configuration

Everything that makes ACH-NEOVIM what it is lives in plain Lua files in the repository. These are the places I change most, and how I change them.

The layout

Plain Text

~/.config/nvim
├── init.lua           checks the Neovim version, then loads lua/ach
├── lazy-lock.json     the commit of every plugin
├── mason-lock.json    the version of every Mason package
├── lua/ach/           options, keys, autocommands, the language table, and the logic behind each feature
│   └── plugins/       the plugin specs, one file per area
├── snippets/          my own snippets
├── ghostty/           Ghostty's settings
├── docs/              the key card, the list of languages, and the hand-written parts of this page
├── scripts/           check, update and docs
└── tests/             the test suite

Options, keymaps and autocommands

Editor options live in lua/ach/options.lua, keys that belong to no plugin in lua/ach/keymaps.lua, and autocommands, the small actions Neovim runs when something happens, such as opening a file or saving one, in lua/ach/autocmds.lua. Keys that belong to a plugin live in that plugin's spec, under keys.

Adding a plugin

A plugin is a file in lua/ach/plugins/ that returns its spec, because lazy.nvim imports every file in that folder. The Full Spec tabs in the Plugins section below are real specs to copy from. Then:

Give every key a desc, and give that description a line in M.keys in lua/ach/icons.lua. The test suite fails a key without one, since that line is what draws its icon in the menus.
Give the plugin an entry in lua/ach/docs.lua, with its category and one sentence saying what it does. The test suite fails a plugin in lazy-lock.json without one.
Start Neovim once, so lazy.nvim installs the plugin and records its commit in lazy-lock.json.
If the plugin adds keys, run scripts/check --keymaps. Then run scripts/check, and commit the new file, lazy-lock.json, lua/ach/icons.lua, lua/ach/docs.lua and docs/site/keymaps.json together.

Adding a language

Every language is one entry in M.languages in lua/ach/languages.lua, under its name. The entry lists the file types it covers in ft, the Tree-sitter parsers in ts, the language servers in lsp, the formatters in fmt, the linters in lint, any other Mason packages it needs in mason, and harper = true when Harper should check its grammar. The Entry tab of each language in the Languages section below is that language's real entry, and CMake's uses every one of these fields. Settings for a server go in M.settings in lua/ach/servers.lua, under the server's name, and show in the language's Options tab.

Then run scripts/check, and scripts/check --full, which installs the new language's tools, tests them, adds their versions to mason-lock.json and rewrites the list of languages in docs/languages.md. Commit all of it together.

Settings for one project

Neovim reads a file called .nvim.lua in the folder it starts in, because ACH-NEOVIM turns on Neovim's exrc option. Neovim asks before it runs such a file the first time, and again whenever the file changes, so a repository you clone cannot run code on you just by shipping one. A LaTeX project can use it to give Space c b its own build command:

Lua

require("ach.latex").build_with(function(main)
  return { "make", "pdf" }, vim.fs.dirname(main)
end)

The function receives the main file's path and returns the command and the folder to run it in. Returning nothing falls back to latexmk.

Updates and the lock files

lazy-lock.json holds the commit of every plugin and mason-lock.json the version of every Mason package, so two Macs on the same commit of this repository run the same code.

scripts/update --list shows what an update would move: the new commits of each plugin and the newer release of each Mason package. It changes nothing.
scripts/update updates every plugin and Mason package, runs scripts/check --full, and commits both lock files when it passes. When it fails, it puts the lock files back and makes what is installed match them again.
scripts/update --restore does only that second part. Run it on a second Mac after a git pull brings new lock files.
Inside Neovim, :AchMasonUpdate updates every installed Mason package and moves its pin, and :AchMasonLock pins a package installed by hand from the :Mason window.

06.Plugins

Every plugin in lazy-lock.json, grouped by what it does, each with a link to its repository. The Options tab shows opts, the settings lazy.nvim hands to the plugin, and the Full Spec tab shows the whole spec: where the plugin comes from, when it loads, its keys and its options. Either one can be copied into a file in lua/ach/plugins/.

Some plugins are set up in pieces, one in each file that needs a part of them, and each piece is shown with the file it lives in. A plugin that only comes in for another plugin's sake shows the line that brings it in.

Coding

blink.cmp

The completion menu, offering words from the language server, snippets, file paths and the open buffer.

Repository: saghen/blink.cmp

From lua/ach/plugins/coding.lua:

Lua

opts = {
  keymap = { preset = "enter" },
  -- The kind icons are the icon database's, bare, since blink adds its own spacing.
  appearance = { nerd_font_variant = "mono", kind_icons = require("ach.icons").kinds },
  completion = {
    accept = { auto_brackets = { enabled = true } },
    documentation = { auto_show = true, auto_show_delay_ms = 200 },
    ghost_text = { enabled = true },
    menu = { draw = { treesitter = { "lsp" } } },
  },
  signature = { enabled = true },
  sources = {
    default = { "lsp", "path", "snippets", "buffer" },
    providers = {
      -- The repository's own folder, so the snippets are found through the link and under nvim -u alike.
      snippets = { opts = { search_paths = { vim.g.ach_root .. "/snippets" } } },
    },
  },
  fuzzy = { implementation = "prefer_rust_with_warning" },
  cmdline = { enabled = true },
}

Lua

-- The completion menu, fed by the language server, file paths, snippets and words in open buffers.
{
  "saghen/blink.cmp",
  -- Releases carry the compiled matcher; scripts/fetch-matcher downloads the one for this tag.
  version = "1.*",
  event = { "InsertEnter", "CmdlineEnter" },
  dependencies = { "rafamadriz/friendly-snippets" },
  opts_extend = { "sources.default" },
  opts = {
    keymap = { preset = "enter" },
    -- The kind icons are the icon database's, bare, since blink adds its own spacing.
    appearance = { nerd_font_variant = "mono", kind_icons = require("ach.icons").kinds },
    completion = {
      accept = { auto_brackets = { enabled = true } },
      documentation = { auto_show = true, auto_show_delay_ms = 200 },
      ghost_text = { enabled = true },
      menu = { draw = { treesitter = { "lsp" } } },
    },
    signature = { enabled = true },
    sources = {
      default = { "lsp", "path", "snippets", "buffer" },
      providers = {
        -- The repository's own folder, so the snippets are found through the link and under nvim -u alike.
        snippets = { opts = { search_paths = { vim.g.ach_root .. "/snippets" } } },
      },
    },
    fuzzy = { implementation = "prefer_rust_with_warning" },
    cmdline = { enabled = true },
  },
}

From lua/ach/plugins/lsp.lua:

Lua

opts = {
  sources = {
    default = { "lazydev" },
    providers = {
      lazydev = { name = "LazyDev", module = "lazydev.integrations.blink", score_offset = 100 },
    },
  },
}

Lua

{
  "saghen/blink.cmp",
  opts = {
    sources = {
      default = { "lazydev" },
      providers = {
        lazydev = { name = "LazyDev", module = "lazydev.integrations.blink", score_offset = 100 },
      },
    },
  },
}

friendly-snippets

A collection of snippets for many languages.

Repository: rafamadriz/friendly-snippets

lazy.nvim installs it as a dependency of blink.cmp, in lua/ach/plugins/coding.lua:

Lua

dependencies = { "rafamadriz/friendly-snippets" }

lazydev.nvim

Tells the Lua language server about Neovim's own Lua functions and the installed plugins, for completion and checking in these configuration files.

Repository: folke/lazydev.nvim

From lua/ach/plugins/lsp.lua:

Lua

opts = {
  library = {
    { path = "${3rd}/luv/library", words = { "vim%.uv" } },
    { path = "snacks.nvim", words = { "Snacks" } },
    "lazy.nvim",
  },
}

Lua

{
  "folke/lazydev.nvim",
  ft = "lua",
  cmd = "LazyDev",
  opts = {
    library = {
      { path = "${3rd}/luv/library", words = { "vim%.uv" } },
      { path = "snacks.nvim", words = { "Snacks" } },
      "lazy.nvim",
    },
  },
}

mini.ai

Extends the a and i text objects, so d i ( and its kind reach further, such as into the next pair.

Repository: nvim-mini/mini.ai

From lua/ach/plugins/coding.lua:

Lua

opts = function()
  local ai = require("mini.ai")
  return {
    -- Look this far for an object, so a long function still counts as one.
    n_lines = 500,
    custom_textobjects = {
      o = ai.gen_spec.treesitter({
        a = { "@block.outer", "@conditional.outer", "@loop.outer" },
        i = { "@block.inner", "@conditional.inner", "@loop.inner" },
      }),
      f = ai.gen_spec.treesitter({ a = "@function.outer", i = "@function.inner" }),
      c = ai.gen_spec.treesitter({ a = "@class.outer", i = "@class.inner" }),
      u = ai.gen_spec.function_call(),
    },
  }
end

Lua

-- Text objects: af and if for a function, ac and ic for a class, ao and io for a block,
-- au and iu for a call, on top of mini.ai's brackets, quotes and arguments.
{
  "nvim-mini/mini.ai",
  event = "VeryLazy",
  opts = function()
    local ai = require("mini.ai")
    return {
      -- Look this far for an object, so a long function still counts as one.
      n_lines = 500,
      custom_textobjects = {
        o = ai.gen_spec.treesitter({
          a = { "@block.outer", "@conditional.outer", "@loop.outer" },
          i = { "@block.inner", "@conditional.inner", "@loop.inner" },
        }),
        f = ai.gen_spec.treesitter({ a = "@function.outer", i = "@function.inner" }),
        c = ai.gen_spec.treesitter({ a = "@class.outer", i = "@class.inner" }),
        u = ai.gen_spec.function_call(),
      },
    }
  end,
}

mini.pairs

Types the closing bracket or quote when the opening one is typed.

Repository: nvim-mini/mini.pairs

From lua/ach/plugins/coding.lua:

Lua

opts = { modes = { insert = true, command = true, terminal = false } }

ts-comments.nvim

Makes g c use the right comment marker in a file that mixes languages.

Repository: folke/ts-comments.nvim

From lua/ach/plugins/coding.lua:

Lua

opts = {}

Colorscheme

tokyonight.nvim

Tokyo Night, in its night style, with the navy background.

Repository: folke/tokyonight.nvim

From lua/ach/plugins/colorscheme.lua:

Lua

opts = function()
  local p = require("ach.palette")
  return {
    style = "night",
    on_colors = function(c)
      c.bg = p.bg
      c.bg_dark = p.bg_dark
      c.bg_float = p.bg_dark
      c.bg_popup = p.bg_dark
      c.bg_sidebar = p.bg_dark
      c.bg_statusline = p.bg_dark
      c.bg_highlight = p.bg_highlight
      c.bg_search = p.bg_search
      c.bg_visual = p.bg_visual
      c.border = p.border
      c.fg = p.fg
      c.fg_dark = p.fg_dark
      c.fg_float = p.fg
      c.fg_gutter = p.fg_gutter
      c.fg_sidebar = p.fg_dark
      c.comment = p.comment
      c.dark3 = p.dark3
    end,
    on_highlights = function(hl)
      hl.AchBanner = { fg = p.banner }
      hl.AchBannerShadow = { fg = p.border }
      hl.AchBannerCaption = { fg = p.fg_dark }
      -- Math drawn by snacks.image takes the text colour, so a formula
      -- reads as part of the page.
      hl.SnacksImageMath = { fg = p.fg }
    end,
  }
end

Lua

{
  "folke/tokyonight.nvim",
  lazy = false,
  priority = 1000,
  opts = function()
    local p = require("ach.palette")
    return {
      style = "night",
      on_colors = function(c)
        c.bg = p.bg
        c.bg_dark = p.bg_dark
        c.bg_float = p.bg_dark
        c.bg_popup = p.bg_dark
        c.bg_sidebar = p.bg_dark
        c.bg_statusline = p.bg_dark
        c.bg_highlight = p.bg_highlight
        c.bg_search = p.bg_search
        c.bg_visual = p.bg_visual
        c.border = p.border
        c.fg = p.fg
        c.fg_dark = p.fg_dark
        c.fg_float = p.fg
        c.fg_gutter = p.fg_gutter
        c.fg_sidebar = p.fg_dark
        c.comment = p.comment
        c.dark3 = p.dark3
      end,
      on_highlights = function(hl)
        hl.AchBanner = { fg = p.banner }
        hl.AchBannerShadow = { fg = p.border }
        hl.AchBannerCaption = { fg = p.fg_dark }
        -- Math drawn by snacks.image takes the text colour, so a formula
        -- reads as part of the page.
        hl.SnacksImageMath = { fg = p.fg }
      end,
    }
  end,
  config = function(_, opts)
    require("tokyonight").setup(opts)
    vim.cmd.colorscheme("tokyonight-night")
  end,
}

Editor

flash.nvim

Jumps anywhere on the screen: s, then the first letters of the place, then the label shown there.

Repository: folke/flash.nvim

From lua/ach/plugins/editor.lua:

Lua

opts = {}

Lua

-- Jump to any spot on screen by typing two or three of its letters.
{
  "folke/flash.nvim",
  event = "VeryLazy",
  opts = {},
  keys = {
    { "s", mode = { "n", "x", "o" }, function() require("flash").jump() end, desc = "Flash Jump" },
    { "S", mode = { "n", "x", "o" }, function() require("flash").treesitter() end, desc = "Flash Select by Syntax" },
    { "r", mode = "o", function() require("flash").remote() end, desc = "Flash Remote" },
    {
      "R",
      mode = { "o", "x" },
      function() require("flash").treesitter_search() end,
      desc = "Flash Search by Syntax",
    },
    { "<c-s>", mode = "c", function() require("flash").toggle() end, desc = "Toggle Flash in Search" },
    {
      "<c-space>",
      mode = { "n", "o", "x" },
      function() require("flash").treesitter({ actions = { ["<c-space>"] = "next", ["<BS>"] = "prev" } }) end,
      desc = "Grow Selection by Syntax",
    },
  },
}

grug-far.nvim

Search and replace across files, with a preview (Space s r).

Repository: MagicDuck/grug-far.nvim

From lua/ach/plugins/editor.lua:

Lua

opts = { headerMaxWidth = 80 }

Lua

-- Project-wide search and replace in a buffer you edit like any other.
{
  "MagicDuck/grug-far.nvim",
  cmd = "GrugFar",
  opts = { headerMaxWidth = 80 },
  keys = {
    {
      "<leader>sr",
      function()
        local ext = vim.bo.buftype == "" and vim.fn.expand("%:e")
        require("grug-far").open({
          transient = true,
          prefills = { filesFilter = ext and ext ~= "" and "*." .. ext or nil },
        })
      end,
      mode = { "n", "x" },
      desc = "Search and Replace",
    },
  },
}

multicursor.nvim

Several cursors that edit together. Alt-Down adds one on the line below.

Repository: jake-stewart/multicursor.nvim

From lua/ach/plugins/editor.lua:

Lua

-- Several cursors that edit together.
{
  "jake-stewart/multicursor.nvim",
  branch = "1.0",
  config = function()
    local m = mc()
    m.setup()
    -- These keys exist only while there is more than one cursor.
    m.addKeymapLayer(function(set)
      set({ "n", "x" }, "<left>", m.prevCursor, { desc = "Previous Cursor" })
      set({ "n", "x" }, "<right>", m.nextCursor, { desc = "Next Cursor" })
      set({ "n", "x" }, "<leader>md", m.deleteCursor, { desc = "Delete This Cursor" })
      set("n", "<esc>", function()
        if not m.cursorsEnabled() then
          m.enableCursors()
        else
          m.clearCursors()
        end
      end, { desc = "Clear Cursors" })
    end)
  end,
  keys = {
    { "<leader>mn", function() mc().matchAddCursor(1) end, mode = { "n", "x" }, desc = "Add Cursor at Next Match" },
    {
      "<leader>mN",
      function() mc().matchAddCursor(-1) end,
      mode = { "n", "x" },
      desc = "Add Cursor at Previous Match",
    },
    { "<leader>ms", function() mc().matchSkipCursor(1) end, mode = { "n", "x" }, desc = "Skip to Next Match" },
    { "<leader>mS", function() mc().matchSkipCursor(-1) end, mode = { "n", "x" }, desc = "Skip to Previous Match" },
    {
      "<leader>mA",
      function() mc().matchAllAddCursors() end,
      mode = { "n", "x" },
      desc = "Add Cursors at Every Match",
    },
    { "<leader>mx", function() mc().toggleCursor() end, mode = { "n", "x" }, desc = "Add or Remove a Cursor Here" },
    { "<leader>ma", function() mc().alignCursors() end, desc = "Align Cursors" },
    -- Ctrl with the arrows resizes windows (keymaps.lua), so Option adds cursors.
    { "<A-Up>", function() mc().lineAddCursor(-1) end, mode = { "n", "x" }, desc = "Add Cursor Above" },
    { "<A-Down>", function() mc().lineAddCursor(1) end, mode = { "n", "x" }, desc = "Add Cursor Below" },
  },
}

oil.nvim

Shows a folder as a text buffer, where renaming a line renames the file (Space f o).

Repository: stevearc/oil.nvim

From lua/ach/plugins/editor.lua:

Lua

opts = { default_file_explorer = false, view_options = { show_hidden = true } }

Lua

-- A folder as a text buffer: rename a line to rename the file, delete it to delete the file.
{
  "stevearc/oil.nvim",
  cmd = "Oil",
  opts = { default_file_explorer = false, view_options = { show_hidden = true } },
  keys = {
    { "<leader>fo", function() require("oil").open() end, desc = "Open Folder as Text (oil)" },
  },
}

todo-comments.nvim

Highlights TODO, FIX, HACK and NOTE comments, and finds them all in a picker.

Repository: folke/todo-comments.nvim

From lua/ach/plugins/editor.lua:

Lua

-- Only the icons change; the colours and alternate names stay todo-comments' own.
opts = { keywords = I.todo_keywords() }

Lua

-- TODO, FIX, HACK, NOTE and WARN comments, highlighted and searchable.
{
  "folke/todo-comments.nvim",
  cmd = "TodoTrouble",
  event = { "BufReadPost", "BufNewFile" },
  -- Only the icons change; the colours and alternate names stay todo-comments' own.
  opts = { keywords = I.todo_keywords() },
  keys = {
    { "]t", function() require("todo-comments").jump_next() end, desc = "Next TODO Comment" },
    { "[t", function() require("todo-comments").jump_prev() end, desc = "Previous TODO Comment" },
    { "<leader>xt", "<cmd>Trouble todo toggle<cr>", desc = "TODO Comments (Trouble)" },
    {
      "<leader>xT",
      "<cmd>Trouble todo toggle filter = {tag = {TODO,FIX,FIXME}}<cr>",
      desc = "TODO and FIX Comments (Trouble)",
    },
    -- todo-comments registers this picker source with snacks when it loads, and pressing
    -- the key loads it first.
    { "<leader>st", function() Snacks.picker.todo_comments() end, desc = "TODO Comments" },
    {
      "<leader>sT",
      function() Snacks.picker.todo_comments({ keywords = { "TODO", "FIX", "FIXME" } }) end,
      desc = "TODO and FIX Comments",
    },
  },
}

trouble.nvim

Lists of problems, references and symbols to move through (Space x x).

Repository: folke/trouble.nvim

From lua/ach/plugins/editor.lua:

Lua

opts = {
  modes = { lsp = { win = { position = "right" } } },
  icons = { kinds = I.spaced(I.kinds) },
}

Lua

-- The problem list: diagnostics, symbols, references, quickfix and location lists.
{
  "folke/trouble.nvim",
  cmd = "Trouble",
  opts = {
    modes = { lsp = { win = { position = "right" } } },
    icons = { kinds = I.spaced(I.kinds) },
  },
  keys = {
    { "<leader>xx", "<cmd>Trouble diagnostics toggle<cr>", desc = "Problems (Trouble)" },
    { "<leader>xX", "<cmd>Trouble diagnostics toggle filter.buf=0<cr>", desc = "Problems in This Buffer (Trouble)" },
    { "<leader>cs", "<cmd>Trouble symbols toggle focus=false<cr>", desc = "Symbols (Trouble)" },
    { "<leader>cS", "<cmd>Trouble lsp toggle<cr>", desc = "Definitions and References (Trouble)" },
    { "<leader>xL", "<cmd>Trouble loclist toggle<cr>", desc = "Location List (Trouble)" },
    { "<leader>xQ", "<cmd>Trouble qflist toggle<cr>", desc = "Quickfix List (Trouble)" },
    { "[q", function() step("prev") end, desc = "Previous Problem or Quickfix Entry" },
    { "]q", function() step("next") end, desc = "Next Problem or Quickfix Entry" },
  },
}

which-key.nvim

Shows the keys that can follow the ones already pressed, each with a description and an icon.

Repository: folke/which-key.nvim

From lua/ach/plugins/keys.lua:

Lua

opts = {
  preset = "helix",
  spec = {
    {
      mode = { "n", "x" },
      { "<leader><tab>", group = "tabs", icon = I.group("tabs") },
      { "<leader>a", group = "claude", icon = I.group("claude") },
      {
        "<leader>b",
        group = "buffer",
        icon = I.group("buffer"),
        expand = function() return require("which-key.extras").expand.buf() end,
      },
      { "<leader>c", group = "code", icon = I.group("code") },
      { "<leader>d", group = "debug", icon = I.group("debug") },
      { "<leader>f", group = "file/find", icon = I.group("file/find") },
      { "<leader>g", group = "git", icon = I.group("git") },
      { "<leader>gh", group = "hunks", icon = I.group("hunks") },
      { "<leader>m", group = "multicursor", icon = I.group("multicursor") },
      { "<leader>q", group = "quit/session", icon = I.group("quit/session") },
      { "<leader>s", group = "search", icon = I.group("search") },
      { "<leader>u", group = "toggles", icon = I.group("toggles") },
      {
        "<leader>w",
        group = "windows",
        icon = I.group("windows"),
        proxy = "<c-w>",
        expand = function() return require("which-key.extras").expand.win() end,
      },
      { "<leader>x", group = "diagnostics/quickfix", icon = I.group("diagnostics/quickfix") },
      { "[", group = "prev", icon = I.group("prev") },
      { "]", group = "next", icon = I.group("next") },
      { "g", group = "goto", icon = I.group("goto") },
      { "z", group = "fold", icon = I.group("fold") },
    },
  },
}

Lua

{
  "folke/which-key.nvim",
  event = "VeryLazy",
  -- A later plugin file may add groups with its own which-key spec; this makes
  -- lazy.nvim join the lists instead of letting the later one replace this one.
  opts_extend = { "spec" },
  opts = {
    preset = "helix",
    spec = {
      {
        mode = { "n", "x" },
        { "<leader><tab>", group = "tabs", icon = I.group("tabs") },
        { "<leader>a", group = "claude", icon = I.group("claude") },
        {
          "<leader>b",
          group = "buffer",
          icon = I.group("buffer"),
          expand = function() return require("which-key.extras").expand.buf() end,
        },
        { "<leader>c", group = "code", icon = I.group("code") },
        { "<leader>d", group = "debug", icon = I.group("debug") },
        { "<leader>f", group = "file/find", icon = I.group("file/find") },
        { "<leader>g", group = "git", icon = I.group("git") },
        { "<leader>gh", group = "hunks", icon = I.group("hunks") },
        { "<leader>m", group = "multicursor", icon = I.group("multicursor") },
        { "<leader>q", group = "quit/session", icon = I.group("quit/session") },
        { "<leader>s", group = "search", icon = I.group("search") },
        { "<leader>u", group = "toggles", icon = I.group("toggles") },
        {
          "<leader>w",
          group = "windows",
          icon = I.group("windows"),
          proxy = "<c-w>",
          expand = function() return require("which-key.extras").expand.win() end,
        },
        { "<leader>x", group = "diagnostics/quickfix", icon = I.group("diagnostics/quickfix") },
        { "[", group = "prev", icon = I.group("prev") },
        { "]", group = "next", icon = I.group("next") },
        { "g", group = "goto", icon = I.group("goto") },
        { "z", group = "fold", icon = I.group("fold") },
      },
    },
  },
  -- The icon rules are built when which-key loads, after the first screen,
  -- rather than when this file is read during the start.
  config = function(_, opts)
    opts.icons = vim.tbl_extend("force", opts.icons or {}, { rules = I.which_key_rules() })
    require("which-key").setup(opts)
  end,
  keys = {
    {
      "<leader>?",
      function() require("which-key").show({ global = false }) end,
      desc = "Buffer Keymaps (which-key)",
    },
    {
      "<c-w><space>",
      function() require("which-key").show({ keys = "<c-w>", loop = true }) end,
      desc = "Window Hydra Mode (which-key)",
    },
  },
}

Formatting

conform.nvim

Runs each language's formatters on save and on Space c f.

Repository: stevearc/conform.nvim

From lua/ach/plugins/format.lua:

Lua

opts = function() return require("ach.format").opts() end

Lua

{
  "stevearc/conform.nvim",
  -- Loaded when a file opens rather than at the first save, so the status
  -- bar can name the formatter from the start.
  event = { "BufReadPost", "BufNewFile", "BufWritePre" },
  cmd = "ConformInfo",
  keys = {
    {
      "<leader>cf",
      function() require("conform").format({ async = true }) end,
      mode = { "n", "x" },
      desc = "Format",
    },
    {
      "<leader>cF",
      function() require("conform").format({ formatters = { "injected" }, async = true }) end,
      mode = { "n", "x" },
      desc = "Format Injected Langs",
    },
  },
  init = function() require("ach.format").setup() end,
  opts = function() return require("ach.format").opts() end,
}

Linting

nvim-lint

Runs each language's linters and shows what they find.

Repository: mfussenegger/nvim-lint

From lua/ach/plugins/lint.lua:

Lua

{
  "mfussenegger/nvim-lint",
  -- Loaded when a file opens, so the first file is linted and the status
  -- bar can name its linters from the start.
  event = { "BufReadPost", "BufNewFile", "BufWritePost" },
  config = function() require("ach.lint").setup() end,
}

LSP

mason.nvim

Downloads language servers, formatters, linters and debuggers into Neovim's own folder, at the versions mason-lock.json names (Space c m).

Repository: mason-org/mason.nvim

From lua/ach/plugins/mason.lua:

Lua

opts = {
  ui = {
    icons = {
      package_installed = I.mason.installed,
      package_pending = I.mason.pending,
      package_uninstalled = I.mason.uninstalled,
    },
  },
}

Lua

{
  "mason-org/mason.nvim",
  cmd = { "Mason", "MasonInstall", "MasonUninstall", "MasonUninstallAll", "MasonLog", "MasonUpdate" },
  keys = { { "<leader>cm", "<cmd>Mason<cr>", desc = "Mason" } },
  init = function()
    vim.api.nvim_create_user_command("AchMasonLock", function()
      local added = require("ach.masonlock").adopt()
      vim.notify(
        #added == 0 and "mason-lock.json already pins every installed package"
          or ("Pinned %s in mason-lock.json"):format(table.concat(added, ", "))
      )
    end, { desc = "Pin each installed Mason package that mason-lock.json does not list" })
    vim.api.nvim_create_user_command("AchMasonUpdate", function()
      vim.notify("Updating Mason packages")
      require("ach.masonlock").update(function(changed, failed)
        local lines =
          { #changed == 0 and "Every Mason package is up to date" or ("Updated " .. table.concat(changed, ", ")) }
        if #failed > 0 then
          lines[#lines + 1] = "Could not update " .. table.concat(failed, ", ")
        end
        vim.notify(table.concat(lines, "\n"), #failed > 0 and vim.log.levels.WARN or vim.log.levels.INFO)
      end)
    end, { desc = "Update every installed Mason package and move its pin" })
  end,
  opts = {
    ui = {
      icons = {
        package_installed = I.mason.installed,
        package_pending = I.mason.pending,
        package_uninstalled = I.mason.uninstalled,
      },
    },
  },
}

nvim-lspconfig

Starting settings for each language server, added to from lua/ach/servers.lua.

Repository: neovim/nvim-lspconfig

From lua/ach/plugins/lsp.lua:

Lua

{
  "neovim/nvim-lspconfig",
  -- Loaded as the first file is read, so the diagnostics' look and the
  -- servers' settings are in place before anything reports on it, and with
  -- no file after the first screen. Its lsp/ folder must be on the runtime
  -- path before the first server is enabled, so lua/ach/lsp.lua loads it
  -- then too, for a file type set on a buffer with no file.
  event = { "BufReadPre", "BufNewFile", "VeryLazy" },
  config = function() require("ach.lsp").setup() end,
}

SchemaStore.nvim

The schemas that tell the JSON and YAML servers what a file such as package.json may hold.

Repository: b0o/SchemaStore.nvim

From lua/ach/plugins/lsp.lua:

Lua

{ "b0o/SchemaStore.nvim", lazy = true, version = false }

TreeSitter

nvim-treesitter

Installs the Tree-sitter parsers, which read each language's syntax for highlighting, indenting and selecting.

Repository: nvim-treesitter/nvim-treesitter

From lua/ach/plugins/treesitter.lua:

Lua

{
  "nvim-treesitter/nvim-treesitter",
  branch = "main",
  -- The main branch says it does not support lazy loading, meaning its
  -- commands and parser folder must be there before a file needs them.
  -- LazyVim loads it lazily all the same, and so does this: at the start
  -- when a file is named, otherwise after the first screen, or sooner when
  -- lua/ach/treesitter.lua starts it on a buffer or one of its commands runs.
  lazy = vim.fn.argc(-1) == 0,
  event = "VeryLazy",
  cmd = { "TSUpdate", "TSInstall", "TSInstallFromGrammar", "TSUninstall", "TSLog" },
  build = ":TSUpdate",
  init = function()
    -- nvim-treesitter rereads its parser list on this event, so the table's
    -- own parsers are added back each time.
    vim.api.nvim_create_autocmd("User", {
      pattern = "TSUpdate",
      callback = function() require("ach.treesitter").register_custom() end,
    })
  end,
  config = function() require("nvim-treesitter").setup({}) end,
}

nvim-treesitter-textobjects

Text objects and moves by syntax: functions, classes and parameters.

Repository: nvim-treesitter/nvim-treesitter-textobjects

From lua/ach/plugins/treesitter.lua:

Lua

{
  "nvim-treesitter/nvim-treesitter-textobjects",
  branch = "main",
  event = "VeryLazy",
  config = function()
    require("nvim-treesitter-textobjects").setup({ move = { set_jumps = true } })
    -- Buffers opened before VeryLazy were attached before these queries
    -- were on the runtime path, so they get their moves now.
    for _, buf in ipairs(vim.api.nvim_list_bufs()) do
      if vim.api.nvim_buf_is_loaded(buf) then
        require("ach.treesitter").attach(buf)
      end
    end
  end,
}

UI

edgy.nvim

Keeps the side panels, such as the file tree, the problem list and the Claude Code panel, at fixed places and sizes.

Repository: folke/edgy.nvim

From lua/ach/plugins/ui.lua:

Lua

opts = function()
  local opts = {
    bottom = {
      { ft = "qf", title = "QuickFix" },
      {
        ft = "help",
        size = { height = 20 },
        -- A help file opened for editing is an ordinary file, not a docked page.
        filter = function(buf) return vim.bo[buf].buftype == "help" end,
      },
    },
    right = {
      -- The Claude Code panel's view comes first, so it claims the panel
      -- before the generic terminal view the loop below appends, which
      -- names no width and would leave the panel 30 columns wide.
      require("ach.claude").view(),
      { title = "Grug Far", ft = "grug-far", size = { width = 0.4 } },
    },
    -- Inside a docked pane, Ctrl and the arrows resize the pane.
    keys = {
      ["<c-Right>"] = function(win) win:resize("width", 2) end,
      ["<c-Left>"] = function(win) win:resize("width", -2) end,
      ["<c-Up>"] = function(win) win:resize("height", 2) end,
      ["<c-Down>"] = function(win) win:resize("height", -2) end,
    },
  }
  for _, pos in ipairs({ "top", "bottom", "left", "right" }) do
    opts[pos] = opts[pos] or {}
    table.insert(opts[pos], {
      ft = "trouble",
      filter = function(_, win)
        local w = vim.w[win].trouble
        return w
          and w.position == pos
          and w.type == "split"
          and w.relative == "editor"
          and not vim.w[win].trouble_preview
      end,
    })
    table.insert(opts[pos], {
      ft = "snacks_terminal",
      size = { height = 0.4 },
      title = "%{b:snacks_terminal.id}: %{b:term_title}",
      filter = function(_, win)
        local w = vim.w[win].snacks_win
        return w and w.position == pos and w.relative == "editor" and not vim.w[win].trouble_preview
      end,
    })
  end
  return opts
end

Lua

-- Help, the terminal, the problem list and search-and-replace dock into fixed panes.
{
  "folke/edgy.nvim",
  event = "VeryLazy",
  keys = {
    { "<leader>ue", function() require("edgy").toggle() end, desc = "Toggle Docked Panes" },
    { "<leader>uE", function() require("edgy").select() end, desc = "Pick a Docked Pane" },
  },
  opts = function()
    local opts = {
      bottom = {
        { ft = "qf", title = "QuickFix" },
        {
          ft = "help",
          size = { height = 20 },
          -- A help file opened for editing is an ordinary file, not a docked page.
          filter = function(buf) return vim.bo[buf].buftype == "help" end,
        },
      },
      right = {
        -- The Claude Code panel's view comes first, so it claims the panel
        -- before the generic terminal view the loop below appends, which
        -- names no width and would leave the panel 30 columns wide.
        require("ach.claude").view(),
        { title = "Grug Far", ft = "grug-far", size = { width = 0.4 } },
      },
      -- Inside a docked pane, Ctrl and the arrows resize the pane.
      keys = {
        ["<c-Right>"] = function(win) win:resize("width", 2) end,
        ["<c-Left>"] = function(win) win:resize("width", -2) end,
        ["<c-Up>"] = function(win) win:resize("height", 2) end,
        ["<c-Down>"] = function(win) win:resize("height", -2) end,
      },
    }
    for _, pos in ipairs({ "top", "bottom", "left", "right" }) do
      opts[pos] = opts[pos] or {}
      table.insert(opts[pos], {
        ft = "trouble",
        filter = function(_, win)
          local w = vim.w[win].trouble
          return w
            and w.position == pos
            and w.type == "split"
            and w.relative == "editor"
            and not vim.w[win].trouble_preview
        end,
      })
      table.insert(opts[pos], {
        ft = "snacks_terminal",
        size = { height = 0.4 },
        title = "%{b:snacks_terminal.id}: %{b:term_title}",
        filter = function(_, win)
          local w = vim.w[win].snacks_win
          return w and w.position == pos and w.relative == "editor" and not vim.w[win].trouble_preview
        end,
      })
    end
    return opts
  end,
}

lualine.nvim

The status bar along the bottom of the screen.

Repository: nvim-lualine/lualine.nvim

From lua/ach/plugins/statusline.lua:

Lua

opts = function() return require("ach.statusline").options() end

mini.hipatterns

Shows a colour code such as #1a1b26 in the colour it names.

Repository: nvim-mini/mini.hipatterns

From lua/ach/plugins/ui.lua:

Lua

opts = function() return { highlighters = { hex_color = require("mini.hipatterns").gen_highlighter.hex_color() } } end

mini.icons

An icon for each file type, folder and plugin.

Repository: nvim-mini/mini.icons

From lua/ach/plugins/statusline.lua:

Lua

-- The icon database's overrides: the hardware languages get chips, gates and
-- waveforms, and file types mini.icons does not know get an icon of their own.
opts = function() return require("ach.icons").mini() end

Lua

{
  "nvim-mini/mini.icons",
  -- The icon database's overrides: the hardware languages get chips, gates and
  -- waveforms, and file types mini.icons does not know get an icon of their own.
  opts = function() return require("ach.icons").mini() end,
  init = function()
    -- Plugins that ask for nvim-web-devicons get mini.icons instead.
    package.preload["nvim-web-devicons"] = function()
      require("mini.icons").mock_nvim_web_devicons()
      return package.loaded["nvim-web-devicons"]
    end
  end,
}

rainbow-delimiters.nvim

Colours each level of nested brackets differently.

Repository: HiPhish/rainbow-delimiters.nvim

From lua/ach/plugins/ui.lua:

Lua

-- Each nesting level of brackets in its own colour, from tokyonight's rainbow groups.
-- It reads no options, so lazy.nvim only has to put it on the runtime path.
{ "HiPhish/rainbow-delimiters.nvim", event = { "BufReadPre", "BufNewFile" } }

Util

lazy.nvim

The plugin manager. It installs each plugin at the commit lazy-lock.json names, and loads each one when it is first needed.

Repository: folke/lazy.nvim

From lua/ach/plugins/core.lua:

Lua

{ "folke/lazy.nvim", version = false }

persistence.nvim

Saves which files were open in each folder, so Space q s brings them back.

Repository: folke/persistence.nvim

From lua/ach/plugins/editor.lua:

Lua

opts = {}

Lua

-- One session per folder, saved on quit under ~/.local/state/nvim/sessions.
{
  "folke/persistence.nvim",
  event = "BufReadPre",
  opts = {},
  keys = {
    { "<leader>qs", function() require("persistence").load() end, desc = "Restore Session for This Folder" },
    { "<leader>qS", function() require("persistence").select() end, desc = "Pick a Session" },
    { "<leader>ql", function() require("persistence").load({ last = true }) end, desc = "Restore Last Session" },
    { "<leader>qd", function() require("persistence").stop() end, desc = "Don't Save This Session" },
  },
}

plenary.nvim

A library of Lua functions other plugins build on, among them octo.nvim.

Repository: nvim-lua/plenary.nvim

lazy.nvim installs it as a dependency of octo.nvim, in lua/ach/plugins/git.lua:

Lua

dependencies = { "nvim-lua/plenary.nvim" }

snacks.nvim

Many small tools in one plugin. Here it gives the file picker, the dashboard, notifications, toggles, the terminal, the file tree, indent guides, the git keys and the image previews.

Repository: folke/snacks.nvim

From lua/ach/plugins/dashboard.lua:

Lua

opts = {
  notifier = { enabled = true, timeout = 3000 },
  dashboard = {
    enabled = true,
    sections = {
      function(self) return require("ach.dashboard").sections(self) end,
    },
  },
}

Lua

{
  "folke/snacks.nvim",
  lazy = false,
  priority = 1000,
  opts = {
    notifier = { enabled = true, timeout = 3000 },
    dashboard = {
      enabled = true,
      sections = {
        function(self) return require("ach.dashboard").sections(self) end,
      },
    },
  },
}

From lua/ach/plugins/editor.lua:

Lua

opts = {
  explorer = { enabled = true },
  bigfile = { enabled = true },
  quickfile = { enabled = true },
}

Lua

-- The file tree with git status, and two guards for very large or first-opened files.
{
  "folke/snacks.nvim",
  opts = {
    explorer = { enabled = true },
    bigfile = { enabled = true },
    quickfile = { enabled = true },
  },
  keys = {
    { "<leader>fe", function() Snacks.explorer({ cwd = root() }) end, desc = "File Tree (project)" },
    { "<leader>fE", function() Snacks.explorer() end, desc = "File Tree (working folder)" },
    { "<leader>e", "<leader>fe", desc = "File Tree (project)", remap = true },
    { "<leader>E", "<leader>fE", desc = "File Tree (working folder)", remap = true },
  },
}

From lua/ach/plugins/git.lua:

Lua

{
  "folke/snacks.nvim",
  keys = {
    { "<leader>gg", git("lazygit"), desc = "Lazygit (Root Dir)" },
    { "<leader>gG", git("lazygit", "cwd"), desc = "Lazygit (cwd)" },
    { "<leader>gs", git("pick", "git_status"), desc = "Git Status" },
    { "<leader>gS", git("pick", "git_stash"), desc = "Git Stash" },
    { "<leader>gd", git("pick", "git_diff"), desc = "Git Diff (hunks)" },
    { "<leader>gl", git("pick", "git_log"), desc = "Git Log (Root Dir)" },
    { "<leader>gL", git("pick", "git_log", "cwd"), desc = "Git Log (cwd)" },
    { "<leader>gf", git("pick", "git_log_file"), desc = "Git File History" },
    { "<leader>gb", git("pick", "git_log_line"), desc = "Git Line History" },
    { "<leader>gc", git("pick", "git_branches"), desc = "Git Branches" },
    { "<leader>gB", git("browse"), mode = { "n", "x" }, desc = "Git Browse (open)" },
    { "<leader>gY", git("copy_link"), mode = { "n", "x" }, desc = "Git Browse (copy link)" },
  },
}

From lua/ach/plugins/keys.lua:

Lua

opts = {
  picker = {
    enabled = true,
    icons = { kinds = I.spaced(I.kinds), diagnostics = I.spaced(I.diagnostics) },
  },
}

Lua

{
  "folke/snacks.nvim",
  opts = {
    picker = {
      enabled = true,
      icons = { kinds = I.spaced(I.kinds), diagnostics = I.spaced(I.diagnostics) },
    },
  },
  -- stylua: ignore
  keys = {
    { "<leader><space>", function() Snacks.picker.files({ cwd = root() }) end, desc = "Find Files (Root Dir)" },
    { "<leader>,", function() Snacks.picker.buffers() end, desc = "Buffers" },
    { "<leader>/", function() Snacks.picker.grep({ cwd = root() }) end, desc = "Grep (Root Dir)" },
    { "<leader>:", function() Snacks.picker.command_history() end, desc = "Command History" },
    { "<leader>n", function() Snacks.picker.notifications() end, desc = "Notification History" },
    -- find
    { "<leader>fb", function() Snacks.picker.buffers() end, desc = "Buffers" },
    { "<leader>fc", function() Snacks.picker.files({ cwd = vim.g.ach_root }) end, desc = "Find Config File" },
    { "<leader>ff", function() Snacks.picker.files({ cwd = root() }) end, desc = "Find Files (Root Dir)" },
    { "<leader>fF", function() Snacks.picker.files() end, desc = "Find Files (cwd)" },
    { "<leader>fg", function() Snacks.picker.git_files() end, desc = "Find Files (git-files)" },
    { "<leader>fp", function() Snacks.picker.projects() end, desc = "Projects" },
    { "<leader>fr", function() Snacks.picker.recent() end, desc = "Recent" },
    { "<leader>fR", function() Snacks.picker.recent({ filter = { cwd = true } }) end, desc = "Recent (cwd)" },
    -- search
    { '<leader>s"', function() Snacks.picker.registers() end, desc = "Registers" },
    { "<leader>s/", function() Snacks.picker.search_history() end, desc = "Search History" },
    { "<leader>sa", function() Snacks.picker.autocmds() end, desc = "Autocmds" },
    { "<leader>sb", function() Snacks.picker.lines() end, desc = "Buffer Lines" },
    { "<leader>sB", function() Snacks.picker.grep_buffers() end, desc = "Grep Open Buffers" },
    { "<leader>sc", function() Snacks.picker.command_history() end, desc = "Command History" },
    { "<leader>sC", function() Snacks.picker.commands() end, desc = "Commands" },
    { "<leader>sd", function() Snacks.picker.diagnostics() end, desc = "Diagnostics" },
    { "<leader>sD", function() Snacks.picker.diagnostics_buffer() end, desc = "Buffer Diagnostics" },
    { "<leader>sg", function() Snacks.picker.grep({ cwd = root() }) end, desc = "Grep (Root Dir)" },
    { "<leader>sG", function() Snacks.picker.grep() end, desc = "Grep (cwd)" },
    { "<leader>sh", function() Snacks.picker.help() end, desc = "Help Pages" },
    { "<leader>sH", function() Snacks.picker.highlights() end, desc = "Highlights" },
    { "<leader>si", function() Snacks.picker.icons() end, desc = "Icons" },
    { "<leader>sj", function() Snacks.picker.jumps() end, desc = "Jumps" },
    { "<leader>sk", function() Snacks.picker.keymaps() end, desc = "Keymaps" },
    { "<leader>sl", function() Snacks.picker.loclist() end, desc = "Location List" },
    { "<leader>sm", function() Snacks.picker.marks() end, desc = "Marks" },
    { "<leader>sM", function() Snacks.picker.man() end, desc = "Man Pages" },
    { "<leader>sp", function() Snacks.picker.lazy() end, desc = "Search for Plugin Spec" },
    { "<leader>sq", function() Snacks.picker.qflist() end, desc = "Quickfix List" },
    { "<leader>sR", function() Snacks.picker.resume() end, desc = "Resume" },
    { "<leader>su", function() Snacks.picker.undo() end, desc = "Undo History" },
    { "<leader>sw", function() Snacks.picker.grep_word({ cwd = root() }) end, desc = "Selection or Word (Root Dir)", mode = { "n", "x" } },
    { "<leader>sW", function() Snacks.picker.grep_word() end, desc = "Selection or Word (cwd)", mode = { "n", "x" } },
  },
}

From lua/ach/plugins/markdown.lua:

Lua

opts = { image = { enabled = true } }

From lua/ach/plugins/tools.lua:

Lua

{
  "folke/snacks.nvim",
  keys = {
    {
      "<leader>cx",
      function() require("ach.x86").lookup() end,
      desc = "x86 Manual",
    },
    {
      "<leader>N",
      function() require("ach.news").open() end,
      desc = "News",
    },
  },
}

From lua/ach/plugins/ui.lua:

Lua

opts = {
  indent = { enabled = true },
  scope = { enabled = true },
  words = { enabled = true },
  statuscolumn = { enabled = true },
  input = { enabled = true },
}

Lua

-- Indent guides, the current scope, highlights on other uses of the word under the
-- cursor, the line-number column and the input box.
{
  "folke/snacks.nvim",
  opts = {
    indent = { enabled = true },
    scope = { enabled = true },
    words = { enabled = true },
    statuscolumn = { enabled = true },
    input = { enabled = true },
  },
}

Debugging (Plugins)

mason-nvim-dap.nvim

Reads which debug packages Mason has installed and sets up an adapter and launch choices for each.

Repository: jay-babu/mason-nvim-dap.nvim

From lua/ach/plugins/dap.lua:

Lua

{ "jay-babu/mason-nvim-dap.nvim", version = "^2", dependencies = { "mason-org/mason.nvim" } }

nvim-dap

The debugger client: breakpoints, stepping and inspecting.

Repository: mfussenegger/nvim-dap

From lua/ach/plugins/dap.lua:

Lua

{
  "mfussenegger/nvim-dap",
  commit = "cfa2d58f4537aca6ca83e2de1a0d9f1491121264",
  dependencies = {
    { "rcarriga/nvim-dap-ui", commit = "cc9dd33aade7f20bae414d0cba163bc60d4d4b43" },
    { "nvim-neotest/nvim-nio", commit = "edcc181a875301dd21840189aa2f2f9ad69fc172" },
    { "theHamsta/nvim-dap-virtual-text", commit = "fbdb48c2ed45f4a8293d0d483f7730d24467ccb6" },
    { "jay-babu/mason-nvim-dap.nvim", version = "^2", dependencies = { "mason-org/mason.nvim" } },
    { "mfussenegger/nvim-dap-python", commit = "1808458eba2b18f178f990e01376941a42c7f93b" },
  },
  cmd = {
    "DapContinue",
    "DapToggleBreakpoint",
    "DapClearBreakpoints",
    "DapToggleRepl",
    "DapStepOver",
    "DapStepInto",
    "DapStepOut",
    "DapPause",
    "DapTerminate",
    "DapDisconnect",
    "DapRestartFrame",
    "DapNew",
    "DapEval",
    "DapSetLogLevel",
    "DapShowLog",
  },
  keys = function()
    local keys = {}
    for _, k in ipairs(require("ach.dap").keys) do
      keys[#keys + 1] = { k[1], k[2], desc = k[3], mode = k[4] }
    end
    return keys
  end,
  config = function() require("ach.dap").setup() end,
}

nvim-dap-python

Debugs Python through debugpy.

Repository: mfussenegger/nvim-dap-python

From lua/ach/plugins/dap.lua:

Lua

{ "mfussenegger/nvim-dap-python", commit = "1808458eba2b18f178f990e01376941a42c7f93b" }

nvim-dap-ui

The debugger's panels (Space d u).

Repository: rcarriga/nvim-dap-ui

From lua/ach/plugins/dap.lua:

Lua

{ "rcarriga/nvim-dap-ui", commit = "cc9dd33aade7f20bae414d0cba163bc60d4d4b43" }

nvim-dap-virtual-text

Shows each variable's value beside the code while the program is paused.

Repository: theHamsta/nvim-dap-virtual-text

From lua/ach/plugins/dap.lua:

Lua

{ "theHamsta/nvim-dap-virtual-text", commit = "fbdb48c2ed45f4a8293d0d483f7730d24467ccb6" }

nvim-nio

A library for running Lua side by side, which nvim-dap-ui needs.

Repository: nvim-neotest/nvim-nio

From lua/ach/plugins/dap.lua:

Lua

{ "nvim-neotest/nvim-nio", commit = "edcc181a875301dd21840189aa2f2f9ad69fc172" }

Language Plugins

haskell-tools.nvim

Starts the Haskell language server, evaluates a module's examples, and debugs through hdb.

Repository: mrcjkb/haskell-tools.nvim

From lua/ach/plugins/managed.lua:

Lua

{ "mrcjkb/haskell-tools.nvim", version = "^11", lazy = false }

lean.nvim

Starts the Lean server and shows the proof state beside the file.

Repository: Julian/lean.nvim

From lua/ach/plugins/managed.lua:

Lua

-- Lean, loaded as a .lean file is read or created, before its file type is
-- set, so its own ftplugin and commands are there when the type is.
{
  "Julian/lean.nvim",
  commit = "42186878a385ab021296e8f8024521d11a661754",
  event = { "BufReadPre *.lean", "BufNewFile *.lean" },
}

nvim-jdtls

Starts jdtls for Java, imports the project, and runs the debugger and the tests.

Repository: mfussenegger/nvim-jdtls

From lua/ach/plugins/managed.lua:

Lua

-- Java and Scala, loaded when ach.managed first requires them.
{ "mfussenegger/nvim-jdtls", commit = "6e9d953f0b82bccdb834cfde0e893f3119c22592" }

nvim-metals

Starts Metals for Scala, with its own debug server.

Repository: scalameta/nvim-metals

From lua/ach/plugins/managed.lua:

Lua

{ "scalameta/nvim-metals", commit = "a4b20656bf1014404dd63bf9fd5f22fcc50fee52" }

rustaceanvim

Starts rust-analyzer for Rust, adds Cargo's commands, and debugs through codelldb.

Repository: mrcjkb/rustaceanvim

From lua/ach/plugins/managed.lua:

Lua

-- Rust and Haskell. Neither may be lazy-loaded: each does its work from an
-- ftplugin, which must be on the runtime path before the first file of its
-- type opens, and each loads the rest of itself only when first used.
{ "mrcjkb/rustaceanvim", version = "^9", lazy = false }

Git (Plugins)

diffview.nvim

Every uncommitted change side by side, and a file's history (Space g D).

Repository: sindrets/diffview.nvim

From lua/ach/plugins/git.lua:

Lua

opts = {
  enhanced_diff_hl = true,
  -- A merge conflict shows the two sides above and the result below.
  view = { merge_tool = { layout = "diff3_mixed" } },
}

Lua

{
  "sindrets/diffview.nvim",
  cmd = {
    "DiffviewOpen",
    "DiffviewClose",
    "DiffviewFileHistory",
    "DiffviewToggleFiles",
    "DiffviewFocusFiles",
    "DiffviewRefresh",
  },
  opts = {
    enhanced_diff_hl = true,
    -- A merge conflict shows the two sides above and the result below.
    view = { merge_tool = { layout = "diff3_mixed" } },
  },
  keys = {
    { "<leader>gD", git("diffview", "open"), desc = "Diff View (Root Dir)" },
    { "<leader>gF", git("diffview", "file"), desc = "File History (Diff View)" },
  },
}

gitsigns.nvim

Change bars in the margin, and keys to move between changes and stage them. ] h moves to the next.

Repository: lewis6991/gitsigns.nvim

From lua/ach/plugins/git.lua:

Lua

opts = function() return require("ach.git").gitsigns_opts() end

Lua

{
  "lewis6991/gitsigns.nvim",
  event = { "BufReadPre", "BufNewFile" },
  opts = function() return require("ach.git").gitsigns_opts() end,
  config = function(_, opts)
    require("gitsigns").setup(opts)
    require("ach.git").toggles()
  end,
}

neogit

git's status page inside Neovim, where changes are staged and committed (Space g n).

Repository: NeogitOrg/neogit

From lua/ach/plugins/git.lua:

Lua

opts = {
  kind = "tab",
  graph_style = "unicode",
  integrations = { diffview = true, snacks = true },
}

Lua

{
  "NeogitOrg/neogit",
  cmd = "Neogit",
  dependencies = { "sindrets/diffview.nvim" },
  opts = {
    kind = "tab",
    graph_style = "unicode",
    integrations = { diffview = true, snacks = true },
  },
  keys = {
    { "<leader>gn", git("neogit"), desc = "Neogit (Root Dir)" },
  },
}

octo.nvim

GitHub's issues and pull requests, through gh, on Space g i and Space g p.

Repository: pwntester/octo.nvim

From lua/ach/plugins/git.lua:

Lua

opts = { picker = "snacks", enable_builtin = true }

Lua

{
  "pwntester/octo.nvim",
  cmd = "Octo",
  -- Reopening an octo:// buffer, from the jump list or a session, loads it.
  event = { { event = "BufReadCmd", pattern = "octo://*" } },
  dependencies = { "nvim-lua/plenary.nvim" },
  opts = { picker = "snacks", enable_builtin = true },
  keys = {
    { "<leader>gi", git("octo", "issue list"), desc = "GitHub Issues" },
    { "<leader>gp", git("octo", "pr list"), desc = "GitHub Pull Requests" },
  },
}

Claude Code (Plugins)

claudecode.nvim

Claude Code in a panel beside the code. It sees the open file and the selection, and shows each change it proposes side by side (Space a c).

Repository: coder/claudecode.nvim

From lua/ach/plugins/claude.lua:

Lua

opts = function() return require("ach.claude").opts() end

Lua

{
  "coder/claudecode.nvim",
  -- Loaded once Neovim is idle, so the server is up before Claude Code looks
  -- for an editor, without slowing the start.
  event = "VeryLazy",
  dependencies = { "folke/snacks.nvim" },
  cmd = {
    "ClaudeCode",
    "ClaudeCodeAdd",
    "ClaudeCodeClose",
    "ClaudeCodeCloseAllDiffs",
    "ClaudeCodeDiffAccept",
    "ClaudeCodeDiffDeny",
    "ClaudeCodeFocus",
    "ClaudeCodeOpen",
    "ClaudeCodeSelectModel",
    "ClaudeCodeSend",
    "ClaudeCodeSendText",
    "ClaudeCodeStart",
    "ClaudeCodeStatus",
    "ClaudeCodeStop",
    "ClaudeCodeTreeAdd",
  },
  opts = function() return require("ach.claude").opts() end,
  keys = {
    { "<leader>ac", claude("ClaudeCode"), desc = "Toggle Claude" },
    { "<leader>af", claude("ClaudeCodeFocus"), desc = "Focus Claude" },
    { "<leader>ar", claude("ClaudeCode --resume"), desc = "Resume Claude" },
    { "<leader>aC", claude("ClaudeCode --continue"), desc = "Continue Claude" },
    { "<leader>am", claude("ClaudeCodeSelectModel"), desc = "Select Claude Model" },
    -- ClaudeCodeAdd completes file names, so Neovim turns % into this file's name.
    { "<leader>ab", claude("ClaudeCodeAdd %"), desc = "Add Buffer to Claude" },
    { "<leader>as", claude("ClaudeCodeSend"), mode = "x", desc = "Send to Claude" },
    {
      "<leader>as",
      claude("ClaudeCodeTreeAdd"),
      ft = { "oil", "snacks_picker_list" },
      desc = "Add File to Claude",
    },
    { "<leader>aa", claude("ClaudeCodeDiffAccept"), desc = "Accept Diff" },
    { "<leader>ad", claude("ClaudeCodeDiffDeny"), desc = "Deny Diff" },
  },
}

LaTeX

vimtex

Builds the PDF on Space c b, shows it in Skim, and jumps from the source to the PDF and back.

Repository: lervag/vimtex

From lua/ach/plugins/latex.lua:

Lua

{
  "lervag/vimtex",
  -- Loaded at start rather than on a LaTeX file, because the Neovim that
  -- Skim starts for an inverse search opens no LaTeX file and still needs
  -- the VimtexInverseSearch command.
  lazy = false,
  -- VimTeX reads its settings when it loads, so they are set first.
  init = function()
    for name, value in pairs(require("ach.latex").globals()) do
      vim.g[name] = value
    end
  end,
  config = function()
    vim.api.nvim_create_autocmd("User", {
      group = vim.api.nvim_create_augroup("ach_latex", { clear = true }),
      pattern = "VimtexEventInitPost",
      callback = function() require("ach.latex").attach(vim.api.nvim_get_current_buf()) end,
    })
  end,
}

Markdown

live-preview.nvim

A preview in the browser that keeps up with the file as it changes (Space c p).

Repository: brianhuster/live-preview.nvim

From lua/ach/plugins/markdown.lua:

Lua

opts = P.opts()

Lua

{
  "brianhuster/live-preview.nvim",
  cmd = "LivePreview",
  opts = P.opts(),
  -- Runs at start, so Space c p is on every Markdown file before the plugin
  -- itself has loaded.
  init = function()
    vim.api.nvim_create_autocmd("FileType", {
      group = vim.api.nvim_create_augroup("ach_markdown", { clear = true }),
      pattern = P.file_types,
      callback = function(ev) require("ach.preview").attach(ev.buf) end,
    })
  end,
  -- The guard goes on as the plugin loads, before its server can start.
  config = function(_, opts)
    require("livepreview.config").set(opts)
    P.guard()
  end,
}

render-markdown.nvim

Draws headings, lists, tables and code blocks in place while a Markdown file is open.

Repository: MeanderingProgrammer/render-markdown.nvim

From lua/ach/plugins/markdown.lua:

Lua

opts = {
  file_types = P.file_types,
  debounce = debounce,
  completions = { blink = { enabled = true } },
  -- snacks draws formulas as pictures, and two drawings would overlap.
  latex = { enabled = false },
  code = { sign = false, width = "block", right_pad = 1 },
  heading = { sign = false },

Lua

{
  "MeanderingProgrammer/render-markdown.nvim",
  ft = P.file_types,
  opts = {
    file_types = P.file_types,
    debounce = debounce,
    completions = { blink = { enabled = true } },
    -- snacks draws formulas as pictures, and two drawings would overlap.
    latex = { enabled = false },
    code = { sign = false, width = "block", right_pad = 1 },
    heading = { sign = false },
  },
  config = function(_, opts)
    require("render-markdown").setup(opts)
    I.toggle(Snacks.toggle({
      id = "render_markdown",
      name = "Render Markdown",
      get = function() return require("render-markdown").get() end,
      set = function(state)
        require("render-markdown").set(state)
        -- render-markdown drops a drawing asked for within debounce of the
        -- last one, so a press straight after scrolling would change the
        -- setting and leave the old drawing up. Asking again once that
        -- window has passed makes the press land.
        vim.defer_fn(function() require("render-markdown").set(state) end, debounce + 50)
      end,
    })):map("<leader>um")
  end,
}

07.Languages

One subsection for each entry in lua/ach/languages.lua. Nothing here is installed until a file of that language is opened. Then its Tree-sitter parser, its language servers, its formatters and its linters install in the background, without asking, and switch on when they are ready. A compiler or runtime that only Homebrew provides is asked about first, once, in one line that names it and its rough size.

Each table names the parts: the file types the entry covers, the parsers that read its syntax, the language servers that check the code as it is typed, the formatters that tidy it on save, the linters that report problems, the debugger, and whether Harper, a grammar checker, reads it. The Entry tab is the language's entry in lua/ach/languages.lua. The Options tab, where there is one, holds its servers' settings from lua/ach/servers.lua.

angular

Part	Names
File types	`htmlangular`
Parsers	`angular`
Servers	`angularls`, `tailwindcss`
Formatters	`prettier`
Linters	none
Debugger	none
Grammar	none

Lua

angular = {
  ft = { "htmlangular" },
  ts = { "angular" },
  lsp = { "angularls", "tailwindcss" },
  fmt = { "prettier" },
  mason = { "prettier" },
}

ansible

Part	Names
File types	`yaml.ansible`
Parsers	`yaml`
Servers	`ansiblels`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

ansible = { ft = { "yaml.ansible" }, ts = { "yaml" }, lsp = { "ansiblels" }, mason = { "ansible-lint" } }

asm

Part	Names
File types	`asm`, `nasm`
Parsers	`asm`, `nasm`
Servers	`asm_lsp`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

asm = { ft = { "asm", "nasm" }, ts = { "asm", "nasm" }, lsp = { "asm_lsp" } }

astro

Part	Names
File types	`astro`
Parsers	`astro`
Servers	`astro`, `tailwindcss`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

astro = { ft = { "astro" }, ts = { "astro" }, lsp = { "astro", "tailwindcss" } }

Lua

-- astro-ls will not start without a path to TypeScript's library. A project
-- with TypeScript installed gives its own; a file outside one, or a project
-- whose packages are not installed yet, gets the copy Mason installed with
-- the server.
astro = {
  before_init = function(_, config)
    local tsdk = require("lspconfig.util").get_typescript_server_path(config.root_dir)
    if tsdk == "" then
      tsdk = mason .. "/astro-language-server/node_modules/typescript/lib"
    end
    config.init_options = config.init_options or {}
    config.init_options.typescript = config.init_options.typescript or {}
    config.init_options.typescript.tsdk = tsdk
  end,
}

awk

Part	Names
File types	`awk`
Parsers	`awk`
Servers	`awk_ls`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

awk = { ft = { "awk" }, ts = { "awk" }, lsp = { "awk_ls" } }

bsv

Part	Names
File types	`bsv`
Parsers	`bsv`
Servers	none
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

bsv = { ft = { "bsv" }, ts = { "bsv" } }

c

Part	Names
File types	`c`, `cpp`, `objc`, `objcpp`, `cuda`
Parsers	`c`, `cpp`, `cuda`, `objc`
Servers	`clangd`
Formatters	`clang_format`
Linters	none
Debugger	lldb-dap
Grammar	Harper, in `c`, `cpp`

Lua

c = {
  ft = { "c", "cpp", "objc", "objcpp", "cuda" },
  ts = { "c", "cpp", "cuda", "objc" },
  lsp = { "clangd" },
  fmt = { "clang_format" },
  mason = { "clang-format" },
  harper = { "c", "cpp" },
}

clojure

Part	Names
File types	`clojure`, `edn`
Parsers	`clojure`
Servers	`clojure_lsp`
Formatters	none
Linters	none
Debugger	none
Grammar	Harper, in `clojure`

Lua

clojure = { ft = { "clojure", "edn" }, ts = { "clojure" }, lsp = { "clojure_lsp" }, harper = { "clojure" } }

cmake

Part	Names
File types	`cmake`
Parsers	`cmake`
Servers	`neocmake`
Formatters	`gersemi`
Linters	`cmakelint`
Debugger	none
Grammar	Harper

Lua

cmake = {
  ft = { "cmake" },
  ts = { "cmake" },
  lsp = { "neocmake" },
  -- cmake-format, from cmakelang, no longer runs on current Python.
  fmt = { "gersemi" },
  lint = { "cmakelint" },
  mason = { "gersemi", "cmakelint" },
  harper = true,
}

css

Part	Names
File types	`css`, `scss`, `less`
Parsers	`css`, `scss`
Servers	`cssls`, `tailwindcss`
Formatters	`prettier`
Linters	none
Debugger	none
Grammar	none

Lua

css = {
  ft = { "css", "scss", "less" },
  ts = { "css", "scss" },
  lsp = { "cssls", "tailwindcss" },
  fmt = { "prettier" },
  mason = { "prettier" },
}

csv

Part	Names
File types	`csv`, `tsv`
Parsers	`csv`, `tsv`
Servers	none
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

csv = { ft = { "csv", "tsv" }, ts = { "csv", "tsv" } }

dart

Part	Names
File types	`dart`
Parsers	`dart`
Servers	`dartls`
Formatters	`dart_format`
Linters	none
Debugger	none
Grammar	Harper

Lua

dart = {
  ft = { "dart" },
  ts = { "dart" },
  lsp = { "dartls" },
  fmt = { "dart_format" },
  harper = true,
  system = { dart = { name = "the Dart SDK", brew = { "dart-sdk" }, size = "about 600 MB" } },
}

devicetree

Part	Names
File types	`dts`
Parsers	`devicetree`
Servers	none
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

devicetree = { ft = { "dts" }, ts = { "devicetree" } }

docker

Part	Names
File types	`dockerfile`, `yaml.docker-compose`
Parsers	`dockerfile`, `yaml`
Servers	`dockerls`, `docker_compose_language_service`
Formatters	none
Linters	`hadolint` for `dockerfile`
Debugger	none
Grammar	none

Lua

docker = {
  ft = { "dockerfile", "yaml.docker-compose" },
  ts = { "dockerfile", "yaml" },
  lsp = { "dockerls", "docker_compose_language_service" },
  lint = { dockerfile = { "hadolint" } },
  mason = { "hadolint" },
}

dot

Part	Names
File types	`dot`
Parsers	`dot`
Servers	`dotls`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

dot = { ft = { "dot" }, ts = { "dot" }, lsp = { "dotls" } }

dotnet

Part	Names
File types	`cs`, `fsharp`
Parsers	`c_sharp`, `fsharp`
Servers	`csharp_ls`, `fsautocomplete`
Formatters	`csharpier` for `cs` and `fantomas` for `fsharp`
Linters	none
Debugger	netcoredbg
Grammar	Harper, in `cs`

Lua

dotnet = {
  ft = { "cs", "fsharp" },
  ts = { "c_sharp", "fsharp" },
  lsp = { "csharp_ls", "fsautocomplete" },
  fmt = { cs = { "csharpier" }, fsharp = { "fantomas" } },
  mason = { "csharpier", "fantomas", "netcoredbg" },
  harper = { "cs" },
  runtime = { name = ".NET SDK", check = { "dotnet", "--version" }, brew = { "dotnet" }, size = "about 800 MB" },
}

elixir

Part	Names
File types	`elixir`, `eelixir`, `heex`
Parsers	`elixir`, `heex`, `eex`
Servers	`elixirls`
Formatters	none
Linters	none
Debugger	elixir-ls's debugger
Grammar	Harper, in `elixir`

Lua

elixir = {
  ft = { "elixir", "eelixir", "heex" },
  ts = { "elixir", "heex", "eex" },
  lsp = { "elixirls" },
  harper = { "elixir" },
  runtime = { name = "Elixir", check = { "elixir", "--version" }, brew = { "elixir" }, size = "about 400 MB" },

elm

Part	Names
File types	`elm`
Parsers	`elm`
Servers	`elmls`
Formatters	`elm_format`
Linters	none
Debugger	none
Grammar	none

Lua

elm = { ft = { "elm" }, ts = { "elm" }, lsp = { "elmls" }, fmt = { "elm_format" }, mason = { "elm-format" } }

ember

Part	Names
File types	`handlebars`, `javascript.glimmer`, `typescript.glimmer`
Parsers	`glimmer`, `glimmer_javascript`, `glimmer_typescript`
Servers	`ember`
Formatters	`prettier`
Linters	none
Debugger	none
Grammar	none

Lua

ember = {
  ft = { "handlebars", "javascript.glimmer", "typescript.glimmer" },
  ts = { "glimmer", "glimmer_javascript", "glimmer_typescript" },
  lsp = { "ember" },
  fmt = { "prettier" },
  mason = { "prettier" },
}

erlang

Part	Names
File types	`erlang`
Parsers	`erlang`
Servers	`elp`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

erlang = {
  ft = { "erlang" },
  ts = { "erlang" },
  lsp = { "elp" },
  runtime = { name = "Erlang", check = { "erl", "-version" }, brew = { "erlang" }, size = "about 350 MB" },
}

firrtl

Part	Names
File types	`firrtl`
Parsers	`firrtl`
Servers	none
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

firrtl = { ft = { "firrtl" }, ts = { "firrtl" } }

fish

Part	Names
File types	`fish`
Parsers	`fish`
Servers	`fish_lsp`
Formatters	`fish_indent`
Linters	none
Debugger	none
Grammar	none

Lua

fish = {
  ft = { "fish" },
  ts = { "fish" },
  lsp = { "fish_lsp" },
  fmt = { "fish_indent" },
  -- fish_indent ships with the shell, and fish-lsp runs it.
  runtime = { name = "fish", check = { "fish", "--version" }, brew = { "fish" }, size = "about 20 MB" },
}

fortran

Part	Names
File types	`fortran`
Parsers	`fortran`
Servers	`fortls`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

fortran = { ft = { "fortran" }, ts = { "fortran" }, lsp = { "fortls" } }

git (Languages)

Part	Names
File types	`gitcommit`, `gitconfig`, `gitrebase`, `gitignore`, `gitattributes`
Parsers	`git_config`, `gitcommit`, `git_rebase`, `gitignore`, `gitattributes`
Servers	none
Formatters	none
Linters	none
Debugger	none
Grammar	Harper, in `gitcommit`

Lua

git = {
  ft = { "gitcommit", "gitconfig", "gitrebase", "gitignore", "gitattributes" },
  ts = { "git_config", "gitcommit", "git_rebase", "gitignore", "gitattributes" },
  harper = { "gitcommit" },
}

gleam

Part	Names
File types	`gleam`
Parsers	`gleam`
Servers	`gleam`
Formatters	`gleam`
Linters	none
Debugger	none
Grammar	Harper

Lua

gleam = {
  ft = { "gleam" },
  ts = { "gleam" },
  lsp = { "gleam" },
  fmt = { "gleam" },
  harper = true,
  system = { gleam = { name = "Gleam", brew = { "gleam" }, size = "about 400 MB" } },
}

glsl

Part	Names
File types	`glsl`
Parsers	`glsl`
Servers	`glsl_analyzer`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

glsl = { ft = { "glsl" }, ts = { "glsl" }, lsp = { "glsl_analyzer" } }

go

Part	Names
File types	`go`, `gomod`, `gowork`, `gotmpl`
Parsers	`go`, `gomod`, `gowork`, `gosum`, `gotmpl`
Servers	`gopls`
Formatters	`goimports`, `gofumpt` for `go`
Linters	`golangcilint` for `go`
Debugger	delve
Grammar	Harper, in `go`

Lua

go = {
  ft = { "go", "gomod", "gowork", "gotmpl" },
  ts = { "go", "gomod", "gowork", "gosum", "gotmpl" },
  lsp = { "gopls" },
  fmt = { go = { "goimports", "gofumpt" } },
  lint = { go = { "golangcilint" } },
  mason = { "goimports", "gofumpt", "gomodifytags", "impl", "golangci-lint", "delve" },
  harper = { "go" },
  runtime = { name = "Go", check = { "go", "version" }, brew = { "go" }, size = "about 250 MB" },
}

Lua

gopls = {
  settings = {
    gopls = {
      gofumpt = true,
      codelenses = {
        generate = true,
        regenerate_cgo = true,
        test = true,
        tidy = true,
        upgrade_dependency = true,
        vendor = true,
        vulncheck = true,
      },
      hints = {
        assignVariableTypes = true,
        compositeLiteralFields = true,
        compositeLiteralTypes = true,
        constantValues = true,
        functionTypeParameters = true,
        parameterNames = true,
        rangeVariableTypes = true,
      },
      analyses = { nilness = true, unusedparams = true, unusedwrite = true },
      usePlaceholders = true,
      staticcheck = true,
      directoryFilters = { "-.git", "-.vscode", "-.idea", "-.vscode-test", "-node_modules" },
      semanticTokens = true,
    },
  },
}

graphql

Part	Names
File types	`graphql`
Parsers	`graphql`
Servers	`graphql`
Formatters	`prettier`
Linters	none
Debugger	none
Grammar	none

Lua

graphql = {
  ft = { "graphql" },
  ts = { "graphql" },
  lsp = { "graphql" },
  fmt = { "prettier" },
  mason = { "prettier" },
}

groovy

Part	Names
File types	`groovy`
Parsers	`groovy`
Servers	`groovyls`
Formatters	none
Linters	none
Debugger	none
Grammar	Harper

Lua

groovy = { ft = { "groovy" }, ts = { "groovy" }, lsp = { "groovyls" }, harper = true, runtime = java }

haskell

Part	Names
File types	`haskell`, `lhaskell`, `cabal`
Parsers	`haskell`
Servers	started by `haskell-tools.nvim`
Formatters	`cabal_fmt` for `cabal` and `fourmolu` for `haskell`
Linters	`hlint` for `haskell`
Debugger	hdb
Grammar	Harper, in `haskell`, `lhaskell`

Lua

haskell = {
  ft = { "haskell", "lhaskell", "cabal" },
  ts = { "haskell" },
  managed = "haskell-tools.nvim",
  fmt = { haskell = { "fourmolu" }, cabal = { "cabal_fmt" } },
  lint = { haskell = { "hlint" } },
  mason = { "haskell-language-server", "fourmolu", "hlint" },
  harper = { "haskell", "lhaskell" },
  runtime = {
    name = "GHC",
    check = { "ghc", "--version" },
    brew = { "ghcup" },
    after = { { "ghcup", "install", "ghc", "--set", "recommended" } },
    size = "about 3 GB",
  },
}

helm

Part	Names
File types	`helm`
Parsers	`helm`
Servers	`helm_ls`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

helm = { ft = { "helm" }, ts = { "helm" }, lsp = { "helm_ls" } }

hlsl

Part	Names
File types	`hlsl`
Parsers	`hlsl`
Servers	`slangd`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

hlsl = { ft = { "hlsl" }, ts = { "hlsl" }, lsp = { "slangd" } }

html

Part	Names
File types	`html`
Parsers	`html`
Servers	`html`, `emmet_language_server`, `tailwindcss`
Formatters	`prettier`
Linters	none
Debugger	none
Grammar	Harper

Lua

html = {
  ft = { "html" },
  ts = { "html" },
  lsp = { "html", "emmet_language_server", "tailwindcss" },
  fmt = { "prettier" },
  mason = { "prettier" },
  harper = true,
}

ini

Part	Names
File types	`dosini`, `editorconfig`
Parsers	`ini`, `editorconfig`
Servers	none
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

ini = { ft = { "dosini", "editorconfig" }, ts = { "ini", "editorconfig" } }

java

Part	Names
File types	`java`
Parsers	`java`
Servers	started by `nvim-jdtls`
Formatters	none
Linters	none
Debugger	java-debug and java-test
Grammar	Harper

Lua

java = {
  ft = { "java" },
  ts = { "java" },
  managed = "nvim-jdtls",
  mason = { "jdtls", "java-debug-adapter", "java-test" },
  harper = true,
  runtime = java,
}

jq

Part	Names
File types	`jq`
Parsers	`jq`
Servers	none
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

jq = { ft = { "jq" }, ts = { "jq" } }

json

Part	Names
File types	`json`, `jsonc`, `json5`
Parsers	`json`, `json5`
Servers	`jsonls`
Formatters	`prettier`
Linters	none
Debugger	none
Grammar	none

Lua

json = {
  ft = { "json", "jsonc", "json5" },
  ts = { "json", "json5" },
  lsp = { "jsonls" },
  fmt = { "prettier" },
  mason = { "prettier" },
}

Lua

-- SchemaStore's catalogue, read when the server starts rather than when
-- this file loads, so opening a Lua file never pays for it.
jsonls = {
  before_init = function(_, config)
    config.settings.json.schemas = config.settings.json.schemas or {}
    vim.list_extend(config.settings.json.schemas, require("schemastore").json.schemas())
  end,
  settings = { json = { format = { enable = true }, validate = { enable = true } } },
}

julia

Part	Names
File types	`julia`
Parsers	`julia`
Servers	`julials`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

julia = {
  ft = { "julia" },
  ts = { "julia" },
  lsp = { "julials" },
  runtime = { name = "Julia", check = { "julia", "--version" }, brew = { "julia" }, size = "about 1.5 GB" },
}

Lua

-- Mason's julia-lsp takes the Julia environment to load as its one
-- argument; nvim-lspconfig's command runs julia directly instead.
julials = {
  cmd = function(dispatchers, config)
    local root = (config and config.root_dir) or vim.fn.getcwd()
    return vim.lsp.rpc.start({ "julia-lsp", root }, dispatchers)
  end,
}

just

Part	Names
File types	`just`
Parsers	`just`
Servers	`just`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

just = { ft = { "just" }, ts = { "just" }, lsp = { "just" } }

kconfig

Part	Names
File types	`kconfig`
Parsers	`kconfig`
Servers	none
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

kconfig = { ft = { "kconfig" }, ts = { "kconfig" } }

kotlin

Part	Names
File types	`kotlin`
Parsers	`kotlin`
Servers	`kotlin_language_server`
Formatters	`ktlint`
Linters	`ktlint`
Debugger	kotlin-debug-adapter
Grammar	Harper

Lua

kotlin = {
  ft = { "kotlin" },
  ts = { "kotlin" },
  lsp = { "kotlin_language_server" },
  fmt = { "ktlint" },
  lint = { "ktlint" },
  mason = { "ktlint", "kotlin-debug-adapter" },
  harper = true,
  runtime = java,
}

Lua

-- nvim-lspconfig works the cache folder out once, from whichever buffer is
-- current when its file loads, and outside a Gradle or Maven project leaves
-- the options empty. Neovim sends an empty table as a JSON array, which the
-- server refuses, so it never starts. Each start gets the project's root,
-- or a folder of Neovim's own cache for a file outside a project.
kotlin_language_server = {
  before_init = function(params, config)
    local storage = config.root_dir
    if not storage then
      storage = vim.fn.stdpath("cache") .. "/kotlin-language-server"
      vim.fn.mkdir(storage, "p")
    end
    params.initializationOptions = { storagePath = storage }
  end,
}

lean

Part	Names
File types	`lean`
Parsers	none
Servers	started by `lean.nvim`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

lean = {
  ft = { "lean" },
  managed = "lean.nvim",
  runtime = {
    name = "elan",
    check = { "elan", "--version" },
    brew = { "elan-init" },
    after = { { "elan", "default", "stable" } },
    size = "about 1.5 GB",
  },
}

linker

Part	Names
File types	`ld`
Parsers	`linkerscript`
Servers	none
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

linker = { ft = { "ld" }, ts = { "linkerscript" } }

llvm

Part	Names
File types	`llvm`
Parsers	`llvm`
Servers	none
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

llvm = { ft = { "llvm" }, ts = { "llvm" } }

lua

Part	Names
File types	`lua`
Parsers	`lua`, `luadoc`, `luap`
Servers	`lua_ls`
Formatters	`stylua`
Linters	none
Debugger	none
Grammar	Harper

Lua

lua = {
  ft = { "lua" },
  ts = { "lua", "luadoc", "luap" },
  lsp = { "lua_ls" },
  fmt = { "stylua" },
  mason = { "stylua" },
  harper = true,
}

Lua

lua_ls = {
  settings = {
    Lua = {
      workspace = { checkThirdParty = false },
      codeLens = { enable = true },
      completion = { callSnippet = "Replace" },
      doc = { privateName = { "^_" } },
      hint = {
        enable = true,
        setType = false,
        paramType = true,
        paramName = "Disable",
        semicolon = "Disable",
        arrayIndex = "Disable",
      },
    },
  },
}

make

Part	Names
File types	`make`, `automake`
Parsers	`make`
Servers	`autotools_ls`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

make = { ft = { "make", "automake" }, ts = { "make" }, lsp = { "autotools_ls" } }

markdown (Languages)

Part	Names
File types	`markdown`, `markdown.mdx`
Parsers	`markdown`, `markdown_inline`
Servers	`marksman`
Formatters	`prettier`, `markdownlint-cli2` (never on save, only on `Space c f`)
Linters	`markdownlint-cli2`
Debugger	none
Grammar	Harper, in `markdown`

Lua

markdown = {
  ft = { "markdown", "markdown.mdx" },
  ts = { "markdown", "markdown_inline" },
  lsp = { "marksman" },
  fmt = { "prettier", "markdownlint-cli2" },
  lint = { "markdownlint-cli2" },
  mason = { "prettier", "markdownlint-cli2" },
  harper = { "markdown" },
  manual = true,
}

meson

Part	Names
File types	`meson`
Parsers	`meson`
Servers	`mesonlsp`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

meson = { ft = { "meson" }, ts = { "meson" }, lsp = { "mesonlsp" } }

mlir

Part	Names
File types	`mlir`
Parsers	`mlir`
Servers	`mlir_lsp_server`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

mlir = { ft = { "mlir" }, ts = { "mlir" }, lsp = { "mlir_lsp_server" }, system = { ["mlir-lsp-server"] = llvm } }

ninja

Part	Names
File types	`ninja`
Parsers	`ninja`
Servers	none
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

ninja = { ft = { "ninja" }, ts = { "ninja" } }

nix

Part	Names
File types	`nix`
Parsers	`nix`
Servers	`nil_ls`
Formatters	`nixfmt`
Linters	`statix`
Debugger	none
Grammar	Harper

Lua

nix = {
  ft = { "nix" },
  ts = { "nix" },
  lsp = { "nil_ls" },
  fmt = { "nixfmt" },
  lint = { "statix" },
  mason = { "statix" },
  -- nil asks Nix for its builtins as it builds, and Homebrew does not carry Nix.
  runtime = {
    name = "Nix",
    check = { "nix", "--version" },
    command = "curl --proto '=https' --tlsv1.2 -L https://nixos.org/nix/install | sh",
  },
  -- Mason's nixfmt is built for Linux only.
  system = { nixfmt = { name = "nixfmt", brew = { "nixfmt" }, size = "about 30 MB" } },
  harper = true,
}

nushell

Part	Names
File types	`nu`
Parsers	`nu`
Servers	`nushell`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

nushell = {
  ft = { "nu" },
  ts = { "nu" },
  lsp = { "nushell" },
  system = { nu = { name = "nushell", brew = { "nushell" }, size = "about 60 MB" } },
}

ocaml

Part	Names
File types	`ocaml`, `ocamlinterface`
Parsers	`ocaml`, `ocaml_interface`
Servers	`ocamllsp`
Formatters	`ocamlformat`
Linters	none
Debugger	none
Grammar	none

Lua

ocaml = {
  ft = { "ocaml", "ocamlinterface" },
  ts = { "ocaml", "ocaml_interface" },
  lsp = { "ocamllsp" },
  fmt = { "ocamlformat" },
  mason = { "ocamlformat" },
  runtime = {
    name = "OCaml",
    check = { "ocaml", "-version" },
    brew = { "opam" },
    after = { { "opam", "init", "-n", "-y" } },
    size = "about 600 MB",
  },
}

perl

Part	Names
File types	`perl`
Parsers	`perl`
Servers	`perlnavigator`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

perl = { ft = { "perl" }, ts = { "perl" }, lsp = { "perlnavigator" } }

php

Part	Names
File types	`php`
Parsers	`php`, `phpdoc`
Servers	`intelephense`
Formatters	`php_cs_fixer`
Linters	`phpcs`
Debugger	php-debug-adapter
Grammar	Harper

Lua

php = {
  ft = { "php" },
  ts = { "php", "phpdoc" },
  lsp = { "intelephense" },
  fmt = { "php_cs_fixer" },
  lint = { "phpcs" },
  mason = { "php-cs-fixer", "phpcs", "php-debug-adapter" },
  harper = true,
  runtime = { name = "PHP", check = { "php", "--version" }, brew = { "php" }, size = "about 500 MB" },

powershell

Part	Names
File types	`ps1`
Parsers	`powershell`
Servers	`powershell_es`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

powershell = {
  ft = { "ps1" },
  ts = { "powershell" },
  lsp = { "powershell_es" },
  runtime = { name = "PowerShell", check = { "pwsh", "-Version" }, brew = { "powershell" }, size = "about 900 MB" },
}

prisma

Part	Names
File types	`prisma`
Parsers	`prisma`
Servers	`prismals`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

prisma = { ft = { "prisma" }, ts = { "prisma" }, lsp = { "prismals" } }

proto

Part	Names
File types	`proto`
Parsers	`proto`
Servers	`buf_ls`
Formatters	`buf`
Linters	none
Debugger	none
Grammar	none

Lua

proto = { ft = { "proto" }, ts = { "proto" }, lsp = { "buf_ls" }, fmt = { "buf" } }

python

Part	Names
File types	`python`
Parsers	`python`, `rst`, `requirements`
Servers	`basedpyright`, `ruff`
Formatters	`ruff_format`
Linters	none
Debugger	debugpy
Grammar	Harper

Lua

python = {
  ft = { "python" },
  ts = { "python", "rst", "requirements" },
  lsp = { "basedpyright", "ruff" },
  fmt = { "ruff_format" },
  mason = { "debugpy" },
  harper = true,
}

Lua

-- basedpyright's default mode reports far more than most code is written
-- for; "standard" matches what pyright checks.
basedpyright = {
  settings = { basedpyright = { analysis = { typeCheckingMode = "standard" } } },
}

-- Ruff's hover only explains its own rule codes, and two hovers in one
-- window bury basedpyright's, which documents the code itself.
ruff = {
  init_options = { settings = { logLevel = "error" } },
  on_init = function(client) client.server_capabilities.hoverProvider = false end,
}

r

Part	Names
File types	`r`, `rmd`, `quarto`, `rnoweb`
Parsers	`r`, `rnoweb`, `markdown`
Servers	`r_language_server`
Formatters	none
Linters	none
Debugger	none
Grammar	Harper, in `quarto`

Lua

r = {
  ft = { "r", "rmd", "quarto", "rnoweb" },
  ts = { "r", "rnoweb", "markdown" },
  lsp = { "r_language_server" },
  harper = { "quarto" },
  -- The server is an R package, which R builds from source on install.
  runtime = {
    name = "R",
    check = { "Rscript", "-e", "library(languageserver)" },
    brew = { "r" },
    after = { { "Rscript", "-e", "install.packages('languageserver', repos = 'https://cloud.r-project.org')" } },
    size = "about 1.5 GB",
  },
}

rego

Part	Names
File types	`rego`
Parsers	`rego`
Servers	`regols`, `regal`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

rego = { ft = { "rego" }, ts = { "rego" }, lsp = { "regols", "regal" } }

ruby

Part	Names
File types	`ruby`, `eruby`
Parsers	`ruby`, `embedded_template`
Servers	`ruby_lsp`, `rubocop`
Formatters	`erb_format` for `eruby` and `rubocop` for `ruby`
Linters	none
Debugger	none
Grammar	Harper, in `ruby`

Lua

ruby = {
  ft = { "ruby", "eruby" },
  ts = { "ruby", "embedded_template" },
  lsp = { "ruby_lsp", "rubocop" },
  fmt = { ruby = { "rubocop" }, eruby = { "erb_format" } },
  mason = { "erb-formatter" },
  harper = { "ruby" },
  runtime = {
    name = "Ruby 3",
    check = { "ruby", "-e", "exit(RUBY_VERSION >= '3.0' ? 0 : 1)" },
    brew = { "ruby" },
    size = "about 100 MB",
  },
}

rust

Part	Names
File types	`rust`
Parsers	`rust`, `ron`
Servers	started by `rustaceanvim`
Formatters	none
Linters	none
Debugger	codelldb
Grammar	Harper

Lua

rust = {
  ft = { "rust" },
  ts = { "rust", "ron" },
  managed = "rustaceanvim",
  mason = { "rust-analyzer", "codelldb" },
  harper = true,
  runtime = {
    name = "Rust",
    check = { "cargo", "--version" },
    brew = { "rustup" },
    after = { { "rustup", "default", "stable" } },
    size = "about 1.5 GB",
  },
}

scala

Part	Names
File types	`scala`, `sbt`
Parsers	`scala`
Servers	started by `nvim-metals`
Formatters	none
Linters	none
Debugger	Metals' own debug server
Grammar	Harper, in `scala`

Lua

scala = {
  ft = { "scala", "sbt" },
  ts = { "scala" },
  managed = "nvim-metals",
  harper = { "scala" },
  runtime = {
    name = "Coursier",
    check = { "coursier", "list" },
    brew = { "coursier", "openjdk@21" },
    size = "about 700 MB",
  },
}

sh

Part	Names
File types	`sh`, `bash`, `zsh`
Parsers	`bash`, `zsh`
Servers	`bashls`
Formatters	`shfmt` for `bash` and `shfmt` for `sh`
Linters	none
Debugger	none
Grammar	Harper, in `sh`

Lua

sh = {
  ft = { "sh", "bash", "zsh" },
  ts = { "bash", "zsh" },
  lsp = { "bashls" },
  fmt = { sh = { "shfmt" }, bash = { "shfmt" } },
  mason = { "shfmt", "shellcheck" },
  harper = { "sh" },

solidity

Part	Names
File types	`solidity`
Parsers	`solidity`
Servers	`solidity_ls`
Formatters	none
Linters	none
Debugger	none
Grammar	Harper

Lua

solidity = { ft = { "solidity" }, ts = { "solidity" }, lsp = { "solidity_ls" }, harper = true }

sql

Part	Names
File types	`sql`, `mysql`, `plsql`
Parsers	`sql`
Servers	none
Formatters	`sqlfluff`
Linters	`sqlfluff`
Debugger	none
Grammar	none

Lua

sql = {
  ft = { "sql", "mysql", "plsql" },
  ts = { "sql" },
  fmt = { "sqlfluff" },
  lint = { "sqlfluff" },
  mason = { "sqlfluff" },
}

starlark

Part	Names
File types	`bzl`, `starlark`
Parsers	`starlark`
Servers	`starpls`
Formatters	`buildifier`
Linters	none
Debugger	none
Grammar	none

Lua

starlark = {
  ft = { "bzl", "starlark" },
  ts = { "starlark" },
  lsp = { "starpls" },
  fmt = { "buildifier" },
  mason = { "buildifier" },
}

svelte

Part	Names
File types	`svelte`
Parsers	`svelte`
Servers	`svelte`, `tailwindcss`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

svelte = { ft = { "svelte" }, ts = { "svelte" }, lsp = { "svelte", "tailwindcss" } }

swift

Part	Names
File types	`swift`
Parsers	`swift`
Servers	`sourcekit`
Formatters	none
Linters	none
Debugger	lldb-dap
Grammar	Harper

Lua

swift = {
  ft = { "swift" },
  ts = { "swift" },
  lsp = { "sourcekit" },
  harper = true,
  system = { ["sourcekit-lsp"] = xcode },
}

systemverilog

Part	Names
File types	`verilog`, `systemverilog`
Parsers	`systemverilog`
Servers	`verible`
Formatters	`verible`
Linters	none
Debugger	none
Grammar	none

Lua

systemverilog = {
  ft = { "verilog", "systemverilog" },
  ts = { "systemverilog" },
  lsp = { "verible" },
  fmt = { "verible" },
  mason = { "verible" },
}

tablegen

Part	Names
File types	`tablegen`
Parsers	`tablegen`
Servers	`tblgen_lsp_server`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

tablegen = {
  ft = { "tablegen" },
  ts = { "tablegen" },
  lsp = { "tblgen_lsp_server" },
  system = { ["tblgen-lsp-server"] = llvm },
}

tcl

Part	Names
File types	`tcl`, `sdc`, `xdc`
Parsers	`tcl`
Servers	`tclsp`
Formatters	none
Linters	`tclint`
Debugger	none
Grammar	none

Lua

tcl = { ft = { "tcl", "sdc", "xdc" }, ts = { "tcl" }, lsp = { "tclsp" }, lint = { "tclint" } }

terraform

Part	Names
File types	`terraform`, `terraform-vars`, `hcl`
Parsers	`terraform`, `hcl`
Servers	`terraformls`
Formatters	none
Linters	`tflint` for `terraform`
Debugger	none
Grammar	none

Lua

terraform = {
  ft = { "terraform", "terraform-vars", "hcl" },
  ts = { "terraform", "hcl" },
  lsp = { "terraformls" },
  lint = { terraform = { "tflint" } },
  mason = { "tflint" },
}

tex

Part	Names
File types	`tex`, `plaintex`, `bib`
Parsers	`latex`, `bibtex`
Servers	`texlab`
Formatters	none
Linters	none
Debugger	none
Grammar	Harper, in `tex`, `plaintex`

Lua

tex = {
  ft = { "tex", "plaintex", "bib" },
  ts = { "latex", "bibtex" },
  lsp = { "texlab" },
  harper = { "tex", "plaintex" },
  manual = true,
}

text

Part	Names
File types	`text`
Parsers	none
Servers	none
Formatters	none
Linters	none
Debugger	none
Grammar	Harper

Lua

text = { ft = { "text" }, harper = true, manual = true }

thrift

Part	Names
File types	`thrift`
Parsers	`thrift`
Servers	`thriftls`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

thrift = { ft = { "thrift" }, ts = { "thrift" }, lsp = { "thriftls" } }

toml

Part	Names
File types	`toml`
Parsers	`toml`
Servers	`taplo`
Formatters	`taplo`
Linters	none
Debugger	none
Grammar	Harper

Lua

toml = { ft = { "toml" }, ts = { "toml" }, lsp = { "taplo" }, fmt = { "taplo" }, harper = true }

twig

Part	Names
File types	`twig`
Parsers	`twig`
Servers	`twiggy_language_server`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

twig = { ft = { "twig" }, ts = { "twig" }, lsp = { "twiggy_language_server" } }

typescript

Part	Names
File types	`javascript`, `javascriptreact`, `javascript.jsx`, `typescript`, `typescriptreact`, `typescript.tsx`
Parsers	`javascript`, `jsdoc`, `typescript`, `tsx`
Servers	`vtsls`, `eslint`, `tailwindcss`
Formatters	`prettier`
Linters	none
Debugger	js-debug
Grammar	Harper, in `javascript`, `javascriptreact`, `typescript`, `typescriptreact`

Lua

typescript = {
  ft = { "javascript", "javascriptreact", "javascript.jsx", "typescript", "typescriptreact", "typescript.tsx" },
  ts = { "javascript", "jsdoc", "typescript", "tsx" },
  lsp = { "vtsls", "eslint", "tailwindcss" },
  fmt = { "prettier" },
  mason = { "prettier", "js-debug-adapter" },
  harper = { "javascript", "javascriptreact", "typescript", "typescriptreact" },

Lua

-- vtsls also serves Vue files, through Vue's TypeScript plugin, which Mason
-- installs inside the Vue server's package.
vtsls = {
  filetypes = {
    "javascript",
    "javascriptreact",
    "javascript.jsx",
    "typescript",
    "typescriptreact",
    "typescript.tsx",
    "vue",
  },
  settings = {
    complete_function_calls = true,
    vtsls = {
      enableMoveToFileCodeAction = true,
      autoUseWorkspaceTsdk = true,
      experimental = {
        maxInlayHintLength = 30,
        completion = { enableServerSideFuzzyMatch = true },
      },
      tsserver = {
        globalPlugins = {
          {
            name = "@vue/typescript-plugin",
            location = mason .. "/vue-language-server/node_modules/@vue/language-server",
            languages = { "vue" },
            configNamespace = "typescript",
            enableForWorkspaceTypeScriptVersions = true,
          },
        },
      },
    },
    typescript = typescript,
    javascript = vim.deepcopy(typescript),
  },
}

typst

Part	Names
File types	`typst`
Parsers	`typst`
Servers	`tinymist`
Formatters	`typstyle` (never on save, only on `Space c f`)
Linters	none
Debugger	none
Grammar	Harper

Lua

typst = {
  ft = { "typst" },
  ts = { "typst" },
  lsp = { "tinymist" },
  fmt = { "typstyle" },
  mason = { "typstyle" },
  harper = true,
  manual = true,
}

veryl

Part	Names
File types	`veryl`
Parsers	`veryl`
Servers	`veryl_ls`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

veryl = { ft = { "veryl" }, ts = { "veryl" }, lsp = { "veryl_ls" } }

vhdl

Part	Names
File types	`vhdl`
Parsers	`vhdl`
Servers	`vhdl_ls`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

vhdl = { ft = { "vhdl" }, ts = { "vhdl" }, lsp = { "vhdl_ls" } }

vim

Part	Names
File types	`vim`
Parsers	`vim`, `vimdoc`
Servers	`vimls`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

vim = { ft = { "vim" }, ts = { "vim", "vimdoc" }, lsp = { "vimls" } }

vue

Part	Names
File types	`vue`
Parsers	`vue`
Servers	`vue_ls`, `vtsls`, `tailwindcss`
Formatters	`prettier`
Linters	none
Debugger	none
Grammar	none

Lua

vue = {
  ft = { "vue" },
  ts = { "vue" },
  lsp = { "vue_ls", "vtsls", "tailwindcss" },
  fmt = { "prettier" },
  mason = { "prettier" },
}

Lua

-- vtsls also serves Vue files, through Vue's TypeScript plugin, which Mason
-- installs inside the Vue server's package.
vtsls = {
  filetypes = {
    "javascript",
    "javascriptreact",
    "javascript.jsx",
    "typescript",
    "typescriptreact",
    "typescript.tsx",
    "vue",
  },
  settings = {
    complete_function_calls = true,
    vtsls = {
      enableMoveToFileCodeAction = true,
      autoUseWorkspaceTsdk = true,
      experimental = {
        maxInlayHintLength = 30,
        completion = { enableServerSideFuzzyMatch = true },
      },
      tsserver = {
        globalPlugins = {
          {
            name = "@vue/typescript-plugin",
            location = mason .. "/vue-language-server/node_modules/@vue/language-server",
            languages = { "vue" },
            configNamespace = "typescript",
            enableForWorkspaceTypeScriptVersions = true,
          },
        },
      },
    },
    typescript = typescript,
    javascript = vim.deepcopy(typescript),
  },
}

wgsl

Part	Names
File types	`wgsl`
Parsers	`wgsl`
Servers	`wgsl_analyzer`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

wgsl = { ft = { "wgsl" }, ts = { "wgsl" }, lsp = { "wgsl_analyzer" } }

xml

Part	Names
File types	`xml`, `xsd`, `xslt`, `svg`
Parsers	`xml`
Servers	`lemminx`
Formatters	none
Linters	none
Debugger	none
Grammar	none

Lua

xml = { ft = { "xml", "xsd", "xslt", "svg" }, ts = { "xml" }, lsp = { "lemminx" } }

yaml

Part	Names
File types	`yaml`
Parsers	`yaml`
Servers	`yamlls`
Formatters	`prettier`
Linters	none
Debugger	none
Grammar	none

Lua

yaml = { ft = { "yaml" }, ts = { "yaml" }, lsp = { "yamlls" }, fmt = { "prettier" }, mason = { "prettier" } }

Lua

yamlls = {
  before_init = function(_, config)
    config.settings.yaml.schemas =
      vim.tbl_deep_extend("force", config.settings.yaml.schemas or {}, require("schemastore").yaml.schemas())
  end,
  settings = {
    redhat = { telemetry = { enabled = false } },
    yaml = {
      keyOrdering = false,
      format = { enable = true },
      validate = true,
      -- SchemaStore.nvim supplies the catalogue; yamlls' own download is off.
      schemaStore = { enable = false, url = "" },
    },
  },
}

zig

Part	Names
File types	`zig`
Parsers	`zig`
Servers	`zls`
Formatters	none
Linters	none
Debugger	lldb-dap
Grammar	Harper

Lua

zig = {
  ft = { "zig" },
  ts = { "zig" },
  lsp = { "zls" },
  harper = true,
  runtime = { name = "Zig", check = { "zig", "version" }, brew = { "zig" }, size = "about 2 GB" },
}

— Anirban

Hardware–software at the seam where compilers meet microcode.

FeedbackBook mode

	-- Closes brackets and quotes as they open.
	{
	"nvim-mini/mini.pairs",
	event = "VeryLazy",
	opts = { modes = { insert = true, command = true, terminal = false } },
	}

	{
	"nvim-lualine/lualine.nvim",
	event = "VeryLazy",
	dependencies = { "nvim-mini/mini.icons" },
	opts = function() return require("ach.statusline").options() end,
	config = function(_, opts) require("ach.statusline").setup(opts) end,

	-- A swatch behind every hex colour such as #rrggbb.
	{
	"nvim-mini/mini.hipatterns",
	event = { "BufReadPre", "BufNewFile" },
	opts = function() return { highlighters = { hex_color = require("mini.hipatterns").gen_highlighter.hex_color() } } end,

	clangd = {
	cmd = {
	"clangd",
	"--background-index",
	"--clang-tidy",
	"--header-insertion=iwyu",
	"--completion-style=detailed",
	"--function-arg-placeholders",
	"--fallback-style=llvm",
	},
	init_options = { usePlaceholders = true, completeUnimported = true, clangdFileStatus = true },
	}

	brew install neovim git ripgrep fd lazygit tree-sitter-cli imagemagick
	brew install --cask ghostty font-jetbrains-mono-nerd-font
	xcode-select --install

	mv ~/.config/nvim ~/.config/nvim.bak
	mv ~/.local/share/nvim ~/.local/share/nvim.bak
	mv ~/.local/state/nvim ~/.local/state/nvim.bak
	mv ~/.cache/nvim ~/.cache/nvim.bak

	mkdir -p ~/.config/ghostty
	ln -s ~/.config/nvim/ghostty/config.ghostty ~/.config/ghostty/config.ghostty

	~/.config/nvim
	├── init.lua checks the Neovim version, then loads lua/ach
	├── lazy-lock.json the commit of every plugin
	├── mason-lock.json the version of every Mason package
	├── lua/ach/ options, keys, autocommands, the language table, and the logic behind each feature
	│ └── plugins/ the plugin specs, one file per area
	├── snippets/ my own snippets
	├── ghostty/ Ghostty's settings
	├── docs/ the key card, the list of languages, and the hand-written parts of this page
	├── scripts/ check, update and docs
	└── tests/ the test suite

	require("ach.latex").build_with(function(main)
	return { "make", "pdf" }, vim.fs.dirname(main)
	end)

	opts = {
	sources = {
	default = { "lazydev" },
	providers = {
	lazydev = { name = "LazyDev", module = "lazydev.integrations.blink", score_offset = 100 },
	},
	},
	}

	opts = {
	library = {
	{ path = "${3rd}/luv/library", words = { "vim%.uv" } },
	{ path = "snacks.nvim", words = { "Snacks" } },
	"lazy.nvim",
	},
	}

	-- The right comment marker inside embedded languages, such as Lua inside Markdown.
	{ "folke/ts-comments.nvim", event = "VeryLazy", opts = {} }

	-- Only the icons change; the colours and alternate names stay todo-comments' own.
	opts = { keywords = I.todo_keywords() }

	opts = {
	modes = { lsp = { win = { position = "right" } } },
	icons = { kinds = I.spaced(I.kinds) },
	}

	{
	"mfussenegger/nvim-lint",
	-- Loaded when a file opens, so the first file is linted and the status
	-- bar can name its linters from the start.
	event = { "BufReadPost", "BufNewFile", "BufWritePost" },
	config = function() require("ach.lint").setup() end,
	}

	opts = {
	ui = {
	icons = {
	package_installed = I.mason.installed,
	package_pending = I.mason.pending,
	package_uninstalled = I.mason.uninstalled,
	},
	},
	}

	{
	"neovim/nvim-lspconfig",
	-- Loaded as the first file is read, so the diagnostics' look and the
	-- servers' settings are in place before anything reports on it, and with
	-- no file after the first screen. Its lsp/ folder must be on the runtime
	-- path before the first server is enabled, so lua/ach/lsp.lua loads it
	-- then too, for a file type set on a buffer with no file.
	event = { "BufReadPre", "BufNewFile", "VeryLazy" },
	config = function() require("ach.lsp").setup() end,
	}

	-- The icon database's overrides: the hardware languages get chips, gates and
	-- waveforms, and file types mini.icons does not know get an icon of their own.
	opts = function() return require("ach.icons").mini() end

	-- Each nesting level of brackets in its own colour, from tokyonight's rainbow groups.
	-- It reads no options, so lazy.nvim only has to put it on the runtime path.
	{ "HiPhish/rainbow-delimiters.nvim", event = { "BufReadPre", "BufNewFile" } }

	opts = {
	notifier = { enabled = true, timeout = 3000 },
	dashboard = {
	enabled = true,
	sections = {
	function(self) return require("ach.dashboard").sections(self) end,
	},
	},
	}

	opts = {
	explorer = { enabled = true },
	bigfile = { enabled = true },
	quickfile = { enabled = true },
	}

	opts = {
	picker = {
	enabled = true,
	icons = { kinds = I.spaced(I.kinds), diagnostics = I.spaced(I.diagnostics) },
	},
	}

	{
	"folke/snacks.nvim",
	opts = { image = { enabled = true } },
	}

	opts = {
	indent = { enabled = true },
	scope = { enabled = true },
	words = { enabled = true },
	statuscolumn = { enabled = true },
	input = { enabled = true },
	}

	-- Lean, loaded as a .lean file is read or created, before its file type is
	-- set, so its own ftplugin and commands are there when the type is.
	{
	"Julian/lean.nvim",
	commit = "42186878a385ab021296e8f8024521d11a661754",
	event = { "BufReadPre .lean", "BufNewFile .lean" },
	}

	-- Java and Scala, loaded when ach.managed first requires them.
	{ "mfussenegger/nvim-jdtls", commit = "6e9d953f0b82bccdb834cfde0e893f3119c22592" }

	-- Rust and Haskell. Neither may be lazy-loaded: each does its work from an
	-- ftplugin, which must be on the runtime path before the first file of its
	-- type opens, and each loads the rest of itself only when first used.
	{ "mrcjkb/rustaceanvim", version = "^9", lazy = false }

	opts = {
	enhanced_diff_hl = true,
	-- A merge conflict shows the two sides above and the result below.
	view = { merge_tool = { layout = "diff3_mixed" } },
	}

	opts = {
	kind = "tab",
	graph_style = "unicode",
	integrations = { diffview = true, snacks = true },
	}

	opts = {
	file_types = P.file_types,
	debounce = debounce,
	completions = { blink = { enabled = true } },
	-- snacks draws formulas as pictures, and two drawings would overlap.
	latex = { enabled = false },
	code = { sign = false, width = "block", right_pad = 1 },
	heading = { sign = false },

	angular = {
	ft = { "htmlangular" },
	ts = { "angular" },
	lsp = { "angularls", "tailwindcss" },
	fmt = { "prettier" },
	mason = { "prettier" },
	}

	c = {
	ft = { "c", "cpp", "objc", "objcpp", "cuda" },
	ts = { "c", "cpp", "cuda", "objc" },
	lsp = { "clangd" },
	fmt = { "clang_format" },
	mason = { "clang-format" },
	harper = { "c", "cpp" },
	}

	cmake = {
	ft = { "cmake" },
	ts = { "cmake" },
	lsp = { "neocmake" },
	-- cmake-format, from cmakelang, no longer runs on current Python.
	fmt = { "gersemi" },
	lint = { "cmakelint" },
	mason = { "gersemi", "cmakelint" },
	harper = true,
	}

	css = {
	ft = { "css", "scss", "less" },
	ts = { "css", "scss" },
	lsp = { "cssls", "tailwindcss" },
	fmt = { "prettier" },
	mason = { "prettier" },
	}