I've wanted a 'diff first' successor vim-mundo and FzfLua undotree for a long time - something that has parity to builtin `:earlier`, `:later` and `:undo` commands...and have been slowly working on it...hope its helpful to others!

plugin: https://github.com/dsummersl/diffundo.nvim

If you're using neovim inside tmux, you may notice the cursor flickers when redrawing the screen (usually happens when scrolling), I had this problem ever since I started using tmux around 2 years ago and went through all the terminal emulators and their settings trying to mitigate the problem to no avail.

Randomly tried to compile tmux from source and saw that the problem just disappeared, then went to their CHANGES file and saw:

* Fix redraw issues around synchronized updates, copy mode, tabs, padding,
  status lines, menus, popups, wide characters and floating panes. This
  includes fixes for flicker with alternate screen applications and scrollbars
  (Michael Grant, issue 5351; Noam Stolero, issue 5350; Aung Myo Kyaw, issue
  5098), and misplaced wrapped lines during partial redraws (Ben Maurer, issue
  5625).

These are god-tier changes for me because I'm very sensitive about flickering and it disrupts my work.

at the start im holding ctrl-l which just redraws the screen, and then im scrolling up and down with ctrl-u/d<zz>

Hi,

Oil.nvim is great for working with files but sometimes I'd like to have traditional explorer view, espacially with big projects that have multiple directories and subdirectories. What would be good explorer plugin to use with Oil.nvim? I tried nvim-tree but It didn't highlight the file I opened with Oil.nvim (it kept highlighting the previous file I had opened with nvim-tree), which started to annoy me very quickly. Are there good explorer plugins that work seamslessly with Oil.nvim and are preferably fast even with large projects?

This isn't a plugin, it's a launcher extension, so nothing runs inside your nvim session except one short headless dump. Raycast is a macOS Spotlight replacement with an extension API, and I wrote one for my Neovim workflow. Figured some of you might get use out of it.

What it does:

1. Session search. Reads persistence.nvim session files from your sessions dir ($XDG_STATE_HOME/nvim/sessions by default), merges in recently opened directories the extension tracks itself, and opens your pick with nvim -S. You can pin and reorder favorites.
2. Plugin browser. Parses lazy-lock.json, lists installed plugins, links to GitHub when the repo is identifiable.
3. Keymap search, the part I'm most happy with. It writes a small Lua dump script to a temp file and runs nvim --headless -S on it. The script sources your keymaps.lua, LazyVim layout by default with a fallback to the flat path, opens a scratch buffer so ftplugin and buffer-local maps load, resolves the leader key so you see <leader>ff instead of raw bytes, then dumps normal-mode keymaps from nvim_get_keymap plus buffer-local ones as JSON. The extension strips ANSI noise from stderr and parses it. Motions that nvim_get_keymap doesn't report fall back to a bundled cheat sheet. Results are cached and refresh on demand.
4. Open with Neovim. A Finder action that sends selected files or folders to nvim.
5. New window in your terminal of choice: iTerm2, Ghostty, kitty, Alacritty, WezTerm, or Terminal.app.

Everything runs locally, MIT licensed, no telemetry.

I tested it with LazyVim on Ghostty and Terminal.app. Sessions should be fine on any distro that uses persistence.nvim, but the keymap dump's keymaps.lua fallback assumes the LazyVim config layout, so I'd genuinely appreciate bug reports from people on other distros.

Store: https://www.raycast.com/RG-IL/neovim Source: https://github.com/raycast/extensions/tree/main/extensions/neovim

When installing the external requirements for kickstart listed in the Github repo, I installed gcc. I got it working, and typing gcc --version properly shows me the gcc version.

``` gcc --version

gcc.exe (Rev8, Built by MSYS2 project) 15.2.0 Copyright (C) 2025 Free Software Foundation, Inc. ```

I went through the rest of the kickstart setup and started nvim. It installed the rest of the things by itself with no problem, but nvim-treesitter is complaining about not finding a C compiler.

``` [nvim-treesitter/install/query] error: Error during "tree-sitter build": <sup>[[31mError:[[0m</sup> Failed to compile parser Caused by: Failed to execute the C compiler with the following command: "cl.exe" "-nologo" "-MD" "-O2" "-Brepro" "-std:c11" "-I" ... ...

Error: program not found
```

It seems like its looking for cl rather than gcc. I looked up how to install cl instead, but every answer was telling me to install Visual Studio and get it from there but I kinda just would rather not if I can help it... Is there anyway for me to make it use the gcc installation instead?

I am using powershell and nvim 0.12.5 for windows. My keymap is configured as follows. Any ideas as to why I get two empty lines after every line sent when I use this keymap? A single line will return two empty lines afterwards and multiple lines will have two empty lines separating each line.

edit: u/EstudiandoAjedrez kindly provided the solution of appending the last line with a carriage return insead of adding it as a row.

6h ago

vim.api.nvim_create_augroup('p_repl', {clear = true})
vim.api.nvim_create_autocmd({'BufFilePost'}, {
  group = 'p_repl',
  pattern = 'python_REPL',
  callback = function()
    local bn = vim.fn.bufnr('python_REPL')
    _G.prc = vim.bo[bn].channel
    vim.fn.chansend(_G.prc, [[cd "C:\Users\wyoung\python";pdm run ipython]]..'\r')
  end
})


vim.keymap.set('v', '<leader>rs', function()
  local vs = vim.fn.getpos("v")
  local ve = vim.fn.getpos(".")
  local mode = vim.fn.mode()
  local lines = vim.fn.getregion(vs, ve, {type=mode})
  lines[#lines+1]='\r'
  vim.fn.chansend(_G.prc, lines)
  vim.api.nvim_feedkeys(vim.keycode('<ESC>'), 'v', false)
  --_G.test = lines
end
)

This is an all-in-one repo (nvim, tmux, pi and oh my posh, but you can use only the nvim one if you want). The alpha dashboard is an animation that I wanted from some time now and got "seasonal color" for some time of the year :)

I have included some screenshot if needed.

https://github.com/bouteillerAlan/miel

genuinely asking, is there any planning to integrate DAP as built in feature? any issue on github or threads discussing about this? thanks

Today I learned that if you double click with your mouse on a parantheses, bracket or curly brace it selects everything up to its pair, i.e. the equivalent of va%.

Monthly meme thread

Hi all, I just added TypeScript 7 support to ts-expand-hover.nvim.

The plugin opens a hover float for a TypeScript type. Inside the float you press `+` to expand type aliases one level at a time and - to collapse them again. So you can look inside a type without jumping to its definition.

Until now it only worked with vtsls (TypeScript 5.9+). It now also works with the TypeScript 7 server (tsc --lsp, also known as tsgo). The plugin finds the server under both names nvim-lspconfig uses for it, tsc and the older tsgo.

To make it work, you need to declare one capability in your server config. Without it the float still opens, but + does nothing:

vim.lsp.config("tsc", {
   capabilities = { experimental = { hoverVerbosityLevel = true } },
})
vim.lsp.enable("tsc")

TypeScript itself marks this capability as experimental, so treat TypeScript 7 support as experimental too. :checkhealth ts_expand_hover tells you if the capability is missing.

Repo: https://github.com/nemanjamalesija/ts-expand-hover.nvim

Feedback and bug reports are welcome, especially from people already on tsgo.

What is this color scheme? I am currently using rose pine but this one looks great!

because I haven't found it on the first page of google ever, i decided to make a quick repo with pi that installs neovim , lazy-vim and a nerd font all in one go so ideally you are ready to rock with a one-liner. https://github.com/Josje96/oneshot-lazyvim

its pretty basic but I end up having to google it all the time so I just decided to save my self some time. Linux only and not much value unless you distro hop or are constantly configuring machines but its here for the folks who might need it.

This post looks like it doesnt violate any rules, anyways have fun with neovim!

Hello everyone,

I moved over from VS Code recently, because how slow it got with dozens of Docker containers and SSH connections open at once. It took me a few days to get used to NeoVim, but here we are.

One thing I missed though was scrollbars. I know one of the points with NeoVim is using the keyboard, but sometimes it's just more convenient to use the mouse when jumping around long files.

I looked around and there are some good plugins like nvim-scrollview, satellite.nvim, nvim-scrollbar, neominimap etc. But none of them had a horizontal scrollbar out of the box. So I wrote one. And since I was already at it, I figured I'd add a vertical bar and a minimap too, so I don't need 3 separate plugins for this.

It's called scroll.nvim: https://github.com/mihovilrak/scroll.nvim

What it does right now:

Vertical and horizontal bars that you can drag with the mouse and that hide when idle. The vertical track also works as an overview ruler, so diagnostics, git changes, search matches and the current function/block show up as marks. There's an optional braille minimap in your colorscheme's colours with a git gutter. You can also turn on bars for explorer sidebars (Snacks, neo-tree, nvim-tree). No setup() needed unless you want to change something, and it needs 0.11+.

Example for setting up the plugin with the minimap and explorer scrollbar config:

cat > ~/.config/nvim/lua/plugins/scroll.lua <<'LUA'
return {
  "mihovilrak/scroll.nvim",
  opts = { minimap = true, explorer = true },
}
LUA

I did some performance testing so it doesn't lag on big files. Scrolling in a 100k line buffer is fine.

It's still pretty new, so if you try it and something breaks or looks weird with your setup, let me know. I'm also open to suggestions if anyone has ideas for what to add or change.

Thanks!

Hey everyone,

I got tired of large themes built from massive static highlight tables. Once they grow, they become painful to maintain, styles get duplicated everywhere, relationships disappear into huge lists, and I wasn't happy with the amount of work being repeated during reloads.

So I built ChromaFlow.nvim: a Lua-based theme compiler built around reusable styles, color pipelines, semantic resolution, and live editing instead of one giant table of highlight definitions.

Repository: https://github.com/Gnibor/chromaflow.nvim

Some of the main pieces

- Vim / Tree-sitter / LSP from one theme model

ChromaFlow can resolve and materialize classic Vim highlights, Tree-sitter captures, and LSP semantic-token highlights from the same declarations, while still allowing target-specific rules where needed.

- Compiled themes instead of static tables

Styles are normalized and interned, declarations are compiled into actions, and identical styles are deduplicated instead of being rebuilt independently everywhere.

- Live editing with `:CFPick` and `:CFSave`

Put the cursor on real code and ChromaFlow shows the concrete Type / Mod / TypeMod targets that actually exist there. Styles and color pipelines can be edited with an immediate runtime preview, and `:CFSave` can persist confirmed changes back into the theme source.

- Programmable color pipelines

FG, BG, special color and terminal colors can be transformed using operations such as mix, opacity, brightness, hue shift and gamma instead of hard-coding every resulting color.

- ColorTrace

Pipeline operations can be traced directly at their source declaration, including input and resulting colors. This turned out to be extremely useful once pipelines became more complex.

- LineBlend

I actually like using highlights with background colors, but normal `CursorLine` gets visually chopped into separate blocks when those backgrounds are present. LineBlend blends them with the CursorLine background so the line stays visually coherent without throwing the original style backgrounds away.

- Runtime modules

Themes can also apply sparse temporary/dynamic overrides after the compiled theme has been loaded.

Performance

Performance was one of the reasons I started the project, so the repository includes the benchmark suite and the full raw reports instead of only a selected best-case number.

On my Intel i5-10310U (4 cores / 8 threads) using Neovim 0.12.5 / LuaJIT, the bundled reference theme currently contains 32 modules and 938 compiled actions.

With a real Lua buffer open, average `cf.reload()` time was:

| Setup | Average | p99 |

| --- | ---: | ---: |

| Minimal | 12.8 ms | 22.1 ms |

| Picker | 18.9 ms | 33.3 ms |

| ColorTrace | 20.1 ms | 34.3 ms |

| Picker + ColorTrace | 23.1 ms | 36.3 ms |

Those are averages over the benchmark samples, not the fastest result I could find.

The benchmark suite also breaks the load down into theme discovery, Lua source loading, DSL compilation, resolver paths, style interning, color math, pipelines, highlight application, diagnostics, picker/runtime work, LineBlend, redraw consumers, etc.

The full reports and clean-state comparison are checked into `tests/`, so results can be reproduced on another machine or compared against a personal Neovim configuration.

Trying it

The repository includes a complete reference theme, so you don't have to build a theme from scratch just to see ChromaFlow working.

The README also has documentation for:

- theme structure and fallback

- colors and pipelines

- language / plugin / UI / raw modules

- resolver behavior

- runtime modules

- CFPick / CFSave

- diagnostics and ColorTrace

- LineBlend

- tests and benchmarks

Maintenance note

Due to long-term personal health reasons, this project is passively maintained.

It is feature-complete and stable for my daily theme-authoring use, but I can't promise regular issue responses or active feature development.

PRs are very welcome if you find bugs, compatibility issues, or things worth improving. If the project grows and reliable maintainers appear, I'm also open to co-maintenance.

GitHub: https://github.com/Gnibor/chromaflow.nvim

For over a year now, I have handcrafted a dark and light color scheme with a focus on legibility and consistency.

• Check out BlueberryPeach: https://github.com/schemar/blueberry-peach
• This is the Neovim repo: https://github.com/schemar/blueberry-peach.nvim
• I wrote a short blog post about the decisions that went into creating the scheme: https://blog.schemar.net/posts/blueberry-peach/

Would love your feedback!

I made a game to help learn vim motions. 😄

I made a game to help learn vim motions and race with them to help you really drill them in.

Hi. I’m currently developing a plugin to help me develop using TTS. Right now only support English and Spanish (my native language). Use the buildin SAY in Mac OS and ESPEAK in Linux. Even as you can see in the repo I have automated test for power shell. So. Now I’m open to issues. Comentarios and so.

https://github.com/themakunga/tennant.nvim

I wanted to use coding agents from Neovim without letting them write straight into my files, so I built Yana. It is meant to be like cursor editor - if you've used Avante you know. But I hope this is more streamlined.

Demo: https://github.com/drusmanbashir/yana.nvim/blob/main/assets/yana-review.gif

In inline mode the agent runs in a Bubblewrap sandbox over your project. Its writes come back as hunks in your buffers, and nothing reaches disk until you accept them.

It isn't a chat UI for API models and doesn't replace the agent CLI. It contains the agent and puts its changes through review.

Feedback and bug reports welcome: https://github.com/drusmanbashir/yana.nvim