Move some stuff

user-lisp/icejam-agent-shell.el

@@ -0,0 +1,33 @@
+;;; icejam-agent-shell.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;;; Agent stuff
+
+;;; Code:
+(declare-function agent-shell-make-environment-variables 'agent-shell)
+(defvar icejam-variables-to-load-in-agent-shell '())
+
+(use-package agent-shell
+  :ensure t
+  ;; Install this only on MacOS. On Linux you want to do it manually.
+  :if (eq system-type 'darwin)
+  :ensure-system-package
+  ((claude-agent-acp . "npm install -g @zed-industries/claude-agent-acp"))
+  :config
+  (setopt agent-shell-anthropic-claude-environment
+          (agent-shell-make-environment-variables :inherit-env t))
+  (setopt agent-shell-opencode-environment
+          (apply #'agent-shell-make-environment-variables
+                 :inherit-env t
+                 icejam-variables-to-load-in-agent-shell))
+  (setopt
+   agent-shell-opencode-default-model-id
+   "google-vertex-anthropic/claude-sonnet-4-6@default"))
+
+(provide 'icejam-agent-shell)
+;;; icejam-agent-shell.el ends here

user-lisp/icejam-avy.el

@@ -0,0 +1,22 @@
+;;; icejam-avy.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; Avy is a navigation manager.
+
+(eval-when-compile (defvar icejam-keys-mode-map))
+
+;;; Code:
+(use-package avy :ensure t :defer t
+  :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)))
+
+(provide 'icejam-avy)
+;;; icejam-avy.el ends here

user-lisp/icejam-base.el

@@ -0,0 +1,171 @@
+;;; pkg/base.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; pkg/base defines basic packages and environment.
+
+;;; Code:
+
+;;;;;;;; Stolen from Doom Emacs. ;;;;;;;;;;;;;
+;; Update emacs less often
+(setopt idle-update-delay 1.0)
+
+;; Prefer newer byte-compiled code
+(setopt load-prefer-newer t)
+
+;; Disable bidirectional text rendering for a modest performance boost. I've set
+;; 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-inhibit-bpa t)
+
+;; Skip fontification when you are typing
+(setopt redisplay-skip-fontification-on-input t)
+
+;; Reduce rendering/line scan work for Emacs by not rendering cursors or regions
+;; in non-focused windows.
+(setq-default cursor-in-non-selected-windows nil)
+(setopt highlight-nonselected-windows nil)
+
+;; More performant rapid scrolling over unfontified regions. May cause brief
+;; spells of inaccurate syntax highlighting right after scrolling, which should
+;; quickly self-correct.
+(setopt fast-but-imprecise-scrolling t)
+
+;; Trust local folder
+(setopt trusted-content '("~/.emacs.d/" "~/Development/"))
+
+;;;;;;;;; TRAMP configuration ;;;;;;;;;;;;;;;;
+(use-package tramp :ensure nil :defer 5
+  :config
+  (setopt tramp-default-method "ssh"))
+
+;;;;;;;;; Emacs bindings ;;;;;;;;;;;;;;;;;;;;;
+(global-set-key (kbd "RET") 'newline)
+
+;;;;;;;;; Easy copying of data ;;;;;;;;;;;;;;;
+(use-package easy-kill :ensure t
+  :bind ([remap kill-ring-save] . easy-kill))
+
+;; Move buffers around with buffer keys
+(use-package buffer-move :ensure t :defer t)
+
+;; Garbage collection magic hack
+(use-package gcmh :ensure t :defer t
+  :commands (gcmh-mode)
+  :hook ((elpaca-after-init . (lambda () (gcmh-mode t))))
+  :config
+  (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"))
+ auto-save-file-name-transforms `((".*" ,"~/.emacs.d/backups/auto-save-list" t))
+ backup-by-copying t
+ delete-old-versions t
+ kept-new-versions 10
+ kept-old-versions 5
+ version-control t)
+
+;; Do not create .#foo.file lock files
+(setopt create-lockfiles nil)
+
+;; Enable line numbers and show cursors position
+(dolist (mode '(prog-mode-hook
+                text-mode-hook
+                conf-mode-hook))
+  (add-hook mode 'display-line-numbers-mode)
+  ;; Highlight current line.
+  (add-hook mode 'hl-line-mode))
+
+;; (global-display-line-numbers-mode t)
+(column-number-mode t)
+
+;; Turn off sounds
+(setopt ring-bell-function 'ignore)
+
+;; Enable y/n answers to questions
+(setopt use-short-answers t)
+
+;; Only warn if a file is bigger than 50 MB when trying to open it
+(setopt large-file-warning-threshold 50000000)
+
+;; Numbers are arbitrary, but work on a large screen. Default is 160
+(setopt split-width-threshold 190)
+
+;;;;;;;;;;;;;;;;;;;;;; Shell stuff ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
+
+;; Disable warning related to PATH on startup
+(defvar exec-path-from-shell-check-startup-files nil)
+
+(eval-when-compile
+  (declare-function exec-path-from-shell-initialize 'exec-path-from-shell))
+
+;; This should be defined in secrets.
+(defvar icejam-variables-to-load-from-shell '())
+
+;; Allow to execute path from shell
+(use-package exec-path-from-shell
+  ;; :if (memq window-system '(x mac ns))
+  :ensure t
+  :defer t
+  :hook ((elpaca-after-init . exec-path-from-shell-initialize))
+  :config
+  (add-to-list 'exec-path "/usr/local/bin")
+  (dolist (var icejam-variables-to-load-from-shell)
+    (add-to-list 'exec-path-from-shell-variables var)))
+
+(use-package direnv :ensure t :defer t
+  :hook ((elpaca-after-init . direnv-mode)))
+
+;; Draw underline lower
+(setopt x-underline-at-descent-line t)
+
+;;; Get rid of bad parts of the windows
+(tool-bar-mode -1)
+(scroll-bar-mode -1)
+(setopt indicate-buffer-boundaries nil
+        indicate-empty-lines nil)
+
+;;;;;;;;;;;;;;;;; Treemacs
+(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 (setopt treemacs-tag-follow-delay 1.0))
+
+(use-package treemacs-all-the-icons :ensure t :defer t
+  :requires (treemacs)
+  :commands (treemacs-load-theme)
+  :config (treemacs-load-theme "all-the-icons"))
+
+;;;;;;;;;;;;;;;;; Record frequency of different commands. Review them later
+(use-package keyfreq :ensure t :defer t
+  :hook ((elpaca-after-init . keyfreq-mode)
+         (elpaca-after-init . keyfreq-autosave-mode))
+  :config
+  (setopt keyfreq-file (concat user-emacs-directory "emacs.keyfreq")))
+
+;;;;;;;;;;;;;;;;; Show hints about key combinations
+(use-package which-key :ensure nil :defer t
+  :hook ((elpaca-after-init . which-key-mode))
+  :config
+  (setopt which-key-idle-delay 0.2))
+
+;;;;;;;;;;;;;;;;; Use C-n to create a new line
+(setopt next-line-add-newlines t)
+
+(provide 'icejam-base)
+;;; icejam-base.el ends here

user-lisp/icejam-complete-at-point.el

@@ -0,0 +1,98 @@
+;;; icejam-complete-at-point.el -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Completion framework configuration
+;;; Code:
+(eval-when-compile
+  (defvar corfu-terminal-mode 'corfu-terminal)
+  (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-prefix-length 'cape)
+  (declare-function cape-capf-super 'cape)
+  (declare-function yasnippet-capf 'yasnippet)
+  (declare-function nerd-icons-corfu-formatter 'nerd-icons-corfu)
+  (declare-function eglot-completion-at-point 'eglot))
+
+(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
+  ;; 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
+  (setopt yasnippet-capf-lookup-by 'name))
+
+(use-package nerd-icons-corfu :ensure t :after corfu :defer 5
+  :config
+  (add-to-list 'corfu-margin-formatters #'nerd-icons-corfu-formatter))
+
+(provide 'icejam-complete-at-point)
+;;; icejam-complete-at-point.el ends here

user-lisp/icejam-completing-read.el

@@ -0,0 +1,84 @@
+;;; icejam-completing-read -- Functions related to completing-read -*- lexical-binding: t; -*-
+;;; Commentary:
+;;;
+;;; completing-read is the way of completing things in minibuffer.  This module
+;;; provides all of that functionality, everything related to minbuffer being
+;;; helpful.
+;;;
+;;; Code:
+(eval-when-compile
+  (defvar icejam-keys-mode-map)
+  (defvar crm-separator))
+
+;; Preparations for using Vertico/Orderless
+(setopt
+ ;; Support opening new minibuffers from inside existing minibuffers.
+ enable-recursive-minibuffers t
+ ;; Hide commands in M-x which do not work in the current mode.  Vertico
+ ;; commands are hidden in normal buffers. This setting is useful beyond
+ ;; Vertico.
+ read-extended-command-predicate #'command-completion-default-include-p
+ ;; Do not allow the cursor in the minibuffer prompt
+ minibuffer-prompt-properties
+ '(read-only t cursor-intangible t face minibuffer-prompt))
+
+(defun crm-indicator (args)
+  "Work with ARGS in `completing-read-multiple`."
+  (cons (format "[CRM%s] %s"
+                (replace-regexp-in-string
+                 "\\`\\[.*?]\\*\\|\\[.*?]\\*\\'" ""
+                 crm-separator)
+                (car args))
+        (cdr args)))
+(advice-add #'completing-read-multiple :filter-args #'crm-indicator)
+(add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)
+
+;; Vertico relies on Emacs 31 compatibility
+(use-package compat :ensure t)
+
+;; Actual orderless
+(use-package vertico :ensure t :defer t
+  :hook ((elpaca-after-init . vertico-mode))
+  :config
+  (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
+  :config
+  ;; Fallback to basic if orderless does not work.
+  (setopt completion-styles '(orderless basic))
+  (setopt completion-category-defaults nil)
+  (setopt completion-category-overrides '((file (styles partial-completion)))))
+
+(use-package marginalia :ensure t :defer t
+  :hook ((elpaca-after-init . marginalia-mode)))
+
+(use-package 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 g" . consult-goto-line)
+              ("C-c a" . consult-ripgrep)))
+
+(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

user-lisp/icejam-custom-init.el

@@ -0,0 +1,168 @@
+;;; icejam-custom-init.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; custom-init does a thing.
+
+;;; Code:
+(eval-when-compile
+  (declare-function elpaca 'elpaca)
+  (declare-function elpaca-process-queues 'elpaca)
+  (declare-function elpaca-generate-autoloads 'elpaca)
+  (declare-function elpaca-write-lock-file 'elpaca)
+  (declare-function elpaca-use-package-mode 'elpaca-use-package))
+
+;; Set GC at 500 MB for startup
+(setopt gc-cons-threshold 500000000)
+(setopt gc-cons-percentage 5.0)
+
+(add-hook 'elpaca-after-init-hook (lambda ()
+                             ;; Restore GC to normal, but still high
+                             (setopt gc-cons-threshold (* 100 1024 1024 2))
+                             (setopt gc-cons-percentage 0.2)))
+
+;; Increase how much data emacs reads from processes to 4 MB.
+(setopt read-process-output-max (* 4 1024 1024))
+
+;; Change file handler for startup
+(defvar last-file-name-handler-alist file-name-handler-alist)
+(setopt file-name-handler-alist nil)
+(add-hook 'after-init-hook (lambda ()
+                             ;; Restore to normal file handler
+                             (setopt file-name-handler-alist
+                                     last-file-name-handler-alist)))
+
+;; Allow for deeper stacktraces / recursion
+;; (setopt max-lisp-eval-depth 10000)
+
+;;; Use elpaca for package management.
+(defvar elpaca-installer-version 0.12)
+(defvar elpaca-directory (expand-file-name "elpaca/" user-emacs-directory))
+(defvar elpaca-builds-directory (expand-file-name "builds/" elpaca-directory))
+(defvar elpaca-sources-directory (expand-file-name "sources/" elpaca-directory))
+(defvar elpaca-order '(elpaca :repo "https://github.com/progfolio/elpaca.git"
+                              :ref nil :depth 1 :inherit ignore
+                              :files (:defaults "elpaca-test.el" (:exclude "extensions"))
+                              :build (:not elpaca-activate)))
+(let* ((repo  (expand-file-name "elpaca/" elpaca-sources-directory))
+       (build (expand-file-name "elpaca/" elpaca-builds-directory))
+       (order (cdr elpaca-order))
+       (default-directory repo))
+  (add-to-list 'load-path (if (file-exists-p build) build repo))
+  (unless (file-exists-p repo)
+    (make-directory repo t)
+    (when (<= emacs-major-version 28) (require 'subr-x))
+    (condition-case-unless-debug err
+        (if-let* ((buffer (pop-to-buffer-same-window "*elpaca-bootstrap*"))
+                  ((zerop (apply #'call-process `("git" nil ,buffer t "clone"
+                                                  ,@(when-let* ((depth (plist-get order :depth)))
+                                                      (list (format "--depth=%d" depth) "--no-single-branch"))
+                                                  ,(plist-get order :repo) ,repo))))
+                  ((zerop (call-process "git" nil buffer t "checkout"
+                                        (or (plist-get order :ref) "--"))))
+                  (emacs (concat invocation-directory invocation-name))
+                  ((zerop (call-process emacs nil buffer nil "-Q" "-L" "." "--batch"
+                                        "--eval" "(byte-recompile-directory \".\" 0 'force)")))
+                  ((require 'elpaca))
+                  ((elpaca-generate-autoloads "elpaca" repo)))
+            (progn (message "%s" (buffer-string)) (kill-buffer buffer))
+          (error "%s" (with-current-buffer buffer (buffer-string))))
+      ((error) (warn "%s" err) (delete-directory repo 'recursive))))
+  (unless (require 'elpaca-autoloads nil t)
+    (require 'elpaca)
+    (elpaca-generate-autoloads "elpaca" repo)
+    (let ((load-source-file-function nil)) (load "./elpaca-autoloads"))))
+(add-hook 'after-init-hook #'elpaca-process-queues)
+(elpaca `(,@elpaca-order))
+
+;; Use package settings
+(setopt use-package-verbose t)
+(setopt use-package-compute-statistics t)
+
+;; 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-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 "user-lisp"))
+(add-to-list 'load-path (concat user-emacs-directory "user-lisp/themes"))
+(add-to-list 'load-path (concat user-emacs-directory "user-lisp/langs"))
+
+(defgroup icejam nil
+  "My customisation group."
+  :group 'local)
+
+;; General configuration files.
+(use-package icejam-keys-mode :ensure nil)
+(use-package icejam-base :ensure nil)
+(use-package icejam-sys-specific :ensure nil)
+(use-package icejam-tree-sitter :ensure nil)
+(use-package icejam-completing-read :ensure nil)
+(use-package icejam-avy :ensure nil)
+(use-package icejam-transient :ensure nil)
+(use-package icejam-prog-mode :ensure nil)
+(use-package icejam-complete-at-point :ensure nil)
+(use-package icejam-agent-shell :ensure nil)
+(use-package icejam-flycheck :ensure nil)
+(use-package icejam-ispell :ensure nil)
+(use-package icejam-deft :ensure nil)
+(use-package icejam-eglot :ensure nil)
+(use-package icejam-dashboard :ensure nil)
+(use-package icejam-magit :ensure nil)
+(use-package icejam-vundo :ensure nil)
+(use-package icejam-speed-type :ensure nil)
+
+;; Themes
+(use-package icejam-themes :ensure nil)
+(use-package icejam-fonts :ensure nil)
+
+;; Actual supported languages and file syntax.
+(use-package icejam-lang-clang :ensure nil)
+(use-package icejam-lang-clojure :ensure nil)
+(use-package icejam-lang-dart :ensure nil)
+(use-package icejam-lang-dhall :ensure nil)
+(use-package icejam-lang-elisp :ensure nil)
+(use-package icejam-lang-elixir :ensure nil)
+(use-package icejam-lang-erlang :ensure nil)
+(use-package icejam-lang-fsharp :ensure nil)
+(use-package icejam-lang-gleam :ensure nil)
+(use-package icejam-lang-golang :ensure nil)
+(use-package icejam-lang-haskell :ensure nil)
+(use-package icejam-lang-javascript :ensure nil)
+(use-package icejam-lang-java :ensure nil)
+(use-package icejam-lang-kotlin :ensure nil)
+(use-package icejam-lang-lua :ensure nil)
+(use-package icejam-lang-markdown :ensure nil)
+(use-package icejam-lang-ocaml :ensure nil)
+(use-package icejam-lang-other :ensure nil)
+(use-package icejam-lang-php :ensure nil)
+(use-package icejam-lang-purescript :ensure nil)
+(use-package icejam-lang-python :ensure nil)
+(use-package icejam-lang-ruby :ensure nil)
+(use-package icejam-lang-rust :ensure nil)
+(use-package icejam-lang-sh :ensure nil)
+(use-package icejam-lang-web :ensure nil)
+(use-package icejam-lang-ziglang :ensure nil)
+
+;; Diminish modeline litter
+(use-package icejam-diminish :ensure nil)
+
+(provide 'icejam-custom-init)
+;;; icejam-custom-init.el ends here

user-lisp/icejam-dashboard.el

@@ -0,0 +1,29 @@
+;;; dashboard.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; Dashboard extracted from Spacemacs.
+
+;;; Code:
+
+(use-package dashboard :ensure t :defer t
+  :commands dashboard-setup-startup-hook
+  :hook ((elpaca-after-init . dashboard-open))
+  :config
+  ;; setopt gives a warning here, so let's use setq
+  (setq dashboard-footer-messages '("Happy coding!"
+                                    "I showed you my source code, pls respond"))
+  (setopt dashboard-startup-banner 'logo)
+  (setopt dashboard-items '((recents  . 5)
+                            ;; (bookmarks . 5)
+                            ;; (agenda . 5)
+                            ;; (registers . 5)
+                            (projects . 5)))
+  (dashboard-setup-startup-hook))
+
+(provide 'icejam-dashboard)
+;;; icejam-dashboard.el ends here

user-lisp/icejam-deft.el

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

user-lisp/icejam-diminish.el

@@ -0,0 +1,35 @@
+;;; icejam-diminish.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; diminish minor modes to remove modeline litter.
+
+;;; Code:
+(use-package diminish :ensure t :defer t :commands (diminish))
+
+(defun icejam-diminish-modes ()
+  "Diminish selected modes."
+  (dolist (package-and-mode '((flyspell flyspell-mode)
+                              (flycheck flycheck-mode)
+                              (rainbow-mode rainbow-mode)
+                              (undo-tree undo-tree-mode)
+                              (which-key which-key-mode)
+                              (eldoc eldoc-mode)
+                              (yasnippet yas-minor-mode)
+                              (whitespace whitespace-mode)
+                              (autorevert auto-revert-mode)
+                              (ivy ivy-mode)
+                              (smerge-mode smerge-mode)
+                              (gcmh gcmh-mode)))
+    (let ((package (car package-and-mode))
+          (mode (car (last package-and-mode))))
+      (with-eval-after-load package (diminish mode)))))
+
+(add-hook 'elpaca-after-init-hook 'icejam-diminish-modes)
+
+(provide 'icejam-diminish)
+;;; icejam-diminish.el ends here

user-lisp/icejam-eglot.el

@@ -0,0 +1,66 @@
+;;; icejam-eglot -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Global Language Server Protocol Config
+;;; Code:
+
+(eval-when-compile
+  (declare-function eglot-completion-at-point 'eglot)
+  (declare-function eglot-managed-p 'eglot))
+
+(use-package eglot :ensure nil
+  :config
+  ;; Use Ruby-Lsp instead of Solargraph
+  (add-to-list 'eglot-server-programs '((ruby-mode ruby-ts-mode) "ruby-lsp"))
+
+  ;; Use gleam LSP
+  (add-to-list 'eglot-server-programs '((gleam-ts-mode) "gleam" "lsp"))
+
+  ;; Use Kotlin-LSP provided by Jetbrains
+  (add-to-list 'eglot-server-programs
+               '((kotlin-mode kotlin-ts-mode) "kotlin-lsp" "--stdio"))
+
+  (setopt eglot-advertise-cancellation t)
+
+  ;; Automatically kill eglot when last buffer associated with a project is
+  ;; closed.
+  (setopt eglot-autoshutdown t)
+
+  (setopt eglot-connect-timeout 60)
+  (setopt eglot-extend-to-xref t)
+
+  ;; Set up server specific switches globally
+  (setq-default eglot-workspace-configuration
+                ;; Elixir configuration
+                '(:elixirLS (
+                             :autoBuild t
+                             :dialyzerEnabled t
+                             :incrementalDialyzer :json-false
+                             :autoInsertRequiredAlias :json-false
+                             :suggestSpecs t
+                             )))
+
+  ;; Eglot insists on adding itself to the completion-at-point-functions but
+  ;; that means that it overrides our combined value of (eglot + yasnippet)
+  (add-hook 'eglot-managed-mode-hook
+            (lambda ()
+              (when eglot--managed-mode
+                (remove-hook 'completion-at-point-functions
+                             #'eglot-completion-at-point t)))))
+
+(defun icejam-start-eglot ()
+  "Start eglot unless already started."
+  (unless (eglot-managed-p)
+    (eglot-ensure)))
+
+(use-package eldoc-box
+  :ensure (:host github :repo "casouri/eldoc-box")
+  :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

user-lisp/icejam-flycheck.el

@@ -0,0 +1,73 @@
+;;; icejam-flycheck -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+;; Use flycheck checks with flymake.
+(use-package flymake-flycheck :ensure t :defer t :config
+  (setq-default
+   flycheck-disabled-checkers
+   (append (default-value 'flycheck-disabled-checkers)
+           '(emacs-lisp emacs-lisp-checkdoc emacs-lisp-package sh-shellcheck))))
+
+(eval-when-compile
+  (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)
+  (declare-function cape-capf-super 'cape)
+  (declare-function cape-dabbrev 'cape)
+  (declare-function cape-file 'cape)
+  (declare-function cape-keyword 'cape)
+  (declare-function yasnippet-capf 'yasnippet-capf))
+
+(use-package el-patch :ensure t :defer t
+  :config
+  ;; Show the diagnostics from flymake in a second window (usually on the
+  ;; opposite side from this one) instead of at the bottom of the current one.
+  ;; Essentially revert the interesting part of this commit:
+  ;; https://github.com/emacs-mirror/emacs/commit/419550c7907275bf962986e1cc8fba1989d8659c
+  (el-patch-feature 'flymake)
+  (with-eval-after-load 'flymake
+    (el-patch-defun flymake-show-project-diagnostics ()
+      "Show a list of Flymake diagnostics for the current project."
+      (interactive)
+      (let* ((prj (project-current))
+             (root (project-root prj))
+             (buffer (flymake--project-diagnostics-buffer root)))
+        (with-current-buffer buffer
+          (flymake-project-diagnostics-mode)
+          (setq-local flymake--project-diagnostic-list-project prj)
+          (display-buffer (current-buffer))
+          (revert-buffer))))
+
+    (el-patch-defun flymake-show-buffer-diagnostics ()
+      "Show a list of Flymake diagnostics for current buffer."
+      (interactive)
+      (unless flymake-mode
+        (user-error "Flymake mode is not enabled in the current buffer"))
+      (let* ((name (flymake--diagnostics-buffer-name))
+             (source (current-buffer))
+             (target (or (get-buffer name)
+                         (with-current-buffer (get-buffer-create name)
+                           (flymake-diagnostics-buffer-mode)
+                           (current-buffer)))))
+        (with-current-buffer target
+          (setq flymake--diagnostics-buffer-source source)
+          (display-buffer (current-buffer))
+          (revert-buffer))))))
+
+;; Use flymake, the built in linter/checker.
+(use-package flymake :ensure nil
+  :defer t
+  :config
+  ;; Show 'Fly' in mode line.
+  (setopt flymake-mode-line-lighter "Fly")
+  ;; Use the same load-path as normal configuration. This makes the errors that
+  ;; appear in elisp files less jarring.
+  (setopt elisp-flymake-byte-compile-load-path load-path)
+  :hook ((prog-mode . flymake-mode)
+         (text-mode . flymake-mode)
+         (flymake-mode . flymake-flycheck-auto)))
+
+(provide 'icejam-flycheck)
+;;; icejam-flycheck.el ends here

user-lisp/icejam-fonts.el

@@ -0,0 +1,133 @@
+;;; icejam-fonts.el --- summary -*- lexical-binding: t; -*-
+
+;; 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"
+;; (defconst icejam-font "Red Hat Mono"
+;; (defconst icejam-font "Agave Nerd Font Mono"
+;; (defconst icejam-font "Input Mono Condensed"
+;; (defconst icejam-font "SF Mono"
+;; (defconst icejam-font "Monaco"
+;; (defconst icejam-font "JetBrains Mono" "Default font.")
+;; (defconst icejam-font "JuliaMono"
+;; (defconst icejam-font "Rec Mono Semicasual"
+;; (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-default-font-family "Iosevka Term" "Default font.")
+(defconst icejam-variable-font-family "Lexica Ultralegible"
+  "Variable pitch font.")
+(defconst icejam-markdown-font-family "Iosevka Comfy Motion"
+  "Font used to render code blocks in markdown.
+It is different than default font to keep it visually distinct.")
+
+;; Require dash functions to be included:
+(eval-when-compile
+  (declare-function -> 'dash))
+
+(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-variable-font-family
+  icejam-default-font-family
+  "Current variable-pitch font.  Defaults to `icejam-variable-font-family`."
+  :type 'string
+  :group 'icejam)
+(defcustom icejam-mut-markdown-font-family
+  icejam-markdown-font-family
+  "Current markdown font family, defaults to the one loaded in the beginning."
+  :type 'string
+  :group 'icejam)
+(defcustom icejam-mut-font-height
+  icejam-font-height
+  "Current font height."
+  :type 'integer
+  :group 'icejam)
+
+;;;;;;;;;;;;;;;;;;;;;; Font configuration ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defun icejam-set-font (family height)
+  "Set font to FAMILY and its HEIGHT to X.
+
+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'.
+
+Modeline faces (`mode-line' and `mode-line-inactive') look better if they are
+two points smaller."
+  (interactive "sNew font: \nnEnter height for %s: ")
+  (setopt icejam-mut-default-font-family family)
+  (setopt icejam-mut-font-height height)
+  (setopt icejam-mut-variable-font-family icejam-variable-font-family)
+
+  ;; Set default font.
+  (dolist (face '(default))
+    (set-face-attribute face nil
+                        :family family
+                        :height (-> height (* 10))))
+
+  ;; Set variable-pitch font
+  (dolist (face '(variable-pitch))
+    (set-face-attribute face nil
+                        :family icejam-mut-variable-font-family
+                        :height (-> height (* 10))))
+
+  ;; Tooltips look better when they are 1 point smaller.
+  (dolist (face '(tooltip))
+    (set-face-attribute face nil :height (-> height
+                                             (- 1)
+                                             (* 10))))
+
+  ;; Modeline looks better when it is 2 points smaller.
+  (dolist (face '(mode-line
+                  mode-line-inactive))
+    (set-face-attribute face nil :height (-> height
+                                             (- 2)
+                                             (* 10)))))
+
+(defun icejam-set-font-to-screen ()
+  "Automatically set font height to suit the monitor."
+  (interactive)
+
+  ;; Only do anything if there's a display at all.
+  (when (x-display-list)
+    (let* ((pixel-height (x-display-pixel-height))
+           (adjustment (cond
+                        ((>= 1080 pixel-height) 0) ;; Built-in 14" Macbook screen
+                        ((>= 1440 pixel-height) 3) ;; 27" screen connected to a Macbook
+                        ((>= 2160 pixel-height) -3)))) ;; 4K screen (i.e Linux)
+      (when adjustment
+        (icejam-set-font icejam-default-font-family
+                         (+ icejam-font-height adjustment))))))
+
+;; Run the above function once, after elpaca finishes all downloads.
+(add-hook 'elpaca-after-init-hook 'icejam-set-font-to-screen)
+
+(defun icejam-set-font-height (height)
+  "Set font to a specified HEIGHT."
+  (interactive "nEnter height for font: ")
+  (icejam-set-font icejam-mut-default-font-family height))
+
+(defun icejam-set-font-height-for-this-frame (new-height)
+  "Set font NEW-HEIGHT for this frame only."
+  (interactive "nEnter new height for font in this frame: ")
+  (set-frame-font (format "%s %d" icejam-mut-default-font-family new-height)))
+
+(provide 'icejam-fonts)
+;;; icejam-fonts.el ends here

user-lisp/icejam-ispell.el

@@ -0,0 +1,24 @@
+;;; pkg/ispell -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Highlight misspelled words
+;;; Code:
+
+(use-package ispell :ensure nil :defer t
+  :config
+  (setopt ispell-program-name "aspell")
+  (setopt ispell-extra-args '("--run-together" "--run-together-limit=5" "--run-together-min=2")))
+
+(use-package flyspell :ensure nil
+  :hook ((prog-mode . flyspell-mode)
+         (text-mode . flyspell-mode)
+         (markdown-mode . flyspell-mode))
+  :config
+  (unbind-key "C-," flyspell-mode-map)
+  (unbind-key "C-." flyspell-mode-map)
+  (unbind-key "C-;" flyspell-mode-map)
+  (unbind-key "C-c $" flyspell-mode-map)
+  (unbind-key "C-M-i" flyspell-mode-map))
+
+(use-package flyspell-correct :ensure t :after flyspell :defer t)
+(provide 'icejam-ispell)
+;;; icejam-ispell.el ends here

user-lisp/icejam-keys-mode.el

@@ -0,0 +1,65 @@
+;;; icejam-keys-mode.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; My global mode, to house my custom keys.
+
+;;; Code:
+
+(define-minor-mode icejam-keys-mode
+  "Minor mode for all of my personal key bindings."
+  :global t
+  :group 'icejam
+  :keymap (make-sparse-keymap))
+
+;; Globally enable my minor mode
+(icejam-keys-mode)
+
+(defun icejam-revert-buffer-no-confirm ()
+  "Revert buffer without confirmation."
+  (interactive) (revert-buffer t t))
+
+;; 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)
+
+;; Move between windows
+(keymap-set icejam-keys-mode-map "C-c <left>" #'windmove-left)
+(keymap-set icejam-keys-mode-map "C-c <right>" #'windmove-right)
+(keymap-set icejam-keys-mode-map "C-c <up>" #'windmove-up)
+(keymap-set icejam-keys-mode-map "C-c <down>" #'windmove-down)
+
+;; History of buffers
+(keymap-set icejam-keys-mode-map "C-c s [" #'previous-buffer)
+(keymap-set icejam-keys-mode-map "C-c s ]" #'next-buffer)
+
+;; These are slightly more conveniently located on an Ergodox/Moonlander
+(keymap-set icejam-keys-mode-map "C-c s <left>" #'previous-buffer)
+(keymap-set icejam-keys-mode-map "C-c s <right>" #'next-buffer)
+
+;; List of buffers buffer
+(keymap-set icejam-keys-mode-map "C-c b" #'ibuffer)
+
+;; Manipulate buffers (kill or revert)
+(keymap-set icejam-keys-mode-map "C-c q" #'kill-buffer-and-window)
+(keymap-set icejam-keys-mode-map "C-c r" #'icejam-revert-buffer-no-confirm)
+
+;; Make emacs behave like a normal editor from 21st century.
+(keymap-set icejam-keys-mode-map "<home>" #'beginning-of-line)
+(keymap-set icejam-keys-mode-map "<end>" #'end-of-line)
+
+;;;;;;;;; Translate keys ;;;;;;;;;;;;;;;;;;;;;
+(keymap-set key-translation-map "<f6>" "C-c l") ;; On F6, send C-c l
+(keymap-set key-translation-map "<f7>" "C-c c") ;; On F7, send C-c c
+(keymap-set key-translation-map "<f8>" "C-c p") ;; On F8, send C-c p
+
+(provide 'icejam-keys-mode)
+;;; icejam-keys-mode.el ends here

user-lisp/icejam-magit.el

@@ -0,0 +1,27 @@
+;;; icejam-magit.el -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(eval-when-compile
+  (defvar icejam-keys-mode-map)
+  (defvar magit-blame-mode-map)
+  (defvar git-commit-setup-hook)
+  (declare-function git-commit-setup-capf 'git-commit))
+
+(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
+        ("<f5> b" . 'magit-blame-quit))
+  :config
+  (setopt git-commit-setup-hook
+          (remove #'git-commit-setup-capf git-commit-setup-hook)))
+
+(provide 'icejam-magit)
+;;; icejam-magit.el ends here

user-lisp/icejam-prog-mode.el

@@ -0,0 +1,79 @@
+;;; icejam-prog-mode.el -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+;;; Wrap long lines
+(toggle-truncate-lines t)
+
+;;; When pasting/writing over a selection, replace it.
+(delete-selection-mode t)
+
+;; When possible, show code documentation
+(global-eldoc-mode t)
+
+;; Revert tag tables without asking
+(use-package etags :ensure nil :defer t
+  :config
+  (setopt tags-revert-without-query t))
+
+;;; Show trailing whitespace and remove whitespace on save
+(use-package whitespace :ensure nil
+  :hook ((prog-mode . whitespace-mode)
+         (text-mode . whitespace-mode)
+         (conf-mode . whitespace-mode)
+         (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 :defer t
+  :hook ((prog-mode . rainbow-delimiters-mode)
+         (text-mode . rainbow-delimiters-mode)
+         (elpaca-after-init . electric-pair-mode)
+         (elpaca-after-init . show-paren-mode)))
+
+;;; Show hex (#aaa) colors as colors
+(use-package rainbow-mode :ensure t :defer t
+  :hook ((prog-mode . rainbow-mode)
+         (text-mode . rainbow-mode)))
+
+;; Dash integration
+(use-package dash-at-point :ensure t :defer t
+  :config
+  (add-to-list 'dash-at-point-mode-alist '(enh-ruby-mode  . "ruby,rubygems,rails"))
+  (add-to-list 'dash-at-point-mode-alist '(elixir-ts-mode . "elixir,hex")))
+
+;; Ensure indentation in steps:
+(defun icejam-set-indent (step)
+  "Set indentation to STEP."
+  (interactive "NNumber of columns for one step: ")
+  (setq-local tab-width step)
+  (setq-local tab-stop-list (number-sequence step 200 step)))
+
+;; By default, use 2 spaces for indentation
+(icejam-set-indent 2)
+
+(use-package column-enforce-mode :ensure t :defer t
+  :hook (elpaca-after-init . global-column-enforce-mode))
+
+;; PCRE to Emacs regex translations
+(use-package pcre2el :ensure t :defer 5)
+
+;; Visual regexp
+(use-package visual-regexp-steroids :ensure t
+  :after (pcre2el)
+  :config
+  ;; Use pcre2el for regexes - so that I can use brackets more naturally with
+  ;; regexp.
+  (setopt vr/engine 'pcre2el))
+
+;; Format all programming languages with the same package
+(use-package apheleia :ensure t :defer t)
+
+(provide 'icejam-prog-mode)
+;;; icejam-prog-mode.el ends here

user-lisp/icejam-speed-type.el

@@ -0,0 +1,16 @@
+;;; icejam-speed-type.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; speed-type teaches you how to type.
+
+;;; Code:
+
+(use-package speed-type :ensure t :defer t)
+
+(provide 'icejam-speed-type)
+;;; icejam-speed-type.el ends here

user-lisp/icejam-sys-specific.el

@@ -0,0 +1,89 @@
+;;; sys-specific -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Make Emacs play nicer with specific operating systems
+;;; Code:
+
+(defconst IS-MAC (eq system-type 'darwin))
+(defconst IS-GNU (eq system-type 'gnu/linux))
+
+(eval-when-compile (defvar icejam-keys-mode-map))
+
+(defun icejam-function-delete-window ()
+  "Kill a window."
+  (interactive) (delete-window))
+
+;; Mac-specific config
+(if IS-MAC
+    (progn
+      (setq mac-option-modifier 'meta)
+      (setq mac-command-modifier 'hyper)
+
+      (defun icejam-mac-switch-meta nil
+        "Switch meta between Option and Command."
+        (interactive)
+        (if (eq mac-option-modifier nil)
+            (progn
+              (setq mac-option-modifier 'meta)
+              (setq mac-command-modifier 'hyper))
+          (progn
+            (setq mac-option-modifier nil)
+            (setq mac-command-modifier 'meta))))
+
+      ;; Mac binding (fix)
+      (keymap-set icejam-keys-mode-map "H-<right>" #'end-of-line)
+      (keymap-set icejam-keys-mode-map "H-<left>" #'beginning-of-line)
+      (keymap-set icejam-keys-mode-map "H-<up>" #'scroll-down) ; WTF is this reverse, I dunno
+      (keymap-set icejam-keys-mode-map "H-<down>" #'scroll-up)
+
+      ;; Use CMD bindings that you know from the operating system
+      (keymap-set icejam-keys-mode-map "H-a" #'mark-whole-buffer) ;; Select all
+      (keymap-set icejam-keys-mode-map "H-v" #'yank) ;; Paste
+      (keymap-set icejam-keys-mode-map "H-x" #'kill-region) ;; Cut
+      (keymap-set icejam-keys-mode-map "H-c" #'kill-ring-save) ;; Copy
+      (keymap-set icejam-keys-mode-map "H-s" #'save-buffer) ;; Save
+      (keymap-set icejam-keys-mode-map "H-z" #'undo) ;; Undo
+      (keymap-set icejam-keys-mode-map "H-Z" #'undo-redo) ;; Redo
+      (keymap-set icejam-keys-mode-map "H-q" #'kill-emacs) ;; Close emacs
+      (keymap-set icejam-keys-mode-map "H-w" #'icejam-function-delete-window) ;; Close window
+
+      ;; And then some extras
+      (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)))
+
+(defun icejam-switch-right-left-alt ()
+  "Set keyboard to das keyboard."
+  (interactive)
+  (if (eq mac-right-option-modifier nil)
+      (progn
+        (setq mac-right-option-modifier 'meta)
+        (setq mac-option-modifier nil))
+    (progn
+      (setq mac-option-modifier 'meta)
+      (setq mac-right-option-modifier nil))))
+
+;; Linux-specific config
+(if IS-GNU
+    (progn
+      ;; Save and undo
+      (keymap-set icejam-keys-mode-map "s-s" #'save-buffer)
+      (keymap-set icejam-keys-mode-map "s-z" #'undo)
+      (keymap-set icejam-keys-mode-map "s-Z" #'undo-redo)
+      (keymap-set icejam-keys-mode-map "s-a" #'mark-whole-buffer)
+
+      ;; Copy and paste bindings
+      (keymap-set icejam-keys-mode-map "s-x" #'kill-region)
+      (keymap-set icejam-keys-mode-map "s-v" #'yank)
+      (keymap-set icejam-keys-mode-map "s-c" #'kill-ring-save)
+
+      ;; Linux Ergo bindings (fix)
+      (keymap-set icejam-keys-mode-map "C-<right>" #'end-of-line)
+      (keymap-set icejam-keys-mode-map "C-<left>" #'beginning-of-line)
+      (keymap-set icejam-keys-mode-map "C-<up>" #'scroll-down) ; WTF is this reverse, I dunno
+      (keymap-set icejam-keys-mode-map "C-<down>" #'scroll-up)))
+
+(provide 'icejam-sys-specific)
+;;; icejam-sys-specific.el ends here

user-lisp/icejam-testing.el

@@ -0,0 +1,15 @@
+;;; icejam-testing.el --- summary  -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; icejam-testing includes required things for writing tests.
+;; Originally this was Buttercup but now I am thinking of writing my
+;; configuration tests in ERTs.
+
+;;; Code:
+ (provide 'icejam-testing)
+;;; icejam-testing.el ends here

user-lisp/icejam-themes.el

@@ -0,0 +1,37 @@
+;;; icejam-themes.el -- Theme configuration -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(use-package spaceline :ensure t
+  :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 modus-themes :ensure t)
+
+;; 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-frappe)
+
+  (if (memq window-system '(x mac ns))
+      (enable-theme 'icejam-base16-catppuccin-frappe)
+    (enable-theme 'icejam-base16-zenburn)))
+
+(provide 'icejam-themes)
+;;; icejam-themes.el ends here

user-lisp/icejam-transient.el

@@ -0,0 +1,174 @@
+;;; icejam-transient -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Global Transient definitions.
+;;; Code:
+(eval-when-compile
+  (defvar icejam-keys-mode-map)
+  (defvar icejam-project-menu)
+  (defvar icejam-code-menu)
+  (defvar icejam-buffer-menu)
+  (defvar icejam-elpaca-menu)
+  (defvar icejam-language-menu)
+  (defvar icejam-command-palette)
+  (declare-function transient-define-prefix 'transient)
+  (declare-function icejam-project-menu 'icejam-transient)
+  (declare-function icejam-code-menu 'icejam-transient)
+  (declare-function icejam-buffer-menu 'icejam-transient)
+  (declare-function icejam-command-palette 'icejam-transient))
+
+(use-package transient :ensure (:wait t))
+
+(defun icejam-mark-and-indent-whole-buffer ()
+  "Mark and indent whole buffer."
+  (interactive)
+  (indent-region (point-min) (point-max)))
+
+(transient-define-prefix icejam-project-menu ()
+  "Project Commands."
+  [["Project"
+    ("s" "Switch project" project-switch-project)
+    ("f" "Find file in project" project-find-file)
+    ("g" "Grep in project" consult-ripgrep)
+    ("t" "Find file anywhere" find-file)]
+   ["Magit"
+    ("m" "Git status" magit-status)
+    ("C" "Git checkout" magit-checkout)
+    ("M" "Git blame" magit-blame)]
+   ["Completions"
+    ("a" "Find line by contents" consult-line)
+    ("b" "Find buffer by name" consult-buffer)]]
+  [["LISP"
+    ("i" "IELM"                 ielm)
+    ("B" "iBuffer"              ibuffer)
+    ("e" "eval-region"          eval-region)]
+   ["Other"
+    ("d" "deft"                 deft)
+    ("T" "Speed Type"           speed-type-text)]]
+  [[""
+    ("q" "Quit" keyboard-quit)]])
+
+(transient-define-prefix icejam-code-menu ()
+  "Code Commands."
+  [["Manipulate"
+    ("c" "Toggle Comment"     comment-line)
+    ("r" "Replace"            vr/replace)
+    ("i" "Indent"             indent-region)]]
+   [["Find"
+    ("s" "Swiper"             consult-line)
+    ("u" "Vundo"              vundo)
+    ("d" "Dash"               dash-at-point)]])
+
+(transient-define-prefix icejam-buffer-menu ()
+  "Buffers and windows."
+  [""
+   ["Move Cursor"
+    :pad-keys t
+    ("<left>"  "Left buffer" windmove-left)
+    ("<right>" "Right buffer" windmove-right)
+    ("<up>"    "Top buffer" windmove-up)
+    ("<down>"  "Bottom buffer" windmove-down)]
+   ["Move this buffer"
+    :pad-keys t
+    ("v[" "To left" buf-move-left)
+    ("v]" "To right"  buf-move-right)
+    ("h[" "Up" buf-move-up)
+    ("h]" "Down"  buf-move-down)]]
+  [["Jump to"
+    ("w" "Word" avy-goto-word-1)
+    ("l" "Line" avy-goto-line)
+    ("c" "Character" avy-goto-char-2)]
+   ["Split"
+    ("sr" "To right" split-window-right)
+    ("sb" "To bottom" split-window-below)
+    ("\\" "To right" split-window-right)
+    ("/"  "To bottom" split-window-below)]]
+  [["Buffers"
+    :pad-keys t
+    ("s[" "Go to previous buffer" previous-buffer)
+    ("s]" "Go to next buffer" next-buffer)
+    ("bi" "iBuffer" ibuffer)
+    ("bf" "Find buffer" consult-buffer)
+    ("k" "Kill buffer and window" kill-buffer-and-window)]]
+  [["Fonts"
+    :pad-keys t
+    ("fs" "Adjust font size globally" global-text-scale-adjust)
+    ("fi" "Increase by one in this buffer"
+     (lambda () (interactive) (text-scale-increase 1)))
+    ("fd" "Decrease by one in this buffer"
+     (lambda () (interactive) (text-scale-decrease 1)))
+    ("fr" "Reset this buffer"
+     (lambda () (interactive) (text-scale-adjust 0)))]]
+  [[""
+    ("q" "Quit" keyboard-quit)]])
+
+(transient-define-prefix icejam-language-menu ()
+  "Language (Buffer) Commands."
+  [[:description
+    (lambda ()
+      (concat (propertize "Code actions for " 'face 'transient-heading)
+              (propertize (format "%s" major-mode) 'face 'transient-key)
+              (propertize ":\n" 'face 'transient-heading)))
+
+    ("r" "Reload buffer" icejam-revert-buffer-no-confirm)
+    ("e" "Show errors" flymake-show-buffer-diagnostics)
+    ("f" "Format buffer with apheleia formatter" apheleia-format-buffer)
+
+    ;; This only appears for emacs-lisp-mode
+    ("d" "Explain thing at point" helpful-at-point :if-mode emacs-lisp-mode)
+
+    ("m" "iMenu" consult-imenu)
+
+    ;; Finally, quit.
+    ("q" "Quit" keyboard-quit)]])
+
+(transient-define-prefix icejam-elpaca-menu ()
+  "Commands related to packages."
+  [["Packages and compilation"
+    ("m" "Open Elpaca manager" elpaca-manager)
+    ("f" "Fetch all package updates" elpaca-fetch-all)
+    ("s" "Symlink treesitter grammar objects" icejam-tree-sitter-symlink-grammar-objects)
+    ("p" "Prune native compilation cache" native-compile-prune-cache)
+    ("w" "Write elpaca lockfile" icejam-elpaca-write-lock)]]
+  [[""
+    ("q" "Quit" keyboard-quit)]])
+
+(defcustom icejam-language-transient-alist
+  '()
+  "List of functions to call for language transient."
+  :group 'icejam
+  :type '(repeat (cons (symbol :tag "Major mode name")
+                       (symbol :tag "Function to call"))))
+
+;; Use different thing for different language
+(defun icejam-language-transient-for-mode (&optional maybe-mode)
+  "Get transient for major mode.
+You can pass MAYBE-MODE to find mode explicitly."
+  (let* ((mode (if maybe-mode maybe-mode major-mode)))
+    (alist-get mode icejam-language-transient-alist 'icejam-language-menu)))
+
+(defun icejam-transient-for-lang ()
+  "Call transient for current major mode."
+  (interactive)
+  (funcall (icejam-language-transient-for-mode)))
+
+(transient-define-prefix icejam-command-palette ()
+  "All transient menus in one place."
+  ["Command palette\n"
+   ["The thing you are editing"
+    ("p" "Project" icejam-project-menu)
+    ("c" "Code" icejam-code-menu)
+    ("l" "Language" icejam-transient-for-lang)
+    ("r" "Revert Buffer" icejam-revert-buffer-no-confirm)]
+   ["The editor itself"
+    ("b" "iBuffer" ibuffer)
+    ("P" "Packages" icejam-elpaca-menu)
+    ("w" "Window" icejam-buffer-menu)]])
+
+(keymap-set icejam-keys-mode-map "C-c p" #'icejam-project-menu)
+(keymap-set icejam-keys-mode-map "C-c c" #'icejam-code-menu)
+(keymap-set icejam-keys-mode-map "C-c w" #'icejam-buffer-menu)
+(keymap-set icejam-keys-mode-map "C-c l" #'icejam-transient-for-lang)
+(keymap-set icejam-keys-mode-map "H-p" #'icejam-command-palette)
+
+(provide 'icejam-transient)
+;;; icejam-transient.el ends here

user-lisp/icejam-tree-sitter.el

@@ -0,0 +1,36 @@
+;;; icejam-treesitter.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; Load treesitter grammars automatically, based on the grammars provided by the
+;; 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)))))
+
+(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)
+  (dolist (file (directory-files (tree-sitter-langs--bin-dir) 'full
+                                 (concat "\\" (car tree-sitter-load-suffixes) "$")))
+    ;; make symlink (or copy) libtree-sitter-c.so -> c.so
+    (let ((target (concat (file-name-as-directory (file-name-directory file))
+                          "libtree-sitter-"
+                          (file-name-nondirectory file))))
+      (if (memq system-type '(ms-dos windows-nt cygwin))
+          (copy-file file target)
+        (make-symbolic-link file target)))))
+
+(provide 'icejam-tree-sitter)
+;;; icejam-tree-sitter.el ends here

user-lisp/icejam-vundo.el

@@ -0,0 +1,20 @@
+;;; icejam-vundo.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; Use more advanced undo options.
+
+;;; Code:
+
+;; Undo UI
+(use-package vundo :ensure t :defer t
+  :config
+  ;; Keep 64 MB of undo data, we have enough RAM to do this.
+  (setopt undo-limit (* 64 1024 1024)))
+
+(provide 'icejam-vundo)
+;;; icejam-vundo.el ends here

user-lisp/langs/icejam-lang-clang.el

@@ -0,0 +1,25 @@
+;;; languages/clang.el --- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(declare-function column-enforce-n "column-enforce-mode" (number))
+
+(defun icejam-lang-activate-clang-mode ()
+  "Goodies for editing c files."
+
+  ;; Set column width to 100
+  (column-enforce-n 100)
+
+  ;; Set indentation to 4 chars
+  (if (boundp 'c-basic-offset)
+      (setq-local c-basic-offset 4)
+    (defvar c-basic-offset 4))
+
+  (if (boundp 'c-default-style)
+      (setq-local c-default-style "bsd")
+    (defvar c-default-style "bsd")))
+
+(add-hook 'c-mode-hook 'icejam-lang-activate-clang-mode)
+
+(provide 'icejam-lang-clang)
+;;; icejam-lang-clang.el ends here

user-lisp/langs/icejam-lang-clojure.el

@@ -0,0 +1,70 @@
+;;; icejam-lang-clojure.el -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(eval-when-compile
+  (defvar icejam-language-transient-alist)
+  (defvar icejam-clojure-lang-menu)
+  (defvar cider-annotate-completion-function)
+  (defvar cider-show-error-buffer)
+  (declare-function column-enforce-n "column-enforce-mode" (number))
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function icejam-start-eglot 'icejam-eglot)
+  (declare-function transient-define-prefix 'transient))
+
+(use-package clojure-mode :defer t :ensure t)
+
+(use-package cider
+  :requires clojure-mode
+  :commands (cider-mode cider-jack-in)
+  :defer t
+  :ensure t
+  :config (setq cider-annotate-completion-function t))
+
+(use-package clj-refactor
+	:requires (cider clojure-mode)
+	:defer t
+	:ensure t)
+
+;; Transient
+(transient-define-prefix icejam-clojure-lang-menu ()
+  "Clojure Buffer Commands."
+  [""
+   ["Cider"
+    ("j" "Jack in"     cider-jack-in)
+    ("t" "Test"        cider-test-run-loaded-tests)]
+   ["Buffer"
+    ("r" "Reload"      icejam-revert-buffer-no-confirm)
+    ("f" "Format"      cider-format-buffer)
+    ("l" "Load"        cider-load-buffer)
+    ("e" "Show Errors" flymake-show-buffer-diagnostics)]]
+  [""
+   ("q"  "Quit"        keyboard-quit)])
+
+(add-to-list
+ 'icejam-language-transient-alist '(clojure-mode . icejam-clojure-lang-menu))
+
+(defun icejam-lang-activate-clojure-mode ()
+  "Goodies for clojure files."
+  (icejam-set-indent 2) ;; Default indentation of 2 characters
+  (column-enforce-n 80)
+  (cider-mode 1)
+
+  (icejam-start-eglot)
+
+  ;; Do not enable paredit for clojure
+  ;; (paredit-mode 1)
+	;; Do not show separate error window when in REPL
+  (setq cider-show-error-buffer 'except-in-repl))
+
+(add-hook 'clojure-mode-hook 'icejam-lang-activate-clojure-mode)
+
+(defun icejam-lang-clojure-repl-config ()
+  "Do not show stacktrace when in REPL."
+	(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-enable-flex-completion)
+
+(provide 'icejam-lang-clojure)
+;;; icejam-lang-clojure.el ends here

user-lisp/langs/icejam-lang-dart.el

@@ -0,0 +1,14 @@
+;;; dart -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(use-package dart-mode :ensure t :defer t)
+
+(defun icejam-lang-activate-dart-mode ()
+  "Reconfigure dart mode for your own purposes."
+  (eglot-ensure))
+
+(add-hook 'dart-mode-hook 'icejam-lang-activate-dart-mode)
+
+(provide 'icejam-lang-dart)
+;;; icejam-lang-dart.el ends here

user-lisp/langs/icejam-lang-dhall.el

@@ -0,0 +1,19 @@
+;;; dhall -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(use-package dhall-mode :ensure t :defer t)
+
+(eval-when-compile
+  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point))
+
+(defun icejam-lang-activate-dhall-mode ()
+  "Reconfigure dhall mode for your own purposes."
+  (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)
+
+(provide 'icejam-lang-dhall)
+;;; icejam-lang-dhall.el ends here

user-lisp/langs/icejam-lang-elisp.el

@@ -0,0 +1,27 @@
+;;; languages/elisp -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(eval-when-compile
+  (declare-function column-enforce-n 'column-enforce-mode (number))
+  (declare-function icejam-set-elisp-capfs 'icejam-complete-at-point)
+  (declare-function icejam-set-indent 'icejam-prog-mode))
+
+(add-to-list 'auto-mode-alist '("/Eask\\'" . emacs-lisp-mode))
+
+(use-package lispy :ensure t :defer t :commands (lispy-mode))
+;; (use-package geiser-guile :ensure t :defer t)
+
+(defun icejam-activate-emacs-lisp-mode ()
+  "Goodies for editing Emacs files."
+
+  (icejam-set-indent 2) ;; Default indentation of 2 characters
+  (column-enforce-n 80) ;; Use 80 char limit.
+  (lispy-mode t)        ;; Modal editing for Lisp
+  (icejam-set-elisp-capfs))
+
+(add-hook 'emacs-lisp-mode-hook 'icejam-activate-emacs-lisp-mode)
+(add-hook 'ielm-mode-hook 'icejam-set-elisp-capfs)
+
+(provide 'icejam-lang-elisp)
+;;; icejam-lang-elisp.el ends here

user-lisp/langs/icejam-lang-elixir.el

@@ -0,0 +1,68 @@
+;;; languages/elixir -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(eval-when-compile
+  (declare-function transient-define-prefix 'transient)
+  (declare-function column-enforce-n 'column-enforce-mode (number))
+  (declare-function -> 'dash)
+  (declare-function yas--table-get-create 'yasnippet)
+  (declare-function yas--remove-template-by-uuid 'yasnippet)
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
+  (declare-function icejam-start-eglot 'icejam-eglot)
+  (defvar icejam-language-transient-alist)
+  (defvar icejam-elixir-lang-menu)
+  (defvar apheleia-mode-alist))
+
+(use-package elixir-ts-mode :ensure t :defer t :after (apheleia)
+  :config
+  (add-to-list 'apheleia-mode-alist '(heex-ts-mode . mix-format)))
+
+(transient-define-prefix icejam-elixir-lang-menu ()
+  [[:description
+    (lambda ()
+      (concat (propertize "Code actions for " 'face 'transient-heading)
+              (propertize (format "%s" major-mode) 'face 'transient-key)
+              (propertize ":\n" 'face 'transient-heading)))
+    ("m" "iMenu" consult-imenu)
+    ("r" "Reload buffer" icejam-revert-buffer-no-confirm)
+    ("e" "Show errors" flymake-show-buffer-diagnostics)
+    ("f" "Format buffer with Elixir formatter" apheleia-format-buffer)
+
+    ("q" "Quit" keyboard-quit)]])
+
+(defun icejam-delete-elixir-snippets ()
+  "This function deletes Elixir snippets I don't use."
+  (-> 'elixir-mode
+      (yas--table-get-create)
+      (yas--remove-template-by-uuid "defmodule XXX end")))
+
+(add-to-list
+ 'icejam-language-transient-alist '(elixir-ts-mode . icejam-elixir-lang-menu))
+
+(defun icejam-activate-elixir-ts-mode ()
+  "All things Elixir."
+  (icejam-set-indent 2)
+  (column-enforce-n 98)
+  (icejam-set-eglot-capfs)
+  (icejam-start-eglot)
+  (icejam-delete-elixir-snippets))
+
+(add-hook 'heex-ts-mode-hook 'icejam-activate-elixir-ts-mode)
+(add-hook 'elixir-ts-mode-hook 'icejam-activate-elixir-ts-mode)
+
+;; (use-package ert :ensure nil :defer t)
+;; (ert-deftest icejam-activate-elixir-ts-mode ()
+;;   "Test `elixir-ts-mode` activation."
+;;   (with-temp-buffer
+;;     (elixir-ts-mode)
+;;     (icejam-activate-elixir-ts-mode)
+;;     (should (eq major-mode 'elixir-ts-mode))
+;;     (should (bound-and-true-p column-enforce-mode))
+;;     (should (equal " 98col" (buffer-local-value 'column-enforce-mode-line-string
+;;                                             (current-buffer))))
+;;     (should (eq 2 (buffer-local-value 'tab-width (current-buffer))))))
+
+(provide 'icejam-lang-elixir)
+;;; icejam-lang-elixir.el ends here

user-lisp/langs/icejam-lang-erlang.el

@@ -0,0 +1,25 @@
+;;; languages/erlang -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(declare-function column-enforce-n 'column-enforce-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
+
+(use-package erlang :defer t :ensure (:depth 1))
+
+(defun icejam-activate-erlang-mode ()
+  "Start Erlang related editing process."
+  (icejam-set-indent 4)
+  (column-enforce-n 80)
+
+  ;; Start LSP
+  (eglot-ensure)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'erlang-mode-hook 'icejam-activate-erlang-mode)
+
+(provide 'icejam-lang-erlang)
+;;; icejam-lang-erlang.el ends here

user-lisp/langs/icejam-lang-fsharp.el

@@ -0,0 +1,31 @@
+;;; fsharp.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; Fsharp configuration
+
+;;; Code:
+(eval-when-compile
+  (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))
+
+(use-package fsharp-mode :ensure t :defer t)
+
+(defun icejam-activate-fsharp-mode ()
+  "Activate F# goodies."
+  (icejam-set-indent 4)
+  (column-enforce-n 100)
+  (eglot-ensure)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'fsharp-mode-hook 'icejam-activate-fsharp-mode)
+
+(provide 'icejam-lang-fsharp)
+;;; icejam-lang-fsharp.el ends here

user-lisp/langs/icejam-lang-gleam.el

@@ -0,0 +1,31 @@
+;;; gleam.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; Gleam language support
+
+;;; 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))
+
+(use-package gleam-ts-mode :defer t :ensure t :mode (rx ".gleam" eos))
+
+;; (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)
+  (icejam-start-eglot)
+  (icejam-set-eglot-capfs))
+
+(add-hook 'gleam-ts-mode-hook 'icejam-lang-activate-gleam-mode)
+
+(provide 'icejam-lang-gleam)
+;;; icejam-lang-gleam.el ends here

user-lisp/langs/icejam-lang-golang.el

@@ -0,0 +1,29 @@
+;;; icejam-lang-golang.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; golang mode stuff
+
+;;; 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))
+
+(use-package go-mode :defer t :ensure t)
+
+(defun icejam-activate-golang-mode ()
+  "Activate my own Golang mode settings."
+  (icejam-set-indent 8)
+  (column-enforce-n 100)
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))
+
+(add-hook 'go-mode-hook #'icejam-activate-golang-mode)
+
+(provide 'icejam-lang-golang)
+;;; icejam-lang-golang.el ends here

user-lisp/langs/icejam-lang-haskell.el

@@ -0,0 +1,32 @@
+;;; haskell.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;;; Provides configuration for haskell files
+
+;;; 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))
+
+(use-package haskell-mode :ensure t :defer t)
+
+(defun icejam-activate-haskell-mode ()
+  "Run this in `haskell-mode'."
+  (icejam-set-indent 2)
+  (column-enforce-n 80)
+  (eglot-ensure)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'haskell-mode-hook 'icejam-activate-haskell-mode)
+
+(provide 'icejam-lang-haskell)
+;;; icejam-lang-haskell.el ends here

user-lisp/langs/icejam-lang-java.el

@@ -0,0 +1,25 @@
+;;; java -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; 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))
+
+(add-to-list 'auto-mode-alist '("\\.java\\'" . java-ts-mode))
+
+;; (use-package eglot-java :ensure t)
+
+(defun icejam-activate-java-mode ()
+	"Java mode overrides."
+	(icejam-set-indent 2)
+  (eglot-ensure)
+  (column-enforce-n 80)
+  (icejam-set-eglot-capfs))
+
+;; (add-hook 'java-ts-mode-hook 'eglot-java-mode)
+(add-hook 'java-ts-mode-hook 'icejam-activate-java-mode)
+
+(provide 'icejam-lang-java)
+;;; icejam-lang-java.el ends here

user-lisp/langs/icejam-lang-javascript.el

@@ -0,0 +1,53 @@
+;;; javascript -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; 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))
+
+(use-package js2-mode :ensure t :defer t :after(web-mode))
+
+(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
+;;   :defer t)
+
+;; Use js2-mode for javascript editing
+(add-to-list 'auto-mode-alist '("\\.js\\'" . js2-mode))
+(add-to-list 'auto-mode-alist '("\\.json\\'" . js2-mode))
+
+(defun icejam-activate-js2-mode ()
+	"JS2 mode overrides."
+	(icejam-set-indent 2)
+
+  (when (not (string-match-p ".json" (buffer-file-name)))
+    (eglot-ensure))
+
+	(column-enforce-n 80)
+	(setq-local js2-basic-offset 2)
+  (setq-local js2-strict-missing-semi-warning nil)
+  (setq js2-mode-show-parse-errors nil)
+  (setq js2-mode-show-strict-warnings nil)
+
+  (setq-local flycheck-check-syntax-automatically '(save mode-enabled))
+
+  (icejam-set-eglot-capfs))
+
+(add-hook 'js2-mode-hook 'icejam-activate-js2-mode)
+
+(provide 'icejam-lang-javascript)
+;;; icejam-lang-javascript.el ends here

user-lisp/langs/icejam-lang-kotlin.el

@@ -0,0 +1,34 @@
+;;; kotlin.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; kotlin does a thing.
+
+;;; 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))
+
+(use-package kotlin-ts-mode :ensure t :defer t)
+
+(add-to-list 'auto-mode-alist '("\\.kt\\'" . kotlin-ts-mode))
+(add-to-list 'auto-mode-alist '("\\.kts\\'" . kotlin-ts-mode))
+
+(use-package gradle-mode :defer t :ensure t)
+
+(defun icejam-activate-kotlin-mode ()
+  "All things Kotlin."
+  (icejam-set-indent 2)
+  (column-enforce-n 100)
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))
+
+(add-hook 'kotlin-ts-mode-hook 'icejam-activate-kotlin-mode)
+
+(provide 'icejam-lang-kotlin)
+;;; icejam-lang-kotlin.el ends here

user-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

user-lisp/langs/icejam-lang-markdown.el

@@ -0,0 +1,38 @@
+;;; markdown -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(eval-when-compile
+  (declare-function elpaca-installed-p "elpaca")
+  (declare-function column-enforce-n 'column-enforce-mode (number))
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function icejam-set-no-eglot-capfs 'icejam-prog-mode)
+  (declare-function rxt--re-builder-switch-pcre-mode "pcre2el"))
+
+(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))
+
+(add-hook 'markdown-mode-hook 'icejam-lang-activate-markdown-mode)
+(add-hook 'markdown-mode-hook 'display-line-numbers-mode)
+
+(provide 'icejam-lang-markdown)
+;;; icejam-lang-markdown.el ends here

user-lisp/langs/icejam-lang-ocaml.el

@@ -0,0 +1,98 @@
+;;; ocaml -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+(eval-when-compile
+  (defvar icejam-ocaml-lang-menu 'icejam-lang-ocaml)
+  (defvar icejam-language-transient-alist)
+  (declare-function transient-define-prefix 'transient)
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point))
+
+(use-package merlin :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)
+
+(with-eval-after-load 'tuareg
+  (add-hook 'tuareg-mode-hook 'merlin-mode))
+
+(transient-define-prefix icejam-ocaml-lang-menu ()
+  "Ocaml Actions."
+  ["OCaml actions"
+   [""
+    ("r" "Reload"   icejam-revert-buffer-no-confirm)
+    ("i" "Indent"   icejam-mark-and-indent-whole-buffer)]
+   [""
+    ("f" "Format"   lsp-format-buffer)
+    ("e" "Errors"   flymake-show-buffer-diagnostics)
+    ("o" "Opam Env" opam-switch-set-switch)]]
+  [""
+   ("q" "Quit"      keyboard-quit)])
+
+(add-to-list 'icejam-language-transient-alist '(tuareg-mode . icejam-ocaml-lang-menu))
+
+(defun icejam-load-ocaml-site-packages ()
+  "Generate ocaml config."
+  (let ((opam-share (ignore-errors (car (process-lines "opam" "var" "share")))))
+    (when (and opam-share (file-directory-p opam-share))
+      ;; Register Merlin
+      (add-to-list 'load-path (expand-file-name "emacs/site-lisp" opam-share))
+      (autoload 'merlin-mode "merlin" nil t nil)
+      (autoload 'utop "utop" nil t nil)
+      (autoload 'dune "dune" nil t nil)
+
+      ;; Use opam switch to lookup ocamlmerlin binary
+      (setq merlin-command 'opam))))
+
+;; OCaml setup
+(defun icejam-activate-tuareg-mode ()
+  "All thing OCaml."
+  (icejam-set-indent 2)
+  (opam-switch-mode t)
+  (icejam-load-ocaml-site-packages)
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))
+
+(add-hook 'tuareg-mode-hook 'icejam-activate-tuareg-mode)
+
+;; Disable merlin keys that are unused by me
+(add-hook 'merlin-mode-hook (lambda ()
+                              (unbind-key "C-c C-d" merlin-mode-map)
+                              (unbind-key "C-c C-l" merlin-mode-map)
+                              (unbind-key "C-c C-n" merlin-mode-map)
+                              (unbind-key "C-c C-p" merlin-mode-map)
+                              (unbind-key "C-c C-r" merlin-mode-map)
+                              (unbind-key "C-c C-t" merlin-mode-map)
+                              (unbind-key "C-c C-x" merlin-mode-map)
+                              (unbind-key "C-c &" merlin-mode-map)))
+
+;; Use tuareg-opam with lock files
+(add-to-list 'auto-mode-alist '("\\.opam.locked\\'" . tuareg-opam-mode))
+
+;; (transient-define-prefix icejam-lang-reasonml-context-menu ()
+;;   "ReasonML Actions."
+;;   ["ReasonML actions"
+;;    [""
+;;     ("r" "Reload"   icejam-revert-buffer-no-confirm)
+;;     ("i" "Indent"   icejam-mark-and-indent-whole-buffer)]
+;;    [""
+;;     ("f" "Format"   refmt)
+;;     ("e" "Opam Env" opam-switch-set-switch)]]
+;;   [""
+;;    ("q" "Quit"      keyboard-quit)])
+
+
+;; (defun icejam-lang-activate-reason-mode ()
+;;   "Generate reason config."
+;;   (define-key
+;;     reason-mode-map (kbd "C-c l") 'icejam-lang-reasonml-context-menu))
+
+;; ;; Reason setup
+;; (add-hook 'reason-mode-hook
+;;           (lambda ()
+;;             (add-hook 'before-save-hook #'refmt-before-save)))
+;; (add-hook 'reason-mode-hook 'icejam-lang-activate-reason-mode)
+;; (add-hook 'reason-mode-hook 'merlin-mode)
+
+(provide 'icejam-lang-ocaml)
+;;; icejam-lang-ocaml.el ends here

user-lisp/langs/icejam-lang-other.el

@@ -0,0 +1,44 @@
+;;; other.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; Load other languages or syntaxes configuration that do not fit anywhere else.
+
+;;; Code:
+
+;; Infrastructure files
+(use-package dockerfile-mode :ensure t :defer t)
+(use-package docker :ensure t :defer t)
+(use-package terraform-mode :ensure t :defer t)
+(use-package ansible :ensure t :defer t)
+(use-package nginx-mode :ensure t :defer t)
+(use-package
+  jenkinsfile-mode
+  :ensure (:repo "https://github.com/john2x/jenkinsfile-mode.git"
+                 :branch "master")
+  :defer t)
+
+;; Graphql schema definition files.
+(use-package graphql-mode :ensure t :defer t
+  :mode ("\\.graphqls\\'" . graphql-mode))
+
+;; Yaml
+(use-package yaml-mode :ensure t :defer t)
+
+(with-eval-after-load 'yaml-mode
+  (defun icejam-lang-activate-yaml-mode ()
+    "Activate yaml-mode."
+    (eglot-ensure))
+  (add-hook 'yaml-mode-hook 'icejam-lang-activate-yaml-mode))
+
+;; Other text files
+(use-package json-mode :ensure t :defer t)
+(use-package git-modes :ensure t :defer t
+  :hook (gitignore . whitespace-mode-hook))
+
+(provide 'icejam-lang-other)
+;;; icejam-lang-other.el ends here

user-lisp/langs/icejam-lang-php.el

@@ -0,0 +1,49 @@
+;;; icejam-lang-php.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; php related settings
+
+;;; Code:
+(eval-when-compile
+  (defvar icejam-language-transient-alist)
+  (defvar icejam-php-lang-menu)
+  (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)
+  (declare-function transient-define-prefix 'transient))
+
+(use-package php-mode :ensure t :defer t)
+
+(transient-define-prefix icejam-php-lang-menu ()
+  "PHP Buffer Commands."
+  [""
+   ["LSP"
+    ("m" "iMenu"       consult-imenu)]
+   ["Buffer"
+    ("r" "Reload"      icejam-revert-buffer-no-confirm)
+    ("f" "Format"      eglot-format-buffer)
+    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)
+    ("e" "Show Errors" flymake-show-buffer-diagnostics)]]
+  [""
+   ("q" "Quit"        keyboard-quit)])
+
+(add-to-list
+ 'icejam-language-transient-alist '(php-mode . icejam-php-lang-menu))
+
+(defun icejam-activate-php-mode ()
+  "All things php."
+  (icejam-set-indent 4)
+  (column-enforce-n 80)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'php-mode-hook 'icejam-activate-php-mode)
+
+(provide 'icejam-lang-php)
+;;; icejam-lang-php.el ends here

user-lisp/langs/icejam-lang-purescript.el

@@ -0,0 +1,35 @@
+;;; purescript.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; Configuration for purescript.
+
+;;; Code:
+
+(eval-when-compile
+  (declare-function column-enforce-n 'column-enforce-mode (number))
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function purescript-indentation-mode 'purescript-mode)
+  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point))
+
+(use-package purescript-mode :ensure t :defer t)
+
+(defun icejam-activate-purescript-mode ()
+  "All things Purescript."
+  (icejam-set-indent 2)
+  (column-enforce-n 98)
+
+  ;; Purescript indentation
+  (purescript-indentation-mode t)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'purescript-mode-hook 'icejam-activate-purescript-mode)
+
+(provide 'icejam-lang-purescript)
+;;; icejam-lang-purescript.el ends here

user-lisp/langs/icejam-lang-python.el

@@ -0,0 +1,42 @@
+;;; python -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+(eval-when-compile
+  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point)
+  (declare-function column-enforce-n "column-enforce-mode" (number))
+  (declare-function transient-define-prefix 'transient)
+  (defvar icejam-language-transient-alist)
+  (defvar icejam-python-lang-menu))
+
+(transient-define-prefix icejam-python-lang-menu ()
+  "Python Buffer Commands."
+  [""
+   ["LSP"
+    ("m" "iMenu"       consult-imenu)]
+   ["Buffer"
+    ("r" "Reload"      icejam-revert-buffer-no-confirm)
+    ("f" "Format"      eglot-format-buffer)
+    ("i" "Indent"      icejam-mark-and-indent-whole-buffer)
+    ("e" "Show Errors" flymake-show-buffer-diagnostics)]]
+  [""
+   ("q" "Quit"        keyboard-quit)])
+
+;; Add lookup for C-c l transient menu
+(add-to-list
+ 'icejam-language-transient-alist '(python-mode . icejam-python-lang-menu))
+
+;; Python template language
+(use-package jinja2-mode :ensure t :defer t)
+
+(defun icejam-lang-activate-python-mode ()
+  "Activate python mode."
+  (eglot-ensure)
+  (column-enforce-n 99)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'python-mode-hook 'icejam-lang-activate-python-mode)
+
+(provide 'icejam-lang-python)
+;;; icejam-lang-python.el ends here

user-lisp/langs/icejam-lang-ruby.el

@@ -0,0 +1,40 @@
+;;; ruby -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(eval-when-compile
+  (defvar icejam-language-transient-alist)
+  (defvar eglot-server-programs)
+  (defvar ruby-insert-encoding-magic-comment)
+  (declare-function icejam-set-indent 'icejam-prog-mode)
+  (declare-function icejam-set-eglot-capfs 'icejam-complete-at-point))
+
+(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)
+
+(add-to-list 'auto-mode-alist '("\\.rb\\'" . ruby-ts-mode))
+
+(defun icejam-activate-ruby-mode ()
+  "All things for ruby mode."
+  (icejam-set-indent 2)
+
+  ;; Disable reek syntax checking permanently
+  (add-to-list (make-local-variable 'flycheck-disabled-checkers) 'ruby-reek 'ruby-rubocop)
+
+  ;; Do not insert magic encoding comment at the begining of each file
+  (setopt ruby-insert-encoding-magic-comment nil)
+
+  ;; Start LSP
+  (eglot-ensure)
+
+  ;; Capf override
+  (icejam-set-eglot-capfs))
+
+(add-hook 'ruby-ts-mode-hook 'rspec-mode)
+(add-hook 'ruby-ts-mode-hook 'ruby-end-mode)
+(eval-after-load 'rspec-mode '(rspec-install-snippets))
+(add-hook 'ruby-ts-mode-hook 'icejam-activate-ruby-mode)
+
+(provide 'icejam-lang-ruby)
+;;; icejam-lang-ruby.el ends here

user-lisp/langs/icejam-lang-rust.el

@@ -0,0 +1,40 @@
+;;; rust -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; 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))
+
+(use-package rust-mode
+  :ensure t
+  :defer t
+  :config (setopt rust-mode-treesitter-derive t))
+
+(use-package rustic
+  :ensure t
+  :defer t
+  :after (rust-mode)
+  :config (setopt rustic-format-on-save nil)
+  (setopt rustic-lsp-client 'eglot))
+
+(use-package flycheck-rust
+  :ensure t
+  :defer t
+  :after (rust-mode))
+
+(defun icejam-activate-rust-mode ()
+  "All things for Rust mode."
+  (interactive)
+  (icejam-set-indent 4)
+  (column-enforce-n 99)
+
+  ;; Run LSP
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))
+
+(add-hook 'rust-mode-hook 'icejam-activate-rust-mode)
+(add-hook 'rust-mode-hook 'flycheck-rust-setup)
+
+(provide 'icejam-lang-rust)
+;;; icejam-lang-rust.el ends here

user-lisp/langs/icejam-lang-sh.el

@@ -0,0 +1,12 @@
+;;; sh -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+
+(use-package fish-mode :ensure t :defer t)
+
+(dolist
+    (ending '("\\.zsh\\'" "\\.zshrc\\'" "\\.envrc\\'" "\\.zshrc\\'"))
+  (add-to-list 'auto-mode-alist (cons ending 'sh-mode)))
+
+(provide 'icejam-lang-sh)
+;;; icejam-lang-sh.el ends here

user-lisp/langs/icejam-lang-web.el

@@ -0,0 +1,35 @@
+;;; web -- summary -*- lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+(use-package web-mode :ensure t :defer t)
+
+;; Eex Web mode
+(add-to-list 'auto-mode-alist '("\\.eex\\'" . web-mode))
+(add-to-list 'auto-mode-alist '("\\.leex\\'" . web-mode))
+
+;; ERB mode
+(add-to-list 'auto-mode-alist '("\\.erb\\'" . web-mode))
+
+;; Vue JS
+(add-to-list 'auto-mode-alist '("\\.vue\\'" . web-mode))
+
+(setopt web-mode-extra-auto-pairs
+        '(("eex"  . (("<%" "%>")))
+          ("leex"  . (("<%" "%>")))
+          ("erb"  . (("<%" "%>")
+                     ("beg" "end")))))
+
+(defun icejam-activate-web-mode ()
+	"Web mode overrides."
+	;; Indent web mode scripts by 2
+	(setq-local web-mode-script-padding 2)
+	(setq-local web-mode-code-indent-offset 2)
+	(setq-local web-mode-markup-indent-offset 2)
+  (setq-local flycheck-check-syntax-automatically '(save mode-enabled))
+	(when (string-match-p ".vue" (buffer-file-name))
+    (eglot-ensure)))
+
+(add-hook 'web-mode-hook 'icejam-activate-web-mode)
+
+(provide 'icejam-lang-web)
+;;; icejam-lang-web.el ends here

user-lisp/langs/icejam-lang-ziglang.el

@@ -0,0 +1,33 @@
+;;; ziglang.el --- summary -*- lexical-binding: t; -*-
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Commentary:
+
+;; ziglang does a thing.
+
+;;; 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))
+
+(use-package zig-mode :ensure t :defer t)
+
+(defun icejam-activate-zig-mode ()
+  "Goodies for editing zig files."
+
+  ;; Set column width to 100
+  (column-enforce-n 100)
+
+  ;; Set indentation to 4 chars
+  (icejam-set-indent 4)
+  (eglot-ensure)
+  (icejam-set-eglot-capfs))
+
+(add-hook 'zig-mode-hook 'icejam-activate-zig-mode)
+
+(provide 'icejam-lang-ziglang)
+;;; icejam-lang-ziglang.el ends here

user-lisp/themes/icejam-base16-catppuccin-frappe.el

@@ -0,0 +1,47 @@
+;; icejam-base16-catppuccin-frappe.el -- A base16 colorscheme  -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Base16: (https://github.com/tinted-theming/home)
+
+;;; Authors:
+;; Scheme: https://github.com/catppuccin/catppuccin
+;; Template: Kaleb Elwert <belak@coded.io>
+
+;;; Code:
+
+(declare-function base16-theme-define "base16-theme" (theme-name theme-colors))
+
+(defvar icejam-base16-catppuccin-frappe-theme-colors
+  '(:base00 "#303446"
+    :base01 "#292c3c"
+    :base02 "#414559"
+    :base03 "#5f667f"
+    :base04 "#626880"
+    :base05 "#c6d0f5"
+    :base06 "#f2d5cf"
+    :base07 "#babbf1"
+    :base08 "#e78284"
+    :base09 "#ef9f76"
+    :base0A "#e5c890"
+    :base0B "#a6d189"
+    :base0C "#81c8be"
+    :base0D "#8caaee"
+    :base0E "#ca9ee6"
+    :base0F "#eebebe")
+  "All colors for Base16 Catppuccin Frappe are defined here.")
+
+;; Define the theme
+(deftheme icejam-base16-catppuccin-frappe)
+
+(with-eval-after-load 'base16-theme
+  (base16-theme-define 'icejam-base16-catppuccin-frappe
+                       icejam-base16-catppuccin-frappe-theme-colors))
+
+;; Add all the faces to the theme
+(base16-theme-define 'icejam-base16-catppuccin-frappe
+                     icejam-base16-catppuccin-frappe-theme-colors)
+
+;; Mark the theme as provided
+(provide-theme 'icejam-base16-catppuccin-frappe)
+(provide 'icejam-base16-catppuccin-frappe)
+;;; icejam-base16-catppuccin-frappe.el ends here

user-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

user-lisp/themes/icejam-base16-harmonic-light.el

@@ -0,0 +1,42 @@
+;;; icejam-base16-harmonic-light-modified.el --- summary
+;;; Commentary:
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Code:
+
+(declare-function base16-theme-define (theme-name colors))
+
+(defvar icejam-base16-harmonic-light-colors
+  '(:base00 "#f7f9fb"
+    :base01 "#e5ebf1"
+    :base02 "#cbd6e2"
+    :base03 "#92a9c0"
+    :base04 "#627e99"
+    :base05 "#405c79"
+    :base06 "#223b54"
+    :base07 "#0b1c2c"
+    :base08 "#bf8b56"
+    :base09 "#bfbf56"
+    :base0A "#8bbf56"
+    :base0B "#56bf8b"
+    :base0C "#568bbf"
+    :base0D "#8b56bf"
+    :base0E "#bf568b"
+    :base0F "#bf5656")
+  "All colors for Base16 Harmonic Light Modified are defined here.")
+
+;; Define the theme
+(deftheme icejam-base16-harmonic-light)
+
+;; Add all the faces to the theme
+(with-eval-after-load 'base16-theme
+  (base16-theme-define
+   'icejam-base16-harmonic-light icejam-base16-harmonic-light-colors))
+
+;; Mark the theme as provided
+(provide-theme 'icejam-base16-harmonic-light)
+(provide 'icejam-base16-harmonic-light)
+;;; icejam-base16-harmonic-light.el ends here

user-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

user-lisp/themes/icejam-base16-not-harmonic.el

@@ -0,0 +1,60 @@
+;; base16-not-harmonic-theme.el -- A base16 colorscheme
+
+;;; Commentary:
+;; Base16: (https://github.com/chriskempson/base16)
+;; Based on harmonic-dark theme by Jannik Seibert (https://github.com/janniks)
+;;; Code:
+
+(use-package icejam-themes :ensure nil)
+
+(defvar base16-not-harmonic-colors
+  '(:base00 "#102941"
+    :base01 "#223b54"
+    :base02 "#2c3a47"
+    :base03 "#627e99"
+    :base04 "#aabcce"
+    :base05 "#cbd6e2"
+    :base06 "#e5ebf1"
+    :base07 "#f7f9fb"
+    :base08 "#bf8b56"
+    :base09 "#bfbf56"
+    :base0A "#8bbf56"
+    :base0B "#56bf8b"
+    :base0C "#568bbf"
+    :base0D "#9b78bc"
+    :base0E "#bf568b"
+    :base0F "#bf5656")
+  "All colors for Base16 Harmonic16 Dark are defined here.")
+
+;; Define the theme
+(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
+(custom-theme-set-faces
+ 'base16-not-harmonic
+ '(cursor ((t (:background "#568bbf"))))
+ '(font-lock-comment-delimiter-face ((t (:foreground "#aabcce"))))
+ '(mode-line ((t (:font "Hasklig 16"))))
+ '(fringe ((t (:background "#2c3a47" :slant normal))))
+
+ '(diff-refine-added ((t (:background "#56bf8b" :foreground "#2c3a47"))))
+ '(diff-refine-removed ((t (:background "#bf5656" :foreground "#2c3a47"))))
+ '(diff-refine-changed ((t (:background "#bfbf56" :foreground "#2c3a47"))))
+
+ '(magit-diff-added ((t (:background "#56bf8b" :foreground "#2c3a47"))))
+ '(magit-diff-added-highlight ((t (:background "#8bbf56" :foreground "#2c3a47"))))
+
+ '(magit-diff-our ((t (:background "#bf5656" :foreground "#2c3a47"))))
+ '(magit-diff-our-highlight ((t (:background "#bf568b" :foreground "#2c3a47"))))
+
+ '(magit-diff-removed ((t (:background "#bf5656" :foreground "#2c3a47"))))
+ '(magit-diff-removed-highlight ((t (:background "#bf568b" :foreground "#2c3a47")))))
+
+;; Mark the theme as provided
+(provide-theme 'base16-not-harmonic)
+(provide 'icejam-base16-not-harmonic)
+;;; icejam-base16-not-harmonic.el ends here

user-lisp/themes/icejam-base16-summerfruit-light.el

@@ -0,0 +1,41 @@
+;;; base16-summerfruit-light-modified-theme.el --- summary
+;;; Commentary:
+
+;; Author: Maciej Szlosarczyk
+;; Maintainer: Maciej Szlosarczyk
+;; Version: 0.1-snapshot
+
+;;; Code:
+
+(use-package icejam-themes :ensure nil)
+
+(defvar base16-summerfruit-light-modified-colors
+  '(:base00 "#fdfcfa"
+    :base01 "#e0e0e0"
+    :base02 "#d0d0d0"
+    :base03 "#b0b0b0"
+    :base04 "#000000"
+    :base05 "#101010"
+    :base06 "#151515"
+    :base07 "#202020"
+    :base08 "#ff0086"
+    :base09 "#fd8900"
+    :base0A "#aba800"
+    :base0B "#00c918"
+    :base0C "#1faaaa"
+    :base0D "#3777e6"
+    :base0E "#ad00a1"
+    :base0F "#cc6633")
+  "All colors for Base16 Summerfruit Light are defined here.")
+
+;; Define the theme
+(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
+(provide-theme 'base16-summerfruit-light-modified)
+(provide 'icejam-base16-summerfruit-light)
+;;; icejam-base16-summerfruit-light.el ends here

user-lisp/themes/icejam-base16-zenburn.el

@@ -0,0 +1,50 @@
+;; icejam-base16-zenburn.el -- A base16 colorscheme
+
+;;; Commentary:
+;; Base16: (https://github.com/chriskempson/base16)
+
+;;; Original Authors:
+;; Scheme: elnawe
+;; Template: Kaleb Elwert <belak@coded.io>
+;; Modification: Maciej Szlosarczyk <maciej@sosek.net>
+
+;;; Code:
+
+;; Modifications
+;; 02 made darker by 5%   #606060 => #5b5b5b
+;; 03 made lighter by 10% #6f6f6f => #898989
+;; 04 made darker by 5%   #808080 => #7a7a7a
+;; 0B made lighter by 10% #5f7f5f => #799979
+
+(declare-function base16-theme-define "base16-theme" (theme-name theme-colors))
+
+(defvar icejam-base16-zenburn-colors
+  '(:base00 "#383838"
+    :base01 "#404040"
+    :base02 "#5b5b5b"
+    :base03 "#898989"
+    :base04 "#7a7a7a"
+    :base05 "#dcdccc"
+    :base06 "#c0c0c0"
+    :base07 "#ffffff"
+    :base08 "#dca3a3"
+    :base09 "#dfaf8f"
+    :base0A "#e0cf9f"
+    :base0B "#799979"
+    :base0C "#93e0e3"
+    :base0D "#7cb8bb"
+    :base0E "#dc8cc3"
+    :base0F "#000000")
+  "All colors for Base16 Zenburn-Modified are defined here.")
+
+;; Define the theme
+(deftheme icejam-base16-zenburn)
+
+;; Add all the faces to the theme
+(with-eval-after-load 'base16-theme
+  (base16-theme-define 'icejam-base16-zenburn icejam-base16-zenburn-colors))
+
+;; Mark the theme as provided
+(provide-theme 'icejam-base16-zenburn)
+(provide 'icejam-base16-zenburn)
+;;; icejam-base16-zenburn.el ends here

user-lisp/themes/icejam-tronesque.el

@@ -0,0 +1,388 @@
+;;; tronesque-theme.el --- Color Theme based on Tron universe.
+
+;; This file is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+
+;; This file is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; License: GPL-3+
+
+;; Copyright (c) 2017  Aurélien Bottazini
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+;; Author: Aurélien Bottazini <aurelienbottazini.com>
+;; URL: https://github.com/aurelienbottazini/tronesque
+;; Version: 2.0
+
+;;; Commentary:
+
+;; In your init file:
+;; (load-theme 'tronesque)
+;;
+;; You can also add:
+;; (tronesque-mode-line)
+;; To get a custom mode-line with additional colors
+;;
+;; Supports both Emacs with a window system and Emacs within a
+;; terminal. When used within a terminal you should use tronesque
+;; themed ansi colors (available in github repository)
+
+;;; Code:
+(deftheme tronesque
+  "Theme based on Tron universe. Colors are inspired / taken from the movies.
+More information on Tron: https://en.wikipedia.org/wiki/Tron")
+
+(let (
+      (base00 (if (window-system) "#081724" "black"))
+      (base01 (if (window-system) "#033340" "brightblack"))
+      (base02 (if (window-system) "#1d5483" "brightyellow"))
+      (base03 (if (window-system) "#2872b2" "brightblue"))
+      (base04 (if (window-system) "#d3f9ee" "white"))
+      (base05 (if (window-system) "#a6f3dd" "brightgreen"))
+      (base06 (if (window-system) "#effffe" "brightwhite"))
+      (base07 (if (window-system) "#fffed9" "brightcyan"))
+      (red (if (window-system) "#ff694d" "red"))
+      (orange (if (window-system) "#f5b55f" "brightred"))
+      (yellow (if (window-system) "#fffe4e" "yellow"))
+      (magenta (if (window-system) "#afc0fd" "brightmagenta"))
+      (violet (if (window-system) "#96a5d9" "magenta"))
+      (blue (if (window-system) "#bad6e2" "blue"))
+      (cyan (if (window-system) "#d2f1ff" "cyan"))
+      (green (if (window-system) "#68f6cb" "green")))
+
+  (custom-theme-set-faces
+   'tronesque
+
+
+   `(button ((t (:background ,base00
+                 :foreground ,magenta
+                 :inherit nil
+                 :box (:line-width 2 :style released-button)))))
+   `(cursor ((t (:background ,base06))))
+
+   `(custom-button ((t (:background ,magenta
+                        :foreground ,base00
+                        :inherit nil
+                        :box (:line-width 2 :style released-button)))))
+   `(custom-state ((t (:foreground ,green))))
+   `(default ((t (:background ,base00 :foreground ,base04))))
+   `(dired-directory ((t (:background ,green :foreground ,base00))))
+   `(dired-symlink ((t (:foreground ,yellow))))
+
+   `(escape-glyph ((t (:foreground ,green))))
+   `(flymake-errline ((t (:background ,red
+                          :foreground ,base00
+                          :underline nil))))
+   `(flymake-warnline ((t (:background ,orange
+                           :foreground ,base00
+                           :underline nil))))
+   `(font-lock-builtin-face ((t (:slant italic :foreground ,violet))))
+   `(font-lock-comment-delimiter-face ((t (:foreground ,base03))))
+   `(font-lock-comment-face ((t (:foreground ,base03))))
+   `(font-lock-constant-face ((t (:weight bold :foreground ,magenta))))
+   `(font-lock-doc-face ((t (:slant italic :foreground ,green))))
+   `(font-lock-function-name-face ((t (:foreground ,blue))))
+   `(font-lock-keyword-face ((t (:weight bold :foreground ,violet))))
+   `(font-lock-negation-char-face ((t (:foreground ,red))))
+   `(font-lock-preprocessor-face ((t (:foreground ,violet))))
+   `(font-lock-regexp-grouping-backslash ((t (:inherit (bold)))))
+   `(font-lock-regexp-grouping-construct ((t (:inherit (bold)))))
+   `(font-lock-string-face ((t (:foreground ,green))))
+   `(font-lock-type-face ((t (:foreground ,orange))))
+   `(font-lock-variable-name-face ((t (:foreground ,red))))
+   `(font-lock-warning-face ((t (:foreground ,orange :underline t))))
+   `(fringe ((t (:foreground ,base04 :background ,base01))))
+   `(header-line ((t (:box (:line-width -1 :color nil :style released-button)
+                      :foreground ,base00 :background ,base07))))
+   `(highlight ((t (:background ,yellow :foreground ,base00))))
+   `(hl-line ((t (:background ,base01 :inherit nil))))
+   `(idle-highlight ((t (:background ,base01 :foreground nil))))
+   `(ido-indicator ((t (:background ,red
+                        :foreground ,base00
+                        :width condensed))))
+   `(ido-only-match ((t (:background ,green :foreground ,base00))))
+   `(ido-first-match ((t (:background ,green :foreground ,base00))))
+   `(ido-subdir ((t (:foreground ,red))))
+   `(info-menu-star ((t (:foreground ,red))))
+   `(info-xref ((t (:foreground ,green))))
+   `(isearch ((t (:weight bold :foreground ,base00 :background ,yellow))))
+   `(isearch-fail ((t (:weight bold :foreground ,red))))
+   `(lazy-highlight ((t (:weight bold
+                         :foreground ,base00
+                         :background ,base07))))
+   `(link ((t (:foreground ,cyan :underline t))))
+   `(link-visited ((t (:foreground ,blue :underline t))))
+   `(match ((t (:foreground ,base00 :background ,blue))))
+   `(minibuffer-prompt ((t (:foreground ,yellow))))
+   `(next-error ((t (:inherit (region)))))
+   `(org-hide ((t (:background ,base00 :foreground ,base00))))
+   `(org-code ((t (:foreground ,violet))))
+   `(org-date ((t (:underline t :foreground ,green))))
+   `(org-agenda-date-today ((t (:foreground ,red :weight bold))))
+   `(query-regplace ((t (:inherit (isearch)))))
+   `(region ((t (:background ,base02))))
+   `(secondary-selection ((t (:background ,base01))))
+   `(shadow ((t (:foreground ,base02))))
+   `(trailing-whitespace ((t (:background ,red))))
+
+   `(magit-header ((t (:background ,base01
+                       :foreground ,magenta
+                       :inherit nil ))))
+   `(magit-item-highlight ((t (:background ,base01 :foreground ,base06))))
+   `(magit-branch ((t (:foreground ,base05))))
+   `(magit-diff-hunk-header ((t (:background ,base02))))
+   `(magit-section-title ((t (:background ,orange
+                              :foreground ,base00
+                              :inherit nil
+                              :box (:line-width 2 :style released-button)))))
+   `(diff-file-header ((t (:background ,base00
+                           :foreground ,magenta
+                           :inherit nil
+                           :box (:line-width 2 :style released-button)))))
+   `(diff-context ((t (:inherit diff-changed :foreground ,base03))))
+   `(diff-added ((t (:inherit diff-changed
+                     :foreground ,green
+                     :background ,base00))))
+   `(diff-removed ((t (:inherit diff-changed
+                       :foreground ,red
+                       :background ,base00))))
+
+   `(outline-1 ((t (:foreground ,red :height 1.7))))
+   `(outline-2 ((t (:foreground ,orange :height 1.3))))
+   `(outline-3 ((t (:foreground ,yellow :height 1.05))))
+   `(outline-4 ((t (:foreground ,blue))))
+   `(outline-5 ((t (:foreground ,magenta))))
+   `(outline-6 ((t (:foreground ,green))))
+   `(outline-7 ((t (:foreground ,cyan))))
+   `(outline-8 ((t (:foreground ,violet))))
+
+   `(success ((t (:background ,green :foreground ,base00 :weight bold))))
+   `(compilation-mode-line-exit ((t (:inherit compilation-info
+                                     :background ,green
+                                     :weight bold))))
+   `(compilation-mode-line-fail ((t (:inherit compilation-error
+                                     :background ,red
+                                     :weight bold))))
+
+   `(erc-dangerous-host-face ((t (:foreground ,red))))
+   `(erc-direct-msg-face ((t (:foreground ,red))))
+   `(erc-error-face ((t (:foreground ,red))))
+   `(erc-fool-face ((t (:foreground ,base02))))
+   `(erc-header-line ((t (:background ,base07 :foreground ,base00))))
+   `(erc-inverse-face ((t (:background ,base04 :foreground ,base00))))
+   `(erc-keyword-face ((t (:foreground ,green :weight bold))))
+   `(erc-nick-msg-face ((t (:foreground ,red :weight bold))))
+   `(erc-notice-face ((t (:foreground ,base02 :weight bold))))
+   `(erc-pal-face ((t (:foreground ,magenta :weight bold))))
+   `(erc-prompt-face ((t (:background ,violet
+                          :foreground ,base00
+                          :weight bold))))
+   `(erc-timestamp-face ((t (:foreground ,green :weight bold))))
+   `(erc-input-face ((t (:foreground ,orange))))
+   `(erc-my-nick-face ((t (:foreground ,yellow))))
+   `(erc-current-nick-face ((t (:foreground ,yellow))))
+
+   `(show-paren-match ((t (:background ,base03 :foreground ,green))))
+   `(show-paren-mismatch ((t (:background ,red :foreground ,base00))))
+   `(sp-show-pair-match-face ((t (:inherit show-paren-match))))
+   `(sp-show-pair-mismatch-face ((t (:inherit show-paren-mismatch))))
+   `(sp-pair-overlay-face ((t (:inherit sp-show-pair-match-face))))
+   `(ac-completion-face ((t (:foreground ,base02 :underline t))))
+   `(ac-candidate-face ((t (:background ,base04 :foreground ,base00))))
+   `(ac-candidate-mouse-face ((t (:inherit ac-completion-face))))
+   `(ac-selection-face ((t (:background ,base02))))
+   `(writegood-weasels-face ((t (:inherit font-lock-warning-face))))
+
+   `(company-echo-common ((t (:foreground ,orange))))
+   `(company-preview ((t (:background ,base02 :foreground ,base06))))
+   `(company-preview-common ((t (:inherit company-preview
+                                 :foreground ,base05))))
+   `(company-preview-search ((t (:inherit company-preview
+                                 :background ,yellow))))
+   `(company-scrollbar-bg ((t (:inherit company-tooltip :background ,violet))))
+   `(company-scrollbar-fg ((t (:background ,blue))))
+   `(company-template-field ((t (:background ,yellow :foreground ,violet))))
+   `(company-tooltip ((t (:background ,base02 :foreground ,base04))))
+   `(company-tooltip-annotation ((t (:inherit company-tooltip
+                                     :foreground ,base00))))
+   `(company-tooltip-common ((t (:inherit company-tooltip
+                                 :foreground ,base04))))
+   `(company-tooltip-common-selection ((t (:inherit company-tooltip-selection
+                                           :foreground ,yellow))))
+   `(company-tooltip-selection ((t (:inherit company-tooltip
+                                    :background ,base01))))
+   `(helm-buffer-directory ((t (:background ,base00 :foreground ,red))))
+   `(helm-buffer-file ((t (:foreground ,base05 :background ,base00))))
+   `(helm-buffer-not-saved ((t (:foreground ,orange))))
+   `(helm-buffer-process ((t (:foreground ,orange))))
+   `(helm-buffer-saved-out ((t (:background ,base00 :foreground ,red))))
+   `(helm-buffer-size ((t (:foreground ,magenta))))
+   `(helm-candidate-number ((t (:background ,yellow :foreground ,base00))))
+   `(helm-header ((t (:inherit header-line))))
+   `(helm-prefarg ((t (:foreground ,green))))
+   `(helm-selection ((t (:background ,green
+                         :foreground ,base00
+                         :underline nil))))
+   `(helm-separator ((t (:foreground ,red))))
+   `(helm-source-header ((t (:background ,violet
+                             :foreground ,base00
+                             :weight bold :height 1.3))))
+   `(helm-visible-mark ((t (:background ,green :foreground ,base00))))
+
+   `(whitespace-empty ((t (:background ,yellow :foreground ,base00))))
+            `(whitespace-hspace ((t (:background ,red :foreground ,yellow))))
+   `(whitespace-indentation ((t (:background ,red :foreground ,yellow))))
+   `(whitespace-line ((t (:foreground ,red))))
+   `(whitespace-newline ((t (:foreground ,base02 :weight normal))))
+   `(whitespace-space ((t (:background ,base00 :foreground ,base02))))
+   `(whitespace-space-after-tab ((t (:background ,yellow :foreground ,red))))
+   `(whitespace-pace-before-tab ((t (:background ,yellow :foreground ,orange))))
+   `(whitespace-tab ((t (:background ,red :foreground ,yellow))))
+   `(whitespace-trailing ((t (:background ,red
+                              :foreground ,yellow :weight bold))))
+
+    `(markdown-header-face ((t (:foreground ,red :weight bold))))
+    `(markdown-header-face-1 ((t (:inherit outline-1))))
+    `(markdown-header-face-2 ((t (:inherit outline-2))))
+    `(markdown-header-face-3 ((t (:inherit outline-3))))
+    `(markdown-header-face-4 ((t (:inherit outline-4))))
+    `(markdown-header-face-5 ((t (:inherit outline-5))))
+   )
+
+  (custom-theme-set-variables
+   'tronesque
+
+   `(ansi-color-names-vector
+     ;; black, red, green, yellow, blue, magenta, cyan, white
+     [,base00 ,red ,green ,yellow ,blue ,magenta ,cyan ,base04])
+   `(ansi-term-color-vector
+     ;; black, red, green, yellow, blue, magenta, cyan, white
+     [unspecified ,base00 ,red ,green ,yellow ,blue ,magenta ,cyan ,base04]))
+
+  ;; Extra mode line faces
+  (make-face 'mode-line-read-only-face)
+  (make-face 'mode-line-modified-face)
+  (make-face 'mode-line-clean-face)
+  (make-face 'mode-line-folder-face)
+  (make-face 'mode-line-filename-face)
+  (make-face 'mode-line-position-face)
+  (make-face 'mode-line-mode-face)
+  (make-face 'mode-line-minor-mode-face)
+  (make-face 'mode-line-vc-face)
+  (make-face 'mode-line-80col-face)
+
+  (set-face-attribute 'mode-line nil
+                      :foreground base00 :background base03
+                      :inverse-video nil
+                      :box `(:line-width 2 :color ,base03  :style nil))
+  (set-face-attribute 'mode-line-inactive nil
+                      :foreground base00 :background base01
+                      :inverse-video nil
+                      :box `(:line-width 2 :color ,base01 :style nil))
+  (set-face-attribute 'mode-line-read-only-face nil
+                      :inherit 'mode-line-face
+                      :foreground red)
+  (set-face-attribute 'mode-line-modified-face nil
+                      :inherit 'mode-line-face
+                      :background red
+                      :box `(:line-width 2 :color ,red :style nil))
+  (set-face-attribute 'mode-line-clean-face nil
+                      :inherit 'mode-line-face
+                      :background green
+                      :box `(:line-width 2 :color ,green :style nil))
+  (set-face-attribute 'mode-line-folder-face nil
+                      :inherit 'mode-line-face
+                      :foreground base00
+                      :background blue
+                      :box `(:line-width 2 :color ,blue :style nil))
+  (set-face-attribute 'mode-line-filename-face nil
+                      :inherit 'mode-line-face
+                      :foreground base02
+                      :background orange
+                      :box `(:line-width 2 :color ,orange :style nil)
+                      :weight 'bold)
+  (set-face-attribute 'mode-line-position-face nil
+                      :inherit 'mode-line-face
+                      :height 100)
+  (set-face-attribute 'mode-line-mode-face nil
+                      :inherit 'mode-line-face
+                      :foreground base00
+                      :background blue
+                      :box `(:line-width 2 :color ,blue :style nil))
+  (set-face-attribute 'mode-line-minor-mode-face nil
+                      :foreground base00
+                      :height 110)
+  (set-face-attribute 'mode-line-vc-face nil
+                      :inherit 'mode-line-face
+                      :background green
+                      :box `(:line-width 2 :color ,green :style nil))
+  (set-face-attribute 'mode-line-80col-face nil
+                      :inherit 'mode-line-position-face
+                      :foreground "black" :background orange
+                      :box `(:line-width 2 :color ,orange :style nil))
+  )
+
+(defun icejam-tronesque-mode-line ()
+  "Change default mode-line."
+  (interactive)
+  (setq-default
+   mode-line-format
+   '(
+     "%e"
+     mode-line-front-space
+     mode-line-mule-info
+     mode-line-client
+     mode-line-modified
+     mode-line-remote
+     mode-line-frame-identification
+     (:propertize " "
+                  face mode-line-filename-face)
+     (:propertize mode-line-buffer-identification
+                  face mode-line-filename-face)
+     (:propertize " "
+                  face mode-line-filename-face)
+     " "
+     mode-line-position
+     (vc-mode vc-mode)
+     " "
+     (:propertize " "
+                  face mode-line-mode-face)
+     (:propertize mode-name
+                  face mode-line-mode-face)
+     (:propertize " "
+                  face mode-line-mode-face)
+
+     (:eval (propertize (format-mode-line minor-mode-alist)
+                        'face 'mode-line-minor-mode-face))
+     mode-line-misc-info
+     mode-line-end-spaces)))
+
+;; Helper function
+(defun icejam-shorten-directory (dir max-length)
+  "Show up a directory named `DIR' with `MAX-LENGTH' characters."
+  (let ((path (reverse (split-string (abbreviate-file-name dir) "/")))
+        (output ""))
+    (when (and path (equal "" (car path)))
+      (setq path (cdr path)))
+    (while (and path (< (length output) (- max-length 4)))
+      (setq output (concat (car path) "/" output))
+      (setq path (cdr path)))
+    (when path
+      (setq output (concat ".../" output)))
+    output))
+
+
+;;;###autoload
+(when load-file-name
+  (add-to-list 'custom-theme-load-path
+               (file-name-as-directory (file-name-directory load-file-name))))
+
+(provide-theme 'tronesque)
+(provide icejam-tronesque)
+;;; icejam-tronesque.el ends here