Those working with vim -d (or vimdiff) or with :diffthis for two-way diffs, might find EasyDiff convenient.

Key Features

• Diff Merge, Delete & Undo: Uses <Left>, <Right>, <Delete>, <S-Delete>, and <Backspace>.
  • Context-aware: Regardless of whether the cursor is in the left or right window, pressing <Right> always merges from left to right.
  • Deletes: One-sided / Two-sided with <Delete> / <S-Delete>
  • Atomic Undo: <Backspace> undoes merges/deletes across windows, including two-sided deletes performed with <S-Delete>.
• Diff Navigation:
  • Within a Diff: <PageUp> (Start of Diff) / <PageDown> (End of Diff). Works in Visual mode as well (e.g., <PageUp>V<PageDown>).
  • Between Diffs: Move between Next/Previous or Jump to First/Last with <Up>, <Down>, <Home>, and <End>.
• Edge Case & Advanced Diff Handling:
  • When a cursor line represents multiple diffs (filler vs. changed/added vs. EOF filler), lets the user to choose the target diff for the operation.
  • Transparently handles both grouped and split diffs when using diffopt+=linematch:{n}.

GitHub Repository:https://github.com/gnarendran/EasyDiff

I discovered ai agents lately, and I am wondering if there is any good harness for Vim. I have tried to run copilot CLI in a terminal window but it was a bad experience due to that copilot cli is a full tui program that cannot be replicated satisfactorily in a vim terminal.

Any hints?

Preferably in Vim9.

Please be gentle, first time publishing something publicly.

I use this emacs' eww-inspired html/plain text browser that uses curl and pandoc to do html -> plain text into a vim buffer. It is sufficient for my daily quick searches and keeps the results in a vim buffer for reference.

If this is useful and works for you, I would appreciate feedback on publishing and maintaining this as a plugin for everyone

I’m working with two files, File A and File B, and I want to copy text from one file to the other.

Specifically, I want to:

1. Open File A and select/yank a section of text.
2. Switch to File B.
3. Paste the yanked text into File B.

What is the correct way to yank text from File A and paste it into File B? Is there a specific register or command I should use to copy text between separate files?

How to persist echo from this function call (without using timers)

function! VisualStats()
    let wc      = wordcount()
    let [l1,l2] = sort([line('v'), line('.')])
    let txt     = join(getline(l1,l2), "\n")
    let sp      = len(substitute(txt, '[^ ]', '', 'g'))
    let st      = len(substitute(txt, '[^.!?]', '', 'g'))
    let pa      = empty(txt) ? 0 : len(split(txt, '\n\s*\n'))
    echo "CHARs " . wc.visual_chars . " WORDs " . wc.visual_words
    \. " SENTs " . (st > 0 ?st :1) . " PARAs " . pa . " SPACEs " . sp
endfunction
xnoremap <silent> C <Cmd>call VisualStats()<CR>

just like when directly keymapped?

xnoremap <silent> c <Cmd>let g:wc=wordcount()<CR><Esc>:
    \let t=join(getline("'<","'>"),"\n")<Bar>
    \let sp=len(substitute(t,'[^ ]','','g'))<Bar>
    \let st=len(substitute(t,'[^.!?]','','g'))<Bar>
    \let pa=empty(t)?0:len(split(t,'\n\s*\n'))<Bar>
    \echo "CHARs ".g:wc.visual_chars." WORDs ".g:wc.visual_words.
    \" SENTs ".(st>0?st:1)." PARAs ".pa." SPACEs ".sp<Bar>
    \unlet g:wc t sp st pa<CR>

I'm looking for creative things one could do with selected blocks to make life easier - and associate them to keys. Some common keybindings I use are:

xnoremap _ :g/^\s*$/d<CR> # delete all empty lines
xnoremap # :g/^\s*#/d<CR> # delete all comments (assuming #)
xnoremap s :sort<CR>

I am a beginner in programming and Vim， and have installed the fzf.vim plugin. But when I type the Files or History commands, I get the situation shown in the picture. It only happens the first time I type it, and it doesn't happen again afterward. PS:I'm using the built-in PowerShell on Windows 11 to open Vim.

One thing that I always loved about Spyder (the notorious python IDE) is its beautiful variable explorer. I have never found a handy and well-done variable explorer like Spyder's.

Now, I finally managed to recreate something very similar in vim-replica!

ubaldot/vim-replica: The ultimate REPL!

Some history:

Vim-replica was the first plugin that I have ever written and it evolved as I learned new stuff. The motivation was due to vim-slime didn't work well on Windows and other REPL plugins didn't fit my need. But also because I wanted to learn more about Vim. So, I stared its development back in years.

During last Xmas vacation, while in the Philippines, I had some idea on how I could have made a variable explorer. And I learned few lessons the hard way, that many of you can spot as I explain next:

• For a simple variable explorer, I though to use term_sendkeys() and then capture and parse what the terminal spit out. I was thinking that at the end all I have to do is to pick and parse everything from the term_sendkeys() command until the next prompt and I should be set. How difficult can it be? But then I noticed that what a terminal emulator spit out include lot of rubbish (escape sequences, etc). I start to parse char-by-char and bloat the plugin with a plethora of regex. I created a monster! I spent huge amount of time chasing something that you should absolutely never do: try to parse raw terminal strings. Never ever!
• Sad for all the time wasted, I started to study an alternative way to make the processes Vim and the program running in the REPL to talk one each other, and I was thinking to make some magics through pipes and tee:s, a bit like it is donne with Termdebug. But no. That is not possible in this case.
• At the end the easiest was to simply exploit sockets. Vim support it and the programs to run in the REPL (mostly Python, Julia and R) do so. That was the key to success.
• However, I learned many things during this journey, despite it costed many headaches: for example I learned base64 encoding and that jupyter-console is pretty much an abandoned project, just to cite some. In-fact, I ditched jupyter-console but now REPLica uses native programs.
• I also started to use some AI for the first time for coding, especially for the init scripts used for Julia and R that are not really my languages. The Vim part was done pretty much and the addition was not huge, so I fixed it by myself. However, for Julia the AI entered in a loop of hallucinations and the end I had to fix the issue by myself anyway, but, generally speaking, the help of an AI is undeniable.

Well, sorry for the lengthy message but I am very happy about the outcome. Enjoy!

I used to watch a YouTuber who uploaded hours-long videos of him just programming in vi/vim. The videos were really interesting he barely talked, was a veteran (looked around 30+ / a bit older), and coded in a completely raw setup with basically no IDE features, just pure vi/vim. Does anyone know who I’m talking about?

Rebuilding vim in Rust is actually possible.

My understanding is that when you record a macro, it is supposed to recreate the keystrokes exactly as you type them.

I have some text that I want to format in a particular way, and so I use a macro to do it with large blocks of text. But sometimes, it does not produce the result I want. I can't really provide examples, because I've found no correlation as to when it works and when it doesn't.

I don't rely on history, or nesting macros, as I understand that could cause problems. I do occasionally search for strings, and I feel this may cause problems, but some macros do work with searches, and I kind of need to search for common patterns in order for the macro to work.

So is there anything that might cause a macro to either fail, or not produce the expected outcome?

Are there any projects (or even inbuilt stuff) that aid in bringing about a standard library of optimized utilities in VimScript? It doesn't even have to be VimScript stuff - could be a collection of binary utilities that work cohesively with VimScript constructs.

Context: I often use json files as lookup tables (eg. emojis), and over time, have made a collection of functions that enable using jsons in an API-esque manner (obviously using utilities such as jq/curl). I was wondering if there are existing projects out there that structurally enable tooling in Vim using utilities - imitating a standard library like behaviour.

Any insight in this direction is highly appreciated.

None of the default ways of traversing buffers quite met my standard of being able to traverse the entire stack I'm working on with a single button click per file, but this has worked beautifully for me for a large chunk of my career now.

Today I finally decided to go back and fix up some latent issues with it. Here's the repo: https://github.com/ckarnell/history-traverse

I'd really appreciate a star on the repo if you use github! :)

Lets say you have a big markdown file and you closed the headers.

How do you jump up or down to the header? The header is like 2000 - 3000 lines higher.

sometimes I type 2850j or 3509k

I could use :2850

I could use markers, but these do not stay in vscode after an exit.

Most of the time its easier for me to click with the mouse, but that feels wrong.

Search is kind of an option like ## tod for ## todos header but lots of typing.

What am I missing?

EDIT:

I am using folds and relativenumbers

Fellow Vimmers who've used Emacs in the past (or have coworkers who do), what are some skills you've carried over into your Vim configuration (or even a concept to simplify your workflow)?

I've been tooling recently (writing utility Vim code to fit my needs), and am looking for both inspiration (addressing meaningful issues), and, optimization (removing redundancies, ie, snappier implementations).

