Neovim & Rust installieren - Ein Leitfaden für Manjaro

Installation NeoVim in Manjaro

Manjaros offizielle Repositories bieten in der Regel eine aktuelle Version von Neovim.

Mit pacman

sudo pacman -Syu
sudo pacman -S neovim lua51

Nach der Installation kannst du die Version mit folgendem Befehl prüfen:

nvim --version

Installation Rust

Was ist Rustup - Toolchain

Vorteil von Rustup

Rustup ist der offizielle Toolchain-Manager für Rust. Ohne Rustup installierst du Rust einmalig über die Paketverwaltung deiner Distribution und bist an diese eine Version gebunden. Rustup bietet darüber hinaus folgende Vorteile:

Mehrere Toolchains parallel

Du kannst gleichzeitig die stable, beta und nightly Version von Rust installieren und zwischen ihnen wechseln:

rustup install nightly
rustup install beta
rustup default stable
rustup override set nightly   # nur für aktuelles Projekt

Das ist besonders nützlich, da einige Crates (Programme oder Bibliotheken) z. B. für experimentelle Features nur auf nightly laufen.

Projektbezogene Versionen

Mit einer rust-toolchain.toml Datei im Projektordner legst du fest, welche Rust-Version das Projekt verwendet:

[toolchain]
channel = "1.75.0"
components = ["rustfmt", "clippy"]

Sobald du in den Ordner wechselst, aktiviert Rustup automatisch die passende Version. Das stellt sicher, dass alle Teammitglieder und CI-Systeme dieselbe Version verwenden.

Pinning auf exakte Versionen

Du kannst gezielt eine bestimmte Rust-Version installieren, um reproduzierbare Builds zu gewährleisten:

rustup install 1.75.0
rustup default 1.75.0

Komponenten nachinstallieren

Zusätzliche Werkzeuge wie rustfmt, clippy, rust-analyzer oder rust-src lassen sich jederzeit ergänzen oder entfernen:

rustup component add clippy
rustup component remove rust-docs

Target-Unterstützung

Für Cross-Compilation kannst du Ziele für andere Plattformen hinzufügen:

rustup target add aarch64-unknown-linux-gnu
rustup target add x86_64-pc-windows-gnu

Updates

Rustup aktualisiert die Toolchains mit einem Befehl:

rustup update

Im Gegensatz dazu hängst du bei der Installation über pacman von den Update-Zyklen der Distribution ab, die oft Monate hinterherhinken.

Vorteil einer Toolchain

Eine Toolchain ist das eigentliche Rust-Komplettpaket und besteht aus mehreren Komponenten:

rustc: der Compiler
cargo: der Build-Manager und Package-Manager
rust-std: die Standardbibliothek
rust-docs: die lokale Dokumentation
optionale Komponenten wie rustfmt und clippy

Warum das wichtig ist

Der Vorteil liegt darin, dass alle Komponenten einer Toolchain aufeinander abgestimmt sind. Der Compiler, die Standardbibliothek und die Werkzeuge stammen aus derselben Version. Das vermeidet Versionskonflikte, wie sie bei manuell zusammengestellten Installationen auftreten können.

Kanal statt Version

Eine Toolchain wird über einen Kanal referenziert (stable, beta, nightly) oder über eine exakte Version (1.75.0). Dadurch kannst du entweder immer die neuesten stabilen Features nutzen oder auf eine feste Version setzen, wenn dein Projekt das erfordert.

Vergleich: Rustup vs. Paketmanager

Aspekt	Rustup	pacman
Version	Aktuell	Oft veraltet
Mehrere Versionen	Ja	Nein
Kanalwechsel	Ja	Nein
Projektbezogene Versionen	Ja	Nein
Komponenten nachinstallieren	Ja	Teilweise
Cross-Compilation-Targets	Ja	Eingeschränkt
Update-Zyklus	Unabhängig	Abhängig von Distribution

Wann reicht der Paketmanager?

