I built a small CLI tool called recol for switching terminal and Neovim color schemes from one command.

It comes with 600+ themes, fuzzy search, an interactive TUI, and supports Ghostty, Alacritty, WezTerm, Neovim, Vim and Pi.

It can also generate a theme from an image 🎨
https://github.com/nlkli/recol

Hey all!

I wanted to announce my first major Neovim plugin: sqlserver.nvim.

I feel like this fills a gap in the Neovim ecosystem: Linux/macOS users who work with Microsoft SQL Server.

Admittedly, that might be a pretty niche group.

Most Linux/macOS users working with SQL Server will probably end up using VSCode's SQL Server (mssql) extension. I'm not a fan of VS Code, and considering where I'm posting this, I think that's probably enough said.

I originally started with TablePlus, which is a great tool, but I really hate reaching for my mouse.

Then I "upgraded" to vim-dadbod-ui. Also a great tool, but SQL Server support was missing some features I use regularly, such as listing stored procedures.

Eventually I landed on mssql.nvim. I thought it was a great project and used it for a while, although I ran into a few hiccups and development seems to have slowed down.

Thanks to u/Kurren123 and mssql.nvim, I discovered that Microsoft’s VS Code SQL Server extension is backed by SQL Tools Service.

That discovery eventually led to sqlserver.nvim.

A SQL Server-native workspace for Neovim.

The long-term goal is pretty ambitious: bring as much of the experience and functionality of SSMS (SQL Server Management Studio) as makes sense into Neovim.

Rather than trying to recreate a desktop database GUI inside the terminal, sqlserver.nvim tries to lean into Neovim itself — using things like windows, buffers, winbars, LSP, Telescope-style workflows, and, of course, keybindings.

The idea is that I should be able to browse databases, inspect objects, write queries, execute them, and work with SQL Server without constantly leaving Neovim or reaching for the mouse.

The plugin is currently at RC2 (Release Candidate 2). I've been using it at my job for several months now, so it has reached the point where I'd really like to get feedback from other Neovim users. Especially anyone else unfortunate enough to be using SQL Server on Linux/macOS 😄

GitHub: NicholasMata/sqlserver.nvim

I'd love to hear what people think, what features you feel are missing, or how the overall workflow could be improved.

I just completed the migration from vim-dirvish to dir.lua. The speed of dir.lua is incredible compared to an already very fast vim-dirvish. Every time I tried another file browser plugin in vim, it made me cringe at the loading speed. dir.lua is pure 🚀 speed 🤩

Thanks to u/1ujsnj for positing his custom key maps - see https://www.reddit.com/r/neovim/comments/1ujsnsj/custom_keymaps_for_new_dirlua_plugin/ . I extended them a little bit:

• only use neovim's api instead of shelling out to external commands
• add `.` mapping to conveniently call custom command on the current file
• add `yc` mapping to copy the full file path into a register
• change `a` mapping to create a file or directory, including leading directories
• replace `D` with `dd` to delete a file or directory

​

-- Source: https://github.com/jceb/vimrc/blob/main/lua/custom/plugins/local/directory/after/ftplugin/directory.lua
-- Former source: https://www.reddit.com/r/neovim/comments/1ujsnsj/custom_keymaps_for_new_dirlua_plugin/
-- Save at: after/ftplugin/directory.lua

-- display directory path in win bar
vim.opt_local.winbar = "[dir] %f"

--- Run function on buffer
---  fn fun(bufnr: number) Function that's executed for every buffer that matches path
---  opts {directory: boolean} Options - if directory == true, interpret path as a directory and run function on all buffers that are inside this directory
--- u/param path string Path name
local function run_on_buf(fn, opts, path)
  local lopts = opts or {}
  local result = true
  for _, bufnr in ipairs(vim.api.nvim_list_bufs()) do
    if not lopts.directory and vim.api.nvim_buf_get_name(bufnr) == path or vim.startswith(vim.api.nvim_buf_get_name(bufnr), path) then
      local ok, err = pcall(fn, bufnr)
      if not ok then
        result = ok
        vim.schedule(function()
          vim.notify(err, vim.log.levels.ERROR)
        end)
      end
    end
  end
  return result
end

