Cancel und Undo

C-g als universelle Notbremse

C-g ruft die Funktion keyboard-quit auf und ist die eine Taste, die in praktisch jeder Situation funktioniert. Sie bricht ab, was gerade läuft, schließt offene Prompts und gibt den Editor in einen sauberen Zustand zurück. Konkret leistet sie vier Dinge:

• Bricht laufende Befehle ab — egal ob eine Suche, ein Ersetzen, eine Datei-Öffnung oder ein gerade ausgeführter Elisp-Ausdruck. Auch eine hängende Funktion, die in einer Endlosschleife festsitzt, lässt sich mit C-g in den meisten Fällen unterbrechen.
• Schließt offene Minibuffer-Prompts — wenn Emacs unten in der Echo-Area auf Eingabe wartet (z. B. „Find file: ..."), schickt C-g diesen Prompt weg, ohne etwas auszuführen.
• Verwirft halb getippte Prefix-Sequenzen — wer C-x drückt und merkt, dass er die Folge-Taste nicht weiß, kommt mit C-g wieder zurück in den neutralen Editier-Zustand. Ohne diese Taste würde Emacs warten, bis irgendeine Folge-Taste kommt.
• Unterbricht numerische Argumente — eine versehentlich getippte C-u 100-Wiederholung lässt sich mit C-g verwerfen, bevor sie zur Anwendung kommt.

Die Faustregel für den Alltag lautet: wenn du nicht weißt, was gerade los ist — drücke C-g. Anders als bei vielen Editoren ist diese Taste nicht destruktiv. Sie verändert nichts am Buffer-Inhalt, sie ruft nur den Zustand „kein Befehl läuft, keine Eingabe wird erwartet" wieder her.

Ein einzelnes C-g reicht in 95 % der Fälle. In tief verschachtelten Situationen — etwa wenn ein laufender Befehl wiederum auf einen Minibuffer wartet, der wiederum aus einem Recursive Edit kam — kann es nötig sein, die Taste mehrmals zu drücken. Drei C-g hintereinander gelten als sicheres „raus aus allem, was nicht der Editor selbst ist".

C-g vs. ESC ESC ESC vs. C-]

Emacs kennt drei verwandte „Beende"-Mechanismen, die sich subtil unterscheiden. Wer sie auseinanderhalten kann, kommt aus jeder Situation ohne Frust heraus.

Die praktischen Unterschiede:

• C-g ist die feinste Klinge — sie bricht nur ab, was gerade aktiv ist, und stört keine geöffneten Help-Windows oder Completion-Buffers. Das ist im Alltag fast immer das, was man will.
• ESC ESC ESC ist der „große Aufräumer": Drei Escapes hintereinander schließen Popup-Buffers (z. B. *Help*, *Completions*), beenden alle Recursive Edits und brechen alles ab, was sonst noch offen ist. Praktisch, wenn der Bildschirm „voll" gelaufen ist und man wieder freie Sicht möchte. Allerdings stoppt diese Variante keine bereits laufenden Befehle — dafür ist nur C-g zuständig.
• C-] ist der Spezialist: Wenn Emacs in einem Recursive Edit steckt (erkennbar an [...] rund um den Major-Mode-Namen in der Modeline), verlässt diese Taste genau diese Ebene. Mehrere Ebenen tief verschachtelt? Dann mehrmals drücken — oder über M-x top-level alle auf einmal verlassen.

Im Alltag reicht C-g. ESC ESC ESC ist die zweite Stufe, wenn der Bildschirm überfüllt wirkt. C-] wird man monatelang nicht brauchen — aber wer einmal in einem Recursive Edit hängt (etwa weil ein Paket explizit einen aufgemacht hat), wird sich freuen, dass es diese Taste gibt.

Undo: eine Funktion, mehrere Tasten — und ein Fallback

Hinter jedem Undo in Emacs steht dieselbe Funktion: undo. Sie ist im Vanilla-Emacs an drei verschiedene Tasten gebunden — und der direkte Aufruf über M-x undo funktioniert immer, unabhängig von Tastatur-Layout, Plattform und Distribution:

Wenn C-x u bei dir nichts tut

In Vanilla-Emacs (Start mit emacs -Q ohne Konfiguration) ist C-x u garantiert an undo gebunden. Wenn es bei dir trotzdem nichts tut, ist die Binding mit hoher Wahrscheinlichkeit von einer Distribution (Doom, Spacemacs) oder einem Paket (evil-mode, cua-mode, eine eigene Custom-Config) überschrieben worden. Drei schnelle Diagnose-Schritte:

1. Direkt testen, ob die Funktion noch existiert und tut, was sie soll: M-x undo RET. Wenn das einen Schritt zurücknimmt, ist die Funktion intakt und nur die Tastatur-Bindung verbogen.
2. Was ist C-x u bei dir gebunden? Mit C-h k (describe-key) und anschließend der Tastenfolge zeigt Emacs an, welches Kommando wirklich darunter liegt. Steht dort undefined oder ein anderer Befehl als undo, hat dich jemand überschrieben.
3. Mit einer leeren Sitzung gegentesten: emacs -Q startet ohne deine init.el und ohne Pakete. Funktioniert C-x u dort, liegt der Override in deiner Konfiguration.