Wenn du Rust nur gelegentlich nutzt, keine projektbezogenen Versionen brauchst und mit der Version deiner Distribution zufrieden bist, ist die Installation über pacman ausreichend. Für die professionelle Entwicklung ist Rustup jedoch die klar bessere Wahl.

Rustup installieren

Schritt 1: base-devel & Rustup aus dem Repository installieren

sudo pacman -S base-devel rustup

Schritt 2: Toolchain aktivieren

rustup default stable

Wichtig: Das rustup-Paket aus den Arch-Repositories installiert standardmäßig keine Toolchain. Die Binaries (rustc, cargo) sind symbolische Links auf rustup, daher muss die Toolchain manuell aktiviert werden.

Schritt 3: Installation überprüfen

rustc --version

cargo --version

Entwicklungswerkzeuge

Nach der Installation von Rustup kannst du zusätzliche Komponenten hinzufügen:

rustup component add rustfmt         # Code-Formatierung
rustup component add clippy          # Statische Analyse
rustup component add rust-analyzer   # Language Server für IDEs

Rust Installation testen

cargo new hello_world
cd hello_world
cargo run

NeoVim 4 Rust

Um Rust in Neovim zu programmieren, brauchst du im Wesentlichen Rust selbst (erledigt) , den Language Server rust-analyzer und eine Neovim-LSP-Konfiguration.

LSP - Language Server rust-analyzer

rust-analyzer (der LSP-Server): Das ist das Herzstück für Code-Vervollständigung, Fehlerprüfung und Navigation. Der beste Weg ist, ihn über rustup als Komponente hinzuzufügen .
```
rustup component add rust-analyzer
```

Weil es hier und da Probleme mit dem Aufruf von rust-analyzer gibt, sollte noch folgende Anpassung gemacht werden.

Sollte der Aufruf nicht funktionieren

rust-analyzer --version

installiere explizit und danach rufe den oberen Befehle nochmal auf

sudo pacman -S rust-analyzer

Das Ganze hat mit einem kaputten Symlink/Proxy zu tun. Eventuell später mehr dazu. Es soll jetzt erstmal funktionieren!

Neovim Konfiguration

# Übersicht der Verzeichnisse

~/.config/nvim/
├── init.lua                          # Einstiegspunkt, lädt config.lazy
└── lua/
    ├── config/
    │   └── lazy.lua                  # Bootstrap & Setup für lazy.nvim
    └── plugins/
        ├── init.lua                  # Platzhalter, verhindert Fehler
        ├── rust.lua                  # rustaceanvim
        └── completion.lua            # blink.cmp

Lege das Konfigurationsverzeichnis an

mkdir -p ~/.config/nvim

Installiere Plugin Manager lazy.vim

Bevor du beginnst, stelle sicher, dass auf deinem System Neovim (>= 0.8.0) und Git (>= 2.19.0) installiert sind.

nvim --version | head -n 1 && git --version

Falls Git noch nicht installiert ist:

sudo pacman -S git

Konfigurationsdateien anlegen

Erstelle zuerst die benötigten Ordner und Dateien in deinem Neovim-Konfigurationsverzeichnis.

mkdir -p ~/.config/nvim/lua/config && mkdir -p ~/.config/nvim/lua/plugins

init.lua erstellen oder anpassen

Erstelle die Datei ~/.config/nvim/init.lua (falls sie noch nicht existiert) und füge diese Zeile ein:

nvim ~/.config/nvim/init.lua

require("config.lazy")

Bootstrap-Datei für lazy.nvim erstellen

Damit lazy.nvim keine Fehlermeldung zurück gibt, muss in ~/.config/nvim/lua/plugins/ eine leere init.lua angelegt werden.

echo "return {}" > ~/.config/nvim/lua/plugins/init.lua

Erstelle die Datei ~/.config/nvim/lua/config/lazy.lua

nvim ~/.config/nvim/lua/config/lazy.lua

