Extensible UI for Neovim notifications and LSP progress messages.
Demo setup
Note that this demo may not always reflect the exact behavior of the latest release.
This screen recording was taken as I opened a Rust file I'm working on,
triggering rust-analyzer to send me some LSP progress messages.
As those messages are ongoing, I trigger some notifications with the following:
local fidget = require("fidget")
vim.keymap.set("n", "A", function()
fidget.notify("This is from fidget.notify().")
end)
vim.keymap.set("n", "B", function()
fidget.notify("This is also from fidget.notify().", vim.log.levels.WARN)
end)
vim.keymap.set("n", "C", function()
fidget.notify("fidget.notify() supports annotations...", nil, { annote = "MY NOTE", key = "foobar" })
end)
vim.keymap.set("n", "D", function()
fidget.notify(nil, vim.log.levels.ERROR, { annote = "bottom text", key = "foobar" })
fidget.notify("... and overwriting notifications.", vim.log.levels.WARN, { annote = "YOUR AD HERE" })
end)(I use normal mode keymaps to avoid going into ex mode, which would pause Fidget rendering and make the demo look glitchy...)
Visible elements:
- Terminal + font: Kitty + Comic Shanns Mono
- Editor: Neovim v0.9.4
- Theme: catppuccin/nvim (mocha, dark)
- Status line: nvim-lualine/lualine.nvim
- Color columns:
:set colorcolumn=81,121,+1,+2(sorry) - Scrollbar: petertriho/nvim-scrollbar
Fidget is an unintrusive window in the corner of your editor that manages its own lifetime. Its goals are:
- to provide a UI for Neovim's
$/progresshandler - to provide a configurable
vim.notify()backend - to support basic ASCII animations (Fidget spinners!) to indicate signs of life
- to be easy to configure, sane to maintain, and fun to hack on
There's only so much information one can stash into the status line. Besides, who doesn't love a little bit of terminal eye candy, as a treat?
Fidget requires Neovim v0.9.0+.
If you would like to see progress notifications, you must have configured Neovim
with an LSP server that uses the $/progress handler.
For an up-to-date list of LSP servers this plugin is known to work with, see
this Wiki page.
Install this plugin using your favorite plugin manager.
See the documentation for setup() options.
{
"j-hui/fidget.nvim",
opts = {
-- options
},
}Plug 'j-hui/fidget.nvim'
" Make sure the plugin is installed using :PlugInstall. Then, somewhere after plug#end():
lua <<EOF
require("fidget").setup {
-- options
}
EOF:Rocks install fidget.nvimFidget is actively developed on the main branch, and may occasionally undergo
breaking changes.
If you would like to ensure configuration/API stability, you can pin your tag to one of the release tags.
For instance, using Lazy:
{
"j-hui/fidget.nvim",
tag = "v1.0.0", -- Make sure to update this to something recent!
opts = {
-- options
},
}Fidget can be configured by passing a table of options to the setup().
Available options are shown below:
{
-- Options related to LSP progress subsystem
progress = {
poll_rate = 0, -- How and when to poll for progress messages
suppress_on_insert = false, -- Suppress new messages while in insert mode
ignore_done_already = false, -- Ignore new tasks that are already complete
ignore_empty_message = false, -- Ignore new tasks that don't contain a message
clear_on_detach = -- Clear notification group when LSP server detaches
function(client_id)
local client = vim.lsp.get_client_by_id(client_id)
return client and client.name or nil
end,
notification_group = -- How to get a progress message's notification group key
function(msg) return msg.lsp_client.name end,
ignore = {}, -- List of LSP servers to ignore
-- Options related to how LSP progress messages are displayed as notifications
display = {
render_limit = 16, -- How many LSP messages to show at once
done_ttl = 3, -- How long a message should persist after completion
done_icon = "✔", -- Icon shown when all LSP progress tasks are complete
done_style = "Constant", -- Highlight group for completed LSP tasks
progress_ttl = math.huge, -- How long a message should persist when in progress
progress_icon = -- Icon shown when LSP progress tasks are in progress
{ pattern = "dots", period = 1 },
progress_style = -- Highlight group for in-progress LSP tasks
"WarningMsg",
group_style = "Title", -- Highlight group for group name (LSP server name)
icon_style = "Question", -- Highlight group for group icons
priority = 30, -- Ordering priority for LSP notification group
skip_history = true, -- Whether progress notifications should be omitted from history
format_message = -- How to format a progress message
require("fidget.progress.display").default_format_message,
format_annote = -- How to format a progress annotation
function(msg) return msg.title end,
format_group_name = -- How to format a progress notification group's name
function(group) return tostring(group) end,
overrides = { -- Override options from the default notification config
rust_analyzer = { name = "rust-analyzer" },
},
},
-- Options related to Neovim's built-in LSP client
lsp = {
progress_ringbuf_size = 0, -- Configure the nvim's LSP progress ring buffer size
log_handler = false, -- Log `$/progress` handler invocations (for debugging)
},
},
-- Options related to notification subsystem
notification = {
poll_rate = 10, -- How frequently to update and render notifications
filter = vim.log.levels.INFO, -- Minimum notifications level
history_size = 128, -- Number of removed messages to retain in history
override_vim_notify = false, -- Automatically override vim.notify() with Fidget
configs = -- How to configure notification groups when instantiated
{ default = require("fidget.notification").default_config },
redirect = -- Conditionally redirect notifications to another backend
function(msg, level, opts)
if opts and opts.on_open then
return require("fidget.integration.nvim-notify").delegate(msg, level, opts)
end
end,
-- Options related to how notifications are rendered as text
view = {
stack_upwards = true, -- Display notification items from bottom to top
icon_separator = " ", -- Separator between group name and icon
group_separator = "---", -- Separator between notification groups
group_separator_hl = -- Highlight group used for group separator
"Comment",
render_message = -- How to render notification messages
function(msg, cnt)
return cnt == 1 and msg or string.format("(%dx) %s", cnt, msg)
end,
},
-- Options related to the notification window and buffer
window = {
normal_hl = "Comment", -- Base highlight group in the notification window
winblend = 100, -- Background color opacity in the notification window
border = "none", -- Border around the notification window
zindex = 45, -- Stacking priority of the notification window
max_width = 0, -- Maximum width of the notification window
max_height = 0, -- Maximum height of the notification window
x_padding = 1, -- Padding from right edge of window boundary
y_padding = 0, -- Padding from bottom edge of window boundary
align = "bottom", -- How to align the notification window
relative = "editor", -- What the notification window position is relative to
},
},
-- Options related to integrating with other plugins
integration = {
["nvim-tree"] = {
enable = true, -- Integrate with nvim-tree/nvim-tree.lua (if installed)
},
["xcodebuild-nvim"] = {
enable = true, -- Integrate with wojciech-kulik/xcodebuild.nvim (if installed)
},
},
-- Options related to logging
logger = {
level = vim.log.levels.WARN, -- Minimum logging level
max_size = 10000, -- Maximum log file size, in KB
float_precision = 0.01, -- Limit the number of decimals displayed for floats
path = -- Where Fidget writes its logs to
string.format("%s/fidget.nvim.log", vim.fn.stdpath("cache")),
},
}For more details, see fidget-option.txt.
Fidget has a Lua API, with documentation generated from source code. You are encouraged to hack around with that.
Fidget exposes some of its Lua API functions through :Fidget sub-commands
(e.g., :Fidget clear), which support shell-like arguments and completion.
These sub-commands are documented below.
Clear active notifications
Arguments
Positional arguments:
{group_key}:(any)group to clear
Clear notifications history
Arguments
Flags:
--before {seconds}:(number)filter history for items updated at least this long ago--group_key {group_key}:(any)clear history by group key--include_active {true|false}:(boolean)whether to clear items that have not been removed (default: true)--include_removed {true|false}:(boolean)whether to clear items that have have been removed (default: true)--since {seconds}:(number)filter history for items updated at most this long ago
Positional arguments:
{group_key}:(any)clear history by group key
Show notifications history
Arguments
Flags:
--before {seconds}:(number)filter history for items updated at least this long ago--group_key {group_key}:(any)filter history by group key--include_active {true|false}:(boolean)whether to clear items that have not been removed (default:true)--include_removed {true|false}:(boolean)whether to clear items that have have been removed (default:true)--since {seconds}:(number)filter history for items updated at most this long ago
Positional arguments:
{group_key}:(any)filter history by group key
Suppress LSP progress notifications
Arguments
Positional arguments:
{suppress}:(boolean)whether to suppress (omitting this argument toggles suppression)
Suppress notification window
Arguments
Positional arguments:
{suppress}:(boolean)whether to suppress (omitting this argument toggles suppression)
Rather than defining its own highlights, Fidget's default configuration uses built-in highlight groups that are typically overridden by custom Vim color schemes. With any luck, these will look reasonable when rendered, but the visual outcome will really depend on what your color scheme decided to do with those highlight groups.
You can override these highlight groups (e.g., icon_style) using the :h fidget-options shown above.
rcarriga/nvim-notify is first and
foremost a vim.notify() backend, and it also supports
LSP progress notifications
(with the integration seems to have been packaged up in
mrded/nvim-lsp-notify).
vigoux/notifier.nvim is
a vim.notify() backend that comes with first-class LSP notification support.
neoclide/coc.nvim provides a nice LSP progress UI in the status line, which first inspired my desire to have this feature for nvim-lsp.
arkav/lualine-lsp-progress was the original inspiration for Fidget, and funnels LSP progress messages into nvim-lualine/lualine.nvim. I once borrowed some of its code (though much of that code has since been rewritten).
nvim-lua/lsp-status.nvim also supports showing progress text, though it requires some configuration to integrate that into their status line.
Most of the Fidget spinner patterns were adapted from the npm package sindresorhus/cli-spinners.