Skip to content
The ultimate Vim configuration: vimrc
VimL C Python Emacs Lisp Shell TeX Other
Find file
Pull request Compare This branch is 42 commits ahead, 101 commits behind amix:master.
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.
autoload
bundle
sources_forked
sources_non_forked
temp_dirs
vim_plugin_candinates_src
vimrcs
.gitignore
.gitmodules
README.md
install_awesome_vimrc.sh
install_basic_vimrc.sh
my_configs.vim
update_plugins.py

README.md

The Ultimate vimrc of hustcalm forked from amix

Below is the original readme post of amix

Over the last 8 years I have used and tweaked Vim. This is my Ultimate vimrc.

There are two versions:

  • Basic: If you want something small just copy basic.vim into your ~/.vimrc and you will have a great basic setup
  • Awesome: This includes a ton of useful plugins, color schemes and configurations

I would of course recommend using the awesome version.

How to install the Basic version?

The basic version is basically just one file and no plugins. You can check out basic.vim.

This is useful to install on remote servers where you don't need many plugins and you don't do many edits.

git clone git://github.com/amix/vimrc.git ~/.vim_runtime
sh ~/.vim_runtime/install_basic_vimrc.sh

How to install the Awesome version?

The awesome version includes a lot of great plugins, configurations and color schemes that make Vim a lot better. To install it simply do following:

git clone git://github.com/amix/vimrc.git ~/.vim_runtime
sh ~/.vim_runtime/install_awesome_vimrc.sh

How to install on Windows?

Use msysgit to checkout the repository and run the installation instructions above. No special instructions needed ;-)

How to update to latest version?

Simply just do a git rebase!

cd ~/.vim_runtime
git pull --rebase

Some screenshots

Colors when editing a Python file: Screenshot 1

Opening recently opened files mru.vim: Screenshot 2

NERD Tree plugin in a terminal window: Screenshot 3

This vimrc even works on Windows! Screenshot 4

What plugins are included?

I recommend reading the docs of these plugins to understand them better. Each of them provide a much better Vim experience!

  • pathogen.vim: Manages the runtime path of the plugins
  • YankRing: Maintains a history of previous yanks, changes and deletes
  • snipMate.vim: snipMate.vim aims to be a concise vim script that implements some of TextMate's snippets features in Vim
  • bufexplorer.zip: Buffer Explorer / Browser. This plugin can be opened with <leader+o>
  • NERD Tree: A tree explorer plugin for vim
  • ack.vim: Vim plugin for the Perl module / CLI script 'ack'
  • vim-powerline: The ultimate vim statusline utility
  • ctrlp.vim: Fuzzy file, buffer, mru and tag finder. In my config it's mapped to <Ctrl+F>, because <Ctrl+P> is used by YankRing
  • mru.vim: Plugin to manage Most Recently Used (MRU) files. Includes my own fork which adds syntax highlighting to MRU. This plugin can be opened with <leader+f>
  • open_file_under_cursor.vim: Open file under cursor when pressing gf
  • zencoding: Expanding abbreviation like zen-coding, very useful for editing XML, HTML.
  • vim-indent-object: Defines a new text object representing lines of code at the same indent level. Useful for python/vim scripts
  • taglist.vim: Source code browser (supports C/C++, java, perl, python, tcl, sql, php, etc)
  • vim-multiple-cursors: Sublime Text style multiple selections for Vim, CTRL+N is remapped to CTRL+S (due to YankRing)
  • vim-expand-region: Allows you to visually select increasingly larger regions of text using the same key combination.

What color schemes are included?

What modes are included?

How to include your own stuff?

After you have installed the setup you can create ~/.vim_runtime/my_configs.vim to fill in any configurations that are important for you. For instance, my my_configs.vim looks like this:

~/.vim_runtime (master)> cat my_configs.vim
map <leader>ct :cd ~/Desktop/Todoist/todoist<cr>
map <leader>cw :cd ~/Desktop/Wedoist/wedoist<cr> 

You can also install your own plugins, for instance, via pathogen we can install vim-rails:

cd ~/.vim_runtime
git clone git://github.com/tpope/vim-rails.git sources_non_forked/vim-rails

Now you have vim-rails installed ;-)

Key Mappings

Plugin related mappings

Open bufexplorer and see and manage the current buffers:

map <leader>o :BufExplorer<cr>

Open MRU.vim and see the recently open files:

map <leader>f :MRU<CR>

Open ctrlp.vim plugin:

let g:ctrlp_map = '<c-f>'

Open PeepOpen plugin:

map <leader>j :PeepOpen<cr>

Managing the NERD Tree plugin:

map <leader>nn :NERDTreeToggle<cr>
map <leader>nb :NERDTreeFromBookmark 
map <leader>nf :NERDTreeFind<cr>

Normal mode mappings

Fast saving of a buffer:

nmap <leader>w :w!<cr>

Treat long lines as break lines (useful when moving around in them):

map j gj
map k gk

Map <Space> to / (search) and <Ctrl>+<Space> to ? (backwards search):

map <space> /
map <c-space> ?
map <silent> <leader><cr> :noh<cr>

Disable highlight when <leader><cr> is pressed:

map <silent> <leader><cr> :noh<cr>

Smart way to move between windows:

map <C-j> <C-W>j
map <C-k> <C-W>k
map <C-h> <C-W>h
map <C-l> <C-W>l

Closing of current buffer(s):

" Close current buffer
map <leader>bd :Bclose<cr>

" Close all buffers
map <leader>ba :1,1000 bd!<cr>

Useful mappings for managing tabs:

map <leader>tn :tabnew<cr>
map <leader>to :tabonly<cr>
map <leader>tc :tabclose<cr>
map <leader>tm :tabmove 

" Opens a new tab with the current buffer's path
" Super useful when editing files in the same directory
map <leader>te :tabedit <c-r>=expand("%:p:h")<cr>/

Switch CWD to the directory of the open buffer:

map <leader>cd :cd %:p:h<cr>:pwd<cr>

Open vimgrep and put the cursor in the right position:

map <leader>g :vimgrep // **/*.<left><left><left><left><left><left><left>

Vimgreps in the current file:

map <leader><space> :vimgrep // <C-R>%<C-A><right><right><right><right><right><right><right><right><right>

Remove the Windows ^M - when the encodings gets messed up:

noremap <leader>m mmHmt:%s/<C-V><cr>//ge<cr>'tzt'm

Quickly open a buffer for scripbble:

map <leader>q :e ~/buffer<cr>

Toggle paste mode on and off:

map <leader>pp :setlocal paste!<cr>

Insert mode mappings

Quickly insert parenthesis/brackets/etc.:

inoremap $1 ()<esc>i
inoremap $2 []<esc>i
inoremap $3 {}<esc>i
inoremap $4 {<esc>o}<esc>O
inoremap $q ''<esc>i
inoremap $e ""<esc>i
inoremap $t <><esc>i

Insert the current date and time (useful for timestamps):

iab xdate <c-r>=strftime("%d/%m/%y %H:%M:%S")<cr>

Visual mode mappings

Visual mode pressing * or # searches for the current selection:

vnoremap <silent> * :call VisualSelection('f')<CR>
vnoremap <silent> # :call VisualSelection('b')<CR>

When you press gv you vimgrep after the selected text:

vnoremap <silent> gv :call VisualSelection('gv')<CR>

When you press <leader>r you can search and replace the selected text:

vnoremap <silent> <leader>r :call VisualSelection('replace')<CR>

Surround the visual selection in parenthesis/brackets/etc.:

vnoremap $1 <esc>`>a)<esc>`<i(<esc>
vnoremap $2 <esc>`>a]<esc>`<i[<esc>
vnoremap $3 <esc>`>a}<esc>`<i{<esc>
vnoremap $$ <esc>`>a"<esc>`<i"<esc>
vnoremap $q <esc>`>a'<esc>`<i'<esc>
vnoremap $e <esc>`>a"<esc>`<i"<esc>

Command line mappings

$q is super useful when browsing on the command line. It deletes everything until the last slash:

cno $q <C-\>eDeleteTillSlash()<cr>

Bash like keys for the command line:

cnoremap <C-A>      <Home>
cnoremap <C-E>      <End>
cnoremap <C-K>      <C-U>

cnoremap <C-P> <Up>
cnoremap <C-N> <Down>

Write the file as sudo (only on Unix). Super useful when you open a file and you don't have permissions to save your changes. Vim tip:

:W 

Spell checking

Pressing <leader>ss will toggle and untoggle spell checking

map <leader>ss :setlocal spell!<cr>

Shortcuts using <leader> instead of special chars

map <leader>sn ]s
map <leader>sp [s
map <leader>sa zg
map <leader>s? z=

Cope

Do :help cope if you are unsure what cope is. It's super useful!

When you search with vimgrep, display your results in cope by doing: <leader>cc

To go to the next search result do: <leader>n

To go to the previous search results do: <leader>p

Vimscript mappings:

map <leader>cc :botright cope<cr>
map <leader>co ggVGy:tabnew<cr>:set syntax=qf<cr>pgg
map <leader>n :cn<cr>
map <leader>p :cp<cr>

Useful blog tips regarding my Vim setup

Above is the original readme post of amix

My Updates to The Ultimate vimrc

Add some useful candinate plugins to the repo

See them in vim_plugin_candintes_src.

All these plugins will be candinates to be added to my Ultimate vimrc.

You can also add your own favorite script from vim-scripts.org or install from github.

Use git and pathogen to manage vim plugins

Amix's method

As amix mentioned, you can isntall your own plugins via pathogen,for instance vim-rails:

cd ~/.vim_runtime
git clone git://github.com/tpope/vim-rails.git sources_non_forked/vim-rails

After this,you got vim-rails under sources_non_forked/vim-rails as a git local repo.

But all you got at this time is a local repo and you may get upset if you want to share your very super plugin together with Ultimate vimrc.

Manage with git submodule

Instead I'm using git submodule to manage vim plugins now(Alternately you can use git subtree), clone them from github and install,config,update,delete,etc...

And as a vimer, I prefer to drop the plugins to bundle rather than sources_plugins thus pathogen can find it automatically.

As we want to install vim-rails:

cd ~/.vim_runtime
git submodule add git://github.com/tpope/vim-rails.git bundle/vim-rails
git commit -a -m 'first commit with submodule vim-rails'
git submodule init

Clone repo with Git Submodule

If you want to clone my repo and favor the vim plugins managed with submodule, you need to run:

git submodule init
git submmodule update

after you clone my repo.

Update Installed module

cd bundle/vim-rails
git pull origin master
cd ~/.vim_runtime
git status
git commit -a -m 'update vim-rails'
git push
git submodule status

Remove Sub Module

git rm --cached bundle/vim-rails
git rm bundle/vim-rails
vi .gitmoudles
vi .git/config
git add . && git commit -m 'Remove Submodule vim-rails'
git submoudule sync

Above we use vi to edit .gitmoudles and .git/config to remove references to specific submoudle.

git submodule reference

Use Vundle to make life easier managing plugins

Vundle is short for Vim bundle and is a Vim plugin manager.

Vundle allows to:

  • keep track and configure your scripts right in .vimrc
  • [install] configured scripts (aka bundle)
  • [update] configured scripts
  • [search] by name [all available vim scripts]
  • [clean] unused scripts up
  • run above actions in a single keypress with [interactive mode]

Also Vundle:

  • manages runtime path of your installed scripts
  • regenerates helptag automatically

Simple commands like BundleInstall, BundleSearch, BundleClean get everything done!

For more info, please refer to the offcial repository.

Currently, I install Vundle as a git submodule and managed by pathogen, but for other plugins management, I'm happy to play with Vundle.

Note:

You can either use git submodule to manage your vim plugins as I do now, or you can manage using Amix's approach cause ha has provided a python script to get all the plugins updated with one single command.

Something went wrong with that request. Please try again.