How Does M Vim Compare To Neovim For Plugins?

If you’re trying to wrangle marks in Vim and keep losing your mental map of where you left stuff, you’re not alone — marks are insanely useful but a little clumsy out of the box. I used to set a bunch of lowercase and uppercase marks, then spend five minutes hunting for the one I actually needed. Over the years I picked up a handful of plugins and tiny tricks that make mark management smooth: visualizing marks in the gutter, persisting bookmarks between sessions, and giving quick keybindings to jump or list marks. The suggestions below are what I reach for when a project gets messy and I want my navigation to feel deliberate again. First up, plugins that make marks obvious and manageable: 'vim-signature' (shows marks in the sign column and offers lightweight mappings for toggling/removing marks), a bookmarks plugin (many are called 'vim-bookmarks' or simply 'bookmarks' on GitHub) which gives a persistent set of bookmarks you can toggle and list, and newer Neovim-focused tools like 'marks.nvim' that offer richer APIs in Lua (persistence, visual indicators, and nicer listing commands). If you do more file-level navigation than line-level, 'harpoon' (by ThePrimeagen) is fantastic for pinning frequently edited files and jumping to them instantly—it’s more file-bookmark than line-mark, but it complements marks nicely. There are also older helpers simply named 'vim-marks' or 'marks' that give :Marks-style listings and quick operations; search GitHub for any of those names and you’ll find several maintained forks and variants. Practical tips that helped me the most: get a plugin that visually marks lines in the sign column (so your eyeballs stop playing hide-and-seek), and pair that with an easy list command (many plugins offer :Marks or :Bookmarks which opens a quickfix or location list). For session persistence, either use a plugin that explicitly saves marks/bookmarks or rely on Vim’s session/mksession features to store your location info when you close a project. I also map a couple of ergonomic keys: one to toggle a bookmark on the current line, one to jump to the next/previous bookmark, and one to open the bookmark list in a quickfix window. Small mappings like that turn marks from an afterthought into a core part of my workflow. Honestly, once I split responsibilities (line marks + visual signs via a signature-style plugin, file marks via 'harpoon' or a bookmarks plugin, and session persistence via the plugin or mksession), my navigation felt way more intentional. If you want, tell me whether you’re using plain Vim or Neovim and which plugin manager you use (vim-plug/packer/ Dein/etc.), and I can sketch exact install lines and a tiny config snippet that matches your setup. I love tinkering with these little UX improvements—they’re the tiny tweaks that make long editing sessions much less painful.

If you're running MacVim (the mvim command) on macOS, the simplest, most reliable route for me has been vim-plug. It just feels clean: drop a tiny bootstrap file into ~/.vim/autoload, add a few lines to ~/.vimrc, then let the plugin manager handle the rest. For vim-plug I run: curl -fLo ~/.vim/autoload/plug.vim --create-dirs https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim. After that I edit ~/.vimrc and add: call plug#begin('~/.vim/plugged') Plug 'tpope/vim-sensible' Plug 'junegunn/fzf', { 'do': { -> fzf#install() } } call plug#end() Then I launch MacVim with mvim and run :PlugInstall (or from the shell mvim +PlugInstall +qall) and watch the plugins clone and install. A few handy things: if a plugin needs build steps, check its README; some require ctags, ripgrep, or Python support. Also remember MacVim reads your ~/.vimrc (and you can put GUI tweaks in ~/.gvimrc). If you prefer built-in package management, the pack/start method works too: mkdir -p ~/.vim/pack/vendor/start && git clone ~/.vim/pack/vendor/start/, then restart mvim.

Totally doable — and honestly, if you care about startup speed and responsiveness, moving Lua into your editor config is one of the cleanest moves I’ve made. I switched much of my setup to a Lua-first workflow (using Neovim) and noticed two big wins: faster plugin startup because plugin managers written in Lua can lazy-load better, and less overhead in your config because Lua is just faster than complex Vimscript. If you’re asking about "m vim" specifically (like MacVim or an ordinary Vim build called mvim), it comes down to how that binary was compiled. Vim can support Lua or LuaJIT if it was built with +lua or +luajit; Neovim, on the other hand, has first-class Lua from 0.5 onward and feels designed around it. Practical tip: check vim --version for +lua or +luajit, or just try :lua print('hi') inside the editor. If you want the smoothest, fastest Lua experience, I recommend trying Neovim and using an init.lua plus a Lua plugin manager like packer.nvim or lazy.nvim. Also profile startup with --startuptime and trim autocommands — that’s where speed really shows. It made editing feel snappier for me, especially when juggling many plugins.