---
title: CachyOS FAQ & Fehlerbehebungs-Leitfaden
description: Häufig gestellte Fragen und Tipps
tableOfContents:
  minHeadingLevel: 1
  maxHeadingLevel: 5
---

import ImageComponent from '~/components/image-component.astro';
import { Steps, Tabs, TabItem } from '@astrojs/starlight/components';

:::note
Die folgenden Fragen & Antworten gelten für CachyOS und Arch-basierte Distributionen.

**Dies soll die Informationen im Arch Linux Wiki nicht ersetzen.**
:::

:::tip
Bleibe up-to-date mit allen offiziellen Ankündigungen von CachyOS in unserem [Forum](https://discuss.cachyos.org/c/announcements/5), Reddit-Posts in unserem [offiziellen Subreddit](https://www.reddit.com/r/cachyos/) oder auf [Discord in #announcements](https://discord.com/channels/862292009423470592/873309651364610118) und [#updates-repo](https://discord.com/channels/862292009423470592/871739561364033566) bezüglich bekannter Probleme mit einem Paket oder Updates, die einen manuellen Eingriff erfordern.
:::

## Wie du ein Problem oder einen Bug an CachyOS meldest

:::danger
Sei vorsichtig, wenn du dich auf Hilfe und Befehle von einem KI-Modell (wie ChatGPT) verlässt, ohne die Informationen aus offiziellen Quellen zu überprüfen. KI-Modelle können manchmal falsche oder irreführende Informationen liefern, besonders in technischen Zusammenhängen. Vergleiche immer mit vertrauenswürdiger Dokumentation oder Community-Ressourcen.

Sonst könntest du am Ende ein komplett kaputtes System haben oder das Problem noch schlimmer machen.
:::

:::tip
Denk dran. In der Linux-Welt gibt es ein fantastisches Zitat: "Höchstwahrscheinlich hatte schon mal jemand vor dir dasselbe Problem." Also nutze bitte die Suchfunktion bei Google, im Arch Wiki oder im CachyOS Forum/Discord, bevor du ein Problem meldest, denn es könnte bereits gelöst sein.
:::

:::tip
Vergiss nicht, den Befehl tldr zu verwenden, um eine vereinfachte Version der Manpages für Befehle anzusehen, mit denen du nicht vertraut bist. Beispiel:

Einige der häufigsten Befehle und Beschreibungen für git:
```bash
tldr git
```

Du kannst tldr auch mit einem spezifischen git-Befehl kombinieren, um detailliertere Informationen über einen Parameter zu erhalten, zum Beispiel:
```bash
tldr git add
```
:::

### Orte zum Melden

- [Github](https://github.com/CachyOS/distribution)
- [Forum](https://discuss.cachyos.org/c/feedback/bugreports/10)
- **Discord:** [Support Forum](https://discord.com/channels/862292009423470592/1400865136373403708)
  - Bevor du einen neuen Beitrag erstellst, lies dir bitte die [support-guidelines](https://discord.com/channels/862292009423470592/1522310323250397274) durch, die im Kanal angepinnt sind.
    - Oder wenn du denkst, dein Problem kann schnell gelöst werden, nutze den [#support-Kanal](https://discord.com/channels/862292009423470592/862294383470051348)
- [Reddit](https://www.reddit.com/r/cachyos/)

### Sei geduldig und respektvoll

Das CachyOS-Team und die Community sind Freiwillige, die in ihrer Freizeit daran arbeiten. Bitte sei geduldig und respektvoll, wenn du mit ihnen interagierst. Einen qualitativ hochwertigen Bug-Report bereitzustellen, ist der beste Weg, damit dein Problem schnell gelöst wird.

Wenn du eine vage Frage stellst oder unzureichende Informationen gibst, bekommst du vielleicht auch eine vage Antwort oder gar keine.

Hier ist ein Beispiel:

- **Gute Frage:**
  - Nach einem kürzlichen Update (mein letztes Update war am DATUM), bootet mein System nicht mehr und zeigt einen schwarzen Bildschirm. Ich habe eine NVIDIA-GPU (Modell). Ich habe versucht, das `linux-cachyos`-Paket auf die vorherige Version downzugraden, aber das Problem besteht weiterhin. Hier ist die Ausgabe von `journalctl -b -1` und `dmesg` aus der Live-Umgebung.
- **Schlechte oder vage Frage:**
  - Mein System ist kaputt, bitte helft mir.
  <details>
  <summary>Sonst siehst du am Ende vielleicht aus wie Abraham aus diesem Meme:</summary>
   <ImageComponent imgsrc={import('~/assets/images/abraham-meme.jpg')} />
  </details>

### Beschreibe dein Problem

Hier sind ein paar Dinge, die du dich fragen solltest:

- Was funktioniert nicht?
- Behebt das Downgraden von Paket X das Problem?
- Erleben andere Leute dieses Problem / wurde es vorher schon gelöst? (nutze die Suchfunktion)
- Trat das Problem nach einem Update auf?
- Hast du selbst Änderungen vorgenommen?
  - Beispiel: Ein zusätzliches Flag in einer Modprobe-Datei hinzugefügt
- Ist es hardwarebedingt? (z.B. GPU, WLAN)
- Ist es softwarebedingt? (z.B. eine bestimmte Anwendung, Desktop-Umgebung)
- Ist es eine frische Installation oder trat das Problem nach einiger Nutzungszeit auf?

## Wie du Protokolle (Logs) sammelst

Es gibt viele Wege, Protokolle von deinem System zu sammeln. Hier sind ein paar Beispiele und Werkzeuge, die du nutzen kannst:

### Einen allgemeinen Bug-Report erstellen
CachyOS bietet ein großartiges Werkzeug zum Sammeln von Systemprotokollen namens `cachyos-bugreport.sh`.
Dieses Werkzeug sammelt Protokolle von:
    - `dmesg`
    - `journalctl`
    - `inxi` (Um Hardware-Informationen zu sammeln)

Wenn die Protokolle gesammelt sind, wirst du gefragt, ob du sie auf unsere Paste-Webseite hochladen möchtest.

Führe den folgenden Befehl im Terminal aus und teile den generierten Link in deinem Report:
    ```sh
    sudo cachyos-bugreport.sh
    ```

### Protokolle von einem Programm sammeln, das nicht startet
Es gibt viele Gründe, warum ein grafisches Programm nicht starten könnte. Der beste Weg, Protokolle für diese Art von Problem zu sammeln, ist, das Programm von einem Terminal aus zu starten. Auf diese Weise kannst du alle Fehlermeldungen oder Ausgaben sehen, die bei der Diagnose des Problems helfen könnten.

Zum Beispiel, wenn Firefox nicht vollständig startet, versuche es vom Terminal aus zu starten und achte auf Fehlermeldungen:
    ```sh
    firefox
    ```

    :::tip
    Wenn du die Ausgabe zur einfacheren Weitergabe in eine Textdatei speichern möchtest, kannst du die Ausgabe so umleiten:
    ```sh
    firefox &> firefox-log.txt
    ```
    Denk daran, `STRG + C` zu drücken, um den Prozess zu beenden, nachdem er nicht gestartet ist, damit das Terminal die Ausgabe in die Datei schreibt.
    :::

### Die zuletzt aktualisierten Pakete in pacman überprüfen.

Um eine Liste der zuletzt aktualisierten Pakete auf deinem System zu erhalten, kannst du den folgenden Befehl verwenden:

```bash
grep "\[ALPM\] upgraded" /var/log/pacman.log | tail -n 50
```

:::tip
Passe den `-n`-Parameter von tail an, um mehr oder weniger Zeilen zu erhalten.
:::

### Tastenkürzel zum Navigieren in journalctl und dmesg

Die gängigsten Tastenkürzel zum Navigieren durch die Protokolle, wenn less oder der für Menschen lesbare Modus verwendet wird:

`Pfeiltasten oder J & K`: um zeilenweise nach oben oder unten zu scrollen.

`Bild auf & Bild ab oder Strg + B/D`: um seitenweise nach oben oder unten zu scrollen.

`G oder Pos1`: um zum Anfang des Protokolls zu springen.

`Umschalt + G oder Ende`: um zum Ende des Protokolls zu springen.

### journalctl zum Sammeln von Systemprotokollen verwenden

Der `journalctl`-Befehl ist ein extrem nützliches Werkzeug zum Anzeigen von Systemprotokollen. Hier sind einige der gebräuchlichsten und nützlichsten Befehlskombinationen.

#### Grundlegende Nutzung und gängige Beispiele

:::tip
Kombiniere mehrere Optionen für eine spezifischere Filterung.
:::

<details>
<summary>Das gesamte Protokoll anzeigen (von ältesten zu neuesten):</summary>
```bash
journalctl
```
</details>

<details>
<summary>Protokolle nur vom aktuellen Bootvorgang anzeigen:</summary>
```bash
journalctl -b
```
</details>

<details>
<summary>Sicherheits- und Authentifizierungsprobleme:</summary>
```bash
journalctl -u sshd -u polkit -b -0 | grep -i "fail\|error\|denied"
```
Suche nach Authentifizierungsfehlern und Ablehnungen von Sicherheitsrichtlinien.
</details>

<details>
<summary>Protokolle in Echtzeit verfolgen:</summary>
```bash
journalctl -f
```
:::tip
Kombiniere dies mit anderen Filtern. Zum Beispiel:
```bash
# Protokolle vom Adguard Home-Dienst verfolgen:
journalctl -u adguardhome -f
```
:::
</details>

<details>
<summary>Audioprobleme vom aktuellen Bootvorgang:</summary>
```bash
journalctl --user -u pipewire -u pipewire-pulse -u wireplumber -b 0
```
Protokolle von Audio-Diensten anzeigen, um Soundprobleme zu beheben.
</details>

<details>
<summary>Speicher- (RAM) Fehler:</summary>
```bash
journalctl -k | grep -i "memory\|ram"
```
Suche nach Speicherbeschädigung oder Erkennungsproblemen.
</details>

<details>
<summary>Bluetooth-bezogene Probleme:</summary>
```bash
# Vom aktuellen Bootvorgang:
journalctl -u bluetooth -b 0
# Vom vorherigen Bootvorgang:
journalctl -u bluetooth -b -1
```
</details>

##### Zeitbasierte Filterung
<details>

<summary>Protokolle der letzten paar Minuten/Stunden anzeigen:</summary>
```bash
journalctl --since "10 minutes ago"
journalctl --since "1 hour ago"
journalctl --since "2024-01-15 14:30:00"
```
</details>

<details>
<summary>Protokolle aus einem bestimmten Zeitraum anzeigen:</summary>
```bash
journalctl --since "09:00" --until "10:00"
```
</details>

##### Filtern nach Priorität und Dienst oder Programm

Mögliche Prioritätsstufen sind: `debug`, `info`, `notice`, `warning`, `err`, `crit`, `alert`, `emerg`.

Oder durch die Verwendung von Zahlen:

`0` entspricht `emerg`

`1` entspricht `alert`

`2` entspricht `crit`

`3` entspricht `err`

`4` entspricht `warning`

`5` entspricht `notice`

`6` entspricht `info`

und `7` entspricht `debug`.

<details>
<summary>Nur Fehler-, kritische und Notfallmeldungen anzeigen:</summary>
```bash
journalctl -p err..emerg
```
:::tip
Du kannst diese mit den vorherigen Beispielen kombinieren:

Beispiel:
```bash
journalctl -p err..emerg --since "9:00" --until "10:00"
```
:::
</details>

<details>
<summary>Protokolle von einem bestimmten Systemdienst anzeigen:</summary>
```bash title='Beispiele'
# Protokolle vom NetworkManager-Dienst anzeigen:
journalctl -u NetworkManager
# Protokolle vom GDM (GNOME Display Manager)-Dienst anzeigen:
journalctl -u gdm
# Protokolle vom SDDM (Simple Desktop Display Manager)-Dienst anzeigen:
journalctl -u sddm
```
</details>

<details>
<summary>Protokolle von einer bestimmten Prozess-ID (PID) anzeigen:</summary>
```bash
journalctl _PID=pid
# Beispiel:
journalctl _PID=3344
```
</details>

<details>
<summary>Protokolle von einer bestimmten ausführbaren Datei anzeigen:</summary>
```bash
journalctl pfad/zur/ausführbaren/datei
# Beispiel:
journalctl /usr/bin/firefox
```
</details>

### Kernel-Meldungen mit journalctl überprüfen

:::note
Wann du `journalctl -k` statt `dmesg` verwenden solltest:

- `journalctl -k` greift auf Kernel-Meldungen zu, die im systemd-Journal gespeichert sind (kann über Neustarts hinweg persistent sein, wenn konfiguriert, und bietet eine bessere Integration mit zeitbasierten Filtern und Journal-Funktionen).
- `dmesg` liest den aktuellen Kernel-Ringpuffer aus (flüchtig, geht nach einem Neustart verloren).
:::

<details>
<summary>Einfache Ansicht der Kernel-Meldungen:</summary>
```bash
journalctl -k
```
Zeigt alle Kernel-Meldungen aus dem Journal an, äquivalent zu `dmesg`, aber aus der Perspektive des Journals.
</details>

<details>
<summary>Nur Kernel-Meldungen des aktuellen Systemstarts:</summary>
```bash
journalctl -k -b 0
```
Zeigt nur die Kernel-Meldungen der aktuellen Boot-Sitzung an.
</details>

<details>
<summary>Kernel-Meldungen des vorherigen Systemstarts:</summary>
```bash
journalctl -k -b -1
```
Sieh dir die Kernel-Meldungen des letzten Systemstarts an. Nützlich zur Diagnose von Boot-Fehlern oder Abstürzen.
</details>

<details>
<summary>Neue Kernel-Meldungen in Echtzeit verfolgen:</summary>
```bash
journalctl -k -f
```
Beobachte Kernel-Meldungen, während sie auftreten. Super, um Hardware-Ereignisse oder das Laden von Treibern zu überwachen.
</details>

<details>
<summary>Nach bestimmten Treiber-Meldungen suchen:</summary>
```bash
# Beispiele:
# GPU-bezogene Meldungen:
journalctl -k | grep -i "nvidia\|amd\|intel"
# USB-Geräte-Meldungen:
journalctl -k | grep -i "usb\|pci"
```
</details>

<details>
<summary>Zeitbasiertes Filtern von Kernel-Meldungen:</summary>
```bash
journalctl -k --since "1 hour ago"
journalctl -k --since "09:00" --until "10:00"
```
Sieh dir Kernel-Meldungen aus bestimmten Zeiträumen an.
</details>

### dmesg für Kernel-Meldungen verwenden

Der `dmesg`-Befehl zeigt den Kernel-Ringpuffer an, der Meldungen des Kernels über Hardware-Erkennung, Treiber-Initialisierung und Systemereignisse enthält.

#### Grundlegende Nutzung und Formatierung

<details>
<summary>Den gesamten Kernel-Meldungspuffer ansehen:</summary>
```bash
dmesg
```
</details>

<details>
<summary>Mit lesbaren Zeitstempeln anzeigen:</summary>
```bash
dmesg -T
```
</details>

<details>
<summary>Zur leichteren Lesbarkeit in einem Pager anzeigen:</summary>
```bash
dmesg | less
```
</details>

#### Nach Prioritätslevel filtern

Ähnlich wie journalctl erlaubt auch dmesg das Filtern von Meldungen nach Prioritätslevel.

<details>
<summary>Nur Fehler und kritische Meldungen anzeigen:</summary>
```bash
dmesg -l err,crit,alert,emerg
```
Mögliche Prioritätslevel sind: `debug`, `info`, `notice`, `warning`, `err`, `crit`, `alert`, `emerg`.

Oder durch die Verwendung von Zahlen:

`0` entspricht `emerg`

`1` entspricht `alert`

`2` entspricht `crit`

`3` entspricht `err`

`4` entspricht `warning`

`5` entspricht `notice`

`6` entspricht `info`

und `7` entspricht `debug`.
</details>

<details>
<summary>Die neuesten Kernel-Meldungen ansehen:</summary>
```bash
dmesg -w
```
</details>

<details>
<summary>Nach bestimmten Hardware- oder Treiber-Meldungen suchen:</summary>
```bash
# Beispiele:
# Um nach USB-bezogenen Meldungen zu suchen:
dmesg | grep -i usb | less
# Bluetooth-Geräte:
dmesg | grep -i bluetooth
# NVIDIA-bezogen:
dmesg | grep -i nvidia | less
# Geräte, die nicht initialisiert werden können:
dmesg | grep -i "error\|failed" | less
```
</details>

##### Häufige Beispiele für spezifische Probleme mit dmesg

<details>
<summary>Wenn ein USB-Gerät nicht erkannt wird:</summary>
```bash
dmesg -w | grep -i usb
```
Stecke dann das Gerät ein und achte auf neue Meldungen.
</details>

<details>
<summary>Probleme bei der GPU-Initialisierung:</summary>
```bash
dmesg | grep -i "nvidia\|amd\|intel\|radeon\|drm\|gpu" | less
```
</details>

<details>
<summary>Probleme mit WLAN oder Netzwerkadaptern:</summary>
```bash
dmesg | grep -i "wlan\|wifi\|network\|firmware" | tail -20
```
Überprüfe, ob Firmware fehlt oder Treiberfehler verhindern, dass deine WLAN-Karte funktioniert.
</details>

<details>
<summary>Probleme bei der Erkennung von HDD/SSD:</summary>
```bash
dmesg | grep -i "sda\|sdb\|nvme\|scsi\|disk" | head -30
```
Verwende dies, wenn ein Speichergerät nicht erkannt wird oder beim Booten Fehler anzeigt.
</details>

<details>
<summary>Systemabstürze oder Kernel Panics:</summary>
```bash
dmesg -T -l emerg,alert,crit,err | tail -30
```
Überprüfe die schwerwiegendsten Kernel-Meldungen, die vor einem Systemabsturz oder -einfrieren aufgetreten sind.
</details>

<details>
<summary>Speicherfehler (RAM):</summary>
```bash
dmesg | grep -i "memory\|ram"
```
Suche nach Speicherbeschädigungen, Erkennungsproblemen oder ECC-Fehlerberichten.
</details>

<details>
<summary>Ereignisse von Audiogeräten:</summary>
```bash
dmesg | grep -i "audio\|snd\|hda" | grep -i "error\|fail\|card"
```
Überprüfe, ob deine Soundkarte korrekt erkannt wird und ob die Treiber richtig geladen werden.
</details>

<details>
<summary>Fehler beim Laden von Kernel-Modulen:</summary>
```bash
dmesg | grep -i "module\|init" | grep -i "error\|fail"
```
Wenn bestimmte Hardware-Treiber nicht geladen werden oder bei der Initialisierung fehlschlagen.
</details>

<details>
<summary>Echtzeit-Überwachung von Hardware-Ereignissen:</summary>
```bash
dmesg -w -l warn,err,crit,alert,emerg -T
```
Beobachte kontinuierlich neue, wichtige Kernel-Meldungen, während du ein Problem reproduzierst.
</details>

<details>
<summary>BIOS/UEFI- und Firmware-Probleme:</summary>
```bash
dmesg | grep -i "bios\|uefi\|firmware\|efi"
```
Überprüfe auf Kompatibilitätsprobleme zwischen deiner Hardware-Firmware und dem Linux-Kernel.
</details>

## Installation & Live-Umgebung

### Warum enthält das CachyOS Live-ISO nur KDE Plasma?

Wir haben uns entschieden, unsere Entwicklungs- und Wartungsbemühungen ausschließlich auf die KDE Plasma Desktop-Umgebung zu konzentrieren. Dies ermöglicht es uns, eine ausgefeiltere, stabilere und konsistentere Benutzererfahrung auf unserem Live-ISO zu liefern.

Die Live-Umgebung ist hauptsächlich für die Installation von CachyOS oder die Verwendung von cachy-chroot zur Systemwiederherstellung gedacht. Um andere Desktop-Umgebungen oder Fenstermanager sicher zu testen, empfehlen wir dir dringend, sie in einer virtuellen Maschine (VM) auszuprobieren.

### Warum dauert es so lange, bis der Installer startet, nachdem man auf "Installer starten" geklickt hat?

:::caution
Stell sicher, dass du eine aktive Internetverbindung hast, sonst passiert nichts, nachdem du auf diesen Button drückst.
:::

Der Installer ist nicht eingefroren. Er führt im Hintergrund ein notwendiges Skript aus, um dein System auf die Installation vorzubereiten. Dieser Prozess stellt sicher, dass die Schlüsselringe und die Uhrzeit deines Systems auf dem neuesten Stand sind, was hilft, häufige Installationsprobleme zu vermeiden.

[Sieh dir das Skript auf GitHub an](https://github.com/CachyOS/CachyOS-Live-ISO/blob/master/archiso/airootfs/usr/local/bin/calamares-online.sh), um besser zu verstehen, was es tut.
<Steps>
  1. Entfernt alte Schlüsselring-Dateien.
  2. Installiert und aktualisiert die neuesten Arch Linux & CachyOS Schlüsselring-Pakete.
  3. Initialisiert und füllt den Pacman-Schlüsselring.
  4. Aktiviert die Netzwerk-Zeitsynchronisation.
  5. Überprüft den Boot-Typ deines Systems (UEFI oder BIOS/MBR), um dich aufzufordern, einen Bootloader je nach Typ auszuwählen.
</Steps>

### Warum bleibt meine Installation bei 33% hängen?

Das passiert, wenn der Installer Schwierigkeiten hat, Pakete herunterzuladen. Es ist normalerweise ein Zeichen für eine sehr langsame oder instabile Internetverbindung. Bitte überprüfe deine Netzwerkverbindung und versuche es erneut.

## Bootloader-Wiederherstellung

:::note
Falls du die `/boot`-Partition gelöscht hast, erstell einfach eine neue. Folge dafür dem jeweiligen [Partitionsschema](/de/installation/installation_on_root#uefigpt) aus Schritt 5.
:::

### Schritte zur Wiederherstellung deines Bootloaders

:::tip
Wenn du dir unsicher bist, wie man `cachy-chroot` benutzt, schau dir bitte zuerst die Dokumentation zum [CachyOS chroot Helper](/de/features/cachy_chroot) an.
:::

<Steps>
    1. Boote in das CachyOS Live-ISO.
    2. Öffne ein Terminal und wechsle mit dem `cachy-chroot`-Befehl in dein installiertes System (chroot).

        ```bash
        sudo cachy-chroot
        ```
        Wenn dein System BTRFS mit unserer Voreinstellung verwendet, antworte mit `y` auf die Frage:
         ```bash title='Beispiel'
         Do you want to use CachyOS BTRFS preset to auto mount root subvolume? y
         Do you want to mount additional partitions? · yes
         Enter the mount point for additional partition (e.g. /boot) type 'skip' to cancel:
         # Gib /boot für systemd-boot, Limine oder rEFInd ein
         # Gib /boot/efi für GRUB ein
         ```
    3. Folge den Anweisungen unten für deinen installierten Bootloader und Systemtyp (UEFI oder MBR/BIOS).
        <Tabs>
            <TabItem label='GRUB'>
                Installiere GRUB mit dem folgenden Befehl neu:
                <Tabs>
                    <TabItem label='UEFI'>
                        ```bash
                        sudo grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=cachyos
                        ```
                    </TabItem>
                    <TabItem label='MBR/BIOS'>
                        ```bash
                        sudo grub-install --target=i386-pc /dev/sdX # Ersetze sdX durch deine Festplatte, z.B. sda
                        ```
                    </TabItem>
                </Tabs>
            </TabItem>
            <TabItem label='systemd-boot (nur UEFI)'>
                Installiere systemd-boot mit dem folgenden Befehl neu:
                ```bash
                sudo bootctl install
                ```
            </TabItem>
            <TabItem label='Limine'>
                Installiere Limine mit dem folgenden Befehl neu:
                <Tabs>
                    <TabItem label='UEFI'>
                        ```bash
                        sudo limine-install
                        ```
                    </TabItem>
                    <TabItem label='MBR/BIOS'>
                        ```bash
                        sudo limine bios-install /dev/sdX # Ersetze sdX durch deine Festplatte, z.B. sda
                        ```
                    </TabItem>
                </Tabs>
            </TabItem>
            <TabItem label='rEFInd (nur UEFI)'>
                Installiere rEFInd mit dem folgenden Befehl neu:
                ```bash
                sudo refind-install
                ```
            </TabItem>
        </Tabs>
    4. Installiere den CachyOS-Kernel neu:
        ```bash
        sudo pacman -Syu linux-cachyos linux-cachyos-headers
        ```
    5. Verlasse cachy-chroot:
        ```bash
        exit
        ```
    6. Starte dein System neu.
</Steps>

## Paketverwaltung & Updates

### Pacman-Fehlerbehebung

#### error: signature is invalid (Fehler: Signatur ist ungültig)

Dieser Fehler deutet auf ein Problem mit der kryptografischen Signatur eines Pakets hin. Er wird normalerweise durch einen veralteten Spiegelserver (Mirror) oder einen kaputten Schlüsselbund (Keyring) auf deinem System verursacht.

Obwohl sich die Spiegelserver oft nach kurzer Zeit von selbst beheben, solltest du eine der folgenden beiden Lösungen ausprobieren, wenn das Problem weiterhin besteht.

<Tabs>

<TabItem label='Erste Lösung: Pacman-Spiegelserver neu synchronisieren'>

```sh
sudo pacman -Syu
```

</TabItem>

<TabItem label='Zweite Lösung: Deine Spiegelserver bewerten'>

```sh title='Bewerte deine Spiegelserver'
sudo cachyos-rate-mirrors
```

</TabItem>

<TabItem label='Dritte Lösung: Schlüsselbunde zurücksetzen'>

Wenn das Bewerten deiner Spiegelserver nicht funktioniert, sind wahrscheinlich die Schlüsselbunde deines Systems kaputt.

- Öffne CachyOS Hello und navigiere zu **Troubleshooting**.
- Klicke auf den Button "Reset keyrings" (Schlüsselbunde zurücksetzen).

</TabItem>

</Tabs>

#### error: 404 Not Found (Fehler: 404 Nicht gefunden)

Dieser Fehler bedeutet, dass das Paket, das du installieren möchtest, auf deinem aktuellen Spiegelserver nicht verfügbar ist. Das passiert normalerweise, wenn deine lokale Paketdatenbank nicht mit den Remote-Repositorys synchron ist.

**Lösung:**

Führe den folgenden Befehl aus, um deine Paketdatenbank zu aktualisieren und ein vollständiges System-Upgrade durchzuführen. Dadurch wird sichergestellt, dass dein System über die neuesten verfügbaren Pakete informiert ist.

```sh
sudo pacman -Syu
# Versuche dann erneut, das gewünschte Paket zu installieren.
```

#### error: could not remove (Fehler: konnte nicht entfernen)

Dieser Fehler tritt auf, wenn der Pacman-Cache Dateien enthält, die das System nicht automatisch verwalten kann. Dies ist ein häufiges Problem, das sich leicht beheben lässt.

- Lösung 1: Benutze CachyOS Hello.
  - Der einfachste Weg, dies zu beheben, ist mit CachyOS Hello. Öffne es und gehe zu **Troubleshooting**, dann klicke auf den Button **Clear package cache** (Paket-Cache leeren).

- Lösung 2: Den Cache manuell entfernen.
  - Führe den folgenden Befehl aus, um alle verwaisten Pakete aus dem Cache zu entfernen.
  ```sh
  sudo rm -r /var/cache/pacman/pkg/*
  ```

#### error: File is corrupted (invalid or corrupted package (PGP signature)) (Fehler: Datei ist beschädigt (ungültiges oder beschädigtes Paket (PGP-Signatur)))

```sh
# Beispiel:
:: File /var/cache/pacman/pkg/python-charset-normalizer-3.4.0-1-any.pkg.tar.zst
is corrupted (invalid or corrupted package (PGP signature)).
```

Dieser Fehler deutet typischerweise auf ein Problem mit den Pacman-Schlüsselbunden deines Systems hin, die die Echtheit von Paketen überprüfen. Die folgenden Befehle setzen die Schlüsselbunde zurück und füllen sie neu, um das Problem zu lösen.

```sh
sudo rm -rf /etc/pacman.d/gnupg/
sudo pacman-key --init
sudo pacman-key --populate

sudo pacman-key --recv-keys F3B607488DB35A47 --keyserver keyserver.ubuntu.com
sudo pacman-key --lsign-key F3B607488DB35A47

sudo rm -R /var/lib/pacman/sync
```

Wenn das nicht klappt, liegt's nicht an deinem Schlüsselbund. Es könnte ein Problem mit deinen Spiegelservern geben, also such dir funktionierende Spiegelserver aus und leer dann deinen Cache, indem du Folgendes ausführst:

```sh
sudo cachyos-rate-mirrors
sudo pacman -Scc
```

#### error: unable to lock database (Fehler: Datenbank kann nicht gesperrt werden)

Dieser Fehler tritt auf, wenn bereits ein anderer Pacman-Prozess läuft, der die Datenbank sperrt, um eine Beschädigung zu verhindern. Wenn der vorherige Prozess abgestürzt oder unterbrochen wurde, wurde die Sperrdatei `db.lck` möglicherweise nicht entfernt.

- Lösung 1: Benutze CachyOS Hello
  - Der einfachste Weg, dies zu beheben, ist mit der Funktion **Remove db lock** (Datenbanksperre entfernen) im Tab **Troubleshooting** von CachyOS Hello.

- Lösung 2: Die Sperrdatei manuell entfernen
  - Wenn du CachyOS Hello lieber nicht benutzen möchtest, kannst du die Sperrdatei manuell entfernen:

```sh
sudo rm /var/lib/pacman/db.lck
```

#### error: failed retrieving file ... Connection timed out (Fehler: Datei konnte nicht abgerufen werden ... Zeitüberschreitung der Verbindung)

Du könntest Fehler wie diese sehen:

```text
# Beispiel-Fehler:
error: failed retrieving file '...' from ... : Connection timed out
error: failed retrieving file '...' from ... : Couldn't resolve host name
error: failed retrieving file '...' from ... : The requested URL returned error: 526
```

Diese Fehler deuten fast immer auf ein Problem mit deinen aktuellen Spiegelservern hin. Sie sind möglicherweise langsam, vorübergehend ausgefallen oder von deinem Standort aus nicht erreichbar.

- Lösung: Der beste Weg, dies zu beheben, ist, deine Spiegelliste mit schnelleren und zuverlässigeren Spiegelservern zu aktualisieren.

```sh
sudo cachyos-rate-mirrors
# Danach kannst du dein System aktualisieren mit:
sudo pacman -Syu
```

:::tip
Der Befehl `cachyos-rate-mirrors` testet verfügbare CachyOS-Spiegelserver basierend auf Geschwindigkeit und Synchronisierungsstatus und aktualisiert dann deine Spiegellistendatei (`/etc/pacman.d/cachyos-mirrorlist`) mit den leistungsstärksten.

Überlege, ihn regelmäßig auszuführen, besonders wenn du Verlangsamungen bei System-Updates bemerkst.
:::

#### warning: local is newer than... (Warnung: lokal ist neuer als...)

Diese Warnung erscheint, wenn eine Paketversion auf deinem System neuer ist als die Version, die in den offiziellen Repositories verfügbar ist. Das kann passieren, wenn ein Spiegelserver veraltet ist, ein Paket in den Repositories herabgestuft wurde oder ein Paket aus einer anderen Quelle installiert wurde.

- Lösung: Der Befehl `pacman -Syuu` führt ein vollständiges System-Upgrade durch und erlaubt Downgrades, was die Warnung behebt, indem es deine lokalen Pakete mit den Repository-Versionen synchronisiert.

```sh title='Um diese Warnungen zu entfernen, führe den folgenden Befehl aus:'
sudo pacman -Syuu
```

#### error: failed to commit transaction (conflicting files) (Fehler: Transaktion konnte nicht durchgeführt werden (konfligierende Dateien))

Dieser Fehler zeigt an, dass Pacman versucht, ein Paket zu installieren oder zu aktualisieren, das Dateien enthält, die bereits aus einer anderen Quelle auf deinem System vorhanden sind. Dies ist eine eingebaute Sicherheitsfunktion, um Systemschäden zu verhindern.

- Lösung: Du kannst dieses Problem lösen, indem du die in Konflikt stehenden Dateien manuell entfernst. Weitere Informationen und Lösungen findest du im [Arch Wiki](https://wiki.archlinux.org/title/Pacman#%22Failed_to_commit_transaction_(conflicting_files)%22_error).

```sh title='Beispiel'
error: failed to commit transaction (conflicting files)
nvidia-utils: /usr/lib/environment.d/10-gsk.conf exists in filesystem
Errors occurred, no packages were upgraded.
 -> error installing repo packages
```

Um dieses spezielle Beispiel zu beheben, würdest du die in Konflikt stehende Datei entfernen und dann deinen Update-Befehl erneut ausführen.

```sh
sudo rm /usr/lib/environment.d/10-gsk.conf
```

#### ERROR: module not found: 'nvidia', 'nvidia_modeset', ... (FEHLER: Modul nicht gefunden: 'nvidia', 'nvidia_modeset', ...)

```sh title='Beispiel'
==> ERROR: module not found: 'nvidia'
==> ERROR: module not found: 'nvidia_modeset'
==> ERROR: module not found: 'nvidia_uvm'
==> ERROR: module not found: 'nvidia_drm'
```

**Zwei Gründe für diesen Fehler:**

1) Da das frühe Laden von Modulen in chwd immer aktiviert ist, erwartet mkinitcpio durchgehend das Vorhandensein von NVIDIA-Modulen; dieser Fehler tritt auf, wenn diese Module fehlen.

2) Es könnten dir NVIDIA-Module von anderen installierten Kerneln auf deinem System fehlen.

```sh title='Installiere das folgende Paket, um diesen Fehler zu beheben'
sudo pacman -S nvidia
```

### Spezifische Software-Probleme

#### Discord verlangt nach einem Update, das in den Repositories nicht verfügbar ist.

<br />
<ImageComponent imgsrc={import('~/assets/images/discord-update.png')} />

Das passiert, weil Discord sein eigenes Update-System verwendet, das den offiziellen Repositories voraus ist. Eine neue Version der App wurde veröffentlicht, aber sie wurde noch nicht für unsere Spiegelserver paketiert.

Um dieses Problem zu umgehen, folge der [Anleitung zur Fehlerbehebung im Arch Wiki](<https://wiki.archlinux.org/title/Discord#Discord_asks_for_an_update_not_yet_available_in_the_repository>).

### Allgemeine Fragen

### Mein PC braucht seit Kurzem zu lang zum Booten

Dieses Problem kann verschiedene Ursachen haben. Als Ansatzpunkt kannst du systemd-analyze überprüfen um zu sehen, wo der PC Schwierigkeiten hat:

Öffne ein Terminal und führe einen der folgenden Befehle aus:

```sh
systemd-analyze blame
```

oder:

```sh
systemd-analyze critical-chain
```

Wenn die Ausgabe zeigt, dass `cachyos-rate-mirrors.service` sehr lange zum Ausführen braucht, solltest du den folgenden Befehl ausführen, um diesen Dienst zu maskieren, wodurch er nicht mehr beim Booten gestartet wird:

```sh
systemctl mask cachyos-rate-mirrors
systemctl mask cachyos-rate-mirrors.timer
```

#### Woher kommt CachyOS und warum heißt es "CachyOS"?

CachyOS ist nach dem "Cachy"-Scheduler benannt, dem ursprünglichen Namen des [cacULE-Schedulers](https://github.com/hamadmarri/cacule-cpu-scheduler), einem CPU-Scheduler für den Linux-Kernel.

Das Projekt hat seinen Ursprung in den Jahren 2020-2021, als ptr1337 (einer der Gründer von CachyOS) mit einem Entwickler namens Hamad am cacULE-Scheduler getüftelt und mit ihm zusammengearbeitet hat. Als sie sich entschieden, eine optimierte Linux-Distribution auf Basis von Arch Linux mit für x86-64-v3 optimierten Paketen zu erstellen,
nannten sie diese "CachyOS" – nach dem Scheduler, der sie zusammengebracht hatte.

#### In welchem Intervall werden -git-Pakete aktualisiert?

Normalerweise einmal am Montag, obwohl es Ausnahmen geben kann.

#### Profitieren die -bin-Pakete in den CachyOS-Repositories von den gleichen Leistungsoptimierungen?

Nein. Die `-bin`-Pakete sind vorkompilierte Binärdateien und enthalten nicht die gleichen Leistungsoptimierungen wie die quellbasierten Pakete in den CachyOS-Repositories.

#### Wie deaktiviere ich die Boot-Animation (Plymouth)?

:::note[Dies könnte bei manchen Systemen ein Problem mit einem schwarzen Bildschirm lösen, z.B. bei alten NVIDIA-GPUs.]
:::

Um die Boot-Animation zu deaktivieren, musst du deine [Bootloader-Konfiguration](/de/configuration/boot_manager_configuration) bearbeiten und die folgenden Kernel-Parameter hinzufügen:

```sh
plymouth.enable=0 disablehooks=plymouth
```

:::note[systemd-boot, GRUB und Limine erfordern eine Neugenerierung der Initramfs-Images]
systemd-boot: `sudo sdboot-manage gen`

GRUB: `sudo grub-mkconfig -o /boot/grub/grub.cfg`

Limine: `sudo limine-mkinitcpio`
:::

#### Paketanfragen an CachyOS senden

CachyOS bietet eine umfangreiche Liste von vorkompilierten AUR-Paketen, die häufig verwendet werden.
Benutzer können auf folgende Weise Anfragen für AUR-Pakete stellen:

Wenn du möchtest, dass wir ein Paket hinzufügen, kannst du eine Anfrage auf GitHub oder im Forum stellen.

- [GitHub](https://github.com/CachyOS/distribution/issues)
- [Forum](https://discuss.cachyos.org/c/feedback/repository/11)
- [Discord Feedback-Kanal](https://discord.com/channels/862292009423470592/1150723027986813018)

## Sicherheit & Bewährte Praktiken

### Sicherheitspraktiken für das AUR

Das AUR bietet eine riesige Auswahl, aber Sicherheit hat oberste Priorität. Hier ist eine kurze Anleitung zur sicheren Nutzung des AUR für dein CachyOS-System.

* **Verstehe das PKGBUILD:** Es ist das Build-Skript. Kenne seine Struktur, Variablen (`source`, `pkgname`) und Funktionen (`build()`, `package()`).
* **Überprüfe die Quell-Links:** Überprüfe immer, dass die `source`-URLs auf offizielle Projektseiten oder vertrauenswürdige Repositories verweisen. Meide verdächtige oder persönliche Links.
* **Überprüfe die Installationsschritte:** Untersuche, wo Dateien installiert werden (`package()`-Funktion) und ob irgendwelche Befehle ungewöhnlich sind oder sensible Systembereiche berühren. Überprüfe auch `.install`-Skripte.
* **Recherchiere den Maintainer:** Untersuche die bisherige Aktivität des Maintainers im AUR auf frühere Sicherheitsprobleme oder verdächtige Aktivitäten.
* **Überprüfe Checksums & PGP:** Absolut entscheidend! Bestätige, dass alle Checksums (SHA256, BLAKE2b, etc.) mit dem Upstream übereinstimmen. Verwende PGP-Signaturen (`validpgpkeys`) zur Authentizitätsprüfung, wenn verfügbar.
* **Sei vorsichtig mit `-bin`-Paketen:** Diese verwenden vorkompilierte Binärdateien, was bedeutet, dass du den Quellcode nicht überprüfen kannst. Prüfe ihre Herkunft und Integrität mit maximaler Sorgfalt.
* **Lies die Kommentare der Community:** Überprüfe die Kommentare auf der AUR-Seite auf Warnungen, Probleme oder Erkenntnisse von anderen Nutzern.
* **Überspringe niemals die Integritätsprüfungen:** Die Verwendung von `--skipinteg` oder ähnlichen Flags umgeht alle Sicherheitsprüfungen. Tu es nicht.
* **Kontrolliere deinen AUR-Helfer:** Verstehe, wie dein Helfer (yay, paru) funktioniert. Stelle sicher, dass er dir das PKGBUILD und seine Diffs anzeigt, oder baue manuell mit `makepkg`.
* **Bewerte die Notwendigkeit:** Frage dich vor der Installation, ob du dieses AUR-Paket wirklich brauchst oder ob eine Alternative aus den offiziellen Repositories existiert.
* **Halte dein System aktuell:** Führe regelmäßig `sudo pacman -Syu` aus, um sicherzustellen, dass alle deine Systemkomponenten, einschließlich `pacman` und `makepkg`, die neuesten Sicherheitspatches haben.

Bleib wachsam, um dein Arch-basiertes System sicher zu halten!

### Regelmäßige Pflege deiner CachyOS-Installation

Infos dazu findest du im Arch Wiki: https://wiki.archlinux.org/title/System_maintenance

### Auswahl eines GUI-Paketmanagers

Obwohl grafische Paketmanager Bequemlichkeit bieten, ist bekannt, dass bestimmte bei Rolling-Release-Systemen wie CachyOS schwere Probleme verursachen und für die Verwaltung von Systempaketen vermieden werden sollten.

- **Pamac:** ist dafür bekannt, bestimmte Paketverwaltungsaufgaben unsachgemäß zu handhaben, wie z.B. die Beschädigung der Schlüsselbunde für Systempakete. Dies kann zu PGP-Signaturfehlern führen, die dich daran hindern, dein System zu aktualisieren.
- **Discover (KDE) & GNOME Software Center:** Diese App-Stores verwenden das PackageKit-Backend. Obwohl sie im Allgemeinen sicher für die Verwaltung von Flatpaks sind, ist die Verwendung zur Installation oder Aktualisierung von **Systempaketen** riskant. PackageKit-basierte Manager können auch instabil oder anfällig für Abstürze sein, was dein System nach einer fehlgeschlagenen Transaktion in einem kaputten Zustand zurücklassen könnte.

Für maximale Stabilität und Zuverlässigkeit **empfehlen wir dringend**, Systempakete über die Kommandozeile mit `pacman` zu verwalten.

Wenn du eine grafische Oberfläche bevorzugst, gelten GUI-Frontends wie **[Shelly](</de/configuration/post_install_setup/#dein-system-aktualisieren>)** oder der **CachyOS Package Installer** als sichere Alternativen, da sie direktere Wrapper für die Pacman-Funktionalität sind.
