What is the difference between the remap, noremap, nnoremap and vnoremap mapping commands in Vim?

Question

What is the difference between the remap, noremap, nnoremap and vnoremap mapping commands in Vim?

Joiejoin

Caution, vnoremap and vmap work in Visual AND Select mode. To have a mapping only in Visual mode, use xmap and xnoremap. – Lipography

Answer 1

remap is an option that makes mappings work recursively. By default, it is on and I'd recommend you leave it that way. The rest are mapping commands, described below:

:map and :noremap are recursive and non-recursive versions of the various mapping commands. For example, if we run:

:map j gg           (moves the cursor to the first line)
:map Q j            (moves the cursor to the first line)
:noremap W j        (moves the cursor down one line)

Then:

• j will be mapped to gg.
• Q will also be mapped to gg, because j will be expanded for the recursive mapping.
• W will be mapped to j (and not to gg) because j will not be expanded for the non-recursive mapping.

Now remember that Vim is a modal editor. It has a normal mode, visual mode and other modes.

For each of these sets of mappings, there is a mapping that works in normal, visual, select and operator modes (:map and :noremap), one that works in normal mode (:nmap and :nnoremap), one in visual mode (:xmap and :xnoremap) and so on.

For more guidance on this, see:

:help :map
:help :noremap
:help recursive_mapping
:help :map-modes

Cagle

Thanks for your answer! Also, when is recursive used, and when is non-recursive used? – Joiejoin

@Chetan: It depends what you want to achieve. I tend to use non-recursive more often, but if you've defined a relatively complicated mapping using non-recursive and what another mapping that does everything the first mapping does and more, it can be easier to use a recursive mapping that includes the original one rather than retyping the whole of the non-recursive one again (particularly if you then need to tweak the original one). – Cagle

I had assumes noremap to be some opposite of map. I mean something which removes a mapping. Thanks for the answer. It clarified me – Stocks

does nore stand for [no] [re]map ? – Prenatal

@Prenatal Basically, yeah. It means essentially "Don't use remap even if it is enabled." – Valley

