Dotfiles

• Init
• Hosts
  • Example (Ubuntu)
• Modules
  • Core
    • Cleanup
    • Package management
    • Hermetic evaluation
    • Literate programming
    • Custom keybindings
      • Hints
      • Leader
      • Evil mode
      • Shortcuts
    • Version control
    • Terminal emulation
    • File management
  • Desktop
    • Startup
    • Applications
    • Initialization
    • Displays
    • Configuration
  • Writing
    • Roam
    • Email
    • Agenda
    • Images
  • Projects
    • Management
    • Passwords
    • Debugging
    • Completion
    • Languages
      • C/C++
      • Python
      • Go
  • Interface
    • Fonts
    • Lines
    • Themes
    • Ligatures
    • Dashboard

                              _.-="_-         _
                         _.-="   _-          | ||"""""""---._______     __..
             ___.===""""-.______-,,,,,,,,,,,,`-''----" """""       """""  __'
      __.--""     __        ,'                   o \           __        [__|
 __-""=======.--""  ""--.=================================.--""  ""--.=======:
]       [w] : /        \ : |========================|    : /        \ :  [w] :
V___________:|          |: |========================|    :|          |:   _-"
 V__________: \        / :_|=======================/_____: \        / :__-"
 -----------'  "-____-"  `-------------------------------'  "-____-"

Immutable GNU Emacs dotfiles. Built for Life, Liberty, and the Open Road.

• 100% Literate

• 100% Immutable

• 100% Reproducible

Init

Although later versions of Emacs introduce early-init.el, it's not used in this configuration for two reasons:

• It's not required due to the modularity

• Maintaining support for older versions

Assuming you have completed all of the following tasks prior to proceeding further:

1. Imported the secrets

2. Initialized the passwords

3. Defined the host file

4. Created all required symbolic links

Launch emacs: emacs -mm --debug-init

;; Load the host configuration.
(let ((host-file (concat user-emacs-directory "/hosts/" system-name ".el")))
  (when (file-exists-p host-file)
    (load-file host-file)))

;; Load the enabled modules.
(dolist (m dotfiles/modules)
  (let ((mod-file (concat dotfiles/home "/modules/" (symbol-name m) ".el")))
    (when (file-exists-p mod-file)
      (load-file mod-file))))

Hosts

Each host system that runs Emacs has a file defined in the hosts/ sub directory, following the pattern of $HOSTNAME.el. All of the configurations are defined within this file, the values of which are read from by the other modules during startup and installation. This does not cover hosts that are controlled via TRAMP, as that will be covered in another section.

Example (Ubuntu)

The first configuration, which was built using the Ubuntu 20.04 LTS server edition. I decided to incorporate flatpaks into this build. Setting the $BROWSER variable is required in the desktop module. Set the browser to the flatpak borwser currently installed, this could change to chromium, firefox, or any other browser by changing this environment variable.

(setenv "BROWSER" "flatpak run org.mozilla.firefox")

Add the modules you want to initialize to the dotfiles/modules variable.

(defvar dotfiles/modules '(core
                           desktop
                           writing
                           projects
                           interface))

Specify the home and cache directories.

(defvar dotfiles/cache "~/.cache/emacs")
(defvar dotfiles/home user-emacs-directory)

Functionality like completion and hints can be delayed to avoid popups for common manuevers. Adjust this value to your personal taste.

(defvar dotfiles/idle 0.0)

Avoid the infamous Emacs pinky by binding SPC as a leader key, utilizing the thumb instead of the weaker pinky finger. You may change this value if you want to use something else.

(defvar dotfiles/leader-key "SPC")
(defvar dotfiles/leader-key-global "C-SPC")

Define where the source repositories are stored, for integration with the Projects module.

(defvar dotfiles/src "~/.local/source/")

Secret keys and passwords are stored in a seperate repository.

(defvar dotfiles/secrets (concat dotfiles/src "secrets/"))
(defvar dotfiles/passwords (concat dotfiles/src "passwords/"))

Modules

Breaking down the project into logical units or chapters to keep the code more maintainable and organized. This is also a fundemental requirement to achieve the goal of modularity. Incorporating just the core module on a build server to build literate programming projects is just one example of what can be achieved.

Core

Minimal configuration to make Emacs usable for my own personal workflow. This does very little in the ways of improving the visuals, only removing what is included by default and not required.

Cleanup

Emacs creates a lot of files relative to user-emacs-directory, these files are not part of this immutable configuration and do not belong in the emacs directory. How can we solve this issue? Shortly after initialization, before most packages are loaded, we change the value to dotfiles/cache. I elaborate more on the technique in my post Immutable Emacs.

(setq user-emacs-directory dotfiles/cache)

Because this project uses version-control, we can disable more unwanted features:

• Lock files

• Backup files

(setq create-lockfiles nil
      make-backup-files nil)

Package management

Download and install packages using straight.el, a functional package manager that integrates with use-package, giving us more control over where packages are sourced from.

• Use the development branch

• Integrate with use-package

Apply the configurations prior to bootstrapping the package manager, by setting (writing) to the variables that straight will ultimately read from.

(setq straight-repository-branch "develop"
      straight-use-package-by-default t)

Bootstrap the package manager, downloading, installing, or configuring depending on the state of the configuration. All packages are downloaded and built from source, and can be pinned to specific git commit hashes.

(defvar bootstrap-version)
(let ((bootstrap-file
       (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory))
      (bootstrap-version 5))
  (unless (file-exists-p bootstrap-file)
    (with-current-buffer
        (url-retrieve-synchronously
         "https://raw.githubusercontent.com/raxod502/straight.el/develop/install.el"
         'silent 'inhibit-cookies)
      (goto-char (point-max))
      (eval-print-last-sexp)))
  (load bootstrap-file nil 'nomessage))

Complete the integration with use-package by installing it with straight.

(straight-use-package 'use-package)

Hermetic evaluation

Despite having our stateful and immutable configurations seperate, it's good practice to make efforts to reduce the trash created by Emacs.

Install no-littering to reduce the files created by Emacs.

(use-package no-littering)

Emacs' default user interface is horrendous, but with less than 10 lines of code we can change that.

(setq inhibit-startup-message t)
(global-prettify-symbols-mode)
(scroll-bar-mode -1)
(menu-bar-mode -1)
(tool-bar-mode -1)
(tooltip-mode -1)

Literate programming

Organize your plain life in plain text

Org-mode is one of the hallmark features of Emacs, and provides the basis for my Literate Programming platform. It's essentially a markdown language with rich features for project management, scheduling, development, and writing. It's hard to convey everything within its capabilities.

• Babel languages

• Structure templates

(use-package org
  :hook
  (org-mode . (lambda ()
		      (org-indent-mode)
		      (visual-line-mode 1)
		      (variable-pitch-mode 1)))
  :config
  (setq org-ellipsis " ▾"
	      org-log-done 'time
	      org-log-into-drawer t
        org-directory dotfiles/home
	      org-src-preserve-indentation t)

  (org-babel-do-load-languages
   'org-babel-load-languages
   '((shell . t)
     (python . t)
     (emacs-lisp . t)))

  (require 'org-tempo)
  (add-to-list 'org-structure-template-alist '("s" . "src"))
  (add-to-list 'org-structure-template-alist '("q" . "quote"))
  (add-to-list 'org-structure-template-alist '("e" . "example"))
  (add-to-list 'org-structure-template-alist '("sh" . "src shell"))
  (add-to-list 'org-structure-template-alist '("py" . "src python"))
  (add-to-list 'org-structure-template-alist '("el" . "src emacs-lisp")))

(defun dotfiles/tangle (dir)
  "Recursively tangle the Org files within a directory."
  (interactive)
  (let ((org-files (directory-files-recursively dir "org")))
    (dolist (f org-files)
      (org-babel-tangle-file f))))

Custom keybindings

Make the ESC key quit (most) prompts, instead of the default C-g.

(global-set-key (kbd "<escape>") 'keyboard-escape-quit)

Hints

Download which-key, a package that displays the current incomplete keybinding input in a mini-buffer, showing available completion options.

(use-package which-key
  :diminish which-key-mode
  :init (which-key-mode)
  :config (setq which-key-idle-delay dotfiles/idle))

Leader

Implement the leader key using general.el, letting us easily configure prefixed keybindings in a much cleaner manner than the default methods.

(use-package general
  :config
  (general-create-definer dotfiles/leader
    :states '(normal motion)
    :keymaps 'override
    :prefix dotfiles/leader-key
    :global-prefix dotfiles/leader-key-global))

Use hydra for transient keybindings sharing a common prefix.

(use-package hydra)

Evil mode

After a few hour with vim I knew it was game over, I cannot even think of another way I would feel comfortable editing text. Luckily, there exist packages to emulate this within Emacs. evil-mode is the extensible VI layer for Emacs.

(use-package evil
  :init (setq evil-want-integration t
	      evil-want-keybinding nil)
  :config (evil-mode 1))

Unfortunately the default keybindings are lacking, but there is a community curated package evil-collection, which does a much better job implementing keybindings you would expect to find.

(use-package evil-collection
  :after evil
  :config (evil-collection-init))

Surround text with functions, quotations, and any other symbols using the evil-surround package.

(use-package evil-surround
  :config (global-evil-surround-mode 1))

https://github.com/redguardtoo/evil-nerd-commenter

• Toggle comments with M-;

(use-package evil-nerd-commenter
  :bind ("M-;" . evilnc-comment-or-uncomment-lines))

Shortcuts

Again cherry picked from Doom, I want to continue utilizing the muscle memory I have developed from a year of mainlining the framework.

• Close buffers with SPC c

• Find files with SPC . (period)

• Switch buffers with SPC , (comma)

(dotfiles/leader
  "." '(find-file :which-key "Files")
  "," '(switch-to-buffer :which-key "Buffers")
  "c" '(kill-buffer-and-window :which-key "Close"))

Run helper functions with SPC h.

• Packages p

• Variables v

• Functions f

(dotfiles/leader
  "h" '(:ignore t :which-key "Help")
  "hp" '(describe-package :which-key "Package")
  "hv" '(describe-variable :which-key "Variable")
  "hf" '(describe-function :which-key "Function"))

Quit emacs with SPC q.

• Saving q

• Without w

• Frame (daemon) f

(dotfiles/leader
  "q" '(:ignore t :which-key "Quit")
  "qq" '(save-buffers-kill-emacs :which-key "Save")
  "qw" '(kill-emacs :which-key "Now")
  "qf" '(delete-frame :which-key "Frame"))

Window management with SPC w.

• Swap with w

• Close with c

• Motions with h,j,k,l

• Split with s + <MOTION>

(dotfiles/leader
  "w" '(:ignore t :which-key "Window")
  "ww" '(window-swap-states :which-key "Swap")
  "wc" '(delete-window :which-key "Close")
  "wh" '(windmove-left :which-key "Left")
  "wj" '(windmove-down :which-key "Down")
  "wk" '(windmove-up :which-key "Up")
  "wl" '(windmove-right :which-key "Right")
  "ws" '(:ignore t :which-key "Split")
  "wsj" '(split-window-below :which-key "Down")
  "wsl" '(split-window-right :which-key "Right"))

Place runtime tweaks behind SPC t.

(dotfiles/leader
  "t" '(:ignore t :which-key "Tweaks"))

Version control

Another hallmark feature is Magit, a complete git porcelain within Emacs.

(use-package magit
  :custom (magit-display-buffer-function
           #'magit-display-buffer-same-window-except-diff-v1))

Work directly with github issues / pull requests using Forge.

• Requires a valid $GITHUB_TOKEN

(use-package forge)

Open the status page for the current repository with SPC g.

(dotfiles/leader
  "g" '(magit-status :which-key "Magit"))

Terminal emulation

While not a traditional terminal emulator, eshell provides me with all of the functionality I expect and require from one. Some users may be left wanting more, I would recommend they look into vterm.

https://github.com/zwild/eshell-prompt-extras

• Enable lambda shell prompt

(use-package eshell-prompt-extras
  :config (setq eshell-highlight-prompt nil
	            eshell-prompt-function 'epe-theme-lambda))

Open an eshell buffer with SPC e.

(dotfiles/leader
  "e" '(eshell :which-key "Shell"))

File management

Emacs' can feel more modern when icon-fonts are installed and prioritized. I feel that this makes navigation of folders much faster, given that file types may be quickly identified by their corresponding icons.

https://github.com/domtronn/all-the-icons.el

• Collects various icon fonts

(use-package all-the-icons)

https://github.com/jtbm37/all-the-icons-dired

• Integration with dired

(use-package all-the-icons-dired
  :hook (dired-mode . all-the-icons-dired-mode))

When opening dired, I don't want to have to press RET twice to navigate to the current directory. This can be avoided with dired-jump, included in the dired-x package shipped with dired.

(require 'dired-x)

By default dired will create a new buffer everytime you press RET over a directory. In my workflow this leads to many unwanted dired buffers that have to be cleaned up manually. Dired-single lets us reuse the same dired buffer.

• Move up a directory with h

• Open a single buffer with l

(use-package dired-single
  :config
  (evil-collection-define-key 'normal 'dired-mode-map
    "h" 'dired-single-up-directory
    "l" 'dired-single-buffer))

Open a dired buffer with SPC d.

(dotfiles/leader
  "d" '(dired-jump :which-key "Dired"))

Desktop

I use Emacs as a Desktop Environment with the exwm package. It allows Emacs to function as a complete tiling window manager for X11. My workflow includes launching the window manager with xinitrc, without the use of a display manager, controlling everything within Emacs.

Startup

exec dbus-launch --exit-with-session emacs -mm --debug-init

When launching into a session, if the display server is not running then startx should be invoked, to run the window manager.

if [ -z "${DISPLAY}" ] && [ "${XDG_VTNR}" -eq 1 ]; then
    exec startx
fi

Applications

Define a method to run an external process, allowing us to launch any application on a new process without interferring with Emacs.

(defun dotfiles/run (command)
  "Run an external process."
  (interactive (list (read-shell-command "λ ")))
  (start-process-shell-command command nil command))

Some methods must be called and applied to the current call process in order to function correctly with Emacs hooks.

(defun dotfiles/run-in-background (command)
  (let ((command-parts (split-string command "[ ]+")))
    (apply #'call-process `(,(car command-parts) nil 0 nil ,@(cdr command-parts)))))

• Run shell commands with SPC x

• Run async shell commands with SPC z

(dotfiles/leader
  "x" '(dotfiles/run :which-key "Run")
  "z" '(async-shell-command :which-key "Async"))

Initialization

When the window manager first launches the init-hook will be called, this allows us to define some custom logic when it's initialized.

• Display time and date

• Display battery info (if available)

In my personal configuration, I do not want the battery or time displayed within Emacs when it's not running as desktop environment because that information is typically already available.

(defun dotfiles/init-hook ()
  (exwm-workspace-switch-create 1)
  (setq display-time-and-date t)
  (display-battery-mode 1)
  (display-time-mode 1))

Displays

Using autorandr with pre configured profiles, switching screens (AKA hot plugging) is also handled through a hook.

(defun dotfiles/update-display ()
  (dotfiles/run-in-background "autorandr --change --force"))

Configuration

Finally we configure the window manager.

• Enable randr support

Connect our custom hooks and configure the input keys, a custom layer for defining which keys are captured by Emacs, and which are passed through to X applications.

• Pass through to Emacs

  • M-x to Emacs

  • C-g to Emacs

  • C-SPC to Emacs

• Bindings with S (Super / Win)

  • Reset S-r

  • Launch S-&

  • Workspace S-[1..9]

(use-package exwm
  :config
  (require 'exwm-randr)
  (exwm-randr-enable)
  (add-hook 'exwm-init-hook #'dotfiles/init-hook)
  (add-hook 'exwm-randr-screen-change-hook #'dotfiles/update-display)
  (dotfiles/update-display)
  (setq exwm-input-prefix-keys
        '(?\M-x
          ?\C-g
          ?\C-\ )
        exwm-input-global-keys
        `(([?\s-r] . exwm-reset)
          ([?\s-&] . dotfiles/run)
          ,@(mapcar (lambda (i)
                      `(,(kbd (format "s-%d" i)) .
                        (lambda ()
                          (interactive)
                          (exwm-workspace-switch-create ,i))))
                    (number-sequence 1 9))))
  (exwm-enable))

Writing

I am using Org-mode extensively for writing projects for different purposes. Most of the improvements are done in the Core module for the Literate programming configuration. Org-superstar-mode for making headline stars more super.

(use-package org-superstar
  :hook (org-mode . org-superstar-mode))

I use Hugo for my personal website, which I write in Org-mode before compiling to hugo-markdown. Ox-hugo, configured for one-post-per-file is my technique for managing my blog.

(use-package ox-hugo 
  :after ox)

Produce high quality presentations that work anywhere with HTML/JS and the Reveal.js package. Ox-reveal, configured to use a cdn allows us to produce ones that are not dependent on a local version of Reveal.js.

(use-package ox-reveal
  :after ox
  :custom (org-reveal-root "https://cdn.jsdelivr.net/npm/reveal.js"))

Roam

Download and install org-roam, a plain text knowledge management system for Emacs.

(use-package org-roam
  :hook (after-init . org-roam-mode)
  :custom
  (org-roam-directory org-directory)
  (org-roam-encrypt-files t))

Visualize the org-roam database with the server, available when the editor is running at http://localhost:8080

(use-package org-roam-server
  :hook (org-roam-mode . org-roam-server-mode))

Place keybindings behind SPC r.

• Find with f

• Toggle buffer with b

• Dailies with d

  • Arbitrary date with d

  • Today with t

  • Tomorrow with m

  • Yesterday with y

(dotfiles/leader
  "r" '(:ignore t :which-key "Roam")
  "rf" '(org-roam-find-file :which-key "Find")
  "rb" '(org-roam-buffer-toggle-display :which-key "Buffer")
  "rd" '(:ignore t :which-key "Dailies")
  "rdd" '(org-roam-dailies-find-date :which-key "Date")
  "rdt" '(org-roam-dailies-find-today :which-key "Today")
  "rdm" '(org-roam-dailies-find-tomorrow :which-key "Tomorrow")
  "rdy" '(org-roam-dailies-find-yesterday :which-key "Yesterday"))

Organize the capture templates, this allows me to quickly dictate where each new item should be placed.

• posts/ contains blog posts

• notes/ contains cited notes on others' work

• slides/ contains presentations / screencasts

(setq org-roam-capture-templates
      '(("p" "Posts" plain (function org-roam-capture--get-point)
          "%?"
          :file-name "docs/posts/${slug}"
          :unnarrowed t
          :head
"
,#+TITLE: ${title}
,#+AUTHOR: Christopher James Hayward
,#+DATE: %<%Y-%m-%d>

,#+ROAM_KEY: https://chrishayward.xyz/posts/${slug}/

,#+HUGO_BASE_DIR: ~/.local/source/website
,#+HUGO_AUTO_SET_LASTMOD: t
,#+HUGO_SECTION: posts
")
        ("n" "Notes" plain (function org-roam-capture--get-point)
          "%?"
          :file-name "docs/notes/${slug}"
          :unnarrowed t
          :head
"
,#+TITLE: ${title}
,#+AUTHOR: Christopher James Hayward

,#+ROAM_KEY: https://chrishayward.xyz/notes/${slug}/

,#+HUGO_BASE_DIR: ~/.local/source/website
,#+HUGO_AUTO_SET_LASTMOD: t
,#+HUGO_SECTION: notes
")
        ("s" "Slides" plain (function org-roam-capture--get-point)
         "%?"
         :file-name "docs/slides/${slug}"
         :unnarrowed t
         :head
"
,#+TITLE: ${title}
,#+AUTHOR: Christopher James Hayward

,#+REVEAL_ROOT: https://cdn.jsdelivr.net/npm/reveal.js
")))

By default I want my daily notes to live in daily/ relative to my dotfiles.

(setq org-roam-dailies-capture-templates
      '(("d" "Default" entry (function org-roam-capture--get-point)
         "* %?"
         :file-name "docs/daily/%<%Y-%m-%d>"
         :head
"
,#+TITLE: %<%Y-%m-%d>
,#+AUTHOR: Christopher James Hayward
")))

Email

Plain text email delivered via mu, mu4e and mbsync. I run my own email server, so your configuration may differ from mine. This is the mbsyncrc file I use to synchronize my local mail with my server. This is required for mu4e in Emacs.

IMAPStore xyz-remote
Host mail.chrishayward.xyz
User chris@chrishayward.xyz
PassCmd "pass chrishayward.xyz/chris"
SSLType IMAPS

MaildirStore xyz-local
Path ~/.cache/mail/
Inbox ~/.cache/mail/inbox
SubFolders Verbatim

Channel xyz
Master :xyz-remote:
Slave :xyz-local:
Patterns * !Archives
Create Both
Expunge Both
SyncState *

The system typically expects to find this file at $HOME/.mbsyncrc, but you may also specify a custom path if launching the command using arguments. I chose to symlink the default location to my repository.

mbsync -a
mu index --maildir="~/.cache/mail"

Once the mail is being synchronized, and the mail has been indexed with mu, it's time to install the required packages for Emacs.

(use-package mu4e
  :load-path "/usr/share/emacs/site-lisp/mu4e"
  :config
  (setq mu4e-change-filenames-when-moving t
        mu4e-update-interval (* 5 60) ;; Every 5 minutes.
        mu4e-get-mail-command "mbsync -a"
        mu4e-maildir "~/.cache/mail"
        mu4e-compose-signature 
          (concat "Chris Hayward\n"
                  "https://chrishayward.xyz\n"))

  ;; Ensure plain text scales for all devices.
  (setq mu4e-compose-format-flowed t)

  ;; GPG signing key for outbound mail.
  (setq mml-secure-openpgp-signers '("37AB1CB72B741E478CA026D43025DCBD46F81C0F"))
  (add-hook 'message-send-hook 'mml-secure-message-sign-pgpmime)

  (setq message-send-mail-function 'smtpmail-send-it)  

  ;; Configure mail account(s).
  (setq mu4e-contexts
    (list
      ;; Main
      ;; chris@chrishayward.xyz
      (make-mu4e-context
        :name "Main"
        :match-func
          (lambda (msg)
            (when msg 
              (string-prefix-p "/Main" (mu4e-message-field msg :maildir))))
        :vars
          '((user-full-name . "Christopher James Hayward")
            (user-mail-address . "chris@chrishayward.xyz")
            (smtpmail-smtp-server . "mail.chrishayward.xyz")
            (smtpmail-smtp-service . 587)
            (smtpmail-stream-type . starttls))))))

Use mu4e-alert to give us desktop notifications about incoming mail.

(use-package mu4e-alert
  :custom
  (mu4e-alert-set-default-style 'libnotify)
  :config
  (mu4e-alert-enable-notifications)
  (mu4e-alert-enable-mode-line-display))

Create a keybinding to open the mail dashboard with SPC m.

(dotfiles/leader
  "m" '(mu4e :which-key "Mail"))

Agenda

Override org-agenda-file-regexp to include .org.gpg files.

(unless (string-match-p "\\.gpg" org-agenda-file-regexp)
  (setq org-agenda-file-regexp
        (replace-regexp-in-string "\\\\\\.org" "\\\\.org\\\\(\\\\.gpg\\\\)?"
                                  org-agenda-file-regexp)))

Configure agenda sources.

(setq org-agenda-files '("~/.emacs.d/docs/"
                         "~/.emacs.d/docs/daily/"))

Open an agenda buffer with SPC a.

(dotfiles/leader
  "a" '(org-agenda :which-key "Agenda"))

Images

Create screencasts with one-frame-per-action GIF recording via emacs-gif-screencast.

• Can be paused / resumed

• High quality images

• Optimized size

It requires the installation of scrot, gifsicle, and convert from the ImageMagick library.

(use-package gif-screencast
  :custom
  (gif-screencast-output-directory (concat dotfiles/home "docs/images/")))

Screencast controls behind SPC s.

• Start / stop with s

• Pause with t

(dotfiles/leader
  "s" '(:ignore t :which-key "Screencast")
  "ss" '(gif-screencast-start-or-stop :which-key "Start / Stop")
  "sp" '(gif-screencast-toggle-pause :which-key "Pause"))

Projects

An IDE like experience (or better) can be achieved in Emacs using two Microsoft open source initiatives.

Turn Emacs into an IDE (or better) with the Language Server Protocol, an open source initiative from Microsoft for the VSCode editor.

Lsp-mode brings support for language servers into Emacs.

(use-package lsp-mode
  :custom (gc-cons-threshold 1000000000)
          (lsp-idle-delay 0.500))

https://emacs-lsp.github.io/lsp-ui/

• UI improvements for lsp-mode

(use-package lsp-ui
  :custom (lsp-ui-doc-position 'at-point)
          (lsp-ui-doc-delay 0.500))

Management

Configure projectile, a project interaction library for Emacs. It provides a nice set of features for operating on a project level without introducing external dependencies.

(use-package projectile
  :config
  (setq projectile-project-search-path '("~/.local/source"))
  (projectile-mode))

Passwords

Pass makes managing passwords extremely easy, encrypring them in a file structure and providing easy commands for generating, modify, and copying passwords. password-store.el provides a wrapper for the functionality within Emacs.

(use-package password-store
  :custom (password-store-dir dotfiles/passwords))

Configure keybindings behind SPC p.

• Copy with p

• Rename with r

• Generate with g

(dotfiles/leader
  "p" '(:ignore t :which-key "Passwords")
  "pp" '(password-store-copy :which-key "Copy")
  "pr" '(password-store-rename :which-key "Rename")
  "pg" '(password-store-generate :which-key "Generate"))

Debugging

Handled through the Debug Adapter Protocol, an open source initiative from Microsoft for the VSCode editor.

Dap-mode adds support for the protocol to Emacs.

(use-package dap-mode)

Completion

Text completion framework via company aka Complete Anything.

http://company-mode.github.io/

• Integrate with lsp-mode

(use-package company)
(use-package company-lsp)

Languages

Support for individual languages are implemented here.

C/C++

Install the ccls language server.

(use-package ccls
  :hook ((c-mode c++-mode objc-mode cuda-mode) .
         (lambda () (require 'ccls) (lsp))))

Python

Install the pyls language server.

pip install --user "python-language-server[all]"

python-mode is an Emacs built in mode.

(use-package python-mode
  :hook (python-mode . lsp)
  :config (require 'dap-python)
  :custom (python-shell-interpreter "python3") ;; Required if "python" is not python 3.
          (dap-python-executable "python3")    ;; Same as above.
          (dap-python-debugger 'debugpy))

Go

Install the gopls language server.

GO111MODULE=on go get golang.org/x/tools/gopls@latest

Set the GOPATH environment variable prior to loading, this allows us to change the default value of $HOME/go to $HOME/.go.

(setenv "GOPATH" (concat (getenv "HOME") "/.go/"))

Additionally, include the bin subdirectory of the $GOPATH in the $PATH variable, adding compiled golang programs.

(setenv "PATH" (concat (getenv "GOPATH") "bin:" (getenv "PATH")))

Finally we can include the go-mode package, integrating it with lsp.

(use-package go-mode
  :hook (go-mode . lsp))

Apply some custom behaviour before saving:

• Format buffer

• Organize imports

(defun dotfiles/go-hook ()
  (add-hook 'before-save-hook #'lsp-format-buffer t t)
  (add-hook 'before-save-hook #'lsp-organize-imports t t))

(add-hook 'go-mode-hook #'dotfiles/go-hook)

Interface

Bring Emacs out of the eighties

Fonts

Configure the system font with a single font-family and define the size, of which variations to the font size are relative to this value.

(defvar dotfiles/font "Fira Code")
(defvar dotfiles/font-size 96)

Write out to all 3 of Emacs' default font faces.

(set-face-attribute 'default nil :font dotfiles/font :height dotfiles/font-size)
(set-face-attribute 'fixed-pitch nil :font dotfiles/font :height dotfiles/font-size)
(set-face-attribute 'variable-pitch nil :font dotfiles/font :height dotfiles/font-size)

Define a transient keybinding for scaling the text.

(defhydra hydra-text-scale (:timeout 4)
  "Scale"
  ("j" text-scale-increase "Increase")
  ("k" text-scale-decrease "Decrease")
  ("f" nil "Finished" :exit t))

Increase the font size in buffers with SPC t f.

• Increase j

• Decrease k

• Finish f

(dotfiles/leader
  "tf" '(hydra-text-scale/body :which-key "Font"))

Lines

Relative line numbers are important when using VI emulation keys. You can prefix most commands with a number, allowing you to jump up / down by a line count.

  5:
  4:
  3:
  2:
  1:
156: << CURRENT LINE >>
  1:
  2:
  3:
  4:
  5:

https://github.com/emacsmirror/linum-relative

• Integrate with display-line-numbers-mode for performance

(use-package linum-relative
  :init (setq linum-relative-backend
              'display-line-numbers-mode)
  :config (linum-relative-global-mode))

Add line numbers to the toggles behind SPC t l.

(dotfiles/leader
  "tl" '(linum-relative-global-mode :which-key "Lines"))

https://github.com/Fanael/rainbow-delimiters

• Colourize nested parenthesis

(use-package rainbow-delimiters
  :hook (prog-mode . rainbow-delimiters-mode))

Themes

Cherry pick a few modules from doom-emacs. High quality and modern colour themes are provided in the doom-themes package.

(use-package doom-themes
  :init (load-theme 'doom-moonlight t))

doom-modeline provides an elegant status bar / modeline.

(use-package doom-modeline
  :init (doom-modeline-mode 1)
  :custom ((doom-modeline-height 16)))

Load a theme with SPC t t.

(dotfiles/leader
  "tt" '(load-theme t t :which-key "Theme"))

Ligatures

Enable font ligatures via fira-code-mode, perform this action only when Fira Code is set as the current font.

(use-package fira-code-mode
  :hook (prog-mode org-mode))

Toggle global ligature mode with SPC t g.

(dotfiles/leader
  "tg" '(global-fira-code-mode :which-key "Ligatures"))

Dashboard

Present a dashboard when first launching Emacs.

(use-package dashboard
  :config
  (setq dashboard-center-content t
        dashboard-set-init-info t
        dashboard-set-file-icons t
        dashboard-set-heading-icons t
        dashboard-set-navigator t
        dashboard-startup-banner 'logo
        dashboard-projects-backend 'projectile
        dashboard-items '((projects . 5)
                          (recents . 5)
                          (agenda . 5 )))
  (dashboard-setup-startup-hook))

Customize the buttons of the navigator:

•  Brain @ http://localhost:8080

•  Homepage @ https://chrishayward.xyz

•  Athabasca @ https://login.athabascau.ca/cas/login

(setq dashboard-navigator-buttons
      `(;; First row.
        ((,(all-the-icons-fileicon "brain" :height 1.1 :v-adjust 0.0)
         "Brain"
         "Knowledge base"
         (lambda (&rest _) (browse-url "http://localhost:8080"))))
        ;; Second row.
        ((,(all-the-icons-material "public" :height 1.1 :v-adjust 0.0)
         "Homepage"
         "Personal website"
         (lambda (&rest _) (browse-url "https://chrishayward.xyz"))))
        ;; Third row.
        ((,(all-the-icons-faicon "university" :height 1.1 :v-adjust 0.0)
         "Athabasca"
         "Univeristy login"
         (lambda (&rest _) (browse-url "https://login.athabascau.ca/cas/login"))))))

When running in daemon mode, ensure that the dashboard is the initial buffer.

(setq initial-buffer-choice
      (lambda ()
        (get-buffer "*dashboard*")))