- M-EMACS
- About EMACS
- About M-EMACS
- Startup
- Package Management
- Global Functionalities
- UI Enhancements
- General Programming
- Programming
- Web Development
- Office
- Internet
- Miscellaneous
Emacs changes how you think about programming.
Emacs is totally introspectable. You can always find out 'what code runs when I press this button?'.
Emacs is an incremental programming environment. There's no edit-compile-run cycle. There isn't even an edit-run cycle. You can execute snippets of code and gradually turn them into a finished project. There's no distinction between your editor and your interpreter.
Emacs is a mutable environment. You can set variables, tweak functions with advice, or redefine entire functions. Nothing is off-limits.
Emacs provides functionality without applications. Rather than separate applications, functionality is all integrated into your Emacs instance. Amazingly, this works. Ever wanted to use the same snippet tool for writing C++ classes as well as emails?
Emacs is full of incredible software concepts that haven't hit the mainstream yet. For example:
- Many platforms have a single item clipboard. Emacs has an infinite clipboard.
- If you undo a change, and then continue editing, you can't redo the original change. Emacs allows undoing to any historical state, even allowing tree-based exploration of history.
- Emacs supports a reverse variable search: you can find variables with a given value.
- You can perform structural editing of code, allowing you to make changes without breaking syntax. This works for lisps (paredit) and non-lisps (smartparens).
- Many applications use a modal GUI: for example, you can't do other edits during a find-and-replace operation. Emacs provides recursive editing that allow you to suspend what you're currently doing, perform other edits, then continue the original task.
Emacs has a documentation culture. Emacs includes a usage manual, a lisp programming manual, pervasive docstrings and even an interactive tutorial.
Emacs has a broad ecosystem. If you want to edit code in a niche language, there's probably an Emacs package for it.
Emacs doesn't have a monopoly on good ideas, and there are other great tools out there. Nonetheless, we believe the Emacs learning curve pays off.
This beautifully written About EMACS section credits to Remacs.
M-EMACS is a custom GNU Emacs setup and configuration distribution that aims not only to enhance the default Emacs experience, and hopefully be a sample that everyone can easily navigate and reference through a highly detailed README that contains 99% of the entire configuration code.
As a young EMACSer, I have experienced the struggle to find a detailed configuration that is loosely coupled and highly readable. This mostly due to the nature of source codes, sometimes comments are harder to notice or simply not enough. Therefore I decided to construct this README and present any human-readable explanation in a much more human-friendly way. Anyone, particularly Emacs beginners who have no idea where to start with their personal config, is more than welcome to read through this document and copy/paste any part to use it on their own.
This distribution is designed and tested for GNU Emacs 26.1 and above only. However, it is always suggested to use Emacs 27, the latest stable version released, for its significant improvement in the core that's out of the scope of M-EMACS. 
Some heartwarming responses from the Emacs community:
- "Actually I understated how much I liked reading through your config… What makes me excited about this config is the readability and possibility of extending in a similar way." – from u/Orgmonics
- "I have to say Matt's setup has the best clarity of all emacs setups I have ever tried. It's really a good template to develop your own emacs config. Thanks again…" – from u/fqye
- "Thanks for the fantastic emacs setup, I love emacs, but trying to get lsp working right was killing me, yours worked out of the box and all I had to do was add some bindings, it's really a time saver" – from ahonnecke
- "Thank you for helping a guy out and for sharing this. I hope this evolves to be into something really big." – from d3v-S
- and more… Love you guys! ❤️❤️
This README is originated from init.org that is generated using M-x org-gfm-export-to-markdown. Every block of code is generated through this function - it exports sections of code from the elisp/ directory. You will not see their presence in init.org. This not only enables a cleaner organization but also significantly improves Emacs start-up time than the traditional everything in an org file approach.
-
Install GNU Emacs.
-
(Optional) On Ubuntu,
emacs-snapshotis a great way to get latest version of Emacs.sudo add-apt-repository -y ppa:ubuntu-elisp sudo apt-get update sudo apt-get install emacs-snapshot
-
(Optional) Build latest Emacs from source.
# Install essential build tools sudo apt-get install build-essential texinfo libx11-dev libxpm-dev libjpeg-dev libpng-dev libgif-dev libtiff-dev libgtk2.0-dev libncurses-dev gnutls-dev libgtk-3-dev git autoconf # Clone source git clone --depth=1 https://github.com/emacs-mirror/emacs.git # Go to source cd emacs/ # Build Emacs ./autogen.sh ./configure --with-mailutils make # Install (optional) sudo make install
-
-
Clone this repo to
HOMEor~/path using git and update all the submodules.cd ~ git clone --recurse-submodules -j8 https://github.com/lanyusan/.emacs.d.git cd .emacs.d
-
Ensure a stable connection to Melpa Packages, then open Emacs.
-
Enter
ywhen prompted withAuto-update packages now?, wait for all packages to install. -
In your favorite browser,
Ctrl-f Prerequisitethrough this README and follow the Prerequisite instructions. -
Restart Emacs.
I will be updating M-EMACS from time to time, it is best to git pull once a while to stay up to date.
Please also execute git submodule update --recursive --remote to sync with all the submodules.
You have the permission to use, modify, distribute in any way you want.
However, what is free stays free. After all, this is GPL.
Remember you must manually sync this README with all the new changes you made by:
- Please do NOT edit this
README.mdfile, editinit.orginstead! - If you add a new mode, create a new
<file-name>.elfile inelisp/directory. - Put
(require '<file-name>)in init.el accordingly. - Add
#+INCLUDE: "~/.emacs.d/elisp/<place-holder>.el" src emacs-lisp :range-begin "<start-line-wrapper-exclusive>" :range-end "<end-line-wrapper-exclusive>"in the appropriate section ininit.org. - Enter
C-x C-sto save and update:lines. (if you don't see the updated effect, runM-x save-and-update-includesmanually) - Call
M-x org-gfm-export-to-markdownto updateREADME.mdautomatically.
If you spotted a bug or you have any suggestions, please fill in an issue. If you have something to fix, feel free to create a pull request.
Everyone starts somewhere, and I started here.
Use lexical-binding. Why?
Until Emacs 24.1 (June 2012), Elisp only had dynamically scoped variables, a feature, mostly by accident, common to old lisp dialects. While dynamic scope has some selective uses, it’s widely regarded as a mistake for local variables, and virtually no other languages have adopted it.
;;; init.el --- -*- lexical-binding: t -*-Emacs27 introduces early-init.el, which is run before init.el, before package and UI initialization happens.
Ensure emacs-version>=26, manually require early-init configurations if emacs-version<27.
(cond ((version< emacs-version "26.1")
(warn "M-EMACS requires Emacs 26.1 and above!"))
((let* ((early-init-f (expand-file-name "early-init.el" user-emacs-directory))
(early-init-do-not-edit-d (expand-file-name "early-init-do-not-edit/" user-emacs-directory))
(early-init-do-not-edit-f (expand-file-name "early-init.el" early-init-do-not-edit-d)))
(and (version< emacs-version "27")
(or (not (file-exists-p early-init-do-not-edit-f))
(file-newer-than-file-p early-init-f early-init-do-not-edit-f)))
(make-directory early-init-do-not-edit-d t)
(copy-file early-init-f early-init-do-not-edit-f t t t t)
(add-to-list 'load-path early-init-do-not-edit-d)
(require 'early-init))))Defer garbage collection further back in the startup process, according to hlissner.
The GC eats up quite a bit of time, easily doubling startup time. The trick is to turn up the memory threshold as early as possible.
(setq gc-cons-threshold 100000000)Package initialize occurs automatically, before user-init-file is loaded, but after early-init-file. We handle package initialization, so we must prevent Emacs from doing it early!
(setq package-enable-at-startup nil)Every file opened and loaded by Emacs will run through this list to check for a proper handler for the file, but during startup, it won’t need any of them.
(defvar file-name-handler-alist-original file-name-handler-alist)
(setq file-name-handler-alist nil)(setq site-run-file nil)It will be faster to disable them here before they've been initialized.
(menu-bar-mode -1)
(unless (and (display-graphic-p) (eq system-type 'darwin))
(push '(menu-bar-lines . 0) default-frame-alist))
(push '(tool-bar-lines . 0) default-frame-alist)
(push '(vertical-scroll-bars) default-frame-alist)A large gc-cons-threshold may cause freezing and stuttering during long-term interactive use.
If you experience freezing, decrease this amount, if you experience stuttering, increase this amount.
(defvar better-gc-cons-threshold 134217728 ; 128mb
"The default value to use for `gc-cons-threshold'.
If you experience freezing, decrease this. If you experience stuttering, increase this.")
(add-hook 'emacs-startup-hook
(lambda ()
(setq gc-cons-threshold better-gc-cons-threshold)
(setq file-name-handler-alist file-name-handler-alist-original)
(makunbound 'file-name-handler-alist-original)))Garbage Collect when Emacs is out of focus and avoid garbage collection when using minibuffer.
(add-hook 'emacs-startup-hook
(lambda ()
(if (boundp 'after-focus-change-function)
(add-function :after after-focus-change-function
(lambda ()
(unless (frame-focus-state)
(garbage-collect))))
(add-hook 'after-focus-change-function 'garbage-collect))
(defun gc-minibuffer-setup-hook ()
(setq gc-cons-threshold (* better-gc-cons-threshold 2)))
(defun gc-minibuffer-exit-hook ()
(garbage-collect)
(setq gc-cons-threshold better-gc-cons-threshold))
(add-hook 'minibuffer-setup-hook #'gc-minibuffer-setup-hook)
(add-hook 'minibuffer-exit-hook #'gc-minibuffer-exit-hook)))Since all the configuration files are stored in elisp/ folder, they need to be added to load-path now.
(defun update-to-load-path (folder)
"Update FOLDER and its subdirectories to `load-path'."
(let ((base folder))
(unless (member base load-path)
(add-to-list 'load-path base))
(dolist (f (directory-files base))
(let ((name (concat base "/" f)))
(when (and (file-directory-p name)
(not (equal f ".."))
(not (equal f ".")))
(unless (member base load-path)
(add-to-list 'load-path name)))))))
(update-to-load-path (expand-file-name "elisp" user-emacs-directory))(defconst *sys/win32*
(eq system-type 'windows-nt)
"Are we running on a WinTel system?")
(defconst *sys/linux*
(eq system-type 'gnu/linux)
"Are we running on a GNU/Linux system?")
(defconst *sys/mac*
(eq system-type 'darwin)
"Are we running on a Mac system?")
(defconst python-p
(or (executable-find "python3")
(and (executable-find "python")
(> (length (shell-command-to-string "python --version | grep 'Python 3'")) 0)))
"Do we have python3?")
(defconst pip-p
(or (executable-find "pip3")
(and (executable-find "pip")
(> (length (shell-command-to-string "pip --version | grep 'python 3'")) 0)))
"Do we have pip3?")
(defconst clangd-p
(or (executable-find "clangd") ;; usually
(executable-find "/usr/local/opt/llvm/bin/clangd")) ;; macOS
"Do we have clangd?")
(defconst eaf-env-p
(and (display-graphic-p) python-p pip-p)
"Do we have EAF environment setup?")An init-private.el file has been designated at user-emacs-directory for you to store personal configurations that you don't want to source-control.
;; Load init-private.el if it exists
(when (file-exists-p (expand-file-name "init-private.el" user-emacs-directory))
(load-file (expand-file-name "init-private.el" user-emacs-directory)))Some packages are disabled with the :disabled tag, because I don't use them very often. You can disable packages similarly yourself too:
(use-package foo
:disabled)Configure package archives, where to install online packages and add them to load-path.
;; Select the folder to store packages
;; Comment / Uncomment to use desired sites
(setq package-user-dir (expand-file-name "elpa" user-emacs-directory)
package-archives
'(("gnu" . "https://elpa.gnu.org/packages/")
("melpa" . "https://melpa.org/packages/")
("cselpa" . "https://elpa.thecybershadow.net/packages/")
;; ("melpa-cn" . "http://mirrors.cloud.tencent.com/elpa/melpa/")
;; ("gnu-cn" . "http://mirrors.cloud.tencent.com/elpa/gnu/")
))Add packages contained in site-elisp/ to load-path too.
cd site-elisp/
git submodule add https://github.com/foo/bar.gitVerify .gitmodules file that the newly added package exist.
git submodule init
git submodule update(unless (bound-and-true-p package--initialized)
(setq package-enable-at-startup nil) ; To prevent initializing twice
(package-initialize))
;; set use-package-verbose to t for interpreted .emacs,
;; and to nil for byte-compiled .emacs.elc.
(eval-and-compile
(setq use-package-verbose (not (bound-and-true-p byte-compile-current-file))))My Emacs configuration is almost entirely dependant on use-package.
The
use-packagemacro allows you to isolate package configuration in your .emacs file in a way that is both performance-oriented and, well, tidy. I created it because I have over 80 packages that I use in Emacs, and things were getting difficult to manage. Yet with this utility my total load time is around 2 seconds, with no loss of functionality!
;; Install use-package if not installed
(unless (package-installed-p 'use-package)
(package-refresh-contents)
(package-install 'use-package))
(eval-and-compile
(setq use-package-always-ensure t)
(setq use-package-expand-minimally t)
(setq use-package-compute-statistics t)
(setq use-package-enable-imenu-support t))
(eval-when-compile
(require 'use-package)
(require 'bind-key))Auto package update automatically updates installed packages if at least auto-package-update-interval days have passed since the last update.
(use-package auto-package-update
:if (not (daemonp))
:custom
(auto-package-update-interval 7) ;; in days
(auto-package-update-prompt-before-update t)
(auto-package-update-delete-old-versions t)
(auto-package-update-hide-results t)
:config
(auto-package-update-maybe))Diminish, a feature that removes certain minor modes from mode-line.
(use-package diminish)Prerequisite: Please update this file your personal info.
(setq user-full-name "Mingde (Matthew) Zeng")
(setq user-mail-address "[email protected]");; Unbind unneeded keys
(global-set-key (kbd "C-z") nil)
(global-set-key (kbd "M-z") nil)
(global-set-key (kbd "M-m") nil)
(global-set-key (kbd "C-x C-z") nil)
(global-set-key (kbd "M-/") nil)
;; Truncate lines
(global-set-key (kbd "C-x C-l") #'toggle-truncate-lines)
;; Adjust font size like web browsers
(global-set-key (kbd "C-=") #'text-scale-increase)
(global-set-key (kbd "C-+") #'text-scale-increase)
(global-set-key (kbd "C--") #'text-scale-decrease)
;; Move up/down paragraph
(global-set-key (kbd "M-n") #'forward-paragraph)
(global-set-key (kbd "M-p") #'backward-paragraph)
;; Revert buffer
(global-set-key (kbd "<f5>") #'revert-buffer-quick)Avy, a nice way to move around text.
(use-package avy
:defer t
:bind
(("C-z c" . avy-goto-char-timer)
("C-z l" . avy-goto-line))
:custom
(avy-timeout-seconds 0.3)
(avy-style 'pre)
:custom-face
(avy-lead-face ((t (:background "#51afef" :foreground "#870000" :weight bold)))));Crux, a Collection of Ridiculously Useful eXtensions for Emacs.
(use-package crux
:bind
(("C-a" . crux-move-beginning-of-line)
("C-x 4 t" . crux-transpose-windows)
("C-x K" . crux-kill-other-buffers)
("C-k" . crux-smart-kill-line))
:config
(crux-with-region-or-buffer indent-region)
(crux-with-region-or-buffer untabify)
(crux-with-region-or-point-to-eol kill-ring-save)
(defalias 'rename-file-and-buffer #'crux-rename-file-and-buffer))Ivy, a generic completion mechanism for Emacs. It utilizes Amx, Counsel and Swiper.
(use-package ivy
:diminish
:init
(use-package amx :defer t)
(use-package counsel :diminish :config (counsel-mode 1))
(use-package swiper :defer t)
(ivy-mode 1)
:bind
(("C-s" . swiper-isearch)
("C-z s" . counsel-rg)
("C-z b" . counsel-buffer-or-recentf)
("C-z C-b" . counsel-ibuffer)
("M-y" . counsel-yank-pop)
(:map ivy-minibuffer-map
("M-RET" . ivy-immediate-done))
(:map counsel-find-file-map
("C-~" . counsel-goto-local-home)))
:custom
(ivy-use-virtual-buffers t)
(ivy-height 10)
(ivy-on-del-error-function nil)
(ivy-magic-slash-non-match-action 'ivy-magic-slash-non-match-create)
(ivy-count-format "【%d/%d】")
(ivy-wrap t)
:config
(defun counsel-goto-local-home ()
"Go to the $HOME of the local machine."
(interactive)
(ivy--cd "~/")))Color rg, a search and refactoring tool based on ripgrep that is used to search text.
Prerequisite: Ensure ripgrep and ensure rg is in PATH.
(use-package color-rg
:load-path (lambda () (expand-file-name "site-elisp/color-rg" user-emacs-directory))
:if (executable-find "rg")
:bind ("C-M-s" . color-rg-search-input))Find File In Project, quick access to project files in Emacs.
Prerequisite: Ensure GNU Find is in PATH. Install Gow or Cygwin or MYSYS2 on Windows.
(use-package find-file-in-project
:if (executable-find "find")
:init
(when (executable-find "fd")
(setq ffip-use-rust-fd t))
:bind (("C-z o" . ffap)
("C-z p" . ffip)))Dired, the directory editor.
(use-package dired
:ensure nil
:bind
(("C-x C-j" . dired-jump))
:custom
;; Always delete and copy recursively
(dired-listing-switches "-lah")
(dired-recursive-deletes 'always)
(dired-recursive-copies 'always)
;; Auto refresh Dired, but be quiet about it
(global-auto-revert-non-file-buffers t)
(auto-revert-verbose nil)
;; Quickly copy/move file in Dired
(dired-dwim-target t)
;; Move files to trash when deleting
(delete-by-moving-to-trash t)
;; Load the newest version of a file
(load-prefer-newer t)
;; Detect external file changes and auto refresh file
(auto-revert-use-notify nil)
(auto-revert-interval 3) ; Auto revert every 3 sec
:config
;; Enable global auto-revert
(global-auto-revert-mode t)
;; Reuse same dired buffer, to prevent numerous buffers while navigating in dired
(put 'dired-find-alternate-file 'disabled nil)
:hook
(dired-mode . (lambda ()
(local-set-key (kbd "<mouse-2>") #'dired-find-alternate-file)
(local-set-key (kbd "RET") #'dired-find-alternate-file)
(local-set-key (kbd "^")
(lambda () (interactive) (find-alternate-file ".."))))))Disk Usage, a file system analyzer that offers a tabulated view of file listings sorted by size.
(use-package disk-usage
:commands (disk-usage))(defun save-all-buffers ()
"Instead of `save-buffer', save all opened buffers by calling `save-some-buffers' with ARG t."
(interactive)
(save-some-buffers t))
(global-set-key (kbd "C-x C-s") nil)
(global-set-key (kbd "C-x C-s") #'save-all-buffers)Winner, a mode to restore previous window layouts.
(use-package winner
:ensure nil
:custom
(winner-boring-buffers
'("*Completions*"
"*Compile-Log*"
"*inferior-lisp*"
"*Fuzzy Completions*"
"*Apropos*"
"*Help*"
"*cvs*"
"*Buffer List*"
"*Ibuffer*"
"*esh command on file*"))
:config
(winner-mode 1))Which Key, a feature that displays the key bindings following the incomplete command.
(use-package which-key
:diminish
:custom
(which-key-separator " ")
(which-key-prefix-prefix "+")
:config
(which-key-mode))Undo tree, a feature that provides a visualization of the undos in a file.
(use-package undo-tree
:defer t
:diminish undo-tree-mode
:init (global-undo-tree-mode)
:custom
(undo-tree-visualizer-diff t)
(undo-tree-history-directory-alist `(("." . ,(expand-file-name ".backup" user-emacs-directory))))
(undo-tree-visualizer-timestamps t))Discover my major, a feature that discovers key bindings and their meaning for the current Emacs major mode.
(use-package discover-my-major
:bind ("C-h C-m" . discover-my-major))Ace Window, a package for selecting windows to switch to.
(use-package ace-window
:bind ("C-x C-o" . ace-window))Shell Here, a tool that opens a shell buffer in (or relative to) default-directory.
(use-package shell-here
:bind ("M-~" . shell-here)
:config
(when *sys/linux*
(setq explicit-shell-file-name "/bin/bash")))Multi Term, a mode based on term.el, for managing multiple terminal buffers in Emacs.
(use-package multi-term
:load-path (lambda () (expand-file-name "site-elisp/multi-term" user-emacs-directory))
:commands (multi-term)
:bind
(("M-$" . multi-term)
(:map dired-mode-map ("M-$" . multi-term)))
:custom
(multi-term-program (executable-find "bash"))
(term-bind-key-alist
'(("C-c C-c" . term-interrupt-subjob)
("C-c C-e" . term-send-esc)
("C-p" . previous-line)
("C-n" . next-line)
("C-m" . term-send-return)
("C-y" . term-paste)
("C-v" . scroll-up-command)
("M-v" . scroll-down-command)
("M-f" . term-send-forward-word)
("M-b" . term-send-backward-word)
("M-o" . term-send-backspace)
("M-p" . term-send-up)
("M-n" . term-send-down)
("M-M" . term-send-forward-kill-word)
("M-N" . term-send-backward-kill-word)
("<C-backspace>" . term-send-backward-kill-word)
("<M-backspace>" . term-send-backward-kill-word)
("M-r" . term-send-reverse-search-history)
("M-d" . term-send-delete-word)
("M-," . term-send-raw)
("M-." . comint-dynamic-complete))))Term Keys, a lossless keyboard input for Emacs in terminal emulators.
(use-package term-keys
:if (not (display-graphic-p))
:config (term-keys-mode t))Exec Path From Shell, a library to ensure environment variables inside Emacs look the same as in the user's shell.
(use-package exec-path-from-shell
:if (memq window-system '(mac ns x))
:config
(exec-path-from-shell-initialize))Sudo Edit, an utility for opening files with sudo.
(use-package sudo-edit
:commands (sudo-edit))Ibuffer, an advanced replacement for BufferMenu, which lets you operate on buffers much in the same manner as Dired.
It uses IBuffer VC that group buffers by git project and show file state.
(use-package ibuffer
:ensure nil
:bind ("C-x C-b" . ibuffer)
:init
(use-package ibuffer-vc
:commands (ibuffer-vc-set-filter-groups-by-vc-root)
:custom
(ibuffer-vc-skip-if-remote 'nil))
:custom
(ibuffer-formats
'((mark modified read-only locked " "
(name 35 35 :left :elide)
" "
(size 9 -1 :right)
" "
(mode 16 16 :left :elide)
" " filename-and-process)
(mark " "
(name 16 -1)
" " filename))))Some essential configs that make my life a lot easier.
Use UTF-8 as much as possible with unix line endings.
(unless *sys/win32*
(set-selection-coding-system 'utf-8)
(prefer-coding-system 'utf-8)
(set-language-environment "UTF-8")
(set-default-coding-systems 'utf-8)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
(setq locale-coding-system 'utf-8))
;; Treat clipboard input as UTF-8 string first; compound text next, etc.
(when (display-graphic-p)
(setq x-select-request-type '(UTF8_STRING COMPOUND_TEXT TEXT STRING)));; Remove useless whitespace before saving a file
(defun delete-trailing-whitespace-except-current-line ()
"An alternative to `delete-trailing-whitespace'.
The original function deletes trailing whitespace of the current line."
(interactive)
(let ((begin (line-beginning-position))
(end (line-end-position)))
(save-excursion
(when (< (point-min) (1- begin))
(save-restriction
(narrow-to-region (point-min) (1- begin))
(delete-trailing-whitespace)
(widen)))
(when (> (point-max) (+ end 2))
(save-restriction
(narrow-to-region (+ end 2) (point-max))
(delete-trailing-whitespace)
(widen))))))
(defun smart-delete-trailing-whitespace ()
"Invoke `delete-trailing-whitespace-except-current-line' on selected major modes only."
(unless (member major-mode '(diff-mode))
(delete-trailing-whitespace-except-current-line)))
(defun toggle-auto-trailing-ws-removal ()
"Toggle trailing whitespace removal."
(interactive)
(if (member #'smart-delete-trailing-whitespace before-save-hook)
(progn
(remove-hook 'before-save-hook #'smart-delete-trailing-whitespace)
(message "Disabled auto remove trailing whitespace."))
(add-hook 'before-save-hook #'smart-delete-trailing-whitespace)
(message "Enabled auto remove trailing whitespace.")))
;; Add to hook during startup
(add-hook 'before-save-hook #'smart-delete-trailing-whitespace)
;; Replace selection on insert
(delete-selection-mode 1)
;; Map Alt key to Meta
(setq x-alt-keysym 'meta)(use-package recentf
:ensure nil
:hook (after-init . recentf-mode)
:custom
(recentf-auto-cleanup "05:00am")
(recentf-max-saved-items 200)
(recentf-exclude '((expand-file-name package-user-dir)
".cache"
".cask"
".elfeed"
"bookmarks"
"cache"
"ido.*"
"persp-confs"
"recentf"
"undo-tree-hist"
"url"
"COMMIT_EDITMSG\\'")))
;; When buffer is closed, saves the cursor location
(save-place-mode 1)
;; Set history-length longer
(setq-default history-length 500);; Move the backup fies to user-emacs-directory/.backup
(setq backup-directory-alist `(("." . ,(expand-file-name ".backup" user-emacs-directory))))
;; Ask before killing emacs
(setq confirm-kill-emacs 'y-or-n-p)
;; Automatically kill all active processes when closing Emacs
(setq confirm-kill-processes nil)
;; Turn Off Cursor Alarms
(setq ring-bell-function 'ignore)
;; Show Keystrokes in Progress Instantly
(setq echo-keystrokes 0.1)
;; Don't Lock Files
(setq-default create-lockfiles nil)
;; Better Compilation
(setq-default compilation-always-kill t) ; kill compilation process before starting another
(setq-default compilation-ask-about-save nil) ; save all buffers on `compile'
(setq-default compilation-scroll-output t)
;; ad-handle-definition warnings are generated when functions are redefined with `defadvice',
;; they are not helpful.
(setq ad-redefinition-action 'accept)
;; Move Custom-Set-Variables to Different File
(setq custom-file (concat user-emacs-directory "custom-set-variables.el"))
(load custom-file 'noerror)
;; So Long mitigates slowness due to extremely long lines.
;; Currently available in Emacs master branch *only*!
(when (fboundp 'global-so-long-mode)
(global-so-long-mode))
;; Add a newline automatically at the end of the file upon save.
(setq require-final-newline t)
;; Enable `erase-buffer' function
(put 'erase-buffer 'disabled nil)
;; Default .args, .in, .out files to text-mode
(add-to-list 'auto-mode-alist '("\\.in\\'" . text-mode))
(add-to-list 'auto-mode-alist '("\\.out\\'" . text-mode))
(add-to-list 'auto-mode-alist '("\\.args\\'" . text-mode))
(add-to-list 'auto-mode-alist '("\\.bb\\'" . shell-script-mode))
(add-to-list 'auto-mode-alist '("\\.bbclass\\'" . shell-script-mode))
(add-to-list 'auto-mode-alist '("\\.Rmd\\'" . markdown-mode))Important functions.
;; Resizes the window width based on the input
(defun resize-window-width (w)
"Resizes the window width based on W."
(interactive (list (if (> (count-windows) 1)
(read-number "Set the current window width in [1~9]x10%: ")
(error "You need more than 1 window to execute this function!"))))
(message "%s" w)
(window-resize nil (- (truncate (* (/ w 10.0) (frame-width))) (window-total-width)) t))
;; Resizes the window height based on the input
(defun resize-window-height (h)
"Resizes the window height based on H."
(interactive (list (if (> (count-windows) 1)
(read-number "Set the current window height in [1~9]x10%: ")
(error "You need more than 1 window to execute this function!"))))
(message "%s" h)
(window-resize nil (- (truncate (* (/ h 10.0) (frame-height))) (window-total-height)) nil))
;; Setup shorcuts for window resize width and height
(global-set-key (kbd "C-z w") #'resize-window-width)
(global-set-key (kbd "C-z h") #'resize-window-height)
(defun resize-window (width delta)
"Resize the current window's size. If WIDTH is non-nil, resize width by some DELTA."
(if (> (count-windows) 1)
(window-resize nil delta width)
(error "You need more than 1 window to execute this function!")))
;; Setup shorcuts for window resize width and height
(defun window-width-increase ()
(interactive)
(resize-window t 5))
(defun window-width-decrease ()
(interactive)
(resize-window t -5))
(defun window-height-increase ()
(interactive)
(resize-window nil 5))
(defun window-height-decrease ()
(interactive)
(resize-window nil -5))
(global-set-key (kbd "M-W =") #'window-width-increase)
(global-set-key (kbd "M-W M-+") #'window-width-increase)
(global-set-key (kbd "M-W -") #'window-width-decrease)
(global-set-key (kbd "M-W M-_") #'window-width-decrease)
(global-set-key (kbd "M-Q =") #'window-height-increase)
(global-set-key (kbd "M-Q M-+") #'window-height-increase)
(global-set-key (kbd "M-Q -") #'window-height-decrease)
(global-set-key (kbd "M-Q M-_") #'window-height-decrease)(defun edit-configs ()
"Opens the README.org file."
(interactive)
(find-file "~/.emacs.d/init.org"))
(global-set-key (kbd "C-z e") #'edit-configs)Update Org Mode INCLUDE Statements Automatically from Artur Malabarba.
(defun save-and-update-includes ()
"Update the line numbers of #+INCLUDE:s in current buffer.
Only looks at INCLUDEs that have either :range-begin or :range-end.
This function does nothing if not in `org-mode', so you can safely
add it to `before-save-hook'."
(interactive)
(when (derived-mode-p 'org-mode)
(save-excursion
(goto-char (point-min))
(while (search-forward-regexp
"^\\s-*#\\+INCLUDE: *\"\\([^\"]+\\)\".*:range-\\(begin\\|end\\)"
nil 'noerror)
(let* ((file (expand-file-name (match-string-no-properties 1)))
lines begin end)
(forward-line 0)
(when (looking-at "^.*:range-begin *\"\\([^\"]+\\)\"")
(setq begin (match-string-no-properties 1)))
(when (looking-at "^.*:range-end *\"\\([^\"]+\\)\"")
(setq end (match-string-no-properties 1)))
(setq lines (decide-line-range file begin end))
(when lines
(if (looking-at ".*:lines *\"\\([-0-9]+\\)\"")
(replace-match lines :fixedcase :literal nil 1)
(goto-char (line-end-position))
(insert " :lines \"" lines "\""))))))))
(add-hook 'before-save-hook #'save-and-update-includes)
(defun decide-line-range (file begin end)
"Visit FILE and decide which lines to include.
BEGIN and END are regexps which define the line range to use."
(let (l r)
(save-match-data
(with-temp-buffer
(insert-file-contents file)
(goto-char (point-min))
(if (null begin)
(setq l "")
(search-forward-regexp begin)
(setq l (line-number-at-pos (match-beginning 0))))
(if (null end)
(setq r "")
(search-forward-regexp end)
(setq r (1+ (line-number-at-pos (match-end 0)))))
(format "%s-%s" (+ l 1) (- r 1)))))) ;; Exclude wrapper(defun abort-minibuffer-using-mouse ()
"Abort the minibuffer when using the mouse."
(when (and (>= (recursion-depth) 1) (active-minibuffer-window))
(abort-recursive-edit)))
(add-hook 'mouse-leave-buffer-hook 'abort-minibuffer-using-mouse)
;; keep the point out of the minibuffer
(setq-default minibuffer-prompt-properties '(read-only t point-entered minibuffer-avoid-prompt face minibuffer-prompt))(defun display-line-overlay+ (pos str &optional face)
"Display line at POS as STR with FACE.
FACE defaults to inheriting from default and highlight."
(let ((ol (save-excursion
(goto-char pos)
(make-overlay (line-beginning-position)
(line-end-position)))))
(overlay-put ol 'display str)
(overlay-put ol 'face
(or face '(:background null :inherit highlight)))
ol))(defun read-lines (file-path)
"Return a list of lines of a file at FILE-PATH."
(with-temp-buffer (insert-file-contents file-path)
(split-string (buffer-string) "\n" t)))(defun where-am-i ()
"An interactive function showing function `buffer-file-name' or `buffer-name'."
(interactive)
(message (kill-new (if (buffer-file-name) (buffer-file-name) (buffer-name)))))Doom Themes, an UI plugin and pack of themes.
(use-package doom-themes
:custom-face
(cursor ((t (:background "Red"))))
:config
;; flashing mode-line on errors
(doom-themes-visual-bell-config)
;; Corrects (and improves) org-mode's native fontification.
(doom-themes-org-config)
(load-theme 'doom-one t)
(defun switch-theme ()
"An interactive funtion to switch themes."
(interactive)
(when custom-enabled-themes
(disable-theme (intern (car (mapcar #'symbol-name custom-enabled-themes)))))
(call-interactively #'load-theme)))Doom Modeline, a modeline from DOOM Emacs, but more powerful and faster.
(use-package doom-modeline
:custom
;; Don't compact font caches during GC. Windows Laggy Issue
(inhibit-compacting-font-caches t)
(doom-modeline-minor-modes t)
(doom-modeline-icon t)
(doom-modeline-major-mode-color-icon t)
(doom-modeline-height 15)
:config
(doom-modeline-mode))Dashboard, an extensible Emacs startup screen.
Use either KEC_Dark_BK.png or KEC_Light_BK.png depends on the backgrond theme.
(use-package dashboard
:demand
:diminish (dashboard-mode page-break-lines-mode)
:bind
(("C-z d" . open-dashboard)
:map dashboard-mode-map
(("n" . dashboard-next-line)
("p" . dashboard-previous-line)
("N" . dashboard-next-section)
("F" . dashboard-previous-section)))
:custom
(dashboard-banner-logo-title "Close the world. Open the nExt.")
(dashboard-startup-banner (expand-file-name "images/KEC_Dark_BK_Small.png" user-emacs-directory))
(dashboard-items '((recents . 7)
(bookmarks . 7)
(agenda . 5)))
(initial-buffer-choice (lambda () (get-buffer dashboard-buffer-name)))
(dashboard-set-heading-icons t)
(dashboard-set-navigator t)
(dashboard-navigator-buttons
(if (featurep 'all-the-icons)
`(((,(all-the-icons-octicon "mark-github" :height 1.1 :v-adjust -0.05)
"M-EMACS" "Browse M-EMACS Homepage"
(lambda (&rest _) (browse-url "https://github.com/MatthewZMD/.emacs.d")))
(,(all-the-icons-fileicon "elisp" :height 1.0 :v-adjust -0.1)
"Configuration" "" (lambda (&rest _) (edit-configs)))
(,(all-the-icons-faicon "cogs" :height 1.0 :v-adjust -0.1)
"Update" "" (lambda (&rest _) (auto-package-update-now)))))
`((("" "M-EMACS" "Browse M-EMACS Homepage"
(lambda (&rest _) (browse-url "https://github.com/MatthewZMD/.emacs.d")))
("" "Configuration" "" (lambda (&rest _) (edit-configs)))
("" "Update" "" (lambda (&rest _) (auto-package-update-now)))))))
:custom-face
(dashboard-banner-logo-title ((t (:family "Love LetterTW" :height 123))))
:config
(dashboard-setup-startup-hook)
;; Open Dashboard function
(defun open-dashboard ()
"Open the *dashboard* buffer and jump to the first widget."
(interactive)
(dashboard-insert-startupify-lists)
(switch-to-buffer dashboard-buffer-name)
(goto-char (point-min))
(delete-other-windows)))Page-break-lines, a feature that displays ugly form feed characters as tidy horizontal rules.
(use-package page-break-lines
:diminish
:init (global-page-break-lines-mode))Prerequisite: Install all the available fonts and icons from fonts/. Execute M-x all-the-icons-install-fonts and M-x nerd-icons-install-fonts.
;; Input Mono, Monaco Style, Line Height 1.3 download from http://input.fontbureau.com/
(defvar font-list '(("Input" . 11) ("Hack" . 12) ("Consolas" . 12) ("Love LetterTW" . 12.5))
"List of fonts and sizes. The first one available will be used.")Function to switch between fonts.
(defun change-font ()
"Interactively change a font from a list a available fonts."
(interactive)
(let* (available-fonts font-name font-size font-setting)
(dolist (font font-list (setq available-fonts (nreverse available-fonts)))
(when (member (car font) (font-family-list))
(push font available-fonts)))
(if (not available-fonts)
(message "No fonts from the chosen set are available")
(if (called-interactively-p 'interactive)
(let* ((chosen (assoc-string (completing-read "What font to use? " available-fonts nil t) available-fonts)))
(setq font-name (car chosen) font-size (read-number "Font size: " (cdr chosen))))
(setq font-name (caar available-fonts) font-size (cdar available-fonts)))
(setq font-setting (format "%s-%d" font-name font-size))
(set-frame-font font-setting nil t)
(add-to-list 'default-frame-alist (cons 'font font-setting)))))
(when (display-graphic-p)
(change-font))All The Icons, a utility package to collect various Icon Fonts. Enable only in GUI Emacs.
(use-package all-the-icons :if (display-graphic-p))Configurations to smooth scrolling.
;; Vertical Scroll
(setq scroll-step 1)
(setq scroll-margin 1)
(setq scroll-conservatively 101)
(setq scroll-up-aggressively 0.01)
(setq scroll-down-aggressively 0.01)
(setq auto-window-vscroll nil)
(setq fast-but-imprecise-scrolling nil)
(setq mouse-wheel-scroll-amount '(1 ((shift) . 1)))
(setq mouse-wheel-progressive-speed nil)
;; Horizontal Scroll
(setq hscroll-step 1)
(setq hscroll-margin 1)(global-hl-line-mode 1)Prettify symbols mode, a built-in mode for displaying sequences of characters as fancy characters or symbols.
(global-prettify-symbols-mode 1)
(defun add-pretty-lambda ()
"Make some word or string show as pretty Unicode symbols. See https://unicodelookup.com for more."
(setq prettify-symbols-alist
'(("lambda" . 955)
("delta" . 120517)
("epsilon" . 120518)
("->" . 8594)
("<=" . 8804)
(">=" . 8805))))
(add-hook 'prog-mode-hook 'add-pretty-lambda)
(add-hook 'org-mode-hook 'add-pretty-lambda)(setq-default frame-title-format '("M-EMACS - " user-login-name "@" system-name " - %b"))(fset 'yes-or-no-p 'y-or-n-p)
(setq use-dialog-box nil)(setq inhibit-startup-screen t)
(setq initial-major-mode 'text-mode)
;; https://www.youtube.com/watch?v=NfjsLmya1PI
(setq initial-scratch-message "Present Day, Present Time...\n")Display line numbers, and column numbers in modeline.
;; Hook line numbers to only when files are opened, also use linum-mode for emacs-version< 26
(if (version< emacs-version "26")
(global-linum-mode)
(add-hook 'text-mode-hook #'display-line-numbers-mode)
(add-hook 'prog-mode-hook #'display-line-numbers-mode))
;; Display column numbers in modeline
(column-number-mode 1)Display time and battery information in modeline.
(display-time-mode 1)
(when (and battery-status-function
(not (string-match-p "N/A" (battery-format "%B" (funcall battery-status-function)))))
(display-battery-mode 1))Pixel scroll precision mode, introduced in Emacs 29.1, displays text pixel-by-pixel.
(when (version<= "29.1" emacs-version)
(pixel-scroll-precision-mode 1))Magit, an interface to the version control system Git.
(use-package magit
:if (executable-find "git")
:bind
(("C-x g" . magit-status)
(:map magit-status-mode-map
("M-RET" . magit-diff-visit-file-other-window)))
:config
(defun magit-log-follow-current-file ()
"A wrapper around `magit-log-buffer-file' with `--follow' argument."
(interactive)
(magit-log-buffer-file t)))Projectile, a Project Interaction Library for Emacs.
Prerequisite: Windows OS: Install Gow and ensure it's in PATH.
Gow is a lightweight installer that installs useful open source UNIX applications compiled as native win32 binaries. Specifically, tr is needed for Projectile alien indexing.
(use-package projectile
:bind
("C-x p" . projectile-command-map)
:custom
(projectile-completion-system 'ivy)
:config
(projectile-mode 1)
(when (and *sys/win32*
(executable-find "tr"))
(setq projectile-indexing-method 'alien))
(add-to-list 'projectile-globally-ignored-directories "node_modules"))YASnippet, a programming template system for Emacs. It loads YASnippet Snippets, a collection of yasnippet snippets for many languages.
(use-package yasnippet
:diminish yas-minor-mode
:init
(use-package yasnippet-snippets :after yasnippet)
:hook ((prog-mode LaTeX-mode org-mode markdown-mode) . yas-minor-mode)
:bind
(:map yas-minor-mode-map ("C-c C-n" . yas-expand-from-trigger-key))
(:map yas-keymap
(("TAB" . smarter-yas-expand-next-field)
([(tab)] . smarter-yas-expand-next-field)))
:config
(yas-reload-all)
(defun smarter-yas-expand-next-field ()
"Try to `yas-expand' then `yas-next-field' at current cursor position."
(interactive)
(let ((old-point (point))
(old-tick (buffer-chars-modified-tick)))
(yas-expand)
(when (and (eq old-point (point))
(eq old-tick (buffer-chars-modified-tick)))
(ignore-errors (yas-next-field))))))Flycheck, a syntax checking extension.
(use-package flycheck
:defer t
:diminish
:hook (after-init . global-flycheck-mode)
:commands (flycheck-add-mode)
:custom
(flycheck-global-modes
'(not outline-mode diff-mode shell-mode eshell-mode term-mode))
(flycheck-emacs-lisp-load-path 'inherit)
(flycheck-indication-mode (if (display-graphic-p) 'right-fringe 'right-margin))
:init
(if (display-graphic-p)
(use-package flycheck-posframe
:custom-face
(flycheck-posframe-face ((t (:foreground ,(face-foreground 'success)))))
(flycheck-posframe-info-face ((t (:foreground ,(face-foreground 'success)))))
:hook (flycheck-mode . flycheck-posframe-mode)
:custom
(flycheck-posframe-position 'window-bottom-left-corner)
(flycheck-posframe-border-width 3)
(flycheck-posframe-inhibit-functions
'((lambda (&rest _) (bound-and-true-p company-backend)))))
(use-package flycheck-pos-tip
:defines flycheck-pos-tip-timeout
:hook (flycheck-mode . flycheck-pos-tip-mode)
:custom (flycheck-pos-tip-timeout 30)))
:config
(use-package flycheck-popup-tip
:hook (flycheck-mode . flycheck-popup-tip-mode))
(when (fboundp 'define-fringe-bitmap)
(define-fringe-bitmap 'flycheck-fringe-bitmap-double-arrow
[16 48 112 240 112 48 16] nil nil 'center))
(when (executable-find "vale")
(use-package flycheck-vale
:config
(flycheck-vale-setup)
(flycheck-add-mode 'vale 'latex-mode))))Flyspell enables on-the-fly spell checking in Emacs and uses Flyspell Correct for distraction-free words correction using Ivy.
(use-package flyspell
:ensure nil
:diminish
:if (executable-find "aspell")
:hook (((text-mode outline-mode latex-mode org-mode markdown-mode) . flyspell-mode))
:custom
(flyspell-issue-message-flag nil)
(ispell-program-name "aspell")
(ispell-extra-args
'("--sug-mode=ultra" "--lang=en_US" "--camel-case"))
:config
(use-package flyspell-correct-ivy
:after ivy
:bind
(:map flyspell-mode-map
([remap flyspell-correct-word-before-point] . flyspell-correct-wrapper)
("C-." . flyspell-correct-wrapper))
:custom (flyspell-correct-interface #'flyspell-correct-ivy)))Dumb jump, an Emacs "jump to definition" package.
(use-package dumb-jump
:bind
(:map prog-mode-map
(("C-c C-o" . dumb-jump-go-other-window)
("C-c C-j" . dumb-jump-go)
("C-c C-i" . dumb-jump-go-prompt)))
:custom (dumb-jump-selector 'ivy))Smartparens, a minor mode for dealing with pairs.
(use-package smartparens
:hook (prog-mode . smartparens-mode)
:diminish smartparens-mode
:bind
(:map smartparens-mode-map
("C-M-f" . sp-forward-sexp)
("C-M-b" . sp-backward-sexp)
("C-M-a" . sp-backward-down-sexp)
("C-M-e" . sp-up-sexp)
("C-M-w" . sp-copy-sexp)
("C-M-k" . sp-change-enclosing)
("M-k" . sp-kill-sexp)
("C-M-<backspace>" . sp-splice-sexp-killing-backward)
("C-S-<backspace>" . sp-splice-sexp-killing-around)
("C-]" . sp-select-next-thing-exchange))
:custom
(sp-escape-quotes-after-insert nil)
:config
;; Stop pairing single quotes in elisp
(sp-local-pair 'emacs-lisp-mode "'" nil :actions nil)
(sp-local-pair 'org-mode "[" nil :actions nil))Match and automatically pair parenthesis, and show parenthesis even when it went offscreen from Clemens Radermacher.
;; Show matching parenthesis
(show-paren-mode 1)
;; we will call `blink-matching-open` ourselves...
(remove-hook 'post-self-insert-hook
#'blink-paren-post-self-insert-function)
;; this still needs to be set for `blink-matching-open` to work
(setq blink-matching-paren 'show)
(let ((ov nil)) ; keep track of the overlay
(advice-add
#'show-paren-function
:after
(defun show-paren--off-screen+ (&rest _args)
"Display matching line for off-screen paren."
(when (overlayp ov)
(delete-overlay ov))
;; check if it's appropriate to show match info,
;; see `blink-paren-post-self-insert-function'
(when (and (overlay-buffer show-paren--overlay)
(not (or cursor-in-echo-area
executing-kbd-macro
noninteractive
(minibufferp)
this-command))
(and (not (bobp))
(memq (char-syntax (char-before)) '(?\) ?\$)))
(= 1 (logand 1 (- (point)
(save-excursion
(forward-char -1)
(skip-syntax-backward "/\\")
(point))))))
;; rebind `minibuffer-message' called by
;; `blink-matching-open' to handle the overlay display
(cl-letf (((symbol-function #'minibuffer-message)
(lambda (msg &rest args)
(let ((msg (apply #'format-message msg args)))
(setq ov (display-line-overlay+
(window-start) msg))))))
(blink-matching-open))))))Indent Bars, a fast, configurable indentation guide-bars for Emacs.
(use-package indent-bars
:load-path (lambda () (expand-file-name "site-elisp/indent-bars" user-emacs-directory))
:custom
(indent-bars-treesit-support t)
(indent-bars-no-descend-string t)
(indent-bars-treesit-ignore-blank-lines-types '("module"))
(indent-bars-treesit-wrap '((python argument_list parameters
list list_comprehension
dictionary dictionary_comprehension
parenthesized_expression subscript)))
(indent-bars-pattern ". . . . ")
(indent-bars-width-frac 0.25)
(indent-bars-pad-frac 0.2)
(indent-bars-zigzag 0.1)
(indent-bars-color-by-depth '(:regexp "outline-\\([0-9]+\\)" :blend 1))
(indent-bars-highlight-current-depth '(:pattern "." :pad 0.1 :width 0.45))
:hook ((prog-mode yaml-mode) . indent-bars-mode))Indentation Configuration
(setq-default indent-tabs-mode nil)
(setq-default indent-line-function 'insert-tab)
(setq-default tab-width 4)
(setq-default c-basic-offset 4)
(setq-default js-switch-indent-offset 4)
(c-set-offset 'comment-intro 0)
(c-set-offset 'innamespace 0)
(c-set-offset 'case-label '+)
(c-set-offset 'access-label 0)
(c-set-offset (quote cpp-macro) 0 nil)
(defun smart-electric-indent-mode ()
"Disable 'electric-indent-mode in certain buffers and enable otherwise."
(cond ((and (eq electric-indent-mode t)
(member major-mode '(erc-mode text-mode)))
(electric-indent-mode 0))
((eq electric-indent-mode nil) (electric-indent-mode 1))))
(add-hook 'post-command-hook #'smart-electric-indent-mode)Format all, a feature that lets you auto-format source code.
Prerequisite: Read Supported Languages to see which additional tool you need to install for the specific language.
(use-package format-all
:bind ("C-c C-f" . format-all-buffer))Ediff, a mode to simultaneously browse through the differences between a pair of files or buffers.
(use-package ediff
:custom
(ediff-split-window-function #'split-window-horizontally)
(ediff-window-setup-function #'ediff-setup-windows-plain))Evil Nerd Commenter, a tool that helps you comment code efficiently.
(use-package evil-nerd-commenter
:bind
(("C-c M-;" . c-toggle-comment-style)
("M-;" . evilnc-comment-or-uncomment-lines)))Iedit, a minor mode that allows editing multiple regions simultaneousy in a buffer or a region.
(use-package iedit
:bind ("C-z ," . iedit-mode)
:diminish)Awesome Pair, a feature that provides grammatical parenthesis completion.
(use-package awesome-pair
:load-path (lambda () (expand-file-name "site-elisp/awesome-pair" user-emacs-directory))
:bind
(:map prog-mode-map
(("M-D" . awesome-pair-kill)
("SPC" . awesome-pair-space)
("=" . awesome-pair-equal)
("M-F" . awesome-pair-jump-right)
("M-B" . awesome-pair-jump-left)))
:hook (prog-mode . awesome-pair-mode))Conf Mode, a simple major mode for editing conf/ini/properties files.
(use-package conf-mode
:ensure nil
:bind
(:map conf-mode-map
(("M-D" . awesome-pair-kill)
("SPC" . awesome-pair-space)
("=" . awesome-pair-equal)
("M-F" . awesome-pair-jump-right)
("M-B" . awesome-pair-jump-left))))Delete Block, a feature that deletes block efficiently.
(use-package delete-block
:load-path (lambda () (expand-file-name "site-elisp/delete-block" user-emacs-directory))
:bind
(("M-d" . delete-block-forward)
("C-<backspace>" . delete-block-backward)
("M-<backspace>" . delete-block-backward)
("M-DEL" . delete-block-backward)))Header2, a support for creation and update of file headers.
(use-package header2
:load-path (lambda () (expand-file-name "site-elisp/header2" user-emacs-directory))
:custom
(header-copyright-notice (concat "Copyright (C) 2019 " (user-full-name) "\n"))
:hook (emacs-lisp-mode . auto-make-header)
:config
(add-to-list 'write-file-functions 'auto-update-file-header)
(autoload 'auto-make-header "header2")
(autoload 'auto-update-file-header "header2"))Emacs IPython Notebook, a Jupyter (formerly IPython) client in Emacs.
- Execute
M-x ein:runto launch a local Jupyter session. - Login with
M-x ein:loginto a local or remote session. - Open
.ipynbfile and pressC-c C-o.
(use-package ein
:if (executable-find "jupyter")
:bind
(("C-c e" . ein:worksheet-execute-cell)
("C-c C-e" . ein:worksheet-execute-all-cells))
:custom-face
(ein:basecell-input-area-face ((t (:extend t :background "#303640"))))
:defer t
:custom
(ein:worksheet-enable-undo t))Language Server Protocol Mode, a client/library for the Language Server Protocol. M-EMACS tries to use lsp-mode whenever possible.
(use-package lsp-mode
:defer t
:commands lsp
:custom
(lsp-keymap-prefix "C-x l")
(lsp-auto-guess-root nil)
(lsp-prefer-flymake nil) ; Use flycheck instead of flymake
(lsp-enable-file-watchers nil)
(lsp-enable-folding nil)
(read-process-output-max (* 1024 1024))
(lsp-keep-workspace-alive nil)
(lsp-eldoc-hook nil)
:bind (:map lsp-mode-map ("C-c C-f" . lsp-format-buffer))
:hook ((java-mode python-mode go-mode rust-mode
js-mode js2-mode typescript-mode web-mode
c-mode c++-mode objc-mode) . lsp-deferred)
:config
(defun lsp-update-server ()
"Update LSP server."
(interactive)
;; Equals to `C-u M-x lsp-install-server'
(lsp-install-server t)))Language Server Protocol UI, provides all the higher level UI modules of lsp-mode, like flycheck support and code lenses.
Note: lsp-ui-doc is too annoying, so it will not be triggered upon hovering. You have to toggle it using M-i.
(use-package lsp-ui
:after lsp-mode
:diminish
:commands lsp-ui-mode
:custom-face
(lsp-ui-doc-background ((t (:background nil))))
(lsp-ui-doc-header ((t (:inherit (font-lock-string-face italic)))))
:bind
(:map lsp-ui-mode-map
([remap xref-find-definitions] . lsp-ui-peek-find-definitions)
([remap xref-find-references] . lsp-ui-peek-find-references)
("C-c u" . lsp-ui-imenu)
("M-i" . lsp-ui-doc-focus-frame))
(:map lsp-mode-map
("M-n" . forward-paragraph)
("M-p" . backward-paragraph))
:custom
(lsp-ui-doc-header t)
(lsp-ui-doc-include-signature t)
(lsp-ui-doc-border (face-foreground 'default))
(lsp-ui-sideline-enable nil)
(lsp-ui-sideline-ignore-duplicate t)
(lsp-ui-sideline-show-code-actions nil)
:config
;; Use lsp-ui-doc-webkit only in GUI
(when (display-graphic-p)
(setq lsp-ui-doc-use-webkit t))
;; WORKAROUND Hide mode-line of the lsp-ui-imenu buffer
;; https://github.com/emacs-lsp/lsp-ui/issues/243
(defadvice lsp-ui-imenu (after hide-lsp-ui-imenu-mode-line activate)
(setq mode-line-format nil))
;; `C-g'to close doc
(advice-add #'keyboard-quit :before #'lsp-ui-doc-hide))Debug Adapter Protocol Mode, a client/library for the Debug Adapter Protocol.
Prerequisite: See Configuration to configure DAP appropriately.
(use-package dap-mode
:diminish
:bind
(:map dap-mode-map
(("<f12>" . dap-debug)
("<f8>" . dap-continue)
("<f9>" . dap-next)
("<M-f11>" . dap-step-in)
("C-M-<f11>" . dap-step-out)
("<f7>" . dap-breakpoint-toggle))))Company, a text completion framework for Emacs.
The function smarter-yas-expand-next-field-complete is to smartly resolve TAB conflicts in company and yasnippet packages.
(use-package company
:diminish company-mode
:hook ((prog-mode LaTeX-mode latex-mode ess-r-mode) . company-mode)
:bind
(:map company-active-map
([tab] . smarter-tab-to-complete)
("TAB" . smarter-tab-to-complete))
:custom
(company-minimum-prefix-length 1)
(company-tooltip-align-annotations t)
(company-require-match 'never)
;; Don't use company in the following modes
(company-global-modes '(not shell-mode eaf-mode))
;; Trigger completion immediately.
(company-idle-delay 0.1)
;; Number the candidates (use M-1, M-2 etc to select completions).
(company-show-numbers t)
:config
(unless clangd-p (delete 'company-clang company-backends))
(global-company-mode 1)
(defun smarter-tab-to-complete ()
"Try to `org-cycle', `yas-expand', and `yas-next-field' at current cursor position.
If all failed, try to complete the common part with `company-complete-common'"
(interactive)
(when yas-minor-mode
(let ((old-point (point))
(old-tick (buffer-chars-modified-tick))
(func-list
(if (equal major-mode 'org-mode) '(org-cycle yas-expand yas-next-field)
'(yas-expand yas-next-field))))
(catch 'func-suceed
(dolist (func func-list)
(ignore-errors (call-interactively func))
(unless (and (eq old-point (point))
(eq old-tick (buffer-chars-modified-tick)))
(throw 'func-suceed t)))
(company-complete-common))))))Company TabNine, A company-mode backend for TabNine, the all-language autocompleter.
This is enabled by default, if ever you find it not good enough for a particular completion, simply use M-q to immediately switch to default backends.
Prerequisite: Execute M-x company-tabnine-install-binary to install the TabNine binary for your system.
(use-package company-tabnine
:defer 1
:custom
(company-tabnine-max-num-results 9)
:bind
(("M-q" . company-other-backend)
("C-z t" . company-tabnine))
:init
(defun company//sort-by-tabnine (candidates)
"Integrate company-tabnine with lsp-mode"
(if (or (functionp company-backend)
(not (and (listp company-backend) (memq 'company-tabnine company-backends))))
candidates
(let ((candidates-table (make-hash-table :test #'equal))
candidates-lsp
candidates-tabnine)
(dolist (candidate candidates)
(if (eq (get-text-property 0 'company-backend candidate)
'company-tabnine)
(unless (gethash candidate candidates-table)
(push candidate candidates-tabnine))
(push candidate candidates-lsp)
(puthash candidate t candidates-table)))
(setq candidates-lsp (nreverse candidates-lsp))
(setq candidates-tabnine (nreverse candidates-tabnine))
(nconc (seq-take candidates-tabnine 3)
(seq-take candidates-lsp 6)))))
(defun lsp-after-open-tabnine ()
"Hook to attach to `lsp-after-open'."
(setq-local company-tabnine-max-num-results 3)
(add-to-list 'company-transformers 'company//sort-by-tabnine t)
(add-to-list 'company-backends '(company-capf :with company-tabnine :separate)))
(defun company-tabnine-toggle (&optional enable)
"Enable/Disable TabNine. If ENABLE is non-nil, definitely enable it."
(interactive)
(if (or enable (not (memq 'company-tabnine company-backends)))
(progn
(add-hook 'lsp-after-open-hook #'lsp-after-open-tabnine)
(add-to-list 'company-backends #'company-tabnine)
(when (bound-and-true-p lsp-mode) (lsp-after-open-tabnine))
(message "TabNine enabled."))
(setq company-backends (delete 'company-tabnine company-backends))
(setq company-backends (delete '(company-capf :with company-tabnine :separate) company-backends))
(remove-hook 'lsp-after-open-hook #'lsp-after-open-tabnine)
(company-tabnine-kill-process)
(message "TabNine disabled.")))
:hook
(kill-emacs . company-tabnine-kill-process)
:config
(company-tabnine-toggle t))Company Box, a company front-end with icons.
(use-package company-box
:diminish
:if (display-graphic-p)
:defines company-box-icons-all-the-icons
:hook (company-mode . company-box-mode)
:custom
(company-box-backends-colors nil)
(company-box-doc-delay 0.1)
(company-box-doc-frame-parameters '((internal-border-width . 1)
(left-fringe . 3)
(right-fringe . 3)))
:config
(with-no-warnings
;; Prettify icons
(defun my-company-box-icons--elisp (candidate)
(when (or (derived-mode-p 'emacs-lisp-mode) (derived-mode-p 'lisp-mode))
(let ((sym (intern candidate)))
(cond ((fboundp sym) 'Function)
((featurep sym) 'Module)
((facep sym) 'Color)
((boundp sym) 'Variable)
((symbolp sym) 'Text)
(t . nil)))))
(advice-add #'company-box-icons--elisp :override #'my-company-box-icons--elisp)
;; Credits to Centaur for these configurations
;; Display borders and optimize performance
(defun my-company-box--display (string on-update)
"Display the completions."
(company-box--render-buffer string on-update)
(let ((frame (company-box--get-frame))
(border-color (face-foreground 'font-lock-comment-face nil t)))
(unless frame
(setq frame (company-box--make-frame))
(company-box--set-frame frame))
(company-box--compute-frame-position frame)
(company-box--move-selection t)
(company-box--update-frame-position frame)
(unless (frame-visible-p frame)
(make-frame-visible frame))
(company-box--update-scrollbar frame t)
(set-face-background 'internal-border border-color frame)
(when (facep 'child-frame-border)
(set-face-background 'child-frame-border border-color frame)))
(with-current-buffer (company-box--get-buffer)
(company-box--maybe-move-number (or company-box--last-start 1))))
(advice-add #'company-box--display :override #'my-company-box--display)
(defun my-company-box-doc--make-buffer (object)
(let* ((buffer-list-update-hook nil)
(inhibit-modification-hooks t)
(string (cond ((stringp object) object)
((bufferp object) (with-current-buffer object (buffer-string))))))
(when (and string (> (length (string-trim string)) 0))
(with-current-buffer (company-box--get-buffer "doc")
(erase-buffer)
(insert (propertize "\n" 'face '(:height 0.5)))
(insert string)
(insert (propertize "\n\n" 'face '(:height 0.5)))
;; Handle hr lines of markdown
;; @see `lsp-ui-doc--handle-hr-lines'
(with-current-buffer (company-box--get-buffer "doc")
(let (bolp next before after)
(goto-char 1)
(while (setq next (next-single-property-change (or next 1) 'markdown-hr))
(when (get-text-property next 'markdown-hr)
(goto-char next)
(setq bolp (bolp)
before (char-before))
(delete-region (point) (save-excursion (forward-visible-line 1) (point)))
(setq after (char-after (1+ (point))))
(insert
(concat
(and bolp (not (equal before ?\n)) (propertize "\n" 'face '(:height 0.5)))
(propertize "\n" 'face '(:height 0.5))
(propertize " "
'display '(space :height (1))
'company-box-doc--replace-hr t
'face `(:background ,(face-foreground 'font-lock-comment-face)))
(propertize " " 'display '(space :height (1)))
(and (not (equal after ?\n)) (propertize " \n" 'face '(:height 0.5)))))))))
(setq mode-line-format nil
display-line-numbers nil
header-line-format nil
show-trailing-whitespace nil
cursor-in-non-selected-windows nil)
(current-buffer)))))
(advice-add #'company-box-doc--make-buffer :override #'my-company-box-doc--make-buffer)
;; Display the border and fix the markdown header properties
(defun my-company-box-doc--show (selection frame)
(cl-letf (((symbol-function 'completing-read) #'company-box-completing-read)
(window-configuration-change-hook nil)
(inhibit-redisplay t)
(display-buffer-alist nil)
(buffer-list-update-hook nil))
(-when-let* ((valid-state (and (eq (selected-frame) frame)
company-box--bottom
company-selection
(company-box--get-frame)
(frame-visible-p (company-box--get-frame))))
(candidate (nth selection company-candidates))
(doc (or (company-call-backend 'quickhelp-string candidate)
(company-box-doc--fetch-doc-buffer candidate)))
(doc (company-box-doc--make-buffer doc)))
(let ((frame (frame-local-getq company-box-doc-frame))
(border-color (face-foreground 'font-lock-comment-face nil t)))
(unless (frame-live-p frame)
(setq frame (company-box-doc--make-frame doc))
(frame-local-setq company-box-doc-frame frame))
(set-face-background 'internal-border border-color frame)
(when (facep 'child-frame-border)
(set-face-background 'child-frame-border border-color frame))
(company-box-doc--set-frame-position frame)
;; Fix hr props. @see `lsp-ui-doc--fix-hr-props'
(with-current-buffer (company-box--get-buffer "doc")
(let (next)
(while (setq next (next-single-property-change (or next 1) 'company-box-doc--replace-hr))
(when (get-text-property next 'company-box-doc--replace-hr)
(put-text-property next (1+ next) 'display
'(space :align-to (- right-fringe 1) :height (1)))
(put-text-property (1+ next) (+ next 2) 'display
'(space :align-to right-fringe :height (1)))))))
(unless (frame-visible-p frame)
(make-frame-visible frame))))))
(advice-add #'company-box-doc--show :override #'my-company-box-doc--show)
(defun my-company-box-doc--set-frame-position (frame)
(-let* ((frame-resize-pixelwise t)
(box-frame (company-box--get-frame))
(box-position (frame-position box-frame))
(box-width (frame-pixel-width box-frame))
(box-height (frame-pixel-height box-frame))
(box-border-width (frame-border-width box-frame))
(window (frame-root-window frame))
((text-width . text-height) (window-text-pixel-size window nil nil
(/ (frame-pixel-width) 2)
(/ (frame-pixel-height) 2)))
(border-width (or (alist-get 'internal-border-width company-box-doc-frame-parameters) 0))
(x (- (+ (car box-position) box-width) border-width))
(space-right (- (frame-pixel-width) x))
(space-left (car box-position))
(fringe-left (or (alist-get 'left-fringe company-box-doc-frame-parameters) 0))
(fringe-right (or (alist-get 'right-fringe company-box-doc-frame-parameters) 0))
(width (+ text-width border-width fringe-left fringe-right))
(x (if (> width space-right)
(if (> space-left width)
(- space-left width)
space-left)
x))
(y (cdr box-position))
(bottom (+ company-box--bottom (frame-border-width)))
(height (+ text-height (* 2 border-width)))
(y (cond ((= x space-left)
(if (> (+ y box-height height) bottom)
(+ (- y height) border-width)
(- (+ y box-height) border-width)))
((> (+ y height) bottom)
(- (+ y box-height) height))
(t y))))
(set-frame-position frame (max x 0) (max y 0))
(set-frame-size frame text-width text-height t)))
(advice-add #'company-box-doc--set-frame-position :override #'my-company-box-doc--set-frame-position))
(when (require 'all-the-icons nil t)
(declare-function all-the-icons-faicon 'all-the-icons)
(declare-function all-the-icons-material 'all-the-icons)
(declare-function all-the-icons-octicon 'all-the-icons)
(setq company-box-icons-all-the-icons
`((Unknown . ,(all-the-icons-material "find_in_page" :height 1.0 :v-adjust -0.2))
(Text . ,(all-the-icons-faicon "text-width" :height 1.0 :v-adjust -0.02))
(Method . ,(all-the-icons-faicon "cube" :height 1.0 :v-adjust -0.02 :face 'all-the-icons-purple))
(Function . ,(all-the-icons-faicon "cube" :height 1.0 :v-adjust -0.02 :face 'all-the-icons-purple))
(Constructor . ,(all-the-icons-faicon "cube" :height 1.0 :v-adjust -0.02 :face 'all-the-icons-purple))
(Field . ,(all-the-icons-octicon "tag" :height 1.1 :v-adjust 0 :face 'all-the-icons-lblue))
(Variable . ,(all-the-icons-octicon "tag" :height 1.1 :v-adjust 0 :face 'all-the-icons-lblue))
(Class . ,(all-the-icons-material "settings_input_component" :height 1.0 :v-adjust -0.2 :face 'all-the-icons-orange))
(Interface . ,(all-the-icons-material "share" :height 1.0 :v-adjust -0.2 :face 'all-the-icons-lblue))
(Module . ,(all-the-icons-material "view_module" :height 1.0 :v-adjust -0.2 :face 'all-the-icons-lblue))
(Property . ,(all-the-icons-faicon "wrench" :height 1.0 :v-adjust -0.02))
(Unit . ,(all-the-icons-material "settings_system_daydream" :height 1.0 :v-adjust -0.2))
(Value . ,(all-the-icons-material "format_align_right" :height 1.0 :v-adjust -0.2 :face 'all-the-icons-lblue))
(Enum . ,(all-the-icons-material "storage" :height 1.0 :v-adjust -0.2 :face 'all-the-icons-orange))
(Keyword . ,(all-the-icons-material "filter_center_focus" :height 1.0 :v-adjust -0.2))
(Snippet . ,(all-the-icons-material "format_align_center" :height 1.0 :v-adjust -0.2))
(Color . ,(all-the-icons-material "palette" :height 1.0 :v-adjust -0.2))
(File . ,(all-the-icons-faicon "file-o" :height 1.0 :v-adjust -0.02))
(Reference . ,(all-the-icons-material "collections_bookmark" :height 1.0 :v-adjust -0.2))
(Folder . ,(all-the-icons-faicon "folder-open" :height 1.0 :v-adjust -0.02))
(EnumMember . ,(all-the-icons-material "format_align_right" :height 1.0 :v-adjust -0.2))
(Constant . ,(all-the-icons-faicon "square-o" :height 1.0 :v-adjust -0.1))
(Struct . ,(all-the-icons-material "settings_input_component" :height 1.0 :v-adjust -0.2 :face 'all-the-icons-orange))
(Event . ,(all-the-icons-octicon "zap" :height 1.0 :v-adjust 0 :face 'all-the-icons-orange))
(Operator . ,(all-the-icons-material "control_point" :height 1.0 :v-adjust -0.2))
(TypeParameter . ,(all-the-icons-faicon "arrows" :height 1.0 :v-adjust -0.02))
(Template . ,(all-the-icons-material "format_align_left" :height 1.0 :v-adjust -0.2)))
company-box-icons-alist 'company-box-icons-all-the-icons)))LSP Java, Emacs Java IDE using Eclipse JDT Language Server. Note that this package is dependant on Request.
Prerequisite: Install Maven and ensure it's in PATH.
(use-package lsp-java
:after lsp-mode
:if (executable-find "mvn")
:init
(use-package request :defer t)
:custom
(lsp-java-server-install-dir (expand-file-name "~/.emacs.d/eclipse.jdt.ls/server/"))
(lsp-java-workspace-dir (expand-file-name "~/.emacs.d/eclipse.jdt.ls/workspace/")))Prerequisite: Since all completion features are provided by LSP Mode, it needs to setup.
- Install CMake >= 3.8 for all OS.
- *nix OS:
- Windows OS:
Emacs CCLS, a client for CCLS, a C/C++/Objective-C language server supporting multi-million line C++ code-bases, powered by libclang.
(use-package ccls
:defer t
:if (not *sys/win32*)
:hook ((c-mode c++-mode objc-mode) .
(lambda () (require 'ccls) (lsp)))
:custom
(ccls-executable (executable-find "ccls")) ; Add ccls to path if you haven't done so
(ccls-sem-highlight-method 'font-lock)
(ccls-enable-skipped-ranges nil)
:config
(lsp-register-client
(make-lsp-client
:new-connection (lsp-tramp-connection (cons ccls-executable ccls-args))
:major-modes '(c-mode c++-mode cuda-mode objc-mode)
:server-id 'ccls-remote
:multi-root nil
:remote? t
:notification-handlers
(lsp-ht ("$ccls/publishSkippedRanges" #'ccls--publish-skipped-ranges)
("$ccls/publishSemanticHighlight" #'ccls--publish-semantic-highlight))
:initialization-options (lambda () ccls-initialization-options)
:library-folders-fn nil)))Modern CPP Font Lock, font-locking for "Modern C++".
(use-package modern-cpp-font-lock
:diminish t
:init (modern-c++-font-lock-global-mode t))Go Mode, an Emacs mode for Golang programming.
Prerequisite: gopls is required for Golang's LSP support.
go get golang.org/x/tools/gopls@latest(use-package go-mode
:mode "\\.go\\'"
:hook (before-save . gofmt-before-save)
:custom (gofmt-command "goimports"))Rust Mode, an Emacs mode for Rust programming.
(use-package rust-mode
:mode "\\.rs\\'"
:custom
(rust-format-on-save t)
:bind (:map rust-mode-map ("C-c C-c" . rust-run))
:config
(use-package flycheck-rust
:after flycheck
:config
(with-eval-after-load 'rust-mode
(add-hook 'flycheck-mode-hook #'flycheck-rust-setup))))(use-package python-mode
:ensure nil
:after flycheck
:mode "\\.py\\'"
:custom
(python-indent-offset 4)
(flycheck-python-pycompile-executable "python3")
(python-shell-interpreter "python3"))LSP Pyright, a lsp-mode client leveraging Pyright language server.
(use-package lsp-pyright
:hook (python-mode . (lambda () (require 'lsp-pyright)))
:custom
(lsp-pyright-multi-root nil))Haskell Mode, an Emacs mode for Haskell programming.
(use-package haskell-mode
:mode "\\.hs\\'")
;; Install and configure lsp-haskell
(use-package lsp-haskell
:hook ((haskell-mode haskell-literate-mode) . lsp-deferred)
:config (setq lsp-haskell-server-path "haskell-language-server"))Emacs Speaks Statistics, short for ESS, it's designed to support editing of scripts and interaction with various statistical analysis programs such as R, S-Plus, SAS, Stata and OpenBUGS/JAGS.
Prerequisite: Install R to start using ESS with R.
(use-package ess
:defer t
:commands R
:config
(load "ess-autoloads"))Prerequisite: Please install TeX Live.
AUCTeX, an extensible package for writing and formatting TeX files. It supports many different TeX macro packages, including AMS-TEX, LaTeX, Texinfo, ConTEXt, and docTEX (dtx files).
(use-package tex
:ensure auctex
:defer t
:custom
(TeX-auto-save t)
(TeX-parse-self t)
(TeX-master nil)
;; to use pdfview with auctex
(TeX-view-program-selection '((output-pdf "pdf-tools"))
TeX-source-correlate-start-server t)
(TeX-view-program-list '(("pdf-tools" "TeX-pdf-tools-sync-view")))
(TeX-after-compilation-finished-functions #'TeX-revert-document-buffer)
:hook
(LaTeX-mode . (lambda ()
(turn-on-reftex)
(setq reftex-plug-into-AUCTeX t)
(reftex-isearch-minor-mode)
(setq TeX-PDF-mode t)
(setq TeX-source-correlate-method 'synctex)
(setq TeX-source-correlate-start-server t)))
:config
(when (version< emacs-version "26")
(add-hook LaTeX-mode-hook #'display-line-numbers-mode)))Yaml mode, the Emacs major mode for editing files in the YAML data serialization format.
(use-package yaml-mode
:defer t
:commands (yaml-get-path-at-point)
:mode "\\.yml\\'"
:config
(use-package yaml-pro
:hook (yaml-mode . yaml-pro-mode)
:bind (("C-c M-p" . yaml-pro-move-subtree-up)
("C-c M-n" . yaml-pro-move-subtree-down)))
;; Based on https://github.com/chopmo/dotfiles/blob/master/.emacs.d/customizations/yaml.el
(defun yaml-indentation-level (s)
(if (string-match "^ " s)
(+ 1 (yaml-indentation-level (substring s 1)))
0))
(defun yaml-clean-string (s)
(let* ((s (replace-regexp-in-string "^[ -:]*" "" s))
(s (replace-regexp-in-string ":$" "" s)))
s))
(defun yaml-path-at-point ()
(save-excursion
(let* ((line (buffer-substring-no-properties (point-at-bol) (point-at-eol)))
(level (yaml-indentation-level line))
result)
(while (> (point) (point-min))
(beginning-of-line 0)
(setq line (buffer-substring-no-properties (point-at-bol) (point-at-eol)))
(let ((new-level (yaml-indentation-level line)))
(when (and (string-match "[^[:blank:]]" line)
(< new-level level))
(setq level new-level)
(setq result (push (yaml-clean-string line) result)))))
(mapconcat 'identity result " => "))))
(defun yaml-get-path-at-point ()
"Display the yaml path at point for 5 seconds"
(interactive)
(let ((ov (display-line-overlay+ (window-start) (yaml-path-at-point))))
(run-with-timer 1 nil (lambda () (when (overlayp ov)
(delete-overlay ov)))))))Docker, a mode to manage docker from Emacs.
(use-package docker :defer t)Dockerfile Mode, an Emacs mode for handling Dockerfiles.
(use-package dockerfile-mode :defer t)Groovy Mode, a groovy major mode, grails minor mode, and a groovy inferior mode.
(use-package groovy-mode :defer t)Cmake Mode, a library that provides syntax highlighting and indentation for CMakeLists.txt and *.cmake source files.
(use-package cmake-mode :defer t)Bazel Mode, a library that provides major modes for editing Bazel BUILD files, WORKSPACE files, .bazelrc files, as well as Starlark files.
(use-package bazel :defer t)Prerequisite: Install NodeJS and ensure it's in PATH. Execute following commands to enable LSP for JavaScript/TypeScript/HTML:
npm i -g typescript
npm i -g typescript-language-serverWeb mode, a major mode for editing web templates.
(use-package web-mode
:custom-face
(css-selector ((t (:inherit default :foreground "#66CCFF"))))
(font-lock-comment-face ((t (:foreground "#828282"))))
:mode
("\\.phtml\\'" "\\.tpl\\.php\\'" "\\.[agj]sp\\'" "\\.as[cp]x\\'"
"\\.erb\\'" "\\.mustache\\'" "\\.djhtml\\'" "\\.[t]?html?\\'"))JS2 mode, a feature that offers improved JavsScript editing mode.
(use-package js2-mode
:mode "\\.js\\'"
:interpreter "node"
:bind (:map js-mode-map ("M-." . nil)))TypeScript mode, a feature that offers TypeScript support for Emacs.
(use-package typescript-mode
:mode "\\.ts\\'"
:commands (typescript-mode))Vue mode, a major mode for Vue.js.
(use-package vue-mode
:mode "\\.vue\\'"
:commands (vue-mode))Emmet, a feature that allows writing HTML using CSS selectors along with C-j. See usage for more information.
(use-package emmet-mode
:hook ((web-mode . emmet-mode)
(css-mode . emmet-mode)))Instant Rename Tag, a plugin that provides ability to rename html tag pairs instantly.
(use-package instant-rename-tag
:load-path (lambda () (expand-file-name "site-elisp/instant-rename-tag" user-emacs-directory))
:bind ("C-z <" . instant-rename-tag))JSON Mode, a major mode for editing JSON files.
(use-package json-mode
:mode "\\.json\\'")Org, a Emacs built-in tool for keeping notes, maintaining TODO lists, planning projects, and authoring documents with a fast and effective plain-text system.
Prerequisite: Configure (org-agenda-files (list "~/org/agenda/")) to your agenda folder to use org-agenda. Once this is set, the agenda items tagged with DEADLINE or SCHEDULED will be displayed on the Dashboard (hopefully the dashboard will be more detailed in the future).
(use-package org
:ensure nil
:defer t
:bind (("C-c l" . org-store-link)
("C-c a" . org-agenda)
("C-c c" . org-capture)
(:map org-mode-map (("C-c C-p" . eaf-org-export-to-pdf-and-open)
("C-c ;" . nil))))
:custom
(org-log-done 'time)
(calendar-latitude 43.65107) ;; Prerequisite: set it to your location, currently default: Toronto, Canada
(calendar-longitude -79.347015) ;; Usable for M-x `sunrise-sunset' or in `org-agenda'
(org-export-backends (quote (ascii html icalendar latex md odt)))
(org-use-speed-commands t)
(org-confirm-babel-evaluate 'nil)
(org-latex-listings-options '(("breaklines" "true")))
(org-latex-listings t)
(org-deadline-warning-days 7)
(org-todo-keywords
'((sequence "TODO" "IN-PROGRESS" "REVIEW" "|" "DONE" "CANCELED")))
(org-agenda-window-setup 'other-window)
(org-latex-pdf-process
'("pdflatex -shelnl-escape -interaction nonstopmode -output-directory %o %f"
"pdflatex -shell-escape -interaction nonstopmode -output-directory %o %f"))
:custom-face
(org-agenda-current-time ((t (:foreground "spring green"))))
:config
(add-to-list 'org-latex-packages-alist '("" "listings"))
(unless (version< org-version "9.2")
(require 'org-tempo))
(when (file-directory-p "~/org/agenda/")
(setq org-agenda-files (list "~/org/agenda/")))
(org-babel-do-load-languages
'org-babel-load-languages
'(;; other Babel languages
(C . t)
(python . t)
(plantuml . t)))
(defun org-export-toggle-syntax-highlight ()
"Setup variables to turn on syntax highlighting when calling `org-latex-export-to-pdf'."
(interactive)
(setq-local org-latex-listings 'minted)
(add-to-list 'org-latex-packages-alist '("newfloat" "minted")))
(defun org-table-insert-vertical-hline ()
"Insert a #+attr_latex to the current buffer, default the align to |c|c|c|, adjust if necessary."
(interactive)
(insert "#+attr_latex: :align |c|c|c|")))Org Roam, a plain-text personal knowledge management system.
(use-package org-roam
:after org
:custom
(org-roam-node-display-template
(concat "${title:*} "
(propertize "${tags:10}" 'face 'org-tag)))
(org-roam-completion-everywhere t)
:bind
(("C-c n l" . org-roam-buffer-toggle)
("C-c n f" . org-roam-node-find)
("C-c n i" . org-roam-node-insert)
("C-c n h" . org-id-get-create))
:config
(when (file-directory-p "~/org/roam/")
(setq org-roam-directory (file-truename "~/org/roam")))
(org-roam-db-autosync-mode))TOC Org generates table of contents for .org files
(use-package toc-org
:hook (org-mode . toc-org-mode))HTMLize, a tool that converts buffer text and decorations to HTML.
(use-package htmlize :defer t)OX-GFM, a Github Flavored Markdown exporter for Org Mode.
(use-package ox-gfm :defer t)PlantUML Mode, a major mode for editing PlantUML sources.
Prerequisite:
- Install plantuml and configure
(org-plantuml-jar-path (expand-file-name "path/to/plantuml.jar")). - Install Graphviz on your system to support graph visualization. Execute
sudo apt install graphvizin Ubuntu.
(use-package plantuml-mode
:defer t
:custom
(org-plantuml-jar-path (expand-file-name "~/tools/plantuml/plantuml.jar")))PDF Tools, an Emacs support library for PDF files. It works best on non-Windows OS.
Note: You need convert provided from imagemagick to Pick a Link and Jump with F.
(use-package pdf-tools-install
:ensure pdf-tools
:if (and (display-graphic-p) (not *sys/win32*) (not eaf-env-p))
:mode "\\.pdf\\'"
:commands (pdf-loader-install)
:custom
(TeX-view-program-selection '((output-pdf "pdf-tools")))
(TeX-view-program-list '(("pdf-tools" "TeX-pdf-tools-sync-view")))
:hook
(pdf-view-mode . (lambda () (display-line-numbers-mode -1)))
:config
(pdf-loader-install))Emacs Application Framework, a GUI application framework that revolutionizes Emacs graphical capabilities.
Prerequisite: Please ensure python3 and pip3 are installed, then follow install instructions.
(use-package eaf
:load-path (lambda () (expand-file-name "site-elisp/emacs-application-framework" user-emacs-directory))
:if eaf-env-p
:custom
(eaf-start-python-process-when-require nil)
(browse-url-browser-function #'eaf-open-browser) ;; Make EAF Browser my default browser
(eaf-start-python-process-when-require t)
(eaf-browser-dark-mode nil)
(eaf-browser-enable-adblocker t)
(eaf-webengine-continue-where-left-off t)
(eaf-webengine-default-zoom 1.25)
(eaf-webengine-scroll-step 200)
(eaf-pdf-dark-mode "ignore")
:demand
:bind
(("M-z r" . eaf-open-rss-reader)
("M-m r" . eaf-open-rss-reader)
("M-#" . eaf-open-pyqterminal))
:config
;; Require all EAF apps unconditionally, change to apps you're interested in.
(require 'eaf-file-manager nil t)
(require 'eaf-music-player nil t)
(require 'eaf-image-viewer nil t)
(require 'eaf-camera nil t)
(require 'eaf-demo nil t)
(require 'eaf-airshare nil t)
(require 'eaf-markdown-previewer nil t)
(require 'eaf-video-player nil t)
(require 'eaf-vue-demo nil t)
(require 'eaf-file-sender nil t)
(require 'eaf-pdf-viewer nil t)
(require 'eaf-mindmap nil t)
(require 'eaf-netease-cloud-music nil t)
(require 'eaf-jupyter nil t)
(require 'eaf-org-previewer nil t)
(require 'eaf-system-monitor nil t)
(require 'eaf-rss-reader nil t)
(require 'eaf-pyqterminal nil t)
(require 'eaf-file-browser nil t)
(require 'eaf-browser nil t)
(require 'eaf-git nil t)
(when (display-graphic-p)
(require 'eaf-all-the-icons))
(defalias 'browse-web #'eaf-open-browser)
(eaf-bind-key nil "M-q" eaf-browser-keybinding)
(eaf-bind-key nil "M-z" eaf-browser-keybinding)
(eaf-bind-key open_link "C-M-s" eaf-browser-keybinding)
(eaf-bind-key open_devtools "M-i" eaf-browser-keybinding)
(eaf-bind-key insert_or_recover_prev_close_page "X" eaf-browser-keybinding)
(eaf-bind-key scroll_up "RET" eaf-pdf-viewer-keybinding)
(eaf-bind-key delete_cookies "C-M-q" eaf-browser-keybinding)
(eaf-bind-key delete_all_cookies "C-M-Q" eaf-browser-keybinding)
(eaf-bind-key clear_history "C-M-p" eaf-browser-keybinding)
(eaf-bind-key scroll_down_page "DEL" eaf-pdf-viewer-keybinding)
(eaf-bind-key scroll_down_page "u" eaf-pdf-viewer-keybinding)
(eaf-bind-key scroll_up_page "d" eaf-pdf-viewer-keybinding)
(eaf-bind-key scroll_to_end "M->" eaf-pdf-viewer-keybinding)
(eaf-bind-key scroll_to_begin "M-<" eaf-pdf-viewer-keybinding)
(eaf-bind-key quit-window "q" eaf-pdf-viewer-keybinding)
(eaf-bind-key zoom_in "C-=" eaf-pdf-viewer-keybinding)
(eaf-bind-key zoom_out "C--" eaf-pdf-viewer-keybinding)
(eaf-bind-key take_photo "p" eaf-camera-keybinding))Popweb, a lightweight version of EAF that provides multimedia capabilities.
(use-package popweb
:if eaf-env-p
:load-path (lambda () (expand-file-name "site-elisp/popweb" user-emacs-directory))
:init
(add-to-list 'load-path (expand-file-name "site-elisp/popweb/extension/latex" user-emacs-directory))
(add-to-list 'load-path (expand-file-name "site-elisp/popweb/extension/dict" user-emacs-directory))
(require 'popweb-latex)
(require 'popweb-dict-youdao)
:custom
(popweb-popup-pos "point-bottom")
:hook ((org-mode . popweb-latex-mode)
(tex-mode . popweb-latex-mode)
(ein:markdown-mode . popweb-latex-mode))
)Emacs Relay Chat, a powerful, modular, and extensible IRC client for Emacs. It utilizes erc-hl-nicks for nickname highlighting and erc-image to fetch and show received images in ERC.
Prerequisite: Put IRC credentials in the file ~/.authinfo and configure my-irc-nick to your IRC nickname.
machine irc.freenode.net login <nickname> password <password> port 6697
(use-package erc
:ensure nil
:init
;; Prerequisite: Configure this to your IRC nickname
(defcustom my-irc-nick ""
"The nickname used to login into ERC"
:type 'string)
(use-package erc-hl-nicks :defer t)
(use-package erc-image :defer t)
:custom-face
(erc-notice-face ((t (:foreground "#ababab"))))
:custom
(erc-autojoin-channels-alist '(("irc.libera.chat" "#emacs")))
(erc-user-full-name user-full-name)
(erc-track-exclude-types '("NICK" "PART" "MODE" "324" "329" "332" "333" "353" "477"))
(erc-server-coding-system '(utf-8 . utf-8))
(erc-interpret-mirc-color t)
(erc-kill-buffer-on-part t)
(erc-kill-queries-on-quit t)
(erc-kill-server-buffer-on-quit t)
(erc-autojoin-timing 'ident)
(erc-fill-function 'erc-fill-static)
(erc-fill-static-center 15)
(erc-lurker-threshold-time 43200)
(erc-server-reconnect-attempts 5)
(erc-server-reconnect-timeout 3)
(erc-prompt-for-password nil)
(erc-prompt-for-nickserv-password nil)
(erc-fill-column 100)
(erc-save-buffer-on-part t)
(erc-nick-uniquifier "_")
(erc-log-channels-directory (expand-file-name ".erc-logs" user-emacs-directory))
:bind
(("M-z i" . erc-start-or-switch)
("M-m i" . erc-start-or-switch)
("C-c C-b" . erc-switch-to-buffer)
(:map erc-mode-map
("M-RET" . newline)))
:hook
(ercn-notify . erc-notify)
:config
(make-directory (expand-file-name ".erc-logs" user-emacs-directory) t)
(add-to-list 'erc-modules 'notifications)
(erc-track-mode t)
(erc-services-mode 1)
(defun erc-start-or-switch ()
"Start ERC or switch to ERC buffer if it has started already."
(interactive)
(if (get-buffer "irc.libera.chat:6697")
(erc-track-switch-buffer 1)
(erc-tls :server "irc.libera.chat" :port 6697 :nick my-irc-nick :full-name user-full-name)))
(defun erc-notify (nickname message)
"Displays a notification message for ERC."
(let* ((channel (buffer-name))
(nick (erc-hl-nicks-trim-irc-nick nickname))
(title (if (string-match-p (concat "^" nickname) channel)
nick
(concat nick " (" channel ")")))
(msg (s-trim (s-collapse-whitespace message))))
(alert (concat nick ": " msg) :title title))))Mu4e, a package that provides an emacs-based e-mail client which uses mu as its backend. Mu4e Thread Folding is used to toggle between long threads.
Note: This mu4e configuration is tailored for Gmail.
Prerequisite:
-
Configure IMAP using isync/mbsync, put your
.mbsyncrcconfig file in~/.emacs.d/mu4e/. A sample is provided. -
Install mu.
-
Execute the follwing commands
mkdir -p ~/Maildir/gmail/ mbsync -c ~/.emacs.d/mu4e/.mbsyncrc -Dmn gmail mbsync -c ~/.emacs.d/mu4e/.mbsyncrc -a mu init --maildir=~/Maildir/ --my-address=YOUR_EMAIL1 --my-address=YOUR_EMAIL2 mu index
- If you are getting
Invalid Credentialserror and you are sure the password is correct, check this link.
- If you are getting
-
(Optional) If you want to track meetings using
org-mode, setgnus-icalendar-org-capture-fileto the meeting's file.
(use-package mu4e
:ensure nil
:commands (mu4e make-mu4e-context)
:init
(use-package mu4e-alert
:defer t
:config
(when (executable-find "notify-send")
(mu4e-alert-set-default-style 'libnotify))
:hook
((after-init . mu4e-alert-enable-notifications)
(after-init . mu4e-alert-enable-mode-line-display)))
(use-package mu4e-overview :defer t)
:bind
(("M-z m" . mu4e)
("M-m m" . mu4e)
(:map mu4e-view-mode-map
("e" . mu4e-view-save-attachment)))
:custom
(mu4e-maildir (expand-file-name "~/Maildir"))
(mu4e-get-mail-command "mbsync -c ~/.emacs.d/mu4e/.mbsyncrc -a")
(mu4e-view-prefer-html t)
(mu4e-update-interval 180)
(mu4e-headers-auto-update t)
(mu4e-compose-format-flowed t)
(mu4e-view-show-images t)
(mu4e-change-filenames-when-moving t) ; work better for mbsync
(mu4e-attachment-dir "~/Downloads")
(message-kill-buffer-on-exit t)
(mu4e-compose-dont-reply-to-self t)
(mu4e-view-show-addresses t)
(mu4e-confirm-quit nil)
(mu4e-use-fancy-chars t)
(mu4e-headers-results-limit 1000)
(mu4e-view-use-gnus t)
(gnus-icalendar-org-capture-file "~/org/agenda/meetings.org") ; Prerequisite: set it to meetings org fie
(gnus-icalendar-org-capture-headline '("Meetings")) ; Make sure to create Calendar heading first
:hook
((mu4e-view-mode . visual-line-mode)
(mu4e-compose-mode . (lambda ()
(visual-line-mode)
(use-hard-newlines -1)
(flyspell-mode)))
(mu4e-view-mode . (lambda() ;; try to emulate some of the eww key-bindings
(local-set-key (kbd "<tab>") 'shr-next-link)
(local-set-key (kbd "<backtab>") 'shr-previous-link)))
(mu4e-headers-mode . (lambda ()
(interactive)
(setq mu4e-headers-fields
`((:human-date . 25) ;; alternatively, use :date
(:flags . 6)
(:from . 22)
(:thread-subject . ,(- (window-body-width) 70)) ;; alternatively, use :subject
(:size . 7))))))
:init
(use-package mu4e-thread-folding
:load-path (lambda () (expand-file-name "site-elisp/mu4e-thread-folding" user-emacs-directory))
:after mu4e
:bind
((:map mu4e-headers-mode-map
("TAB" . mu4e-headers-toggle-at-point)
("C-<tab>" . mu4e-headers-toggle-fold-all))
(:map mu4e-search-minor-mode-map
("S" . mu4e-kill-update-mail)))
:custom
(mu4e-thread-folding-default-view `folded)
(mu4e-headers-fields '((:empty . 2)
(:human-date . 12)
(:flags . 6)
(:mailing-list . 10)
(:from . 22)
(:subject . nil)))
:config
(add-to-list 'mu4e-header-info-custom
'(:empty . (:name "Empty"
:shortname ""
:function (lambda (msg) " ")))))
:config
(require 'mu4e-icalendar)
(setq mail-user-agent (mu4e-user-agent))
(mu4e-icalendar-setup)
(gnus-icalendar-org-setup)
(defalias 'mu4e-add-attachment 'mail-add-attachment
"I prefer the add-attachment function to begin wih mu4e so I can find it easily.")
(add-to-list 'mu4e-view-actions
'("ViewInBrowser" . mu4e-action-view-in-browser) t)
(setq mu4e-contexts
(list
(make-mu4e-context
:name "gmail"
:enter-func (lambda () (mu4e-message "Entering context gmail"))
:leave-func (lambda () (mu4e-message "Leaving context gmail"))
:match-func
(lambda (msg)
(when msg
(string-match "gmail" (mu4e-message-field msg :maildir))))
:vars '((mu4e-sent-folder . "/gmail/Sent Mail")
(mu4e-drafts-folder . "/gmail/Drafts")
(mu4e-trash-folder . "/gmail/Trash")
(mu4e-sent-messages-behavior . sent)
(mu4e-compose-signature . user-full-name)
(user-mail-address . user-mail-address) ; Prerequisite: Set this to your email
(mu4e-compose-format-flowed . t)
(smtpmail-queue-dir . "~/Maildir/gmail/queue/cur")
(message-send-mail-function . smtpmail-send-it)
(smtpmail-smtp-user . "matthewzmd") ; Set to your username
(smtpmail-starttls-credentials . (("smtp.gmail.com" 587 nil nil)))
(smtpmail-auth-credentials . (expand-file-name "~/.authinfo.gpg"))
(smtpmail-default-smtp-server . "smtp.gmail.com")
(smtpmail-smtp-server . "smtp.gmail.com")
(smtpmail-smtp-service . 587)
(smtpmail-debug-info . t)
(smtpmail-debug-verbose . t)
(mu4e-maildir-shortcuts . ( ("/gmail/INBOX" . ?i)
("/gmail/Sent Mail" . ?s)
("/gmail/Trash" . ?t)
("/gmail/All Mail" . ?a)
("/gmail/Starred" . ?r)
("/gmail/Drafts" . ?d))))))))Tramp, short for Transparent Remote Access, Multiple Protocols is a package for editing remote files using a remote shell connection (rlogin, telnet, ssh).
Connect to Google Cloud Platform using the following:
/gssh:some-instance:/path/to/file
(use-package tramp
:ensure nil
:defer 1
:config
(add-to-list 'tramp-remote-path 'tramp-own-remote-path)
;; TRAMP gcloud ssh
(add-to-list 'tramp-methods
'("gssh"
(tramp-login-program "gcloud compute ssh")
(tramp-login-args (("%h")))
(tramp-async-args (("-q")))
(tramp-remote-shell "/bin/bash")
(tramp-remote-shell-args ("-c"))
(tramp-gw-args (("-o" "GlobalKnownHostsFile=/dev/null")
("-o" "UserKnownHostsFile=/dev/null")
("-o" "StrictHostKeyChecking=no")))
(tramp-default-port 22))))LeetCode, an Emacs LeetCode client. Note that this package is dependant on aio and GraphQL.
(use-package leetcode
:load-path (lambda () (expand-file-name "site-elisp/leetcode.el" user-emacs-directory))
:commands (leetcode)
:init
(use-package graphql :defer t)
(use-package aio :defer t)
:custom
(url-debug t)
(leetcode-prefer-language "python3"))Debbugs, a package lets you access the GNU Bug Tracker from within Emacs.
(use-package debbugs
:commands (debbugs-gnu))A simple Hacker News Emacs client.
(use-package hackernews
:commands (hackernews)
:bind
(("M-z h" . hackernews)
("M-m h" . hackernews)))Emacs Web Wowser, the HTML-based Emacs Web Browser.
(use-package eww
:ensure nil
:commands (eww)
:hook (eww-mode . (lambda ()
"Rename EWW's buffer so sites open in new page."
(rename-buffer "eww" t)))
:config
;; I am using EAF-Browser instead of EWW
(unless eaf-env-p
(setq browse-url-browser-function 'eww-browse-url))) ; Hit & to browse url with system browserPackages and configurations suitable for Chinese users. Non-Chinese users feel free to add :disabled tags for them.
- Pyim, an Emacs Chinese Pinyin Input. It uses posframe package to display candidates.
- Pyim BaseDict, the default Chinese-Pyim dictionary.
我已经停止使用作者推荐的无痛中英切换，它对需要同时打英文和中文的情况不是很友好。如需切换输入法，请善用 C-\ 。
(use-package pyim
:init
(use-package posframe :defer t)
:custom
(default-input-method "pyim")
(pyim-default-scheme 'quanpin)
(pyim-page-tooltip 'posframe)
(pyim-page-length 9)
:config
(use-package pyim-basedict
:after pyim
:config (pyim-basedict-enable))
(pyim-isearch-mode 1)
(diminish pyim-isearch-mode "")
(setq-default pyim-english-input-switch-functions
'(pyim-probe-isearch-mode
pyim-probe-org-structure-template))
(setq-default pyim-punctuation-half-width-functions
'(pyim-probe-punctuation-line-beginning
pyim-probe-punctuation-after-punctuation))
:bind
("M-j" . pyim-convert-string-at-point)) ; M-j 强制将光标前的拼音字符串转换为中文。Youdao interface for Emacs.
(use-package youdao-dictionary
:commands (youdao-dictionary-search
youdao-dictionary-search-at-point
youdao-dictionary-search-at-point-posframe)
:bind ("C-M-y" . youdao-dictionary-search-at-point-posframe))Although Tetris is part of Emacs, but there still could be some configurations.
(use-package tetris
:ensure nil
:commands (tetris)
:bind
(:map tetris-mode-map
("C-p" . tetris-rotate-prev)
("C-n" . tetris-rotate-down)
("C-b" . tetris-move-left)
("C-f" . tetris-move-right)
("C-SPC" . tetris-move-bottom))
:config
(defadvice tetris-end-game (around zap-scores activate)
(save-window-excursion ad-do-it)))Speed type, a game to practice touch/speed typing in Emacs.
(use-package speed-type
:commands (speed-type-text))2048 Game, an implementation of 2048 in Emacs.
(use-package 2048-game
:commands (2048-game))Let it snow in Emacs!
(use-package snow
:load-path (lambda () (expand-file-name "site-elisp/snow.el" user-emacs-directory))
:commands (snow))EPaint, a simple paint tool for emacs.
(use-package epaint
:if (display-graphic-p)
:load-path (lambda () (expand-file-name "site-elisp/epaint" user-emacs-directory))
:commands (epaint)
:init
(with-eval-after-load (quote epaint-context)
(unless (boundp (quote cl-struct-epaint-drawable))
(defvar cl-struct-epaint-drawable (quote epaint-drawable)))
(unless (boundp (quote cl-struct-epaint-gc))
(defvar cl-struct-epaint-gc (quote epaint-gc)))))Zone, a minor-mode 'zones' Emacs out, choosing one of its random modes to obfuscate the current buffer.
(use-package zone
:ensure nil
:defer 5
:config
;; (zone-when-idle 600) ; in seconds
(defun zone-choose (pgm)
"Choose a PGM to run for `zone'."
(interactive
(list
(completing-read
"Program: "
(mapcar 'symbol-name zone-programs))))
(let ((zone-programs (list (intern pgm))))
(zone))))