mit folgendem Inhalt. Dieser Code in lazy.lua lädt das Plugin lazy.nvim automatisch herunter, falls es noch nicht vorhanden ist:

-- ~/.config/nvim/lua/config/lazy.lua

-- Bootstrap lazy.nvim
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not (vim.uv or vim.loop).fs_stat(lazypath) then
  local lazyrepo = "https://github.com/folke/lazy.nvim.git"
  local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
  if vim.v.shell_error ~= 0 then
    vim.api.nvim_echo({
      { "Failed to clone lazy.nvim:\n", "ErrorMsg" },
      { out, "WarningMsg" },
      { "\nPress any key to exit..." },
    }, true, {})
    vim.fn.getchar()
    os.exit(1)
  end
end
vim.opt.rtp:prepend(lazypath)

-- Leader-Tasten müssen vor lazy.nvim gesetzt werden
vim.g.mapleader = " "
vim.g.maplocalleader = "\\"

-- lazy.nvim Setup
require("lazy").setup({
  spec = {
    { import = "plugins" },
  },

  -- LuaRocks-Unterstützung mit hererocks
  rocks = {
    enabled = true,
    hererocks = true,
  },

  -- Farbschema beim Installieren
  install = { colorscheme = { "habamax" } },

  -- Automatische Update-Prüfung
  checker = { enabled = true },

  -- Performance
  performance = {
    rtp = {
      disabled_plugins = {
        "gzip",
        "matchit",
        "matchparen",
        "netrwPlugin",
        "tarPlugin",
        "tohtml",
        "tutor",
        "zipPlugin",
      },
    },
  },
})

Installation prüfen

Nachdem du die Konfiguration gespeichert hast, starte Neovim neu. Das Plugin lazy.nvim sollte sich nun automatisch installieren.

lazy.nvim öffnen: Gib den Befehl :Lazy ein, um die grafische Oberfläche zu öffnen.

Sobald lazy.nvim läuft, kannst du mit dem nächsten Schritt fortfahren: der Einrichtung von rustaceanvim in deiner Plugin-Konfiguration.

Plugin rustaceanvim installieren

Für die Konfiguration gibt es zwei gängige Wege. Der einfachste und modernste Weg ist ein spezielles Plugin für Rust.

Dieses Plugin ist eine Art “Rundum-sorglos-Paket” für Rust in Neovim. Es verbindet sich automatisch mit rust-analyzer und bringt viele nützliche Funktionen mit, ohne dass du den LSP-Server manuell konfigurieren musst .

Der rustaceanvim-Eintrag kommt nicht in die lazy.lua, sondern in eine separate Datei im plugins-Ordner. Die lazy.lua ist nur für den Bootstrap und die globale Konfiguration von lazy.nvim zuständig. Deine eigentlichen Plugins gehören in ~/.config/nvim/lua/plugins/.

Erstelle eine neue Datei:

nvim ~/.config/nvim/lua/plugins/rust.lua

Die Datei muss eine Tabelle zurückgeben. Der rustaceanvim-Eintrag steht in dieser Tabelle:

-- ~/.config/nvim/lua/plugins/rust.lua
return {
  {
    "mrcjkb/rustaceanvim",
    version = "^9", -- Version 9 für aktuelle Neovim-Versionen
    lazy = false,   -- Wichtig: Lädt das Plugin sofort
  },
}

Speichere die Datei.
Starte Neovim neu.
gib :Lazy ein und eventuell U zum Updaten
lazy.nvim erkennt die neue Datei und installiert rustaceanvim automatisch.
Öffne eine .rs-Datei. rustaceanvim startet dann rust-analyzer.

Plugin blink.cmp - autocompletion

Installation

Erstelle folgende Datei :

nvim ~/.config/nvim/lua/plugins/completion.lua

Mit folgendem Inhalt

