Register sind in Emacs benannte Speicherplätze, addressierbar mit einem einzigen Buchstaben (a–z). Sie speichern alles, was sich wiederverwenden lässt: Positionen im Buffer, Text-Schnipsel, Window-Layouts, sogar ganze Frame-Configs und Zahlen. Wer Snippets häufig braucht, aber kein YASnippet einrichten will, kommt mit Registern weit. Und wer regelmäßig zwischen zwei Edit-Stellen pendelt, hat mit zwei Tastendrücken einen direkten Sprung — ohne Suchen, ohne Bookmarks-UI, ohne History-Cyclen.
Was ein Register ist
Ein Register ist intern ein einzelner Lisp-Slot, der durch einen Buchstaben benannt ist. Alle Register-Befehle teilen sich das gemeinsame Prefix C-x r — es wurde in dieser Doku bereits für Rectangles eingeführt und ist tatsächlich der ältere, ursprüngliche Heimathafen: das r stand zuerst für „register". Auf das Prefix folgen zwei Dinge: ein Verb-Buchstabe (welche Art von Inhalt? SPC für Position, s für Text, w für Window-Config …) und ein Register-Buchstabe (welcher Slot? a, b, c …).
Drei Eigenschaften, die Register von anderen Wiederverwendungs-Mechanismen abgrenzen:
- Direkt addressierbar. Anders als der Kill-Ring (LIFO-Liste, die man rückwärts durchcyclen muss) ist ein Register direkt per Buchstabe ansprechbar. „Spring zu Register
a" ist eine deterministische Operation. - Buffer-übergreifend. Register leben global in der Emacs-Instanz. Ein Position-Register, das du in Buffer A setzt, springt von jedem anderen Buffer aus zurück nach A.
- Polymorph. Ein und derselbe Slot kann je nach Befehl eine Position, einen Text, eine Window-Config oder eine Zahl enthalten. Der Abruf-Befehl entscheidet aus dem gespeicherten Typ heraus, was passieren soll.
| Inhalt im Register | Speichern mit | Abrufen mit |
|---|---|---|
| Position (Punkt+Buffer) | C-x r SPC <reg> | C-x r j <reg> |
| Text (Region) | C-x r s <reg> | C-x r i <reg> |
| Rectangle | C-x r r <reg> | C-x r i <reg> |
| Window-Configuration | C-x r w <reg> | C-x r j <reg> |
| Frame-Configuration | C-x r f <reg> | C-x r j <reg> |
| Zahl | C-u N C-x r n <reg> | C-x r i <reg> |
| Dateiname | (set-register ?<reg> '(file . "/pfad")) | C-x r j <reg> |
Auffällig: C-x r j ist der eine Sprung-Befehl für alle „strukturellen" Inhalte (Position, Window-Config, Frame-Config), und C-x r i ist der eine Einfüge-Befehl für alle „textuellen" Inhalte (Text, Rectangle, Zahl). Emacs schaut beim Aufruf in den Slot und macht das, was zum Typ passt.
Position-Register: C-x r SPC
Der häufigste Einstieg in Register ist das Speichern einer Position. Eine Position ist mehr als nur die Zeilen-/Spalten-Nummer: gespeichert wird (Buffer, Punkt-Position) als Paar. Der Sprung zurück wechselt also bei Bedarf automatisch den Buffer.
- C-x r SPC a —
point-to-register— speichert die aktuelle Position im Registera. - C-x r j a —
jump-to-register— springt zur gespeicherten Position (ggf. mit Buffer-Wechsel).
Per Befehlsnamen aufrufbar über M-x point-to-register bzw. M-x jump-to-register. Beide fragen anschließend im Minibuffer nach dem Register-Buchstaben — die Tastenfolge C-x r SPC a und der dialogische Weg führen also zum exakt selben Ergebnis.
Der typische Pendel-Workflow zwischen zwei Edit-Stellen sieht so aus:
Schritt 1: Cursor an Stelle 1 → C-x r SPC a
Schritt 2: Cursor an Stelle 2 → C-x r SPC b
Schritt 3: zurück zu Stelle 1 → C-x r j a
Schritt 4: wieder zu Stelle 2 → C-x r j b
Schritt 5: beliebig oft hin und herAnders als bei set-mark und dem Mark-Ring brauchst du dir nicht zu merken, wie oft du schon zurück-cyclen musst — der Buchstabe a ist und bleibt Stelle 1, der Buchstabe b ist und bleibt Stelle 2. Das Mark-Ring-Verhalten („letzte gesetzte Marke") ist flüchtig und konkurriert mit jeder anderen Aktion, die Mark setzt. Register-Positionen sind explizit und stabil.
Eine Feinheit: Position-Register überleben das Schließen eines Buffers nicht sauber. Wird der Buffer, in dem die Position liegt, gekillt, meldet jump-to-register That register doesn't contain a buffer or file. Soll der Sprung-Punkt auch nach Buffer-Kill funktionieren, hilft bookmark-set (C-x r m) — Bookmarks speichern den Datei-Pfad und können die Datei neu öffnen.
Text-Register: C-x r s und C-x r i
Soll nicht eine Position, sondern der Text einer Region in einem Register landen, ist der Befehl copy-to-register. Voraussetzung: eine aktive Region (Mark gesetzt, Punkt am Region-Ende).
- C-x r s a —
copy-to-register— kopiert die Region in Registera. - C-x r i a —
insert-register— fügt den Inhalt von Registeraan Point ein.
Beide kennen zwei Prefix-Argument-Varianten, die das Verhalten umschalten:
| Befehl | Wirkung |
|---|---|
C-x r s a | Region in Register a kopieren — Buffer bleibt unverändert. |
C-u C-x r s a | Region in Register a kopieren UND aus dem Buffer löschen (Kill-Variante). |
C-x r i a | Inhalt einfügen, Point steht NACH dem eingefügten Text, Mark davor. |
C-u C-x r i a | Inhalt einfügen, Point steht VOR dem eingefügten Text, Mark dahinter. |
Praktischer als der Kill-Ring ist copy-to-register immer dann, wenn ein Snippet diese Session mehrfach gebraucht wird, sich aber nicht im Ring nach hinten schieben soll, sobald du zwischendurch etwas anderes killst. Beispiel: du editierst eine längere Datei, brauchst zwischendurch immer wieder denselben Boilerplate-Block für Logger-Aufrufe. Ein einmaliges C-x r s l (l für „Logger") legt den Block in den Slot — egal, was du danach kopierst oder killst, mit C-x r i l ist er immer wieder verfügbar.
Zwei verwandte Befehle, die kein eigenes Tasten-Binding haben, aber per M-x nützlich sind:
- M-x append-to-register — hängt die aktive Region an den bestehenden Inhalt des Registers an. Mit
C-uzusätzlich die Region im Buffer löschen. - M-x prepend-to-register — fügt die Region VOR den bestehenden Register-Inhalt. Prefix-Verhalten analog.
Das Trennzeichen zwischen den Fragmenten steuert die Variable register-separator — wer Fragmente etwa durch eine Leerzeile getrennt sammeln will, kann das so vorgeben:
;; Wenn vorhanden, wird der Inhalt von Register S beim Append/Prepend
;; als Trenner zwischen den Fragmenten verwendet.
(set-register ?S "\n\n")
(setq register-separator ?S)Wohin dieser Code gehört, klärt der Artikel zur Konfiguration mit init.el und early-init.el.
Window-Configurations
Eine Window-Configuration ist die komplette Anordnung der Fenster innerhalb des aktuellen Frames: welche Buffer wo angezeigt werden, in welcher Aufteilung, mit welchen Größen. Genau diese Anordnung lässt sich in einem Register ablegen — und mit demselben Sprung-Befehl, der auch für Positionen genutzt wird, wiederherstellen.
- C-x r w a —
window-configuration-to-register— aktuelle Window-Anordnung in Registeraspeichern. - C-x r j a —
jump-to-register(identischer Befehl wie für Positionen) — Window-Anordnung wiederherstellen.
Der eine j-Befehl erkennt am Inhalt des Registers, was zu tun ist: liegt eine Position drin, springt er. Liegt eine Window-Config drin, restauriert er das Layout. Liegt eine Frame-Config drin, restauriert er sogar die Frame-Anordnung. Polymorphie nach Inhaltstyp.
Der häufigste Use-Case ist „Layout sichern vor dem Experiment": vor einem Refactoring, einer Compile-Session oder einem Debug-Lauf wird das funktionierende Layout per C-x r w a gesichert. Splittest du danach beliebig viel um, öffnest Hilfs-Buffer, schließt Fenster — ein einziges C-x r j a ist der Reset auf den Ausgangszustand.
+-----------------+-----------+
| main.go | repl | Ausgangs-Layout
| | | (3-fach Split)
+-----------------+-----------+
| *Messages* |
+-----------------------------+
↓ C-x r w a (sichern in Register a)
... viele Splits, Helper-Buffer, Hilfe-Fenster, *grep* ...
↓ C-x r j a (zurück zum gespeicherten Layout)
+-----------------+-----------+
| main.go | repl | wiederhergestellt
| | |
+-----------------+-----------+
| *Messages* |
+-----------------------------+Eine sinnvolle Ergänzung ist winner-mode — siehe Winner-Mode und windmove. winner arbeitet History-basiert (Undo/Redo für Fenster-Änderungen), Register-Layouts arbeiten benannt. In der Praxis ergänzen sich beide gut: winner für „einen Schritt zurück", Register für „zurück zu meinem gesunden Layout, egal wie tief ich gerade drin bin".
Frame-Configurations und Zahlen-Register
Zwei weniger genutzte, aber existierende Register-Arten runden das Bild ab.
Frame-Configurations
- C-x r f a —
frame-configuration-to-register— speichert ALLE offenen Frames inklusive ihrer Größen, Positionen, Fenster-Splits. - C-x r j a — derselbe Sprung-Befehl restauriert die komplette Multi-Frame-Anordnung.
Interessant für Multi-Monitor-Setups oder Daemon-Sessions mit mehreren Frames: ein einziger Befehl bringt die gesamte Arbeitsumgebung in einen definierten Zustand zurück. Im Alltag eher Nische, wer aber regelmäßig zwischen „2 Frames für Code" und „1 Frame für Schreiben" pendelt, hat hier einen sauberen Schalter.
Zahlen-Register
Register können auch Zahlen enthalten — gemeinsam mit Keyboard-Makros (siehe Keyboard-Macros) sind sie ein einfacher Mechanismus für Counter und Schleifen.
- C-u 42 C-x r n a —
number-to-registermit Prefix-Argument 42 — speichert die Zahl 42 im Registera. - C-x r + a —
increment-register— erhöht die Zahl im Registeraum 1. Auf Text-Registern hängt der Befehl statt zu inkrementieren die Region an den bestehenden Text an. - C-x r i a —
insert-register— fügt die Zahl als Dezimal-String an Point ein.
Der Klassiker dazu ist „nummerierte Listen per Makro": Counter mit C-u 1 C-x r n a auf 1 setzen, dann im Makro pro Iteration einmal C-x r i a einfügen und mit C-x r + a erhöhen. Das Makro produziert beim Abspielen 1, 2, 3, … ohne Suchen-Ersetzen-Tricks.
Vorbereitung:
C-u 1 C-x r n a Register a := 1
Makro definieren (F3 startet Aufnahme, F4 beendet sie):
F3
C-x r i a Zahl einfügen
C-x r + a Zahl erhöhen
TAB ". Eintrag" Text dahinter
RET Zeile beenden
F4
Mit F4 abspielen oder C-u 10 F4 für zehn Wiederholungen.
Ergebnis:
1. Eintrag
2. Eintrag
3. Eintrag
...Alle Register anzeigen
Register sind ohne Hilfsmittel unsichtbar — der Buchstabe alleine sagt nichts darüber, was im Slot liegt. Zwei eingebaute Wege schaffen Übersicht.
- M-x list-registers — öffnet einen
*Register List*-Buffer mit allen aktuell belegten Registern. Jede Zeile zeigt den Buchstaben, den Typ und einen Vorschau-Auszug des Inhalts. - M-x view-register — fragt nach einem einzelnen Register-Buchstaben und zeigt dessen Inhalt im Echo-Area bzw. in einem temporären Buffer (für längere Texte).
Im *Register List*-Buffer sind die wichtigen Tasten:
| Taste | Wirkung |
|---|---|
RET | Auf einer Zeile: zum Register springen (Position/Layout) bzw. einfügen (Text) |
d | Aktuelle Zeile zum Löschen markieren |
x | Markierte Lösch-Einträge ausführen |
q | Liste schließen |
Wer keine Liste braucht, sondern nur „kurz reingucken, was in a liegt", nutzt M-x view-register mit a als Argument. Beide Befehle sind Pflichtwissen — ohne sie verliert man nach 10–15 belegten Registern schnell die Übersicht über die Buchstaben-Zuordnung.
Praktische Workflows
Fünf konkrete Muster, die Register im Alltag tragen:
Zwischen zwei Edit-Stellen pendeln
Cursor an Stelle 1 → C-x r SPC a. Cursor an Stelle 2 → C-x r SPC b. Ab jetzt bringen dich C-x r j a und C-x r j b direkt zwischen beiden hin und her — auch über Buffer-Grenzen hinweg. Funktioniert auch für drei oder vier Stellen (c, d, …). Die Buchstaben kannst du frei wählen.
Snippet für die Session
Region markieren → C-x r s s (Register „s" für Snippet). Mit C-x r i s beliebig oft einfügen, in jedem Buffer, in beliebiger Reihenfolge. Sobald du den Snippet nicht mehr brauchst, lass ihn einfach liegen — er belegt nur ein Byte Speicher.
Layout sichern vor Experiment
Bevor du das laufende Refactoring oder Debug-Setup mit neuen Splits durcheinanderbringst: C-x r w a (Layout-Register „a"). Splittest, schließt, öffnest Hilfe-Buffer, grep, Help, Messages. Wenn das Layout kaputt ist: C-x r j a bringt alles zurück.
Counter im Keyboard-Macro
C-u 1 C-x r n a setzt Register a auf 1. Im Makro: C-x r i a fügt die Zahl ein, C-x r + a inkrementiert. Beim Abspielen produziert das Makro fortlaufende Nummern — ohne dass du eine Schleife schreiben müsstest.
Wo war ich gestern?
Register überleben die laufende Emacs-Session, aber nicht den Emacs-Restart. Wenn du eine Position auch über Tage halten willst, sind Bookmarks das richtige Werkzeug — sie persistieren in ~/.emacs.d/bookmarks und können sogar Dateien neu öffnen, die zwischenzeitlich geschlossen wurden. Details im Artikel Bookmarks. Bookmark setzen: C-x r m — übrigens auch unter dem C-x r-Prefix, weil Bookmarks im selben System wohnen.
Interessantes
Register sind buffer-übergreifend
Register leben in einer globalen Lisp-Variable der Emacs-Instanz, nicht im Buffer. Ein in Buffer A gesetztes Position-Register springt auch von Buffer B oder einem ganz anderen Frame aus zurück nach A — der Buffer-Wechsel passiert automatisch. Gleiches gilt für Text-Register: einmal gespeichert, sind sie überall einfügbar.
`C-x r j` ist polymorph
Der Sprung-Befehl ist EINER für drei Inhaltsarten: Position, Window-Configuration, Frame-Configuration. Emacs schaut beim Aufruf in den Slot und tut das, was zum Typ passt. Das ist auch der Grund, warum die Mnemonik j für „jump" sowohl „springe zum Punkt" als auch „springe zurück zum Layout" meint.
Register-Buchstaben frei wählen — sprechend belegen
Die Buchstaben sind frei (a–z, auch Zahlen und einige Sonderzeichen). Nutze sprechende Mnemoniken: s für Snippet, l für Layout, t für Test-Position, c für Counter, b für Boilerplate. Wer alles auf a/b/c schiebt, verliert nach kurzer Zeit den Überblick.
Register überleben NICHT den Emacs-Restart
Beendest du Emacs, sind alle Register weg. Für persistente Sprung-Punkte sind Bookmarks (bookmark-set, C-x r m) das richtige Werkzeug — sie speichern auf Platte und überleben Neustarts. Für persistenten Text bietet sich das Paket savehist mit register-alist in savehist-additional-variables an.
`C-u C-x r s a` löscht beim Speichern (Kill-Variante)
Mit Prefix-Argument wird aus dem Copy ein Cut: der Text landet im Register UND wird aus dem Buffer entfernt. Praktisch, wenn man einen Block kurz „beiseite legen" will. Ohne Prefix bleibt der Text im Buffer.
`C-u C-x r i a` setzt Point VOR den eingefügten Text
Default-Einfügen lässt Point hinter dem Text und Mark davor — typisch für „weitertippen nach dem Snippet". Mit Prefix-Argument ist es umgekehrt: Point steht vor dem Inhalt, Mark dahinter. Praktisch, wenn man unmittelbar nach dem Einfügen am Anfang weiterarbeiten will.
`M-x list-registers` ist Pflichtwissen
Ohne die Übersicht weißt du nach einer Stunde Arbeit nicht mehr, welche Buchstaben belegt sind. list-registers öffnet einen Buffer mit allen Slots und ihren Inhaltstypen — die schnellste Weise, „was war nochmal in s?" zu beantworten. Für einzelne Register reicht view-register.
`append-to-register` und `prepend-to-register` sammeln Fragmente
Wer aus mehreren Stellen Schnipsel sammelt, hängt sie mit append-to-register an einen Slot an. Mit gesetztem register-separator (z. B. Doppelzeilenumbruch) werden die Fragmente lesbar getrennt. Beim Einfügen mit C-x r i kommt der gesammelte Block am Stück heraus — ohne Yank-Pop-Akrobatik.
Auf modernen Setups oft durch Bookmarks oder Snippets ersetzt
Wer YASnippet, bookmark+ oder consult-register einsetzt, hat komfortablere UIs. Für Quick-and-Dirty-Speicherung ohne Setup bleiben Register aber das schnellste Werkzeug — sie sind eingebaut, brauchen keine Konfiguration und kein Paket-Setup.
Weiterführende Ressourcen
Externe Quellen
- GNU Emacs Manual — Registers — offizielle Übersicht aller Register-Arten und des
C-x r-Prefix. - GNU Emacs Manual — Position Registers —
point-to-register,jump-to-registerim Detail. - GNU Emacs Manual — Text Registers —
copy-to-register,insert-register,append-to-register,prepend-to-registerinklusive Prefix-Verhalten. - GNU Emacs Manual — Configuration Registers — Window- und Frame-Configurations.
- GNU Emacs Manual — Number Registers —
number-to-registerundincrement-register.