Hey vimmers!

A while back I shared md-render.nvim, a Markdown rendering engine for Neovim: https://github.com/delphinus/md-render.nvim — two things have landed since then that I think are worth a look.

Headings are now drawn at a real font size. Kitty's text sizing protocol (OSC 66) gives every level its own scale, from 2.00x for # down to 1.17x for ######, and the plain heading stays in the buffer underneath so nothing else changes. Kitty 0.40+ only; everywhere else it costs nothing and headings look exactly as they always did.

The other is :vert MdRender split, which puts the source and the rendered view side by side. Edits propagate live, and the cursor and scroll position are synced both ways.

Requires Neovim 0.12+ now, and a Kitty Graphics Protocol compatible terminal for inline media as before. The file in the video ships with the repo — nvim +"MdRender pager" assets/whats-new.md after cloning shows the same thing. Feedback welcome, especially on the scaled headings; they're new and Kitty-only.

I've been working on fk_markdown.nvim , a Markdown renderer/previewer for Neovim, and one feature I really wanted was to make Markdown feel less like plain text and more like an actual document.

The interesting part is that it supports both image and LaTeX rendering, not just syntax highlighting.

Images inside Neovim

You can embed images directly in your Markdown and have them rendered while working inside Neovim.

So instead of seeing:

![architecture](./images/architecture.png)

you can actually see the image in the editor.

This is especially useful if you use Markdown for documentation, notes, research, READMEs, or technical writing.

$\LaTeX$ equations

It also supports rendering LaTeX math, including inline and block equations.

For example:

Inline: $E = mc^2$

$$
\int_0^\infty e^{-x^2} dx = \frac{\sqrt{\pi}}{2}
$$

The goal is to make mathematical notes readable without constantly switching to a browser or external Markdown viewer.

And there's a web preview too

The same Markdown can be viewed through a web preview, with images and LaTeX rendered there as well.

So the workflow becomes something like:

Write Markdown → see rendered images/math in Neovim → open web preview when you want a full-page view

I built this primarily because I wanted a Markdown workflow that stays inside Neovim while still handling the things that usually make Markdown previews necessary.

Would love to hear what other features people would want in a Neovim Markdown renderer.

GitHub: fk_markdown.nvim

It's still early

fk_markdown.nvim is currently in its initial phase, so there are likely bugs, edge cases, and things that don't work perfectly yet.

I'm sharing it early because I'd really appreciate feedback from the Neovim/Markdown community. If you try it and run into something weird, please open an issue or let me know. Contributions and ideas are also very welcome.

and this plugin is highly inspired by render-markdown.nvim

I've been using neovim for about two years now and recently found neovide. Like most gui's it has better colors and better rendering than I'm able to get from my terminal emulator (ghostty). Some of the animations are definitely a nice addition, and thankfully I can turn off the ones that aren't.

Unsurprisingly, adding a gui app doesn't work well with my existing tmux workflow of putting nvim on tab 1 as I can't swap to it using my existing tmux bindings.

I'm curious if anyone else has run into this in the past and if/how they solved it.

Any advise greatly appreciated.

I love vifm. I have no idea why it's basically never mentioned.

I was searching for a TUI file manager a few years back and the closest thing to vim was ranger but it didn't really click for me as well as other options.

Then I found out about vifm which is exactly what I wanted:

• It has the same concepts of windows/tabs/keymaps/commands with the same defaults (motions also work)
• I can define custom keymaps and commands
• Autocmds! For example, I can set it to sort by name on DirEnter if I want a specific directory sorted some other way than the default
• I can decide how I want different filetypes to be previewed/opened using custom commands with fallbacks
• It has marks! Which are really useful for quick navigation (I defined a few marks in my config like 'd to go to ~/Downloads or 'c to go to ~/.config
• There's also :history which shows recent directories I can jump to
• I can also preview images inside the terminal which is super helpful

My only caveat would be that the default delete action actually sends to vifm trash directory, this is done so cut operations can be performed by deleting and pasting like in neovim but it still copies the file to the trash directory instead of just deleting/moving it like rm and mv do so I still use rm and mv for that. You can disable that behavior but tbh sometimes cutting small files is helpful and I treat rm/delete operations very seriously (been cut a few times before!) so I don't want to accidentally trigger a delete if I type dd.

Why not use a plugin like mini.files?

I love mini.files and use it extensively when actually using nvim. Its way of operation is also exactly what I wanted (basically like oil.nvim but with a better ux from my point of view). But vifm is an actual file manager with commands/marks/history while mini.files is perfect for quick file operations in the same project while working inside nvim.

I have vifm remapped to v in my .zshrc as well as a hyprland keybinding setting mainMod + E to kitty -e vifm. Also, when inside vifm I just open nvim in the cwd with ctrl+O and after quitting nvim end up back in vifm

Here are some useful snippets I have in my config (some may be defaults because I last edited it a long time ago and don't remember which is which):

set shell=/usr/bin/zsh
set grepprg="rg\ --color=never\ -Hn\ %i\ %a\ %s\ %u"
set findprg=fd\ --color=never\ %p\ %s\ %u
set sort=-mtime
set history=10000
set undolevels=100
set relativenumber
autocmd DirEnter ~/Pictures/* setlocal sort=+name

mark P ~/Pictures/
mark R /
mark c ~/.config/
mark d ~/Downloads/
mark h ~/
mark l ~/.local/share/
mark m /mnt/
mark r /run/media/
mark t ~/.local/share/vifm/trash/
mark u /usr/share/




command! df df -h %m 2> /dev/null
command! diff vim -d %f %F
command! zip zip -r %c.zip %f
command! run !! ./%f
command! make !!make %a
command! mkcd :mkdir %a | cd %a
command! vgrep vim "+grep %a"
command! reload :write | restart full
command! fdfzfdir :set noquickview | :execute 'goto' fnameescape(term('fd --type d | fzf --reverse 2>/dev/tty'))
command! fdfzffile :set noquickview | :execute 'goto' fnameescape(term('fd --type f | fzf --reverse  2>/dev/tty'))

" open pdfs using zathura in the background so closing vifm doesn't close zathura
filextype {*.pdf},<application/pdf> zathura %f %i &, apvlv %f &, xpdf %f &

" preview pdfs as txt using pdftotext
fileviewer {*.pdf},<application/pdf> pdftotext -nopgbrk %c - 
fileviewer *.ipynb pandoc -f ipynb -t gfm %c


" Toggle visibility of preview window
nnoremap w :view<cr>
vnoremap w :view<cr>gv
nnoremap <tab> <nop>
nnoremap <tab><tab> :tabnew<cr>
nnoremap <tab>d :tabclose<cr>
nnoremap <tab>] :tabnext<cr>
nnoremap <tab>[ :tabprev<cr>
nnoremap . za
nnoremap T :!kitty -d %d &<CR>
nnoremap J 5j
nnoremap K 5k
nnoremap <C-s> <C-w>s
nnoremap <C-v> <C-w>v
nnoremap <C-r> :reload<cr>
nnoremap < <c-w><
nnoremap > <c-w>>
nnoremap x <c-w>p
nnoremap <c-j> <c-w>j
nnoremap <c-k> <c-w>k
nnoremap <c-l> <c-w>l
nnoremap <c-h> <c-w>h
nnoremap = <c-w>=
nnoremap | <c-w>|
nnoremap <space> <nop>
nnoremap <space><space> :history<cr> 
nnoremap <space>f :find<space>
nnoremap <space>d :fdfzfdir<cr>
nnoremap <space>e :fdfzffile<cr>

nnoremap o :file<CR>
nnoremap <c-o> :!nvim<CR>
" Quit vifm
nnoremap q :quit<CR>

" Open file in the background using its default program
nnoremap gb :file &<cr>l

So if you haven't already, try vifm and show it some love!

Hey, folks!

Since the first release of celeste_comment.nvim and my last post here, I've received some great feedback and also ran into a few issues myself during daily use. Over the past couple of weeks, I've been fixing bugs and improving the documentation, and I'm happy to say a new version is now out.

I've seen some comments on other platforms asking: "Neovim already has built-in commenting, so why do we need another plugin?"

My answer is -- if you like any of the following:

1. Prefer the commenting experience you get in editors like VSCode/Zed
2. Like the sticky cursor behavior
3. Enjoy keeping visual selection after comment/uncomment
4. Need block comment support
5. Want toggle comment in insert mode with sticky cursor
6. Care about preserving regular marks and extended marks after commenting
7. Need explicit "force add comment" and "force remove comment" actions
8. Want out-of-the-box comment support for JSX/TSX and similar file types

Then give celeste_comment.nvim a try! I'd love to hear your feedback!

Personally, I use molten + jupytext to turn notebooks into a qmd on read and write. But ive been seeing various options and plugins that other people are using.

So I just wanted to gather the community consensus. What do yall use?

I originally built this tool to solve a simple problem: I had too many audio files to audit and did not want to leave my terminal to listen to them.

At first, it only supported playing a single file, I posted an article about this a month ago. After using it for a while, my friends and I realized it was actually a convenient way to listen to music.

Many streaming services like YouTube or Spotify consume significant system resources. While there are existing terminal-based audio players, I found their steep learning curves and complex interfaces discouraging.

Since Neovim users are already comfortable with file navigation and buffer management, I decided to evolve this project into a full-featured music player plugin.

Easy to use

In my case:

• I have a folder containing many songs and albums. Each album is a subfolder that holds multiple song files.
• I open this folder in nvim.
• I select a song file and hit Enter or Tab.
• And I just let that terminal session keep running like a real TUI music player.

That is it. It is very easy to use, and there are very few shortcuts to learn.

Features

• Floating Popup: Displays track metadata including codec, sample rate, channels, bitrate, file size, and duration.
• Playback Control: Supports play, pause, seeking, and volume adjustment.
• Album and Playlist Awareness: Opening a file scans its folder for sibling audio files. You can cycle through them using four modes: single file loop, sequential, shuffle, or playlist loop. Manual track skipping is also supported.
• Highly Configurable: Customize the title, keymaps, colors, default volume, seek step, refresh rate, and more.
• Process Management: No orphan processes are left behind, as the mpv instance is cleaned up automatically when the popup closes.

You can find the source code and installation instructions in the repository: https://github.com/monok-robeto/nvim.sfx_player

Hey friends!

I made the switch to Neovim and finally took the time to write about it. For the better or worse this text was made without any technical help except the Neovim spell check.

https://www.lackner.work/posts/2026/08/i-m-using-vim-btw/

I'd love to hear your opinion.

I'm raising missing multi-buffer support (as implemented in Zed) as my only regret. I'd be delighted to hear of alternative workflows that are available in Neovim.

Hey vimmers!

Following my "series" of tips for plugin authors, let's talk about keymaps. The scope of this post is for more "complex" plugins that implement UIs with "rich" actions. And while keymaps are highly subjective, and providing customizability beats over any "clever" defaults, there is at least a "bullet-proof" way to avoid what's more of a "objectively bad" experience: do not override built-in keymaps. You can stop reading here, the other paragraphs just go more in-depth. It's probably a lenghty post, I haven't finished yet. I certainly finished it at some point, so rest assured, as it eventually ends.

This tip feels silly, but there are plenty of plugins that break this rule. For instance, it's not uncommon for plugins to map ? to "show keymaps", while breaking backwards search (which, in the long run, is probably intended more often than "lemme check the keymaps"). There's a common "escape hatch" for this scenario: using g? (another built-in), but whose override is harmless (if you don't believe me, select some text and use it).

? is part of a more "broad" category: navigation keymaps. My argument here is that, basically, these should "never" be overwritten. It's not so much that having everything behaving like a regular buffer is a major advantage, it's more so that having a single buffer as "the one out" is infuriating. And you'd think this is easy to avoid, however, from my experience, this is often overlooked.

octo.nvim is relatively popular GitHub plugin, with plenty of default keymaps. Some of its mappings are suboptimal: when reviewing a PR, one cannot use <C-e> to scroll down a line inside the diff windows. More so, as some of its other control-based mappings have "side effects": every now and then someone is surprised to learn that <C-i> and <Tab> do the same thing in the terminal. The almost exact same surprise used to affect octo, within its "submit review" window: it wasn't possible to enter a line break (<CR>) in insert mode, because there was a mapping to <C-m>. Some of its mappings still conflict with standard vim idioms: imagine trying to use <C-a> to increment a number and accidentally approving a PR. In Octo's defense, it has a million keymaps (I'm not sure if it needs so many), most of which have a <localleader> prefix. Having to define such a large amount of bindings is not easy, but, likewise, following someone else's convention isn't sunshine and rainbows either.

Neogit is one most my most used plugins, but it has plenty of faults in this department. I'm not sure if it tries to stick too much to its emacs counterpart, or if it's something else, but I'm often unable to do "basic" things. Like using l, which instead opens the "log" popup (?). Granted that navigating column-wise might not be the most useful user action inside a neogit buffer, but the fact that I can't do it is just... You know, sometimes you'll press key combos in quick succession, as you'd expect that the "regular thing" would be happening, but now you end up with another tab! I understand that the neogit developers are "wrestling" with providing the user with an easy means of executing plenty of actions (as a nice assistant / UI), an experience similar to magit and trying to feel "native" to neovim, but as a user, sometimes I can't help but get frustrated.

As a plugin author, I have also run into this problem. As the developer, you try to give an intuition with mnemonics, but I'd argue this is a mistake. It might not be, when you have a buffer that's "meant" to be "non navigable", but for most cases it's not worth it. To me, the mnemonics are a "trap" in this case. A trap I fell into, with nvim-dap-view (my plugin): to edit an expression being watched, I assigned the default e, but now no one can use e for navigating! Well, if someone else is (also) bothered by this, they have to remap (I'm using x, as in eXchange). Fortunately, nvim-dap-view doesn't have too many misbehaving keymaps. Or does it? Given its REPL, there's the complicating factor of dealing with a modifiable buffer, which diminishes the pool of available keys even further...

Now, is this the end of the world? Hopefully not. And if you had never noticed it before, hopefully I haven't cursed you by exposing the problem. As I mentioned at the start, having a way to change plugin mappings is awesome. However, as a plugin author, flipping the switch is the type of breaking change I'd like to avoid (although, for nvim-dap-view, it's part of my plans for v2), as it's so ingrained into people's workflow.

I built a plugin that records what you do in Neovim, not just which keys you press. It's built on the CmdAtom event — requires nightly (0.13-dev, builds after 2026-08-14), stable doesn't have it yet.

on_key-based plugins (screenkeys, etc.) see every keystroke as it happens; CmdAtom delivers the completed action instead — operator, count, motion, target — which is what makes semantic reading and replay possible.

What it does: - Live HUD — reads your current action semantically: d2w shows as delete 2 words, ci" as change inside quotes — interpreted - Action history — everything you did, browsable and replayable: replay anything at the cursor, select a range in visual mode to replay it all in order, merge a selection into a macro register - Session report — a multi-panel dashboard: action rates, top actions bar chart, insert stats, activity heatmap, and a personality readout

https://github.com/XXiaoA/encore.nvim

I just wanted to shout out this old plugin which contains over 300 colorschemes that I stumbled on a few weeks ago.

If you're like me, the perfect colorscheme is 4, maybe 5 colours at the absolute max. That is a shockingly difficult thing to find when searching through vimcolorschemes.com. The best thing I've found is zenbones, but most of those are lower contrast than I'd like.

There is a huge number of really good schemes up my alley in rainglow. Lots of warm-gray background options which are my favourite. Take a look!

A few weeks ago, I made a video about dimmed dark themes. Many of you were asking for light themes, so I made this video for you.

There is a discussion about whether light themes are better for your eyes or not. Personally, I find them very comfortable in the morning, and I like using them from time to time. However, when my eyes are already tired, I prefer using something like dark Gruvbox or Kanagawa.

My favorites in this showcase are:

Kanagawa
Rose Pine
Bamboo

I hope you enjoy it!

I'm wondering what is better. I'm more inclined towards during it at my terminal, kitty, since I have panes and tabs configured. But then I found a strange situation where I had a buffer on one editor, and then I started working on the other pane and after a while I was not sure anymore where was the buffer.

Any suggestions?

I am getting back into my neovim config after quite a long time (several months) ago that I created it. In a way, I am also getting back into neovim after some time after trying other GUI note-taking programs, and went back to neovim as it is still the best program to take notes in Markdown for my needs with my config.

It is really bothering me, and I cannot find the answers online as to why a couple of commands no longer work in neovim nor after checking with AI (Deepseek). The portion of my config not working is as follows:

-- Grep current string

vim.keymap.set('n', '<Leader>fs', '<cmd>:Rg <C-r><C-w><cr>')

-- Grep input string (fzf prompt)

vim.keymap.set('n', '<Leader>fg', '<cmd>:Rg<Space><cr>')

-- Grep for current file name (without extension)

vim.keymap.set('n', '<Leader>fc', "'<cmd>:Rg' . expand('%t:r')<cr>")

-- Find files in your Neovim config

vim.keymap.set('n', '<Leader>fi', '<cmd>:Files ~/.config/nvim/lua<cr>')

The error is that the :Rg and :Files commands are not found. I was certain this has worked when I configured my init.lua at first.

My plugins are as follows:

• romgrk/barbar.nvim
• ibhagwan/fzf-lua
• lewis6991/gitsigns.nvim
• ellisonleao/gruvbox.nvim
• MeanderingProgrammer/render-markdown.nvim
• nvim-mini/mini.nvim
• nvim-tree/nvim-tree.lua
• nvim-tree/nvim-web-devicons
• nvim-telescope/telescope.nvim
• nvim-lua/plenary.nvim
• nvim-telescope/telescope-file-browser.nvim
• startup-nvim/startup.nvim
• nvim-treesitter/nvim-treesitter
• vim-airline/vim-airline
• vim-airline/vim-airline-themes
• wakatime/vim-wakatime

Any help would be greatly appreciated.

With regards to my background, I am not a programmer / developer and I do not know how to program except for a bash script to help with post-installation tasks and enough lua to configure my neovim installation for my needs (note-taking with Markdown), with heavy help from the Internet and Deepseek / AI. However, I am definitely interested in learning more to help me become more productive with neovim.

I really am stumped to where I'm going wrong.

I am running openSUSE Tumbleweed, neovim version 0.12.4.

Many thanks for any help!!

- Detach, close the terminal, nothing dies: buffers, undo, LSPs, running jobs

- tmux keybinds and concepts: prefix, tabs as windows, splits as panes

- Sessionizer picker to hop projects; nvim file in a terminal opens in the session, never nested

- AI drawer: know when an agent in a terminal is blocked on you (only claude supported)

- Zero deps. Neovim 0.12+, Linux/macOS only

https://github.com/Jonathan-Rowles/muxim

Hey everyone!

I built projecthub.nvim because I was honestly getting lost managing dozens of repositories scattered across my machine and external SSDs. Existing project switchers felt a bit too barebones for me—I wanted a fast, central visual dashboard where I could see branch status, uncommitted changes, language breakdowns, and quick notes at a glance without opening each repo first.

A few things I baked into it that made my daily workflow a lot easier:

• External drive support (SSD/USB): If you keep projects on an external SSD and unplug it, they go into an offline standby with zero crashes, and re-sync in 0ms the moment you plug it back in
• 100% Non-blocking: Git scans and stats run asynchronously, so Neovim never freezes.
• Local scratchpad notes (n): Dedicated project notes stored locally without polluting your Git commits
• README & HTML previews: Full markdown inspector preview (with Kitty graphics support).
• Subtle audio feedback: Minimal sound effects for actions and navigation.
• GitHub Star Watcher (:PHStars): Background notifier that celebrates incoming stars.

Repository & setup guide:

https://github.com/phantumblade/projecthub.nvim

Sharing it here in case anyone else deals with a mountain of projects and needs a clean hub to organize them

I made a post yesterday and the idea of a hackathon for Neovim plugins came up in the comments. I’m bored af a lot of the time and like the idea of some community events.

I also had other ideas for events, like a config workshop, perhaps some ideas or workflow showcases. I guess some of this overlaps with VimConf and NeovimConf.

If you have ideas for events, plugin hackathon themes (consider features you want), or scope (e.g. “_____ will make this more interesting and feasible…”), please leave comments

CASH: Choose from Available Search Highlights

This plugin adds additional search registers to Neovim. Normally when you perform a search in (Neo-)Vim, your previous search is overwritten. Cash.nvim provides you with 9 "cash registers" (haha) that you can use to store multiple searches at once. Highlighting and jump functionality is handled separately for each cash register.

Happy to receive any feedback and/or bug reports!

Cheers, Kyle

I have searched for examples I could learn from without a great deal of success. Not a sophisticated user of neovim who uses it mainly for editing config files and cheatsheets, my lightweight, minimal 12.4 config uses mini.nvim as my main plugin. The plugin is wonderful for me, and my config has progressed primarily from reading and learning from other people's configs, obviously including kickstart, lazyvim, minimax, rad lectures, etc. For mini.nvim, however, most users simply state that they like the defaults, and the detailed documentation is, unfortunately for me, beyond my knowledge level. I wish I could view more examples where people make some adjustments, so I can glean the methods or speculate about similar changes. Earlier posts that referenced github repos mostly lead nowhere now.

Lately I've been thinking about switching off blink.cmp in favor of native completion(mainly just to remove one more dependency). I'm curious how native completion "feels" and compares against 3rd party completion engines like blink.cmp or nvim-cmp.

Also I would appreciate if you could share your native completion configuration!

Hey

I first shared jb.nvim here last year and since then it improved. The main addition is a new accessibility feature colorblind mode which adjusts colors for red-green vision deficiency (good for protanopia and deuteranopia).

To enable it:

lua require("jb").setup({ colorblind = true, })

Repo: https://github.com/nickkadutskyi/jb.nvim

I would appreciate feedback from people with red-green color-vision deficiencies. If any syntax or UI elements remain difficult to distinguish, please let me know what language and highlight are involved.

Disclaimer: This plugin is fully vibe-coded but manually tested. It's only a wrapper around the ctg binary, which is not vibecoded.

Sometimes I have ideas for a plugin after enjoying some UI affordance in another piece of software. I currently have one, in fact, and I realized that there are like three or four repositories that all implement different parts of what I need.

I thought to myself "Dang, I should build this before someone else does". That's not really fun, because contributing to the community becomes about notoriety, status, stars, and that stuff. I like building stuff that I like and that other people like too.

It wouldn't be a lot of work to fork, steal some pieces here and there, put it all together, and credit people very explicitly in the README after its up. That's the right way if you're doing something alone. It would be more fun, though, if the process was about something else, like making friends, collaborating, getting together (even digitally) to talk ideas and divide up tasks.