return {
  {
    'saghen/blink.cmp',
    -- Optional: Stellt Snippets für die Snippet-Vervollständigung bereit
    dependencies = { 'rafamadriz/friendly-snippets' },

    -- Nutzt einen Release-Tag, um vorgebaute Binärdateien herunterzuladen.
    -- Das ist der empfohlene Weg für die beste Performance.
    version = '1.*',

    ---@module 'blink.cmp'
    ---@type blink.cmp.Config
    opts = {
      -- 'default' verwendet Tastenkürzel, die denen der eingebauten
      -- Vervollständigung ähneln (z.B. <C-y> zum Akzeptieren)
      keymap = { preset = 'default' },

      appearance = {
        -- 'mono' für 'Nerd Font Mono', um Icons korrekt auszurichten
        nerd_font_variant = 'mono'
      },

      -- Standardmäßig werden Vorschläge von LSP, Dateipfaden,
      -- Snippets und dem aktuellen Buffer verwendet.
      sources = {
        default = { 'lsp', 'path', 'snippets', 'buffer' },
      },

      -- Nutzt die Rust-Implementierung für den Fuzzy-Matcher (schneller),
      -- fällt aber automatisch auf die Lua-Implementierung zurück.
      fuzzy = { implementation = "prefer_rust_with_warning" }
    },
    opts_extend = { "sources.default" }
  }
}

Shortcuts

blink.cmp verwendet standardmäßig das default-Preset, das sich an der eingebauten Neovim-Vervollständigung orientiert . Die wichtigsten Tastenkürzel im Insert-Modus sind:

<C-Space>: Menü öffnen oder Dokumentation umschalten .
<C-y>: Ausgewählten Vorschlag akzeptieren .
<C-e>: Menü schließen (und Vorschau rückgängig machen) .
<C-n> / <C-p> (oder Pfeil runter/hoch): Nächsten oder vorherigen Eintrag auswählen .
<C-k>: Signatur-Hilfe umschalten (sofern aktiviert) .
<C-b> / <C-f>: In der Dokumentationsvorschau scrollen .
<Tab> / <S-Tab>: Zwischen Snippet-Platzhaltern springen .

Möchtest du ein anderes Verhalten, kannst du in deiner blink.cmp-Konfiguration einfach ein anderes Preset wählen, z. B. keymap = { preset = 'super-tab' } für Tab-zum-Akzeptieren .

Neben den von mir genannten Shortcuts gibt es bei blink.cmp noch einige weitere, die je nach Konfiguration und Kontext (z.B. in der Kommandozeile) verfügbar sind.

Presets

Presets sind bei blink.cmp vorgefertigte Tastaturbelegungen, die festlegen, wie du das Vervollständigungsmenü bedienst. Sie sind sozusagen „Pakete“ von Tastenkürzeln für bestimmte Arbeitsweisen.

Die wichtigsten Presets im Überblick

Du wählst ein Preset über keymap = { preset = 'name' } in deiner Konfiguration .

default: Orientiert sich an der eingebauten Neovim-Vervollständigung. Du bestätigst einen Vorschlag mit <C-y> (wie „Yes“) .
super-tab: Orientiert sich an VS Code. Die Tab-Taste akzeptiert den ausgewählten Vorschlag .
enter: Verwendet die Enter-Taste (<CR>) zum Akzeptieren. Die Tab-Taste bleibt für die Navigation zwischen Snippet-Platzhaltern reserviert .
cmdline: Ist speziell für die Kommandozeile (:) optimiert. Die Tab-Taste zeigt das Menü, fügt den ersten Eintrag ein oder wählt den nächsten aus .

Gemeinsame Tasten in allen Presets

Unabhängig vom gewählten Preset sind einige Tasten immer gleich belegt, zum Beispiel :

<C-space>: Menü öffnen oder Dokumentation umschalten.
<C-n> / <C-p> (oder Pfeiltasten): Nächsten oder vorherigen Eintrag auswählen.
<C-e>: Menü schließen.

Die wichtigsten Presets im Vergleich

