Installation und erste Schritte zum eigenen Programm.

Für die Entwicklung mit Rust unter Linux haben sich verschiedene Programme etabliert, die sich jedoch durch dem Funktionsumfang, Performance und Einrichtungsaufwand unterscheiden. Ich habe mich fuer den Editor „Zed“ entschieden. Es ist ein vergleichsweise neuer Editor, der selbst auch in Rust geschrieben wurde und nativ unter Linux (X11 und Wayland) funktioniert.

・Setup: rust-analyzer und grundlegende Rust Unterstützung sind direkt integriert; viele Funktionen stehen ohne langes Konfigurieren bereit.

・Vorteile: Extrem schnell, minimale Latenz beim Tippen (GPU-beschleunigt) und sehr geringer Speicherbedarf.

・Nachteile: Das Plugin-Ökosystem ist noch kleiner als bei VS Code, und komplexe Debugging-Workflows sind weniger ausgereift.

1. Installation unter CachyOS

CachyOS stellt ein optimiertes Paket direkt in seinen eigenen extra-Repositories bereit.

1. Zed und die Rust-Toolchain installieren:Öffne dein Terminal (z. B. Konsole) und führe folgenden Befehl aus:
   
   Bash
   sudo pacman -S zed rustup lldb
   
   (Hinweis: lldb wird als Backend für das Debugging von Rust-Apps in Zed benötigt).Verifizierung: Gib zed --version ein – es sollte die installierte Versionsnummer ausgegeben werden.
   
2. Rust-Komponenten einrichten:Initialisiere die Toolchain und den Language Server (rust-analyzer), damit Zed Autovervollständigung und Typen-Prüfung nutzen kann:
   
   Bash
   rustup default stable rustup component add rust-analyzer clippy rustfmt
   
   Verifizierung: rust-analyzer --version gibt einen gültigen Versionsstring ohne Fehlermeldung aus.

2. Empfohlene Plugins (Extensions) für Linux-App-Entwicklung

Zed bringt Syntax-Highlighting (Tree-sitter), Git-Integration, Terminal und LSP-Unterstützung bereits ohne Plugins mit. Öffne die Erweiterungsübersicht in Zed mit Strg + Shift + X (oder über Strg + Shift + P -> zed: extensions) und installiere folgende Ergänzungen:

• TOML: Unverzichtbar für die saubere Bearbeitung und Syntax-Hervorhebung deiner Cargo.toml und Konfigurationsdateien.
• CargoTom: Bietet Autovervollständigung für Crate-Namen, aktuelle Versionsnummern und verfügbare Feature-Flags direkt in der Cargo.toml.
• C / C++ (Optional, aber wichtig für Linux-GUI): Wenn du eine native Linux-App mit Toolkits wie GTK4 (gtk4-rs), Iced, Slint oder Tauri baust, bindest du oft C-Systembibliotheken (pkg-config, Header-Dateien) ein. Dieses Plugin hilft, falls du C-Header oder Bindings inspizieren musst.
• Slint (Falls du Slint als GUI-Framework wählst): Offizielle Unterstützung für .slint-UI-Dateien inklusive Live-Vorschau.
• Dockerfile / Compose: Praktisch, falls du deine Linux-App später in Containern (z. B. für verschiedene Distributionen) testen möchtest.
• Catppuccin / Breeze / One Dark (Themes): Falls du das Erscheinungsbild von Zed optisch an dein KDE-Plasma-Desktop-Theme anpassen willst.

3. Empfohlene settings.json Anpassung für Rust

Drücke in Zed Strg + ,, um deine Konfigurationsdatei (~/.config/zed/settings.json) zu öffnen, und füge diesen Block hinzu, damit Clippy (der Rust-Linter) beim Speichern automatisch prüft:

JSON

{
  "format_on_save": "on",
  "inlay_hints": {
    "enabled": true
  },
  "lsp": {
    "rust-analyzer": {
      "initialization_options": {
        "check": {
          "command": "clippy"
        }
      }
    }
  }
}

Pruefen, ob rust-analyzer im System vorhanden ist

Öffne dein Terminal und teste, ob der Analyzer global erreichbar ist:

Bash

rust-analyzer --version

• Erfolgskriterien: Es wird eine Versionsnummer (z. B. rust-analyzer 1.xx.x) ausgegeben.
• Falls ein Fehler kommt: Installiere die Komponente nach:Bashrustup component add rust-analyzer

Alternative: Direkt aus den CachyOS-Repos installieren (Optional)

Falls du rustup nicht nutzt oder den Analyzer systemweit haben möchtest, kannst du ihn direkt über den Arch-Paketmanager pacman installieren (dieser legt ihn automatisch in /usr/bin/ ab, wo Fish ihn sofort findet):

Bash

sudo pacman -S rust-analyzer

Nächster Schritt, um es in Zed zu verifizieren:

1. Öffne ein neues Terminal und starte Zed direkt über die Konsole, um sicherzustellen, dass es die Umgebung übernimmt:
   
   Bash
   
   zededitor &
   
   
2. Öffne in Zed dein Rust-Projektverzeichnis (wichtig: den Ordner mit der Cargo.toml, nicht nur die .rs-Datei).
3. Schau unten links auf die Statusleiste von Zed – dort sollte nun der rust-analyzer einspringen, Symbole wie cargo check ausführen und das Indexieren starten.

Kurzer Funktions-Check in Zed

Um sicherzugehen, dass der rust-analyzer jetzt aktiv ist und deine settings.json-Einstellungen (wie Clippy) greifen:

Auf dem Screenshot der Zed-Statusleiste sieht alles genau richtig aus:

• Häkchen-Symbol (✓) links: Der Language Server (rust-analyzer) ist aktiv, hat dein Projekt erfolgreich geladen und meldet keine Fehler.
• Käfer-Symbol (Debugger) rechts: Das Debugging-Backend ist einsatzbereit.

Nächster Schritt: Das passende GUI-Framework wählen

Da du eine Linux-App entwickeln möchtest und unter KDE Plasma arbeitest, stehen dir vier bewährte Rust-Frameworks zur Auswahl:

1. Iced: Reines Rust-Framework (inspiriert von Elm), sehr beliebt für moderne Linux-Desktop-Apps (u. a. Basis für den neuen COSMIC-Desktop von System76) – keine C-Abhängigkeiten nötig.
2. Slint: Deklarative UI-Sprache (.slint-Dateien) mit Live-Vorschau, ideal für flüssige, moderne Oberflächen und native System-Styles.
3. gtk4-rs (mit Relm4): Perfekt, wenn du klassische GNOME/GTK-Apps mit nativer Linux-Integration bauen willst.
4. Tauri: Nutzt Web-Technologien (HTML/CSS/JS) für das Frontend und Rust für das Backend – sehr ressourcenschonend im Vergleich zu Electron.

Ich habe mich für „Iced“ entschieden.

Neues Cargo-Projekt erstellen

Öffne dein Terminal und erstelle ein neues binäres Rust-Projekt:

Bash

cargo new iced_demo --bin
cd iced_demo

Die Cargo.toml anpassen

Öffne die Cargo.toml in Zed und füge die Abhängigkeit für iced hinzu:

Ini, TOML

[package]
name = "iced_demo"
version = "0.1.0"
edition = "2021"

[dependencies]
iced = "0.13" # Verwendet die stabile aktuelle Iced-Version

(Hinweis: Speichere die Datei, woraufhin der rust-analyzer im Hintergrund die Abhängigkeiten lädt.)

Den Code in src/main.rs einfügen

Ersetze den Inhalt von src/main.rs mit folgendem minimalistischen, aber vollständigen Code, der das sogenannte Elm-Architektur-Muster (State, Message, Update, View) von Iced nutzt:

Rust

use iced::widget::{button, column, text};
use iced::Element;

pub fn main() -> iced::Result {
    iced::application("Iced Linux Demo", Counter::update, Counter::view)
        .run_with(Counter::new)
}

struct Counter {
    value: i32,
}

#[derive(Debug, Clone, Copy)]
enum Message {
    IncrementPressed,
    DecrementPressed,
}

impl Counter {
    fn new() -> (Self, iced::Task<Message>) {
        (Self { value: 0 }, iced::Task::none())
    }

    fn update(&mut self, message: Message) {
        match message {
            Message::IncrementPressed => {
                self.value += 1;
            }
            Message::DecrementPressed => {
                self.value -= 1;
            }
        }
    }

    fn view(&self) -> Element<'_, Message> {
        column![
            button("Erhöhen (+)").on_press(Message::IncrementPressed),
            text(format!("Aktueller Wert: {}", self.value)).size(30),
            button("Verringern (-)").on_press(Message::DecrementPressed),
        ]
        .padding(20)
        .spacing(10)
        .into()
    }
}

Das Projekt kompilieren und starten

Baue und starte die Anwendung direkt über das Terminal:

Bash

cargo run

Das Fenster öffnet sich, rendert sauber unter Wayland/X11 und reagiert direkt auf Klicks. Der rust-analyzer in Zed zeigt dir währenddessen alle Typen und Signaturen an.

Nützliche Tastenkombinationen auf einen Blick

Fertig 🙂 Glückwunsch