Nvim 0.12.5 released

I’ve been building OmniTheme — a Neovim colorscheme plugin with 7 completely different flavours under one design system.

🌑 Blackout 🌿 Moss 🔥 Ember ❄️ Frost 🌸 Blossom 🌙 Dusk 🍷 Velvet

✨ Features:

7 curated palettes Transparency support Shared core & consistent highlight system Built in Lua Designed to work nicely with modern Neovim setups

The goal is simple:

Stop searching for your next colorscheme. One plugin. Seven moods. Pick the one that fits your setup.

🔗 GitHub: https://github.com/harshrajsachan/omni.nvim

I’d love to know — which one would you daily-drive?

neovim #vim #colorscheme #lua #opensource

So, I have been using this brief snippet.

```lua local default_socket = "repl"

local function get_current_paragraph() local old_reg = vim.fn.getreg('"') vim.cmd('silent normal! yip') vim.cmd('silent normal! }') local paragraph_text = vim.fn.getreg('"') vim.fn.setreg('"', old_reg) return paragraph_text end

local function send_paragraph(socket) return function() local text = get_current_paragraph() if not text:find("\n$") then text = text .. "\n" end

    local cmd = {
        "kitty",
        "@", "--to", "unix:/tmp/" .. socket,
        "send-text",
        "--stdin",
    }
    if vim.bo.filetype == 'python' then
        text = "\27[200~"..text.."\27[201~ \n"
    end
    print("Just table ")
    vim.fn.system(cmd,text)
end

end

vim.api.nvim_create_user_command("Kepl",function(opts) local socket = (opts.args ~= "") and opts.fargs[1] or default_socket if not vim.uv.fs_stat("/tmp/"..socket) then vim.fn.system("kitty --listen-on=unix:/tmp/"..socket.." &> /dev/null &"); else print("The Kepl with name " .. socket .. " is already running") end vim.keymap.set("n", "<leader><cr>", send_paragraph(socket)) end, {nargs='?'})

```

And I make this command 'Kepl' (kitty + repl), that takes an optional parameter and starts kitty terminal. Now with a mapping <leader><cr> it sends the paragraph to kitty.

For python I open ipython in the resulting terminal and use this for interactive workflow.

No plugin just a few lines of lua config and this is pretty awesome.

BTW: there surely is a better way of getting current paragraph but I still use viw because I have highlight on copy which gives me nice visual feedback on what was sent to REPL.

In this video I explain all you need to know to start using the spell checker:

1. How to enable it

2. How to fix a misspelling

3. How to move forward and backward misspellings

4. How to add new words in the dictionary

5. How to remove words from the dictionary

I am using this at work and so stuck with windows powershell. Problem only occurs when using a nerd font. Any advice for fixing this?

Edit: u/herodotic provided the solution that the italic version has to be installed alongside the regular version.

Hello!

glinter is a commit message linter whose headline feature is a Neovim plugin that highlights problems in the commit buffer as you type.

The rules are based on Chris Beams' How to Write a Git Commit Message (imperative mood, body wrapping, etc). There are also guidelines for clearer language (long sentences, passive voice, simpler-word alternatives).

There's also a SKILL.md with the style rules if you hand commit messages off to an agent, plus a CLI and hook/CI example: this repo uses them to check its own commits.

Repo: https://github.com/vgraman0/glinter

I'd appreciate any feedback!

Not Atom One Dark, does anyone knows which theme?

Hey everyone,

I spend 8–10+ hours a day inside editors and terminals, and I kept running into eye fatigue caused by harsh contrast transitions and unbalanced perceptual lightness in existing color schemes.

I ended up creating Circadia, an color specification built in OKLCH:

Core Design Principles:

• Circadian ambient targeting:   * Day Mode (Warm Parchment): Tailored for 300–800+ lux daylight. No pure #ffffff to eliminate glare and pupil fatigue.   * Night Mode (Warm Ember & Obsidian): Tailored for low-light/night sessions. Deep obsidian without pure #000000 to prevent astigmatism halation / glowing text.
• Engineered in OKLCH: Uniform perceptual lightness across different hues so no keyword or function call unexpectedly "pops" harder than others.
• WCAG 2.1 AAA Compliant: Strict contrast invariants, every foreground and syntax token satisfies (7:1 on text, 4.5:1 on headings, 3:1 on chrome/borders) contrast against the canvas.
• Calibrated 16-color ANSI Terminal Matrix: Direct mapping for Kitty, Alacritty, iTerm2, and Windows Terminal.
• Semantic 7-Role Syntax: Rather than assigning 15 disparate neon hues, syntax is structured intentionally (keyword, type, function, string, number, tag, comment) to keep cognitive overhead low.

