My Emacs System

Starting with Emacs 27, an early-init.el file can be used to do early configuration and optimization.

Emacs can now be configured using an early init file. The file is called early-init.el, in user-emacs-directory. It is loaded very early in the startup process: before graphical elements such as the tool bar are initialized, and before the package manager is initialized. The primary purpose is to allow customizing how the package system is initialized given that initialization now happens before loading the regular init file (see below).

We recommend against putting any customizations in this file that don’t need to be set up before initializing installed add-on packages, because the early init file is read too early into the startup process, and some important parts of the Emacs session, such as ’window-system’ and other GUI features, are not yet set up, which could make some customization fail to work.

We can use this to our advantage and optimize the initial loading of emacs.

• Before Emacs 27, the init file was responsible for initializing the package manager by calling `package-initialize’. Emacs 27 changed the default behavior: It now calls `package-initialize’ before loading the init file.

  (setq package-enable-at-startup nil)
  

• Let’s inhibit resizing the frame at early stage.

  (setq frame-inhibit-implied-resize t)
  

• I never use the menu-bar, or the tool-bar or even the scroll-bar, so we can safely disable those very very early.

  (menu-bar-mode -1)
  (tool-bar-mode -1)
  (scroll-bar-mode -1)
  (horizontal-scroll-bar-mode -1)
  

• Finally we can try to avoid garbage collection at startup. The garbage collector can easily double startup time, so we suppress it at startup by turning up gc-cons-threshold (and perhaps gc-cons-percentage) temporarily.

  (setq gc-cons-threshold 402653184
        gc-cons-percentage 0.6)
  

• Another small optimization concerns on file-name-handler-alist : on every .el and .elc file loaded during start up, it has to runs those regexps against the filename ; setting it to nil and after initialization finished put the value back make the initialization process quicker.

  (defvar file-name-handler-alist-original file-name-handler-alist)
  (setq file-name-handler-alist nil)
  

  However, it is important to reset it eventually. Not doing so will cause garbage collection freezes during long-term interactive use. Conversely, a gc-cons-threshold that is too small will cause stuttering. This will be done at the end.

• It’s also possible to put the theme and the font in early-init.el to speed the start.

  (defvar contrib/after-load-theme-hook nil
    "Hook run after a color theme is loaded using `load-theme'.")
  
  (defun contrib/run-after-load-theme-hook (&rest _)
    "Run `contrib/after-load-theme-hook'."
    (run-hooks 'contrib/after-load-theme-hook))
  
  (advice-add #'load-theme :after #'contrib/run-after-load-theme-hook)
  (require 'modus-operandi-theme)
  
  (defun vde/modus-operandi ()
    "Enable some Modus Operandi variables and load the theme.
  This is used internally by `vde/modus-themes-toggle'."
    (setq modus-operandi-theme-slanted-constructs t
          modus-operandi-theme-bold-constructs t
          modus-operandi-theme-subtle-diffs t
          modus-operandi-theme-rainbow-headings t
          modus-operandi-theme-section-headings nil
          modus-operandi-theme-scale-headings nil
          modus-operandi-theme-fringes 'subtle ; {nil,'subtle,'intense}
          modus-operandi-theme-mode-line '3d ; {nil,'3d,'moody}
          modus-operandi-theme-3d-modeline t
          modus-operandi-theme-faint-syntax nil
          modus-operandi-theme-intense-hl-line t
          modus-operandi-theme-intense-paren-match t
          modus-operandi-theme-prompts 'subtle ; {nil,'subtle,'intense}
          modus-operandi-theme-completions 'opinionated ; {nil,'moderate,'opinionated}
          modus-operandi-theme-diffs 'desaturated ; {nil,'desaturated,'fg-only}
          modus-operandi-theme-org-blocks 'greyscale ; {nil,'greyscale,'rainbow}
          modus-operandi-theme-variable-pitch-headings nil
          modus-operandi-theme-rainbow-headings t
          modus-operandi-theme-section-headings nil
          modus-operandi-theme-scale-headings t
          modus-operandi-theme-scale-1 1.05
          modus-operandi-theme-scale-2 1.1
          modus-operandi-theme-scale-3 1.15
          modus-operandi-theme-scale-4 1.2)
    (load-theme 'modus-operandi t))
  
  (defun vde/modus-operandi-custom ()
    "Customize modus-operandi theme"
    (if (member 'modus-operandi custom-enabled-themes)
        (modus-operandi-theme-with-color-variables ; this macro allows us to access the colour palette
          (custom-theme-set-faces
           'modus-operandi
           `(whitespace-tab ((,class (:background "#ffffff" :foreground "#cccccc"))))
           `(whitespace-space ((,class (:background "#ffffff" :foreground "#cccccc"))))
           `(whitespace-hspace ((,class (:background "#ffffff" :foreground "#cccccc"))))
           `(whitespace-newline ((,class (:background "#ffffff" :foreground "#cccccc"))))
           `(whitespace-indentation ((,class (:background "#ffffff" :foreground "#cccccc"))))
           ))))
  
  (add-hook 'contrib/after-load-theme-hook 'vde/modus-operandi-custom)
  (vde/modus-operandi)
  
  (defconst font-height 130
    "Default font-height to use.")
  (defconst font-family-mono "Ubuntu Mono"
    "Default monospace font-family to use.")
  (defconst font-family-sans "Ubuntu Sans"
    "Default sans font-family to use.")
  ;; Middle/Near East: שלום, السّلام عليكم
  (when (member "Noto Sans Arabic" (font-family-list))
    (set-fontset-font t 'arabic "Noto Sans Arabic"))
  (when (member "Noto Sans Hebrew" (font-family-list))
    (set-fontset-font t 'arabic "Noto Sans Hebrew"))
  ;; Africa: ሠላም
  (when (member "Noto Sans Ethiopic" (font-family-list))
    (set-fontset-font t 'ethiopic "Noto Sans Ethiopic"))
  
  ;; If font-family-mono or font-family-sans are not available, use the default Emacs face
  (when (member font-family-mono (font-family-list))
    (set-face-attribute 'default nil
                        :family font-family-mono
                        :height font-height)
    (set-face-attribute 'fixed-pitch nil
                        :family font-family-mono))
  (when (member font-family-sans (font-family-list))
    (set-face-attribute 'variable-pitch nil
                        :family font-family-sans
                        :weight 'regular))
  
  ;; Ignore X resources; its settings would be redundant with the other settings
  ;; in this file and can conflict with later config (particularly where the
  ;; cursor color is concerned).
  (advice-add #'x-apply-session-resources :override #'ignore)
  

• Reseting garbage collection and file-name-handler values.

  (add-hook 'after-init-hook
            `(lambda ()
               (setq gc-cons-threshold 67108864 ; 64mb
                     gc-cons-percentage 0.1
                     file-name-handler-alist file-name-handler-alist-original)
               (garbage-collect)) t)
  

I am using the portable dump feature (to speed things up) but I want to also start without pdump, so I need to take both cases into account.

(defvar sbr-dumped nil
  "non-nil when a dump file is loaded (because dump.el sets this variable).")

(defmacro sbr-if-dump (then &rest else)
  "Evaluate IF if running with a dump file, else evaluate ELSE."
  (declare (indent 1))
  `(if sbr-dumped
       ,then
     ,@else))

(sbr-if-dump
    (progn
      (global-font-lock-mode)
      (transient-mark-mode)
      (setq load-path sbr-dumped-load-path))
  ;; add load-path’s and load autoload files
  (package-initialize))

First thing first, let’s define a emacs-start-time constant to be able to compute the time Emacs took to start.

(defconst emacs-start-time (current-time))

My configuration do not support Emacs version lower than 26.

(let ((minver 26))
  (unless (>= emacs-major-version minver)
    (error "Your Emacs is too old -- this configuration requires v%s or higher" minver)))

One thing though, I am currently not necessarily running Emacs 27, so I am going to need to have the same configuration in init.el for a little bit of time.

Note: the lowest emacs version I wanna support is 26 (as of today, might evolve)

;; load early-init.el before Emacs 27.0
(unless (>= emacs-major-version 27)
  (message "Early init: Emacs Version < 27.0")
  (load (expand-file-name "early-init.el" user-emacs-directory)))

We also want our configuration to be working the same on any computer, this means we want to define every option by ourselves, not relying on default files (default.el) that would be set by our distribution. This is where inhibit-default-init comes into play, setting it to non-nil inhibit loading the default library.

We also want to inhibit some initial default start messages and screen. The default screen will be as bare as possible.

(setq inhibit-default-init t)           ; Disable the site default settings

(setq inhibit-startup-message t
      inhibit-startup-screen t)

Let’s also use y or n instead of yes and no when exiting Emacs.

(setq confirm-kill-emacs #'y-or-n-p)

One last piece to the puzzle is the default mode. Setting it to fundamental-mode means we won’t load any heavy mode at startup (like org-mode). We also want this scratch buffer to be empty, so let’s set it as well

(setq initial-major-mode 'fundamental-mode
      initial-scratch-message nil)

By default, all my systems are configured and support utf-8, so let’s just make it a default in Emacs ; and handle special case on demand.

(prefer-coding-system 'utf-8)
(set-default-coding-systems 'utf-8)
(set-language-environment 'utf-8)
(set-selection-coding-system 'utf-8)
(set-terminal-coding-system 'utf-8)

use-package is a tool that streamlines the configuration of packages. It handles everything from assigning key bindings, setting the value of customisation options, writing hooks, declaring a package as a dependency for another, and so on.

The use-package macro allows you to isolate package configuration in your .emacs file in a way that is both performance-oriented and, well, tidy. I created it because I have over 80 packages that I use in Emacs, and things were getting difficult to manage. Yet with this utility my total load time is around 2 seconds, with no loss of functionality!

With use-package we can improve the start-up performance of Emacs in a few fairly simple ways. Whenever a command is bound to a key it is configured to be loaded only once invoked. Otherwise we can specify which functions should be autoloaded by means of the :commands keyword.

We need to setup the emacs package system and install use-package if not present already.

(require 'package)

(setq package-archives
      '(("melpa" . "http://melpa.org/packages/")
        ("org" . "https://orgmode.org/elpa/")
        ("gnu" . "https://elpa.gnu.org/packages/")))

(setq package-archive-priorities
      '(("melpa" .  3)
        ("org" . 2)
        ("gnu" . 1)))

(require 'tls)

;; From https://github.com/hlissner/doom-emacs/blob/5dacbb7cb1c6ac246a9ccd15e6c4290def67757c/core/core-packages.el#L102
(setq gnutls-verify-error (not (getenv "INSECURE")) ; you shouldn't use this
      tls-checktrust gnutls-verify-error
      tls-program (list "gnutls-cli --x509cafile %t -p %p %h"
                        ;; compatibility fallbacks
                        "gnutls-cli -p %p %h"
                        "openssl s_client -connect %h:%p -no_ssl2 -no_ssl3 -ign_eof"))

;; Initialise the packages, avoiding a re-initialisation.
(unless (bound-and-true-p package--initialized)
  (setq package-enable-at-startup nil)
  (package-initialize))

(setq load-prefer-newer t)              ; Always load newer compiled files
(setq ad-redefinition-action 'accept)   ; Silence advice redefinition warnings

;; Init `delight'
(unless (package-installed-p 'delight)
  (package-refresh-contents)
  (package-install 'delight))

;; Configure `use-package' prior to loading it.
(eval-and-compile
  (setq use-package-always-ensure nil)
  (setq use-package-always-defer nil)
  (setq use-package-always-demand nil)
  (setq use-package-expand-minimally nil)
  (setq use-package-enable-imenu-support t))

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

(eval-when-compile
  (require 'use-package))

I want to force =SSH_AUTH_SOCK in Emacs to use my gpg-agent.

(setenv "SSH_AUTH_SOCK" "/run/user/1000/gnupg/S.gpg-agent.ssh")

When you install a package or use the various customisation interfaces to tweak things to your liking, Emacs will append a piece of elisp to your init file. I prefer to have that stored in a separate file.

(defconst vde/custom-file (locate-user-emacs-file "custom.el")
  "File used to store settings from Customization UI.")

(use-package cus-edit
  :config
  (setq
   custom-file vde/custom-file
   custom-buffer-done-kill nil          ; Kill when existing
   custom-buffer-verbose-help nil       ; Remove redundant help text
   custom-unlispify-tag-names nil       ; Show me the real variable name
   custom-unlispify-menu-entries nil)
  (unless (file-exists-p custom-file)
    (write-region "" nil custom-file))

  (load vde/custom-file 'no-error 'no-message))

I want to make sure I am using the installed version of orgmode (from my org configuration) instead of the built-in one. To do that safely, let’s remove the built-in version out of the load path.

(require 'cl-seq)
(setq load-path
      (cl-remove-if
       (lambda (x)
         (string-match-p "org$" x))
       load-path))

This org-mode document tangles into several files in different folders :

• config for my configuration
• lisp for imported code or library I’ve written and not yet published

I used to load them by hand in the init.el file, which is very cumbersome, so let’s try to automatically load them. I want to first load the file in the lisp folder as they are potentially used by my configuration (in config).

Let’s define some functions that would do the job.

(defun vde/el-load-dir (dir)
  "Load el files from the given folder"
  (let ((files (directory-files dir nil "\.el$")))
    (while files
      (load-file (concat dir (pop files))))))

(defun vde/short-hostname ()
  "Return hostname in short (aka wakasu.local -> wakasu)"
  (string-match "[0-9A-Za-z-]+" system-name)
  (substring system-name (match-beginning 0) (match-end 0)))

Let’s define some constants early, based on the system, and the environment, to be able to use those later on to skip some package or change some configuration accordingly.

(defconst *sys/gui*
  (display-graphic-p)
  "Are we running on a GUI Emacs ?")
(defconst *sys/linux*
  (eq system-type 'gnu/linux)
  "Are we running on a GNU/Linux system?")
(defconst *sys/mac*
  (eq system-type 'darwin)
  "Are we running on a Mac system?")
(defconst *sys/root*
  (string-equal "root" (getenv "USER"))
  "Are you a ROOT user?")
(defconst *nix*
  (executable-find "nix")
  "Do we have nix? (aka are we running in NixOS or a system using nixpkgs)")
(defconst *rg*
  (executable-find "rg")
  "Do we have ripgrep?")
(defconst *gcc*
  (executable-find "gcc")
  "Do we have gcc?")
(defconst *git*
  (executable-find "git")
  "Do we have git?")

(defvar *sys/full*
  (member (vde/short-hostname) '("wakasu" "naruhodo")) ; "naruhodo" <- put naruhodo back in
  "Is it a full system ?")
(defvar *sys/light*
  (not *sys/full*)
  "Is it a light system ?")

Now, in order to load lisp and config files, it’s just a matter of calling this function with the right argument.

(add-to-list 'load-path (concat user-emacs-directory "lisp/"))
(add-to-list 'load-path (concat user-emacs-directory "lisp/vorg"))
(require 'init-func)
(vde/el-load-dir (concat user-emacs-directory "/config/"))

Finally, I want to be able to load files for a specific machine, in case I need it (not entirely sure why yet but…)

(if (file-exists-p (downcase (concat user-emacs-directory "/hosts/" (vde/short-hostname) ".el")))
    (load-file (downcase (concat user-emacs-directory "/hosts/" (vde/short-hostname) ".el"))))

I have a few scripts and desktop files that I want to get installed in my environment.

• org-protocol.desktop: this register the org protocol in xdg.

  [Desktop Entry]
  Name=org-protocol
  Exec=emacsclient -s /run/user/1000/emacs/org -n %u
  Type=Application
  Terminal=false
  Categories=System;
  MimeType=x-scheme-handler/org-protocol;
  

• ec.desktop: this starts a new frame on the org daemon.

  [Desktop Entry]
  Name=Emacs (client)
  Exec=ec
  Type=Application
  Terminal=false
  Categories=System;
  Icon=emacs;
  

• capture.desktop: this runs the capture script above

  [Desktop Entry]
  Name=Emacs capture
  Exec=capture
  Type=Application
  Terminal=false
  Categories=System;
  Icon=emacs;
  

And then, we need to link those up :

home.file.".local/share/applications/org-protocol.desktop".source = ./emacs/org-protocol.desktop;
home.file.".local/share/applications/ec.desktop".source = ./emacs/ec.desktop;
home.file.".local/share/applications/capture.desktop".source = ./emacs/capture.desktop;

We need to install a few packages:

• ditaa and graphiz are there for org-mode and org-babel
• pandoc is for when I when to migrate a document from markdown to org-mode or the opposite
• sqlite is for packages like forge
• zip is… always useful
• capture is the script defined abovoe.

home.packages = with pkgs; [
  ditaa
  graphviz
  pandoc
  sqlite
  zip
  # See if I can hide this under an option
  capture
  e
  ec
  et
];

home-manager comes with a modules named programs.emacs, so we are going to use it

programs.emacs = {
  enable = true;
  package = pkgs.my.emacs;
  extraPackages = myExtraPackages;
};

myExtraPackages = epkgs: with epkgs; [
  ace-window
  aggressive-indent
  async
  avy
  bbdb
  beginend
  color-identifiers-mode
  company
  company-emoji
  company-go
  dash
  delight
  diredfl
  dired-collapse
  dired-git-info
  dired-narrow
  dired-quick-sort
  dired-rsync
  dired-subtree
  dockerfile-mode
  dumb-jump
  easy-kill
  edit-indirect
  envrc
  esh-autosuggest
  eshell-prompt-extras
  esup
  expand-region
  flimenu
  flycheck
  flycheck-golangci-lint
  git-annex
  git-commit
  gitattributes-mode
  gitconfig-mode
  github-review
  gitignore-mode
  go-mode
  go-stacktracer
  gotest
  goto-last-change
  hardhat
  helpful
  highlight
  highlight-indentation
  highlight-numbers
  ibuffer-vc
  icomplete-vertical
  iedit
  json-mode
  magit
  magit-annex
  magit-popup
  magit-todos
  markdown-mode
  minions
  modus-operandi-theme
  moody
  mwim
  nix-buffer
  nix-mode
  nixpkgs-fmt
  no-littering
  ob-async
  ob-go
  ob-http
  olivetti
  orderless
  org-capture-pop-frame
  org-gcal
  org-journal
  org-plus-contrib
  org-ql
  org-ref
  org-roam
  org-super-agenda
  org-superstar
  org-tree-slide
  org-web-tools
  orgit
  ox-pandoc
  pandoc-mode
  pdf-tools
  pkgs.bookmark-plus
  pkgs.dired-plus
  projectile
  python-mode
  rainbow-delimiters
  rainbow-mode
  rg
  ripgrep
  scratch
  shr-tag-pre-highlight
  smartparens
  symbol-overlay
  trashed
  try
  undo-tree
  use-package
  visual-fill-column
  visual-regexp
  vterm
  web-mode
  wgrep
  whole-line-or-region
  with-editor
  xterm-color
  yaml-mode
];

Let’s define some useful commands that can be used

Let’s define some

Here we define the emacs.nix file that gets generated by the source blocks in our Org document. This is the file that actually gets loaded on startup. The placeholders in angled brackets correspond to the NAME directives above the SRC blocks throughout this document.

# Note: this file is autogenerated from an org-mode file.
{ config, lib, pkgs, ... }:

with lib;
let
  <<script-capture>>
  <<script-e>>
  <<script-et>>
  <<script-ec>>
  <<myExtraPackages>>
in
{
  <<desktop-files>>
  <<packages>>
  <<programs.emacs>>
  <<emacs-server>>
  <<legacy>>
}

[2020-09-17 Thu 17:55]

[2020-07-08 Wed 07:37]

[2020-06-02 Tue 18:07]

[2020-06-02 Tue 18:04]

[2020-05-29 Fri 15:05]

[2020-03-24 Tue 07:54]

[2020-03-25 Wed 16:58]

[2020-03-08 Sun 16:44]

[2020-06-18 Thu 18:41]

[2020-06-23 Tue 17:45]

[2020-06-29 Mon 11:35]

[2020-07-02 Thu 18:20]

[2020-07-15 Wed 12:29]

[2020-11-17 Tue 18:09]

[2020-11-19 Thu 11:00]

[2020-11-19 Thu 11:11]

[2020-12-01 Tue 08:02]

[2020-12-01 Tue 08:12]