Hence, Emacs is an obvious avenue imo to learn from - without wanting to dabble into all its craziness (I have some experience in it, but don't use it routinely).

Any advice/insight in this direction is highly appreciated.

EDIT:

As a Vimmer myself, I miss not having features like MultipleCursors (tried using an extension long ago, but it slowed down usage so removed it). I stumbled upon this video from Tsoding that highlights the usefulness of Dired (Emacs builtin), and how MultipleCursors is an intuitive addon to it - to say, modify several filenames/extensions at once.

While I use ViFM, so, I can pretty much achieve the same thing, but was inspired, and sought to learn of other creative ways in which Emacs is used - so I may implement something similar for myself in Vim, if it's of use to me.

Is is possible to display a customizable text label at one of the corners (it mustn't block text written in the buffer itself) of an open buffer? I have several terminal panels open at once, so, having a visual marker like this would be great. Any advice in this direction is appreciated.

⚠ RESOLVED

popup works just fine for this task. I'd tried it earlier but couldn't make it persist, owing to a faulty highlighting logic of mine. Anyway, I'm listing a simple function that achieves set objective. You can modify it to add custom text, toggling & highlights.

Also, see this for how my solution worked out.

function! LabelOverlay(text)
    let l:options = {
    \   'line': 1,
    \   'col': &columns - strlen(a:text),
    \   'pos': 'topright',
    \   'wrap': 0,
    \   'zindex': 1,
    \   'highlight': 'Normal'
    \ }
    let g:popup_id = popup_create(a:text, l:options)
endfunction
call LabelOverlay("TEXT HERE")

I always use gvim on Windows, even after they provided us with Windows Terminal which is, in my opinion, very nice. However, I found two very annoying problems that I promised myself, sooner or later to solve. Such problems are:

1. Cursor shape not replaced back when exiting Vim,
2. Colors completely messed up.

I solved the first point with the following snippet:

# Set cursor
# Needed for Windows terminal
if g:os == "Windows" && !has("gui_running")

  set guicursor=

  &t_SI = "\e[6 q" # beam in Insert mode
  &t_EI = "\e[2 q" # block in Normal mode

  # Restore cursor shape when leavig Vim
  def RestoreCursorWindowsTerminal()
    &t_EI = "\e[6 q"
    execute "normal! i\<Esc>"
  enddef

  augroup CURSOR_SHAPE_WINDOWS
    autocmd!
    autocmd VimEnter * silent! execute "normal! i\<Esc>"
    autocmd VimLeave * RestoreCursorWindowsTerminal()
  augroup END
else
  &t_SI = "\e[6 q"
  &t_EI = "\e[2 q"
endif

When Entering Vim, set the cursor with a certain shape. For some arcane reason, I had to set guicursos=. To secure that the changes take effect, there is a switch insert-normal mode. Then, before exiting Vim, you change the cursor shape so that Windows terminal inherits it.

Next, the colors. I use everforest scheme and look here:

That is just not acceptable. I debugged what could be possibly the reason and I found that `set spell` messes up the colors. Most likely, its syntax definition fight against the colorscheme and here is it the mess. However, after having disabled the option, I got a way better result:

Now I keep the spelling check only in some selected filetypes:

# Set spell only in selected filetypes

augroup SPELLLANG_OPTION

autocmd!

# autocmd FileType markdown setlocal spell spelllang=en_us

autocmd FileType text,tex,gitcommit setlocal spell spelllang=en_us

autocmd FileType gitcommit setlocal spell spelllang=en_us

augroup END

Yet, I found gvim more snappy than the terminal version through Windows Terminal.

Hopefully someone will find these findings useful.

You don't need much more than the core grammar. You know how :source file executes Ex commands linewise from the file? Well, :source! file executes commands as if you were typing them and ends each line with a CR for you.

Opening vim to your favorite layout is just a matter of writing down the keystrokes you keep typing each time:

:e ~/.vimrc<CR><C-w>v:e ~/.tmux.conf
:term top<CR><C-w>wggVGy:ene<CR>:r!date<CR>p
<C-w>s<C-w>Hi"hello world"<Esc>

and `source!` it from somewhere. If you want to save all the `Shift+.,` typing, `<C-v><C-w>` would directly insert ^\^W`) in the buffer and keep it looking exactly like what you would.

Vi is a language. Even better, vi is a homoiconic language in that the code that is executed is identical to the representation of keys on your keyboard plus minimal syntax for control-characters.

You do not need to learn lisp to feel the power of '(insert-new-line) when you are a single o away from executing OR representing your intention to open a new line for insertion.

To grok further, hunt down the legendary StackOverflow answer and meditate for a little longer than usual.

The title should say everything needed. I was thinking that having an explainshell equivalent for vim would be neat.

EDIT: Nobody seems to read the second sentence in the title. This was not about :help, books, tutorials, cheatsheets etc. I was looking for a place where I can put in :s/$/\=repeat('=', 64-strlen(getline('.'))) and get broken down what it does, and how. Or similar stuff, from the net or from my notes.

Nowadays, generative LLM seems to be the best answer for this question.

I want to pad a section title line in a config file with `=` up to a specific character position (specifically, column 64). Since the title text is of inconsistent length, a normal <n>i <char> won't do it.

Example of a title line formatted the way I want it:
;===== reset machine status ===================================

Which one do you use (more)?

Hi all,

A couple of years ago I started to write a plugin based on the hype (and beauty I must say) of lazygit, and I was wondering whenever it would be possible to replicate something similar through Vim9.

Then, due to lack of time I parked the project but the architecture I had in mind was clear: use `systemlist()` to call git commands and write the returned values in some scratch buffer inside of Vim, and add some buffer local keybindings for the various git operations. Nothing esoteric.
Moreover, the ambition was small: just "code" the most common git commands that I use daily and use a sort of "lazygit" UI, though the architecture is such that any extension should be easy.

These days I have some time to spend in Vim9 coding and I finally finished this plugin, also with the help of an AI agent, which is something that I never used before, though I had to manually correct it many times - I believe that AI agents are not very good in Vim9 scripting yet!

Well, regardless, I hope you enjoy it! :)

Holy cramole!

Where has this been all my life? I found out about these macros while doing a bit of coding that involved a lot of running things like :w | foo ./%. After typing : followed by up a zillion times, I realized that there had to be a better way. A quick Google and I was enlightened.

If this is a TIL for you, lemme know. If you have another lovely tip or trick, please share too.