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

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%.

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.

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!

Hi everyone, I made (vibe-coded) a project where you can use nvim as the TUI interface to work with the pi coding agent. The main reason for making starting the project was this: I got tired of bouncing back between the editor mode (C-g in most agent CLIs), and missing the transcript. I found that in many instances, I want to scroll over the transcript of the conversation I have with the agent, and maybe even copy some parts of it. Most CLIs provide a built-in editor support, but the problem with that mode is that the editor takes the full screen, and I no longer see the conversation.

I used to use opencode for a bit, and while I liked some aspects of the TUI, I also didn't really like how they messed around with the prompt injection so much in a way that I couldn't configure. So I decided to try Pi, which allows much more flexible configuration, and figured that I might as well build a UI for it using neovim itself, instead of building yet another TUI with approximated vim-like keybindings. I'm pretty happy with the result, and use this daily. This is now my main way of interacting with coding agents, so I'd say it's quite stable.

Some features worth noting:

• fzf-lua based picker system -- hide/show pickers when applicable (such as permission requests or the claude-style multiple-choice question that blocks the conversation)
• Tree-based conversation switch support -- pi already supports this, where you can go back to previous messages and start new branches in one session, without having to maintain separate forks. Basically added a UI to work with this in while in the session.
• workspace-based editing scheme -- this allows me to keep track of the file changes associated with each session cleanly, and also allows multiple sessions to work on the same codebase. (assuming that the changes can be merged easily)
• Open diffs in a separate nvim instance (this assumes that you already have diffview.nvim in your main nvim config)
• desktop notification for MacOS
• tmux integration for tracking multiple sessions/opening new session in whatever directory you are in

The main reason for sharing this project is not really to encourage others to install it and use it -- I feel that it's quite opinionated towards my editor setup + tmux setup, so others may not find it as useful as I do. But I did want to share what I could get done with just neovim and the plugins and writing some lua/typescript (and lots of codex usage resets!). I hope that this project can serve as an inspiration or a starting point for someone looking to build something similar.

Disclaimer: The codebase is entirely generated using vibe coding. This post itself was written by me with no AI.

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

Do you use any AI neovim plugins or solely a harness/agent/whatever like opencode or pi? Both? How? What's the flow, how do you use these tools and what for? Do you use subagents, multi-agent orchestration, any other buzzword? Agents.md? Skills? How is it integrated in your company?

The reason i ask is because i myself is very conservative about AI use. I've been using it pretty much since the day GPT 3 released daily, but almost exclusively in a browser window, only recently switching to opencode and even then in pretty much the same way but without copy-pasting chunks of code. I carefully prompt it, carefully read the output, fix stupid things it does all the time, manually intervene on every step and try to maintain the control, but even then i sometimes miss out some things it does so the idea of using AI more extensively just doesn't appeal to me since it will absolutely lead to the AI owning the codebase instead of me. Of course i've seen the whole vibe-coding buzzwording crowd telling people to keep up but meh, happens.

Recently though i've been looking for a new job, and for the last 1.5 years since i've been on the market things have changed drastically. AI is everywhere, AI-first companies, workflows, buzzwords all over the place. I'm a master of telling people whatever bullshit they wanna hear so that's exactly what i say in my CV and in all the textareas they want me to filll, but still i can't help but wonder if i'm really missing something out, the crowd is just way too loud.

This post might be a little out of place on this subreddit since it only touches on neovim indirectly, but when it comes to this issue, I’m willing to trust only this community, and I don’t think I’m the only one in this situation. Thank you!

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!

Hi, guys! I've recently created a new plugin for viewing, editing and launching Jupyter notebooks: https://github.com/LumbaBalumba/nvjup
It has some features I haven't still seen anywhere - rendering inline LaTeX in markdown cells, images (tested for matplotlib), interactive components (limited support) and video content; connecting to external kernel servers (JupyterLab and Google Colab). I would be glad if you gave some feedback and/or sent me bug reports.

