Last year I released videre.nvim, a plugin that lets you explore JSON, YAML, and TOML in Neovim as a dynamic graph. It was a fun project, but the codebase resembled spaghetti. Adding features became a slog, and a bunch of things I wanted to build just weren’t possible with how the original version was structured.

So I did the only reasonable thing: I nuked it and rewrote the whole plugin from scratch.

The rewrite is finally done, and videre.nvim is in a much better place: cleaner internals, new features, and a way nicer editing experience overall.

Highlights

• Full YAML and TOML editing support
• Completely updated editing UI
• New spacing options
• New alignment settings
• Settings validation (no more silent misconfigs)
• Better highlighting API
• More themes
• General QoL improvements across the board
• And most importantly: a codebase that doesn’t fight me every time I touch it

The plugin is actually moving again instead of being stuck under its own weight. If you tried the old version, this is a big upgrade. If you haven’t tried it yet, now’s a great time.

Repo: https://github.com/Owen-Dechow/videre.nvim

Hi,

If you ever wanted to have Which Key hints for nvim-surround, my new plugin has got you covered. I have a lot of custom surrounds and found myself in need of this functionality (e.g., “How did I configure Markdown links again?”)

Enjoy

Hello peoples,

With the release of pierre-style diffs, my plugin diffs.nvim is now fleshed out. Whether you're a plain diff viewer or plugin author, diffs.nvim is the most comprehensive diff highlighter in the plugin ecosystem. See for yourself:

diffs.nvim v0.4.0: various diffing methods

Above are three diffing modes:

1. Unified (botright): the classic "unified" diff that diffs.nvim pioneered, with stacked line numbers.
2. Split (top): a unified &diff (builtin vimdiff) style split preview with custom highlight rendering and synchronized scrolling
3. Stacked (botleft): like "unified", but see two line number columns according to the source and target, respectively.

As a recap, diffs.nvim is a robust and efficient diff viewer providing syntax highlighting to diffs. It's a must have if you use NeoGit, vim-fugitive, or want a more lightweight alternative to something like codediff.nvim.

Check it out here. As always, feel free to leave feedback.

I'm hoping to get treesitter-based diff highlighting in core in the coming months. This would mean you could see syntax highlighting on patch and git-diff style buffers natively, just by (likely) setting an option.

Lastly, I've learned a lot working on Neovim and learning from maintainers in recent months. Make sure to give them a shout-out for their consistency and hard work. Fun things ahead!

When I’m deep in a task, I keep bouncing between a small set of files.

I wanted something with near-zero thinking cost:

• one-key label jump to buffers
• pinned buffers for task-focused workflows
• quick pinned cycling shortcuts
• fast cleanup of unpinned noise

Inspired by flash.nvim and harpoon.nvim, I made QuickBuf.

Why QuickBuf

• Fast one-key buffer switch (label -> buffer)
• Pinned buffers = task focus (keep your working set tight)
• Even faster pinned navigation with :QuickBufNextPinned / :QuickBufPrevPinned
• Designed for brainless speed when context-switching a lot

Features

• Ranked list: alternate buffer first, then pinned, then MRU
• One-key jump labels
• Batch pin/unpin (V + T)
• Batch delete (V + d safe / D force)
• Split/vsplit/tab open mode (s/v/t + label)
• Fuzzy fallback on / (Snacks/Telescope/fzf-lua, or custom backend)
• Clear all unpinned buffers quickly (c/C)
• Optional devicons and highlight customization

Repo: https://github.com/tjgao/quickbuf.nvim

Would love for people to try it and share feedback/ideas.

In this video, I showcase 10 Vim macro examples that I've used throughout my programming journey. Some of them are truly awesome!

1. Capitalize the First Letter of Each Line
2. Capitalize the First Letter After a Period
3. Convert a CSV List to a JSON Array
4. Convert a Markdown List to HTML
5. Add Line Numbers
6. Convert a Log File to CSV
7. Convert CSV Data to an SQL Script
8. Convert Text to a Markdown TODO List
9. The Primeagen's Best Macro
10. Split Function Parameters

Hey, I used lazy.nvim forever. But, recently I became worried about supply chain attacks and how neovim/lazy can fall victim to it. I was also curious about the new native package manager (vim.pack). So, I built packard (pack + guard).

