Emacs on dev@iostream.pl

Seek & Destroy

Sat, 25 Jul 2026 00:20:00 +0200

Every respectable text editor supports searching and replacing text, whether interactively or automatically. Editors from the upper shelves can also work with regular expressions.

And then there is the editor from the highest shelf — Emacs — which handles all of this brilliantly, in several different ways.

Searching

In an average text editor, searching for text requires pressing a keyboard shortcut. Alternatively, you can try to remember beneath which pile of debris on your desk the mouse is buried, move it around until the pointer appears, and click whichever button opens the appropriate dialog box.

Then you type the search term, confirm it, and the text is found. Thank you very much, and we hope to see you again during your next search.

But not in Emacs.

By default, the King of Editors provides incremental search. Pressing C-s — or invoking M-x isearch-forward — starts the search and waits for input in the minibuffer.

With every character you type, Emacs attempts to find the entire string entered so far and moves the cursor to the matching location in the text. The current match is highlighted by default. Any other occurrences visible in the buffer are highlighted as well, using a different combination of foreground and background colours.

The search string is remembered between searches. Pressing C-s again moves the cursor to the next occurrence of the current search string.

When Emacs reaches the end of the buffer, it displays an appropriate message in the minibuffer. Pressing C-s once more wraps the search around and continues from the beginning of the buffer.

Searching backwards

Incremental search also works backwards.

The C-r shortcut — or M-x isearch-backward — behaves just like forward incremental search, except that it moves in the opposite direction.

After reaching the beginning of the buffer, Emacs displays an appropriate message in the minibuffer. Pressing C-r again wraps the search around and continues from the end of the buffer.

Search results

Pressing M-s o during an incremental search — which invokes M-x isearch-occur — opens another window containing the search results: every line in which the requested phrase occurs.

The matching phrase is, naturally, highlighted so that it stands out. At the top of the window, Emacs displays a summary showing how many matches were found, on how many lines, and in which buffer.

More importantly, the results are navigable. Move to any entry and press RET, and Emacs takes you directly to the corresponding line in the original buffer.

Non-incremental search

What if someone simply wants to enter a complete search string first and then jump to its first occurrence?

A traditional, non-incremental search can be performed as follows:

C-s RET <search text> RET — or M-x search-forward — searches forwards,
C-r RET <search text> RET — or M-x search-backward — searches backwards.

In other words, it works much like incremental search, except that you press RET before entering the phrase.

Case sensitivity

By default, Emacs uses a convenient mechanism known as case folding.

As long as the search string contains only lowercase letters, Emacs ignores case and attempts to match as many occurrences as possible. As soon as you enter an uppercase letter, the search becomes case-sensitive.

During an incremental search, M-c toggles case sensitivity explicitly, so there is no need to introduce an uppercase letter merely to change the matching behaviour.

Searching with regular expressions

Emacs also provides both incremental and non-incremental searches based on regular expressions:

M-x re-search-forward searches forwards for the next piece of text matching the given regular expression. When a match is found, the cursor is moved to its end. If no match exists, Emacs displays an appropriate message in the minibuffer.
M-x re-search-backward performs the same operation in the opposite direction.
C-M-s — M-x isearch-forward-regexp — starts an incremental forward search using a regular expression.
C-M-r — M-x isearch-backward-regexp — starts an incremental backward search using a regular expression.

Searching within a region

By default, Emacs searches through the buffer. To limit a search to a particular region, one can use a small but extremely useful trick: narrowing.

Press C-x n n — or invoke M-x narrow-to-region — to narrow the buffer to the currently selected region.

This is interesting because the rest of the text temporarily disappears. All subsequent operations, including searching, are restricted to the visible part of the buffer.

Once the work is complete, press C-x n w — or invoke M-x widen — to restore the hidden text to its rightful place.

Search history

Search history is, of course, preserved.

While searching, you can use:

M-p to recall the previous search string,
M-n to move to the next search string in the history.

Other useful commands

