ideavim Documentation

Doc/Home

Welcome to the IdeaVim wiki!

List of IdeaVim plugins: plugins
Examples of ideajoin option (also known as "smart join"): "ideajoin" examples
List of "set" commands: "set" commands
Docs about "select" mode in vim: select mode

Doc/IdeaVim Plugins

IdeaVim Plugins

IdeaVim plugins work like the original Vim plugins. If you want to turn any of them on, you have to enable it via this command in your ~/.ideavimrc:

text

Plug '<plugin-github-reference>'

If you reuse your existing .vimrc file using source ~/.vimrc, IdeaVim can parse and enable plugins that are defined
using vim-plug or vundle.
No additional set commands in ~/.ideavimrc are required.
If you'd like to disable some plugin that's enabled in .vimrc, you can use set no<extension-name>
in ~/.ideavimrc. E.g. set nosurround.

Available plugins:

abolish: Case-aware substitute and coercion mappings between case styles

Original plugin: vim-abolish.

Summary:

Coercion mappings (crs/cr_, crm/crp, crc, cru/crU, cr-/crk, cr., cr<Space>, crt)
recase the word under the cursor between snake_case, MixedCase, camelCase, UPPER_SNAKE, kebab-case,
dot.case, space case and Title Case. :Subvert (alias :S) is a case-aware :substitute that
handles all case variants and {a,b,c} brace alternatives in a single command. With only a pattern
(:S/foo/ or :S?foo?) it does a case-aware forward or backward search instead.

Setup:

Add the following command to ~/.ideavimrc: Plug 'tpope/vim-abolish'

text

Alternative syntax
`Plugin 'tpope/vim-abolish'`

`Plug 'https://github.com/tpope/vim-abolish'`

`Plug 'vim-abolish'`

`set abolish`

Instructions

https://github.com/tpope/vim-abolish/blob/master/doc/abolish.txt

:Abolish (insert-mode auto-correcting abbreviations) is not supported.

By default each cr<x> mapping recases the inner word under the cursor.
To get tpope-style motion support (crsiw, crsap, crs2w, …) remap to the
per-style operator `` mappings:

text

nmap crs <Plug>(abolish-coerce-snake)
nmap crm <Plug>(abolish-coerce-pascal)
nmap crc <Plug>(abolish-coerce-camel)
nmap cru <Plug>(abolish-coerce-upper_snake)
nmap cr- <Plug>(abolish-coerce-kebab)
nmap cr. <Plug>(abolish-coerce-dot)
nmap cr<Space> <Plug>(abolish-coerce-space)
nmap crt <Plug>(abolish-coerce-title)

To bind extra trigger characters, set g:abolish_coercions before enabling
the plugin. Each entry maps a single character to the name of a built-in case
style (case-insensitive: snake, pascal, camel, upper_snake, kebab,
dot, space, title).

text

let g:abolish_coercions = {'q': 'kebab', 'x': 'upper_snake'}

After this, crq recases to kebab-case and crx to UPPER_SNAKE.

anyobject: Useful text objects like functions, arguments, classes, loops, list items, block comments, and more.

Summary:

An extension for IdeaVim plugin that adds useful text objects to improve your productivity on JetBrains IDEs.

Text objects allow a more efficient way of communicating edition or selection actions in the editor. Instead of thinking in terms of characters, words, lines, or paragraphs, use more advance text constructs like quoted text, text between brackets, items in a collection, or programming language constructs like arguments, classes, functions, loops, or comments.

By Ricardo Rodriguez

Setup

Install Vim AnyObject
Add set anyobject to your ~/.ideavimrc file, then run :source ~/.ideavimrc
or restart the IDE.

Instructions

https://plugins.jetbrains.com/plugin/28333-vim-anyobject

argtextobj: Provides a text-object 'a' argument

Original plugin: argtextobj.vim.

Summary:

This plugin provides a text-object 'a' (argument).
You can d(elete), c(hange), v(select)... an argument or inner argument in familiar ways.

That is, such as 'daa'(delete-an-argument) 'cia'(change-inner-argument) 'via'(select-inner-argument).
What this script does is more than just typing

F,dt,

because it recognizes inclusion relationship of parentheses.

Setup:

Add the following command to ~/.ideavimrc: Plug 'vim-scripts/argtextobj.vim'

text

Alternative syntax
`Plugin 'vim-scripts/argtextobj.vim'`

`Plug 'https://github.com/vim-scripts/argtextobj.vim'`

`Plug 'argtextobj.vim'`

`Plug 'https://www.vim.org/scripts/script.php?script_id=2699'`

`set argtextobj`

Instructions

