EMACS FUNDAMENTALS

Type i to enter Evil Insert State and type as usual.

To cut some text, you must kill it.

The simplest way to kill some text is to kill the entire contents right of the cursor with D (lispyville-delete-line) while in Normal State.

To kill a whole line, type d d in Normal State.

You can kill single characters with x, single words with k i w or M-backspace. You can kill the contents within some textual boundaries like () or "" with k i ( or k i quotemark. You can include the boundaries with k o instead of k i.

To copy something, you must yank it.

Use y y in Evil Normal State to yank a line. You can yank a word with y i w or a symbol with y i o.

To paste some text, type p in Evil Normal State, or s-v (or whatever keyboard shortcut you're accustomed to using to paste text).

You can mark regions of text to work on using Visual State. Type v and then navigate text to select it from where you first entered.

Marked text can be killed or yanked. There are plenty of other operations that you can do on marked text, but we'll save that for another time.

You can search for some text in a buffer with SPC s s (+default/search-buffer).

Let's say you pressed SPC f, but you decided you don't want to continue. To abort the command, press C-g (doom/escape).

It's common to accidently hit a key or combination of keys you didn't mean to. If you are "stuck" inside some command, or in the middle of a keybinding, the quickest solution is to press C-g a few times.

C-/ (undo-fu-only-undo) will undo the previous action. Doom also includes the s-z keybinding, which is the same as undo in the browser, MS Word, etc.

In Doom Emacs, if you press a number while in Normal State before running a command, entering Evil Insert State, etc. Emacs will run the action the same number of times as the number you typed.

If you don't know VIM/evil keybindings, you probably won't want to do this, but you may accidently do so. For example, you may be in Evil Normal State, press 9, enter Insert State and type something, then return to Normal State with ESC, at which point you now have inserted the same text 9 times. It might look something like this:

(+ 1 1(+ 1 1(+ 1 1(+ 1 1(+ 1 1(+ 1 1(+ 1 1(+ 1 1(+ 1 1)))))))))

The best thing to do in this situation is just undo and retype.

This functionality can be quite useful. For example, if you want to navigate down 10 lines, you can type 10 j in Normal State to navigate down ten lines. It also makes it easy to type decorative dividers in comments like this:

;; ==============================

Type g z z (+multiple-cursors/evil-mc-toggle-cursor-here) to create a cursor. Move your cursor and the one you created stays in place. You can create arbitrary numbers of cursors. Once you've made all the cursors you need, you can begin editing them by entering Evil Insert State.

If you need to pause the cursors, type g z t (+multiple-cursors/evil-mc-toggle-cursors). If you need to undo the creation of the last cursor, type g z u (+multiple-cursors/evil-mc-undo-cursor).

If you like multicursor editing in other editors, you're going to love multiediting in Doom Emacs. With multiple cursors, you can place cursors in arbitrary locations. The downside is that you need to move the cursor to each location you want to place the cursor. With multiediting, you can search and highlight text and edit all highlighted areas simultaneously. You can leave the highlighted regions and edit other text, then return to the highlighted region an

Place the cursor or mark a region. Type M-d (evil-multiedit-match-symbol-and-next) to begin multiediting. If you type M-d again, you will mark the next symbol or region that matches the first one. You can continue that as many times as you want.

You can also match backwards with M-D (evil-multiedit-match-symbol-and-prev).

While multiediting, if you press Enter, you will remove a match from being edited. C-g to quit multiediting. Typing Enter again will toggle the match back on.

After marking several matches, you can navigate directly between them with C-n (evil-multiedit-next) and C-p (evil-multiedit-prev).

To unmark all matches and quit multiediting, type C-g (maybe a few times).

When you want to rename a few instances of a symbol in a defun, multiediting is the right tool for the job. If you want to rename a function throughout a file, there is a better tool for the job: VIM search and replace.

To begin using it, just type : (evil-ex). How you proceed from there depends on how sophisticated your search and replace operation needs to be. The simplest case is replacing all instances of some text throughout the buffer:

:%s/TEXT TO REPLACE/TEXT TO REPLACE IT WITH/g

This search and replace tool is very powerful, but a full treatment is out of the scope of this book. A good place to learn more is the Vim tips wiki (https://vim.fandom.com/wiki/Search_and_replace).

There are many commands that don't have keybindings. There are also many commands you don't know the keybindings for.

To find and run those commands, type M-x. A minibuffer will open with a list of commands and a short description. If they have a keybinding, it will be displayed in parentheses next to the command itself.

C-n will move the cursor down a line inside that minibuffer. C-p will move the cursor up a line.

Here's a quick reference table for everything covered in this section:

To open a file buffer, type C-x C-f or SPC f f to run find-file. You can open a file that already exists, or you can navigate to a directory and/or file that doesn't exist, type Enter, and create a buffer for that location. The file/directory doesn't exist until you save the buffer.

Besides file buffers, there are many other kinds of buffers. The most important buffer to know as a beginner is the M-x command minibuffer. There you can get a list of function you can (possibly) run. There are many commands that aren't bound to keybindings that you may want to use on occasion (or perhaps you would like bind them to a custom key command).

The scratch buffer is a buffer that can be opened to use the same way "scratch" paper is use–to do a little work that you'll quickly save somewhere else or discard after a short time. You can open it with SPC x. Once in the buffer, you can change the mode using M-x and typing in the mode.

You can switch buffers by typing C-x b or SPC b B (consult-buffer). You will be presented with a minibuffer listing all buffers that are open. Unlike list-buffers, you can navigate the list of buffers using C-n/C-p and peak at the buffer before switching to it. The minibuffer is smaller and disappears after you select a buffer to switch to.

You can't mouse click buffers in the list to switch to them. You have to either type the name (often the ideal way to switch to a buffer anyway) or use Emacs keybindings to move the cursor up and down the list with C-n an C-p and select with Enter.

To close the active buffer, type s-k or SPC b k. If you want to close multiple buffers, you can type C-x C-b to run list-buffers. Inside the *Buffer List* buffer, you can mark a buffer to close with d. After marking all of the buffers you want to close, you can "execute" the closing with x.

Different minibuffers often can be closed with simpler keybindings like ESC or q.

You can save the current file buffer with C-x C-s or s-s.

As you get more experience with Emacs, you may want to know how something works. Many functions–especially in a distribution like Doom–are not native functions. They are often available because of a major or minor mode created by a certain package that's installed. Thus, learning more about the environment can help you come to grips with what package does what and what other functionality is available but "hidden".

You can get more information about the major and minor modes of the active buffer using C-h m or SPC h m (describe-mode). A minibuffer listing all the modes–including all of the functions/keybindings those modes provide–will appear.

You can go deeper and find information about a function with C-h o or SPC h o (describe-symbol) and then typing in an Emacs Lisp symbol or function name. Documentation and the actual code of the function will be made available in a minibuffer.

The documentation that describe-symbol shows includes keybindings for the function. Unlike the M-x minibuffer, you can see all of the bindings for a single function (many functions have multiple bindings, as you've probably noticed already). The M-x minibuffer will only show one binding.

Maybe you know a keybinding but don't know or remember the function that the keybinding calls? Maybe you hit a key that did something surprising and want to know what the heck it was?

In that case, you can use C-h k or SPC h k (describe-key). You will be prompted to type the keybinding you want to know more about.

To browse keybindings and functions, you can either type M-x to open a list of all commands, or you can open embark-bindings with C-h b b or SPC h b b. The embark-bindings command is especially useful because it only shows the keybindings available in the current buffer. describe-mode also shows all of the functions a mode provides, but only shows a maximum of one binding per function. The embark-bindings command, on the other hand, shows you all of the bindings. Additionally, embark-bindings lets you search keybindings. For example, you can search for "C-c" and find all keybindings that include C-c in any of them. This will be especially useful for fuzzy searching keybindings, or if you're looking for an open keybinding in a buffer you want to make a custom shortcut for.

Here's a quick reference for everything in this section:

You can split a window vertically or horizontally (creating another window).

To split vertically, type C-x 2 or SPC w s. To split horizontally, type C-x 3 or SPC w v.

You can delete a window with C-x 0 or SPC w d, or you can close all except the currently selected window with C-x 1 or C-w C-o.

While you can use the mouse to move the cursor around, eventually you'll want to learn to use keybindings instead. Trust me, it's nice.

You can use the ace-window packages' functionality to switch windows. Type C-x o or C-w C-w to run ace-window. If there are only two windows open, then it will move the cursor to the one that isn't currently active. If however, you have three or more windows open, ace-window will display letters at the top left of each buffer. Typing the letter displayed in a window will move the cursor to that window.

This method is my preferred method of switching windows because it works regardless of what Evil state or Emacs major mode I'm in. It's also more direct. However, it does require some getting used to. As a beginner, you can't predict what letter you can use to switch to a window. Thus, in the beginning this method will often be slower then the next method I'll introduce to you.

The next method uses evil-window keybindings. With evil navigation, in Normal State, you navigate the cursor one line up and down with j and k, and one character left and right with h and l.

Using this familiar navigation method, you switch windows like this:

• SPC w l or C-w l (evil-window-right), move the cursor one window to the right.
• SPC w h or C-w h (evil-window-left), move the cursor one window to the left.
• SPC w j or C-w j (evil-window-down), move the cursor one window down.
• SPC w k or C-w k (evil-window-down), move the cursor one window up.

It's simple and effective. Even with experience, you may prefer it over using ace-window. However, as I said above, all of these shortcuts require you to be in Evil Normal State (C-w in Insert State is mapped to evil-delete-backward-word).

The above commands move the cursor from one window to another. It's also possible to move a window from one position to another.

• SPC w L or C-w L (+evil/window-move-right)
• SPC w H or C-w H (+evil/window-move-left)
• SPC w J or C-w J (+evil/window-move-down)
• SPC w K or C-w K (+evil/window-move-up)

Technically, it's more like you are switching buffers between windows. What this means is that all windows maintain their current size; if you have one large window and one small window, if you run one of the above commands while the cursor is in the large window, the buffer in that window will appear in the smaller window

You probably won't find yourself resizing windows very often. Sometimes Emacs will do some weird resizing of windows for certain actions (keep an eye out when using sly-sticker-replay, introduced in a later chapter) that you need to fix, you might want to dedicate a window to a certain buffer (such as the org-agenda buffer, introduced in a later chapter) and keep it open, and thus want to make the window smaller. Or maybe you really need to micro-adjust everything.

You can use the mouse to resize windows (click and drag the border between windows). It's honestly not such a bad idea since it will likely be an infrequent activity. However, it's also possible to resize windows with keybindings.

• C-x { (shrink-window-horizontally) or SPC w > or C-w > (evil-window-increase-width).
• C-x } (enlarge-window-horizontally) or SPC w < or C-w < (evil-window-decrease-width).
• SPC w + or C-w + (evil-window-increase-height)
• SPC w - or C-w - (evil-window-decrease-height)

Each of the above commands will resize by one line or character. If you are in evil Normal State, you can type a number n and then run the command n times. In Normal State, typing 50 SPC w > will increase the window width by 50 characters.

You can also make one window larger than all your other windows using C-w o or SPC w o (doom/window-enlargen).

You can make all windows equal in size with SPC w = or C-w = (balance-windows).

Undoing any change is simple: C-w u or SPC w u (winner-undo).

This is useful not only for typos (for example, maybe you accidentally typed C-x C-x a and accidently closed all but one window) or for strange changes made by Emacs (sometimes closing a minibuffer drastically resizes other windows for no known reason), but also for intentional changes. For example, the above doom/window-enlargen command drastically resizes all windows. You can undo that change with winner-undo.

winner-undo no only undoes window resizes, but any changes to windows. If you accidentally closed a window, you can undo with winner-undo. If you move a window, you can undo the move. It's perhaps one of the most essential commands for beginners who are most likely to make mistakes or be faced with strange changes in window arrangements they weren't expecting.

Of course, you can also run winner-redo with C-w C-r or SPC w C-r

If you want to learn more about what's possible with windows, just type C-w and look at the list of commands available in the minibuffer.

Here's a quick reference table for everything covered in this section:

Project-level functionality is not the result of just a single package. Instead, it is the result of the coordination between several packages.

• projectile provides many of the functions like project-level file searching, project-wide file saving, project switching, etc.
• helm/ido/ivy/vertico provide the project-level text search functionality.
• persp-mode provides "workspaces" that can be saved and loaded.
• embark enables project-wide text search-replace operations.

Doom Emacs provides some abstractions over some of these modes, so some names could become confusing later.

To create a project:

• Create an empty .project file in the project root directory.
• Type SPC p a (project-add-known-project), navigate to the project root directory and then type Enter.

Now if you type SPC p p (projectile-switch-project) you will find your project in a list of projects you can open or switch to.

After creating and switching to a project, a small label at the bottom will appear with the name of the project (the name of the project root directory). That label is a workspace.

If you have multiple projects open, you can switch between them via several means.

• SPC TAB [ (+workspace/switch-left) to switch to the workspace to the right in the list of workspaces.
• SPC TAB ] (+workspace/switch-right)
• SPC TAB . (+workspace/switch-to) to choose from a list of open workspaces.
• SPC TAB <number> Switch to the nth workspace.

Workspaces are not strictly speaking exclusive to projects. A workspace can be created independent of projects using SPC TAB n (+workspace/new). If open some buffers, windows, etc. and then save the workspace with SPC TAB s, you can close the workspace and reopen it with SPC TAB l.

If you have a complex setup that you want to save, the ability to save the state of your workspace is a useful feature.

Once you have a project/workspace open and start editing, you may find several files in your project haven't been saved. This is especially true in Common Lisp projects where you update them by compiling files or individual functions–with no need to save the application files in order to update them in memory.

To save all the files in your project, type SPC p s (projectile-save-project-buffers).

Using C-x b or SPC b B you can switch between all buffers. However, if you want switch between project buffers, you can use C-c p b or SPC b b. The exact function is called depends on the :completion library you chose in the init.el file when we first installed Doom Emacs.

:completion
company           ; the ultimate code completion backend
;;helm ; the *other* search engine for love and life ido ; the other
;;*other* search engine... ivy ; a search engine for love and life
vertico           ; the search engine of the future

I recommended vertico, but helm, ido, and ivy will all have similar functionality.

The vertico command called is +vertico/switch-workspace-buffer.

There are two kinds of searches: filename searches and text searches.

treemacs provides a tree view of your project. Open it with SPC o p (+treemacs/toggle).

Here's a quick reference table for everything covered in this section: