Shorten corfu completion delay

It makes icons also appear in the terminal

.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

.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

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
+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.
-* Ruby
-* Rust
-* Markdown
-* HTML and compatibile (ERB)
-
-As of current iteration, I avoid usage of Evil modes, instead focusing of usage of Emacs functionality.
 
 ## 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)
 ```

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

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

lisp/icejam-avy.el

@@ -8,11 +8,12 @@
 
 ;; Avy is a navigation manager.
 
-;;; Code:
+(eval-when-compile (defvar icejam-keys-mode-map))
-(require 'icejam-keys-mode)
 
+;;; 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)))

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)
+(use-package tramp :ensure nil :defer 5
-(setopt tramp-default-method "ssh")
+  :config
+  (setopt tramp-default-method "ssh"))
 
 ;;;;;;;;; Emacs bindings ;;;;;;;;;;;;;;;;;;;;;
 (global-set-key (kbd "RET") 'newline)
@@ -48,32 +50,38 @@
 (use-package buffer-move :ensure t :defer t)
 
 ;; Garbage collection magic hack
-(use-package gcmh :ensure t
+(use-package gcmh :ensure t :defer t
-  :custom ((gcmh-verbose nil "Do not log GC messages.")
+  :commands (gcmh-mode)
-           (gcmh-idle-delay 'auto "Compute GC delay based on gcmh-auto-idle-delay-factor")
+  :hook ((elpaca-after-init . (lambda () (gcmh-mode t))))
-           (gcmh-auto-idle-delay-factor 10 "Original value was 10"))
   :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
-      `((".*" . "~/.emacs.d/backups/auto-save-list")))
+        `((".*" . "~/.emacs.d/backups/auto-save-list")))
 (setopt auto-save-file-name-transforms
       `((".*", "~/.emacs.d/backups/auto-save-list" t)))
 
 (setopt backup-by-copying t)
 (setopt delete-old-versions t
-  kept-new-versions 6
+  kept-new-versions 10
-  kept-old-versions 2
+  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)
+(dolist (mode '(prog-mode-hook
-(add-hook 'text-mode-hook 'display-line-numbers-mode)
+                text-mode-hook
-(add-hook 'conf-mode-hook 'display-line-numbers-mode)
+                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"))
+  (dolist (var '("DEFT_PATH" "LANG" "LC_CTYPE"))
-      (add-to-list 'exec-path-from-shell-variables var))
+    (add-to-list 'exec-path-from-shell-variables var)))
-    (exec-path-from-shell-initialize))
 
-(use-package direnv :ensure t
+(use-package direnv :ensure t :defer t
-  :config
+  :hook ((elpaca-after-init . direnv-mode)))
-  (declare-function direnv-mode "direnv")
-  (direnv-mode t))
 
 ;; 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
+  :config (setopt treemacs-tag-follow-delay 1.0))
-  (treemacs-follow-mode t)
-  (treemacs-project-follow-mode t))
 
 (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")
+  (setopt keyfreq-file (concat user-emacs-directory "emacs.keyfreq")))
-  (declare-function keyfreq-autosave-mode "keyfreq")
-  (keyfreq-mode t)
-  (keyfreq-autosave-mode t))
 
 ;;;;;;;;;;;;;;;;; Show hints about key combinations
-(use-package which-key :ensure t
+(use-package which-key :ensure nil :defer t
-  :custom (which-key-idle-delay 0.5)
+  :hook ((elpaca-after-init . which-key-mode))
-  :config (which-key-mode t))
+  :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

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

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

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

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:
-
+(eval-when-compile (defvar icejam-keys-mode-map))
-(require 'icejam-keys-mode)
 
 ;; 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
+(use-package vertico :ensure t :defer t
-  :custom ((vertico-scroll-margin 1 "Scroll on N-1")
+  :hook ((elpaca-after-init . vertico-mode))
-           (vertico-count 15 "Show 5 more candidates")
-           (vertico-resize t "Grow and shrink the vertico minibufffer")
-           (vertico-cycle t "Cycle completion"))
   :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)
+  :config
-                              "Fallback to basic if orderless does not work.")
+  ;; Fallback to basic if orderless does not work.
-           (completion-category-defaults nil)
+  (setopt completion-styles '(orderless basic))
-           (completion-category-overrides
+  (setopt completion-category-defaults nil)
-            '((file (styles partial-completion))))))
+  (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

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

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)
+(use-package icejam-keys-mode :ensure nil)
-(require 'icejam-blocking)
+(use-package icejam-base :ensure nil)
-(require 'icejam-base)
+(use-package icejam-sys-specific :ensure nil)
-(require 'icejam-sys-specific)
+(use-package icejam-tree-sitter :ensure nil)
-(require 'icejam-tree-sitter)
+(use-package icejam-completing-read :ensure nil)
-(require 'icejam-completing-read)
+(use-package icejam-avy :ensure nil)
-(require 'icejam-avy)
+(use-package icejam-transient :ensure nil)
-(require 'icejam-transient)
+(use-package icejam-prog-mode :ensure nil)
-(require 'icejam-prog-mode)
+(use-package icejam-complete-at-point :ensure nil)
-(require 'icejam-company-yasnippet)
+(use-package icejam-aider :ensure nil)
-(require 'icejam-copilot)
+(use-package icejam-flycheck :ensure nil)
-(require 'icejam-flycheck)
+(use-package icejam-ispell :ensure nil)
-(require 'icejam-ispell)
+(use-package icejam-deft :ensure nil)
-(require 'icejam-deft)
+(use-package icejam-eglot :ensure nil)
-(require 'icejam-lsp)
+(use-package icejam-dashboard :ensure nil)
-(require 'icejam-dashboard)
+(use-package icejam-magit :ensure nil)
-(require 'icejam-magit)
+(use-package icejam-vundo :ensure nil)
-(require 'icejam-vundo)
+(use-package icejam-speed-type :ensure nil)
-(require 'icejam-speed-type)
 
 ;; Themes
-(require 'icejam-themes)
+(use-package icejam-themes :ensure nil)
-(require 'icejam-fonts)
+(use-package icejam-fonts :ensure nil)
 
 ;; Actual supported languages and file syntax.
-(require 'icejam-lang-clang)
+(use-package icejam-lang-clang :ensure nil)
-(require 'icejam-lang-clojure)
+(use-package icejam-lang-clojure :ensure nil)
-;; (require 'icejam-lang-common-lisp)
+(use-package icejam-lang-dart :ensure nil)
-(require 'icejam-lang-dart)
+(use-package icejam-lang-dhall :ensure nil)
-(require 'icejam-lang-dhall)
+(use-package icejam-lang-elisp :ensure nil)
-(require 'icejam-lang-elisp)
+(use-package icejam-lang-elixir :ensure nil)
-(require 'icejam-lang-elixir)
+(use-package icejam-lang-erlang :ensure nil)
-(require 'icejam-lang-erlang)
+(use-package icejam-lang-fsharp :ensure nil)
-(require 'icejam-lang-fsharp)
+(use-package icejam-lang-gleam :ensure nil)
-(require 'icejam-lang-gleam)
+(use-package icejam-lang-golang :ensure nil)
-(require 'icejam-lang-golang)
+(use-package icejam-lang-haskell :ensure nil)
-(require 'icejam-lang-haskell)
+(use-package icejam-lang-javascript :ensure nil)
-(require 'icejam-lang-javascript)
+(use-package icejam-lang-kotlin :ensure nil)
-(require 'icejam-lang-kotlin)
+;; (use-package icejam-lang-lean :ensure nil)
-(require 'icejam-lang-lean)
+(use-package icejam-lang-lua :ensure nil)
-(require 'icejam-lang-markdown)
+(use-package icejam-lang-markdown :ensure nil)
-(require 'icejam-lang-ocaml)
+(use-package icejam-lang-ocaml :ensure nil)
-(require 'icejam-lang-other)
+(use-package icejam-lang-other :ensure nil)
-(require 'icejam-lang-php)
+(use-package icejam-lang-php :ensure nil)
-(require 'icejam-lang-purescript)
+(use-package icejam-lang-purescript :ensure nil)
-(require 'icejam-lang-python)
+(use-package icejam-lang-python :ensure nil)
-(require 'icejam-lang-ruby)
+(use-package icejam-lang-ruby :ensure nil)
-(require 'icejam-lang-rust)
+(use-package icejam-lang-rust :ensure nil)
-(require 'icejam-lang-sh)
+(use-package icejam-lang-sh :ensure nil)
-(require 'icejam-lang-web)
+(use-package icejam-lang-web :ensure nil)
-(require 'icejam-lang-ziglang)
+(use-package icejam-lang-ziglang :ensure nil)
 
 ;; Diminish modeline litter
-(require 'icejam-diminish)
+(use-package icejam-diminish :ensure nil)
-
-;; Restore GC to normal, but still high
-(setopt gc-cons-threshold 200000000)
-(setopt gc-cons-percentage 0.2)
 
 (provide 'icejam-custom-init)
 ;;; icejam-custom-init.el ends here

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
+  :hook ((elpaca-after-init . dashboard-open))
-  ((elpaca-after-init . dashboard-open))
+  :config
-  :custom
+  ;; setopt gives a warning here, so let's use setq
-  ((dashboard-footer-messages '("Happy coding!" "I showed you my source code, pls respond"))
+  (setq dashboard-footer-messages '("Happy coding!"
-   (dashboard-startup-banner 'logo)
+                                    "I showed you my source code, pls respond"))
-   (dashboard-items '((recents  . 5)
+  (setopt dashboard-startup-banner 'logo)
-                      ;; (bookmarks . 5)
+  (setopt dashboard-items '((recents  . 5)
-                      ;; (agenda . 5)
+                            ;; (bookmarks . 5)
-                      ;; (registers . 5)
+                            ;; (agenda . 5)
-                      (projects . 5))))
+                            ;; (registers . 5)
-  :config (dashboard-setup-startup-hook))
+                            (projects . 5)))
+  (dashboard-setup-startup-hook))
 
 (provide 'icejam-dashboard)
 ;;; icejam-dashboard.el ends here

lisp/icejam-deft.el

@@ -3,24 +3,21 @@
 ;;; Notational velocity, backed by OneDrive.
 ;;; Code:
 
-(require 'icejam-keys-mode)
+(use-package deft :ensure t :defer t
-(require 'icejam-transient)
+  :config
-
+  (setopt deft-directory (substitute-in-file-name "$DEFT_PATH")
-(use-package deft :ensure t
+          deft-default-extension "md"
-  :custom
+          deft-ignore-file-regexp "\\._[0-9-A-Z_]+\\.md$"
-  ((deft-directory (substitute-in-file-name "$DEFT_PATH"))
+          deft-strip-summary-regexp (concat "\\("
-   (deft-default-extension "md")
+                                          "[\n\t]" ;; blank
-   (deft-ignore-file-regexp "\\._[0-9-A-Z_]+\\.md$")
+                                          "\\|^:[[:ascii:]]+:.*$" ;; org-mode properties string
-   (deft-strip-summary-regexp (concat "\\("
+                                          "\\|^Title:.*$" ;; Title string
-                                      "[\n\t]" ;; blank
+                                          "\\|^title:.*$" ;; title string
-                                      "\\|^:[[:ascii:]]+:.*$" ;; org-mode properties string
+                                          "\\|^\\[\\[file:.*$" ;; org-mode inline-images
-                                      "\\|^Title:.*$" ;; Title string
+                                          ;; org-mode properties
-                                      "\\|^title:.*$" ;; title string
+                                          ;; "\\|:PROPERTIES:\n\\(.+\n\\)+:END:\n" ;;
-                                      "\\|^\\[\\[file:.*$" ;; org-mode inline-images
+                                          "\\)")
-                                      ;; org-mode properties
+          deft-auto-save-interval 30.0))
-                                      ;; "\\|:PROPERTIES:\n\\(.+\n\\)+:END:\n" ;;
-                                      "\\)"))
-   (deft-auto-save-interval 30.0)))
 
 (provide 'icejam-deft)
 ;;; icejam-deft.el ends here

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 :defer t :commands (diminish))
-;; (use-package diminish :ensure t)
 
-(with-eval-after-load 'diminish
+(defun icejam-diminish-modes ()
-  (with-eval-after-load 'flyspell (diminish 'flyspell-mode))
+  "Diminish selected modes."
-  (with-eval-after-load 'flycheck (diminish 'flycheck-mode))
+  (dolist (package-and-mode '((flyspell flyspell-mode)
-  (with-eval-after-load 'rainbow-mode (diminish 'rainbow-mode))
+                              (flycheck flycheck-mode)
-  (with-eval-after-load 'undo-tree (diminish 'undo-tree-mode))
+                              (rainbow-mode rainbow-mode)
-  (with-eval-after-load 'company (diminish 'company-mode))
+                              (undo-tree undo-tree-mode)
-  (with-eval-after-load 'which-key (diminish 'which-key-mode))
+                              (which-key which-key-mode)
-  (with-eval-after-load 'eldoc (diminish 'eldoc-mode))
+                              (eldoc eldoc-mode)
-  (with-eval-after-load 'yasnippet (diminish 'yas-minor-mode))
+                              (yasnippet yas-minor-mode)
-  (with-eval-after-load 'whitespace (diminish 'whitespace-mode))
+                              (whitespace whitespace-mode)
-  (with-eval-after-load 'autorevert (diminish 'auto-revert-mode))
+                              (autorevert auto-revert-mode)
-  (with-eval-after-load 'ivy (diminish 'ivy-mode))
+                              (ivy ivy-mode)
-  (with-eval-after-load 'company-box (diminish 'company-box-mode))
+                              (smerge-mode smerge-mode)
-  (with-eval-after-load 'smerge-mode (diminish 'smerge-mode))
+                              (gcmh gcmh-mode)))
-  (with-eval-after-load 'gcmh (diminish '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

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

lisp/icejam-flycheck.el

@@ -2,28 +2,67 @@
 ;;; Commentary:
 ;;; Code:
 
-;; Use flycheck globally to check syntax and compile languages
+;; Use flycheck checks with flymake.
-(use-package flycheck :ensure t
+(use-package flymake-flycheck :ensure t :defer t :config
-  :custom ((flycheck-emacs-lisp-load-path 'inherit))
+(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)
+  ;; Show the diagnostics from flymake in a second window (usually on the
-  (setopt flycheck-emacs-lisp-load-path 'inherit)
+  ;; opposite side from this one) instead of at the bottom of the current one.
-  (unbind-key "C-c ! C-c" flycheck-mode-map)
+  ;; Essentially revert the interesting part of this commit:
-  (unbind-key "C-c ! C-w" flycheck-mode-map)
+  ;; https://github.com/emacs-mirror/emacs/commit/419550c7907275bf962986e1cc8fba1989d8659c
-  (unbind-key "C-c ! ?" flycheck-mode-map)
+  (el-patch-feature 'flymake)
-  (unbind-key "C-c ! C" flycheck-mode-map)
+  (with-eval-after-load 'flymake
-  (unbind-key "C-c ! H" flycheck-mode-map)
+    (el-patch-defun flymake-show-project-diagnostics ()
-  (unbind-key "C-c ! V" flycheck-mode-map)
+      "Show a list of Flymake diagnostics for the current project."
-  (unbind-key "C-c ! c" flycheck-mode-map)
+      (interactive)
-  (unbind-key "C-c ! e" flycheck-mode-map)
+      (let* ((prj (project-current))
-  (unbind-key "C-c ! h" flycheck-mode-map)
+             (root (project-root prj))
-  (unbind-key "C-c ! i" flycheck-mode-map)
+             (buffer (flymake--project-diagnostics-buffer root)))
-  (unbind-key "C-c ! l" flycheck-mode-map)
+        (with-current-buffer buffer
-  (unbind-key "C-c ! n" flycheck-mode-map)
+          (flymake-project-diagnostics-mode)
-  (unbind-key "C-c ! p" flycheck-mode-map)
+          (setq-local flymake--project-diagnostic-list-project prj)
-  (unbind-key "C-c ! s" flycheck-mode-map)
+          (display-buffer (current-buffer))
-  (unbind-key "C-c ! v" flycheck-mode-map)
+          (revert-buffer))))
-  (unbind-key "C-c ! x" flycheck-mode-map))
+
+    (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

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"
+(defconst icejam-default-font-family "Iosevka Term" "Default font.")
-  "Default font.")
+(defconst icejam-variable-font-family "Lexica Ultralegible" "Variable pitch font.")
-(defconst icejam-font-size 14
+(defconst icejam-markdown-font-family "Iosevka Comfy Motion"
-  "Default size of then font.
+  "Font used to render code blocks in markdown.
-It is used to calculated the size in relation to the screen
+It is different than default font to keep it visually distinct.")
-in icejam-set-font-to-screen.")
 
-(defcustom icejam-mut-font
+;; Require dash functions to be included:
-  icejam-font
+(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
+(defcustom icejam-mut-variable-font-family
-  icejam-font-size
+  icejam-default-font-family
-  "Current font size."
+  "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
+              (set-face-attribute 'default frame
-               'default frame :font
+                                  :family icejam-mut-default-font-family
-               (format "%s %d" icejam-mut-font (- icejam-mut-font-size 2))))))
+                                  :height (-> icejam-mut-font-height
+                                              (- 2)
+                                              (* 10))))))
 
-(defun icejam-set-font (name size)
+(defun icejam-set-font (family height)
-  "Set font to NAME and its SIZE to X pixels."
+  "Set font to FAMILY and its HEIGHT to X.
-  (interactive "sNew font: \nnEnter size for %s: ")
-  (setopt icejam-mut-font name)
-  (setopt icejam-mut-font-size size)
 
-  (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
+Modeline faces (`mode-line' and `mode-line-inactive') look better if they are
-  ;; the general font
+two points smaller."
-  ;; (set-face-attribute
+  (interactive "sNew font: \nnEnter height for %s: ")
-  ;;  'markdown-code-face nil :font (format "%s %d" name (- size 1)))
+  (setopt icejam-mut-default-font-family family)
-  (set-face-attribute
+  (setopt icejam-mut-font-height height)
-   'tooltip nil :font (format "%s %d" name (- size 1)))
+  (setopt icejam-mut-variable-font-family icejam-variable-font-family)
-  (set-face-attribute
+
-   'company-tooltip nil :font (format "%s %d" name (- size 1)))
+  ;; Set default font.
-  (set-face-attribute
+  (set-face-attribute 'default nil
-   'company-tooltip-annotation nil :font (format "%s %d" name (- size 1)))
+                      :family family
-  (set-face-attribute
+                      :height (-> height
-   'company-tooltip-mouse nil :font (format "%s %d" name (- size 1)))
+                                  (* 10)))
-  (set-face-attribute
+
-   'mode-line nil :font (format "%s %d" name (- size 1)))
+  ;; Set variable-pitch font
-  (set-face-attribute
+  (set-face-attribute 'variable-pitch nil
-   'mode-line-inactive nil :font (format "%s %d" name (- size 1)))
+                      :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."
+  "Automatically set font height to suit the monitor."
-  ;; If display is set to emulate FullHD resultion or less, make the font
-  ;; smaller.
   (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
+  ;; Only do anything if there's a display at all.
-        ((>= 1080 (x-display-pixel-height))
+  (if (x-display-list)
-         (icejam-set-font icejam-font icejam-font-size))
+      (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
+         ;; 27" screen connected to a MacBook.
-        ((>= 1120 (x-display-pixel-height))
+         ((>= 1440 pixel-height)
-         (icejam-set-font icejam-font icejam-font-size))
+          (icejam-set-font icejam-default-font-family (+ icejam-font-height 3)))
 
-        ((>= 1440 (x-display-pixel-height))
+         ;; 4K screen on Windows or Linux
-         (icejam-set-font icejam-font (+ icejam-font-size 3)))
+         ((>= 2160 pixel-height)
+          (icejam-set-font icejam-default-font-family (- icejam-font-height 3)))))))
 
-        ((>= 1920 (x-display-pixel-height))
+;; Run the above function once, after elpaca finishes all downloads.
-         (icejam-set-font icejam-font icejam-font-size))
+(add-hook 'elpaca-after-init-hook 'icejam-set-font-to-screen)
 
-        ;; 4K screen on Windows or Linux
+(defun icejam-set-font-height (height)
-        ((>= 2160 (x-display-pixel-height))
+  "Set font to a specified HEIGHT."
-         (icejam-set-font icejam-font (- icejam-font-size 3)))
+  (interactive "nEnter height for font: ")
+  (icejam-set-font icejam-mut-default-font-family height))
 
-        ;; Default
+(defun icejam-set-font-height-for-this-frame (new-height)
-        (t (icejam-set-font icejam-font (- icejam-font-size 3)))))
+  "Set font NEW-HEIGHT for this frame only."
-
+  (interactive "nEnter new height for font in this frame: ")
-;; Do it automatically on startup
+  (set-frame-font (format "%s %d" icejam-mut-default-font-family new-height)))
-(icejam-set-font-to-screen)
-
-(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))
 
 (provide 'icejam-fonts)
 ;;; icejam-fonts.el ends here

lisp/icejam-ispell.el

@@ -3,12 +3,10 @@
 ;;; Highlight misspelled words
 ;;; Code:
 
-
+(use-package ispell :ensure nil :defer t
-
+  :config
-(use-package ispell :ensure nil
+  (setopt ispell-program-name "aspell")
-  :custom
+  (setopt ispell-extra-args '("--run-together" "--run-together-limit=5" "--run-together-min=2")))
-  ((ispell-program-name "aspell")
-   (ispell-extra-args '("--run-together" "--run-together-limit=5" "--run-together-min=2"))))
 
 (use-package flyspell :ensure nil
   :hook ((prog-mode . flyspell-mode)

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 ;;;;;;;;;;;;;;;;;;;;;
+;; Move between windows
-(define-key icejam-keys-mode-map [home] 'beginning-of-line)
+(keymap-set icejam-keys-mode-map "C-c <left>" #'windmove-left)
-(define-key icejam-keys-mode-map [end] 'end-of-line)
+(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
+(keymap-set key-translation-map "<f6>" "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
+(keymap-set key-translation-map "<f7>" "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 "<f8>" "C-c p") ;; On F8, send C-c p
 
 (provide 'icejam-keys-mode)
 ;;; icejam-keys-mode.el ends here

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

lisp/icejam-magit.el

@@ -2,17 +2,18 @@
 ;;; 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)
               ("<f5> b" . magit-blame-addition)
               ("<f5> g" . magit-status))
-        (:map magit-blame-mode-map
+  (:map magit-blame-mode-map
-              ("<f5> b" . 'magit-blame-quit)))
+        ("<f5> b" . 'magit-blame-quit)))
 
 (provide 'icejam-magit)
 ;;; icejam-magit.el ends here

lisp/icejam-prog-mode.el

@@ -12,44 +12,42 @@
 (global-eldoc-mode t)
 
 ;; Revert tag tables without asking
-(use-package etags :ensure nil
+(use-package etags :ensure nil :defer t
-  :custom (tags-revert-without-query t "Revert tag tables without asking"))
+  :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))
+         (text-mode . rainbow-delimiters-mode)
-  :config
+         (elpaca-after-init . electric-pair-mode)
-  (electric-pair-mode t)
+         (elpaca-after-init . show-paren-mode)))
-  (show-paren-mode t))
 
 ;;; 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)
+(use-package dash-at-point :ensure t :defer t
-(with-eval-after-load 'dash-at-point
+  :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
+;; By default, use 2 spaces for indentation
-  :config
+(icejam-set-indent 2)
-  (declare-function global-column-enforce-mode "column-enforce-mode")
+
-  (global-column-enforce-mode t))
+(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)
+(use-package visual-regexp-steroids :ensure t
-  :custom (vr/engine 'pcre2el "Use pcre2el for regexes"))
+  :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

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) ;;;;;;;;;;;;;;;;;;
+      ;; Mac binding (fix)
-      (define-key icejam-keys-mode-map (kbd "H-<right>") #'end-of-line)
+      (keymap-set icejam-keys-mode-map "H-<right>" #'end-of-line)
-      (define-key icejam-keys-mode-map (kbd "H-<left>") #'beginning-of-line)
+      (keymap-set icejam-keys-mode-map "H-<left>" #'beginning-of-line)
-      (define-key icejam-keys-mode-map (kbd "H-<up>") #'scroll-down) ; WTF is this reverse, I dunno
+      (keymap-set icejam-keys-mode-map "H-<up>" #'scroll-down) ; WTF is this reverse, I dunno
-      (define-key icejam-keys-mode-map (kbd "H-<down>") #'scroll-up)
+      (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
+      (keymap-set icejam-keys-mode-map "H-a" #'mark-whole-buffer) ;; Select all
-      (define-key icejam-keys-mode-map [(hyper v)] #'yank) ;; Paste
+      (keymap-set icejam-keys-mode-map "H-v" #'yank) ;; Paste
-      (define-key icejam-keys-mode-map [(hyper x)] #'kill-region) ;; Cut
+      (keymap-set icejam-keys-mode-map "H-x" #'kill-region) ;; Cut
-      (define-key icejam-keys-mode-map [(hyper c)] #'kill-ring-save) ;; Copy
+      (keymap-set icejam-keys-mode-map "H-c" #'kill-ring-save) ;; Copy
-      (define-key icejam-keys-mode-map [(hyper s)] #'save-buffer) ;; Save
+      (keymap-set icejam-keys-mode-map "H-s" #'save-buffer) ;; Save
-      (define-key icejam-keys-mode-map [(hyper z)] #'undo) ;; Undo
+      (keymap-set icejam-keys-mode-map "H-z" #'undo) ;; Undo
-      (define-key icejam-keys-mode-map [(hyper q)] #'kill-emacs) ;; Close emacs
+      (keymap-set icejam-keys-mode-map "H-Z" #'undo-redo) ;; Redo
-      (define-key icejam-keys-mode-map [(hyper w)] #'icejam-function-delete-window) ;; Close window
+      (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
+      ;; Save and undo
-      (define-key icejam-keys-mode-map (kbd "s-s") 'save-buffer)
+      (keymap-set icejam-keys-mode-map "s-s" #'save-buffer)
-      (define-key icejam-keys-mode-map (kbd "s-z") 'undo)
+      (keymap-set icejam-keys-mode-map "s-z" #'undo)
-      (define-key icejam-keys-mode-map (kbd "s-a") 'mark-whole-buffer)
+      (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 ;;;;;;;;;;;;;;;;;;
+      ;; Copy and paste bindings
-      (define-key icejam-keys-mode-map (kbd "s-x") 'kill-region)
+      (keymap-set icejam-keys-mode-map "s-x" #'kill-region)
-      (define-key icejam-keys-mode-map (kbd "s-v") 'yank)
+      (keymap-set icejam-keys-mode-map "s-v" #'yank)
-      (define-key icejam-keys-mode-map (kbd "s-c") 'kill-ring-save)
+      (keymap-set icejam-keys-mode-map "s-c" #'kill-ring-save)
 
-      ;;;;;;;;; Linux Ergo bindings (fix) ;;;;;;;;;;;;;;;;;;
+      ;; Linux Ergo bindings (fix)
-      (define-key icejam-keys-mode-map (kbd "C-<right>") 'end-of-line)
+      (keymap-set icejam-keys-mode-map "C-<right>" #'end-of-line)
-      (define-key icejam-keys-mode-map (kbd "C-<left>") 'beginning-of-line)
+      (keymap-set icejam-keys-mode-map "C-<left>" #'beginning-of-line)
-      (define-key icejam-keys-mode-map (kbd "C-<up>") 'scroll-down) ; WTF is this reverse, I dunno
+      (keymap-set icejam-keys-mode-map "C-<up>" #'scroll-down) ; WTF is this reverse, I dunno
-      (define-key icejam-keys-mode-map (kbd "C-<down>") 'scroll-up)))
+      (keymap-set icejam-keys-mode-map "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))))
 
 (provide 'icejam-sys-specific)
 ;;; icejam-sys-specific.el ends here

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
+(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 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)

lisp/icejam-transient.el

@@ -2,11 +2,9 @@
 ;;; Commentary:
 ;;; Global Transient definitions.
 ;;; Code:
+(eval-when-compile (defvar icejam-keys-mode-map))
 
-(require 'icejam-avy)
+(use-package transient :ensure (:wait t))
-(require 'icejam-keys-mode)
-(require 'icejam-blocking)
-;; (use-package transient :ensure (:wait t) :demand 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)
-    ("s" "Switch project"       project-switch-project)
     ("f" "Find file in project" project-find-file)
-    ("g" "Grep in project"      consult-ripgrep)]
+    ("g" "Grep in project" consult-ripgrep)
-   ["Completions"
+    ("t" "Find file anywhere" find-file)]
-    ("a" "Grep in buffer"       consult-line)
-    ("b" "Buffer list"          consult-buffer)
-    ("t" "Find file"            find-file)]
    ["Magit"
-    ("m" "Git status"           magit-status)
+    ("m" "Git status" magit-status)
-    ("C" "Git checkout"         magit-checkout)
+    ("C" "Git checkout" magit-checkout)
-    ("M" "Git blame"            magit-blame)]]
+    ("M" "Git blame" magit-blame)]
-  [""
+   ["Completions"
-   ["LISP"
+    ("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)]
+    ("i" "Indent"             indent-region)]]
-   ["Complete"
+  [["Complete"
-    ("y" "Snippet"            company-yasnippet)
+    ("g" "Ask GPTel"             gptel-menu)
-    ("m" "Any (Company)"      company-complete)
+    ("a" "Aider"                 aidermacs-transient-menu)
-    ("g" "Ask GPT"            gptel-menu)
+    ("e" "Refactor with Elysium" elysium-query)]]
-    ("e" "Refactor (Elysium)" elysium-query)]
+   [["Find"
-   ["Find"
     ("s" "Swiper"             consult-line)
     ("u" "Vundo"              vundo)
     ("d" "Dash"               dash-at-point)]])
 
-(transient-define-prefix icejam-window-menu ()
+(transient-define-prefix icejam-buffer-menu ()
-  "Windows Commands."
+  "Buffers and windows."
   [""
-   ["Move"
+   ["Move Cursor"
-    ("<left>" " Left"   windmove-left)
+    :pad-keys t
-    ("<right>" "Right"  windmove-right)
+    ("<left>"  "Left buffer" windmove-left)
-    ("<up>" "   Up"     windmove-up)
+    ("<right>" "Right buffer" windmove-right)
-    ("<down>" " Down"   windmove-down)]
+    ("<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)
+    ("sr" "To right" split-window-right)
-    ("v" "Vertically"   split-window-right)]
+    ("sb" "To bottom" split-window-below)
-   ["Kill"
+    ("\\" "To right" split-window-right)
-    ""
+    ("/"  "To bottom" split-window-below)]]
-    ""
+  [["Buffers"
-    ""
+    :pad-keys t
-    ("k" "Kill Buffer"  kill-buffer-and-window)]])
+    ("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."
-  [""
+  [[:description
-   ["Buffer"
+    (lambda ()
-    ("r" "Reload"      icejam-revert-buffer-no-confirm)
+      (concat (propertize "Code actions for " 'face 'transient-heading)
-    ("f" "Format"      lsp-format-buffer)
+              (propertize (format "%s" major-mode) 'face 'transient-key)
-    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)]
+              (propertize ":\n" 'face 'transient-heading)))
-   ["Other"
-    ("m" "iMenu"       lsp-ui-imenu)
-    ("e" "Show Errors" flycheck-list-errors)]])
 
-(transient-define-prefix icejam-history-menu ()
+    ("r" "Reload buffer" icejam-revert-buffer-no-confirm)
-  "Buffer History Commands."
+    ("e" "Show errors" flymake-show-buffer-diagnostics)
-  ["History"
+    ("f" "Format buffer with apheleia formatter" apheleia-format-buffer)
-   ("[" "Previous" previous-buffer)
-   ("]" "Next" previous-buffer)])
 
-(transient-define-prefix icejam-move-menu ()
+    ;; This only appears for emacs-lisp-mode
-  "Move Commands."
+    ("d" "Explain thing at point" helpful-at-point :if-mode emacs-lisp-mode)
-  [""
-   ["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)]])
 
-(transient-define-prefix icejam-font-menu ()
+    ("m" "iMenu" consult-imenu)
-  "Font Commands."
+
-  [""
+    ;; Finally, quit.
-   ["Everywhere"
+    ("q" "Quit" keyboard-quit)]])
-    ("s" "Adjust font size" global-text-scale-adjust)]
+
-   ["In this buffer"
+(transient-define-prefix icejam-elpaca-menu ()
-    ("i" "Bigger"           (lambda () (interactive) (text-scale-increase 1)))
+  "Commands related to packages."
-    ("d" "Smaller"          (lambda () (interactive) (text-scale-decrease 1)))
+  [["Packages and compilation"
-    ("r" "Reset"            (lambda () (interactive) (text-scale-adjust 0)))]])
+    ("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)
+(transient-define-prefix icejam-command-palette ()
-(define-key icejam-keys-mode-map (kbd "C-c c") 'icejam-code-menu)
+  "All transient menus in one place."
-(define-key icejam-keys-mode-map (kbd "C-c w") 'icejam-window-menu)
+  ["Command palette\n"
-(define-key icejam-keys-mode-map (kbd "C-c s") 'icejam-history-menu)
+   ["The thing you are editing"
-(define-key icejam-keys-mode-map (kbd "C-c f") 'icejam-font-menu)
+    ("p" "Project" icejam-project-menu)
-(define-key icejam-keys-mode-map (kbd "C-c m") 'icejam-move-menu)
+    ("c" "Code" icejam-code-menu)
-(define-key icejam-keys-mode-map (kbd "C-c l") 'icejam-transient-for-lang)
+    ("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

lisp/icejam-tree-sitter.el

@@ -10,26 +10,27 @@
 ;; community.
 
 ;;; Code:
+(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)))))
 
-(use-package tree-sitter-langs :ensure t
+(defun icejam-tree-sitter-symlink-grammar-objects ()
-  :config
+  "Create symlinks for treesitter grammars.
-  (declare-function tree-sitter-langs--bin-dir "tree-sitter-langs")
+Tree-sitter-langs-build releases grammars as LANG.so.  Treesit needs
-  (add-to-list 'treesit-extra-load-path (tree-sitter-langs--bin-dir))
-
-  (defun icejam-tree-sitter-symlink-grammar-objects ()
-    "Create symlinks for treesitter grammars.
-Tree-sitter-langs-build releases grammars as LANG.so. Treesit needs
 libtree-sitter-LANG.so"
-    (interactive)
+  (interactive)
-    (dolist (file (directory-files (tree-sitter-langs--bin-dir) 'full
+  (dolist (file (directory-files (tree-sitter-langs--bin-dir) 'full
-                                   (concat "\\" (car tree-sitter-load-suffixes) "$")))
+                                 (concat "\\" (car tree-sitter-load-suffixes) "$")))
-      ;; make symlink (or copy) libtree-sitter-c.so -> c.so
+    ;; make symlink (or copy) libtree-sitter-c.so -> c.so
-      (let ((target (concat (file-name-as-directory (file-name-directory file))
+    (let ((target (concat (file-name-as-directory (file-name-directory file))
-                            "libtree-sitter-"
+                          "libtree-sitter-"
-                            (file-name-nondirectory file))))
+                          (file-name-nondirectory file))))
-        (if (memq system-type '(ms-dos windows-nt cygwin))
+      (if (memq system-type '(ms-dos windows-nt cygwin))
-            (copy-file file target)
+          (copy-file file target)
-          (make-symbolic-link file target))))))
+        (make-symbolic-link file target)))))
 
 (provide 'icejam-tree-sitter)
 ;;; icejam-tree-sitter.el ends here

lisp/icejam-vundo.el

@@ -10,8 +10,11 @@
 
 ;;; Code:
 
-;;;;;;;;;;;;;;;;; Use more advanced undo options
+;; Undo UI
-(use-package vundo :ensure t :defer t)
+(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

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"))
+    (defvar c-default-style "bsd")))
-
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-etags company-yasnippet)))
 
 (add-hook 'c-mode-hook 'icejam-lang-activate-clang-mode)
 

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
+  (define-key clojure-mode-map (kbd "C-c l") 'icejam-lang-cider-context-menu)
-    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

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

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)
 

lisp/langs/icejam-lang-dhall.el

@@ -2,14 +2,12 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(use-package dhall-mode :ensure t :defer t)
-(require 'icejam-lsp)
-
-(use-package dhall-mode :ensure t :defer t :requires (lsp))
 
 (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)

lisp/langs/icejam-lang-elisp.el

@@ -2,43 +2,26 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(eval-when-compile
-(require 'icejam-transient)
+  (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 ()
+(use-package lispy :ensure t :defer t :commands (lispy-mode))
-  "Elisp Buffer Commands."
+;; (use-package geiser-guile :ensure t :defer t)
-  [""
-   ["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)])
 
-(add-to-list
+(defun icejam-activate-emacs-lisp-mode ()
- 'icejam-language-transient-alist '(emacs-lisp-mode . icejam-elisp-lang-menu))
+  "Goodies for editing Emacs files."
 
-(with-eval-after-load 'lispy
+  (icejam-set-indent 2) ;; Default indentation of 2 characters
-  (declare-function lispy-mode "lispy")
+  (column-enforce-n 80) ;; Use 80 char limit.
-  (defun icejam-activate-emacs-lisp-mode ()
+  (lispy-mode t)        ;; Modal editing for Lisp
-    "Goodies for editing Emacs files."
+  (icejam-set-elisp-capfs))
-    (icejam-set-indent 2) ;; Default indentation of 2 characters
-    (column-enforce-n 80)
 
-    (lispy-mode t)
+(add-hook 'emacs-lisp-mode-hook 'icejam-activate-emacs-lisp-mode)
-    (setq-default indent-tabs-mode nil)
+(add-hook 'ielm-mode-hook 'icejam-set-elisp-capfs)
-
-    ;; 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))
 
 (provide 'icejam-lang-elisp)
 ;;; icejam-lang-elisp.el ends here

lisp/langs/icejam-lang-elixir.el

@@ -2,32 +2,40 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(eval-when-compile
-(require 'icejam-flycheck)
+  (declare-function transient-define-prefix 'transient)
-(require 'icejam-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)
+(use-package elixir-ts-mode :ensure t :defer t :after (apheleia)
-(declare-function column-enforce-n "column-enforce-mode" (number))
+  :config
-
+  (add-to-list 'apheleia-mode-alist '(heex-ts-mode . mix-format)))
-(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)))
 
 (transient-define-prefix icejam-elixir-lang-menu ()
-  "Elixir Buffer Commands."
+  [[:description
-  [""
+    (lambda ()
-   ["LSP"
+      (concat (propertize "Code actions for " 'face 'transient-heading)
-    ("m" "iMenu"       lsp-ui-imenu)]
+              (propertize (format "%s" major-mode) 'face 'transient-key)
-   ["Buffer"
+              (propertize ":\n" 'face 'transient-heading)))
-    ("r" "Reload"      icejam-revert-buffer-no-confirm)
+    ("m" "iMenu" consult-imenu)
-    ("f" "Format"      elixir-format)
+    ("r" "Reload buffer" icejam-revert-buffer-no-confirm)
-    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)
+    ("e" "Show errors" flymake-show-buffer-diagnostics)
-    ("e" "Show Errors" flycheck-list-errors)]]
+    ("f" "Format buffer with Elixir formatter" apheleia-format-buffer)
-  [""
+
-   ("q" "Quit"        keyboard-quit)])
+    ("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)
+  (eglot-ensure)
-  (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)
 
   ;; If needed, switch the one below to false to disable documentation pop-ups
   ;; (setq-local lsp-ui-doc-enable t)
-
+  (icejam-set-eglot-capfs)
-  ;; Company list override
+  (icejam-delete-elixir-snippets))
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
 
 (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

lisp/langs/icejam-lang-erlang.el

@@ -2,85 +2,22 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode)
-(require 'icejam-lsp)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
 
-(declare-function lsp "lsp-mode" nil)
+(use-package erlang :defer t :ensure (:depth 1))
-(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))
 
 (defun icejam-activate-erlang-mode ()
-  "All things for all Erlang, including header files."
+  "Start Erlang related editing process."
-  (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)
   (icejam-set-indent 4)
   (column-enforce-n 80)
 
   ;; Start LSP
-  (lsp)
+  (eglot-ensure)
 
-  ;; Company list override
+  ;; Capf override
-  (add-to-list (make-local-variable 'company-backends)
+  (icejam-set-eglot-capfs))
-               '(company-capf company-yasnippet)))
 
 (add-hook 'erlang-mode-hook 'icejam-activate-erlang-mode)
 

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)
+(use-package fsharp-mode :ensure t :defer t)
-(require 'icejam-lsp)
-
-(use-package fsharp-mode
-  :requires (lsp-mode lsp-ui)
-  :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
+  ;; Capf override
-  (add-to-list (make-local-variable 'company-backends)
+  (icejam-set-eglot-capfs))
-               '(company-capf company-yasnippet)))
 
 (add-hook 'fsharp-mode-hook 'icejam-activate-fsharp-mode)
 

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
+;; (add-to-list 'auto-mode-alist '("\\.gleam\\'" . 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))
 
 (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

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 :defer t :ensure t)
-
-(use-package go-mode
-  :requires (lsp-mode lsp-ui)
-  :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

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
+(use-package haskell-mode :ensure t :defer t)
-  :ensure t
-  :defer t)
-
-(use-package lsp-haskell
-  :ensure t
-  :defer t
-  :requires (lsp-mode lsp-ui haskell-mode))
 
 (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
+  ;; Capf override
-  (add-to-list (make-local-variable 'company-backends)
+  (icejam-set-eglot-capfs))
-               '(company-capf company-yasnippet)))
 
 (add-hook 'haskell-mode-hook 'icejam-activate-haskell-mode)
 

lisp/langs/icejam-lang-javascript.el

@@ -2,15 +2,24 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
-(require 'icejam-flycheck)
+(declare-function icejam-set-indent 'icejam-prog-mode)
-(require 'icejam-lsp)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
 
-(use-package js2-mode
+(use-package js2-mode :ensure t :defer t :after(web-mode))
-  :requires (web-mode company-web lsp-mode lsp-ui)
-  :ensure t)
 
-(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."
+  (icejam-set-eglot-capfs))
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
 
 (add-hook 'js2-mode-hook 'icejam-activate-js2-mode)
 

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
+(use-package kotlin-ts-mode :ensure t :defer t)
-	:defer t
-	:ensure t)
 
-(use-package gradle-mode
+(add-to-list 'auto-mode-alist '("\\.kt\\'" . kotlin-ts-mode))
-	:defer t
+(add-to-list 'auto-mode-alist '("\\.kts\\'" . kotlin-ts-mode))
-	:ensure t)
+
+(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-hook 'kotlin-ts-mode-hook 'icejam-activate-kotlin-mode)
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
-
-(add-hook 'kotlin-mode-hook 'icejam-activate-kotlin-mode)
 
 (provide 'icejam-lang-kotlin)
 ;;; icejam-lang-kotlin.el ends here

lisp/langs/icejam-lang-lean.el

@@ -1,17 +1,14 @@
 ;;; lean -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
-(require 'icejam-prog-mode)
-(require 'icejam-lsp)
 
 (use-package lean4-mode
   :ensure (lean4-mode
-	   :type git
+           :type git
-	   :host github
+           :host github
-	   :repo "leanprover/lean4-mode"
+           :repo "leanprover/lean4-mode"
-	   :files ("*.el" "data"))
+           :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
+  ;; Capf override
-  (add-to-list (make-local-variable 'company-backends)
+  (icejam-set-eglot-capfs))
-               '(company-capf company-yasnippet)))
 
-(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

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

lisp/langs/icejam-lang-markdown.el

@@ -2,25 +2,36 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(eval-when-compile
-(declare-function elpaca-installed-p "elpacs")
+  (declare-function elpaca-installed-p "elpaca")
-(unless (elpaca-installed-p 'markdown-mode)
+  (declare-function column-enforce-n 'column-enforce-mode (number))
-  (use-package markdown-mode :ensure t))
+  (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
+;; Markdown is a dependency of LSP mode. By wrapping it in unless we silence
-  (setq-default markdown-command "pandoc"))
+;; 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)
+  (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))
 
 (add-hook 'markdown-mode-hook 'icejam-lang-activate-markdown-mode)
 (add-hook 'markdown-mode-hook 'display-line-numbers-mode)

lisp/langs/icejam-lang-ocaml.el

@@ -1,13 +1,12 @@
 ;;; ocaml -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
+(declare-function icejam-set-indent 'icejam-prog-mode)
-(require 'icejam-transient)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
-(require 'icejam-prog-mode)
+(eval-when-compile (defvar icejam-language-transient-alist))
-(declare-function lsp "lsp-mode" nil)
 
 (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)
 

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)
-(use-package yaml-mode :ensure t :defer t :requires (lsp))
 
 (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

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)
+(use-package php-mode :ensure t :defer t)
-(require 'icejam-flycheck)
-(require 'icejam-transient)
 
-(use-package php-mode
+(transient-define-prefix icejam-lang-php-context-menu ()
-  :requires (lsp-mode lsp-ui)
-  :ensure t)
-
-(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
+  ;; Capf override
-  (add-to-list (make-local-variable 'company-backends)
+  (icejam-set-eglot-capfs))
-               '(company-capf company-yasnippet)))
 
 (add-hook 'php-mode-hook 'icejam-lang-activate-php-mode)
 

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)
+(declare-function column-enforce-n 'column-enforce-mode (number))
-  :ensure t)
+(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
+  ;; Capf override
-  (add-to-list (make-local-variable 'company-backends)
+  (icejam-set-eglot-capfs))
-               '(company-capf company-yasnippet)))
 
 (add-hook 'purescript-mode-hook 'icejam-activate-purescript-mode)
 

lisp/langs/icejam-lang-python.el

@@ -1,23 +1,24 @@
 ;;; python -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
-(require 'icejam-prog-mode)
-(require 'icejam-transient)
-
-(declare-function lsp nil)
 (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
+  ;; Capf override
-  (add-to-list (make-local-variable 'company-backends)
+  (icejam-set-eglot-capfs))
-               '(company-capf company-yasnippet)))
 
 (add-hook 'python-mode-hook 'icejam-lang-activate-python-mode)
 

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
+  ;; Capf override
-  (add-to-list (make-local-variable 'company-backends)
+  (icejam-set-eglot-capfs))
-               '(company-capf company-yasnippet)))
 
 (add-hook 'ruby-ts-mode-hook 'rspec-mode)
 (add-hook 'ruby-ts-mode-hook 'ruby-end-mode)

lisp/langs/icejam-lang-rust.el

@@ -1,19 +1,27 @@
 ;;; rust -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
+(eval-when-compile
-(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 rust-mode
   :ensure t
   :defer t
-  :config
+  :config (setopt rust-mode-treesitter-derive t))
-  (setq 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)
+  (eglot-ensure)
-
+  (icejam-set-eglot-capfs))
-  ;; Company list override
-  (add-to-list (make-local-variable 'company-backends)
-               '(company-capf company-yasnippet)))
 
 (add-hook 'rust-mode-hook 'icejam-activate-rust-mode)
 (add-hook 'rust-mode-hook 'flycheck-rust-setup)

lisp/langs/icejam-lang-web.el

@@ -1,13 +1,7 @@
 ;;; web -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
+(use-package web-mode :ensure t :defer t)
-(require 'icejam-lsp)
-(require 'icejam-flycheck)
-
-(use-package web-mode
-  :requires (lsp-mode flycheck)
-  :ensure 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)
 

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)
 

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

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

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

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

snippets/text-mode/dco-signoff

@@ -0,0 +1,4 @@
+# -*- mode: snippet -*-
+# name: dco-signoff
+# --
+Signed-off-by: Maciej Szlosarczyk (${1:maciej@sosek.net})