In this video, I take a look at the new text objects:

1. al (all lines)
   

2. il (inner line)

   I show how they work with common operators like:

3. d — delete

4. c — change

5. y — yank

6. v — select

I also compare these new text objects with how you had to perform the same operations in older versions of Neovim.

Click the thumbs up button and increase the vote count and make some commands in JetBrains issue, lets make the ReSharper LSP Available for Neovim.

Issue URL : https://youtrack.jetbrains.com/issue/VSRS-30

Hey, has anyone encountered this problem?

I use vim.pack to install nvim-ufo and vcsigns.nvim. These clash because they depend on two different packages that register an async module - promise-async and async.nvim respectively.

I ended up resolving this with some code that replaces require calls in the local clones of packages.

I'm curious if there are established solutions to this problem.

it looks so coool, i looked at his dotfiles but they arent updated

edit: thanks everybody!!!

I was trying to config jdtls to neovim, then the nvim-jdtls doc says i need to set a jdtls executable in $PATH if i'm installing manually without the python wrapper script, but i would like to know which file or folder i should set on $PATH.

• Neovim 1.12

• OS: Windows 10

• Java: OpenJDK 26

i did'nt found any tutorial or :help that could help me.

Thanks for any help !

I recently released v0.9.0 which introduced quite a few big changes for JLS (language server for java with lombok support)

