Developing Lua plugins for Nvim

Introduction lua-plugin

This document provides guidance for developing Nvim Lua plugins.

Creating your first plugin lua-plugin-new

Any Vimscript or Lua code file that lives in the right directory, automatically is a "plugin". There's no manifest or "registration" step.

You can try it right now:

Besides plugin/foo.lua, which is always run at startup, you can define Lua modules in the lua/ directory. Those modules aren't loaded until your plugin/foo.lua, or the user, calls require(…).

Type safety lua-plugin-type-safety

Lua, as a dynamically typed language, is great for configuration. It provides virtually immediate feedback. But for larger projects, this can be a double-edged sword, leaving your plugin susceptible to unexpected bugs at the wrong time.

You can leverage LuaCATS or "emmylua" annotations https://luals.github.io/wiki/annotations/ along with lua-language-server ("LuaLS") https://luals.github.io/ to catch potential bugs in your CI before your plugin's users do. The Nvim codebase uses these annotations extensively.

TOOLS

Keymaps lua-plugin-keymaps

Avoid creating excessive keymaps automatically. Doing so can conflict with user mappings.

NOTE: An example for uncontroversial keymaps are buffer-local mappings for specific file types or floating windows, or <Plug> mappings.

A common approach to allow keymap configuration is to define a declarative DSL https://en.wikipedia.org/wiki/Domain-specific_language via a setup function.

However, doing so means that

As an alternative, you can provide <Plug> mappings to allow users to define their own keymaps with vim.keymap.set().

Another option is to simply expose a Lua function or user-commands.

Some benefits of <Plug> mappings are that you can

Some benefits of exposing a Lua function are:

NOTE: If your function takes an options table, users may still benefit from <Plug> mappings for the most common combinations.

KEYMAP EXAMPLE

In your plugin:

vim.keymap.set('n', '<Plug>(SayHello)', function()
    print('Hello from normal mode')
end)

vim.keymap.set('v', '<Plug>(SayHello)', function()
    print('Hello from visual mode')
end)

In the user's config:

vim.keymap.set({'n', 'v'}, '<leader>h', '<Plug>(SayHello)')

Initialization lua-plugin-init

Strictly separated configuration and smart initialization allow your plugin to work out of the box. Common approaches are:

Typically, automatic initialization logic is done in a plugin or ftplugin script. See also 'runtimepath'.

On the other hand, a single setup(opts) that combines configuration and initialization may be useful in specific cases:

Keep in mind that this approach requires users to call setup in order to use your plugin, even if the default configuration is enough for them. Consider carefully whether your plugin benefits from combined setup() pattern before adopting it. This article chronicles the history and tradeoffs of setup(): https://mrcjkb.dev/posts/2023-08-22-setup.html

NOTE: A well designed plugin has minimal impact on startup time. See also lua-plugin-lazy.

Lazy loading lua-plugin-lazy

Some users like to micro-manage "lazy loading" of plugins by explicitly configuring which commands and key mappings load the plugin.

Your plugin should not depend on every user micro-managing their configuration in such a way. Nvim has a mechanism for every plugin to do its own implicit lazy-loading, via autoload (Vimscript) and lua/ (Lua).

Plugin authors can provide "lazy loading" by providing a plugin/<name>.lua file which defines their commands and keymappings. This file should be small, and should not eagerly require() the rest of your plugin. Commands and mappings should do the require().

Guidance:

Defer require() calls lua-plugin-defer-require

plugin/<name>.lua scripts (plugin) are eagerly run at startup; this is intentional, so that plugins can setup the (minimal) commands and keymappings that users will use to invoke the plugin. This also means these "plugin/" files should NOT eagerly require Lua modules.

For example, instead of:

local foo = require('foo')
vim.api.nvim_create_user_command('MyCommand', function()
    foo.do_something()
end, {
  -- ...
})

which calls require('foo') as soon as the module is loaded, you can lazy-load it by moving the require into the command's implementation:

vim.api.nvim_create_user_command('MyCommand', function()
    local foo = require('foo')
    foo.do_something()
end, {
  -- ...
})

Likewise, if a plugin uses a Lua module as an entrypoint, it should defer require calls too.

NOTE: For a Vimscript alternative to require, see autoload.

NOTE: If you are worried about eagerly creating user commands, autocommands or keymaps at startup: Plugin managers that provide abstractions for lazy-loading plugins on such events do the same amount of work. There is no performance benefit for users to define lazy-loading entrypoints in their configuration instead of plugins defining it in plugin/<name>.lua.

NOTE: You can use --startuptime to profile the impact a plugin has on startup time.

Filetype-specific functionality lua-plugin-filetype

Consider making use of 'filetype' for any functionality that is specific to a filetype, by putting the initialization logic in a ftplugin/{filetype}.lua script.

For buffers owned by your plugin (often used to show a custom UI or view), typically your plugin will set a custom 'filetype'. In that case, it's useful to set the 'filetype' "as late as possible", so that users can override buffer-local settings after your plugin has (re)initialized the buffer.

FILETYPE EXAMPLE

A plugin tailored to Rust development might have initialization in ftplugin/rust.lua:

if not vim.g.loaded_my_rust_plugin then
    -- Initialize
end
-- NOTE: Using `vim.g.loaded_` prevents the plugin from initializing twice
-- and allows users to prevent plugins from loading
-- (in both Lua and Vimscript).
vim.g.loaded_my_rust_plugin = true

local bufnr = vim.api.nvim_get_current_buf()
-- do something specific to this buffer,
-- e.g. add a |<Plug>| mapping or create a command
vim.keymap.set('n', '<Plug>(MyPluginBufferAction)', function()
    print('Hello')
end, { buf = bufnr })

Opening files lua-plugin-open-file

To robustly open a file, see open-file.

Configuration lua-plugin-config

To allow users to override buffer-local configuration for filetypes owned by your plugin, publish a FileType event, "as late as possible". lua-plugin-filetype

Once you have merged the default configuration with the user's config, you should validate configs.

Validations could include:

UI lua-plugin-ui

Some plugins have their own "UI" which they present in a buffer that the plugin "owns". In that buffer typically you will want to provide custom actions.

Besides creating <Plug> mappings, you may want to consider providing actions by defining an in-process LSP server. Offering actions as code-actions vim.lsp.buf.code_action() means the user can see all available actions using the default gra mapping to view the code-actions menu. They can even define mappings to a specific action by invoking vim.lsp.buf.code_action() with the filter + apply parameters:

vim.lsp.buf.code_action({
    apply = true,
    filter = function(a)
        return a.title == 'Do something'
    end,
})

Example: See runtime/lua/vim/pack/_lsp.lua for how vim.pack defines an in-process LSP server to provide interactive features in its nvim-pack://confirm buffer.

Troubleshooting lua-plugin-troubleshooting

While developing a plugin, you can use the :restart command to see the result of code changes in your plugin.

HEALTH

Nvim's "health" framework gives plugins a simple way to report status checks to users. See health-dev for an example.

Basically, this just means your plugin will have a lua/{plugin}/health.lua file. :checkhealth will automatically find this file when it runs.

Some things to validate:

MINIMAL CONFIG TEMPLATE

It can be useful to provide a template for a minimal configuration, along with a guide on how to use it to reproduce issues.

Versioning and releases lua-plugin-versioning

Consider:

FURTHER READING

VERSIONING TOOLS

Documentation lua-plugin-doc

Provide vimdoc (see help-writing), so that users can read your plugin's documentation in Nvim, by entering :h {plugin} in command-mode. The help-tags (the right-aligned "search keywords" in the help documents) are regenerated using the :helptags command.

DOCUMENTATION TOOLS