Working with external warnings and diagnostics in NVIM

2026-01-20T00:00:00+00:00

While most modern programming languages feature very advanced editor integrations especially through LSP server implementations, VLSI, RTL, and (System)Verilog tooling is always a bit ... different.

Fortunately, these tools are not inherently bad, but rather a little more old-fashioned. This means that while they might not be as straightforward to use, the tools and techniques for an efficient workflow are already out there.

In particular, I was interested in being able to quickly see and navigate to all the numerous warnings and errors they produce directly in neovim.

I will use verilator</a> - an open-source SystemVerilog simulator that works by transpiling RTL models to C++ code - as an example for this post, but these same tools and techniques apply to everything from commercial simulators and backend tools to any tool that generates errors and warnings that are attached to a file location.

The Quickfix List</h2>
As is so often the case, this exact feature is already supported in (neo)vim without any external plugins.
In fact, for a simple C project using a Makefile</code>, you don't even have to configure anything! The command :make</code> will cause vim to call make</code> with no arguments, capture its output and parse it into the so-called quickfix list, which you can open with :cwindow</code>:
</a> Errors produced by :make</code> in the quick-fix list. </center> As you scroll through the quickfix list, vim will automatically jump to the location of the errors and warnings. Even without opening the quickfix list, you can jump between entries using :cn</code> and :cp</code>. For more information about the quickfix list, see :h quickfix</code></a>. The makeprg</code> option and cfile</code></h3> The :make</code> command and quickfix list, despite its name, is not limited to Makefiles and their output. The makeprg</code> option controls which command is invoked when :make</code> is called. For example, the following will cause it to run cargo build</code>: :set makeprg=cargo\ build</code></pre> Any arguments you provide to the :make</code> command will be appended to the end of makeprg</code>, unless the $*</code> placeholder is used to specify where exactly the arguments should be inserted: :set makeprg=make\ $*\ verilate :make MYDEFINE=1 make MYDEFINE=1 verilate</code></pre> The %</code> placeholder will be replaced with the path of the current file, which is particularly useful for single-file linters or scripts: :set makeprg=shellcheck\ % " or :set makeprg=python\ %</code></pre> For long-running compilations and programs, running them directly in vim can be a bit cumbersome. In such cases, the :cfile</code> command can be used to read program output that has been written to a file: :cfile program_output.log</code></pre> The content will be used to populate the quickfix list just like the output of the :make</code> command. For more information see :h makeprg</code></a> and :h cfile</code></a>. The errorformat</code> option</h3> The errorformat</code> option, in turn, contains one or more regex-like parsing rules used to extract the source code location and other metadata from the :make</code> output or :cfile</code>. For example, consider the output of the aforementioned verilator</code> tool: %Warning-DECLFILENAME: looong_path/tc_clk.sv:11:8: Filename 'tc_clk' does not match MODULE name: 'tc_clk_and2' %Error-PINCONNECTEMPTY: other_path/trip_counter.sv:43:10: Instance pin connected by name with empty reference: 'overflow_o'</code></pre> A parsing rule consists of literal text and %</code>-prefixed placeholders. For the above, a basic rule might look something like this: :set errorformat=%%%t%*[a-zA-Z]-%*[^:]:\ %f:%l:%c:\ %m</code></pre> It consists of the following components: Component</th> Function</th></tr></thead> %%</code></td> Matches a single %</code> character.</td></tr> %t</code></td> Matches a single character which determines the error type. (Error, Warning, Info, Note)</td></tr> %*[a-zA-Z]</code></td> Matches one or more lower or uppercase letters. This "consumes" the rest of Error, Warning, Info, or Note.</td></tr> -</code></td> Matches a single -</code> character.</td></tr> %*[^:]</code></td> Matches one or more characters that are not a :</code>.</td></tr> :</code></td> Matches a single :</code> character.</td></tr> \ </code></td> Matches a single space ( </code>).</td></tr> %f</code></td> Matches a file path.</td></tr> %l</code></td> Matches a line number.</td></tr> %c</code></td> Matches a column number.</td></tr> %m</code></td> Matches an error message (a string).</td></tr> </tbody></table> :h error-file-format</code></a> contains documentation about how errorformat</code> strings are interpreted, including many more placeholders and tools. Consider also having a look at existing compiler plugins as a reference (see below). The above errorformat</code> does not cover all possible verilator warnings and errors. See below for a more complete implementation that handles warnings without error code and without column. </blockquote> Compiler Plugins</h3> (Neo)vim ships a set of pre-configured makeprg</code> and errorformat</code> values for a number of common compilers and tools. These take the form of so-called compiler plugins. For a list of built-in compiler plugins, have a look at the runtime/compiler</code></a> folder of the (neo)vim source tree. For a list of compiler plugins available in your current (neo)vim instance you can run: :for f in globpath(&rtp, 'compiler/*.vim', 0, 1) | echo fnamemodify(f, ':t:r') | endfor</code></pre> In typical vim fashion, the set of compiler plugins spans from slightly older tools, such as different fortran</code> flavours, to slightly more modern tools such as gleam-build</code>. A few that might be of interest: cargo</code> and rustc</code> for rust development.</li> eslint</code> and tsc</code> for webdev.</li> tex</code> and typst</code> for typesetting.</li> </ul> And even modelsim_vcom</code>, which is the VHDL compiler in modelsim! It is worth having a look at the content of the compiler plugin file for a tool you are intending to use. Many of them feature extra options and settings you can control via global variables. For example, to determine the exact flags with which cargo</code> is called, the cargo</code> compiler plugin considers the g:cargo_makeprg_params</code> global: " runtime/compiler/cargo.vim: if exists('g:cargo_makeprg_params') execute 'CompilerSet makeprg=cargo\ '.escape(g:cargo_makeprg_params, ' \|"').'\ $*' else CompilerSet makeprg=cargo\ $* endif</code></pre>Custom Compiler Plugins: Verilator</h3> If you find yourself often parsing the output of a tool that is not yet included in (neo)vim's list of built-in compiler plugins, consider adding a custom compiler plugin in your configuration. On linux, new compiler plugins should be placed in $XDG_CONFIG_HOME/nvim/compiler/</code>, while overrides to existing compiler plugins go in $XDG_CONFIG_HOME/nvim/after/compiler/</code>. For example, on my machine, to create a new verilator</code> compiler plugin, I create ~/.config/nvim/compiler/verilator.vim</code> with the following content: " ~/.config/nvim/compiler/verilator.vim: " Verilator warnings always start with "%Error" or "%Warning", optionally directly " followed by an error code. If a location is known, it may be given with or " without column number. Examples of errors: " " "%Warning: ..msg.." " "%Error-DECLFORMAT: myfile:1: ..msg.." " "%Error-PINCONNECT: myfile:1:2: ..msg.." CompilerSet errorformat=%%%t%*[a-zA-Z]-%*[^:]:\ %f:%l:%c:\ %m, \%%%t%*[a-zA-Z]-%*[^:]:\ %f:%l:\ %m, \%%%t%*[a-zA-Z]:\ %f:%l:%c:\ %m, \%%%t%*[a-zA-Z]:\ %f:%l:\ %m,</code></pre> See :h write-compiler-plugin</code></a> for more info. Unfortunately, the %*[^:]</code> pattern used to match the error code causes it to not be shown in the quickfix list. Parsing it as a module (%o</code>) will make it visible in the quickfix list, but hide the file name: CompilerSet errorformat=%%%t%*[a-zA-Z]-%o:\ %f:%l:%c:\ %m, \%%%t%*[a-zA-Z]-%o:\ %f:%l:\ %m, \%%%t%*[a-zA-Z]:\ %f:%l:%c:\ %m, \%%%t%*[a-zA-Z]:\ %f:%l:\ %m,</code></pre></blockquote> Diagnostics</h2> If you instead prefer to display external warnings and errors as in-line diagnostics in the same style as LSP servers, that is also an option, but requires a bit of lua scripting. The vim.diagnostic</code> API</h3> To display a set of diagnostics, first create a namespace to contain them: local my_namespace = vim.api.nvim_create_namespace("my_namespace")</code></pre> Next, configure how the diagnostics in this namespace should be displayed: vim.diagnostic.config({ virtual_text = true, signs = true, underline = true, update_in_insert = false, }, my_namespace)</code></pre> Collect all your diagnostics for a given buffer into a table, and use vim.diagnostic.set()</code> to display them: local bufnr = 0 local diagnostics = { { bufnr = bufnr, -- buffer lnum = 10, -- line number col = 0, -- column severity = vim.diagnostic.severity.WARN, -- severity message = "Something went wrong!", -- message } } vim.diagnostic.set(my_namespace, bufnr, diagnostics, {})</code></pre> To remove all diagnostics, including before you re-apply a new set, use vim.diagnostic.reset()</code>: vim.diagnostic.reset(my_namespace)</code></pre>Implementation</h3> With this, you can write a lua function that parses any external source and displays them as nvim diagnostics. Have a look at the documentation of the tool you are using - many feature an option for generating the diagnostics information in a machine readable format. Verilator, for instance, can be instructed to write all errors and warnings to a JSON file with standard SARIF formatting: verilator --diagnostics-sarif --diagnostics-sarif-output log.json</code></pre> In addition to seeing the errors inline, I like to use the excellent trouble.nvim</a> to also show a quickfix-like pane with all diagnostics. If you prefer to use the quickfix list, you can also programatically insert the diagnostics there. This approach, while a little bit more work, has the advantage of being extremely flexible. For example, for my verilator output parsing, I added simple reload and filtering capabilities: " Parse + display verilator diagnostics file: :VerilatorDiag log.json " Reload diagnostics file: :VerilatorDiag " Only display diagnostics that contain the string "frontend", and remove any " "UNOPTFLAT" and "UNUSEDSIGNAL" diagnostics: :VerilatorDiagFilter frontend -UNOPTFLAT -UNUSEDSIGNAL " Reset/clear the diagnostics: :VerilatorDiagReset</code></pre>Notes & Resources</h2> You can find my complete setup in my neovim configuration here</a>. A self-contained verilator sarif output parser and diagnostic generator with filtering as described above follows below: local M = {} M.verilator_namespace = vim.api.nvim_create_namespace("diag_verilator") M.verilator_file = nil M.verilator_exclude_filters = {} M.verilator_include_filters = {} function M.filter_check(file, msg, severity) local severity_lower = string.lower(severity) local diag = file .. " " .. msg -- Reject based on exclude filters: for _, filter in ipairs(M.verilator_exclude_filters) do local filter_lower = string.lower(filter) if string.find(diag, filter) or string.find(severity_lower, filter_lower) then return false end end -- If any include filters are defined, check if we match one: if #M.verilator_include_filters > 0 then local any_filter_matches = false for _, filter in ipairs(M.verilator_include_filters) do local filter_lower = string.lower(filter) if string.find(diag, filter) or string.find(severity_lower, filter_lower) then any_filter_matches = true end end if not any_filter_matches then return false end end return true end function M.generate_diags(log_file) local file = io.open(log_file, "r") if not file then error("Could not open verilator sarif file: " .. log_file) return end local content = file:read("*all") file:close() local success, data = pcall(vim.json.decode, content) if not success then error("Invalid JSON/SARIF in file: " .. log_file) return end if not data["runs"] or #data["runs"] ~= 1 then error("Invalid JSON/SARIF in file - not exactly one run: " .. log_file) return end data = data["runs"][1] if not data["results"] then error("Invalid JSON/SARIF in file - no results: " .. log_file) return end data = data["results"] -- per-bufnr diagnostics: local diagnostics = {} -- Iterate through data: for _, result in ipairs(data) do local rule_id = "" if result["ruleId"] then rule_id = result["ruleId"] .. ": " end local message = rule_id .. (result["message"]["text"] or "No message") local level = vim.diagnostic.severity.INFO if result["level"] == "error" then level = vim.diagnostic.severity.ERROR elseif result["level"] == "warning" then level = vim.diagnostic.severity.WARN end if not result["locations"] or #result["locations"] == 0 then goto continue end local loc = result["locations"][1]["physicalLocation"] if not loc or not loc["artifactLocation"] or not loc["region"] then goto continue end local file_path = loc["artifactLocation"]["uri"]:gsub("^file://", "") local start_line = loc["region"]["startLine"] or 1 local start_column = (loc["region"]["startColumn"] or 1) - 1 if not M.filter_check(file_path, message, result["level"]) then goto continue end local bufnr = vim.fn.bufadd(file_path) if not bufnr then error("Error") return end if not diagnostics[bufnr] then diagnostics[bufnr] = {} end table.insert(diagnostics[bufnr], { bufnr = bufnr, lnum = start_line - 1, col = start_column, message = message, severity = level, source = "verilator", }) ::continue:: end -- Set Diagnostics, per-buffer: local cnt = 0 vim.diagnostic.reset(M.verilator_namespace) for bufnr, diags in pairs(diagnostics) do vim.diagnostic.set(M.verilator_namespace, bufnr, diags, {}) cnt = cnt + #diags end -- Notification: local filters = {} for _, f in ipairs(M.verilator_include_filters) do table.insert(filters, f) end for _, f in ipairs(M.verilator_exclude_filters) do table.insert(filters, "-" .. f) end local filters_str = "" if #filters ~= 0 then -- all filters joined by spaces: filters_str = "\nFilters: " .. table.concat(filters, " ") end vim.notify("Found " .. cnt .. " verilator diagnostics." .. filters_str) end function M.reload() if M.verilator_file then M.generate_diags(M.verilator_file) end end function M.cmd_diags(args) if #args.fargs == 0 then if not M.verilator_file then error("No verilator log file set.") return end M.generate_diags(M.verilator_file) else local abs_path = vim.fn.fnamemodify(args.args, ":p") M.verilator_file = abs_path M.generate_diags(abs_path) end end function M.cmd_reset() M.verilator_file = nil M.verilator_exclude_filters = {} M.verilator_include_filters = {} vim.diagnostic.reset(M.verilator_namespace) end function M.cmd_clear() vim.diagnostic.reset(M.verilator_namespace) end function M.cmd_filter(args) M.verilator_exclude_filters = {} M.verilator_include_filters = {} for _, arg in ipairs(args.fargs) do if vim.startswith(arg, "-") then table.insert(M.verilator_exclude_filters, arg:sub(2)) else table.insert(M.verilator_include_filters, arg) end end if M.verilator_file then M.generate_diags(M.verilator_file) end end function M.setup() vim.diagnostic.config({ virtual_text = true, signs = true, underline = true, update_in_insert = false, }, M.verilator_namespace) vim.api.nvim_create_user_command("VerilatorDiagReset", M.cmd_reset, { nargs = 0 }) vim.api.nvim_create_user_command("VerilatorDiagClear", M.cmd_clear, { nargs = 0 }) vim.api.nvim_create_user_command("VerilatorDiag", M.cmd_diags, { nargs = "?", complete = "file" }) vim.api.nvim_create_user_command("VerilatorDiagFilter", M.cmd_filter, { nargs = "*" }) end return M</code></pre> Managing project-specific NVIM configuration 2026-01-19T00:00:00+00:00 One size fits not quite all</h2> While my neovim configuration</a> works out of the box for most of the projects I work on, I have increasingly encountered situations where I need to adjust certain aspects on a per-project basis. For example, while doing some work with LLVM, I wanted to make use of the MLIR and TableGen LSP servers. While I could install these on my machine and add them to my main neovim configuration, it is in many ways much better to use the specific binaries built from the LLVM tree I am currently editing - that way any changes I make to, for example, an MLIR dialect, are immediately available in the MLIR LSP after a quick re-compile. There is nothing stopping me from adding such edge-case checks to my main configuration - but that does not scale nicely and inevitably leaves behind a whole bunch of configuration snippets I don't actively use, but don't want to delete in case I go back to a project in the future. I would much prefer a strategy that allows me to keep such per-project configuration with the actual project. As with anything related to neovim configuration there are about 50 different ways this can be achieved, and because neovim is usually configured with executable code instead of declarative config files, there are a few gotchas that might not be immediately obvious. Therefore I thought it might be useful to quickly write up how the setup I landed on works, and my thoughts behind why I built it in this way. Notable built-in features & plugins</h2> First, a quick overview of some built-in features and plugins that are related to this subject: (Neo)Vim's exrc</code> option</h3> The exrc</code> option is the historical solution to this problem, dating all the way back to vi</code>: set exrc</code></pre> On startup, when this option is set, vim will look for a .vimrc</code> or .exrc</code> vimscript file in the current directory, while neovim will look for a .nvimrc</code> or .exrc</code> vimscript file, or a .nvim.lua</code> lua script file. If one such file is found, after the system and main user configuration is loaded, (neo)vim will :source</code> this file, executing whatever code it contains. Without any additional security mechanism, this option will execute arbitrary code when opening your editor without any prompt or confirmation. NeoVim features some mitigation to make this less risky - see below. </blockquote> Have a look at :h exrc</code></a> for more information. NeoVim's :trust</code> list</h3> As executing arbitrary code when opening your editor in some repository you just cloned from the internet is not an amazing idea, neovim introduced vim.secure.read()</code> and the associated trust</code> list in v0.9.0</code> (released in 2022 - f1922e7</code></a>). When attempting to read a file for the first time using vim.secure.read()</code>, neovim will prompt the user to view the file and explicitly trust it: :lua vim.secure.read("README.md") exrc: Found untrusted code. To enable it, choose (v)iew then run `:trust`: /home/schilkp/repos/schilkp.github.io/README.md [i]gnore, (v)iew, (d)eny:</code></pre> Only if the user actually marks the file as trusted, will the content be read. The location and name of the file, a sha256 hash of its content, and the user decision will be stored in the trust</code> list, located at $XDG_STATE_HOME/nvim/trust</code>: d84ce812f0b22bf6fd2502d9deadbeef2229931192efef1abc0002091b40 /home/schilkp/repos/schilkp.github.io/README.md ! /home/schilkp/Downloads/random_project/sketchy_file_i_dont_trust.lua</code></pre> After it has been trusted, successive secure reads of this file will complete without a user prompt, unless the file content or location has changed. In neovim, vim.secure.read()</code> is used for reading the content of any file discovered and sourced through the exrc</code> option mechanism, making it significantly less reckless (294910a</code></a>). See :h vim.secure</code></a> for more information. A long list of plugins</h3> Per-project configuration is a common need, and there are also quite a few plugins available to help you manage it, including tpope/vim-projectionist</code></a>, klen/nvim-config-local</code></a>, and direnv/direnv</code></a>. My setup</h2> With the vim.secure.read()</code> mechanism, the exrc</code> option in neovim is already fairly close to what I want. Its one major limitation for my use is that it is sourced after my main configuration and therefore after all plugins are configured and loaded. This makes it tricky to do things like adding new plugins, or disabling LSP servers and features that my main configuration enables - by the time a .nvim.lua</code> file is sourced, all this is already done. For a similar reason, using one of the many plugins is also not so attractive, as I ideally want my local configuration to be available before my plugin manager sources all plugins. Instead, I opted to implement a simple version of the exrc</code> option directly in my configuration: --- local_config.lua local M = {} M.CONFIG_FILE_NAMES = { ".schilk.nvim.lua" } --- Look for local config file function M.lookup() for _, filename in ipairs(M.CONFIG_FILE_NAMES) do filename = vim.fn.findfile(filename, ".;") if filename ~= "" then return vim.fn.fnamemodify(filename, ":p") end end end --- Find & load local config file function M.source() local file = M.lookup() if not file or file == "" then return end local content = vim.secure.read(file) --[[@as string|nil]] if not content then vim.notify("[local_config]: local config file found but not trusted!", vim.log.levels.WARN) return end local config_fn, err_load = loadstring(content, "@" .. file) if not config_fn then vim.notify("[local_config]: failed to load local config file: " .. err_load, vim.log.levels.ERROR) return end local success, err_call = pcall(config_fn) if not success then vim.notify("[local_config]: failed to load local config file: " .. err_call, vim.log.levels.ERROR) return end vim.notify("[local_config]: loaded local config file", vim.log.levels.INFO) end return M</code></pre> This module looks for a file called .schilk.nvim.lua</code> in the current or any parent directories. If one is found the vim.secure.read()</code> function is used to load it, allowing me to manually review and approve the content before it is actually sourced. In my main init.lua</code>, I can then use this module even before my plugin manager lazy</code> is initialized: -- init.lua require("local_config").source()</code></pre> Because I want the vim.notify</code> status messages to show up in the notification feed of the fidget</code></a> plugin instead of the default nvim message list, I tend to wrap the calls to vim.notify</code> above in a vim.defer_fn</code> with a short timeout, to make them appear after the fidget</code> has been loaded: local function defer_notif(msg, level) vim.defer_fn(function() vim.notify(msg, level) end, 250) end </code></pre> That workaround is very hacky - I know. Local Config Files</h3> While the config file can contain arbitrary code, most of the time I want to change some setting or behaviour of my main configuration. I do this by storing information in the global _G</code> table, which my main configuration then checks for and applies if it exists. For example, to install an additional plugin, I place one or more lazy</code> plugin specs in _G.SCHILK_LOCAL_PLUGINS</code>: -- Extra plugins to be inserted into the lazy spec _G.SCHILK_LOCAL_PLUGINS = { 'schilkp/my_cool_plugin' } </code></pre> In my main configuration, I then inject any plugins into the default list of plugin specs before starting the plugin manager. local plugins = { -- ... list of plugins ... } -- Inject local plugins: _G.SCHILK_LOCAL_PLUGINS = _G.SCHILK_LOCAL_PLUGINS or {} if _G.SCHILK_LOCAL_PLUGINS then for _, plugin in ipairs(_G.SCHILK_LOCAL_PLUGINS) do table.insert(plugins, plugin) end end require("lazy").setup(plugins)</code></pre> For reference, here are some of the things which I often do in my local config files: Install and enable additional plugins, as shown above.</li> Enable additional LSP servers from nvim-lspconfig</code>.</li> Disable LSP servers that I have usually enabled.</li> Configure local, project-specific LSP servers, such as the aforementioned MLIR and TableGen LSPs.</li> </ul> Shareability</h3> The one big downside of this approach is that it is very tightly coupled to my neovim configuration, and therefore these config files are not very useful to anyone else. Unfortunately, because neovim configurations are all so incredibly different, I don't see a great way of changing that. This is reflected in my choice to name the files .schilk.nvim.lua</code>: I doubt anyone else will directly use them. For this reason, I also typically don't check them into project git repositories. As I doubt that the LLVM project will be interested in a patch that adds .schilk.nvim.lua</code> to their .gitignore</code>, to avoid having to keep juggling that change around locally, I just ignore these files in all git repos using a global .gitignore</code>: # ~/.gitconfig: [core] excludesfile = /home/schilkp/.gitignore_global # ~/.gitignore_global: .schilk.nvim.lua</code></pre>Notes</h2> You can find my complete setup directly in my neovim configuration here</a>. Changes</h2> 13-03-2026</code>: Fixed the version of nvim</code> in which vim.secure.read()</code> was introduced - thanks, justinmk!</li> Updated the example snippet to use the actual content read by vim.secure.read()</code> instead of just using said function to check if the file is trusted before sourcing from the file.</li> Add explanation about deferred notify</code> calls.</li> </ul> </li> </ul>

