I showed you my source code, pls respond

Christopher James Hayward a582635c87 Add Dockerfile		3 years ago
bin	Update dotfiles script	4 years ago
config	Replace old dotfiles with immutable nixos dotfiles	3 years ago
docs	Update tasks	3 years ago
hosts	Add flake output	3 years ago
modules	Add missing outputs	3 years ago
shells	Add missing outputs	3 years ago
.gitattributes	Add GPG handling to attributes	4 years ago
.gitignore	Update ignores	4 years ago
.gitmodules	Move submodule	4 years ago
Dockerfile	Add Dockerfile	3 years ago
LICENSE	Update README/LICENSE	4 years ago
README.org	Add Dockerfile	3 years ago
flake.lock	Add flake output	3 years ago
flake.nix	Add flake output	3 years ago
shell.nix	Add flake output	3 years ago

README.org

Dotfiles

Introduction
Operating System
Host Configurations
- Default
  - Configuration
  - Hardware
- Acernitro
  - Configuration
  - Hardware
Module Definitions
- X11
- Flakes
- Cachix
- Home Manager
- Git
- Gpg
- Vim
- GTK
Development Shells
- Go
- gRPC
- C/C++
- Python
Emacs Configuration
- Disable UI
- Native Comp
- Backup Files
- Shell Commands
- Nix Mode
- Evil Mode
- EXWM
- General
- Which Key
- EWW
- Dired
- Icons
- Emojis
- EShell
- VTerm
- Magit
- Fonts
- Elfeed
- Org Mode
- Org Roam
- Org Drill
- Org Agenda
- Org Pomodoro
- Writegood Mode
- Aspell
- Hugo
- Reveal
- Passwords
- MU4E
- Projectile
- LSP Mode
- Company Mode
- Go Mode
- Python Mode
- PlantUML
- Swiper
- Doom Themes
- Doom Modeline
Footnotes

Immutable NixOS dotfiles.

Built for Life, Liberty, and the Open Road.

100% Immutable
100% Declarative
100% Reproducible

Introduction

This is my personal configuration(s) for GNU/Linux¹ systems. It enables a consistent experience and computing environment across all of my machines. This project is written with GNU/Emacs², leveraging its capabilities for Literate Programming³, a technique where programs are written in a natural language, such as English, interspersed with snippets of code to describe a software project.

This file is controlled by /etc/dotfiles/README.org

Getting Started

Download the latest version of NixOS https://nixos.org/download.html
Partition drives and mount the file system https://nixos.org/manual/nixos/stable/#sec-installation-partitioning
Clone the project to /mnt/etc/dotfiles git clone git@git.chrishayward.xyz:chris/dotfiles /mnt/etc/dotfiles
Load the default shell environment nix-shell /mnt/etc/dotfiles
Install the default system sudo nixos-install --flake /mnt/etc/dotfiles#nixos
Reboot and login, start a graphical system with startx

Making Changes

The nixos-rebuild command updates the system so that it corresponds to the configuration specified in the module. It builds the new system in /nix/store/, runs the activation scripts, and restarts and system services (if needed). The command has one required argument, which specifies the desired operation:

switch: Build and activate the new configuration, making it the new boot default
boot: Build the new configuration and make it the boot default, without activation
test: Build and activate the new configuration, without adding it to the boot menu
build: Build the new configuration, without activation, nor adding it to the boot menu
build-vm: Build a script that starts a virtual machine with the desired configuration

# Build and activate a new configuration.
sudo nixos-rebuild switch --flake $FLAKE#$HOSTNAME

Instead of building a new configuration, it's possible to rollback to a previous generation using the nixos-rebuild command, by supplying the --rollback argument.

# Rollback to the previous generation.
sudo nixos-rebuild switch --rollback

Docker Container

It's possible to use parts of this configuration using the container. By default, sandboxing is turned off inside of the container, even though it's enabled in new installations. This can lead to differences between derivations built inside containers, versus those built without any containerization. This is especially true if a derivation relies on sandboxing to block sideloading of dependencies.

# Derive from the official image.
FROM nixos/nix

# Add the unstable channel.
RUN nix-channel --add https://nixos.org/channels/nixpkgs-unstable nixpkgs
RUN nix-channel --update

# Setup the default environment.
WORKDIR /etc/dotfiles
COPY . .

# Load the default system shell.
RUN nix-shell -p

Operating System

NixOS⁴ is a purely functional Linux distribution built on top of the Nix⁵ package manager. It uses a declarative configuration language to define entire computer systems, and allows reliable system upgrades and rollbacks. NixOS⁴ also has tool dedicated to DevOps and deployment tasks, and makes it trivial to share development environments.

# <<file-warning>>
{
  description = "<<description>>";

  inputs = {
    <<os-nixpkgs>> 
    <<os-home-manager>>
    <<os-emacs-overlay>>
    <<os-nixos-hardware>>
  };

  outputs = inputs @ { self, nixpkgs, nixpkgs-unstable, ... }: {
    nixosConfigurations = {
      <<host-default>>
      <<host-acernitro>>
    };
  };
}

Nixpkgs

Nixpkgs⁶ is a collection of over 60,000 software packages that can be installed with the Nix⁵ package manager. Two main branches are offered:

The current stable release
The Unstable branch following the latest development

nixpkgs.url = "nixpkgs/nixos-unstable";
nixpkgs-unstable.url = "nixpkgs/master";

Home Manager

Home Manager⁷ provides a basic system for managing user environments using the Nix⁵ package manager together with the Nix libraries found in Nixpkgs⁶. It allows declarative configuration of user specific (non-global) packages and files.

home-manager.url = "github:nix-community/home-manager";
home-manager.inputs.nixpkgs.follows = "nixpkgs";

Emacs Overlay

Adding the Emacs Overlay⁸ extends the GNU/Emacs² package set to contain the latest versions, and daily generations from popular package sources, including the needed dependencies to run GNU/Emacs² as a Window Manager.

emacs-overlay.url = "github:nix-community/emacs-overlay";

NixOS Hardware

NixOS Hardware⁹ is a collection of NixOS⁴ modules covering specific hardware quirks. Unlike the channel, this will update the git repository on a rebuild. However, it's easy to pin particular revisions for more stability.

nixos-hardware.url = "github:nixos/nixos-hardware";

Host Configurations

NixOS⁴ typically stores the current machine configuration in /etc/nixos/configuration.nix. In this project, this file is stored in /etc/dotfiles/hosts/$HOSTNAME/..., and imported, along with the generated hardware configurations. This ensures that multiple host machines can share the same modules, and generating new host definitions is trivial.

Default

The default host, built using QEMU¹⁰, a free and open-source emulator that can perform hardware virtualization. It features a lightweight system optimized for development, running GNU/Emacs² + EXWM¹¹ as the graphical environment.

