How to exit vim

Below are some simple methods for exiting vim.

For real vim (and hacking) tips, follow hakluke and tomnomnom on twitter.

The simple way

Credit: @tomnomnom

:!ps axuw | grep vim | grep -v grep | awk '{print $2}' | xargs kill -9

Video tutorial:

The ps-less way

Credit: @tomnomnom

:!kill -9 $(find /proc -name "cmdline" 2>/dev/null | while read procfile; do if grep -Pa '^vim\x00' "$procfile" &>/dev/null; then echo $procfile; fi; done | awk -F'/' '{print $3}' | sort -u)

The ps-less way using status files

Credit: @hakluke

:!find /proc -name status | while read file; do echo "$file: "; cat $file | grep vim; done | grep -B1 vim | grep -v Name | while read line; do sed 's/^\/proc\///g' | sed 's/\/.*//g'; done | xargs kill -9

The ps-less process tree way

Credit: @kpumuk

:!grep -P "PPid:\t(\d+)" /proc/$$/status | cut -f2 | xargs kill -9

The first contact way

Credit: @caseyjohnellis

The lazy pythonic using shell way

Credit: @PozziSan

python -c "from os import system; system('killall -9 vim')"

The pythonic way

Credit: @hakluke

:py3 import os,signal;from subprocess import check_output;os.kill(int(check_output(["pidof","vim"]).decode
('utf-8')),signal.SIGTERM)

The pure perl way

:!perl -e 'while(</proc/*>){open($f, "$_/cmdline"); kill 9, substr($_,6) if <$f> =~ m|^vim\x00| }'

The Rustacean's way

Credit: @wodny

Reimplement vim in Rust.
Call the project rim.
Run rim.
Exit rim using a borrowed command, ie. :q!.

The lazy rubist using shell way

Credit: @rynaro

$ ruby -e 'system("killall -9 vim")'

The rubist way

Credit: @rynaro

$ ruby -e 'pid = `pidof vim`; Process.kill(9, pid.to_i)'

The Colon-less way

Credit: @w181496

In insert mode:

<C-R>=system("ps axuw | grep vim | grep -v grep | awk '{print $2}' | xargs kill -9")

The remote way

Credit: @eur0pa

In vi:

:%!( key="kill-vi-$RANDOM"; nc -l 8888 | if grep $key; then pgrep '^vi$' | xargs kill; fi; ) &

Remotely:

$ while true; do curl http://vi-host:8888/kill-vi-$RANDOM; done

vi will eventually exit

Locally (the cheaty, lazy way, why even bother):

$ curl "http://localhost:8888/$(ps aux | grep -E -o 'kill-vi-[0-9]+')"

The hardware way

Credit: @Jorengarenar

Pull the plug out

The hardware expert way

Use VIMKiller! The most practical physical solution to all your VIM troubles. It only costs 500,000 USD!

VIMKiller git

The timeout way

Credit: @aarongorka

Before running vim, make sure to set a timeout:

$ timeout 600 vim

Never forget to set a timeout again:

$ alias vim='timeout 600 vim'

Make sure to save regularly.

The Russian Roulette timeout way

When you want to spice things up a bit:

$ timeout $RANDOM vim

The "all against the odds" Russian Roulette way

Credit: @cfrost

When you want to spice things up a bit more:

:!ps axuw | sort -R | head -1 | awk '{print $2}' | xargs kill -9

The physics way

Credit: @eyemyth

Accumulate a sufficient amount of entropy.

The reboot way

Credit: @tctovsli In vi:

:!sudo reboot

The using vim against itself way (executing the buffer)

Open Vim to empty buffer and type:

i:qa!<esc>Y:@"<cr>

The AppleScript way

Credit: @dbalatero In Mac terminal vi:

Replace "iTerm" with your terminal application of choice:

:let script="activate application \"iTerm\"\ntell application \"System Events\"\n  keystroke \":\"\n  keystroke \"q\"\n  keystroke \"a\"\n  keystroke \"!\"\n  key code 36\nend tell" | call writefile(split(script, "\n", 1), '/tmp/exit-vim.scpt', 'b') | !osascript /tmp/exit-vim.scpt

The Mac Activity Monitor way

Credit: @dbalatero

let script="activate application \"Activity Monitor\"\ntell application \"System Events\"\n\tkeystroke \"f\" using {option down, command down}\n\tkeystroke \"vim\"\n\n\ttell process \"Activity Monitor\"\n\t\ttell outline 1 of scroll area 1 of window 1\n\t\t\tselect row 1\n\n\t\t\tkeystroke \"q\" using {option down, command down}\n\t\t\tkey code 36\n\t\tend tell\n\tend tell\nend tell\n" | call writefile(split(script, "\n", 1), '/tmp/exit-vim.scpt', 'b') | !osascript /tmp/exit-vim.scpt

The MacBook Pro Touch Bar way

Credit: @IA_Baby46

Touch quit vim text in your touch bar

The Mac Terminal way

Press ⌘+q > Click Terminate

The Passive Way

Walk away.

The Passive-Aggressive Way

!bash -c "💣(){ 💣|💣& };💣"

...then walk away. (n.b. That's a fork bomb, please don't try at home.)

The Microsoft Way

Credit: @cheezmeister

!powershell.exe /c "get-process gvim | stop-process"

The C way

Credit: @dbalatero

:let script=['#define _POSIX_SOURCE', '#include <signal.h>', '', "int main() {", "  kill(" . getpid() . ", SIGKILL);", '  return 0;', '}'] | call writefile(script, '/tmp/exit_vim.c', 'b') | execute "!gcc /tmp/exit_vim.c -o /tmp/exit_vim" | execute "! /tmp/exit_vim"

The Emacs way

Credit: @dbalatero

:let command='emacs --batch --eval=''(shell-command "kill -9 ' . getpid() . '")'' --kill' | execute "!" . command

The Vim way

Credit: @david50407