Every package update goes through a mandatory quarantine: fetch → 30-day cooldown → manual review (with optional inline AI diff analysis) → explicit approve/reject. Nothing installs without your say-so.

Built on native `vim.pack`, zero external dependencies, lazy.nvim-compatible specs, semver support, BYOK AI review, dependency resolution, and a full dashboard UI.

I've ran it daily with my 60+ plugins config, but would appreciate help debugging it.

https://github.com/ruicsh/packard.nvim

https://preview.redd.it/t985a286a46h1.png?width=2426&format=png&auto=webp&s=0f6d6344ad1fee5926bb644468ce45eca080227a

I created this plugin for my own use, and it evolved in my dotfiles over several months. Today, I decided to split it into a separate repository and publish it. https://github.com/kremovtort/tabterm.nvim

Hello I am back again LOL!

Fyler.nvim core rewrite is completed and user can use it for their general uses and this time it will work without breaking in some common cases.

Release is not published yet! but i will publish it this sunday. I am preparing the github organization and transfer it there because there will be some other optional community asked extensions gonna live.

There are some missing features that I haven't been implemented yet but those feature will be there in a week or two because i haven't decided their flow yet.

If you wanna give me some advice on github organization then am all ears and you can access the rewrite here:

https://github.com/A7Lavinraj/fyler.nvim/tree/refactor/quality-of-life

Let me know what you think :)

Just wanna share another addition to my config. I'm just bored.

``` local function define_word() local word = vim.fn.expand("<cword>") local buffer = vim.api.nvim_create_buf(false, true) local lines = nil

if vim.fn.executable('dict') == 0 then vim.notify("dict executable not found", "ERROR") return end

local command = vim.system({ "dict", word }, { text = true }):wait()

if command.code ~= 0 then print(command.stderr) return end

lines = vim.split(command.stdout, "\n", { plain = true }) vim.api.nvim_buf_set_lines(buffer, 0, -1, false, lines)

local window = vim.api.nvim_open_win(buffer, true, { relative = "cursor", bufpos = { 0, 0 }, border = "single", width = 90, height = 25, style = "minimal", title = word })

vim.api.nvim_create_autocmd("WinLeave", { buf = buffer, once = true, callback = function() vim.api.nvim_win_close(window, true) vim.bo[buffer].bufhidden = "wipe" end })

print("Dictionary", word) end

vim.keymap.set("n", "<leader>dc", define_word, { desc = "Dictionary" })

```

What it does is it creates a floating window for the definition of the word that's in the cursor. It's just a floating window for the output of dict <word> command.

📁 I've been using Oil for a long time and always felt a little friction from metadata being part of the editable buffer.

So I made this:

🔗 https://github.com/ergodice/statuscol-oil.nvim

✨ Features

• 📋 Render Oil metadata inside statuscol.nvim
• 🧹 Keep permissions, owners, sizes, icons, etc. outside the editable buffer
• 🎯 Prevent accidental cursor movement into metadata fields
• 👤 UID/GID display support
• 📏 Configurable size formatting and width
• 🛠️ A few additional QoL improvements

💭 Suggestions, feature requests, and feedback are very welcome!

Tutorial Demo

I've been building rubiks-cube.nvim — a playable Rubik's cube in a floating window: isometric ASCII render, Singmaster-notation keys, timer with best-time tracking, and optional auto-solve via kociemba. The feature that finally made me want to share it: press t and it teaches you to solve the cube you actually scrambled, with the classic beginner layer-by-layer method — a side panel walks through eight stages (white cross → white corners → middle layer → … → done), each with a short explanation and the next move.

• You can press n to let it make the move, or do the moves yourself.
• If you make a different move instead, it re-plans from your new cube state.
• No external binaries — the tutorial ships entirely in Lua.

Repo: https://github.com/xiangnongWu2233/rubiks-cube.nvim

Feedback welcome — especially from anyone who actually learns to solve the cube this way!

fork: https://github.com/starbaser/codewindow.nvim

A lot of times I found myself losing my train of thought while switching between branches, so I just created nvim-scratchpad, a simple branch-aware scratchpad to take notes in markdown before I leave a branch.

https://github.com/grohith327/nvim-scratchpad/

Hi guys!

Minifugit.nvim nightly version has an improved split diff view. It does not rely on the built in diff anymore, they are custom buffers with improved highlighting.

Try it if you find it interesting. Any feedback is welcome :)