nixos = nixpkgs.lib.nixosSystem {
  system = "x86_64-linux";
  specialArgs = { inherit inputs; };
  modules = [
    ./hosts/nixos
    <<module-x11>>
    <<module-flakes>>
    <<module-cachix>>
    <<module-home-manager>>
  ];
};

Deploy this configuration with nixos-rebuild switch --flake /etc/dotfiles/#nixos.

# <<file-warning>>
{ ... }:

{
  imports = [
    ./configuration.nix
    ./hardware.nix
  ];
}

Configuration

This configuration can function independently from the rest of the project. If you wish to install a specific host without including the entire flake, you can create a symbolic link from /etc/nixos to /etc/dotfiles/hosts/<name>. This configuration also handles a few requirements that must occur outside of the Home Manager⁷ integration:

It imports the Emacs Overlay⁸
It installs the unstable version of Nix⁵

# <<file-warning>>
{ config, pkgs, inputs, ... }:

{
  boot.loader.grub.enable = true;
  boot.loader.grub.version = 2;
  boot.loader.grub.device = "/dev/sda";

  time.timeZone = "America/Toronto";

  networking.hostName = "nixos";
  networking.useDHCP = false;
  networking.firewall.enable = false;
  networking.interfaces.ens3.useDHCP = true;

  programs.mtr.enable = true;
  programs.fish.enable = true;
  programs.gnupg.agent.enable = true;

  users.users.chris = {
    shell = pkgs.fish;
    isNormalUser = true;
    extraGroups = [ "wheel" ];
  };
}

Hardware

The file system for this host is a single 24GB QCOW file, a format for disk images used by QEMU¹⁰. The file can be recreated easily by following the steps listed in the NixOS⁴ installation manual, specifically the section on disk formatting.

# <<file-warning>>
{ config, lib, pkgs, modulesPath, ... }:

{
  imports =
    [ (modulesPath + "/profiles/qemu-guest.nix")
    ];

  boot.initrd.availableKernelModules = [ "ata_piix" "floppy" "sd_mod" "sr_mod" ];
  boot.initrd.kernelModules = [ ];
  boot.kernelModules = [ ];
  boot.extraModulePackages = [ ];

  fileSystems."/" =
    { device = "/dev/disk/by-uuid/fddc37ff-a442-41fa-afc4-abf878be7c5a";
      fsType = "ext4";
    };

  swapDevices =
    [ { device = "/dev/disk/by-uuid/5fc0e3df-e796-4fe2-8482-c6acaed9d36f"; }
    ];
}

TODO Acernitro

My gaming laptop, the model is an Acer Nitro AN-515-53¹². The Nitro 5 has more in common with the mid-range notebooks rather than the gaming models due to its cooling design, chassis, and overall construction.

Here are the specs:

Slot	Component
CPU	Intel Core i5-8300H
GPU	NVIDIA GeForce GTX 1050Ti (4GB GDDR5)
RAM	16GB DDR4
Display	15.6" Full HD (1920 x 1080), IPS
Storage	1000GB HDD
Weight	2.48kg (5.5 lbs)

# NOTE: Work In Progress!
# acernitro = nixpkgs.lib.nixosSystem {
#   system = "x86_64-linux";
#   specialArgs = { inherit inputs; };
#   modules = [
#     ./hosts/acernitro
#     <<module-x11>>
#     <<module-flakes>>
#     <<module-cachix>>
#     <<module-home-manager>>
#   ];
# };

Deploy this configuration with nixos-rebuild switch --flake /etc/dotfiles/#acernitro.

# <<file-warning>>
{ ... }:

{
  imports = [
    ./configuration.nix
    ./hardware.nix
  ];
}

TODO Configuration

TODO Hardware

Module Definitions

Modules are files combined by NixOS⁴ to produce the full system configuration. Modules wre introduced to allow extending NixOS⁴ without modifying its source code. They also allow splitting up configuration.nix, making the system configuration easier to maintain and use.

X11

./modules/x11.nix

X11, or X¹³ is the generic name for the X Window System Display Server. All graphical GNU/Linux¹ applications connect to an X-Window¹³ (or Wayland¹⁴) to display graphical data on the monitor of a computer. Its a program that acts as the interface between graphical applications and the graphics subsystem of the computer.

# <<file-warning>>
{ config, pkgs, ... }:

{
  services.xserver.enable = true;
  services.xserver.layout = "us";
  services.xserver.libinput.enable = true;
  services.xserver.displayManager.startx.enable = true;

  environment = {
    systemPackages = with pkgs; [
      pkgs.sqlite
    ];
    extraInit = ''
      export XAUTHORITY=/tmp/Xauthority
      [ -e ~/.Xauthority ] && mv -f ~/.Xauthority "$XAUTHORITY"
    '';
  };

  services.picom.enable = true;
  services.openssh.enable = true;
  services.printing.enable = true;

  fonts.fonts = with pkgs; [
    iosevka
    emacs-all-the-icons-fonts
  ];
}

Flakes

./modules/flakes.nix

Nix Flakes¹⁵ are an upcoming feature of the Nix package manager⁵. They allow you to specify your codes dependencies in a declarative way, simply by listing them inside of a flake.nix file. Each dependency is then pinned to a specific git-hash. Flakes¹⁵ replace the nix-channels command and things like builtins.fetchGit, keeping dependencies at the top of the tree, and channels always in sync. Currently, Flakes¹⁵ are not available unless explicitly enabled.

# <<file-warning>>
{ config, pkgs, inputs, ... }:

{
  nix = {
    package = pkgs.nixUnstable;
    extraOptions = ''
      experimental-features = nix-command flakes
    '';
  };

  nixpkgs = {
    config = { allowUnfree = true; };
    overlays = [ inputs.emacs-overlay.overlay ];
  };
}

Cachix

./modules/cachix.nix

Cachix¹⁶ is a Command line client for Nix⁵ binary cache hosting. This allows downloading and usage of pre-compiled binaries for applications on nearly every available system architecture. This speeds up the time it takes to rebuild configurations.

# <<file-warning>>
{ config, ... }:

{
  nix = {
    binaryCaches = [
      "https://nix-community.cachix.org"
    ];
    binaryCachePublicKeys = [
      "nix-community.cachix.org-1:mB9FSh9qf2dCimDSUo8Zy7bkq5CX+/rkCWyvRCYg3Fs="
    ];
  };
}

Home Manager

Home Manager⁷ includes a flake.nix file for compatibility with Nix Flakes, a feature utilized heavily in this project. When using flakes, switching to a new configuration is done only for the entire system, using the command nixos-rebuild switch --flake <path>, instead of nixos-rebuild, and home-manager seperately.

inputs.home-manager.nixosModules.home-manager {
  home-manager.useGlobalPkgs = true;
  home-manager.useUserPackages = true;
  home-manager.users.chris = {
    imports = [
      <<module-git>>
      <<module-gpg>>
      <<module-vim>>
      <<module-gtk>>
      <<module-emacs>>
    ];
  };
}

