             ((not mode)
              (error "No namespace specified on `doom!' for %s" p))
             (t
-             (setq doom-modules (append doom-modules (list (cons mode p))))))))
-  (unless doom--dont-load-p
-    `(let (file-name-handler-alist)
+             (setq doom-enabled-modules (append doom-enabled-modules (list (cons mode p))))))))
+  `(unless noninteractive
+     (let (file-name-handler-alist)
        ,@(mapcar (lambda (pkg) (macroexpand `(load! ,(car pkg) ,(cdr pkg))))
-                 doom-modules)
-
-       (unless noninteractive
-         (when (display-graphic-p)
-           (require 'server)
-           (unless (server-running-p)
-             (server-start)))
-
-         ;; Prevent any auto-displayed text + benchmarking
-         (advice-add 'display-startup-echo-area-message :override 'ignore)
-         (message "Loaded %s packages in %s"
-                  (length doom-packages)
-                  (emacs-init-time))))))
+                 doom-enabled-modules)
+
+       (when (display-graphic-p)
+         (require 'server)
+         (unless (server-running-p)
+           (server-start)))
+
+       ;; Prevent any auto-displayed text + benchmarking
+       (advice-add 'display-startup-echo-area-message :override 'ignore)
+       (message "Loaded %s packages in %s"
+                (- (length load-path) (length doom--load-path))
+                (emacs-init-time)))))
 
 (defun doom-initialize (&optional force-p)
-  "Initialize installed packages (using package.el). On first run it will
-prepare Emacs to auto-install all missing packages. If you byte compile
-core/core.el, calls to `package.el' are avoided to speed up startup."
+  "Initialize installed packages (using package.el) and ensure the core packages
+are installed. If you byte compile core/core.el, calls to `package.el' are
+avoided to speed up startup."
   (unless (or doom--init force-p)
     (setq load-path doom--load-path
           package-activated-list nil)
     (package-initialize)
-    (unless (package-installed-p 'quelpa-use-package)
+    (unless (and (file-exists-p doom-packages-dir)
+                 (require 'quelpa-use-package nil t))
       (package-refresh-contents)
-      (package-install 'quelpa-use-package t)
-      (setq doom--auto-install-p (not noninteractive)))
-    (unless (featurep 'quelpa-use-package)
-      (require 'quelpa-use-package)
-      (quelpa-use-package-activate-advice)
-      (setq use-package-expand-minimally t)
-      ;; Move :ensure to after conditional properties
-      (delq :ensure use-package-keywords)
-      (push :ensure (cdr (memq :unless use-package-keywords))))
+      ;; Ensure core packages are installed
+      (mapc 'package-install '(quelpa-use-package dash f s)))
+    (unless (require 'quelpa-use-package nil t)
+      (delete-directory doom-packages-dir t)
+      (error "There was an error initializing DOOM. Try running it again"))
+    (quelpa-use-package-activate-advice)
+    ;; Move :ensure to after conditional properties
+    (delq :ensure use-package-keywords)
+    (push :ensure (cdr (memq :unless use-package-keywords)))
     (setq doom--init t)))
 
+(defun doom-reload-modules ()
+  "Reload `doom-modules'."
+  (setq doom-modules nil)
+  (let ((doom--prefer-el-p t)
+        (noninteractive t))
+    (load (concat doom-emacs-dir "init.el") nil :nomessage :nosuffix)))
+
+(defun doom-reload-packages (&optional install-p)
+  "Reload `doom-packages'."
+  (doom-initialize)
+  (doom-reload-modules)
+  (let ((before-packages-n (length package-alist))
+        (doom--auto-install-p (and install-p t))
+        (doom--prefer-el-p t)
+        (after-packages-n 0)
+        noninteractive)
+    (when doom--auto-install-p
+      (package-refresh-contents))
+    (load (f-expand "core.el" doom-core-dir) nil (not doom-debug-mode) :nosuffix)
+    (mapc (lambda (pkg)
+            (let ((path (f-expand "packages.el" (doom-module-path (car pkg) (cdr pkg)))))
+              (when (f-exists-p path)
+                (load path nil (not doom-debug-mode) :nosuffix))))
+          doom-enabled-modules)
+    (- (length package-alist) before-packages-n)))
+
 
 ;;
 ;; Macros
 ;;
 
-(defvar doom--packages nil
-  "List of packages explicitly installed during this session.")
-
-(defalias 'use-package! 'use-package
-  "To adhere to the naming conventions of DOOM emacs.")
+(defvar __DIR__ nil  "The directory of the currently loaded file (set by `load!')")
+(defvar __FILE__ nil "The full path of the currently loaded file (set by `load!')")
+
+(defmacro use-package! (name &rest plist)
+  "A `use-package' wrapper, to adhere to the naming conventions of DOOM emacs
+and let-bind `package-name' for the containing forms. Note that packages are
+deferred by default."
+  (macroexpand
+   `(let ((package-name ',name))
+      (use-package ,name ,@plist))))
 
 (defmacro package! (name &rest plist)
   "Wraps around `use-package' (with `quelpa-use-package') and takes the same
 arguments. Ensures the package named NAME is installed and available. If
 `doom--auto-install-p' is nil, then strip out :ensure and :quelpa properties,
-which is the case if you've byte-compiled DOOM Emacs."
+which is the case if you've byte-compiled DOOM Emacs.
+
+Note that packages are deferred by default."
   (declare (indent defun))
   (let ((use-package-always-ensure doom--auto-install-p)
         (recipe (plist-get plist :quelpa)))

;;    more stable.
;; 4. No external dependencies (e.g. Cask) for plugin management.

(defvar doom-packages '((quelpa-use-package))
  "List of packages that have been explicitly installed (not dependencies) with
`package!'. Each element is a list whose car is the package symbol, and cdr is
its quelpa recipe, if available.")

(defvar doom-modules nil
  "List of enabled modules; each element is a cons cell (MODULE . SUBMODULE),
where MODULE is the module's property symbol, e.g. :lang, and SUBMODULE is the
submodule symbol, e.g. 'evil.")

(defvar doom--init nil
  "Non-nil if doom's package system has been initialized or not. It may not be
if you have byte-compiled your configuration (as intended).")

    ;; MELPA lookups by quelpa.
    (when (and recipe (= 0 (mod (length recipe) 2)))
      (push name recipe)
      (setq plist (plist-put plist :quelpa recipe)))
    (unless doom--auto-install-p
      (setq plist (use-package-plist-delete plist :ensure))
      (setq plist (use-package-plist-delete plist :quelpa)))
    ;; (package--save-selected-packages (cons name package-selected-packages))
    (pushnew name doom-packages)
    (macroexpand `(use-package ,name ,@plist))))

(defmacro load! (file-or-module-sym &optional submodule file)
  "Load a module from `doom-modules-dir'. Plays the same role as
`load-relative', but is specific to DOOM emacs modules and submodules. If
`doom--prefer-el-p' is non-nil, prefer the un-compiled elisp file.

Examples:
 (load! :lang emacs-lisp)

  Loads modules/lang/emacs-lisp/FILE.el (defaults to config.el).

 (load! +local-module)

  Loads +local-module.el relative to `__DIR__' or `doom-core-dir'."
  (let (path file)
    (cond ((null submodule)
           (setq path (or __DIR__ doom-core-dir)
                 file (concat (if (symbolp file-or-module-sym)
                                  (symbol-name file-or-module-sym)
                                file-or-module-sym)
                              ".el")))
          (t
           (setq path (doom-module-path file-or-module-sym submodule)
                 file (or file "config.el"))))
    (setq path (f-slash path)
          file (concat path file))
    `(let ((__FILE__ ,file)
           (__DIR__  ,path))
       (load (if doom--prefer-el-p ,file ,(f-no-ext file))
             nil (not doom-debug-mode) doom--prefer-el-p))))

(defun doom-module-path (module submodule &optional file)
  "Get the full path to a module: e.g. :lang emacs-lisp maps to
~/.emacs.d/modules/lang/emacs-lisp/. Will append FILE if non-nil."
  (when (symbolp module)
    (setq module (symbol-name module)))
  (when (string-prefix-p ":" module)
    (setq module (substring module 1)))
  (when (symbolp submodule)
    (setq submodule (symbol-name submodule)))
  (f-expand (concat module "/" submodule "/" file)
            doom-modules-dir))


;;
;; Defuns
;;

(defun doom/refresh-autoloads ()
  "Refreshes the autoloads.el file, which tells Emacs where to find all the
autoloaded functions in the modules you use or among the core libraries.

Rerun this whenever you modify your init.el (or use `make autoloads` from the
command line)."
  (interactive)
  (unless doom--init
    (doom-reload-modules))
  (let ((generated-autoload-file (concat doom-local-dir "autoloads.el"))
        (autoload-files
         (append (-flatten (mapcar (lambda (dir)
                                     (let ((auto-dir  (f-expand "autoload" dir))
                                           (auto-file (f-expand "autoload.el" dir)))
                                       (cond ((f-directory-p auto-dir)
                                              (f-glob "*.el" auto-dir))
                                             ((f-exists-p auto-file)
                                              auto-file))))
                                   (--map (doom-module-path (car it) (cdr it)) doom-enabled-modules)))
                 (f-glob "autoload/*.el" doom-core-dir))))
    (when (f-exists-p generated-autoload-file)
      (f-delete generated-autoload-file)
      (message "Deleted old autoloads.el"))
    (dolist (file autoload-files)
      (update-file-autoloads file)
      (message "Detected: %s" (f-relative file doom-emacs-dir)))
    (with-current-buffer (get-file-buffer generated-autoload-file)
      (save-buffer))
    (load generated-autoload-file nil t t)
    (message "Done!")))

(defun doom/byte-compile ()
  "Byte (re)compile the important files in your emacs configuration (i.e.