Im Alltag empfehlen wir M-x undo als sichere Bank und C-x u als bequeme Kurzform, wenn die Binding bei dir aktiv ist. Auf deutschen Tastaturen sind C-/ und C-_ dagegen aus einem anderen Grund problematisch: / und _ sind beide Shift-Tasten, und das System reicht Strg+Shift+7 je nach Plattform unterschiedlich an Emacs durch — mal als C-/, mal als C-S-7, mal als reines C-7. Letztere beide sind nicht an undo gebunden, der Tastendruck verpufft wirkungslos.

Warum dann überhaupt drei Bindings?

Historisch: auf US-Tastatur-Layouts liegen / und _ zusammen mit den Sonderzeichen ? direkt erreichbar, und in alten Terminals senden C-/ und C-_ dasselbe Byte (0x1F). Emacs hat alle drei Schreibweisen offiziell beibehalten, damit englischsprachige Doku und Tutorials, die C-/ oder C-_ als „die" Undo-Taste nennen, auch unter Emacs auf DE-System lesbar bleiben — du musst aber nichts davon selbst tippen.

Praktische Empfehlung

• Im Alltag: C-x u nutzen. Funktioniert plattform- und layout-unabhängig.
• Wenn du eine eigene, schneller erreichbare Binding willst, leg undo auf einen Prefix in deinem eigenen Reserve-Raum (C-c <buchstabe> ist für User reserviert — siehe Tasten-Notation):

;; Eigene Undo-Taste auf C-c z (frei wählbar)
(keymap-global-set "C-c z" #'undo)

Wo diese Zeile hingehört (~/.emacs.d/init.el oder ~/.config/emacs/init.el) und wie man die Konfiguration sauber strukturiert, klärt der spätere Artikel Konfiguration mit init.el und early-init.el.

Undo als Baum, nicht als Stack

Das konzeptionelle Herzstück, an dem viele Umsteiger zuerst stolpern. In den meisten Editoren ist Undo ein linearer Stack: jede Änderung kommt oben drauf, ein Redo holt die letzte Änderung zurück, und sobald du nach einem Undo eine neue Aktion machst, wird die Redo-Historie gelöscht. Was ab da neu kommt, überschreibt den alten Pfad.

Emacs macht das anders: Undo selbst ist eine Operation, die rückgängig gemacht werden kann. Es gibt keinen klassischen Stack und kein Redo, sondern eine durchgehende Änderungs-Historie, in der auch jedes Undo wieder als Schritt vermerkt wird. Die Folge: nichts geht verloren — aber die Navigation fühlt sich am Anfang seltsam an.

Eine kleine Sequenz macht das anschaulich:

Schritt 1:  Tippe "A"            → Buffer: A
Schritt 2:  Tippe "B"            → Buffer: AB
Schritt 3:  Undo (C-/)           → Buffer: A      (B wurde entfernt)
Schritt 4:  Tippe "C"            → Buffer: AC
Schritt 5:  Undo (C-/)           → Buffer: A      (C wurde entfernt)
Schritt 6:  Undo (C-/)           → Buffer: AB     (!)

Schritt 6 ist das Überraschende: man würde erwarten, dass nach mehrmaligem Undo der leere Buffer übrig bleibt. Stattdessen erscheint wieder AB. Der Grund: Schritt 3 (das erste Undo) war selbst eine Aktion. Schritt 5 hat Schritt 4 zurückgenommen — und Schritt 6 nimmt jetzt Schritt 3 zurück, holt also das verworfene B zurück.

Aus klassischer Stack-Sicht klingt das wie ein Bug; aus Emacs-Sicht ist es das, was die Verzweigungs-Logik überhaupt erst leistet: kein Daten-Verlust. Im AC-Pfad von oben ist B nie wirklich gelöscht worden — es liegt nur „weiter hinten im Baum" und ist über genug Undos erreichbar.

Diese Eigenschaft macht das System mächtig, aber rohes undo allein ist als Werkzeug zur Navigation in dem Baum unhandlich. Genau dafür gibt es die nächsten beiden Abschnitte.

Redo-Workaround und undo-redo (Emacs 28+)

Vanilla-Emacs vor 28 hatte keinen expliziten Redo-Befehl. Der klassische Workaround nutzte die Stack-Logik aus: eine kurze Nicht-Undo-Aktion einschieben (z. B. den Cursor einmal nach rechts und wieder zurück), dann wieder undo drücken — das bricht die Redo-Kette und kehrt die Richtung der Wieder-Herstellung um.

1.  C-/  C-/  C-/         ; drei Schritte rückwärts
2.  C-f  C-b              ; beliebige Nicht-Undo-Aktion (Cursor versetzen)
3.  C-/  C-/  C-/         ; bringt die letzten Undos zurück → effektives Redo

Seit Emacs 28 gibt es dafür die offizielle Funktion undo-redo — kein Workaround mehr nötig. Sie nimmt das letzte undo zurück, ohne die Baum-Logik zu brechen:

;; undo-redo ist seit Emacs 28 eingebaut.
;; Wir geben ihm zusätzlich ein griffiges Binding.
(global-set-key (kbd "C-?")     #'undo-redo)   ; spiegelt C-/
(global-set-key (kbd "C-M-_")   #'undo-redo)   ; klassische zweite Belegung
(global-set-key (kbd "C-S-z")   #'undo-redo)   ; vertraut aus GUI-Welten

Mit undo-redo verhält sich Emacs aus Anwendersicht wieder wie ein „normaler" Editor mit Undo/Redo — die Baum-Logik bleibt darunter erhalten, ist aber nicht mehr nötig, um einen einfachen Hin-und-Her-Workflow zu fahren. Für die meisten Anwender ist das die heute richtige Default-Wahl, bevor man zu externen Paketen greift.

undo-tree und vundo als visuelle Alternativen

Wer die Baum-Struktur nicht nur als Konzept akzeptieren, sondern sie auch sehen und navigieren möchte, hat im Paket-Ökosystem mehrere Optionen. Die drei wichtigsten:

undo-tree ist der historische Klassiker: es zeigt die komplette Verzweigungs-Struktur in einem eigenen Buffer und erlaubt das Wandern zwischen Branches. Der Preis: es ersetzt das eingebaute Undo durch ein eigenes Format und legt — wenn aktiviert — pro Datei eine zusätzliche .~undo-tree~-Datei an, um die Historie über Sessions hinweg zu erhalten. Wer das nicht will, deaktiviert die Persistenz; viele Setups tun das.

vundo (Visual Undo) ist der moderne Gegenentwurf: es greift nicht in das Undo-System ein, sondern liest die ohnehin vorhandenen Undo-Daten und stellt sie als Baum dar. Keine Persistenz, kein neues Format, keine zusätzlichen Dateien. Aufrufen, navigieren, schließen. Für die meisten Setups ist vundo 2026 die ergonomisch sinnvollere Wahl.

;; vundo: visualisiert die Undo-Baum-Struktur,
;; ohne die Emacs-internen Undo-Daten zu verändern.
(use-package vundo
  :ensure t
  :bind ("C-x u" . vundo)
  :custom
  ;; Hübsche Unicode-Glyphen statt ASCII fuer die Baum-Linien
  (vundo-glyph-alist vundo-unicode-symbols))

undo-fu ist die dritte Option für alle, die das eingebaute Verhalten behalten, aber ein robusteres Redo wollen, ohne sich auf die Versionen-Verfügbarkeit von undo-redo verlassen zu müssen. Praktisch in Evil-Mode-Setups, wo viele Vim-Pakete undo-fu als Backend voraussetzen.

Undo-Grenzen und -Sicherheit

Die Undo-Historie ist mächtig, aber endlich. Drei Variablen steuern, wie viel davon Emacs pro Buffer vorhält. Wer mit großen Dateien arbeitet (Logs, generierter Code, Datenbank-Dumps), läuft sonst irgendwann in eine Undo information truncated-Meldung.

Für moderne Rechner sind diese Defaults konservativ. Eine großzügigere Konfiguration sieht so aus:

;; Undo-Historie pro Buffer großzuegiger halten.
;; Werte in Bytes — hier verzehnfacht gegenueber dem Default.
(setq undo-limit        1600000)   ;  ~1,6 MB
(setq undo-strong-limit 2400000)   ;  ~2,4 MB
(setq undo-outer-limit  240000000) ; ~240 MB fuer Einzelaktionen

Drei wichtige Eigenschaften, die im Alltag oft überraschen:

• Undo ist buffer-lokal. Es gibt kein globales Undo über mehrere Buffer hinweg. Was du in foo.go rückgängig machst, betrifft bar.go nicht.
• Beim Schließen eines Buffers ist die Undo-Historie weg. Wer den Buffer neu öffnet, bekommt einen leeren Verlauf — egal, wie viele Stunden vorher editiert wurde. Einzige Ausnahme: undo-tree mit aktivierter Persistenz, die schreibt die Historie als .~undo-tree~-Datei mit.
• Auto-Compaction bei sehr großen Aktionen. Wenn ein einzelner Befehl (z. B. eine massive Ersetzung) undo-outer-limit sprengt, verwirft Emacs die gesamte Undo-Information dieses Buffers, um Speicher freizugeben — und meldet das in der Echo-Area. Wer das vermeiden will, hebt den Wert an, bevor er eine solche Operation auslöst.

Weiterführende Ressourcen

Externe Quellen

• GNU Emacs Manual — Quitting — offizielle Definition von C-g, ESC ESC ESC und C-].
• GNU Emacs Manual — Undo — offizielle Beschreibung der Undo-Bindings, von undo-redo und der Grenz-Variablen.
• undo-tree (Toby Cubitt) — Projektseite mit Dokumentation und Download.
• vundo auf GitHub — moderner visueller Undo-Browser ohne Eingriff in das Emacs-Undo-System.

Verwandte Artikel

• Tasten-Notation
• Minibuffer und Echo-Area
• M-x-Befehle
• Editieren
• undo-tree und vundo