It isn't that important for the majority of use cases, but it should be noted that :map, etc. don't work in all modes, exactly, just all the common ones (specifically, normal mode, visual mode, select mode, and operator-pending mode). If you want a mapping to work in insert, command-line, or lang-arg mode, you need to use :map!, etc. (Source: vimdoc.sourceforge.net/htmldoc/map.html#map-overview) – Valley

@Prenatal noremap = non-recursive mapping – Shadwell

And if I use noremap j gg and then map Q j is pressing Q going to call gg ? I understand the opposite wouldn't. – Vladamir

@AshwinNanjappa absolutely! I find the help inside of Vim so hard to understand most of the time! +cram2208 this is a great question and it's too bad no one has answered you! My guess would be that Q would indeed call gg. I would think that this is only stopping recursing of j to anything beyond gg. But maybe it does affect "inherited(?)" maps? I really don't know and hope someone can shed some light on this; I'm still not even 100% on what the purpose of recursive vs non-recursive maps are! EDIT: it looks like your question was answered in an answer below. Short answer: Q will call gg. – Least

I think I've got it now, you can essentially use recursive and non-recursive to bind and unbind keymaps, I think (it is how you can refer to the normal function of a key). – Least

Great answer! Thank you. After I read this, I dove into the docs and FINALLY found a references to this. If I hadn't known this was "recursive mapping", I never would have found it. :help recursive_mapping – Herrmann

Wouldn't transitive have been more apt than recursive given the examples of how they seem to be used. – Lemal

Answer 2

I think the Vim documentation should've explained the meaning behind the naming of these commands. Just telling you what they do doesn't help you remember the names.

map is the "root" of all recursive mapping commands. The root form applies to "normal", "visual+select", and "operator-pending" modes. (I'm using the term "root" as in linguistics.)

noremap is the "root" of all non-recursive mapping commands. The root form applies to the same modes as map. (Think of the nore prefix to mean "non-recursive".)

(Note that there are also the ! modes like map! that apply to insert & command-line.)

See below for what "recursive" means in this context.

Prepending a mode letter like n modify the modes the mapping works in. It can choose a subset of the list of applicable modes (e.g. only "visual"), or choose other modes that map wouldn't apply to (e.g. "insert").

Use help map-modes will show you a few tables that explain how to control which modes the mapping applies to.

Mode letters:

• n: normal only
• v: visual and select
• o: operator-pending
• x: visual only
• s: select only
• i: insert
• c: command-line
• l: insert, command-line, regexp-search (and others. Collectively called "Lang-Arg" pseudo-mode)

"Recursive" means that the mapping is expanded to a result, then the result is expanded to another result, and so on.

The expansion stops when one of these is true:

1. the result is no longer mapped to anything else.
2. a non-recursive mapping has been applied (i.e. the "noremap" [or one of its ilk] is the final expansion).

At that point, Vim's default "meaning" of the final result is applied/executed.

"Non-recursive" means the mapping is only expanded once, and that result is applied/executed.

Example:

 nmap K H
 nnoremap H G
 nnoremap G gg

The above causes K to expand to H, then H to expand to G and stop. It stops because of the nnoremap, which expands and stops immediately. The meaning of G will be executed (i.e. "jump to last line"). At most one non-recursive mapping will ever be applied in an expansion chain (it would be the last expansion to happen).

The mapping of G to gg only applies if you press G, but not if you press K. This mapping doesn't affect pressing K regardless of whether G was mapped recursively or not, since it's line 2 that causes the expansion of K to stop, so line 3 wouldn't be used.

Irritability

One thing: map only applies to normal, visual, select, and operator-pending modes, not to all modes. – Forever

Answer 3

I will explain mapping commands simply.

First, we have two general mapping commands:

• map - works recursively in normal, visual, select and operator pending modes.
• map! - works recursively in insert and command-line modes.

The non-recursive variations of these commands are:

• noremap - works non-recursively in normal, visual, select and operator pending modes.
• noremap! - works non-recursively in insert and command-line modes.

You can think of it as no[remap] {lhs} {rhs} which means to map the key sequence {lhs} to {rhs}, but do not re-map any commands in {rhs} to avoid nested and recursive mappings.

Then, we have mode-specific commands:

• nmap - works recursively in normal mode.
• imap - works recursively in insert mode.
• vmap - works recursively in visual and select modes.
• xmap - works recursively in visual mode.
• smap - works recursively in select mode.
• cmap - works recursively in command-line mode.
• omap - works recursively in operator pending mode.

And their non-recursive variations:

• nnoremap - works non-recursively in normal mode.
• inoremap - works non-recursively in insert mode.
• vnoremap - works non-recursively in visual and select modes.
• xnoremap - works non-recursively in visual mode.
• snoremap - works non-recursively in select mode.
• cnoremap - works non-recursively in command-line mode.
• onoremap - works non-recursively in operator pending mode.

Finally, remap is a boolean option that allows for mappings to work recursively. It is worth mentioning that you should always keep this option at the default on.

Sidewinder

This is a great explanation. However, I understand what recursion is, but I don't understand what it means in this context. What does it mean to work non-recursively? – Suchta

You can think of it as no[remap] {lhs} {rhs} which means to map the key sequence {lhs} to {rhs}, but do not re-map any commands in {rhs} to avoid nested and recursive mappings. – Sidewinder

@Sidewinder it would be good if you could add the preceding comment to your answer, perhaps immediately after the part about noremap and noremap!. I was wondering exactly the same thing as Janac Meena. (I think I might have the ability to make the edit, but I don't want to add something new to someone else's answer.) – Romeu

Answer 4

One difference is that:

• :map does nvo == normal + (visual + select) + operator pending
• :map! does ic == insert + command-line mode

as stated on help map-modes tables.

So: map does not map to all modes.

To map to all modes you need both :map and :map!.

Madalynmadam

Careful !! command mode is another historical name for normal mode viz. chapt 5 vimdoc.sourceforge.net/htmldoc/intro.html#vim-modes-intro). The abbreviation 'c' is for 'command-line'. In other words, by default: map! lhs rhs recursively maps lhs to rhs for insert + command-LINE modes. That is unless the remap default option is explicitely disabled with set noremap[!] in ~/.vimrc. In that case mapping would not be recursive (not advisable). – Lollapalooza

This answer lacks context and does not answer the question. It might be better suited as a comment. – Sterne

Answer 5

In Vim, the mapping commands remap, noremap, nnoremap and vnoremap are used to define key mappings that allow you to execute a series of Vim commands by pressing a single key or key combination. Here's a brief overview of the differences between each of these mapping commands:

remap: This command allows you to remap an existing mapping to a new mapping. For example, if you want to remap the "jk" sequence to escape in insert mode, you can use the following command:

:remap jk <Esc>

This will replace the "jk" sequence with the "Esc" key.

noremap: This command creates a non-recursive mapping. This means that any mappings that are defined in the new mapping will not be expanded. For example, if you have the following mappings:

:map a b
:map b c

And you use the following command:

:noremap a b

This will create a non-recursive mapping for "a" that directly maps to "b" without expanding any other mappings.

nnoremap: This command creates a non-recursive mapping for normal mode only. This means that the mapping will only apply in normal mode, and any mappings that are defined in the new mapping will not be expanded. For example, if you have the following mappings:

:map a b
:map b c

And you use the following command:

:nnoremap a b

This will create a non-recursive mapping for "a" that directly maps to "b" without expanding any other mappings, but it will only apply in normal mode.

vnoremap: This command creates a non-recursive mapping for visual mode only. This means that the mapping will only apply in visual mode, and any mappings that are defined in the new mapping will not be expanded. For example, if you have the following mappings:

:map a b
:map b c

And you use the following command:

:vnoremap a b

This will create a non-recursive mapping for "a" that directly maps to "b" without expanding any other mappings, but it will only apply in visual mode.

It's important to note that when creating mappings, especially recursive mappings, it's possible to create unintended consequences or "mapping conflicts" that can cause issues when trying to use Vim. Careful attention to the mappings being created, especially when modifying the behavior of commonly used keys, is recommended to avoid unwanted side effects.

In general, noremap, nnoremap, and vnoremap are considered safer to use than remap, as they don't create recursive mappings and thus are less likely to cause unintended side effects. However, there may be situations where a recursive mapping is necessary, in which case remap can be used to overwrite an existing mapping with a new one.

It's also worth noting that there are other mapping commands in Vim, such as imap for insert mode mappings and map! for command-line mappings. Each of these commands behaves similarly to the mapping commands described above, but applies to a specific mode in Vim.

Deed

Was this generated using ChatGPT (or similar)? There is a marked difference in writing style before and after December 2022. – Cry

@PeterMortensen it is possible I used one of those tools to help cleanup my writing, I am not the best writer and have been experimenting with using these tools to improve the quality and readability of my long form writing, if that goes against the policies of SO I can delete this answer or try to rewrite it in my inferior writing style – Deed