Fenster und Splits

Splits erzeugen

Vim kennt zwei Split-Richtungen — horizontal (übereinander) und vertikal (nebeneinander). Beide gibt es als Ex-Befehl und als Tastenkombination:

<C-w>s und <C-w>v öffnen den gleichen Buffer in einem neuen Split — was anfangs verwirrt: warum will man dasselbe File zweimal sehen? Sehr oft genau, weil man im selben File an zwei verschiedenen Stellen arbeitet — z. B. eine Funktion-Definition oben, ihre Aufruf-Stelle unten, beides in der gleichen Datei.

Wer einen Split mit einer anderen Datei öffnen will, hat zwei Wege:

" Variante A: direkt mit Ex-Befehl
:split src/util.go
:vsplit src/util.go

" Variante B: Split öffnen, dann darin Datei laden
<C-w>v               " vertikalen Split (zeigt erstmal aktuellen Buffer)
:e src/util.go       " in den neuen Split die andere Datei laden

" Variante C: Buffer-Variante :sb (siehe Buffer-Wechseln-Artikel)
:vert sb util        " vertikaler Split mit bereits geladenem Buffer

Wo der neue Split landet: splitright und splitbelow

Vims Default ist nicht intuitiv: ein horizontaler Split öffnet sich oben, ein vertikaler links. Die meisten User wollen das Gegenteil — neue Splits unten/rechts, wie in den meisten IDEs:

" Neue horizontale Splits unten statt oben
set splitbelow

" Neue vertikale Splits rechts statt links
set splitright

Diese zwei Zeilen gehören in praktisch jede moderne Vim-Konfig. Sie ändern nicht das Verhalten der Befehle, sondern nur die Default-Richtung, in der neue Splits erscheinen.

Navigation zwischen Fenstern

Mit Tastatur navigierst du zwischen Splits über den <C-w>-Präfix gefolgt von einer Richtung:

Die hjkl-Navigation ist konsistent mit der Cursor-Bewegung — links, unten, oben, rechts. Wer das verinnerlicht hat, navigiert in einem 2×2-Layout aus vier Fenstern blind. Die ständige <C-w>-Präfix-Eingabe kann nerven; viele Konfigs mappen das auf bequemere Sequenzen:

" Direkt Ctrl-hjkl statt Ctrl-w hjkl
nnoremap <C-h> <C-w>h
nnoremap <C-j> <C-w>j
nnoremap <C-k> <C-w>k
nnoremap <C-l> <C-w>l

Achtung: <C-l> ist im Default-Vim „Bildschirm neu zeichnen" (:redraw). Wer das Mapping setzt, verliert diese Funktion — was im Alltag aber selten gebraucht wird.

Fenster verschieben und reorganisieren

Splits lassen sich nachträglich umordnen, ohne sie schließen und neu öffnen zu müssen. Die wichtigsten Befehle:

<C-w>H/J/K/L (Großbuchstaben!) sind besonders nützlich: wenn das aktuelle Layout sich „falsch" anfühlt — z. B. zwei horizontale Splits, von denen man jetzt einen lieber vertikal hätte —, drückt man im richtigen Fenster <C-w>L und es springt an die rechte Seite mit voller Höhe. Layout-Reorganisation in zwei Tasten.

<C-w>T (großes T für Tab) ist die nützliche Variante, wenn ein Split zum eigenständigen Workspace werden soll: zwei Fenster sind zu viel auf dem Bildschirm, eines davon braucht aber weiterhin Aufmerksamkeit — <C-w>T schiebt es in einen neuen Tab.

Größe anpassen

Splits haben eine Default-Größe (gleichmäßig verteilt). Sie lässt sich auf vier Wegen ändern:

Inkrementelle Resize

Mit Count multipliziert: 10<C-w>> macht das Fenster 10 Spalten breiter, 5<C-w>+ 5 Zeilen höher.

Absolute Resize via Ex-Befehl

:resize 20           " Höhe auf 20 Zeilen
:resize +10          " 10 Zeilen größer
:vertical resize 60  " Breite auf 60 Spalten
:vert res 60         " Kurzform

Maximieren und Ausgleichen

<C-w>= ist der häufigste Reset-Befehl: nach mehreren Resize-Operationen wird das Layout schief — <C-w>= bringt alle Fenster wieder auf gleiche Größe. Sehr beruhigend.

<C-w>_ und <C-w>| zoomen das aktuelle Fenster maximal in die jeweilige Richtung. Vorsicht: die anderen Fenster bleiben sichtbar, schrumpfen aber auf die Minimal-Größe (Default: 1 Zeile bzw. Spalte). Mit <C-w>= lässt sich das wieder ausgleichen.

Auto-Resize beim Fokuswechsel

Eine sehr praktische, oft übersehene Konfiguration: bei jedem Fokuswechsel das aktive Fenster auf eine Mindest-Größe vergrößern. Über winwidth und winheight:

" Aktuelles Fenster bekommt mindestens 80 Spalten Breite,
" inaktive Fenster werden entsprechend zusammengedrückt.
set winwidth=80
set winminwidth=10

" Analog für Höhe
set winheight=30
set winminheight=5

Damit „atmet" das Layout: das aktive Fenster wird groß, die anderen schrumpfen. Wechselt man, expandiert das vorherig kleine Fenster automatisch. Im Alltag mit 3+ Splits ist das angenehmer als feste Größen.

Fenster schließen

Vier Wege, einen Split loszuwerden:

:q ist der gewohnte Befehl — er funktioniert hier wie überall. Beim letzten Fenster im letzten Tab schließt :q den ganzen Vim. :close ist sicherer, wenn man garantieren will, dass nur ein Fenster verschwindet und Vim nicht versehentlich beendet wird.

:only (oder <C-w>o mit O für „only") ist das Fenster-Aufräum-Kommando: alle anderen Splits weg, nur das aktuelle bleibt. Praktisch, wenn das Layout aus den Fugen geraten ist und man frisch starten will, ohne die Buffer zu verlieren.

vim-tmux-navigator — die Brücke zu tmux

Wer Vim innerhalb einer tmux-Session nutzt, hat plötzlich zwei Split-Systeme: tmux-Panes außerhalb des Vim-Fensters, Vim-Splits innerhalb. Beide haben eigene Navigation, beide kollidieren bei den <C-h/j/k/l>-Mappings.

Das Plugin christoomey/vim-tmux-navigator löst das elegant: es macht <C-h/j/k/l> zu universellen Navigatoren — sie navigieren zwischen Vim-Splits, wenn der nächste Pane noch in Vim ist, und springen zu tmux-Panes, wenn am Rand. Ein nahtloser Layout-Wechsel.

Setup in zwei Schritten:

" vim-tmux-navigator installieren (mit vim-plug oder Manager der Wahl)
Plug 'christoomey/vim-tmux-navigator'

# Smart pane switching with awareness of Vim splits.
# See: https://github.com/christoomey/vim-tmux-navigator
is_vim="ps -o state= -o comm= -t '#{pane_tty}' \
    | grep -iqE '^[^TXZ ]+ +(\\S+\\/)?g?(view|n?vim?x?)(diff)?$'"
bind-key -n 'C-h' if-shell "$is_vim" 'send-keys C-h' 'select-pane -L'
bind-key -n 'C-j' if-shell "$is_vim" 'send-keys C-j' 'select-pane -D'
bind-key -n 'C-k' if-shell "$is_vim" 'send-keys C-k' 'select-pane -U'
bind-key -n 'C-l' if-shell "$is_vim" 'send-keys C-l' 'select-pane -R'

Nach diesem Setup sind <C-h/j/k/l> an jeder Stelle „navigiere in die Richtung" — egal ob die Ziel-Pane in Vim oder tmux ist. Ein erheblicher Workflow-Gewinn für alle, die Vim und tmux kombinieren.

Layout-Workflows aus der Praxis

Drei typische Layouts und wie sie entstehen:

Layout 1: Code links, Tests rechts (50/50)

:e src/foo.go        " Code-Datei öffnen
:vsplit              " vertikal teilen — zweite Kopie rechts
:e src/foo_test.go   " im rechten Split die Test-Datei laden

Layout 2: Drei Files, eines oben, zwei unten

:e src/main.go       " main im Vollbild
:split src/util.go   " horizontal teilen — util darüber
" (jetzt: main unten, util oben)
<C-w>j               " in main-Fenster wechseln
:vsplit src/config.go  " vertikal teilen — config rechts daneben
" (Layout: util oben (volle Breite), main + config unten)

Layout 3: Aus 2×2 wieder zu einem Fenster

" Annahme: 2×2-Layout existiert, du willst zurück zu einem Fenster
" (z. B. wegen einer länglichen Lese-Session in main.go)
<C-w>h<C-w>k         " zum Fenster oben-links navigieren
:only                " alle anderen Splits schließen
" Buffer bleiben im Speicher (mit set hidden)

Im Wechsel zwischen diesen Layouts liegt der eigentliche Vim-Workflow-Vorteil. Mit set hidden aus dem Buffer-Konzept-Artikel sind alle Buffer im Speicher — Layouts können beliebig umgebaut werden, ohne dass Inhalte verloren gehen.

Weiterführende Ressourcen

Externe Quellen

• Vim Help: windows.txt — vollständige Fenster-Referenz.
• Vim Help: window-resize — alle Resize-Befehle.
• Vim Help: window-move-cursor — Navigation zwischen Fenstern.
• Vim Help: splitright — Split-Richtungs-Optionen.
• christoomey/vim-tmux-navigator — universelle Vim+tmux-Navigation.

Verwandte Artikel

• Das Buffer-Konzept
• Buffer wechseln
• Tabs richtig verstehen
• Argument-List
• Installation auf Linux — tmux-Integration
• Plugin-Management