Emacs-for-Goodness-Sake

Chapter 2: The Emacs Philosophy

Or: Why Everything Is a Buffer and That’s Actually Genius

Imagine if every window in your house was actually just a different view of the same infinite room. You could look through the kitchen window and see your documents. Look through the bedroom window and see your email. Look through the bathroom window and see… well, maybe IRC chat. That’s Emacs.

This chapter is about understanding why Emacs works the way it does. Once you grok this, everything else makes sense. Skip this chapter, and you’ll forever be fighting against Emacs instead of flowing with it.

The Buffer: Emacs’s Universal Container

In your IDE, you have files. In Emacs, you have buffers.

“But wait,” you say, “when I open a file, isn’t that the same thing?”

No. And this difference is everything.

A buffer is just a chunk of text that Emacs is managing. It might be:

🤔 Why Though? Because in Emacs, everything is text, and all text lives in buffers. This means you can use the same editing commands on your code, your email, your chat messages, and your git commit messages. Learn once, use everywhere.

The Three-Layer Cake: Frames, Windows, and Buffers

This is where newcomers get confused, because Emacs uses these words differently than every other program:

Let me blow your mind: You can have the same buffer displayed in multiple windows. At the same time. Even in different frames. Change the text in one, it changes in all of them, because they’re all just views of the same buffer.

🚸 IDE Refugee Note: In VS Code, you have tabs that contain files. In Emacs, you have buffers that can be displayed in zero, one, or many windows. This seems insane until you realize you can have your code in one window and scroll to a different part of the same file in another window. Or have your README.md open in two windows with different formatting views.

Let’s See This in Action

Try this experiment:

  1. Open a file: C-x C-f test.txt
  2. Type some text: “Hello from buffer land!”
  3. Split the window horizontally: C-x 2
  4. You now have the same buffer in two windows
  5. In the bottom window, add more text
  6. Notice it appears in both windows—they’re the same buffer!
  7. Switch the bottom window to a different buffer: C-x b *scratch*
  8. Now you have two different buffers visible
  9. Split again: C-x 3 (vertical split)
  10. Create a new frame: C-x 5 2

Congratulations, you’re now looking at multiple windows across multiple frames showing multiple buffers. You’ve entered the Matrix.

The Buffer List: Your Mission Control

See all your buffers:

C-x C-b

This opens the buffer list. It’s not just a list—it’s a buffer itself! Which means you can:

🎯 Pro Tip: Mark buffers for deletion with d, then execute with x. It’s like a file manager, but for buffers.

Special Buffers: The Hidden World

Buffers whose names start with * are special. They’re usually not associated with files:

These buffers are part of Emacs itself. They’re how Emacs talks to you.

The Minibuffer: The Command Line That Isn’t

At the bottom of your Emacs frame is a single line that usually shows something like:

-UUU:----F1  test.txt      All L1     (Text)

Below that, when you run commands, a space opens up. That’s the minibuffer. It’s—wait for it—also a buffer! A very special one where you enter commands, search terms, and filenames.

🤔 Why Though? Because if it’s a buffer, you can use all your editing commands in it. Made a typo in a long file path? Use normal editing commands to fix it. Want to paste something? Same commands work. It’s buffers all the way down.

Major Modes: One Buffer, One Personality

Every buffer has exactly one “major mode” that defines its primary behavior:

The major mode determines:

See your current major mode in the modeline (that status bar at the bottom of each window).

Minor Modes: The Mix-ins

While a buffer has one major mode, it can have many minor modes. These add functionality:

Toggle them on and off:

🎯 Pro Tip: C-h m shows all active modes and their key bindings. It’s like a personalized manual for your current buffer.

The Scratch Buffer: Your Digital Napkin

When Emacs starts, it creates a buffer called *scratch*. This is your playground. It’s not connected to a file. It’s just… there.

;; This buffer is for text that is not saved, and for Lisp evaluation.
;; To create a file, visit it with C-x C-f and enter text in its buffer.