By default, only the arguments inside parenthesis are considered. To extend the functionality
to other types of brackets, set g:argtextobj_pairs variable to a comma-separated
list of colon-separated pairs (same as VIM's matchpairs option), like
let g:argtextobj_pairs="(:),{:},<:>". The order of pairs matters when
handling symbols that can also be operators: func(x << 5, 20) >> 17. To handle
this syntax parenthesis, must come before angle brackets in the list.

https://www.vim.org/scripts/script.php?script_id=2699

CamelCaseMotion: Motions through CamelCase and snake_case words

Original plugin: CamelCaseMotion.

Summary:

Adds w, b, e, ge style motions and iw/ib/ie/ige inner "word" text objects that move
and select by sub-word boundaries — uppercase letters in CamelCase and _/- delimiters in
snake_case/kebab-case — instead of whole words. For example, with the leader as the key,
<leader>w jumps Camel|CaseWord → Camel[C]aseWord, and ci<leader>w changes a single chunk of
an identifier. The motions honour [count], work in normal, visual and operator-pending modes, and
respect the 'iskeyword' option.

Setup:

Add the following command to ~/.ideavimrc: Plug 'bkad/CamelCaseMotion'

text

Alternative syntax
`Plugin 'bkad/CamelCaseMotion'`

`Plug 'https://github.com/bkad/CamelCaseMotion'`

`Plug 'CamelCaseMotion'`

`set CamelCaseMotion`

No mappings are created until you choose a key. The most common setup is to add this to your
~/.ideavimrc (before the Plug/set line):
text
```
let g:camelcasemotion_key = '<leader>'
```
which creates <leader>w, <leader>b, <leader>e, <leader>ge and the inner objects
i<leader>w, i<leader>b, i<leader>e, i<leader>ge.

Instructions

https://github.com/bkad/CamelCaseMotion/blob/master/README.markdown

With g:camelcasemotion_key set to <leader> (the default leader is \):

Mapping	Description
`<leader>w`	Move forward to the next start of a sub-word
`<leader>b`	Move backward to the previous start of a sub-word
`<leader>e`	Move forward to the next end of a sub-word
`<leader>ge`	Move backward to the previous end of a sub-word
`i<leader>w`	Inner sub-word (e.g. `ci<leader>w`, `vi<leader>w`)
`i<leader>b`	Inner sub-word, extends backward with a count
`i<leader>e`	Inner sub-word, excludes a trailing delimiter
`i<leader>ge`	Inner sub-word, backward to the previous word end

Instead of (or in addition to) g:camelcasemotion_key, you can map the motion `` targets
directly, for example to replace the built-in w/b/e:

text

map <silent> w <Plug>CamelCaseMotion_w
map <silent> b <Plug>CamelCaseMotion_b
map <silent> e <Plug>CamelCaseMotion_e
map <silent> ge <Plug>CamelCaseMotion_ge

classtextobj: Provides a text object for class definitions

Summary:

Adds the ac text object that selects "a class definition" — the entire class declaration and body. Works in any language whose PSI tree provides a class element (Java, Kotlin, Python, JavaScript/TypeScript, Go, Dart, PHP, Ruby, Rust).

Setup:

Add the following command to ~/.ideavimrc: set classtextobj

Instructions

Mapping	Description
`ac`	A class definition (e.g. `vac`, `dac`, `cac`, `yac`)

When classes are nested, the innermost enclosing class is selected.

commentary: Adds mapping for quickly commenting stuff out

By Daniel Leong
Original plugin: commentary.vim.

Summary:

Comment stuff out.
Use gcc to comment out a line (takes a count), gc to comment out the target of a motion
(for example, gcap to comment out a paragraph), gc in visual mode to comment out the selection,
and gc in operator pending mode to target a comment.
You can also use it as a command, either with a range like :7,17Commentary,
or as part of a :global invocation like with :g/TODO/Commentary.
That's it.

Setup:

Add the following command to ~/.ideavimrc: Plug 'tpope/vim-commentary'

text

Alternative syntax
`Plugin 'tpope/vim-commentary'`

`Plug 'https://github.com/tpope/vim-commentary'`

`Plug 'vim-commentary'`

`Plug 'tcomment_vim'`

`set commentary`

Instructions

https://github.com/tpope/vim-commentary/blob/master/doc/commentary.txt

dial: Advanced text increment and decrement functionality.

Summary:

IdeaVim extension with advanced text increment and decrement functionality. It enhances the standard increment/decrement functionality found in Vim editors by adding support for complex text patterns beyond simple numbers.

Cycle through related values from various text elements, including numbers, dates, boolean values, operators, and programming language-specific keywords.

By Ricardo Rodriguez

Setup

Install Vim Dial
Add set dial to your ~/.ideavimrc file, then run :source ~/.ideavimrc
or restart the IDE.

Instructions

https://plugins.jetbrains.com/plugin/28237-vim-dial

easymotion: Simplifies some motions

Original plugin: vim-easymotion.

Summary:

EasyMotion provides a much simpler way to use some motions in vim.
It takes the <number> out of <number>w or <number>f{char} by highlighting all possible choices
and allowing you to press one key to jump directly to the target.

Setup:

Install IdeaVim-EasyMotion
and AceJump plugins.

Add the following command to ~/.ideavimrc: Plug 'easymotion/vim-easymotion'

text

Alternative syntax
`Plugin 'easymotion/vim-easymotion'`

`Plug 'https://github.com/easymotion/vim-easymotion'`

`Plug 'vim-easymotion'`

`set easymotion`

Instructions

All commands with the mappings are supported. See the full list of supported commands.

exchange: Easy text exchange operator

By fan-tom
Original plugin: vim-exchange.

Summary:

Easy text exchange operator for Vim.

Setup:

Add the following command to ~/.ideavimrc: Plug 'tommcdo/vim-exchange'

text

Alternative syntax
`Plugin 'tommcdo/vim-exchange'`

`Plug 'https://github.com/tommcdo/vim-exchange'`

`Plug 'vim-exchange'`

`set exchange`

Instructions

https://github.com/tommcdo/vim-exchange/blob/master/doc/exchange.txt

functextobj: Provides text objects for method/function definitions

Inspired by vim-textobj-function.

Summary:

Adds text objects for selecting methods/functions. Three variants distinguish what is included: the signature and body, the same with JavaDoc and annotations, or just the inner body content. Works in any language whose PSI tree provides a function/method element (Java, Kotlin, Python, JavaScript/TypeScript, Go, Dart, PHP, Ruby, Rust).

Setup:

Add the following command to ~/.ideavimrc: set functextobj

text

Alternative syntax
`Plug 'kana/vim-textobj-function'`

`Plug 'vim-textobj-function'`

Instructions

Mapping	Description
`am`	A method definition (signature + body, excluding JavaDoc and annotations)
`aM`	A Method definition (same as `am`, but including JavaDoc and annotations)
`im`	Inner method definition (only the contents between the body braces)

Use with operators (d, c, y) or in visual mode — e.g. dam, cim, vaM. When methods are nested, the innermost enclosing method is selected.

FunctionTextObj: Adds text objects for manipulating functions/methods

By Julien Phalip

Summary:

An extension for IdeaVim that adds text objects for manipulating functions/methods in your code.
Similar to how iw operates on words or i" operates on quoted strings,
this plugin provides if and af to operate on functions

Setup

Add set functiontextobj to your ~/.ideavimrc file, then run :source ~/.ideavimrc
or restart the IDE.

Instructions

https://plugins.jetbrains.com/plugin/25897-vim-functiontextobj

highlightedyank: Highlights the yanked region

By KostkaBrukowa
Original plugin: vim-highlightedyank.

Summary:

Make the yanked region apparent!

Setup:

Add the following command to ~/.ideavimrc: Plug 'machakann/vim-highlightedyank'

text

Alternative syntax
`Plugin 'machakann/vim-highlightedyank'`

`Plug 'https://github.com/machakann/vim-highlightedyank'`

`Plug 'vim-highlightedyank'`

`set highlightedyank`

Instructions

If you want to optimize highlight duration, assign a time in milliseconds:
let g:highlightedyank_highlight_duration = "1000"
A negative number makes the highlight persistent.

If you want to change background color of highlight you can provide the rgba of the color you want e.g.
let g:highlightedyank_highlight_color = "rgba(160, 160, 160, 155)"

If you want to change text color of highlight you can provide the rgba of the color you want e.g.
let g:highlightedyank_highlight_foreground_color = "rgba(0, 0, 0, 255)"

https://github.com/machakann/vim-highlightedyank/blob/master/doc/highlightedyank.txt

indent-object: Adds text objects for manipulating sentences/paragraphs/etc...

By Shrikant Sharat Kandula
Original plugin: vim-indent-object.

Summary:

Vim text objects provide a convenient way to select and operate on various types of objects.
These objects include regions surrounded by various types of brackets and various parts of language
(ie sentences, paragraphs, etc).

Setup:

Add the following command to ~/.ideavimrc: Plug 'michaeljsmith/vim-indent-object'

text

Alternative syntax
`Plugin 'michaeljsmith/vim-indent-object'`

`Plug 'https://github.com/michaeljsmith/vim-indent-object'`

`Plug 'vim-indent-object'`

`set textobj-indent`

Instructions

https://github.com/michaeljsmith/vim-indent-object/blob/master/doc/indent-object.txt

indentwise: Motions based on indentation depth and indent blocks

Original plugin: vim-indentwise.

Summary:

Adds motions that navigate by the indentation level of lines rather than by their content. You can
jump to the previous/next line of lesser, greater or equal indentation relative to the current line,
and jump to the beginning/end of the current indentation block. Blank and whitespace-only lines are
skipped, so the motions follow the visible structure of the code. The motions take a [count], and
work in normal, visual and operator-pending modes (e.g. d]-, v[%). Operator-pending and visual
moves are line-wise.

Setup:

Add the following command to ~/.ideavimrc: Plug 'jeetsukumaran/vim-indentwise'

text

Alternative syntax
`Plugin 'jeetsukumaran/vim-indentwise'`

`Plug 'https://github.com/jeetsukumaran/vim-indentwise'`

`Plug 'vim-indentwise'`

`set indentwise`

Instructions

https://github.com/jeetsukumaran/vim-indentwise/blob/master/doc/indentwise.txt

Mapping	Description
`[-`	Move to the previous line of lesser indent
`]-`	Move to the next line of lesser indent
`[+`	Move to the previous line of greater indent
`]+`	Move to the next line of greater indent
`[=`	Move to the previous line of equal indent
`]=`	Move to the next line of equal indent
`[%`	Move to the beginning of the current indent block
`]%`	Move to the end of the current indent block

For the block-scope motions, a [count] repeats outward through enclosing blocks (e.g. 2[%). The
absolute-indent motions ([_, ]_) from the original plugin are not currently supported.

matchit.vim: Extends the % key functionality

By Martin Yzeiri
Original plugin: matchit.vim.

Summary:

In Vim, as in plain vi, the percent key, |%|, jumps the cursor from a brace, bracket, or paren to its match.
This can be configured with the 'matchpairs' option.
The matchit plugin extends this in several ways...

Setup:

Add the following command to ~/.ideavimrc: packadd matchit

text

Alternative syntax
`Plug 'vim-matchit'`

`Plug 'chrisbra/matchit'`

`set matchit`

Instructions

https://github.com/adelarsq/vim-matchit/blob/master/doc/matchit.txt

Mini.ai: Extend and create a/i textobjects (IMPORTANT: The plugin is not related with artificial intelligence)

Summary:

Extend and create a/i textobjects

Features:

Provides additional text object motions for handling quotes and brackets. The following motions are included:

aq: Around any quotes.
iq: Inside any quotes.
ab: Around any parentheses, curly braces, and square brackets.
ib: Inside any parentheses, curly braces, and square brackets.

Original plugin: mini.ai.

Setup:

Add the following command to ~/.ideavimrc: set mini-ai

multiple-cursors: Extends multicursor support

Original plugin: vim-multiple-cursors.

Setup:

Add the following command to ~/.ideavimrc: Plug 'terryma/vim-multiple-cursors'

text

Alternative syntax
`Plugin 'terryma/vim-multiple-cursors'`

`Plug 'https://github.com/terryma/vim-multiple-cursors'`

`Plug 'vim-multiple-cursors'`

`set multiple-cursors`

Instructions

The default key bindings match the original terryma/vim-multiple-cursors plugin:

Action	Shortcut
Start / add next occurrence (whole word)	`<C-n>`
Start / add next occurrence (not whole word)	`g<C-n>`
Select all occurrences in file (whole word)	`<A-n>`
Select all occurrences in file (not whole word)	`g<A-n>`
Skip current and select next (during selection)	`<C-x>`
Remove current selection (during selection)	`<C-p>`

These map to the following `` mappings:

text

nmap <C-n> <Plug>NextWholeOccurrence
xmap <C-n> <Plug>NextWholeOccurrence
nmap g<C-n> <Plug>NextOccurrence
xmap g<C-n> <Plug>NextOccurrence
nmap <A-n> <Plug>AllWholeOccurrences
xmap <A-n> <Plug>AllWholeOccurrences
nmap g<A-n> <Plug>AllOccurrences
xmap g<A-n> <Plug>AllOccurrences
xmap <C-x> <Plug>SkipOccurrence
xmap <C-p> <Plug>RemoveOccurrence

Custom mappings

To use your own mappings instead of the defaults, set g:multi_cursor_use_default_mapping to 0 and bind the
`` mappings yourself. This is also how you restore the old IdeaVim <A-n> based mappings:

text

let g:multi_cursor_use_default_mapping = 0

" Note that the <A-n> and g<A-n> shortcuts don't work on Mac due to dead keys.
" <A-n> is used to enter accented text e.g. ñ
nmap <A-n> <Plug>NextWholeOccurrence
xmap <A-n> <Plug>NextWholeOccurrence
nmap g<A-n> <Plug>NextOccurrence
xmap g<A-n> <Plug>NextOccurrence
xmap <A-x> <Plug>SkipOccurrence
xmap <A-p> <Plug>RemoveOccurrence

NERDTree: Adds NERDTree navigation to the project panel

Original plugin: NERDTree.

Summary:

Adds NERDTree navigation to the project panel.

Setup:

Add the following command to ~/.ideavimrc: Plug 'preservim/nerdtree'

text

Alternative syntax
`Plugin 'preservim/nerdtree'`

`Plug 'https://github.com/preservim/nerdtree'`

`Plug 'nerdtree'`

`set NERDTree`

Instructions

See here.

paragraph-motion: Extends the { and } motions to ignore whitespace on otherwise empty lines

Original plugin: vim-paragraph-motion.

Summary:

Normally the { and } motions only match completely empty lines.
With this plugin lines that only contain whitespace are also matched.

Setup:

Add the following command to ~/.ideavimrc: Plug 'dbakker/vim-paragraph-motion'

text

Alternative syntax
`Plugin 'dbakker/vim-paragraph-motion'`

`Plug 'https://github.com/dbakker/vim-paragraph-motion'`

`Plug 'vim-paragraph-motion'`

`Plug 'https://github.com/vim-scripts/Improved-paragraph-motion'`

`Plug 'vim-scripts/Improved-paragraph-motion'`

`Plug 'Improved-paragraph-motion'`

`set vim-paragraph-motion`

Instructions

https://github.com/dbakker/vim-paragraph-motion#vim-paragraph-motion

Peekaboo: Extends " @ CTRL-r to show a popup of the register contents

By Julien Phalip
Original plugin: vim-peekaboo.

Summary:

Peekaboo extends " and @ in normal mode and in insert mode so you can see the contents of the registers.

Setup

Add set peekaboo to your ~/.ideavimrc file, then run :source ~/.ideavimrc
or restart the IDE.

Instructions

https://plugins.jetbrains.com/plugin/25776-vim-peekaboo

quick-scope: Always-on highlight for a unique character in every word on a line to help use f, F, etc.

Original plugin: quick-scope.

Summary:

An always-on highlight for a unique character in every word on a line to help you use f, F, and family.

This plugin should help you get to any word on a line in two or three keystrokes with Vim's built-in f
(which moves your cursor to ).

Setup:

Install IdeaVim-Quickscope plugin.
Add the following command to ~/.ideavimrc: set quickscope

Instructions

https://plugins.jetbrains.com/plugin/19417-ideavim-quickscope

ReplaceWithRegister: Adds two-in-one command that replaces text with the contents of a register.

By igrekster
Original plugin: ReplaceWithRegister.

Summary:

This plugin offers a two-in-one command that replaces text covered by a
{motion}, entire line(s) or the current selection with the contents of a
register; the old text is deleted into the black-hole register, i.e. it's
gone. (But of course, the command can be easily undone.)

Setup:

Add the following command to ~/.ideavimrc: Plug 'vim-scripts/ReplaceWithRegister'

text

Alternative syntax
`Plugin 'vim-scripts/ReplaceWithRegister'`

`Plug 'ReplaceWithRegister'`

`Plug 'https://github.com/inkarkat/vim-ReplaceWithRegister'`

`Plug 'inkarkat/vim-ReplaceWithRegister'`

`Plug 'vim-ReplaceWithRegister'`

`Plug 'https://www.vim.org/scripts/script.php?script_id=2703'`

`set ReplaceWithRegister`

Instructions

https://github.com/vim-scripts/ReplaceWithRegister/blob/master/doc/ReplaceWithRegister.txt

sneak: Jump to any location specified by two characters

By Mikhail Levchenko
Original repository with the plugin: https://github.com/Mishkun/ideavim-sneak
Original plugin: vim-sneak.

Summary:

Jump to any location specified by two characters.

Setup:

Add the following command to ~/.ideavimrc: Plug 'justinmk/vim-sneak'

Instructions

Type s and two chars to start sneaking in forward direction
Type S and two chars to start sneaking in backward direction
Type ; or , to proceed with sneaking just as if you were using f or t commands

surround: Adds provides mappings to easily delete, change, and add surroundings in pairs

Original plugin: vim-surround.

Summary:

Surround.vim is all about "surroundings": parentheses, brackets, quotes, XML tags, and more.
The plugin provides mappings to easily delete, change, and add such surroundings in pairs.

Setup:

Add the following command to ~/.ideavimrc: Plug 'tpope/vim-surround'

text

Alternative syntax
`Plugin 'tpope/vim-surround'`

`Plug 'https://www.vim.org/scripts/script.php?script_id=1697'`

`Plug 'vim-surround'`

`set surround`

Instructions

https://github.com/tpope/vim-surround/blob/master/doc/surround.txt

Switch: Switch some text under the cursor based on regex patterns

By Julien Phalip
Original plugin: switch.vim.

Summary:

The purpose of the plugin is to switch some text under the cursor based on regex patterns.
The main entry point is a single command, :Switch.
When the command is executed,
the plugin looks for one of a few specific patterns under the cursor and performs a substitution depending on it.

Setup

Add set switch to your ~/.ideavimrc file, then run :source ~/.ideavimrc
or restart the IDE.

Instructions

https://plugins.jetbrains.com/plugin/25899-vim-switch

targets: Adds many seeking text objects for pairs, quotes, separators, arguments and tags

Original plugin: targets.vim.

Summary:

Targets.vim expands on the built-in text objects (di(, ci", …) to give you more targets to
operate on and the ability to reach them without moving the cursor there first. It adds text objects
for pairs (( ) { } [ ] < >, plus b for "any block"), quotes (' " \``, plus q for "any quote"), separators (, . ; : + - = ~ _ * # / | \ & $), arguments (a) and tags (t), each available with four modifiers and the n/l` next/last qualifiers:

i — inside the object (e.g. ci()
a — a whole object, including its delimiters (e.g. da, deletes one list item and a separator)
I — inside, excluding surrounding whitespace
A — around, including adjacent whitespace
in/il (and an, In, Al, …) — operate on the next / last object without moving there, e.g.
cin) changes inside the next parentheses; a [count] skips further (c2in)).

When the cursor is not inside an object, the plain commands seek to the nearest one. Quotes are
paired by counting from the start of the line, so ci" skips the gap between two strings and changes
the real one. Re-issuing a text object in visual mode grows the selection outward (vi(i().

Setup:

Add the following command to ~/.ideavimrc: Plug 'wellle/targets.vim'

text

Alternative syntax
`Plugin 'wellle/targets.vim'`

`Plug 'https://github.com/wellle/targets.vim'`

`Plug 'targets.vim'`

`set targets`

Instructions

https://github.com/wellle/targets.vim/blob/master/README.md
(see also the cheat sheet).

The settings (g:targets_aiAI, g:targets_nl, g:targets_seekRanges, targets#mappings#extend, …)
and forced motions (dVi-, d<C-V>i-) are not currently supported.

textobj-entire: Adds mapping for selecting entire contents of file regardless of cursor position

By Alexandre Grison
Original plugin: vim-textobj-entire.

Summary:

vim-textobj-entire is a Vim plugin to provide text objects
(ae and ie by default) to select the entire content of a buffer.
Though these are trivial operations (e.g. ggVG), text object versions are more handy,
because you do not have to be conscious of the cursor position (e.g. vae).

Setup:

Add the following command to ~/.ideavimrc: Plug 'kana/vim-textobj-entire'

text

Alternative syntax
`Plugin 'kana/vim-textobj-entire'`

`Plug 'vim-textobj-entire'`

`Plug 'https://www.vim.org/scripts/script.php?script_id=2610'`

`set textobj-entire`

Instructions

https://github.com/kana/vim-textobj-entire/blob/master/doc/textobj-entire.txt

textobj-user: Framework for defining your own text objects

Original plugin: vim-textobj-user.

Summary:

A framework that lets you declaratively define your own text objects from your ~/.ideavimrc, without
writing any plugin code. You describe each object with a Vim pattern and the keys that should select
it, and textobj-user creates the mappings for you. For example, define ad/id to select an
ISO date such as 2013-03-16:

text

call textobj#user#plugin('datetime', {
\   'date': {
\     'pattern': '\<\d\d\d\d-\d\d-\d\d\>',
\     'select': ['ad', 'id'],
\   },
\ })

After this, dad deletes the date under (or ahead of) the cursor, vad selects it, and so on.

Setup:

Add the following command to ~/.ideavimrc: Plug 'kana/vim-textobj-user'

text

Alternative syntax
`Plugin 'kana/vim-textobj-user'`

`Plug 'https://github.com/kana/vim-textobj-user'`

`Plug 'vim-textobj-user'`

`set textobj-user`

Instructions

https://github.com/kana/vim-textobj-user/blob/master/doc/textobj-user.txt

Define text objects by calling textobj#user#plugin({name}, {specs}), where {specs} maps an object
name to a dictionary of properties. The following properties are supported:

Property	Description
`pattern`	The Vim regexp for the object. A single string selects the whole match; a `[head, tail]` pair selects the region between the two delimiter patterns.
`select`	Key(s) that select a single-`pattern` object (string or list of strings).
`select-a`	Key(s) that select "a" region of a `[head, tail]` pair — including the delimiters.
`select-i`	Key(s) that select the "inner" region of a `[head, tail]` pair — excluding the delimiters.
`region-type`	Selection type: `'v'` (charwise, the default), `'V'` (linewise) or `"\<C-v>"` (blockwise).
`move-n` / `move-p`	Key(s) that move the cursor to the beginning of the next / previous object.
`move-N` / `move-P`	Key(s) that move the cursor to the end of the next / previous object.

Selecting objects works with operators (d, c, y) and in visual mode; the move-* mappings also
work in normal, visual and operator-pending modes.

A [head, tail] pair example — aA selects <<…>> including the markers, iA only the text between
them:

text

call textobj#user#plugin('braces', {
\   'angle': {
\     'pattern': ['<<', '>>'],
\     'select-a': 'aA',
\     'select-i': 'iA',
\   },
\ })

Each operation also gets a remappable `` interface mapping named
(textobj-{plugin}-{object}-{operation}), where {operation} is the mapping-property suffix
(a, i, n, p, N, P, or omitted for a plain select). For the datetime example above that
is (textobj-datetime-date), so you can choose your own keys:

text

omap gd <Plug>(textobj-datetime-date)
xmap gd <Plug>(textobj-datetime-date)

textobj#user#map({name}, {specs}) binds additional keys to an already-defined plugin's ``
names (reading only the select / select-a / select-i / move-* properties):

text

call textobj#user#map('datetime', {'date': {'select': 'gd'}})

The following features of the original plugin are not currently supported:

select-function, select-a-function, select-i-function and the move-*-function variants
(custom objects computed by a Vim function). This also means [count] support, which the original
plugin only offers through such functions, is unavailable.
The scan property (configurable search direction).
Blockwise region-type ("\<C-v>") only takes effect in visual mode; an operator (e.g. dad)
over a blockwise object acts charwise.

VimEverywhere: Keyboard-driven IDE navigation outside the editor

Summary:

Brings vim-style keyboard navigation to the rest of the IDE. Enabling VimEverywhere turns on three
behaviors:

Hints overlay. Press Ctrl+Shift+\ (Ctrl+Cmd+\ on macOS) to display hint labels over
interactive UI components — buttons, tool window tabs, tree nodes, text fields, scroll panes, and
so on. Type the letters next to a target to focus or click it without touching the mouse.
NERDTree-style mappings everywhere. NERDTree file-opening mappings (o, t, T, s, i,
go, gs, gi) work in any focused tree, not just the Project tool window.
Tool window navigation. Vim-style window-motion keys work inside tool windows, so you can move
between split panes without leaving the keyboard.

Setup:

Install the AceJump plugin.
Add the following command to ~/.ideavimrc: set VimEverywhere

Instructions

Press Ctrl+Shift+\ (Ctrl+Cmd+\ on macOS) to toggle the hints overlay. Type the letters shown
next to a target to activate it, or press Esc to dismiss the overlay without activating anything.
NERDTree-style and window-nav mappings are active automatically whenever the corresponding
component has focus.

Which-Key: Displays available keybindings in popup

Original plugin: vim-which-key.

Summary:

vim-which-key is vim port of emacs-which-key that displays available keybindings in popup.

Setup:

Install Which-Key plugin.
Add the following command to ~/.ideavimrc: set which-key

Instructions

https://github.com/TheBlob42/idea-which-key?tab=readme-ov-file#installation

yankring: Keeps a history of yanks, deletes and changes to paste from

Original plugin: YankRing.vim.

Summary:

Vim keeps a history of deletes in "1-"9, but a yank always overwrites the last one. The yank ring
adds the missing history - the Emacs kill ring - over yanks, deletes and changes alike. Paste with
p, then press <C-P> to swap what you just pasted for the entry before it, and keep pressing to
walk further back. <C-N> walks forward again, and a count like 2<C-P> skips.

Setup:

Add the following command to ~/.ideavimrc: Plug 'vim-scripts/YankRing.vim'

text

Alternative syntax
`Plugin 'vim-scripts/YankRing.vim'`

`Plug 'https://github.com/vim-scripts/YankRing.vim'`

`Plug 'YankRing'`

`set yankring`

Instructions

Cycling replaces the text of the last paste, so it works while the caret is still on the line you
pasted onto and you have not edited the buffer since; otherwise it tells you to paste first. p,
P, gp, gP, ]p, [p, ]P and [P are all tracked, in normal and visual mode, counts
included. One u undoes the paste and the cycling together.

:YRShow lists the ring newest first, :YRClear empties it, and :YRReplace {offset} {p|P} is what
the keys call - a negative offset steps to an older entry, a positive one to a newer one.

let g:yankring_max_history = 100 caps how many entries are kept.

Note that <C-P> and <C-N> stop being k and j in normal mode, as with the original plugin.
Visual, operator-pending, insert and command-line mode are untouched. To keep the keys, map your own
in ~/.ideavimrc, which suppresses the defaults:

text

nmap <A-p> <Plug>YankRingReplacePrevious
nmap <A-n> <Plug>YankRingReplaceNext

Not implemented yet: the ring window (:YRShow prints the listing instead), the other :YR*
commands, every g:yankring_* option but the one above, persistence across restarts, and clipboard
monitoring. Behaviour with multiple carets is undefined.

https://github.com/vim-scripts/YankRing.vim/blob/master/doc/yankring.txt

youcompleteme: Cycle through code completion with Tab

Inspired by YouCompleteMe / SuperTab.

Summary:

Makes <Tab> cycle through the IDE's code completion popup, SuperTab style. While the completion
popup (lookup) is open, <Tab> selects the next item and <S-Tab> the previous one — the same as
the native <C-N>/<C-P> insert-mode completion keys. When no popup is open, <Tab> falls back to
its normal behaviour (indentation), so ordinary tabbing is unaffected.

Setup:

Add the following command to ~/.ideavimrc: set youcompleteme

Instructions

Enabling the plugin removes <Tab> and <S-Tab> from the lookupkeys
option so that IdeaVim — rather than the IDE — handles them while the completion popup is open. If
you want to keep Vim's default insert-mode completion keys as well, they continue to work alongside
Tab:

Mapping	Description
`<Tab>`	Select the next item in the completion popup (or insert a tab when none is open)
`<S-Tab>`	Select the previous item in the completion popup

Doc/NERDTree Support

NERDTree

IdeaVim supports the NERDTree plugin. Update your ~/.ideavimrc to turn it on:

vim

Plug 'preservim/nerdtree'

vim

set NERDTree

Use set noNERDTree to disable this extension.

Full list of aliases

vim

set NERDTree
Plug 'preservim/nerdtree'
Plug 'https://github.com/preservim/nerdtree'
Plug 'https://github.com/scrooloose/nerdtree'
Plug 'scrooloose/nerdtree'
Plug 'nerdtree'

Preview

Click for the preview

Supported commands

:NERDTree
:NERDTreeFocus
:NERDTreeToggle
:NERDTreeClose
:NERDTreeFind
:NERDTreeRefreshRoot

Key	Description	Map Setting
`o`	Open files, directories and bookmarks	`g:NERDTreeMapActivateNode`
`go`	Open selected file, but leave cursor in the NERDTree	`g:NERDTreeMapPreview`
`t`	Open selected node/bookmark in a new tab	`g:NERDTreeMapOpenInTab`
`T`	Same as 't' but keep the focus on the current tab	`g:NERDTreeMapOpenInTabSilent`
`i`	Open selected file in a split window	`g:NERDTreeMapOpenSplit`
`gi`	Same as i, but leave the cursor on the NERDTree	`g:NERDTreeMapPreviewSplit`
`s`	Open selected file in a new vsplit	`g:NERDTreeMapOpenVSplit`
`gs`	Same as s, but leave the cursor on the NERDTree	`g:NERDTreeMapPreviewVSplit`
`O`	Recursively open the selected directory	`g:NERDTreeMapOpenRecursively`
`x`	Close the current nodes parent	`g:NERDTreeMapCloseDir`
`X`	Recursively close all children of the current node	`g:NERDTreeMapCloseChildren`
`P`	Jump to the root node	`g:NERDTreeMapJumpRoot`
`p`	Jump to current nodes parent	`g:NERDTreeMapJumpParent`
`K`	Jump up inside directories at the current tree depth	`g:NERDTreeMapJumpFirstChild`
`J`	Jump down inside directories at the current tree depth	`g:NERDTreeMapJumpLastChild`
`<C-J>`	Jump down to next sibling of the current directory	`g:NERDTreeMapJumpNextSibling`
`<C-K>`	Jump up to previous sibling of the current directory	`g:NERDTreeMapJumpPrevSibling`
`r`	Recursively refresh the current directory	`g:NERDTreeMapRefresh`
`R`	Recursively refresh the current root	`g:NERDTreeMapRefreshRoot`
`m`	Display the NERDTree menu	`g:NERDTreeMapMenu`
`q`	Close the NERDTree window	`g:NERDTreeMapQuit`
`A`	Zoom (maximize/minimize) the NERDTree window	`g:NERDTreeMapToggleZoom`
`d`	Delete file or directory	`g:NERDTreeMapDelete`
`n`	Create File	`g:NERDTreeMapNewFile`
`N`	Create Directory	`g:NERDTreeMapNewDir`

Troubleshooting

If you see the the file is opened automatically on every movement in the Project View (j, k, etc.)
please make sure that you have "Open Files with Single click" disabled.

Doc/Select Mode

FAQ

What is select mode?

This mode is where the selection works the same as system selection. When you start typing, the text in the selected area is removed and replaced by the new characters that are being typed in.

Why is select mode enabled during refactoring?

With the help of the select mode, you can immediately enter the variable name during refactoring. You can go to the beginning or the end of a variable using the arrow keys. If you need to make more complex changes, you can always go back to normal mode with <ESC>.

What if I want to use visual mode during refactoring?

Select mode is controlled by the keymodel, selectmode and idearefactormode options. Set idearefactormode to visual to adjust this behavior.
set idearefactormode=visual

What if I don't want to change the mode during refactoring?

set idearefactormode=keep

Autocommands

IdeaVim supports Vim's :autocmd for running commands on editor events.
Handlers are registered from ~/.ideavimrc or interactively in Command-line mode.
Every effort is made to match Vim's behaviour, but some differences are inevitable
because the IDE's event model doesn't map 1:1 onto Vim's.

Syntax

text

autocmd [group] {event}[,{event}...] {pattern} {command}
autocmd!
autocmd! {group}

{event} — one or more comma-separated event names (see below).
{pattern} — file pattern (see "Patterns" below). For FileType, the pattern matches the filetype name, not the file
path.
{command} — any Ex command or Vimscript expression.
autocmd! — clears all registered handlers, or all handlers in the given augroup.

vim

augroup my_group
  autocmd!
  autocmd BufWritePre *.py echo "saving python"
augroup END

Patterns

Autocmd file patterns support the following glob syntax:

Pattern	Matches
`*`	Any characters except path separators
`**`	Any characters including path separators
`?`	Any single non-separator character
`[abc]`	Any character in the set
`{foo,bar}`	Either `foo` or `bar`

If the pattern contains / or \, it matches against the full path;
otherwise it matches against the filename only.

FileType is special: its pattern matches against the filetype name
(e.g. python, java) rather than the file path.

Supported events

Insert mode

Event	Fires when
`InsertEnter`	Entering Insert mode
`InsertLeave`	Leaving Insert mode

Buffers

Event	Fires when
`BufEnter`	A buffer becomes active (every switch)
`BufLeave`	A buffer stops being active
`BufRead`	A file is loaded into a buffer for the first time
`BufReadPost`	Alias of `BufRead` (same event, two names)
`BufNewFile`	Editing a file that was just created (fires instead of `BufRead`)
`BufWrite`	Alias of `BufWritePre`
`BufWritePre`	Before the buffer is written to disk
`BufWritePost`	After the buffer has been written to disk

Windows

Event	Fires when
`WinEnter`	A window becomes active (every switch)
`WinLeave`	A window stops being active

Files

Event	Fires when
`FileType`	A buffer's filetype is determined (typically once per file load). Pattern matches filetype name.

Focus

Event	Fires when
`FocusGained`	The IDE window gains focus
`FocusLost`	The IDE window loses focus

Event order

When opening a file for the first time:

text

BufRead/BufReadPost → FileType → BufEnter

When opening a just-created file:

text

BufNewFile → FileType → BufEnter

When switching buffers:

text

BufLeave → WinLeave → WinEnter → BufEnter

When saving:

text

BufWrite/BufWritePre → (write) → BufWritePost

Differences from Vim

FileType names. IdeaVim maps IntelliJ's file type name to a Vim-style
filetype. For most languages the lowercased IJ name matches Vim's filetype
(Python→python, JAVA→java). A small override table handles cases where
Vim's convention differs: PLAIN_TEXT→text, C++→cpp, C#→cs,
Shell Script→sh, ObjectiveC→objc, JavaScript→javascript,
TypeScript→typescript, Vue.js→vue, CMakeLists.txt→cmake,
Handlebars/Mustache→handlebars.

BufNewFile detection. IdeaVim tracks files created during the session
via the VFS. When such a file is opened in an editor, BufNewFile fires
instead of BufRead. Files created by VCS pulls, build tools, or external
processes that you later open in an editor will also be treated as new files.

BufWritePre / BufWritePost frequency. IntelliJ auto-saves on focus
loss, tab switch, build, and other events. These autocmds fire more often
than Vim's :w, so handlers should be idempotent.

Doc/Ideajoin Examples

Some examples of join command with ideajoin option enabled.
Put set ideajoin to your ~/.ideavimrc to enable this functionality.

Now, you can press J (shift+j) on a line or a selected block of text to join the lines together.

:warning: This feature is language-specific. This means that the IDE should implement this feature for a particular
language in order for the IDE to work as described below. If any of the examples provided below don't match your case,
please file an issue in the project related to your IDE: https://youtrack.jetbrains.com/.
Here is a list of known requests: https://youtrack.jetbrains.com/issues?q=links:VIM-3214.

Automatic join concatenated lines:

text

"Hello" +                 ->       "Hello world"
" world!"

Nested if's:

text

if (a) {                  ->       if (a && b) {
  if (b) {                             ...
     ...                           }
  }
}

Comments:

text

// Hello                  ->       // Hello world
// world

Remove braces from one line for / if / while:

text

if (fail) {               ->       if (fail) return;
     return;
}

Kotlin one line method:

text

fun myNumber(): Int {     ->       fun myNumber(): Int = 42
    return 42
}

Join declaration and initialization:

text

int a;                    ->       int a = 5;
a = 5;

Chain call:

text

sb.append("a");           ->       sb.append("a").append("b");
sb.append("b");

And other features provided by the plugins.

Doc/Marketplace Plugin Example

Using actions from external plugins is the same, as tracking and reusing any IDE action. As an example, let's create a mapping that will toggle case of the word under caret using the CamelCase plugin when you press <leader>t.

Steps to make this mapping

Install the plugin via Marketplace
Enable action tracking. You can enable it by one of the following ways:
- Execute :set trackactionids ex command or just :set tai
- Open the "Find actions" window by pressing Ctrl-Shift-A and search for "Track Action IDs" to find the toggle that enables and disables action tracking
Execute the plugin action the way intended by plugin author "See Edit menu or use ⇧ + ⌥ + U / Shift + Alt + U" or just find the Toggle Camel Case action in the "Find actions" window (Ctrl-Shift-A). If you action tracking is on, you will see this notification in your right bottom corner:
Copy the action id from the notification to create the following mapping in your .ideavimrc

map <leader>t <Action>(de.netnexus.CamelCasePlugin.ToggleCamelCase)

Doc/Set Commands

List of Supported Options

The following options can be set with the :set, :setglobal and :setlocal commands.
They can be added to the ~/.ideavimrc file, or set manually in Command-line mode.
For more details of each option, please see the Vim documentation.
Every effort is made to make these options compatible with Vim behaviour.
However, some differences are inevitable.

text

/* Detailed source-code truncated for AI context efficiency. */

IdeaVim options mapped to IntelliJ-based IDE settings

IdeaVim provides its own implementation for handling scroll jump and offset, even though IntelliJ-based IDEs have similar functionality (there are differences in behaviour).
When IdeaVim is hosted in an IntelliJ-based IDE (but not JetBrains Fleet), the following options map to the equivalent IDE settings:

text

'scrolljump'    'sj'    Minimal number of lines to scroll
'scrolloff'     'so'    Minimal number of lines above and below the cursor
'sidescroll'    'ss'    Minimal number of columns to scroll horizontally
'sidescrolloff' 'siso'  Minimal number of columns to left and right of cursor

IdeaVim options for IntelliJ-based IDE features

Some Vim features cannot be implemented by IdeaVim, and must be implemented by the host IDE, such as showing whitespace and line numbers, and enabling soft-wrap.
The following options modify equivalent settings and features implemented by IntelliJ-based IDEs.

There is some mismatch when trying to map Vim options, most of which are local options, to IDE settings, which are mostly global-local.
The Vim option will always reflect the effective value of the IDE setting for the current editor, and modifying the Vim option will update the local value of the IDE setting.
The default value of the Vim option set during startup is not passed to the IDE setting.

If the IDE setting has a way to modify the local value, such as entries in the View | Active Editor menu, then changing this will update the current editor and be reflected in the Vim option value.
If the IDE setting can only modify its global setting in the main Settings dialog, this change does not always update the current editor (because the local IDE setting has been modified and takes precedence).

IdeaVim tries to make this work more naturally by updating the editor and local Vim option when a global value changes unless the Vim option has been explicitly set in Command-line mode.

In other words, if the local Vim value is explicitly set for a window or buffer, interactively, then it should not be reset.
If the Vim option was explicitly set in ~/.ideavimrc however, then the value will be reset, because this can be viewed as a "global" value - set once and applied to subsequently opened windows.
(This should not be confused with Vim's concept of global options, which are mainly used to initialise new windows.)

The local Vim option can always be reset to the global IDE setting value by resetting the Vim option to default with the :set {option}& syntax.

text

/* Detailed source-code truncated for AI context efficiency. */

IdeaVim only options

These options are IdeaVim only, and not supported by Vim.
They control integration with the host IDE.
Unless otherwise stated, these options do not have abbreviations.

text

/* Detailed source-code truncated for AI context efficiency. */

Doc/Sethandler

Configuring conflicting keys via .ideavimrc

IdeaVim allows defining handlers for the shortcuts that exist for both IDE and Vim (e.g. <C-C>).

vim

" Use ctrl-c as an ide shortcut in normal and visual modes
sethandler <C-C> n-v:ide i:vim

This option consist of an optional shortcut and a list of space separated list of handlers:
mode-list:handler mode-list:handler ...
The mode-list is a dash separated list of modes that is similar to guicursor notation
and defines the following modes:

n - normal mode
i - insert mode
x - visual mode
s - select mode
v - visual and select modes
c - command-line mode
a - all modes

The handler is an argument that may accept the following values:

ide - use IDE handler
vim - use Vim handler

Examples:

n:ide - use IDE handler in normal mode
i-v:vim - use Vim handler in normal, visual, and select modes
a:ide - use IDE handler in all modes
a:ide c:vim - use IDE handler everywhere except command-line mode

By using sethandler you can define handlers:

For a single shortcut: sethandler <C-A> n:vim i-x:ide - use Vim handler in normal mode and IDE handler in insert and visual modes,
For all shortcuts: sethandler n:vim i:ide - use Vim handlers in normal mode and IDE handlers in insert mode.

Later definitions override earlier ones, so a:ide c:vim first assigns every mode to the IDE
and then hands command-line mode back to Vim. This is useful for keeping a cnoremap working
while the IDE owns the shortcut everywhere else:

vim

" 'Fighting Kirby' regex: capture the current word so it can be used in back references
cnoremap <F2> \(.*\)
sethandler <F2> a:ide c:vim

If the definition of the handler is missing for some mode, it defaults to vim:
sethandler <C-X> i:ide - use IDE handler in insert mode and Vim handler in all other modes.

Doc/Support Guide

Support Guide

This document is created to help our support team.
It's not intended to be read by the users as it brings no value to them.

Support channels

Main, YouTrack: https://youtrack.jetbrains.com/issues/VIM
Chat on gitter
IdeaVim Channel on JetBrains Server
Rare: GitHub discussions - https://github.com/JetBrains/ideavim/discussions

Expectations from the support

Process incoming requests from all the support channels
Request for an additional information
Help users to answer simple cases
Try to reproduce the issue
Try to help user if this is misconfiguration / incorrect usage
Pass actual bugs to the dev team
Update "State" and "Area" fields

YouTrack statuses

IdeaVim has multiple YouTrack statuses, main are:

Submitted: issue is created by user, but not processed by our team. This is the default status for new tickets.
Open: issues is processed by our team, what means that the issues is reproduced and accepted
Waiting For Reply: Waiting for further information from the user. These issues are automatically closed if the
user doesn't reply in 30 days.
Ready To Release: Bug is fixed, but not yet released
Fixed: Bug is fixed
Closed: Issue is closed by some other reason

~.ideavimrc file

~/.ideavimrc is the file that is used for IdeaVim configuration. It may affect behaviour of the program,
so it makes sense to additionally request this file in case the issues can't be reproduced.

Doc/Home Copy Section

Doc/IdeaVim Plugins Copy Section

IdeaVim Plugins Copy Chapter

abolish: Case-aware substitute and coercion mappings between case styles

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

anyobject: Useful text objects like functions, arguments, classes, loops, list items, block comments, and more.

Summary: Copy Section

Setup Copy Section

Instructions Copy Section

argtextobj: Provides a text-object 'a' argument

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

CamelCaseMotion: Motions through CamelCase and snake_case words

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

classtextobj: Provides a text object for class definitions

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

commentary: Adds mapping for quickly commenting stuff out

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

dial: Advanced text increment and decrement functionality.

Summary: Copy Section

Setup Copy Section

Instructions Copy Section

easymotion: Simplifies some motions

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

exchange: Easy text exchange operator

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

functextobj: Provides text objects for method/function definitions

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

FunctionTextObj: Adds text objects for manipulating functions/methods

Summary: Copy Section

Setup Copy Section

Instructions Copy Section

highlightedyank: Highlights the yanked region

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

indent-object: Adds text objects for manipulating sentences/paragraphs/etc...

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

indentwise: Motions based on indentation depth and indent blocks

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

matchit.vim: Extends the % key functionality

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

Mini.ai: Extend and create a/i textobjects (IMPORTANT: The plugin is not related with artificial intelligence)

Summary: Copy Section

Features: Copy Section

Setup: Copy Section

multiple-cursors: Extends multicursor support

Setup: Copy Section

Instructions Copy Section

Custom mappings Copy Section

NERDTree: Adds NERDTree navigation to the project panel

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

paragraph-motion: Extends the { and } motions to ignore whitespace on otherwise empty lines

Summary: Copy Section

Setup: Copy Section

Instructions Copy Section

Peekaboo: Extends " @ CTRL-r to show a popup of the register contents

Doc/Home

Doc/IdeaVim Plugins

IdeaVim Plugins

Summary:

Setup:

Instructions

Summary:

Setup

Instructions

Summary:

Setup:

Instructions

Summary:

Setup:

Instructions

Summary:

Setup:

Instructions

Summary:

Setup:

Instructions

Summary:

Setup

Instructions

Summary:

Setup:

Instructions

Summary:

Setup:

Instructions

Summary:

Setup:

Instructions

Summary:

Setup

Instructions

Summary:

Setup:

Instructions

Summary:

Setup:

Instructions

Summary:

Setup:

Instructions

Summary:

Setup:

Instructions

Summary:

Features:

Setup:

Setup:

Instructions

Custom mappings

Summary:

Setup:

Instructions

Summary:

Setup:

Instructions

Summary:

Setup

Instructions

Summary:

Setup:

Instructions

Summary:

Setup:

Instructions

Summary:

Setup:

Instructions

Summary:

Setup:

Instructions

Summary:

Setup

Instructions

Summary:

Setup: