Org based init method slows down emacs startup DRAMATICLLY (6 minute startup)..help needed

Question

So after a few months of frustration today i discovered the issue that's been bothering me for a long time..the REALLY slow emacs startup (sometimes 5 minutes or more).

The cause is the org mode init file i use. what i currently have in my setup is

A. this init.el:

(require 'package)
;since we are using use-package-don't autoload anythings
(setq package-enable-at-startup nil)

(add-to-list 'package-archives '("gnu" . "http://elpa.gnu.org/packages/"))
(add-to-list 'package-archives '("marmalade" . "https://marmalade-repo.org/packages/"))
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/"))
;; org maybe suspect of hanging melpa, if you have hangs disable this first
(add-to-list 'package-archives '("org" . "http://orgmode.org/elpa/"))
;; Initialize installed package
(package-initialize)  

;; Bootstrap `use-package'
(unless (package-installed-p 'use-package)
    (package-refresh-contents)
    (package-install 'use-package))

(org-babel-load-file (expand-file-name "~/.emacs.d/settings.org"))

B. My config stored in settings.org which alot of lisp code (like 17,000 lines..yeah i like to tinker :))

Using this method i discovered that every time i make a small change to setting.org and restart emacs the setting.org gets tangled to settings.el and emacs takes nearly 6!!! minutes to start (Init time was 396.10s (395.33s in init.el) , yeah thats painful as you can imagine.

BUT what i discovered today is that if i just stick my config chunks from setting.org (ie the tangled setting.el file) into init.el, emacs starts super fast each time, even when i change the init.el file!

can anyone help me with this, i really would appreciate you guys help with this as its driving me mad :)

Answer 1

Not necessarily a solution, but at least an explanation.

I’ve seen this myself, although not to the extent of your tangling time. The startup time appears related to the number of separate begin_src blocks that you’ve got – in the case of a literate programming init.el file you’re likely to have a lot of separate blocks as you intersperse elisp fragments with explanatory text and headings, which leads to the worst case startup time.

I’ve not investigated this myself, but it’s described in more detail here: http://www.holgerschurig.de/en/emacs-init-tangle/

(EDIT: zeltak has pointed out an updated approach here: http://www.holgerschurig.de/en/emacs-efficiently-untangling-elisp/)

That post doesn’t have a solution for “fixing” Org-mode’s tangling time, but it does present an alternative tangling function that avoids this problem. That function isn’t as general as Org-babel, but for this use case it’s quite likely sufficient.

I won’t reproduce that function here since it’s not my work, but the above link describes that in more detail. Note that I’ve not used this myself because my tangling time isn’t bad enough to force me down that path and I don’t modify my init.org much any more.

Answer 2

Another route is to tangle, and compile, upon saving the file. I do this and then the init.el loads that compiled file. Fast to load, but slower to save.

My ~/.emacs.d/init/init-org.org contains the usual Org structured file with headings and #+BEGIN_SRC emacs-lisp as described elsewhere.

I define this hook to detect that this file is being saved and tangle and byte-compile after save:

(defun my/tangle-dotfiles ()
   "If the current file is this file, the code blocks are tangled"
   (when (equal (buffer-file-name) (expand-file-name "~/.emacs.d/init/init-org.org"))
     (org-babel-tangle nil "~/.emacs.d/init/init-org.el")
     (byte-compile-file "~/.emacs.d/init/init-org.el")))

(add-hook 'after-save-hook #'my/tangle-dotfiles)

The ~/.emacs.d/init/init.el contains:

(package-initialize)

(load-file "~/.emacs.d/init/init-org.elc")

(custom-set-variables...

followed by whatever else Emacs wants to put in there.