Erster Start

Emacs starten

Emacs lässt sich auf drei Wegen starten, je nachdem, wie du arbeitest und welche Plattform du nutzt. Voraussetzung ist eine funktionierende Installation — falls Emacs noch nicht eingerichtet ist, helfen die Artikel Installation auf macOS, Installation auf Windows oder Installation auf Linux weiter.

• Als grafische App über das Betriebssystem. Auf macOS aus dem Dock, dem Launchpad oder über Spotlight. Auf Windows über das Startmenü, auf Linux aus dem Anwendungsmenü deiner Desktop-Umgebung. Das ist der gewohnteste Einstieg und liefert ein klassisches Fenster mit Menü- und Statusbereichen.
• Aus dem Terminal mit emacs. Der Befehl emacs öffnet ebenfalls ein grafisches Fenster, gibt dir aber zusätzlich Argumente an die Hand: emacs notiz.txt öffnet die Datei direkt, emacs & (Linux/macOS) startet den Editor im Hintergrund, sodass dein Terminal frei bleibt.
• Als reine Terminal-Anwendung mit emacs -nw. Das Argument -nw steht für „no window system" — Emacs läuft komplett im Terminal, ohne eigene Fenster. Sinnvoll auf Servern per SSH, in tmux-Sessions oder einfach, wenn du nicht aus dem Terminal heraus wechseln möchtest.

# Grafisches Emacs starten (öffnet ein Fenster)
emacs

# Datei direkt öffnen
emacs notiz.txt

# Reine Terminal-Variante, ohne eigenes Fenster
emacs -nw

Welcher Weg „richtig" ist, hängt vom Workflow ab. Für die ersten Schritte und alle Beispiele in diesem Artikel reicht ein nackter Aufruf ohne Datei — also emacs aus dem Terminal oder das App-Icon. Beide Varianten zeigen denselben Splash-Screen und dieselben fünf Regionen, die wir gleich genauer ansehen.

Der Splash-Screen

Direkt nach dem Start zeigt Emacs ein Begrüßungs-Bild — den Splash-Screen. Er erscheint nur, wenn du Emacs ohne Datei-Argument aufrufst, und ist eine Mischung aus Logo, Versions-Info und Schnellzugang zur wichtigsten Hilfe. Sichtbar sind typischerweise:

• das GNU-Emacs-Logo (ein stilisierter Gnu),
• die installierte Version mit Datum,
• mehrere Anker-Links in den Editor selbst: zum mitgelieferten Tutorial, zum Hilfe-System, zu den Release-Notes (NEWS) und zu den GNU-Hinweisen zu Freiheit und Lizenz,
• ein kurzer Hinweis auf das Tutorial, das alle wichtigen Tasten erklärt.

Der Splash-Screen ist ausdrücklich nur eine Begrüßung. Er ist kein Dialog und blockiert nichts. Sobald du irgendwo zu tippen oder zu klicken anfängst, eine Datei öffnest oder einen Befehl auslöst, verschwindet er und gibt den Blick auf den eigentlichen Arbeits-Buffer frei. Das ist kein Fehler und auch nichts, was du wegklicken müsstest — es ist genau das gewünschte Verhalten.

Wer Emacs später kennt und den Splash-Screen nicht mehr braucht, kann ihn dauerhaft abschalten. Wie das geht, gehört in die Konfigurations-Kapitel; für den ersten Start ist er bewusst aktiv, weil er die Tutorial-Anker prominent macht.

Die fünf sichtbaren Regionen

Was am Anfang als unübersichtliches Fenster wirkt, ist in Wahrheit immer dasselbe, klar gegliederte Layout. Ein laufendes Emacs-Frame besteht aus fünf Regionen — eine davon optional, alle anderen ständig sichtbar. Wer diese fünf Bereiche einmal verinnerlicht hat, fühlt sich in jedem Emacs sofort zu Hause, egal wie es konfiguriert ist.

+-----------------------------------------------------------+
| Menüleiste   (auf macOS: oben am Display)                 |  ← 1
+-----------------------------------------------------------+
| [Icon] [Icon] [Icon] [Icon]   Toolbar (optional)          |  ← 2
+-----------------------------------------------------------+
|                                                           |
|                                                           |
|     Buffer-Bereich                                        |  ← 3
|     (der eigentliche Inhalt: Text, Code, Hilfe …)         |
|                                                           |
|                                                           |
+-----------------------------------------------------------+
| -UUU:----F1  *scratch*   All L1   (Lisp Interaction) ---  |  ← 4  Modeline
+-----------------------------------------------------------+
| Meldungen und Eingaben erscheinen hier                    |  ← 5  Echo-Area / Minibuffer
+-----------------------------------------------------------+

