GNU bug report logs - #77438
[FEATURE REQUEST] Freely positioning the cursor anywhere in the buffer (Vim’s virtualedit=all Equivalent in Emacs)

Previous Next

To reply to this bug, email your comments to 77438 AT debbugs.gnu.org.

Toggle the display of automated, internal messages from the tracker.

Message #5 received at submit <at> debbugs.gnu.org (full text, mbox):

From: James Cherti <contact <at> jamescherti.com>
To: bug-gnu-emacs <at> gnu.org
Subject: [FEATURE REQUEST] Freely positioning the cursor anywhere in the buffer (Vim’s virtualedit=all Equivalent in Emacs)
Date: Tue, 1 Apr 2025 16:02:39 -0400

Hello,

Implementing an Emacs equivalent of Vim's `set virtualedit=all`
feature would be interesting, especially for editing
indentation-sensitive file types like YAML or Python.

In Vim, the `set virtualedit=all` setting allows the cursor to move
freely to any position in the text, even beyond the end of lines and
after the last line of the file. This differs from the default
behavior, where the cursor is constrained to valid text positions.

Unlike Vim's `virtualedit=all` mode, Emacs' quarter-plane,
picture-mode, and artist-mode packages insert actual spaces into the
buffer. In contrast, Vim’s `set virtualedit=all` allows the cursor to
be placed in positions where no text exists, but real spaces are not
added until a character is typed.

This distinction is important because, in `virtualedit=all`, the
absence of real spaces ensures that the undo/redo history remains
unaffected by cursor movements alone.

--
James Cherti
GitHub: https://github.com/jamescherti
Website: https://www.jamescherti.com/

Message #8 received at 77438 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: James Cherti <contact <at> jamescherti.com>
Cc: 77438 <at> debbugs.gnu.org
Subject: Re: bug#77438: [FEATURE REQUEST] Freely positioning the cursor
 anywhere
 in the buffer (Vim’s virtualedit=all Equivalent in
 Emacs)
Date: Wed, 02 Apr 2025 14:39:50 +0300

> Date: Tue, 1 Apr 2025 16:02:39 -0400
> From: James Cherti <contact <at> jamescherti.com>
> 
> Implementing an Emacs equivalent of Vim's `set virtualedit=all`
> feature would be interesting, especially for editing
> indentation-sensitive file types like YAML or Python.
> 
> In Vim, the `set virtualedit=all` setting allows the cursor to move
> freely to any position in the text, even beyond the end of lines and
> after the last line of the file. This differs from the default
> behavior, where the cursor is constrained to valid text positions.
> 
> Unlike Vim's `virtualedit=all` mode, Emacs' quarter-plane,
> picture-mode, and artist-mode packages insert actual spaces into the
> buffer. In contrast, Vim’s `set virtualedit=all` allows the cursor to
> be placed in positions where no text exists, but real spaces are not
> added until a character is typed.
> 
> This distinction is important because, in `virtualedit=all`, the
> absence of real spaces ensures that the undo/redo history remains
> unaffected by cursor movements alone.

Can't one do this using overlays instead of inserting spaces?

But eventually, you'd need to insert spaces, if you actually type
something wherever you move cursor.  So maybe an easier way is to use
picture-mode after forcing undo to not record some commands for a
period.  (Not that I understand why not touching the undo history is
such a big deal.)

Message #11 received at submit <at> debbugs.gnu.org (full text, mbox):

From: James Cherti <contact <at> jamescherti.com>
To: bug-gnu-emacs <at> gnu.org, Eli Zaretskii <eliz <at> gnu.org>
Subject: Re: bug#77438: [FEATURE REQUEST] Freely positioning the cursor anywhere in the buffer (Vim’s virtualedit=all Equivalent in Emacs)
Date: Wed, 2 Apr 2025 09:02:04 -0400

Hello Eli,