blink.cmp bringt verschiedene vordefinierte Tastaturbelegungen mit, die sogenannten Presets. Deine aktuell genutzten Shortcuts (<C-Space>, <C-y>, <C-e> etc.) gehören zum default-Preset. Andere Presets ändern die Belegung grundlegend:

Funktion	`default`	`super-tab`	`enter`	`cmdline`
Akzeptieren	`<C-y>`	`<Tab>` (smart)	`<CR>` (Enter)	`<Tab>`
Nächstes	`<C-n>`, `<Down>`	`<C-n>`, `<Down>`	`<C-n>`, `<Down>`	`<Tab>`, `<C-n>`
Vorheriges	`<C-p>`, `<Up>`	`<C-p>`, `<Up>`	`<C-p>`, `<Up>`	`<S-Tab>`, `<C-p>`
Snippet vorwärts	`<Tab>`	`<Tab>` (smart)	`<Tab>`	—

Wenn du also z.B. möchtest, dass Tab den Vorschlag akzeptiert (wie in VS Code), änderst du keymap = { preset = 'super-tab' } in deiner Konfiguration .

Weitere nützliche Standard-Shortcuts

Unabhängig vom Preset gibt es einige Befehle, die in den meisten Konfigurationen zu finden sind:

<C-k>: Schaltet die Signatur-Hilfe um (sofern aktiviert) .
<C-b> / <C-f>: Scrollt in der Dokumentationsvorschau nach oben/unten .
<C-l>: Zeigt das Vervollständigungsmenü oder die Dokumentation an .
<C-e>: Schließt das Menü (und macht eine automatische Vorschau rückgängig) .

Shortcuts in der Kommandozeile (cmdline)

Wenn du in der Neovim-Kommandozeile (:) tippst, gelten oft andere Regeln. Das cmdline-Preset ist speziell dafür optimiert :

<Tab>: Zeigt das Menü, fügt das erste Element ein oder wählt das nächste aus.
<S-Tab>: Wählt das vorherige Element aus.
<Right> / <Left>: Navigiert wie in der normalen Vervollständigung durch die Vorschläge.

Eigene Shortcuts definieren

Du kannst die Belegung jederzeit anpassen. Wenn du zum Beispiel <CR> (Enter) zum Akzeptieren nutzen möchtest, änderst du in deiner blink.cmp-Konfiguration den Eintrag keymap:

keymap = { preset = 'enter' },

Oder du definierst komplett eigene Kombinationen, indem du ein preset = 'none' setzt und die Tasten selbst belegst .

Beispiel:

-- ~/.config/nvim/lua/plugins/completion.lua
return {
  {
    'saghen/blink.cmp',
    dependencies = { 'rafamadriz/friendly-snippets' },
    version = '1.*',
    opts = {
      keymap = { preset = 'enter' }, -- Hier wird das Preset gewählt
      -- ... restliche Optionen wie appearance, sources, fuzzy
    },
  },
}

Installation Script für Neovim, Rust und Plugins unter Manjaro

Für Ungeduldige mit Risikobereitschaft: Hier ist ein vollständiges Bash-Skript, das alle Schritte aus deinem Leitfaden automatisiert. Es installiert Neovim, Rust (via Rustup), die Rust-Komponenten und richtet die komplette Neovim-Konfiguration mit lazy.nvim, rustaceanvim und blink.cmp ein.

#!/usr/bin/env bash
### ### install_neovim_rust.sh
### Installiert Neovim, Rust (Rustup) und richtet die Neovim-Konfiguration
### mit lazy.nvim, rustaceanvim und blink.cmp unter Manjaro ein.
### ### Autor: hoergen (Vorlage), automatisiert
### Datum: 2026-09-22
### 
set -euo pipefail

### ------------------------------------------------------------------
### Farben für Ausgaben
### ------------------------------------------------------------------
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
NC='\033[0m' # No Color

info()  { echo -e "${GREEN}[INFO]${NC}  $*"; }
warn()  { echo -e "${YELLOW}[WARN]${NC}  $*"; }
error() { echo -e "${RED}[ERROR]${NC} $*" >&2; }