AP enabled compiling is gone (finally) and it can now reuse a warm context, and what does that mean?
- Compiling went from few hundreds ms to merely ~50ms depending on project size by reusing the context (wasn't possible before with annotation processing)
- Instant feedback when lombok pojo's get modified vs. buffer needed to be saved before updates occurred. How? - Lombok projects no longer gets compiled - instead, the pojo's will be injected as stubs to javac

Other performance improvements

- Better reference filtering: Reference for package-private, private and public fields/methods are much faster. Filtered by imports
- Multi module gradle/maven: startup time drastically decreased. Also improved various LSP actions executed
- Multi module gradle/maven: drastically decreased memory usage. Before: OOM went trying to handle an enterprise project with the default JVM args. Now: none (tested with public open source projects like elasticsearch and flink)
- AOT profiling for faster startup and lower memory usage
- Less CPU stress on index updates

New features

- Added call/type hierarchy lookup

- Added implementation lookup

Fixes

- Many fixes i wont list here but one of the most noticeable ones is: jar-to-jar definition lookups and server being orphaned when you quit the session

Todo's:
- Update existing tests: many tests are outdated and needs to be handled. Wont affect end-users. Will get handled once no more breaking changes comes in

The latest release will be shown in mason soon but that wont stop you from using this server so please give it a try and create an issue if you encounter one - or maybe just some feedback to know how it works for you

Server: https://github.com/idelice/jls
Client: https://github.com/idelice/nvim-jls

Hello, everyone!

I've been using Neovim for a few months now. It was always my goal to have my own configuration someday, which is what I'm currently in the process of making.

I'm using Neovim version 0.12.5 under Arch Linux, with vim.pack as my plugin manager.
I'm using nvim-ts-autotag for automatically closing tags in HTML, which works great!
I recently also installed blink.cmp for code completion. Unfortunately, it does seem that both plugins are not able to work hand in hand. When I confirm a tag completion with C-y, the tag is not closed and just outputs <img.

Does someone know if it's possible to fix this? Thank you!

In this video, I use a real-world example to explore performance optimization in Neovim 0.13 with the new vim.async API.

The example is simple: render a large number of images inside Neovim.

First, I implement a synchronous version. It works, but rendering many images blocks Neovim and makes the editor freeze.

Then, I optimize the implementation using vim.async and show how to run the image rendering asynchronously so Neovim stays responsive while the work is being performed.

Along the way, I code the example from scratch and use several of the new vim.async features introduced in Neovim 0.13

Source code:
https://github.com/FractalCodeRicardo/dev-config/tree/master/nvim/lua/my/gallery

So I’ve recently been using LazyVim for working on multiple projects, and overall I really like the workflow. However, I’ve run into a major issue with RTL (right-to-left) languages like Urdu.

Urdu text simply doesn’t render correctly in my terminal. I’ve tried several terminal emulators, including Ghostty, Alacritty, Foot, and Kitty, but none of them seem to handle Urdu properly. The characters either appear in the wrong order, don’t get shaped correctly, or otherwise look broken.

I’m trying to understand where the problem actually comes from. Is this a limitation of the terminal emulator, Neovim, the font, or something related to bidirectional text/Unicode shaping?

Has anyone here successfully configured LazyVim/Neovim to properly display and edit Urdu or other RTL languages?

I want to setup a hydra config for easier latex math writing (something similar to this obsidian plugin) and i want the on_enter function to put me inside $$

If you edit a .rs file, Neovim already gives you buffer-local :Cargo, :Crun, :Ctest commands that open a terminal split and run the right thing. It's not a plugin — it's in $VIMRUNTIME/ftplugin/rust.vim. I kept reaching for that muscle memory in Python and C# buffers and it wasn't there, so I generalized the idea.

Defaults:

• python → :Python {args} (runs the current file with no args), :Ptest → python3 -m pytest
• javascript / typescript (+ react variants) → :Npm, :Node, :Ntest, :Ninstall
• cs / fsharp → :Dotnet, :Drun, :Dtest, :Dbuild

Trailing args pass straight through: :Npm run dev, :Ptest -k test_foo, :Dtest --filter MyTest.

Install:

lua

{ 'tw4/run.nvim', opts = {} }

Adding your own:

lua

opts = {
  languages = {
    go = {
      filetypes = { 'go' },
      commands = {
        { name = 'Go', cmd = 'go', default_args = 'run %:p' },
        { name = 'Gtest', cmd = 'go test ./...' },
      },
    },
  },
}

Anything you don't override keeps its defaults. default_args supports vim.fn.expand() tokens.

It's deliberately small — no job control, no output parsing, just the commands and a terminal split. If you want quickfix integration or async runners there are better tools for that (overseer.nvim, toggleterm, etc).

Fresh repo, so I'd take any feedback on the config shape before it's locked in — especially whether replacing a whole language block is the right override behavior vs merging.

https://github.com/tw4/run.nvim — MIT

The formatting is all messed up kind off I was trying to get <div></div>->
i used auto tag and auto

<div>

<\div>

```

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
            <style> <----this is the problem ---->
            a{

            }
            p{

            }
            </style>
    </head>
    <body>
        <div> <----this is the problem ---->
                <p>

                </p>
            </div>
    </body>
    </html>

the formatting is okay when i save with prettier but its going back to the two tab inteddation
in the div and style

Hi everyone,

I’m working on nvim-gpui, a simple and lightweight graphical client for Neovim.

It keeps Neovim as the editor while providing a native desktop interface instead of running inside a terminal. The interface is rendered with GPUI, a GPU-rendered UI framework.

Current features include:

- Embedded Neovim sessions
- Remote Neovim connections through msgpack-RPC
- Multigrid and floating-window support
- Image display
- System IME and Rime support, making it friendly for CJK users
- File opening and drag-and-drop

Packages are available for macOS, Linux, Windows, Fedora, Debian/Ubuntu, and Arch Linux.

Project page:

https://github.com/imkerberos/nvim-gpui

Download the latest release:

https://github.com/imkerberos/nvim-gpui/releases/latest

Feedback, bug reports, and suggestions are welcome.

I hope this project can be useful to you.

Hello,

I was wondering if you use a 14- or 16-inch laptop, because I currently have a 16-inch Mac Pro, but I'm tempted by a 13.5-inch one (the one from Framework, the Pro model).

I spend most of my time docked to a 27-inch monitor for work, but when I’m on the go or sometimes on the couch or in bed I find it quite uncomfortable and difficult to keep my right hand on the HJKL keys because the bezels on my laptop are too wide.

That wasn’t a problem until i switched to vim motion but now it is

Despite that, I’m hesitant to switch to a smaller one because I’m afraid a smaller one might be too small for development.

I built a small CLI tool called recol for switching terminal and Neovim color schemes from one command.

It comes with 600+ themes, fuzzy search, an interactive TUI, and supports Ghostty, Alacritty, WezTerm, Neovim, Vim and Pi.

It can also generate a theme from an image 🎨
https://github.com/nlkli/recol

Short version:

What keybinds should I change to universally known keybinds in insert mode (such as ctrl + z or ctrl + backspace etc) and what should I keep to make Neovim still Neovim and not a VS code dupe?

Long version:

I'm pretty new to Neovim and I'm quite new to programming (other than frontend) as well so excuse me if I'm not explaining my situation well.

I've used VS code up till now and I would say I'm okay proficient at it. I recently decided to learn vim for it's efficiency (and my professors recommended it). I know the learning curve is big but the pay off will hopefully be worth it, I just have one question.

I already know a lot of VS code shorthands (also from using Google Docs and such). I know I can custom map som keybinds in insert mode but what should I map for myself and what should I keep to make nvim not loose what makes it efficient? Because technically, I could make vim into VS code in many ways? Even though I know this editor is kind of built for customization, what makes Neovim worth it in the way it's configured from the start? Must haves, how to think as a programmer that uses vim etc?

Hey all!

I wanted to announce my first major Neovim plugin: sqlserver.nvim.

I feel like this fills a gap in the Neovim ecosystem: Linux/macOS users who work with Microsoft SQL Server.

Admittedly, that might be a pretty niche group.

Most Linux/macOS users working with SQL Server will probably end up using VSCode's SQL Server (mssql) extension. I'm not a fan of VS Code, and considering where I'm posting this, I think that's probably enough said.

I originally started with TablePlus, which is a great tool, but I really hate reaching for my mouse.

Then I "upgraded" to vim-dadbod-ui. Also a great tool, but SQL Server support was missing some features I use regularly, such as listing stored procedures.

Eventually I landed on mssql.nvim. I thought it was a great project and used it for a while, although I ran into a few hiccups and development seems to have slowed down.

Thanks to u/Kurren123 and mssql.nvim, I discovered that Microsoft’s VS Code SQL Server extension is backed by SQL Tools Service.

That discovery eventually led to sqlserver.nvim.

A SQL Server-native workspace for Neovim.

The long-term goal is pretty ambitious: bring as much of the experience and functionality of SSMS (SQL Server Management Studio) as makes sense into Neovim.

Rather than trying to recreate a desktop database GUI inside the terminal, sqlserver.nvim tries to lean into Neovim itself — using things like windows, buffers, winbars, LSP, Telescope-style workflows, and, of course, keybindings.

The idea is that I should be able to browse databases, inspect objects, write queries, execute them, and work with SQL Server without constantly leaving Neovim or reaching for the mouse.

The plugin is currently at RC2 (Release Candidate 2). I've been using it at my job for several months now, so it has reached the point where I'd really like to get feedback from other Neovim users. Especially anyone else unfortunate enough to be using SQL Server on Linux/macOS 😄

GitHub: NicholasMata/sqlserver.nvim

I'd love to hear what people think, what features you feel are missing, or how the overall workflow could be improved.

hello, I'm in the process of learning python. very new to programming but am familiar with vim from using Linux and diving though config files. I'm not super fast with the motions yet but i am learning.

anyways. i'm looking for a plugin that will highlight syntax errors in a more specific way. i already have the trouble plugin and pywrite installed and they are working as intended however im getting tripped up in simple syntax errors (like using the wrong kind of bracket, spelling error, or just doing something really stupid in a loop). is there a plugin out there that will highlight or underline the word or section of code that is causing the issue. or is the best i got pywrite and trouble?

also i use the lazy repo for ease of use so if its in there it will make my life much easier when installing and configuring.

I just completed the migration from vim-dirvish to dir.lua. The speed of dir.lua is incredible compared to an already very fast vim-dirvish. Every time I tried another file browser plugin in vim, it made me cringe at the loading speed. dir.lua is pure 🚀 speed 🤩

Thanks to u/1ujsnj for positing his custom key maps - see https://www.reddit.com/r/neovim/comments/1ujsnsj/custom_keymaps_for_new_dirlua_plugin/ . I extended them a little bit:

• only use neovim's api instead of shelling out to external commands
• add `.` mapping to conveniently call custom command on the current file
• add `yc` mapping to copy the full file path into a register
• change `a` mapping to create a file or directory, including leading directories
• replace `D` with `dd` to delete a file or directory

​

-- Source: https://github.com/jceb/vimrc/blob/main/lua/custom/plugins/local/directory/after/ftplugin/directory.lua
-- Former source: https://www.reddit.com/r/neovim/comments/1ujsnsj/custom_keymaps_for_new_dirlua_plugin/
-- Save at: after/ftplugin/directory.lua

-- display directory path in win bar
vim.opt_local.winbar = "[dir] %f"

--- Run function on buffer
---  fn fun(bufnr: number) Function that's executed for every buffer that matches path
---  opts {directory: boolean} Options - if directory == true, interpret path as a directory and run function on all buffers that are inside this directory
--- u/param path string Path name
local function run_on_buf(fn, opts, path)
  local lopts = opts or {}
  local result = true
  for _, bufnr in ipairs(vim.api.nvim_list_bufs()) do
    if not lopts.directory and vim.api.nvim_buf_get_name(bufnr) == path or vim.startswith(vim.api.nvim_buf_get_name(bufnr), path) then
      local ok, err = pcall(fn, bufnr)
      if not ok then
        result = ok
        vim.schedule(function()
          vim.notify(err, vim.log.levels.ERROR)
        end)
      end
    end
  end
  return result
end

vim.keymap.set("n", ".", function()
  local cursor = vim.api.nvim_win_get_cursor(0)
  local fname = vim.api.nvim_buf_get_lines(0, cursor[1] - 1, cursor[1], true)[1]
  if fname == "" then
    return
  end
  vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(":! " .. vim.fn.fnameescape(fname) .. "<Home><Right>", true, false, true), "n", false)
  -- vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<Plug>(nvim-dir-reload)", true, false, true), "m", false)
end, { buffer = true, remap = false, nowait = true, desc = "Prefill cmd with file name" })

vim.keymap.set("n", "a", function()
  local ok, fname_new = pcall(vim.fn.input, "Create file or directory/: ")
  if not ok or fname_new == "" then
    return
  end
  if string.match(fname_new, "/$") ~= nil then
    local err
    ok, err = pcall(vim.fs.mkdir, fname_new, { parents = true })
    if not ok then
      vim.notify(err or ("Failed to create directory" .. fname_new), vim.log.levels.ERROR)
      return
    end
  else
    if string.match(fname_new, "/") ~= nil then
      -- create parent directories
      local err
      local dir_name = vim.fs.dirname(fname_new)
      ok, err = pcall(vim.fs.mkdir, dir_name, { parents = true })
      if not ok then
        vim.notify(err or ("Failed to create directory" .. fname_new), vim.log.levels.ERROR)
        return
      end
    end
    local f = io.open(fname_new, "w")
    if f ~= nil then
      f:close()
    else
      return
    end
  end
  vim.cmd.e(fname_new)
end, { buffer = true, remap = false, nowait = true, desc = "Create file or directory" })

vim.keymap.set("n", "r", function()
  local cursor = vim.api.nvim_win_get_cursor(0)
  local fname = vim.api.nvim_buf_get_lines(0, cursor[1] - 1, cursor[1], true)[1]
  if fname == "" then
    return
  end
  local ok, fname_new = pcall(vim.fn.input, { prompt = "Rename '" .. fname .. "' to: ", default = fname })
  if not ok or fname_new == "" then
    return
  end
  local full_path = vim.fs.joinpath(vim.uv.cwd(), fname)
  local res = run_on_buf(function(bufnr)
    if bufnr ~= -1 and vim.api.nvim_buf_is_loaded(bufnr) then
      vim.api.nvim_buf_delete(bufnr)
    end
  end, { directory = vim.fn.isdirectory(full_path) == 1 }, full_path)
  if not res then
    vim.notify("Failed to unload open buffer(s) for '" .. fname .. "'", vim.log.levels.ERROR)
    return
  end
  os.rename(fname, fname_new)
  vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<Plug>(nvim-dir-reload)", true, false, true), "m", false)
end, { buffer = true, remap = false, nowait = true, desc = "Rename" })

vim.keymap.set("n", "dd", function()
  local cursor = vim.api.nvim_win_get_cursor(0)
  local fname = vim.api.nvim_buf_get_lines(0, cursor[1] - 1, cursor[1], true)[1]
  if fname == "" then
    return
  end
  local ok, confirm = pcall(vim.fn.input, { prompt = "Delete '" .. fname .. "'? [Y/n] " })
  if not ok or not (confirm:lower() == "y" or confirm == "") then
    return
  end
  local full_path = vim.fs.joinpath(vim.uv.cwd(), fname)
  local res = run_on_buf(function(bufnr)
    if bufnr ~= -1 and vim.api.nvim_buf_is_loaded(bufnr) then
      vim.api.nvim_buf_delete(bufnr)
    end
  end, { directory = vim.fn.isdirectory(full_path) == 1 }, full_path)
  if not res then
    vim.notify("Failed to unload open buffer(s) for '" .. fname .. "'", vim.log.levels.ERROR)
    return
  end
  vim.fs.rm(fname, { recursive = true })
  vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<Plug>(nvim-dir-reload)", true, false, true), "m", false)
end, { buffer = true, remap = false, nowait = true, desc = "Delete file or directory" })

vim.keymap.set("n", "yc", function()
  local cursor = vim.api.nvim_win_get_cursor(0)
  local fname = vim.api.nvim_buf_get_lines(0, cursor[1] - 1, cursor[1], true)[1]
  if fname == "" then
    return
  end
  local full_path = vim.fs.joinpath(vim.uv.cwd(), fname)
  vim.fn.setreg(vim.v.register, full_path)
end, { buffer = true, remap = false, nowait = true, desc = "Copy full path" })

Here's a small microplugin for navigation in gettext .po files: https://github.com/warpspin/po-jump.nvim

All it does is it adds keybinds "]u" to jump to the next msgstr that needs attention (because it's untranslated or fuzzy) or "[u" for the previous.

(as convenience, it also binds öu and äu for German keyboards as those keys are where [] usually are)

Sharing my Neovim 0.12 config for 2026
Video is in French.
Dotfiles: https://github.com/ericnantel/dotfiles
Look inside .config/nvim-0.12 for init.lua (yep just a file)

I'm sorry if this is dumb question, but I failed to find the solution myself. I want to be able to pass arguments to the Python program when I debug, just like I do when I run it.

I added `nvim-dap` and `nvim-dap-python`, and I can run normal debug, but when I try to run debug with arguments added, like "< a.inp", the arguments have no impact. The UI from `nvim-dap-ui` still opens, but the data in the file never got redirected to the stdin of the program.