LazyVim: Neovim als vollwertige IDE und VS Code Alternative

LazyVim verwandelt Neovim in eine moderne, blitzschnelle IDE, die VS Code in vielen Bereichen übertrifft. In diesem Guide zeige ich, wie du LazyVim einrichtest und effektiv nutzt.

LazyVim beim Start mit dem Dashboard

Warum LazyVim statt VS Code?

%%{init: {'theme': 'dark'}}%%
xychart-beta
    title "Performance-Vergleich: Startzeit (ms)"
    x-axis ["VS Code", "LazyVim"]
    y-axis "Millisekunden" 0 --> 3000
    bar [2500, 80]

Aspekt	VS Code	LazyVim
Startzeit	2-5 Sekunden	< 100ms
RAM-Verbrauch	500MB - 2GB	50-150MB
Tastatur-Effizienz	Gut	Exzellent
Remote-Nutzung	Möglich (SSH)	Native (Terminal)
Konfigurierbarkeit	Extensions	Lua (volle Kontrolle)
Lernkurve	Flach	Steil, aber lohnend

%%{init: {'theme': 'dark'}}%%
pie showData
    title RAM-Verbrauch (MB)
    "VS Code" : 800
    "LazyVim" : 100

LazyVim ist ideal für Entwickler, die viel Zeit im Terminal verbringen und maximale Effizienz anstreben.

Was ist LazyVim?

LazyVim ist eine Neovim-Distribution, die “out of the box” funktioniert. Es kombiniert:

• lazy.nvim - Moderner Plugin-Manager mit Lazy-Loading
• LSP - Language Server Protocol für IDE-Features
• Treesitter - Intelligentes Syntax-Highlighting
• Telescope - Fuzzy-Finder für alles
• Mason - Automatische Tool-Installation

flowchart TD
    A[Neovim] --> B[LazyVim Distribution]
    B --> C[lazy.nvim Plugin Manager]
    B --> D[Vorkonfigurierte Plugins]
    B --> E[Sane Defaults]
    C --> F[50+ Plugins]
    D --> G[LSP / Treesitter]
    D --> H[Telescope / Neo-tree]
    D --> I[Git Integration]

Installation

Voraussetzungen

# Neovim >= 0.11.0 (für aktuelle LazyVim Version)
sudo apt install neovim    # Debian/Ubuntu
# oder manuell für neueste Version:
curl -LO https://github.com/neovim/neovim/releases/latest/download/nvim-linux-x86_64.tar.gz
sudo tar -xzf nvim-linux-x86_64.tar.gz -C /opt
sudo ln -sf /opt/nvim-linux-x86_64/bin/nvim /usr/local/bin/nvim

# Abhängigkeiten
sudo apt install git gcc make nodejs npm ripgrep fd-find

LazyVim installieren

# Alte Config sichern
mv ~/.config/nvim ~/.config/nvim.bak
mv ~/.local/share/nvim ~/.local/share/nvim.bak

# LazyVim Starter klonen
git clone https://github.com/LazyVim/starter ~/.config/nvim
rm -rf ~/.config/nvim/.git

# Neovim starten - Plugins werden automatisch installiert
nvim

Beim ersten Start installiert LazyVim automatisch alle Plugins. Das kann einige Minuten dauern.

lazy.nvim installiert automatisch alle Plugins

Nach der Installation :checkhealth ausführen, um die Konfiguration zu prüfen.

---

Die Benutzeroberfläche

LazyVim präsentiert sich mit einer aufgeräumten, modernen Oberfläche:

┌─────────────────────────────────────────────────────────────────┐
│  Neo-tree        │               Editor                        │
│  (File Explorer) │                                              │
│                  │   -- Dateiinhalt --                          │
│  📁 src/         │                                              │
│    📄 main.py    │   1  def hello():                            │
│    📄 utils.py   │   2      print("Hello World")                │
│  📁 tests/       │   3                                          │
│  📄 README.md    │   4  if __name__ == "__main__":              │
│                  │   5      hello()                             │
│                  │                                              │
├──────────────────┴──────────────────────────────────────────────┤
│  main.py [+]  │  utils.py  │  README.md                         │ <- Bufferline
├─────────────────────────────────────────────────────────────────┤
│   main  │ ~/project │ main.py │ utf-8 │ python │ 5:1 │ 100%   │ <- Statusline
└─────────────────────────────────────────────────────────────────┘