### ------------------------------------------------------------------
### 0. Voraussetzungen prüfen
### ------------------------------------------------------------------
if [[ $EUID -eq 0 ]]; then
  error "Bitte NICHT als root ausführen. Das Skript nutzt sudo wo nötig."
  exit 1
fi

if ! command -v pacman &>/dev/null; then
  error "pacman nicht gefunden. Dieses Skript ist für Manjaro/Arch gedacht."
  exit 1
fi

### ------------------------------------------------------------------
### 1. System aktualisieren und Neovim + Lua installieren
### ------------------------------------------------------------------
info "Aktualisiere Paketdatenbank und System ..."
sudo pacman -Syu --noconfirm

info "Installiere Neovim, Lua 5.1, git, base-devel und rustup ..."
sudo pacman -S --noconfirm --needed \
  neovim \
  lua51 \
  git \
  base-devel \
  rustup

### ------------------------------------------------------------------
### 2. Rust-Toolchain aktivieren
### ------------------------------------------------------------------
info "Aktiviere Rust stable Toolchain ..."
if ! rustup toolchain list | grep -q '^stable'; then
  rustup default stable
else
  info "stable Toolchain ist bereits aktiv."
fi

### ------------------------------------------------------------------
### 3. Rust-Komponenten installieren
### ------------------------------------------------------------------
info "Installiere Rust-Komponenten: rustfmt, clippy, rust-analyzer ..."
rustup component add rustfmt   || warn "rustfmt konnte nicht installiert werden."
rustup component add clippy    || warn "clippy konnte nicht installiert werden."
rustup component add rust-analyzer || warn "rust-analyzer (rustup) konnte nicht installiert werden."

### Fallback: rust-analyzer aus den Repos, falls der rustup-Aufruf nicht klappt.
if ! command -v rust-analyzer &>/dev/null; then
  warn "rust-analyzer nicht im PATH gefunden. Installiere aus den Repos ..."
  sudo pacman -S --noconfirm --needed rust-analyzer
fi

### ------------------------------------------------------------------
### 4. Versionen prüfen
### ------------------------------------------------------------------
info "Überprüfe Installationen ..."
nvim --version | head -n 1
rustc --version
cargo --version
rust-analyzer --version 2>/dev/null || warn "rust-analyzer --version nicht verfügbar."

### ------------------------------------------------------------------
### 5. Neovim-Konfigurationsverzeichnis anlegen
### ------------------------------------------------------------------
NVIM_CONFIG="$HOME/.config/nvim"
NVIM_LUA="$NVIM_CONFIG/lua"
NVIM_PLUGINS="$NVIM_LUA/plugins"

info "Lege Neovim-Konfigurationsverzeichnisse an ..."
mkdir -p "$NVIM_CONFIG"
mkdir -p "$NVIM_LUA/config"
mkdir -p "$NVIM_PLUGINS"

### ------------------------------------------------------------------
### 6. init.lua erstellen
### ------------------------------------------------------------------
info "Erstelle $NVIM_CONFIG/init.lua ..."
cat > "$NVIM_CONFIG/init.lua" <<'EOF'
require("config.lazy")
EOF

### ------------------------------------------------------------------
### 7. Plugin-Init (leer, damit lazy.nvim keine Fehler wirft)
### ------------------------------------------------------------------
info "Erstelle $NVIM_PLUGINS/init.lua ..."
cat > "$NVIM_PLUGINS/init.lua" <<'EOF'
return {}
EOF

### ------------------------------------------------------------------
### 8. lazy.lua Bootstrap-Datei erstellen
### ------------------------------------------------------------------
info "Erstelle $NVIM_LUA/config/lazy.lua ..."
cat > "$NVIM_LUA/config/lazy.lua" <<'EOF'
-- ~/.config/nvim/lua/config/lazy.lua