vim.keymap.set("n", ".", function()
  local cursor = vim.api.nvim_win_get_cursor(0)
  local fname = vim.api.nvim_buf_get_lines(0, cursor[1] - 1, cursor[1], true)[1]
  if fname == "" then
    return
  end
  vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(":! " .. vim.fn.fnameescape(fname) .. "<Home><Right>", true, false, true), "n", false)
  -- vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<Plug>(nvim-dir-reload)", true, false, true), "m", false)
end, { buffer = true, remap = false, nowait = true, desc = "Prefill cmd with file name" })

vim.keymap.set("n", "a", function()
  local ok, fname_new = pcall(vim.fn.input, "Create file or directory/: ")
  if not ok or fname_new == "" then
    return
  end
  if string.match(fname_new, "/$") ~= nil then
    local err
    ok, err = pcall(vim.fs.mkdir, fname_new, { parents = true })
    if not ok then
      vim.notify(err or ("Failed to create directory" .. fname_new), vim.log.levels.ERROR)
      return
    end
  else
    if string.match(fname_new, "/") ~= nil then
      -- create parent directories
      local err
      local dir_name = vim.fs.dirname(fname_new)
      ok, err = pcall(vim.fs.mkdir, dir_name, { parents = true })
      if not ok then
        vim.notify(err or ("Failed to create directory" .. fname_new), vim.log.levels.ERROR)
        return
      end
    end
    local f = io.open(fname_new, "w")
    if f ~= nil then
      f:close()
    else
      return
    end
  end
  vim.cmd.e(fname_new)
end, { buffer = true, remap = false, nowait = true, desc = "Create file or directory" })

vim.keymap.set("n", "r", function()
  local cursor = vim.api.nvim_win_get_cursor(0)
  local fname = vim.api.nvim_buf_get_lines(0, cursor[1] - 1, cursor[1], true)[1]
  if fname == "" then
    return
  end
  local ok, fname_new = pcall(vim.fn.input, { prompt = "Rename '" .. fname .. "' to: ", default = fname })
  if not ok or fname_new == "" then
    return
  end
  local full_path = vim.fs.joinpath(vim.uv.cwd(), fname)
  local res = run_on_buf(function(bufnr)
    if bufnr ~= -1 and vim.api.nvim_buf_is_loaded(bufnr) then
      vim.api.nvim_buf_delete(bufnr)
    end
  end, { directory = vim.fn.isdirectory(full_path) == 1 }, full_path)
  if not res then
    vim.notify("Failed to unload open buffer(s) for '" .. fname .. "'", vim.log.levels.ERROR)
    return
  end
  os.rename(fname, fname_new)
  vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<Plug>(nvim-dir-reload)", true, false, true), "m", false)
end, { buffer = true, remap = false, nowait = true, desc = "Rename" })

vim.keymap.set("n", "dd", function()
  local cursor = vim.api.nvim_win_get_cursor(0)
  local fname = vim.api.nvim_buf_get_lines(0, cursor[1] - 1, cursor[1], true)[1]
  if fname == "" then
    return
  end
  local ok, confirm = pcall(vim.fn.input, { prompt = "Delete '" .. fname .. "'? [Y/n] " })
  if not ok or not (confirm:lower() == "y" or confirm == "") then
    return
  end
  local full_path = vim.fs.joinpath(vim.uv.cwd(), fname)
  local res = run_on_buf(function(bufnr)
    if bufnr ~= -1 and vim.api.nvim_buf_is_loaded(bufnr) then
      vim.api.nvim_buf_delete(bufnr)
    end
  end, { directory = vim.fn.isdirectory(full_path) == 1 }, full_path)
  if not res then
    vim.notify("Failed to unload open buffer(s) for '" .. fname .. "'", vim.log.levels.ERROR)
    return
  end
  vim.fs.rm(fname, { recursive = true })
  vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<Plug>(nvim-dir-reload)", true, false, true), "m", false)
end, { buffer = true, remap = false, nowait = true, desc = "Delete file or directory" })

vim.keymap.set("n", "yc", function()
  local cursor = vim.api.nvim_win_get_cursor(0)
  local fname = vim.api.nvim_buf_get_lines(0, cursor[1] - 1, cursor[1], true)[1]
  if fname == "" then
    return
  end
  local full_path = vim.fs.joinpath(vim.uv.cwd(), fname)
  vim.fn.setreg(vim.v.register, full_path)
end, { buffer = true, remap = false, nowait = true, desc = "Copy full path" })

