RSS Reader

Whenever I did a config change, I was never that bothered with quitting Neovim and re-opening it. But this new :restart command feels like such a huge step up. Thank you Neovim team!

It's so nice restarting Neovim in-place and see the changes right away.

Sharing my keymap that restarts Neovim in-place while preserving the window layout, buffers, and cursor position:

lua vim.keymap.set('n', '<leader>R', function() local session = vim.fn.stdpath('state') .. '/restart_session.vim' vim.cmd('mksession! ' .. vim.fn.fnameescape(session)) vim.cmd('restart source ' .. vim.fn.fnameescape(session)) end, { desc = 'Restart Neovim' })

I moved away from nvim-treesitter a while ago. The reason actually was that after switching from master to main branch some of my parsers stopped working, so I decided to figure out how to set up these myself. And it was actually pretty simple.

First thing you need is tree-sitter-cli, I've installed it with brew install tree-sitter-cli. Then:

1. Find out the parsers you need. Google them, their names are usually tree-sitter-<lang>. As an example, I will take Go language, the parser is here
2. git clone https://github.com/tree-sitter/tree-sitter-go ~/my/location/tree-sitter-go
3. cd ~/my/location/tree-sitter-go
4. tree-sitter generate
5. tree-sitter build
6. You will get a parser file in current directory, usually it's either .so or .dylib file. In my case, it's go.dylib
7. mv go.dylib ~/.config/nvim/parser/go.dylib. The name of the parser should be the same as language name (open any file in neovim and type :echo &filetype to get the name)
8. Now you can run :checkhealth vim.treesitter. Neovim should find this new parser you've built
9. The next step is to download .scm files for your parser. You can find some of them in tree-sitter repository, in queries/ dir, but usually it's better to download them from nvim-treesitter repo. There are more queries for folding, injections, etc. The easiest way for me was to:

​

git clone https://github.com/nvim-treesitter/nvim-treesitter ~/my/location/nvim-treesitter cd !$ cp -r runtime/queries ~/.config/nvim/queries 

Done!

Hey vimmers,

Sorry if the successive posts feel spammy.

After an overwhelmingly negative response in my last post, I'm here to inform you that nvim-dap-view switched to GPL v3. That's it.

As a reminder of my commitment to transparency, I encourage you guys to take a look at the acknowledgements page.

Thanks.

I just started to look at Nvim 0.12's changes, and it includes a new ui2 module, an experimental replacement for the message and cmdline UIs. I current use Noice and just feel indifferent at the thought of trying it, but what are your thoughts?

Edit: Now includes queries. Open, non-plugin specific query repo at arborist-ts/queries.

I built a pretty no-nonsense Tree-sitter (TS) parser manager I’m calling Arborist. Find it here: arborist-ts/arborist.nvim.

Arborist is a WASM-first, native-second tree-sitter parser manager for Neovim 0.12+. Parsers (plus nvim highlights, folds, indents, injections, and locals) install automatically when you open files. No manual steps, no maintenance.

Install:

vim.pack.add({ "https://github.com/arborist-ts/arborist.nvim", })

Works out of the box with no setup call. I designed it to be as fire and forget as possible.

OPEN REGISTRY AND QUERIES:

I firmly believe the TS registry deserves its own home which can be used by many different projects, which I started here: arborist-ts/registry. Similarly, queries deserve their own non-plugin-specific home, which is here: arborist-ts/queries. These are both independent of arborist-ts/arborist.nvim, and can (and should!) be used by other plugins.

Feedback, bug reports, and contributions all extremely welcome.

Anyone interested in joining the arborist-ts organization to help with maintenance of the plugin, the parser registry, and the queries? Please just ask. This will take a village.

my neovim config used to be 800+ lines. i was collecting plugins like pokemon. had a plugin for everything. half of them overlapping, some of them i configured once and never touched again.

about 6 months ago i nuked everything and started over with just the stuff i actually use. went from 40+ plugins down to 12. the editor loads faster and i actually understand my config now. also stopped spending friday nights debugging why some keymap stopped working after an update which is a bonus.

the plugin that survived every purge for me is telescope. i tried replacing it twice, once with fzf-lua and once with just going back to fzf.vim. kept coming back. the live grep through the entire project while previewing matches is something i use probably 50 times a day. it's muscle memory at this point.