Git

./modules/git.nix

Git¹⁷ is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. Git is easy to learn, has a tiny footprint, and lighting fast performance. It outclasses every other version control tool such as: SCM, Subversion, CVS, ClearCase, with features like cheap local branching, convinient staging areas, and multiple workflows.

# <<file-warning>>
{ pkgs, ... }:

{
  programs.git = {
    enable = true;
    userName = "Christopher James Hayward";
    userEmail = "chris@chrishayward.xyz";

    signing = {
      key = "37AB1CB72B741E478CA026D43025DCBD46F81C0F";
      signByDefault = true;
    };
  };
}

Gpg

./modules/gpg.nix

GNU Privacy Guard¹⁸ is a free-software replacement for Symantec's PGP cryptographic software suite. It is compliant with RFC 4880, the IETF standards-track specification of OpenPGP. Modern versions of PGP are interoperable with GnuPG and other OpenPGP-compliant systems.

# <<file-warning>>
{ pkgs, ... }:

{
  services.gpg-agent = {
    enable = true;
    defaultCacheTtl = 1800;
    enableSshSupport = true;
    pinentryFlavor = "gtk2";
  };
}

Vim

./modules/vim.nix

Neovim¹⁹ is a project that seeks to aggressively refactor Vim in order to:

Simplify maintenance and encourage contributions
Split the work between multiple developers
Enable advanced UIs without core modification
Maximize extensibility

# <<file-warning>>
{ pkgs, ... }:

{
  programs.neovim = {
    enable = true;
    viAlias = true;
    vimAlias = true;
    vimdiffAlias = true;
    extraConfig = ''
      set number relativenumber
      set nobackup
    '';
    extraPackages = [
      pkgs.nixfmt
    ];
    plugins = with pkgs.vimPlugins; [
      vim-nix
      vim-airline
      vim-polyglot
    ];
  };
}

GTK

./modules/gtk.nix

GTK²⁰ is a free and open-source, cross-platform widget toolkit for graphical user interfaces. It's one of the most popular toolkits for the Wayland¹⁴ and X11¹³ windowing systems.

# <<file-warning>>
{ pkgs, ... }:

{
  home.packages = [
    pkgs.nordic
    pkgs.lxappearance
  ];

  home.file.".gtkrc-2.0" = {
    text = ''
      gtk-theme-name="Nordic-bluish-accent"
      gtk-icon-theme-name="Adwaita"
      gtk-font-name="Sans 10"
      gtk-cursor-theme-size=0
      gtk-toolbar-style=GTK_TOOLBAR_BOTH_HORIZ
      gtk-toolbar-icon-size=GTK_ICON_SIZE_LARGE_TOOLBAR
      gtk-button-images=0
      gtk-menu-images=0
      gtk-enable-event-sounds=1
      gtk-enable-input-feedback-sounds=1
      gtk-xft-antialias=1
      gtk-xft-hinting=1
      gtk-xft-hintstyle="hintmedium"
    '';
  };
}

Development Shells

The command nix-shell²¹ will build the dependencies of the specified derivation, but not the derivation itself. It will then start an interactive shell in which all environment variables defined by the derivation path have been set to their corresponding values.

Import this shell with nix-shell /etc/dotfiles.

# <<file-warning>>
{ pkgs ? import <nixpkgs> { } }:

with pkgs;

let
  nixBin = writeShellScriptBin "nix" ''
    ${nixFlakes}/bin/nix --option experimental-features "nix-command flakes" "$@"
  '';

in mkShell {
  buildInputs = [
    git
  ];
  shellHook = ''
    export FLAKE=$(pwd)
    export PATH=$FLAKE/bin:${nixBin}/bin:$PATH"
  '';
}

Go

Go²² is an open-source programming language that makes it easy to build simple, reliable, and efficient software. It's statically typed and compiled programming language. It's syntactically similar to C, but with memory safety, garbage collection, structural typing, and CSP-style concurrency.

Import this shell with nix-shell /etc/dotfiles/shells/go

# <<file-warning>>
{ pkgs ? import <nixpkgs> { } }:

with pkgs;
mkShell {
  buildInputs = [
    go
    gopls
    protoc-gen-go-grpc
  ];
  shellHook = ''
    export GO111MODULE=on
    export GOPATH=$HOME/.go/
    export PATH=$GOPATH/bin:$PATH
  '';
}

gRPC

gRPC²³ is a modern open-source, high-performance Remote Procedure Call (RPC) framework that can run in any environment. It can efficiently connect services in and across data centres with pluggable support for load balancing, tracing, health checking, and authentication.

Import this shell with nix-shell /etc/dotfiles/shells/grpc

# <<file-warning>>
{ pkgs ? import <nixpkgs> { } }:

with pkgs;
mkShell {
  buildInputs = [
    grpc
    grpc-tools
    grpcui
    grpcurl
  ];
  shellHook = ''
  '';
}

C/C++

C²⁴ is a general-purpose, procedural computer programming language support structured programming, lexical variable scope, and recursion. It has a static type system, and by design provides constructs that map efficiently to typical machine instructions. C++²⁵ is a general-purpose programming language created as an extension of the C²⁴ programming language.

Import this shell with nix-shell /etc/dotfiles/shells/cc

# <<file-warning>>
{ pkgs ? import <nixpkgs> { } }:

with pkgs;
mkShell {
  buildInputs = [
    ccls
    gnumake
    libstdcxx5
    gcc-unwrapped
  ];
  shellHook = ''
  '';
}

Python

Python²⁶ is an interpreted high-level, general-purpose programming language. Its design philosophy emphasizes code readability, with its notable use of significant indentation. Its language constructs, as well as its object-oriented approach aim to help programmers write clear, logical, code for small and large projects.

Import this shell with nix-shell /etc/dotfiles/shells/python

# <<file-warning>>
{ pkgs ? import <nixpkgs> { } }:

with pkgs;
mkShell {
  buildInputs = [
    python39Packages.pip
    python39Packages.pip-tools
    python39Packages.pyls-mypy
    python39Packages.pyls-isort
    python39Packages.pyls-black
  ];
  shellHook = ''
  '';
}

Emacs Configuration

./modules/emacs.nix

GNU/Emacs² is an extensible, customizable, free/libre text editor – and more. At its core is an interpreter for Emacs Lisp¹⁸, a dialect of the Lisp programming language with extensions to support text editing. Other features include:

Highly customizable
Full Unicopde support
Content-aware editing modes
Complete built-in documentation
Wide range of functionality beyond text editing

# <<file-warning>>
{ pkgs, ... }:

let
  myEmacs = pkgs.emacsWithPackagesFromUsePackage {
    config = ../README.org;
    package = <<emacs-native-comp-package>>
    alwaysEnsure = true;
    alwaysTangle = true;
    extraEmacsPackages = epkgs: [
      # Required packages...
      <<emacs-exwm-package>>
      <<emacs-evil-package>>
      <<emacs-general-package>>
      <<emacs-which-key-package>>

      # Optional packages.
      <<emacs-org-package>>
      <<emacs-org-roam-package>>
      <<emacs-org-drill-package>>
      <<emacs-pomodoro-package>>
      <<emacs-writegood-package>>
      <<emacs-hugo-package>>
      <<emacs-reveal-package>>
      <<emacs-pass-package>>
      <<emacs-mu4e-package>>
      <<emacs-dired-package>>
      <<emacs-icons-package>>
      <<emacs-emoji-package>>
      <<emacs-eshell-package>>
      <<emacs-vterm-package>>
      <<emacs-magit-package>>
      <<emacs-elfeed-package>>
      <<emacs-nix-mode-package>>
      <<emacs-projectile-package>>
      <<emacs-lsp-package>>
      <<emacs-company-package>>
      <<emacs-golang-package>>
      <<emacs-python-package>>
      <<emacs-plantuml-package>>
      <<emacs-swiper-package>>
      <<emacs-doom-themes-package>>
      <<emacs-doom-modeline-package>>
    ];
  };

in {
  home.packages = [
    <<emacs-exwm-extras>>
    <<emacs-hugo-extras>>
    <<emacs-pass-extras>>
    <<emacs-mu4e-extras>>
    <<emacs-aspell-extras>>
    <<emacs-plantuml-extras>>
    <<emacs-nix-mode-extras>>
  ];

  programs.emacs = {
    enable = true;
    package = myEmacs;
  };

  <<emacs-exwm-config>>
  <<emacs-exwm-xinitrc>>
  <<emacs-mu4e-config>>
}

When Emacs is started, it normally tries to load a Lisp program from an ititialization file, or init file. This file, if it exists, specifies how to initialize and configure Emacs.

;; <<file-warning>>

;; Required inputs.
<<emacs-exwm-elisp>>
<<emacs-evil-elisp>>
<<emacs-general-elisp>>
<<emacs-which-key-elisp>>

;; Optional inputs.
<<emacs-org-elisp>>
<<emacs-org-roam-elisp>>
<<emacs-org-drill-elisp>>
<<emacs-org-agenda-elisp>>
<<emacs-pomodoro-elisp>>
<<emacs-writegood-elisp>>
<<emacs-aspell-elisp>>
<<emacs-eww-elisp>>
<<emacs-hugo-elisp>>
<<emacs-reveal-elisp>>
<<emacs-pass-elisp>>
<<emacs-mu4e-elisp>>
<<emacs-dired-elisp>>
<<emacs-icons-elisp>>
<<emacs-emoji-elisp>>
<<emacs-eshell-elisp>>
<<emacs-vterm-elisp>>
<<emacs-magit-elisp>>
<<emacs-fonts-elisp>>
<<emacs-elfeed-elisp>>
<<emacs-projectile-elisp>>
<<emacs-lsp-elisp>>
<<emacs-company-elisp>>
<<emacs-golang-elisp>>
<<emacs-python-elisp>>
<<emacs-plantuml-elisp>>

;; User interface.
<<emacs-swiper-elisp>>
<<emacs-doom-themes-elisp>>
<<emacs-doom-modeline-elisp>>

It's somtimes desirable to have customization that takes effect during Emacs startup earlier than the normal init file. Place these configurations in ~/.emacs.d/early-init.el. Most customizations should be put in the normal init file ~/.emacs.d/init.el.

;; <<file-warning>>
<<emacs-disable-ui-elisp>>
<<emacs-native-comp-elisp>>
<<emacs-backup-files-elisp>>
<<emacs-shell-commands-elisp>>

Disable UI

Emacs² has been around since the 1980s, and it's painfully obvious when you're greeted with the default user interface. Disable some unwanted features to clean it up, and bring the appearance to something closer to a modern editor.

;; Disable unwanted UI elements.
(tooltip-mode -1)
(menu-bar-mode -1)
(tool-bar-mode -1)
(scroll-bar-mode -1)

;; Fix the scrolling behaviour.
(setq scroll-conservatively 101)

