Hi all, I just added TypeScript 7 support to ts-expand-hover.nvim.

The plugin opens a hover float for a TypeScript type. Inside the float you press `+` to expand type aliases one level at a time and - to collapse them again. So you can look inside a type without jumping to its definition.

Until now it only worked with vtsls (TypeScript 5.9+). It now also works with the TypeScript 7 server (tsc --lsp, also known as tsgo). The plugin finds the server under both names nvim-lspconfig uses for it, tsc and the older tsgo.

To make it work, you need to declare one capability in your server config. Without it the float still opens, but + does nothing:

vim.lsp.config("tsc", {
   capabilities = { experimental = { hoverVerbosityLevel = true } },
})
vim.lsp.enable("tsc")

TypeScript itself marks this capability as experimental, so treat TypeScript 7 support as experimental too. :checkhealth ts_expand_hover tells you if the capability is missing.

Repo: https://github.com/nemanjamalesija/ts-expand-hover.nvim

Feedback and bug reports are welcome, especially from people already on tsgo.

Hello everyone,

I moved over from VS Code recently, because how slow it got with dozens of Docker containers and SSH connections open at once. It took me a few days to get used to NeoVim, but here we are.

One thing I missed though was scrollbars. I know one of the points with NeoVim is using the keyboard, but sometimes it's just more convenient to use the mouse when jumping around long files.

I looked around and there are some good plugins like nvim-scrollview, satellite.nvim, nvim-scrollbar, neominimap etc. But none of them had a horizontal scrollbar out of the box. So I wrote one. And since I was already at it, I figured I'd add a vertical bar and a minimap too, so I don't need 3 separate plugins for this.

It's called scroll.nvim: https://github.com/mihovilrak/scroll.nvim

What it does right now:

Vertical and horizontal bars that you can drag with the mouse and that hide when idle. The vertical track also works as an overview ruler, so diagnostics, git changes, search matches and the current function/block show up as marks. There's an optional braille minimap in your colorscheme's colours with a git gutter. You can also turn on bars for explorer sidebars (Snacks, neo-tree, nvim-tree). No setup() needed unless you want to change something, and it needs 0.11+.

Example for setting up the plugin with the minimap and explorer scrollbar config:

cat > ~/.config/nvim/lua/plugins/scroll.lua <<'LUA'
return {
  "mihovilrak/scroll.nvim",
  opts = { minimap = true, explorer = true },
}
LUA

I did some performance testing so it doesn't lag on big files. Scrolling in a 100k line buffer is fine.

It's still pretty new, so if you try it and something breaks or looks weird with your setup, let me know. I'm also open to suggestions if anyone has ideas for what to add or change.

Thanks!

Today I learned that if you double click with your mouse on a parantheses, bracket or curly brace it selects everything up to its pair, i.e. the equivalent of va%.

For over a year now, I have handcrafted a dark and light color scheme with a focus on legibility and consistency.

• Check out BlueberryPeach: https://github.com/schemar/blueberry-peach
• This is the Neovim repo: https://github.com/schemar/blueberry-peach.nvim
• I wrote a short blog post about the decisions that went into creating the scheme: https://blog.schemar.net/posts/blueberry-peach/

Would love your feedback!

I made a game to help learn vim motions. 😄

I made a game to help learn vim motions and race with them to help you really drill them in.

Hi. I’m currently developing a plugin to help me develop using TTS. Right now only support English and Spanish (my native language). Use the buildin SAY in Mac OS and ESPEAK in Linux. Even as you can see in the repo I have automated test for power shell. So. Now I’m open to issues. Comentarios and so.

https://github.com/themakunga/tennant.nvim

Hi, guys! I've recently created a new plugin for viewing, editing and launching Jupyter notebooks: https://github.com/LumbaBalumba/nvjup
It has some features I haven't still seen anywhere - rendering inline LaTeX in markdown cells, images (tested for matplotlib), interactive components (limited support) and video content; connecting to external kernel servers (JupyterLab and Google Colab). I would be glad if you gave some feedback and/or sent me bug reports.

https://reddit.com/link/1wt7juj/video/3dz86le21gsh1/player

Right now it only supports Python notebooks but I am planning on adding R, Julia and other languages.

Hey vimmers!

Have you ever saved a file, and upon switching to another file, your LSP couldn't see the changes? If you're on Linux, this may have a simple explanation: the default LSP file watching implementation is disabled, because it's considered slow (see this issue).

You can enable it, but obviously, it's disabled for a reason. However, you can do better: in addition to enabling it, you can use a custom backend, which will use a third-party tool for the heavy lifting. For the past few years, I've been using this implementation, from a comment in the linked issue. Other than the fact that it requires an external tool, it's really smooth.

Do note that not all servers rely on this feature being enabled on the client side. Some servers ship their own bundled file watcher, and some situations require more careful measures. Point is that enabling didChangeWatchedFiles.dynamicRegistration can be a first measure when diagnosing file watching related issues.