On 2025-04-02 07:39, Eli Zaretskii wrote:
>> Date: Tue, 1 Apr 2025 16:02:39 -0400
>> From: James Cherti <contact <at> jamescherti.com>
>>
>> Implementing an Emacs equivalent of Vim's `set virtualedit=all`
>> feature would be interesting, especially for editing
>> indentation-sensitive file types like YAML or Python.
>>
>> In Vim, the `set virtualedit=all` setting allows the cursor to move
>> freely to any position in the text, even beyond the end of lines and
>> after the last line of the file. This differs from the default
>> behavior, where the cursor is constrained to valid text positions.
>>
>> Unlike Vim's `virtualedit=all` mode, Emacs' quarter-plane,
>> picture-mode, and artist-mode packages insert actual spaces into the
>> buffer. In contrast, Vim’s `set virtualedit=all` allows the cursor to
>> be placed in positions where no text exists, but real spaces are not
>> added until a character is typed.
>>
>> This distinction is important because, in `virtualedit=all`, the
>> absence of real spaces ensures that the undo/redo history remains
>> unaffected by cursor movements alone.
> 
> Can't one do this using overlays instead of inserting spaces?

I previously attempted to implement this behavior using overlays, but
I encountered an issue: when adding virtual spaces with overlays,
Emacs still treated all the added spaces as a single space for
movement and alignment purposes. This made precise cursor positioning
difficult, as the cursor did not behave as expected when navigating or
attempting to place text at arbitrary positions.

> But eventually, you'd need to insert spaces, if you actually type
> something wherever you move cursor.  So maybe an easier way is to use
> picture-mode after forcing undo to not record some commands for a
> period.  (Not that I understand why not touching the undo history is
> such a big deal.)

One of the purposes of this bug report is to explore the possibility
of implementing a feature in Emacs that allows positioning the cursor
anywhere within the buffer. This would benefit not only modes like
picture-mode, but also indentation-sensitive modes such as Python
and YAML.

Not recording cursor movement in the undo history is advantageous
because it prevents unnecessary undo entries from being created. This
helps keep the undo tree clean and ensures that reverting meaningful
edits remains efficient and straightforward.

For example:
- Modify line 10 (change 1).
- Move the cursor down 10 times.
- Modify line 21 (change 2).

If undo records every cursor movement due to spaces being added
multiple times, reverting to "change 1" would require 12 undo
steps instead of just two, making the process inefficient.

--
James Cherti
GitHub: https://github.com/jamescherti
Website: https://www.jamescherti.com/

Message #14 received at 77438 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: James Cherti <contact <at> jamescherti.com>
Cc: 77438 <at> debbugs.gnu.org
Subject: Re: bug#77438: [FEATURE REQUEST] Freely positioning the cursor
 anywhere in the buffer (Vim’s virtualedit=all
 Equivalent in Emacs)
Date: Wed, 02 Apr 2025 16:25:28 +0300

> Date: Wed, 2 Apr 2025 09:02:04 -0400
> From: James Cherti <contact <at> jamescherti.com>
> 
> >> This distinction is important because, in `virtualedit=all`, the
> >> absence of real spaces ensures that the undo/redo history remains
> >> unaffected by cursor movements alone.
> > 
> > Can't one do this using overlays instead of inserting spaces?
> 
> I previously attempted to implement this behavior using overlays, but
> I encountered an issue: when adding virtual spaces with overlays,
> Emacs still treated all the added spaces as a single space for
> movement and alignment purposes. This made precise cursor positioning
> difficult, as the cursor did not behave as expected when navigating or
> attempting to place text at arbitrary positions.

You could either replace the overlay on each cursor motion command, or
set the 'cursor' property of the overlay string to tell Emacs where to
place the cursor, and move that property with each cursor motion
command.

> > But eventually, you'd need to insert spaces, if you actually type
> > something wherever you move cursor.  So maybe an easier way is to use
> > picture-mode after forcing undo to not record some commands for a
> > period.  (Not that I understand why not touching the undo history is
> > such a big deal.)
> 
> One of the purposes of this bug report is to explore the possibility
> of implementing a feature in Emacs that allows positioning the cursor
> anywhere within the buffer. This would benefit not only modes like
> picture-mode, but also indentation-sensitive modes such as Python
> and YAML.