Component</th>	Function</th></tr></thead>
`%%</code></td>`	Matches a single `%</code> character.</td></tr>`
`%t</code></td>`	Matches a single character which determines the error type. (E</strong>rror, W</strong>arning, I</strong>nfo, N</strong>ote)</td></tr>
`%*[a-zA-Z]</code></td>`	Matches one or more lower or uppercase letters. This "consumes" the rest of Error</strong>, Warning</strong>, Info</strong>, or Note</strong>.</td></tr>
`-</code></td>`	Matches a single `-</code> character.</td></tr>`
`%*[^:]</code></td>`	Matches one or more characters that are not a `:</code>.</td></tr>`
`:</code></td>`	Matches a single `:</code> character.</td></tr>`
`\ </code></td>`	Matches a single space (`</code>).</td></tr>`
`%f</code></td>`	Matches a file path.</td></tr>
`%l</code></td>`	Matches a line number.</td></tr>
`%c</code></td>`	Matches a column number.</td></tr>
`%m</code></td>`	Matches an error message (a string).</td></tr> </tbody></table> `:h error-file-format</code></a> contains documentation about how errorformat</code> strings are interpreted, including many more placeholders and tools. Consider also having a look at existing compiler plugins as a reference (see below).</p>` `The above errorformat</code> does not cover all possible verilator warnings and errors. See below for a more complete implementation that handles warnings without error code and without column.</p> </blockquote>` `Compiler Plugins</h3> (Neo)vim ships a set of pre-configured makeprg</code> and errorformat</code> values for a number of common compilers and tools. These take the form of so-called compiler plugins.</p>`For a list of built-in compiler plugins, have a look at the runtime/compiler</code></a> folder of the (neo)vim source tree. For a list of compiler plugins available in your current (neo)vim instance you can run:</p> :</span>for</span> f </span>in</span> globpath</span>(</span>&rtp</span>,</span> 'compiler/.vim'</span>,</span> 0</span>,</span> 1</span>) \| </span>echo</span> fnamemodify</span>(f,</span> ':t:r'</span>) \| </span>endfor</span></span></code></pre> In typical vim fashion, the set of compiler plugins spans from slightly older tools, such as different fortran</code> flavours, to slightly more modern tools such as gleam-build</code>.</p> A few that might be of interest:</p> cargo</code> and rustc</code> for rust development.</li> eslint</code> and tsc</code> for webdev.</li> tex</code> and typst</code> for typesetting.</li> </ul> And even modelsim_vcom</code>, which is the VHDL compiler in modelsim!</p> It is worth having a look at the content of the compiler plugin file for a tool you are intending to use. Many of them feature extra options and settings you can control via global variables. For example, to determine the exact flags with which cargo</code> is called, the cargo</code> compiler plugin considers the g:cargo_makeprg_params</code> global:</p> " runtime/compiler/cargo.vim:</span></span> if</span> exists</span>(</span>'g:cargo_makeprg_params'</span>)</span></span> execute</span> 'CompilerSet makeprg=cargo\ '</span>.escape</span>(g:cargo_makeprg_params,</span> ' \\|"'</span>).</span>'\ $'</span></span> else</span></span> CompilerSet </span>makeprg</span>=</span>cargo</span>\</span> $</span></span> endif</span></span></code></pre>Custom Compiler Plugins: Verilator</h3> If you find yourself often parsing the output of a tool that is not yet included in (neo)vim's list of built-in compiler plugins, consider adding a custom compiler plugin in your configuration.</p> On linux, new compiler plugins should be placed in $XDG_CONFIG_HOME/nvim/compiler/</code>, while overrides to existing compiler plugins go in $XDG_CONFIG_HOME/nvim/after/compiler/</code>.</p> For example, on my machine, to create a new verilator</code> compiler plugin, I create ~/.config/nvim/compiler/verilator.vim</code> with the following content:</p> " ~/.config/nvim/compiler/verilator.vim:</span></span> " Verilator warnings always start with "%Error" or "%Warning", optionally directly</span></span> " followed by an error code. If a location is known, it may be given with or</span></span> " without column number. Examples of errors:</span></span> "</span></span> " "%Warning: ..msg.."</span></span> " "%Error-DECLFORMAT: myfile:1: ..msg.."</span></span> " "%Error-PINCONNECT: myfile:1:2: ..msg.."</span></span> CompilerSet </span>errorformat</span>=</span>%%%t%[a-zA-Z]-%[^:]:</span>\</span> %f:%l:%c:</span>\</span> %m,</span></span> \</span>%%%t%[a-zA-Z]-%[^:]:</span>\</span> %f:%l:</span>\</span> %m,</span></span> \</span>%%%t%[a-zA-Z]:</span>\</span> %f:%l:%c:</span>\</span> %m,</span></span> \</span>%%%t%[a-zA-Z]:</span>\</span> %f:%l:</span>\</span> %m,</span></span></code></pre> See :h write-compiler-plugin</code></a> for more info.</p> Unfortunately, the %[^:]</code> pattern used to match the error code causes it to not be shown in the quickfix list. Parsing it as a module (%o</code>) will make it visible in the quickfix list, but hide the file name:</p> CompilerSet </span>errorformat</span>=</span>%%%t%[a-zA-Z]-%o:</span>\</span> %f:%l:%c:</span>\</span> %m,</span></span> \</span>%%%t%[a-zA-Z]-%o:</span>\</span> %f:%l:</span>\</span> %m,</span></span> \</span>%%%t%[a-zA-Z]:</span>\</span> %f:%l:%c:</span>\</span> %m,</span></span> \</span>%%%t%[a-zA-Z]:</span>\</span> %f:%l:</span>\</span> %m,</span></span></code></pre></blockquote> Diagnostics</h2> If you instead prefer to display external warnings and errors as in-line diagnostics in the same style as LSP servers, that is also an option, but requires a bit of lua scripting.</p> The vim.diagnostic</code> API</h3> To display a set of diagnostics, first create a namespace to contain them:</p> local</span> my_namespace</span> =</span> vim.</span>api</span>.</span>nvim_create_namespace</span>(</span>"my_namespace"</span>)</span></span></code></pre> Next, configure how the diagnostics in this namespace should be displayed:</p> vim.</span>diagnostic</span>.</span>config</span>({</span></span> virtual_text</span> =</span> true</span>,</span></span> signs</span> =</span> true</span>,</span></span> underline</span> =</span> true</span>,</span></span> update_in_insert</span> =</span> false</span>,</span></span> }, my_namespace)</span></span></code></pre> Collect all your diagnostics for a given buffer into a table, and use vim.diagnostic.set()</code> to display them:</p> local</span> bufnr</span> =</span> 0</span></span> local</span> diagnostics</span> =</span> {</span></span> {</span></span> bufnr</span> =</span> bufnr, </span>-- buffer</span></span> lnum</span> =</span> 10</span>, </span>-- line number</span></span> col</span> =</span> 0</span>, </span>-- column</span></span> severity</span> =</span> vim.</span>diagnostic</span>.</span>severity</span>.</span>WARN</span>, </span>-- severity</span></span> message</span> =</span> "Something went wrong!"</span>, </span>-- message</span></span> }</span></span> }</span></span> vim.</span>diagnostic</span>.</span>set</span>(my_namespace, bufnr, diagnostics, {})</span></span></code></pre> To remove all diagnostics, including before you re-apply a new set, use vim.diagnostic.reset()</code>:</p> vim.</span>diagnostic</span>.</span>reset</span>(my_namespace)</span></span></code></pre>Implementation</h3> With this, you can write a lua function that parses any external source and displays them as nvim diagnostics.</p> Have a look at the documentation of the tool you are using - many feature an option for generating the diagnostics information in a machine readable format. Verilator, for instance, can be instructed to write all errors and warnings to a JSON file with standard SARIF formatting:</p> verilator</span> --diagnostics-sarif --diagnostics-sarif-output</span> log.json</span></span></code></pre> In addition to seeing the errors inline, I like to use the excellent trouble.nvim</a> to also show a quickfix-like pane with all diagnostics. If you prefer to use the quickfix list, you can also programatically insert the diagnostics there.</p> This approach, while a little bit more work, has the advantage of being extremely flexible. For example, for my verilator output parsing, I added simple reload and filtering capabilities:</p> " Parse + display verilator diagnostics file:</span></span> :VerilatorDiag log.json</span></span> </span> " Reload diagnostics file:</span></span> :VerilatorDiag</span></span> </span> " Only display diagnostics that contain the string "frontend", and remove any</span></span> " "UNOPTFLAT" and "UNUSEDSIGNAL" diagnostics:</span></span> :VerilatorDiagFilter frontend -UNOPTFLAT -UNUSEDSIGNAL</span></span> </span> " Reset/clear the diagnostics:</span></span> :VerilatorDiagReset</span></span></code></pre>Notes & Resources</h2> You can find my complete setup in my neovim configuration here</a>.</p> A self-contained verilator sarif output parser and diagnostic generator with filtering as described above follows below:</p> local</span> M</span> =</span> {}</span></span> </span> M.</span>verilator_namespace</span> =</span> vim.</span>api</span>.</span>nvim_create_namespace</span>(</span>"diag_verilator"</span>)</span></span> M.</span>verilator_file</span> =</span> nil</span></span> M.</span>verilator_exclude_filters</span> =</span> {}</span></span> M.</span>verilator_include_filters</span> =</span> {}</span></span> </span> function</span> M</span>.</span>filter_check</span>(file, msg, severity)</span></span> local</span> severity_lower</span> =</span> string.lower</span>(severity)</span></span> local</span> diag</span> =</span> file</span> ..</span> " " </span>..</span> msg</span></span> </span> -- Reject based on exclude filters:</span></span> for</span> _, filter</span> in</span> ipairs</span>(M.</span>verilator_exclude_filters</span>) </span>do</span></span> local</span> filter_lower</span> =</span> string.lower</span>(filter)</span></span> if</span> string.find</span>(diag, filter) </span>or</span> string.find</span>(severity_lower, filter_lower) </span>then</span></span> return</span> false</span></span> end</span></span> end</span></span> </span> -- If any include filters are defined, check if we match one:</span></span> if #</span>M.</span>verilator_include_filters</span> ></span> 0</span> then</span></span> local</span> any_filter_matches</span> =</span> false</span></span> for</span> _, filter</span> in</span> ipairs</span>(M.</span>verilator_include_filters</span>) </span>do</span></span> local</span> filter_lower</span> =</span> string.lower</span>(filter)</span></span> if</span> string.find</span>(diag, filter) </span>or</span> string.find</span>(severity_lower, filter_lower) </span>then</span></span> any_filter_matches</span> =</span> true</span></span> end</span></span> end</span></span> </span> if not</span> any_filter_matches</span> then</span></span> return</span> false</span></span> end</span></span> end</span></span> </span> return</span> true</span></span> end</span></span> </span> function</span> M</span>.</span>generate_diags</span>(log_file)</span></span> local</span> file</span> =</span> io.open</span>(log_file, </span>"r"</span>)</span></span> if not</span> file</span> then</span></span> error</span>(</span>"Could not open verilator sarif file: " </span>..</span> log_file)</span></span> return</span></span> end</span></span> </span> local</span> content</span> =</span> file</span>:</span>read</span>(</span>"all"</span>)</span></span> file</span>:</span>close</span>()</span></span> local</span> success, data</span> =</span> pcall</span>(vim.</span>json</span>.</span>decode</span>, content)</span></span> if not</span> success</span> then</span></span> error</span>(</span>"Invalid JSON/SARIF in file: " </span>..</span> log_file)</span></span> return</span></span> end</span></span> </span> if not</span> data[</span>"runs"</span>] </span>or #</span>data[</span>"runs"</span>] </span>~=</span> 1</span> then</span></span> error</span>(</span>"Invalid JSON/SARIF in file - not exactly one run: " </span>..</span> log_file)</span></span> return</span></span> end</span></span> data</span> =</span> data[</span>"runs"</span>][</span>1</span>]</span></span> </span> if not</span> data[</span>"results"</span>] </span>then</span></span> error</span>(</span>"Invalid JSON/SARIF in file - no results: " </span>..</span> log_file)</span></span> return</span></span> end</span></span> data</span> =</span> data[</span>"results"</span>]</span></span> </span> -- per-bufnr diagnostics:</span></span> local</span> diagnostics</span> =</span> {}</span></span> </span> -- Iterate through data:</span></span> for</span> _, result</span> in</span> ipairs</span>(data) </span>do</span></span> local</span> rule_id</span> =</span> ""</span></span> if</span> result[</span>"ruleId"</span>] </span>then</span></span> rule_id</span> =</span> result[</span>"ruleId"</span>] </span>..</span> ": "</span></span> end</span></span> local</span> message</span> =</span> rule_id</span> ..</span> (result[</span>"message"</span>][</span>"text"</span>] </span>or</span> "No message"</span>)</span></span> </span> local</span> level</span> =</span> vim.</span>diagnostic</span>.</span>severity</span>.</span>INFO</span></span> if</span> result[</span>"level"</span>] </span>==</span> "error" </span>then</span></span> level</span> =</span> vim.</span>diagnostic</span>.</span>severity</span>.</span>ERROR</span></span> elseif</span> result[</span>"level"</span>] </span>==</span> "warning" </span>then</span></span> level</span> =</span> vim.</span>diagnostic</span>.</span>severity</span>.</span>WARN</span></span> end</span></span> </span> if not</span> result[</span>"locations"</span>] </span>or #</span>result[</span>"locations"</span>] </span>==</span> 0</span> then</span></span> goto</span> continue</span></span> end</span></span> </span> local</span> loc</span> =</span> result[</span>"locations"</span>][</span>1</span>][</span>"physicalLocation"</span>]</span></span> </span> if not</span> loc</span> or not</span> loc[</span>"artifactLocation"</span>] </span>or not</span> loc[</span>"region"</span>] </span>then</span></span> goto</span> continue</span></span> end</span></span> </span> local</span> file_path</span> =</span> loc[</span>"artifactLocation"</span>][</span>"uri"</span>]:</span>gsub</span>(</span>"^file://"</span>, </span>""</span>)</span></span> local</span> start_line</span> =</span> loc[</span>"region"</span>][</span>"startLine"</span>] </span>or</span> 1</span></span> local</span> start_column</span> =</span> (loc[</span>"region"</span>][</span>"startColumn"</span>] </span>or</span> 1</span>) </span>-</span> 1</span></span> </span> if not</span> M.</span>filter_check</span>(file_path, message, result[</span>"level"</span>]) </span>then</span></span> goto</span> continue</span></span> end</span></span> </span> local</span> bufnr</span> =</span> vim.</span>fn</span>.</span>bufadd</span>(file_path)</span></span> if not</span> bufnr</span> then</span></span> error</span>(</span>"Error"</span>)</span></span> return</span></span> end</span></span> </span> if not</span> diagnostics[bufnr] </span>then</span></span> diagnostics[bufnr] </span>=</span> {}</span></span> end</span></span> </span> table.insert</span>(diagnostics[bufnr], {</span></span> bufnr</span> =</span> bufnr,</span></span> lnum</span> =</span> start_line</span> -</span> 1</span>,</span></span> col</span> =</span> start_column,</span></span> message</span> =</span> message,</span></span> severity</span> =</span> level,</span></span> source</span> =</span> "verilator"</span>,</span></span> })</span></span> </span> ::continue::</span></span> end</span></span> </span> -- Set Diagnostics, per-buffer:</span></span> local</span> cnt</span> =</span> 0</span></span> vim.</span>diagnostic</span>.</span>reset</span>(M.</span>verilator_namespace</span>)</span></span> for</span> bufnr, diags</span> in</span> pairs</span>(diagnostics) </span>do</span></span> vim.</span>diagnostic</span>.</span>set</span>(M.</span>verilator_namespace</span>, bufnr, diags, {})</span></span> cnt</span> =</span> cnt</span> + #</span>diags</span></span> end</span></span> </span> -- Notification:</span></span> local</span> filters</span> =</span> {}</span></span> for</span> _, f</span> in</span> ipairs</span>(M.</span>verilator_include_filters</span>) </span>do</span></span> table.insert</span>(filters, f)</span></span> end</span></span> for</span> _, f</span> in</span> ipairs</span>(M.</span>verilator_exclude_filters</span>) </span>do</span></span> table.insert</span>(filters, </span>"-" </span>..</span> f)</span></span> end</span></span> local</span> filters_str</span> =</span> ""</span></span> if #</span>filters</span> ~=</span> 0</span> then</span></span> -- all filters joined by spaces:</span></span> filters_str</span> =</span> "</span>\n</span>Filters: " </span>..</span> table.concat</span>(filters, </span>" "</span>)</span></span> end</span></span> vim.</span>notify</span>(</span>"Found " </span>..</span> cnt</span> ..</span> " verilator diagnostics." </span>..</span> filters_str)</span></span> end</span></span> </span> function</span> M</span>.</span>reload</span>()</span></span> if</span> M.</span>verilator_file</span> then</span></span> M.</span>generate_diags</span>(M.</span>verilator_file</span>)</span></span> end</span></span> end</span></span> </span> function</span> M</span>.</span>cmd_diags</span>(args)</span></span> if #</span>args.</span>fargs</span> ==</span> 0</span> then</span></span> if not</span> M.</span>verilator_file</span> then</span></span> error</span>(</span>"No verilator log file set."</span>)</span></span> return</span></span> end</span></span> M.</span>generate_diags</span>(M.</span>verilator_file</span>)</span></span> else</span></span> local</span> abs_path</span> =</span> vim.</span>fn</span>.</span>fnamemodify</span>(args.</span>args</span>, </span>":p"</span>)</span></span> M.</span>verilator_file</span> =</span> abs_path</span></span> M.</span>generate_diags</span>(abs_path)</span></span> end</span></span> end</span></span> </span> function</span> M</span>.</span>cmd_reset</span>()</span></span> M.</span>verilator_file</span> =</span> nil</span></span> M.</span>verilator_exclude_filters</span> =</span> {}</span></span> M.</span>verilator_include_filters</span> =</span> {}</span></span> vim.</span>diagnostic</span>.</span>reset</span>(M.</span>verilator_namespace</span>)</span></span> end</span></span> </span> function</span> M</span>.</span>cmd_clear</span>()</span></span> vim.</span>diagnostic</span>.</span>reset</span>(M.</span>verilator_namespace</span>)</span></span> end</span></span> </span> function</span> M</span>.</span>cmd_filter</span>(args)</span></span> M.</span>verilator_exclude_filters</span> =</span> {}</span></span> M.</span>verilator_include_filters</span> =</span> {}</span></span> for</span> _, arg</span> in</span> ipairs</span>(args.</span>fargs</span>) </span>do</span></span> if</span> vim.</span>startswith</span>(arg, </span>"-"</span>) </span>then</span></span> table.insert</span>(M.</span>verilator_exclude_filters</span>, </span>arg</span>:</span>sub</span>(</span>2</span>))</span></span> else</span></span> table.insert</span>(M.</span>verilator_include_filters</span>, arg)</span></span> end</span></span> end</span></span> if</span> M.</span>verilator_file</span> then</span></span> M.</span>generate_diags</span>(M.</span>verilator_file</span>)</span></span> end</span></span> end</span></span> </span> function</span> M</span>.</span>setup</span>()</span></span> vim.</span>diagnostic</span>.</span>config</span>({</span></span> virtual_text</span> =</span> true</span>,</span></span> signs</span> =</span> true</span>,</span></span> underline</span> =</span> true</span>,</span></span> update_in_insert</span> =</span> false</span>,</span></span> }, M.</span>verilator_namespace</span>)</span></span> vim.</span>api</span>.</span>nvim_create_user_command</span>(</span>"VerilatorDiagReset"</span>, M.</span>cmd_reset</span>, { nargs</span> =</span> 0</span> })</span></span> vim.</span>api</span>.</span>nvim_create_user_command</span>(</span>"VerilatorDiagClear"</span>, M.</span>cmd_clear</span>, { nargs</span> =</span> 0</span> })</span></span> vim.</span>api</span>.</span>nvim_create_user_command</span>(</span>"VerilatorDiag"</span>, M.</span>cmd_diags</span>, { nargs</span> =</span> "?"</span>, complete</span> =</span> "file" </span>})</span></span> vim.</span>api</span>.</span>nvim_create_user_command</span>(</span>"VerilatorDiagFilter"</span>, M.</span>cmd_filter</span>, { nargs</span> =</span> "" </span>})</span></span> end</span></span> </span> return</span> M</span></span></code></pre> Managing project-specific NVIM configuration 2026-01-19T00:00:00+00:00 One size fits not quite all</h2> While my neovim configuration</a> works out of the box for most of the projects I work on, I have increasingly encountered situations where I need to adjust certain aspects on a per-project basis.</p> For example, while doing some work with LLVM, I wanted to make use of the MLIR and TableGen LSP servers. While I could install these on my machine and add them to my main neovim configuration, it is in many ways much better to use the specific binaries built from the LLVM tree I am currently editing - that way any changes I make to, for example, an MLIR dialect, are immediately available in the MLIR LSP after a quick re-compile.</p> There is nothing stopping me from adding such edge-case checks to my main configuration - but that does not scale nicely and inevitably leaves behind a whole bunch of configuration snippets I don't actively use, but don't want to delete in case I go back to a project in the future. I would much prefer a strategy that allows me to keep such per-project configuration with the actual project.</p> As with anything related to neovim configuration there are about 50 different ways this can be achieved, and because neovim is usually configured with executable code instead of declarative config files, there are a few gotchas that might not be immediately obvious. Therefore I thought it might be useful to quickly write up how the setup I landed on works, and my thoughts behind why I built it in this way.</p> Notable built-in features & plugins</h2> First, a quick overview of some built-in features and plugins that are related to this subject:</p> (Neo)Vim's exrc</code> option</h3> The exrc</code> option is the historical solution to this problem, dating all the way back to vi</code>:</p> set</span> exrc</span></span></code></pre> On startup, when this option is set, vim will look for a .vimrc</code> or .exrc</code> vimscript file in the current directory, while neovim will look for a .nvimrc</code> or .exrc</code> vimscript file, or a .nvim.lua</code> lua script file. If one such file is found, after the system and main user configuration is loaded, (neo)vim will :source</code> this file, executing whatever code it contains.</p> Without any additional security mechanism, this option will execute arbitrary code when opening your editor without any prompt or confirmation. NeoVim features some mitigation to make this less risky - see below.</p> </blockquote> Have a look at :h exrc</code></a> for more information.</p> NeoVim's :trust</code> list</h3> As executing arbitrary code when opening your editor in some repository you just cloned from the internet is not an amazing idea, neovim introduced vim.secure.read()</code> and the associated trust</code> list in v0.9.0</code> (released in 2022 - f1922e7</code></a>).</p> When attempting to read a file for the first time using vim.secure.read()</code>, neovim will prompt the user to view the file and explicitly trust it:</p> :lua vim.secure.read("README.md")</span></span> exrc: Found untrusted code. To enable it, choose (v)iew then run `:trust`:</span></span> /home/schilkp/repos/schilkp.github.io/README.md</span></span> [i]gnore, (v)iew, (d)eny:</span></span></code></pre> Only if the user actually marks the file as trusted, will the content be read.</p> The location and name of the file, a sha256 hash of its content, and the user decision will be stored in the trust</code> list, located at $XDG_STATE_HOME/nvim/trust</code>:</p> d84ce812f0b22bf6fd2502d9deadbeef2229931192efef1abc0002091b40 /home/schilkp/repos/schilkp.github.io/README.md</span></span> ! /home/schilkp/Downloads/random_project/sketchy_file_i_dont_trust.lua</span></span></code></pre> After it has been trusted, successive secure reads of this file will complete without a user prompt, unless the file content or location has changed. In neovim, vim.secure.read()</code> is used for reading the content of any file discovered and sourced through the exrc</code> option mechanism, making it significantly less reckless (294910a</code></a>).</p> See :h vim.secure</code></a> for more information.</p> A long list of plugins</h3> Per-project configuration is a common need, and there are also quite a few plugins available to help you manage it, including tpope/vim-projectionist</code></a>, klen/nvim-config-local</code></a>, and direnv/direnv</code></a>.</p> My setup</h2> With the vim.secure.read()</code> mechanism, the exrc</code> option in neovim is already fairly close to what I want. Its one major limitation for my use is that it is sourced after</em> my main configuration and therefore after all plugins are configured and loaded. This makes it tricky to do things like adding new plugins, or disabling LSP servers and features that my main configuration enables - by the time a .nvim.lua</code> file is sourced, all this is already done.</p> For a similar reason, using one of the many plugins is also not so attractive, as I ideally want my local configuration to be available before my plugin manager sources all plugins.</p> Instead, I opted to implement a simple version of the exrc</code> option directly in my configuration:</p> --- local_config.lua</span></span> local</span> M</span> =</span> {}</span></span> </span> M.</span>CONFIG_FILE_NAMES</span> =</span> { </span>".schilk.nvim.lua" </span>}</span></span> </span> --- Look for local config file</span></span> function</span> M</span>.</span>lookup</span>()</span></span> for</span> _, filename</span> in</span> ipairs</span>(M.</span>CONFIG_FILE_NAMES</span>) </span>do</span></span> filename</span> =</span> vim.</span>fn</span>.</span>findfile</span>(filename, </span>".;"</span>)</span></span> if</span> filename</span> ~=</span> "" </span>then</span></span> return</span> vim.</span>fn</span>.</span>fnamemodify</span>(filename, </span>":p"</span>)</span></span> end</span></span> end</span></span> end</span></span> </span> --- Find & load local config file</span></span> function</span> M</span>.</span>source</span>()</span></span> local</span> file</span> =</span> M.</span>lookup</span>()</span></span> if not</span> file</span> or</span> file</span> ==</span> "" </span>then</span></span> return</span></span> end</span></span> </span> local</span> content</span> =</span> vim.</span>secure</span>.</span>read</span>(file) </span>--[[@as string\|nil]]</span></span> if not</span> content</span> then</span></span> vim.</span>notify</span>(</span>"[local_config]: local config file found but not trusted!"</span>, vim.</span>log</span>.</span>levels</span>.</span>WARN</span>)</span></span> return</span></span> end</span></span> </span> local</span> config_fn, err_load</span> =</span> loadstring</span>(content, </span>"@" </span>..</span> file)</span></span> if not</span> config_fn</span> then</span></span> vim.</span>notify</span>(</span>"[local_config]: failed to load local config file: " </span>..</span> err_load, vim.</span>log</span>.</span>levels</span>.</span>ERROR</span>)</span></span> return</span></span> end</span></span> </span> local</span> success, err_call</span> =</span> pcall</span>(config_fn)</span></span> if not</span> success</span> then</span></span> vim.</span>notify</span>(</span>"[local_config]: failed to load local config file: " </span>..</span> err_call, vim.</span>log</span>.</span>levels</span>.</span>ERROR</span>)</span></span> return</span></span> end</span></span> </span> vim.</span>notify</span>(</span>"[local_config]: loaded local config file"</span>, vim.</span>log</span>.</span>levels</span>.</span>INFO</span>)</span></span> end</span></span> </span> return</span> M</span></span></code></pre> This module looks for a file called .schilk.nvim.lua</code> in the current or any parent directories. If one is found the vim.secure.read()</code> function is used to load it, allowing me to manually review and approve the content before it is actually sourced.</p> In my main init.lua</code>, I can then use this module even before my plugin manager lazy</code> is initialized:</p> -- init.lua</span></span> require</span>(</span>"local_config"</span>).</span>source</span>()</span></span></code></pre> Because I want the vim.notify</code> status messages to show up in the notification feed of the fidget</code></a> plugin instead of the default nvim message list, I tend to wrap the calls to vim.notify</code> above in a vim.defer_fn</code> with a short timeout, to make them appear after the fidget</code> has been loaded:</p> local function</span> defer_notif</span>(msg, level)</span></span> vim.</span>defer_fn</span>(</span>function</span>()</span></span> vim.</span>notify</span>(msg, level)</span></span> end</span>, </span>250</span>)</span></span> end</span></span> </span></code></pre> That workaround is very hacky - I know.</p> Local Config Files</h3> While the config file can contain arbitrary code, most of the time I want to change some setting or behaviour of my main configuration. I do this by storing information in the global _G</code> table, which my main configuration then checks for and applies if it exists. For example, to install an additional plugin, I place one or more lazy</code> plugin specs in _G.SCHILK_LOCAL_PLUGINS</code>:</p> -- Extra plugins to be inserted into the lazy spec</span></span> _G</span>.</span>SCHILK_LOCAL_PLUGINS</span> =</span> {</span></span> 'schilkp/my_cool_plugin'</span></span> }</span></span> </span></code></pre> In my main configuration, I then inject any plugins into the default list of plugin specs before starting the plugin manager.</p> local</span> plugins</span> =</span> {</span></span> -- ... list of plugins ...</span></span> }</span></span> </span> -- Inject local plugins:</span></span> _G</span>.</span>SCHILK_LOCAL_PLUGINS</span> =</span> _G</span>.</span>SCHILK_LOCAL_PLUGINS</span> or</span> {}</span></span> if</span> _G</span>.</span>SCHILK_LOCAL_PLUGINS</span> then</span></span> for</span> _, plugin</span> in</span> ipairs</span>(</span>_G</span>.</span>SCHILK_LOCAL_PLUGINS</span>) </span>do</span></span> table.insert</span>(plugins, plugin)</span></span> end</span></span> end</span></span> </span> require</span>(</span>"lazy"</span>).</span>setup</span>(plugins)</span></span></code></pre> For reference, here are some of the things which I often do in my local config files:</p> Install and enable additional plugins, as shown above.</li> Enable additional LSP servers from nvim-lspconfig</code>.</li> Disable LSP servers that I have usually enabled.</li> Configure local, project-specific LSP servers, such as the aforementioned MLIR and TableGen LSPs.</li> </ul> Shareability</h3> The one big downside of this approach is that it is very tightly coupled to my neovim configuration, and therefore these config files are not very useful to anyone else. Unfortunately, because neovim configurations are all so incredibly different, I don't see a great way of changing that.</p> This is reflected in my choice to name the files .schilk.nvim.lua</code>: I doubt anyone else will directly use them.</p> For this reason, I also typically don't check them into project git repositories. As I doubt that the LLVM project will be interested in a patch that adds .schilk.nvim.lua</code> to their .gitignore</code>, to avoid having to keep juggling that change around locally, I just ignore these files in all git repos using a global .gitignore</code>:</p> # ~/.gitconfig:</span></span> [core]</span></span> excludesfile = /home/schilkp/.gitignore_global</span></span> </span> # ~/.gitignore_global:</span></span> .schilk.nvim.lua</span></span></code></pre>Notes</h2> You can find my complete setup directly in my neovim configuration here</a>.</p> Changes</h2> 13-03-2026</code>: Fixed the version of nvim</code> in which vim.secure.read()</code> was introduced - thanks, justinmk!</li> Updated the example snippet to use the actual content read by vim.secure.read()</code> instead of just using said function to check if the file is trusted before sourcing from the file.</li> Add explanation about deferred notify</code> calls.</li> </ul> </li> </ul>

- nvim

Working with external warnings and diagnostics in NVIM

Diagnostics</h2> If you instead prefer to display external warnings and errors as in-line diagnostics in the same style as LSP servers, that is also an option, but requires a bit of lua scripting.</p>

Managing project-specific NVIM configuration

Diagnostics</h2>
If you instead prefer to display external warnings and errors as in-line diagnostics in the same style as LSP servers, that is also an option, but requires a bit of lua scripting.</p>