Komponenten

Komponente	Plugin	Beschreibung
File Explorer	neo-tree.nvim	Datei-Browser mit Git-Status
Editor	Neovim Core	Hauptbereich für Code
Bufferline	bufferline.nvim	Tab-ähnliche Buffer-Anzeige
Statusline	lualine.nvim	Informationsleiste unten
Command Palette	Telescope	Fuzzy-Finder für alles

---

Der Leader Key

Der Leader Key ist das Herzstück der LazyVim-Bedienung. Standardmäßig ist er auf Space (Leertaste) gesetzt.

%%{init: {'theme': 'dark'}}%%
flowchart LR
    subgraph "Leader Key Workflow"
        A["⎵ Space"] --> B["which-key Popup"]
        B --> C["f → Dateien"]
        B --> D["g → Git"]
        B --> E["c → Code"]
        B --> F["s → Suche"]
        B --> G["... mehr"]
    end
    style A fill:#7c3aed,stroke:#a78bfa,color:#fff
    style B fill:#1e40af,stroke:#60a5fa,color:#fff

Nach Drücken von Space erscheint which-key - ein Popup, das alle verfügbaren Befehle anzeigt:

┌─────────────────────────────────────────┐
│  <leader>                               │
│                                         │
│  f  → file/find      g  → git          │
│  s  → search         c  → code         │
│  b  → buffer         w  → windows      │
│  x  → diagnostics    u  → ui           │
│  l  → lazy           q  → quit         │
│                                         │
│  e  → Explorer       E  → Explorer cwd │
│  -  → Split horiz    |  → Split vert   │
└─────────────────────────────────────────┘

Drücke Space und warte kurz - which-key zeigt dir alle Optionen!

---

Wichtige Keybindings

Vim-Modi verstehen

%%{init: {'theme': 'dark'}}%%
stateDiagram-v2
    [*] --> Normal : nvim startet
    Normal --> Insert : i, a, o
    Insert --> Normal : Esc
    Normal --> Visual : v, V, Ctrl+v
    Visual --> Normal : Esc
    Normal --> Command : Doppelpunkt
    Command --> Normal : Enter/Esc

    note right of Normal : Navigation und Befehle
    note right of Insert : Text eingeben
    note right of Visual : Text auswaehlen
    note right of Command : Ex-Befehle

Grundlegende Textbearbeitung (Must-Have!)

Diese Befehle sind das absolute Minimum, das du kennen musst:

Text markieren (Visual Mode)

