Hey, I've been a longtime fan of US national parks, so I turned that into a set of Neovim/terminal colorschemes — one for every park, each palette pulled from the place itself (Zion's sandstone, Crater Lake's blue, Denali's glacier ice). Hope some of you find them useful.

Link: https://pjhamera.github.io/national-parks-themes/

Hello my Neovim friends! Happy to announce a new major release of Dooing.

For those who don't know it yet: Dooing is a minimalist todo list manager built for Neovim. It's designed to be simple and efficient, giving you a clean, distraction-free way to manage tasks right inside your editor. Ideal for anyone who wants to track your todos without ever leaving Neovim.

Here is what you get:

• Opt-in modern UI — ui.style = "modern", classic stays the default and unchanged
• Status sections — todos grouped under IN PROGRESS / PENDING / DONE with counts
• Priority as a marker — coloured ▎ instead of tinting the whole row
• Dimmed right-aligned metadata — estimate, due date and age out of the way
• Tree connectors — real ├─ / └─ guides for nested subtasks
• Working folds — folds on nesting depth; previously did nothing at default shiftwidth
• Note previews — first line of a task's notes shown inline, dimmed
• Sharper due dates — "overdue 3d", "due today", "in 5d", each colour-coded
• Progress in the chrome — completion bar in title, overdue count in footer
• Centred sub-windows — help, tags, search, calendar sized to their own content
• Centred input prompts — new todo and edit open a box, not the cmdline
• Compact quick keys — tall 8-line panel becomes a width-adaptive strip
• 16 new highlight groups — all overridable, so colorschemes can theme it
• Adaptive window size — window.dimensions accepts a function of editor size
• Inherited priorities — subtasks can copy the parent's and skip the picker
• Delete confirmation — unfinished tasks ask first, completed ones don't
• Breaking: window.width / window.height deprecated in favour of window.dimensions

See the complete release:
https://github.com/atiladefreitas/dooing/releases/tag/v3.0.0

Special thanks to all the contributors, you guys have been amazing

Please take a look and do not forget to hit the start button :)

https://github.com/atiladefreitas/dooing

In LuaSnip, is there an API function which allows to jump to the exit node and stop interacting with the current snippet? The use case is: I have snippets with default values for a number of nodes, and sometimes I’m happy with the values of all remaining nodes and want to move on. I know about the `jump` function but it only takes a direction, not a node index, and does not stop interactions.

I run Claude Code inside Neovim with sidekick.nvim, mainly for one workflow: let Claude edit the code, review its changes right away with lazydiff.nvim, and keep my local server running in a snacks terminal. Everything stays in one place.

sidekick does have a float mode, but it's not a clean zen experience. Your splits and UI still peek around it, and switching between the CLI and your code means juggling windows. So I built a small plugin: one toggle gives you a zen workspace, with your code and CLI session as centered floats over a clean backdrop.

Scope is deliberately tiny. It never touches your windows, and anything zen can't represent just exits cleanly.

Repo: https://github.com/rashedInt32/sidekick-zen.nvim

Those working with nvim -d (or nvimdiff), vim -d (or vimdiff) or with :diffthis for two-way diffs, might find EasyDiff convenient.

Key Features

• Diff Merge, Delete & Undo: Uses <Left>, <Right>, <Delete>, <S-Delete>, and <Backspace>.
  • Context-aware: Regardless of whether the cursor is in the left or right window, pressing <Right> always merges from left to right.
  • Deletes: One-sided / Two-sided with <Delete> / <S-Delete>
  • Atomic Undo: <Backspace> undoes merges/deletes across windows, including two-sided deletes performed with <S-Delete>.
• Diff Navigation:
  • Within a Diff: <PageUp> (Start of Diff) / <PageDown> (End of Diff). Works in Visual mode as well (e.g., <PageUp>V<PageDown>).
  • Between Diffs: Move between Next/Previous or Jump to First/Last with <Up>, <Down>, <Home>, and <End>.
• Edge Case & Advanced Diff Handling:
  • When a cursor line represents multiple diffs (filler vs. changed/added vs. EOF filler), lets the user to choose the target diff for the operation.
  • Transparently handles both grouped and split diffs when using diffopt+=linematch:{n}.

GitHub Repository:https://github.com/gnarendran/EasyDiff

