diff --git a/core/core-defuns.el b/core/core-defuns.el
index 17465e8ac..f2522788b 100644
--- a/core/core-defuns.el
+++ b/core/core-defuns.el
@@ -110,54 +110,52 @@ Examples:
                      `((add-hook 'find-file-hook ',hook-name))))))))))
 
 (after! evil
-  ;; Register keywords for proper indentation (see `bind!')
-  (put ':prefix  'lisp-indent-function 'defun)
-  (put ':map     'lisp-indent-function 'defun)
-  (put ':after   'lisp-indent-function 'defun)
-  (put ':when    'lisp-indent-function 'defun)
-  (put ':unless  'lisp-indent-function 'defun)
+  ;; Register keywords for proper indentation (see `map!')
+  (put ':prefix      'lisp-indent-function 'defun)
+  (put ':map         'lisp-indent-function 'defun)
+  (put ':after       'lisp-indent-function 'defun)
+  (put ':when        'lisp-indent-function 'defun)
+  (put ':unless      'lisp-indent-function 'defun)
+  (put ':leader      'lisp-indent-function 'defun)
+  (put ':localleader 'lisp-indent-function 'defun)
 
-  (defmacro bind! (&rest rest)
+  (defmacro map! (&rest rest)
     (let ((i 0)
-          key def
-          first-set
-          prefix
-          internal
-          (default-keymaps '((current-global-map)))
-          (keymaps (if (boundp 'keymaps) keymaps))
-          (states  (if (boundp 'states) states '()))
           (forms '())
+          (keymaps (if (boundp 'keymaps) keymaps))
+          (default-keymaps '((current-global-map)))
           (state-map '(("n" . normal)
                        ("v" . visual)
                        ("i" . insert)
                        ("e" . emacs)
                        ("o" . operator)
                        ("m" . motion)
-                       ("r" . replace))))
+                       ("r" . replace)))
+          key def prefix states)
       (unless keymaps
         (setq keymaps default-keymaps))
       (while rest
         (setq key (pop rest))
         (add-to-list
          'forms
-         (cond ((eq key '-) nil) ; skip this
-
-               ((listp key) ; it's a sub exp
-                `((bind! ,@key)))
+         (cond ((listp key) ; it's a sub exp
+                `(,(macroexpand `(map! ,@key))))
 
                ((keywordp key)
+                (when (memq key '(:leader :localleader))
+                  (push (pcase key
+                          (:leader narf-leader-prefix)
+                          (:localleader narf-localleader-prefix))
+                        rest)
+                  (setq key :prefix))
                 (pcase key
                   ;; TODO: Data checks
-                  (:prefix      (setq prefix (kbd (pop rest)))
-                    (if (= i 0) (setq first-set `(:prefix . ,prefix)))
-                    nil)
-                  (:map         (setq keymaps (-list (pop rest)))
-                    (if (= i 0) (setq first-set `(:map . ,keymaps)))
-                    nil)
-                  (:unset       `((bind! ,(kbd (pop rest)) nil)))
-                  (:after       (prog1 `((after! ,(pop rest)   (bind! ,@rest))) (setq rest '())))
-                  (:when        (prog1 `((if ,(pop rest)       (bind! ,@rest))) (setq rest '())))
-                  (:unless      (prog1 `((if (not ,(pop rest)) (bind! ,@rest))) (setq rest '())))
+                  (:prefix      (setq prefix (kbd (pop rest))) nil)
+                  (:map         (setq keymaps (-list (pop rest))) nil)
+                  (:unset      `(,(macroexpand `(map! ,(kbd (pop rest)) nil))))
+                  (:after       (prog1 `((after! ,(pop rest)   ,(macroexpand `(map! ,@rest)))) (setq rest '())))
+                  (:when        (prog1 `((if ,(pop rest)       ,(macroexpand `(map! ,@rest)))) (setq rest '())))
+                  (:unless      (prog1 `((if (not ,(pop rest)) ,(macroexpand `(map! ,@rest)))) (setq rest '())))
                   (otherwise ; might be a state prefix
                    (mapc (lambda (letter)
                            (if (assoc letter state-map)
@@ -179,16 +177,12 @@ Examples:
                 (unless (> (length rest) 0)
                   (user-error "Map has no definition for %s" key))
                 (setq def (pop rest))
-                (let ((first-key (car first-set))
-                      (first-value (cdr first-set))
-                      out-forms)
+                (let (out-forms)
                   (dolist (keymap keymaps)
                     (if (not states)
                         (add-to-list 'out-forms `(evil-define-key nil ,keymap ,key ,def) t)
                       (dolist (state states)
                         (add-to-list 'out-forms `(evil-define-key ',state ,keymap ,key ,def) t))))
-                  (setq prefix  (if (eq first-key :prefix) first-value))
-                  (setq keymaps (if (eq first-key :map) first-value default-keymaps))
                   (setq states '())
                   out-forms))
 
diff --git a/core/core-flycheck.el b/core/core-flycheck.el
index 83c71e978..2ffe6120f 100644
--- a/core/core-flycheck.el
+++ b/core/core-flycheck.el
@@ -11,14 +11,14 @@
         flycheck-disabled-checkers '(emacs-lisp-checkdoc make))
   :config
   (evil-initial-state 'flycheck-error-list-mode 'emacs)
-  (bind! (:map flycheck-error-list-mode-map
-           :n [escape] 'kill-this-buffer
-           :n "q"      'kill-this-buffer
-           :n "C-n"    'flycheck-error-list-next-error
-           :n "C-p"    'flycheck-error-list-previous-error
-           :n "j"      'flycheck-error-list-next-error
-           :n "k"      'flycheck-error-list-previous-error
-           :n "RET"    'flycheck-error-list-goto-error))
+  (map! (:map flycheck-error-list-mode-map
+          :n [escape] 'kill-this-buffer
+          :n "q"      'kill-this-buffer
+          :n "C-n"    'flycheck-error-list-next-error
+          :n "C-p"    'flycheck-error-list-previous-error
+          :n "j"      'flycheck-error-list-next-error
+          :n "k"      'flycheck-error-list-previous-error
+          :n "RET"    'flycheck-error-list-goto-error))
 
   ;; Check buffer when normal mode is entered
   (add-hook! evil-normal-state-entry 'narf*flycheck-buffer)
diff --git a/core/core-helm.el b/core/core-helm.el
index a9f37145c..99198d54c 100644
--- a/core/core-helm.el
+++ b/core/core-helm.el
@@ -32,24 +32,24 @@
   (mapc (lambda (r) (add-to-list 'helm-boring-file-regexp-list r))
         (list "\\.projects$" "\\.DS_Store$"))
 
-  (bind! (:map (helm-map helm-generic-files-map helm-find-files-map helm-swoop-map helm-projectile-find-file-map)
-           "C-w"        'backward-kill-word
-           "C-r"        'evil-ex-paste-from-register ; Evil registers in helm! Glorious!
-           "<escape>"   'helm-keyboard-quit
-           [escape]     'helm-keyboard-quit)
-         (:map helm-find-files-map
-           "C-w"        'helm-find-files-up-one-level
-           ;; "TAB"        'helm-execute-persistent-action
-           "/"          'helm-execute-persistent-action)
-         (:map helm-ag-map
-           "<backtab>"  'helm-ag-edit)
-         (: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))
+  (map! (:map (helm-map helm-generic-files-map helm-find-files-map helm-swoop-map helm-projectile-find-file-map)
+          "C-w"        'backward-kill-word
+          "C-r"        'evil-ex-paste-from-register ; Evil registers in helm! Glorious!
+          "<escape>"   'helm-keyboard-quit
+          [escape]     'helm-keyboard-quit)
+        (:map helm-find-files-map
+          "C-w"        'helm-find-files-up-one-level
+          ;; "TAB"        'helm-execute-persistent-action
+          "/"          'helm-execute-persistent-action)
+        (:map helm-ag-map
+          "<backtab>"  'helm-ag-edit)
+        (: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))
 
   ;;; Helm hacks
   (defun narf*helm-hide-source-header-maybe ()
diff --git a/core/core-project.el b/core/core-project.el
index b52d31a29..d1b25f3a3 100644
--- a/core/core-project.el
+++ b/core/core-project.el
@@ -33,13 +33,13 @@
     (ido-vertical-mode 1)
     (require 'flx-ido)
     (flx-ido-mode 1)
-    (bind! :map (ido-common-completion-map
-                 ido-completion-map
-                 ido-file-completion-map)
-           "C-n" 'ido-next-match
-           "C-p" 'ido-prev-match
-           "C-w" 'ido-delete-backward-word-updir
-           "C-u" 'ido-up-directory))
+    (map! :map (ido-common-completion-map
+                ido-completion-map
+                ido-file-completion-map)
+          "C-n" 'ido-next-match
+          "C-p" 'ido-prev-match
+          "C-w" 'ido-delete-backward-word-updir
+          "C-u" 'ido-up-directory))
 
   (advice-add 'ido-sort-mtime :override 'narf*ido-sort-mtime)
   (add-hook! (ido-make-file-list ido-make-dir-list) 'narf*ido-sort-mtime)
@@ -68,22 +68,22 @@
         neo-modern-sidebar t)
   :config
   (defun narf|neotree-init-keymap ()
-    (bind! :map evil-motion-state-local-map
-           "ESC"  'neotree-hide
-           "\\\\" 'neotree-hide
-           "RET" 'neotree-enter
-           "J"   'neotree-select-next-sibling-node
-           "K"   'neotree-select-previous-sibling-node
-           "H"   'neotree-select-up-node
-           "L"   'neotree-select-down-node
-           "v"   'neotree-enter-vertical-split
-           "s"   'neotree-enter-horizontal-split
-           "c"   'neotree-create-node
-           "d"   'neotree-delete-node
-           "g"   'neotree-refresh
-           "q"   'neotree-hide
-           "r"   'neotree-rename-node
-           "R"   'neotree-change-root))
+    (map! :map evil-motion-state-local-map
+          "ESC"  'neotree-hide
+          "\\\\" 'neotree-hide
+          "RET" 'neotree-enter
+          "J"   'neotree-select-next-sibling-node
+          "K"   'neotree-select-previous-sibling-node
+          "H"   'neotree-select-up-node
+          "L"   'neotree-select-down-node
+          "v"   'neotree-enter-vertical-split
+          "s"   'neotree-enter-horizontal-split
+          "c"   'neotree-create-node
+          "d"   'neotree-delete-node
+          "g"   'neotree-refresh
+          "q"   'neotree-hide
+          "r"   'neotree-rename-node
+          "R"   'neotree-change-root))
 
   (add-hook! neotree-mode 'narf|neotree-init-keymap)
   (add-hook! window-configuration-change 'narf|neotree-close-on-window-change)
diff --git a/core/core-yasnippet.el b/core/core-yasnippet.el
index 4e641d957..6a5fd44cf 100644
--- a/core/core-yasnippet.el
+++ b/core/core-yasnippet.el
@@ -23,8 +23,8 @@
         yas-snippet-dirs `(,@narf-snippet-dirs)
         yas-prompt-functions '(yas-ido-prompt yas-no-prompt))
 
-  (bind! :i [(tab)] 'yas-expand
-         :v "<backtab>" 'narf/yas-insert-snippet)
+  (map! :i [(tab)] 'yas-expand
+        :v "<backtab>" 'narf/yas-insert-snippet)
 
   (defvar yas-minor-mode-map
     (let ((map (make-sparse-keymap)))
@@ -40,21 +40,21 @@
   ;; Simpler `yas-selected-text' alias for templates
   (defvaralias '% 'yas-selected-text)
   ;; Undo global maps
-  (bind! :i [(tab)]     nil
-         :v "<backtab>" nil)
+  (map! :i [(tab)]     nil
+        :v "<backtab>" nil)
 
   ;; keybinds
-  (bind! :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
+  (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)
+        "<escape>"      'evil-normal-state
+        [backspace]     'narf/yas-backspace
+        "<delete>"      'narf/yas-delete)
 
   ;; Once you're in normal mode, you're out
   (add-hook! evil-normal-state-entry 'yas-abort-snippet)
diff --git a/modules/module-csharp.el b/modules/module-csharp.el
index 77e376f53..faa024906 100644
--- a/modules/module-csharp.el
+++ b/modules/module-csharp.el
@@ -18,11 +18,12 @@
   :init
   (add-hook! csharp-mode '(emr-initialize omnisharp-mode))
   :config
-  (evil-define-key 'normal omnisharp-mode-map
-    (kbd "gd")  'omnisharp-go-to-definition
-    (kbd ",tr") (λ (omnisharp-unit-test "fixture"))
-    (kbd ",ts") (λ (omnisharp-unit-test "single"))
-    (kbd ",ta") (λ (omnisharp-unit-test "all")))
+  (map! :map omnisharp-mode-map
+        "gd" 'omnisharp-go-to-definition
+        (:prefix "\\"
+          "tr" (λ (omnisharp-unit-test "fixture"))
+          "ts" (λ (omnisharp-unit-test "single"))
+          "ta" (λ (omnisharp-unit-test "all"))))
 
   (after! company
     (define-company-backend! csharp-mode (omnisharp))
diff --git a/modules/module-eshell.el b/modules/module-eshell.el
index 70d5dadba..72803ffe1 100644
--- a/modules/module-eshell.el
+++ b/modules/module-eshell.el
@@ -26,13 +26,13 @@
   ;; em-prompt
   (setq eshell-prompt-function 'narf/eshell-prompt)
 
-  (bind! :map eshell-mode-map
-         :n "i" 'narf/eshell-evil-prepend-maybe
-         :n "I" 'narf/eshell-evil-prepend
-         :n "a" 'narf/eshell-evil-append-maybe
-         :n "A" 'narf/eshell-evil-append
-         :n "r" 'narf/eshell-evil-replace-maybe
-         :n "R" 'narf/eshell-evil-replace-state-maybe))
+  (map! :map eshell-mode-map
+        :n "i" 'narf/eshell-evil-prepend-maybe
+        :n "I" 'narf/eshell-evil-prepend
+        :n "a" 'narf/eshell-evil-append-maybe
+        :n "A" 'narf/eshell-evil-append
+        :n "r" 'narf/eshell-evil-replace-maybe
+        :n "R" 'narf/eshell-evil-replace-state-maybe))
 
 (provide 'module-eshell)
 ;;; module-eshell.el ends here
diff --git a/modules/module-go.el b/modules/module-go.el
index 64039f406..1764b3a4e 100644
--- a/modules/module-go.el
+++ b/modules/module-go.el
@@ -36,14 +36,14 @@
     :config
     (define-company-backend! go-mode (go yasnippet)))
 
-  (bind!
-   (:map go-mode-map
-     :n "gd" 'godef-jump
-     :n "gD" 'godef-describe
-     :n ",i" 'helm-go-package
-     :n ",tr" 'narf:go-test-run-all
-     :n ",ta" 'narf:go-test-run-all
-     :n ",ts" 'narf:go-test-run-package)))
+  (map! :map go-mode-map
+        :n "gd" 'godef-jump
+        :n "gD" 'godef-describe
+        (:localleader
+         :n "p" 'helm-go-package
+         :n "tr" 'narf:go-test-run-all
+         :n "ta" 'narf:go-test-run-all
+         :n "ts" 'narf:go-test-run-package)))
 
 (provide 'module-go)
 ;;; module-go.el ends here
diff --git a/modules/module-java.el b/modules/module-java.el
index 82d23f5e6..74ee7a660 100644
--- a/modules/module-java.el
+++ b/modules/module-java.el
@@ -23,7 +23,7 @@
       :functions company-emacs-eclim-setup
       :config (company-emacs-eclim-setup)))
 
-  (bind! :map java-mode-map :m "gd" 'eclim-java-find-declaration))
+  (map! :map java-mode-map :m "gd" 'eclim-java-find-declaration))
 
 (use-package android-mode
   :commands android-mode
diff --git a/modules/module-js.el b/modules/module-js.el
index 3c51bce5e..3efe5c6c7 100644
--- a/modules/module-js.el
+++ b/modules/module-js.el
@@ -16,7 +16,7 @@
 
   (after! web-beautify
     (add-hook! js2-mode (setenv "jsbeautify_indent_size" "4"))
-    (bind! :map js2-mode-map :m "gQ" 'web-beautify-js))
+    (map! :map js2-mode-map :m "gQ" 'web-beautify-js))
 
   (use-package js2-refactor
     :init (add-hook! js2-mode 'emr-initialize)
diff --git a/modules/module-lisp.el b/modules/module-lisp.el
index e00a43302..97af0a3a7 100644
--- a/modules/module-lisp.el
+++ b/modules/module-lisp.el
@@ -22,7 +22,7 @@
 
   ;; Highlight extra NARF keywords
   (let ((keywords '("add-hook!"
-                    "bind!"
+                    "map!"
                     "after!"
                     "λ"
                     "in!"
@@ -38,9 +38,9 @@
  'emacs-lisp-mode `(("\\(lambda\\)" (0 (narf/show-as ?λ)))))
 
 ;; Real go-to-definition for elisp
-(bind! :map emacs-lisp-mode-map
-       :m "gd" 'narf/elisp-find-function-at-pt
-       :m "gD" 'narf/elisp-find-function-at-pt-other-window)
+(map! :map emacs-lisp-mode-map
+      :m "gd" 'narf/elisp-find-function-at-pt
+      :m "gD" 'narf/elisp-find-function-at-pt-other-window)
 
 (use-package slime :defer t
   :config
diff --git a/modules/module-markdown.el b/modules/module-markdown.el
index d3ad2f5a9..8e143f756 100644
--- a/modules/module-markdown.el
+++ b/modules/module-markdown.el
@@ -14,29 +14,30 @@
   (add-hook! markdown-mode
     (exmap! "preview"  'narf/markdown-preview)
     (exmap! "export"   'narf:org-export))
-  (bind! (:map markdown-mode-map
-           "<backspace>"  nil
-           "<M-left>"     nil
-           "<M-right>"    nil
+  (map! (:map markdown-mode-map
+          "<backspace>"  nil
+          "<M-left>"     nil
+          "<M-right>"    nil
 
-           ;; Assumes you have a markdown renderer plugin in chrome
-           :nv "M-r"  (λ (narf-open-with "Google Chrome"))
+          ;; Assumes you have a markdown renderer plugin in chrome
+          :nv "M-r"  (λ (narf-open-with "Google Chrome"))
 
-           "M-*"  'markdown-insert-list-item
-           "M-b"  'markdown-insert-bold
-           "M-i"  'markdown-insert-italic
-           "M-`"  'narf/markdown-insert-del
+          "M-*"  'markdown-insert-list-item
+          "M-b"  'markdown-insert-bold
+          "M-i"  'markdown-insert-italic
+          "M-`"  'narf/markdown-insert-del
 
-           :nv ",i"   'markdown-insert-image
-           :nv ",l"   'markdown-insert-link
-           :nv ",L"   'markdown-insert-reference-link-dwim
-           :nv ",b"   'markdown-preview
+          (:localleader
+           :nv "i"   'markdown-insert-image
+           :nv "l"   'markdown-insert-link
+           :nv "L"   'markdown-insert-reference-link-dwim
+           :nv "b"   'markdown-preview)
 
-           ;; TODO: Make context sensitive
-           :n "[p"   'markdown-promote
-           :n "]p"   'markdown-demote
+          ;; TODO: Make context sensitive
+          :n "[p"   'markdown-promote
+          :n "]p"   'markdown-demote
 
-           :i "M--"  'markdown-insert-hr)))
+          :i "M--"  'markdown-insert-hr)))
 
 ;; TODO: Test previewing capability
 
diff --git a/modules/module-org.el b/modules/module-org.el
index 764395fd7..f6067da36 100644
--- a/modules/module-org.el
+++ b/modules/module-org.el
@@ -399,117 +399,128 @@ will function properly."
   (define-key org-mode-map (kbd "C-j") nil)
   (define-key org-mode-map (kbd "C-k") nil)
   ;; Keybinds
-  (bind! (:map org-mode-map
-           :i [remap narf/inflate-space-maybe] 'org-self-insert-command
-           :i "RET" 'org-return-indent)
+  (map! (:map org-mode-map
+          :i [remap narf/inflate-space-maybe] 'org-self-insert-command
+          :i "RET" 'org-return-indent)
 
-         (:map evil-org-mode-map
-           :ni "A-l" 'org-metaright
-           :ni "A-h" 'org-metaleft
-           :ni "A-k" 'org-metaup
-           :ni "A-j" 'org-metadown
-           ;; Expand tables (or shiftmeta move)
-           :ni "A-L" 'narf/org-table-append-field-or-shift-right
-           :ni "A-H" 'narf/org-table-prepend-field-or-shift-left
-           :ni "A-K" 'narf/org-table-prepend-row-or-shift-up
-           :ni "A-J" 'narf/org-table-append-row-or-shift-down
+        (:map evil-org-mode-map
+          :ni "A-l" 'org-metaright
+          :ni "A-h" 'org-metaleft
+          :ni "A-k" 'org-metaup
+          :ni "A-j" 'org-metadown
+          ;; Expand tables (or shiftmeta move)
+          :ni "A-L" 'narf/org-table-append-field-or-shift-right
+          :ni "A-H" 'narf/org-table-prepend-field-or-shift-left
+          :ni "A-K" 'narf/org-table-prepend-row-or-shift-up
+          :ni "A-J" 'narf/org-table-append-row-or-shift-down
 
-           :i  "C-L" 'narf/org-table-next-field
-           :i  "C-H" 'narf/org-table-previous-field
-           :i  "C-K" 'narf/org-table-previous-row
-           :i  "C-J" 'narf/org-table-next-row
+          :i  "C-L" 'narf/org-table-next-field
+          :i  "C-H" 'narf/org-table-previous-field
+          :i  "C-K" 'narf/org-table-previous-row
+          :i  "C-J" 'narf/org-table-next-row
 
-           :i  "C-e" 'org-end-of-line
-           :i  "C-a" 'org-beginning-of-line
+          :i  "C-e" 'org-end-of-line
+          :i  "C-a" 'org-beginning-of-line
 
-           :nv "j"   'evil-next-visual-line
-           :nv "k"   'evil-previous-visual-line
-           :v  "<S-tab>" 'narf/yas-insert-snippet
+          :nv "j"   'evil-next-visual-line
+          :nv "k"   'evil-previous-visual-line
+          :v  "<S-tab>" 'narf/yas-insert-snippet
 
-           :i  "M-a" (λ (evil-visual-state) (org-mark-element))
-           :n  "M-a" 'org-mark-element
-           :v  "M-a" 'mark-whole-buffer
+          :i  "M-a" (λ (evil-visual-state) (org-mark-element))
+          :n  "M-a" 'org-mark-element
+          :v  "M-a" 'mark-whole-buffer
 
-           :ni "<M-return>"   (λ (narf/org-insert-item 'below))
-           :ni "<S-M-return>" (λ (narf/org-insert-item 'above))
+          :ni "<M-return>"   (λ (narf/org-insert-item 'below))
+          :ni "<S-M-return>" (λ (narf/org-insert-item 'above))
 
-           :i  "M-b" (λ (narf/org-surround "*")) ; bold
-           :i  "M-u" (λ (narf/org-surround "_")) ; underline
-           :i  "M-i" (λ (narf/org-surround "/")) ; italics
-           :i  "M-`" (λ (narf/org-surround "+")) ; strikethrough
+          :i  "M-b" (λ (narf/org-surround "*")) ; bold
+          :i  "M-u" (λ (narf/org-surround "_")) ; underline
+          :i  "M-i" (λ (narf/org-surround "/")) ; italics
+          :i  "M-`" (λ (narf/org-surround "+")) ; strikethrough
 
-           :v  "M-b" "S*"
-           :v  "M-u" "S_"
-           :v  "M-i" "S/"
-           :v  "M-`" "S+"
+          :v  "M-b" "S*"
+          :v  "M-u" "S_"
+          :v  "M-i" "S/"
+          :v  "M-`" "S+"
 
-           :n  ",;" 'helm-org-in-buffer-headings
-           :nv ",l" 'org-insert-link
-           :n  ",L" 'org-store-link
-           ;; TODO narf/org-replace-link-by-link-description
-           :n  ",=" 'org-align-all-tags
-           :n  ",f" 'org-sparse-tree
-           :n  ",?" 'org-tags-view
-           :n  ",e" 'org-edit-special
-           :n  ",a" 'org-agenda
-           :n  ",D" 'org-time-stamp-inactive
-           :n  ",i" 'narf/org-toggle-inline-images-at-point
-           :n  ",t" 'org-todo
-           :n  ",T" 'org-show-todo-tree
-           :n  ",d" 'org-time-stamp
-           :n  ",r" 'org-refile
-           :n  ",s" 'org-schedule
-           :n  ",oa" 'narf/org-attachment-reveal
-           :n  ", SPC" 'narf/org-toggle-checkbox
-           :n  ", RET" 'org-archive-subtree
+          (:leader
+           :n ";" 'helm-org-in-buffer-headings
+           :n "oa" 'narf/org-attachment-reveal
+           )
 
-           :n "za" 'org-cycle
-           :n "zA" 'org-shifttab
-           :n "zm" 'hide-body
-           :n "zr" 'show-all
-           :n "zo" 'show-subtree
-           :n "zO" 'show-all
-           :n "zc" 'hide-subtree
-           :n "zC" 'hide-all
+          (:localleader
+           :n  "/"  'org-sparse-tree
+           :n  "?"  'org-tags-view
 
-           :m  "]]" (λ (call-interactively 'org-forward-heading-same-level) (org-beginning-of-line))
-           :m  "[[" (λ (call-interactively 'org-backward-heading-same-level) (org-beginning-of-line))
-           :m  "]l" 'org-next-link
-           :m  "[l" 'org-previous-link
+           :n  "n"  (λ (if (buffer-narrowed-p) (widen) (org-narrow-to-subtree)))
+           :n  "e"  'org-edit-special
+           :n  "="  'org-align-all-tags
+           :nv "l"  'org-insert-link
+           :n  "L"  'org-store-link
+           :n  "x"  'narf/org-remove-link
+           :n  "w"  'writing-mode
+           :n  "SPC" 'narf/org-toggle-checkbox
+           :n  "RET" 'org-archive-subtree
 
-           :n  "RET" 'narf/org-dwim-at-point
+           :n  "a"  'org-agenda
+           :n  "A"  'narf:org-attachment-list
 
-           :m  "gh"  'outline-up-heading
-           :m  "gj"  'org-forward-heading-same-level
-           :m  "gk"  'org-backward-heading-same-level
-           :m  "gl"  (λ (call-interactively 'outline-next-visible-heading) (show-children))
+           :n  "d"  'org-time-stamp
+           :n  "D"  'org-time-stamp-inactive
+           :n  "i"  'narf/org-toggle-inline-images-at-point
+           :n  "t"  (λ (org-todo (if (org-entry-is-todo-p) 'none 'todo)))
+           :n  "T"  'org-todo
+           :n  "r"  'org-refile
+           :n  "s"  'org-schedule
+           )
 
-           :n  "go"  'org-open-at-point
-           :n  "gO"  (λ (let ((org-link-frame-setup (append '((file . find-file-other-window)) org-link-frame-setup))
-                              (org-file-apps '(("\\.org$" . emacs)
-                                               (t . "open \"%s\""))))
-                          (call-interactively 'org-open-at-point)))
+          :n  "za"  'org-cycle
+          :n  "zA"  'org-shifttab
+          :n  "zm"  'hide-body
+          :n  "zr"  'show-all
+          :n  "zo"  'show-subtree
+          :n  "zO"  'show-all
+          :n  "zc"  'hide-subtree
+          :n  "zC"  'hide-all
 
-           :n  "gQ" 'org-fill-paragraph
-           :m  "$" 'org-end-of-line
-           :m  "^" 'org-beginning-of-line
-           :n  "<" 'org-metaleft
-           :n  ">" 'org-metaright
-           :v  "<" (λ (org-metaleft)  (evil-visual-restore))
-           :v  ">" (λ (org-metaright) (evil-visual-restore))
-           :n  "-" 'org-cycle-list-bullet
-           :n  [tab] 'org-cycle)
+          :m  "]]"  (λ (call-interactively 'org-forward-heading-same-level) (org-beginning-of-line))
+          :m  "[["  (λ (call-interactively 'org-backward-heading-same-level) (org-beginning-of-line))
+          :m  "]l"  'org-next-link
+          :m  "[l"  'org-previous-link
 
-         (:map org-src-mode-map
-           :n  "<escape>" (λ (message "Exited") (org-edit-src-exit)))
+          :n  "RET" 'narf/org-dwim-at-point
 
-         (:after org-agenda
-           (:map org-agenda-mode-map
-             :e "<escape>" 'org-agenda-Quit
-             :e "C-j" 'org-agenda-next-item
-             :e "C-k" 'org-agenda-previous-item
-             :e "C-n" 'org-agenda-next-item
-             :e "C-p" 'org-agenda-previous-item)))
+          :m  "gh"  'outline-up-heading
+          :m  "gj"  'org-forward-heading-same-level
+          :m  "gk"  'org-backward-heading-same-level
+          :m  "gl"  (λ (call-interactively 'outline-next-visible-heading) (show-children))
+
+          :n  "go"  'org-open-at-point
+          :n  "gO"  (λ (let ((org-link-frame-setup (append '((file . find-file-other-window)) org-link-frame-setup))
+                             (org-file-apps '(("\\.org$" . emacs)
+                                              (t . "open \"%s\""))))
+                         (call-interactively 'org-open-at-point)))
+
+          :n  "gQ"  'org-fill-paragraph
+          :m  "$"   'org-end-of-line
+          :m  "^"   'org-beginning-of-line
+          :n  "<"   'org-metaleft
+          :n  ">"   'org-metaright
+          :v  "<"   (λ (org-metaleft)  (evil-visual-restore))
+          :v  ">"   (λ (org-metaright) (evil-visual-restore))
+          :n  "-"   'org-cycle-list-bullet
+          :n  [tab] 'org-cycle)
+
+        (:map org-src-mode-map
+          :n  "<escape>" (λ (message "Exited") (org-edit-src-exit)))
+
+        (:after org-agenda
+          (:map org-agenda-mode-map
+            :e "<escape>" 'org-agenda-Quit
+            :e "C-j" 'org-agenda-next-item
+            :e "C-k" 'org-agenda-previous-item
+            :e "C-n" 'org-agenda-next-item
+            :e "C-p" 'org-agenda-previous-item)))
 
     ;;; OS-Specific
   (cond (IS-MAC (narf-org-init-for-osx))
diff --git a/modules/module-python.el b/modules/module-python.el
index 6530de4db..723f6df84 100644
--- a/modules/module-python.el
+++ b/modules/module-python.el
@@ -22,14 +22,15 @@
     :init
     (associate! nose-mode :pattern "/test_.+\\.py\\'")
     :config
-    (bind! :map nose-mode-map
-           :n ",tr" 'nosetests-again
-           :n ",ta" 'nosetests-all
-           :n ",ts" 'nosetests-one
-           :n ",tv" 'nosetests-module
-           :n ",tA" 'nosetests-pdb-all
-           :n ",tO" 'nosetests-pdb-one
-           :n ",tV" 'nosetests-pdb-module))
+    (map! :map nose-mode-map
+          (:localleader
+           :n "tr" 'nosetests-again
+           :n "ta" 'nosetests-all
+           :n "ts" 'nosetests-one
+           :n "tv" 'nosetests-module
+           :n "tA" 'nosetests-pdb-all
+           :n "tO" 'nosetests-pdb-one
+           :n "tV" 'nosetests-pdb-module)))
 
   (use-package anaconda-mode
     :diminish anaconda-mode
@@ -39,8 +40,8 @@
     (add-hook! python-mode '(anaconda-mode eldoc-mode))
     (setq anaconda-mode-installation-directory (concat narf-temp-dir "anaconda/"))
     :config
-    (bind! :map anaconda-mode-map     :m "gd"     'anaconda-mode-goto-definitions)
-    (bind! :map anaconda-nav-mode-map :n [escape] 'anaconda-nav-quit)
+    (map! :map anaconda-mode-map     :m "gd"     'anaconda-mode-goto-definitions)
+    (map! :map anaconda-nav-mode-map :n [escape] 'anaconda-nav-quit)
 
     (advice-add 'anaconda-mode-doc-buffer :after 'narf*anaconda-mode-doc-buffer)
 
diff --git a/modules/module-regex.el b/modules/module-regex.el
index f5b32289a..66fcaaa93 100644
--- a/modules/module-regex.el
+++ b/modules/module-regex.el
@@ -5,14 +5,14 @@
   :config
   (require 'pcre2el)
   (setq reb-re-syntax 'pcre)
-  (bind! :map rxt-help-mode-map :n [escape] 'kill-buffer-and-window)
+  (map! :map rxt-help-mode-map :n [escape] 'kill-buffer-and-window)
 
   (add-hook! reb-mode 'narf|reb-cleanup)
   (evil-set-initial-state 'reb-mode 'insert)
-  (bind! :map reb-mode-map
-         :n "C-g"        'reb-quit
-         :n [escape]     'reb-quit
-         :n [backtab]    'reb-change-syntax))
+  (map! :map reb-mode-map
+        :n "C-g"        'reb-quit
+        :n [escape]     'reb-quit
+        :n [backtab]    'reb-change-syntax))
 
 (provide 'module-regex)
 ;;; module-regex.el ends here
diff --git a/modules/module-ruby.el b/modules/module-ruby.el
index 986638baf..f9534ba38 100644
--- a/modules/module-ruby.el
+++ b/modules/module-ruby.el
@@ -49,11 +49,12 @@
       ;; Rake
       (("task" "namespace") () "end")))
   :config
-  (bind! (:map rspec-mode-map
-           :n ",tr" 'rspec-rerun
-           :n ",ta" 'rspec-verify-all
-           :n ",ts" 'rspec-verify-single
-           :n ",tv" 'rspec-verify)))
+  (map! :map rspec-mode-map
+        (:localleader
+         :n "tr" 'rspec-rerun
+         :n "ta" 'rspec-verify-all
+         :n "ts" 'rspec-verify-single
+         :n "tv" 'rspec-verify)))
 
 (use-package inf-ruby
   :commands (inf-ruby inf-ruby-console-auto)
diff --git a/modules/module-rust.el b/modules/module-rust.el
index 3ecb4464a..58883b322 100644
--- a/modules/module-rust.el
+++ b/modules/module-rust.el
@@ -14,7 +14,9 @@
     :config
     (setq racer-cmd "/usr/local/bin/racer"
           racer-rust-src-path "~/Dropbox/lib/rust/src/")
-    (bind! :map rust-mode-map :m "gd" 'racer-find-definition)
+    (map! :map rust-mode-map :m "gd" 'racer-find-definition)
+
+    ;; TODO Unit test keybinds
 
     (add-hook! rust-mode '(racer-mode eldoc-mode flycheck-rust-setup))
     (define-company-backend! rust-mode (racer))))
diff --git a/modules/module-web.el b/modules/module-web.el
index bbbe6167e..a367ec4be 100644
--- a/modules/module-web.el
+++ b/modules/module-web.el
@@ -14,14 +14,15 @@
   (setq-default css-indent-offset 2)
   (setq scss-compile-at-save nil)
   :config
-  (bind! :map scss-mode-map
-         :n "M-r" 'narf/web-refresh-browser
-         :n ",;" 'helm-css-scss
-         :n ",:" 'helm-css-scss-multi)
+  (map! :map scss-mode-map
+        :n "M-r" 'narf/web-refresh-browser
+        (:leader
+         :n ";" 'helm-css-scss
+         :n ":" 'helm-css-scss-multi))
 
   (after! web-beautify
     (add-hook! scss-mode (setenv "jsbeautify_indent_size" "2"))
-    (bind! :map scss-mode-map :m "gQ" 'web-beautify-css))
+    (map! :map scss-mode-map :m "gQ" 'web-beautify-css))
 
   (after! emr
     (emr-declare-command 'narf/scss-toggle-inline-or-block
@@ -36,7 +37,7 @@
   :init
   (after! css-mode
     (add-hook! css-mode (setenv "jsbeautify_indent_size" "2"))
-    (bind! :map css-mode-map :m "gQ" 'web-beautify-css)))
+    (map! :map css-mode-map :m "gQ" 'web-beautify-css)))
 
 (use-package jade-mode
   :mode "\\.jade$"
@@ -56,26 +57,26 @@
   :config
   (after! web-beautify
     (add-hook! web-mode (setenv "jsbeautify_indent_size" "4"))
-    (bind! :map web-mode-map :m "gQ" 'web-beautify-html))
+    (map! :map web-mode-map :m "gQ" 'web-beautify-html))
 
   (after! nlinum
     ;; Fix blank line numbers after unfolding
     (advice-add 'web-mode-fold-or-unfold :after 'nlinum--flush))
 
-  (bind! :map web-mode-map
-         "M-/" 'web-mode-comment-or-uncomment
+  (map! :map web-mode-map
+        "M-/" 'web-mode-comment-or-uncomment
 
-         :n  "za" 'web-mode-fold-or-unfold
-         :n  ",t" 'web-mode-element-rename
+        :n  "za" 'web-mode-fold-or-unfold
+        (:localleader :n "t" 'web-mode-element-rename)
 
-         :n  "M-r" 'narf/web-refresh-browser
+        :n  "M-r" 'narf/web-refresh-browser
 
-         :nv "]a" 'web-mode-attribute-next
-         :nv "[a" 'web-mode-attribute-previous
-         :nv "]t" 'web-mode-tag-next
-         :nv "[t" 'web-mode-tag-previous
-         :nv "]T" 'web-mode-element-child
-         :nv "[T" 'web-mode-element-parent))
+        :nv "]a" 'web-mode-attribute-next
+        :nv "[a" 'web-mode-attribute-previous
+        :nv "]t" 'web-mode-tag-next
+        :nv "[t" 'web-mode-tag-previous
+        :nv "]T" 'web-mode-element-child
+        :nv "[T" 'web-mode-element-parent))
 
 (use-package emmet-mode
   :defer t
@@ -85,10 +86,10 @@
   (defvar emmet-mode-keymap (make-sparse-keymap))
   :config
   (setq emmet-move-cursor-between-quotes t)
-  (bind! :map emmet-mode-keymap
-         :v "M-e" 'emmet-wrap-with-markup
-         :i "M-e" 'emmet-expand-yas
-         :i "M-E" 'emmet-expand-line))
+  (map! :map emmet-mode-keymap
+        :v "M-e" 'emmet-wrap-with-markup
+        :i "M-e" 'emmet-expand-yas
+        :i "M-E" 'emmet-expand-line))
 
 (define-minor-mode jekyll-mode
   "Jekyll development mode."
diff --git a/private/my-bindings.el b/private/my-bindings.el
index 0446ed681..76eb4a5ea 100644
--- a/private/my-bindings.el
+++ b/private/my-bindings.el
@@ -6,46 +6,35 @@
 
 (eval-when-compile (require 'core-defuns))
 
-(bind!
- -
+;; See `narf-leader-prefix' & `narf-localleader-prefix' in ../core/core-vars.el
+
+(map!
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;; Global keymaps                     ;;
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
- "M-x"   'helm-M-x
- "M-;"   'eval-expression
- "M-/"   'evil-commentary-line
+ "M-x"  'helm-M-x
+ "M-;"  'eval-expression
+ "M-/"  'evil-commentary-line
+ "A-x"  'helm-M-x
+ "A-;"  'eval-expression
+ "A-/"  'evil-commentary-line
 
- "A-x"   'helm-M-x
- "A-;"   'eval-expression
- "A-/"   'evil-commentary-line
+ "M-0"  (λ (text-scale-set 0))
+ "M-="  'text-scale-increase
+ "M--"  'text-scale-decrease
 
- (:when window-system
-   "M-0" (λ (text-scale-set 0))
-   "M-=" 'text-scale-increase
-   "M--" 'text-scale-decrease)
+ "M-b"  'narf:build
+ "M-t"  'helm-projectile-find-file
+ "<f9>" 'what-face
+ "A-`"  'narf-switch-to-iterm
+ "C-`"  'narf/popup-toggle
+ "C-~"  'rtog/toggle-repl
 
- "M-b"   'narf:build
- "M-t"   'helm-projectile-find-file
- "A-`"   'narf-switch-to-iterm
- "C-`"   'narf/popup-toggle
- "C-~"   'rtog/toggle-repl
- "<f9>"  'what-face
-
- "M-w"   'evil-window-delete
- "M-W"   'delete-frame
- "M-n"   (λ (switch-to-buffer (generate-new-buffer "*new*")))
- "M-N"   (λ (let ((nlinum-p (and (featurep 'nlinum)
-                                 (memq 'nlinum--setup-window window-configuration-change-hook))))
-              ;; Disable nlinum to fix elusive "invalid face linum" bug
-              (remove-hook 'window-configuration-change-hook 'nlinum--setup-window t)
-              (let ((frame (new-frame))
-                    (frame-name (format "*new-%s*" (length narf-wg-frames))))
-                (with-selected-frame frame
-                  (wg-create-workgroup frame-name t)
-                  (add-to-list 'narf-wg-frames (cons frame frame-name))))
-              (when nlinum-p
-                (add-hook 'window-configuration-change-hook 'nlinum--setup-window nil t))))
+ "M-w"  'evil-window-delete
+ "M-W"  'delete-frame
+ "M-n"  'narf/new-buffer
+ "M-N"  'narf/new-frame
 
  ;; Simpler window navigation
  "C-j"  'evil-window-down
@@ -72,21 +61,6 @@
  :m "M-9"  (λ (narf:switch-to-workgroup-at-index 8))
 
  (:when IS-MAC
-   :ni "M-d"  'dash-at-point
-
-   ;; Add animated transitions to OSX emacs
-   "M-w"   'evil-window-delete
-   "M-W"   (λ (let ((data (assq (selected-frame) narf-wg-frames)))
-                (if data
-                    (progn (wg-delete-workgroup (wg-get-workgroup (cdr data)))
-                           (delete-frame (car data)))
-                  (delete-frame))))
-   "M-n"   (λ (switch-to-buffer (generate-new-buffer "*new*")))
-
-   ;; Textmate-esque indent shift left/right
-   :i "M-["           (kbd "C-o m l C-o I DEL C-o ` l")
-   :i "M-]"           (λ (evil-shift-right (point-at-bol) (point-at-eol)))
-
    "<A-left>"       'backward-word
    "<A-right>"      'forward-word
    "<M-backspace>"  'narf/backward-kill-to-bol-and-indent
@@ -98,7 +72,17 @@
    "M-q"            'evil-quit-all
    "M-z"            'undo
    "M-Z"            'redo
-   "C-M-f"          'narf:toggle-fullscreen)
+   "C-M-f"          'narf:toggle-fullscreen
+
+   :ni "M-d"        'dash-at-point
+
+   ;; Textmate-esque indent shift left/right
+   :i "M-["           (kbd "C-o m l C-o I DEL C-o ` l")
+   :i "M-]"           (λ (evil-shift-right (point-at-bol) (point-at-eol)))
+
+   ;; Restore osx text objects
+   :i "<A-backspace>" 'evil-delete-backward-word
+   :i "<A-delete>"    (λ (evil-forward-word) (evil-delete-backward-word)))
 
 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -106,69 +90,67 @@
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
  :m ";" 'evil-ex
+ (:leader
+  :nv ","   (λ (if (narf/project-p) (helm-projectile-switch-to-buffer) (helm-buffers-list)))
+  :nv "<"   'helm-buffers-list
+  :nv "."   'helm-find-files
+  :nv ">"   'helm-projectile-find-file-in-known-projects
+  :nv "/"   'helm-projectile-find-file
+  :nv ";"   'helm-semantic-or-imenu
+  :nv ":"   'helm-imenu-in-all-buffers
+  :nv "]"   'helm-etags-select
+  :nv "a"   'helm-projectile-find-other-file
+  :nv "E"  (λ (in! narf-emacs-dir (helm-projectile-find-file)))
+  :nv "m"   'helm-recentf
+  :nv "M"   'helm-projectile-recentf  ; recent PROJECT files
+  :nv "P"   'helm-projectile-switch-project
+  :v  "="   'align-regexp
+  :nv "r"   'emr-show-refactor-menu
+  :n  "R"   'narf/reset-theme
 
- ;; <leader>
- (:prefix ","
-   :nv ","   (λ (if (narf/project-p) (helm-projectile-switch-to-buffer) (helm-buffers-list)))
-   :nv "<"   'helm-buffers-list
-   :nv "."   'helm-find-files
-   :nv ">"   'helm-projectile-find-file-in-known-projects
-   :nv "/"   'helm-projectile-find-file
-   :nv ";"   'helm-semantic-or-imenu
-   :nv ":"   'helm-imenu-in-all-buffers
+  :n  "s"  (λ (narf:yas-snippets t))        ; ido snippets dir
+  :n  "h"  'diff-hl-diff-goto-hunk
+  :n  "e"  'narf/flycheck-errors
+  :nv "p"  'helm-show-kill-ring
 
-   :nv "]"   'helm-etags-select
-   :nv "a"   'helm-projectile-find-other-file
-   :nv "E"   (λ (in! narf-emacs-dir (helm-projectile-find-file)))
-   :nv "m"   'helm-recentf
-   :nv "M"   'helm-projectile-recentf  ; recent PROJECT files
-   :nv "p"   'helm-projectile-switch-project
-   :v  "="   'align-regexp
-   :nv "r"   'emr-show-refactor-menu
+  :n  "b"  'helm-bookmarks
+  :n  "w"  'narf:workgroup-display
+  :n  "W"  'narf:helm-wg
 
-   :nv "qq"  'evil-save-and-quit
-   :nv "QQ"  'narf/kill-all-buffers-do-not-remember
+  :nv "n"  'narf/neotree-toggle
+  :nv "N"  'narf/neotree-find
+  :nv "t"  'narf-switch-to-iterm
+  :nv "l"  'narf/nlinum-toggle
+  :nv "\\"  'evil-emacs-state
 
-   :n  "oo"  'narf-open-with
-   :n  "ob"  (λ (narf-open-with "Google Chrome"))
-   :n  "of"  (λ (narf-open-with "Finder.app" default-directory))
-   :n  "oF"  (λ (narf-open-with "Finder.app" (narf/project-root)))
-   :n  "ou"  (λ (narf-open-with "Transmit"))
-   :n  "oU"  (λ (narf-open-with "Transmit" default-directory))
-   :n  "ol"  (λ (narf-open-with "LaunchBar"))
-   :n  "oL"  (λ (narf-open-with "LaunchBar" default-directory))
-   :n  "ot"  (λ (narf:tmux-chdir nil t))
-   :n  "oT"  'narf:tmux-chdir
+  :nv "qq"  'evil-save-and-quit
+  :nv "QQ"  'narf/kill-all-buffers-do-not-remember
 
-   ;; Org
-   :nv "n."  (λ (in! org-directory (let ((helm-ff-skip-boring-files t)) (helm-find-files-1 org-directory))))
-   :nv "n/"  'narf/helm-org
-   :nv "np"  'narf/helm-org-projects
-   :nv "nc"  'narf/helm-org-contacts
-   :nv "ni"  'narf/helm-org-invoices
-   :nv "nw"  'narf/helm-org-writing)
+  ;; Open with O/S
+  :n  "oo"  'narf-open-with
+  :n  "ob"  (λ (narf-open-with "Google Chrome"))
+  :n  "of"  (λ (narf-open-with "Finder.app" default-directory))
+  :n  "oF"  (λ (narf-open-with "Finder.app" (narf/project-root)))
+  :n  "ou"  (λ (narf-open-with "Transmit"))
+  :n  "oU"  (λ (narf-open-with "Transmit" default-directory))
+  :n  "ol"  (λ (narf-open-with "LaunchBar"))
+  :n  "oL"  (λ (narf-open-with "LaunchBar" default-directory))
+  :n  "ot"  (λ (narf:tmux-chdir nil t))
+  :n  "oT"  'narf:tmux-chdir
 
- ;; <localleader>
- (:prefix "\\"
-   :nv "\\" 'narf/neotree-toggle
-   :nv "|"  'narf-switch-to-iterm
-   :nv "."  'narf/neotree-find
-   :nv ";"  'narf/nlinum-toggle
-   :nv "E"  'evil-emacs-state
+  ;; Org notes
+  :nv "x."  (λ (in! org-directory (let ((helm-ff-skip-boring-files t)) (helm-find-files-1 org-directory))))
+  :nv "x/"  'narf/helm-org
+  :nv "xp"  'narf/helm-org-projects
+  :nv "xc"  'narf/helm-org-contacts
+  :nv "xi"  'narf/helm-org-invoices
+  :nv "xw"  'narf/helm-org-writing)
 
-   :n  "]"  'next-buffer
-   :n  "["  'previous-buffer
+ (:localleader
+  :n  "\\" 'narf/neotree-toggle
+  :n  "."  'narf/neotree-find)
 
-   :n  "c"  'narf/reset-theme
-   :n  "s"  (λ (narf:yas-snippets t))        ; ido snippets dir
-   :n  "g"  'diff-hl-diff-goto-hunk
-   :n  "e"  (λ (call-interactively 'flycheck-buffer) (flycheck-list-errors))
-   :n  "p"  'helm-show-kill-ring
-   :n  "b"  'helm-bookmarks
-   :n  "w"  'narf:helm-wg
-   :n  "W"  'narf:workgroup-display)
-
- :nv "K"   'smart-up
+ :nv "K"  'smart-up
 
  ;; Don't move cursor on indent
  :n "="   (λ (save-excursion (call-interactively 'evil-indent)))
@@ -195,10 +177,10 @@
  :n "g="  'evil-numbers/inc-at-pt
  :n "g-"  'evil-numbers/dec-at-pt
 
- :n "gR"  'narf:eval-buffer
  :n "gc"  'evil-commentary
  :n "gx"  'evil-exchange
  :n "gr"  'narf:eval-region
+ :n "gR"  'narf:eval-buffer
  :v "gR"  'narf:eval-region-and-replace
  :m "gl"  'avy-goto-line
  :m "g]"  'smart-right
@@ -242,15 +224,10 @@
                           (hs-toggle-hiding)
                         (call-interactively 'evilmi-jump-items)))))
 
- ;; Restore osx text objects
- :i "<A-backspace>" 'evil-delete-backward-word
- :i "<A-delete>"    (λ (evil-forward-word) (evil-delete-backward-word))
-
- ;; Newline magic
+ ;; Textmate-esque newlines
  :i "<backspace>"   'backward-delete-char-untabify
  :i "<M-backspace>" 'narf/backward-kill-to-bol-and-indent
  :i "<C-return>"    'evil-ret-and-indent
- :i "<C-SPC>"       (λ (insert ", "))
 
  ;; escape from insert mode (more responsive than using key-chord-define)
  :ir  "j"    'narf:exit-mode-maybe
@@ -262,7 +239,7 @@
 
  :n "!"      'rotate-word-at-point
  :v "!"      'rotate-region
- :e [escape] 'evil-normal-state
+ :e "<escape>" 'evil-normal-state
 
  (:map evil-window-map ; prefix "C-w"
    "u"       'narf/undo-window-change
@@ -290,6 +267,7 @@
 
  ;; Vim omni-complete emulation
  :i "C-SPC"     'company-complete-common
+ :i "C-x C-l"   'narf/company-whole-lines
  :i "C-x C-k"   'company-dict
  :i "C-x C-f"   'company-files
  :i "C-x C-]"   'company-tags
@@ -313,12 +291,12 @@
      "C-SPC"      'company-complete-common-or-cycle
      [tab]        'narf/company-complete-common-or-complete-full
      "<backtab>"  'company-select-previous
-     [escape]     'company-abort
+     [escape]     (λ (company-abort) (evil-normal-state 1))
      "<C-return>" 'helm-company)
    (:map company-search-map
      "C-n"        'company-search-repeat-forward
      "C-p"        'company-search-repeat-backward
-     [escape]     'company-abort))
+     [escape]     'company-search-abort))
 
  (:after help-mode
    (:map help-mode-map
@@ -354,67 +332,67 @@
 
 ;; Restores "dumb" indentation to the tab key. This rustles a lot of
 ;; peoples' jimmies, apparently, but it's how I like it.
-(bind! :i "<tab>"   'narf/dumb-indent
-       :i "<C-tab>" 'indent-for-tab-command
+(map! :i "<tab>"   'narf/dumb-indent
+      :i "<C-tab>" 'indent-for-tab-command
 
-       ;; No dumb-tab for lisp
-       :i :map lisp-mode-map        [remap narf/dumb-indent] 'indent-for-tab-command
-       :i :map emacs-lisp-mode-map  [remap narf/dumb-indent] 'indent-for-tab-command
+      ;; No dumb-tab for lisp
+      :i :map lisp-mode-map        [remap narf/dumb-indent] 'indent-for-tab-command
+      :i :map emacs-lisp-mode-map  [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
+      ;; 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
+      ;; 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
+      ;; 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
+      ;; 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 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
+      ;; 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)))
+      ;; 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
-       :e [escape] 'narf-minibuffer-quit
-       (:map (minibuffer-local-map
-              minibuffer-local-ns-map
-              minibuffer-local-completion-map
-              minibuffer-local-must-match-map
-              minibuffer-local-isearch-map)
-         [escape] 'narf-minibuffer-quit)
+      ;; Make ESC quit all the things
+      :e [escape] 'narf-minibuffer-quit
+      (:map (minibuffer-local-map
+             minibuffer-local-ns-map
+             minibuffer-local-completion-map
+             minibuffer-local-must-match-map
+             minibuffer-local-isearch-map)
+        [escape] 'narf-minibuffer-quit)
 
-       :map read-expression-map "C-w" 'backward-kill-word)
+      :map read-expression-map "C-w" 'backward-kill-word)
 
-(bind! :i "A-o" (λ (insert "ø"))
-       :i "A-O" (λ (insert "Ø"))
+(map! :i "A-o" (λ (insert "ø"))
+      :i "A-O" (λ (insert "Ø"))
 
-       :i "A--" (λ (insert "–"))
-       :i "A-_" (λ (insert "—")))
+      :i "A--" (λ (insert "–"))
+      :i "A-_" (λ (insert "—")))
 
 ;; Disable the global drag-mouse map; clicking in new buffers often sends evil
 ;; into visual mode, which is UN...ACCEPTAABBLLLEEEE!