How to "copy to clipboard" in vim of Bash on Windows? [closed]

Question

I used to use "+y to copy text to system's clipboard, but it doesn't work in vim of Bash on Windows.

Answer 1

Since neither "*y nor "+y (...) work, an alternative is the following:

Add this to your .vimrc and create a file called ~/.vimbuffer

" copy (write) highlighted text to .vimbuffer
vmap <C-c> y:new ~/.vimbuffer<CR>VGp:x<CR> \| :!cat ~/.vimbuffer \| clip.exe <CR><CR>
" paste from buffer
map <C-v> :r ~/.vimbuffer<CR>

Higlight any text using visual or visual-block and press ctrl-c. Paste copied text outside your terminal using the usual method or paste copied text to any vim pane using ctrl-v in normal or visual mode.

Ctrl-c yanks the selected text, overwrites ~/.vimbuffer with the selected text, runs a UNIX command to pipe out the data from ~/.vimbuffer to clip.exe.

Any further improvement (e.g.: making command silent) is much appreciated!

Edit: command can now copy strings with any length, not just whole lines. Old command:

vmap <C-c> :w! ~/.vimbuffer \| !cat ~/.vimbuffer \| clip.exe <CR><CR>

Edit2: @Tropilio below has a much cleaner approach down in the comments using system events. I've been using that for a year now.

Answer 2

To copy to the clipboard from within vim in Bash on Windows 10, hold Shift and drag the cursor over text. then press enter

A selection should look like this before pressing enter:

EDIT: This only works with text that fits on the screen all at once; it cannot be used to copy blocks of text that span many 'screens'

Answer 3

So there's a lot of answers, even on cross-network questions like this one on Super User, and this one on Vi and Vim, and unfortunately I'm not satisfied with any of them, so here's a different answer.

Neovim

If we're using Neovim, it's easy. We can read their docs about providers under Clipboard integration, which also has a section about WSL. The rest of this section is just context.

By setting set clipboard=unnamedplus as if we were on a regular Linux system under X11, we tell Neovim to use the system registers as our default clipboard when yanking and pasting. Based on where Neovim is running, it chooses an appropriate provider to interact with these system registers. For v0.4.3, how that provider is chosen can be found at provider#clipboard#Executable.

While this solution requires installing an external binary win32yank.exe, I'm personally very satisfied with it as both clip.exe and powershell.exe [Set|Get]-Clipboard pale in user experience to it. For example, clip.exe only supports copying, but fails to address the pasting issue. And while the Powershell Get-Clipboard cmdlet allows for us to paste into Vim from our Windows clipboard, it'll retain Windows line-endings, so there will be nasty ^Ms everywhere after pasting. In addition, it's a super small binary and only has to be installed within our WSL distro; nothing on the Windows side.

curl -sLo /tmp/win32yank.zip https://github.com/equalsraf/win32yank/releases/download/v0.0.4/win32yank-x64.zip
unzip -p /tmp/win32yank.zip win32yank.exe > /tmp/win32yank.exe
chmod +x /tmp/win32yank.exe
sudo mv /tmp/win32yank.exe /usr/local/bin/

Vim

If we're just using regular Vim, we can still use win32yank.exe, but we have to manually implement what Neovim would normally do for us. That is, the following:

set clipboard=unnamed