;; Fix mouse-wheel scrolling behaviour.
(setq mouse-wheel-follow-mouse t
      mouse-wheel-progressive-speed t
      mouse-wheel-scroll-amount '(3 ((shift) . 3)))

Native Comp

pkgs.emacsGcc;

Native Comp, also known as GccEmacs, refers to the --with-native-compilation configuration option when building GNU/Emacs². It adds support for compiling Emacs Lisp to native code using libgccjit. All of the Emacs Lisp packages shipped with Emacs are native-compiled, providing a noticable performance iomprovement out-of-the-box.

;; Silence warnings from packages that don't support `native-comp'.
(setq comp-async-report-warnings-errors nil         ;; Emacs 27.2 ...
      native-comp-async-report-warnings-errors nil) ;; Emacs 28+  ...

Backup Files

Emacs² makes a backup for a file only the first time the file is saved from a buffer. No matter how many times the file is subsequently written to, the backup remains unchanged. For files managed by a version control system, backup files are redundant since the previous versions are already stored.

;; Disable unwanted features.
(setq make-backup-files nil
      create-lockfiles nil)

Shell Commands

Define some methods for interaction between GNU/Emacs², and the systems underyling shell:

Method to run an external process, launching any application on a new process without interferring with Emacs²
Method to apply commands to the curren call process, effecting the running instance of Emacs²

;; Define a method to run an external process.
(defun dotfiles/run (cmd)
  "Run an external process."
  (interactive (list (read-shell-command "λ ")))
  (start-process-shell-command cmd nil cmd))

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

Nix Mode

pkgs.nixfmt

Nix-mode²⁷ is an Emacs² major mode for editing Nix⁵ expressions. This provides basic handling of .nix files. Syntax highlighting and indentation support using SMIE are provided.

epkgs.nix-mode

Evil Mode

Evil¹² is an extensible VI layer for GNU/Emacs². It emulates the main features of Vim¹⁹, turning GNU/Emacs² into a modal editor.

epkgs.evil
epkgs.evil-collection
epkgs.evil-surround
epkgs.evil-nerd-commenter

The next time Emacs² is started, it will come up in normal state, denoted by <N> in the modeline. This is where the main vi bindings are defined. Like Emacs² in general, Evil¹² is extensible in Emacs Lisp¹⁸.

;; Enable the Extensible VI Layer for Emacs.
(setq evil-want-integration t   ;; Required for `evil-collection.'
      evil-want-keybinding nil) ;; Same as above.
(evil-mode +1)

;; Configure `evil-collection'.
(evil-collection-init)

;; Configure `evil-surround'.
(global-evil-surround-mode +1)

;; Configure `evil-nerd-commenter'.
(global-set-key (kbd "M-;") 'evilnc-comment-or-uncomment-lines)

EXWM

epkgs.exwm

EXWM (Emacs X Window Manager)¹¹ is a full-featured tiling X window manager for GNU/Emacs² built on-top of XELB. It features:

Fully keyboard-driven operations
Hybrid layout modes (tiling & stacking)
Dynamic workspace support
ICCM/EWMH compliance

pkgs.arandr
pkgs.autorandr

I wanted to leave (exwm-enable) out of my Emacs configuration (which does no harm anyways). This can be called when using the daemon to start EXWM¹¹.

xsession = {
  enable = true;
  windowManager.command = ''
    ${myEmacs}/bin/emacs --daemon -f exwm-enable
    ${myEmacs}/bin/emacsclient -c
  '';
};

EXWM¹¹ cannot make an X window manager by itself, this is by design; You must tell X to do it. Override the ~/.xinitrc file to start the xsession.

home.file.".xinitrc" = {
  text = ''
    exec ./.xsession
  '';
};

;; Configure `exwm'.
(setq exwm-worspace-show-all-buffers t)
(setq exwm-input-prefix-keys
  '(?\M-x
  ?\C-g
  ?\C-\ ))
(setq exwm-input-global-keys
  `(([?\s-r] . exwm-reset)
    ,@(mapcar (lambda (i)
                `(,(kbd (format "s-%d" i)) .
                (lambda ()
                (interactive)
                (exwm-workspace-switch-create ,i))))
                (number-sequence 1 9))))

;; Configure `exwm-randr'.
(require 'exwm-randr)
(exwm-randr-enable)

;; Configure custom hooks.
(setq display-time-and-date t)
(add-hook 'exwm-init-hook
  (lambda ()
    (display-battery-mode +1) ;; Display battery info (if available).
    (display-time-mode +1)))  ;; Display the time in the modeline.

;; Setup buffer display names.
(add-hook 'exwm-update-class-hook
  (lambda ()
    (exwm-workspace-rename-buffer exwm-class-name))) ;; Use the system class name.

;; Configure monitor hot-swapping.
(add-hook 'exwm-randr-screen-change-hook
  (lambda ()
    (dotfiles/run-in-background "autorandr --change --force"))) ;; Swap to the next screen config.

General

epkgs.general

General²⁸ provides a more convenient method for binding keys in Emacs², providing a unified interface for key definitions. Its primary purpose is to build on existing functionality to make key definitions more clear and concise.

;; Use <SPC> as a leader key via `general.el'.
(general-create-definer dotfiles/leader
  :states '(normal motion)
  :keymaps 'override
  :prefix "SPC"
  :global-prefix "C-SPC")

;; Find files with <SPC> <period> ...
;; Switch buffers with <SPC> <comma> ...
(dotfiles/leader
  "." '(find-file :which-key "File")
  "," '(switch-to-buffer :which-key "Buffer")
  "c" '(kill-buffer-and-window :which-key "Close"))

;; Add keybindings for executing shell commands.
(dotfiles/leader
  "r" '(:ignore t :which-key "Run")
  "rr" '(dotfiles/run :which-key "Run")
  "ra" '(async-shell-command :which-key "Async"))

;; Add keybindings for quitting Emacs.
(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"))

;; Add keybindings for toggles / tweaks.
(dotfiles/leader
  "t" '(:ignore t :which-key "Toggle / Tweak"))

;; Add keybindings for working with frames to replace
;; the C-x <num> <num> method of bindings, which is awful.
(dotfiles/leader
  "w" '(:ignore t :which-key "Windows")
  "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 "Below")
  "wsl" '(split-window-right :which-key "Right"))

Which Key

Which-key²⁹ is a minor mode for Emacs² that displays the key bindings following your currently entered incomplete command (prefix) in a popup or mini-buffer.

epkgs.which-key

;; Configure `which-key' to see keyboard bindings in the
;; mini-buffer and when using M-x.
(setq which-key-idle-delay 0.0)
(which-key-mode +1)

EWW

The Emacs Web Wowser³⁰ is a Web browser written in Emacs Lisp¹⁸ based on the shr.el library. It's my primary browser when it comes to text-based browsing.

Use eww as the default browser
Don't use any special fonts or colours

;; Set `eww' as the default browser.
(setq browse-url-browser-function 'eww-browse-url)

;; Configure the `shr' rendering engine.
(setq shr-use-fonts nil
      shr-use-colors nil)

Dired

epkgs.dired-single

Dired³¹ shows a directory listing inside of an Emacs² buffer that can be used to perform various file operations on files and subdirectories. THe operations you can perform are numerous, from creating subdirectories, byte-compiling files, searching, and editing files. Dired-Extra³² provides extra functionality for Dired³¹.

;; Include `dired-x' for the `jump' method.
(require 'dired-x)

;; Configure `dired-single' to support `evil' keys.
(evil-collection-define-key 'normal 'dired-mode-map
  "h" 'dired-single-up-directory
  "l" 'dired-single-buffer)

;; Setup `all-the-icons' and the `dired' extension.

;; Configure keybindings for `dired'.
(dotfiles/leader
  "d" '(dired-jump :which-key "Dired"))

Icons

epkgs.all-the-icons
epkgs.all-the-icons-dired

All The Icons³³ is a utility package to collect various Icon Fonts and prioritize them within GNU/Emacs².

;; Setup `all-the-icons-dired'.
(add-hook 'dired-mode-hook 'all-the-icons-dired-mode)

;; Display default font ligatures.
(global-prettify-symbols-mode +1)

Emojis

epkgs.emojify

Emojify³⁴ is an Emacs² extension to display Emojis. It can display GitHub style Emojis like 😄 or plain ascii ones such as :). It tries to be as efficient as possible, while also providing flexibility.

;; Setup `emojify'.
(add-hook 'after-init-hook 'global-emojify-mode)

EShell

epkgs.eshell-prompt-extras

EShell ³⁵ is a shell-like command interpreter for GNU/Emacs² implemented in Emacs Lisp¹⁸. It invokes no external processes except for those requested by the user. It's intended to be an alternative for IELM, and a full REPL envionment for Emacs².

;; Configure `eshell'.
(setq eshell-highlight-prompt nil
      eshell-prefer-lisp-functions nil)

;; Configure the lambda prompt.
(autoload 'epe-theme-lambda "eshell-prompt-extras")
(setq eshell-prompt-function 'epe-theme-lambda)

;; Configure keybindings for `eshell'.
(dotfiles/leader
  "e" '(eshell :which-key "EShell"))

VTerm

Emacs Libvterm (VTerm)³⁶ is a fully-fledged terminal emulator inside GNU/Emacs² based on Libvterm³⁷, a blazing fast C library used in Neovim¹⁹. As a result of using compiled code (instead of Emacs Lisp¹⁸), VTerm³⁶ is capable, fast, and it can seamlessly handle large outputs.

epkgs.vterm

;; Add keybindings for interacting with the shell(s).
(dotfiles/leader
  "v" '(vterm :which-key "VTerm"))

Magit

Magit³⁸ is an interface to the Git¹⁷ version control system, implemented as a GNU/Emacs² package written in Elisp¹⁸. It fills the glaring gap between the Git¹⁷ command line interface and various GUIs, letting you perform trivial as well as elaborate version control tasks within a few mnemonic key presses.

epkgs.magit

Key	Description
gg	Check the status of a repository
gc	Clone a remote repository
gf	Fetch the contents of the repository
gp	Pull the remotes of the repository

;; Add keybindings for working with `magit'.
(dotfiles/leader
  "g" '(:ignore t :which-key "Git")
  "gg" '(magit-status :which-key "Status")
  "gc" '(magit-clone :which-key "Clone")
  "gf" '(magit-fetch :which-key "Fetch")
  "gp" '(magit-pull :which-key "Pull"))

Fonts

;; Configure the font when running as `emacs-server'.
(custom-set-faces
  '(default ((t (:inherit nil :height 96 :family "Iosevka")))))

;; Set all three of Emacs' font faces.
;; NOTE: This only works without `emacs-server'.
;; (set-face-attribute 'default nil :font "Iosevka" :height 96)
;; (set-face-attribute 'fixed-pitch nil :font "Iosevka" :height 96)
;; (set-face-attribute 'variable-pitch nil :font "Iosevka" :height 96)

Elfeed

epkgs.elfeed

Elfeed³⁹ is an extensible web feed reader for GNU/Emacs², support both Atom and RSS. It requires Emacs 24.3+ and is available for download from the standard repositories.

Key	Command
l	Open
u	Update

;; Add custom feeds for `elfeed' to fetch.
(setq elfeed-feeds (quote
                     (("https://hexdsl.co.uk/rss.xml")
                      ("https://lukesmith.xyz/rss.xml")
                      ("https://friendo.monster/rss.xml")
                      ("https://chrishayward.xyz/index.xml")
                      ("https://protesilaos.com/codelog.xml"))))

;; Add custom keybindings for `elfeed'.
(dotfiles/leader
  "l" '(:ignore t :which-key "Elfeed")
  "ll" '(elfeed :which-key "Open")
  "lu" '(elfeed-update :which-key "Update"))

Org Mode

epkgs.org

Org-mode⁴⁰ is a document editing and organizing mode, designed for notes, planning, and authoring within the free software text editor GNU/Emacs². The name is used to encompass plain text files (such as this one) that include simple marks to indicate levels of a hierarchy, and an editor with functions that can read the markup and manipulate the hierarchy elements.

;; Configure `org-mode' source blocks.
(setq org-src-fontify-natively t      ;; Make source blocks prettier.
      org-src-tab-acts-natively t     ;; Use TAB indents within source blocks.
      org-src-preserve-indentation t) ;; Stop `org-mode' from formatting blocks.

;; Add an `org-mode-hook'.
(add-hook 'org-mode-hook
  (lambda ()
    (org-indent-mode)
    (visual-line-mode)))

;; Remove the `Validate XHTML 1.0' message from HTML export.
(setq org-export-html-validation-link nil
      org-html-validation-link nil)

;; TODO: Configure default structure templates.
;; (require 'org-tempo)

;; Apply custom keybindings.
(dotfiles/leader
  "o" '(:ignore t :which-key "Org")
  "oe" '(org-export-dispatch :which-key "Export")
  "ot" '(org-babel-tangle :which-key "Tangle")
  "of" '(:ignore t :which-key "Footnotes")
  "ofn" '(org-footnote-normalize :which-key "Normalize"))

Org Roam

epkgs.org-roam
epkgs.org-roam-server

Org Roam⁴¹ is a plain-text knowledge management system. It borrows principles from the Zettelkasten method⁴², providing a solution for non-hierarchical note-taking. It should also work as a plug-and-play solution for anyone already using Org Mode⁴⁰ for their personal wiki (me). Org Roam Server⁴³ is a Web application to visualize the Org Roam⁴¹ database. Although it should automatically reload if there's a change in the database, it can be done so manually by clicking the reload button on the Web interface.

;; Setup `org-roam' hooks.
(add-hook 'after-init-hook
  (lambda ()
    (org-roam-mode)
    (org-roam-server-mode)))

;; Configure `org-roam'.
(setq org-roam-encrypt-files t
      org-roam-directory (expand-file-name "/etc/dotfiles")
      org-roam-capture-templates '()
      org-roam-dailies-capture-templates '())

;; Encrypt files with the public key.
(setq epa-file-select-keys 2
      epa-file-encrypt-to "37AB1CB72B741E478CA026D43025DCBD46F81C0F"
      epa-cache-passphrase-for-symmetric-encryption t)

;; Define a new `title-to-slug' function to override the default `org-roam-title-to-slug' function.
;; This is done to change the replacement character from "_" to "-".
(require 'cl-lib)
(defun dotfiles/title-to-slug (title)
  "Convert TITLE to a filename-suitable slug."
  (cl-flet* ((nonspacing-mark-p (char)
                                (eq 'Mn (get-char-code-property char 'general-category)))
             (strip-nonspacing-marks (s)
                                     (apply #'string (seq-remove #'nonspacing-mark-p
                                                                 (ucs-normalize-NFD-string s))))
             (cl-replace (title pair)
                         (replace-regexp-in-string (car pair) (cdr pair) title)))
    (let* ((pairs `(("[^[:alnum:][:digit:]]" . "-") ;; Convert anything not alphanumeric.
                    ("--*" . "-")                   ;; Remove sequential dashes.
                    ("^-" . "")                     ;; Remove starting dashes.
                    ("-$" . "")))                   ;; Remove ending dashes.
           (slug (-reduce-from #'cl-replace (strip-nonspacing-marks title) pairs)))
      (downcase slug))))
(setq org-roam-title-to-slug-function #'dotfiles/title-to-slug)

;; Configure capture templates.
;; Standard document.
(add-to-list 'org-roam-capture-templates
  '("d" "Default" entry (function org-roam-capture--get-point)
        "%?"
        :file-name "docs/${slug}"
        :unnarrowed t
        :head 
"
,#+TITLE: ${title}
,#+AUTHOR: Christopher James Hayward
,#+EMAIL: chris@chrishayward.xyz
"))

;; Course document.
(add-to-list 'org-roam-capture-templates
  '("c" "Course" plain (function org-roam-capture--get-point)
        "%?"
        :file-name "docs/courses/${slug}"
        :unnarrowed t
        :head
"
,#+TITLE: ${title}
,#+SUBTITLE:
,#+AUTHOR: Christopher James Hayward
,#+EMAIL: chris@chrishayward.xyz

,#+OPTIONS: num:nil toc:nil todo:nil tasks:nil tags:nil
,#+OPTIONS: skip:nil author:nil email:nil creator:nil timestamp:nil
"))

;; Daily notes.
(add-to-list '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

,#+OPTIONS: num:nil toc:nil todo:nil tasks:nil tags:nil
,#+OPTIONS: skip:nil author:nil email:nil creator:nil timestamp:nil
"))

;; Apply custom keybindings.
(dotfiles/leader
  "or"  '(:ignore t :which-key "Roam")
  "ori" '(org-roam-insert :which-key "Insert")
  "orf" '(org-roam-find-file :which-key "Find")
  "orc" '(org-roam-capture :which-key "Capture")
  "orb" '(org-roam-buffer-toggle-display :which-key "Buffer"))

;; Apply custom keybindings for dailies.
(dotfiles/leader
  "ord" '(:ignore t :which-key "Dailies")
  "ordd" '(org-roam-dailies-find-date :which-key "Date")
  "ordt" '(org-roam-dailies-find-today :which-key "Today")
  "ordm" '(org-roam-dailies-find-tomorrow :which-key "Tomorrow")
  "ordy" '(org-roam-dailies-find-yesterday :which-key "Yesterday"))

Org Drill

epkgs.org-drill

Org Drill⁴⁴ is an extension for Org Mode⁴⁰ that uses a spaced repition algorithm to conduct interactive Drill Sessions using Org files as sources of facts to be memorized.

;; Configure keybindings for `org-drill'.
(dotfiles/leader
  "od" '(:ignore t :which-key "Drill")
  "odd" '(org-drill :which-key "Drill")
  "odc" '(org-drill-cram :which-key "Cram")
  "odr" '(org-drill-resume :which-key "Resume"))

Org Agenda

The way Org Mode⁴⁰ works, TODO items, time-stamped items, and tagged headlines can be scattered throughout a file, or even a number of files. To get an overview of open action items, or of events that are important for a particular date, this information must be collected, sorted, and displayed in an organized way.

;; Configure `org-agenda' to use the project files.
(setq org-agenda-files '("/etc/dotfiles/"
                         "/etc/dotfiles/docs/"
                         "/etc/dotfiles/docs/courses/"
                         "/etc/dotfiles/docs/daily/"
                         "/etc/dotfiles/docs/notes/"
                         "/etc/dotfiles/docs/posts/"
                         "/etc/dotfiles/docs/slides/"))

;; Include files encrypted with `gpg'.
(require 'org)
(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)))

;; Open an agenda buffer with SPC o a.
(dotfiles/leader
  "oa" '(org-agenda :which-key "Agenda"))

Org Pomodoro

epkgs.org-pomodoro

Org Pomodoro⁴⁵ adds basic support for the Pomodoro Technique⁴⁶ in GNU/Emacs². It can be started for the task at point, or the last task time was clocked for. Each session starts a timer of 25 minutes, finishing with a break of 5 minutes. After 4 sessions, ther will be a break of 20 minutes. All values are customizable.

;; Configure `org-pomodor' with the overtime workflow.
(setq org-pomodoro-manual-break t
      org-pomodoro-keep-killed-time t)

;; Configure keybindings.
(dotfiles/leader
  "op" '(org-pomodoro :which-key "Pomodoro"))

Writegood Mode

epkgs.writegood-mode

Writegood Mode⁴⁷ is an Emacs² minor mode to aid in finding common writing problems. It highlights the text based on the following criteria:

Weasel Words
Passive Voice
Duplicate Words

;; Configure `writegood-mode'.
(dotfiles/leader
  "tg" '(writegood-mode :which-key "Grammar"))

Aspell

pkgs.aspell
pkgs.aspellDicts.en
pkgs.aspellDicts.en-science
pkgs.aspellDicts.en-computers

GNU Aspell⁴⁸ is a Free and Open Source spell checker designed to replace ISpell. It can be used as a library, or an independent spell checker. Its main feature is that it does a superior job of suggesting possible replacements for mis-spelled words than any other spell checker for the English language.

;; Use `aspell' as a drop-in replacement for `ispell'.
(setq ispell-program-name "aspell"
      ispell-eextra-args '("--sug-mode=fast"))

;; Configure the built-in `flyspell-mode'.
(dotfiles/leader
  "ts" '(flyspell-mode :which-key "Spelling"))

Hugo

pkgs.hugo

Hugo⁴⁹ is one of the most popular open-source static site generators.

epkgs.ox-hugo

Ox-Hugo⁵⁰ is an Org-Mode⁴⁰ exporter for Hugo⁴⁹ compabile markdown. I post nonsense on my Personal Blog⁵¹, and share my notes on various textbooks, articles, and software Here⁵².

;; Configure `ox-hugo' as an `org-mode-export' backend.
(require 'ox-hugo)

;; Capture templates.
;; Personal blog post.
(add-to-list 'org-roam-capture-templates
             '("p" "Post" 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>

,#+OPTIONS: num:nil todo:nil tasks:nil

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

,#+HUGO_BASE_DIR: ../
,#+HUGO_AUTO_SET_LASTMOD: t
,#+HUGO_SECTION: posts
,#+HUGO_DRAFT: true
"))

;; Shared notes.
(add-to-list 'org-roam-capture-templates
             '("n" "Notes" plain (function org-roam-capture--get-point)
                "%?"
                :file-name "docs/notes/${slug}"
                :unnarrowed t
                :head
"
,#+TITLE: ${title}
,#+AUTHOR: Christopher James Hayward

,#+OPTIONS: num:nil todo:nil tasks:nil
,#+EXPORT_FILE_NAME: ${slug}
,#+ROAM_KEY: https://chrishayward.xyz/notes/${slug}/

,#+HUGO_BASE_DIR: ../
,#+HUGO_AUTO_SET_LASTMOD: t
,#+HUGO_SECTION: notes
,#+HUGO_DRAFT: true
"))

Reveal

epkgs.ox-reveal

Reveal.js⁵³ is an open source HTML presentation framework. It enables anyone with a web browser to create fully-featured and beautiful presentations for free. Presentations with Reveal.js⁵³ are built on open web technologies. That means anything you can do on the web, you can do in your presentation. Ox Reveal⁵⁴ is an Org Mode⁴⁰ export backend.

;; Configure `ox-reveal' as an `org-mode-export' backend.
(require 'ox-reveal)

;; Don't rely on any local software.
(setq org-reveal-root "https://cdn.jsdelivr.net/npm/reveal.js")

;; Create a capture template.
(add-to-list 'org-roam-capture-templates
             '("s" "Slides" plain (function org-roam-capture--get-point)
               "%?"
               :file-name "docs/slides/${slug}"
               :unnarrowed t
               :head
"
,#+TITLE: ${title}
,#+AUTHOR: Christopher James Hayward
,#+EMAIL: chris@chrishayward.xyz

,#+REVEAL_ROOT: https://cdn.jsdelivr.net/npm/reveal.js
,#+REVEAL_THEME: serif

,#+EXPORT_FILE_NAME: ${slug}

,#+OPTIONS: reveal_title_slide:nil
,#+OPTIONS: num:nil toc:nil todo:nil tasks:nil tags:nil
,#+OPTIONS: skip:nil author:nil email:nil creator:nil timestamp:nil
"))

Passwords

pkgs.pass

With Pass⁵⁵, each password lives inside of an encrypted gpg file, whose name is the title of the website or resource that requires the password. These encrypted files may be organized into meaningful folder hierarchies, compies from computer to computer, and in general, manipulated using standard command line tools.

epkgs.password-store

Configure keybindings for passwords behind SPC p:

Key	Description
p	Copy a password
r	Rename a password
g	Generate a password

;; Set the path to the password store.
(setq password-store-dir (expand-file-name "~/.password-store"))

;; Apply custom keybindings.
(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"))

MU4E

pkgs.mu
pkgs.isync

epkgs.mu4e-alert

home.file.".mbsyncrc" = {
  text = ''
    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
    Far :xyz-remote:
    Near :xyz-local:
    Patterns * !Archives
    Create Both
    Expunge Both
    SyncState *
  '';
};

mbsync -a
mu init --maildir="~/.cache/mail" --my-address="chris@chrishayward.xyz"
mu index

;; Add the `mu4e' shipped with `mu' to the load path.
(add-to-list 'load-path "/etc/profiles/per-user/chris/share/emacs/site-lisp/mu4e/")
(require 'mu4e)

;; Confiugure `mu4e'.
(setq mu4e-maildir "~/.cache/mail"
      mu4e-update-interval (* 5 60)
      mu4e-get-mail-command "mbsync -a"
      mu4e-compose-format-flowed t
      mu4e-change-filenames-when-moving t
      mu4e-compose-signature (concat "Chris Hayward\n"
                                     "chris@chrishayward.xyz"))

;; Sign all outbound email with GPG.
(add-hook 'message-send-hook 'mml-secure-message-sign-pgpmime)
(setq message-send-mail-function 'smtpmail-send-it
      mml-secure-openpgp-signers '("37AB1CB72B741E478CA026D43025DCBD46F81C0F"))

;; Setup `mu4e' accounts.
(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)))))

;; Setup `mu4e-alert'.
(setq mu4e-alert-set-default-style 'libnotify)
(mu4e-alert-enable-notifications)
(mu4e-alert-enable-mode-line-display)

;; Open the `mu4e' dashboard.
(dotfiles/leader
  "m" '(mu4e :which-key "Mail"))

Projectile

epkgs.projectile

Projectile⁵⁶ is a project interaction library for GNU/Emacs². Its goal is to provide a nice set of features operating on a project level, without introducing external dependencies.

;; Configure the `projectile-project-search-path'.
(setq projectile-project-search-path '("~/.local/source"))
(projectile-mode +1)

LSP Mode

epkgs.lsp-mode
epkgs.lsp-ui

The Language Server Protocol (LSP)⁵⁷ defines the protocol used between an Editor or IDE, and a language server that provides features like:

Auto Complete
Go To Defintion
Find All References

;; Configure `lsp-mode'.
(setq lsp-idle-delay 0.5
      lsp-prefer-flymake t)

;; Configure `lsp-ui'.
(setq lsp-ui-doc-position 'at-point
      lsp-ui-doc-delay 0.5)

Company Mode

epkgs.company

Company⁵⁸ is a text completion framework for GNU/Emacs². The name stands for Complete Anything. It uses pluggable back-ends and front-ends to retieve and display completion candidates.

;; Configure `company-mode'.
(setq company-backend 'company-capf
      lsp-completion-provider :capf)

;; Enable it globally.
(global-company-mode +1)

Go Mode

epkgs.go-mode

Go Mode⁵⁹ is a major mode for editing Golang²² source code in GNU/Emacs².

;; Configure `go-mode' to work with `lsp-mode'.
(defun dotfiles/go-hook ()
  (add-hook 'before-save-hook #'lsp-format-buffer t t)
  (add-hook 'before-save-hook #'lsp-organize-imports t t))

;; Configure a custom `before-save-hook'.
(add-hook 'go-mode-hook #'dotfiles/go-hook)

Python Mode

epkgs.pretty-mode

The built in Python Mode⁶⁰ has a nice feature set for working with Python²⁶ code in GNU/Emacs². It is complimented with the addition of an LSP⁵⁷ server. These tools are included in the Development Shell²¹ for Python²⁶.

;; Configure `pretty-mode' to work with `python-mode'.
(add-hook 'python-mode-hook
  (lambda ()
    (turn-on-pretty-mode)))

PlantUML

pkgs.plantuml

PlantUML⁶¹ is an open-source tool allowing users to create diagrams from a plain-text language. Besides various UML diagrams, PlantUML⁶¹ has support for various other software developmented related formats, as well as visualizations of JSON and YAML files.

epkgs.plantuml-mode

PlantUML Mode⁶² is a major mode for editing PlantUML⁶¹ sources in GNU/Emacs².

;; Configure `plantuml-mode'.
(setq plantuml-default-exec-mode 'executable)

Swiper

epkgs.ivy
epkgs.counsel
epkgs.ivy-rich
epkgs.ivy-posframe
epkgs.ivy-prescient

Ivy (Swiper)⁶³ is a generic completion mechanism for GNU/Emacs². While operating similarily to other completion schemes like icomplete-mode, it aims to be more efficient, smaller, simpler, and smoother to use, while remaining highly customizable.

;; Configure `ivy'.
(setq counsel-linux-app-format-function
  #'counsel-linux-app-format-function-name-only)
(ivy-mode +1)
(counsel-mode +1)

;; Configure `ivy-rich'.
(ivy-rich-mode +1)

;; Configure `ivy-posframe'.
(setq ivy-posframe-parameters '((parent-frame nil))
      ivy-posframe-display-functions-alist '((t . ivy-posframe-display)))
(ivy-posframe-mode +1)

;; Configure `ivy-prescient'.
(setq ivy-prescient-enable-filtering nil)
(ivy-prescient-mode +1)

Doom Themes

epkgs.doom-themes

Doom Themes⁶⁴ is a theme megapack for GNU/Emacs², inspired by community favourites.

;; Include modern themes from `doom-themes'.
(setq doom-themes-enable-bold t
      doom-themes-enable-italic t)

;; Load the `doom-moonlight' theme.
(load-theme 'doom-moonlight t)
(doom-modeline-mode +1)

Doom Modeline

epkgs.doom-modeline

Doom Modeline⁶⁵ is a fancy and fast modeline inspired by minimalism design. It's integrated into Centaur Emacs, Doom Emacs, and Spacemacs.

;; Add the `doom-modeline' after initialization.
(add-hook 'after-init-hook 'doom-modeline-mode)
(setq doom-modeline-height 16
      doom-modeline-icon t)