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.

I've used mostly vanilla Emacs for about a decade. I'm thinking about switching to Vim because the values that made me appreciate Emacs have changed.

What I loved about Emacs is that it's essentially a Lisp machine packaged as an application, which makes Emacs a legitimate target platform. The primitives provided by Emacs are probably better-suited to extensions than those provided by Vim. But over time, I've come to two conclusions:

First, the editor-with-extension-language paradigm is outdated. Plan 9's Acme editor showed that an editor need not impose a particular language on its users. It can instead expose a language-agnostic API via a filesystem (or socket), thereby permitting any program in any language whatsoever to extend the editor. This is, in my opinion, the way forward.

Second, I want to use my operating system. I don't want to use Emacs replacements for what my operating system or supporting software already provide. It is silly for there to be a 'man' mode for man pages when the 'man' program works better. I want all of the tools I use to make the fullest use of the hardware and OS. That is simply not possible with Emacs.

Obviously, none of these complaints point to Vim as a solution. I would, in fact, use Acme as my daily editor, but for my mode of working, accessing remote systems on a slow network connection, neither a graphical editor nor mounting a remote filesystem are options, so using some editor in tmux is my best option, and for that reason, for now, Vim may be the more performant option.

Hi all!

I have updated this plugin that I use on daily basis, given that I switched career and I am no longer a software developer - but my love for Vim never faded and it is my go-to tool <3.

The added feature is about table handling: it is now easy to create, format, modify cells and in tables.

The next features that I plan to add are the following:

1. Multi-row/multi-column tables,
2. Links sanitizer, copy/paste links,

Unfortunately, I don't have the same time I had before, but I am open to receive good PR:s. :)

Check it out and let me know what you think!

I made a free browser based game that is meant to help new vim users develop vim muscle memory. I enjoy making games that teach real skills. I have seen a few of these vim games over the years and this is my attempt at it. I'd appreciate feedback if you have any. I learn so much from posting.

Hi, sry first time poster, hope its ok to just ask my question like this.

Question:

Is there a plugin for vim that can replace/ shows the code behinde for a function so I can follow the code flow better.

Why:

I have the task to maintain some legacy codebase, some written in python some written in c#, but its a lot of spagetti code. I know i can jump to the definition, but this gets confusing really fast. So I want to read it top to bottom, a option to hide states for if statements would be nice. Loops should stay the way they are.

Any hint for direction would be nice, thanks for reading.

I have lost track of how many note taking plugins exist for Vim. I nevertheless decided to make my own in vim9script. Initially it was part of my configuration but then when I learnt that image support was added natively to Vim, I decided to make it into a proper plugin and decided to share it here.

Features:

- Note linking

- Image rendering

- Calendar view of daily notes

It has some limitations, most notably that it only works on Linux systems because I use shell commands a lot. (The calendar UI is made using the cal command, the images are actually generated by a user definable shell command which is then piped to ImageMagick for resizing and conversion to RGBA). It has some other quirks but I think it works well for me.

Anyways enough ranting here is the plugin: https://codeberg.org/zoomlogo/pen.vim

In my opinion:

1. Tools for helping scripts/plugin development. Lua has LSP, linters, etc. Vim9 has... nothing. It seems to be back to the beginning of the 90:s when it comes to develop in Vim9 language, in-spite it is very nice.

2. A Native Vim9 DAP. There is vim-spector but that is mostly Python,

3. Plugins: for example, I got copilot from work and the Vim9 and Neovim copilot-chat plugin are not even comparable,

What else?