Kill und Yank — das Konzept

Kill ≠ Cut, Yank ≠ Paste

Die Emacs-Terminologie wirkt auf den ersten Blick willkürlich, ist aber präzise: jeder Begriff bezeichnet eine Operation, die nicht ganz dasselbe ist wie ihr Pendant aus VS Code, Word oder TextEdit. Vor allem deshalb, weil Emacs nicht ein Clipboard-Slot, sondern eine History an Einträgen verwaltet.

Drei Beobachtungen dazu, die für das ganze Konzept tragen:

• Kill und Copy legen beide etwas auf denselben Ring. Der einzige Unterschied: Kill entfernt zusätzlich aus dem Buffer.
• Yank ist nicht „pastiere das System-Clipboard", sondern „nimm den vordersten Kill-Ring-Eintrag" — wobei das System-Clipboard inzwischen automatisch mitspielt (Sektion 05).
• Yank-Pop hat in klassischen Editoren keine Entsprechung. Es ist der Grund, warum der Ring überhaupt eine Datenstruktur ist und nicht ein einzelner Slot.

Die historische Erklärung für die Wörter ist kurz: „Yank" war auf den frühen Lisp-Maschinen am MIT der Befehl, Text aus dem Editor-internen Puffer „herauszuziehen" — er ist älter als „Cut/Copy/Paste", das erst später mit Xerox-PARC, Apple Lisa und Macintosh populär wurde. Emacs hat seine Sprache behalten, während die Welt drumherum sich umbenannt hat.

Der Kill-Ring als Ring-Datenstruktur

Der Kill-Ring ist intern eine Liste mit fester Maximal-Länge. Jeder Kill-Befehl (kill-region, kill-line, kill-word, kill-ring-save …) schiebt einen neuen Eintrag vorne hinein; sobald die Maximal-Länge überschritten wird, fallen die ältesten Einträge hinten heraus. Die Länge steuert die Variable kill-ring-max mit Default-Wert 60.

Kill-Ring (Default kill-ring-max = 60):

  [0] "drittes gekilltes Stück"   ← „aktueller" Eintrag (was C-y einfügen würde)
  [1] "zweites gekilltes Stück"
  [2] "erstes gekilltes Stück"
  ...
  [59] (vor 60 Kills)              ← würde beim nächsten Kill rausfallen

Vier Eigenschaften, die im Alltag immer wieder relevant werden:

• Global pro Emacs-Session. Der Kill-Ring lebt nicht im Buffer, sondern in der Emacs-Instanz. Was du in einem Buffer killst, kannst du in jedem anderen Buffer yanken — auch in einem anderen Frame.
• Keine Persistenz über Neustarts. Beendest du Emacs, ist der Ring weg. Wer das ändern will, nutzt das Paket savehist mit dem zusätzlichen Eintrag kill-ring in savehist-additional-variables.
• Frisches Element vorne. Ein neuer Kill geht immer auf Position [0]. Alle anderen Einträge rücken um eine Stelle nach hinten.
• „Ring" ist nicht nur Metapher. Der Index ist mod-arithmetisch — wer mit M-y über den ältesten Eintrag hinaus cyclet, landet wieder beim aktuellen.

Möchtest du den Ring größer haben, etwa um Wochen-History zu behalten, reicht eine einzige Zeile in der Konfiguration:

;; Statt der Default-60 mehr History behalten
(setq kill-ring-max 200)

Wo dieser Code hingehört

Die Zeile gehört in deine zentrale Konfigurations-Datei (~/.emacs.d/init.el oder ~/.config/emacs/init.el). Eine ausführliche Einführung, wie diese Datei strukturiert wird und wann sie geladen wird, findest du im Artikel Konfiguration mit init.el und early-init.el. Wer das Snippet direkt in der laufenden Session testen will, markiert es und ruft M-x eval-region auf.

C-y (Yank) und M-y (Yank-Pop)

Die beiden zentralen Befehle, um Inhalt aus dem Kill-Ring zurück in einen Buffer zu holen, sind:

• C-y — yank — fügt den aktuellen (vordersten) Kill-Ring-Eintrag an Point ein.
• M-y — yank-pop — nur direkt nach einem Yank: ersetzt das eingefügte Stück mit dem nächst-älteren Kill-Ring-Eintrag.

Die Mechanik ist konsekutiv: C-y setzt einen Marker, dass „der letzte Befehl war ein Yank". Solange dieser Marker steht, ersetzt jedes weitere M-y das eingefügte Stück durch den nächst-älteren Ring-Eintrag. Bewegst du den Cursor, tippst Text oder rufst einen anderen Befehl auf, ist der Marker weg — und M-y meldet Previous command was not a yank.

Konkretes Beispiel-Szenario: du hast gerade drei Schnipsel hintereinander gekillt — "alpha", "beta", "gamma" (in dieser Reihenfolge). Der Kill-Ring sieht so aus:

[0] "gamma"   ← C-y würde dies einfügen
[1] "beta"
[2] "alpha"

Tippst du jetzt nacheinander C-y M-y M-y, sieht der Buffer in drei Schritten so aus:

Nach C-y:       ...gamma
Nach C-y M-y:   ...beta     (gamma wurde ersetzt durch beta)
Nach C-y M-y M-y: ...alpha  (beta wurde ersetzt durch alpha)

Ein weiteres M-y würde wieder bei gamma landen — der Ring ist zyklisch. Wer den Befehl per Namen aufrufen will, nutzt M-x yank bzw. M-x yank-pop; mit numerischem Argument lässt sich M-y auch direkt um mehrere Schritte rückwärts oder vorwärts cyclen (z. B. C-u 3 M-y).

Konsekutive Kills werden zusammengefasst

Eine Eigenheit, die regelmäßig irritiert: zwei direkt aufeinanderfolgende Kill-Befehle erzeugen NICHT zwei Einträge im Kill-Ring, sondern werden zu einem zusammengefasst. Drei C-k hintereinander (also kill-line dreimal) killen drei Zeilen — landen im Kill-Ring aber als ein einziger Eintrag mit dem zusammenhängenden Inhalt aller drei Zeilen.

Die technische Grundlage ist die Variable last-command: solange der vorangegangene Befehl ebenfalls ein Kill-Befehl war, hängt Emacs den neuen Text an den existierenden vordersten Ring-Eintrag an. Sobald ein Nicht-Kill-Befehl dazwischenkommt (Cursor-Bewegung, Tippen, beliebige Funktion), wird die Sequenz gebrochen, und der nächste Kill-Befehl beginnt einen frischen Ring-Eintrag.

Praktischer Effekt — der häufigste Workflow im Alltag:

Vorher:                Nach C-k C-k C-k:
Zeile A                |
Zeile B                |   ← Cursor steht jetzt vor einer leeren Zeile,
Zeile C                |     der Kill-Ring enthält EINEN Eintrag mit
Zeile D                |     "Zeile A\nZeile B\nZeile C\n".

Mit einem einzigen C-y kommen dann alle drei Zeilen am Ziel wieder zusammen heraus — kein wiederholtes Yank, kein Concatenieren von Hand. Genau diese Eigenschaft macht Kill-und-Yank zu einem komfortablen Block-Move-Werkzeug, das ohne explizite Markierung der Region auskommt.

Wer das umgekehrt nicht will — etwa weil zwei Kills bewusst als getrennte Ring-Einträge gespeichert werden sollen — schiebt einen beliebigen Nicht-Kill-Befehl zwischen sie: eine Cursor-Bewegung wie C-f reicht, um die Sequenz zu brechen.

System-Clipboard-Integration

Seit Emacs 25 ist die Verzahnung von Kill-Ring und System-Clipboard standardmäßig aktiv. Die zuständige Variable heißt select-enable-clipboard und steht per Default auf t. Was das praktisch bedeutet:

• Kill schreibt ins System-Clipboard. C-w (kill-region) oder M-w (kill-ring-save) legen den Text gleichzeitig vorne auf den Kill-Ring UND ins System-Clipboard. Andere Anwendungen (Browser, Slack, Mail-Client) können den Inhalt sofort einfügen.
• Yank liest das System-Clipboard. Hat ein anderes Programm zuletzt etwas ins Clipboard gelegt, fügt C-y diesen Inhalt ein und schiebt ihn obendrein vorne in den Kill-Ring — er wird dort ein „echter" Eintrag, durch M-y wieder erreichbar.

Auf X11/Linux gibt es zusätzlich die PRIMARY-Selection — der Inhalt, den jeder Text-Markier-Vorgang automatisch im X-Server hinterlegt und der per Mittel-Klick eingefügt wird. Emacs kann diese parallel zum CLIPBOARD bedienen, gesteuert über select-enable-primary. Auf macOS und Windows gibt es keinen Gegenpart — dort ist nur CLIPBOARD relevant.

;; Kill/Yank arbeitet mit dem System-Clipboard (Default seit Emacs 25)
(setq select-enable-clipboard t)

;; Linux/X11: zusätzlich die PRIMARY-Selection bedienen
(setq select-enable-primary t)

Wo dieser Code hingehört

Auch dieses Snippet gehört in deine init.el. Notwendig ist es streng genommen nicht — die Defaults sind seit Emacs 25 sinnvoll —, aber wer den Zustand explizit dokumentieren will, ist mit den Zeilen oben auf der sicheren Seite.

Terminal-Emacs ohne Window-System

In emacs -nw (Terminal-Modus) gibt es keine direkte Brücke zum System-Clipboard, weil Emacs gar nicht mit dem Window-Server spricht. Drei verbreitete Lösungen:

• macOS: das Tool pbcopy/pbpaste ist vorinstalliert. Pakete wie osx-clipboard oder eigene Wrapper schreiben den Kill-Ring per Shell-Aufruf ins Mac-Clipboard.
• Linux/X11: xclip oder xsel als Brücken-Binary; Pakete wie xclip.el oder clipetty automatisieren den Aufruf.
• Wayland: wl-copy/wl-paste aus wl-clipboard.

Wer regelmäßig in Terminal-Emacs arbeitet, sollte einen dieser Wege einmal sauber einrichten — Clipboard-Brücken sind eine der häufigsten Frustrations-Quellen für Terminal-Workflows.

Den Kill-Ring inspizieren

Der Kill-Ring ist ohne Hilfsmittel unsichtbar — man weiß nur, was vorne liegt (per C-y) und kann sich rückwärts blind durch M-y cyclen. Sobald mehr als ein paar Einträge im Ring liegen, ist das unhandlich. Vier Wege, den Ring sichtbar zu machen:

• M-x browse-kill-ring — externes Paket browse-kill-ring. Öffnet einen eigenen Buffer mit allen Einträgen, in dem du mit n/p navigieren und mit RET einfügen kannst.
• M-x consult-yank-from-kill-ring — Teil des consult-Pakets, der modernen Suchen-Auswahl-Erweiterung. Zeigt alle Kill-Ring-Einträge mit Vorschau im Buffer, während du durch sie scrollst — und filtert per Fuzzy-Match.
• M-x kill-ring-save — selbst kein Inspector, aber als Erinnerung praktisch: dies ist der Copy-Befehl (legt Region in den Ring, ohne sie zu entfernen).
• C-h v kill-ring RET — zeigt die Variable kill-ring direkt an. Die Ausgabe ist die rohe Lisp-Liste der ersten Einträge — funktional, aber unschön und nur als Notlösung gedacht.

Empfehlung für Power-User: consult-yank-from-kill-ring früh einrichten. Mit Live-Vorschau und Fuzzy-Filter verwandelt sich der Kill-Ring von einer blinden History in eine echte, durchsuchbare Zwischenablagen-Verwaltung. Wer noch tiefer geht, kombiniert das mit savehist und persistiert den Ring über Neustarts hinweg — dann hat man wirklich „die letzten 200 Zwischenablagen der letzten Woche" zur Hand.

Praktische Workflows

Vier Muster, die das Konzept im Alltag tragen:

Drei Stellen in einem Buffer umkopieren

C-k C-k C-k drei Zeilen killen → mit C-n oder M-g g zur Ziel-Stelle → C-y alle drei Zeilen als zusammenhängenden Block einfügen. Der Trick: weil die drei C-k konsekutiv sind, werden sie zu einem Ring-Eintrag zusammengefasst (Sektion 04), und ein einziges C-y reicht.

Falsches eingefügt

C-y fügt etwas Falsches ein? Tippe M-y, bis der richtige Eintrag erscheint. Solange du dazwischen keinen anderen Befehl auslöst, cyclet yank-pop durch beliebig viele Ring-Einträge — bis die ganze History durch ist. Funktioniert auch mehrfach hintereinander; rückwärts cyclen über C-u - M-y.

Aus dem Browser kopiert, dann zurück zum Browser

Ein Text aus Firefox/Chrome kommt per Cmd+C/Strg+C ins System-Clipboard → C-y in Emacs fügt ihn ein UND schiebt ihn vorne auf den Kill-Ring. Du editierst, killst Teile mit C-w — diese Kills landen automatisch im System-Clipboard. Cmd+V/Strg+V im Browser fügt das Ergebnis ein, ohne dass ein Bridge-Tool nötig wäre.

Killen über Buffer-Grenzen

Der Kill-Ring ist global pro Emacs-Session. In Buffer A killst du mit C-w, wechselst mit C-x b in Buffer B und yankst dort mit C-y. Das funktioniert auch zwischen Frames und über Daemon-Sessions hinweg — alles, was Emacs als denselben Prozess sieht, teilt sich denselben Ring.

Weiterführende Ressourcen

Externe Quellen

• GNU Emacs Manual — Killing — offizielle Definition aller Kill-Befehle und ihres Verhältnisses zum Kill-Ring.
• GNU Emacs Manual — Yanking — yank, yank-pop und das numerische Argument im Detail.
• GNU Emacs Manual — The Kill Ring — Datenstruktur, kill-ring-max und das Verhalten konsekutiver Kills.
• GNU Emacs Manual — Clipboard — select-enable-clipboard, select-enable-primary und die Interaktion mit X11, macOS und Windows.
• browse-kill-ring auf GitHub — komfortabler Kill-Ring-Inspector mit eigenem Major-Mode.
• consult auf GitHub — moderne Auswahl-UI inklusive consult-yank-from-kill-ring mit Live-Vorschau.

Verwandte Artikel

• Kill-Befehle im Detail
• Region und Mark
• Rectangles
• Register
• Point und Cursor
• Consult für Completion und Suche
• Konfiguration mit init.el und early-init.el