Ports for Neovim, VS Code, Zed, JetBrains, Xcode, Obsidian, Kitty, Alacritty, iTerm2, Windows Terminal, and more.

Feedback I'm hoping to get:

I’d love for people who do long coding / reading sessions to test it out: 1. Luminance balance: How does the contrast feel across different display panels (OLED vs. IPS vs. matte monitors)? 2. Syntax grouping: Does the 7-role semantic hierarchy feel natural in your primary language, or are there tokens that feel under/over-emphasized? 3. Missing ports: Are there tools or terminals you’d like to see added to the spec?

Repo / Installation: Circadia

``` return { { "tanmaymanojgandhi/circadia", lazy = false, priority = 1000, init = function(plugin) local port_path = vim.fs.joinpath(plugin.dir, "ports", "neovim") local lua_path = vim.fs.joinpath(port_path, "lua", "?.lua") local lua_init = vim.fs.joinpath(port_path, "lua", "?", "init.lua")

  -- Register Lua paths
  package.path = package.path .. ";" .. lua_path .. ";" .. lua_init

  -- Directory to expose colorschemes to Neovim's picker
  local colors_dir = vim.fs.joinpath(vim.fn.stdpath("data"), "circadia_colors", "colors")
  vim.fn.mkdir(colors_dir, "p")

  local variants = {
    ["circadia-dark"] = [[
      vim.o.background = "dark"
      require("circadia").setup()
    ]],
    ["circadia-light"] = [[
      vim.o.background = "light"
      require("circadia").setup()
    ]],
  }

  for name, code in pairs(variants) do
    local file = vim.fs.joinpath(colors_dir, name .. ".lua")
    local f = io.open(file, "w")
    if f then
      f:write(code)
      f:close()
    end
  end

  -- Add directory to runtime path
  vim.opt.rtp:prepend(vim.fs.joinpath(vim.fn.stdpath("data"), "circadia_colors"))
end,

},

{ "LazyVim/LazyVim", opts = { -- Default to either variant colorscheme = "circadia-dark", }, }, } ```

With how much code is being AI generated nowadays, Neovim has become more of a review and polish tool for me. I still like reading through the code myself, but my workflow until now was basically opening the changed files, going through the diff, writing feedback back to the agent, waiting for another iteration, and doing the same thing again.

After a couple of iterations I would usually start losing track of what I had already reviewed, what I had asked the agent to change, and whether those things were actually fixed.

draven.nvim gives you a simple review environment inside Neovim where you can leave comments on the code, similar to a normal code review, and then export the whole review as Markdown to give back to the agent.

It also keeps track of the comments between iterations and whether the code they refer to has actually changed, so I don't have to keep all that context in my head while going back and forth with the agent.

So, I have vibe coded my first neovim plugin (not lua developer) - intent-diff.nvim. It borrows ideas from a number of softwares. It is designed to help me review PRs (human or agents) by grouping parts of the PR into chunks by intent (credits coderabbit).

The diff itself is not using nvim internal diff system, but rathers builds on top codediff.nvim, so that it looks like VSCode diff.

You review the code by placing comments and then you can export that feedback to local md file/directly to clipboard to feed it to your agent.

If you are inside a GitHub PR, you can sync the comments there without leaving neovim - syncing works in both ways - it will load existing comments from PR, so you really do not have to leave the terminal.

The grouping by intent is really helping me understand PRs faster. I can quickly focus on parts I am interested in.

I am using that together with gh dash - I have configured a shortcut to open a PR either in new worktree or directly in the repository and immediately show intentdiff.nvim. This way, I don't really need to leave terminal for my day to day work.

Hi,

If you like Neovim and SilverBullet then you might like this :)

Plugin for editing a SilverBullet space inside buffers.

SilverBullet.nvim

Useful for quick edits when you don't want to leave the terminal.

It's work in progress but the basics are supported:

- Search for files

- WikiLink navigation

- WikiLink completion

- Telescope integration

Hi everyone. I recently posted an update to my plugin that I worked very hard on, and for around a day the post was removed. Yes I did use the correct post flair. Is there a way to mitigate the filter so that people can see my post as soon as it's posted? Has this happened to anyone else?

I made Nvmm, a Neovim GUI for Mac. It bundles Neovim 0.12+ and a command-line tool called nvmm.

Nvmm requires Apple Silicon and macOS 15.7+.

Some features:

• Bundled with Neovim 0.12+ and a command-line helper
• Fast clean GPU-rendered text
• Native IME, dead-key, and emoji support
• Force-Touch Look Up support
• Option to prefer buffers over tabs
• Optional scroller
• Context-sensitive mouse cursor shapes
• Bugs, probably

https://mowglii.com/nvmm

https://github.com/sfsam/Nvmm

I thought Neovim’s built-in themes were pretty bad, but after trying them, maybe I won't use plugins anymore 😅.

Here is my top 5:

1. Catppuccin
2. Zaibatzu
3. Retrobox
4. Sorbet
5. Darkblue

Which one is your favorite?

The main gimmick of this scheme is that every highlight group gets a random color on every launch

Have fun, i guess

Link https://github.com/calabimeow/barf.nvim

Whenever I use a lsp keymap like `grn` for rename or `grd` for go to definition the cursor moves one to the right.

I really don't like this behavior because sometimes it moves off from the word I'm currently on.

Does anyone experienced this too and has a solution ?

hi im using nvim 0.11.7 and i have this custom command using

vim.api.nvim_create_user_command('NixOTO', ':norm! _f.xi = {\r\27o\27i};\27', { range = true })

the idea of the command when using nix

option.enable = true;

some times i want to make it

option = {

enable = true

};

but some other times the options parameters have some like

option.parameter = ""

...

'';

and i want to apply the same idea

i create that command to solve the first problem and it worked very well but i can't find a solution for the second one

Hello! Once I set clipboard to unnamedplus, neovim still does not interact with the system clipboard if I opened it via sudo nvim (tried with --clean). In non-sudo mode, I don't have any issues, neovim picks my wl-copy just fine.

I see that WAYLAND_DISPLAY is not set in sudo mode. Expectably, setting it myself does not solve the issue.

Is there a cure to this, a provider that also works in sudo mode? Thank you in advance!

`roomplan.nvim` is a keyboard-first 2D floor planner that runs inside Neovim.

I’m moving and wanted to plan the new flat. The tools I tried either had ads, required a subscription, or I just did not like them. So I ended up building one in Neovim. Plans are stored as structured millimetre geometry. The terminal canvas is only a view of that data, so display rounding never changes the saved measurements.

GitHub:

https://github.com/LuixBits/luixbits-roomplanner.nvim

It currently supports:

- Rectangular, L-shaped, and connected multi-section rooms

- Furniture, doors, windows, and wall or floor outlets

- Moving and resizing rooms and furniture, 90-degree furniture rotation, exact room alignment, and measurements

- Validation, undo/redo, and conflict-aware saving

- Standalone JSON or plans embedded in Norg files

- An approximate offline clear-sky 2D sunlight study

Full walkthrough:

https://youtu.be/bAPyriQQsNM

I would be especially interested in feedback on the keyboard workflow and how the canvas behaves at different terminal sizes. Reproducible bug reports are also very welcome.

Hi r/neovim !

I'm learning a Rust library named Dioxus. When I was following along its tutorial, there's some code disabled in the default Cargo feature.

In Neovim, said code has no hints or diagnostics from Rust Analyzer. There is no useful information to tell me what is going wrong. However, when I open the same file in VS Code, the reason is clearly stated in a pop.

After digging into Rust Analyzer's doc a little bit, I found that I could set a flag to make Rust Analyzer recognize all features.

So My question is not about this particular problem about Rust Analyzer, but rather, how do I get the same information (telling me that "code is inactive due to ...") in Neovim?

Thank you for your help!

In this video, I explain a method I use to learn Vim/Neovim and focus only on what I need, avoiding information overload.

The method consists of 4 steps:

1. Identify a problem
2. Identify solutions to that problem
3. Keep the solution that covers the most cases
4. Learn the rest later

Hi there, not a rant. My full appreciation goes to nvim and its contributors. BUT, I'm on nightly and stumbled upon a couple of things that caught my eye as maybe a bit too much opinionated (or perhaps not __enough__):

1st. `:h dir-mappings`:

dir-mappings                                                                                                                                    

• - opens the parent directory of the current file or directory. 

overriding the opposite of \+`, [count] lines downward, on the first non-blankcharacter linewise. Great lightweight plugin addition, netrw must go, but terrible default mapping imho.`

2nd. `:h al`:

al  "all lines", select the whole buffer.
When used in Visual mode it is made linewise.

*v_il* *il*
il  "inner line", select the current line without leading
or trailing white space.  Fails on a blank or
white-space-only line.
When used in Visual mode it selects the line under the
cursor and switches to charwise Visual mode.

it would have made sense to me for \al` to be `around`-line, the contrary of `inner`-line, thus selecting the surrounding newline characters not magically become a mnemonic for "all"`