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 commands and insertion mode.
All existing key bindings will work in God mode. It's only there to reduce your usage of modifier keys.
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.
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-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
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 use the
god-mode-enable-function-key-translation variable, as follows:
(setq god-mode-enable-function-key-translation nil)
Also, you can add this to your
.xmodmap to rebind the caps lock key to the
remove Lock = Caps_Lock keysym Caps_Lock = Escape
xmodmap .xmodmap for the changes to take effect immediately.
dconf write /org/gnome/desktop/input-sources/xkb-options "['caps:escape']"
See this link for more details.
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)
You can pause or resume God mode depending on whether
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)
There is an optional feature for providing God mode behaviour in
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.
You can rebind
self-insert-command as you prefer. For example, here's a
mapping that calls
(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
(add-to-list 'god-exempt-major-modes 'dired-mode)
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
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-bindingscommand works well with Evil without additional customization. This is quite similar to Evil's
evil-execute-in-emacs-statecommand. All Evil bindings remain available when using
god-execute-with-current-bindings. For example, executing
god-execute-with-current-bindingsand 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
god-local-mode-map. For example, you can enable use of God mode in Normal state as follows:
(evil-make-intercept-map (evil-get-auxiliary-keymap god-local-mode-map 'god t t) 'normal)
Another option to use God mode with Evil is to use the
evil-god-statepackage, which provides a dedicated Evil state for using God mode. For running occasional, single commands through God mode, use the
evil-execute-in-god-statecommand. This works similar to
god-execute-with-current-bindings. For sustained use of God mode, use the
evil-god-stateis also useful for accessing default Emacs keybindings through God mode. However, a disadvantage of
evil-god-stateis that Evil's state-specific keybindings will not be available in God mode.