The scratch buffer starts in lisp-interaction-mode. Type some Elisp and press C-j to evaluate it:

(+ 2 2) C-j
4

🚸 IDE Refugee Note: This is like having a REPL always available, but for your editor’s programming language. Imagine if VS Code had a JavaScript console where you could modify VS Code itself while it’s running. That’s what this is.

The Philosophy in Practice: Why This Matters

Here’s where it all comes together. Because everything is a buffer:

  1. Universal Operations: Learn one set of commands, use them everywhere
  2. Composability: Any tool that works on buffers works on everything
  3. Introspection: Emacs can examine and modify itself
  4. Persistence: Buffers exist independently of windows and frames
  5. Flexibility: Display anything anywhere in any configuration

Real-World Example: The Power of Buffers

Let’s say you’re writing code and need to:

  1. Look at documentation
  2. Run tests
  3. Check git status
  4. Read email about a bug report

In a traditional IDE:

In Emacs:

All without leaving Emacs. All using the same key bindings. All searchable with the same commands. All copyable with the same keys.

The Kill Ring: Copy/Paste on Steroids

Since we’re talking philosophy, let’s discuss the kill ring. In Emacs:

But here’s the beautiful part: Emacs remembers everything you’ve killed in a ring. Kill five different things, then cycle through them when yanking:

  1. Kill some text: C-k
  2. Kill more text: C-k
  3. Kill even more: C-k
  4. Yank the last: C-y
  5. Cycle to previous: M-y
  6. Keep cycling: M-y

It’s not a clipboard; it’s a clipboard history that you can browse.

🤔 Why Though? Because when Emacs was created, there was no system clipboard. So they invented something better. Now we’re stuck with the names “kill” and “yank”, but we get infinite clipboard history, so it’s a fair trade.

Regions and Marks: Selection That Makes Sense (Eventually)

In Emacs, you don’t “select” text. You set a “mark” and move the “point” (cursor). The area between them is the “region”.

Or use C-x h to mark the whole buffer. Because sometimes you just want it all.

Recursive Editing: Inception for Text

Sometimes, while you’re doing something in the minibuffer, you need to do something else. Emacs lets you recursively enter another command. You’ll see [...] in the modeline when you’re in a recursive edit.

Don’t panic. C-] gets you out. Or C-g if you want to abort completely.

This is like having multiple command lines stacked on top of each other. It sounds confusing, but it’s occasionally brilliant.

Your Growing Mental Model

By now, you should be starting to see Emacs differently:

This mental model is why Emacs users seem like they’re in a cult. Once you internalize this, every other editor feels like it’s fighting you.

Practical Exercises

🎮 Try This:

  1. Buffer Gymnastics:
    • Open 5 different files
    • Use C-x b with partial names to switch between them
    • Kill a buffer with C-x k
    • Recover it from the recent files with C-x C-f and arrow keys
  2. Window Management:
    • Split horizontally: C-x 2
    • Split vertically: C-x 3
    • Delete other windows: C-x 1
    • Delete this window: C-x 0
    • Cycle through windows: C-x o
  3. The Same Buffer Trick:
    • Open a long file
    • Split the window
    • Scroll to different parts in each window
    • Edit in one, watch it change in the other
  4. Special Buffer Tourism:
    • Visit *Messages* buffer
    • Check out *scratch*
    • Look at *Buffer List*
    • Try M-x list-packages (spoiler for Chapter 5!)

What’s Next?

Now that you understand the Emacs philosophy, Chapter 3 will teach you to move through text like a wizard. We’ll cover the movement commands that make Emacs users look like they’re playing a text-based video game.

But here’s the secret: once you understand buffers, windows, and frames, you’ve already learned the hard part. Everything else is just memorizing keys.

“Emacs is not a mere editor; it is a way of life.” —Someone who understood buffers

Chapter 2 Summary

Once you stop thinking “files” and start thinking “buffers,” you’ll understand why we never leave.

This site is open source. Improve this page.