I'm not sure I understand how this is related to indentation-sensitive
modes.  Can you tell more?

> Not recording cursor movement in the undo history is advantageous
> because it prevents unnecessary undo entries from being created. This
> helps keep the undo tree clean and ensures that reverting meaningful
> edits remains efficient and straightforward.

Emacs normally records cursor motion commands in the undo list, so I'm
not sure I understand why undo revert commands that are not just
buffer text modifications would be annoying enough to justify the
complicated implementation you'd need to use overlays.

> For example:
> - Modify line 10 (change 1).
> - Move the cursor down 10 times.
> - Modify line 21 (change 2).
> 
> If undo records every cursor movement due to spaces being added
> multiple times, reverting to "change 1" would require 12 undo
> steps instead of just two, making the process inefficient.

Yes, but this happens also in normal editing, doesn't it?

Message #17 received at submit <at> debbugs.gnu.org (full text, mbox):

From: James Cherti <contact <at> jamescherti.com>
To: bug-gnu-emacs <at> gnu.org, Eli Zaretskii <eliz <at> gnu.org>
Subject: Re: bug#77438: [FEATURE REQUEST] Freely positioning the cursor anywhere in the buffer (Vim’s virtualedit=all Equivalent in Emacs)
Date: Wed, 2 Apr 2025 11:22:20 -0400

On 2025-04-02 09:25, Eli Zaretskii wrote:
>> Date: Wed, 2 Apr 2025 09:02:04 -0400
>> From: James Cherti <contact <at> jamescherti.com>
>>
>>>> This distinction is important because, in `virtualedit=all`, the
>>>> absence of real spaces ensures that the undo/redo history remains
>>>> unaffected by cursor movements alone.
>>>
>>> Can't one do this using overlays instead of inserting spaces?
>>
>> I previously attempted to implement this behavior using overlays, but
>> I encountered an issue: when adding virtual spaces with overlays,
>> Emacs still treated all the added spaces as a single space for
>> movement and alignment purposes. This made precise cursor positioning
>> difficult, as the cursor did not behave as expected when navigating or
>> attempting to place text at arbitrary positions.
> 
> You could either replace the overlay on each cursor motion command, or
> set the 'cursor' property of the overlay string to tell Emacs where to
> place the cursor, and move that property with each cursor motion
> command.
> 
>>> But eventually, you'd need to insert spaces, if you actually type
>>> something wherever you move cursor.  So maybe an easier way is to use
>>> picture-mode after forcing undo to not record some commands for a
>>> period.  (Not that I understand why not touching the undo history is
>>> such a big deal.)
>>
>> One of the purposes of this bug report is to explore the possibility
>> of implementing a feature in Emacs that allows positioning the cursor
>> anywhere within the buffer. This would benefit not only modes like
>> picture-mode, but also indentation-sensitive modes such as Python
>> and YAML.
> 
> I'm not sure I understand how this is related to indentation-sensitive
> modes.  Can you tell more?

When navigating up or down, a cursor that shifts left or right due to
varying line lengths can be visually distracting and disrupt the
editing flow. Keeping the cursor in a fixed column ensures a
straight-line movement, making it easier to track its position and
maintain indentation accuracy.

>> Not recording cursor movement in the undo history is advantageous
>> because it prevents unnecessary undo entries from being created. This
>> helps keep the undo tree clean and ensures that reverting meaningful
>> edits remains efficient and straightforward.
> 
> Emacs normally records cursor motion commands in the undo list, so I'm
> not sure I understand why undo revert commands that are not just
> buffer text modifications would be annoying enough to justify the
> complicated implementation you'd need to use overlays.
> 
>> For example:
>> - Modify line 10 (change 1).
>> - Move the cursor down 10 times.
>> - Modify line 21 (change 2).
>>
>> If undo records every cursor movement due to spaces being added
>> multiple times, reverting to "change 1" would require 12 undo
>> steps instead of just two, making the process inefficient.
> 
> Yes, but this happens also in normal editing, doesn't it?