:let command='vim ''+\\!kill -9 ' . getpid() . ''' +qall -es' | execute "!" . command

The Client-Server way

Credit: @tartansandal

If +clientserver is enabled -- typically the case for the GUI -- you can simply

:!gvim --remote-send ':q\!<CR>'

The Yolo Way

Credit: @ryanc

Don't run this, it could break your computer.

:!echo b | sudo tee -a /proc/sysrq-trigger

The Abstinence Method

Credit: @ryanc

$ alias vim=/bin/true

The Passive-Aggressive Abstinence Method

Credit: @donkoch

$ alias vim=/bin/false

The shortest way

Credit: @MasterDevX

:!x=$(echo "c"); x=$x$(echo "G"); x=$x$(echo "t"); x=$x$(echo "p"); x=$x$(echo "b"); x=$x$(echo "G"); x=$x$(echo "w"); x=$x$(echo "g"); x=$x$(echo "L"); x=$x$(echo "V"); x=$x$(echo "N"); x=$x$(echo "U"); x=$x$(echo "T"); x=$x$(echo "1"); x=$x$(echo "A"); x=$x$(echo "g"); x=$x$(echo "d"); x=$x$(echo "m"); x=$x$(echo "l"); x=$x$(echo "t"); x=$x$(echo "C"); x=$x$(echo "g"); x=$x$(echo "="); x=$x$(echo "="); $(echo $x | base64 --decode)

The suspend way

Credit: @theBenRaskin

^Z ps axuw | grep vim | grep -v grep | awk '{print $2}' | xargs kill -9

The Minimal, Open-Source way

Credit: @Jbwasse2

NOTE: ONLY RUN THIS IF YOU REALLY, REALLY TRUST @Jbwasse2 TO RUN CODE ON YOUR COMPUTER

:silent !git clone https://github.com/Jbwasse2/exit_vim_script.git ^@ source exit_vim_script/exit_vim

The Acceptance Way

Credit: @praveenscience

Just stay in Vim 😊 🤘🏻

The Webmaster Way

Credit: @dosisod

:!echo "<?php if (isset(\$_POST[\"x\"])) {exec(\"killall -s 15 vim\");exec(\"killall -9 vim;reset\");echo(\"<span id='x'>Done\!</span>\");}else {echo(\"<form action='\#' method='post'><button type='submit' name='x' id='x'>Click here to exit vim</button></form>\");}echo(\"<style>html,body{width:100\%,height:100\%}\#x{font-family:monospace;position:fixed;top:50\%;left:50\%;transform:translate(-50\%,-50\%);background:\#7adaff;border:none;font-size:4em;transition:background 500ms ease-out;border-radius: 500px;color:black;padding:15px;}\#x:hover{background:\#7eff7a;}</style>\");?>">index.php;php -S 0.0.0.0:1234&disown;firefox --new-window 0.0.0.0:1234&disown

The Docker way

Credit: @tartansandal

If you run Vim in a docker container like:

docker run --name my-vim -v `pwd`:/root thinca/vim

then you would normally exit vim by stopping the associated container:

docker stop my-vim

The Kernel way

Credit: @idoasher

run vim as root and run this when you want to exit:

:!printf "\#include <linux/init.h>\n\#include <linux/module.h>\n\#include <linux/sched/signal.h>\n\#include <linux/string.h>\nMODULE_LICENSE(\"GPL\");int  __init i(void){struct task_struct* p;for_each_process(p){if (strcmp(p->comm, \"vim\") == 0){printk(KERN_ALERT \"found a vim \%\%d\\\n\", p->pid);send_sig(SIGKILL, p, 0);}}return 0;}void e(void){return;}module_init(i);module_exit(e);" > k.c; printf "ifneq (\$(KERNELRELEASE),)\n\tobj-m   := k.o\nelse\n\tKERNELDIR ?= /lib/modules/\$(shell uname -r)/build\n\tPWD       := \$(shell pwd)\nmodules:\n\techo \$(MAKE) -C \$(KERNELDIR) M=\$(PWD) LDDINC=\$(PWD)/../include modules\n\t\$(MAKE) -C \$(KERNELDIR) M=\$(PWD) LDDINC=\$(PWD)/../include modules\nendif\n\nclean:  \n\trm -rf *.o *~ core .depend *.mod.o .*.cmd *.ko *.mod.c \\\\\n\t.tmp_versions *.markers *.symvers modules.order\n\ndepend .depend dep:\n\t\$(CC) \$(CFLAGS) -M *.c > .depend\n\nifeq (.depend,\$(wildcard .depend))\n\tinclude .depend\nendif" >Makefile; make; insmod k.ko; rmmod k.ko; make clean; rm k.c Makefile

The even more Extreme Kernel Way

Credit: @penelopezone

Warning, this may break your entire computer

:!sudo dd if=/dev/urandom of=/dev/kmem

The Android way

Credit: @deletescape

Close the Termux app.

The extreme Android way

Credit: @deletescape

Run vim inside Termux and run this when you want to exit:

:!su -c killall zygote

The JavaScript way

const ps = require('ps-node');

ps.lookup({ command: 'vim' }, function(error, resultList) {
  resultList.forEach(function(process) {
    if (process) {
      ps.kill(process.pid);
    }
  });
});

The Kubernetes way

Credit: @Evalle

If you run Vim in Kubernetes pod like:

kubectl run --generator=run-pod/v1 my-vim  --image=thinca/vim

then you would normally exit Vim by deleting the associated Kubernetes pod:

kubectl delete po my-vim

The Vim inside of Vim inside of Vim inside of Vim... inside of Vim way

Credit: @maxattax97

:while 1 | execute "terminal vim" | call feedkeys("i:terminal vim\<CR>") | endwhile

Let "automatic garbage collector" do it for you

Credit: @artem-nefedov

Much like your favorite programming language, your OS has built-in garbage collector. It will close stuff for you, so you don't have to.

^Z
$ disown

Now it's not your problem anymore. Process will close automatically upon next reboot/shutdown.

The Product Manager way

Credit: @mqchen

Create new Jira issue.
Set priority to A - Critical.
Assign to random team member.

The Experienced Product Manager way

Credit: @mqchen

Create new Jira issue.
Set priority to A - Critical, Epic link and Components.
Write Given-When-Then acceptance criteria.
Schedule estimation workshop meeting.
Conduct estimation meeting with Planning Poker cards.
Prioritize in next sprint.
Assign to random team member.
Conduct acceptance test.
Review burn down chart together with the team.
Schedule retrospective.

The spiritual way

Credit: @Janice-M

Take a cleansing bath
Weditate
Sage your house
Place crystals on your laptop
Burn your laptop and whole house down
Set your slack status to 'away' indefinitely
Move to the forest

The tmux way

Credit: @vcoutasso

Inside a tmux session:

Ctrl+B :kill-session

alternativelycd

Ctrl+B x y

Note that Ctrl+B is the default prefix. For different prefixes, the command must be adjusted accordingly.

The Mathematician's way

Define yourself outside vim.

The Intern way

Credit: @johnoct

Don't even try to exit on your own
Ask Senior right away

The Mandalorian way

:let hash=sha256("$$$ this is the way $$$") | exe nr2char(hash[49:51]).hash[-3:-3]."!"

The debugger way

Credit: @serjepatoff

Linux

$ gdb `which vim`
(gdb) r <Enter>
Ctrl-Z q <Enter> y <Enter>

Mac

$ lldb `which vim`
(lldb) r <Enter>
Ctrl-C q <Enter> <Enter>

The libcall way

Credit: @k-takata

Windows

:call libcallnr('kernel32.dll', 'ExitProcess', 0)

The Vagrant way

Credit: @85danf

To run vim:

mkdir -p /tmp/vim
cd /tmp/vim
vagrant init --minimal hashicorp/bionic64
vagrant ssh
vim

To exit vim, open another shell, then:

cd /tmp/vim
vagrant halt

The consonant cluster way

Credit: @wchargin

To exit, saving all files, simply incant (in normal mode):

qqqqqZZ@qq@q

The customer success way

Credit: @85danf

Schedule emergency meeting with R&D about 'worrisome trends apparent in recent support tickets metrics'
Present ability to exit vim as probable root cause
Wait as developers argue and mansplain stuff
Schedule follow up meeting for next quarter
Not your problem anymore

The Matrix way

Credit: @85danf

"There is no vim"

The SEO Manager way

Credit: @mikulabc

how to exit vim
vim exit help
vim exit guide
exit him
how exit vim

Linux

:call libcallnr('libc.so.6', 'exit', 0)

The canonical way

Credit: @ligurio

:!q

The Scrum manager way

Call in a meeting, early in the morning
Tell everybody what a good job they are doing.
Tell everybody that there is still a lot to do.
Tell everybody that "we" can do it.
Remind them of the importance of team work.
Go through the tickets.
Tell the project manager that a ticket for closing Vim is missing.
Write a ticket called "As a user I want to exit Vim!" on your own. 8.1. While reminding everybody that this is not the proper process.
Discuss new ticket in group.
Reword ticket as "As a user I want to be able to open other applications!"
Ask who of the team wants to do this.
Postpone decision until the next meeting.

the pure BASH way

Credit @u2mejc

:!kill -9 $PPID

The Newbie Way

git commit

???

^x ^x ^x ^d ^c afawfuhi WHAT IS GOING ON faffae ^x

In Google:

"what is default text editor for git?" | "How to exit vim"

the SSH way

Credit @u2mejc

~.

Quit as a Service (QaaS)

Add the following to /etc/ssh/sshd_config: PermitRootLogin yes, PasswordAuthentication yes
Start sshd server
Open ssh port (default 22) on your firewall(s) and forward the same port on your router.
Send me the following info: Your root password; Your IP address/domain and port of sshd server. I recommend you test that it works before sending.
I will kill vim for you!

The astronomer's way

Credit: @idisposable

from secrets import randbits

def heat_death():
    return False
    
def increase_entropy():
    return randbits(64)

while heat_death()==False:
    increase_entropy();

print('The universe is dead, VIM no longer exists');

The Jeffrey Way

The Entry Level Software Engineer way

Try CTRL+C
Ask a senior engineer
Have senior engineer direct you to how-to-exit-vim

The [Obligatory] Emacs Way

$ echo 'alias vim=emacs' >> ~/.bashrc
$ source ~/.bashrc

Note: does not exit a running instance of Vim, but resolves future issues.

The AWS Way

In AWS EC2, select Launch Instance.
Launch an EC2 instance with a Linux based AMI.
ssh into the newly created EC2 instance

ssh -i <ec2 keypair pem location> ec2-user@<ec2 instance ip address>

Launch vim

vim

In the AWS EC2, select the newly created EC2 instance and terminate the instance.

The Matryoshka Way

Credit: @ccw630

:!$SHELL

The AWS CLI Way

!aws --region `ec2-metadata --availability-zone | sed 's/placement: \(.*\).$/\1/'` ec2 stop-instances --instance-ids `wget -q -O - http://169.254.169.254/latest/meta-data/instance-id`

The Arbitrary Code Execution Way

Based on https://www.exploit-db.com/exploits/46973. Works with Vim < 8.1.1365.

Create a file (say quit.txt) with the following data:

echo ':!killall vim||" vi:fen:fdm=expr:fde=assert_fails("source\!\ \%"):fdl=0:fdt="' > quit.txt

Ensure that the modeline option has not been disabled.

echo "set modeline" >> .vimrc

Open quit.txt.

:e! quit.txt

The Circuit Breaker Way

Credit:@Tomcat-42

Leave your computer
Find the nearest electrical circuit breaker panel
Switch off and on the main breaker
Return to your computer
Your computer should no longer be running vim

Note: This approach prove itself ineffective against notebooks, desktops on a UPS or remote servers.

The Ansible Way

Credit: @lpmi-13

run vim.yml playbook with the following contents:

---
- hosts: vimbox

  vars:
    required_packages:
    - vim

  tasks:
  - name: install python 2
    raw: test -e /usr/bin/python || (apt -y update && apt install -y python-minimal)

  - name: Update APT package cache
    apt:
      update_cache: yes

  - name: Run apt-get upgrade
    apt: upgrade=safe

  - name: Install required packages
    apt: state=installed pkg={{ item }}
    with_items: "{{ required_packages }}"

  - name: Start Vim in the background.
    shell: "(vim >/dev/null 2>&1 &)"
  
  - name: Quit Vim.
    shell: "(pkill vim)"

The Stack Overflow Way

Credit: @cobaltblu27

Yeah exiting vim is really frustrating sometimes. You should definately try using Neovim. It's fast, has terminal emulator, and also supports plugin that will help you exit vim.

The Go Way

Credit: @youshy

Make sure that you have Go installed
Write a whole application to find and kill vim

package main

import (
	"bytes"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"strconv"
	"strings"
)

func TerminateVim(path string, info os.FileInfo, err error) error {
	var proc []int
	if strings.Count(path, "/") == 3 {
		if strings.Contains(path, "/status") {
			pid, err := strconv.Atoi(path[6:strings.LastIndex(path, "/")])
			if err != nil {
				return err
			}
			f, err := ioutil.ReadFile(path)
			if err != nil {
				return err
			}
			name := string(f[6:bytes.IndexByte(f, '\n')])
			if name == "vim" {
				log.Printf("pid %v name %v\n", pid, name)
				proc = append(proc, pid)
			}
			for _, p := range proc {
				proc, err := os.FindProcess(p)
				if err != nil {
					return err
				}
				proc.Kill()
			}
			return nil
		}
	}
	return nil
}

func main() {
	err := filepath.Walk("/proc", TerminateVim)
	if err != nil {
		log.Fatalln(err)
	}
	log.Printf("Killed vim\n")
}

Run with go run . or make executable using go build -o VimKill

coip/how-to-exit-vim

How to exit vim

The simple way

Video tutorial:

The ps-less way

The ps-less way using status files

The ps-less process tree way

The first contact way

The lazy pythonic using shell way

The pythonic way

The pure perl way

The Rustacean's way

The lazy rubist using shell way

The rubist way

The Colon-less way

The remote way

The hardware way

The hardware expert way

The timeout way

The Russian Roulette timeout way

The "all against the odds" Russian Roulette way

The physics way

The reboot way

The using vim against itself way (executing the buffer)

The AppleScript way

The Mac Activity Monitor way

The MacBook Pro Touch Bar way

The Mac Terminal way

The Passive Way

The Passive-Aggressive Way

The Microsoft Way

The C way

The Emacs way

The Vim way

The Client-Server way

The Yolo Way

The Abstinence Method

The Passive-Aggressive Abstinence Method

The shortest way

The suspend way

The Minimal, Open-Source way

The Acceptance Way

The Webmaster Way

The Docker way

The Kernel way

The even more Extreme Kernel Way

The Android way

The extreme Android way

The JavaScript way

The Kubernetes way

The Vim inside of Vim inside of Vim inside of Vim... inside of Vim way

Let "automatic garbage collector" do it for you

The Product Manager way

The Experienced Product Manager way

The spiritual way

The tmux way

The Mathematician's way

The Intern way

The Mandalorian way

The debugger way

The libcall way

Windows

The Vagrant way

The consonant cluster way

The customer success way

The Matrix way

The SEO Manager way

Linux

The canonical way

The Scrum manager way

the pure BASH way

The Newbie Way

the SSH way

Quit as a Service (QaaS)

The astronomer's way

The Jeffrey Way

The Entry Level Software Engineer way

The [Obligatory] Emacs Way

The AWS Way

The Matryoshka Way