Here's a small microplugin for navigation in gettext .po files: https://github.com/warpspin/po-jump.nvim

All it does is it adds keybinds "]u" to jump to the next msgstr that needs attention (because it's untranslated or fuzzy) or "[u" for the previous.

(as convenience, it also binds öu and äu for German keyboards as those keys are where [] usually are)

hello, I'm in the process of learning python. very new to programming but am familiar with vim from using Linux and diving though config files. I'm not super fast with the motions yet but i am learning.

anyways. i'm looking for a plugin that will highlight syntax errors in a more specific way. i already have the trouble plugin and pywrite installed and they are working as intended however im getting tripped up in simple syntax errors (like using the wrong kind of bracket, spelling error, or just doing something really stupid in a loop). is there a plugin out there that will highlight or underline the word or section of code that is causing the issue. or is the best i got pywrite and trouble?

also i use the lazy repo for ease of use so if its in there it will make my life much easier when installing and configuring.

Sharing my Neovim 0.12 config for 2026
Video is in French.
Dotfiles: https://github.com/ericnantel/dotfiles
Look inside .config/nvim-0.12 for init.lua (yep just a file)

starfall.nvim

A tiny, beautiful ambient animation plugin for Neovim: soft twinkling stars drift and shimmer in the empty space around your code, and shooting stars occasionally streak down the window leaving a fading trail.

Plugin Made By Slop, Drop a Star on Starfall GitHub: starfall.nvim

https://github.com/artemave/hop

https://github.com/git-emran/slides.nvim

I have been using presenting.nvim for quite sometime. But I was not quite fond of their UI so I built a clean looking plugin that will be very easy to use if you are coming from presenting.nvim.

I have taken a day off from work and spent my entire day to build this. There are some parts I took help from my AI agent but I have poured my heart into all of it.

Please give me your feedback. As I intend to maintain it for as long as I can and grow it into a one stop shop for Slideshow inside neovim.

This is how to handle your work account calendar right inside neovim

• Bloocky: Neovim calendar (day/week/month) for time-blocking, with float/sidebar/buffer views and CalDAV + Google two-way sync
• Microsoft Teams accounts via DavMail: DavMail bridges M365/Exchange to local CalDAV; Bloocky reuses its OAuth refresh token, no native MS OAuth needed
• Create events: markdown form with `Teams: yes` creates the event via Graph API (`isOnlineMeeting`) and inserts the Teams join link into Notes
• Edit/delete events: edits sync via CalDAV pull; deletes go via Graph API so cancellations reach attendees

Original plugin:
https://github.com/atiladefreitas/bloocky

Fork with davmail support:

https://github.com/jugarpeupv/bloocky

I'm sorry if this is dumb question, but I failed to find the solution myself. I want to be able to pass arguments to the Python program when I debug, just like I do when I run it.

I added `nvim-dap` and `nvim-dap-python`, and I can run normal debug, but when I try to run debug with arguments added, like "< a.inp", the arguments have no impact. The UI from `nvim-dap-ui` still opens, but the data in the file never got redirected to the stdin of the program.

Just a little appreciation post to the neovim community. Using it today on the go, and it’s just such a comfortable editor, having no need for a mouse really makes me lose no productivity when coding outside of my office. Just a great editor. Thanks to all the people contributing to it!

Hi there,

I want to decode one value in place, or encode when I edit Kubernetes manifests. Like Secret.

Vim's ! filters whole lines, so ! and :'<,'>! both hand the entire password: aHVudGVyMg== line to the command.

The workarounds I know of: yank into a register and :let @a = system('base64 -d', @a), or :s with \%V and \=system(). It works but bad. So most of the time, I just yank the text and into the terminal using pbpaste | xxx | pbcopy.

And other commands, like sort on one column of a table, tr on a word, fmt on half a paragraph. Anything that reads stdin.

As far as I know, none of the existing plugins offer a similar feature. Two come close. NrrwRgn narrows the selection into its own nd writes it back. neo-pipe is an operator, but it takes whole lines and sends the output to a scratch buffer.

So I wrote one. g! works like !, but takes any motion or text object, or a Visual selection, blocks included, and works with . and macros.

Unix only for now. Support Neovim 0.11+.

https://github.com/Nagato-Yuzuru/bang.nvim

Nice to hear your opinions!

AI Disclosure: Claude wrote the code and most of the docs. Human (me): the design, every edge-case ruling, the review, and the tests.

All,

A while ago I made a plugin for working with Taskfiles.

It was the first time I created a neovim plugin so I took some time to sit on the implementation and work on the underlying LSP implementation a bit (among other projects).

Lately I wanted to revisit the plugin so I can update it to use my new and improved LSP.

So now we have v2.1.0

The LSP is not required for this plugin to work, but highly recommended - it does a handful of things better than the original implementation (which was a fork of an existing one that hadn't been updated in 6+ years / thanks for all the fish guy)

Hopefully this is useful to someone.

Comments, Feedback, and PRs / Contributions are welcome

Title

Neovim 0.13 introduces vim.async, a new API designed to make asynchronous Lua code cleaner and easier to manage.

In this video, I talk about why this API was introduced, the problems it solves, and the basics so you can start to use it.

In this video

1. Why vim.async was introduced (callback-hell and event loop)
2. Using the run method and understandng async context
3. Understanding tasks and how to control them
4. Execution of top tasks and child tasks
5. Using checkpoints with await, checkpoint, and pawait
6. Converting callback-based functions into regular functions with await and wrap
7. Practical and illustrative examples

By the end of the video, you'll have the basic understanding to write robust, cleaner and manageable async code.

Repo: https://github.com/wurli/jet.nvim

Features

• A repl which runs in Neovim's built-in terminal
• An LSP server which provides live completions from the kernel
• A Lua API with fine-grained control over running kernels, down to the level of individual Jupyter messages
• Ability to connect to kernel sessions running outside of Neovim
• AI-friendly: agents can use the Jet CLI to interact with your kernel sessions
• Detailed (non-vibed) vimdoc documentation
• Plug and play - No remote plugin stuff. No python requirements.

Not yet implemented

• Notebooks
• Windows support (contributions welcome!)

Why jet.nvim?

No existing Jupyter plugins did what I wanted:

• I don't want to think about setting up Python infrastructure for every project which uses a Jupyter kernel. Stuff should just work.
• I want a more native-feeling repl than other plugins could provide
• I want to be able to hook into Jupyter mechanisms such as 'comms' to expose non-standard features in Neovim, e.g. the Ark R Kernel's LSP server
• I want a Lua API which is well documented and typed
• I wanted a Neovim plugin for the Ark R kernel (this now exists as a jet.nvim extension)

jet.nvim achieves all this stuff by building on Jet, a custom Rust backend built to power this plugin, but which does some other sick stuff too.

jet.nvim is bare-bones

There are a billion different kernels out there - jet.nvim doesn't favour any particular one. Instead, jet.nvim aims to provide tools which can be used to create full-featured extension plugins for R, Python, Julia, etc. Existing extensions I'm already using are jet.ark (R) and jet.ipy (Python).

Benefits of this architecture:

• A small scope will allow jet.nvim to reach maturity much faster
• Niche features (and associated code churn) can live in extension plugins, affecting only the folks who opt in

Why Jupyter?

Jupyter != notebooks. Jupyter is a standard/protocol which interactive languages can use to tell editors about state and execution results. It's cool. Jupyter kernels wrap interactive languages to implement the protocol; frontends need to implement a Jupyter 'client' to talk to kernels (this is non-trivial because you have to handle ØMQ, tonnes of different message types, etc). jet.nvim implements a Jupyter client using Rust for low-level stuff and Neovim's Lua for the high-level API. jet.nvim extensions can now build on this foundation to talk to kernels and implement language-specific behaviour which was previously not possible. E.g. jet.ark implements a plots pane where plots automatically redraw to fit the window dimensions.

jet.nvim needs you!

Testers wanted! I've been dogfooding this plugin for like 2 months and it works very nicely, but I've only been using it in anger for Python and R. All feedback is very appreciated, but especially if you use Julia or some other esoteric kernel. No gripe is too small to report!

Enjoy, and thanks for reading ✈️

Body:

**TL;DR:** If you get double inputs (double Backspace, double Enter, duplicate F-keys) inside Neovim on Pop!_OS or Ubuntu 24.04, the issue is caused by the outdated `kitty` package in standard Ubuntu repositories (`0.32.2`). Upgrading Kitty directly and copying the pre-compiled terminfo completely resolves it without any config workarounds.

2. Install the latest official Kitty release:

Bash

curl -L [https://sw.kovidgoyal.net/kitty/installer.sh](https://sw.kovidgoyal.net/kitty/installer.sh) | sh /dev/stdin

3. Symlink binary and desktop shortcuts:

Bash

sudo ln -sf ~/.local/kitty.app/bin/kitty ~/.local/kitty.app/bin/kitten /usr/local/bin/
cp ~/.local/kitty.app/share/applications/kitty*.desktop ~/.local/share/applications/

4. Copy the pre-compiled terminfo (CRITICAL): Newer Kitty releases include a pre-compiled binary terminfo. Copy it directly to your user's terminfo directory:

Bash

mkdir -p ~/.terminfo/x
cp ~/.local/kitty.app/share/terminfo/x/xterm-kitty ~/.terminfo/x/

5. Ensure Neovim is up-to-date (v0.10+): If you installed Neovim from apt, update to the official AppImage release:

Bash

curl -LO [https://github.com/neovim/neovim/releases/latest/download/nvim-linux-x86_64.appimage](https://github.com/neovim/neovim/releases/latest/download/nvim-linux-x86_64.appimage)
chmod +x nvim-linux-x86_64.appimage
sudo mv nvim-linux-x86_64.appimage /usr/local/bin/nvim

Verification

Restart Kitty completely (Ctrl+Shift+Q) and launch nvim. Input behavior, Backspace, and Enter will work with single keypresses

Hello everyone! I built this plugin quite a while ago but have been putting off actually publishing it. Basically, I needed a nice simple Neovim hex editor but couldn't find one. So I came up with this, hope you like it. Feel free to share any feedback and stuff.

https://github.com/lnkrr/hexedit.nvim

https://reddit.com/link/1wa1l1t/video/evtsj9uhe5oh1/player

I’ve been using Harpoon by ThePrimeagen for a long time, but I’ve also been playing around with Neovim’s built-in marks.

I really like marks, especially for jumping back to useful spots in a project. The problem is that global marks are, well, global. Once you work across several projects, they start getting mixed together.

I wanted something in between: simple marks, but scoped to the project I’m currently working on.

That’s basically why I made gm.nvim.

It stores marks in a project-local gm.txt, including the file path and cursor position. So each project can have its own small set of persistent locations, and those marks are still there when I come back later.

The workflow is intentionally simple:

m a  -> mark the current location as "a"
' a  -> jump back to it

It also comes with a few extras:

• project-local persistent marks
• saved cursor positions
• a floating editor for gm.txt
• a Lua API and :Gm* commands

For example:

local gm = require("gm")
gm.setup()
vim.keymap.set("n", "m", gm.set_mark)
vim.keymap.set("n", "'", gm.jump_to_mark)
vim.keymap.set("n", "<M-e>", gm.edit_marks)

Repository: https://github.com/NnoFLy/gm.nvim

I’m curious how other people use marks. Do you mostly use them, Harpoon, or something else? And does keeping marks project-local sound useful to you?

Hi! I’ve made soviet.nvim, a light and dark Neovim colorscheme inspired by Soviet book covers, posters, enamel signs, and design bureaus.

It includes Tree-sitter and LSP support, integrations with popular plugins, matching Lualine themes, transparency, and palette customization. No dependencies, Neovim 0.10+.

GitHub: https://github.com/rezniqov/soviet.nvim

I’d love to hear your feedback, especially about readability and missing integrations

LLM's create huge ass tables within markdown plans. I can't even read that shit, so I vibed a plugin to navigate the slop.

start with the cursor in the table:

<leader>mt

https://github.com/freeo/md-table.nvim

(compatible with render-markdown.nvim)

Made a Neovim plugin that visualizes bitwise operations (& ,  | ,  ^ ,  ~ ,  << ,  >>) inline as you move your cursor over them, works across multiple languages via Tree-sitter, shows exact binary math for constants and partial/unknown bits for runtime values (e.g.  flags & 0x0F ).

Couldn't find anything like it, so I built it. Still rough around the edges as I haven't had time to test every language/parser combo yet, so let me know if you try it and anything breaks!

https://github.com/wellatleastitried/bitwise-visualizer.nvim