God Mode — no more RSI

NOTE: Emacs 25.1 is required for this package to work well.

This is a global minor mode for entering Emacs commands without modifier keys. It's similar to Vim's separation of command mode and insert mode.

All existing key bindings will work in God mode. It's only there to reduce your usage of modifier keys.

Example

In the example below, you can see how much effort is reduced:

Before: C-p C-k C-n M-^ ) C-j C-y M-r C-x z z M-2 M-f C-x C-s
After:    p   k   n g ^ )   j   y g r     . .   2 g f   x   s

(Regarding ., see the useful key bindings section.)

You'll find this mode surprisingly natural, as you would already know how to use your existing Emacs commands. Whenever you feel like it, you can explicitly use modifier keys too.

See the key mapping section for a complete walk-through of key translations.

Setup

You can load and activate God mode as follows:

(require 'god-mode)
(god-mode)

This will activate God mode in all future buffers. However, activation of God mode itself is buffer-local.

God mode can be toggled through god-local-mode using the escape key (ESC) as follows:

(global-set-key (kbd "<escape>") #'god-local-mode)

If you want to toggle God mode on all active and future buffers, use god-mode-all as follows:

(global-set-key (kbd "<escape>") #'god-mode-all)

If God mode is activated through god-mode or god-mode-all, you might want to ensure that no buffers are skipped, as follows:

(setq god-exempt-major-modes nil)
(setq god-exempt-predicates nil)

This means that magit-mode or dired-mode, for example, will also enter God mode when you activate it in all buffers. This means you can always reliably use God mode commands in any buffer.

When God mode is enabled, entering function keys will be translated to use appropriate key modifiers. For example, entering <f5> is translated to C-<f5>. To disable this translation, you can set the god-mode-enable-function-key-translation variable to nil before loading God mode, as follows:

(setq god-mode-enable-function-key-translation nil)
(require 'god-mode)

Also, you can add this to your .xmodmap to rebind the caps lock key to the escape key:

remove Lock = Caps_Lock
keysym Caps_Lock = Escape

And run xmodmap .xmodmap for the changes to take effect immediately.

Or use dconf:

dconf write /org/gnome/desktop/input-sources/xkb-options "['caps:escape']"

See this link for more details.

Key mapping

This package defines the following key mappings:

• All commands are assumed to use the control modifier (C-) unless otherwise indicated. Here are some examples:

  • x → C-x
  • f → C-f
  • x s → C-x C-s
  • x SPC s → C-x s

  Note the use of the space key (SPC) to produce C-x s.

• g is used to indicate the meta modifier (M-). This means that there is no way to enter C-g in God mode, and you must therefore type in C-g directly. This key can be changed through god-mode-alist. Here are some examples:

  • g x → M-x
  • g f → M-f

• G is used to indicate both the control and meta modifiers (C-M-). This key can also be changed through god-mode-alist. Here are some examples:

  • G x → C-M-x
  • G f → C-M-f

• Digit arguments can also be used:

  • 1 2 f → M-12 C-f

• If you use some of the useful key bindings, z or . can repeat the previous command:

  • g f . . → M-f M-f M-f

• Universal arguments can also be specified using u:

  • u c o → C-u C-c C-o

Cursor style to indicate mode

You can change the cursor style to indicate whether God mode is active as follows:

(defun my-god-mode-update-cursor ()
  (setq cursor-type (if (or god-local-mode buffer-read-only)
                        'box
                      'bar)))

(add-hook 'god-mode-enabled-hook #'my-god-mode-update-cursor)
(add-hook 'god-mode-disabled-hook #'my-god-mode-update-cursor)

Change modeline color

You can change the entire modeline's foreground and background to indicate whether God mode is active as follows:

(defun my-god-mode-update-modeline ()
  (let ((limited-colors-p (> 257 (length (defined-colors)))))
    (cond (god-local-mode (progn
                            (set-face-background 'mode-line (if limited-colors-p "white" "#e9e2cb"))
                            (set-face-background 'mode-line-inactive (if limited-colors-p "white" "#e9e2cb"))))
          (t (progn
               (set-face-background 'mode-line (if limited-colors-p "black" "#0a2832"))
               (set-face-background 'mode-line-inactive (if limited-colors-p "black" "#0a2832")))))))

(add-hook 'god-mode-enabled-hook #'my-god-mode-update-modeline)
(add-hook 'god-mode-disabled-hook #'my-god-mode-update-modeline)

overwrite-mode

You can pause or resume God mode depending on whether overwrite-mode is activated as follows:

(defun my-god-mode-toggle-on-overwrite ()
  "Toggle god-mode on overwrite-mode."
  (if (bound-and-true-p overwrite-mode)
      (god-local-mode-pause)
    (god-local-mode-resume)))

(add-hook 'overwrite-mode-hook #'my-god-mode-toggle-on-overwrite)

isearch integration

There is an optional feature for providing God mode behaviour in isearch. It allows you to hit ESC, for example, while in isearch to enable God mode. Here's a more complete example:

s h e y ESC s s s RET → C-s h e y C-s C-s C-s RET

You can load and activate this feature as follows:

(require 'god-mode-isearch)
(define-key isearch-mode-map (kbd "<escape>") #'god-mode-isearch-activate)
(define-key god-mode-isearch-map (kbd "<escape>") #'god-mode-isearch-disable)

You can also configure god-mode-isearch-map for additional keybindings.

Rebinding self-insert-command

You can rebind self-insert-command as you prefer. For example, here's a mapping that calls org-self-insert-command in org-mode:

(defun my-god-mode-self-insert ()
  (interactive)
  (if (and (bolp)
           (eq major-mode 'org-mode))
      (call-interactively 'org-self-insert-command)
    (call-interactively 'god-mode-self-insert)))

(define-key god-local-mode-map [remap self-insert-command] #'my-god-mode-self-insert)

Useful key bindings

The following key bindings are popular:

(define-key god-local-mode-map (kbd "z") #'repeat)
(define-key god-local-mode-map (kbd "i") #'god-local-mode)

Although I personally prefer:

(define-key god-local-mode-map (kbd ".") #'repeat)

These are also handy:

(global-set-key (kbd "C-x C-1") #'delete-other-windows)
(global-set-key (kbd "C-x C-2") #'split-window-below)
(global-set-key (kbd "C-x C-3") #'split-window-right)
(global-set-key (kbd "C-x C-0") #'delete-window)

So that you can run x 1, x 2, x 3, and x 0 in God mode.

Exempt major modes

NOTE: This is less necessary in recent versions of God mode, as it overrides all printable single byte keys and bindings in most major modes.

Sometimes, God mode is enabled in buffers where it makes no sense. In such cases, you can add the major mode to god-exempt-major-modes:

(add-to-list 'god-exempt-major-modes 'dired-mode)

Since dired-mode is already in the list, that's a no-op, but you get the idea. Consider opening an issue or pull request if you find a major mode that should be on the official list.

Another option to control the behavior of God mode in new buffers is to provide a function with no arguments that must return non-nil if God mode should be disabled in the current buffer. See the god-exempt-predicates variable and its default members god-exempt-mode-p, god-comint-mode-p, god-view-mode-p and god-special-mode-p for further details.

Usage with Evil

Evil is a popular Emacs package that provides modal editing in the style of Vi. While Evil doesn't always work well with God mode, there are a few simple customizations that enable them to be used together smoothly.

• For running occasional and single commands in God mode, the built-in god-execute-with-current-bindings command works well with Evil without additional customization. This is quite similar to Evil's evil-execute-in-emacs-state command. All Evil bindings remain available when using god-execute-with-current-bindings. For example, executing god-execute-with-current-bindings and entering v will execute evil-visual-block, which is bound to C-v in Evil's Normal state.

• For sustained usage of God mode, it's a bit trickier as keybindings in Evil states generally override God mode. For example, if God mode is activated in Normal state, entering v executes evil-visual-char, which is bound to v in Normal state, instead of executing evil-visual-block. A good option to use Evil's state-specific keybindings through God mode is to create an intercept keymap using evil-make-intercept-map and god-local-mode-map. For example, you can enable use of God mode in Normal state as follows:

  (with-eval-after-load 'god-mode
    (evil-make-intercept-map god-local-mode-map 'normal)
    (add-hook 'god-local-mode-hook 'evil-normalize-keymaps))
  

• Another option to use God mode with Evil is to use the evil-god-state package, which provides a dedicated Evil state for using God mode. For running occasional, single commands through God mode, use the evil-execute-in-god-state command. This works similar to god-execute-with-current-bindings. For sustained use of God mode, use the evil-god-state command. evil-god-state is also useful for accessing default Emacs keybindings through God mode. However, a disadvantage of evil-god-state is that Evil's state-specific keybindings will not be available in God mode.