second one is treesitter but that barely counts since it's basically part of neovim now.

what's the one plugin you'd keep if you had to mass-delete everything else? not your whole config, just the one thing you'd rebuild around.

Hello folks,

Roughly speaking, neovim users fall into one of two categories: those who consider vim to be "another tool" in their "toolbox", along with, e.g., CLI tools, and those who mostly like to do everything directly from vim. Of course, most users do not fall completely into one extreme (or the other), and there are more complex scenarios (what about a plugin that just wraps a TUI app?). By the sheer amount of people in both "camps", you'd think both are approximately "equivalent" in terms of user experience.

However, there's a scenario where doing everything from vim has a clear benefit: LSP file operations. These are (either) requests (or notifications) the client (neovim) sends after it detects a change in the file system. Most commonly, these are leveraged by "file explorer" plugins, such as oil.nvim. In practical terms, what happens is that when you rename* a file, its imports are automatically updated (thanks to the language server). Nothing stops you from also leveraging this capability with an external file explorer, by hooking up events and communicating with neovim over RPC (for instance), but that does sound much more complex than using a "file explorer" plugin (curious to see if any wrappers, like yazi.nvim, have implemented such plumbing).

Not every file explorer ships this feature natively, though. Some solutions have been built around that, namely, nvim-lsp-file-operations (and a snacks' module). I had been using the former basically since its inception (and then, my own fork for like a year), but I was wondering if the nvim-tree guys wanted to support this feature natively, and, as it turns out, they do! Which lead me to, eventually, make my own implementation. But I never got to submitting the PR. If you're a nvim-tree user who's missing this feature, let me know, and I may take this over the finish line. If anyone else is interested in yoinking my code and submitting the patch themselves, feel free to do so!

*: Create or delete as well, depends on the LS's capabilities

I have seen so many posts saying that oil is a MUST have plugin and have tried to use it on multiple occasions and just haven't seen what's so great. It may just be how I use neovim but does anyone else feel this way?

UPDATE: I moved back to the archived version nvim-treesitter/nvim-treesiter after realizing that my move to this project may or may have not been premature. Will have to wait and see for a few more weeks how things develop.

Had to install plenary.nvim and a few query-only parsers to fix errors in :checkhealth and have been living happily ever after.

vim.pack

 -- Treesitter { src = 'https://github.com/nvim-lua/plenary.nvim' }, { src = 'https://github.com/neovim-treesitter/nvim-treesitter' }, { src = 'https://github.com/nvim-treesitter/nvim-treesitter-textobjects' }, { src = 'https://github.com/nvim-treesitter/nvim-treesitter-context' }, 

my treesitter config

-- Treesitter require('nvim-treesitter').setup({ install_dir = vim.fn.stdpath('data') .. '/site', }) -- jsonc uses the json parser vim.treesitter.language.register('json', { 'jsonc' }) local parsers = { 'bash', 'css', 'diff', 'dtd', 'ecma', 'editorconfig', 'fish', 'git_config', 'git_rebase', 'gitattributes', 'gitcommit', 'gitignore', 'hcl', 'html', 'html_tags', 'javascript', 'jsdoc', 'json', 'jsx', 'latex', 'lua', 'make', 'markdown', 'markdown_inline', 'python', 'query', 'regex', 'scss', 'toml', 'tsx', 'typescript', 'typst', 'vim', 'vimdoc', 'xml', 'yaml', 'yang', } -- Install parsers after startup vim.schedule(function() require('nvim-treesitter').install(parsers) end) -- Textobjects (selection handled by mini.ai, movement by treesitter-textobjects) require('nvim-treesitter-textobjects').setup({ move = { set_jumps = true, }, }) local map = vim.keymap.set -- Movement map({ 'n', 'x', 'o' }, ']f', function() require('nvim-treesitter-textobjects.move').goto_next_start('@function.outer', 'textobjects') end, { desc = 'next function start' }) map({ 'n', 'x', 'o' }, '[f', function() require('nvim-treesitter-textobjects.move').goto_previous_start('@function.outer', 'textobjects') end, { desc = 'previous function start' }) map({ 'n', 'x', 'o' }, ']F', function() require('nvim-treesitter-textobjects.move').goto_next_end('@function.outer', 'textobjects') end, { desc = 'next function end' }) map({ 'n', 'x', 'o' }, '[F', function() require('nvim-treesitter-textobjects.move').goto_previous_end('@function.outer', 'textobjects') end, { desc = 'previous function end' }) map({ 'n', 'x', 'o' }, ']k', function() require('nvim-treesitter-textobjects.move').goto_next_start('@class.outer', 'textobjects') end, { desc = 'next class start' }) map({ 'n', 'x', 'o' }, '[k', function() require('nvim-treesitter-textobjects.move').goto_previous_start('@class.outer', 'textobjects') end, { desc = 'previous class start' }) map({ 'n', 'x', 'o' }, ']K', function() require('nvim-treesitter-textobjects.move').goto_next_end('@class.outer', 'textobjects') end, { desc = 'next class end' }) map({ 'n', 'x', 'o' }, '[K', function() require('nvim-treesitter-textobjects.move').goto_previous_end('@class.outer', 'textobjects') end, { desc = 'previous class end' }) -- Context require('treesitter-context').setup({ line_numbers = true, max_lines = 3, min_window_height = 20, }) map('n', 'gC', function() require('treesitter-context').go_to_context() end, { desc = 'go to context' }) 

I got into nvim partly because of watching ThePrimagen. Therefor one of the first plugins i've used was harpoon. I never used it a lot, since most of my navigation is done through telescope, but recently I value direct file swaps a little bit more. I've been doing this with the native nvim mark system

The first change I made was setting up some file markers for global marks, e.g. 'mT' for going to my .../todo.md via "'T". That's kinda nice already, but it doesn't drop you were you left the buffer.

There are two interesting marks already set by nvim '" and '.

These go to the last point you exited the buffer (") or to the last edit of the buffer (.). Thats handy.

Since 'T'" is a mouthful and i don't really see the value of swapping to my marks without going to the location I left I set a keymap to do both commands in one

-- in my init.lua -- Instead of jumping to the mark at the file jump to the file and go to the last exit of the buffer local function remap_uppercase_marks() for i = string.byte("A"), string.byte("Z") do local mark = string.char(i) vim.keymap.set("n", "'" .. mark, function() vim.cmd("normal! '" .. mark) vim.cmd([[normal! '"]]) end, { noremap = true, silent = true }) end end remap_uppercase_marks() 

If you want to go exactly where you set the mark there is still the backtick `T which brings you exactly were you set the mark.

But harpoon has another feature, which is project wide marks instead of global marks.

Most of my projects already have a .nvim.lua in their root. For those of you who dont know, the file is run at nvim startup when running nvim from this directory or a child. Just make sure to run :trust before and let nvim know you are using this kind of setup with

--in init.lua vim.o.exrc = true -- <- Nvim will execute any .nvim.lua, .nvimrc, or .exrc file found in the |current-directory| and all parent directories (ordered upwards), if the files are in the |trust| list. vim.o.secure = true -- <- - *'secure'* : Everything is allowed in 'exrc' files, because they must be explicitly marked as "trusted". 

Its perfect to set project wide settings. To have project wide marks I add

-- .nvim.lua local function set_file_mark(mark, filepath) local bufnr = vim.fn.bufadd(filepath) vim.fn.setpos("'" .. mark, { bufnr, 1, 1, 0 }) end set_file_mark("M", "main.py") set_file_mark("A", "foo/add.py") 

To conclude, these roughly 20 lines of lua fulfill my "jump to specific" file needs and patch in the missing functionality of project wide marks and going back to the position of the buffer I left. Harpoon offers other features, too, e.g. ui, and no need of sourcing .nvim e.g. when switching projects from the same nvim instance but these dont have a high prio for me right now.

Using the native mark system also seems kinda right to me, since when you get used to it, it can be used in vanilla vim/nvim in a very similar way.

Using alphabetic keys is also handy for mnemonic shortcuts.

That's it, maybe some of you give it a try.

A recent commit on 10th of April updated the readme with an announcement that the plugin is no longer maintained and will be archived soon. Does anybody have more information about this on what happened?
I wonder what this will have for effect, I have a bunch of plugins that depend on this plugin.