autocmd TextYankPost * call system('win32yank.exe -i --crlf', @")

function! Paste(mode)
    let @" = system('win32yank.exe -o --lf')
    return a:mode
endfunction

map <expr> p Paste('p')
map <expr> P Paste('P')

First set the clipboard to the default register (@") as the system registers might not even be enabled if Vim was compiled without clipboard support like on my default Ubuntu WSL distro. Copies use an autocmd to pass the default register to win32yank, and pastes intercept the paste to assign the system clipboard to the default register.

This works but it's noticeably jittery if performing several successive yanks and pastes quickly as we have to shell out every time. We can improve the yank by debouncing it:

autocmd TextYankPost * call YankDebounced()

function! Yank(timer)
    call system('win32yank.exe -i --crlf', @")
    redraw!
endfunction

let g:yank_debounce_time_ms = 500
let g:yank_debounce_timer_id = -1

function! YankDebounced()
    let l:now = localtime()
    call timer_stop(g:yank_debounce_timer_id)
    let g:yank_debounce_timer_id = timer_start(g:yank_debounce_time_ms, 'Yank')
endfunction

But this will require Vim 8, and if you have to upgrade, I'd recommend to just go with Neovim instead. Trying to implement proper caching and debouncing would be a headache!

Answer 4

If you don't want to set up an X server, this method will allow you to copy selected text to your clipboard using the clip.exe program which comes shipped with Windows.

The code snippets below can be placed in your .vimrc file.

First create a helper function which will return the currently selected text as a string. We can use this function to pipe highlighted text into clip.exe:

func! GetSelectedText()
    normal gv"xy
    let result = getreg("x")
    return result
endfunc

The system function will allow us to call native programs and pipe parameters into them. The snippet below sets up two key mappings; the first line will allow Ctrl+C to be used for copying text and the second will allow Ctrl+X for cutting text:

noremap <C-C> :call system('clip.exe', GetSelectedText())<CR>
noremap <C-X> :call system('clip.exe', GetSelectedText())<CR>gvx

After saving the changes to your .vimrc file you should be good to go.

If you are going to be using your .vimrc on multiple systems, I suggest wrapping these mappings in an if statement to check if clip.exe actually exists:

if !has("clipboard") && executable("clip.exe")
    noremap <C-C> :call system('clip.exe', GetSelectedText())<CR>
    noremap <C-X> :call system('clip.exe', GetSelectedText())<CR>gvx
endif

The above will also allow Vim to ignore those key bindings if it has direct access to the system clipboard.

You might also want to add keybindings for when vim does have access to the clipboard, like so:

if has("clipboard")
    vnoremap <C-X> "+x
    vnoremap <S-Del> "+x

    vnoremap <C-C> "+y
    vnoremap <C-Insert> "+y

    map <C-V>       "+gP
    map <S-Insert>      "+gP

    cmap <C-V>      <C-R>+
    cmap <S-Insert>     <C-R>+
endif

Which will come in handy if you are using Vim natively on Windows or are using vim-gtk on a Linux system.

Answer 5

If you only care about copying complete lines, you can use Vim's ability to pipe the file contents to an external program. So you can do

:w !clip.exe

to pipe into clip.exe. If you need specific lines, say 2 through 10, you can just do

:2,10w !clip.exe

See Piping buffer to external command in Vim

Answer 6

Add following to .vimrc:

autocmd TextYankPost * if v:event.operator ==# 'y' | call system('/mnt/c/Windows/System32/clip.exe', @0) | endif

For convenience, if desired, you can add copying by ctrl + c

vmap <C-c> y

Answer 7

If you want use vim that bundled within WSL, you can only use the Clipboard provided by vim itself, which means you can only copy & paste within vim only.

Or, you can try:

1. Install VcXsrv and run it.
2. export DISPLAY=localhost:0 in your WSL Bash.
3. Run vim-gtk or vim-gnome(or any other GUI Apps) and try Clipboard across Linux and Windows.

Answer 8

Combining the information above, it's possible to copy simple text from any register to a clipboard without using any keybinding (what can be more convenient in some cases). For example, if you want to copy last yanked text to the windows clipboard, enter the following command (start typing):

:call system('clip.exe', '

Now press Ctrl+r, followed by a register +. It will paste a text from the specified register. Next, close the single quote and the parentheses. The command will look like:

:call system('clip.exe', 'a text from 0 register')

Press Enter, done!

Answer 9

Below are mappings

• in normal mode cy, cyy and cY (=Clipboard Yank) that copy, respectively, the given text object, line(s), rest of the line from the cursor position to the clipboard, and
• in visual mode Y that copies the visual selection to the clipboard,

independent of whether Vim is started in WSL or not.

nnoremap                    cy                   "+y
nnoremap                    <sid>(mgu)   m`_
onoremap                    <sid>(gu)        g_
nnoremap                    <sid>(ggg)   g``
nmap         <expr>     cyy                  '<sid>(mgu)cy' . v:count1 . '<sid>(gu)' . '<sid>(ggg)'
nmap                            cY                   cy<sid>(gu)

xnoremap Y  "+y

if has('unix') && executable('clip.exe')
    " From :help map-operator
    function! SendToClip(type, ...) abort
        if a:0
            " Visual mode
            normal! gv"+y
        elseif a:type ==# 'line'
            normal! '[V']"+y
        elseif a:type ==# 'char'
            normal! `[v`]"+y
        endif

        call system('clip.exe', @+)
    endfunction

    nnoremap <silent> cy            :set operatorfunc=SendToClip<cr>g@
    xnoremap <silent> Y             :<C-U>call SendToClip(visualmode(),1)<cr>
endif

Answer 10

vmap <silent> <leader>y :w !clip.exe<CR><CR>
"---------------------- :w !clip.exe
" The core command, thanks to Mitchell's answer.
"---------------------------------- <CR><CR>
" The first <CR> closes the command;
" the second <CR> suppresses "Press ENTER or type command to continue".
"--- :h map-silent
" This fix the flicker caused by external commands and <CR><CR>.
"------------ :h leader
" `:echo mapleader` to view your leader key.

Standing on the shoulders of giants, I'm using the above solution now.

Answer 11

What works for me is simply:

Holding Shift key and selecting the text you would like to copy using the mouse. Then go to any text editor on your host and paste; your selected text should be there.