C-y — M-x yank — inserts the most recently killed text into the search string, because why would it not?
C-w adds the remainder of the word at point to the search string.

Replacing

Once again, the King of Editors refuses to blend in with the crowd and offers something better than the competition.

M-% — M-x query-replace — interactively replaces occurrences of one string with another, starting from the position at which the command was invoked.

At every match, Emacs asks the user what should happen next:

y replaces the current match and moves to the next one,
n skips the current match and moves to the next one,
q ends the replacement operation,
! replaces the current match and every remaining match without asking any more unnecessary questions.

Other available actions can be found, for example, by invoking:

M-x describe-function RET query-replace RET

C-M-% — M-x query-replace-regexp — works in the same way, but uses regular expressions.

Emacs also tries to preserve the capitalisation style of the replaced text.

Suppose that every occurrence of windows must be replaced with linux. Emacs may perform the following replacements:

windows becomes linux,
Windows becomes Linux,
WINDOWS becomes LINUX.

The author believes that Windows should be replaced with Linux not only in this example, but also in the lives of us all.

Non-interactive replacement

Emacs also provides commands that replace all matching occurrences without asking for confirmation:

M-x replace-string replaces every occurrence of one string with another, starting from the position at which the command was invoked.
M-x replace-regexp replaces every piece of text matching the given regular expression with the specified replacement string, again starting from the current position.

Replacing within a region

If a region is active, Emacs performs replacement commands within that region by default.

There is no need to narrow or widen the buffer manually — although, naturally, Emacs will not prevent anyone from doing so.

2026-06-29

Mon, 29 Jun 2026 19:15:00 +0200

Buffer Overflow

Today we begin in a slightly unusual place.

Interrupting the Current Operation

If there is one key binding worth remembering before you even open your first file in Emacs, it is this one:

C-g

While Emacs is executing some more complicated Lisp code, it may occasionally stop responding to user commands and give the impression that it has frozen.

Nothing could be further from the truth.

Emacs is not dead. It is merely busy executing that unfortunate piece of Lisp.

There are two possible approaches:

wait patiently until the Lisp interpreter finishes its work,
or interrupt it.

The latter is usually more practical.

C-g interrupts the current operation. It works when Emacs is running a long command, waiting for minibuffer input, or otherwise pretending not to hear you.
M-x keyboard-quit is the function bound to C-g by default. Calling it manually is usually pointless: when Emacs is busy, you cannot invoke it, and when Emacs is not busy, there is nothing to interrupt. Still, the name is worth knowing if you ever decide to remap keys.

If you forget everything else from this section, remember C-g.

When something goes wrong, Emacs will usually listen.

Lisp programmers are less predictable.

What Does This Key Do?

Let us continue.

Emacs contains an excellent built-in help system. One of its most useful features is the ability to ask:

What command is this key binding actually running?

To find out, use:

M-x describe-key
or, more conveniently, C-h k

Emacs will then ask you to press a key sequence, mouse button, or menu item.

For example:

C-h k C-p

opens a help buffer describing the command bound to C-p.

A shortened version looks like this:

C-p runs the command previous-line.

It is bound to C-p and <up>.

Move cursor vertically up ARG lines.

