dot-emacs

config.org (35204B)

---

 #+title: Fast (il)literate emacs config built on ~elpaca~
 #+author: Ethan Long
 #+startup: overview
 
 * Overview of this config
 This is my (subjectively) simplistic literate config for Emacs.
 I aim to keep this minimal, and to use as few large dependencies as possible.
 
 I previously had a very complicated handwoven Emacs config with a beautiful ~org-mode~, but I have grown tired of the number of packages that is used, and I don't really use ~org~ that heavily.
 
 The reader may disagree on the minimalism of this configuration, which is rather subjective.
 If one wanted to be as minimal as possible, vanilla Emacs without any configuration technically functions, but that's not in the spirit of Emacs in my opinion.
 
 As an added bonus of being more minimal, this config should also be more portable across systems (I hope).
 
 This config has the following explicit package dependencies:
 |--------------+--------------------------------------------------------------------|
 | *Package*      | *Use*                                                                |
 |--------------+--------------------------------------------------------------------|
 | ~org~          | Karthinks build, required for LaTeX previews. Declared in ~init.el~. |
 |--------------+--------------------------------------------------------------------|
 | ~meow~         | For modal keybinds.                                                |
 |--------------+--------------------------------------------------------------------|
 | ~ligature~     | For font ligatures on regular Emacs builds.                        |
 |--------------+--------------------------------------------------------------------|
 | ~batppuccin~   | For the Catppuccin theme.                                          |
 |--------------+--------------------------------------------------------------------|
 | ~ultra-scroll~ | For better smooth scrolling when navigating with a mouse.          |
 |--------------+--------------------------------------------------------------------|
 | ~async~        | For the easy ability to start async processes.                     |
 |              | Used for async treesitter grammar building and installation.       |
 |--------------+--------------------------------------------------------------------|
 | ~org-modern~   | For a nicer looking Org mode in only 900 lines of elisp.           |
 |--------------+--------------------------------------------------------------------|
 | ~vterm~        | For a usable terminal emulator within Emacs.                       |
 |--------------+--------------------------------------------------------------------|
 | ~powershell~   | A small powershell mode for working with psh files over TRAMP.     |
 |--------------+--------------------------------------------------------------------|
 There are a total of 9 packages installed by these dependencies.
 * Keybinds
 ** Meow (modal editing)
 This package is very important to me, I have been poisoned by ~vi~ and rely on the modal editing model to function properly.
 If you're interested in my config function, see ~meow-setup~.
 I use mostly the recommended QWERTY binds given by the Meow devs:
 :meow-setup:
 #+begin_src emacs-lisp
   (defun ethandl/meow-setup ()
     (require 'meow)
     (setq meow-cheatsheet-layout meow-cheatsheet-layout-qwerty)
     (setq meow-keypad-leader-dispatch "C-x")
     (meow-motion-overwrite-define-key
      '("j" . meow-next)
      '("k" . meow-prev)
      '("<escape>" . ignore))
     (meow-leader-define-key
      ;; SPC j/k will run the original command in MOTION state.
      '("j" . "H-j")
      '("k" . "H-k")
      ;; Use SPC (0-9) for digit arguments.
      '("1" . meow-digit-argument)
      '("2" . meow-digit-argument)
      '("3" . meow-digit-argument)
      '("4" . meow-digit-argument)
      '("5" . meow-digit-argument)
      '("6" . meow-digit-argument)
      '("7" . meow-digit-argument)
      '("8" . meow-digit-argument)
      '("9" . meow-digit-argument)
      '("0" . meow-digit-argument)
      '("/" . meow-keypad-describe-key)
      '("?" . meow-cheatsheet))
     (meow-normal-define-key
      '("0" . meow-expand-0)
      '("9" . meow-expand-9)
      '("8" . meow-expand-8)
      '("7" . meow-expand-7)
      '("6" . meow-expand-6)
      '("5" . meow-expand-5)
      '("4" . meow-expand-4)
      '("3" . meow-expand-3)
      '("2" . meow-expand-2)
      '("1" . meow-expand-1)
      '("-" . negative-argument)
      '(";" . meow-reverse)
      '("," . meow-inner-of-thing)
      '("." . meow-bounds-of-thing)
      '("[" . meow-beginning-of-thing)
      '("]" . meow-end-of-thing)
      '("a" . meow-append)
      '("A" . meow-open-below)
      '("b" . meow-back-word)
      '("B" . meow-back-symbol)
      '("c" . meow-change)
      '("d" . meow-delete)
      '("D" . meow-backward-delete)
      '("e" . meow-next-word)
      '("E" . meow-next-symbol)
      '("f" . meow-find)
      '("g" . meow-cancel-selection)
      '("G" . meow-grab)
      '("h" . meow-left)
      '("H" . meow-left-expand)
      '("i" . meow-insert)
      '("I" . meow-open-above)
      '("j" . meow-next)
      '("J" . meow-next-expand)
      '("k" . meow-prev)
      '("K" . meow-prev-expand)
      '("l" . meow-right)
      '("L" . meow-right-expand)
      '("m" . meow-join)
      '("n" . meow-search)
      '("o" . meow-block)
      '("O" . meow-to-block)
      '("p" . meow-yank)
      '("q" . meow-quit)
      '("Q" . meow-goto-line)
      '("r" . meow-replace)
      '("R" . meow-swap-grab)
      '("s" . meow-kill)
      '("t" . meow-till)
      '("u" . meow-undo)
      '("U" . meow-undo-in-selection)
      '("v" . meow-visit)
      '("w" . meow-mark-word)
      '("W" . meow-mark-symbol)
      '("x" . meow-line)
      '("X" . meow-goto-line)
      '("y" . meow-save)
      '("Y" . meow-sync-grab)
      '("z" . meow-pop-selection)
      '("'" . repeat)
      '(">" . indent-rigidly-right-to-tab-stop)
      '("<" . indent-rigidly-left-to-tab-stop)
      '("<escape>" . ignore)))
 #+end_src
 :end:
 
 #+begin_src emacs-lisp
   (elpaca 'meow
     (require 'meow)
     (ethandl/meow-setup)
     (meow-global-mode 1))
 #+end_src
 Unfortunately in daemon mode, meow's fonts are not initialized correctly. Here is a workaround (very similar to [[https://github.com/meow-edit/meow/issues/491][this one on GitHub]]):
 #+begin_src emacs-lisp
   (defun ethandl/fix-meow-faces ()
     "Fixes the faces for meow when emacs is running in daemon mode"
     (add-hook 'server-after-make-frame-hook #'meow--prepare-face))
 #+end_src
 Now because we don't have any guarantee of ~meow--prepare-face~ being available until after elpaca has completed the installation of everything, we have to add this to the ~elpaca-after-init-hook~:
 #+begin_src emacs-lisp
   (add-hook 'elpaca-after-init-hook #'ethandl/fix-meow-faces)
 #+end_src
 ** Window navigation
 When navigating windows, I find the binding ~C-x o~ to be rather slow when you have many buffers open in different arrangements, so I have adopted a set of bindings for the ~windmove-*~ functions that are left unused in the default configuration. These binds fit in quite nicely with the ~vim~-like keybinds that I use with ~meow~.
 
 This is mostly just the work of [[https://dev.to/rajasegar/vim-style-repeatable-key-bindings-for-navigating-windows-in-emacs-5c4l][Rajasegar Chandran]].
 #+begin_src emacs-lisp
   (global-set-key (kbd "C-x w h") 'windmove-left)
   (global-set-key (kbd "C-x w j") 'windmove-down)
   (global-set-key (kbd "C-x w k") 'windmove-up)
   (global-set-key (kbd "C-x w l") 'windmove-right)
   (repeat-mode t)
   (defvar-keymap windmove-repeat-map
     :repeat t
     "h" #'windmove-left
     "j" #'windmove-down
     "k" #'windmove-up
     "l" #'windmove-right)
 #+end_src
 ** Super as meta
 For all systems that aren't MacOS (and even some MacOS emacs builds), the default meta key is Alt. Because I frequently use keyboards where I have swapped my meta and alt keys, I would like to keep this consistant across operating systems.
 
 The following works on Linux, it is untested on Windows, and does nothing on my MacOS build.
 #+begin_src emacs-lisp
   (setq x-super-keysym 'meta)
 #+end_src
 * Emacs appearance
 I think that vanilla emacs has a charming appearance that I aim to keep for the most part, I won't be using any packages to change the modeline or anything special.
 ** Menu bar removal
 The menu bar is /fine/ on MacOS or in an NS environment (see platform specific tweaks), but elsewhere it tends to add clutter.
 Begone.
 #+begin_src emacs-lisp
   (menu-bar-mode 0)
 #+end_src
 ** Tool bar removal
 Even worse than the menu bar: the tool bar.
 Simply a waste of space in my opinion.
 #+begin_src emacs-lisp
   (tool-bar-mode 0)
 #+end_src
 ** Scroll bar removal
 The scroll bar is unnecessary if you are navigating via keyboard, and takes up space.
 #+begin_src emacs-lisp
   (scroll-bar-mode 0)
 #+end_src
 ** Line numbers
 When working with modal editing and in general programming, it is useful to be able to see distances to previous or subsequent lines in the buffer.
 Emacs comes with a nice built-in mode that displays line numbers on the left-hand side of a buffer, much like in ~vi~.
 #+begin_src emacs-lisp
   (add-hook 'prog-mode-hook #'display-line-numbers-mode)
 #+end_src
 Optionally, you can also set the line numbers to be relative to the cursor position.
 #+begin_src emacs-lisp :tangle no
   (setq display-line-numbers-type 'relative)
 #+end_src
 
 By default, the size of the line-numbers column is only big enough for small files and will grow and shrink to accomodate the line numbers as you scroll, leading to the jarring movement of code horizontally as a buffer is scrolled.
 This can be fixed:
 #+begin_src emacs-lisp
   (setq display-line-numbers-width-start 0)
   (setq display-line-numbers-grow-only t)
 #+end_src
 ** Modeline customisation
 *** Disable line number
 The current line number is irrelevant to have on the modeline, given that we display the current line number in the buffer.
 #+begin_src emacs-lisp
   (line-number-mode 0)
 #+end_src
 *** Enable horizontal cursor position
 For some reason, this is not displayed by default in the Emacs modeline.
 It can be very useful to know the current position of the cursor in a line so that you can restrict line length in applications where that matters.
 #+begin_src emacs-lisp
   (column-number-mode 1)
 #+end_src
 ** Indentation indicators
 Programming languages that use indentation to control scope such as Python are greatly enhanced by the ability to see indentation more clearly.
 The ~indent-bars~ package by jdtsmith gives us the ability to see this indentation much more clearly.
 #+begin_src emacs-lisp
   (elpaca indent-bars
     (setq indent-bars-no-descend-lists 'skip) ; prevent extra bars in nested lists + skip intermediate bars
     (setq indent-bars-treesit-support t))
 #+end_src
 
 Because I want all aspects of language configuration to be in [[The programming environment][the programming environment]] section, I don't want to set language-specific variables here.
 The plist ~indent-bars-treesit-scope~ is one such language-specific variable, if there are ever any more that I want to configure, I will also add them here:
 #+begin_src emacs-lisp
   (defvar ethandl/indent-bars-treesit-scope nil)
   (defun ethandl/set-indent-bars-treesit-scope ()
     (require 'indent-bars)
     (setq indent-bars-treesit-scope ethandl/indent-bars-treesit-scope))
   (add-hook 'elpaca-after-init-hook #'ethandl/set-indent-bars-treesit-scope)
 #+end_src
 ** Fonts
 *** Code fonts
 These are the fonts used generally by the Emacs user interface, and in any buffer that doesn't use ~variable-pitch-mode~.
 
 I like the fonts created by Toshi Omagari, primarily Codelia and Comic code.
 As a fallback, I don't mind Monaco/Monego.
 #+begin_src emacs-lisp
   (defvar ethandl/font-name nil
     "Font name for regular Emacs fonts
   Used in all buffers.")
 
   (defvar ethandl/font-size nil
     "Size for regular Emacs fonts
   Used in all buffers.")
 
   (defvar ethandl/default-font-size 12
     "Default size for regular Emacs fonts
   Used in all buffers.")
 
   (defvar ethandl/font-string nil
     "Fully qualified string for use with `set-frame-font'
   Describes the font used in all regular Emacs buffers.")
 
   (defun ethandl/font-exists (fname)
     "Returns nil if the font FNAME does not exist, else
   returns the font list after and including FNAME"
     (member fname (font-family-list)))
 
   (defun ethandl/set-font-vars (&optional name size)
     "Set font configuration variables
 
   Use NAME as the font family and SIZE as the font size in
   points. If NAME is nil, select the first available font
   from a predefined list. If SIZE is nil, uses
   `ethandl/default-font-size'.
 
   Sets `ethandl/font-name', `ethandl/font-size', and
   `ethandl/font-string'."
     (setq ethandl/font-name
   	(or name
   	    (seq-find #'ethandl/font-exists
     		      '("Codelia Ligatures"
     			"Comic Code Ligatures"
     			"Monego"
     			"Monaco"
     			"monospace"))))
     (setq ethandl/font-size
     	(or size ethandl/default-font-size))
     (setq ethandl/font-string
     	(format "%s-%d" ethandl/font-name ethandl/font-size)))
 
   (defun ethandl/set-frame-font (&optional frame name size)
     "Sets the font for a frame or all frames if FRAME is not
   specified.
 
   Use FRAME to specify the frame to change, NAME as the font family,
   and SIZE as the font size in points. If FRAME is nil, will apply to
   all open frames. If NAME or SIZE are nil, follows the same
   convention as `ethandl/set-font-vars'."
     (if (or name size)
         (ethandl/set-font-vars name size)
       (unless (and ethandl/font-name
   		 ethandl/font-size
   		 ethandl/font-string)
         (ethandl/set-font-vars)))
     
     (set-frame-font ethandl/font-string t (if frame (list frame) t)))
 #+end_src
 Now we ensure that these functions apply the fonts both when the config is loaded, and whenever a new frame is made.
 It is particularly important to have the ~server-after-make-frame-hook~ if you are planning on running Emacs as a daemon:
 #+begin_src emacs-lisp
   (ethandl/set-font-vars)
   (ethandl/set-frame-font)
   
   (add-hook 'after-make-frame-functions #'ethandl/set-frame-font)
   (add-hook 'server-after-make-frame-hook #'ethandl/set-frame-font)
 #+end_src
 *** Org fonts
 Org documents are configured to start in variable pitch mode such that we have two sets of fonts: Body (variable-pitch), and verbatim (monospaced fixed-pitch):
 #+begin_src emacs-lisp
   (add-hook 'org-mode-hook #'variable-pitch-mode)
 #+end_src
 
 To define our desired fonts, we create functions as we did before in [[Code fonts]]:
 #+begin_src emacs-lisp
   (defvar ethandl/org-mono-font-name nil
     "Font for code and any monospace blocks in Org documents")
   (defvar ethandl/org-var-font-name nil
     "Font for Org documents, variable width")
   (defvar ethandl/org-default-font-height 140
     "Default height for fonts in org documents")
   (defvar ethandl/org-font-ht nil
     "Font height in org documents")
   
   (defun ethandl/org-set-font-vars (&optional height var mono)
     "Sets the mono font variables for Org mode
 
   Use HEIGHT to specify the font height in px, VAR as the
   variable-pitch font family, and MONO as the monospace font
   family. If HEIGHT is nil, uses the default height given by
   `ethandl/org-default-font-height'. If VAR or MONO are nil,
   selects the first available font for each from a predefined
   list."
     (setq ethandl/org-mono-font-name
   	(or mono
   	    (seq-find #'ethandl/font-exists
   		      '("Codelia Ligatures"
   			"Iosevka"
   			"Monego"
   			"Monaco"
   			"CMU Typewriter Text"
   			"DejaVu Sans Mono"
   			"monospace"))))
     (setq ethandl/org-var-font-name
   	(or var
   	    (seq-find #'ethandl/font-exists
   		      '("CMU Serif"
   			"Iosevka Aile"
   			"Times New Roman"
   			"DejaVu Serif"))))
     (setq ethandl/org-font-ht
   	(or height ethandl/org-default-font-height)))
 #+end_src
 
 Next, we define a way to easily apply these fonts.
 This is not as simple as it should be, because ~variable-pitch-mode~ takes over all Org fonts.
 #+begin_src emacs-lisp
   (defun ethandl/org-set-fonts (&optional height var mono)
     "Applies the mono fonts for org mode. Arguments are the
   same as for `ethandl/set-org-font-vars'."
     (if (or height var mono)
         (ethandl/org-set-font-vars height var mono)
       (unless (and ethandl/org-mono-font-name
   		 ethandl/org-var-font-name
   		 ethandl/org-font-ht)
         (ethandl/org-set-font-vars)))
     
     (custom-theme-set-faces
      'user
      `(variable-pitch ((t (:family ,ethandl/org-var-font-name :height ,ethandl/org-font-ht))))
      `(fixed-pitch ((t (:family ,ethandl/org-mono-font-name :height 0.9))))
      
      '(org-block ((t (:inherit fixed-pitch))))
      '(org-code ((t (:inherit (shadow fixed-pitch)))))
      '(org-document-info ((t (:foreground "dark orange"))))
      '(org-document-info-keyword ((t (:inherit (shadow fixed-pitch)))))
      '(org-indent ((t (:inherit (org-hide fixed-pitch)))))
      '(org-link ((t (:foreground "royal blue" :underline t))))
      '(org-meta-line ((t (:inherit (font-lock-comment-face fixed-pitch)))))
      '(org-property-value ((t (:inherit fixed-pitch))) t)
      '(org-special-keyword ((t (:inherit (font-lock-comment-face fixed-pitch)))))
      '(org-table ((t (:inherit fixed-pitch :foreground "#83a598"))))
      '(org-tag ((t (:inherit (shadow fixed-pitch) :weight bold :height 0.8))))
      '(org-verbatim ((t (:inherit (shadow fixed-pitch)))))))
 #+end_src
 
 Finally, we ensure that these functions are run whenever necessary:
 #+begin_src emacs-lisp
   ;; Evaluate available fonts when loading config
   (ethandl/org-set-font-vars)
 
   ;; Evaluate available fonts when making a new frame (relevant for daemon mode)
   (add-hook 'after-make-frame-functions #'ethandl/org-set-font-vars)
   (add-hook 'server-after-make-frame-hook #'ethandl/org-set-font-vars)
 
   ;; Set the fonts when loading into an org buffer
   (add-hook 'org-mode-hook #'ethandl/org-set-fonts)
 #+end_src
 *** Ligatures
 In order to get ligatures to display in regular builds of emacs, we use ~ligature.el~:
 #+begin_src emacs-lisp
   (unless (eq system-type 'darwin)
     (elpaca 'ligature
       (ligature-set-ligatures 'prog-mode '("<---" "<--"  "<<-" "<-" "->" "-->" "--->" "<->" "<-->" "<--->" "<---->" "<!--"
   					 "<==" "<===" "<=" "=>" "=>>" "==>" "===>" ">=" "<=>" "<==>" "<===>" "<====>" "<!---"
   					 "<~~" "<~" "~>" "~~>" "::" ":::" "==" "!=" "===" "!=="
   					 ":=" ":-" ":+" "<*" "<*>" "*>" "<|" "<|>" "|>" "+:" "-:" "=:" "<******>" "++" "+++"))
       (global-ligature-mode t)))
 #+end_src
 ** Theme
 I like the Catppuccin theme, but the official one kinda stinks. As such, I use the ~batppuccin~ theme:
 #+begin_src emacs-lisp
   (elpaca 'batppuccin
     (require 'batppuccin)
     (load-theme 'batppuccin-mocha t))
 #+end_src
 
 Another nice theme is ~gruber-darker~ by tsoding, one can use it similarly:
 #+begin_src emacs-lisp :tangle no
   (elpaca 'gruber-darker-theme
     (require 'gruber-darker-theme)
     (load-theme 'gruber-darker t))
 #+end_src
 * Emacs behaviour
 ** Startup screen removal
 Boot straight into a scratch buffer, removing the startup screen:
 #+begin_src emacs-lisp
   (setq-default inhibit-startup-screen t)
 #+end_src
 ** Line wrapping
 The default line wrapping doesn't respect words and will arbitrarily wrap on the last character.
 Luckily Emacs comes with an alternate wrapping method:
 #+begin_src emacs-lisp
   (global-visual-line-mode 1)
 #+end_src
 
 Futhermore, with vanilla Emacs 30.1 or newer the indentation of the wrapped line will be respected with the addition of the following mode:
 #+begin_src emacs-lisp
   (when (fboundp 'global-visual-wrap-prefix-mode)
     (global-visual-wrap-prefix-mode 1))
 #+end_src
 ** Scrolling
 There are a collection of variables that make scrolling behave more like that in ~vi~, my poison.
 #+begin_src emacs-lisp
   (setq scroll-conservatively 10000
         scroll-margin 0
         auto-window-vscroll nil)
 #+end_src
 
 For smooth mouse and faster document scrolling, I use the package ~ultra-scroll~ by jdtsmith.
 This works on all emacs builds to my knowledge, and is by far the best scrolling package.
 #+begin_src emacs-lisp
   (elpaca 'ultra-scroll
     (require 'ultra-scroll)
     (ultra-scroll-mode 1)
     (add-hook 'ultra-scroll-hide-functions #'org-modern-mode))
 #+end_src
 ** Suppress ~native-compiler~ warnings
 These warnings are generally not useful.
 It seems that there's a lot that can go wrong with native compilation that cause it to freak out and give warnings, but as long as we aren't gettings errors, everything is fine.
 For debugging purposes, you can disable the tangling of this block:
 #+begin_src emacs-lisp
   (setq native-comp-async-report-warnings-errors `silent)
 #+end_src
 ** Asyncronous commands
 The package ~async~ allows for us to run long, blocking commands in separate Emacs processes.
 #+begin_src emacs-lisp
   (defvar ethandl/async-job-queue nil)
   (defvar ethandl/async-job-results nil)
 
   (defun ethandl/eval-async-job (job)
     (let ((form (car job))
   	(inject-vars (cadr job)))
       (async-start
        (if inject-vars
   	 `(lambda ()
   	    ,(async-inject-variables inject-vars)
   	    ,form)
          `(lambda () ,form))
        (lambda (result)
          (push result ethandl/async-job-results)))))
        
 
   (defun ethandl/eval-async-job-queue ()
     (mapc #'ethandl/eval-async-job ethandl/async-job-queue)
     (setq ethandl/async-job-queue nil))
 
   (defun ethandl/async-job-queue-add (form &optional inject-vars)
     (push (list form inject-vars) ethandl/async-job-queue))
 
   (elpaca 'async
     (require 'async)
     (ethandl/eval-async-job-queue)
     (run-with-idle-timer 30 t 'ethandl/eval-async-job-queue))
 #+end_src
 ** Ahead-of-time nativecomp
 After just installing this Emacs config, things can be a little stuttery. We can speed this up by telling Emacs to nativecomp everything.
 
 Here is a simple convenience function to compile everything in this config, including all packages installed with ~elpaca~:
 #+begin_src emacs-lisp
   (defun ethandl/nativecomp-aot ()
     (interactive)
     (native-compile-async user-emacs-directory t))
 #+end_src
 
 We add this to the ~elpaca-after-init-hook~ so that everything is compiled after initial installation. Any subsequent compilation can occur at runtime.
 #+begin_src emacs-lisp
   (add-hook 'elpaca-after-init-hook
   	  #'ethandl/nativecomp-aot)
 #+end_src
 ** Indenting without tabs
 Tabs make your code unreadable on editors with different tab settings if used incorrectly.
 Unfortunately Emacs does this incorrectly by default, so I will disable this behaviour:
 #+begin_src emacs-lisp
   (indent-tabs-mode -1)
   (setq-default indent-tabs-mode -1)
 #+end_src
 ** Autosave & backup directories
 By default, Emacs puts backup files alongside regular files in the format of ~filename~~.
 This clutters up directories with extra files, and can be problematic when working in Git repos or shared spaces.
 
 Emacs additionally puts autosave files in the format of ~.#filename~.
 Whilst these are less intrusive and disappear upon saving, it is still worth putting them in a dedicated directory.
 
 First defining our dedicated directories for both of these files:
 #+begin_src emacs-lisp
   (defvar ethandl/backup-dir
     (expand-file-name "backups/" user-emacs-directory))
   (defvar ethandl/autosave-dir
     (expand-file-name "autosaves/" user-emacs-directory))
 #+end_src
 Now we ensure the directories exist:
 #+begin_src emacs-lisp
   (unless (file-directory-p ethandl/backup-dir)
     (make-directory ethandl/backup-dir t))
   (unless (file-directory-p ethandl/autosave-dir)
     (make-directory ethandl/autosave-dir t))
 #+end_src
 Finally we set the appropriate variables so that these directories are used:
 #+begin_src emacs-lisp
   (setq backup-directory-alist `(("." . ,ethandl/backup-dir)))
   (setq auto-save-file-name-transforms
         `((".*" ,ethandl/autosave-dir t)))
 #+end_src
 * Org mode
 ** Section numbering
 I like my sections numbered:
 #+begin_src emacs-lisp
   (add-hook 'org-mode-hook #'org-num-mode)
 #+end_src
 ** Better emphasis rendering
 Emphasis markers (/italics/, *bold*, _underline_, ~verbatim~, =code=, and +strikethrough+) all render with the markers (~/~, ~*~, ~_~, ~~~, ~=~, and ~+~) included in the text by default.
 I think that these markers work better when they aren't rendered:
 #+begin_src emacs-lisp
   (setq org-hide-emphasis-markers t)
 #+end_src
 ** Pretty appearance
 I know that I said that I would keep things minimal...
 
 I lied: this package is just for beauty because Org is somewhat ugly by default.
 Unfortunately, this package conflicts with ~visual-wrap-prefix-mode~, so we need to explicitly disable that for org mode with a hook function.
 #+begin_src emacs-lisp
   (elpaca 'org-modern
     (require 'org-modern)
     (add-hook 'org-mode-hook #'org-modern-mode)
     (add-hook 'org-agenda-finalize-hook #'org-modern-agenda)
     (add-hook 'org-mode-hook (lambda () (visual-wrap-prefix-mode 0))))
 #+end_src
 ** \(\text{\LaTeX}\) rendering
 We are already secretly using a buggy Org branch to get \(\text{\LaTeX}\) to render correctly and automagically.
 This is not ideal, but vanilla Org doesn't support live \(\text{\LaTeX}\) rendering and is slow. It's a tradeoff...
 
 To enable this rendering automatically, as well as a live preview while writing:
 #+begin_src emacs-lisp
   (add-hook 'org-mode-hook #'org-latex-preview-mode)
   (setq org-latex-preview-mode-display-live t)
 #+end_src
 
 By default, ~org-latex-preview-mode~ only renders \(\text{\LaTeX}\) in the visible regions, which is problematic for documents like this that start in ~overview~ on startup.
 This can be fixed by rendering all \(\text{\LaTeX}\) in the buffer ahead of time when loading the buffer, this may be intensive for buffers with a lot of \(\text{\LaTeX}\), but at least this rewrite of ~org-latex-preview~ is asyncronous.
 #+begin_src emacs-lisp
   (add-hook 'org-mode-hook (lambda () (org-latex-preview 'buffer)))
 #+end_src
 
 By default, the \(\text{\LaTeX}\) previews are displayed with PNG for speed, but I will change this to use SVG for display sexiness:
 #+begin_src emacs-lisp
   (setq org-latex-preview-process-default 'dvisvgm)
 #+end_src
 ** Start with images
 By default, Org will wait until ~org-link-preview~ is run to display images. The following sets images to automatically load on file opening:
 #+begin_src emacs-lisp
   (setq org-startup-with-inline-images t)
 #+end_src
 
 If we want images generated by the output of ~org-babel~ to automatically render, we need to add the following to the hook:
 #+begin_src emacs-lisp
   (add-hook 'org-babel-after-execute-hook #'org-link-preview-region)
 #+end_src
 This will save a ~C-c C-x C-v~ invocation every time we want to display newly generated images.
 * LaTeX
 \(\text{\LaTeX}\) takes up a large part of my work, so I would like to have a nice \(\text{\LaTeX}\) editing environment.
 ** PDF Viewing
 Whilst Emacs can view PDFs out of the box (wow), it rasterises the PDFs to something that is quite low resolution and doesn't look the best on all displays and is quite slow.
 
 The ~pdf-tools~ package allows for much better PDF rendering:
 #+begin_src emacs-lisp
   (elpaca pdf-tools
     (require 'pdf-tools)
     (pdf-tools-install t t)
     (add-to-list 'pdf-tools-enabled-modes #'pdf-view-midnight-minor-mode)
     (add-to-list 'pdf-tools-enabled-modes #'auto-revert-mode))
 #+end_src
 * The programming environment
 This will be perpetually incomplete, my config cannot support /every/ language, nor do I really need it to.
 
 The selection of languages may seem odd, but they are just what I have been bothered to put the effort into to-date. If I stop using one and it breaks, I will delete it rather than fix it until I need it again.
 ** Org babel
 In addition to being a useful Markdown alternative, Org mode can also serve as a literate programming environment and (shitty) Jupyter replacement.
 
 The intended configuration for ~org-babel~ involves defining your list of languages to support all at once using the ~org-babel-do-load-languages~ function.
 To allow for the language list (contained in ~ethandl/org-babel-langs~) to be defined dynamically (even in environment), the following function is defined:
 #+begin_src emacs-lisp
   (setq ethandl/org-babel-langs nil)
   (defun ethandl/org-babel-load-langs ()
     (org-babel-do-load-languages
      'org-babel-load-languages
      ethandl/org-babel-langs))
 #+end_src
 This list is then evaluated dynamically every time an Org document is opened through the ~org-mode-hook~:
 #+begin_src emacs-lisp
   (add-hook 'org-mode-hook #'ethandl/org-babel-load-langs)
 #+end_src
 ** The ~vterm~ terminal emulator
 To make emacs a useful development environment, we need a good terminal.
 In addition to using separate (good) terminals, we can use the cromulent ~vterm~ package:
 #+begin_src emacs-lisp
   (elpaca 'vterm)
 #+end_src
 ** Treesitter grammar async install
 Treesitter grammar installation is slow and blocks up the emacs process. The following allows for asyncronous treesitter grammar installation on separate processes:
 #+begin_src emacs-lisp
   (defun ethandl/treesit-install-async (lang)
     (unless (treesit-language-available-p lang)
       (ethandl/async-job-queue-add
        `(treesit-install-language-grammar ',lang)
        "\\`treesit-language-source-alist\\'")))
 #+end_src
 ** Markdown
 For markdown, I will use ~markdown-ts-mode~, which utilises treesitter to provide highlighting for markdown.
 To use this mode, we need to install the treesitter grammar(s):
 #+begin_src emacs-lisp
   (add-to-list 'treesit-language-source-alist
   	     '(markdown "https://github.com/tree-sitter-grammars/tree-sitter-markdown"
   			"split_parser"
   			"tree-sitter-markdown/src"))
   (add-to-list 'treesit-language-source-alist
   	     '(markdown-inline "https://github.com/tree-sitter-grammars/tree-sitter-markdown"
   			       "split_parser"
   			       "tree-sitter-markdown-inline/src"))
 
   (ethandl/treesit-install-async 'markdown)
   (ethandl/treesit-install-async 'markdown-inline)
 #+end_src
 ** Emacs Lisp
 Not much needs to be done here.
 For verbosity, I will specify that we want Org babel to be able to evaluate elisp ~src~ blocks:
 #+begin_src emacs-lisp
   (add-to-list 'ethandl/org-babel-langs '(emacs-lisp . t))
 #+end_src
 ** Python
 There are two python modes installed by default with Emacs.
 From my (admittedly limited) experience, ~python-ts-mode~ tends to have better syntax highlighting due to it having a better AST.
 #+begin_src emacs-lisp
   (add-to-list 'treesit-language-source-alist
   	     '(python "https://github.com/tree-sitter/tree-sitter-python"))
 
   (add-to-list 'major-mode-remap-alist
   	     '(python-mode . python-ts-mode))
 
   (ethandl/treesit-install-async 'python)
 
   (add-to-list 'ethandl/org-babel-langs '(python . t))
 #+end_src
 
 For python, I like to have indentation visible with ~indent-bars~,
 #+begin_src emacs-lisp
   (add-hook 'python-mode-hook #'indent-bars-mode)
   (add-hook 'python-ts-mode-hook #'indent-bars-mode)
 #+end_src
 A simple configuration for treesit-python is given on the github repo for ~indent-bars~:
 #+begin_src emacs-lisp
   (setq indent-bars-treesit-ignore-blank-lines-types '("module"))
   (add-to-list 'ethandl/indent-bars-treesit-scope
   	     '(python function_definition class_definition for_statement
   		      if_statement with_statement while_statement))
 #+end_src
 ** Powershell
 I don't like or use Powershell, but seeing as I sometimes operate on Windows (and even have a sample in this config for TRAMP compatability), it /could/ be nice to have.
 
 Due to my general distaste for all things Microslop, this may disappear if I deem it too much effort to keep around. That said, here is a mode to use when working with Powershell (the slowest shell known to mankind).
 #+begin_src emacs-lisp
   (elpaca 'powershell)
 #+end_src
 * Tramp
 We all love tramp. Tramp is great.
 ** Windows remote support
 Disclaimer: This isn't my solution, though I got part of the way there are just so many reasons why Windows is broken and shit. I borrowed heavily on the PowerShell and ~sshw~ definition from [[https://emacs.stackexchange.com/a/85533][this stackexchange post]].
 
 Ensure first that the Windows remote has been de-crappified as much as possible, with Git and hence ~bash~ installed, and the OpenSSH Server feature enabled with the service started.
 Then run the following in a PowerShell prompt on the remote to enable ~bash~ as the SSH shell (if it isn't already):
 #+begin_src powershell
   New-ItemProperty -Path "HKLM:\SOFTWARE\OpenSSH" -Name DefaultShell -Value "C:\Program Files\Git\bin\bash.exe" -PropertyType String -Force
   New-ItemProperty -Path "HKLM:\SOFTWARE\OpenSSH" -Name DefaultShellCommandOption -Value "-c" -PropertyType String -Force
 #+end_src
 
 Now that the remote is set up, we can use the following tramp method:
 #+begin_src emacs-lisp
   (require 'tramp)
   (add-to-list
    'tramp-methods
    '("sshw" (tramp-login-program "ssh")
      (tramp-login-args
       (("-l" "%u") ("-p" "%p") ("%c") ("-e" "none") ("-T")
        ("-o" "RemoteCommand=\"%l\"") ("%h")))
      (tramp-async-args (("-q"))) (tramp-remote-shell "/bin/sh")
      (tramp-remote-shell-login ("-l")) (tramp-remote-shell-args ("-c"))))
 #+end_src
 * Platform specifics
 I have structured the following sections such that each specific platform is tangled only if it is applicable.
 Tangled outputs are saved to ~config-TARG.el~ where ~TARG~ is a property of your platform.
 
 Any tangled outputs are automatically included in the final subsection of this section.
 
 Generally only small deviations from the main config should be put in here.
 This is the place to check if you're getting any strange bugs or different behaviour on different platforms.
 ** MacOS
 *** The menu bar
 Because the menu bar exists regardless on MacOS, I like to keep ~menu-bar-mode~ enabled.
 #+begin_src emacs-lisp :tangle (if (eq system-type 'darwin) "platform-config/darwin.el" "no")
   (menu-bar-mode 1)
 #+end_src
 ** Work PC
 My work PC has a lower resolution screen, so I like to have smaller fonts so that they take up less screen space.
 #+begin_src emacs-lisp :tangle (if (equal system-name "lobotomite") "platform-config/work-system.el" "no")
   (setq ethandl/org-default-font-height 110)
   (ethandl/org-set-font-vars)
 #+end_src
 ** Windows
 Windows is a very feculant platform to deal with, as almost nothing works as you would expect.
 
 Firstly, there is no ~nativecomp~, so we have to redefine the function to be a no-op or everything will break:
 #+begin_src emacs-lisp :tangle (if (eq system-type 'windows-nt) "platform-config/windows.el" "no")
   (defun ethandl/nativecomp-aot ()
     (interactive)
     (lwarn '(windows-is-shit) :debug "Nativecomp not supported on Windows NT. Use a real OS"))
 #+end_src
 ** Emacs <31
 There are a few assumptions that are made in this configuration that do not hold for versions of Emacs less than 31.
 *** ~markdown-ts-mode~
 ~markdown-ts-mode~ is only shipped with Emacs31 and newer, so we need to install it on older versions:
 #+begin_src emacs-lisp :tangle (if (< (string-to-number emacs-version) 31) "platform-config/old-emacs.el" "no")
   (elpaca markdown-ts-mode
     (require 'markdown-ts-mode)
     (add-to-list 'auto-mode-alist '("\\.md\\'" . markdown-ts-mode)))
 #+end_src
 ** Including the platforms
 Finally, we include any tangled platforms:
 #+begin_src emacs-lisp
   (dolist (file (directory-files ethandl/platform-config-dir t "\\.el$"))
     (load file))
 #+end_src