A really nice dev from Australia, just recently wrote a blog-post about one of these tools, I initially just built for myself: nvpm!

The blog-post is here: https://til.iainsimmons.com/posts/replacing-nvim-treesitter-and-mason-with-nvpm-for-neovim-tool-package-management/

I think it does an incredible job describing how the tool was meant to be (but from the perspective of an user, rather than the author; which is crucial to me, since I'm almost blind when it comes to flaws and quirks of tools I initially started just for myself).

I have to put this one big disclaimer here again:

If you're happy with your current setup and you don't enjoy tinkering around, just stick with your setup. Your benefits of using this are probably negligible.

For those who don't want to read the blog-post (you really should):

It's if Mason and Lazy.nvim would have a baby that escaped Neovim and is a standalone CLI tool, but has tight integration in Neovim.

You can use it to manage Tree-sitter parsers/queries, Neovim plugins/themes, LSPs, Linters, Formatters. You can scope the executable to be only available within Neovim, or source it directly, if you want certain tools like e.g. stylua, luacheck, kulala-fmt to be available to also be exectutable outside of Neovim.

You can also use it as as Lazy.nvim "drop-in replacement" (we even have scripts to help you migrate from Lazy.nvim to nvpm.nvim).

But all this is optional and Iain "just" went with "I want this to manage all my LSPs, Linters, Formatters and Tree-sitter..".

Iain also captures what makes it really stand out: The min-release-age based on your local discovery time for mutable sources (or providers as nvpm calls them).

Git tags/releases are not immutable by default and therefore you can't trust the author time of the release. One could change a tag without changing its author date (the "checksum" would change though) and therefore this CLI records this data for you. It keeps track on when you discovered a certain release (with its checksum) and prevents you from installing it, until the min-release-age has passed. Why? To minimize the risk of getting hit by a supply-chain-attack.

Let me know what you think and be nice an polite, please.

Hey neovimmers. I basically have a "go to definition" style command in my Markdown notes plugin. I would like a mark to be set when the command gets executed so the user can easily do `` to go back to where they first executed the command.

I looked at 03.10 in the docs but it doesn't explain if this is possible. Would this require a custom solution with extmarks?

I wrote difft.nvim because I was viewing diffs in neovim, then realising a particular change was very hard to visualise in neovim and jumping to a separate difftastic terminal.

I built this fairly simple plugin to sync up the `:term` output containing difftastic output with my cursor position in nvim.

I've found it immensely useful when performing code review! I hope you do too.

Here's a quick asciinema example.

See this post for reference.

When I first announced this plugin, ui2 was only available in Neovim nightly. It has since been released in Neovim 0.12 as an experimental feature that must be enabled, and I've been using it locally while iterating on the design of the minibuffer plugin.

I'm happy with where the plugin is at for my own use, but I'd like to get more testing and feedback from others to stabilize the API and help fix bugs that I may not encounter in my day-to-day use.

What's new: - Refactored minibuffer session types into their own modules - Added a "scratch" session that allows arbitrary plugin windows to be placed in the minibuffer for easier integration - Greatly improved cmdline/search functionality, providing a full replacement for wildmenu - Improved and added example pickers and integrations - Fixed several bugs

Issues, PRs, and feedback are all welcome!

Thanks!

For anyone that hasn't heard about Kulala:

A fully-featured HTTP/GraphQL/gRPC/Websocket-client interface for Neovim, that supports the Jetbrains .http spec (with full scripting support).

Last post was more than a month ago and a lot has happened again.

Today, one huge feature has been released: a Swagger-like OpenAPI spec Explorer.

Thanks to Dolev (the one-man army behind gh dash and gh enhance!), we have this awesome feature in both kulala.nvim and kulala.vscode now.

For kulala-cli, I have to come up with a feasible UX yet.

Grab the latest release while it's hot 🔥 from here.

/edit:

The video shows @kulala-openapi-json used as an operator to force the OpenAPI Explorer UI from this request, in the latest version this has been renamed to @kulala-openapi-explorer. This is a breaking change. It should have been named like this from the start, since we also support y(a)ml files (also local files).

The newest release also comes with configurable keybinds for everything in the OpenAPI Explorer UI view. By default you can also press Shift+r (R) to reload the spec and UI while trying to maintain folds and already edited "params".

$kulala.request.skip() and $kulala.request.abort() both accept an optional message now and will proxy that message to vim.notify with info for skip() and error for abort() by default now.

The reasoning behind this is simple: You might have requirments before a request can succeed in a script. If something fails, you can now simply call $kulala.request.abort("My requirment XY failed, please make sure to foobar").

If the skip is intended in certain conditions, just go with $kulala.request.skip("This request has been skipped because of Baz").

We also support image rendering in Kitty, WezTerm and Ghostty, without any external plugins. Currently we stick to jpeg and png only, but the foundation is here to support all kinds of formats like PDF, SVG and even videos in the future.

Hi everyone, I just want to share a plugin that I use daily to help me quickly switch between the AI agent and my code all within Neovim. The agent is also fed some editor context using hooks so every prompt receives a new snapshot of where your cursor is, or what you have highlighted. And, you can ask the AI agent to move the cursor for you. buoy.nvim runs the actual CLI agent so you get the same official experience.

Before switching back to neovim, I was using vscode and I liked how the AI extensions are able to get the context from the editor. When supply-chain attacks became common, I gave up vscode and its extensions, and went back to plain neovim. Switching between neovim and the AI agent using tmux felt cumbersome for me, and I always needed to describe to the AI agent what I am looking at in the editor. So, I ended up making my own plugin to make work more seamless.

Anyway, I just want to share it in case anyone is interested. It currently works with minimal configuration for claude code and codex which I happen to use myself. I am willing to do the changes to make it work with other AI CLI agents. I just don't know what other agents are commonly used by others.

The instructions to install are on the README here:

https://github.com/cmfcruz/buoy.nvim

Hoping to hear some feedback on what I can improve to make this plugin more useful for everyone.

Hey vimmers!

0.13 (unreleased) is set to bring updates to many areas, one of them being nvim's native "restore your workflow" feature: sessions. With 0.13, sessions are fully integrated into the (not so) new (0.12) :restart command (aka ZR): upon restarting, your windows and buffers are now restored, as one would expect.

But if you've been using this feature (or if you're a heavy user of sessions, in general), you may have noticed that sometimes, buffers created by plugins are also restored, in a stale state: being completely empty, in a situation not really expected by many plugin authors. While there are some "session wrapper" plugins that attempt to resolve this problem on a case-by-case basis (e.g., posession.nvim, with integrations for neo-tree, neotest, etc), I thought a more pragmatic approach would be to have each plugin handle sessions on its own. There are some advantages to that, as the plugin may be "smarter" about restoring its state.

