diff --git a/init.el b/init.el
index 2b6be0c9c..14945fc0a 100644
--- a/init.el
+++ b/init.el
@@ -47,5 +47,5 @@
     mod-cpp             ; C++ gamedev
     mod-eclim           ; Integration into eclipse (for Java)
     mod-csharp          ; Emacs as a Csharp/Unity IDE
-    mod-collab          ; For collab programming
+    ;; mod-collab          ; For collab programming
     ))
diff --git a/init/core-editor.el b/init/core-editor.el
index 6fb3b6ad4..ae58e6ea0 100644
--- a/init/core-editor.el
+++ b/init/core-editor.el
@@ -1,7 +1,16 @@
 ;;;; Editor behavior ;;;;;;;;;;;;;;;;
-(setq initial-scratch-buffer nil)   ; empty scratch buffer
-(electric-indent-mode +1) 			; auto-indent on RET
-(global-hl-line-mode +1)            ; highlight the line
+;; (electric-indent-mode +1) 			; auto-indent on RET
+;; (defun disable-electric-indent-mode ()
+;;   (set (make-local-variable 'electric-indent-mode) nil)
+;;   (setq-local tab-always-indent t))
+
+;; ;; Only enable electric-mode in programming languages
+;; (add-hook 'text-mode-hook 'disable-electric-indent-mode)
+;; (add-hook 'org-mode-hook 'disable-electric-indent-mode)
+;; (add-hook 'markdown-mode-hook 'disable-electric-indent-mode)
+
+;; (global-hl-line-mode +1)            ; highlight the line
+(blink-cursor-mode -1)
 (setq-default
   tab-width             4           ; set tab width to 4 for all buffers
   indent-tabs-mode      nil         ; use tabs, not spaces
@@ -28,13 +37,13 @@
     (evil-mode 1)
 
     (use-package evil-leader :ensure t)
-    (use-package evil-nerd-commenter :ensure t)
     (use-package evil-matchit :ensure t)
     (use-package evil-surround :ensure t)
     (use-package evil-numbers :ensure t)
     (use-package evil-exchange :ensure t)
     (use-package evil-space :ensure t)
     (use-package evil-visualstar :ensure t)
+    (use-package evil-nerd-commenter :ensure t)
     (use-package evil-ex-registers)
 
     ;; To get evil-leader mappings to work in the messages buffer...
diff --git a/init/core-keymaps.el b/init/core-keymaps.el
index 4ccdec732..8e2abf1e3 100644
--- a/init/core-keymaps.el
+++ b/init/core-keymaps.el
@@ -12,28 +12,30 @@
         (kbd "C-c l")   'send-to-launchbar
         (kbd "C-c L")   'send-dir-to-launchbar
         (kbd "C-c t")   'my/tmux-chdir
-        (kbd "C-c T")   (λ (my/tmux-chdir (projectile-project-root)))
-        )
+        (kbd "C-c T")   (λ (my/tmux-chdir (projectile-project-root))))
 
   ;; Evaluating elisp
   (nmap my/mode-map (kbd "C-c x") 'eval-buffer)
   (vmap my/mode-map (kbd "C-c x") 'eval-region)
 
   (when window-system
-    (global-set-key (kbd "s-=")	  'text-scale-increase)
-    (global-set-key (kbd "s--")	  'text-scale-decrease)
-    (global-set-key (kbd "s-/")   'evilnc-comment-or-uncomment-lines)
-    (global-set-key (kbd "s-w")   'evil-window-delete)
+    (global-set-key (kbd "s-=")	    'text-scale-increase)
+    (global-set-key (kbd "s--")	    'text-scale-decrease)
+    (global-set-key (kbd "s-w")     'evil-window-delete)
+    (global-set-key (kbd "s-/")     'evilnc-comment-or-uncomment-lines)
     (global-set-key (kbd "s-<f12>") 'toggle-frame-fullscreen)
 
-    (nmap my/mode-map
-          ;; Faster scrolling
-          (kbd "s-j") "5j"
-          (kbd "s-k") "5k"
+    ;; Faster scrolling
+    (mapc (lambda(map)
+            (evil-define-key map my/mode-map (kbd "s-j") "5j")
+            (evil-define-key map my/mode-map (kbd "s-k") "5k"))
+          '(emacs normal visual))
 
+    (nmap my/mode-map
           ;; Leader alternatives
           (kbd "s-f") 	'projectile-find-file
           (kbd "s-F") 	'projectile-ag
+          (kbd "s-p") 	'projectile-switch-project
           (kbd "s-m") 	'my/recentf-ido-find-file
           (kbd "s-M") 	'projectile-recentf
           (kbd "s-o") 	'ido-find-file
@@ -43,8 +45,8 @@
           (kbd "C-s-'") 'mc/mark-all-like-this
           (kbd "s-d")   'dash-at-point)
 
-    ;; Newlines from insert mode
     (imap my/mode-map
+          ;; Textmate-esque insert-line before/after
           (kbd "<s-return>")    'evil-open-below
           (kbd "<S-s-return>")  'evil-open-above
 
@@ -56,106 +58,114 @@
           ;; Fixes delete
           (kbd "<kp-delete>")   'delete-char)))
 
-
 ;; Local keymaps ;;;;;;;;;;;;;;;;
 (evil-leader/set-leader ",")
 (evil-leader/set-key
-  "`"       'my/notes
-  "'" 		'mc/mark-next-like-this
-  "\""		'mc/mark-all-like-this
-  "e"       'ido-find-file
-  "E"       'my/initfiles
-  "d"       'dash-at-point
-  "f"       'projectile-find-file
-  "F"       'projectile-ag
-  "g"       'git-gutter:stage-hunk
-  "G"       'git-gutter:revert-hunk
-  ;; "m"       'helm-recentf 					; recent GLOBAL files
-  "m"       'my/recentf-ido-find-file	    ; recent GLOBAL files
-  "M"       'projectile-recentf				; recent PROJECT files
-  "p"       'projectile-switch-project
-  "/"       'evilnc-comment-or-uncomment-lines
-  "\\"      'neotree-show
-  "|"       'neotree-hide
-  ";"       'helm-imenu
-  ":"       'my/ido-goto-symbol
-  ","       'ido-switch-buffer
-  "="       'align-regexp
-  "x"       'my/kill-other-buffers
-  "X"       'my/kill-all-buffers
-  (kbd "RET") 'org-capture)
+      "`"       'my/notes
+      "'" 		'mc/mark-next-like-this
+      "\""		'mc/mark-all-like-this
+      "e"       'ido-find-file
+      "E"       'my/initfiles
+      "d"       'dash-at-point
+      "f"       'projectile-find-file
+      "F"       'projectile-ag
+      "g"       'git-gutter:stage-hunk
+      "G"       'git-gutter:revert-hunk
+      "m"       'my/recentf-ido-find-file	    ; recent GLOBAL files
+      "M"       'projectile-recentf				; recent PROJECT files
+      "p"       'projectile-switch-project
+      "\\"      'neotree-show
+      "|"       'neotree-hide
+      ";"       'helm-imenu
+      ":"       'my/ido-goto-symbol
+      ","       'ido-switch-buffer
+      "="       'align-regexp
+      "x"       'my/kill-other-buffers
+      "X"       'my/kill-all-buffers
+      (kbd "RET") 'org-capture)
+
+;; Remap ; to : - SPC and shift-SPC replace ; and , - have to use
+;; define-key instead of n/vmap for this one to register.
+(define-key evil-normal-state-map ";" 'evil-ex)
+(define-key evil-visual-state-map ";" 'evil-ex)
 
 (nmap my/mode-map
-  ";"           'evil-ex            ; Remap ; to : - SPC and shift-SPC replace ; and ,
-  (kbd "C-;")   'eval-expression    ; Elisp command
+      (kbd "C-;")   'eval-expression    ; Elisp command
+      (kbd "s-;")   'my/tmux-run
+      (kbd "s-:")   'my/tmux-paste
 
-  ;; Moving rows rather than lines (in case of wrapping)
-  "j"       'evil-next-visual-line
-  "k"       'evil-previous-visual-line
+      ;; Moving rows rather than lines (in case of wrapping)
+      "j"       'evil-next-visual-line
+      "k"       'evil-previous-visual-line
 
-  "X"       'evil-destroy           ; Delete without yanking
+      "X"       'evil-destroy           ; Delete without yanking
 
-  ;; copy to end of line
-  "Y"       (λ (evil-yank (point) (point-at-eol)))
+      ;; behave like D and C; yank to end of line
+      "Y"       (λ (evil-yank (point) (point-at-eol)))
 
-  "zz"      'kill-this-buffer       ; Close buffer
-  "]b"      'previous-buffer
-  "[b"      'next-buffer
-  "]e"      'next-error
-  "[e"      'previous-error
-  "]g"      'git-gutter:next-hunk
-  "[g"      'git-gutter:previous-hunk
+      "zz"      'kill-this-buffer       ; Close buffer
+      "]b"      'previous-buffer
+      "[b"      'next-buffer
+      "]e"      'next-error
+      "[e"      'previous-error
+      "]h"      'git-gutter:next-hunk
+      "[h"      'git-gutter:previous-hunk
 
-  ;; winner-mode: window layout undo/redo (see init-core.el)
-  (kbd "C-w u")     'winner-undo
-  (kbd "C-w C-r")   'winner-redo
+      ;; winner-mode: window layout undo/redo (see init-core.el)
+      (kbd "C-w u")     'winner-undo
+      (kbd "C-w C-r")   'winner-redo
 
-  ;; Increment/decrement number under cursor
-  (kbd "C--")  'evil-numbers/inc-at-pt
-  (kbd "C-+")  'evil-numbers/dec-at-pt)
+      ;; Increment/decrement number under cursor
+      (kbd "C--")  'evil-numbers/inc-at-pt
+      (kbd "C-+")  'evil-numbers/dec-at-pt)
 
 (vmap my/mode-map
-  ; vnoremap < <gv
-  "<"      (λ (evil-shift-left (region-beginning) (region-end))
-              (evil-normal-state)
-              (evil-visual-restore))
-  ; vnoremap > >gv
-  ">"      (λ (evil-shift-right (region-beginning) (region-end))
-              (evil-normal-state)
-              (evil-visual-restore)))
+      ;; vnoremap < <gv
+      "<"      (λ (evil-shift-left (region-beginning) (region-end))
+                  (evil-normal-state)
+                  (evil-visual-restore))
+      ;; vnoremap > >gv
+      ">"      (λ (evil-shift-right (region-beginning) (region-end))
+                  (evil-normal-state)
+                  (evil-visual-restore)))
 
 (imap my/mode-map
-  (kbd "s-j")         'evil-join
-  (kbd "M-SPC")       'expand-space
-  (kbd "<C-return>")  'indent-new-comment-line)
+      ;; Make DEL act like expandtab in vim
+      (kbd "DEL")           'backward-delete-whitespace-to-column
+      ;; Join lines from insert mode
+      (kbd "<M-kp-delete>") 'evil-join
+
+      ;; Newline magic
+      (kbd "RET")           'newline-and-indent
+      (kbd "M-RET")         (kbd "RET DEL")
+      (kbd "<C-return>")    'indent-new-comment-line
+
+      ;; Textmate-esque indent shift left/right
+      (kbd "s-[")           (λ (evil-shift-left (point-at-bol) (point-at-eol)))
+      (kbd "s-]")           (λ (evil-shift-right (point-at-bol) (point-at-eol)))
+      (kbd "<backtab>")     (kbd "S-["))
 
 (emap my/mode-map
-  ;; Preserve buffer-movement in emacs mode
-  "j" 'evil-next-line
-  "k" 'evil-previous-line
+      ;; Preserve buffer-movement in emacs mode
+      "j" 'evil-next-line
+      "k" 'evil-previous-line
 
-  (kbd "C-w h") 'evil-window-left
-  (kbd "C-w l") 'evil-window-right
-  (kbd "C-w j") 'evil-window-down
-  (kbd "C-w k") 'evil-window-up
-
-  (kbd "s-j") "5j"
-  (kbd "s-k") "5k")
-
-;; Commenting lines
-(nmap my/mode-map "gcc" 'evilnc-comment-or-uncomment-lines)
-(vmap my/mode-map "gc"  'evilnc-comment-or-uncomment-lines)
+      (kbd "C-w h") 'evil-window-left
+      (kbd "C-w l") 'evil-window-right
+      (kbd "C-w j") 'evil-window-down
+      (kbd "C-w k") 'evil-window-up)
 
 ;; Rotate-text (see elisp/rotate-text.el)
 (nmap my/mode-map "!" 'rotate-word-at-point)
 (vmap my/mode-map "!" 'rotate-region)
 
-;; Enable TAB to do matchit
-(nmap evil-matchit-mode-map (kbd "TAB") 'evilmi-jump-items)
-
 ;; Easy escape from insert mode
 (ichmap "jj" 'evil-normal-state)
 
+;; Enable TAB to do matchit
+(nmap evil-matchit-mode-map (kbd "TAB") 'evilmi-jump-items)
+
+;; Real go-to-definition for elisp
 (nmap emacs-lisp-mode-map "gd"
       (λ (let ((func (function-called-at-point)))
            (if func (find-function func)))))
@@ -168,16 +178,14 @@
 
 ;;;; Keymap fixes ;;;;;;;;;;;;;;;
 ;; Make ESC quit all the things
-(nmap my/mode-map [escape] 'keyboard-quit)
-(vmap my/mode-map [escape] 'keyboard-quit)
+(nvmap my/mode-map [escape] 'keyboard-quit)
 (mapc (lambda (map)
     (define-key map [escape] 'minibuffer-quit))
-      (list
-        minibuffer-local-map
-        minibuffer-local-ns-map
-        minibuffer-local-completion-map
-        minibuffer-local-must-match-map
-        minibuffer-local-isearch-map))
+      (list minibuffer-local-map
+            minibuffer-local-ns-map
+            minibuffer-local-completion-map
+            minibuffer-local-must-match-map
+            minibuffer-local-isearch-map))
 (global-set-key [escape] 'evil-exit-emacs-state)
 ;; Close help window with escape
 (define-key global-map [escape] 'quit-window)
@@ -196,9 +204,7 @@
     ;; take that "Text is read-only" and stick it where emacs don't shine!
     (define-key ido-completion-map (kbd "<backspace>") 'ido-delete-backward-updir)
     (define-key ido-completion-map "\C-n" 'ido-next-match)
-    (define-key ido-completion-map "\C-f" 'ido-next-match)
     (define-key ido-completion-map "\C-p" 'ido-prev-match)
-    (define-key ido-completion-map "\C-b" 'ido-prev-match)
 
     ;; Auto-complete on tab/space (why is it called ido-exit-minibuffer?)
     (define-key ido-completion-map " " 'ido-exit-minibuffer)))
@@ -218,5 +224,21 @@
     (when (get-buffer "*Completions*") (delete-windows-on "*Completions*"))
     (abort-recursive-edit)))
 
+;; Mimic expandtab in vim
+(defun backward-delete-whitespace-to-column ()
+  "delete back to the previous column of whitespace, or as much whitespace as possible,
+or just one char if that's not possible"
+  (interactive)
+  (if indent-tabs-mode
+      (call-interactively 'backward-delete-char-untabify)
+    (let ((movement (% (current-column) tab-width))
+          (p (point)))
+      (when (= movement 0) (setq movement tab-width))
+      (save-match-data
+        (if (string-match "\\w*\\(\\s-+\\)$" (buffer-substring-no-properties (- p movement) p))
+            (backward-delete-char-untabify (- (match-end 1) (match-beginning 1)))
+        (call-interactively 'backward-delete-char-untabify))))))
+
+
 ;;
 (provide 'core-keymaps)
diff --git a/init/core.el b/init/core.el
index 421c7c27e..1dbcf8d36 100644
--- a/init/core.el
+++ b/init/core.el
@@ -24,7 +24,8 @@
       inhibit-startup-buffer-menu t
       inhibit-startup-echo-area-message t
       initial-major-mode 'text-mode
-      initial-scratch-message nil)
+      initial-scratch-message nil
+      initial-scratch-buffer nil)   ; empty scratch buffer
 
 (setq require-final-newline nil)
 
@@ -40,23 +41,17 @@
 ;; window layout undo/redo, keymaps in core-keymaps.el
 (when (fboundp 'winner-mode) (winner-mode 1))
 
-(defconst is-mac
-  (eq system-type 'darwin)
-  "Is this running on OS X?")
-(defconst is-linux
-  (eq system-type 'gnu/linux)
-  "Is this running on Linux?")
+(defconst is-mac (eq system-type 'darwin))
+(defconst is-linux (eq system-type 'gnu/linux))
 
 ;;;; Advice ;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Make next/previous-buffer skip special buffers
 (defadvice next-buffer (after avoid-messages-buffer-in-next-buffer)
   "Advice around `next-buffer' to avoid going into the *Messages* buffer."
-  (when (string= "*Messages*" (buffer-name))
-    (next-buffer)))
+  (when (string-match "\\`\\*.+\\*\\'" (buffer-name)) (next-buffer)))
 (defadvice previous-buffer (after avoid-messages-buffer-in-previous-buffer)
   "Advice around `previous-buffer' to avoid going into the *Messages* buffer."
-  (when (string= "*Messages*" (buffer-name))
-    (previous-buffer)))
+  (when (string-match "\\`\\*.+\\*\\'" (buffer-name)) (previous-buffer)))
 
 ;;;; My personal minor mode ;;;;;;;;
 (defvar my/mode-map (make-sparse-keymap))
@@ -66,7 +61,7 @@
 (require 'core-packages)
 (require 'core-ui)
 (require 'core-editor)
-(when is-mac (require 'core-osx))
+(if is-mac (require 'core-osx))
 
 (add-hook 'after-init-hook (lambda() (require 'core-keymaps)))
 
diff --git a/init/init-ac.el b/init/init-ac.el
index 8b3eed05f..81dae81f2 100644
--- a/init/init-ac.el
+++ b/init/init-ac.el
@@ -35,8 +35,7 @@
     (define-key ac-completing-map [return] nil)
 
     ;; Tell ido not to care about case
-    (setq completion-ignore-case t)
-    ))
+    (setq completion-ignore-case t)))
 
 ;;
 (provide 'init-ac)
diff --git a/init/init-fly.el b/init/init-fly.el
index f8417a397..2b698c7b5 100644
--- a/init/init-fly.el
+++ b/init/init-fly.el
@@ -1,5 +1,4 @@
 (use-package flycheck :ensure t
-    :commands global-flycheck-mode
     :init (add-hook 'after-init-hook #'global-flycheck-mode)
     :config
     (progn
diff --git a/init/init-project.el b/init/init-project.el
index 84fc9a5d5..9dc6253a6 100644
--- a/init/init-project.el
+++ b/init/init-project.el
@@ -10,9 +10,9 @@
                     dired-dwim-target t))))
 
 (use-package ag :ensure t :defer t)
-;; (use-package helm :ensure t :defer t)
+(use-package helm :ensure t :defer t)
 (use-package grizzl :ensure t :defer t)
-(use-package neotree :commands (neotree-show neotree-hide neotree-toggle))
+(use-package neotree :ensure t :commands (neotree-show neotree-hide neotree-toggle))
 
 (use-package projectile :ensure t
   :diminish projectile-mode
@@ -22,7 +22,7 @@
                projectile-enable-caching t)))
 
 (use-package ido
-  :pre-load
+  :init
   (progn
     ;; ido remaps its keys every time it's invoked, this screws with
     ;; custom mappings. So we've gotta neuter ido.
diff --git a/init/init-snippets.el b/init/init-snippets.el
index 45da9a893..a406f4e1e 100644
--- a/init/init-snippets.el
+++ b/init/init-snippets.el
@@ -25,6 +25,7 @@
     (progn
       (add-hook 'prog-mode-hook 'yas-minor-mode)
       (add-hook 'snippet-mode-hook 'yas-minor-mode)
+      (add-hook 'markdown-mode-hook 'yas-minor-mode)
       (add-hook 'org-mode-hook 'yas-minor-mode)))
 
 ;;
diff --git a/init/mod-cpp.el b/init/mod-cpp.el
index 890c94748..61221b38d 100644
--- a/init/mod-cpp.el
+++ b/init/mod-cpp.el
@@ -17,5 +17,17 @@
          ("\\.frag\\'" . glsl-mode)
          ("\\.geom\\'" . glsl-mode)))
 
+(define-minor-mode cocos2d-mode
+  "Buffer local minor mode for Cocos2D-x"
+  :init-value nil
+  :lighter " C2D"
+  :keymap (make-sparse-keymap))
+
+(defun cocoa2d-mode-maybe()
+  (let ((root (projectile-project-root)))
+    (if (or (string-match "[.-]cocos2d/" root)
+            (file-exists-p (concat root ".cocos2d-mode")))
+        (cocos-mode t))))
+
 ;;
 (provide 'mod-cpp)
diff --git a/init/mod-dev.el b/init/mod-dev.el
index 3fcb6e180..0a3012d24 100644
--- a/init/mod-dev.el
+++ b/init/mod-dev.el
@@ -1,3 +1,5 @@
+(add-hook 'prog-mode-hook 'my/enable-comment-hard-wrap)
+
 (add-to-list 'auto-mode-alist '("\\.plist\\'" . nxml-mode))
 
 (use-package dash-at-point :ensure t
@@ -8,7 +10,11 @@
     (add-to-list 'dash-at-point-mode-alist '(ruby-mode . "rb"))
     (add-to-list 'dash-at-point-mode-alist '(python-mode . "py2"))))
 
-(use-package yaml-mode :ensure t :mode "\\.yaml\\'")
+(use-package yaml-mode :ensure t
+  :defer t
+  :config
+  (defun my/setup-yaml-mode () (setq tab-width 2))
+  (add-hook 'yaml-mode-hook 'my/setup-yaml-mode))
 
 (use-package json-mode :ensure t
   :mode (("\\.json\\'" . json-mode)
@@ -63,6 +69,5 @@
     (my/setup-run-code ruby-mode-map "ruby")
     (nmap ruby-mode-map "gd" 'rsense-jump-to-definition)))
 
-
 ;;
 (provide 'mod-dev)
diff --git a/init/mod-love.el b/init/mod-love.el
index 6e4a2886e..9322424d6 100644
--- a/init/mod-love.el
+++ b/init/mod-love.el
@@ -1,28 +1,27 @@
 (use-package lua-mode :ensure t
   :mode "\\.lua\\'"
   :interpreter "lua"
+  :config
+  (my/setup-run-code lua-mode-map "lua")
   :init
   (progn
     (define-minor-mode love-mode
-      "Buffer local minor mode for evil-org"
+      "Buffer local minor mode for Love2D"
       :init-value nil
       :lighter " <3"
       :keymap (make-sparse-keymap) ; defines love-mode-map
       :group lua)
 
-    (define-key love-mode-map (kbd "s-b")
-      (λ (shell-command (concat "open -a love.app " default-directory))))
+    (nmap love-mode-map (kbd ",b")
+      (λ (shell-command (concat "open -a love.app " (projectile-project-root)))))
 
-    (add-hook 'lua-mode-hook
-        (lambda()
-          (if (string-match "\\.love/.+\\.lua\\'" (buffer-file-name))
-              (love-mode t))
+    (add-hook 'lua-mode-hook 'love-mode-maybe)))
 
-          (nmap lua-mode-map (kbd "s-r")
-                (lambda() (interactive) (shell-command-on-region (point-min) (point-max) "lua")))
-          (vmap lua-mode-map (kbd "s-r")
-                (lambda() (interactive) (shell-command-on-region (region-beginning) (region-end) "lua")))
-          ))))
+(defun love-mode-maybe()
+  (let ((root (projectile-project-root)))
+    (if (or (string-match "[.-]love/" root)
+            (file-exists-p (concat root ".love-mode")))
+        (love-mode t))))
 
 ;;
 (provide 'mod-love)
diff --git a/init/mod-org.el b/init/mod-org.el
index 3e459091c..7224dd19a 100644
--- a/init/mod-org.el
+++ b/init/mod-org.el
@@ -12,6 +12,9 @@
   (funcall fun)
   (evil-append nil))
 
+(defun my/org-surround (delim)
+  (insert delim) (save-excursion (insert delim)))
+
 ;;
 (use-package org :ensure t
   :mode ("\\.org\\'" . org-mode)
@@ -19,12 +22,14 @@
   (progn
     (setq org-directory "~/Dropbox/notes")
     (setq org-default-notes-file "~/Dropbox/notes/notes.org")
-    (setq org-archive-location "~/Dropbox/notes/archives.org")
+    (setq org-mobile-inbox-for-pull "~/Dropbox/notes/notes.org")
+    (setq org-mobile-directory "~/Dropbox/Apps/MobileOrg")
     (setq org-agenda-files '("~/Dropbox/notes/gtd.org"
                              "~/Dropbox/notes/notes.org"
                              "~/Dropbox/notes/blog.org"
                              "~/Dropbox/notes/invoices.org"
                              "~/Dropbox/notes/journal.org"
+                             "~/Dropbox/notes/trivia.org"
                              "~/Dropbox/notes/vocab.org"
                              "~/Dropbox/notes/excerpts.org"))
 
@@ -32,7 +37,9 @@
     (setq org-hide-leading-stars t)
     (setq org-export-backends '(ascii html latex md))
     (setq org-todo-keywords
-          '((sequence "TODO" "DOING" "VERIFY" "WAITING" "|" "DONE" "DELEGATED" "CANCELLED")))
+          '((sequence "TODO(t)" "|" "DONE(d)")
+            (sequence "STARTED(s)" "VERIFY(v)" "WAITING(w)")
+            (sequence "|" "CANCELLED(c)")))
 
     (org-babel-do-load-languages 'org-babel-load-languages
           '((python . t)
@@ -61,8 +68,10 @@
             ("n" "Note" entry (file+datetree org-default-notes-file) "** %?")
             ("b" "Blog" entry (file+datetree "~/Dropbox/notes/blog.org") "** %?")
             ("j" "Journal" entry (file+datetree "~/Dropbox/notes/journal.org") "** %?%^g\n%?\nAdded: %U")
-            ("v" "Vocab" entry (file "~/Dropbox/notes/vocab.org") "* %?" :prepend t)
-            ("e" "Excerpt" entry (file "~/Dropbox/notes/excerpts.org") "* %?" :prepend t)))
+            ("a" "Trivia" entry (file "~/Dropbox/notes/trivia.org") "* %u %?" :prepend t)
+            ("s" "Writing Scraps" entry (file "~/Dropbox/notes/writing.org") "* %u %?" :prepend t)
+            ("v" "Vocab" entry (file "~/Dropbox/notes/vocab.org") "* %u %?" :prepend t)
+            ("e" "Excerpt" entry (file "~/Dropbox/notes/excerpts.org") "* %u %?" :prepend t)))
 
     (setq org-agenda-custom-commands
           '(("x" agenda)
@@ -85,31 +94,45 @@
     ;; (emap org-agenda-mode-map
     ;;       ...)
 
+    ;; Formatting shortcuts
+    ;; Bold
+    (vmap evil-org-mode-map (kbd "s-b") "s*")
+    (imap evil-org-mode-map (kbd "s-b") (λ (my/org-surround "*")))
+    ;; Italics
+    (vmap evil-org-mode-map (kbd "s-i") "s/")
+    (imap evil-org-mode-map (kbd "s-i") (λ (my/org-surround "/")))
+    ;; Underline
+    (imap evil-org-mode-map (kbd "s-u") (λ (my/org-surround "_")))
+    ;; Strikethrough
+    (imap evil-org-mode-map (kbd "s-`") (λ (my/org-surround "+")))
+
     (imap evil-org-mode-map
           (kbd "<s-return>") 'org-insert-heading-after-current)
 
-    (vmap evil-org-mode-map
+    (nvmap evil-org-mode-map
           ",l" 'org-insert-link)
 
+    ;; (vmap evil-org-mode-map
+    ;;       ",l" 'org-insert-link)
+
     (nmap evil-org-mode-map
-          ",l" 'org-insert-link
+          ",d" 'org-time-stamp
+          ",D" 'org-time-stamp-inactive
           ",s" 'org-schedule
           ",a" 'org-attach
-          ",A" 'org-agenda
+          ",A" 'org-attach-open
           ",t" 'org-todo
           ",T" 'org-show-todo-tree
-          ",\\" 'org-match-sparse-tree
+          ",/" 'org-match-sparse-tree
+          ",?" 'org-tags-view
           ",+" 'org-align-all-tags
+          ",r" 'org-refile
           "gh" 'outline-up-heading
-          "gj" (if (fboundp 'org-forward-same-level) ;to be backward compatible with older org version
-                   'org-forward-same-level
-                 'org-forward-heading-same-level)
-          "gk" (if (fboundp 'org-backward-same-level)
-                   'org-backward-same-level
-                 'org-backward-heading-same-level)
+          "gj" 'org-forward-heading-same-level
+          "gk" 'org-backward-heading-same-level
           "gl" 'outline-next-visible-heading
           "go" 'org-open-at-point
-          "gr" 'org-refile
+          "ga" 'org-agenda
           "H" 'org-beginning-of-line
           "L" 'org-end-of-line
           "$" 'org-end-of-line
@@ -117,9 +140,9 @@
           "<" 'org-metaleft
           ">" 'org-metaright
           "-" 'org-cycle-list-bullet
-          (kbd "RET") (λ (org-insert-heading-after-current) (evil-insert-state))
-          (kbd "SPC") 'org-todo
-          (kbd "M-SPC") (λ (org-todo "DONE"))
+          (kbd ", SPC") 'org-archive-subtree
+          (kbd "<s-return>") (λ (org-insert-heading-after-current) (evil-insert-state))
+          (kbd "RET") (λ (org-todo 'done))
           (kbd "TAB") 'org-cycle)
 
     ;; normal & insert state shortcuts.
@@ -134,7 +157,7 @@
               (kbd "M-H") 'org-shiftmetaleft
               (kbd "M-K") 'org-shiftmetaup
               (kbd "M-J") 'org-shiftmetadown
-              (kbd "M-o") '(lambda () (interactive)
+              (kbd "<M-return>") '(lambda () (interactive)
                              (my/org-eol-call
                               '(lambda()
                                  (org-insert-heading)
diff --git a/init/mod-text.el b/init/mod-text.el
index 2cd95de2c..61a131ff8 100644
--- a/init/mod-text.el
+++ b/init/mod-text.el
@@ -3,13 +3,50 @@
 (use-package markdown-mode :ensure t
   :mode (("\\.md\\'" . markdown-mode)
          ("/README\\'" . markdown-mode))
-  :init
-  (add-hook 'markdown-mode-hook
-            (lambda()
-              ;; Restore native mac M-left/right functionality
-              (local-unset-key (kbd "<M-left>"))
-              (local-unset-key (kbd "<M-right>")))))
+  :config
+  (progn
+    (let ((map markdown-mode-map))
+      (define-key map (kbd "<backspace>") nil)
+      (define-key map (kbd "<M-left>") nil)
+      (define-key map (kbd "<M-right>") nil)
 
+      (nvmap map
+             (kbd ",i") 'markdown-insert-image
+             (kbd ",l") 'markdown-insert-link
+             (kbd ",L") 'markdown-insert-reference-link-dwim)
+
+      (imap map (kbd "M--") 'markdown-insert-hr)
+
+      (nmap map
+            "[p" 'markdown-promote
+            "]p" 'markdown-demote)
+
+      (define-key map (kbd "s-*") 'markdown-insert-list-item)
+      (define-key map (kbd "s-b") 'markdown-insert-bold)
+      (define-key map (kbd "s-i") 'markdown-insert-italic)
+      (define-key map (kbd "s-`") 'markdown-insert-del)
+      )
+    ))
+
+(defvar markdown-regex-del "\\(^\\|[^\\]\\)\\(\\(~\\{2\\}\\)\\([^ \n	\\]\\|[^ \n	]\\(?:.\\|\n[^\n]\\)*?[^\\ ]\\)\\(\\3\\)\\)")
+(defun markdown-insert-del ()
+  "Insert markup to make a region or word bold.
+If there is an active region, make the region bold.  If the point
+is at a non-bold word, make the word bold.  If the point is at a
+bold word or phrase, remove the bold markup.  Otherwise, simply
+insert bold delimiters and place the cursor in between them."
+  (interactive)
+  (let ((delim "~~"))
+    (if (markdown-use-region-p)
+        ;; Active region
+        (let ((bounds (markdown-unwrap-things-in-region
+                       (region-beginning) (region-end)
+                       markdown-regex-del 2 4)))
+          (markdown-wrap-or-insert delim delim nil (car bounds) (cdr bounds)))
+      ;; Bold markup removal, bold word at point, or empty markup insertion
+      (if (thing-at-point-looking-at markdown-regex-del)
+          (markdown-unwrap-thing-at-point nil 2 4)
+        (markdown-wrap-or-insert delim delim 'word nil nil)))))
 
 ;;
 (provide 'mod-text)
diff --git a/init/mod-webdev.el b/init/mod-webdev.el
index 9c41001b9..a2fb1e658 100644
--- a/init/mod-webdev.el
+++ b/init/mod-webdev.el
@@ -4,14 +4,9 @@
 
 (use-package scss-mode :ensure t
   :mode "\\.scss\\'"
-  :config
-  (add-hook 'scss-mode-hook (lambda() (add-to-list 'ac-sources 'ac-css-mode-setup))))
+  :config (add-hook 'scss-mode-hook 'ac-css-mode-setup))
 
 (use-package haml-mode :ensure t :mode "\\.haml\\'")
-(use-package web-mode :ensure t
-  :mode (("\\.\\(p\\)?htm\\(l\\)?\\'" . web-mode)
-         ("\\.tpl\\(\\.php\\)?\\'" . web-mode)
-         ("\\.erb\\'" . web-mode)))
 
 (use-package php-mode :ensure t
   :mode (("\\.php\\'" . php-mode)
@@ -22,9 +17,13 @@
     (my/setup-run-code php-mode-map "php")
     (setq php-template-compatibility nil)))
 
-(use-package js-mode
-  :mode "\\.js\\'"
-  :interpreter "node")
+(use-package web-mode :ensure t
+  :mode (("\\.\\(p\\)?htm\\(l\\)?\\'" . web-mode)
+         ("\\.tpl\\(\\.php\\)?\\'" . web-mode)
+         ("\\.erb\\'" . web-mode)
+         ("wp-content/themes/.+/.+\\.php\\'" . web-mode))
+  :config
+  (add-hook 'web-mode-hook 'jekyll-mode-maybe))
 
 (use-package tern :ensure t
   :commands tern-mode
@@ -44,12 +43,36 @@
 (use-package emmet-mode :ensure t
   :defer t
   :config
-  (imap 'emmet-mode-map (kbd "s-e") 'emmet-expand-line)
+  (progn
+    (imap emmet-mode-keymap (kbd "s-e") 'emmet-expand-yas)
+    (imap emmet-mode-keymap (kbd "s-E") 'emmet-expand-line)
+
+    (setq emmet-move-cursor-between-quotes t))
   :init
   (progn
     (add-hook 'scss-mode-hook   'emmet-mode)
     (add-hook 'web-mode-hook    'emmet-mode)
+    (add-hook 'haml-mode-hook   'emmet-mode)
     (add-hook 'nxml-mode-hook   'emmet-mode)))
 
+;; Jekyll support
+(define-minor-mode jekyll-mode
+  :init-value nil
+  :lighter " :{"
+  :keymap (make-sparse-keymap))
+
+(defun jekyll-mode-maybe()
+  (let ((root (projectile-project-root)))
+    (if (or (string-match "[.-]jekyll/" root)
+            (file-exists-p (concat root ".jekyll-mode")))
+        (jekyll-mode t))))
+
+(nmap jekyll-mode-map (kbd ",b")
+  (λ (open-file-with "http://localhost:4000")))
+
+(add-hook 'scss-mode-hook 'jekyll-mode-maybe)
+(add-hook 'web-mode-hook 'jekyll-mode-maybe)
+(add-hook 'markdown-mode-hook 'jekyll-mode-maybe)
+
 ;;
 (provide 'mod-webdev)
diff --git a/init/my-defuns.el b/init/my-defuns.el
index e0dcdd604..0dd0c3a10 100644
--- a/init/my-defuns.el
+++ b/init/my-defuns.el
@@ -11,6 +11,9 @@
   `(evil-define-key 'insert ,map ,@body))
 (defmacro emap (map &rest body)
   `(evil-define-key 'emacs ,map ,@body))
+(defmacro nvmap (map &rest body)
+  `(evil-define-key 'normal ,map ,@body)
+  `(evil-define-key 'visual ,map ,@body))
 
 ;; insert-mode key-chord mapping
 (defmacro ichmap (key command)
@@ -29,22 +32,6 @@
   (switch-to-buffer (get-buffer-create "*scratch*"))
   (text-mode))
 
-(defun my/expand-space ()
-  "Insert a space ahead of the cursor"
-  (interactive)
-  (save-excursion (insert " ")))
-
-(defun my/expand-backspace ()
-  "Add a space before and ahead of the cursor"
-  (interactive)
-  (save-excursion (delete-char 1))
-  (delete-backward-char 1))
-
-(defun my/enable-hard-wrap()
-  "Enable hard line wrapping"
-  (interactive)
-  (auto-fill-mode 1))
-
 (defun my/byte-recompile ()
   "Byte compile init.el, ~/.emacs.d/init/* and ~/.emacs.d/elisp/*"
   (interactive)
@@ -71,7 +58,12 @@
   (mapc 'kill-buffer (cdr (buffer-list (current-buffer))))
   (message "All other buffers killed"))
 
-(defun my/kill-non-project-buffers ()) ; TODO Implement this
+(defun my/kill-dired-buffers ()
+	 (interactive)
+	 (mapc (lambda (buffer)
+           (when (eq 'dired-mode (buffer-local-value 'major-mode buffer))
+             (kill-buffer buffer)))
+         (buffer-list)))
 
 (defun my/recentf-ido-find-file ()
   "Find a recent file using ido."
@@ -128,7 +120,16 @@
               (add-to-list 'symbol-names name)
               (add-to-list 'name-and-pos (cons name position))))))))
 
-;;;; Ac-setup Defuns ;;;;;;;;;;;;;;
+;;;; Hooks ;;;;;;;;;;;;;;;;;;;;;;;;
+(defun my/enable-hard-wrap()
+  (auto-fill-mode 1)
+  (diminish 'auto-fill-function))
+
+(defun my/enable-comment-hard-wrap ()
+  (set (make-local-variable 'comment-auto-fill-only-comments) t)
+  (auto-fill-mode 1)
+  (diminish 'auto-fill-function))
+
 (defun my/ac-ruby-setup()
   "Set up RSense and ac-sources"
   (setq ac-sources (append '(ac-source-rsense ac-source-yasnippet) ac-sources)))
@@ -140,34 +141,54 @@
 (defun my/setup-run-code(mode interpreter)
   "Set up s-r to run code using a specified interpreter and print the
 output in the echo area"
-  (interactive)
-  (nmap mode (kbd "s-r")
-        `(lambda() (interactive) (shell-command-on-region (point-min) (point-max) ,interpreter)))
-  (vmap mode (kbd "s-r")
+  (nmap mode (kbd ",r")
+        `(lambda()
+           (interactive)
+           (if (file-exists-p (buffer-file-name))
+               (shell-command (concat ,interpreter " " (buffer-file-name)))
+             (shell-command-on-region (point-min) (point-max) ,interpreter))))
+  (vmap mode (kbd ",r")
         `(lambda() (interactive) (shell-command-on-region (region-beginning) (region-end) ,interpreter))))
 
 ;;;; Tmux defuns ;;;;;;;;;;;;;;;;;
-(defun my/tmux-send(command)
-  (interactive "sRun command: ")
-  (shell-command (concat "tmux send-keys C-u " (shell-quote-argument command) " Enter"))
+(defun my/tmux-run (command)
+  "Run command in tmux"
+  (interactive
+   (list
+    (read-shell-command "Tmux command: " nil nil
+                        (let ((filename (cond (buffer-file-name)
+                                              ((eq major-mode 'dired-mode)
+                                               (dired-get-filename nil t)))))
+                          (and filename (file-relative-name filename))))))
+
+  (shell-command (concat "/usr/local/bin/tmux send-keys C-u " (shell-quote-argument command) " Enter"))
+  ;; (call-process "/usr/local/bin/tmux" nil nil nil "C-u" "send-keys" command "C-m")
   (message "Tmux: Command sent!"))
 
+(defun my/tmux-paste (command)
+  (interactive "sSend to Tmux: ")
+  (shell-command (concat "/usr/local/bin/tmux send-keys " command))
+  (message "Tmux: Text pasted!"))
+
 (defun my/tmux-chdir(dir)
+  "CD into a new directory in tmux"
   (interactive "DDirectory: ")
-  (shell-command (concat "tmux send-keys C-u \"cd " dir "\" Enter"))
+  (my/tmux-run (concat "cd " (shell-quote-argument dir)))
   (message "Tmux: Directory changed!"))
 
 ;;;; Mac-specific Defuns ;;;;;;;;;
 (when is-mac
   ;; Send current file to OSX apps
   (defun open-file-with (path &optional appName)
-    (if (not (string= "" appName))
+    (if (and appName
+             (stringp appName)
+             (not (string= "" appName)))
         (setq appName (concat "-a " appName ".app")))
-    (shell-command (concat "open " appName " " path)))
+    (shell-command (concat "open " appName " " (shell-quote-argument path))))
 
   (defun open-with (appName)
-    (interactive)
-    (open-file-with (buffer-file-name) appName))
+    (interactive "sApp name: ")
+    (open-file-with buffer-file-name appName))
 
   (defun send-to-transmit ()      (interactive) (open-with "Transmit"))
   (defun send-to-launchbar ()     (interactive) (open-with "LaunchBar"))
diff --git a/themes/brin-theme.el b/themes/brin-theme.el
index a73669e01..b58bfd806 100644
--- a/themes/brin-theme.el
+++ b/themes/brin-theme.el
@@ -26,10 +26,7 @@
 
 (deftheme brin "Space Grey theme for Emacs")
 
-  (custom-theme-set-variables
-    'brin
-    ;; '(linum-format " %1d ")
-    )
+  (custom-theme-set-variables 'brin)
 
   (let ((background       "#1f1f1f")
         ;; (gutters          "#262E34")
@@ -85,6 +82,8 @@
    `(highlight-indentation-face		              ((t (:background ,gutters) )))
    `(highlight-indentation-current-column-face    ((t (:background ,gutters-active) )))
 
+   `(flyspell-incorrect   ((t (:underline "#ff5555" :inherit unspecified))))
+
 ;; Font lock faces
 ;; *****************************************************************************************
 
@@ -103,11 +102,6 @@
 
    )
 
-;;;###autoload
-(when (and (boundp 'custom-theme-load-path) load-file-name)
-  (add-to-list 'custom-theme-load-path
-               (file-name-as-directory (file-name-directory load-file-name))))
-
 ;; *****************************************************************************************
 
 (provide-theme 'brin)