# quicker.nvim: a quickfix window you can read, expand, and edit

> quicker.nvim is a Neovim plugin that restyles the quickfix and location lists, adds context lines around results, and makes the quickfix buffer editable so a multi-file change can be made and written in one go. It requires Neovim 0.10 or newer and is configured through a single setup call.

**stevearc/quicker.nvim** — Improved UI and workflow for the Neovim quickfix

- Repository: https://github.com/stevearc/quicker.nvim
- Stars: 1,034 · Forks: 17
- Language: Lua
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/stevearc-quicker-nvim

## Four features, and one of them changes what you can do

quicker.nvim is an improved UI and workflow for the Neovim quickfix, and the feature list is short enough to read in full.

Improved styling, including syntax highlighting of grep results. Show context lines, so you can easily view lines above and below the quickfix results. An editable buffer, to make changes across your whole project by editing the quickfix buffer and `:w`. And API helpers, some helper methods for common tasks such as toggling the quickfix.

Three of those are presentation. The fourth is a different category, and it is the one that makes this plugin more than a colour scheme.

The editable buffer means the quickfix is not a read-only list of results but a buffer you can change. The plugin renders each result as a line in the buffer, with the filename and line number as columns and the file content as text. If you edit that text and write the buffer, the changes are applied to the underlying files. A grep that finds forty occurrences of a function name across twelve files becomes a buffer you can edit and save, in the same way you would edit a file, rather than a list of locations you visit one at a time.

That is a genuine workflow change, and it is why the plugin carries an `edit` option with an `enabled` flag and an `autosave` setting rather than treating editing as an always-on side effect.

The requirement is Neovim 0.10 or newer, and the plugin is not for Vim, since the quickfix internals and the API surface it relies on are Neovim's.

## Context expansion is the feature you will use most

Showing context lines is the feature that makes a quickfix readable, and the mechanism is an API call with options.

`expand(opts)` expands the context around the quickfix results, and the options table gives the shape: `before` is the number of lines of context to show before the line, with a default of 2, and `after` is the matching count after. There are also `opts` for `add_to_existing` and similar.

The setup example shows how it is bound in practice:

```lua
require("quicker").setup({
  keys = {
    {
      ">",
      function()
        require("quicker").expand({ before = 2, after = 2, add_to_existing = true })
      end,
      desc = "Expand quickfix context",
    },
    {
      "<",
      function()
        require("quicker").collapse()
      end,
      desc = "Collapse quickfix context",
    },
  },
})
```

So `>` expands and `<` collapses, with `add_to_existing = true` meaning the expansion adds to what is already shown rather than replacing it. The pairing is a good design, because expanding a second time with more context is the natural next step when you narrow in on a result, and collapsing gets you back to the plain list.

The `add_to_existing` flag has a second use that the naming does not make obvious. If the quickfix holds results from several different searches, and each search is a separate task, then expanding one and adding to the existing view lets you build up a combined view of context across searches without losing what you had.

The rendering of that context is where the borders option comes in, and it is the detail that makes the result readable. There are strong headers, which separate results from different files, and soft headers, which separate results within the same file, each with their own horizontal, cross, and end characters. The default strong header is a heavy line and the soft header a light one, and the strong cross character joins the vertical divider at that point. When context is expanded, the two levels of separator tell you at a glance whether you have crossed a file boundary, which is exactly the information you need when the list is long.

## The options list shows how much of the quickfix it takes over

The complete options list is in the project summary, and reading it tells you how deeply the plugin integrates with the window.

The `opts` block sets local options for the quickfix window, and the defaults are all about making the list read as a document rather than as a code buffer: `buflisted = false`, `number = false`, `relativenumber = false`, `signcolumn = auto`, `winfixheight = true`, and `wrap = false`. Turning off numbers and relative numbers is the clearest signal, since the quickfix already shows a line number column and the second one would be redundant. `use_default_opts = true` disables the defaults if you set it to false.

The `keys` option takes a list of key and function pairs for the quickfix buffer, and the `on_qf` option is a callback function to run any custom logic or keymaps for the quickfix buffer, with the buffer number passed in.

The `edit` block is the one to read twice. `enabled = true` enables editing the quickfix like a normal buffer. `autosave` is set to "unmodified" by default, and the comments explain the two other values: set to true to write buffers after applying edits, and set to "unmodified" to only write unmodified buffers. The default is the conservative one, which is the right default for a feature that writes to your source files.