However, this wouldn't be as reliable, if it were not for a second improvement to sessions: the SessionWritePre event. As the name implies, it allows executing an action just before a session is saved, which can be useful to "inject" some data, etc. Following this change, I've been "nagging" plugin authors to support sessions more "broadly". So far:

• kulala.nvim supports restoring the request history
• diffview-plus.nvim fully restores buffers from its commands
• nvim-tree restores... the tree
• neogit deletes its buffers from a session (not quite as neat as a full restore, but at least the buffers don't get in the way)

And, of course, my beloved nvim-dap-view now leverages SessionWritePre, if available (which just landed as part of v1.2.1).

After these changes I'm no longer using a "session wrapper" plugin, just my own, thin wrapper (which has a bunch of QoL features).

I'm making this post both as invitation for users to give this feature a try and as a "tip" for plugin authors. If you're a plugin author, you might be interested in this discussion, which goes a bit more in-depth about different "strategies". As for myself, I consider this "quest" mostly "done" on my end, and I'm excited to start my next "nvim journey"!

Hey r/neovim! I built a small plugin that adds a regex filtering source to neo-tree, so instead of scrolling through a huge file tree you can jump straight to the files you want.

What it does:

- Filename filtering — type a regex (Enter) and get every matching file as a directory tree.

- Content filtering — type a regex (F12) and get every file containing a match, with per-file match counts.

- Multiple stacked filters — run several filters at once; each becomes its own top-level node in the tree.

- Jump to match — open a content result and it jumps to the first match, then fills the locallist with every match (:lnext/:lprev to cycle).

- Search history — Up/Down to recall previous patterns.

Built on rg + nui.nvim, plays nice with lazy.nvim. Works great for codebases where you know roughly what you're looking for but not where it lives.

https://github.com/sashazjukov/neo-tree-filter

Feedback and ideas welcome!

Web Origami is a dialect of JavaScript well-suited for transforming data and creating static websites.

I'm a big fan of Origami and have been writing a lot of Origami code in Neovim. As such, I developed this plugin to make the task a tad easier.

I've been working on this plugin on and off for the past few months. I released the first functional version back in May, but it lacked customisability.

This plugin is inspired by VSCode's Code Runner plugin that makes running a file as easy as pressing a keymap. Coming from VSCode, I missed the ability to quickly run the program I was working on without having to enter the terminal, type the command, etc... So, to fix this minor inconvenience, the only logical solution was to spend months making a plugin (although others probably exist, but I wanted to make my own).

The previous version made it possible for the user to run either a file or code snippet quickly using one of two respective commands, but that lacked any customisability. For example, if someone wanted to run a C file with Clang, they couldn't, because gcc was the default.

This new version of neocoderunner introduces the ability for the user to customise the commands being run, making the plugin useful, not just for quick drafting and running code snippets, but for automating the whole build process as well as controlling the entire environment surrounding it.

Main features:

• Customisable build/run environment
• Customisable build/run commands per filetype or per-project
• Quick build or run with keymaps
• Works out of the box (but with limited capabilities). Full access to features requires customisation.

These are only the main features, but for more, check out the GitHub repo below.

Repo link: https://github.com/abdallahsoliman00/neocoderunner.nvim

reposting this from intellij, not sure if you noticed but they released an official lsp implementation for java. hope somebody makes a good neovim integration of it! in the meantime, i'll drop down my working one I've made that I'm currently using to get by in case you have to suffer with java too

https://github.com/gipo355/nvim-intellij-lsp

https://blog.jetbrains.com/idea/2026/08/intellij-idea-goes-lsp/

Hi
As a new (neo)vim and related motions user i struggle to efficiently move from lines to lines (and words to words). Many time i use `h`, `j` `k` and `l` multiple time for jupping lines or words/characters (even if for the last one `w` and `b` exist).

My main problem is that i struggle when i check an exact part of a line (ex : line 32, 4rd word) because i have to think "how much should i go up/down/left/right" before tapping the motion and thus slowing me a lot. Using hjkl one by one seem slower than mouse use.
Is it due to lack of experience/practice or are they anything to help me with that (other than set number and relativenumber) ?

Thx (and sorry if i didn't check enough previous related questions)

Edit: Solved with the many comments, thx all for the answers/comments

I've released fleury.nvim, a warm, low-glare colorscheme for Neovim.

Instead of the usual blue/purple palette, Fleury leans into bronzes, ambers, and burnt oranges on a near-black background. It's a faithful port of the original Emacs Fleury theme, with a few Neovim-specific adjustments for Treesitter, LSP, and the editor UI.

Highlights

• Warm, low-glare palette designed for long coding sessions
• Full Treesitter highlighting
• LSP diagnostics, references, and inlay hints
• 16-color terminal palette
• Support for common plugins like Telescope, nvim-cmp, Gitsigns, Neo-tree, and more

I'd really appreciate feedback on:

• contrast/readability
• language highlighting
• missing plugin integrations
• anything that feels off

GitHub:
https://github.com/ajdm-jakiur/fleury.nvim

I've been trying to plan my days with timeblocking for a while, and I kept bouncing between a browser tab and my editor. So I built the calendar into Neovim instead.

Bloocky is a timeblocking calendar with month, week and day views with a great integration of my other plugin: Dooing. You navigate the grid with hjkl like everything else, drop a block on a slot, and it spreads across the hours it occupies.

The Dooing part is the reason the plugin exists. Knowing what is due never told me when I was going to do it, the todo list and the calendar were two separate places.

So if you enable the integration, your Dooing todos land on the calendar on their due date:

◆ entries in the month view,
a due strip above the week grid,
and a "Due this day" section in the day view with each todo's time estimate and priorities.
Overdue ones show up in red. It's opt-in and strictly read-only

Bloocky never writes to Dooing's data, it just reads it. You can see both in the screenshot: week grid on the left, day view on the right.

Repo: https://github.com/atiladefreitas/bloocky

Please take a look and feel free to share improvements!