This function is for interactive use only;
in Lisp code use `forward-line' with negative argument instead.

Even this small fragment tells us quite a lot:

which function is bound to the key,
where the function comes from,
which other keys invoke the same command,
what the command does,
whether it is meant for interactive use,
and sometimes which related commands or variables are worth knowing about.

This is one of Emacs’ great strengths.

The program is not merely configurable. It is also unusually good at explaining itself.

Bookmark: if you have reached this point and started yawning, leave this article open. Tomorrow you will know exactly where to resume reading.

You do not have to thank me.

What Does This Function Do?

The same idea works in the other direction.

If you know the name of a function and want to inspect it, use:

M-x describe-function
or simply C-h f

For example:

C-h f find-file

opens a help buffer for the function used to visit files.

A shortened fragment looks like this:

find-file is an interactive function in `files.el`.

It is bound to <open> and C-x C-f.

Edit file FILENAME.
Switch to a buffer visiting file FILENAME, creating one if none already exists.

You can visit files on remote machines by specifying something like:

/ssh:SOME_REMOTE_MACHINE:FILE

You can also visit local files as a different user by specifying:

/sudo::FILE

To visit a file without conversion and without automatically choosing
a major mode, use M-x find-file-literally.

This is why reading Emacs help buffers is often surprisingly useful.

Even a command as ordinary as find-file turns out to do more than merely open files.

Several useful details appear immediately:

Wildcards — file name patterns can be expanded, allowing multiple files to be opened at once.
Remote files — paths such as /ssh:some-host:some-file open files over SSH.
Files as another user — paths such as /sudo::some-file allow editing files with elevated privileges.

The last option is useful for editing configuration files that require administrative access.

Other possible uses are left to the reader’s imagination and the local security department.

At this point, Dear Reader, I assume you have already typed a single * in some directory full of random files and discovered that Emacs can open rather more things than expected:

images,
PDFs,
OpenOffice and LibreOffice documents,
documents produced by that office suite which now apparently wishes to be known as a co-pilot,
EPUB and MOBI files,
archives,
and many other formats.

It probably will not play your movies, but it can certainly inspect archives.

What to do with all those joyfully opened files will be discussed a little later.

Buffers and Frames

Dividing the working area of a frame into two or more windows was invented mainly so that several buffers could be displayed side by side.

Anyone who writes code probably understands the value of that immediately.

The King of Editors can split a frame both horizontally and vertically. The resulting windows can be split again, although not forever. Once a window becomes too small, Emacs will politely refuse and display an appropriate message.

Useful key bindings:

C-x 2 — split the current window horizontally
C-x 3 — split the current window vertically
C-x 1 — delete all other windows and return to a single-window layout
C-x 0 — delete the current window
C-x 5 2 — create a new frame
C-x 5 1 — delete other frames
C-x 5 0 — delete the current frame
C-x o — move focus to the next window
C-x S-o — move focus to the previous window

A very important detail:

C-x 1 removes window splits, but it does not kill any buffers. The buffers remain open; only one of them is currently visible.

Working with Multiple Buffers

Emacs can open as many buffers as available memory allows.

Because of that, there is usually no point in starting another Emacs instance every time you want to open another file. When you need another file, open it in the same Emacs session.

Emacs was designed for working with many buffers at once. Running several separate instances is possible, but in everyday use it is rarely necessary.

Yes, this is the “a little later” mentioned above.

If a file is no longer needed, kill its buffer with:

C-x k

By default, Emacs asks what to do with buffers that contain unsaved changes.

You can move to the previous or next buffer with:

C-x Left
C-x Right

You can also switch directly to a named buffer using:

C-x b

If the buffer visits a file, its name is usually the same as the file name.

If you do not remember the exact name, press TAB. Emacs will display possible completions in a temporary window. You can also start typing and let completion narrow the list.

Completion, selection, and minibuffer behavior are, of course, topics for another volume of the Emacs saga.

To list all buffers, use:

C-x C-b

This opens a buffer containing the buffer list. You can move into that buffer and choose one of the listed entries.

The buffer list does not automatically refresh every time a new buffer is created. This makes sense once you realize that the buffer list is itself just another buffer.

Press:

to refresh it.

What else can be done inside the buffer list?

As homework, press:

and read the help page.

Scrolling Another Window

One of the more useful Emacs features is the ability to scroll the contents of another window while continuing to work in the current one.

No switching back and forth.

No mouse.

No unnecessary ceremony.

If you are writing in one window and need to inspect something above or below in another window, Emacs has you covered.

This is especially useful when both windows display different parts of the same file and you want to check what regrettable code you wrote earlier.

Useful key bindings:

C-M-v — scroll the other window down
C-M-S-v — scroll the other window up

Alternative bindings:

M-PageDown — scroll the other window down
M-PageUp — scroll the other window up

This is one of those features that sounds minor until you start using it. After a few days, working without it feels unnecessarily clumsy.

A note that will age badly and is not really on topic: at the moment, southern Poland is experiencing temperatures that feel entirely incompatible with human life. Some people of questionable judgment still insist that climate change does not exist, and that trains in the seventeenth century were also stuffy.

Drink enough water.

This is not a joke.

Otherwise, the seventeenth-century train will arrive for you personally.

2026-06-25

Thu, 25 Jun 2026 11:15:00 +0200

Installation

There isn’t much to say about installing Emacs.

Every respectable Linux distribution includes Emacs in its package repositories. Simply use your distribution’s package manager.
The same is true for the BSD family.
On macOS, you can install it using Homebrew, MacPorts, or download a native build from https://emacsformacosx.com/.
On Windows, simply download the official installer (.exe) or the ZIP archive and extract it somewhere sensible.
On Android, install the official .apk package and allow applications from unknown sources in the system settings.

A small note: if you have no interest in running the graphical version, most Unix-like systems also provide an emacs-nox package.

Of course, you can always build Emacs from source.

But why would you, when you could spend that hour starting another flame war on Twitter (formerly “X”), Reddit, or simply improving your thumb’s scrolling endurance on social media?

Personally, I’d rather spend that hour weeding the vegetable garden.

Usenet has long since passed into history, and no equally entertaining place for operating-system flame wars has ever truly replaced it.

Getting Started

Launching Emacs

Launching the Finest Editor Known to Humankind is surprisingly simple.

On graphical desktops, Emacs should appear in your applications menu like any other program.
On Windows, if you extracted the ZIP archive instead of running the installer, start bin\runemacs.exe.
If you prefer a purely terminal-based experience, simply run:

emacs -nw

This is where the Emacs journey truly begins.

The first launch of an unmodified (vanilla) Emacs under X11, Windows, or macOS opens a window featuring the GNU antelope, a welcome screen, and a few introductory notes.

Curiously, what most desktop environments call a window, Emacs calls a frame.

The reason is historical.

Long before graphical user interfaces became commonplace, Emacs already knew how to divide a terminal screen into multiple independent editing areas called windows. When graphical support arrived, the terminology remained unchanged: the top-level GUI object became a frame, while the individual editing regions inside it continued to be called windows.

Some traditions are simply too old to change.

Meet the Interface

A default Emacs frame consists of:

a menu bar,
a toolbar (whose appearance ranges from “functional” to “deeply unfortunate”, although fortunately it can be hidden),
one or more editing buffers,
and the command line, better known as the minibuffer.

Buffers

A buffer is the place where text is edited.

Unlike most editors, however, an Emacs buffer is not necessarily associated with a file.

Buffers may contain:

source code,
documentation,
shell sessions,
email,
directory listings,
Git status,
help pages,
or virtually anything else.

This abstraction is one of the core ideas behind Emacs.

Every buffer contains an editing area together with a mode line, which displays useful information such as:

the buffer name,
whether the buffer has unsaved changes,
the current cursor position,
and the active editing mode.

Major Modes

Most editing behavior in Emacs is controlled by major modes.

A major mode typically corresponds to the type of document being edited.

Whether you’re writing C code, XML, Markdown, Lisp, YAML, or something entirely your own, the selected mode determines:

syntax highlighting,
indentation rules,
available commands,
keyboard shortcuts,
and countless editor behaviors.

Creating your own modes is also entirely possible, should inspiration strike.

The Minibuffer

The minibuffer serves as the communication channel between Emacs and its user.

Emacs displays prompts and status messages there, while the user enters commands, filenames, search patterns, and countless other parameters.

The minibuffer supports:

command history,
TAB completion,
and context-sensitive suggestions.

It may look like a single line of text, but it is one of the most heavily used parts of Emacs.

Windows and Frames

A frame may be divided into multiple windows.

Each window displays a buffer.

Interestingly, multiple windows may display the very same buffer simultaneously, each with its own cursor position and viewport.

Only the minibuffer is shared across the entire frame.

Keys and Commands

Emacs documentation uses a notation that initially looks mysterious but quickly becomes second nature.

The most common forms are:

C-x — hold the Control key while pressing x.
C-x C-f — execute the first key sequence, release the regular keys (you may keep holding Control if you like), then execute the second.
M-x — hold the Meta key. On most PC keyboards this is simply the left Alt key. I strongly recommend getting used to the left Alt immediately, since the right one is often reserved for national characters or other platform-specific input methods.
C-M-x — press both Control and Meta together.
S-x — press Shift together with the specified key.

Finally, one notation deserves its own paragraph.

M-x

M-x executes an Emacs command.

Press M-x, release the keys, type the command name into the minibuffer, and press Enter.

Almost everything Emacs can do—apart from simply inserting text—is ultimately implemented as a Lisp function.

Some of those functions appear in menus.

Some are bound to keyboard shortcuts.

All of them can be executed directly via M-x.

For example:

choosing File → Open…
pressing C-x C-f
executing M-x find-file

all invoke exactly the same underlying function.

Useful Keyboard Shortcuts

The following commands quickly become second nature:

C-x C-c — exit Emacs. Generally considered a questionable life decision, although shutting down the computer is usually accepted as a valid excuse.
C-x C-f — open an existing file or create a new one.
C-x C-s — save the current buffer.
C-x C-w — save the current buffer under a different name.
C-x k — kill (close) the current buffer.
C-x Left — previous buffer.
C-x Right — next buffer.
C-x C-b — list all buffers.
C-x h — select the entire buffer.

Editing Text

Unlike some other editors, Emacs does not have separate “insert” and “command” modes.

Open a file.

Start typing.

That’s all there is to it.

Modern keyboards provide cursor keys, Home, End, Page Up, and Page Down, and Emacs fully supports them.

For historical reasons—and because terminals were not always so well equipped—traditional Emacs key bindings are also available:

C-a — beginning of line
C-e — end of line
C-f — forward one character
C-b — backward one character
C-p — previous line
C-n — next line
M-v — previous page
C-v — next page
M-w — copy selected text
C-w — cut selected text
C-y — paste
M-y — immediately after C-y, cycle through previous clipboard entries
C-k — kill text from the cursor to the end of the line. Pressing it twice at the beginning of a line removes the entire line.
C-x h — select the whole buffer.
C-_ (or C-x u) — undo, with unlimited history.

Graphical Emacs naturally supports selecting text with the mouse.

Keyboard users, however, can set the beginning of a selection using C-SPC, move the cursor to the desired position, and then perform any operation on the selected region.

It is one of those habits that soon becomes completely automatic.

One unexpected benefit of learning Emacs is that the keyboard shortcuts tend to follow you.

Bash, the Python REPL, GDB, and many other command-line programs borrow their line-editing behavior from GNU Readline, whose default key bindings are deliberately Emacs-like.

Even if you eventually decide that Emacs is not your editor of choice, the time spent learning C-a, C-e, C-k, or M-f will continue to pay dividends every time you open a terminal.

In fact, many people use Emacs key bindings every day without realizing where they originally came from.

2026-06-20

Sat, 20 Jun 2026 08:15:00 +0200

What Is Emacs, and Do I Need It?

GNU Emacs is a text editor originally created by Richard Stallman for the PDP-10 platform.
GNU Emacs is a universal development environment available on Unix and Unix-like systems, Microsoft Windows, macOS, and many others.
GNU Emacs is an operating system disguised as a text editor.
GNU Emacs is a philosophy and a way of life.
GNU Emacs is a religion.

All right, let’s start over.

A Brief History

Richard Stallman, while working at MIT, became increasingly frustrated with proprietary software. Not only was it often full of bugs, but there was usually little anyone outside the vendor could do to fix them. Bug reports rarely led to meaningful improvements, and users were expected to simply accept whatever they were given.

Eventually, Stallman left MIT and launched the GNU Project, whose goal was to create a completely free Unix-like operating system.

Emacs itself began as a collection of macros for the TECO editor. After a rapid evolution, it became a standalone application and eventually one of the most influential pieces of software in the free software ecosystem. A large community of developers, thousands of articles, books, tutorials, and decades of active use suggest that Emacs still has a long future ahead of it.

Not everyone, however, was happy with the project’s leadership style. The most significant fork occurred when developers from Lucid, who wanted to use Emacs as the foundation of their development environment, split off and created Lucid Emacs. This project later evolved into XEmacs.

Incidentally, the “X” in XEmacs has nothing to do with whether the editor can run under the X Window System. Both GNU Emacs and XEmacs work perfectly well with or without X11.

Over the years, various other forks appeared, often for technical or political reasons. While some introduced interesting ideas, none managed to surpass GNU Emacs itself. XEmacs, despite its innovations, gradually lost momentum. A long period without significant releases and declining community activity eventually left the project effectively dormant. Its website still feels like a time capsule from the late 1990s, apparently untouched by mobile devices, TLS certificates, or modern web design.

What Is Emacs?

A Text Editor

At its core, Emacs is a text editor.

This remains the primary goal of the project: creating an exceptionally capable environment for editing text of all kinds. Source code, notes, books, articles, documentation, LaTeX manuscripts, configuration files—everything is ultimately text, and Emacs is designed to handle all of it.

A Lisp Interpreter and Runtime Environment

One of Emacs’ defining features is its built-in Lisp interpreter.

Through Emacs Lisp, users can extend the editor to perform virtually any task imaginable. Email clients, news readers, calendars, web browsers, file managers, games, and countless other tools are available either as part of the standard distribution or through third-party packages.

Need an AI assistant? Someone has almost certainly written one already.

Installing extensions is typically as simple as fetching the appropriate package from a repository and enabling it.

A Development Environment

For many users, Emacs serves primarily as an integrated development environment.

Support exists for an astonishing number of programming languages. Syntax highlighting, code navigation, language servers, debugging tools, build systems, version control integration, documentation generation, shells, terminals, and countless other development tools are readily available.

Whether you write C++, Go, Python, Rust, Lisp, or something more obscure, chances are that someone has already built excellent Emacs support for it.

An Environment for Markup Languages

Emacs is equally comfortable working with markup and document-oriented formats.

XML, HTML, YAML, Markdown, Org Mode, TeX, LaTeX, DocBook, and many others are all well supported. Validation, transformation, navigation, and editing tools are often available out of the box.

The live preview capabilities available for TeX and LaTeX workflows remain particularly impressive even today.

Anything You Can Convince Lisp to Do

Ultimately, Emacs is whatever you can persuade Emacs Lisp to become.

This flexibility is both its greatest strength and one of the reasons why Emacs users occasionally develop a reputation for eccentricity.

What Emacs Is Not

A Universal Solution

Emacs is an incredibly powerful tool, but it is not magic.

Installing Emacs will not automatically teach you a programming language, system administration, networking, or software architecture. It can help you work more effectively, but it cannot replace knowledge or experience.

Is Emacs for Me?

Perhaps.

Emacs may be a good fit if:

You want a consistent environment for editing, programming, writing, note-taking, and other text-oriented tasks.
You enjoy highly configurable tools.
You appreciate software that can evolve alongside your workflow.

Emacs may not be a good fit if:

Editing configuration files makes you uncomfortable.
You expect every feature to be immediately discoverable through graphical menus.
You are unwilling to invest time learning new tools.
Your primary computing activity consists of scrolling through social media feeds on a phone.

Emacs has a steep learning curve, but it rewards patience. For many users it eventually becomes much more than an editor; it becomes the environment in which a significant portion of their computing life takes place.

Whether that sounds exciting or alarming is entirely up to you.