diff --git a/core/core-autoinsert.el b/core/core-autoinsert.el
index 7ec904c3f..da78580b6 100644
--- a/core/core-autoinsert.el
+++ b/core/core-autoinsert.el
@@ -2,10 +2,9 @@
 
 (use-package autoinsert
   :after yasnippet
-  :init
+  :config
   (setq auto-insert-query nil  ; Don't prompt before insertion
         auto-insert-alist '()) ; Tabula rasa
-  :config
   (auto-insert-mode 1)
 
   (mapc (lambda (rule)
@@ -69,8 +68,8 @@
           ("\\.php$"                         "__"               php-mode)
 
           ;; Python
-          ;;"tests?/test_.+\\.py$"         "__"               nose-mode)
-          ;;"/setup\\.py$"                 "__setup.py"       python-mode)
+          ;;"tests?/test_.+\\.py$"         "__"                 nose-mode)
+          ;;"/setup\\.py$"                 "__setup.py"         python-mode)
           ("\\.py$"                          "__"               python-mode)
 
           ;; Ruby
diff --git a/core/core-company.el b/core/core-company.el
index 29a4687cb..497206e76 100644
--- a/core/core-company.el
+++ b/core/core-company.el
@@ -23,12 +23,12 @@
         evil-complete-previous-func 'narf/company-evil-complete-previous)
   (push 'company-sort-by-occurrence company-transformers)
 
-  (define-key company-active-map "\C-w" nil)
-
-  (global-company-mode +1))
+  (global-company-mode +1)
+  (define-key company-active-map "\C-w" nil))
 
 ;; NOTE: Doesn't look pretty outside of emacs-mac
 (use-package company-quickhelp
+  :when (featurep 'mac)
   :after company
   :config (company-quickhelp-mode +1))
 
diff --git a/core/core-defuns.el b/core/core-defuns.el
index 5df790520..5f2a28653 100644
--- a/core/core-defuns.el
+++ b/core/core-defuns.el
@@ -160,6 +160,12 @@ Examples:
 (after! evil
   (defalias 'ex! 'evil-ex-define-cmd)
 
+  (defmacro def-text-obj! (key inner-fn &optional outer-fn)
+    (unless outer-fn (setq outer-fn inner-fn))
+    `(progn
+       (define-key evil-inner-text-objects-map ,key ,inner-fn)
+       (define-key evil-outer-text-objects-map ,key ,outer-fn)))
+
   ;; Register keywords for proper indentation (see `map!')
   (put ':prefix      'lisp-indent-function 'defun)
   (put ':map         'lisp-indent-function 'defun)
diff --git a/core/core-editor.el b/core/core-editor.el
index a73ef65eb..7453e84f0 100644
--- a/core/core-editor.el
+++ b/core/core-editor.el
@@ -1,29 +1,32 @@
 ;;; core-editor.el
 
-(setq-default
- ;; spaces instead of tabs
- indent-tabs-mode nil
- tab-always-indent t
- tab-width 4
+(global-auto-revert-mode 1)    ; revert buffers for changed files
+;; Enable syntax highlighting for older emacs
+(unless (bound-and-true-p global-font-lock-mode)
+  (global-font-lock-mode t))
 
- require-final-newline t
+(setq-default
+ ;; Formatting
  delete-trailing-lines nil
  fill-column 80
+ indent-tabs-mode nil
  line-spacing 0
- word-wrap t
+ require-final-newline t
+ tab-always-indent t
+ tab-width 4
  truncate-lines t
  truncate-partial-width-windows 50
-
  visual-fill-column-center-text nil
-
- ;; Sane scroll settings
- scroll-margin 0
- scroll-conservatively 1001
- scroll-preserve-screen-position t
- hscroll-step 1
+ word-wrap t
+ ;; Scrolling
  hscroll-margin 1
-
+ hscroll-step 1
+ scroll-conservatively 1001
+ scroll-margin 0
+ scroll-preserve-screen-position t
+ ;; Regions
  shift-select-mode t
+ ;; Whitespace
  tabify-regexp "^\t* [ \t]+"
  whitespace-line-column fill-column
  whitespace-style '(face tabs tab-mark
@@ -71,22 +74,34 @@
       recentf-filename-handlers '(abbreviate-file-name))
 (recentf-mode 1)
 
+;; window config undo/redo
+(setq winner-dont-bind-my-keys t)
+(winner-mode 1)
+(add-hook! after-init
+  (setq winner-boring-buffers narf-ignore-buffers))
+
 ;; Let editorconfig handle global whitespace settings
-(use-package editorconfig
-  :config
-  (editorconfig-mode +1)
-  (associate! editorconfig-conf-mode :match "/\\.?editorconfig$")
-  ;; So whitespace in tabs indentation mode
+(use-package editorconfig :demand t
+  :mode ("\\.?editorconfig$" . editorconfig-conf-mode)
+  :config (editorconfig-mode +1)
+  ;; Show whitespace in tabs indentation mode
   (add-hook! 'editorconfig-custom-hooks
     (if indent-tabs-mode (whitespace-mode +1))))
 
 
 ;;
-;; Modes, hooks 'n hacks
+;; Hooks 'n hacks
 ;;
 
 (associate! makefile-gmake-mode :match "/Makefile$")
 (add-hook! special-mode (setq truncate-lines nil))
+;; If file is oversized...
+(add-hook! find-file
+  (when (> (buffer-size) 1048576)
+    (setq buffer-read-only t)
+    (buffer-disable-undo)
+    (fundamental-mode)
+    (visual-line-mode)))
 
 (defadvice delete-trailing-whitespace
     (around delete-trailing-whitespace-ignore-line activate)
@@ -100,16 +115,9 @@
                (string-match-p "^[\s\t]*$" linestr))
       (insert linestr))))
 
-;; If file is oversized...
-(add-hook! find-file
-  (when (> (buffer-size) 1048576)
-    (setq buffer-read-only t)
-    (buffer-disable-undo)
-    (fundamental-mode)
-    (visual-line-mode)))
-
-;; Smarter electric-indent (see `def-electric!')
-(electric-indent-mode -1) ; on by default
+;; Disable by default, please
+(electric-indent-mode -1)
+;; Smarter, keyword-based electric-indent (see `def-electric!')
 (defvar narf-electric-indent-p nil)
 (defvar-local narf-electric-indent-words '())
 (setq electric-indent-chars '(?\n ?\^?))
@@ -121,18 +129,6 @@
              (concat "\\<" (regexp-opt narf-electric-indent-words))))))
       electric-indent-functions)
 
-;;
-(global-auto-revert-mode 1)    ; revert buffers for changed files
-;; Enable syntax highlighting for older emacs
-(unless (bound-and-true-p global-font-lock-mode)
-  (global-font-lock-mode t))
-
-;; window config undo/redo
-(setq winner-dont-bind-my-keys t)
-(winner-mode 1)
-(add-hook! after-init
-  (setq winner-boring-buffers narf-ignore-buffers))
-
 
 ;;
 ;; Plugins
@@ -171,8 +167,7 @@
   :config (setq hs-isearch-open t)
   :init
   (advice-add 'evil-toggle-fold :before 'narf*load-hs-minor-mode)
-
-  ;; Prettify code folding in emacs ;;;;;;
+  ;; Prettify code folding in emacs
   (define-fringe-bitmap 'hs-marker [16 48 112 240 112 48 16] nil nil 'center)
   (defface hs-face '((t (:background "#ff8")))
     "Face to hightlight the ... area of hidden regions"
@@ -180,7 +175,6 @@
   (defface hs-fringe-face '((t (:foreground "#888")))
     "Face used to highlight the fringe on folded regions"
     :group 'hideshow)
-
   (setq hs-set-up-overlay
         (lambda (ov)
           (when (eq 'code (overlay-get ov 'hs))
@@ -201,7 +195,6 @@
   (setq imenu-list-mode-line-format nil
         imenu-list-position 'right
         imenu-list-size 32)
-
   (map! :map imenu-list-major-mode-map
         :n [escape] 'narf/imenu-list-quit
         :n "RET" 'imenu-list-goto-entry
@@ -210,17 +203,16 @@
 
 (use-package re-builder
   :commands (re-builder reb-mode-buffer-p)
-  :init
-  (add-hook 'reb-mode-hook 'narf|reb-cleanup)
-  (evil-set-initial-state 'reb-mode 'insert)
+  :init (add-hook 'reb-mode-hook 'narf|reb-cleanup)
   :config
+  (evil-set-initial-state 'reb-mode 'insert)
   (setq reb-re-syntax 'string)
   (map! :map rxt-help-mode-map
         :n [escape] 'kill-buffer-and-window
         :map reb-mode-map
-        :n "C-g"        'reb-quit
-        :n [escape]     'reb-quit
-        :n [backtab]    'reb-change-syntax))
+        :n "C-g" 'reb-quit
+        :n [escape] 'reb-quit
+        :n [backtab] 'reb-change-syntax))
 
 (use-package rotate-text
   :commands (rotate-text rotate-text-backward)
@@ -261,5 +253,82 @@
   (sp-with-modes '(xml-mode nxml-mode php-mode)
     (sp-local-pair "<!--" "-->"   :post-handlers '(("| " "SPC")))))
 
+
+;;
+;; Keybinding fixes
+;;
+
+;; This section is dedicated to bindings that "fix" certain keys so that they
+;; behave more like vim (or how I like it).
+
+;; Line-wise mouse selection on margin
+(global-set-key (kbd "<left-margin> <down-mouse-1>") 'narf/mouse-drag-line)
+(global-set-key (kbd "<left-margin> <mouse-1>")      'narf/mouse-select-line)
+(global-set-key (kbd "<left-margin> <drag-mouse-1>") 'narf/mouse-select-line)
+
+;; Restores "dumb" indentation to the tab key. This rustles a lot of peoples'
+;; jimmies, apparently, but it's how I like it.
+(map! :i "<tab>"     'narf/dumb-indent
+      :i "<backtab>" 'narf/dumb-dedent
+      :i "<C-tab>"   'indent-for-tab-command
+      ;; No dumb-tab for lisp
+      (:map lisp-mode-map        :i [remap narf/dumb-indent] 'indent-for-tab-command)
+      (:map emacs-lisp-mode-map  :i [remap narf/dumb-indent] 'indent-for-tab-command)
+      ;; Highjacks space/backspace to:
+      ;;   a) eat spaces on either side of the cursor, if present ( | ) -> (|)
+      ;;   b) allow backspace to delete space-indented blocks intelligently
+      ;;   c) but do none of this when inside a string
+      :i "SPC"                                  'narf/inflate-space-maybe
+      :i [remap backward-delete-char-untabify]  'narf/deflate-space-maybe
+      :i [remap newline]                        'narf/newline-and-indent
+      ;; Smarter move-to-beginning-of-line
+      :i [remap move-beginning-of-line]         'narf/move-to-bol
+      ;; Restore bash-esque keymaps in insert mode; C-w and C-a already exist
+      :i "C-e" 'narf/move-to-eol
+      :i "C-u" 'narf/backward-kill-to-bol-and-indent
+      ;; Fixes delete
+      :i "<kp-delete>" 'delete-char
+      ;; Fix osx keymappings and then some
+      :i "<M-left>"   'narf/move-to-bol
+      :i "<M-right>"  'narf/move-to-eol
+      :i "<M-up>"     'beginning-of-buffer
+      :i "<M-down>"   'end-of-buffer
+      :i "<C-up>"     'smart-up
+      :i "<C-down>"   'smart-down
+      ;; Fix emacs motion keys
+      :i "A-b"      'evil-backward-word-begin
+      :i "A-w"      'evil-forward-word-begin
+      :i "A-e"      'evil-forward-word-end
+      ;; Textmate-esque insert-line before/after
+      :i "<M-return>"    'evil-open-below
+      :i "<S-M-return>"  'evil-open-above
+      ;; insert lines in-place)
+      :n "<M-return>"    (λ! (save-excursion (evil-insert-newline-below)))
+      :n "<S-M-return>"  (λ! (save-excursion (evil-insert-newline-above)))
+      ;; Make ESC quit all the things
+      (:map (minibuffer-local-map
+             minibuffer-local-ns-map
+             minibuffer-local-completion-map
+             minibuffer-local-must-match-map
+             minibuffer-local-isearch-map)
+        [escape] 'abort-recursive-edit
+        "C-r" 'evil-paste-from-register)
+
+      (:map (evil-ex-search-keymap read-expression-map)
+        "C-w" 'backward-kill-word
+        "C-u" 'backward-kill-sentence
+        "C-b" 'backward-word)
+
+      (:map evil-ex-completion-map "C-a" 'move-beginning-of-line)
+
+      (:after view
+        (:map view-mode-map "<escape>" 'View-quit-all))
+
+      (:after help-mode
+        (:map help-map
+          ;; Remove slow/annoying help subsections
+          "h" nil
+          "g" nil)))
+
 (provide 'core-editor)
 ;;; core-editor.el ends here
diff --git a/core/core-eval.el b/core/core-eval.el
index 19062a0fb..e10ada30b 100644
--- a/core/core-eval.el
+++ b/core/core-eval.el
@@ -5,7 +5,7 @@
 ;; + Simple code navigation (using `dump-jump' and `imenu-list')
 ;; + A universal tags config (WIP)
 
-;; remove annoying ellipsis when printing sexp in message buffer
+;; remove ellipsis when printing sexp in message buffer
 (setq eval-expression-print-length nil
       eval-expression-print-level  nil)
 
@@ -17,19 +17,15 @@
              quickrun-compile-only
              quickrun-replace-region
              helm-quickrun)
-  :init
-  (add-hook 'quickrun/mode-hook 'linum-mode)
-  :config
-  (setq quickrun-focus-p nil)
-  (push '("\\.gvy$" . "groovy") quickrun-file-alist))
+  :init (add-hook 'quickrun/mode-hook 'linum-mode)
+  :config (setq quickrun-focus-p nil))
 
 (use-package repl-toggle
   :commands (rtog/toggle-repl rtog/add-repl)
   :init
-  (setq rtog/mode-repl-alist '())
-
   (defvar narf--repl-buffer nil)
   (defvar-local repl-p nil)
+  (setq rtog/mode-repl-alist '())
 
   (add-hook! repl-toggle-mode
     (evil-initialize-state 'emacs)
diff --git a/core/core-evil.el b/core/core-evil.el
index 6bb4ac6b1..976b157f1 100644
--- a/core/core-evil.el
+++ b/core/core-evil.el
@@ -2,16 +2,6 @@
 
 (use-package evil
   :init
-  ;; highlight matching delimiters where it's important
-  (defun show-paren-mode-off () (show-paren-mode -1))
-  (add-hook 'evil-insert-state-entry-hook    'show-paren-mode)
-  (add-hook 'evil-insert-state-exit-hook     'show-paren-mode-off)
-  (add-hook 'evil-visual-state-entry-hook    'show-paren-mode)
-  (add-hook 'evil-visual-state-exit-hook     'show-paren-mode-off)
-  (add-hook 'evil-operator-state-entry-hook  'show-paren-mode)
-  (add-hook 'evil-operator-state-exit-hook   'show-paren-mode-off)
-  (add-hook 'evil-normal-state-entry-hook    'show-paren-mode-off)
-
   ;; Disable highlights on insert-mode
   (add-hook 'evil-insert-state-entry-hook 'evil-ex-nohighlight)
   (setq evil-magic t
@@ -43,49 +33,59 @@
         ;; https://bitbucket.org/lyro/evil/issues/594/undo-doesnt-behave-like-vim
         evil-want-fine-undo (if (> emacs-major-version 24) 'fine))
 
+  ;; highlight matching delimiters where it's important
+  (defun show-paren-mode-off () (show-paren-mode -1))
+  (add-hook 'evil-insert-state-entry-hook   'show-paren-mode)
+  (add-hook 'evil-insert-state-exit-hook    'show-paren-mode-off)
+  (add-hook 'evil-visual-state-entry-hook   'show-paren-mode)
+  (add-hook 'evil-visual-state-exit-hook    'show-paren-mode-off)
+  (add-hook 'evil-operator-state-entry-hook 'show-paren-mode)
+  (add-hook 'evil-operator-state-exit-hook  'show-paren-mode-off)
+  (add-hook 'evil-normal-state-entry-hook   'show-paren-mode-off)
+
   :config
   (evil-mode 1)
   (evil-select-search-module 'evil-search-module 'evil-search)
+  (mapc (lambda (r) (evil-set-initial-state (car r) (cdr r)))
+        '((compilation-mode       . normal)
+          (help-mode              . normal)
+          (message-mode           . normal)
+          (debugger-mode          . normal)
+          (image-mode             . normal)
+          (doc-view-mode          . normal)
+          (tabulated-list-mode    . emacs)
+          (profile-report-mode    . emacs)
+          (Info-mode              . emacs)
+          (view-mode              . emacs)
+          (comint-mode            . emacs)
+          (cider-repl-mode        . emacs)
+          (term-mode              . emacs)
+          (calendar-mode          . emacs)
+          (Man-mode               . emacs)
+          (grep-mode              . emacs)))
 
   (map! :map evil-command-window-mode-map :n [escape] 'kill-buffer-and-window)
 
-  ;; modes to map to different default states
-  (dolist (mode-map '((compilation-mode       . normal)
-                      (help-mode              . normal)
-                      (message-mode           . normal)
-                      (debugger-mode          . normal)
-                      (image-mode             . normal)
-                      (doc-view-mode          . normal)
-                      (tabulated-list-mode    . emacs)
-                      (profile-report-mode    . emacs)
-                      (Info-mode              . emacs)
-                      (view-mode              . emacs)
-                      (comint-mode            . emacs)
-                      (cider-repl-mode        . emacs)
-                      (term-mode              . emacs)
-                      (calendar-mode          . emacs)
-                      (Man-mode               . emacs)
-                      (grep-mode              . emacs)))
-    (evil-set-initial-state `,(car mode-map) `,(cdr mode-map)))
-
   (progn ; evil hacks
     (advice-add 'evil-force-normal-state :after 'narf*evil-esc-quit)
     (defun narf*evil-esc-quit ()
       "Close popups, disable search highlights and quit the minibuffer if open."
-      (let ((minib-p (minibuffer-window-active-p (minibuffer-window)))
-            (evil-hl-p (evil-ex-hl-active-p 'evil-ex-search)))
-        (when minib-p (abort-recursive-edit))
-        (when evil-hl-p (evil-ex-nohighlight))
-        ;; Close non-repl popups and clean up `narf-popup-windows'
-        (unless (or minib-p evil-hl-p
-                    (memq (get-buffer-window) narf-popup-windows))
-          (mapc (lambda (w)
-                  (if (window-live-p w)
-                      (with-selected-window w
-                        (unless (derived-mode-p 'comint-mode)
-                          (narf/popup-close w)))
-                    (narf/popup-remove w)))
-                narf-popup-windows))))
+      (if (eq major-mode 'help-mode)
+          (narf/popup-close)
+        (let ((minib-p (minibuffer-window-active-p (minibuffer-window)))
+              (evil-hl-p (evil-ex-hl-active-p 'evil-ex-search)))
+          (when minib-p (abort-recursive-edit))
+          (when evil-hl-p (evil-ex-nohighlight))
+          ;; Close non-repl popups and clean up `narf-popup-windows'
+          (unless (or minib-p evil-hl-p
+                      (memq (get-buffer-window) narf-popup-windows))
+            (mapc (lambda (w)
+                    (if (window-live-p w)
+                        (with-selected-window w
+                          (unless (derived-mode-p 'comint-mode)
+                            (narf/popup-close w)))
+                      (narf/popup-remove w)))
+                  narf-popup-windows)))))
 
     ;; Fix harmless (yet disruptive) error reporting w/ hidden buffers caused by
     ;; workgroups killing windows
@@ -168,50 +168,21 @@
           ;; Clean up
           (setq file-name (replace-regexp-in-string regexp "\\1" file-name t)))))
 
-  ;; Make :g[lobal] highlight matches
-  ;; TODO Redo this mess
-  (defvar narf-buffer-match-global evil-ex-substitute-global "")
-  (defun narf--ex-buffer-match (flag &optional arg)
-    (let ((hl-name 'evil-ex-buffer-match))
-      (with-selected-window (minibuffer-selected-window)
-        (narf/-ex-match-init hl-name)
-        (narf/-ex-buffer-match arg hl-name (list (if narf-buffer-match-global ?g))))))
-  (defun narf--ex-global-match (flag &optional arg)
-    (let ((hl-name 'evil-ex-global-match))
-      (with-selected-window (minibuffer-selected-window)
-        (narf/-ex-match-init hl-name)
-        (let ((result (car-safe (evil-ex-parse-global arg))))
-          (narf/-ex-buffer-match result hl-name nil (point-min) (point-max))))))
-
-  (evil-ex-define-argument-type buffer-match :runner narf--ex-buffer-match)
-  (evil-ex-define-argument-type global-match :runner narf--ex-global-match)
+  ;; Extra argument types for highlight buffer (or global) regexp matches
+  (evil-ex-define-argument-type buffer-match :runner narf/evil-ex-buffer-match)
+  (evil-ex-define-argument-type global-match :runner narf/evil-ex-global-match)
 
   (evil-define-interactive-code "<//>"
     :ex-arg buffer-match
     (list (when (evil-ex-p) evil-ex-argument)))
   (evil-define-interactive-code "<g//>"
     :ex-arg global-match
-    (when (evil-ex-p) (evil-ex-parse-global evil-ex-argument)))
-
-  (evil-define-operator narf:align (&optional beg end bang pattern)
-    "Ex interface to `align-regexp'. Accepts vim-style regexps."
-    (interactive "<r><!><//>")
-    (align-regexp
-     beg end
-     (concat "\\(\\s-*\\)"
-             (if bang
-                 (regexp-quote pattern)
-               (evil-transform-vim-style-regexp pattern)))
-     1 1))
-
-  (evil-define-operator narf:evil-ex-global (beg end pattern command &optional invert)
-    :motion mark-whole-buffer
-    :move-point nil
-    (interactive "<r><g//><!>")
-    (evil-ex-global beg end pattern command invert))
-  (evil-ex-define-cmd "g[lobal]" 'narf:evil-ex-global))
+    (when (evil-ex-p) (evil-ex-parse-global evil-ex-argument))))
 
 ;; evil plugins
+(use-package evil-numbers
+  :commands (evil-numbers/inc-at-pt evil-numbers/dec-at-pt))
+
 (use-package evil-anzu
   :config
   (setq anzu-cons-mode-line-p nil
@@ -220,9 +191,7 @@
 
 (use-package evil-args
   :commands (evil-inner-arg evil-outer-arg evil-forward-arg evil-backward-arg evil-jump-out-args)
-  :init
-  (define-key evil-inner-text-objects-map "a" #'evil-inner-arg)
-  (define-key evil-outer-text-objects-map "a" #'evil-outer-arg))
+  :init (def-text-obj! "a" 'evil-inner-arg 'evil-outer-arg))
 
 (use-package evil-commentary
   :commands (evil-commentary evil-commentary-yank evil-commentary-line)
@@ -230,8 +199,7 @@
 
 (use-package evil-exchange
   :commands evil-exchange
-  :config
-  (advice-add 'evil-force-normal-state :after 'narf*evil-exchange-off))
+  :config (advice-add 'evil-force-normal-state :after 'narf*evil-exchange-off))
 
 (use-package evil-multiedit
   :commands (evil-multiedit-match-all
@@ -242,20 +210,14 @@
              evil-multiedit-prev
              evil-multiedit-abort
              evil-multiedit-ex-match)
-  :init
-  (map! :v  "R"     'evil-multiedit-match-all
-        :n  "M-C-D" 'evil-multiedit-restore
-        :nv "M-d"   'evil-multiedit-match-and-next
-        :nv "M-D"   'evil-multiedit-match-and-prev)
   :config
-  (map! (:map evil-multiedit-state-map
-          "RET" 'evil-multiedit-toggle-or-restrict-region
-          "C-n" 'evil-multiedit-next
-          "C-p" 'evil-multiedit-prev
-          :v "RET" 'evil-multiedit-toggle-or-restrict-region)
-        (:map evil-multiedit-insert-state-map
-          "C-n" 'evil-multiedit-next
-          "C-p" 'evil-multiedit-prev)))
+  (map! :map evil-multiedit-state-map
+        "RET" 'evil-multiedit-toggle-or-restrict-region
+        "C-n" 'evil-multiedit-next
+        "C-p" 'evil-multiedit-prev
+        :map evil-multiedit-insert-state-map
+        "C-n" 'evil-multiedit-next
+        "C-p" 'evil-multiedit-prev))
 
 (use-package evil-indent-plus
   :commands (evil-indent-plus-i-indent
@@ -265,31 +227,18 @@
              evil-indent-plus-i-indent-up-down
              evil-indent-plus-a-indent-up-down)
   :init
-  (map! :map evil-inner-text-objects-map
-        "i" 'evil-indent-plus-i-indent
-        "I" 'evil-indent-plus-i-indent-up
-        "J" 'evil-indent-plus-i-indent-up-down
-        :map evil-outer-text-objects-map
-        "i" 'evil-indent-plus-a-indent
-        "I" 'evil-indent-plus-a-indent-up
-        "J" 'evil-indent-plus-a-indent-up-down))
+  (def-text-obj! "i" 'evil-indent-plus-i-indent 'evil-indent-plus-a-indent)
+  (def-text-obj! "I" 'evil-indent-plus-i-indent-up 'evil-indent-plus-a-indent-up)
+  (def-text-obj! "J" 'evil-indent-plus-i-indent-up-down 'evil-indent-plus-a-indent-up-down))
 
 (use-package evil-matchit
   :commands (evilmi-jump-items evilmi-text-object global-evil-matchit-mode)
   :config (global-evil-matchit-mode 1)
-  :init
-  (map! :n "%" 'evilmi-jump-items
-        :map evil-inner-text-objects-map "%" 'evilmi-text-object
-        :map evil-outer-text-objects-map "%" 'evilmi-text-object))
-
-(use-package evil-numbers
-  :commands (evil-numbers/inc-at-pt evil-numbers/dec-at-pt))
+  :init (def-text-obj! "%" 'evilmi-text-object))
 
 (use-package evil-textobj-anyblock
   :commands (evil-textobj-anyblock-inner-block evil-textobj-anyblock-a-block)
-  :init
-  (map! :map evil-inner-text-objects-map "B" 'evil-textobj-anyblock-inner-block
-        :map evil-outer-text-objects-map "B" 'evil-textobj-anyblock-a-block))
+  :init (def-text-obj! "B" 'evil-textobj-anyblock-inner-block 'evil-textobj-anyblock-a-block))
 
 (use-package evil-search-highlight-persist
   :config
@@ -334,7 +283,6 @@
   :config
   (evil-snipe-mode 1)
   (evil-snipe-override-mode 1)
-
   (define-key evil-snipe-parent-transient-map (kbd "C-;") 'narf/evil-snipe-easymotion))
 
 (use-package evil-surround
diff --git a/core/core-helm.el b/core/core-helm.el
index 063fee258..afde4ea64 100644
--- a/core/core-helm.el
+++ b/core/core-helm.el
@@ -7,7 +7,6 @@
   (defvar helm-global-prompt "››› ")
   (setq-default
    helm-quick-update t
-
    ;; Speedier without fuzzy matching
    helm-mode-fuzzy-match nil
    helm-buffers-fuzzy-matching nil
@@ -15,58 +14,39 @@
    helm-M-x-fuzzy-match nil
    helm-recentf-fuzzy-match nil
    helm-projectile-fuzzy-match nil
-
+   ;; Display extraineous helm UI elements
    helm-display-header-line nil
    helm-ff-auto-update-initial-value nil
    helm-find-files-doc-header nil
-   helm-move-to-line-cycle-in-source t
-
    ;; Don't override evil-ex's completion
    helm-mode-handle-completion-in-region nil
-   helm-candidate-number-limit 50)
+   helm-candidate-number-limit 50
+   ;; Don't wrap item cycling
+   helm-move-to-line-cycle-in-source t)
+
+  (defvar helm-projectile-find-file-map (make-sparse-keymap))
 
   :config
-  (map! (:map (helm-map helm-projectile-find-file-map)
-          :e "ESC"        nil
-          :e "/"          nil
-          :e "M-v"        'clipboard-yank
-          :e "C-w"        'backward-kill-word
-          :e "C-r"        'evil-paste-from-register ; Evil registers in helm! Glorious!
-          :e "C-b"        'backward-word
-          :e "<left>"     'backward-char
-          :e "<right>"    'forward-char
-          :e "<escape>"   'helm-keyboard-quit
-          :e [escape]     'helm-keyboard-quit
-          :e "<tab>"      'helm-execute-persistent-action)
-        (:map (helm-generic-files-map helm-projectile-find-file-map)
-          :e "ESC"        'helm-keyboard-quit)
-        (:map helm-ag-map
-          :e "<backtab>"  'helm-ag-edit)
-        (:after helm-ag
-          (:map helm-ag-edit-map
-            "<escape>"   'helm-ag--edit-abort
-            :n "zx"      'helm-ag--edit-abort))
-        (:map helm-map
-          "C-S-n"      'helm-next-source
-          "C-S-p"      'helm-previous-source
-          "C-u"        'helm-delete-minibuffer-contents))
+  (set-keymap-parent helm-projectile-find-file-map helm-map)
+  (map! :map helm-map
+        "C-S-n"      'helm-next-source
+        "C-S-p"      'helm-previous-source
+        "C-u"        'helm-delete-minibuffer-contents
+        "C-w"        'backward-kill-word
+        "M-v"        'clipboard-yank
+        "C-r"        'evil-paste-from-register ; Evil registers in helm! Glorious!
+        "C-b"        'backward-word
+        "<left>"     'backward-char
+        "<right>"    'forward-char
+        "<escape>"   'helm-keyboard-quit
+        "ESC"        'helm-keyboard-quit
+        [escape]     'helm-keyboard-quit
+        "<tab>"      'helm-execute-persistent-action
+        :map helm-generic-files-map
+        :e "ESC"     'helm-keyboard-quit)
 
   ;;; Helm hacks
   (defvar narf-helm-header-fg (face-attribute 'helm-source-header :foreground) "docstring")
-  (defun narf*helm-hide-source-header-maybe ()
-    (if (<= (length helm-sources) 1)
-        (set-face-attribute 'helm-source-header nil :height 0.1 :foreground "#111111")
-      (set-face-attribute 'helm-source-header nil :height 1.0 :foreground narf-helm-header-fg)))
-
-  (defun narf*helm-hide-header (source &optional force)
-    (setq header-line-format nil)
-    (narf|hide-mode-line))
-
-  (defun narf*helm-replace-prompt (plist)
-    (if (keywordp (car plist))
-        (setq plist (plist-put plist :prompt helm-global-prompt))
-      (setcar (nthcdr 2 plist) helm-global-prompt))
-    plist)
 
   ;; Shrink source headers if there is only one source
   (add-hook 'helm-after-initialize-hook 'narf*helm-hide-source-header-maybe)
@@ -74,7 +54,6 @@
   (advice-add 'helm :filter-args 'narf*helm-replace-prompt)
   ;; Hide mode-line in helm windows
   (advice-add 'helm-display-mode-line :override 'narf*helm-hide-header)
-  ;; (advice-add 'helm-display-mode-line :override 'narf*helm-hide-header)
 
   (after! yasnippet (push 'helm-alive-p yas-dont-activate)))
 
@@ -115,8 +94,7 @@
   (map! :map helm-find-files-map
         "C-w" 'helm-find-files-up-one-level
         "TAB" 'helm-execute-persistent-action)
-
-  (mapc (lambda (r) (add-to-list 'helm-boring-file-regexp-list r))
+  (mapc (lambda (r) (push r helm-boring-file-regexp-list))
         (list "\\.projects$" "\\.DS_Store$")))
 
 (use-package helm-ag
@@ -129,7 +107,13 @@
              helm-ag-project-root
              helm-ag-pop-stack
              helm-ag-buffers
-             helm-ag-clear-stack))
+             helm-ag-clear-stack)
+  :config
+  (map! :map helm-ag-map
+        "<backtab>"  'helm-ag-edit
+        :map helm-ag-edit-map
+        "<escape>"   'helm-ag--edit-abort
+        :n "zx"      'helm-ag--edit-abort))
 
 (use-package helm-css-scss ; https://github.com/ShingoFukuyama/helm-css-scss
   :commands (helm-css-scss
diff --git a/core/core-popup.el b/core/core-popup.el
index cfcbbd472..e21d014ab 100644
--- a/core/core-popup.el
+++ b/core/core-popup.el
@@ -11,48 +11,49 @@
   (shackle-mode 1)
   (setq shackle-rules
         '(;; Debuggers
-          ("\\`\\*\\(g\\|zsh\\|bash\\)db.*?\\*\\'" :regexp t :align below :size 20)
-          ("\\`\\*trepanjs.*?\\*\\'" :regexp t :align below :size 20)
-          ("\\`\\*\\(debug:\\)haskell\\*\\'" :regexp t :align below :size 20)
+          ("\\`\\*\\(g\\|zsh\\|bash\\)db.*?\\*\\'" :align below :size 20 :regexp t)
+          ("\\`\\*trepanjs.*?\\*\\'"               :align below :size 20 :regexp t)
+          ("\\`\\*\\(debug:\\)haskell\\*\\'"       :align below :size 20 :regexp t)
 
           ;; Plugins
-          ("\\` ?\\*[hH]elm.*?\\*\\'" :regexp t :align below  :size 20 :select t)
-          (" ?\\*Flycheck.+\\*"       :regexp t :align below  :size 15  :noselect t)
-          ("*helm bookmarks*"                :align below  :size 7 :select t)
-          (" *NeoTree*"                      :align left             :select t)
-          ("*evil-registers*"                :align below  :size 0.3)
-          ("*quickrun*"                      :align below  :size 10)
-          ("*nosetests*"                     :align below  :size 0.4 :noselect t)
-          ("*esup*"                          :align below  :size 30 :noselect t)
-          ("*ert*"                           :align below  :size 20 :noselect t)
+          ("\\` ?\\*[hH]elm.*?\\*\\'" :align below :size 20  :select t   :regexp t)
+          (" ?\\*Flycheck.+\\*"       :align below :size 15  :noselect t :regexp t)
+          ("*helm bookmarks*"         :align below :size 7   :select t)
+          (" *NeoTree*"               :align left            :select t)
+          ("*evil-registers*"         :align below :size 0.3)
+          ("*quickrun*"               :align below :size 10)
+          ("*nosetests*"              :align below :size 0.4 :noselect t)
+          ("*esup*"                   :align below :size 30  :noselect t)
+          ("*ert*"                    :align below :size 20  :noselect t)
           ;; vcs
-          ("^\\*git-gutter.+\\*$"  :regexp t :align below  :size 0.4 :noselect t)
-          ("*vc-diff*"                       :align below  :size 0.4 :noselect t)
-          ("*vc-change-log*"                 :align below            :select t)
-          (vc-annotate-mode                  :same t)
+          ("^\\*git-gutter.+\\*$"     :align below :size 0.4 :noselect t :regexp t)
+          ("*vc-diff*"                :align below :size 0.4 :noselect t)
+          ("*vc-change-log*"          :align below           :select t)
+          (vc-annotate-mode           :same t)
           ;; Util
-          ("*Apropos*"                       :align below  :size 0.3)
-          ("*minor-modes*"                   :align below  :size 0.5 :noselect t)
+          ("*Apropos*"                :align below :size 0.3)
+          ("*minor-modes*"            :align below :size 0.5 :noselect t)
 
           ;; Org
-          ("^\\*Org Src .+\\*$"    :regexp t :align below  :size 0.4 :select t)
-          ("^\\*Org-Babel.*\\*$"   :regexp t :align below  :size 0.4)
-          ("^\\*Org Agenda.+"      :regexp t :align below  :size 0.4)
-          ("*Calendar*"                      :align below  :size 0.4)
-          (" *Agenda Commands*"              :align below  :size 30)
-          (" *Org todo*"                     :align below  :size 5   :noselect t)
-          ("*Org Links*"                     :align below  :size 5)
+          ("^\\*Org Src .+\\*$"       :align below :size 0.4 :select t :regexp t)
+          ("^\\*Org-Babel.*\\*$"      :align below :size 0.4 :regexp t)
+          ("^\\*Org Agenda.+"         :align below :size 0.4 :regexp t)
+          ("*Calendar*"               :align below :size 0.4)
+          (" *Agenda Commands*"       :align below :size 30)
+          (" *Org todo*"              :align below :size 5   :noselect t)
+          ("*Org Links*"              :align below :size 5)
 
           ;; Emacs
-          ("^\\*.+-Profiler-Report .+\\*$" :regexp t :align below :size 0.3)
-          ("*processing-compilation*" :align below :size 10 :noselect t)
-          ("*Backtrace*" :align below :size 0.25 :noselect t)
-          ("*scratch*"   :align below :size 0.3  :select t)
-          ("*Help*"      :align below :size 21 :select t)
-          ("*Messages*"  :align below :size 20 :select t)
-          ("*Completions*" :align below :size 20 :noselect t)
-          (debugger-mode :align below :size 0.25 :noselect t)
-          (compilation-mode :noselect t)
+          ("^\\*.+-Profiler-Report .+\\*$" :align below :size 0.3 :regexp t)
+          ("*processing-compilation*"  :align below :size 10   :noselect t)
+          ("*Backtrace*"               :align below :size 0.25 :noselect t)
+          ("*scratch*"                 :align below :size 0.3  :select t)
+          ("*Help*"                    :align below :size 16   :select t)
+          ("*Messages*"                :align below :size 15   :select t)
+          ("*Warnings*"                :align below :size 10   :noselect t)
+          ("*Completions*"             :align below :size 20   :noselect t)
+          (debugger-mode               :align below :size 0.25 :noselect t)
+          (compilation-mode                                    :noselect t)
 
           ;; Custom + REPLs
           ("*eval*" :align below :size 12)
diff --git a/core/core-vcs.el b/core/core-vcs.el
index 09a61a7ad..63f2afd3b 100644
--- a/core/core-vcs.el
+++ b/core/core-vcs.el
@@ -27,9 +27,8 @@
     [0 0 0 0 0 0 0 0 0 0 0 0 0 128 192 224 240 248]
     nil nil 'center)
 
-  ;; Refresh git-gutter on ESC in normal mode
+  ;; Refreshing git-gutter
   (advice-add 'evil-force-normal-state :after 'git-gutter)
-
   (add-hook 'focus-in-hook 'git-gutter:update-all-windows)
 
   (defalias 'narf/vcs-next-hunk    'git-gutter:next-hunk)
@@ -39,7 +38,7 @@
   (defalias 'narf/vcs-revert-hunk  'git-gutter:revert-hunk))
 
 (after! vc-annotate
-  (evil-set-initial-state 'vc-annotate-mode 'normal)
+  (evil-set-initial-state 'vc-annotate-mode     'normal)
   (evil-set-initial-state 'vc-git-log-view-mode 'normal)
   (map! :map vc-annotate-mode-map
         :n "q" 'kill-this-buffer
@@ -52,26 +51,7 @@
         :n "RET" 'vc-annotate-find-revision-at-line))
 
 (use-package browse-at-remote
-  :commands (browse-at-remote/browse browse-at-remote/to-clipboard)
-  :init
-  (evil-define-command narf:git-remote-browse (&optional bang)
-    "Open the website for the current (or specified) version controlled FILE. If BANG,
-then use hub to do it."
-    (interactive "<!>")
-    (let (url)
-      (condition-case err
-          (setq url (browse-at-remote/get-url))
-        (error
-         (setq url (shell-command-to-string "hub browse -u --"))
-         (setq url (if url
-                       (concat (s-trim url) "/" (f-relative (buffer-file-name) (narf/project-root))
-                               (when (use-region-p) (format "#L%s-L%s"
-                                                            (line-number-at-pos (region-beginning))
-                                                            (line-number-at-pos (region-end)))))))))
-      (when url
-        (if bang
-            (message "Url copied to clipboard: %s" (kill-new url))
-          (browse-url url))))))
+  :commands (browse-at-remote/browse browse-at-remote/to-clipboard))
 
 (provide 'core-vcs)
 ;;; core-vcs.el ends here
diff --git a/core/core-workgroups.el b/core/core-workgroups.el
index 4a4c2bab3..c935deb9b 100644
--- a/core/core-workgroups.el
+++ b/core/core-workgroups.el
@@ -16,6 +16,7 @@ automatically renamed to the project name.")
 (use-package workgroups2
   :when (display-graphic-p)
   :init
+  (add-hook 'emacs-startup-hook 'workgroups-mode)
   (setq-default
    wg-session-file (concat narf-temp-dir "/workgroups/last")
    wg-workgroup-directory (concat narf-temp-dir "/workgroups/")
@@ -44,7 +45,6 @@ automatically renamed to the project name.")
    wg-list-display-decor-previous-left ""
    wg-list-display-decor-previous-right "")
 
-  (add-hook 'emacs-startup-hook 'workgroups-mode)
   :config
   ;; Remember fixed workgroup names between sessions
   (push 'narf-wg-names savehist-additional-variables)
diff --git a/core/core-yasnippet.el b/core/core-yasnippet.el
index 77b829492..1604fb4c1 100644
--- a/core/core-yasnippet.el
+++ b/core/core-yasnippet.el
@@ -9,6 +9,7 @@
              yas-new-snippet
              yas-visit-snippet-file)
   :init
+  (defvar yas-minor-mode-map (make-sparse-keymap))
   (setq yas-verbosity 0
         yas-indent-line 'auto
         yas-also-auto-indent-first-line t
@@ -17,62 +18,35 @@
         yas-snippet-dirs narf-snippet-dirs
         yas-prompt-functions '(yas-ido-prompt yas-no-prompt))
 
-  (map! :i [(tab)] 'yas-expand
-        :v "<backtab>" 'narf/yas-insert-snippet)
-
   (add-hook! (text-mode prog-mode snippet-mode markdown-mode org-mode)
     'yas-minor-mode-on)
 
-  (defvar yas-minor-mode-map
-    (let ((map (make-sparse-keymap)))
-      (evil-define-key 'insert map [(tab)] 'yas-expand)
-      (evil-define-key 'visual map (kbd "<backtab>") 'narf/yas-insert-snippet)
-      map))
-
   :config
   (yas-reload-all)
+  (map! :map yas-keymap
+        "C-e"           'narf/yas-goto-end-of-field
+        "C-a"           'narf/yas-goto-start-of-field
+        "<M-right>"     'narf/yas-goto-end-of-field
+        "<M-left>"      'narf/yas-goto-start-of-field
+        "<S-tab>"       'yas-prev-field
+        "<M-backspace>" 'narf/yas-clear-to-sof
+        "<escape>"      'evil-normal-state
+        [backspace]     'narf/yas-backspace
+        "<delete>"      'narf/yas-delete)
 
-  (associate! snippet-mode :match "emacs\\.d/private/\\(snippets\\|templates\\)/.+$")
-
-  (map! :i [(tab)] nil
-        :v "<backtab>" nil
-
-        (:map yas-keymap
-          "C-e"           'narf/yas-goto-end-of-field
-          "C-a"           'narf/yas-goto-start-of-field
-          "<M-right>"     'narf/yas-goto-end-of-field
-          "<M-left>"      'narf/yas-goto-start-of-field
-          "<S-tab>"       'yas-prev-field
-          "<M-backspace>" 'narf/yas-clear-to-sof
-
-          "<escape>"      'evil-normal-state
-          [backspace]     'narf/yas-backspace
-          "<delete>"      'narf/yas-delete))
-
-  ;; Prevents evil's visual-line from gobbling up the newline on the right due
-  ;; to an off-by-one issue.
-  (defadvice yas-expand-snippet (around yas-expand-snippet-visual-line activate)
-    (when (narf/evil-visual-line-state-p)
-      (ad-set-arg 2 (1- (ad-get-arg 2)))) ad-do-it)
-
+  ;; Exit snippets on ESC in normal mode
+  (advice-add 'evil-force-normal-state :before 'yas-exit-all-snippets)
+  ;; Fix an issue with smartparens interfering with yasnippet keybindings
+  (advice-add 'yas-expand :before 'sp-remove-active-pair-overlay)
   ;; Once you're in normal mode, you're out
   (add-hook 'evil-normal-state-entry-hook 'yas-abort-snippet)
   ;; Strip out whitespace before a line selection
   (add-hook 'yas-before-expand-snippet-hook 'narf|yas-before-expand)
   ;; Fix previous hook persisting yas-selected-text between expansions
-  (add-hook 'yas-after-exit-snippet-hook 'narf|yas-after-expand)
-
-  ;; Exit snippets on ESC in normal mode
-  (advice-add 'evil-force-normal-state :before 'yas-exit-all-snippets)
-
-  ;; Fix an issue with smartparens interfering with yasnippet keybindings
-  (advice-add 'yas-expand :before 'sp-remove-active-pair-overlay))
+  (add-hook 'yas-after-exit-snippet-hook 'narf|yas-after-expand))
 
 (use-package auto-yasnippet
   :commands (aya-create aya-expand aya-open-line aya-persist-snippet)
-  :init
-  (map! :i  "<C-tab>" 'aya-expand
-        :nv "<C-tab>" 'aya-create)
   :config
   (setq aya-persist-snippets-dir (concat narf-private-dir "auto-snippets/")))
 
diff --git a/core/defuns/defuns-evil.el b/core/defuns/defuns-evil.el
index a82abea2b..6797725db 100644
--- a/core/defuns/defuns-evil.el
+++ b/core/defuns/defuns-evil.el
@@ -57,8 +57,8 @@
                            (or macro (read-char "@-"))))))
 
 ;;; Custom argument handlers
-;;;###autoload
-(defun narf/-ex-match-init (name &optional face update-hook)
+(defvar narf-buffer-match-global evil-ex-substitute-global "")
+(defun narf--evil-ex-match-init (name &optional face update-hook)
   (with-current-buffer evil-ex-current-buffer
     (cond
      ((eq flag 'start)
@@ -70,8 +70,7 @@
      ((eq flag 'stop)
       (evil-ex-delete-hl name)))))
 
-;;;###autoload
-(defun narf/-ex-buffer-match (arg &optional hl-name flags beg end)
+(defun narf--evil-ex-buffer-match (arg &optional hl-name flags beg end)
   (when (and (eq flag 'update)
              evil-ex-substitute-highlight-all
              (not (zerop (length arg))))
@@ -94,6 +93,21 @@
       (user-error
        (evil-ex-pattern-update-ex-info nil (format "?%s" lossage))))))
 
+;;;###autoload
+(defun narf/evil-ex-buffer-match (flag &optional arg)
+  (let ((hl-name 'evil-ex-buffer-match))
+    (with-selected-window (minibuffer-selected-window)
+      (narf--evil-ex-match-init hl-name)
+      (narf--evil-ex-buffer-match arg hl-name (list (if narf-buffer-match-global ?g))))))
+
+;;;###autoload
+(defun narf/evil-ex-global-match (flag &optional arg)
+  (let ((hl-name 'evil-ex-global-match))
+    (with-selected-window (minibuffer-selected-window)
+      (narf--evil-ex-match-init hl-name)
+      (let ((result (car-safe (evil-ex-parse-global arg))))
+        (narf--evil-ex-buffer-match result hl-name nil (point-min) (point-max))))))
+
 ;;;###autoload
 (defun narf/evil-ex-undefine-cmd (cmd)
   (if (string-match "^[^][]*\\(\\[\\(.*\\)\\]\\)[^][]*$" cmd)
diff --git a/core/defuns/defuns-git.el b/core/defuns/defuns-git.el
new file mode 100644
index 000000000..abf6b0332
--- /dev/null
+++ b/core/defuns/defuns-git.el
@@ -0,0 +1,24 @@
+;;; defuns-git.el
+
+;;;### (autoload 'narf/git-remote-browse "defuns-git" nil t)
+(evil-define-command narf:git-remote-browse (&optional bang)
+  "Open the website for the current (or specified) version controlled FILE. If BANG,
+then use hub to do it."
+  (interactive "<!>")
+  (let (url)
+    (condition-case err
+        (setq url (browse-at-remote/get-url))
+      (error
+       (setq url (shell-command-to-string "hub browse -u --"))
+       (setq url (if url
+                     (concat (s-trim url) "/" (f-relative (buffer-file-name) (narf/project-root))
+                             (when (use-region-p) (format "#L%s-L%s"
+                                                          (line-number-at-pos (region-beginning))
+                                                          (line-number-at-pos (region-end)))))))))
+    (when url
+      (if bang
+          (message "Url copied to clipboard: %s" (kill-new url))
+        (browse-url url)))))
+
+(provide 'defuns-git)
+;;; defuns-git.el ends here
diff --git a/core/defuns/defuns-helm.el b/core/defuns/defuns-helm.el
index 9229fe4ca..82e717aee 100644
--- a/core/defuns/defuns-helm.el
+++ b/core/defuns/defuns-helm.el
@@ -73,5 +73,23 @@ buffers."
   (let ((narf-helm-force-project-buffers (and (not all-p) (narf/project-p))))
     (helm-buffers-list)))
 
+;;;###autoload
+(defun narf*helm-replace-prompt (plist)
+  (if (keywordp (car plist))
+      (setq plist (plist-put plist :prompt helm-global-prompt))
+    (setcar (nthcdr 2 plist) helm-global-prompt))
+  plist)
+
+;;;###autoload
+(defun narf*helm-hide-header (source &optional force)
+  (setq header-line-format nil)
+  (narf|hide-mode-line))
+
+;;;###autoload
+(defun narf*helm-hide-source-header-maybe ()
+  (if (<= (length helm-sources) 1)
+      (set-face-attribute 'helm-source-header nil :height 0.1 :foreground "#111111")
+    (set-face-attribute 'helm-source-header nil :height 1.0 :foreground narf-helm-header-fg)))
+
 (provide 'defuns-helm)
 ;;; defuns-helm.el ends here
diff --git a/core/defuns/defuns-window.el b/core/defuns/defuns-window.el
index f1d010136..517d9f3c6 100644
--- a/core/defuns/defuns-window.el
+++ b/core/defuns/defuns-window.el
@@ -85,6 +85,20 @@ evil-window-move-* (e.g. `evil-window-move-far-left')"
           ((memq direction '(above below))
            (evil-window-increase-height count)))))
 
+;;;###autoload (autoload 'narf/evil-window-resize-r "defuns-window" nil t)
+(evil-define-command narf/evil-window-resize-r (&optional count)
+  (interactive "<c>") (narf/evil-window-resize 'right count))
+;;;###autoload (autoload 'narf/evil-window-resize-l "defuns-window" nil t)
+(evil-define-command narf/evil-window-resize-l (&optional count)
+  (interactive "<c>") (narf/evil-window-resize 'left count))
+;;;###autoload (autoload 'narf/evil-window-resize-u "defuns-window" nil t)
+(evil-define-command narf/evil-window-resize-u (&optional count)
+  :repeat nil
+  (interactive "<c>") (narf/evil-window-resize 'above count))
+;;;###autoload (autoload 'narf/evil-window-resize-d "defuns-window" nil t)
+(evil-define-command narf/evil-window-resize-d (&optional count)
+  (interactive "<c>") (narf/evil-window-resize 'below count))
+
 ;;;###autoload
 (defun narf/window-reorient ()
   "Reorient all windows that are scrolled to the right."
diff --git a/core/defuns/macros-evil.el b/core/defuns/macros-evil.el
index 73f19a45b..174ede72c 100644
--- a/core/defuns/macros-evil.el
+++ b/core/defuns/macros-evil.el
@@ -1,17 +1,5 @@
 ;;; macros-evil.el
 
-;;;###autoload
-(defmacro def-textobj! (key start-regex end-regex)
-  (let ((inner-name (make-symbol "narf--inner-name"))
-        (outer-name (make-symbol "narf--outer-name")))
-    `(progn
-       (evil-define-text-object ,inner-name (count &optional beg end type)
-         (evil-select-paren ,start-regex ,end-regex beg end type count nil))
-       (evil-define-text-object ,outer-name (count &optional beg end type)
-         (evil-select-paren ,start-regex ,end-regex beg end type count t))
-       (define-key evil-inner-text-objects-map ,key (quote ,inner-name))
-       (define-key evil-outer-text-objects-map ,key (quote ,outer-name)))))
-
 ;;;###autoload
 (defmacro def-tmp-excmd! (cmd-on cmd-off &rest commands)
   "Creates a toggle for a set of ex commands, named CMD-ON and CMD-OFF."
diff --git a/modules/module-java.el b/modules/module-java.el
index e26c97246..249388e76 100644
--- a/modules/module-java.el
+++ b/modules/module-java.el
@@ -35,7 +35,11 @@
   (after! company-dict
     (push 'android-mode company-dict-minor-mode-list)))
 
-(use-package groovy-mode :mode "\\.g\\(radle\\|vy\\|roovy\\)$")
+(use-package groovy-mode
+  :mode "\\.g\\(radle\\|vy\\|roovy\\)$"
+  :config
+  (after! quickrun
+    (push '("\\.gvy$" . "groovy") quickrun-file-alist)))
 
 (provide 'module-java)
 ;;; module-java.el ends here
diff --git a/modules/module-lisp.el b/modules/module-lisp.el
index a3064d309..489cfcdef 100644
--- a/modules/module-lisp.el
+++ b/modules/module-lisp.el
@@ -3,12 +3,8 @@
 (associate! emacs-lisp-mode :match "\\(/Cask\\|\\.\\(el\\|gz\\)\\)$")
 (add-hook! emacs-lisp-mode '(turn-on-eldoc-mode flycheck-mode highlight-numbers-mode))
 
-(use-package highlight-quoted
-  :commands (highlight-quoted-mode)
-  :init (add-hook 'emacs-lisp-mode-hook 'highlight-quoted-mode))
-
-(use-package slime :defer t
-  :config (setq inferior-lisp-program "clisp"))
+;; Real go-to-definition for elisp
+(map! :map emacs-lisp-mode-map :m "gd" 'narf/elisp-find-function-at-pt)
 
 (add-hook 'emacs-lisp-mode-hook 'narf/elisp-init)
 (defun narf/elisp-init ()
@@ -27,9 +23,6 @@
         (delq (assq 'emacs-lisp-mode editorconfig-indentation-alist)
               editorconfig-indentation-alist))
 
-  ;; Real go-to-definition for elisp
-  (map! :map emacs-lisp-mode-map :m "gd" 'narf/elisp-find-function-at-pt)
-
   (remove-hook 'emacs-lisp-mode-hook 'narf/elisp-init))
 
 (add-hook 'emacs-lisp-mode-hook 'narf/elisp-hook)
@@ -43,7 +36,7 @@
          (,(concat
             "(\\(def-"
             (regexp-opt '("electric" "project-type" "company-backend"
-                          "builder" "repl" "textobj" "tmp-excmd" "rotate"
+                          "builder" "repl" "text-obj" "tmp-excmd" "rotate"
                           "repeat" "yas-mode" "version-cmd" "docset"
                           "open-with"))
             "!\\)")
@@ -100,6 +93,15 @@
              (cons disp (cons k v)))))
 
 
+;;
+(use-package highlight-quoted
+  :commands (highlight-quoted-mode)
+  :init (add-hook 'emacs-lisp-mode-hook 'highlight-quoted-mode))
+
+(use-package slime :defer t
+  :config (setq inferior-lisp-program "clisp"))
+
+
 ;;
 (def-project-type! emacs-ert "ert"
   :modes (emacs-lisp-mode)
diff --git a/private/my-bindings.el b/private/my-bindings.el
index e98b63410..d412efe7c 100644
--- a/private/my-bindings.el
+++ b/private/my-bindings.el
@@ -1,18 +1,6 @@
 ;;; my-bindings.el
 
-;; Minimalistic key mapping! Why go so far for this?
-;; ...
-;; Uh. Good question.
-
-(eval-when-compile (require 'core-defuns))
-
-;; See `narf-leader-prefix' & `narf-localleader-prefix' in ../core/core.el
-
 (map!
- ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
- ;; Global keymaps                     ;;
- ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
  "M-x"  'helm-M-x
  "A-x"  'helm-M-x
  "M-;"  'eval-expression
@@ -31,9 +19,8 @@
  "M-t"  'narf:tab-create
  "M-T"  'narf/tab-display
  "A-`"  'os-switch-to-term
- "C-`"  'narf/popup-messages
+ "C-`"  'narf/popup-toggle
  "C-~"  'narf:repl
- "M-`"  'narf/popup-toggle
 
  "M-w"  'narf/close-window-or-tab
  "M-W"  'delete-frame
@@ -46,10 +33,10 @@
  "C-h"  'evil-window-left
  "C-l"  'evil-window-right
 
- "A-j"  (λ! (narf/evil-window-resize 'below))
- "A-k"  (λ! (narf/evil-window-resize 'above))
- "A-h"  (λ! (narf/evil-window-resize 'left))
- "A-l"  (λ! (narf/evil-window-resize 'right))
+ "A-j"  'narf/evil-window-resize-d
+ "A-k"  'narf/evil-window-resize-u
+ "A-h"  'narf/evil-window-resize-l
+ "A-l"  'narf/evil-window-resize-r
 
  "C-<escape>" 'evil-emacs-state
  :e "C-<escape>" 'evil-normal-state
@@ -95,11 +82,6 @@
    :i "<A-backspace>" 'evil-delete-backward-word
    :i "<A-delete>"    (λ! (evil-forward-word) (evil-delete-backward-word)))
 
-
- ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
- ;; Local keymaps                      ;;
- ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
  :m ";" 'evil-ex
  (:leader
    :nv ","  'narf/helm-buffers-dwim
@@ -252,9 +234,9 @@
 
  ;; aliases for %
  :m  "%"   'evilmi-jump-items
- :m [tab] (λ! (if (ignore-errors (hs-already-hidden-p))
-                  (hs-toggle-hiding)
-                (call-interactively 'evilmi-jump-items)))
+ :m  [tab] (λ! (if (ignore-errors (hs-already-hidden-p))
+                   (hs-toggle-hiding)
+                 (call-interactively 'evilmi-jump-items)))
 
  ;; Textmate-esque newlines
  :i  "<backspace>"   'backward-delete-char-untabify
@@ -297,6 +279,22 @@
    "C-S-w"   (λ! (ace-window 4))    ; swap windows
    "C-C"     (λ! (ace-window 16)))  ; delete windows
 
+ ;; `evil-multiedit'
+ :v  "R"     'evil-multiedit-match-all
+ :n  "M-C-D" 'evil-multiedit-restore
+ :nv "M-d"   'evil-multiedit-match-and-next
+ :nv "M-D"   'evil-multiedit-match-and-prev
+ (:map evil-multiedit-state-map
+   :v "RET" 'evil-multiedit-toggle-or-restrict-region)
+
+ ;; `yasnippet'
+ :i  [(tab)]     'yas-expand
+ :v  "<backtab>" 'narf/yas-insert-snippet
+
+ ;; `auto-yasnippet'
+ :i  "<C-tab>" 'aya-expand
+ :nv "<C-tab>" 'aya-create
+
  ;; Vim omni-complete emulation
  :i "C-SPC" 'narf/company-complete
  (:prefix "C-x"
@@ -333,93 +331,10 @@
 
  (:after help-mode
    (:map help-map
-     "e" 'narf/popup-messages
-     ;; Remove slow/annoying help subsections
-     "h" nil
-     "g" nil)
+     "e" 'narf/popup-messages)
    (:map help-mode-map
      :n "]]" 'help-go-forward
-     :n "[[" 'help-go-back
-     :n "<escape>" 'narf/popup-close)))
-
-;; Line-wise mouse selection on margin
-(global-set-key (kbd "<left-margin> <down-mouse-1>") 'narf/mouse-drag-line)
-(global-set-key (kbd "<left-margin> <mouse-1>")      'narf/mouse-select-line)
-(global-set-key (kbd "<left-margin> <drag-mouse-1>") 'narf/mouse-select-line)
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Keymap fixes                       ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; This section is dedicated to bindings that "fix" certain keys so that they behave more
-;; like vim (or how I like it).
-
-;; Restores "dumb" indentation to the tab key. This rustles a lot of peoples' jimmies,
-;; apparently, but it's how I like it.
-(map! :i "<tab>"     'narf/dumb-indent
-      :i "<backtab>" 'narf/dumb-dedent
-      :i "<C-tab>"   'indent-for-tab-command
-
-      ;; No dumb-tab for lisp
-      (:map lisp-mode-map        :i [remap narf/dumb-indent] 'indent-for-tab-command)
-      (:map emacs-lisp-mode-map  :i [remap narf/dumb-indent] 'indent-for-tab-command)
-
-      ;; Highjacks space/backspace to:
-      ;;   a) delete spaces on either side of the cursor, if present ( | ) -> (|)
-      ;;   b) allow backspace to delete space-indented blocks intelligently
-      ;;   c) and not do any of this magic when inside a string
-      :i "SPC"                                  'narf/inflate-space-maybe
-      :i [remap backward-delete-char-untabify]  'narf/deflate-space-maybe
-      :i [remap newline]                        'narf/newline-and-indent
-
-      ;; Smarter move-to-beginning-of-line
-      :i [remap move-beginning-of-line]         'narf/move-to-bol
-
-      ;; Restore bash-esque keymaps in insert mode; C-w and C-a already exist
-      :i "C-e" 'narf/move-to-eol
-      :i "C-u" 'narf/backward-kill-to-bol-and-indent
-
-      ;; Fixes delete
-      :i "<kp-delete>" 'delete-char
-
-      ;; Fix osx keymappings and then some
-      :i "<M-left>"   'narf/move-to-bol
-      :i "<M-right>"  'narf/move-to-eol
-      :i "<M-up>"     'beginning-of-buffer
-      :i "<M-down>"   'end-of-buffer
-      :i "<C-up>"     'smart-up
-      :i "<C-down>"   'smart-down
-
-      ;; Fix emacs motion keys
-      :i "A-b"      'evil-backward-word-begin
-      :i "A-w"      'evil-forward-word-begin
-      :i "A-e"      'evil-forward-word-end
-
-      ;; Textmate-esque insert-line before/after
-      :i "<M-return>"    'evil-open-below
-      :i "<S-M-return>"  'evil-open-above
-      ;; insert lines in-place)
-      :n "<M-return>"    (λ! (save-excursion (evil-insert-newline-below)))
-      :n "<S-M-return>"  (λ! (save-excursion (evil-insert-newline-above)))
-
-      ;; Make ESC quit all the things
-      (:map (minibuffer-local-map
-             minibuffer-local-ns-map
-             minibuffer-local-completion-map
-             minibuffer-local-must-match-map
-             minibuffer-local-isearch-map)
-        [escape] 'abort-recursive-edit
-        "C-r" 'evil-paste-from-register)
-
-      (:map (evil-ex-search-keymap read-expression-map)
-        "C-w" 'backward-kill-word
-        "C-u" 'backward-kill-sentence
-        "C-b" 'backward-word)
-
-      (:map evil-ex-completion-map "C-a" 'move-beginning-of-line)
-
-      (:map view-mode-map "<escape>" 'View-quit-all))
+     :n "[[" 'help-go-back)))
 
 ;; Common unicode characters
 (map! :i "A-o" (λ! (insert "ø"))
diff --git a/private/my-commands.el b/private/my-commands.el
index faa797b0a..188868f86 100644
--- a/private/my-commands.el
+++ b/private/my-commands.el
@@ -1,91 +1,104 @@
 ;;; my-commands.el
 
+(evil-define-operator narf:evil-ex-global (beg end pattern command &optional invert)
+  "Rewritten :g[lobal] that will highlight buffer matches. Takes the same arguments."
+  :motion mark-whole-buffer :move-point nil
+  (interactive "<r><g//><!>")
+  (evil-ex-global beg end pattern command invert))
+
+(evil-define-operator narf:align (&optional beg end bang pattern)
+  "Ex interface to `align-regexp'. Accepts vim-style regexps."
+  (interactive "<r><!><//>")
+  (align-regexp
+   beg end
+   (concat "\\(\\s-*\\)"
+           (if bang
+               (regexp-quote pattern)
+             (evil-transform-vim-style-regexp pattern)))
+   1 1))
+
+;;; Rewritten commands
+(ex! "g[lobal]"    'narf:evil-ex-global)
+
+;;; Custom commands
 ;; Emacs utilities
-(evil-ex-define-cmd "echo"          'narf:echo)
-(evil-ex-define-cmd "minor"         'helm-describe-modes) ; list minor modes
+(ex! "echo"        'narf:echo)
+(ex! "minor"       'helm-describe-modes)         ; list minor modes
 ;; Quick mapping keys to commands, allows :nmap \m !make
-(evil-ex-define-cmd "nmap"          'narf:nmap)
-(evil-ex-define-cmd "imap"          'narf:imap)
-(evil-ex-define-cmd "vmap"          'narf:vmap)
-(evil-ex-define-cmd "mmap"          'narf:mmap)
-(evil-ex-define-cmd "omap"          'narf:omap)
-
+(ex! "imap"        'narf:imap)
+(ex! "mmap"        'narf:mmap)
+(ex! "nmap"        'narf:nmap)
+(ex! "omap"        'narf:omap)
+(ex! "vmap"        'narf:vmap)
 ;; Editing
-(evil-ex-define-cmd "@"             'narf/evil-macro-on-all-lines) ; run macro on each line
-(evil-ex-define-cmd "al[ign]"       'narf:align) ; align by regexp
-(evil-ex-define-cmd "na[rrow]"      'narf:narrow) ; narrow buffer to selection
-(evil-ex-define-cmd "ref[actor]"    'emr-show-refactor-menu) ; open emr menu
-(evil-ex-define-cmd "retab"         'narf:whitespace-retab)
-(evil-ex-define-cmd "settr[im]"     'narf:toggle-delete-trailing-whitespace)
-(evil-ex-define-cmd "snip[pets]"    'narf:yas-snippets) ; visit a snippet
-(evil-ex-define-cmd "tsnip[pets]"   'narf:yas-file-templates) ; visit a file template
-(evil-ex-define-cmd "wal[ign]"      'narf:whitespace-align) ; align spaces
-(evil-ex-define-cmd "rec[ent]"      'narf:helm-recentf) ; show recent files in helm
-(evil-ex-define-cmd "reo[rient]"    'narf/window-reorient) ; scroll all windows to left
-(evil-ex-define-cmd "ie[dit]"       'evil-multiedit-ex-match)
-(evil-ex-define-cmd "htmle[nt]"     'narf/html-entities) ; encode/decode html entities
-
+(ex! "@"           'narf/evil-macro-on-all-lines)
+(ex! "al[ign]"     'narf:align)
+(ex! "htmle[nt]"   'narf/html-entities)          ; encode/decode html entities
+(ex! "ie[dit]"     'evil-multiedit-ex-match)
+(ex! "na[rrow]"    'narf:narrow)
+(ex! "rec[ent]"    'narf:helm-recentf)           ; show recent files
+(ex! "ref[actor]"  'emr-show-refactor-menu)
+(ex! "reo[rient]"  'narf/window-reorient)        ; scroll all windows to left
+(ex! "retab"       'narf:whitespace-retab)
+(ex! "settr[im]"   'narf:toggle-delete-trailing-whitespace)
+(ex! "snip[pets]"  'narf:yas-snippets)           ; open snippet
+(ex! "tsnip[pets]" 'narf:yas-file-templates)     ; open file template
+(ex! "wal[ign]"    'narf:whitespace-align)       ; align by spaces
 ;; External resources
-(evil-ex-define-cmd "dash"          'narf:dash) ; look up in Dash.app
-(evil-ex-define-cmd "http"          'httpd-start) ; start http server
-(evil-ex-define-cmd "re[gex]"       'narf:regex) ; open re-builder
-(evil-ex-define-cmd "repl"          'narf:repl) ; invoke or send to repl
-(evil-ex-define-cmd "t[mux]"        'narf:tmux) ; send to tmux
-(evil-ex-define-cmd "tcd"           'narf:tmux-cd) ; cd to default-directory in tmux
-(evil-ex-define-cmd "x"             'narf:send-to-scratch-or-org)
+(ex! "dash"        'narf:dash)                   ; look up in Dash.app
+(ex! "http"        'httpd-start)                 ; start http server
+(ex! "re[gex]"     'narf:regex)                  ; open re-builder
+(ex! "repl"        'narf:repl)                   ; invoke or send to repl
+(ex! "t[mux]"      'narf:tmux)                   ; send to tmux
+(ex! "tcd"         'narf:tmux-cd)                ; cd to default-directory in tmux
+(ex! "x"           'narf:send-to-scratch-or-org)
 ;; GIT
-(evil-ex-define-cmd "gbr[owse]"     'narf:git-remote-browse) ; show file in github/gitlab
-
+(ex! "ga[dd]"      'narf/vcs-stage-hunk)
+(ex! "gbr[owse]"   'narf:git-remote-browse)      ; show file in github/gitlab
+(ex! "gre[vert]"   'narf/vcs-revert-hunk)
 ;; Dealing with buffers
-(evil-ex-define-cmd "k[ill]"        'narf/kill-real-buffer)     ; Kill current buffer
-(evil-ex-define-cmd "k[ill]all"     'narf:kill-all-buffers)     ; Kill all buffers (bang = in project)
-(evil-ex-define-cmd "k[ill]buried"  'narf:kill-buried-buffers)  ; Kill all buried buffers (bang = in project)
-(evil-ex-define-cmd "k[ill]o"       'narf:kill-other-buffers)   ; kill all other buffers
-(evil-ex-define-cmd "k[ill]unreal"  'narf/kill-unreal-buffers)  ; kill unreal buffers
-(evil-ex-define-cmd "k[ill]match"   'narf:kill-matching-buffers) ; kill buffers that match regexp
-(evil-ex-define-cmd "l[ast]"        'narf/popup-last-buffer) ; pop up last popup
-(evil-ex-define-cmd "m[sg]"         'narf/popup-messages) ; open *messages* in popup
-
+(ex! "k[ill]"      'narf/kill-real-buffer)       ; Kill current buffer
+(ex! "k[ill]all"   'narf:kill-all-buffers)       ; Kill buffers (bang = in project)
+(ex! "k[ill]b"     'narf:kill-buried-buffers)    ; Kill buried buffers
+(ex! "k[ill]m"     'narf:kill-matching-buffers)  ; kill buffers by regexp
+(ex! "k[ill]o"     'narf:kill-other-buffers)     ; kill other buffers
+(ex! "k[ill]u"     'narf/kill-unreal-buffers)    ; kill unreal buffers
+(ex! "l[ast]"      'narf/popup-last-buffer)      ; pop up last popup
+(ex! "m[sg]"       'narf/popup-messages)         ; open *messages* in popup
 ;; Project navigation
-(evil-ex-define-cmd "a"             'helm-projectile-find-other-file) ; open alternate file
-(evil-ex-define-cmd "ag"            'narf:helm-ag-search) ; project text search
-(evil-ex-define-cmd "ag[cw]d"       'narf:helm-ag-search-cwd) ; current directory search
-(evil-ex-define-cmd "cd"            'narf:cd)
-(evil-ex-define-cmd "se[arch]"      'narf:helm-swoop) ; in-file search
+(ex! "a"           'helm-projectile-find-other-file)
+(ex! "ag"          'narf:helm-ag-search)
+(ex! "ag[cw]d"     'narf:helm-ag-search-cwd)
+(ex! "cd"          'narf:cd)
+(ex! "se[arch]"    'narf:helm-swoop)             ; in-file search
 ;; Project tools
-(evil-ex-define-cmd "ma[ke]"        'narf:build)
-(evil-ex-define-cmd "build"         'narf:build)
+(ex! "build"       'narf:build)
+(ex! "ma[ke]"      'narf:build)
 ;; File operations
-(evil-ex-define-cmd "mv"            'narf:file-move)
-(evil-ex-define-cmd "rm"            'narf:file-delete)          ; rm[!]
-
+(ex! "mv"          'narf:file-move)
+(ex! "rm"          'narf:file-delete)
 ;; Presentation/demo
-(evil-ex-define-cmd "big"           'big-mode)
-(evil-ex-define-cmd "full[scr]"     'narf:toggle-fullscreen)
-
+(ex! "big"         'big-mode)
+(ex! "full[scr]"   'narf:toggle-fullscreen)
 ;; Sessions/tabs
-(evil-ex-define-cmd "sl[oad]"       'narf:load-session)
-(evil-ex-define-cmd "ss[ave]"       'narf:save-session)
-(evil-ex-define-cmd "tabs"          'narf/tab-display)
-(evil-ex-define-cmd "tabn[ew]"      'narf:tab-create)
-(evil-ex-define-cmd "tabr[ename]"   'narf:tab-rename)
-(evil-ex-define-cmd "tabc[lose]"    'narf:kill-tab)
-(evil-ex-define-cmd "tabc[lose]o"   'narf:kill-other-tabs)
-(evil-ex-define-cmd "tabn[ext]"     'narf:switch-to-tab-right)
-(evil-ex-define-cmd "tabp[rev]"     'narf:switch-to-tab-left)
-(evil-ex-define-cmd "tabl[ast]"     'narf:switch-to-tab-last)
-
+(ex! "sl[oad]"     'narf:load-session)
+(ex! "ss[ave]"     'narf:save-session)
+(ex! "tabc[lose]"  'narf:kill-tab)
+(ex! "tabc[lose]o" 'narf:kill-other-tabs)
+(ex! "tabl[ast]"   'narf:switch-to-tab-last)
+(ex! "tabn[ew]"    'narf:tab-create)
+(ex! "tabn[ext]"   'narf:switch-to-tab-right)
+(ex! "tabp[rev]"   'narf:switch-to-tab-left)
+(ex! "tabr[ename]" 'narf:tab-rename)
+(ex! "tabs"        'narf/tab-display)
 ;; Org-mode
-(evil-ex-define-cmd "link"          'narf:org-link)
-(evil-ex-define-cmd "att[ach]"      'narf:org-attach) ; attach file to org file
-(evil-ex-define-cmd "org"           'narf:org-helm-search) ; search org notes
-
+(ex! "att[ach]"    'narf:org-attach)             ; attach file to org file
+(ex! "link"        'narf:org-link)
+(ex! "org"         'narf:org-helm-search)        ; search org notes
 ;; Plugins
-(after! flycheck
-  (evil-ex-define-cmd "er[rors]"    (λ! (flycheck-buffer) (flycheck-list-errors))))
-
+(ex! "er[rors]"    'narf/flycheck-errors)
 ;; Debuggers
-(evil-ex-define-cmd "debug"    'narf:debug)
+(ex! "debug"       'narf:debug)
 
 (provide 'my-commands)
 ;;; my-commands.el ends here