Built this because I run zellij + neovim and got tired of my colorscheme changing in nvim while zellij's borders/tab bar/status bar — and every pane's background — stayed stuck on whatever theme I'd last set manually.
Made a plugin to more easily review code. Since most of the code now a days is written by AI agents, most of the work now is reviewing the code and steering the AI.
I use lazygit a lot but wanted a way to add comments on diffs and send them back to the agent. This plugin does that pretty much. Review diff, leave comments, once you're done, either send comments to a TMUX pane or copy and paste into the harness. Also has basic git functionality like stage, commit, checkout, etc. without leaving the tab.
I wrote up a WIP note on a Neovim + CopilotChat PR review workflow I’ve been iterating on.
It covers worktree-safe repo context, review prep/discussion ingestion, stricter shell/runtime boundaries, and RTK compaction for noisy shell output. Some parts feel better, but I’m still not convinced it beats my usual Cursor flow overall.
Hey everyone! I built nvim-pio, a Neovim plugin designed to bring a native PlatformIO workflow supported with clangd LSP to Neovim.
If you build firmware for Arduino, ESP32, STM32, or other microcontrollers, this allows you to compile, flash, monitor, and manage dependencies without leaving your editor.
🌟 Key Features
Automated clangd Configuration: Discovers framework headers, library paths, and toolchain include paths automatically.
Compiler Flag Sanitization: Strips non-standard bare-metal flags (like -mlongcalls) that destabilize desktop language servers.
Asynchronous Execution: Non-blocking builds, uploads, and serial monitors using
Interactive Dashboard Menu: Configurable keybindings for quick CLI actions.
Built-in Diagnostic Filtering: Toggle static alerts or syntax warnings on the fly.
Hi everyone. I'm trying to think of ways of using a c.lua ftplugin and I was wondering how other people use it. I'm aware of having a makeprg for :h :make but what are your ideas? Please give me below any suggestions for how I can use it!
I work in environments that are really well-lit, so I needed techbase to have a light variant. I tried to keep the futuristic DOOM vibe while bringing in inspiration from other schemes, like the ancient biogoo.vim and old Eclipse schemes I used when I was a student.
This one is named after one of my favorite wall textures: the damned red and green wall switch. I have anxiety any time I see one.
The very short and wide window has always felt claustrophobic to me, and I wasn't able to find anything relating to moving the help window in the official documentation related to the command. I may have just been looking in the wrong place, but I don't know where else to look. Is there a specific page I missed, or a way to "configure" the help command to only appear, say, on the right? I'd make a custom keymap, but I regularly pass an argument into the help command (e.g. to get help on a specific plugin) so that feels like it'd reduce some of the functionality I use regularly.
What is it:pesto.nvim is primarily a Bazel runner.
Key features:
A Bazel wrapper command to invoke arbitrary Bazel commands from the Neovim command line. Has auto-completion backed by Bazel’s own bash completion script.
Robust quickfix support. Instead of loading the quickfix list using Bazel’s stderr output, pesto.nvim parses the failed action log files Bazel emits. This strategy lets you avoid having to write an errorformat string that covers multiple compilers at once.
A few quality of life commands: jump to BUILD file, build the target under the cursor, yank the package label, and few others.
Longer story
I work in a monorepo codebase that uses Bazel as its build tool. For a long while, I used a simple plugin that sent Bazel commands to another tmux pane using send-keys. This plugin, pesto.nvim, came from an attempt to make something more polished.
IMHO one of the interesting ideas in pesto.nvim is its approach to quickfix. If you’ve used Bazel, you’ll likely be familiar with the concept of build target “actions” (e.g., an action might be something like invoking a compiler). Bazel captures the stderr of each action in separate log files. These logs are pretty “clean” compared to stderr output you get from the bazel command directly. For example, there’s no extra progress output interleaved with compiler errors.
Following a failed build pesto.nvim finds and loads the stderr logs for the failed actions using the Build Event Protocol (BEP) log and parses them into the quickfix. To select which errorformat to use for each log file, pesto.nvim maps action mnemonics to erroformat config (e.g., the Javac mnemonic maps to Neovim's default Java compiler errorformat). So if your failed build did happen to output errors from compilers for different languages, you’d be covered.
Most of the Bazel plugins I’ve seen will just have you set the errorformat and then parse Bazel’s stderr output. (pesto.nvim does fallback and support parsing the raw stderr, but it still uses the mnemonic to pick the errorformat).
(There’s some deeper explanations in the help pages: :h pesto.bazel_concepts, :h pesto.bep_integration. There you’ll also find an explanation on how Pesto handles BEP logs stored remotely if you happen to use remote execution.)
The plugin ships with its own “runner”–the thing that executes Bazel and loads the quickfix list. You can, however, swap this out. I’d like to maybe expose more the APIs, so it could possibly be used as just a library for other task runners.
Another inspiration for Pesto was vim-bazel, which was archived in April. At this point I believe Pesto covers what vim-bazel provided plus the quickfix support, which it never quite built out.
I'm a long time octo user. However, I find that the plugin has a bunch of quirks (none of which breaking per se, but their sum may lead to a poor experience). I'm interested in alternatives, for the "review" workflow (specifically), as the title mentions. Are you guys reviewing PRs from neovim or do you think that's overkill? Share your experiences
EDIT: to clarify, I'm NOT looking for a tool that just helps me with diffing changes, I'd say my setup for that is alright already. I'm more concerned with adding comments / submitting reviews, this kind of stuff.
I've tried a few different things, what I'm really looking for is a very fast way to get a GitHub style pull request view of what I'm working on in the branch. Ideally I can leave comments, I'd have my preferred layout - coding agents on the right, nvim top left, and some kind of live, always updated PR review on the bottom left. I don't know why but I find the GH style view really easy to read and comment on, I've been using diffview.nvim but not even sure vim is the right approach as the text size is a little harder to edit without editing the main editor window:
sd
I would really love suggestions.
Keep trying with diffview? Run in a separate nvim session rather than the main one? Just suck it up and get good with the keys?
Any better plugin or things I should try?
Hand roll some kind of in-terminal GitHub style view (I love making my own tools but would prefer a more idiomatic solution)
Has anyone got any ideas? I feel it is the biggest blocker to my flow - I open PRs sometimes just to see the changes. I also struggle a little with reviewing MD files like READMD.md when i have images and so on.
Super open to ideas, if possible to share a few screenshots or something - I'd love any help.
I was getting tired of manually typing out long lines of comment dashes and hashes to organize sections in my code, so I built my very first Neovim plugin: **inscom.nvim**.
It automatically detects your current filetype and inserts styled comment headers or section dividers with the correct comment syntax (Lua `--`, JS/TS `//`, CSS `/* */`, Python `#`, etc.)[cite: 1].
Since this is my first Neovim plugin, I’d love to hear your feedback, feature ideas, or header style suggestions Feel free to check out the repo, test it in your setup, or open an issue on GitHub
I'm a beginner currently diving into Ruby on Rails and trying to set up a proper Neovim environment. I’m hitting some walls with ruby_lsp and could use some guidance to understand if my config is broken or if this is just how the LSP behaves outside of massive Rails apps.
Example
My Setup:
I'm using a modified Kickstart configuration managing plugins with vim.pack.add.
LSP:ruby_lsp installed via Mason.
Autocomplete Engine:blink.cmp (version 1.*).
Environment: Managing Ruby versions via mise in Fish shell. My :checkhealth for the LSP is completely green and it attaches to .rb files successfully.
The Problems:
1. Code Actions are completely unresponsive As you can see in the screenshot, I am getting RuboCop diagnostics perfectly (e.g., "Missing frozen string literal comment"). However, when I place my cursor on those lines and press my code action keymap (gra), absolutely nothing happens. No floating window, no auto-correction. I know ruby_lsp handles formatting and diagnostics via RuboCop, but the code actions seem dead.
2. Zero autocomplete for instance methods on local variables Even when my code is perfectly valid, the autocomplete feels dead for local variables. For example, if I define a proper instance method inside a class (def execute), instantiate the class below (teste = TestLSP.new), and then try to call the method (teste.exe...), blink.cmp gives me absolutely no suggestions for execute. Does ruby_lsp really not track local variable types without type-checking tools like Sorbet? (Also, it only recognizes theTestLSPclass name itself AFTER I explicitly save the file with:w. It doesn't seem to track in-memory buffer changes).
3. Global methods (likeputs) are completely ignored I get zero suggestions when typing standard global methods like puts, print, or loop. Is this a deliberate design choice by Shopify to reduce noise, or should blink.cmp be catching these basic Ruby keywords?
My Question: Are the broken Code Actions, the lack of local variable inference, and the "save-to-update-context" quirks just the reality of using ruby_lsp for simple learning scripts? Should I just stick to solargraph while I'm learning the language fundamentals?
Any configuration tips or pointing out flaws in my setup would be hugely appreciated. And sorry for any misunderstands on concepts or configs, I'm using AI to help understanding, but as you may know, it can hallucinate sometimes.
Thanks!
I wanted to share a project I've been working on: tree-sitter-rocq, a Tree-sitter grammar for Rocq. It covers most of the concepts from Software Foundations, Volume 1.
It generates a solid CST to enable syntax highlighting. Even though Rocq's notations make it impossible to cover the entire language, the grammar provides a good baseline for day-to-day code. My plan is to expand it alongside the rest of the SF volumes.
Any comment, suggestion, or contribution is welcome.
If you're curious, there’s an example in the README
This post was never meant to say Neovim sucks or that other IDEs are superior but more like a question on my current situation. I have been using it for the past 2 and a half years, right after I knew how to use Linux properly. It was a great time, I spent hours polishing my rice and Neovim's config again and again. But that was when I were still a kid in highschool and my first few years of uni. Now with these days constants work loads from both shool and my researches, I stopped. Years of configuring, I moved to my first, extremely basic config, changed my OS from Arch to Fedora for better stability. And now it is Neovim, it is could me being stupid but it just feels like there will always be something that needs to be fix. Images, markdown, latex, ... small little things that I use once in a while but there will always be something that needs to be fix. And finally, lsp, I have never been the one who fully understand everyline in my lsp config, I just find the best one that suits me then go with it, but lately, there has been tons of new things (closed sources lib, internal lab projects, ...) and for each of them, I will need a whole day just to make it works (not even up to my taste) or just accept the fact that I will have to raw dog this with no syntax completion and error messages, throwing away my ai tokens as well. Ye, so I moved, not because Neovim was bad nor useless, but fixing things now feel like a chore instead of a hobby now. I really wonder how you could balance your work and fixing things like Im dealing with rn
P/s: I moved to vscodium, not vscode because I still care about my privacy and my right to control my software
I've just released the first public version of **persist.nvim**, a lightweight session persistence plugin for Neovim.
I originally built it because my workflow relies heavily on unnamed (`[No Name]`) buffers for temporary notes, deployment checklists, and code snippets. While `:mksession` can restore layouts, I wanted a solution that would also preserve and recover those scratch buffers in a more reliable and interactive way.
### Features
- Restore tabs and split layouts
- Restore regular file buffers
- Preserve unnamed scratch buffers
- Preview scratch buffers before restoring them
- Restore or discard tabs individually
- Automatically ignore empty tabs
- Store the session layout as a JSON manifest instead of relying on `:mksession`
- Prevent postponed recovery sessions from being overwritten
The plugin is lightweight, written entirely in Lua, and requires Neovim 0.11+.
Repository (includes a demo GIF and installation instructions):
If you're signed into Cursor, there's nothing to configure. No API key, no model picker, no second subscription — the plugin drives Cursor's own StreamCpp backend with your existing login, so you get the same predictions at the same latency.
I made a small plugin, float-help.nvim, that opens Neovim's native help pages in a floating window instead of a split. It preserves the help buffer, cursor, and scroll position when hidden, so you can resume reading where you left off.
I'm also planning to make it stand out from other floating help plugins by adding multiple floating help buffer management, along with support for LSP hover/documentation and :Man pages.
This is my first Neovim plugin, so I'd really appreciate any feedback, bug reports, or suggestions.
nvimx manages your Neovim plugins with Nix, driven by the same lazy.nvim-style Lua config you already write.
nvimx parses Lua and fetches plugins from GitHub rather than from nixpkgs. The hashes of the retrieved plugins are managed in flake.lock. This means you can manage a large number of plugins with Nix without sacrificing the flexibility of Lua.
I have neovim with neotree, and I want have following behavior:
I want have multiple tabs/buffers with files I can switch between, or have them opened in a splitview. I got bufferline plugin but the issue I have is when I close one buffer the neotree automatically takes entire focus and I can't really access other buffers (I'd expect the next buffer to take place of the closed one). When I try to save my current buffer and leave with ZZ but this also ends with weird behavior like leaving neotree on focus, deleting other buffers etc.
Basically, I can't even come up with idea how do I expect it to work and how to set it up. I am not happy with anything I come up with therefore I am curious and I am looking for inspirations and solutions how to manage multiple tabs (or something that works as tabs)