Taste	Aktion
v	Zeichen-Auswahl starten
V	Ganze Zeilen markieren
Ctrl+v	Block-Auswahl (Spalten)
viw	Wort markieren
vi"	Text in "..." markieren
vi{	Text in {...} markieren
vip	Absatz markieren
ggVG	Alles markieren

Kopieren (Yank)

Taste	Aktion
y	Auswahl kopieren (im Visual Mode)
yy	Ganze Zeile kopieren
yiw	Wort kopieren
y$	Bis Zeilenende kopieren

Ausschneiden / Löschen

Taste	Aktion
d	Auswahl ausschneiden (im Visual Mode)
dd	Ganze Zeile löschen
D	Ab Cursor bis Zeilenende löschen
diw	Wort löschen
x	Einzelnes Zeichen löschen
5dd	5 Zeilen löschen

Einfügen (Paste)

Taste	Aktion
p	Nach Cursor einfügen
P	Vor Cursor einfügen

System-Clipboard

Taste	Aktion
"+y	In System-Clipboard kopieren
"+p	Aus System-Clipboard einfügen

Tipp: " + + bezieht sich auf das System-Clipboard. Damit kannst du zwischen Nvim und anderen Programmen kopieren.

Speichern & Beenden

Taste	Aktion
:w	Speichern
:w!	Speichern erzwingen
:q	Beenden (wenn gespeichert)
:q!	Beenden ohne Speichern
:wq oder ZZ	Speichern & Beenden
<leader>bd	Buffer schließen (Datei verlassen)
<leader>qq	Nvim komplett beenden

Rückgängig / Wiederholen

Taste	Aktion
u	Rückgängig (Undo)
Ctrl + r	Wiederholen (Redo)

Diese Grundbefehle funktionieren in jedem Vim/Neovim - nicht nur in LazyVim!

Dateien & Navigation

Taste	Aktion	Beschreibung
<leader>ff	Find Files	Dateien im Projekt suchen
<leader>fg	Live Grep	In Dateiinhalten suchen
<leader>fb	Buffers	Offene Buffer anzeigen
<leader>fr	Recent	Zuletzt geöffnete Dateien
<leader>e	Explorer	File Explorer öffnen/schließen
<leader>/	Search	Suche im Projekt

Buffer & Windows

Taste	Aktion	Beschreibung
<S-h>	Prev Buffer	Vorheriger Buffer
<S-l>	Next Buffer	Nächster Buffer
<leader>bd	Delete	Buffer schließen
<leader>-	Split H	Horizontaler Split
<leader>\|	Split V	Vertikaler Split
<C-h/j/k/l>	Navigate	Zwischen Windows wechseln

Code & LSP

Taste	Aktion	Beschreibung
gd	Definition	Zur Definition springen
gr	References	Alle Referenzen anzeigen
gI	Implementation	Zur Implementierung
K	Hover	Dokumentation anzeigen
<leader>ca	Actions	Code Actions (Quick Fixes)
<leader>cr	Rename	Symbol umbenennen
<leader>cf	Format	Code formatieren
<leader>cd	Diagnostics	Fehler in Zeile anzeigen

Git Integration

Taste	Aktion	Beschreibung
<leader>gg	Lazygit	Git TUI öffnen
<leader>gf	Git Files	Geänderte Dateien
<leader>gc	Commits	Commit-Historie
<leader>gb	Blame	Git Blame anzeigen
]h / [h	Hunks	Zum nächsten/vorherigen Hunk

Editing

Taste	Aktion	Beschreibung
gcc	Comment	Zeile kommentieren
gc (visual)	Comment	Auswahl kommentieren
s	Flash	Zu Zeichen springen
S	Flash TS	Mit Treesitter springen
<C-Space>	Complete	Autocomplete trigger

---

LSP - Language Server Protocol

LSP bringt IDE-Features wie Autocomplete, Go-to-Definition und Refactoring. LazyVim konfiguriert LSP automatisch über Mason.

%%{init: {'theme': 'dark'}}%%
flowchart TB
    subgraph Editor["Neovim Editor"]
        A[Code schreiben]
    end

    subgraph LSP["Language Server"]
        B[pyright / lua_ls / bashls]
    end

    subgraph Features["IDE Features"]
        C[Autocomplete]
        D[Go to Definition]
        E[Find References]
        F[Hover Docs]
        G[Diagnostics]
        H[Refactoring]
    end

    A <-->|"JSON-RPC"| B
    B --> C
    B --> D
    B --> E
    B --> F
    B --> G
    B --> H

    style Editor fill:#1e3a5f,stroke:#60a5fa
    style LSP fill:#3b1e5f,stroke:#a78bfa
    style Features fill:#1e5f3a,stroke:#4ade80

Mason - Der LSP Installer

Öffne Mason mit :Mason oder <leader>cm:

┌─ Mason ─────────────────────────────────────────────────┐
│                                                         │
│  Language Servers                                       │
│  ✓ pyright          Python                             │
│  ✓ lua_ls           Lua                                │
│  ✓ bashls           Bash                               │
│  ○ gopls            Go                    [i]nstall    │
│  ○ rust_analyzer    Rust                               │
│                                                         │
│  Formatters                                             │
│  ✓ prettier         JS/TS/JSON/YAML                    │
│  ✓ black            Python                             │
│  ✓ shfmt            Shell                              │
│                                                         │
│  Linters                                                │
│  ✓ ruff             Python                             │
│  ✓ shellcheck       Shell                              │
│                                                         │
└─────────────────────────────────────────────────────────┘

Mit i installierst du einen Server, mit X deinstallierst du ihn.

Unterstützte Sprachen

LazyVim bietet “Extras” für viele Sprachen:

-- In ~/.config/nvim/lua/config/lazy.lua
{ import = "lazyvim.plugins.extras.lang.python" },
{ import = "lazyvim.plugins.extras.lang.go" },
{ import = "lazyvim.plugins.extras.lang.rust" },
{ import = "lazyvim.plugins.extras.lang.typescript" },
{ import = "lazyvim.plugins.extras.lang.docker" },
{ import = "lazyvim.plugins.extras.lang.yaml" },
{ import = "lazyvim.plugins.extras.lang.json" },
{ import = "lazyvim.plugins.extras.lang.markdown" },

LSP in Aktion

Wenn du eine Python-Datei öffnest:

1. Autocomplete erscheint automatisch beim Tippen
2. Diagnostics zeigen Fehler inline an
3. Hover mit K zeigt Dokumentation
4. Go to Definition mit gd springt zur Quelle

import requests  # <- Hover zeigt Modul-Doku

def fetch_data(url: str) -> dict:
    """Fetches JSON data from URL."""
    response = requests.get(url)  # <- gd springt zu requests.get
    return response.json()

result = fetch_data("https://api.example.com")
result.  # <- Autocomplete zeigt dict-Methoden

---

Telescope - Der Fuzzy Finder

Telescope ist das mächtigste Tool in LazyVim. Es findet alles - Dateien, Text, Symbole, Git-Commits.

Telescope Dateisuche mit Fuzzy-Matching

Grundlegende Suche

<leader>ff  →  Dateien finden
<leader>fg  →  Text in Dateien suchen (grep)
<leader>fb  →  Offene Buffer
<leader>fr  →  Zuletzt geöffnet
<leader>fs  →  Symbole im File

Telescope Interface

┌─ Find Files ────────────────────────────────────────────┐
│  > main                                                 │  <- Eingabe
├─────────────────────────────────────────────────────────┤
│  src/main.py                               [Python]     │
│  src/main.js                               [JavaScript] │
│  tests/test_main.py                        [Python]     │
│  docs/main.md                              [Markdown]   │
└─────────────────────────────────────────────────────────┘
│  <C-n/p> Navigate  <CR> Open  <C-x> Split  <C-v> VSplit│
└─────────────────────────────────────────────────────────┘

Telescope Keybindings

Taste	Aktion
<C-n> / <C-p>	Nächstes/Vorheriges Ergebnis
<CR>	Öffnen
<C-x>	In horizontalem Split öffnen
<C-v>	In vertikalem Split öffnen
<C-t>	In neuem Tab öffnen
<C-h>	Hidden Files ein/aus
<Esc>	Schließen

---

Neo-tree - Der File Explorer

Neo-tree ist der Datei-Explorer von LazyVim.

Navigation

Taste	Aktion
<leader>e	Explorer togglen
j / k	Hoch/Runter navigieren
<CR>	Datei öffnen / Ordner auf/zuklappen
H	Versteckte Dateien togglen
a	Neue Datei/Ordner erstellen
d	Löschen
r	Umbenennen
c	Kopieren
m	Verschieben
y	Pfad kopieren
/	Filter
?	Hilfe

Git-Status Icons

 📁 src/
   📄 main.py        ✓  (unmodified)
   📄 utils.py       M  (modified)
   📄 new_file.py    +  (added)
 📁 tests/
   📄 old_test.py    D  (deleted)

---

Formatting & Linting

Conform.nvim - Formatierung

LazyVim nutzt conform.nvim für Code-Formatierung:

-- ~/.config/nvim/lua/plugins/formatting.lua
return {
  {
    "stevearc/conform.nvim",
    opts = {
      formatters_by_ft = {
        python = { "ruff_format", "black" },
        javascript = { "prettier" },
        typescript = { "prettier" },
        json = { "prettier" },
        yaml = { "prettier" },
        markdown = { "prettier" },
        sh = { "shfmt" },
        lua = { "stylua" },
      },
    },
  },
}

Formatieren mit <leader>cf oder automatisch beim Speichern.

nvim-lint - Linting

return {
  {
    "mfussenegger/nvim-lint",
    opts = {
      linters_by_ft = {
        python = { "ruff", "mypy" },
        javascript = { "eslint" },
        sh = { "shellcheck" },
        dockerfile = { "hadolint" },
        yaml = { "yamllint" },
      },
    },
  },
}

Fehler werden inline angezeigt. <leader>xx öffnet die Trouble-Übersicht.

---

Git Integration

%%{init: {'theme': 'dark'}}%%
flowchart LR
    subgraph LazyVim["LazyVim Git Tools"]
        A[gitsigns.nvim]
        B[lazygit.nvim]
        C[diffview.nvim]
    end

    A --> D["Inline Änderungen<br/>+ - ~"]
    A --> E["Stage/Reset Hunks"]
    B --> F["Commit/Push/Pull"]
    B --> G["Branch Management"]
    C --> H["Diff Ansicht"]

    style LazyVim fill:#7c2d12,stroke:#fb923c

Gitsigns

Zeigt Git-Änderungen im Editor:

  1   def hello():           │   (keine Änderung)
+ 2       print("Hello!")    │+  (hinzugefügt - grün)
~ 3       return True        │~  (geändert - blau)
  4                          │
- 5   # removed line         │-  (gelöscht - rot)

Taste	Aktion
]h	Nächster Hunk
[h	Vorheriger Hunk
<leader>hs	Stage Hunk
<leader>hr	Reset Hunk
<leader>hp	Preview Hunk
<leader>gb	Blame Line

Lazygit

<leader>gg öffnet Lazygit - ein mächtiges Git-TUI:

┌─ Lazygit ───────────────────────────────────────────────┐
│ Status │ Files │ Branches │ Commits │ Stash            │
├────────┴───────┴──────────┴─────────┴──────────────────┤
│  Unstaged Changes                                       │
│    M src/main.py                                        │
│    A src/new_file.py                                    │
│                                                         │
│  Staged Changes                                         │
│    M README.md                                          │
├─────────────────────────────────────────────────────────┤
│ [a]dd all  [c]ommit  [p]ush  [P]ull  [?] help          │
└─────────────────────────────────────────────────────────┘

---

Terminal Integration

LazyVim bietet eine leistungsstarke Terminal-Integration direkt im Editor. Du kannst Shell-Befehle ausführen, ohne Neovim zu verlassen.

Toggleterm - Das integrierte Terminal

Space + t + t öffnet ein schwebendes Terminal:

┌─────────────────────────────────────────────────────────┐
│                                                         │
│  ~/project $ python main.py                             │
│  Hello World!                                           │
│  ~/project $ git status                                 │
│  On branch main                                         │
│  nothing to commit, working tree clean                  │
│  ~/project $ _                                          │
│                                                         │
└─────────────────────────────────────────────────────────┘

Terminal-Modi verstehen

Das Terminal in Neovim hat zwei Modi:

%%{init: {'theme': 'dark'}}%%
stateDiagram-v2
    [*] --> TerminalMode : Terminal öffnen
    TerminalMode --> NormalMode : Esc Esc
    NormalMode --> TerminalMode : i oder Enter
    NormalMode --> [*] : Terminal schließen

    note right of TerminalMode : Shell-Eingabe aktiv
    note right of NormalMode : Vim-Navigation möglich

Modus	Beschreibung	Erkennbar an
Terminal-Mode	Direkte Shell-Eingabe	Cursor blinkt, Eingabe geht an Shell
Normal-Mode	Vim-Navigation im Terminal-Buffer	Cursor ist Block, vim-Befehle aktiv

Terminal-Tastenkombinationen

Terminal öffnen und schließen

Tastenkombination	Aktion
Space + t + t	Floating Terminal togglen
Ctrl + \\	Alternatives Terminal-Toggle
Ctrl + /	Snacks.nvim Terminal (LazyVim default)

Zwischen Modi wechseln

Tastenkombination	Von → Nach	Beschreibung
Esc Esc	Terminal → Normal	Terminal-Mode verlassen
i	Normal → Terminal	In Terminal-Mode wechseln
Enter	Normal → Terminal	Alternative zu i
Ctrl + \\ Ctrl + n	Terminal → Normal	Standard Neovim-Weg

Navigation mit offenem Terminal

Tastenkombination	Aktion
Ctrl + h	Zum linken Window
Ctrl + j	Zum unteren Window
Ctrl + k	Zum oberen Window
Ctrl + l	Zum rechten Window

Terminal im Normal-Mode nutzen

Wenn du im Terminal-Buffer im Normal-Mode bist, kannst du:

• Mit y + y eine Zeile aus der Ausgabe kopieren
• Mit / in der Terminal-Ausgabe suchen
• Mit ? rückwärts suchen
• Mit g + g zum Anfang der Ausgabe springen
• Mit G zum Ende springen

Das ist extrem nützlich, um Fehlermeldungen oder Ausgaben zu kopieren!

Mehrere Terminals

Du kannst mehrere Terminal-Instanzen öffnen:

-- In Terminal-Mode verschiedene Terminals öffnen:
-- 1<C-\> öffnet Terminal 1
-- 2<C-\> öffnet Terminal 2
-- etc.

Terminal-Tipps

1. Schnelles Befehls-Ausführen: Öffne Terminal, führe Befehl aus, schließe wieder
2. Build-Prozesse: Halte ein Terminal für make oder npm run dev offen
3. Git-Operationen: Nutze das Terminal für komplexe Git-Befehle
4. Logs beobachten: tail -f in einem persistenten Terminal

Für umfangreichere Terminal-Arbeit empfiehlt sich tmux als Ergänzung zu LazyVim. Siehe den Abschnitt unten.

---

tmux Grundlagen für LazyVim-Nutzer

Wenn du viel im Terminal arbeitest, ist tmux eine perfekte Ergänzung zu LazyVim. tmux ist ein Terminal-Multiplexer, der:

• Mehrere Terminal-Sessions in einem Fenster verwaltet
• Sessions beim Schließen des Terminals erhält
• Splits und Panes wie in vim ermöglicht

tmux vs. LazyVim Terminal

Feature	LazyVim Terminal	tmux
Integration	Direkt im Editor	Separates Tool
Persistenz	Verloren beim Beenden	Sessions bleiben erhalten
Splits	Begrenzt	Unbegrenzt flexibel
SSH-Nutzung	Nur lokal	Ideal für Remote-Arbeit
Lernkurve	Minimal	Moderat

Wann tmux nutzen?

• SSH-Sessions: Arbeit auf Remote-Servern, die nicht abbricht
• Lange Prozesse: Builds, Downloads, die im Hintergrund laufen
• Komplexe Layouts: Mehr als 2-3 Terminal-Fenster gleichzeitig
• Pair Programming: Session-Sharing mit Kollegen

Schnellstart tmux

# tmux installieren
sudo apt install tmux

# Neue Session starten
tmux new -s dev

# Von Session trennen (detach)
# Prefix + d (Standard: Ctrl+b, dann d)

# Session wieder verbinden
tmux attach -t dev

tmux Basis-Keybindings

tmux verwendet einen Prefix-Key (Standard: Ctrl + b), gefolgt von einem Befehl:

Tastenkombination	Aktion
Ctrl + b, dann c	Neues Fenster erstellen
Ctrl + b, dann n	Nächstes Fenster
Ctrl + b, dann p	Vorheriges Fenster
Ctrl + b, dann %	Vertikaler Split
Ctrl + b, dann "	Horizontaler Split
Ctrl + b, dann Pfeiltaste	Zwischen Panes wechseln
Ctrl + b, dann d	Session detachen
Ctrl + b, dann x	Pane schließen

Für einen ausführlichen tmux-Guide siehe den separaten tmux-Artikel.

---

Konfiguration anpassen

%%{init: {'theme': 'dark'}}%%
graph TD
    subgraph Config["~/.config/nvim/"]
        A[init.lua] --> B[lua/config/]
        B --> C[lazy.lua<br/>Plugin Manager]
        B --> D[options.lua<br/>Einstellungen]
        B --> E[keymaps.lua<br/>Tastenkürzel]
        B --> F[autocmds.lua<br/>Auto-Commands]

        A --> G[lua/plugins/]
        G --> H[colorscheme.lua]
        G --> I[ide.lua]
        G --> J[formatting.lua]
    end

    style Config fill:#1f2937,stroke:#6b7280
    style A fill:#7c3aed,stroke:#a78bfa,color:#fff

Verzeichnisstruktur

~/.config/nvim/
├── init.lua                 # Einstiegspunkt
├── lua/
│   ├── config/
│   │   ├── autocmds.lua     # Auto-Commands
│   │   ├── keymaps.lua      # Eigene Keybindings
│   │   ├── lazy.lua         # Plugin-Manager Config
│   │   └── options.lua      # Neovim Optionen
│   └── plugins/
│       ├── colorscheme.lua  # Theme
│       ├── ide.lua          # IDE-Erweiterungen
│       └── formatting.lua   # Formatter/Linter
└── stylua.toml

Eigene Keymaps

-- ~/.config/nvim/lua/config/keymaps.lua
local map = vim.keymap.set

-- Schnelles Speichern
map("n", "<leader>w", "<cmd>w<cr>", { desc = "Save" })

-- Besseres Escape
map("i", "jk", "<Esc>", { desc = "Escape" })

-- Zeilen verschieben
map("v", "J", ":m '>+1<CR>gv=gv", { desc = "Move down" })
map("v", "K", ":m '<-2<CR>gv=gv", { desc = "Move up" })

Eigene Optionen

-- ~/.config/nvim/lua/config/options.lua
local opt = vim.opt

opt.relativenumber = true      -- Relative Zeilennummern
opt.scrolloff = 8              -- Kontext beim Scrollen
opt.wrap = false               -- Kein Zeilenumbruch
opt.expandtab = true           -- Spaces statt Tabs
opt.shiftwidth = 4             -- 4 Spaces pro Indent
opt.tabstop = 4

---

Tipps für VS Code Umsteiger

Äquivalente Aktionen

VS Code	LazyVim
Ctrl + P	Space + f + f
Ctrl + Shift + F	Space + f + g
Ctrl + Shift + E	Space + e
Ctrl + B	Space + e
Ctrl + `	Space + t + t
F2 (Rename)	Space + c + r
Ctrl + . (Quick Fix)	Space + c + a
Ctrl + Shift + P	Space (which-key)
Ctrl + / (Comment)	g + c + c

Lernstrategie

%%{init: {'theme': 'dark'}}%%
timeline
    title LazyVim Lernpfad
    section Woche 1
        Basis-Navigation : hjkl, w, b, 0, $
                        : Datei öffnen/speichern
    section Woche 2
        File-Operations : leader+ff (Dateien)
                       : leader+e (Explorer)
                       : Buffer wechseln
    section Woche 3
        LSP Features : gd (Definition)
                    : gr (Referenzen)
                    : K (Hover Docs)
    section Woche 4
        Git Integration : leader+gg (Lazygit)
                       : Hunks navigieren
                       : Code Reviews

1. Woche 1: Basis-Navigation (hjkl, w, b, 0, $)
2. Woche 2: File-Operations (<leader>ff, <leader>e, Buffer)
3. Woche 3: LSP nutzen (gd, gr, K, <leader>ca)
4. Woche 4: Git-Workflow (<leader>gg, Hunks)

Nutze vimtutor im Terminal für die Vim-Grundlagen!

---

Fazit

LazyVim ist mehr als nur ein Editor - es ist eine hocheffiziente Entwicklungsumgebung:

Pro	Contra
Extrem schnell	Steile Lernkurve
Ressourcenschonend	Konfiguration in Lua
Volle Terminal-Integration	Weniger “klickbar”
Unendlich anpassbar	Vim-Keybindings lernen
Funktioniert überall (SSH)	Plugin-Updates können brechen

Meine Empfehlung: Gib LazyVim mindestens 2 Wochen Zeit. Die Anfangsinvestition zahlt sich durch erhöhte Produktivität schnell aus.

Ressourcen

• LazyVim Dokumentation
• Neovim Homepage
• Vim Cheat Sheet
• ThePrimeagen YouTube - Vim Tips
• TJ DeVries YouTube - Neovim Core Dev