-- Bootstrap lazy.nvim
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not (vim.uv or vim.loop).fs_stat(lazypath) then
  local lazyrepo = "https://github.com/folke/lazy.nvim.git"
  local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
  if vim.v.shell_error ~= 0 then
    vim.api.nvim_echo({
      { "Failed to clone lazy.nvim:\n", "ErrorMsg" },
      { out, "WarningMsg" },
      { "\nPress any key to exit..." },
    }, true, {})
    vim.fn.getchar()
    os.exit(1)
  end
end
vim.opt.rtp:prepend(lazypath)

-- Leader-Tasten müssen vor lazy.nvim gesetzt werden
vim.g.mapleader = " "
vim.g.maplocalleader = "\\"

-- lazy.nvim Setup
require("lazy").setup({
  spec = {
    { import = "plugins" },
  },

  -- LuaRocks-Unterstützung mit hererocks
  rocks = {
    enabled = true,
    hererocks = true,
  },

  -- Farbschema beim Installieren
  install = { colorscheme = { "habamax" } },

  -- Automatische Update-Prüfung
  checker = { enabled = true },

  -- Performance
  performance = {
    rtp = {
      disabled_plugins = {
        "gzip",
        "matchit",
        "matchparen",
        "netrwPlugin",
        "tarPlugin",
        "tohtml",
        "tutor",
        "zipPlugin",
      },
    },
  },
})
EOF

### ------------------------------------------------------------------
### 9. rustaceanvim Plugin-Konfiguration
### ------------------------------------------------------------------
info "Erstelle $NVIM_PLUGINS/rust.lua ..."
cat > "$NVIM_PLUGINS/rust.lua" <<'EOF'
-- ~/.config/nvim/lua/plugins/rust.lua
return {
  {
    "mrcjkb/rustaceanvim",
    version = "^9", -- Version 9 für aktuelle Neovim-Versionen
    lazy = false,   -- Wichtig: Lädt das Plugin sofort
  },
}
EOF

### ------------------------------------------------------------------
### 10. blink.cmp Plugin-Konfiguration
### ------------------------------------------------------------------
info "Erstelle $NVIM_PLUGINS/completion.lua ..."
cat > "$NVIM_PLUGINS/completion.lua" <<'EOF'
-- ~/.config/nvim/lua/plugins/completion.lua
return {
  {
    'saghen/blink.cmp',
    -- Optional: Stellt Snippets für die Snippet-Vervollständigung bereit
    dependencies = { 'rafamadriz/friendly-snippets' },

    -- Nutzt einen Release-Tag, um vorgebaute Binärdateien herunterzuladen.
    -- Das ist der empfohlene Weg für die beste Performance.
    version = '1.*',

    ---@module 'blink.cmp'
    ---@type blink.cmp.Config
    opts = {
      -- 'default' verwendet Tastenkürzel, die denen der eingebauten
      -- Vervollständigung ähneln (z.B. <C-y> zum Akzeptieren)
      keymap = { preset = 'default' },

      appearance = {
        -- 'mono' für 'Nerd Font Mono', um Icons korrekt auszurichten
        nerd_font_variant = 'mono'
      },

      -- Standardmäßig werden Vorschläge von LSP, Dateipfaden,
      -- Snippets und dem aktuellen Buffer verwendet.
      sources = {
        default = { 'lsp', 'path', 'snippets', 'buffer' },
      },

      -- Nutzt die Rust-Implementierung für den Fuzzy-Matcher (schneller),
      -- fällt aber automatisch auf die Lua-Implementierung zurück.
      fuzzy = { implementation = "prefer_rust_with_warning" }
    },
    opts_extend = { "sources.default" }
  }
}
EOF

### ------------------------------------------------------------------
### 11. Plugins headless installieren (lazy.nvim sync)
### ------------------------------------------------------------------
info "Installiere Plugins über lazy.nvim (headless) ..."
if nvim --headless "+Lazy! sync" +qa 2>/dev/null; then
  info "Plugins erfolgreich synchronisiert."
else
  warn "Headless-Sync fehlgeschlagen. Bitte Neovim manuell starten und ':Lazy sync' ausführen."
fi

### ------------------------------------------------------------------
### 12. Fertig
### ------------------------------------------------------------------
info "Fertig! Zusammenfassung:"
echo "  - Neovim-Version:       $(nvim --version | head -n 1)"
echo "  - Rust-Version:         $(rustc --version)"
echo "  - Cargo-Version:        $(cargo --version)"
echo "  - rust-analyzer:        $(rust-analyzer --version 2>/dev/null || echo 'nicht verfügbar')"
echo "  - Neovim-Konfig:        $NVIM_CONFIG"
echo
info "Starte Neovim mit 'nvim' und prüfe mit ':Lazy', ob alle Plugins installiert sind."
info "Öffne eine .rs-Datei, um rustaceanvim und rust-analyzer zu testen."

Verwendung

Datei speichern als z. B. install_neovim_rust.sh.
Ausführbar machen:
```
chmod +x install_neovim_rust.sh
```
Starten (nicht als root):
```
./install_neovim_rust.sh
```

Was das Skript macht

Schritt	Aktion
1	System-Update via `pacman -Syu`
2	Installation von `neovim`, `lua51`, `git`, `base-devel`, `rustup`
3	Aktivierung der Rust-`stable`-Toolchain
4	Hinzufügen von `rustfmt`, `clippy`, `rust-analyzer`
5	Fallback: `rust-analyzer` aus den Repos, falls rustup-Version nicht im PATH
6	Anlegen der Verzeichnisse `~/.config/nvim/lua/{config,plugins}`
7	Erstellen von `init.lua` mit `require("config.lazy")`
8	Erstellen der leeren `plugins/init.lua`
9	Erstellen der `config/lazy.lua` (Bootstrap + Setup)
10	Erstellen der `plugins/rust.lua` (rustaceanvim)
11	Erstellen der `plugins/completion.lua` (blink.cmp, Preset `default`)
12	Headless-Installation der Plugins via `nvim --headless "+Lazy! sync" +qa`

Hinweise

Das Skript verwendet bewusst das default-Preset für blink.cmp. Die Custom-Shortcuts (z. B. super-tab oder enter) sind nicht enthalten – du kannst sie später in ~/.config/nvim/lua/plugins/completion.lua anpassen.
rust-analyzer wird zuerst über rustup installiert. Falls das fehlschlägt oder der Befehl nicht im PATH landet, wird automatisch das Paket aus den Manjaro-Repos nachinstalliert.
Die Plugin-Installation läuft headless. Sollte das fehlschlagen, kannst du Neovim einfach normal starten und :Lazy sync ausführen.

Installation NeoVim in Manjaro#

Installation Rust#

Was ist Rustup - Toolchain#

Vorteil von Rustup#

Mehrere Toolchains parallel#

Projektbezogene Versionen#

Pinning auf exakte Versionen#

Komponenten nachinstallieren#

Target-Unterstützung#

Updates#

Vorteil einer Toolchain#

Warum das wichtig ist#

Kanal statt Version#

Vergleich: Rustup vs. Paketmanager#

Wann reicht der Paketmanager?#

Rustup installieren#

Entwicklungswerkzeuge#

Rust Installation testen#

NeoVim 4 Rust#

LSP - Language Server rust-analyzer#

Neovim Konfiguration#

Plugin blink.cmp - autocompletion#

Installation#

Shortcuts#

Presets#

Die wichtigsten Presets im Überblick#

Gemeinsame Tasten in allen Presets#

Die wichtigsten Presets im Vergleich#

Weitere nützliche Standard-Shortcuts#

Shortcuts in der Kommandozeile (cmdline)#

Eigene Shortcuts definieren#

Installation Script für Neovim, Rust und Plugins unter Manjaro#

Verwendung#

Was das Skript macht#

Hinweise#