configs/Emacs/emacs.org

Emacs Configuration

About

My attempt at a litterate configuration for Emacs. to tangle this file, run the following command in Emacs:

(org-babel-tangle)

or keyboard shortcut `C-c C-v t` (org-babel-tangle) in Emacs. This will generate the `~/.emacs.d/init.el` file with the configuration.

Prep

Copilot Authentication

To use GitHub Copilot, you need to authenticate with your GitHub account. This is done by running the following command in Emacs: after installing the copilot package: Try to trigger the GitHub OAuth flow from within Emacs:

(call-interactively 'copilot-auth)

Configuration

Setup lexical binding

Here we set up lexical binding, which is a feature in Emacs Lisp that allows for more efficient variable scoping and function closures. This is recommended for performance reasons.

;; enable lexical binding
(setq lexical-binding t)

Set automatic update of packages

We set up Emacs to automatically update packages on startup. This ensures that we always have the latest versions of the packages we use.

(defun geokkjer/display-startup-time ()
  (message "Emacs loaded in %s with %d grabage collections."
           (format "%.2f seconds"
                   (float-time
                    (time-subtract after-init-time before-init-time)))
           gcs-done))

(add-hook 'emacs-startup-hook #'geokkjer/display-startup-time)

(setq gc-cons-threshold (* 50 1000 1000))

Customize UI

Here we set up the UI to our liking. We disable the menu bar, tool bar, and scroll bar, and set the font size to 14pt.

;; disable startup screen
(setq inhibit-startup-screen t)
;; disable menu bar
(menu-bar-mode -1)
;; disable tool bar
(tool-bar-mode -1)
;; disable scroll bar
(scroll-bar-mode -1)
;; set font size
(set-face-attribute 'default nil :height 140)

Set up doom modeline, which is a nice status line for Emacs. We set it up to show the current buffer name and the current line number.

;; install doom-modeline if not already installed
(unless (package-installed-p 'doom-modeline)
  (package-refresh-contents)
  (package-install 'doom-modeline))
(require 'doom-modeline)
;; enable doom-modeline
(doom-modeline-mode 1)
;; set up doom-modeline to show the current buffer name and line number
(setq doom-modeline-buffer-file-name-style 'truncate-with-project)

Set up package management

;; set up package archives
(require 'package)
(setq package-archives
      '(("melpa" . "https://melpa.org/packages/")
        ("gnu"   . "https://elpa.gnu.org/packages/")))
(package-initialize)

Install use-package

;; install use-package if not already installed
(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))
(require 'use-package)
;; ensure that use-package is always used
(setq use-package-always-ensure t)

Org Mode

Configure Org-mode for literate programming and note-taking.

;; ensure org-mode is installed and up to date
(use-package org
  :ensure t
  :mode ("\\.org\\'" . org-mode)
  :config
  ;; enable syntax highlighting in code blocks
  (setq org-src-fontify-natively t)
  ;; preserve indentation in code blocks
  (setq org-src-preserve-indentation t)
  ;; enable babel for code execution
  (org-babel-do-load-languages
   'org-babel-load-languages
   '((emacs-lisp . t)
     (shell . t)
     (python . t)
     (nix . t)))
  ;; don't ask for confirmation when evaluating code blocks
  (setq org-confirm-babel-evaluate nil))

Code Completion and ide features

LSP Mode

Here we install lsp-mode and lsp-ui, which are the core components of the LSP (Language Server Protocol) support in Emacs. We also set up keybindings for common LSP commands.

;; install lsp-mode and lsp-ui if not already installed
(unless (package-installed-p 'lsp-mode)
  (package-refresh-contents)
  (package-install 'lsp-mode))
(unless (package-installed-p 'lsp-ui)
  (package-refresh-contents)
  (package-install 'lsp-ui))
(require 'lsp-mode)
(require 'lsp-ui)
;; enable lsp-mode in programming buffers
(add-hook 'prog-mode-hook #'lsp)

GitHub Copilot

Here we install from MELPA, enable it in all prog-modes and bind keys for completion:

;; ensure Copilot is installed
(unless (package-installed-p 'copilot)
  (package-refresh-contents)
  (package-install 'copilot))

(require 'copilot)
;; turn on in programming buffers
(add-hook 'prog-mode-hook #'copilot-mode)

;; keybindings: M-TAB to trigger, TAB to accept
(define-key copilot-mode-map       (kbd "M-TAB") #'copilot-complete)
(define-key copilot-completion-map (kbd "<tab>")   #'copilot-accept-completion)

Language support

Here we install and configure support for various programming languages. We use the `use-package` macro to ensure that the packages are installed and configured correctly.

NixOS from Emacs

Editing Nix files and doing NixOS admin stuff like nixos-rebuild boot –upgrade Run the commands with M-x shell-command

;; NixOS commands   
(defun nixos-upgrade ()
  "Run 'nixos-rebuild boot --upgrade' in a shell."
  (interactive)
  (shell-command "nixos-rebuild boot --upgrade"))

(defun nixos-switch ()
  "Run 'nixos-rebuild switch' in a shell."
  (interactive)
  (shell-command "nixos-rebuild switch"))

;; install nix-mode
(use-package nix-mode
  :ensure t
  :mode "\\.nix\\'")
;; install nix-repl
(use-package nix-repl
  :ensure t
  :mode "\\.nix\\'")
;; install nixpkgs
(use-package nixpkgs
  :ensure t
  :mode "\\.nix\\'")