`constrain_cursor = true` keeps the cursor to the right of the filename and lnum columns, which stops the cursor from sitting in the metadata when you jump to a line to edit it.

The `highlight` block has three options. `treesitter = true` uses treesitter highlighting, `lsp = true` uses LSP semantic token highlighting, and `load_buffers = false` loads the referenced buffers to apply more accurate highlights, with the note that this may be slow. That last one is the trade-off: to highlight a grep result the way it looks in its real file, the plugin has to read that file, and reading every file in a large result set is not free.

The `follow` block controls whether the quickfix window scrolls to the closest item to the cursor when the window is open, and it is off by default, because following the cursor in the source window while editing the quickfix is a fight between two focus behaviours.

## Presentation options, down to the border characters

The remaining options are about how the list looks, and they are unusually fine-grained, which tells you how much attention the author paid to the shape of the output.

`type_icons` is a map of quickfix item type to icon, with entries for E, W, I, N, and H, which are the error, warning, info, note, and help types that a diagnostic can carry. Each maps to a nerd font glyph followed by a space, and the highlight groups list includes `DiagnosticSign*` for the signs that display the quickfix error type, so the icon and the sign are separate mechanisms and you can style them independently.

`borders` sets the border characters. `vert` is the vertical divider between the filename, the line number, and the text, and the default is a heavy vertical bar. Then there are the strong and soft header characters, each with a horizontal line, a cross, and an end, with the comments explaining that strong headers separate results from different files and soft headers separate results within the same file.

`trim_leading_whitespace` controls how the leading whitespace is trimmed from results, and it can be `all`, `common`, or false. The default of `common` is the thoughtful choice, because trimming to the common indentation across all results keeps the relative indentation of the code intact while removing the shared left margin, which is what makes a multi-file grep result readable as a column of code.

`max_filename_width` is a function returning the maximum width of the filename column, and the default computes half the screen width, capped at 95. `header_length` is a function taking the type and the start column and returning how far the header should extend to the right, and the default uses the screen width. The fact that these are functions rather than numbers is the detail, because a fixed number would be wrong on every screen but one, and a plugin that respects `vim.o.columns` adapts to the window you are in.

The `highlight` groups are listed separately, and they are the contract for anyone who wants the plugin to match their colour scheme. `QuickFixText` is the base text when there are no syntax highlights, and `QuickFixTextInvalid` is the text when `valid = 0`. Then `QuickFixHeaderHard` and `QuickFixHeaderSoft` for the two divider levels, `Delimiter` for the divider between filename, line number, and text, `QuickFixLineNr`, `QuickFixFilename`, and `QuickFixFilenameInvalid` for the filename when `valid = 0`.

And the documentation says you can set these highlight groups yourself, or use `:help winhighlight` in the setup `opts` option to override them for just the quickfix window. The winhighlight route is the one to know, because it applies only to that window and so you do not have to redesign your colourscheme to suit the plugin.

## Installation, and the fact that setup is required

quicker.nvim supports all the usual plugin managers, and the summary gives the configuration for six of them.

For lazy.nvim the spec is a table with the plugin name, `ft = "qf"` for lazy loading, the `---@module "quicker"` and `---@type quicker.SetupOptions` annotations, and an empty `opts`.

For Packer it is a `use` call with a `config` function that calls `require("quicker").setup()`. For Paq it is a single entry with the plugin name. For vim-plug it is `Plug 'stevearc/quicker.nvim'`. For dein it is `call dein#add('stevearc/quicker.nvim')`. And for Pathogen and the Neovim native package manager it is a shallow git clone into the right directory, with the native package path being the site pack directory under `XDG_DATA_HOME`.

Then there is the step that catches people out. You will need to call `setup()` for quicker to start working:

```lua
require("quicker").setup()
```

It is not required to pass in any options, but you may wish to set some keymaps. The example maps `<leader>q` to `require("quicker").toggle()` and `<leader>l` to `require("quicker").toggle({ loclist = true })`, with descriptions of Toggle quickfix and Toggle loclist.

So the plugin has two lists, the quickfix and the location list, and the toggle takes an option to say which one you are toggling. That is the API helper the feature list mentions, and it is a small thing that reflects how you actually work, where the quickfix holds results from searches and the location list holds results from other sources like the language server, and you want to flip between them with the same key.

The `ft = "qf"` in the lazy.nvim spec is worth a second look too. It means the plugin is only loaded when a quickfix buffer is opened, which is the right lazy-loading key for something that only matters when you are looking at a list of results.