In my setup, cursor movement is only included in the undo history
when a change is made.

I am using evil-mode and undo-fu with the following settings:
(setq evil-want-fine-undo t)
(setq evil-undo-system 'undo-fu)

Here is what happens in this setup:
1. Modify line 10 (change 1).
2. Move the cursor down 10 times.
3. Modify line 21 (change 2).

When I press u (undo) the first time, only the change on line 21 is
undone.

When I press u (undo) again, the change on line 10 is undone.

(I don’t need to press u (undo) 10 more times to undo the cursor
movement before I can undo the change on line 10.)

--
James Cherti
GitHub: https://github.com/jamescherti
Website: https://www.jamescherti.com/

Message #20 received at 77438 <at> debbugs.gnu.org (full text, mbox):

From: Richard Stallman <rms <at> gnu.org>
To: James Cherti <contact <at> jamescherti.com>
Cc: 77438 <at> debbugs.gnu.org
Subject: Re: bug#77438: [FEATURE REQUEST] Freely positioning the cursor
 anywhere
 in the buffer (Vim’s virtualedit=all Equivalent
 in Emacs)
Date: Wed, 02 Apr 2025 23:36:57 -0400

[[[ To any NSA and FBI agents reading my email: please consider    ]]]
[[[ whether defending the US Constitution against all enemies,     ]]]
[[[ foreign or domestic, requires you to follow Snowden's example. ]]]

  > Unlike Vim's `virtualedit=all` mode, Emacs' quarter-plane,
  > picture-mode, and artist-mode packages insert actual spaces into the
  > buffer. In contrast, Vim’s `set virtualedit=all` allows the cursor to
  > be placed in positions where no text exists, but real spaces are not
  > added until a character is typed.

This won't be exactly easy to do in Emacs.  It is fundamental in Emacs
that point is on a position between two characters.

-- 
Dr Richard Stallman (https://stallman.org)
Chief GNUisance of the GNU Project (https://gnu.org)
Founder, Free Software Foundation (https://fsf.org)
Internet Hall-of-Famer (https://internethalloffame.org)

Message #23 received at submit <at> debbugs.gnu.org (full text, mbox):

From: James Cherti <contact <at> jamescherti.com>
To: bug-gnu-emacs <at> gnu.org, rms <at> gnu.org
Subject: Re: bug#77438: [FEATURE REQUEST] Freely positioning the cursor anywhere in the buffer (Vimâs virtualedit=all Equivalent in Emacs)
Date: Thu, 3 Apr 2025 11:30:12 -0400

Hello Richard,

On 2025-04-02 23:36, Richard Stallman wrote:
> [[[ To any NSA and FBI agents reading my email: please consider    ]]]
> [[[ whether defending the US Constitution against all enemies,     ]]]
> [[[ foreign or domestic, requires you to follow Snowden's example. ]]]
> 
>    > Unlike Vim's `virtualedit=all` mode, Emacs' quarter-plane,
>    > picture-mode, and artist-mode packages insert actual spaces into the
>    > buffer. In contrast, Vim’s `set virtualedit=all` allows the cursor to
>    > be placed in positions where no text exists, but real spaces are not
>    > added until a character is typed.
> 
> This won't be exactly easy to do in Emacs.  It is fundamental in Emacs
> that point is on a position between two characters.

Thank you for taking the time to comment on this feature request, which
I hope to see implemented in Emacs.

Could this be implemented without modifying the fundamental concept
in Emacs that a point is a position between two characters?

Here’s an idea: instead of modifying the internal concept where the
cursor is equal to the position between two characters, we could
implement a new mode that displays a "virtual cursor." This mode
would display a cursor representing a specific line/column, rather
than a position between two characters. It would allow the cursor to
be placed at a line/column position, which may not necessarily be
between two characters.

> -- Dr Richard Stallman (https://stallman.org) Chief GNUisance of the GNU 
> Project (https://gnu.org) Founder, Free Software Foundation (https:// 
> fsf.org) Internet Hall-of-Famer (https://internethalloffame.org)

--
James Cherti
GitHub: https://github.com/jamescherti
Website: https://www.jamescherti.com/

Message #26 received at submit <at> debbugs.gnu.org (full text, mbox):

From: James Cherti <contact <at> jamescherti.com>
To: bug-gnu-emacs <at> gnu.org, Eli Zaretskii <eliz <at> gnu.org>
Subject: Re: bug#77438: [FEATURE REQUEST] Freely positioning the cursor anywhere in the buffer (Vim’s virtualedit=all Equivalent in Emacs)
Date: Thu, 3 Apr 2025 11:33:02 -0400

Hello Eli,

Thank you for your comments, which helped clarify the purpose of
this feature request.

If you have any ideas on how this could be implemented, whether or
not it involves changing the Emacs internals, please feel free to
share your insights.

--
James Cherti
GitHub: https://github.com/jamescherti
Website: https://www.jamescherti.com/

On 2025-04-02 11:22, James Cherti wrote:
> On 2025-04-02 09:25, Eli Zaretskii wrote:
>>> Date: Wed, 2 Apr 2025 09:02:04 -0400
>>> From: James Cherti <contact <at> jamescherti.com>
>>>
>>>>> This distinction is important because, in `virtualedit=all`, the
>>>>> absence of real spaces ensures that the undo/redo history remains
>>>>> unaffected by cursor movements alone.
>>>>
>>>> Can't one do this using overlays instead of inserting spaces?
>>>
>>> I previously attempted to implement this behavior using overlays, but
>>> I encountered an issue: when adding virtual spaces with overlays,
>>> Emacs still treated all the added spaces as a single space for
>>> movement and alignment purposes. This made precise cursor positioning
>>> difficult, as the cursor did not behave as expected when navigating or
>>> attempting to place text at arbitrary positions.
>>
>> You could either replace the overlay on each cursor motion command, or
>> set the 'cursor' property of the overlay string to tell Emacs where to
>> place the cursor, and move that property with each cursor motion
>> command.
>>
>>>> But eventually, you'd need to insert spaces, if you actually type
>>>> something wherever you move cursor.  So maybe an easier way is to use
>>>> picture-mode after forcing undo to not record some commands for a
>>>> period.  (Not that I understand why not touching the undo history is
>>>> such a big deal.)
>>>
>>> One of the purposes of this bug report is to explore the possibility
>>> of implementing a feature in Emacs that allows positioning the cursor
>>> anywhere within the buffer. This would benefit not only modes like
>>> picture-mode, but also indentation-sensitive modes such as Python
>>> and YAML.
>>
>> I'm not sure I understand how this is related to indentation-sensitive
>> modes.  Can you tell more?
> 
> When navigating up or down, a cursor that shifts left or right due to
> varying line lengths can be visually distracting and disrupt the
> editing flow. Keeping the cursor in a fixed column ensures a
> straight-line movement, making it easier to track its position and
> maintain indentation accuracy.
> 
>>> Not recording cursor movement in the undo history is advantageous
>>> because it prevents unnecessary undo entries from being created. This
>>> helps keep the undo tree clean and ensures that reverting meaningful
>>> edits remains efficient and straightforward.
>>
>> Emacs normally records cursor motion commands in the undo list, so I'm
>> not sure I understand why undo revert commands that are not just
>> buffer text modifications would be annoying enough to justify the
>> complicated implementation you'd need to use overlays.
>>
>>> For example:
>>> - Modify line 10 (change 1).
>>> - Move the cursor down 10 times.
>>> - Modify line 21 (change 2).
>>>
>>> If undo records every cursor movement due to spaces being added
>>> multiple times, reverting to "change 1" would require 12 undo
>>> steps instead of just two, making the process inefficient.
>>
>> Yes, but this happens also in normal editing, doesn't it?
> 
> In my setup, cursor movement is only included in the undo history
> when a change is made.
> 
> I am using evil-mode and undo-fu with the following settings:
> (setq evil-want-fine-undo t)
> (setq evil-undo-system 'undo-fu)
> 
> Here is what happens in this setup:
> 1. Modify line 10 (change 1).
> 2. Move the cursor down 10 times.
> 3. Modify line 21 (change 2).
> 
> When I press u (undo) the first time, only the change on line 21 is
> undone.
> 
> When I press u (undo) again, the change on line 10 is undone.
> 
> (I don’t need to press u (undo) 10 more times to undo the cursor
> movement before I can undo the change on line 10.)
> 
> -- 
> James Cherti
> GitHub: https://github.com/jamescherti
> Website: https://www.jamescherti.com/
> 
> 
> 

Message #29 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: James Cherti <contact <at> jamescherti.com>
Cc: bug-gnu-emacs <at> gnu.org
Subject: Re: bug#77438: [FEATURE REQUEST] Freely positioning the cursor
 anywhere in the buffer (Vim’s virtualedit=all
 Equivalent in Emacs)
Date: Thu, 03 Apr 2025 18:48:37 +0300

> Date: Thu, 3 Apr 2025 11:33:02 -0400
> From: James Cherti <contact <at> jamescherti.com>
> 
> Thank you for your comments, which helped clarify the purpose of
> this feature request.
> 
> If you have any ideas on how this could be implemented, whether or
> not it involves changing the Emacs internals, please feel free to
> share your insights.

All of my suggestions were based on existing features.  If they work
and do the job you want this to do, you should be able to implement
these features without any changes to the internals.

Message #32 received at 77438 <at> debbugs.gnu.org (full text, mbox):

From: Richard Stallman <rms <at> gnu.org>
To: James Cherti <contact <at> jamescherti.com>
Cc: 77438 <at> debbugs.gnu.org
Subject: Re: bug#77438: [FEATURE REQUEST] Freely positioning the cursor
 anywhere
 in the buffer (Vimâs virtualedit=all Equivalent in
 Emacs)
Date: Thu, 03 Apr 2025 22:51:25 -0400

[[[ To any NSA and FBI agents reading my email: please consider    ]]]
[[[ whether defending the US Constitution against all enemies,     ]]]
[[[ foreign or domestic, requires you to follow Snowden's example. ]]]

  > Here’s an idea: instead of modifying the internal concept where the
  > cursor is equal to the position between two characters, we could
  > implement a new mode that displays a "virtual cursor." This mode
  > would display a cursor representing a specific line/column, rather
  > than a position between two characters. It would allow the cursor to
  > be placed at a line/column position, which may not necessarily be
  > between two characters.

This would make display work as it should in this mode, with editing
commands that have special code to update the virtual cursor.

But if that will work only for commands that are updated with extra code
to understand these virtual cursor positions.  That would be an enormous
amount of work and wuuld complicate future maintenance.

A less ugly way to do this would be to modify the buffer contents model
so that there can be virtual spaces at the end of the current line.

But it won't be easy to make that work with full consistency for all
commands that operate on or look at the buffer.  Would the virtual spaces
extend to the right margin?  Would they extend only as far as he cursor?

If you do C-SPC C-n M-w, what should that put in the kill ring?
What about C-SPC C-u C-n M-w?  One would need to figure out a system that
gives the "right" answers for such questions.

-- 
Dr Richard Stallman (https://stallman.org)
Chief GNUisance of the GNU Project (https://gnu.org)
Founder, Free Software Foundation (https://fsf.org)
Internet Hall-of-Famer (https://internethalloffame.org)

Previous Next

GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997,2003 nCipher Corporation Ltd, 1994-97 Ian Jackson.