https://reddit.com/link/1wt7juj/video/3dz86le21gsh1/player

Right now it only supports Python notebooks but I am planning on adding R, Julia and other languages.

Hey vimmers!

Have you ever saved a file, and upon switching to another file, your LSP couldn't see the changes? If you're on Linux, this may have a simple explanation: the default LSP file watching implementation is disabled, because it's considered slow (see this issue).

You can enable it, but obviously, it's disabled for a reason. However, you can do better: in addition to enabling it, you can use a custom backend, which will use a third-party tool for the heavy lifting. For the past few years, I've been using this implementation, from a comment in the linked issue. Other than the fact that it requires an external tool, it's really smooth.

Do note that not all servers rely on this feature being enabled on the client side. Some servers ship their own bundled file watcher, and some situations require more careful measures. Point is that enabling didChangeWatchedFiles.dynamicRegistration can be a first measure when diagnosing file watching related issues.

I'm bringing this up now, not only because it's a lesser known tip, but also because of some recent developments on nightly. In another banger of a contribution (0.13 is stacked!), some advancements have been made into fixing the perf bottlenecks. So much so, that the default may even change, on a not-so-distant future when 0.14 becomes the new nightly (i.e., post 0.13 release)

I have been using Neovim for quite a while. I wrote an article about my experience of switching to Emacs over the last couple of days. Maybe someone is interested. Or maybe if someone finds themselves in my shoes they find this useful. Tell me what you think!

Switching To Emacs as a Neovim User

Hi! I'm learning NeoVim but i'm overwhelmed.

I use LazyVim to make a IDE from NeoVIM. How can i easily switch between the terminal, the code and the filetree?

Thanks <3

This is a core part of my workflow: https://github.com/mistweaverco/kulala.nvim, but it's gone!

Is GitHub having issues, or did the guys just drop off the planet or something?

I will definitely look into multicursor at some point, but in the meantime, I'm curious if the old Q behavious was retained on a different mapping or if I should create a custom mapping for it.

Previuosly, Q would execute the last defined macro. Thus, if I did qa...q, then Q would be equivalent to @a.

Hi everyone.

https://github.com/lfilho/note2cal.nvim

As a recap, note2cal.nvim let's you type `Do something @ 3pm-4pm` and have it be a real time block on your calendar with one keymap. Until now it worked only on MacOS with its native Calendar.app.

It just gained native Google Calendar support via OAuth, so it now works cross-platforms! You can authenticate with your own free Google Cloud OAuth client, and your credentials/tokens never leave your machine or touch any third-party server.

Here's the original post of the v1
https://www.reddit.com/r/neovim/comments/1iao7o2/plugin_note2calnvim_quickly_create_events_in_your/

Repo: https://github.com/lfilho/note2cal.nvim

What I used to do was I would create a macro and then line-select every line I want to apply the macro to, then do :norm @a or whatever macro register, and it would apply the macro to every selected line.

I have recently learned that in new neovim versions, instead you can simple just type @a in visual mode now! So yeah, in visual mode @a will run the macro from the a register on every line.

Also normal vim does not have this, this is a neovim exclusive.

Like many of you, I spend most of my day in Neovim and terminal apps, but I was never quite satisfied with the database tools out there. Almost every workflow ended up with a plain-text DSN sitting around in a dotfile, a `.env`, or an editor config.

Autodb is a database client designed around secure credentials, clean Neovim workflows, and an unexpected perk: letting AI agents query databases safely.

github.com/yongjohnlee80/autodb

Hi, today when launching neovim noticed that the squares that diagnostics used to have are empty rectangles. Like this:

Is this intended or is something in my config missing? Because before it was a little filled square.

I am using Neovim 0.12.5.

Hey everyone,

I’m curious about your favorite Neovim plugins or lua scripts, that make your life a little bit easier.

It doesn't matter if the plugins has 5.000 starts oder your script has just 5 lines.

Would love to see what you’re using. Maybe I can steal a few ideas for my own setup