## The project keeps the docs generated and the types checked

The Makefile is more elaborate than a plugin of this size usually needs, and it is worth reading because it shows what the maintainer considers the definition of done.

The `all` target chains doc, lint, and test. The `doc` target generates the documentation and lints it, using a Python virtual environment with the requirements in `scripts/requirements.txt` and a `scripts/main.py` script that both generates and lints. The tooling it uses is cloned from another repository of the same author, `nvim_doc_tools`, which is the same pattern the type checking uses.

The `lint` target depends on `scripts/nvim-typecheck-action` and `fastlint`, and it runs the typecheck script from `scripts/nvim-typecheck-action/typecheck.sh` against the `lua` directory. That is a LuaLS typecheck driven by a GitHub action's tooling, cloned locally so it can be run from the Makefile. The `fastlint` target runs the Python doc linter, then `luacheck lua tests --formatter plain`, then `stylua --check lua tests`.

So the checks are a documentation lint, a Lua type check, luacheck, and stylua for formatting. The `.luacheckrc` and `.luarc.json` at the root are the linter and language server configuration, and `.stylua.toml` is the formatter configuration.

The tests run through a shell script, `./run_tests.sh`, and there is an `update_snapshots` target that runs the same script with `--update`. Snapshot testing is the right approach for a plugin whose output is a rendered screen, and the `syntax/` directory at the root is where the syntax files for the highlighted grep results live.

The `clean` target removes the two cloned tool repositories, the virtual environment, and the test environment, which tells you that the tooling is not vendored but fetched.

The releases are v1.4.0 in February 2025, v1.5.0 in January 2026, and v1.5.1 on 2026-05-24, with the last push on the same day as the 1.5.1 tag. The licence is MIT, the primary language is Lua, and there is a `CHANGELOG.md` and a `doc/` directory alongside the `lua/` directory where the plugin lives.

## Conclusion

quicker.nvim fits a Neovim user who treats the quickfix as a working surface rather than a list to scroll through, especially one who greps, reads a result with its context, and then edits and writes the change across several files. It is the wrong tool if you are on Vim rather than Neovim, or if your quickfix is a transient list you never act on. Check three things before you install it: that you are on Neovim 0.10 or newer, that you read the `edit.autosave` option carefully, because writing modified buffers automatically is a behaviour change with real consequences, and that your colour scheme renders the plugin's highlight groups, since the whole presentation depends on them.

## FAQ

### What does quicker.nvim add to the Neovim quickfix?

Improved styling including syntax highlighting of grep results, context lines that show the lines above and below each result, an editable buffer where you can make changes across your project by editing the quickfix and writing it, and API helpers for common tasks such as toggling the quickfix. It requires Neovim 0.10 or newer.

### How do I install quicker.nvim and set it up?

It supports the usual plugin managers, with lazy.nvim, Packer, Paq, vim-plug, dein, Pathogen, and the Neovim native package manager each documented. After installing you must call `require("quicker").setup()`, with no options required, and you may want to set keymaps such as `<leader>q` for `require("quicker").toggle()` and `<leader>l` for the loclist variant.

### How does quicker.nvim handle editing the quickfix buffer?

The `edit` option has `enabled = true` by default so the quickfix behaves like a normal buffer, and an `autosave` setting that controls writing: set to true to write buffers after applying edits, and the default is "unmodified", which writes only unmodified buffers. There is also a `constrain_cursor` option that keeps the cursor to the right of the filename and line number columns.

### Which highlight groups does quicker.nvim use?

They are QuickFixText, QuickFixTextInvalid, QuickFixHeaderHard, QuickFixHeaderSoft, Delimiter, QuickFixLineNr, QuickFixFilename, QuickFixFilenameInvalid, and the DiagnosticSign group for the quickfix error type signs. You can set them yourself, or use `:help winhighlight` in the setup `opts` option to override them for just the quickfix window.

## Sources

- [Issues](https://github.com/stevearc/quicker.nvim/issues)
- [License: MIT](https://github.com/stevearc/quicker.nvim/blob/master/LICENSE)
- [README](https://github.com/stevearc/quicker.nvim/blob/master/README.md)
- [Releases](https://github.com/stevearc/quicker.nvim/releases)
- [stevearc/quicker.nvim on GitHub](https://github.com/stevearc/quicker.nvim)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/stevearc-quicker-nvim