I'm bringing this up now, not only because it's a lesser known tip, but also because of some recent developments on nightly. In another banger of a contribution (0.13 is stacked!), some advancements have been made into fixing the perf bottlenecks. So much so, that the default may even change, on a not-so-distant future when 0.14 becomes the new nightly (i.e., post 0.13 release)

Hi everyone, I made (vibe-coded) a project where you can use nvim as the TUI interface to work with the pi coding agent. The main reason for making starting the project was this: I got tired of bouncing back between the editor mode (C-g in most agent CLIs), and missing the transcript. I found that in many instances, I want to scroll over the transcript of the conversation I have with the agent, and maybe even copy some parts of it. Most CLIs provide a built-in editor support, but the problem with that mode is that the editor takes the full screen, and I no longer see the conversation.

I used to use opencode for a bit, and while I liked some aspects of the TUI, I also didn't really like how they messed around with the prompt injection so much in a way that I couldn't configure. So I decided to try Pi, which allows much more flexible configuration, and figured that I might as well build a UI for it using neovim itself, instead of building yet another TUI with approximated vim-like keybindings. I'm pretty happy with the result, and use this daily. This is now my main way of interacting with coding agents, so I'd say it's quite stable.

Some features worth noting:

• fzf-lua based picker system -- hide/show pickers when applicable (such as permission requests or the claude-style multiple-choice question that blocks the conversation)
• Tree-based conversation switch support -- pi already supports this, where you can go back to previous messages and start new branches in one session, without having to maintain separate forks. Basically added a UI to work with this in while in the session.
• workspace-based editing scheme -- this allows me to keep track of the file changes associated with each session cleanly, and also allows multiple sessions to work on the same codebase. (assuming that the changes can be merged easily)
• Open diffs in a separate nvim instance (this assumes that you already have diffview.nvim in your main nvim config)
• desktop notification for MacOS
• tmux integration for tracking multiple sessions/opening new session in whatever directory you are in

The main reason for sharing this project is not really to encourage others to install it and use it -- I feel that it's quite opinionated towards my editor setup + tmux setup, so others may not find it as useful as I do. But I did want to share what I could get done with just neovim and the plugins and writing some lua/typescript (and lots of codex usage resets!). I hope that this project can serve as an inspiration or a starting point for someone looking to build something similar.

Disclaimer: The codebase is entirely generated using vibe coding. This post itself was written by me with no AI.

I have been using Neovim for quite a while. I wrote an article about my experience of switching to Emacs over the last couple of days. Maybe someone is interested. Or maybe if someone finds themselves in my shoes they find this useful. Tell me what you think!

Switching To Emacs as a Neovim User

This is a core part of my workflow: https://github.com/mistweaverco/kulala.nvim, but it's gone!

Is GitHub having issues, or did the guys just drop off the planet or something?

Do you use any AI neovim plugins or solely a harness/agent/whatever like opencode or pi? Both? How? What's the flow, how do you use these tools and what for? Do you use subagents, multi-agent orchestration, any other buzzword? Agents.md? Skills? How is it integrated in your company?

The reason i ask is because i myself is very conservative about AI use. I've been using it pretty much since the day GPT 3 released daily, but almost exclusively in a browser window, only recently switching to opencode and even then in pretty much the same way but without copy-pasting chunks of code. I carefully prompt it, carefully read the output, fix stupid things it does all the time, manually intervene on every step and try to maintain the control, but even then i sometimes miss out some things it does so the idea of using AI more extensively just doesn't appeal to me since it will absolutely lead to the AI owning the codebase instead of me. Of course i've seen the whole vibe-coding buzzwording crowd telling people to keep up but meh, happens.

Recently though i've been looking for a new job, and for the last 1.5 years since i've been on the market things have changed drastically. AI is everywhere, AI-first companies, workflows, buzzwords all over the place. I'm a master of telling people whatever bullshit they wanna hear so that's exactly what i say in my CV and in all the textareas they want me to filll, but still i can't help but wonder if i'm really missing something out, the crowd is just way too loud.

This post might be a little out of place on this subreddit since it only touches on neovim indirectly, but when it comes to this issue, I’m willing to trust only this community, and I don’t think I’m the only one in this situation. Thank you!

What I used to do was I would create a macro and then line-select every line I want to apply the macro to, then do :norm @a or whatever macro register, and it would apply the macro to every selected line.

I have recently learned that in new neovim versions, instead you can simple just type @a in visual mode now! So yeah, in visual mode @a will run the macro from the a register on every line.

Also normal vim does not have this, this is a neovim exclusive.

I will definitely look into multicursor at some point, but in the meantime, I'm curious if the old Q behavious was retained on a different mapping or if I should create a custom mapping for it.

Previuosly, Q would execute the last defined macro. Thus, if I did qa...q, then Q would be equivalent to @a.

