Emacs on Ozbem

1- Emacs Terminology (Emacs Survival Guide)

info@ozbem.com (ebeem) — Mon, 03 Aug 2026 00:00:00 +0000

Introduction

Calling Emacs simply a text editor is like calling Windows a text editor just because it happens to ship with Notepad. At its core, Emacs is an interactive Emacs Lisp (Elisp) environment layered on top of a C engine. On top of this runtime environment, an entire ecosystem is built: a text editor, web browser, calculator, calendar, mail and news reader, RSS reader, IRC client, Tetris game, and countless other utilities. While all of these tools come built into Emacs out of the box, the community has also created thousands of third-party packages using that very same environment.

Emacs is best described as an extensible, self-documenting, and primarily keyboard-driven computing environment:

Extensible: Virtually all built-in tools, workflows, and core components can be customized or entirely replaced.
Self-documenting: All the help and reference material you need is available directly inside Emacs. You can explore, inspect, and learn Emacs using its own introspection tools.
Keyboard-driven: While mouse support is available, Emacs is designed to be driven entirely by the keyboard. Investing in a good ergonomic split keyboard and learning touch typing is very rewarding.

Diagram of the Emacs architecture: built-in and third-party tools layered over the Elisp runtime and core C engine

This section might seem boring at first, but understanding Emacs terminology is essential. It clarifies how Emacs is structured, making it far easier to master its commands and navigate its documentation.

Emacs was developed in the 1970s and it predates modern graphical desktop conventions by more than a decade. Its vocabulary can feel counterintuitive to newcomers used to modern operating systems. To bridge that gap, this guide maps Emacs terms to their counterparts in VSCode.

Note: These comparisons help you understand the terminology, but you should adopt native Emacs terminology by calling components by their proper names which will make manuals and community tutorials much easier to follow.

Frame

A Frame is an independent operating system window. Just as you can open multiple VSCode windows across different monitors, you can spawn multiple Emacs Frames across your screens.

Window

An Emacs Window is a pane inside a Frame. Just as you can split your VSCode editor area into vertical or horizontal panes to view different files side by side, you can split an Emacs Frame into multiple Windows.

Buffer

A Buffer is an in-memory object containing text or binary data. You can think of it as an open file/tab inside VSCode.

Emacs buffers fall into three primary categories:

File-Visiting Buffers: Associated with persistent files on disk, such as source code files and notes.
Process Buffers: Driven by underlying system processes, such as terminal emulators and compilation outputs.
Internal Buffers: Utilities maintained directly by Emacs, typically named with surrounding asterisks (such as *scratch* for Elisp scratchpads and *Messages* for runtime logs).

Mode Line

A Mode Line is a status bar displayed at the bottom of every Emacs Window. It functions like the status bar in VSCode, reporting diagnostics such as modification state, current line number, and file encoding. Unlike VSCode's single global bar, every active window in Emacs has its own dedicated Mode Line.

Echo Area

The Echo Area is a single-line output display at the bottom of the Emacs Frame. It displays short status updates, error alerts, and function output, serving a purpose similar to the bottom output or notification panel in modern editors.

Minibuffer

The Minibuffer is an interactive prompt at the bottom of the frame that activates whenever Emacs needs user input. It functions similarly to VSCode's Command Palette, prompting for commands, file names, or search queries.

Major Mode

Every buffer has exactly one Major Mode active at any time. It governs fundamental behaviors including syntax highlighting, indentation rules, and language-specific keybindings like Python mode, Rust mode, and Org mode.

Minor Mode

Minor Modes are modular, optional features layered on top of the active major mode. Multiple minor modes can run concurrently in a single buffer, providing granular functionality such as line numbers, on-the-fly spell checking, and auto-saving.

Discovery and Completion

I still remember very well the first time I downloaded and ran Emacs back in 2008. I'm certain I said something along the lines of, "Meh, this definitely isn't my type of text editor." Out of the box, Emacs is plain and confusing for newcomers, it also has a steep learning curve. However, there is a good reason so many developers stick with it and treat it almost as a way of life, there simply is no other tool that offers what Emacs provides.

On the left is a customized Emacs setup; on the right is vanilla Emacs without any customizations.

I prepared a minimal helpful starter kit. For now, do not worry about the Lisp syntax or how every detail works under the hood. We will break down package management and configuration step by step in future articles. The goal right now is simply to give you a polished and modern environment.

Locating Your Configuration File

Emacs stores its user configuration in a file called init.el. If this file does not exist yet, you can create it in the following locations depending on your operating system:

Linux & macOS: ~/.emacs.d/init.el or ~/.config/emacs/init.el
Windows: %APPDATA%/.emacs.d/init.el (typically C:/Users/<Username>/AppData/Roaming/.emacs.d/init.el)

Open or create init.el, replace its contents with the configuration below, and restart Emacs. If the file was loaded successfully, you will notice your Emacs became dark themed.

;;; init.el --- Minimal configuration for Emacs 30+ -*- lexical-binding: t; -*-

;;; Package management
(require 'package)
(add-to-list 'package-archives '("gnu" . "https://elpa.gnu.org/packages/") t)
(add-to-list 'package-archives '("nongnu" . "https://elpa.nongnu.org/nongnu/") t)
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t)
(package-initialize)

