Shorten corfu completion delay

Configure treemacs
Replace lsp-mode with eglot
2026-01-22 15:26:15 +02:00 · 2025-10-28 12:14:01 +02:00 · 2025-09-18 15:06:30 +03:00 · 2025-08-04 11:39:09 +03:00 · 2025-02-04 08:39:24 +02:00 · 2025-01-29 09:22:41 +02:00
61 changed files with 2336 additions and 2038 deletions
--- a/.forgejo/workflows/demo.yml
+++ b/.forgejo/workflows/demo.yml
@ -20,7 +20,7 @@ jobs:
        run: npm install -g @emacs-eask/cli

      - name: Run tests
-        run: emacs --init-directory . --debug-init --eval "(kill-emacs 0)"
+        run: eask test buttercup

      - name: Uninstall eask
        run: npm uninstall -g @emacs-eask/cli
--- a/.gitignore
+++ b/.gitignore
@ -25,6 +25,8 @@ ac-comphist.dat
 /speed-type
 /tutorial
 /tree-sitter
+emacs.keyfreq
+ielm-history.eld

 # Ignore actual init as it can contain private data
 init.el
--- a/README.MD
+++ b/README.MD
@ -1,14 +1,8 @@
-# My emacs config
+# Emacs configuration

-Contains config I use for the following languages/modes:
+This is the repository of my emacs configuration that I use on both MacOS and Linux. There are some additional configuration properties to use with BSD when I was testing it, but it is best treated as abandoned.

-* Elixir
-* Ruby
-* Rust
-* Markdown
-* HTML and compatibile (ERB)
-
-As of current iteration, I avoid usage of Evil modes, instead focusing of usage of Emacs functionality.
+I predominantly write Elixir, so that part is the most polished bit of the configuration but it also works for Ruby, Rust, Go, Javascript/Typescript and Kotlin. I use emacs for programming, so there is no org-mode, GTD, email or RSS here. I use deft to keep some programming notes here and there.

 ## Installation

@ -19,6 +13,5 @@ git clone git@github.com:maciej-szlosarczyk/emacs.git ~/.emacs.d
 And then put the following lines into init.el

 ```emacs
-(add-to-list 'load-path (concat user-emacs-directory "lisp"))
 (require 'icejam-custom-init)
 ```
--- a/early-init.el
+++ b/early-init.el
@ -17,4 +17,17 @@
 ;; Log garbage collection.
 (setq garbage-collection-messages nil)

+;; Monitor startup time
+(add-hook 'emacs-startup-hook
+          (lambda ()
+            (message "Emacs ready in %s with %d garbage collections."
+                     (format "%.2f seconds"
+                             (float-time
+                              (time-subtract after-init-time before-init-time)))
+                     gcs-done)))
+
+;; set path for native compilation to work
+(setenv "PATH" "/Users/maciej/.local/share/zinit/polaris/bin:/Users/maciej/.asdf/shims:/Users/maciej/.local/bin:/Users/maciej/.opam/default/bin:/Users/maciej/.go/bin:/Users/maciej/.elan/bin:/opt/homebrew/opt/postgresql@17/bin:/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/System/Cryptexes/App/usr/bin:/usr/bin:/bin:/usr/sbin:/sbin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/local/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/appleinternal/bin:/Library/Apple/usr/bin:/usr/local/MacGPG2/bin:/usr/local/share/dotnet:/Users/maciej/.dotnet/tools:/Applications/Postgres.app/Contents/Versions/latest/bin:/Applications/kitty.app/Contents/MacOS")
+(setq exec-path (split-string (getenv "PATH") path-separator))
+
 ;;; early-init.el ends here
--- a/elpaca.lock
+++ b/elpaca.lock
--- a/lisp/icejam-aider.el
+++ b/lisp/icejam-aider.el
@ -0,0 +1,81 @@
+;;; icejam-aider.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;;; Copilot and other GPT stuff
+
+;;; Code:
+(use-package copilot :ensure (:host github :repo "copilot-emacs/copilot.el" :files ("*.el"))
+  :defer t
+  ;; It sort of sucks so let's disable it.
+  ;; :hook ((prog-mode . copilot-mode))
+  :bind (:map copilot-completion-map
+              ([tab] . copilot-accept-completion))
+  :config
+  (add-to-list 'copilot-indentation-alist '(emacs-lisp-mode . 2)))
+
+;; Enable Anthropic Claude LLM support for chat (it also sucks)
+(defcustom anthropic-api-key "api-key" "The value of your Anthropic API key."
+  :type 'string
+  :group 'icejam
+  :initialize 'custom-initialize-set)
+
+(use-package gptel :ensure t :defer t
+  :config
+  (declare-function gptel-make-anthropic "gptel")
+  (declare-function gptel-make-ollama "gptel")
+  (gptel-make-ollama "Ollama@Linux"
+    :host "192.168.88.110:11434"
+    :stream t
+    :models '(qwen2.5-coder:7b qwen2.5-coder:14b deepseek-r1:14b deepseek-r1:32b))
+  (setq
+   gptel-model 'claude-3-5-sonnet-20241022
+   gptel-backend (gptel-make-anthropic "Claude"
+                   :stream t :key (lambda () anthropic-api-key))))
+
+;; Pretend to be 'AI editor' vol 1. Before usage make sure aider is installed:
+;; $ pip install aider-install
+;; $ aider install
+;; (use-package aider :ensure (:host github :repo "tninja/aider.el")
+;;   :defer t
+;;   :config
+;;   ;; (setenv "OLLAMA_API_BASE" "http://127.0.0.1:11434")
+;;   (setenv "OLLAMA_API_BASE" "http://192.168.88.110:11434")
+;;   (setopt aider-args (list "--model"
+;;                            "ollama_chat/deepseek-r1:32b"
+;;                            "--no-auto-commits"
+;;                            "--no-analytics"
+;;                            "--no-gitignore")))
+
+(use-package aidermacs :ensure (:host github :repo "MatthewZMD/aidermacs")
+  :defer t
+  :config
+  ;; (setenv "OLLAMA_API_BASE" "http://127.0.0.1:11434")
+  (setenv "OLLAMA_API_BASE" "http://192.168.88.13:11434")
+  (setopt aidermacs-default-chat-mode 'architect)
+  (setopt aidermacs-default-model "ollama_chat/qwen3-coder:30b")
+  (setopt aider-extra-args (list "--model"
+                                 "ollama_chat/qwen3-coder:30b"
+                                 "--no-auto-commits"
+                                 "--no-analytics"
+                                 "--no-gitignore")))
+
+;; Pretend to be 'AI editor' vol 2.
+(use-package elysium :ensure t :defer t
+  :config
+  (setopt
+   ;; The elysium buffer will be 1/3 your screen
+   elysium-window-size 0.33
+   ;; Elysium buffer will be vertical
+   elysium-window-style 'vertical))
+
+;; Merging with SMerge
+(use-package smerge-mode :ensure nil
+  :hook ((prog-mode . smerge-mode)))
+
+(provide 'icejam-aider)
+;;; icejam-aider.el ends here
--- a/lisp/icejam-avy.el
+++ b/lisp/icejam-avy.el
@ -8,11 +8,12 @@

 ;; Avy is a navigation manager.

-;;; Code:
-(require 'icejam-keys-mode)
+(eval-when-compile (defvar icejam-keys-mode-map))

+;;; Code:
 (use-package avy :ensure t :defer t
-  :custom (avy-timeout-seconds 1 "Wait for 1 second for candidates")
+  :config
+  (setopt avy-timeout-seconds 1.0) ;; Wait for 1 second for candidates
  :bind (:map icejam-keys-mode-map
              ;; Jump to text in sight with CMD-j
              ([(hyper j)] . avy-goto-char-timer)))
--- a/lisp/icejam-base.el
+++ b/lisp/icejam-base.el
@ -9,11 +9,8 @@
 ;; pkg/base defines basic packages and environment.

 ;;; Code:
-(require 'icejam-keys-mode)

-;;;;;;;; Other optimizations ;;;;;;;;;;;;;;;;;
 ;;;;;;;; Stolen from Doom Emacs. ;;;;;;;;;;;;;
-
 ;; Update emacs less often
 (setopt idle-update-delay 1.0)

@ -21,7 +18,8 @@
 ;; this to `nil' in the past, but the `bidi-display-reordering's docs say that
 ;; is an undefined state and suggest this to be just as good:
 (setq-default bidi-display-reordering 'left-to-right
-              bidi-paragraph-direction 'left-to-right)
+              bidi-paragraph-direction 'left-to-right
+              bidi-inhibit-bpa t)

 ;; Reduce rendering/line scan work for Emacs by not rendering cursors or regions
 ;; in non-focused windows.
@ -33,9 +31,13 @@
 ;; quickly self-correct.
 (setopt fast-but-imprecise-scrolling t)

+;; Trust local folder
+(setopt trusted-content '("~/.emacs.d/" "~/Development/"))
+
 ;;;;;;;;; TRAMP configuration ;;;;;;;;;;;;;;;;
-(require 'tramp)
-(setopt tramp-default-method "ssh")
+(use-package tramp :ensure nil :defer 5
+  :config
+  (setopt tramp-default-method "ssh"))

 ;;;;;;;;; Emacs bindings ;;;;;;;;;;;;;;;;;;;;;
 (global-set-key (kbd "RET") 'newline)
@ -48,12 +50,14 @@
 (use-package buffer-move :ensure t :defer t)

 ;; Garbage collection magic hack
-(use-package gcmh :ensure t
-  :custom ((gcmh-verbose nil "Do not log GC messages.")
-           (gcmh-idle-delay 'auto "Compute GC delay based on gcmh-auto-idle-delay-factor")
-           (gcmh-auto-idle-delay-factor 10 "Original value was 10"))
+(use-package gcmh :ensure t :defer t
+  :commands (gcmh-mode)
+  :hook ((elpaca-after-init . (lambda () (gcmh-mode t))))
  :config
-  (gcmh-mode t))
+  (setopt gcmh-verbose nil) ;; Do not log GC messages
+  (setopt gcmh-idle-delay 'auto) ;; Compute GC delay based on gcmh-auto-idle-delay-factor
+  (setopt gcmh-auto-idle-delay-factor 10) ;; Original value was 10
+  (setopt gcmh-high-cons-threshold (* 256 1024 1024)))

 ;; #====================== Backup config #==============================
 (setopt backup-directory-alist
@ -63,17 +67,21 @@

 (setopt backup-by-copying t)
 (setopt delete-old-versions t
-  kept-new-versions 6
-  kept-old-versions 2
+  kept-new-versions 10
+  kept-old-versions 5
  version-control t)

 ; Do not create .#foo.file lock files
 (setopt create-lockfiles nil)

 ;; Enable line numbers and show cursors position
-(add-hook 'prog-mode-hook 'display-line-numbers-mode)
-(add-hook 'text-mode-hook 'display-line-numbers-mode)
-(add-hook 'conf-mode-hook 'display-line-numbers-mode)
+(dolist (mode '(prog-mode-hook
+                text-mode-hook
+                conf-mode-hook))
+  (add-hook mode 'display-line-numbers-mode)
+  ;; Highlight current line.
+  (add-hook mode 'hl-line-mode))
+
 ;; (global-display-line-numbers-mode t)
 (column-number-mode t)

@ -87,7 +95,8 @@
 (setopt large-file-warning-threshold 50000000)

 ;; Numbers are arbitrary, but work on a large screen. Default is 160
-(setopt split-width-threshold 200)
+(setopt split-width-threshold 190)
+
 ;;;;;;;;;;;;;;;;;;;;;; Shell stuff ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)

@ -96,18 +105,18 @@

 ;; Allow to execute path from shell
 (use-package exec-path-from-shell
-  :if (memq window-system '(x mac ns))
+  ;; :if (memq window-system '(x mac ns))
  :ensure t
+  :defer t
+  :hook ((elpaca-after-init . exec-path-from-shell-initialize))
  :config
+  (declare-function exec-path-from-shell-initialize "exec-path-from-shell")
  (add-to-list 'exec-path "/usr/local/bin")
  (dolist (var '("DEFT_PATH" "LANG" "LC_CTYPE"))
-      (add-to-list 'exec-path-from-shell-variables var))
-    (exec-path-from-shell-initialize))
+    (add-to-list 'exec-path-from-shell-variables var)))

-(use-package direnv :ensure t
-  :config
-  (declare-function direnv-mode "direnv")
-  (direnv-mode t))
+(use-package direnv :ensure t :defer t
+  :hook ((elpaca-after-init . direnv-mode)))

 ;; Draw underline lower
 (setopt x-underline-at-descent-line t)
@ -119,13 +128,15 @@
        indicate-empty-lines nil)

 ;;;;;;;;;;;;;;;;; Treemacs
-(use-package treemacs :ensure t
+(eval-when-compile (defvar icejam-keys-mode-map))
+
+(use-package treemacs :ensure t :defer t
+  :hook ((elpaca-after-init . treemacs-follow-mode)
+         (elpaca-after-init . treemacs-project-follow-mode))
  :commands (treemacs-follow-mode treemacs-project-follow-mode treemacs)
  :bind (:map icejam-keys-mode-map
              ([(hyper b)] . treemacs))
-  :config
-  (treemacs-follow-mode t)
-  (treemacs-project-follow-mode t))
+  :config (setopt treemacs-tag-follow-delay 1.0))

 (use-package treemacs-all-the-icons :ensure t :defer t
  :requires (treemacs)
@ -133,24 +144,20 @@
  :config (treemacs-load-theme "all-the-icons"))

 ;;;;;;;;;;;;;;;;; Record frequency of different commands. Review them later
-(use-package keyfreq :ensure t
+(use-package keyfreq :ensure t :defer t
+  :hook ((elpaca-after-init . keyfreq-mode)
+         (elpaca-after-init . keyfreq-autosave-mode))
  :config
-  (declare-function keyfreq-mode "keyfreq")
-  (declare-function keyfreq-autosave-mode "keyfreq")
-  (keyfreq-mode t)
-  (keyfreq-autosave-mode t))
+  (setopt keyfreq-file (concat user-emacs-directory "emacs.keyfreq")))

 ;;;;;;;;;;;;;;;;; Show hints about key combinations
-(use-package which-key :ensure t
-  :custom (which-key-idle-delay 0.5)
-  :config (which-key-mode t))
+(use-package which-key :ensure nil :defer t
+  :hook ((elpaca-after-init . which-key-mode))
+  :config
+  (setopt which-key-idle-delay 0.2))

 ;;;;;;;;;;;;;;;;; Use C-n to create a new line
 (setopt next-line-add-newlines t)

-;;;;;;;;;;;;;;;;; Speed up long line display by disabling bidirectional text
-(setq-default bidi-paragraph-direction 'left-to-right
-              bidi-inhibit-bpa t)
-
 (provide 'icejam-base)
 ;;; icejam-base.el ends here
--- a/lisp/icejam-blocking.el
+++ b/lisp/icejam-blocking.el
@ -1,21 +0,0 @@
-;;; icejam-blocking.el --- summary
-
-;; Author: Maciej Szlosarczyk
-;; Maintainer: Maciej Szlosarczyk
-;; Version: 0.1-snapshot
-
-;;; Commentary:
-;; These packages are foundational dependency and possibly can be blocking.
-;;; Code:
-
-(use-package transient :ensure (:wait t))
-(use-package diminish :ensure (:wait t))
-(use-package company :ensure (:wait t))
-
-;; https://emacs-lsp.github.io/lsp-mode/page/performance/#use-plists-for-deserialization
-;; This supposedly makes it faster.
-(setenv "LSP_USE_PLISTS" "true")
-(use-package lsp-mode :ensure (:wait t))
-
-(provide 'icejam-blocking)
-;;; icejam-blocking.el ends here
--- a/lisp/icejam-company-yasnippet.el
+++ b/lisp/icejam-company-yasnippet.el
@ -1,90 +0,0 @@
-;;; icejam-company-yasnippet.el -- summary -*- lexical-binding: t; -*-
-;;; Commentary:
-;;; Company completion framework configuration
-;;; Code:
-(require 'icejam-blocking)
-
-(use-package yasnippet :ensure t
-  :config
-  (yas-global-mode t)
-  (unbind-key "C-c & C-n" yas-minor-mode-map)
-  (unbind-key "C-c & C-s" yas-minor-mode-map)
-  (unbind-key "C-c & C-v" yas-minor-mode-map))
-
-(use-package yasnippet-snippets :ensure t :after (yasnippet))
-(use-package company-box :ensure t :after (company)
-  :hook (company-mode . company-box-mode))
-
-(with-eval-after-load 'company
-  (global-company-mode t)
-
-  ;; Hacks for orderless
-  (defun just-one-face (fn &rest args)
-    (let ((orderless-match-faces [completions-common-part]))
-      (apply fn args)))
-
-  (advice-add 'company-capf--candidates :around #'just-one-face)
-
-  (defun company-completion-styles (capf-fn &rest args)
-    (let ((completion-styles '(partial-completion basic)))
-      (apply capf-fn args)))
-
-  (advice-add 'company-capf :around #'company-completion-styles)
-
-  (setq-default
-   company-minimum-prefix-length 3 ;; minimum prefix character number for auto complete.
-   company-idle-delay 0.1
-   company-require-match nil
-   company-echo-delay 0 ;;;; company-show-numbers t
-   company-tooltip-align-annotations t ;; align annotations to the right tooltip border.
-   company-tooltip-flip-when-above t
-   company-tooltip-limit 10  ;; tooltip candidates max limit.
-   company-tooltip-minimum 2 ;; minimum candidates limit.
-   company-tooltip-minimum-width 10 ;; The minimum width of the tooltip's inner area.
-   ;; This doesn't include the margins and the scroll bar.
-   company-tooltip-margin 2 ;; width of margin columns to show around the tooltip
-   company-tooltip-offset-display 'lines ;; 'lines - how to show tooltip unshown candidates number.
-   company-show-numbers nil ;; t: show quick-access numbers for the first ten candidates.
-   company-selection-wrap-around t ;; loop over candidates
-   company-dabbrev-other-buffers t ;; Only offer dabbrev from the same major mode
-   company-dabbrev-downcase nil    ;; Preserve case of candidates
-   company-format-margin-function nil
-   ;; company-async-wait 0.03
-   ;; company-async-timeout 2
-   )
-
-  ;; Absolute defaults for company mode
-  (setopt company-backends
-        '((company-files                ; files & directory
-           company-keywords             ; keywords
-           company-capf
-           )
-          (company-dabbrev company-abbrev)
-          ))
-
-  ;; Use standard emacs next and previous bindings for navigating company
-  ;; suggestions
-  (define-key company-active-map (kbd "C-p") 'company-select-previous-or-abort)
-  (define-key company-active-map (kbd "C-n") 'company-select-next-or-abort)
-
-  (defun icejam-insert-space-and-complete ()
-    "Insert space before trying to complete a section."
-    (interactive)
-    (save-excursion
-      (insert " "))
-    (company-indent-or-complete-common))
-
-  ;; Only use RETURN for completion in company
-  (unbind-key "TAB" company-active-map)
-
-;;; Yasnippet configuration
-  (define-key prog-mode-map (kbd "C-c y") 'company-yasnippet)
-  (define-key prog-mode-map (kbd "<f13>") 'icejam-insert-space-and-complete)
-  (define-key prog-mode-map (kbd "TAB") 'company-indent-or-complete-common)
-
-  (define-key text-mode-map (kbd "C-c y") 'company-yasnippet)
-  (define-key text-mode-map (kbd "<f13>") 'icejam-insert-space-and-complete)
-  (define-key text-mode-map (kbd "TAB") 'company-indent-or-complete-common))
-
-(provide 'icejam-company-yasnippet)
-;;; icejam-company-yasnippet.el ends here
--- a/lisp/icejam-complete-at-point.el
+++ b/lisp/icejam-complete-at-point.el
@ -0,0 +1,95 @@
+;;; icejam-complete-at-point.el -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Completion framework configuration
+;;; Code:
+(use-package yasnippet :ensure t :defer t
+  :hook ((elpaca-after-init . yas-global-mode))
+  :config
+  (unbind-key "C-c & C-n" yas-minor-mode-map)
+  (unbind-key "C-c & C-s" yas-minor-mode-map)
+  (unbind-key "C-c & C-v" yas-minor-mode-map))
+
+(use-package yasnippet-snippets :ensure t :after (yasnippet))
+
+;; Corfu is the main engine for displaying suggestions.
+(use-package corfu :ensure t :defer t
+  :hook ((elpaca-after-init . global-corfu-mode)
+         (global-corfu-mode . corfu-popupinfo-mode))
+  :config
+  ;; Go up to go the the last item on the list
+  (setopt corfu-cycle t
+          corfu-count 20 ;; Show 20 completion candidates
+
+          corfu-max-width 100 ;; Max width of the corfu frame
+          corfu-right-margin-width 0.5
+          corfu-left-margin-width 0.5
+          corfu-bar-width 0.5
+          ;; Do not insert when you type a word that happens to be a
+          ;; completion candidate. A typical example is `format`, which
+          ;; is a yas snippet.
+          corfu-on-exact-match 'quit
+          corfu-quit-at-boundary t
+          corfu-popupinfo-delay '(0.4 . 0.2)
+          corfu-auto t
+          corfu-auto-delay 0.2
+          corfu-quit-no-match 'separator
+
+          ;; Invoke completion with tab when needed.
+          tab-always-indent 'complete))
+
+;; Allow corfu to work in terminal
+(use-package corfu-terminal :ensure t :defer t
+  :if (not (display-graphic-p))
+  :hook ((elpaca-after-init . corfu-terminal-mode)))
+
+;; These are actual completions
+(use-package cape :ensure t :after corfu
+  :config
+  (declare-function cape-dabbrev 'cape)
+  (declare-function cape-file 'cape)
+  (declare-function cape-keyword 'cape)
+  (declare-function cape-elisp-symbol 'cape)
+  (declare-function cape-capf-super 'cape)
+
+  ;; Set default completion values:
+  (set-default 'completion-at-point-functions
+               (list (cape-capf-super #'cape-dabbrev #'yasnippet-capf)
+                     #'cape-file
+                     #'cape-keyword)))
+
+(defun icejam-set-no-eglot-capfs ()
+  "Set `completion-at-point-function` to non-LSP list."
+  (setq-local completion-at-point-functions
+              (list (cape-capf-super #'cape-dabbrev #'yasnippet-capf)
+                    #'cape-file
+                    #'cape-keyword)))
+
+(defun icejam-set-eglot-capfs ()
+  "Set `completion-at-point-function` to list where LSP is supported."
+  (setq-local completion-at-point-functions
+              (list (cape-capf-super #'yasnippet-capf #'eglot-completion-at-point)
+                    #'cape-dabbrev
+                    #'cape-file)))
+
+(defun icejam-set-elisp-capfs ()
+  "Set `completion-at-point-function` to what is useful in Elisp."
+  (setq-local completion-at-point-functions
+              (list (cape-capf-super #'elisp-completion-at-point
+                                     #'yasnippet-capf)
+                    #'cape-dabbrev
+                    #'cape-file
+                    #'cape-elisp-symbol)))
+
+(use-package yasnippet-capf :ensure t :after corfu :defer t
+  :config
+  (declare-function yasnippet-capf 'yasnippet)
+  (setopt yasnippet-capf-lookup-by 'name))
+
+(use-package nerd-icons-corfu :ensure t :defer 5
+  :after corfu
+  :config
+  (declare-function nerd-icons-corfu-formatter 'nerd-icons-corfu)
+  (add-to-list 'corfu-margin-formatters #'nerd-icons-corfu-formatter))
+
+(provide 'icejam-complete-at-point)
+;;; icejam-complete-at-point.el ends here
--- a/lisp/icejam-completing-read.el
+++ b/lisp/icejam-completing-read.el
@ -2,11 +2,11 @@
 ;;; Commentary:
 ;;;
 ;;; completing-read is the way of completing things in minibuffer.  This module
-;;; provides all of that functionality, everything related to minbuffer being helpful.
+;;; provides all of that functionality, everything related to minbuffer being
+;;; helpful.
 ;;;
 ;;; Code:
-
-(require 'icejam-keys-mode)
+(eval-when-compile (defvar icejam-keys-mode-map))

 ;; Preparations for using Vertico/Orderless
 (setopt
@ -31,30 +31,48 @@
 (add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)

 ;; Actual orderless
-(use-package vertico :ensure t
-  :custom ((vertico-scroll-margin 1 "Scroll on N-1")
-           (vertico-count 15 "Show 5 more candidates")
-           (vertico-resize t "Grow and shrink the vertico minibufffer")
-           (vertico-cycle t "Cycle completion"))
+(use-package vertico :ensure t :defer t
+  :hook ((elpaca-after-init . vertico-mode))
  :config
-  (vertico-mode t))
+  (setopt vertico-scroll-margin 1) ;; Scroll on N-1
+  (setopt vertico-count 15)        ;; Show 5 more candidates
+  (setopt vertico-resize t) ;; Grow and shrink the vertico minibufffer
+  (setopt vertico-cycle t)  ;; Cycle completion
+
+  ;; Use H-enter to submit current value instead of first matching candidate
+  (keymap-set vertico-map "H-<return>" 'vertico-exit-input)
+
+  ;; Add working page up /down
+  (keymap-set vertico-map "<next>" 'vertico-scroll-up)
+  (keymap-set vertico-map "<prior>" 'vertico-scroll-down))

 (use-package orderless :ensure t
-  :custom ((completion-styles '(orderless partial-completion basic)
-                              "Fallback to basic if orderless does not work.")
-           (completion-category-defaults nil)
-           (completion-category-overrides
-            '((file (styles partial-completion))))))
+  :config
+  ;; Fallback to basic if orderless does not work.
+  (setopt completion-styles '(orderless basic))
+  (setopt completion-category-defaults nil)
+  (setopt completion-category-overrides '((file (styles partial-completion)))))

+(use-package marginalia :ensure t :defer t
+  :hook ((elpaca-after-init . marginalia-mode)))

-(use-package marginalia :ensure t
-  :config (marginalia-mode t))
 (use-package consult :ensure t
+  :config
+  ;; Using ripgrep, show hidden files but ignore contents of .git
+  (setopt consult-ripgrep-args
+          "rg --null --line-buffered --color=never --max-columns=1000 \
+--path-separator / --smart-case --no-heading --with-filename --line-number \
+--search-zip --hidden --glob \"!.git/*\"")
  :bind (:map icejam-keys-mode-map
              ("C-c t" . find-file)
-              ("M-g"   . consult-goto-line)
+              ("M-g g" . consult-goto-line)
              ("C-c a" . consult-ripgrep)))
-(use-package helpful :ensure t)
+
+(use-package helpful :ensure t :defer t
+  :bind (([remap describe-key] . helpful-key)
+         ([remap describe-variable] . helpful-variable)
+         ([remap describe-function] . helpful-callable)
+         ([remap describe-command] . helpful-command)))

 (provide 'icejam-completing-read)
 ;;; icejam-completing-read.el ends here
--- a/lisp/icejam-copilot.el
+++ b/lisp/icejam-copilot.el
@ -1,45 +0,0 @@
-;;; icejam-copilot.el --- summary
-
-;; Author: Maciej Szlosarczyk
-;; Maintainer: Maciej Szlosarczyk
-;; Version: 0.1-snapshot
-
-;;; Commentary:
-
-;;; Copilot and other GPT stuff
-
-;;; Code:
-(use-package copilot :ensure (:host github :repo "copilot-emacs/copilot.el" :files ("*.el"))
-  :defer t
-  ;; It sort of sucks so let's disable it.
-  ;; :hook ((prog-mode . copilot-mode))
-  :bind (:map copilot-completion-map
-              ([tab] . copilot-accept-completion))
-  :config
-  (add-to-list 'copilot-indentation-alist '(emacs-lisp-mode . 2)))
-
-;; Enable Anthropic Claude LLM support for chat (it also sucks)
-(defcustom anthropic-api-key "api-key" "The value of your Anthropic API key."
-  :type 'string
-  :group 'icejam
-  :initialize 'custom-initialize-set)
-
-(use-package gptel :ensure t :defer t
-  :config
-  (setq
-   gptel-model 'claude-3-5-sonnet-20241022
-   gptel-backend (gptel-make-anthropic "Claude"
-                   :stream t :key (lambda () anthropic-api-key))))
-
-;; Pretend to be 'AI editor'.
-(use-package elysium :ensure t :defer t
-  :custom
-  ((elysium-window-size 0.33 "The elysium buffer will be 1/3 your screen")
-   (elysium-window-style 'vertical "Elysium buffer will be vertical")))
-
-;; Merging with SMerge
-(use-package smerge-mode :ensure nil
-  :hook ((prog-mode . smerge-mode)))
-
-(provide 'icejam-copilot)
-;;; icejam-copilot.el ends here
--- a/lisp/icejam-custom-init.el
+++ b/lisp/icejam-custom-init.el
@ -12,18 +12,23 @@

 ;; Set GC at 500 MB for startup
 (setopt gc-cons-threshold 500000000)
-(setopt gc-cons-percentage 0.6)
+(setopt gc-cons-percentage 5.0)
+
+(add-hook 'after-init-hook (lambda ()
+                             ;; Restore GC to normal, but still high
+                             (setopt gc-cons-threshold 204800000)
+                             (setopt gc-cons-percentage 0.2)))

 ;; Allow for deeper stacktraces / recursion
 ;; (setopt max-lisp-eval-depth 10000)

 ;;; Use elpaca for package management.
-(defvar elpaca-installer-version 0.7)
+(defvar elpaca-installer-version 0.11)
 (defvar elpaca-directory (expand-file-name "elpaca/" user-emacs-directory))
 (defvar elpaca-builds-directory (expand-file-name "builds/" elpaca-directory))
 (defvar elpaca-repos-directory (expand-file-name "repos/" elpaca-directory))
 (defvar elpaca-order '(elpaca :repo "https://github.com/progfolio/elpaca.git"
-                              :ref nil :depth 1
+                              :ref nil :depth 1 :inherit ignore
                              :files (:defaults "elpaca-test.el" (:exclude "extensions"))
                              :build (:not elpaca--activate-package)))
 (let* ((repo  (expand-file-name "elpaca/" elpaca-repos-directory))
@ -60,83 +65,85 @@
 ;; Use package settings
 (setopt use-package-verbose t)
 (setopt use-package-compute-statistics t)
-(elpaca elpaca-use-package
-  ;; Enable use-package :ensure support for Elpaca.
-  (elpaca-use-package-mode))

-(elpaca-load-lockfile (concat user-emacs-directory "elpaca.lock"))
+;; Enable use-package :ensure support for Elpaca.
+(defvar elpaca-use-package)
+(elpaca elpaca-use-package (elpaca-use-package-mode))
+
+;; (elpaca-load-lockfile (concat user-emacs-directory "elpaca.lock"))
+;; (setopt elpaca-lock-file (concat user-emacs-directory "elpaca.lock"))
+
+(use-package benchmark-init :ensure (:wait t)
+  :config
+  (add-hook 'after-init-hook 'benchmark-init/deactivate))

 (defun icejam-elpaca-write-lock ()
  "Write elpaca lock file."
  (interactive)
-  (elpaca-write-lockfile (concat user-emacs-directory "elpaca.lock")))
+  (elpaca-write-lock-file (concat user-emacs-directory "elpaca.lock")))

 ;; I don't know why this needs to be here and with a lisp directory, but
 ;; normal subdirs.el file doesn't work.
+(add-to-list 'load-path (concat user-emacs-directory "lisp"))
 (add-to-list 'load-path (concat user-emacs-directory "lisp/themes"))
 (add-to-list 'load-path (concat user-emacs-directory "lisp/langs"))

 (defgroup :icejam nil "My customisation group.")

 ;; General configuration files.
-(require 'icejam-keys-mode)
-(require 'icejam-blocking)
-(require 'icejam-base)
-(require 'icejam-sys-specific)
-(require 'icejam-tree-sitter)
-(require 'icejam-completing-read)
-(require 'icejam-avy)
-(require 'icejam-transient)
-(require 'icejam-prog-mode)
-(require 'icejam-company-yasnippet)
-(require 'icejam-copilot)
-(require 'icejam-flycheck)
-(require 'icejam-ispell)
-(require 'icejam-deft)
-(require 'icejam-lsp)
-(require 'icejam-dashboard)
-(require 'icejam-magit)
-(require 'icejam-vundo)
-(require 'icejam-speed-type)
+(use-package icejam-keys-mode :ensure nil)
+(use-package icejam-base :ensure nil)
+(use-package icejam-sys-specific :ensure nil)
+(use-package icejam-tree-sitter :ensure nil)
+(use-package icejam-completing-read :ensure nil)
+(use-package icejam-avy :ensure nil)
+(use-package icejam-transient :ensure nil)
+(use-package icejam-prog-mode :ensure nil)
+(use-package icejam-complete-at-point :ensure nil)
+(use-package icejam-aider :ensure nil)
+(use-package icejam-flycheck :ensure nil)
+(use-package icejam-ispell :ensure nil)
+(use-package icejam-deft :ensure nil)
+(use-package icejam-eglot :ensure nil)
+(use-package icejam-dashboard :ensure nil)
+(use-package icejam-magit :ensure nil)
+(use-package icejam-vundo :ensure nil)
+(use-package icejam-speed-type :ensure nil)

 ;; Themes
-(require 'icejam-themes)
-(require 'icejam-fonts)
+(use-package icejam-themes :ensure nil)
+(use-package icejam-fonts :ensure nil)

 ;; Actual supported languages and file syntax.
-(require 'icejam-lang-clang)
-(require 'icejam-lang-clojure)
-;; (require 'icejam-lang-common-lisp)
-(require 'icejam-lang-dart)
-(require 'icejam-lang-dhall)
-(require 'icejam-lang-elisp)
-(require 'icejam-lang-elixir)
-(require 'icejam-lang-erlang)
-(require 'icejam-lang-fsharp)
-(require 'icejam-lang-gleam)
-(require 'icejam-lang-golang)
-(require 'icejam-lang-haskell)
-(require 'icejam-lang-javascript)
-(require 'icejam-lang-kotlin)
-(require 'icejam-lang-lean)
-(require 'icejam-lang-markdown)
-(require 'icejam-lang-ocaml)
-(require 'icejam-lang-other)
-(require 'icejam-lang-php)
-(require 'icejam-lang-purescript)
-(require 'icejam-lang-python)
-(require 'icejam-lang-ruby)
-(require 'icejam-lang-rust)
-(require 'icejam-lang-sh)
-(require 'icejam-lang-web)
-(require 'icejam-lang-ziglang)
+(use-package icejam-lang-clang :ensure nil)
+(use-package icejam-lang-clojure :ensure nil)
+(use-package icejam-lang-dart :ensure nil)
+(use-package icejam-lang-dhall :ensure nil)
+(use-package icejam-lang-elisp :ensure nil)
+(use-package icejam-lang-elixir :ensure nil)
+(use-package icejam-lang-erlang :ensure nil)
+(use-package icejam-lang-fsharp :ensure nil)
+(use-package icejam-lang-gleam :ensure nil)
+(use-package icejam-lang-golang :ensure nil)
+(use-package icejam-lang-haskell :ensure nil)
+(use-package icejam-lang-javascript :ensure nil)
+(use-package icejam-lang-kotlin :ensure nil)
+;; (use-package icejam-lang-lean :ensure nil)
+(use-package icejam-lang-lua :ensure nil)
+(use-package icejam-lang-markdown :ensure nil)
+(use-package icejam-lang-ocaml :ensure nil)
+(use-package icejam-lang-other :ensure nil)
+(use-package icejam-lang-php :ensure nil)
+(use-package icejam-lang-purescript :ensure nil)
+(use-package icejam-lang-python :ensure nil)
+(use-package icejam-lang-ruby :ensure nil)
+(use-package icejam-lang-rust :ensure nil)
+(use-package icejam-lang-sh :ensure nil)
+(use-package icejam-lang-web :ensure nil)
+(use-package icejam-lang-ziglang :ensure nil)

 ;; Diminish modeline litter
-(require 'icejam-diminish)
-
-;; Restore GC to normal, but still high
-(setopt gc-cons-threshold 200000000)
-(setopt gc-cons-percentage 0.2)
+(use-package icejam-diminish :ensure nil)

 (provide 'icejam-custom-init)
 ;;; icejam-custom-init.el ends here
--- a/lisp/icejam-dashboard.el
+++ b/lisp/icejam-dashboard.el
@ -10,19 +10,20 @@

 ;;; Code:

-(use-package dashboard :ensure t :demand t
+(use-package dashboard :ensure t :defer t
  :commands dashboard-setup-startup-hook
-  :hook
-  ((elpaca-after-init . dashboard-open))
-  :custom
-  ((dashboard-footer-messages '("Happy coding!" "I showed you my source code, pls respond"))
-   (dashboard-startup-banner 'logo)
-   (dashboard-items '((recents  . 5)
+  :hook ((elpaca-after-init . dashboard-open))
+  :config
+  ;; setopt gives a warning here, so let's use setq
+  (setq dashboard-footer-messages '("Happy coding!"
+                                    "I showed you my source code, pls respond"))
+  (setopt dashboard-startup-banner 'logo)
+  (setopt dashboard-items '((recents  . 5)
                            ;; (bookmarks . 5)
                            ;; (agenda . 5)
                            ;; (registers . 5)
-                      (projects . 5))))
-  :config (dashboard-setup-startup-hook))
+                            (projects . 5)))
+  (dashboard-setup-startup-hook))

 (provide 'icejam-dashboard)
 ;;; icejam-dashboard.el ends here
--- a/lisp/icejam-deft.el
+++ b/lisp/icejam-deft.el
@ -3,15 +3,12 @@
 ;;; Notational velocity, backed by OneDrive.
 ;;; Code:

-(require 'icejam-keys-mode)
-(require 'icejam-transient)
-
-(use-package deft :ensure t
-  :custom
-  ((deft-directory (substitute-in-file-name "$DEFT_PATH"))
-   (deft-default-extension "md")
-   (deft-ignore-file-regexp "\\._[0-9-A-Z_]+\\.md$")
-   (deft-strip-summary-regexp (concat "\\("
+(use-package deft :ensure t :defer t
+  :config
+  (setopt deft-directory (substitute-in-file-name "$DEFT_PATH")
+          deft-default-extension "md"
+          deft-ignore-file-regexp "\\._[0-9-A-Z_]+\\.md$"
+          deft-strip-summary-regexp (concat "\\("
                                          "[\n\t]" ;; blank
                                          "\\|^:[[:ascii:]]+:.*$" ;; org-mode properties string
                                          "\\|^Title:.*$" ;; Title string
@ -19,8 +16,8 @@
                                          "\\|^\\[\\[file:.*$" ;; org-mode inline-images
                                          ;; org-mode properties
                                          ;; "\\|:PROPERTIES:\n\\(.+\n\\)+:END:\n" ;;
-                                      "\\)"))
-   (deft-auto-save-interval 30.0)))
+                                          "\\)")
+          deft-auto-save-interval 30.0))

 (provide 'icejam-deft)
 ;;; icejam-deft.el ends here
--- a/lisp/icejam-diminish.el
+++ b/lisp/icejam-diminish.el
@ -6,27 +6,30 @@

 ;;; Commentary:

-;; diminish minor modes
+;; diminish minor modes to remove modeline litter.

 ;;; Code:
-(require 'icejam-blocking)
-;; (use-package diminish :ensure t)
+(use-package diminish :ensure t :defer t :commands (diminish))

-(with-eval-after-load 'diminish
-  (with-eval-after-load 'flyspell (diminish 'flyspell-mode))
-  (with-eval-after-load 'flycheck (diminish 'flycheck-mode))
-  (with-eval-after-load 'rainbow-mode (diminish 'rainbow-mode))
-  (with-eval-after-load 'undo-tree (diminish 'undo-tree-mode))
-  (with-eval-after-load 'company (diminish 'company-mode))
-  (with-eval-after-load 'which-key (diminish 'which-key-mode))
-  (with-eval-after-load 'eldoc (diminish 'eldoc-mode))
-  (with-eval-after-load 'yasnippet (diminish 'yas-minor-mode))
-  (with-eval-after-load 'whitespace (diminish 'whitespace-mode))
-  (with-eval-after-load 'autorevert (diminish 'auto-revert-mode))
-  (with-eval-after-load 'ivy (diminish 'ivy-mode))
-  (with-eval-after-load 'company-box (diminish 'company-box-mode))
-  (with-eval-after-load 'smerge-mode (diminish 'smerge-mode))
-  (with-eval-after-load 'gcmh (diminish 'gcmh-mode)))
+(defun icejam-diminish-modes ()
+  "Diminish selected modes."
+  (dolist (package-and-mode '((flyspell flyspell-mode)
+                              (flycheck flycheck-mode)
+                              (rainbow-mode rainbow-mode)
+                              (undo-tree undo-tree-mode)
+                              (which-key which-key-mode)
+                              (eldoc eldoc-mode)
+                              (yasnippet yas-minor-mode)
+                              (whitespace whitespace-mode)
+                              (autorevert auto-revert-mode)
+                              (ivy ivy-mode)
+                              (smerge-mode smerge-mode)
+                              (gcmh gcmh-mode)))
+    (let ((package (car package-and-mode))
+          (mode (car (last package-and-mode))))
+      (with-eval-after-load package (diminish mode)))))
+
+(add-hook 'elpaca-after-init-hook 'icejam-diminish-modes)

 (provide 'icejam-diminish)
 ;;; icejam-diminish.el ends here
--- a/lisp/icejam-eglot.el
+++ b/lisp/icejam-eglot.el
@ -0,0 +1,16 @@
+;;; icejam-eglot -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Global Language Server Protocol Config
+;;; Code:
+
+(use-package eldoc-box :ensure t
+  :hook ((emacs-lisp-mode . eldoc-box-hover-at-point-mode)
+         (eglot--managed-mode . eldoc-box-hover-at-point-mode))
+  :custom-face
+  (eldoc-box-markdown-separator ((t (:inherit (fringe))))))
+
+;; Add debugger support to emacs.
+(use-package dape :ensure t)
+
+(provide 'icejam-eglot)
+;;; icejam-eglot.el ends here
--- a/lisp/icejam-flycheck.el
+++ b/lisp/icejam-flycheck.el
@ -2,28 +2,67 @@
 ;;; Commentary:
 ;;; Code:

-;; Use flycheck globally to check syntax and compile languages
-(use-package flycheck :ensure t
-  :custom ((flycheck-emacs-lisp-load-path 'inherit))
+;; Use flycheck checks with flymake.
+(use-package flymake-flycheck :ensure t :defer t :config
+(setq-default
+     flycheck-disabled-checkers
+     (append (default-value 'flycheck-disabled-checkers)
+             '(emacs-lisp emacs-lisp-checkdoc
+                          emacs-lisp-package sh-shellcheck))))
+
+(declare-function flymake--project-diagnostics-buffer 'flymake)
+(declare-function flymake--diagnostics-buffer-name 'flymake)
+(declare-function flymake-project-diagnostics-mode 'flymake)
+(declare-function flymake-diagnostics-buffer-mode 'flymake)
+
+(use-package el-patch :ensure t :defer t
  :config
-  (global-flycheck-mode t)
-  (setopt flycheck-emacs-lisp-load-path 'inherit)
-  (unbind-key "C-c ! C-c" flycheck-mode-map)
-  (unbind-key "C-c ! C-w" flycheck-mode-map)
-  (unbind-key "C-c ! ?" flycheck-mode-map)
-  (unbind-key "C-c ! C" flycheck-mode-map)
-  (unbind-key "C-c ! H" flycheck-mode-map)
-  (unbind-key "C-c ! V" flycheck-mode-map)
-  (unbind-key "C-c ! c" flycheck-mode-map)
-  (unbind-key "C-c ! e" flycheck-mode-map)
-  (unbind-key "C-c ! h" flycheck-mode-map)
-  (unbind-key "C-c ! i" flycheck-mode-map)
-  (unbind-key "C-c ! l" flycheck-mode-map)
-  (unbind-key "C-c ! n" flycheck-mode-map)
-  (unbind-key "C-c ! p" flycheck-mode-map)
-  (unbind-key "C-c ! s" flycheck-mode-map)
-  (unbind-key "C-c ! v" flycheck-mode-map)
-  (unbind-key "C-c ! x" flycheck-mode-map))
+  ;; Show the diagnostics from flymake in a second window (usually on the
+  ;; opposite side from this one) instead of at the bottom of the current one.
+  ;; Essentially revert the interesting part of this commit:
+  ;; https://github.com/emacs-mirror/emacs/commit/419550c7907275bf962986e1cc8fba1989d8659c
+  (el-patch-feature 'flymake)
+  (with-eval-after-load 'flymake
+    (el-patch-defun flymake-show-project-diagnostics ()
+      "Show a list of Flymake diagnostics for the current project."
+      (interactive)
+      (let* ((prj (project-current))
+             (root (project-root prj))
+             (buffer (flymake--project-diagnostics-buffer root)))
+        (with-current-buffer buffer
+          (flymake-project-diagnostics-mode)
+          (setq-local flymake--project-diagnostic-list-project prj)
+          (display-buffer (current-buffer))
+          (revert-buffer))))
+
+    (el-patch-defun flymake-show-buffer-diagnostics ()
+      "Show a list of Flymake diagnostics for current buffer."
+      (interactive)
+      (unless flymake-mode
+        (user-error "Flymake mode is not enabled in the current buffer"))
+      (let* ((name (flymake--diagnostics-buffer-name))
+             (source (current-buffer))
+             (target (or (get-buffer name)
+                         (with-current-buffer (get-buffer-create name)
+                           (flymake-diagnostics-buffer-mode)
+                           (current-buffer)))))
+        (with-current-buffer target
+          (setq flymake--diagnostics-buffer-source source)
+          (display-buffer (current-buffer))
+          (revert-buffer))))))
+
+;; Use flymake, the built in linter/checker.
+(use-package flymake :ensure nil
+  :defer t
+  :config
+  ;; Show 'Fly' in mode line.
+  (setopt flymake-mode-line-lighter "Fly")
+  ;; Use the same load-path as normal configuration. This makes the errors that
+  ;; appear in elisp files less jarring.
+  (setopt elisp-flymake-byte-compile-load-path load-path)
+  :hook ((prog-mode . flymake-mode)
+         (text-mode . flymake-mode)
+         (flymake-mode . flymake-flycheck-auto)))

 (provide 'icejam-flycheck)
 ;;; icejam-flycheck.el ends here
--- a/lisp/icejam-fonts.el
+++ b/lisp/icejam-fonts.el
@ -3,13 +3,11 @@
 ;; Author: Maciej Szlosarczyk
 ;; Maintainer: Maciej Szlosarczyk
 ;; Version: 0.1-snapshot
-
 ;;; Commentary:

 ;; Set font stuff

 ;;; Code:
-
 ;; (defconst icejam-font "Monoid"
 ;; (defconst icejam-font "Fira Mono"
 ;; (defconst icejam-font "Fira Code"
@ -18,29 +16,47 @@
 ;; (defconst icejam-font "Input Mono Condensed"
 ;; (defconst icejam-font "SF Mono"
 ;; (defconst icejam-font "Monaco"
-;; (defconst icejam-font "JetBrains Mono"
+;; (defconst icejam-font "JetBrains Mono" "Default font.")
 ;; (defconst icejam-font "JuliaMono"
 ;; (defconst icejam-font "Rec Mono Semicasual"
-;; (defconst icejam-font "Victor Mono"
 ;; (defconst icejam-font "IBM Plex Mono"
 ;; (defconst icejam-font "Berkeley Mono Trial"
 ;; (defconst icejam-font "Inconsolata"
+;; (defconst icejam-font "Victor Mono Medium" "Default font.")
+;; (defconst icejam-font "Iosevka Term" "Default font.")

-(defconst icejam-font "Iosevka Term"
-  "Default font.")
-(defconst icejam-font-size 14
-  "Default size of then font.
-It is used to calculated the size in relation to the screen
-in icejam-set-font-to-screen.")
+(defconst icejam-default-font-family "Iosevka Term" "Default font.")
+(defconst icejam-variable-font-family "Lexica Ultralegible" "Variable pitch font.")
+(defconst icejam-markdown-font-family "Iosevka Comfy Motion"
+  "Font used to render code blocks in markdown.
+It is different than default font to keep it visually distinct.")

-(defcustom icejam-mut-font
-  icejam-font
+;; Require dash functions to be included:
+(declare-function -> "dash.el")
+
+(defconst icejam-font-height 14
+  "Default height of then font.
+It is used to calculated the height in relation to the screen
+in `icejam-set-font-to-screen`.")
+
+(defcustom icejam-mut-default-font-family
+  icejam-default-font-family
  "Current font, defaults to the one loaded in the beginning."
  :type 'string
  :group 'icejam)
-(defcustom icejam-mut-font-size
-  icejam-font-size
-  "Current font size."
+(defcustom icejam-mut-variable-font-family
+  icejam-default-font-family
+  "Current variable-pitch font.  Defaults to `icejam-variable-font-family`."
+  :type 'string
+  :group 'icejam)
+(defcustom icejam-mut-markdown-font-family
+  icejam-markdown-font-family
+  "Current markdown font family, defaults to the one loaded in the beginning."
+  :type 'string
+  :group 'icejam)
+(defcustom icejam-mut-font-height
+  icejam-font-height
+  "Current font height."
  :type 'integer
  :group 'icejam)

@ -49,94 +65,89 @@ in icejam-set-font-to-screen.")
 (defvar lsp-ui-doc-frame-hook)

 (defun icejam-set-lsp-ui-font-hook ()
-  "Reset LSP IO font to specified icejam-font and icejam-font-size."
+  "Reset LSP IO font to specified `icejam-font` and `icejam-font-height`."
  (setopt lsp-ui-doc-frame-hook nil)
  (add-hook 'lsp-ui-doc-frame-hook
            (lambda (frame _w)
-              (set-face-attribute
-               'default frame :font
-               (format "%s %d" icejam-mut-font (- icejam-mut-font-size 2))))))
+              (set-face-attribute 'default frame
+                                  :family icejam-mut-default-font-family
+                                  :height (-> icejam-mut-font-height
+                                              (- 2)
+                                              (* 10))))))

-(defun icejam-set-font (name size)
-  "Set font to NAME and its SIZE to X pixels."
-  (interactive "sNew font: \nnEnter size for %s: ")
-  (setopt icejam-mut-font name)
-  (setopt icejam-mut-font-size size)
+(defun icejam-set-font (family height)
+  "Set font to FAMILY and its HEIGHT to X.

-  (set-face-attribute 'default nil :font (format "%s %d" name size))
+Not all faces will be set to this value.  Some of them look better with being
+slightly smaller than the default face, by 1 point.  Those are: `tooltip'.

-  ;; Set completion and modeline font to be 1 pixel point smaller than
-  ;; the general font
-  ;; (set-face-attribute
-  ;;  'markdown-code-face nil :font (format "%s %d" name (- size 1)))
-  (set-face-attribute
-   'tooltip nil :font (format "%s %d" name (- size 1)))
-  (set-face-attribute
-   'company-tooltip nil :font (format "%s %d" name (- size 1)))
-  (set-face-attribute
-   'company-tooltip-annotation nil :font (format "%s %d" name (- size 1)))
-  (set-face-attribute
-   'company-tooltip-mouse nil :font (format "%s %d" name (- size 1)))
-  (set-face-attribute
-   'mode-line nil :font (format "%s %d" name (- size 1)))
-  (set-face-attribute
-   'mode-line-inactive nil :font (format "%s %d" name (- size 1)))
+Modeline faces (`mode-line' and `mode-line-inactive') look better if they are
+two points smaller."
+  (interactive "sNew font: \nnEnter height for %s: ")
+  (setopt icejam-mut-default-font-family family)
+  (setopt icejam-mut-font-height height)
+  (setopt icejam-mut-variable-font-family icejam-variable-font-family)
+
+  ;; Set default font.
+  (set-face-attribute 'default nil
+                      :family family
+                      :height (-> height
+                                  (* 10)))
+
+  ;; Set variable-pitch font
+  (set-face-attribute 'variable-pitch nil
+                      :family icejam-mut-variable-font-family
+                      :height (-> height
+                                  (* 10)))
+
+  ;; Some font faces look better when they are 1 point smaller.
+  (dolist (face '(tooltip))
+    (set-face-attribute face nil :height (-> height
+                                             (- 1)
+                                             (* 10))))
+
+  ;; And some, mainly in modeline with 2 points.
+  (dolist (face '(mode-line
+                  mode-line-inactive))
+    (set-face-attribute face nil :height (-> height
+                                             (- 2)
+                                             (* 10))))

  ;; Call LSP-UI hook
  (icejam-set-lsp-ui-font-hook))

 (defun icejam-set-font-to-screen ()
-  "Automatically set font size to suit the monitor."
-  ;; If display is set to emulate FullHD resultion or less, make the font
-  ;; smaller.
+  "Automatically set font height to suit the monitor."
  (interactive)
-  (cond ((eq (x-display-list) nil))
-        ;; built-in screen
-        ((>= 1050 (x-display-pixel-height))
-         (icejam-set-font icejam-font icejam-font-size))

-        ;; 4K screen on a Mac
-        ((>= 1080 (x-display-pixel-height))
-         (icejam-set-font icejam-font icejam-font-size))
+  ;; Only do anything if there's a display at all.
+  (if (x-display-list)
+      (let ((pixel-height (x-display-pixel-height)))
+        (cond
+         ;; MacBook 14" built-in screen.
+         ((>= 1080 pixel-height)
+          (icejam-set-font icejam-default-font-family icejam-font-height))

-        ;; Other screens
-        ((>= 1120 (x-display-pixel-height))
-         (icejam-set-font icejam-font icejam-font-size))
-
-        ((>= 1440 (x-display-pixel-height))
-         (icejam-set-font icejam-font (+ icejam-font-size 3)))
-
-        ((>= 1920 (x-display-pixel-height))
-         (icejam-set-font icejam-font icejam-font-size))
+         ;; 27" screen connected to a MacBook.
+         ((>= 1440 pixel-height)
+          (icejam-set-font icejam-default-font-family (+ icejam-font-height 3)))

         ;; 4K screen on Windows or Linux
-        ((>= 2160 (x-display-pixel-height))
-         (icejam-set-font icejam-font (- icejam-font-size 3)))
+         ((>= 2160 pixel-height)
+          (icejam-set-font icejam-default-font-family (- icejam-font-height 3)))))))

-        ;; Default
-        (t (icejam-set-font icejam-font (- icejam-font-size 3)))))
+;; Run the above function once, after elpaca finishes all downloads.
+(add-hook 'elpaca-after-init-hook 'icejam-set-font-to-screen)

-;; Do it automatically on startup
-(icejam-set-font-to-screen)
+(defun icejam-set-font-height (height)
+  "Set font to a specified HEIGHT."
+  (interactive "nEnter height for font: ")
+  (icejam-set-font icejam-mut-default-font-family height))

-(defun icejam-set-font-size (size)
-  "Set font to a specified SIZE."
-  (interactive "nEnter size for font: ")
-  (icejam-set-font icejam-mut-font size))
-
-(defun icejam-set-font-size-for-this-frame (new-size)
-  "Set font NEW-SIZE for this frame only."
-  (interactive "nEnter new size for font in this frame: ")
-  (set-frame-font (format "%s %d" icejam-mut-font new-size)))
-
-;; Remove ugly black line
-(set-face-attribute 'vertical-border nil :foreground
-                    (face-attribute 'fringe :background))
-
-;; Set fringe colors to default, so it does not bother you.
-(set-face-attribute 'fringe nil
-                    :foreground (face-foreground 'default)
-                    :background (face-background 'default))
+(defun icejam-set-font-height-for-this-frame (new-height)
+  "Set font NEW-HEIGHT for this frame only."
+  (interactive "nEnter new height for font in this frame: ")
+  (set-frame-font (format "%s %d" icejam-mut-default-font-family new-height)))

 (provide 'icejam-fonts)
 ;;; icejam-fonts.el ends here
--- a/lisp/icejam-ispell.el
+++ b/lisp/icejam-ispell.el
@ -3,12 +3,10 @@
 ;;; Highlight misspelled words
 ;;; Code:

-
-
-(use-package ispell :ensure nil
-  :custom
-  ((ispell-program-name "aspell")
-   (ispell-extra-args '("--run-together" "--run-together-limit=5" "--run-together-min=2"))))
+(use-package ispell :ensure nil :defer t
+  :config
+  (setopt ispell-program-name "aspell")
+  (setopt ispell-extra-args '("--run-together" "--run-together-limit=5" "--run-together-min=2")))

 (use-package flyspell :ensure nil
  :hook ((prog-mode . flyspell-mode)
--- a/lisp/icejam-keys-mode.el
+++ b/lisp/icejam-keys-mode.el
@ -19,43 +19,47 @@
 ;; Globally enable my minor mode
 (icejam-keys-mode)

-;;; Helpful key bindings
-(define-key icejam-keys-mode-map (kbd "C-c \\") 'split-window-right) ;; Split window to the right
-(define-key icejam-keys-mode-map (kbd "C-c /") 'split-window-below) ;; Split window to the bottom
-
-;; Move between windows key bindings
-(define-key icejam-keys-mode-map (kbd "C-c <left>") 'windmove-left)
-(define-key icejam-keys-mode-map (kbd "C-c <right>") 'windmove-right)
-(define-key icejam-keys-mode-map (kbd "C-c <up>") 'windmove-up)
-(define-key icejam-keys-mode-map (kbd "C-c <down>") 'windmove-down)
-
-;; The same, but without using arrow keys
-(define-key icejam-keys-mode-map (kbd "C-c [") 'windmove-left)
-(define-key icejam-keys-mode-map (kbd "C-c ]") 'windmove-right)
-(define-key icejam-keys-mode-map (kbd "C-c {") 'windmove-up)
-(define-key icejam-keys-mode-map (kbd "C-c }") 'windmove-down)
-
-;; Kill current buffer and window
-(define-key icejam-keys-mode-map (kbd "C-c q") 'kill-buffer-and-window)
-
-;; List buffers
-(define-key icejam-keys-mode-map (kbd "C-c b") 'ibuffer)
-
-;; Revert without asking
 (defun icejam-revert-buffer-no-confirm ()
  "Revert buffer without confirmation."
  (interactive) (revert-buffer t t))

-(define-key icejam-keys-mode-map (kbd "C-c r") 'icejam-revert-buffer-no-confirm)
+;; Splitting window
+(keymap-set icejam-keys-mode-map "C-c \\" #'split-window-right)
+(keymap-set icejam-keys-mode-map "C-c /" #'split-window-below)
+(keymap-set icejam-keys-mode-map "C-c \"" #'split-window-right)
+(keymap-set icejam-keys-mode-map "C-c %" #'split-window-below)
+(keymap-set icejam-keys-mode-map "C-c '" #'split-window-right)
+(keymap-set icejam-keys-mode-map "C-c 5" #'split-window-below)

-;;;;;;;;; Emacs bindings ;;;;;;;;;;;;;;;;;;;;;
-(define-key icejam-keys-mode-map [home] 'beginning-of-line)
-(define-key icejam-keys-mode-map [end] 'end-of-line)
+;; Move between windows
+(keymap-set icejam-keys-mode-map "C-c <left>" #'windmove-left)
+(keymap-set icejam-keys-mode-map "C-c <right>" #'windmove-right)
+(keymap-set icejam-keys-mode-map "C-c <up>" #'windmove-up)
+(keymap-set icejam-keys-mode-map "C-c <down>" #'windmove-down)
+
+;; History of buffers
+(keymap-set icejam-keys-mode-map "C-c s [" #'previous-buffer)
+(keymap-set icejam-keys-mode-map "C-c s ]" #'next-buffer)
+
+;; These are slightly more conveniently located on an Ergodox/Moonlander
+(keymap-set icejam-keys-mode-map "C-c s <left>" #'previous-buffer)
+(keymap-set icejam-keys-mode-map "C-c s <right>" #'next-buffer)
+
+;; List of buffers buffer
+(keymap-set icejam-keys-mode-map "C-c b" #'ibuffer)
+
+;; Manipulate buffers (kill or revert)
+(keymap-set icejam-keys-mode-map "C-c q" #'kill-buffer-and-window)
+(keymap-set icejam-keys-mode-map "C-c r" #'icejam-revert-buffer-no-confirm)
+
+;; Make emacs behave like a normal editor from 21st century.
+(keymap-set icejam-keys-mode-map "<home>" #'beginning-of-line)
+(keymap-set icejam-keys-mode-map "<end>" #'end-of-line)

 ;;;;;;;;; Translate keys ;;;;;;;;;;;;;;;;;;;;;
-(define-key key-translation-map (kbd "<f6>") (kbd "C-c l")) ;; On F6, send C-c l
-(define-key key-translation-map (kbd "<f7>") (kbd "C-c c")) ;; On F7, send C-c c
-(define-key key-translation-map (kbd "<f8>") (kbd "C-c p")) ;; On F8, send C-c p
+(keymap-set key-translation-map "<f6>" "C-c l") ;; On F6, send C-c l
+(keymap-set key-translation-map "<f7>" "C-c c") ;; On F7, send C-c c
+(keymap-set key-translation-map "<f8>" "C-c p") ;; On F8, send C-c p

 (provide 'icejam-keys-mode)
 ;;; icejam-keys-mode.el ends here
--- a/lisp/icejam-lsp.el
+++ b/lisp/icejam-lsp.el
@ -1,76 +0,0 @@
-;;; icejam-lsp -- summary -*- lexical-binding: t; -*-
-;;; Commentary:
-;;; Global Language Server Protocol Config
-;;; Code:
-
-;; (use-package lsp-mode :ensure (:depth 5) :requires (company))
-(with-eval-after-load 'lsp-mode
-  (setq-default lsp-file-watch-threshold 10000
-                lsp-restart 'auto-restart
-                lsp-prefer-capf t
-                lsp-completion-provider :capf
-                lsp-server-trace nil
-                lsp-lens-enable nil
-                lsp-lens-mode nil
-                read-process-output-max (* 1024 1024 4)
-                ;; Disable the piece of shit vue LSP server. It activates itself in every
-                ;; project with .js, .ts or .json file due to something called 'takeover
-                ;; mode' or 'hybrid mode' or some such.
-                ;; It would be okay, but it also doesn't work 99% of the time.
-
-                ;; When needed, enable this hot garbage in dir-locals.el
-                lsp-disabled-clients '(vue-semantic-server
-                                       ;; Ruby LSP servers, none of which actually work.
-                                       ruby-ls rubocop-ls typeprof-ls)
-                lsp-log-io nil
-                lsp-enable-file-watchers nil)
-  (unbind-key "s-l =" lsp-mode-map)
-  (unbind-key "s-l G" lsp-mode-map)
-  (unbind-key "s-l T" lsp-mode-map)
-  (unbind-key "s-l a" lsp-mode-map)
-  (unbind-key "s-l g" lsp-mode-map)
-  (unbind-key "s-l r" lsp-mode-map)
-  (unbind-key "C-S-SPC" lsp-mode-map)
-  (unbind-key "s-l G g" lsp-mode-map)
-  (unbind-key "s-l G r" lsp-mode-map)
-  (unbind-key "s-l G s" lsp-mode-map)
-  (unbind-key "s-l h g" lsp-mode-map)
-  (unbind-key "s-l h h" lsp-mode-map)
-  (unbind-key "s-l h s" lsp-mode-map)
-  (unbind-key "s-l g a" lsp-mode-map)
-  (unbind-key "s-l g e" lsp-mode-map)
-  (unbind-key "s-l g g" lsp-mode-map)
-  (unbind-key "s-l g h" lsp-mode-map)
-  (unbind-key "s-l g r" lsp-mode-map)
-  (unbind-key "s-l T D" lsp-mode-map)
-  (unbind-key "s-l T L" lsp-mode-map)
-  (unbind-key "s-l T S" lsp-mode-map)
-  (unbind-key "s-l T T" lsp-mode-map)
-  (unbind-key "s-l T b" lsp-mode-map)
-  (unbind-key "s-l T d" lsp-mode-map)
-  (unbind-key "s-l T f" lsp-mode-map)
-  (unbind-key "s-l T l" lsp-mode-map)
-  (unbind-key "s-l T s" lsp-mode-map)
-  (unbind-key "s-l F a" lsp-mode-map)
-  (unbind-key "s-l F b" lsp-mode-map)
-  (unbind-key "s-l F r" lsp-mode-map)
-  (unbind-key "s-l = =" lsp-mode-map)
-  (unbind-key "s-l s D" lsp-mode-map)
-  (unbind-key "s-l s d" lsp-mode-map)
-  (unbind-key "s-l s q" lsp-mode-map)
-  (unbind-key "s-l s r" lsp-mode-map)
-  (unbind-key "s-l s s" lsp-mode-map))
-
-(use-package lsp-ui :ensure t :after (lsp-mode))
-(with-eval-after-load 'lsp-ui
-  (setq lsp-ui-doc-enable t
-        lsp-ui-header t
-        lsp-ui-delay 0.5 ;; Wait half a second to display documentation
-        lsp-ui-doc-position 'at-point
-        lsp-ui-doc-include-signature t))
-
-;; Lsp debugger mode
-(use-package dap-mode :ensure t :after (lsp-mode lsp-ui))
-
-(provide 'icejam-lsp)
-;;; icejam-lsp.el ends here
--- a/lisp/icejam-magit.el
+++ b/lisp/icejam-magit.el
@ -2,10 +2,11 @@
 ;;; Commentary:
 ;;; Code:

-(require 'icejam-keys-mode)
+(eval-when-compile (defvar icejam-keys-mode-map))

 (use-package magit
  :ensure t
+  :commands (magit-blame-quit)
  :defer t
  :bind (:map icejam-keys-mode-map
              ("<f5> c" . magit-checkout)
--- a/lisp/icejam-prog-mode.el
+++ b/lisp/icejam-prog-mode.el
@ -12,44 +12,42 @@
 (global-eldoc-mode t)

 ;; Revert tag tables without asking
-(use-package etags :ensure nil
-  :custom (tags-revert-without-query t "Revert tag tables without asking"))
+(use-package etags :ensure nil :defer t
+  :config
+  (setopt tags-revert-without-query t))

 ;;; Show trailing whitespace and remove whitespace on save
 (use-package whitespace :ensure nil
-  :custom ((whitespace-style #'(face trailing empty) "New whitespace style.")
-           (require-final-newline 't "Insert newline on save"))
  :hook ((prog-mode . whitespace-mode)
         (text-mode . whitespace-mode)
         (conf-mode . whitespace-mode)
-         (before-save . whitespace-cleanup)))
+         (before-save . whitespace-cleanup))
+  :config
+  (setopt whitespace-style #'(face trailing empty) ;; New whitespace style
+          require-final-newline 't ;; Insert newline on save
+          ))

 (setq-default indent-tabs-mode nil)

 ;; Use colorful, matching parens
 ;; Rework the code below to enumerate each hook separately:
-(use-package rainbow-delimiters :ensure t
+(use-package rainbow-delimiters :ensure t :defer t
  :hook ((prog-mode . rainbow-delimiters-mode)
-         (text-mode . rainbow-delimiters-mode))
-  :config
-  (electric-pair-mode t)
-  (show-paren-mode t))
+         (text-mode . rainbow-delimiters-mode)
+         (elpaca-after-init . electric-pair-mode)
+         (elpaca-after-init . show-paren-mode)))

 ;;; Show hex (#aaa) colors as colors
-(use-package rainbow-mode :ensure t
+(use-package rainbow-mode :ensure t :defer t
  :hook ((prog-mode . rainbow-mode)
         (text-mode . rainbow-mode)))

 ;; Dash integration
-(use-package dash-at-point :ensure t)
-(with-eval-after-load 'dash-at-point
+(use-package dash-at-point :ensure t :defer t
+  :config
  (add-to-list 'dash-at-point-mode-alist '(enh-ruby-mode  . "ruby,rubygems,rails"))
  (add-to-list 'dash-at-point-mode-alist '(elixir-ts-mode . "elixir,hex")))

-;; By default, use 2 spaces for indentation
-(setopt tab-width 2)
-(setopt tab-stop-list (number-sequence tab-width 200 tab-width))
-
 ;; Ensure indentation in steps:
 (defun icejam-set-indent (step)
  "Set indentation to STEP."
@ -57,17 +55,25 @@
  (setq-local tab-width step)
  (setq-local tab-stop-list (number-sequence step 200 step)))

-(use-package column-enforce-mode :ensure t
-  :config
-  (declare-function global-column-enforce-mode "column-enforce-mode")
-  (global-column-enforce-mode t))
+;; By default, use 2 spaces for indentation
+(icejam-set-indent 2)
+
+(use-package column-enforce-mode :ensure t :defer t
+  :hook (elpaca-after-init . global-column-enforce-mode))

 ;; PCRE to Emacs regex translations
-(use-package pcre2el :ensure t)
+(use-package pcre2el :ensure t :defer 5)

 ;; Visual regexp
-(use-package visual-regexp-steroids :ensure t :requires (pcre2el)
-  :custom (vr/engine 'pcre2el "Use pcre2el for regexes"))
+(use-package visual-regexp-steroids :ensure t
+  :after (pcre2el)
+  :config
+  ;; Use pcre2el for regexes - so that I can use brackets more naturally with
+  ;; regexp.
+  (setopt vr/engine 'pcre2el))
+
+;; Format all programming languages with the same package
+(use-package apheleia :ensure t :defer t)

 (provide 'icejam-prog-mode)
 ;;; icejam-prog-mode.el ends here
--- a/lisp/icejam-sys-specific.el
+++ b/lisp/icejam-sys-specific.el
@ -4,16 +4,15 @@
 ;;; Code:

 (defconst IS-MAC (eq system-type 'darwin))
-(defconst IS-BSD (eq system-type 'berkeley-unix))
 (defconst IS-GNU (eq system-type 'gnu/linux))

-(require 'icejam-keys-mode)
+(eval-when-compile (defvar icejam-keys-mode-map))

 (defun icejam-function-delete-window ()
  "Kill a window."
  (interactive) (delete-window))

-;;;;;;;;; Mac-specific config ;;;;;;;;;;;;;;;;;;;;;
+;; Mac-specific config
 (if IS-MAC
    (progn
      (setq mac-option-modifier 'meta)
@ -30,30 +29,30 @@
            (setq mac-option-modifier nil)
            (setq mac-command-modifier 'meta))))

-      ;;;;;;;;; Mac binding (fix) ;;;;;;;;;;;;;;;;;;
-      (define-key icejam-keys-mode-map (kbd "H-<right>") #'end-of-line)
-      (define-key icejam-keys-mode-map (kbd "H-<left>") #'beginning-of-line)
-      (define-key icejam-keys-mode-map (kbd "H-<up>") #'scroll-down) ; WTF is this reverse, I dunno
-      (define-key icejam-keys-mode-map (kbd "H-<down>") #'scroll-up)
+      ;; Mac binding (fix)
+      (keymap-set icejam-keys-mode-map "H-<right>" #'end-of-line)
+      (keymap-set icejam-keys-mode-map "H-<left>" #'beginning-of-line)
+      (keymap-set icejam-keys-mode-map "H-<up>" #'scroll-down) ; WTF is this reverse, I dunno
+      (keymap-set icejam-keys-mode-map "H-<down>" #'scroll-up)

      ;; Use CMD bindings that you know from the operating system
-      (define-key icejam-keys-mode-map [(hyper a)] #'mark-whole-buffer) ;; Select all
-      (define-key icejam-keys-mode-map [(hyper v)] #'yank) ;; Paste
-      (define-key icejam-keys-mode-map [(hyper x)] #'kill-region) ;; Cut
-      (define-key icejam-keys-mode-map [(hyper c)] #'kill-ring-save) ;; Copy
-      (define-key icejam-keys-mode-map [(hyper s)] #'save-buffer) ;; Save
-      (define-key icejam-keys-mode-map [(hyper z)] #'undo) ;; Undo
-      (define-key icejam-keys-mode-map [(hyper q)] #'kill-emacs) ;; Close emacs
-      (define-key icejam-keys-mode-map [(hyper w)] #'icejam-function-delete-window) ;; Close window
+      (keymap-set icejam-keys-mode-map "H-a" #'mark-whole-buffer) ;; Select all
+      (keymap-set icejam-keys-mode-map "H-v" #'yank) ;; Paste
+      (keymap-set icejam-keys-mode-map "H-x" #'kill-region) ;; Cut
+      (keymap-set icejam-keys-mode-map "H-c" #'kill-ring-save) ;; Copy
+      (keymap-set icejam-keys-mode-map "H-s" #'save-buffer) ;; Save
+      (keymap-set icejam-keys-mode-map "H-z" #'undo) ;; Undo
+      (keymap-set icejam-keys-mode-map "H-Z" #'undo-redo) ;; Redo
+      (keymap-set icejam-keys-mode-map "H-q" #'kill-emacs) ;; Close emacs
+      (keymap-set icejam-keys-mode-map "H-w" #'icejam-function-delete-window) ;; Close window

      ;; And then some extras
-      (define-key icejam-keys-mode-map [(hyper l)] #'goto-line) ;; Goto Line
+      (keymap-set icejam-keys-mode-map "H-l" #'goto-line) ;; Goto Line
      ;; Disable meta on right alt (useful for Polish characters)
      ;; (setq mac-right-option-modifier nil)

      ;; Allow for fullscreen frames without gaps
-      (setq frame-resize-pixelwise t)
-      ))
+      (setq frame-resize-pixelwise t)))

 (defun icejam-switch-right-left-alt ()
  "Set keyboard to das keyboard."
@ -66,42 +65,25 @@
      (setq mac-option-modifier 'meta)
      (setq mac-right-option-modifier nil))))

-;;;;;;;;; Linux-specific config ;;;;;;;;;;;;;;;;;;;;;
+;; Linux-specific config
 (if IS-GNU
    (progn
-      ;;;; Save and undo
-      (define-key icejam-keys-mode-map (kbd "s-s") 'save-buffer)
-      (define-key icejam-keys-mode-map (kbd "s-z") 'undo)
-      (define-key icejam-keys-mode-map (kbd "s-a") 'mark-whole-buffer)
+      ;; Save and undo
+      (keymap-set icejam-keys-mode-map "s-s" #'save-buffer)
+      (keymap-set icejam-keys-mode-map "s-z" #'undo)
+      (keymap-set icejam-keys-mode-map "s-Z" #'undo-redo)
+      (keymap-set icejam-keys-mode-map "s-a" #'mark-whole-buffer)

-      ;;;;;;;; Copy and paste bindings ;;;;;;;;;;;;;;;;;;
-      (define-key icejam-keys-mode-map (kbd "s-x") 'kill-region)
-      (define-key icejam-keys-mode-map (kbd "s-v") 'yank)
-      (define-key icejam-keys-mode-map (kbd "s-c") 'kill-ring-save)
+      ;; Copy and paste bindings
+      (keymap-set icejam-keys-mode-map "s-x" #'kill-region)
+      (keymap-set icejam-keys-mode-map "s-v" #'yank)
+      (keymap-set icejam-keys-mode-map "s-c" #'kill-ring-save)

-      ;;;;;;;;; Linux Ergo bindings (fix) ;;;;;;;;;;;;;;;;;;
-      (define-key icejam-keys-mode-map (kbd "C-<right>") 'end-of-line)
-      (define-key icejam-keys-mode-map (kbd "C-<left>") 'beginning-of-line)
-      (define-key icejam-keys-mode-map (kbd "C-<up>") 'scroll-down) ; WTF is this reverse, I dunno
-      (define-key icejam-keys-mode-map (kbd "C-<down>") 'scroll-up)))
-
-;;;;;;;;; BSD-specific config ;;;;;;;;;;;;;;;;;;;;;
-(if IS-BSD
-    (progn
-      (define-key icejam-keys-mode-map (kbd "A-<right>") 'end-of-line)
-      (define-key icejam-keys-mode-map (kbd "A-<left>") 'beginning-of-line)
-      (define-key icejam-keys-mode-map (kbd "A-<up>") 'scroll-down) ; WTF is this reverse, I dunno
-      (define-key icejam-keys-mode-map (kbd "A-<down>") 'scroll-up)
-
-      (define-key icejam-keys-mode-map (kbd "A-a") 'mark-whole-buffer)
-      (define-key icejam-keys-mode-map (kbd "A-v") 'yank)
-      (define-key icejam-keys-mode-map (kbd "A-x") 'kill-region)
-      (define-key icejam-keys-mode-map (kbd "A-c") 'kill-ring-save)
-      (define-key icejam-keys-mode-map (kbd "A-s") 'save-buffer)
-      (define-key icejam-keys-mode-map (kbd "A-l") 'goto-line)
-      (define-key icejam-keys-mode-map (kbd "A-w" '+delete-window)
-      (define-key icejam-keys-mode-map (kbd "A-z") 'undo)
-      (define-key icejam-keys-mode-map (kbd "A-q") 'kill-emacs))))
+      ;; Linux Ergo bindings (fix)
+      (keymap-set icejam-keys-mode-map "C-<right>" #'end-of-line)
+      (keymap-set icejam-keys-mode-map "C-<left>" #'beginning-of-line)
+      (keymap-set icejam-keys-mode-map "C-<up>" #'scroll-down) ; WTF is this reverse, I dunno
+      (keymap-set icejam-keys-mode-map "C-<down>" #'scroll-up)))

 (provide 'icejam-sys-specific)
 ;;; icejam-sys-specific.el ends here
--- a/lisp/icejam-themes.el
+++ b/lisp/icejam-themes.el
@ -3,31 +3,20 @@
 ;;; Code:

 (use-package spaceline :ensure t
-  :hook ((elpaca-after-init . spaceline-emacs-theme)))
+  :hook ((elpaca-after-init . spaceline-emacs-theme))
+  :config
+  ;; Recompile spaceline after each theme has been reloaded to ensure
+  ;; that there are no artifacts instead of arrows on the screen.
+  (setopt enable-theme-functions 'spaceline-compile))

-(use-package base16-theme :ensure t
-  ;; :config
-  ;; (load-theme 'base16-atelier-forest-light t t)
-  ;; (load-theme 'base16-harmonic16-light t t)
-  ;; (load-theme 'base16-horizon-light t t)
-  ;; (load-theme 'base16-humanoid-light t t)
-  ;; (load-theme 'base16-zenburn t)
-  ;; (load-theme 'base16-tomorrow-night-eighties t t)
-  ;; (load-theme 'base16-darcula t t)
-  ;; (load-theme 'base16-solarflare t t)
-  ;; (load-theme 'base16-snazzy t t)
-  ;; (load-theme 'base16-onedark t t)
-  ;; (load-theme 'base16-gruvbox-dark-hard t t)
-  ;; (load-theme 'modus-vivendi t t)
-  ;; (load-theme 'base16-zenbones t t)
-  )
+(use-package base16-theme :ensure t)

 ;; (use-package apropospriate-theme :ensure t
 ;;   :config (load-theme 'apropospriate-light t t))
 ;; (use-package leuven-theme :ensure t
 ;;   :config
 ;;   (load-theme 'leuven t t))
-;; (use-package modus-themes :ensure t )
+(use-package modus-themes :ensure t)
 ;; (use-package darktooth-theme :ensure t
 ;;   :config
 ;;   (load-theme 'darktooth t t))
@ -43,6 +32,7 @@
 ;; (use-package zenburn-theme :ensure t
 ;;   :config
 ;;   (load-theme 'zenburn t t))
+
 ;; (use-package catppuccin-theme :ensure t
 ;;   :custom
 ;;   ((catpuccin-flavor 'frappe))
@ -52,11 +42,19 @@
 ;; Disable cursor blinking
 (blink-cursor-mode 0)

+;; Scroll with the trackpad smoothly
+(pixel-scroll-precision-mode 1)
+
 ;; My own theme modifications:
 (with-eval-after-load 'base16-theme
  (setopt base16-theme-256-color-source 'colors)
+  (load-theme 'base16-equilibrium-light t t)
+  (load-theme 'base16-gruvbox-dark-pale t t)
+  (load-theme 'base16-onedark t t)
+  (load-theme 'modus-operandi-tinted t t)
  (require 'icejam-base16-zenburn)
  (require 'icejam-base16-harmonic-light)
+  (require 'icejam-base16-catppuccin-latte)

  (if (memq window-system '(x mac ns))
      (enable-theme 'icejam-base16-zenburn)
--- a/lisp/icejam-transient.el
+++ b/lisp/icejam-transient.el
@ -2,11 +2,9 @@
 ;;; Commentary:
 ;;; Global Transient definitions.
 ;;; Code:
+(eval-when-compile (defvar icejam-keys-mode-map))

-(require 'icejam-avy)
-(require 'icejam-keys-mode)
-(require 'icejam-blocking)
-;; (use-package transient :ensure (:wait t) :demand t)
+(use-package transient :ensure (:wait t))

 (defun icejam-mark-and-indent-whole-buffer ()
  "Mark and indent whole buffer."
@ -15,100 +13,116 @@

 (transient-define-prefix icejam-project-menu ()
  "Project Commands."
-  [""
-   ["Project"
+  [["Project"
    ("s" "Switch project" project-switch-project)
    ("f" "Find file in project" project-find-file)
-    ("g" "Grep in project"      consult-ripgrep)]
-   ["Completions"
-    ("a" "Grep in buffer"       consult-line)
-    ("b" "Buffer list"          consult-buffer)
-    ("t" "Find file"            find-file)]
+    ("g" "Grep in project" consult-ripgrep)
+    ("t" "Find file anywhere" find-file)]
   ["Magit"
    ("m" "Git status" magit-status)
    ("C" "Git checkout" magit-checkout)
-    ("M" "Git blame"            magit-blame)]]
-  [""
-   ["LISP"
+    ("M" "Git blame" magit-blame)]
+   ["Completions"
+    ("a" "Find line by contents" consult-line)
+    ("b" "Find buffer by name" consult-buffer)]]
+  [["LISP"
    ("i" "IELM"                 ielm)
+    ("B" "iBuffer"              ibuffer)
    ("e" "eval-region"          eval-region)]
   ["Other"
    ("d" "deft"                 deft)
-    ("T" "Speed Type"           speed-type-text)]])
+    ("T" "Speed Type"           speed-type-text)]]
+  [[""
+    ("q" "Quit" keyboard-quit)]])

 (transient-define-prefix icejam-code-menu ()
  "Code Commands."
-  [""
-   ["Manipulate"
+  [["Manipulate"
    ("c" "Toggle Comment"     comment-line)
    ("r" "Replace"            vr/replace)
-    ("i" "Indent"             indent-region)]
-   ["Complete"
-    ("y" "Snippet"            company-yasnippet)
-    ("m" "Any (Company)"      company-complete)
-    ("g" "Ask GPT"            gptel-menu)
-    ("e" "Refactor (Elysium)" elysium-query)]
-   ["Find"
+    ("i" "Indent"             indent-region)]]
+  [["Complete"
+    ("g" "Ask GPTel"             gptel-menu)
+    ("a" "Aider"                 aidermacs-transient-menu)
+    ("e" "Refactor with Elysium" elysium-query)]]
+   [["Find"
    ("s" "Swiper"             consult-line)
    ("u" "Vundo"              vundo)
    ("d" "Dash"               dash-at-point)]])

-(transient-define-prefix icejam-window-menu ()
-  "Windows Commands."
+(transient-define-prefix icejam-buffer-menu ()
+  "Buffers and windows."
  [""
-   ["Move"
-    ("<left>" " Left"   windmove-left)
-    ("<right>" "Right"  windmove-right)
-    ("<up>" "   Up"     windmove-up)
-    ("<down>" " Down"   windmove-down)]
+   ["Move Cursor"
+    :pad-keys t
+    ("<left>"  "Left buffer" windmove-left)
+    ("<right>" "Right buffer" windmove-right)
+    ("<up>"    "Top buffer" windmove-up)
+    ("<down>"  "Bottom buffer" windmove-down)]
+   ["Move this buffer"
+    :pad-keys t
+    ("v[" "To left" buf-move-left)
+    ("v]" "To right"  buf-move-right)
+    ("h[" "Up" buf-move-up)
+    ("h]" "Down"  buf-move-down)]]
+  [["Jump to"
+    ("w" "Word" avy-goto-word-1)
+    ("l" "Line" avy-goto-line)
+    ("c" "Character" avy-goto-char-2)]
   ["Split"
-    ("h" "Horizontally" split-window-below)
-    ("v" "Vertically"   split-window-right)]
-   ["Kill"
-    ""
-    ""
-    ""
-    ("k" "Kill Buffer"  kill-buffer-and-window)]])
+    ("sr" "To right" split-window-right)
+    ("sb" "To bottom" split-window-below)
+    ("\\" "To right" split-window-right)
+    ("/"  "To bottom" split-window-below)]]
+  [["Buffers"
+    :pad-keys t
+    ("s[" "Go to previous buffer" previous-buffer)
+    ("s]" "Go to next buffer" next-buffer)
+    ("bi" "iBuffer" ibuffer)
+    ("bf" "Find buffer" consult-buffer)
+    ("k" "Kill buffer and window" kill-buffer-and-window)]]
+  [["Fonts"
+    :pad-keys t
+    ("fs" "Adjust font size globally" global-text-scale-adjust)
+    ("fi" "Increase by one in this buffer"
+     (lambda () (interactive) (text-scale-increase 1)))
+    ("fd" "Decrease by one in this buffer"
+     (lambda () (interactive) (text-scale-decrease 1)))
+    ("fr" "Reset this buffer"
+     (lambda () (interactive) (text-scale-adjust 0)))]]
+  [[""
+    ("q" "Quit" keyboard-quit)]])

 (transient-define-prefix icejam-language-menu ()
  "Language (Buffer) Commands."
-  [""
-   ["Buffer"
-    ("r" "Reload"      icejam-revert-buffer-no-confirm)
-    ("f" "Format"      lsp-format-buffer)
-    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)]
-   ["Other"
-    ("m" "iMenu"       lsp-ui-imenu)
-    ("e" "Show Errors" flycheck-list-errors)]])
+  [[:description
+    (lambda ()
+      (concat (propertize "Code actions for " 'face 'transient-heading)
+              (propertize (format "%s" major-mode) 'face 'transient-key)
+              (propertize ":\n" 'face 'transient-heading)))

-(transient-define-prefix icejam-history-menu ()
-  "Buffer History Commands."
-  ["History"
-   ("[" "Previous" previous-buffer)
-   ("]" "Next" previous-buffer)])
+    ("r" "Reload buffer" icejam-revert-buffer-no-confirm)
+    ("e" "Show errors" flymake-show-buffer-diagnostics)
+    ("f" "Format buffer with apheleia formatter" apheleia-format-buffer)

-(transient-define-prefix icejam-move-menu ()
-  "Move Commands."
-  [""
-   ["Move this buffer"
-    ("{" "Up"    buf-move-left)
-    ("[" "Left"  buf-move-right)
-    ("}" "Right" buf-move-up)
-    ("]" "Down"  buf-move-down)]
-   ["Jump to"
-    ("w" "Word" avy-goto-word-1)
-    ("l" "Character" avy-goto-line)
-    ("c" "Line" avy-goto-char-2)]])
+    ;; This only appears for emacs-lisp-mode
+    ("d" "Explain thing at point" helpful-at-point :if-mode emacs-lisp-mode)

-(transient-define-prefix icejam-font-menu ()
-  "Font Commands."
-  [""
-   ["Everywhere"
-    ("s" "Adjust font size" global-text-scale-adjust)]
-   ["In this buffer"
-    ("i" "Bigger"           (lambda () (interactive) (text-scale-increase 1)))
-    ("d" "Smaller"          (lambda () (interactive) (text-scale-decrease 1)))
-    ("r" "Reset"            (lambda () (interactive) (text-scale-adjust 0)))]])
+    ("m" "iMenu" consult-imenu)
+
+    ;; Finally, quit.
+    ("q" "Quit" keyboard-quit)]])
+
+(transient-define-prefix icejam-elpaca-menu ()
+  "Commands related to packages."
+  [["Packages and compilation"
+    ("m" "Open Elpaca manager" elpaca-manager)
+    ("f" "Fetch all package updates" elpaca-fetch-all)
+    ("s" "Symlink treesitter grammar objects" icejam-tree-sitter-symlink-grammar-objects)
+    ("p" "Prune native compilation cache" native-compile-prune-cache)
+    ("w" "Write elpaca lockfile" icejam-elpaca-write-lock)]]
+  [[""
+    ("q" "Quit" keyboard-quit)]])

 (defcustom icejam-language-transient-alist
  '()
@ -129,13 +143,24 @@ You can pass MAYBE-MODE to find mode explicitly."
  (interactive)
  (funcall (icejam-language-transient-for-mode)))

-(define-key icejam-keys-mode-map (kbd "C-c p") 'icejam-project-menu)
-(define-key icejam-keys-mode-map (kbd "C-c c") 'icejam-code-menu)
-(define-key icejam-keys-mode-map (kbd "C-c w") 'icejam-window-menu)
-(define-key icejam-keys-mode-map (kbd "C-c s") 'icejam-history-menu)
-(define-key icejam-keys-mode-map (kbd "C-c f") 'icejam-font-menu)
-(define-key icejam-keys-mode-map (kbd "C-c m") 'icejam-move-menu)
-(define-key icejam-keys-mode-map (kbd "C-c l") 'icejam-transient-for-lang)
+(transient-define-prefix icejam-command-palette ()
+  "All transient menus in one place."
+  ["Command palette\n"
+   ["The thing you are editing"
+    ("p" "Project" icejam-project-menu)
+    ("c" "Code" icejam-code-menu)
+    ("l" "Language" icejam-transient-for-lang)
+    ("r" "Revert Buffer" icejam-revert-buffer-no-confirm)]
+   ["The editor itself"
+    ("b" "iBuffer" ibuffer)
+    ("P" "Packages" icejam-elpaca-menu)
+    ("w" "Window" icejam-buffer-menu)]])
+
+(keymap-set icejam-keys-mode-map "C-c p" #'icejam-project-menu)
+(keymap-set icejam-keys-mode-map "C-c c" #'icejam-code-menu)
+(keymap-set icejam-keys-mode-map "C-c w" #'icejam-buffer-menu)
+(keymap-set icejam-keys-mode-map "C-c l" #'icejam-transient-for-lang)
+(keymap-set icejam-keys-mode-map "H-p" #'icejam-command-palette)

 (provide 'icejam-transient)
 ;;; icejam-transient.el ends here
--- a/lisp/icejam-tree-sitter.el
+++ b/lisp/icejam-tree-sitter.el
@ -10,11 +10,12 @@
 ;; community.

 ;;; Code:
-
-(use-package tree-sitter-langs :ensure t
-  :config
-  (declare-function tree-sitter-langs--bin-dir "tree-sitter-langs")
-  (add-to-list 'treesit-extra-load-path (tree-sitter-langs--bin-dir))
+(use-package tree-sitter-langs :ensure t :defer t
+  :commands tree-sitter-langs--bin-dir
+  :hook
+  (elpaca-after-init . (lambda () (add-to-list
+                                   'treesit-extra-load-path
+                                   (tree-sitter-langs--bin-dir)))))

 (defun icejam-tree-sitter-symlink-grammar-objects ()
  "Create symlinks for treesitter grammars.
@ -29,7 +30,7 @@ libtree-sitter-LANG.so"
                          (file-name-nondirectory file))))
      (if (memq system-type '(ms-dos windows-nt cygwin))
          (copy-file file target)
-          (make-symbolic-link file target))))))
+        (make-symbolic-link file target)))))

 (provide 'icejam-tree-sitter)
 ;;; icejam-tree-sitter.el ends here
--- a/lisp/icejam-vundo.el
+++ b/lisp/icejam-vundo.el
@ -10,8 +10,11 @@

 ;;; Code:

-;;;;;;;;;;;;;;;;; Use more advanced undo options
-(use-package vundo :ensure t :defer t)
+;; Undo UI
+(use-package vundo :ensure t :defer t
+  :config
+  ;; Keep 64 MB of undo data, we have enough RAM to do this.
+  (setopt undo-limit (* 64 1024 1024)))

 (provide 'icejam-vundo)
 ;;; icejam-vundo.el ends here
--- a/lisp/langs/icejam-lang-clang.el
+++ b/lisp/langs/icejam-lang-clang.el
@ -2,8 +2,6 @@
 ;;; Commentary:
 ;;; Code:

-(require 'icejam-prog-mode)
-
 (declare-function column-enforce-n "column-enforce-mode" (number))

 (defun icejam-lang-activate-clang-mode ()
@ -19,10 +17,7 @@

  (if (boundp 'c-default-style)
      (setq-local c-default-style "bsd")
-    (defvar c-default-style "bsd"))
-
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-etags company-yasnippet)))
+    (defvar c-default-style "bsd")))

 (add-hook 'c-mode-hook 'icejam-lang-activate-clang-mode)

--- a/lisp/langs/icejam-lang-clojure.el
+++ b/lisp/langs/icejam-lang-clojure.el
@ -2,16 +2,14 @@
 ;;; Commentary:
 ;;; Code:

-(require 'icejam-prog-mode)
-(require 'icejam-transient)
-
 (declare-function column-enforce-n "column-enforce-mode" (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)

 (use-package clojure-mode :defer t :ensure t)

 (use-package cider
  :requires clojure-mode
-  :commands cider-jack-in
+  :commands (cider-mode cider-jack-in)
  :defer t
  :ensure t
  :config (setq cider-annotate-completion-function t))
@ -32,7 +30,7 @@
    ("r" "Reload"      icejam-revert-buffer-no-confirm)
    ("f" "Format"      cider-format-buffer)
    ("l" "Load"        cider-load-buffer)
-    ("e" "Show Errors" flycheck-list-errors)]]
+    ("e" "Show Errors" flymake-show-buffer-diagnostics)]]
  [""
   ("q"  "Quit"        keyboard-quit)])

@ -41,10 +39,8 @@
  (icejam-set-indent 2) ;; Default indentation of 2 characters
  (column-enforce-n 80)
  (cider-mode 1)
-  (setq-local indent-tabs-mode nil)

-  (define-key
-    clojure-mode-map (kbd "C-c l") 'icejam-lang-cider-context-menu)
+  (define-key clojure-mode-map (kbd "C-c l") 'icejam-lang-cider-context-menu)

  ;; Do not enable paredit for clojure
  ;; (paredit-mode 1)
@ -58,7 +54,7 @@
 	(setq-local cider-show-error-buffer 'except-in-repl))

 (add-hook 'cider-repl-mode-hook 'icejam-lang-clojure-repl-config)
-(add-hook 'cider-mode-hook #'cider-company-enable-fuzzy-completion)
+(add-hook 'cider-mode-hook 'cider-enable-flex-completion)

 (provide 'icejam-lang-clojure)
 ;;; icejam-lang-clojure.el ends here
--- a/lisp/langs/icejam-lang-common-lisp.el
+++ b/lisp/langs/icejam-lang-common-lisp.el
@ -1,22 +0,0 @@
-;;; common-lisp.el --- summary -*- lexical-binding: t; -*-
-
-;; Author: Maciej Szlosarczyk
-;; Maintainer: Maciej Szlosarczyk
-;; Version: 0.1-snapshot
-
-;;; Commentary:
-
-;;; Code:
-
-(require 'icejam-prog-mode)
-(require 'icejam-company-yasnippet)
-
-(use-package slime :ensure t)
-(use-package slime-company :ensure t
-  :requires (slime company))
-
-(setq inferior-lisp-program "sbcl")
-(slime-setup '(slime-fancy slime-company slime-quicklisp slime-asdf))
-
-(provide 'icejam-lang-common-lisp)
-;;; icejam-lang-common-lisp.el ends here
--- a/lisp/langs/icejam-lang-dart.el
+++ b/lisp/langs/icejam-lang-dart.el
@ -2,14 +2,11 @@
 ;;; Commentary:
 ;;; Code:

-(require 'icejam-prog-mode)
-
 (use-package dart-mode :ensure t :defer t)
-(use-package lsp-dart :defer t :ensure t :requires (dart-mode lsp))

 (defun icejam-lang-activate-dart-mode ()
  "Reconfigure dart mode for your own purposes."
-  (lsp))
+  (eglot-ensure))

 (add-hook 'dart-mode-hook 'icejam-lang-activate-dart-mode)

--- a/lisp/langs/icejam-lang-dhall.el
+++ b/lisp/langs/icejam-lang-dhall.el
@ -2,14 +2,12 @@
 ;;; Commentary:
 ;;; Code:

-(require 'icejam-prog-mode)
-(require 'icejam-lsp)
-
-(use-package dhall-mode :ensure t :defer t :requires (lsp))
+(use-package dhall-mode :ensure t :defer t)

 (defun icejam-lang-activate-dhall-mode ()
  "Reconfigure dhall mode for your own purposes."
-  (lsp))
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))

 (add-hook 'dhall-mode-hook 'icejam-lang-activate-dhall-mode)
 (add-hook 'dhall-mode-hook 'display-line-numbers-mode)
--- a/lisp/langs/icejam-lang-elisp.el
+++ b/lisp/langs/icejam-lang-elisp.el
@ -2,43 +2,26 @@
 ;;; Commentary:
 ;;; Code:

-(require 'icejam-prog-mode)
-(require 'icejam-transient)
+(eval-when-compile
+  (declare-function column-enforce-n 'column-enforce-mode (number))
+  (declare-function icejam-set-elisp-capfs 'icejam-complete-at-point)
+  (declare-function icejam-set-indent 'icejam-prog-mode))

-(use-package lispy :ensure t)
-
-(declare-function column-enforce-n "column-enforce-mode" (number))
 (add-to-list 'auto-mode-alist '("/Eask\\'" . emacs-lisp-mode))

-(transient-define-prefix icejam-elisp-lang-menu ()
-  "Elisp Buffer Commands."
-  [""
-   ["Buffer"
-    ("r" "Reload"      icejam-revert-buffer-no-confirm)
-    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)
-    ("d" "Explain"     helpful-at-point)
-    ("e" "Show Errors" flycheck-list-errors)]]
-  [""
-   ("q" "Quit"        keyboard-quit)])
+(use-package lispy :ensure t :defer t :commands (lispy-mode))
+;; (use-package geiser-guile :ensure t :defer t)

-(add-to-list
- 'icejam-language-transient-alist '(emacs-lisp-mode . icejam-elisp-lang-menu))
-
-(with-eval-after-load 'lispy
-  (declare-function lispy-mode "lispy")
 (defun icejam-activate-emacs-lisp-mode ()
  "Goodies for editing Emacs files."
+
  (icejam-set-indent 2) ;; Default indentation of 2 characters
-    (column-enforce-n 80)
+  (column-enforce-n 80) ;; Use 80 char limit.
+  (lispy-mode t)        ;; Modal editing for Lisp
+  (icejam-set-elisp-capfs))

-    (lispy-mode t)
-    (setq-default indent-tabs-mode nil)
-
-    ;; Company list override
-    (add-to-list (make-local-variable 'company-backends)
-                 '(company-yasnippet company-capf)))
-
-  (add-hook 'emacs-lisp-mode-hook 'icejam-activate-emacs-lisp-mode))
+(add-hook 'emacs-lisp-mode-hook 'icejam-activate-emacs-lisp-mode)
+(add-hook 'ielm-mode-hook 'icejam-set-elisp-capfs)

 (provide 'icejam-lang-elisp)
 ;;; icejam-lang-elisp.el ends here
--- a/lisp/langs/icejam-lang-elixir.el
+++ b/lisp/langs/icejam-lang-elixir.el
@ -2,32 +2,40 @@
 ;;; Commentary:
 ;;; Code:

-(require 'icejam-prog-mode)
-(require 'icejam-flycheck)
-(require 'icejam-transient)
+(eval-when-compile
+  (declare-function transient-define-prefix 'transient)
+  (declare-function column-enforce-n 'column-enforce-mode (number))
+  (declare-function -> 'dash)
+  (declare-function yas--table-get-create 'yasnippet)
+  (declare-function yas--remove-template-by-uuid 'yasnippet)
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
+  (defvar icejam-language-transient-alist)
+  (defvar icejam-elixir-lang-menu)
+  (defvar apheleia-mode-alist))

-(declare-function lsp "lsp-mode" nil)
-(declare-function column-enforce-n "column-enforce-mode" (number))
-
-(use-package elixir-mode :ensure t)
-(use-package elixir-ts-mode :ensure t :requires (elixir-mode lsp-mode lsp-ui))
-
-(with-eval-after-load 'elixir-ts-mode
-  (add-to-list 'auto-mode-alist '("\\.exs\\'" . elixir-ts-mode))
-  (add-to-list 'auto-mode-alist '("\\.ex\\'" . elixir-ts-mode)))
+(use-package elixir-ts-mode :ensure t :defer t :after (apheleia)
+  :config
+  (add-to-list 'apheleia-mode-alist '(heex-ts-mode . mix-format)))

 (transient-define-prefix icejam-elixir-lang-menu ()
-  "Elixir Buffer Commands."
-  [""
-   ["LSP"
-    ("m" "iMenu"       lsp-ui-imenu)]
-   ["Buffer"
-    ("r" "Reload"      icejam-revert-buffer-no-confirm)
-    ("f" "Format"      elixir-format)
-    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)
-    ("e" "Show Errors" flycheck-list-errors)]]
-  [""
-   ("q" "Quit"        keyboard-quit)])
+  [[:description
+    (lambda ()
+      (concat (propertize "Code actions for " 'face 'transient-heading)
+              (propertize (format "%s" major-mode) 'face 'transient-key)
+              (propertize ":\n" 'face 'transient-heading)))
+    ("m" "iMenu" consult-imenu)
+    ("r" "Reload buffer" icejam-revert-buffer-no-confirm)
+    ("e" "Show errors" flymake-show-buffer-diagnostics)
+    ("f" "Format buffer with Elixir formatter" apheleia-format-buffer)
+
+    ("q" "Quit" keyboard-quit)]])
+
+(defun icejam-delete-elixir-snippets ()
+  "This function deletes Elixir snippets I don't use."
+  (-> 'elixir-mode
+      (yas--table-get-create)
+      (yas--remove-template-by-uuid "defmodule XXX end")))

 (add-to-list
 'icejam-language-transient-alist '(elixir-ts-mode . icejam-elixir-lang-menu))
@ -36,21 +44,27 @@
  "All things Elixir."
  (icejam-set-indent 2)
  (column-enforce-n 98)
-  (lsp)
-  (setq-local flycheck-check-syntax-automatically '(save mode-enabled))
-  (setq-local lsp-eldoc-enable-hover nil)
-  (setq-local lsp-completion-enable-additional-text-edit nil)
-  (setq-local company-minimum-prefix-length 3)
+  (eglot-ensure)

  ;; If needed, switch the one below to false to disable documentation pop-ups
  ;; (setq-local lsp-ui-doc-enable t)
-
-  ;; Company list override
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
+  (icejam-set-eglot-capfs)
+  (icejam-delete-elixir-snippets))

 (add-hook 'heex-ts-mode-hook 'icejam-activate-elixir-ts-mode)
 (add-hook 'elixir-ts-mode-hook 'icejam-activate-elixir-ts-mode)

+;; (use-package ert :ensure nil :defer t)
+;; (ert-deftest icejam-activate-elixir-ts-mode ()
+;;   "Test `elixir-ts-mode` activation."
+;;   (with-temp-buffer
+;;     (elixir-ts-mode)
+;;     (icejam-activate-elixir-ts-mode)
+;;     (should (eq major-mode 'elixir-ts-mode))
+;;     (should (bound-and-true-p column-enforce-mode))
+;;     (should (equal " 98col" (buffer-local-value 'column-enforce-mode-line-string
+;;                                             (current-buffer))))
+;;     (should (eq 2 (buffer-local-value 'tab-width (current-buffer))))))
+
 (provide 'icejam-lang-elixir)
 ;;; icejam-lang-elixir.el ends here
--- a/lisp/langs/icejam-lang-erlang.el
+++ b/lisp/langs/icejam-lang-erlang.el
@ -2,85 +2,22 @@
 ;;; Commentary:
 ;;; Code:

-(require 'icejam-prog-mode)
-(require 'icejam-lsp)
+(declare-function column-enforce-n 'column-enforce-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)

-(declare-function lsp "lsp-mode" nil)
-(declare-function column-enforce-n "column-enforce-mode" (number))
-
-(use-package erlang
-  :defer t
-  :ensure (:depth 1)
-  :after (lsp lsp-ui))
-
-(cl-defun icejam-erlang-emacs-path (erlang-version)
-  "Find path to Emacs tooling for ERLANG-VERSION."
-  (car (split-string
-        (shell-command-to-string
-         (format "find $HOME/.asdf/installs/erlang/%s/ -name erlang.el"
-                 erlang-version)) "erlang.el")))
-
-(cl-defun icejam-erlang-path (erlang-version)
-  "Find asdf path for ERLANG-VERSION."
-  (format "$HOME/.asdf/installs/erlang/%s/" erlang-version))
-
-(defun icejam-erlang-plist (erlang-version)
-  "Create property list for ERLANG-VERSION."
-  (list :version erlang-version
-        :erlang-path (icejam-erlang-path erlang-version)
-        :emacs-path (icejam-erlang-emacs-path erlang-version)))
-
-(cl-defun icejam-installed-erlangs ()
-  "List Erlang versions installed with asdf."
-  (split-string
-   (shell-command-to-string
-    (format "asdf list erlang"))))
-
-(cl-defun icejam-erlang-available-versions--plist ()
-  "Create plist for all installed Erlang versions."
-  (mapcar 'icejam-erlang-plist (icejam-installed-erlangs)))
-
-(defvar icejam-erlang-available-versions (icejam-erlang-available-versions--plist))
-
-(cl-defun icejam-erlang-currently-in-use ()
-  "Get Erlang version currently in use."
-  (car (split-string (shell-command-to-string "asdf current erlang"))))
-
-(cl-defun icejam-erlang-current-version--plistp (erlang-plist)
-  "Check if currently in use Erlang is the same as the one in ERLANG-PLIST."
-  (equal (plist-get erlang-plist :version) (icejam-erlang-currently-in-use)))
-
-(cl-defun icejam-erlang-current-plist ()
-  "Create plist from current Erlang version."
-  (seq-find 'icejam-erlang-current-version--plistp icejam-erlang-available-versions))
+(use-package erlang :defer t :ensure (:depth 1))

 (defun icejam-activate-erlang-mode ()
-  "All things for all Erlang, including header files."
-  (when (featurep 'erlang-start) (unload-feature 'erlang-start))
-
-  (defvar erlang/current-erlang (icejam-erlang-current-plist))
-
-  (add-to-list (make-local-variable 'load-path)
-               (plist-get erlang/current-erlang :emacs-path))
-
-  (add-to-list (make-local-variable 'exec-path)
-               (format "%slib/tools-3.1/emacs"
-                       (plist-get erlang/current-erlang :erlang-path)))
-
-  (setq-local erlang-man-root-dir
-              (format "%sman"
-                      (plist-get erlang/current-erlang :erlang-path)))
-
-  (require 'erlang-start)
+  "Start Erlang related editing process."
  (icejam-set-indent 4)
  (column-enforce-n 80)

  ;; Start LSP
-  (lsp)
+  (eglot-ensure)

-  ;; Company list override
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
+  ;; Capf override
+  (icejam-set-eglot-capfs))

 (add-hook 'erlang-mode-hook 'icejam-activate-erlang-mode)

--- a/lisp/langs/icejam-lang-fsharp.el
+++ b/lisp/langs/icejam-lang-fsharp.el
@ -9,24 +9,20 @@
 ;; Fsharp configuration

 ;;; Code:
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)

-(require 'icejam-prog-mode)
-(require 'icejam-lsp)
-
-(use-package fsharp-mode
-  :requires (lsp-mode lsp-ui)
-  :ensure t
-  :defer t)
+(use-package fsharp-mode :ensure t :defer t)

 (defun icejam-activate-fsharp-mode ()
  "Activate F# goodies."
  (icejam-set-indent 4)
  (column-enforce-n 100)
-  (lsp-deferred)
+  (eglot-ensure)

-  ;; Company list override
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
+  ;; Capf override
+  (icejam-set-eglot-capfs))

 (add-hook 'fsharp-mode-hook 'icejam-activate-fsharp-mode)

--- a/lisp/langs/icejam-lang-gleam.el
+++ b/lisp/langs/icejam-lang-gleam.el
@ -9,24 +9,23 @@
 ;; Gleam language support

 ;;; Code:
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)

-(require 'icejam-prog-mode)
+(use-package gleam-ts-mode :defer t :ensure t
+  :mode (rx ".gleam" eos))

-(use-package gleam-ts-mode
-  :ensure (:type git
-                 :host github
-                 :repo "gleam-lang/gleam-mode"
-                 :files ("gleam-ts-mode.el")))
-
-(add-to-list 'auto-mode-alist '("\\.gleam\\'" . gleam-ts-mode))
+;; (add-to-list 'auto-mode-alist '("\\.gleam\\'" . gleam-ts-mode))

 (defun icejam-lang-activate-gleam-mode ()
  "All things Gleam."
  (icejam-set-indent 2)
  (column-enforce-n 100)
-  (lsp))
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))

-(add-hook 'gleam-mode-hook 'icejam-lang-activate-gleam-mode)
+(add-hook 'gleam-ts-mode-hook 'icejam-lang-activate-gleam-mode)

 (provide 'icejam-lang-gleam)
 ;;; icejam-lang-gleam.el ends here
--- a/lisp/langs/icejam-lang-golang.el
+++ b/lisp/langs/icejam-lang-golang.el
@ -9,21 +9,20 @@
 ;; golang mode stuff

 ;;; Code:
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)

-(require 'icejam-prog-mode)
-
-(use-package go-mode
-  :requires (lsp-mode lsp-ui)
-  :defer t
-  :ensure t)
+(use-package go-mode :defer t :ensure t)

 (defun icejam-activate-golang-mode ()
  "Activate my own Golang mode settings."
  (icejam-set-indent 8)
  (column-enforce-n 100)
-  (lsp))
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))

-(add-hook 'go-mode-hook 'icejam-activate-golang-mode)
+(add-hook 'go-mode-hook #'icejam-activate-golang-mode)

 (provide 'icejam-lang-golang)
 ;;; icejam-lang-golang.el ends here
--- a/lisp/langs/icejam-lang-haskell.el
+++ b/lisp/langs/icejam-lang-haskell.el
@ -10,26 +10,20 @@

 ;;; Code:

-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)

-(use-package haskell-mode
-  :ensure t
-  :defer t)
-
-(use-package lsp-haskell
-  :ensure t
-  :defer t
-  :requires (lsp-mode lsp-ui haskell-mode))
+(use-package haskell-mode :ensure t :defer t)

 (defun icejam-activate-haskell-mode ()
-  "Run this in haskell-mode."
+  "Run this in `haskell-mode'."
  (icejam-set-indent 2)
  (column-enforce-n 80)
-  (lsp-deferred)
+  (eglot-ensure)

-  ;; Company list override
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
+  ;; Capf override
+  (icejam-set-eglot-capfs))

 (add-hook 'haskell-mode-hook 'icejam-activate-haskell-mode)

--- a/lisp/langs/icejam-lang-javascript.el
+++ b/lisp/langs/icejam-lang-javascript.el
@ -2,15 +2,24 @@
 ;;; Commentary:
 ;;; Code:

-(require 'icejam-prog-mode)
-(require 'icejam-flycheck)
-(require 'icejam-lsp)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)

-(use-package js2-mode
-  :requires (web-mode company-web lsp-mode lsp-ui)
-  :ensure t)
+(use-package js2-mode :ensure t :defer t :after(web-mode))

-(use-package typescript-mode :ensure t)
+(use-package typescript-ts-mode :ensure nil :defer t)
+
+(add-to-list 'auto-mode-alist '("\\.ts\\'" . typescript-ts-mode))
+(add-to-list 'auto-mode-alist '("\\.tsx\\'" . typescript-ts-mode))
+
+(defun icejam-activate-typescript-ts-mode ()
+  "Typescript mode overrides."
+  (icejam-set-indent 2)
+  (eglot-ensure)
+  (column-enforce-n 100))
+
+(add-hook 'typescript-ts-mode-hook 'icejam-activate-typescript-ts-mode)

 ;; (use-package vue-mode
 ;;   :ensure t
@ -25,21 +34,17 @@
 	(icejam-set-indent 2)

  (when (not (string-match-p ".json" (buffer-file-name)))
-    (lsp-deferred))
+    (eglot-ensure))

 	(column-enforce-n 80)
 	(setq-local js2-basic-offset 2)
  (setq-local js2-strict-missing-semi-warning nil)
-  (setq-local lsp-eldoc-enable-hover nil)
  (setq js2-mode-show-parse-errors nil)
  (setq js2-mode-show-strict-warnings nil)

-  (setq-local lsp-eldoc-enable-hover nil)
  (setq-local flycheck-check-syntax-automatically '(save mode-enabled))

-  ;; "Company list override."
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
+  (icejam-set-eglot-capfs))

 (add-hook 'js2-mode-hook 'icejam-activate-js2-mode)

--- a/lisp/langs/icejam-lang-kotlin.el
+++ b/lisp/langs/icejam-lang-kotlin.el
@ -9,26 +9,25 @@
 ;; kotlin does a thing.

 ;;; Code:
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)

-(use-package kotlin-mode
-	:defer t
-	:ensure t)
+(use-package kotlin-ts-mode :ensure t :defer t)

-(use-package gradle-mode
-	:defer t
-	:ensure t)
+(add-to-list 'auto-mode-alist '("\\.kt\\'" . kotlin-ts-mode))
+(add-to-list 'auto-mode-alist '("\\.kts\\'" . kotlin-ts-mode))
+
+(use-package gradle-mode :defer t :ensure t)

 (defun icejam-activate-kotlin-mode ()
  "All things Kotlin."
-  (icejam-set-indent 4)
+  (icejam-set-indent 2)
  (column-enforce-n 100)
-  (lsp)
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))

-  ;; Company list override
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
-
-(add-hook 'kotlin-mode-hook 'icejam-activate-kotlin-mode)
+(add-hook 'kotlin-ts-mode-hook 'icejam-activate-kotlin-mode)

 (provide 'icejam-lang-kotlin)
 ;;; icejam-lang-kotlin.el ends here
--- a/lisp/langs/icejam-lang-lean.el
+++ b/lisp/langs/icejam-lang-lean.el
@ -1,9 +1,7 @@
 ;;; lean -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
-(require 'icejam-prog-mode)
-(require 'icejam-lsp)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)

 (use-package lean4-mode
  :ensure (lean4-mode
@ -11,7 +9,6 @@
           :host github
           :repo "leanprover/lean4-mode"
           :files ("*.el" "data"))
-  :requires (lsp)
  :defer t)

 (defun icejam-activate-lean-mode ()
@ -19,13 +16,12 @@
  (interactive)

  ;; Run LSP
-  (lsp-deferred)
+  (eglot-ensure)

-  ;; Company list override
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
+  ;; Capf override
+  (icejam-set-eglot-capfs))

-(add-hook 'lean4-mode-hook 'icejam-activate-lean-mode)
+(add-hook 'lean4-mode-hook #'icejam-activate-lean-mode)

 (provide 'icejam-lang-lean)
 ;;; icejam-lang-lean.el ends here
--- a/lisp/langs/icejam-lang-lua.el
+++ b/lisp/langs/icejam-lang-lua.el
@ -0,0 +1,30 @@
+;;; icejam-lang-lua.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; Lua mode
+
+;;; Code:
+(eval-when-compile
+  (declare-function column-enforce-n 'column-enforce-mode (number))
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
+  (defvar icejam-language-transient-alist))
+
+(use-package lua-mode :ensure t :defer t)
+
+(defun icejam-activate-lua-mode ()
+  "All things related to Lua."
+  (icejam-set-indent 4)
+  (column-enforce-n 100)
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))
+
+(add-hook 'lua-mode-hook 'icejam-activate-lua-mode)
+
+(provide 'icejam-lang-lua)
+;;; icejam-lang-lua.el ends here
--- a/lisp/langs/icejam-lang-markdown.el
+++ b/lisp/langs/icejam-lang-markdown.el
@ -2,25 +2,36 @@
 ;;; Commentary:
 ;;; Code:

-(require 'icejam-prog-mode)
-(declare-function elpaca-installed-p "elpacs")
-(unless (elpaca-installed-p 'markdown-mode)
-  (use-package markdown-mode :ensure t))
+(eval-when-compile
+  (declare-function elpaca-installed-p "elpaca")
+  (declare-function column-enforce-n 'column-enforce-mode (number))
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function icejam-set-no-eglot-capfs 'icejam-prog-mode)
+  (declare-function rxt--re-builder-switch-pcre-mode "pcre2el"))

-(with-eval-after-load 'markdown-mode
-  (setq-default markdown-command "pandoc"))
+;; Markdown is a dependency of LSP mode. By wrapping it in unless we silence
+;; a warning from the byte compiler.
+(unless (elpaca-installed-p 'markdown-mode)
+  (use-package markdown-mode :ensure t :defer t
+    :commands (markdown-preview)
+    :config
+    ;; Render preview and open it in browser.
+    (keymap-set markdown-mode-map "C-c C-v" #'markdown-preview)
+
+    ;; Render HTML preview with pandoc
+    (setq-default markdown-command '("pandoc"
+                                     "-f"
+                                     "markdown_mmd"
+                                     "-t"
+                                     "html5"
+                                     "--template"
+                                     "github.html5"
+                                     "--highlight-style"
+                                     "pygments"))))

 (defun icejam-lang-activate-markdown-mode ()
  "Reconfigure markdown mode for your own purposes."
-  (icejam-set-indent 2)
-  (column-enforce-n 10000)
-
-  ;; Markdown mode reuses my bindings, remove them.
-  (define-key markdown-mode-map (kbd "C-c <left>") nil)
-  (define-key markdown-mode-map (kbd "C-c <right>") nil)
-  (define-key markdown-mode-map (kbd "C-c <up>") nil)
-  (define-key markdown-mode-map (kbd "C-c <down>") nil)
-  (define-key markdown-mode-map (kbd "C-c C-v") 'markdown-preview))
+  (icejam-set-indent 2))

 (add-hook 'markdown-mode-hook 'icejam-lang-activate-markdown-mode)
 (add-hook 'markdown-mode-hook 'display-line-numbers-mode)
--- a/lisp/langs/icejam-lang-ocaml.el
+++ b/lisp/langs/icejam-lang-ocaml.el
@ -1,13 +1,12 @@
 ;;; ocaml -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
-(require 'icejam-transient)
-(require 'icejam-prog-mode)
-(declare-function lsp "lsp-mode" nil)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
+(eval-when-compile (defvar icejam-language-transient-alist))

 (use-package merlin :defer t :ensure t)
-(use-package opam-switch-mode :defer t :ensure t)
+(use-package opam-switch-mode :defer t :ensure t :commands (opam-switch-mode))
 (use-package dune :defer t :ensure t)
 (use-package tuareg :defer t :ensure t)

@ -22,7 +21,7 @@
    ("i" "Indent"   icejam-mark-and-indent-whole-buffer)]
   [""
    ("f" "Format"   lsp-format-buffer)
-    ("e" "Errors"   flycheck-list-errors)
+    ("e" "Errors"   flymake-show-buffer-diagnostics)
    ("o" "Opam Env" opam-switch-set-switch)]]
  [""
   ("q" "Quit"      keyboard-quit)])
@ -48,7 +47,8 @@
  (icejam-set-indent 2)
  (opam-switch-mode t)
  (icejam-load-ocaml-site-packages)
-  (lsp))
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))

 (add-hook 'tuareg-mode-hook 'icejam-activate-tuareg-mode)

--- a/lisp/langs/icejam-lang-other.el
+++ b/lisp/langs/icejam-lang-other.el
@ -18,22 +18,21 @@
 (use-package nginx-mode :ensure t :defer t)
 (use-package
  jenkinsfile-mode
-  :ensure (:repo "https://github.com/john2x/jenkinsfile-mode.git" :branch "master")
+  :ensure (:repo "https://github.com/john2x/jenkinsfile-mode.git"
+                 :branch "master")
  :defer t)
-(use-package lua-mode :ensure t :defer t)

 ;; Graphql schema definition files.
 (use-package graphql-mode :ensure t :defer t
  :mode ("\\.graphqls\\'" . graphql-mode))

 ;; Yaml
-(declare-function lsp "lsp-mode" nil)
-(use-package yaml-mode :ensure t :defer t :requires (lsp))
+(use-package yaml-mode :ensure t :defer t)

 (with-eval-after-load 'yaml-mode
  (defun icejam-lang-activate-yaml-mode ()
    "Activate yaml-mode."
-    (lsp))
+    (eglot-ensure))
  (add-hook 'yaml-mode-hook 'icejam-lang-activate-yaml-mode))

 ;; Other text files
--- a/lisp/langs/icejam-lang-php.el
+++ b/lisp/langs/icejam-lang-php.el
@ -9,25 +9,23 @@
 ;; php related settings

 ;;; Code:
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
+(eval-when-compile (defvar icejam-language-transient-alist))

-(require 'icejam-prog-mode)
-(require 'icejam-flycheck)
-(require 'icejam-transient)
+(use-package php-mode :ensure t :defer t)

-(use-package php-mode
-  :requires (lsp-mode lsp-ui)
-  :ensure t)
-
-(transient-define-prefix icejam-lang-php/context-menu ()
+(transient-define-prefix icejam-lang-php-context-menu ()
  "PHP Buffer Commands."
  [""
   ["LSP"
-    ("m" "iMenu"       lsp-ui-imenu)]
+    ("m" "iMenu"       consult-imenu)]
   ["Buffer"
    ("r" "Reload"      icejam-revert-buffer-no-confirm)
-    ("f" "Format"      lsp-format-buffer)
+    ("f" "Format"      eglot-format-buffer)
    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)
-    ("e" "Show Errors" flycheck-list-errors)]]
+    ("e" "Show Errors" flymake-show-buffer-diagnostics)]]
  [""
   ("q" "Quit"        keyboard-quit)])

@ -37,11 +35,10 @@
  (icejam-set-indent 4)
  (column-enforce-n 80)

-  (define-key php-mode-map (kbd "C-c l") 'icejam-lang-php/context-menu)
+  (keymap-set php-mode-map "C-c l" #'icejam-lang-php-context-menu)

-  ;; Company list override
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
+  ;; Capf override
+  (icejam-set-eglot-capfs))

 (add-hook 'php-mode-hook 'icejam-lang-activate-php-mode)

--- a/lisp/langs/icejam-lang-purescript.el
+++ b/lisp/langs/icejam-lang-purescript.el
@ -6,12 +6,17 @@

 ;;; Commentary:

-;; purescript does a thing.
+;; Configuration for purescript.

 ;;; Code:
-(use-package purescript-mode
-  :requires (lsp-mode lsp-ui)
-  :ensure t)
+
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
+
+(use-package purescript-mode :ensure t :defer t)
+
+(declare-function purescript-indentation-mode "purescript-mode")

 (defun icejam-activate-purescript-mode ()
  "All things Purescript."
@ -21,9 +26,8 @@
  ;; Purescript indentation
  (purescript-indentation-mode t)

-  ;; Company list override
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
+  ;; Capf override
+  (icejam-set-eglot-capfs))

 (add-hook 'purescript-mode-hook 'icejam-activate-purescript-mode)

--- a/lisp/langs/icejam-lang-python.el
+++ b/lisp/langs/icejam-lang-python.el
@ -1,23 +1,24 @@
 ;;; python -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
-(require 'icejam-prog-mode)
-(require 'icejam-transient)
-
-(declare-function lsp nil)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
 (declare-function column-enforce-n "column-enforce-mode" (number))
+(declare-function transient-define-prefix 'transient)
+
+(eval-when-compile
+  (defvar icejam-language-transient-alist)
+  (defvar icejam-python-lang-menu))

 (transient-define-prefix icejam-python-lang-menu ()
  "Python Buffer Commands."
  [""
   ["LSP"
-    ("m" "iMenu"       lsp-ui-imenu)]
+    ("m" "iMenu"       consult-imenu)]
   ["Buffer"
    ("r" "Reload"      icejam-revert-buffer-no-confirm)
-    ("f" "Format"      lsp-format-buffer)
+    ("f" "Format"      eglot-format-buffer)
    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)
-    ("e" "Show Errors" flycheck-list-errors)]]
+    ("e" "Show Errors" flymake-show-buffer-diagnostics)]]
  [""
   ("q" "Quit"        keyboard-quit)])

@ -27,12 +28,11 @@

 (defun icejam-lang-activate-python-mode ()
  "Activate python mode."
-  (lsp)
+  (eglot-ensure)
  (column-enforce-n 99)

-  ;; Company list override
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
+  ;; Capf override
+  (icejam-set-eglot-capfs))

 (add-hook 'python-mode-hook 'icejam-lang-activate-python-mode)

--- a/lisp/langs/icejam-lang-ruby.el
+++ b/lisp/langs/icejam-lang-ruby.el
@ -2,9 +2,11 @@
 ;;; Commentary:
 ;;; Code:

-(require 'icejam-prog-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
+(eval-when-compile (defvar icejam-language-transient-alist))

-(use-package rspec-mode :ensure t :defer t)
+(use-package rspec-mode :ensure t :defer t :commands (rspec-install-snippets))
 (use-package ruby-end :ensure t :defer t)
 (use-package rbs-mode :ensure t :defer t)

@ -21,11 +23,10 @@
  (setq ruby-insert-encoding-magic-comment nil)

  ;; Start LSP
-  (lsp)
+  (eglot-ensure)

-  ;; Company list override
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
+  ;; Capf override
+  (icejam-set-eglot-capfs))

 (add-hook 'ruby-ts-mode-hook 'rspec-mode)
 (add-hook 'ruby-ts-mode-hook 'ruby-end-mode)
--- a/lisp/langs/icejam-lang-rust.el
+++ b/lisp/langs/icejam-lang-rust.el
@ -1,19 +1,27 @@
 ;;; rust -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
-(require 'icejam-prog-mode)
+(eval-when-compile
+  (declare-function column-enforce-n 'column-enforce-mode (number))
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point))

 (use-package rust-mode
  :ensure t
  :defer t
-  :config
-  (setq rust-mode-treesitter-derive t))
+  :config (setopt rust-mode-treesitter-derive t))
+
+(use-package rustic
+  :ensure t
+  :defer t
+  :after (rust-mode)
+  :config (setopt rustic-format-on-save nil)
+  (setopt rustic-lsp-client 'eglot))

 (use-package flycheck-rust
  :ensure t
  :defer t
-  :requires (rust-mode lsp))
+  :after (rust-mode lsp))

 (defun icejam-activate-rust-mode ()
  "All things for Rust mode."
@ -22,11 +30,8 @@
  (column-enforce-n 99)

  ;; Run LSP
-  (lsp-deferred)
-
-  ;; Company list override
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))

 (add-hook 'rust-mode-hook 'icejam-activate-rust-mode)
 (add-hook 'rust-mode-hook 'flycheck-rust-setup)
--- a/lisp/langs/icejam-lang-web.el
+++ b/lisp/langs/icejam-lang-web.el
@ -1,13 +1,7 @@
 ;;; web -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
-(require 'icejam-lsp)
-(require 'icejam-flycheck)
-
-(use-package web-mode
-  :requires (lsp-mode flycheck)
-  :ensure t)
+(use-package web-mode :ensure t :defer t)

 ;; Eex Web mode
 (add-to-list 'auto-mode-alist '("\\.eex\\'" . web-mode))
@ -33,16 +27,8 @@
 	(setq-local web-mode-markup-indent-offset 2)
  (setq-local lsp-eldoc-enable-hover nil)
  (setq-local flycheck-check-syntax-automatically '(save mode-enabled))
-
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet))
-
-	(when (string-match-p ".jsx" (buffer-file-name))
-		(lsp))
-	(when (string-match-p ".tsx" (buffer-file-name))
-		(lsp))
 	(when (string-match-p ".vue" (buffer-file-name))
-		(lsp)))
+    (eglot-ensure)))

 (add-hook 'web-mode-hook 'icejam-activate-web-mode)

--- a/lisp/langs/icejam-lang-ziglang.el
+++ b/lisp/langs/icejam-lang-ziglang.el
@ -9,9 +9,11 @@
 ;; ziglang does a thing.

 ;;; Code:
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)

-(use-package zig-mode :ensure t :defer t :requires (lsp))
+(use-package zig-mode :ensure t :defer t)

 (defun icejam-activate-zig-mode ()
  "Goodies for editing zig files."
@ -21,7 +23,8 @@

  ;; Set indentation to 4 chars
  (icejam-set-indent 4)
-  (lsp))
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))

 (add-hook 'zig-mode-hook 'icejam-activate-zig-mode)

--- a/lisp/themes/icejam-base16-catppuccin-latte.el
+++ b/lisp/themes/icejam-base16-catppuccin-latte.el
@ -0,0 +1,49 @@
+;; icejam-base16-catppuccin-latte.el -- A base16 colorscheme
+
+;;; Commentary:
+;; Base16: (https://github.com/tinted-theming/home)
+
+;;; Authors:
+;; Scheme: https://github.com/catppuccin/catppuccin
+;; Template: Kaleb Elwert <belak@coded.io>
+
+;;; Code:
+
+;; Modifications:
+;; 03 darker by 8% #bcc0cc => #aaafbe
+
+(eval-when-compile
+  (declare-function base16-theme-define "base16-theme" (theme-name theme-colors)))
+
+(defvar icejam-base16-catppuccin-latte-theme-colors
+  '(:base00 "#eff1f5"
+            :base01 "#e6e9ef"
+            :base02 "#ccd0da"
+            :base03 "#aaafbe"
+            :base04 "#acb0be"
+            :base05 "#4c4f69"
+            :base06 "#dc8a78"
+            :base07 "#7287fd"
+            :base08 "#d20f39"
+            :base09 "#fe640b"
+            :base0A "#df8e1d"
+            :base0B "#40a02b"
+            :base0C "#179299"
+            :base0D "#1e66f5"
+            :base0E "#8839ef"
+            :base0F "#dd7878")
+  "All colors for Base16 Catppuccin Latte are defined here.")
+
+;; Define the theme
+(deftheme icejam-base16-catppuccin-latte)
+
+;; Add all the faces to the theme
+(with-eval-after-load 'base16-theme
+  (base16-theme-define 'icejam-base16-catppuccin-latte
+                       icejam-base16-catppuccin-latte-theme-colors))
+
+;; Mark the theme as provided
+(provide-theme 'icejam-base16-catppuccin-latte)
+(provide 'icejam-base16-catppuccin-latte)
+
+;;; icejam-base16-catppuccin-latte.el ends here
--- a/lisp/themes/icejam-base16-modus-operandi-tinted.el
+++ b/lisp/themes/icejam-base16-modus-operandi-tinted.el
@ -0,0 +1,41 @@
+;;; base16-modus-operandi-tinded.el --- summary
+;;; Commentary:
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Code:
+
+(use-package icejam-themes :ensure nil)
+
+(defvar base16-modus-operandi-tinted-colors
+  '(:base00 "#fbf7f0"
+    :base01 "#efe9dd"
+    :base02 "#c9b9b0"
+    :base03 "#595959"
+    :base04 "#595959"
+    :base05 "#000000"
+    :base06 "#193668"
+    :base07 "#193668"
+    :base08 "#a60000"
+    :base09 "#006300"
+    :base0A "#006300"
+    :base0B "#0031a9"
+    :base0C "#721045"
+    :base0D "#00598b"
+    :base0E "#731c52"
+    :base0F "#80601f")
+  "All colors for Base16 Modus Operandi are defined here.")
+
+;; Define the theme
+(deftheme base16-modus-operandi-tinted)
+
+;; Add all the faces to the theme
+(declare-function base16-theme-define 'base16-theme)
+(base16-theme-define 'base16-modus-operandi-tinted base16-modus-operandi-tinted-colors)
+
+;; Mark the theme as provided
+(provide-theme 'base16-modus-operandi-tinted)
+(provide 'icejam-base16-modus-operandi-tinted)
+;;; icejam-base16-modus-operandi-tinted.el ends here
--- a/lisp/themes/icejam-base16-not-harmonic.el
+++ b/lisp/themes/icejam-base16-not-harmonic.el
@ -5,7 +5,7 @@
 ;; Based on harmonic-dark theme by Jannik Seibert (https://github.com/janniks)
 ;;; Code:

-(use-package base16-theme :ensure t :defer t)
+(use-package icejam-themes :ensure nil)

 (defvar base16-not-harmonic-colors
  '(:base00 "#102941"
@ -30,6 +30,7 @@
 (deftheme base16-not-harmonic)

 ;; Add all the faces to the theme
+(declare-function base16-theme-define 'base16-theme)
 (base16-theme-define 'base16-not-harmonic base16-not-harmonic-colors)

 ;; Customise things
--- a/lisp/themes/icejam-base16-summerfruit-light.el
+++ b/lisp/themes/icejam-base16-summerfruit-light.el
@ -7,7 +7,7 @@

 ;;; Code:

-(use-package base16-theme :ensure t :defer t)
+(use-package icejam-themes :ensure nil)

 (defvar base16-summerfruit-light-modified-colors
  '(:base00 "#fdfcfa"
@ -32,6 +32,7 @@
 (deftheme base16-summerfruit-light-modified)

 ;; Add all the faces to the theme
+(declare-function base16-theme-define 'base16-theme)
 (base16-theme-define 'base16-summerfruit-light-modified base16-summerfruit-light-modified-colors)

 ;; Mark the theme as provided
--- a/snippets/text-mode/dco-signoff
+++ b/snippets/text-mode/dco-signoff
@ -0,0 +1,4 @@
+# -*- mode: snippet -*-
+# name: dco-signoff
+# --
+Signed-off-by: Maciej Szlosarczyk (${1:maciej@sosek.net})
Author	SHA1	Message	Date
Maciej Szlosarczyk	1b64c05b0f	Shorten corfu completion delay Some checks failed / Test config on 20 (push) Failing after 56s Details	2026-01-22 15:26:15 +02:00
Maciej Szlosarczyk	b10acede86	Configure treemacs Some checks failed / Test config on 20 (push) Failing after 51s Details	2025-10-28 12:14:01 +02:00
Maciej Szlosarczyk	2ef1340e6c	Replace lsp-mode with eglot Some checks failed / Test config on 20 (push) Failing after 49s Details	2025-09-18 15:06:30 +03:00
Maciej Szlosarczyk	f03cae68b3	Update August 2025 Some checks failed / Test config on 20 (push) Failing after 51s Details	2025-08-04 11:39:09 +03:00
Maciej Szlosarczyk	ef16f1af55	Use new elpaca-write-lock-file function Some checks failed / Test config on 20 (push) Failing after 45s Details	2025-02-04 08:39:24 +02:00
Maciej Szlosarczyk	c2aebb5450	Some small comment change Some checks failed / Test config on 20 (push) Failing after 41s Details	2025-01-29 09:22:41 +02:00
Maciej Szlosarczyk	8242a27306	Fix compilation warning in avy Some checks failed / Test config on 20 (push) Failing after 47s Details	2025-01-29 08:17:02 +02:00
Maciej Szlosarczyk	ea0e8706f2	Remove BSD specific config and make HEEx formatter work Some checks failed / Test config on 20 (push) Failing after 46s Details	2025-01-28 08:11:57 +02:00
Maciej Szlosarczyk	67066dee3d	Add new theme and make lua a standalone lang module Some checks failed / Test config on 20 (push) Failing after 50s Details	2025-01-22 14:17:38 +02:00
Maciej Szlosarczyk	62a523fbec	Update elpaca that broke after FSF servers broke Some checks failed / Test config on 20 (push) Failing after 46s Details	2025-01-20 09:47:01 +02:00
Maciej Szlosarczyk	87913bbd6a	More config changes Some checks failed / Test config on 20 (push) Failing after 57s Details	2025-01-18 21:09:06 +02:00
Maciej Szlosarczyk	118cf92a27	Make loading faster by eliminating require blocks Some checks failed / Test config on 20 (push) Failing after 45s Details	2025-01-17 10:22:38 +02:00
Maciej Szlosarczyk	3641dad52a	Configure transients Some checks failed / Test config on 20 (push) Failing after 50s Details	2025-01-16 19:22:00 +02:00
Maciej Szlosarczyk	040ffa7cb3	Remove icejam-blocking file Some checks failed / Test config on 20 (push) Failing after 42s Details	2025-01-15 14:46:32 +02:00
Maciej Szlosarczyk	eb58a51bab	Cleanup Some checks failed / Test config on 20 (push) Failing after 42s Details	2025-01-15 11:06:47 +02:00
Maciej Szlosarczyk	2150285aea	fix problem with lispy not loading Some checks failed / Test config on 20 (push) Failing after 44s Details	2025-01-09 09:26:38 +02:00
Maciej Szlosarczyk	3c59ad8bbc	Remove some packages that do not work properly	2025-01-07 18:59:09 +02:00
Maciej Szlosarczyk	d7e51e32d5	use corfu	2025-01-07 18:55:07 +02:00
Maciej Szlosarczyk	a0500746f4	Working corfu setup without company	2025-01-07 14:25:33 +02:00
Maciej Szlosarczyk	b9559eabe0	Replace company-box with kind-icons Some checks failed / Test config on 20 (push) Failing after 49s Details It makes icons also appear in the terminal	2025-01-07 08:04:41 +02:00
Maciej Szlosarczyk	d260817105	Make gcmh deferred Some checks failed / Test config on 20 (push) Failing after 44s Details	2025-01-06 19:59:33 +02:00
Maciej Szlosarczyk	46b86fc5a9	Make diminish non-blocking Some checks failed / Test config on 20 (push) Failing after 37s Details Further lowers the startup time	2025-01-06 11:36:39 +02:00
Maciej Szlosarczyk	0ec8f700af	Fix bug in exec-path-from-shell hook, simplify font setup Some checks failed / Test config on 20 (push) Failing after 48s Details	2025-01-05 17:34:12 +02:00
Maciej Szlosarczyk	b0361861b4	Further housekeeping, bring the initial load down to under 1500 ms Some checks failed / Test config on 20 (push) Failing after 53s Details Make the editor load faster by deferring as much as possible until later use. For example, LSP load is now deferred until first use and no longer blocking. Use only elixir-format from elixir-mode, for similar speed reasons. The rest of the package has been taken over by the treesitter version of the mode.	2025-01-05 08:07:18 +02:00
Maciej Szlosarczyk	3ffb484fd8	Housekeeping Some checks failed / Test config on 20 (push) Failing after 44s Details - Keep longer undo data, I have run into situations where the history is too short. - Clean up undo/redo key bindings. - Try to make the dashboard package load async and faster. I have seen it block more than once.	2025-01-02 07:58:01 +02:00
Maciej Szlosarczyk	bd87a9f883	Add Aider and change font to other Iosevka Some checks failed / Test config on 20 (push) Failing after 47s Details	2024-12-27 07:59:52 +02:00
Maciej Szlosarczyk	3d47b6e70f	Update packages Some checks failed / Test config on 20 (push) Failing after 46s Details	2024-12-15 10:41:05 +02:00
Maciej Szlosarczyk	4be55a9351	Update packages Some checks failed / Test config on 20 (push) Failing after 47s Details	2024-12-04 10:13:06 +02:00
Maciej Szlosarczyk	d1ee6a12ed	Use TS mode for Kotlin Some checks failed / Test config on 20 (push) Failing after 49s Details	2024-11-24 15:30:05 +02:00
Maciej Szlosarczyk	34a2741886	Update packages All checks were successful / Test config on 20 (push) Successful in 27s Details	2024-11-11 07:58:11 +02:00
Maciej Szlosarczyk	d15b0776b0	Update elpaca All checks were successful / Test config on 20 (push) Successful in 28s Details	2024-11-07 17:07:28 +02:00
Maciej Szlosarczyk	42ccce60bd	Minor changes All checks were successful / Test config on 20 (push) Successful in 27s Details	2024-11-04 08:05:39 +02:00
Maciej Szlosarczyk	a68257ee41	Prefer setopt to :custom from use-package All checks were successful / Test config on 20 (push) Successful in 26s Details The following does not provide completion for variables: (use-package thing :custom (thing-thing :ok))	2024-10-31 14:36:47 +02:00
Maciej Szlosarczyk	ba82470bea	No workey All checks were successful / Test config on 20 (push) Successful in 24s Details	2024-10-30 14:41:35 +02:00