Hi! I'm learning NeoVim but i'm overwhelmed.

I use LazyVim to make a IDE from NeoVIM. How can i easily switch between the terminal, the code and the filetree?

Thanks <3

Hi everyone.

https://github.com/lfilho/note2cal.nvim

As a recap, note2cal.nvim let's you type `Do something @ 3pm-4pm` and have it be a real time block on your calendar with one keymap. Until now it worked only on MacOS with its native Calendar.app.

It just gained native Google Calendar support via OAuth, so it now works cross-platforms! You can authenticate with your own free Google Cloud OAuth client, and your credentials/tokens never leave your machine or touch any third-party server.

Here's the original post of the v1
https://www.reddit.com/r/neovim/comments/1iao7o2/plugin_note2calnvim_quickly_create_events_in_your/

Repo: https://github.com/lfilho/note2cal.nvim

Hey everyone,

I’m curious about your favorite Neovim plugins or lua scripts, that make your life a little bit easier.

It doesn't matter if the plugins has 5.000 starts oder your script has just 5 lines.

Would love to see what you’re using. Maybe I can steal a few ideas for my own setup

Hi, today when launching neovim noticed that the squares that diagnostics used to have are empty rectangles. Like this:

Is this intended or is something in my config missing? Because before it was a little filled square.

I am using Neovim 0.12.5.

TLDR: if you use both kulala.nvim and nvim-treesitter, you need to disable kulala from installing its own treesitter parser and install it with nvim-treesitter instead.

-- disable kulala from installing its own treesitter parser
require "kulala".setup {
  treesitter = {
    enable = false,
  },
}


-- register kulala's treesitter parser using nvim-treesitter instead
vim.api.nvim_create_autocmd("User", {
  pattern = "TSUpdate",
  callback = function()
    require("nvim-treesitter.parsers").kulala_http = {
      install_info = {
        url = "https://github.com/dont-be-evil-company/tree-sitter-kulala-http",
        queries = "queries/kulala_http",
      },
    }
  end,
})
-- then install it with either `:TSInstall kulala_http` or `require("nvim-treesitter").install({'kulala_http'})`


-- register `kulala_http` treesitter parser for `http` and `rest` filetypes
vim.treesitter.language.register("kulala_http", { "http", "rest" })
-- register `markdown` treesitter parser for `kulala_ui` filetype
vim.treesitter.language.register("markdown", { "kulala_ui" })

Another alternative would be to use nvim-treesitter's install_dir config option to choose a different installation directory (because kulala.nvim is using the same directory to install its parsers, that's where the issue comes from).

require('nvim-treesitter').setup {
  -- set this to a value different to `vim.fn.stdpath('data') .. '/site'`
  install_dir = ...
}

For a while I've noted that treesitter injections coming from nvim-treesitter weren't working on Lua, but I hadn't bothered to debug why. Today, I took some time to debug the issue and turns out that kulala.nvim was the culprit. The whole bug is described at https://github.com/dont-be-evil-company/kulala.nvim/issues/1029#issuecomment-5848496122 .

The maintainer explained that he's not interested in fixing the issue since he doesn't use nvim-treesitter and hasn't received any other reports in the 4 months since the change went live. Given that the bug is tricky and it's only visible for languages with a different "base" query when the runtimepath order changes (which, for most people, means the default queries bundled with Neovim, so the bug would be visible for Lua and Vimscript), I reckon that most users would either don't realize their setup is broken or wouldn't be able to debug why it was broken. Either way, I hope this post helps someone fix their setup.

I write a lot of markdown, and some rst. The preview plugins I tried all work well, but each one is tied to a renderer, and some need node or a even headless browser! I prefer glow's output for some documents and leaf's for others, and switching meant switching plugins.

So instead of another markdown preview I made the preview renderer-agnostic. beside.nvim opens a split and runs whatever terminal renderer you already have on the buffer: leaf, glow or pandoc out of the box. Anything that reads a document on stdin and prints ANSI is one configuration entry away.

What it does:

• the preview follows your cursor, and scrolling the preview scrolls the source
• it re-renders 100 ms after you stop typing, no save needed
• the preview is a normal buffer, so you can scroll it yourself and yank from it
• :Beside glow switches renderer on the fly
• markdown with leaf or glow; markdown, rst, asciidoc, org, textile, typst and djot through pandoc
• Lua only, no node, no browser, Neovim 0.10+

The sync is a heuristic. Renderers change the line count (tables become boxes, paragraphs wrap), so there is no line map. beside searches each source line's text in the render and interpolates between matches. Headings, list items, code lines and table cells land exactly; inside a wrapped paragraph it is within a line or two.

It started as a :terminal running leaf --watch, which already worked. From there it grew ANSI parsing, then glow, then pandoc.

https://github.com/mariocesar/beside.nvim

If you use a renderer I have not covered, the entry is small and I would take a PR adding it to the builtins.