1 — Menüleiste

Die Menüleiste ist die klassische obere Leiste mit den Einträgen File, Edit, Options, Buffers, Tools, Help und je nach Modus weiteren Punkten. Auf macOS liegt sie wie bei allen nativen Apps am oberen Bildschirmrand und gehört zum aktiven Programm — nicht zum Fenster. Auf Linux und Windows sitzt sie direkt im Emacs-Frame unter der Titelleiste.

Die Menüleiste ist vor allem ein Lerngerät. Sie listet hinter jedem Menüpunkt auch die zugehörige Tastenkombination — wenn du also später wissen willst, wie sich ein Befehl per Tastatur auslösen lässt, lohnt sich ein Blick ins Menü. Für den Alltag verschwindet sie in den Hintergrund: Erfahrene Nutzer benutzen sie selten, weil Tastatur-Befehle schneller sind. Für den Einstieg ist sie deine Notbrücke zu jeder Aktion.

2 — Toolbar

Die Toolbar ist die schmale Icon-Reihe direkt unter dem Menü mit Symbolen für Öffnen, Speichern, Suchen, Rückgängig usw. Sie ist nach der Installation standardmäßig aktiv, wird aber von vielen Emacs-Nutzern früh oder spät abgeschaltet — sie verbraucht vertikalen Platz, dupliziert Funktionalität aus Menü und Tastatur und passt optisch selten zu späteren Themes.

Funktional ist die Toolbar nicht wichtig. Ob sie sichtbar ist oder nicht, ändert nichts an dem, was Emacs kann. Für den ersten Start lässt du sie einfach an; abschalten ist später eine Konfigurations-Frage.

3 — Buffer-Bereich

Der große mittlere Bereich ist der Buffer-Bereich. Hier landet der eigentliche Inhalt — alles, was Emacs gerade „bearbeitet", ob das eine Datei ist, das Hilfe-System, der Versionskontroll-Status oder, beim ersten Start, der *scratch*-Buffer (mehr dazu im nächsten Abschnitt). Der Cursor blinkt in diesem Bereich, hier wird getippt, gelesen und navigiert.

Wichtig: Was du im Buffer-Bereich siehst, ist nicht zwingend eine Datei. Es ist immer ein Buffer, und Buffer und Datei sind verwandt, aber nicht dasselbe — die Unterscheidung ist eines der wenigen Konzepte, das du wirklich verinnerlichen musst, um Emacs zu verstehen.

4 — Modeline

Die Modeline ist die dunkler (oder anders hervorgehobene) hinterlegte Statuszeile direkt unter dem Buffer-Bereich (nicht ganz am unteren Fensterrand — darunter liegt noch die Echo-Area). Sie zeigt immer den Zustand des aktiven Buffers: dessen Name, ob er ungespeicherte Änderungen hat, wo der Cursor steht, welcher Modus aktiv ist und welche zusätzlichen Minor-Modes mitlaufen.

Die Modeline ist Emacs' wichtigstes Anzeige-Werkzeug. Wer sich verirrt fühlt, schaut zuerst dorthin: Sie sagt dir, in welchem Buffer du bist und in welchem Modus Emacs dich gerade behandelt.

5 — Echo-Area und Minibuffer

Die unterste Zeile des Frames ist die Echo-Area. Sie zeigt zwei Dinge: Meldungen von Emacs (etwa „Saved file …" oder Fehler-Hinweise) und Eingabe-Aufforderungen — also Stellen, an denen Emacs eine Datei, einen Befehl oder eine Bestätigung von dir verlangt. Sobald Emacs aktiv etwas von dir wissen will, verwandelt sich diese Zeile in den sogenannten Minibuffer: einen kleinen, eigenständigen Buffer für deine Eingabe.

Echo-Area und Minibuffer teilen sich denselben Platz, sind aber verschiedene Zustände derselben Region. Im Ruhezustand siehst du dort Meldungen; sobald du nach einer Datei gefragt wirst oder einen Befehl per Namen eingibst, ist es der Minibuffer.

Buffer-Konzept als Vorgeschmack

Der zentrale Begriff in Emacs heißt Buffer. Ein Buffer ist die in-Memory-Repräsentation eines Inhalts — alles, was Emacs anzeigt, ist ein Buffer. Eine geöffnete Datei ist ein Buffer, der Hilfe-Text ist ein Buffer, der Output eines Shell-Aufrufs ist ein Buffer, sogar das Eingabefeld in der Echo-Area ist technisch gesehen ein Buffer.

Wichtig zu verstehen: Ein Buffer ist nicht dasselbe wie eine Datei. Eine Datei liegt auf der Festplatte und ist persistent. Ein Buffer existiert nur im laufenden Emacs und kann — muss aber nicht — mit einer Datei verbunden sein. Schließt du Emacs, ohne zu speichern, ist der Buffer-Inhalt weg; die Datei am Datenträger bleibt unverändert. Umgekehrt kannst du Buffer haben, die nie eine Datei werden — etwa das *scratch*-Beispiel weiter unten.

Direkt nach dem Start (sobald der Splash-Screen weicht) findest du in der Regel diese drei besonderen Buffer vor:

• *scratch* — ein freier Notiz- und Test-Buffer. Hier kannst du tippen, ohne dass etwas gespeichert wird; der Buffer ist nicht mit einer Datei verbunden. Standardmäßig läuft er im Lisp-Interaction-Mode, sodass sich kleine Elisp-Ausdrücke direkt auswerten lassen. Für den ersten Start ist er einfach dein Spielplatz.
• *Messages* — das System-Log von Emacs. Alles, was kurz in der Echo-Area aufblitzt — Lade-Meldungen, Speichern-Bestätigungen, kleine Fehler — sammelt sich hier. Wenn dir eine Meldung „zu schnell" verschwunden ist, findest du sie in *Messages* noch einmal.
• *Help* — der Buffer, in dem Emacs Hilfe-Texte ausgibt. Er existiert nicht von Anfang an, sondern entsteht, sobald du irgendetwas im Hilfe-System abfragst.

Buffer-Namen, die mit Sternchen anfangen und enden (*scratch*, *Messages*, *Help*), sind Spezial-Buffer: Sie sind nicht für eine Datei, sondern für interne Zwecke gedacht. Diese Konvention zieht sich durch das ganze System.

Das vollständige Buffer-Modell — wie du zwischen Buffern wechselst, sie verbirgst, beendest, in mehreren Fenstern parallel anzeigst — ist Thema des Kapitels Buffer-Konzept. Für den Moment reicht: Alles ist ein Buffer, und das *scratch*-Sternchen markiert ihn als nicht-mit-Datei-verbunden.

Die Modeline lesen

Die Modeline sieht beim ersten Blick wie eine kryptische Zeichenreihe aus, ist aber sehr regelmäßig aufgebaut. Ein typisches Beispiel direkt nach dem Start im *scratch*-Buffer:

-UUU:----F1  *scratch*   All L1   (Lisp Interaction) ---
 │   │    │    │         │   │     │
 │   │    │    │         │   │     └─ Major-Mode des Buffers
 │   │    │    │         │   └─────── aktuelle Zeile (Line 1)
 │   │    │    │         └─────────── sichtbarer Anteil ("All" / "Top" / "12%")
 │   │    │    └───────────────────── Buffer-Name (Sternchen = Spezial-Buffer)
 │   │    └────────────────────────── Frame-Nummer
 │   └─────────────────────────────── Modified-Marker
 │                                    ("--" = unverändert, "**" = geändert,
 │                                     "%%" = read-only)
 └─────────────────────────────────── Encoding und Zeilenende-Format
                                      (z. B. "UUU" = UTF-8 …)

Die wichtigsten Felder im Klartext:

• Encoding (ganz links) — kodiert in wenigen Zeichen das Datei-Encoding und das Zeilenende-Format. Für den Alltag uninteressant, wird wichtig, sobald du an Dateien mit fremden Encodings arbeitest.
• Modified-Marker — zeigt, ob der Buffer ungespeicherte Änderungen hat. Zwei Bindestriche heißen „unverändert", zwei Sternchen „geändert seit dem letzten Speichern", zwei Prozentzeichen „read-only".
• Buffer-Name — der Name des aktuellen Buffers. Bei Dateien ist es meist der Dateiname, bei Spezial-Buffern der *name*-Name.
• Position — wo der sichtbare Bereich im Buffer liegt (Top, Bot, All, oder ein Prozentwert) und in welcher Zeile der Cursor steht (L1, L42, …).
• Major-Mode in Klammern — der Haupt-Modus des Buffers, der Sprache und Verhalten festlegt. Im *scratch*-Buffer ist das Lisp Interaction, in einer .py-Datei Python, in einer .md-Datei Markdown.
• Danach folgen je nach Konfiguration Minor-Modes — zusätzliche Verhaltens-Schichten wie Zeilennummerierung, Autovervollständigung oder Versionskontroll-Anzeige.

Faustregel: Was in der Modeline steht, gilt immer für den aktuell sichtbaren Buffer, nicht für „Emacs" als Ganzes. Wechselst du in einen anderen Buffer, ändert sich die Modeline mit.

Sicher beenden, ohne Tasten zu kennen

Du musst keine einzige Tastenkombination kennen, um Emacs zu beenden — die Menüleiste reicht völlig aus.

• Auf macOS öffnest du oben am Bildschirm das Menü Emacs (ganz links neben dem Apfel-Menü) und wählst Quit Emacs. Alternativ funktioniert in vielen Versionen auch File → Quit.
• Auf Linux und Windows öffnest du im Emacs-Frame selbst das Menü File (bzw. Datei in einer eingedeutschten Variante) und wählst Quit bzw. Beenden.

Bevor Emacs sich tatsächlich schließt, prüft es noch einmal alle Buffer. Sind irgendwo ungespeicherte Änderungen in dateigebundenen Buffern, fragt Emacs in der Echo-Area nach: Speichern? Verwerfen? Beenden abbrechen? Du kannst diese Frage über das Menü oder direkt in der Echo-Area beantworten. Spezial-Buffer wie *scratch* oder *Messages* ignoriert Emacs dabei — sie sind nicht mit Dateien verbunden, ihr Inhalt geht beim Beenden bewusst verloren.

Für den produktiven Alltag gibt es zusätzlich eine Tastenkombination, die Emacs beendet — sie ist in der Emacs-Welt so verbreitet wie Strg+C zum Kopieren in anderen Programmen. Welche Tasten das sind und wie die Notation funktioniert, ist Thema des nächsten Kapitels zur Tasten-Notation. Bis dahin reicht der Menü-Weg ohne Einschränkung.

Was tun, wenn man sich „verirrt"?

Es ist normal, dass die ersten Sessions kleine Schreckmomente liefern: Eine Eingabe-Aufforderung in der Echo-Area, die nicht weichen will. Ein Befehl, der nicht das tut, was erwartet war. Ein Buffer, den man nicht zugeordnet bekommt. Für diese Fälle gibt es in Emacs zwei verlässliche Anker.

• Die universelle Abbruch-Operation. Emacs hat eine systemweite Abbruch-Geste, mit der sich jeder laufende Befehl, jede Minibuffer-Eingabe und jede halb gestartete Tastenfolge sofort beenden lässt — sie funktioniert quasi überall und ist deine wichtigste Notbremse. Welche Taste das ist, wird im Kapitel zum Bedienkonzept eingeführt. Bis dahin gilt: Über die Menüleiste lässt sich praktisch jede Aktion zurücknehmen oder durch eine andere ersetzen, und im Zweifelsfall öffnest du einfach Edit → Undo.
• Das Tutorial nicht überspringen. GNU Emacs liefert ein eingebautes, interaktives Tutorial mit, das genau für diesen Lernabschnitt gedacht ist. Es führt dich durch die zentralen Tasten und Konzepte — auf Deutsch verfügbar, im Editor selbst, ohne Browser. Wie du es aufrufst, klärt der Artikel zum Hilfe-System. Eine halbe Stunde dort spart später viele Stunden Frust.

Sollte etwas wirklich gar nicht mehr reagieren — was selten ist —, beendest du Emacs einfach über das Menü, wie im vorherigen Abschnitt beschrieben, und startest neu. Du verlierst dabei nur ungespeicherte Spezial-Buffer; bekannte Dateien fragt Emacs vor dem Schließen ab.

Weiterführende Ressourcen

Externe Quellen

• GNU Emacs Manual — Screen — die offizielle Beschreibung des Bildschirm-Layouts mit allen Regionen.
• GNU Emacs Manual — User Input — wie Emacs Tastatur- und Maus-Eingaben grundsätzlich verarbeitet.
• GNU Emacs Tour — die offizielle, bebilderte Kurz-Tour durch Emacs-Konzepte.
• Mastering Emacs — Mickey Petersens fortlaufend aktualisierte Sammlung von Erklär-Artikeln, gute Anlaufstelle nach dem Einstieg.

Verwandte Artikel

• Was ist Emacs?
• Installation auf macOS
• Installation auf Windows
• Installation auf Linux
• Hilfe-System und Tutorial
• Tasten-Notation und Bedienkonzept
• Buffer-Konzept