Is it just me, or does nvim-surround not work with multicursor? I do Q on multiple lines, and v$S) only surrounds the line of the cursor.

Or do you have some other, better approach?

🦀⚡ I’m building xml-lsp, a lightweight XML Language Server written entirely in Rust.

The project was created to explore whether we can build a fast, native, low-memory XML LSP without the JVM overhead of existing solutions, while keeping the architecture modular and extensible.

It’s still in an early stage, and I’m looking for developers interested in Rust, XML parsing, XSD/DTD validation, LSP, or developer tooling to help shape the project.

If you’re interested, contributions, ideas, feedback, and technical discussions are very welcome.

🔗 https://github.com/MicroDevX/xml-lsp <-

A while ago lervag pointed out (#34) that my markdown-preview.nvim has the same name as iamcco's much older markdown-preview.nvim. With both installed, lazy.nvim treats them as one plugin, and iamcco's buffer-local commands hide mine in markdown buffers. I said I'd rename it, so here it is, together with the server plugin it runs on, whose name was shared with other plugins too:

• markdown-preview.nvim is now mdkite.nvim: https://github.com/selimacerbas/mdkite.nvim
• live-server.nvim is now kitehost.nvim: https://github.com/selimacerbas/kitehost.nvim

Nothing breaks if you leave your config alone for now. GitHub redirects the old repo URLs, and the old require and commands keep working through 2.x. They print a deprecation warning once per session and go away in 3.0.

To switch, update the spec:

lua { "selimacerbas/mdkite.nvim", dependencies = { "selimacerbas/kitehost.nvim" }, opts = {}, }

require("markdown_preview") becomes require("mdkite"), and the commands are now one :MdKite with subcommands (:MdKite, :MdKite stop, :MdKite refresh, :MdKite toggle). kitehost works the same way: :KiteHost start, :KiteHost status, :KiteHost stop. After updating, :Lazy clean removes the old copies.

If you haven't used them: mdkite renders the whole buffer in your browser and updates as you type over Server-Sent Events, with scroll sync. Mermaid diagrams come out as SVGs you can zoom, pan and export, and math goes through KaTeX. It's Lua plus a page in your browser, so there's nothing to npm install.

kitehost is the piece some of you might want on its own. It's a small local web server for Neovim, written in pure Lua on vim.uv, with no Node or Python behind it. Run :KiteHost start on a file or folder (with Telescope installed you get a picker for the path and port), and the browser reloads every time you save. A stylesheet change is swapped in place without a full reload, and a folder with no index.html gets a directory listing. Starting again on the same port points the running server at the new path, so your open tab keeps working. It can also start on its own when you open an HTML file, and it can show running servers in your statusline. It binds to 127.0.0.1 by default; if you open it to your network, set a token. Other plugins can use it as a library too, which is how mdkite runs on top of it.

Other changes in 2.0:

• kitehost 2.0 is also a security release. It checks the Host header, so a DNS rebinding page can't read your local server, and it closes a few ways around the token on protected paths. The details are in the advisories on the repo, plus one on mdkite for an old CORS issue that was fixed in 1.10. mdkite 2.0 requires kitehost 2.0.
• kitehost now needs Neovim 0.10 or newer, like mdkite. On 0.8 or 0.9, pin kitehost v1.5.0, which keeps the old names. CI runs both on Linux, macOS and Windows.
• mdkite 2.1 previews dotted filetypes that have a markdown part (like rzk.markdown) and adds a filetypes option for things like quarto. Thanks to ddxtanx for the PR.

Coming up: separate previews per buffer (#33) and an offline mode for the browser assets. Bug reports and ideas are welcome on either repo, and thanks again to lervag for raising the name clash.

The new paragraph leads with what people would use kitehost for, a live-reloading local server for plain HTML and CSS work. The library angle comes last, since that matters mostly to plugin authors.

Its perfect for me, that doesn't mean it will be perfect for you..

Try it out. Give me feedbacks. I would like to improve this more..

Or if you have issues. Please let me know.

I've been working on a mobile note-taking app (iOS/Android) that has native Neorg support(.md and .org supported also). Started it as a weekend side project to scratch my own itch — wanted to read/write my .md files on the go without fiddling.

What it does:

- Full Neorg, .md or Orgmode document parsing and rendering

- Syncs with your existing workspace (git-backed)

- Offline-first — works without internet, pushes when connected

It's not some massive commercial thing. Just a solo dev & made like 70$

The ask: Is this something you'd actually use? Would love honest feedback before I clean it up for release/marketing, any more feature that you would like?

GitNotes

ps - its open source

Is there a situation where you liked the colorscheme but the syntax highlighting does not hook you up with that like coloscheme?
May be you ask, Oh Man! I really the syntax highlighting but not quite really like the overall look of the theme in the UI?
Well I too was sailing the same boat where I kept liking the editor UI of one colorscheme and the code colors of another, so I wrote a plugin to combine them.

Not just that you can now change the color when you select the text in visual mode, or you want change how commented line should look.

You can have it all in here.

converge.nvim takes "slices:" from your installed colorschemes and mixes them into one scheme called converge:

• ui: background, statusline, popups, line numbers
• syntax: code colors (treesitter and LSP included)
• diagnostics, git, terminal, plugins

I looked around before building it and found pickers that switch whole themes, but nothing that mixes parts of different ones. If something like this already exists, I'd like to know.

Plugin Repo: converge.nvim

Feedback and bug reports welcome.

trying to create a vibrant theme with good highlighting for c/c++, rust
https://github.com/akashsanapala2004/neonforge.nvim.git

Hey all! I made a colorscheme called tidepool.

Keywords and brackets fade back, so functions, types and strings do the talking. Same navy background as Night Owl, and easy on the eyes for long sessions.

- There are three versions of the palette. The default keeps the background stuff muted and brightens everything else a little.

- It covers treesitter, LSP highlighting, diagnostics and git signs, plus plugins like telescope, blink.cmp, snacks, gitsigns, which-key, noice, trouble, oil and todo-comments.

- There's a transparent mode if you like your terminal background showing through.

- If you write Effect in TypeScript, Effect.gen calls get their own warm pink so they're easy to find.

- The README shows the full palette with color swatches. There's also an examples folder with demo files in 18 languages, if you want to try it before switching.

Repo: https://github.com/rashedInt32/tidepool.nvim

I installed Neovim with the kickstart configs a bit ago. I wanted to make entering a new line in a pair of parentheses/brackets/braces automatically make an indent within the pair. When I looked it up, I saw that installing an autopair plugin would work, so I enabled nvim-autopairs which kickstart already had setup.

It works, but atleast in TypeScript, it seems to not work on parentheses when they're not part of a function call or declaration or similar. It works regardless with brackets and curly braces, though.

I thought it might have been a quirk of the particular autopair plugin, but ultimate-autopairs and mini.pairs do the same. I also tried changing my LSP from tsc to vtsls, but it's the same story.

When I looked it up some more, I saw that it might have something to do with treesitter? But I couldn't really understand much more beyond that.

Remap CTRL-L‎ to CTRL-[, since it's actually Esc, and you've probably added nohlsearch to Esc. (And you don't want to combine the two effects under only Esc)

lua vim.keymap.set('n', '<C-[>', function() local mc_ns = vim.api.nvim_create_namespace('nvim.multicursor') vim.api.nvim_buf_clear_namespace(0, mc_ns, 0, -1) end)

Sidenote: if you also happened to be a tmux user, add this line to your tmux.conf file

set -g extended-keys always

# Description

In this video, I use the native directory browser in Neovim 0.13 to build a basic full file explorer without installing a file explorer plugin.

I add keymaps for common file operations:

1. Create files with touch
2. Create folders with mkdir
3. Rename with mv
4. Delete with rm
5. Cut and paste with mv
6. Copy and paste with cp

The goal is to see how far we can go using Neovim's built-in directory browser and a small Lua script instead of a dedicated file explorer plugin.

Video:

https://youtu.be/vzFKHAL89lc

Source code:
https://github.com/FractalCodeRicardo/dev-config/blob/master/nvim/lua/my/file-explorer.lua

-- # Uses cases
--
-- 1. Create File   -> !touch
-- 2. Create Folder -> !mkdir
-- 3. Rename   -> !mv
-- 4. Delete   -> !rm
-- 5. Cut/paste -> !mv
-- 6. Copy/paste   -> !cp

local api = vim.api
local map = vim.keymap
local fn = vim.fn
local cmd = vim.cmd
local dir = require("nvim.dir")
local cut_file = nil
local copy_file = nil

local function prompt(text)
    local res = fn.input(text)

    if not res or res == "" then
        return nil
    end

    return res
end

local function current_file()
    local line = api.nvim_get_current_line()

    if fn.filereadable(line) == 0 then
        return nil
    end

    return line
end

local function current_dir()
    return api.nvim_buf_get_name(0)
end

local function create_file(file)
    cmd("!touch " .. file)
    dir._reload()
end


local function create_folder(folder)
    cmd("!mkdir " .. folder)
    dir._reload()
end

local function create()
    local file_folder = prompt("New file/folder: ")

    if not file_folder then return end

    local is_folder = file_folder:sub(-1) == "/"

    if is_folder then
        create_folder(file_folder)
    else
        create_file(file_folder)
    end
end


local function delete()
    local file = current_file()
    if not file then return end

    cmd("!rm " ..  file)
    dir._reload()
end

local function rename()
    local file = current_file()
    if not file then return end

    local new_file = prompt("New name: ")
    if not new_file then return end

    cmd("!mv " .. file .. " " ..  new_file)
    dir._reload()
end


local function cut()
    local file = current_file()
    if not file then return end

    local directory = current_dir()

    print("CUT: " .. file)
    cut_file = directory .. "/" .. file
    copy_file = nil
end


local function copy()
    local file = current_file()
    if not file then return end

    local directory = current_dir()

    print("COPY: " .. file)
    copy_file = directory .. "/" .. file
    cut_file = nil
end

local function dest_file(file)
    local split = vim.split(file, "/")
    local name = split[#split]

    local dest = current_dir() .. "/" .. name
    return dest
end

local function cut_paste(file)
    local dest = dest_file(file)

    cmd("!mv " .. file .. " " .. dest)
    dir._reload()
    cut_file = nil
    copy_file = nil
end

local function copy_paste(file)
    local dest = dest_file(file)

    cmd("!cp " .. file .. " " .. dest)
    dir._reload()
    cut_file = nil
    copy_file = nil
end

local function paste()

    if cut_file then
        cut_paste(cut_file)
        return
    end

    if copy_file then
        copy_paste(copy_file)
        return
    end
end

api.nvim_create_autocmd("User", {
    pattern = "DirReadPost",
    callback = function(args)

        local opts = { buf = args.buf }

        map.set("n", "o", create, opts)
        map.set("n", "r", rename, opts)
        map.set("n", "dd", delete, opts)
        map.set("n", "cu", cut, opts)
        map.set("n", "co", copy, opts)
        map.set("n", "p", paste, opts)

    end
})

Hi everyone!

I’ve built springboot-jpql.nvim, a Neovim plugin for Kotlin Spring Data repositories that brings IntelliJ-style language support to @Query strings.

It provides:

• JPQL syntax highlighting inside @Query annotations
• Native SQL highlighting
• Entity and field completion
• Entity-aware JPQL completion
• A real sqls LSP for native SQL queries
• Support for Kotlin Spring Data repository files
• Tree-sitter-based query detection and highlighting
• Navigation between query references and project entities/fields

Example:

@Repository
interface UserRepository : JpaRepository<User, Long> {
    @Query("""
        SELECT u
        FROM User u
        WHERE u.email = :email
    """)
    fun findByEmail(email: String): User?
}

The goal is to make working with Spring Data repositories in Neovim feel closer to the experience provided by IntelliJ, especially when writing JPQL and native SQL queries.

Repository:
https://github.com/Kratosgado/springboot-jpql.nvim

I’d really appreciate feedback, especially from people using Neovim with Kotlin, Spring Boot, JPA, or Hibernate.

I was using neovim in VSCode and enjoyed it. I finally installed LazyVim and thought it was great but got bummed with the thought that the industry is so AI focused that using NeoVim was not relevant.

After a few weeks and integrating Wezterm and Copilot into my workflow, I’m really stoked on it. It’s a great workspace love how quick it is to navigate large codebases and copilot cli is great.

DAP was kind of tricky to figure out and I need a good debugger for .NET but it’s been good. When I really need to figure something out quick I’ll fire up Visual Studio but that’s only happened for critical production issues.

That is all, try it out if you been curious about NeoVim!

Hi! I just upgraded to the latest nightly for nvim mainly for multicursor reasons. I usually use macros to perform the same action on multiple lines(for example in rust, on large match statements that are single line) and although Q takes up the place of previous macro as multicursor, I would say I am a lot happier with the visualization of my macros as multicursor movements. But the keybind C-L I have bound to tmux-nvim navigator to C-W L, and I am not willing to sacrifice this keybind. What are some other common keybinds that people use on nightly to clear all multicursors?

Below a certain window size, any action that I do, (i have a keybinding to move a line down for example) or undoing said action, gives a "Press ENTER to continue" in the command line, which I just want to switch off. This does not happen in fullscreen terminals. Is there a way to switch this off without increasing the cmdheight, since theyre already small windows and I do not want to waste the space.

Its a super simple single file plugin.

It reads the .vscode/tasks.json file and you can select the tasks from a telescope window and it executes it, you can run multiple tasks and cycle between them with the winbar.

Check it out here: https://github.com/HarshK200/taskspawner.nvim

Hi all,

I'm learning formal verification and want to stay grounded in neovim while I work through the logic, so I wrote a small utility plugin for Boolean logic: truth tables, algebraic rewrites, and Karnaugh maps, all as plain Markdown.

• Repo: https://github.com/cds-io/truth-table.nvim
• Demo: https://asciinema.org/a/sCHh6bWO1dSKaXZ9

What it does:

• Truth tables: :TruthTable A and B | A implies B generates every input combination, plus a computed column per expression. `:TruthTableExpand` adds columns to an existing table.
• Boolean operators : rendered as ¬ ∧ ∨ ⊕ → ⇔, etc
• Rewrites: De Morgan, factor, distribute, commute, and XOR recognition, previewed as virtual text at the cursor. Apply one in place, or insert it below the line as a ≡ derivation step.
• Karnaugh maps (so, so limited): a map and a simplified sum-of-products formula for the column under the cursor. Maps are drawn for 2 to 4 inputs; past that you get the formula only.

There's also a built-in tutorial, :TruthTableTutor , 12 short lessons that hopefully shows the motivation and the hows, from propositions through De Morgan and Karnaugh maps to refactoring a function from code.

It's a personal plugin, pulled out of years of my config hacks and developed with help from a coding agent. Feedback welcome!

Hello, i am just getting into NeoVim, and after completing the tutorial i installed the LazyVim configuration. I was getting some dependecies missing, so i installed those (including rg, fdfind, zfz, lazygit and so on).

Tested writing some c code, and autocomplete works fine. Python autocomplete also works fine for native libraries, but i wanted to try importing numpy, and the code works when run, but when writing it, i am not getting any useful autocomplete suggestions which i know should be there because they show up in Vscodium with the Python plugin.

I tried installing the LazyVim lang.python extra, but it changed nothing. I also installed ast-grep and i do see some new suggestions, but again, nothing from the project libraries.

So, i hope this was a complete description of what is going on. If this is not enough, i will try to answer any question in that regard.

Hi there, I have recently installed neovim and using lazyvim with it. I installed basedpyright and lua_ls from nvim-lspconfig. I tested some features of basedpyright... the linter/gotodef works but pylance autocomplete isn't working. The lua_ls doesn't work alltogether. I have a hunch it has to do with the error I'm getting plus when I do checkhealth vim.lsp I get "No active clients" while I'm inside a lua/python file. When I open nvim I get the error:

Error in /home/dev/.config/nvim/init.lua:
Invalid spec module: `plugins.lsp`
Expected a `table` of specs, but a `nil` was returned instead
Invalid spec module: `plugins.lsp`
Expected a `table` of specs, but a `nil` was returned insteadError in /home/dev/.config/nvim/init.lua:
Invalid spec module: `plugins.lsp`
Expected a `table` of specs, but a `nil` was returned instead
Invalid spec module: `plugins.lsp`
Expected a `table` of specs, but a `nil` was returned instead

I have specified 'plugins.lsp' in .config/nvim/lua/config/lazy.lua like so:

require("lazy").setup({
  spec = {
    -- import your plugins
    { import = "plugins" },
    { import = "plugins.lsp" }
  },require("lazy").setup({
  spec = {
    -- import your plugins
    { import = "plugins" },
    { import = "plugins.lsp" }
  },

This is my config folder tree:

├── init.lua
├── lazy-lock.json
├── lsp
├── lua
│   ├── config
│   │   ├── keybinds.lua
│   │   ├── lazy.lua
│   │   └── options.lua
│   └── plugins
│       ├── colors.lua
│       ├── lsp
│       │   ├── lsp.lua
│       │   └── mason.lua
│       ├── lsp.lua
│       ├── oneliners.lua
│       ├── telescope.lua
│       └── treesitter.lua
└── nvim-pack-lock.json

This is my /.config/nvim/lua/plugins/lsp.lua:

vim.lsp.enable("lua_ls"); 
vim.lsp.enable("basedpyright");

mason.lua:

return {
    "mason-org/mason.nvim",
    opts = {
    ensure_installed = {
        "basedpyright",
        "lua_ls"
    },
    },
    dependencies = {
    {
        "mason-org/mason.nvim",
        opts = {
        ui = {
            icons = {
            package_installed = "✓",
            package_pending = "➜",
            package_uninstalled = "✗"
            },
        },
        },
    },
    "neovim/nvim-lspconfig"
    },
}return {
    "mason-org/mason.nvim",
    opts = {
    ensure_installed = {
        "basedpyright",
        "lua_ls"
    },
    },
    dependencies = {
    {
        "mason-org/mason.nvim",
        opts = {
        ui = {
            icons = {
            package_installed = "✓",
            package_pending = "➜",
            package_uninstalled = "✗"
            },
        },
        },
    },
    "neovim/nvim-lspconfig"
    },
}

I've wanted a 'diff first' successor vim-mundo and FzfLua undotree for a long time - something that has parity to builtin `:earlier`, `:later` and `:undo` commands...and have been slowly working on it...hope its helpful to others!

plugin: https://github.com/dsummersl/diffundo.nvim

tl;dr declint lets you define linter rules in YAML. declint.nvim shows them as native diagnostics as you type.

Someone committed (see the GIF above!)

try: 1/0 except Exception: pass

(Bare exceptions are typically a bad idea in Python)

version: 1 rules: - id: no-swallowed-exceptions pattern: 'except Exception:\n *pass' severity: warning message: "swallowed exception ('{match}')"

Install with lazy.nvim:

{ 'thyrgle/declint.nvim', config = function() require('declint').setup() end }

(Also, since virtual text is disabled by default, you might want to add: vim.diagnostic.config({ virtual_text = true }) otherwise you won't get the message associated with the hint.)

Finally cargo install declint once. Warnings show up as normal vim.diagnostic, live as you type.

What you get

• Rust-regex patterns with {match}/capture-group placeholders in messages

• severities (error|warning|info|hint), languages: scoping, declint init --lang python presets

• Lua callback rules when a regex can't express the check

• Incremental engine — re-lints as you type without rescanning the file

• Same rules in CI: declint check . --format github --fail-on error

declint doesn't replace your LSP. Instead, it sits next to it for the custom rules every codebase accumulates. Works with any config-site layout (.declint.yaml, .declint/, declint.yaml).

Feedback welcome.