diff --git a/bootstrap.el b/bootstrap.el
index 90488cca3..f8f82cc75 100644
--- a/bootstrap.el
+++ b/bootstrap.el
@@ -74,7 +74,7 @@
     ;; Local settings
     (load "~/.emacs.local.el" t t)
     (setq narf-current-theme (if (display-graphic-p) narf-default-theme narf-terminal-theme)
-          narf-current-font  narf-default-font)
+          narf-current-font narf-default-font)
     ;; Here we a'go!
     (mapc 'require packages)
 
diff --git a/core/core-evil.el b/core/core-evil.el
index 32c503b7d..1b4475c0a 100644
--- a/core/core-evil.el
+++ b/core/core-evil.el
@@ -74,10 +74,8 @@
       "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))
+        (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))
diff --git a/core/core-popup.el b/core/core-popup.el
index e4d55ff4d..cfcbbd472 100644
--- a/core/core-popup.el
+++ b/core/core-popup.el
@@ -73,179 +73,178 @@
   (add-hook 'shackle-popup-hook 'narf|hide-mode-line) ; No mode line in popups
 
   ;; Prevents popups from messaging with windows-moving functions
-  (after! defuns-popup
-    (defun narf*save-popups (orig-fun &rest args)
-      (narf/popup-save (apply orig-fun args)))
-    (advice-add 'narf--evil-window-move  :around 'narf*save-popups)
-    (advice-add 'narf--evil-swap-windows :around 'narf*save-popups))
+  (defun narf*save-popups (orig-fun &rest args)
+    (narf/popup-save (apply orig-fun args)))
+  (advice-add 'narf/evil-window-move :around 'narf*save-popups))
 
-  ;;
-  ;; Hacks
-  ;;
 