(require 'use-package)

;;; typography
(set-face-attribute 'default nil
 ;; :family "Iosevka" ;; Uncomment and set your preferred font
 :height 160 ;; Font size (1/10 pt, e.g., 160 = 16pt)
 :weight 'regular)

;;; theme
(use-package modus-themes
 :ensure t
 :config
 (load-theme 'modus-vivendi-tinted :no-confirm))

;;; which-key: in-buffer keybinding cheat sheet (built-in starting in emacs 30)
(use-package which-key
 :ensure nil
 :init
 (which-key-mode 1))

;;; vertico: vertical minibuffer completion ui
(use-package vertico
 :ensure t
 :init
 (vertico-mode 1))

;;; orderless: out-of-order space-separated fuzzy pattern matching
(use-package orderless
 :ensure t
 :custom
 (completion-styles '(orderless basic))
 (completion-category-defaults nil)
 (completion-category-overrides '((file (styles partial-completion)))))

;;; marginalia: contextual annotations in minibuffer margins
(use-package marginalia
 :ensure t
 :init
 (marginalia-mode 1))

;;; sensible ui defaults
(setq inhibit-startup-screen t)
(menu-bar-mode -1)
(tool-bar-mode -1)
(scroll-bar-mode -1)

;;; init.el ends here

What's Next?

Understanding the separation between frames, windows, buffers, and modes establishes a solid foundation for everything that follows.

In Part 2: User Input & Text Navigation, we explore the Emacs input hierarchy, modifier chords, and motion primitives.

Emacs Vanilla vs Flavors (Spacemacs and Doom Emacs)

info@ozbem.com (ebeem) — Sun, 28 Jun 2026 00:00:00 +0000

Where to Begin?

Emacs is not just a text editor, it is a Lisp machine that happens to edit text. When stepping into the Emacs ecosystem, new users are immediately faced with a choice: build from scratch (Vanilla Emacs) or use a pre-configured starter kit like Doom Emacs or Spacemacs. Each approach has distinct pros and cons, and understanding them can save you months of configuration frustration.

The Batteries-Included Flavors

Starter kits are fantastic for package discovery. They show you exactly what Emacs is capable of right out of the box, coming pre-configured with themes, completion frameworks, and integrations for almost every programming language.

However, this convenience comes at a cost. "Batteries-included" setups reduce your visibility into the underlying mechanics. When something breaks, or when you want to change a core behavior, deep customization becomes harder. You often find yourself fighting the framework's design rather than just configuring Emacs.

Spacemacs

Spacemacs revolutionized the community by popularizing mnemonic, space-bar-driven keybindings and excellent Vim emulation. However, it relies heavily on configuration "layers."

These layers add a massive amount of abstraction on top of the base editor. While this makes it incredibly easy to toggle features on and off, migrating your configuration from Spacemacs to Vanilla Emacs becomes an extremely difficult task. Because of the heavy abstraction, you end up learning the "Spacemacs way" rather than the "Emacs way."

Doom Emacs

Doom Emacs takes a different philosophical approach. It still provides a beautiful, feature-rich out-of-the-box experience, but it significantly reduces the layers between the user's configuration and the core Emacs configuration.

It utilizes clever macros to keep startup times incredibly fast and maintains a structure much closer to standard Emacs Lisp. If you want to peek under the hood and see how a feature is implemented, Doom makes it highly visible and accessible.

Vanilla Emacs

Vanilla Emacs is exactly what you get when you download the software from the GNU website. It is a completely blank slate.

The primary advantage here is total ownership. You understand every single line in your configuration file because you put it there. You learn standard Emacs Lisp, making it straightforward to read official documentation and leverage community packages. The major downside is the steep learning curve. You are fully responsible for setting up your own package manager, user interface, completion frameworks, and language servers.

The Keybinding

Your choice of flavor is often heavily tied to your preferred typing style and hardware setup.

Evil Mode (Vim Bindings)

If you are a user coming from vi or Vim, Evil mode (which powers both Spacemacs and Doom by default) is practically magic. It flawlessly brings the language of Vim text objects into Emacs. However, modal editing can sometimes feel like a second-class citizen in niche Emacs packages, requiring extra translation packages (like evil-collection) to make third-party tools play nicely.

Vanilla Bindings (Emacs Bindings)

Standard Emacs keybindings (using Ctrl and Meta). They are deeply integrated into the entire Emacs ecosystem. Everything just works, seamlessly and consistently without any translation layers.

The common complaint is that they require uncomfortable hand stretching. However, if you use a high-quality split ergonomic keyboard, you can easily map modifiers to your thumb clusters. With good hardware, the chances are high that you will not need anything but the standard vanilla keybindings.

Meow (Middle Ground)

If you want the ergonomic benefits of modal editing without straying too far from the standard ecosystem, the meow package is a fantastic alternative. Packages like meow try to sit right in the middle. It allows modal editing but does not fight the default Emacs environment the way Evil sometimes does, keeping your experience much closer to vanilla Emacs.

My Recommendation

For newcomers to Emacs, I highly recommend starting with Doom Emacs. It offers a polished, out-of-the-box experience that lets you get real work done immediately while showing you what Emacs is truly capable of. Later on, as you pick up Emacs Lisp and learn more about the popular packages, you will want to configure things exactly your way, you'll be well-prepared to drop the starter kit and craft your own Vanilla Emacs configuration from scratch.

If you're already a vim user or just want to explore modal editing, evil-mode provides a fantastic experience. If you want the benefits of modal editing but aren't tied to traditional vim bindings, meow is an excellent alternative. I do believe everyone should learn vim keybindings eventually as they are invaluable when you find yourself on a machine without Emacs. However, as a modal editing package, I prefer meow over evil-mode because it's lightweight and integrates much more naturally with the native Emacs ecosystem. If you type on a solid ergonomic split keyboard, I strongly suggest sticking to standard vanilla Emacs keybindings.

My personal progression went from Spacemacs to Doom Emacs, and finally to vanilla. If I go back in time I would skip Spacemacs, it didn't teach me much about how things work under the hood. My editing journey followed a similar path: evil-mode to meow to vanilla. I am incredibly glad I spent time with evil-mode, as it left me highly proficient and comfortable with vim keybindings.

Useful Resources