-  (after! help-mode
-    ;; So that help buffer links do not open in the help popup, we need to redefine these
-    ;; three button types to use `switch-to-buffer-other-window' rather than
-    ;; `pop-to-buffer'. Instead of lambas these help-functions should be function symbols,
-    ;; so that we could advise those instead of clumsify redefine these button types.
-    (define-button-type 'help-function-def
-      :supertype 'help-xref
-      'help-function (lambda (fun file)
-                       (require 'find-func)
-                       (when (eq file 'C-source)
-                         (setq file (help-C-file-name (indirect-function fun) 'fun)))
-                       (let ((location
-                              (find-function-search-for-symbol fun nil file)))
-                         (switch-to-buffer-other-window (car location))
-                         (if (cdr location)
-                             (goto-char (cdr location))
-                           (message "Unable to find location in file"))))
-      'help-echo (purecopy "mouse-2, RET: find function's definition"))
+;;
+;; Hacks
+;;
 
-    (define-button-type 'help-variable-def
-      :supertype 'help-xref
-      'help-function (lambda (var &optional file)
-                       (when (eq file 'C-source)
-                         (setq file (help-C-file-name var 'var)))
-                       (let ((location (find-variable-noselect var file)))
-                         (switch-to-buffer-other-window (car location))
-                         (if (cdr location)
-                             (goto-char (cdr location))
-                           (message "Unable to find location in file"))))
-      'help-echo (purecopy "mouse-2, RET: find variable's definition"))
+(after! help-mode
+  ;; So that help buffer links do not open in the help popup, we need to redefine these
+  ;; three button types to use `switch-to-buffer-other-window' rather than
+  ;; `pop-to-buffer'. Instead of lambas these help-functions should be function symbols,
+  ;; so that we could advise those instead of clumsify redefine these button types.
+  (define-button-type 'help-function-def
+    :supertype 'help-xref
+    'help-function (lambda (fun file)
+                     (require 'find-func)
+                     (when (eq file 'C-source)
+                       (setq file (help-C-file-name (indirect-function fun) 'fun)))
+                     (let ((location
+                            (find-function-search-for-symbol fun nil file)))
+                       (switch-to-buffer-other-window (car location))
+                       (if (cdr location)
+                           (goto-char (cdr location))
+                         (message "Unable to find location in file"))))
+    'help-echo (purecopy "mouse-2, RET: find function's definition"))
 
-    (define-button-type 'help-face-def
-      :supertype 'help-xref
-      'help-function (lambda (fun file)
-                       (require 'find-func)
-                       (let ((location
-                              (find-function-search-for-symbol fun 'defface file)))
-                         (switch-to-buffer-other-window (car location))
-                         (if (cdr location)
-                             (goto-char (cdr location))
-                           (message "Unable to find location in file"))))
-      'help-echo (purecopy "mouse-2, RET: find face's definition")))
+  (define-button-type 'help-variable-def
+    :supertype 'help-xref
+    'help-function (lambda (var &optional file)
+                     (when (eq file 'C-source)
+                       (setq file (help-C-file-name var 'var)))
+                     (let ((location (find-variable-noselect var file)))
+                       (switch-to-buffer-other-window (car location))
+                       (if (cdr location)
+                           (goto-char (cdr location))
+                         (message "Unable to find location in file"))))
+    'help-echo (purecopy "mouse-2, RET: find variable's definition"))
 
-  (after! helm
-    ;; This is a good alternative to either popwin or shackle, specifically for helm. If
-    ;; either fail me (for the last time), this is where I'll turn.
-    ;;(add-to-list 'display-buffer-alist
-    ;;             `(,(rx bos "*helm" (* not-newline) "*" eos)
-    ;;               (display-buffer-in-side-window)
-    ;;               (inhibit-same-window . t)
-    ;;               (window-height . 0.4)))
+  (define-button-type 'help-face-def
+    :supertype 'help-xref
+    'help-function (lambda (fun file)
+                     (require 'find-func)
+                     (let ((location
+                            (find-function-search-for-symbol fun 'defface file)))
+                       (switch-to-buffer-other-window (car location))
+                       (if (cdr location)
+                           (goto-char (cdr location))
+                         (message "Unable to find location in file"))))
+    'help-echo (purecopy "mouse-2, RET: find face's definition")))
 
-    ;; Helm tries to clean up after itself, but shackle has already done this. This fixes
-    ;; that. To reproduce, add a helm rule in `shackle-rules', open two splits
-    ;; side-by-side, move to the buffer on the right and invoke helm. It will close all
-    ;; but the left-most buffer.
-    (setq-default helm-reuse-last-window-split-state t
-                  helm-split-window-in-side-p t))
+(after! helm
+  ;; This is a good alternative to either popwin or shackle, specifically for helm. If
+  ;; either fail me (for the last time), this is where I'll turn.
+  ;;(add-to-list 'display-buffer-alist
+  ;;             `(,(rx bos "*helm" (* not-newline) "*" eos)
+  ;;               (display-buffer-in-side-window)
+  ;;               (inhibit-same-window . t)
+  ;;               (window-height . 0.4)))
 
-  (after! helm-swoop
-    (setq helm-swoop-split-window-function (lambda ($buf) (narf/popup-buffer $buf))))
+  ;; Helm tries to clean up after itself, but shackle has already done this. This fixes
+  ;; that. To reproduce, add a helm rule in `shackle-rules', open two splits
+  ;; side-by-side, move to the buffer on the right and invoke helm. It will close all
+  ;; but the left-most buffer.
+  (setq-default helm-reuse-last-window-split-state t
+                helm-split-window-in-side-p t))
 
-  (after! helm-ag
-    ;; Helm-ag needs a little coaxing for it to cooperate with shackle. Mostly to prevent
-    ;; it from switching between windows and buffers.
-    (defadvice helm-ag--edit-abort (around helm-ag-edit-abort-popup-compat activate)
-      (cl-letf (((symbol-function 'select-window) 'ignore)) ad-do-it)
-      (narf/popup-close nil t t))
-    (defadvice helm-ag--edit-commit (around helm-ag-edit-commit-popup-compat activate)
-      (cl-letf (((symbol-function 'select-window) 'ignore)) ad-do-it)
-      (narf/popup-close nil t t))
-    (defadvice helm-ag--edit (around helm-ag-edit-popup-compat activate)
-      (cl-letf (((symbol-function 'other-window) 'ignore)
-                ((symbol-function 'switch-to-buffer) 'narf/popup-buffer))
-        ad-do-it)))
+(after! helm-swoop
+  (setq helm-swoop-split-window-function (lambda ($buf) (narf/popup-buffer $buf))))
 
-  (after! quickrun
-    ;; This allows us to run code several times in a row without having to close the popup
-    ;; window and move back to the code buffer.
-    (defun narf*quickrun-close-popup (&optional _ _ _ _)
-      (let* ((buffer (get-buffer quickrun/buffer-name))
-             (window (and buffer (get-buffer-window buffer))))
-        (when buffer
-          (shut-up! (quickrun/kill-running-process))
-          (narf/popup-close window nil t))))
-    (advice-add 'quickrun :before 'narf*quickrun-close-popup)
-    (advice-add 'quickrun-region :before 'narf*quickrun-close-popup)
+(after! helm-ag
+  ;; Helm-ag needs a little coaxing for it to cooperate with shackle. Mostly to prevent
+  ;; it from switching between windows and buffers.
+  (defadvice helm-ag--edit-abort (around helm-ag-edit-abort-popup-compat activate)
+    (cl-letf (((symbol-function 'select-window) 'ignore)) ad-do-it)
+    (narf/popup-close nil t t))
+  (defadvice helm-ag--edit-commit (around helm-ag-edit-commit-popup-compat activate)
+    (cl-letf (((symbol-function 'select-window) 'ignore)) ad-do-it)
+    (narf/popup-close nil t t))
+  (defadvice helm-ag--edit (around helm-ag-edit-popup-compat activate)
+    (cl-letf (((symbol-function 'other-window) 'ignore)
+              ((symbol-function 'switch-to-buffer) 'narf/popup-buffer))
+      ad-do-it)))
 
-    ;; Turns on `nlinum-mode', and ensures window is scrolled to EOF
-    (defun narf|quickrun-after-run ()
-      (let ((window (get-buffer-window quickrun/buffer-name)))
-        (with-selected-window window
-          (goto-char (point-min)))))
-    (add-hook 'quickrun-after-run-hook 'narf|quickrun-after-run)
-    (add-hook 'quickrun/mode-hook 'narf|hide-mode-line))
+(after! quickrun
+  ;; This allows us to run code several times in a row without having to close the popup
+  ;; window and move back to the code buffer.
+  (defun narf*quickrun-close-popup (&optional _ _ _ _)
+    (let* ((buffer (get-buffer quickrun/buffer-name))
+           (window (and buffer (get-buffer-window buffer))))
+      (when buffer
+        (shut-up! (quickrun/kill-running-process))
+        (narf/popup-close window nil t))))
+  (advice-add 'quickrun :before 'narf*quickrun-close-popup)
+  (advice-add 'quickrun-region :before 'narf*quickrun-close-popup)
 
-  (add-hook! org-load
-    ;; This ensures org-src-edit yields control of its buffer to shackle.
-    (defun org-src-switch-to-buffer (buffer context)
-      (pop-to-buffer buffer))
+  ;; Turns on `nlinum-mode', and ensures window is scrolled to EOF
+  (defun narf|quickrun-after-run ()
+    (let ((window (get-buffer-window quickrun/buffer-name)))
+      (with-selected-window window
+        (goto-char (point-min)))))
+  (add-hook 'quickrun-after-run-hook 'narf|quickrun-after-run)
+  (add-hook 'quickrun/mode-hook 'narf|hide-mode-line))
 
-    ;; And these for org-todo, org-link and agenda
-    (defun org-pop-to-buffer-same-window (&optional buffer-or-name norecord label)
-      "Pop to buffer specified by BUFFER-OR-NAME in the selected window."
-      (display-buffer buffer-or-name))
+(add-hook! org-load
+  ;; This ensures org-src-edit yields control of its buffer to shackle.
+  (defun org-src-switch-to-buffer (buffer context)
+    (pop-to-buffer buffer))
 
-    (defun org-switch-to-buffer-other-window (&rest args)
-      (mapc (lambda (b)
-              (let ((buf (if (stringp b) (get-buffer-create b) b)))
-                (pop-to-buffer buf t t)))
-            args))
+  ;; And these for org-todo, org-link and agenda
+  (defun org-pop-to-buffer-same-window (&optional buffer-or-name norecord label)
+    "Pop to buffer specified by BUFFER-OR-NAME in the selected window."
+    (display-buffer buffer-or-name))
 
-    ;; Taming Org-agenda!
-    (defun narf/org-agenda-quit ()
-      "Necessary to finagle org-agenda into shackle popups and behave properly on quit."
-      (interactive)
-      (if org-agenda-columns-active
-          (org-columns-quit)
-        (let ((buf (current-buffer)))
-          (and (not (eq org-agenda-window-setup 'current-window))
-               (not (one-window-p))
-               (delete-window))
-          (kill-buffer buf)
-          (setq org-agenda-archives-mode nil
-                org-agenda-buffer nil))))
+  (defun org-switch-to-buffer-other-window (&rest args)
+    (mapc (lambda (b)
+            (let ((buf (if (stringp b) (get-buffer-create b) b)))
+              (pop-to-buffer buf t t)))
+          args))
 
-    (map! :map org-agenda-mode-map
-          :e "<escape>" 'narf/org-agenda-quit
-          :e "ESC" 'narf/org-agenda-quit
-          :e [escape] 'narf/org-agenda-quit
-          "q" 'narf/org-agenda-quit
-          "Q" 'narf/org-agenda-quit))
+  ;; Taming Org-agenda!
+  (defun narf/org-agenda-quit ()
+    "Necessary to finagle org-agenda into shackle popups and behave properly on quit."
+    (interactive)
+    (if org-agenda-columns-active
+        (org-columns-quit)
+      (let ((buf (current-buffer)))
+        (and (not (eq org-agenda-window-setup 'current-window))
+             (not (one-window-p))
+             (delete-window))
+        (kill-buffer buf)
+        (setq org-agenda-archives-mode nil
+              org-agenda-buffer nil))))
 
-  (after! realgud
-    ;; This allows realgud debuggers to run in a popup.
-    ;; TODO Find a more elegant advice-based solution
-    ;; FIXME Causes realgud:cmd-* to focus popup on every invocation
-    (defun realgud:run-process(debugger-name script-filename cmd-args minibuffer-history &optional no-reset)
-      (let ((cmd-buf))
-        (setq cmd-buf
-              (apply 'realgud-exec-shell debugger-name script-filename
-                     (car cmd-args) no-reset (cdr cmd-args)))
-        (let ((process (get-buffer-process cmd-buf)))
-          (if (and process (eq 'run (process-status process)))
-              (progn
-                (pop-to-buffer cmd-buf)
-                (define-key evil-emacs-state-local-map (kbd "ESC ESC") 'narf/debug-quit)
-                (realgud:track-set-debugger debugger-name)
-                (realgud-cmdbuf-info-in-debugger?= 't)
-                (realgud-cmdbuf-info-cmd-args= cmd-args)
-                (when cmd-buf
-                  (switch-to-buffer cmd-buf)
-                  (when realgud-cmdbuf-info
-                    (let* ((info realgud-cmdbuf-info)
-                           (cmd-args (realgud-cmdbuf-info-cmd-args info))
-                           (cmd-str  (mapconcat 'identity  cmd-args " ")))
-                      (set minibuffer-history
-                           (list-utils-uniq (cons cmd-str (eval minibuffer-history))))))))
-            ;; else
+  (map! :map org-agenda-mode-map
+        :e "<escape>" 'narf/org-agenda-quit
+        :e "ESC" 'narf/org-agenda-quit
+        :e [escape] 'narf/org-agenda-quit
+        "q" 'narf/org-agenda-quit
+        "Q" 'narf/org-agenda-quit))
+
+(after! realgud
+  ;; This allows realgud debuggers to run in a popup.
+  ;; TODO Find a more elegant advice-based solution
+  ;; FIXME Causes realgud:cmd-* to focus popup on every invocation
+  (defun realgud:run-process(debugger-name script-filename cmd-args minibuffer-history &optional no-reset)
+    (let ((cmd-buf))
+      (setq cmd-buf
+            (apply 'realgud-exec-shell debugger-name script-filename
+                   (car cmd-args) no-reset (cdr cmd-args)))
+      (let ((process (get-buffer-process cmd-buf)))
+        (if (and process (eq 'run (process-status process)))
             (progn
-              (if cmd-buf (switch-to-buffer cmd-buf))
-              (message "Error running command: %s" (mapconcat 'identity cmd-args " ")))))
-        cmd-buf))))
+              (pop-to-buffer cmd-buf)
+              (define-key evil-emacs-state-local-map (kbd "ESC ESC") 'narf/debug-quit)
+              (realgud:track-set-debugger debugger-name)
+              (realgud-cmdbuf-info-in-debugger?= 't)
+              (realgud-cmdbuf-info-cmd-args= cmd-args)
+              (when cmd-buf
+                (switch-to-buffer cmd-buf)
+                (when realgud-cmdbuf-info
+                  (let* ((info realgud-cmdbuf-info)
+                         (cmd-args (realgud-cmdbuf-info-cmd-args info))
+                         (cmd-str  (mapconcat 'identity  cmd-args " ")))
+                    (set minibuffer-history
+                         (list-utils-uniq (cons cmd-str (eval minibuffer-history))))))))
+          ;; else
+          (progn
+            (if cmd-buf (switch-to-buffer cmd-buf))
+            (message "Error running command: %s" (mapconcat 'identity cmd-args " ")))))
+      cmd-buf)))
 
 (provide 'core-popup)
 ;;; core-popup.el ends here
diff --git a/core/core-ui.el b/core/core-ui.el
index 829856fd0..2b7c5a76d 100644
--- a/core/core-ui.el
+++ b/core/core-ui.el
@@ -1,5 +1,10 @@
 ;;; core-ui.el --- interface & mode-line config
 
+;; y/n instead of yes/no
+(fset 'yes-or-no-p 'y-or-n-p)
+
+(defvar narf-fringe-size 3 "Default fringe width")
+
 (setq-default
  blink-matching-paren nil ; don't blink--too distracting
  show-paren-delay 0.075
@@ -36,8 +41,6 @@
  fringe-indicator-alist (delq (assoc 'continuation fringe-indicator-alist)
                               fringe-indicator-alist))
 
-(fset 'yes-or-no-p 'y-or-n-p)  ; y/n instead of yes/no
-
 ;; Ask for confirmation on exit only if there are real buffers left
 (when window-system
   (setq confirm-kill-emacs
@@ -47,7 +50,7 @@
             t))))
 
 (load-theme narf-current-theme t)
-(tooltip-mode -1)  ; show tooltips in echo area
+(tooltip-mode -1) ; show tooltips in echo area
 ;; set up minibuffer and fringe
 (if (not window-system)
     (menu-bar-mode -1)
@@ -160,8 +163,7 @@
   :commands (rainbow-mode)
   :init
   ;; hl-line-mode and rainbow-mode don't play well together
-  (add-hook! (sass-mode scss-mode less-css-mode)
-    '(rainbow-mode narf|hl-line-off)))
+  (add-hook 'rainbow-mode-hook 'narf|hl-line-off))
 
 (use-package nlinum
   :commands nlinum-mode
diff --git a/core/core.el b/core/core.el
index 92b0f5ae7..fcdc931dd 100644
--- a/core/core.el
+++ b/core/core.el
@@ -9,7 +9,7 @@
 ;;   narf|…     A hook
 ;;   narf*…     An advising function
 ;;   narf.…     Custom prefix commands
-;;   …!         Macro
+;;   …!         Macro or shortcut alias
 ;;
 ;; Autoloaded functions are in {core,modules}/defuns/defuns-*.el
 ;;
@@ -79,21 +79,14 @@
 ;; Variables
 ;;
 
-(defvar narf-leader-prefix "," "Prefix key for <leader> maps")
-(defvar narf-localleader-prefix "\\" "Prefix key for <localleader> maps")
-
-;; Buffers/Files
 (defvar narf-unreal-buffers '("^ ?\\*.+\\*"
                               image-mode
                               dired-mode
                               reb-mode
                               messages-buffer-mode)
   "A list of regexps or modes whose buffers are considered unreal, and will be
-ignored when using `narf:next-real-buffer' and `narf:previous-real-buffer', and
-killed by `narf/kill-unreal-buffers'.
-
-`narf/kill-real-buffer' will also gloss over these buffers when finding a new
-buffer to display.")
+ignored when using `narf:next-real-buffer' and `narf:previous-real-buffer' (or
+killed by `narf/kill-unreal-buffers', or after `narf/kill-real-buffer').")
 
 (defvar narf-ignore-buffers '("*Completions*" "*Compile-Log*" "*inferior-lisp*"
                               "*Fuzzy Completions*" "*Apropos*" "*Help*" "*cvs*"
@@ -131,21 +124,19 @@ gets killed.")
   "A list of files that count as 'project files', which determine whether a
 folder is the root of a project or not.")
 
-;; Fringe/margins
-(defvar narf-fringe-size 6 "Default width to use for the fringes.")
-
 
 ;;
-;; Bootstrap
+;; Libraries
 ;;
 
 (require 'f)
-(autoload 'use-package "use-package" "" nil 'macro)
 (unless (require 'autoloads nil t)
   (load (concat narf-emacs-dir "/scripts/generate-autoloads.el"))
   (require 'autoloads))
 (require 'core-defuns)
 
+(autoload 'use-package "use-package" "" nil 'macro)
+
 (use-package anaphora
   :commands (awhen aif acond awhile))
 
@@ -204,13 +195,14 @@ enable multiple minor modes for the same regexp.")
 
 ;;
 (add-hook! after-init
-  ;; We add this to `after-init-hook' to allow errors to stop this advice
+  ;; We add this to `after-init-hook' to allow errors to stop it
   (defadvice save-buffers-kill-emacs (around no-query-kill-emacs activate)
     "Prevent annoying \"Active processes exist\" query when you quit Emacs."
     (cl-flet ((process-list ())) ad-do-it))
 
-  ;; Don't display anything
+  ;; Prevent any auto-displayed text...
   (advice-add 'display-startup-echo-area-message :override 'ignore)
+  ;; ...so we can display our own
   (message ":: Loaded in %.3fs"
            (float-time (time-subtract (current-time) emacs-start-time))))
 
diff --git a/init.el b/init.el
index 25ff7d343..b10e3468d 100644
--- a/init.el
+++ b/init.el
@@ -47,6 +47,10 @@
 (defconst narf-terminal-theme 'narf-dark)
 (defconst narf-default-font (font-spec :family "Fira Mono" :size 12))
 
+(defconst narf-leader-prefix      ","  "Prefix for <leader> bindings")
+(defconst narf-localleader-prefix "\\" "Prefix for <localleader> bindings")
+
+;; Load packages
 (narf `(core ; core/core.el
 
         ;; OS-specific config
@@ -74,6 +78,7 @@
         module-cc          ; C/C++/Obj-C madness
         module-crystal     ; ruby at the speed of c
         module-csharp      ; unity, .NET, and mono shenanigans
+        module-css         ; #big-bang::before { content: ""; }
         module-data        ; config and data formats
         module-go          ; the hipster dialect
         module-haskell     ; a language that's lazier than I am
@@ -92,7 +97,7 @@
         module-scala       ; Java, but good
         module-sh          ; she sells Z-shells by the C XOR
         module-text        ; writing docs for people to ignore
-        module-web         ; #big-bang::before { content: ""; }
+        module-web         ; The end is always near </html>
 
         ;; Experimental
         ;;module-eshell      ; for inferior OSes *cough*windows