update

2026-10-31 19:09:32 +01:00
parent 5fb4db5069
commit 9df5da50b0
12 changed files with 1236 additions and 1 deletions
@@ -0,0 +1,29 @@
+Ich hab ein bisschen recherchiert und ein paar gute Optionen gefunden — sowohl Open Source / native [[Linux]]-PlugIns als auch Tipps, wie man bewährte Windows/Proprietär-Drum-Libraries unter Linux laufen lassen kann. Wenn du willst, kann ich auch ein paar kommerzielle Kandidaten heraussuchen, die unter Linux getestet sind. Hier zunächst ein Überblick:
+
+---
+
+## 🎯 Native bzw. sehr gut unter Linux laufende Drum-Sampler / Drum-PlugIns
+
+Diese Tools/Plugins laufen nativ unter Linux / oder haben Linux-Versionen, und sind gute Alternativen oder Ergänzungen zu EZ-Drummer:
+
+| Plugin / Tool        | Format / Linux-Support                                                                                         | Vorteile                                                                                                                             | Einschränkungen / Punkte, auf die man achten sollte                                                                                                                                                      |
+| -------------------- | -------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **[[DrumGizmo]]**    | VSTi & LV2 Version, stand-alone auch; multichannel, multilayered.                                              | Sehr gute Drumsounds mit mehreren Velocity-Schichten; man kann einzelne Mikros / Kanäle nutzen, also gute Flexibilität beim Mischen. | Die Drums werden nicht immer sofort so fett wie bei kommerziellen Tools; erfordert gutes Setup (Routing, Mix) und ggf. eigene Kits.                                                                      |
+| **[[LinuxSampler]]** | VST, LV2, DSSI etc.                                                                                            | Sehr mächtig, kann große Sample-Libraries nutzen; volle Kontrolle.                                                                   | Bedienung nicht so „slick“ wie bei Markenprodukten, evtl. Lernkurve; große Sample-Bibliotheken nötig für gute Vielfalt.                                                                                  |
+| **[[drumkv1]]**      | LV2 / Standalone (JACK / ALSA MIDI)-Client; native Linux.                                                      | Leichtgewichtig, einfach einzurichten; ideal wenn man nicht so viele Features braucht.                                               | Kein High-End-Drumkit mit riesiger Bibliothek; klingt eher sauber/klassisch, nicht unbedingt super „produziert“.                                                                                         |
+| **Geonkick**         | Synthesizer Drum / Percussion; VST3 und LV2 auf Linux.                                                         | Sehr flexibel bei perkussiven Sounds, interessant wenn man eigene, eher synthetische Drums bauen will.                               | Eher auf Drum-Synthese fokussiert, nicht ein „Drumkit-Sammler“ mit kompletten Kits wie bei EZ Drummer etc. Kann sein, dass man noch eigene Samples oder Bearbeitung braucht, damit’s wirklich gut passt. |
+| **Sitala**           | Stand-alone / PlugIn Version, unterstützt Linux in früheren Versionen (V1) zumindest; sehr leicht zu bedienen. | Schnelle Ergebnisse; ideal für kreative Ideen, wenn man schnell Drums triggern möchte; UI ist simpel und effizient.                  | Wenn man ganz spezifische Kits oder sehr aufwendige Layer/Velocity braucht, stößt man evtl. an Grenzen; neuere Versionen evtl. eingeschränkter Linux-Support.                                            |
+
+---
+
+## 🔧 Kommerzielle PlugIns / Windows-Drum-Libraries unter Linux verwenden
+
+Wenn dir die Qualität / Klang von EZ-Drummer oder ähnlichen wichtig ist und du nicht komplett auf native Alternativen umsteigen willst, hier ein paar Tipps, wie man kommerzielle Plugins unter Linux zuverlässiger nutzen kann:
+
+- **Wine + VST Bridge / yabridge**: Viele Nutzer berichten, dass Windows-VSTs mit yabridge in Reaper unter Linux ziemlich gut laufen. Manche hatten Probleme mit Soundlibrary-Pfaden etc., aber wenn man das richtig einrichtet (z. B. Wineprefix, korrekter Pfad zu den Samples), dann klappt’s oft sehr gut.
+- **Reaper Native + Linux-VST Unterstützung**: Die Linux-Version von Reaper kann native Linux VSTs nutzen, und mit yabridge auch Windows VSTs; das heißt, du kannst beides kombinieren.
+- **Sample Libraries exportieren / konvertieren**: Wenn du z. B. Libraries hast, die in einem Format sind, das EZ-Drummer verwendet, könnte man prüfen, ob man die Samples in ein universelles Format bringt (z.B. SFZ) und dann mit einem Sampler wie LinuxSampler oder DrumGizmo nutzen. Das erspart Abhängigkeiten.
+
+---
+
+Wenn du möchtest, kann ich ein paar **kommerziell verfügbare Drum-PlugIns** heraussuchen, die nachweislich unter Linux + Reaper stabil laufen, inkl. Preis & Klangbeispiele, damit du vergleichen kannst? Möchtest du das?
@@ -0,0 +1,272 @@
+
+Ich bin auf der Suche nach einer guten Software für meine MP3 Musiksammlung in Linux, mit die Synchronisation mit meinem Android Handy gut funktioniert.
+
+### Hintergrund
+Bisher habe ich als Ex-Windows-Nutzer das Programm "Media-Monkey" in der Pro Version verwendet, d.h. auf dem PC und dem Handy mit der gleichnamigen App.
+
+### Anfrage
+Bitte zeige mir gute Alternativen, bestehend aus Linux Programm für PC und Android App für Handy. 
+
+### Anforderungen:
+* Flexible Organisation der Library nach Benutzerdefinierten Kriterien (z.B. Album Artist, Genre, Album, etc.)
+* Bearbeitungsmöglichkeiten aller Song Infos
+* Bewertungssystem und Verschlagwortung
+* Playlisten: statisch und dynamsisch (d.h. regelbasiert)
+* Leichte Synchronisierbarkeit zwischen Rechner und Handy:
+  * Änderungen an Metadaten, insbes. "Last Played" werden in beide Richtungen übernommen
+  * Möglichkeit die Bitrate der MP3s beim Synchronisieren anzupassen (z.B. um Speicherplatz auf Handy zu sparen)
+  * Synchronisation kabelgebunden oder über WLAN
+
+### Optionale Anforderungen
+* Möglichkeit, fehlende Metadaten aus WWW zu ergänzen
+* Erstellung von Benutzerdefinierten Metadaten Feldern, z.B. als Berechnung aus anderen Feldern
+---
+
+---
+Super, danke für die präzise Beschreibung – das hilft sehr!  
+Ich fasse mal die Landschaft für dich zusammen: es gibt unter Linux kein exaktes 1:1-Pendant zu **MediaMonkey**, aber einige Kombinationen aus Desktop-Software + Android-App können sehr nahe herankommen.
+
+---
+
+## 1. **MusicBee (via Wine) + Gonemad / PowerAmp (Android)**
+
+- **Linux (Wine):** MusicBee läuft recht stabil unter Wine. Viele Ex-MediaMonkey-User nutzen es als Ersatz, weil es die meisten Features (flexible Library, Tags, Bewertungen, Smart-Playlists, Metadaten aus dem Netz) abdeckt.
+    
+- **Android:** Keine eigene App, aber Sync mit **GoneMAD** oder **PowerAmp** möglich. Mit Tools wie `syncthing` oder `Resilio Sync` kannst du Library, Ratings & Playcounts abgleichen.
+    
+- **Pro:** Funktionsumfang fast wie MediaMonkey.
+    
+- **Contra:** Keine native Linux-App, Integration Handy↔PC muss manuell über Sync-Tools eingerichtet werden.
+    
+
+---
+
+## 2. **Clementine / Strawberry (Linux) + Android App Clementine Remote / DSub**
+
+- **Linux:** [[Strawberry 1]] ist ein Fork von Clementine, moderner gepflegt.
+    
+    - Bibliotheksorganisation nach vielen Kriterien.
+        
+    - Metadatenbearbeitung, inkl. Coverdownload von Last.fm, MusicBrainz.
+        
+    - Playlists: statisch + dynamisch.
+        
+- **Android:** Offizielle Clementine-Remote-App für Steuerung, oder Streaming via Subsonic-kompatibler Apps (z. B. [[DSub]], [[Ultrasonic]]).
+	- siehe auch [[IT-Know-How/Linux/Subsonic-API]]
+    
+- **Sync:**
+    
+    - Metadaten (Playcount, Ratings) werden am PC gespeichert.
+        
+    - Handy-Sync ist etwas frickelig, echte **bidirektionale Playcount-Synchronisation** gibt es nicht nativ.
+        
+- **Pro:** Native Linux-App, offene Formate.
+    
+- **Contra:** Sync mit Handy nicht so nahtlos wie MediaMonkey.
+    
+
+---
+
+## 3. **Amarok / Elisa (KDE) + Android (KDE Connect, VLC, PowerAmp)**
+
+- **Linux:** Amarok war früher sehr stark, inzwischen etwas veraltet. Elisa ist der moderne KDE-Player, aber weniger mächtig in Smart-Playlists.
+    
+- **Android:** Mit **KDE Connect** kannst du Dateien kabellos synchronisieren, aber Metadaten-Sync (z. B. "Last Played") fehlt.
+    
+- **Pro:** Schön in KDE integriert.
+    
+- **Contra:** Nicht so mächtig wie MediaMonkey.
+    
+
+---
+
+## 4. **Rhythmbox + Android (Lollypop / VLC)**
+
+- **Linux:** Rhythmbox (GNOME Standard) oder Lollypop (modernere Oberfläche).
+    
+- **Features:** Library, Metadaten, Bewertungen.
+    
+- **Sync:** Per Kabel (MTP) oder WLAN/Sync-Tools, aber kein sauberer Playcount-Abgleich.
+    
+- **Contra:** Sehr basic, keine regelbasierten Playlists wie MediaMonkey.
+    
+
+---
+
+## 5. **Self-Hosted Server + Android (Subsonic/Airsonic + DSub/Ampache)**
+
+- **Linux:** Airsonic, [Navidrome] oder Koel als **Musikserver**.
+    
+- **Features:** Vollständige Weboberfläche, flexible Library, Tags, Playcounts, Bewertungen.
+    
+- **Android:** Mit Apps wie **DSub**, **Substreamer**, **Ultrasonic** Zugriff und **automatische Playcount-Sync**.
+    
+- **Pro:**
+    
+    - Playcounts, Metadaten und Playlists sind _immer synchronisiert_.
+        
+    - Zugriff auch von unterwegs.
+        
+- **Contra:** Kein klassischer "Desktop-Player", sondern Server-Setup. Eher für Power-User.
+    
+
+---
+
+## 6. **Syncthing / rsync als Backend für bestehende Player**
+
+- Falls dir wichtig ist, die MP3s in voller Struktur 1:1 zwischen Rechner und Handy zu haben (inkl. Playcounts, Bitrate-Anpassung), kannst du auch einen reinen Player wie **Strawberry** am PC + **GoneMAD** oder **PowerAmp** am Handy nutzen, und den Abgleich über **Syncthing** erledigen.
+    
+- Bitraten-Transkodierung beim Sync ist tricky: am besten über ein Script oder mit Tools wie **FFmpeg** beim Kopieren lösen.
+    
+
+---
+
+## Fazit (Empfehlungen)
+
+- **"Am nächsten an MediaMonkey"** → **MusicBee unter Wine + GoneMAD/PowerAmp auf Android** (aber kein native Linux).
+    
+- **Native Linux-Lösung, solide & gepflegt** → **Strawberry auf Linux + GoneMAD auf Android**, Sync per Syncthing/rsync.
+    
+- **Wenn Playcount/Rating-Sync über Geräte _wirklich_ zentral ist** → **[[IT-Know-How/Linux/Navidrome]] (Server) + DSub/Ultrasonic auf Android**.
+    
+
+---
+
+👉 Frage an dich:  
+Ist dir wichtiger, dass das Ganze **nativ auf Linux läuft** (also Wine vermeiden), oder dass du **möglichst nahe an der MediaMonkey-Experience bleibst**, auch wenn’s Wine erfordert?
+
+---
+Ich ziehe es vor, wenn es nativ unter Linux läuft. Es **muss** nicht auch nicht Media Monkey nachahmen, es sollte vom Funktionsumfang nur ähnlich mächtig sein. Wenn für Synchronisation extra Tools benötigt werden ist das ok. Wichtig wäre mir, dass Bearbeitungen am PC (Hinzugefügte Songs, Playlisten statisch und dynamisch, Metadaten etc) möglichst 1 zu 1 auch auf dem Handy verfügbar sind.
+
+---
+Perfekt — danke für die Präzisierung. Du willst also **native Linux**-Werkzeuge, die in Summe ungefähr so mächtig sind wie MediaMonkey, und die Änderungen am PC (neue Songs, statische + dynamische Playlists, Metadaten usw.) sollen **möglichst 1:1 auf dem Android-Handy verfügbar** sein. Ich habe zwei praxiserprobte, native-unter-Linux-Workflows für genau dieses Ziel — einer ist _server-zentriert_ (am zuverlässigsten für Bidirektionalität von Playcounts/Playlists/Metadaten), der andere ist _Datei-Sync/Offline_-orientiert (besser für rein lokale Dateien/Offline-Nutzung, aber mit Einschränkungen bei Playcount/Ratings). Ich liste jeweils Voraussetzungen, wie es funktioniert, Vor-/Nachteile und konkrete Umsetzungspunkte.
+
+# Empfehlung A — **(Meine Top-Wahl)** Lokaler Musik-Server ([[IT-Know-How/Linux/Navidrome]]/Airsonic) + native Player (Strawberry) auf PC + Subsonic-Client auf Android (z. B. DSub / Ultrasonic)
+
+**Warum:** [[IT-Know-How/Linux/Navidrome]] (leichtgewichtiger, moderner Subsonic-kompatibler Server) läuft nativ unter Linux, indexiert deine Musikdateien und stellt Bibliothek + Playlists + Playcounts + Ratings zentral zur Verfügung. Android-Clients, die das Subsonic-API unterstützen, können sowohl streamen als auch offline cachen und melden Wiedergaben/Playcounts zurück an den Server — dadurch hast du eine echte 1:1-Synchronisation der Nutzungsdaten zwischen PC und Handy. [Navidrome] bietet außerdem Transcoding/Download-Transkodierung (nützlich, um Bitrate beim Übertragen zu reduzieren). Auf dem Desktop nutzt du einen richtigen Player/Tag-Editor wie **Strawberry** zum Bearbeiten der Dateien; der Server erkennt Änderungen bei Rescan/Auto-Import. ([[IT-Know-How/Linux/Navidrome]](https://www.Navidrome.org/docs/overview/?utm_source=chatgpt.com "[[IT-Know-How/Linux/Navidrome]] Overview"))
+
+Wie das zusammenwirkt — Kurzablauf:
+
+1. Auf dem Linux-PC: music-folder (z. B. `~/Music`) → Strawberry zum Abspielen & Tag-Editing. Strawberry ist native, hat Smart/Dynamic-Playlists und Tag-Editoren. ([strawberrymusicplayer.org](https://www.strawberrymusicplayer.org/?utm_source=chatgpt.com "Strawberry Music Player"))
+    
+2. Auf dem Linux-PC: [[IT-Know-How/Linux/Navidrome]] (als Dienst oder Docker) so konfigurieren, dass es auf genau denselben Music-Ordner zeigt. [[IT-Know-How/Linux/Navidrome]] indexiert die Dateien, liest Tags, Playlists (importiert `.m3u`) und verwaltet Playcounts/ratings serverseitig. ([[IT-Know-How/Linux/Navidrome]](https://www.Navidrome.org/docs/overview/?utm_source=chatgpt.com "[[IT-Know-How/Linux/Navidrome]] Overview"))
+    
+3. Auf Android: Subsonic-kompatible App installieren (z. B. **DSub**, **Ultrasonic** oder Subsonic-App). Diese Apps können streamen, offline cachen/downloaden und (je nach App/Server-Einstellung) Playbacks/Playcounts an [[IT-Know-How/Linux/Navidrome]] zurückmelden; sie unterstützen auch clientseitiges Transcoding / Download-Qualitätssteuerung. (Subsonic-App-Ökosystem ist groß, DSub ist ein verbreiteter Client.) ([subsonic.org](https://www.subsonic.org/pages/apps.jsp?utm_source=chatgpt.com "Subsonic Apps"))
+    
+
+Wesentliche Vorteile:
+
+- **Echte Bidirektionalität** für Playcount/Play/Rating, wenn Client ↔ Server dies unterstützt (sehr viel zuverlässiger als reine Datei-Syncs). ([[IT-Know-How/Linux/Navidrome]](https://www.Navidrome.org/docs/overview/?utm_source=chatgpt.com "[[IT-Know-How/Linux/Navidrome]] Overview"))
+    
+- **On-the-fly Transcoding / Bitrate-Limit** beim Stream/Download — du kannst z. B. mobil immer in 128–192 kbps laden, während der PC die Originals behält. ([[IT-Know-How/Linux/Navidrome]](https://www.Navidrome.org/docs/usage/configuration-options/?utm_source=chatgpt.com "[[IT-Know-How/Linux/Navidrome]] Configuration Options"))
+    
+- Desktop bleibt native (Strawberry), Server läuft nativ unter Linux. ([strawberrymusicplayer.org](https://www.strawberrymusicplayer.org/?utm_source=chatgpt.com "Strawberry Music Player"))
+    
+
+Nachteile / Dinge, die du beachten solltest:
+
+- Es ist kein „klassischer“ Einzelprogramm-Desktop-Workflow mehr, sondern ein **Server + Clients**-Setup (läuft aber lokal auf deinem Rechner, keine Cloud nötig).
+    
+- Manche Subsonic-Clients handhaben Offline-Caching unterschiedlich (Ordnerstruktur, Caching-Verhalten). Testen lohnt sich. ([GitHub](https://github.com/airsonic-advanced/airsonic-advanced/issues/873?utm_source=chatgpt.com "DSub sync/cache with Airsonic 11 dumps all files into main ..."))
+    
+
+**Kurz-Setup-Hinweise:**
+
+- Installiere [[IT-Know-How/Linux/Navidrome]] (Deb/Flatpak/Docker) und stelle `MUSIC_FOLDER` auf deinen bestehenden Musikordner. Aktiviere ggf. `AutoImportPlaylists`. ([[IT-Know-How/Linux/Navidrome]](https://www.Navidrome.org/docs/usage/configuration-options/?utm_source=chatgpt.com "[[IT-Know-How/Linux/Navidrome]] Configuration Options"))
+    
+- Installiere Strawberry als Desktop-Player und bearbeite Tags/Playlists dort; [[IT-Know-How/Linux/Navidrome]] neu scannen lassen oder Auto-Rescan aktivieren. ([strawberrymusicplayer.org](https://www.strawberrymusicplayer.org/?utm_source=chatgpt.com "Strawberry Music Player"))
+    
+- Auf Android: DSub/Ultrasonic konfigurieren (Server-URL mit deiner lokalen IP), in der App die Download/Transcode-Qualität setzen. ([subsonic.org](https://www.subsonic.org/pages/apps.jsp?utm_source=chatgpt.com "Subsonic Apps"))
+    
+
+---
+
+# Empfehlung B — **Datei-Sync (offline) Workflow**: Strawberry (Linux) + Syncthing (oder rsync) + Android-Player (GoneMAD / Poweramp)
+
+**Warum:** Wenn du viel offline hörst und tatsächliche Dateien auf dem Handy brauchst (z. B. Hi-Res oder bestimmte Ordnerstruktur), ist Syncthing eine sehr komfortable, native Lösung zum Spiegeln von Ordnern PC ↔ Handy. Strawberry bearbeitet Tags/Playlists auf dem PC und die Dateien werden 1:1 auf's Handy kopiert. ([strawberrymusicplayer.org](https://www.strawberrymusicplayer.org/?utm_source=chatgpt.com "Strawberry Music Player"))
+
+Wie das zusammenwirkt — Kurzablauf:
+
+1. Strawberry verwaltet die Dateien lokal und erzeugt Playlists (M3U).
+    
+2. Syncthing synchronisiert den Music-Ordner (und Playlist-Exports) automatisch auf das Handy. Syncthing läuft nativ unter Linux und Android. ([Gist](https://gist.github.com/johanwiden/d14ec414bd212e2ee8c2fae576115ef7?utm_source=chatgpt.com "How to configure Syncthing for Android"))
+    
+3. Auf Android: ein mächtiger Offline-Player wie **GoneMAD** oder **Poweramp** liest die Dateien/Playlists vom synchronisierten Ordner.
+    
+
+Vorteile:
+
+- Volle Offline-Verfügbarkeit (keine Server-Software nötig).
+    
+- Absolute Dateiintegrität — exakt die gleichen MP3/FLAC liegen auf beiden Geräten.
+    
+
+Wesentliche Einschränkungen (sehr wichtig):
+
+- **Playcounts / Ratings**: Viele Android-Player (z. B. Poweramp) speichern Playcounts/Rating in einer **internen App-Datenbank** und schreiben diese **nicht** zuverlässig zurück in die MP3-Tags (POPM/PCNT). Dadurch geht die echte bidirektionale Synchronisation von „Last played / playcount / rating“ verloren, bzw. sie ist nur mit zusätzlichen Tools/Workarounds möglich. Poweramp z.B. unterstützt POPM nicht als schreibbaren Standard-Rating-Export. GoneMAD hat einige Optionen, kann aber nicht immer sauber bidirektional zu jedem Desktop-Tool synchronisieren. ([Poweramp](https://forum.powerampapp.com/topic/21099-will-not-recognize-ratings-tags/?utm_source=chatgpt.com "Will not recognize ratings tags - Poweramp Feature Requests"))
+    
+- Android-Medienindexer kann neue Dateien verzögert erkennen; manchmal muss man den Index anstoßen oder die App neu starten, wenn Syncthing neue Musik ablegt. ([Syncthing Community Forum](https://forum.syncthing.net/t/music-synced-onto-phone-not-picked-up-by-android/22191?utm_source=chatgpt.com "Music Synced onto Phone Not Picked Up by Android"))
+    
+
+Workarounds:
+
+- Verwende ID3-Frames, die als Standard existieren — z. B. **PCNT** (Play Counter) oder **POPM** (Popularimeter) — und scripte gelegentlich ein Update/Export/Import dieser Frames zwischen Player-DB und Dateien. Die PCNT-Frame ist Teil der ID3-Spec und kann playcount direkt in die Datei schreiben — das funktioniert aber nur, wenn der Android-Player diese Frames auch schreibt/liest. ([id3.org](https://id3.org/id3v2.3.0?utm_source=chatgpt.com "id3v2.3.0"))
+    
+- Manche Nutzer verwenden periodische Exporte (z. B. M3U/CSV) und ein kleines Script, das die DB-Werte abgleicht — ist aber Aufwand und fragile Lösung. (Wenn du experimentierfreudig bist, möglich.)
+    
+
+---
+
+# Vergleich & Entscheidungshilfe — kurz
+
+- **Wenn du wirklich möchtest, dass Playcounts / LastPlayed / Ratings verlässlich zwischen PC ↔ Handy synchron sind → wähle den Server-Ansatz ([[IT-Know-How/Linux/Navidrome]] / Airsonic)**. Das ist die sauberste, wartungsarme Lösung für bidirektionale Nutzungsdaten; zusätzlich hast du komfortable Transcoding-Optionen für mobile Daten/Storage. ([[IT-Know-How/Linux/Navidrome]](https://www.Navidrome.org/docs/overview/?utm_source=chatgpt.com "[[IT-Know-How/Linux/Navidrome]] Overview"))
+    
+- **Wenn du maximale Offline-Kontrolle über die Dateien willst (keine Serverstruktur) → wähle Syncthing + ein mächtiges Android-Player,** akzeptiere aber Einschränkungen bei Ratings/Playcounts bzw. plane zusätzliche Scripts/Workarounds ein. ([Gist](https://gist.github.com/johanwiden/d14ec414bd212e2ee8c2fae576115ef7?utm_source=chatgpt.com "How to configure Syncthing for Android"))
+    
+
+---
+
+# Konkrete Vorschläge zum sofortigen Ausprobieren (in dieser Reihenfolge)
+
+1. **Testlauf Server-Option (empfohlen):**
+    
+    - Installiere [[IT-Know-How/Linux/Navidrome]] (Docker oder Paket) und zeige es auf `~/Music`. ([[IT-Know-How/Linux/Navidrome]] ist leicht, kann lokal laufen.) ([[IT-Know-How/Linux/Navidrome]](https://www.Navidrome.org/docs/overview/?utm_source=chatgpt.com "[[IT-Know-How/Linux/Navidrome]] Overview"))
+        
+    - Installiere DSub (oder Ultrasonic) auf dem Handy, verbinde mit [[IT-Know-How/Linux/Navidrome]]. Teste Streaming + Offline-Download + setzte Download-Bitrate auf z. B. 160 kbps. ([subsonic.org](https://www.subsonic.org/pages/apps.jsp?utm_source=chatgpt.com "Subsonic Apps"))
+        
+    - Auf dem PC: installiere **Strawberry**, bearbeite ein paar Tags & Playlists, lasse [[IT-Know-How/Linux/Navidrome]] neu scannen — prüfe die Änderungen im Android-Client. ([strawberrymusicplayer.org](https://www.strawberrymusicplayer.org/?utm_source=chatgpt.com "Strawberry Music Player"))
+        
+2. **Falls du stattdessen Offline-Dateien bevorzugst:**
+    
+    - Installiere **Syncthing** auf PC + Android, sync einen kleinen Test-Musikordner. ([Gist](https://gist.github.com/johanwiden/d14ec414bd212e2ee8c2fae576115ef7?utm_source=chatgpt.com "How to configure Syncthing for Android"))
+        
+    - Auf Android: teste **GoneMAD** (sehr anpassbar) oder **Poweramp** als Player, probiere, ob Ratings/Playcounts in deiner Kombination zuverlässig geschrieben/gezogen werden (Hinweis: Poweramp schreibt POPM nicht). ([Google Play](https://play.google.com/store/apps/details?hl=en_US&id=gonemad.gmmp&utm_source=chatgpt.com "GoneMAD Music Player - Apps on Google Play"))
+        
+
+---
+
+# Quellen (wichtigste Belege)
+
+- Strawberry — native Linux Player: Smart/dynamic playlists, Tag-Editor, MusicBrainz/cover lookup. ([strawberrymusicplayer.org](https://www.strawberrymusicplayer.org/?utm_source=chatgpt.com "Strawberry Music Player"))
+    
+- [[IT-Know-How/Linux/Navidrome]] — leichter Subsonic-kompatibler Server, lokal nutzbar; Optionen für AutoImportPlaylists / Transcoding/Download-Transcode. ([[IT-Know-How/Linux/Navidrome]](https://www.Navidrome.org/docs/overview/?utm_source=chatgpt.com "[[IT-Know-How/Linux/Navidrome]] Overview"))
+    
+- Subsonic/DSub ecosystem — Android-Clients für Subsonic/[[IT-Know-How/Linux/Navidrome]] (Streaming, Offline Caching, Bitrate/Transcode Optionen). ([subsonic.org](https://www.subsonic.org/pages/apps.jsp?utm_source=chatgpt.com "Subsonic Apps"))
+    
+- ID3-Frames (PCNT / POPM) — Playcount-Frame `PCNT` ist Teil der ID3v2-Spec (kann in Datei gespeichert werden). ([id3.org](https://id3.org/id3v2.3.0?utm_source=chatgpt.com "id3v2.3.0"))
+    
+- Poweramp & Rating/Tagging Limit: Poweramp schreibt/liest POPM/PCNT nicht standardmäßig; Ratings werden intern gespeichert — wichtige Einschränkung für Datei-Sync Workflows. ([Poweramp](https://forum.powerampapp.com/topic/21099-will-not-recognize-ratings-tags/?utm_source=chatgpt.com "Will not recognize ratings tags - Poweramp Feature Requests"))
+    
+- Syncthing für Datei-Sync Android ↔ PC — verbreitete Praxis, aber Android-Indexing / Rechte / folder ownership sind zu beachten. ([Gist](https://gist.github.com/johanwiden/d14ec414bd212e2ee8c2fae576115ef7?utm_source=chatgpt.com "How to configure Syncthing for Android"))
+    
+
+---
+
+Wenn du willst, mache ich sofort eines von beiden für dich praktisch:
+
+- **Variante A:** Ich erstelle dir eine Schritt-für-Schritt-Anleitung (konkret für Debian/Ubuntu/Fedora) zum Installieren/Einrichten von [[IT-Know-How/Linux/Navidrome]] + Strawberry + DSub (inkl. Beispiel-Config für Transcoding/AutoImport).
+    
+- **Variante B:** Oder ich schreibe ein kurzes Syncthing-Setup-Tutorial + Hinweise, wie du Ratings/Playcounts am besten per ID3/Script synchronisierst (inkl. Beispielscript, das `PCNT`/`POPM` per `mutagen` oder `eyeD3` setzt).
+    
+
+Sag mir einfach welches Setup du zuerst ausprobieren willst — ich liefere die konkrete, sofort ausführbare Anleitung (inkl. Konfig-Snippets).
@@ -0,0 +1,142 @@
+
+
+
+
+**Warum:** [[IT-Know-How/Linux/Navidrome]] (leichtgewichtiger, moderner Subsonic-kompatibler Server, -> [[IT-Know-How/Linux/Subsonic-API]]) läuft nativ unter Linux, indexiert deine Musikdateien und stellt Bibliothek + Playlists + Playcounts + Ratings zentral zur Verfügung. Android-Clients, die das Subsonic-API unterstützen, können sowohl streamen als auch offline cachen und melden Wiedergaben/Playcounts zurück an den Server — dadurch hast du eine echte 1:1-Synchronisation der Nutzungsdaten zwischen PC und Handy. [Navidrome] bietet außerdem Transcoding/Download-Transkodierung (nützlich, um Bitrate beim Übertragen zu reduzieren). Auf dem Desktop nutzt du einen richtigen Player/Tag-Editor wie [[Strawberry 1]] zum Bearbeiten der Dateien; der Server erkennt Änderungen bei Rescan/Auto-Import. ([[IT-Know-How/Linux/Navidrome]](https://www.Navidrome.org/docs/overview/?utm_source=chatgpt.com "[[IT-Know-How/Linux/Navidrome]] Overview"))
+
+Wie das zusammenwirkt — Kurzablauf:
+
+1. Auf dem Linux-PC: music-folder (z. B. `~/Music`) → Strawberry zum Abspielen & Tag-Editing. Strawberry ist native, hat Smart/Dynamic-Playlists und Tag-Editoren. ([strawberrymusicplayer.org](https://www.strawberrymusicplayer.org/?utm_source=chatgpt.com "Strawberry Music Player"))
+    
+2. Auf dem Linux-PC: [[IT-Know-How/Linux/Navidrome]] (als Dienst oder Docker) so konfigurieren, dass es auf genau denselben Music-Ordner zeigt. [[IT-Know-How/Linux/Navidrome]] indexiert die Dateien, liest Tags, Playlists (importiert `.m3u`) und verwaltet Playcounts/ratings serverseitig. ([[IT-Know-How/Linux/Navidrome]](https://www.Navidrome.org/docs/overview/?utm_source=chatgpt.com "[[IT-Know-How/Linux/Navidrome]] Overview"))
+    
+3. Auf Android: Subsonic-kompatible App installieren (z. B. **DSub**, **Ultrasonic** oder Subsonic-App). Diese Apps können streamen, offline cachen/downloaden und (je nach App/Server-Einstellung) Playbacks/Playcounts an [[IT-Know-How/Linux/Navidrome]] zurückmelden; sie unterstützen auch clientseitiges Transcoding / Download-Qualitätssteuerung. (Subsonic-App-Ökosystem ist groß, DSub ist ein verbreiteter Client.) ([subsonic.org](https://www.subsonic.org/pages/apps.jsp?utm_source=chatgpt.com "Subsonic Apps"))
+    
+
+Wesentliche Vorteile:
+
+- **Echte Bidirektionalität** für Playcount/Play/Rating, wenn Client ↔ Server dies unterstützt (sehr viel zuverlässiger als reine Datei-Syncs). ([[IT-Know-How/Linux/Navidrome]](https://www.Navidrome.org/docs/overview/?utm_source=chatgpt.com "[[IT-Know-How/Linux/Navidrome]] Overview"))
+    
+- **On-the-fly Transcoding / Bitrate-Limit** beim Stream/Download — du kannst z. B. mobil immer in 128–192 kbps laden, während der PC die Originals behält. ([[IT-Know-How/Linux/Navidrome]](https://www.Navidrome.org/docs/usage/configuration-options/?utm_source=chatgpt.com "[[IT-Know-How/Linux/Navidrome]] Configuration Options"))
+    
+- Desktop bleibt native (Strawberry), Server läuft nativ unter Linux. ([strawberrymusicplayer.org](https://www.strawberrymusicplayer.org/?utm_source=chatgpt.com "Strawberry Music Player"))
+    
+
+Nachteile / Dinge, die du beachten solltest:
+
+- Es ist kein „klassischer“ Einzelprogramm-Desktop-Workflow mehr, sondern ein **Server + Clients**-Setup (läuft aber lokal auf deinem Rechner, keine Cloud nötig).
+    
+- Manche Subsonic-Clients handhaben Offline-Caching unterschiedlich (Ordnerstruktur, Caching-Verhalten). Testen lohnt sich. ([GitHub](https://github.com/airsonic-advanced/airsonic-advanced/issues/873?utm_source=chatgpt.com "DSub sync/cache with Airsonic 11 dumps all files into main ..."))
+    
+
+**Kurz-Setup-Hinweise:**
+
+- Installiere [[IT-Know-How/Linux/Navidrome]] (Deb/Flatpak/Docker) und stelle `MUSIC_FOLDER` auf deinen bestehenden Musikordner. Aktiviere ggf. `AutoImportPlaylists`. ([[IT-Know-How/Linux/Navidrome]](https://www.Navidrome.org/docs/usage/configuration-options/?utm_source=chatgpt.com "[[IT-Know-How/Linux/Navidrome]] Configuration Options"))
+    
+- Installiere Strawberry als Desktop-Player und bearbeite Tags/Playlists dort; [[IT-Know-How/Linux/Navidrome]] neu scannen lassen oder Auto-Rescan aktivieren. ([strawberrymusicplayer.org](https://www.strawberrymusicplayer.org/?utm_source=chatgpt.com "Strawberry Music Player"))
+    
+- Auf Android: DSub/Ultrasonic konfigurieren (Server-URL mit deiner lokalen IP), in der App die Download/Transcode-Qualität setzen. ([subsonic.org](https://www.subsonic.org/pages/apps.jsp?utm_source=chatgpt.com "Subsonic Apps"))
+
+
+---
+
+### 1. **Playcounts / Metadaten in Strawberry vs. Navidrome**
+
+- **Wenn du Strawberry „lokal“ (eigene Library, also direkt auf den Musikdateien im Dateisystem) benutzt:**
+    
+    - Playcounts und Ratings werden **nur in Strawberries interner Datenbank** gepflegt, nicht in Navidrome.
+        
+    - Metadatenänderungen (Tags, Cover etc.), die du in den Dateien speicherst, **sieht Navidrome** beim nächsten Scan (manuell oder automatisch). → Cover/Tags sind also synchron, **aber Playcounts und Ratings nicht**.
+        
+- **Wenn du Strawberry „über Streaming“ mit Navidrome verbindest:**
+    
+    - Playcounts und Ratings werden im **Navidrome-Server** gespeichert, d.h. Handy + PC greifen auf denselben Zähler/Rating zurück.
+        
+    - Änderungen in der Datei selbst sind dann nachrangig (es sei denn, du editierst die Tags explizit im Dateisystem).
+        
+
+👉 Empfehlung:
+
+- Für **Playcounts und Bewertungen**, immer über das Navidrome-Streaming-Backend hören.
+    
+- Für **Tag-Bearbeitung** (Album Artist, Genre, Cover etc.) kannst du ruhig Strawberry lokal verwenden → nach dem Speichern erkennt Navidrome die geänderten Tags.
+    
+
+---
+
+### 2. **Navidrome auf Synology NAS installieren – sinnvoll?**
+
+- **Ja, absolut sinnvoll.** Vorteile:
+    
+    - Deine Musik liegt vermutlich sowieso schon auf der NAS.
+        
+    - Navidrome kann 24/7 laufen, unabhängig vom PC.
+        
+    - Dein Handy kann direkt auf die NAS zugreifen (auch unterwegs, wenn du Portfreigabe oder VPN einrichtest).
+        
+- Installationsmöglichkeiten:
+    
+    - **Docker-Container** (empfohlen, wenn du Docker auf der Synology nutzt). Das offizielle Image ist `deluan/navidrome`.
+        
+    - Oder als native Binary in einer Synology-Chroot/Entwicklungsumgebung (Docker ist aber deutlich einfacher).
+        
+
+👉 Empfehlung: Wenn die NAS immer läuft → installiere Navidrome dort. Dann kannst du Strawberry am PC so konfigurieren, dass er sich nur noch als Client auf den NAS-Server verbindet.
+
+---
+
+### 3. **Navidrome beim Systemstart automatisch starten lassen**
+
+Hängt davon ab, wie du es installiert hast:
+
+- **Systemd-Service (klassisch, wenn du es auf deinem Linux-PC laufen lässt):**
+    
+    1. Service-Datei erstellen:
+        
+        ```ini
+        # /etc/systemd/system/navidrome.service
+        [Unit]
+        Description=Navidrome Music Server
+        After=network.target
+        
+        [Service]
+        User=deinuser
+        Group=deinuser
+        ExecStart=/usr/local/bin/navidrome --configfile /etc/navidrome.toml
+        Restart=on-failure
+        WorkingDirectory=/home/deinuser
+        
+        [Install]
+        WantedBy=multi-user.target
+        ```
+        
+    2. Aktivieren & starten:
+        
+        ```bash
+        sudo systemctl enable navidrome
+        sudo systemctl start navidrome
+        ```
+        
+- **Docker + Systemd:**  
+    Wenn du Navidrome via Docker laufen lässt, kannst du entweder `docker run --restart=always ...` nutzen oder einen systemd-Service schreiben, der den Container startet.
+    
+- **Synology NAS (Docker):**  
+    Die Synology Docker-Oberfläche bietet eine Einstellung **„Automatisch starten“** beim Container an. Einfach anhaken, dann startet Navidrome mit der NAS.
+    
+
+---
+
+✅ **Kurz zusammengefasst:**
+
+- **Playcounts/Ratings:** Nur über Navidrome-Streaming → sonst bleiben sie lokal in Strawberry.
+    
+- **Metadaten (Tags, Cover):** Bearbeitung in Strawberry → Navidrome liest sie beim nächsten Scan ein.
+    
+- **NAS:** Ideal für Dauerbetrieb, am besten per Docker.
+    
+- **Autostart:** systemd-Service (Linux) oder Autostart in Synology Docker aktivieren.
+    
+
+---
+
+👉 Soll ich dir eine konkrete Schritt-für-Schritt-Anleitung für **Navidrome auf Synology NAS (per Docker)** schreiben, inkl. `docker run`-Beispiel und Volume-Mounts (z. B. für `music/` und `data/`)? Dann kannst du deine PC-Instanz ablösen und alles zentralisieren.
@@ -0,0 +1,97 @@
+<https://www.navidrome.org/>
+
+Hier eine ausführliche Vorstellung von **Navidrome**:
+
+---
+
+## 🔎 Was ist Navidrome?
+
+Navidrome ist ein **selbstgehosteter Musikserver** für \[\[Linux\]\] (und andere Plattformen). Er funktioniert ähnlich wie Spotify oder Apple Music – nur mit deiner eigenen Musikbibliothek. Du lädst deine Audiodateien (MP3, FLAC, OGG, AAC etc.) auf deinen Server, und Navidrome macht sie über ein Web-Interface oder kompatible Apps (\[\[Subsonic-API\]\]) überall verfügbar.
+
+Kurz:  
+👉 Deine Musik, dein Server, jederzeit und überall streambar.
+
+---
+
+## 🎶 Was kann Navidrome?
+
+- **Streaming im Browser** mit einem modernen, responsiven Webplayer.
+- **Unterstützt viele Clients** über die Subsonic-API (z. B. \[\[DSub\]\], \[\[Ultrasonic\]\], \[\[Substreamer\]\], Symfonium, etc.).
+- **Automatische Bibliotheksindizierung**: Scannt Ordner, liest Metadaten und baut deine Mediathek.
+- **Benutzerverwaltung**: Mehrere Accounts mit eigenen Playlists, Favoriten und Rechten.
+- **Playlists & Favoriten** (inkl. Smart-Playlists).
+- **Transcoding on the fly**: Wandelt Dateien in kleinere Formate um, falls deine Verbindung langsam ist.
+- **Leichtgewichtig & ressourcenschonend** (geschrieben in Go).
+- **Cross-Plattform**: \[\[Linux\]\], Windows, macOS, ARM (z. B. Raspberry Pi).
+- **Docker-Images verfügbar** für einfache Installation.
+
+---
+
+## ✅ Vorteile gegenüber anderen Lösungen
+
+- **Leichtgewichtiger als Plex oder Jellyfin**, weil es sich auf Musik konzentriert.
+- **Moderner und aktiver entwickelt als Airsonic, Subsonic & Co.**
+- **Einfach zu installieren und zu warten** (ein Binary oder Docker-Container reicht).
+- **Sehr niedrige Hardware-Anforderungen** – läuft problemlos auf kleinen VPS oder einem Raspberry Pi.
+- **Sehr gute Client-Kompatibilität** durch \[\[Subsonic-API\]\].
+
+---
+
+## 🛠️ Installation unter Linux
+
+### Variante 1: Per Binary (klassisch)
+
+1. Lade die aktuelle Version herunter:
+
+   ```bash
+   wget https://github.com/navidrome/navidrome/releases/latest/download/navidrome_linux_amd64.tar.gz
+   tar xzf navidrome_linux_amd64.tar.gz
+   sudo mv navidrome /usr/local/bin/
+   ```
+2. Erstelle einen Benutzer für Navidrome:
+
+   ```bash
+   sudo useradd -r -s /bin/false navidrome
+   ```
+3. Erstelle ein Konfigurationsverzeichnis:
+
+   ```bash
+   sudo mkdir /var/lib/navidrome
+   sudo chown navidrome:navidrome /var/lib/navidrome
+   ```
+4. Systemd-Service einrichten (optional).
+
+---
+
+### Variante 2: \[\[Docker\]\] (empfohlen)
+
+```bash
+docker run -d \
+  --name=navidrome \
+  -p 4533:4533 \
+  -v /pfad/zu/deiner/musik:/music \
+  -v /pfad/zu/navidrome/data:/data \
+  deluan/navidrome:latest
+```
+
+---
+
+## ⚙️ Ersteinrichtung
+
+- Navidrome läuft nun auf: <http://localhost:4533>
+- Beim ersten Start wirst du aufgefordert, ein **Admin-Konto** anzulegen.
+- Danach: Musikordner wird automatisch eingelesen (Metadaten, Cover, etc.).
+
+---
+
+## 📌 Dinge, die man beachten sollte
+
+- **Firewall/Portfreigabe**: Wenn du von außen zugreifen willst, Port 4533 öffnen oder einen Reverse Proxy (nginx/traefik mit HTTPS) davor schalten.
+- **Sicherung**: Datenbank & Konfigurationsordner `/data` regelmäßig sichern.
+- **Rechte**: Musikordner muss für den Navidrome-Benutzer lesbar sein.
+- **Transcoding**: Falls du FLAC → MP3 brauchst, sollte `ffmpeg` installiert sein.
+- **Clients**: Nutze eine kompatible App für Smartphone-Streaming (z. B. Symfonium [Android], iSub [iOS]).
+
+---
+
+\[\[Navidrome mit Strawberry 1\]\]
@@ -0,0 +1,137 @@
+Strawberry ist ein **Musikplayer und -manager** für [[Linux]] (auch für Windows und macOS verfügbar), der sich auf **lokale Musiksammlungen** konzentriert. Er ist ein Fork von _Clementine_, das wiederum auf _Amarok_ basiert. Strawberry richtet sich vor allem an Nutzer, die eine **große Sammlung an Musikdateien (MP3, FLAC, OGG, etc.) lokal verwalten** möchten – im Gegensatz zu Playern, die stark auf Streaming setzen.
+
+---
+
+## 🎯 Zweck von Strawberry
+
+- **Abspielen von Musikdateien** in allen gängigen Formaten.
+    
+- **Bibliotheksverwaltung**: Organisieren großer Sammlungen anhand von Metadaten, Tags und Ordnerstrukturen.
+    
+- **Metadatenverwaltung**: Bearbeiten von Tags, Laden von Cover-Artworks, Abgleich mit Online-Datenbanken (z. B. MusicBrainz).
+    
+- **Wiedergabelisten**: Erstellen und Verwalten komplexer Playlists.
+    
+- **Audiowiedergabe in hoher Qualität** mit Unterstützung von Hi-Res-Formaten.
+    
+- **Externe Dienste**: Scrobbling zu Last.fm, Libre.fm oder ListenBrainz.
+    
+
+---
+
+## ⚙️ Funktionen
+
+- Unterstützung für FLAC, MP3, OGG, WAV, WMA, AAC u. v. m.
+    
+- Wiedergabe mit **GStreamer** (gute Audioqualität, viele Codecs).
+    
+- **Tag-Editor** für ID3, Vorbis- und FLAC-Tags.
+    
+- Automatisches Laden von **Album-Covern**.
+    
+- **EQ und ReplayGain**-Unterstützung.
+    
+- **Wiedergabelisten** im M3U-, XSPF- und PLS-Format.
+    
+- **Gerätesynchronisation**: Musik auf mobile Player kopieren.
+    
+- **Streaming-Radio** (einfache Integration, aber nicht Hauptfokus).
+    
+
+---
+
+## ✅ Vorteile
+
+- **Fokus auf lokale Musik** – ideal für Sammler, die ihre eigene Bibliothek pflegen.
+    
+- **Schnell und ressourcenschonend** im Vergleich zu schwergewichtigeren Lösungen wie Amarok.
+    
+- **Moderne Code-Basis**: aktiver Fork von Clementine mit Bugfixes und Verbesserungen.
+    
+- **Hohe Audioqualität** mit vielen Formaten und Hi-Res-Support.
+    
+- **Cross-Platform**: Linux, Windows, macOS.
+    
+- **Keine Zwangs-Cloud-Anbindung** wie bei Spotify & Co.
+    
+
+---
+
+## ❌ Nachteile
+
+- **Kein nativer Streaming-Fokus** (nur begrenzte Unterstützung für Online-Dienste, keine direkte Spotify-/Apple-Music-Integration).
+    
+- **Eher klassische Oberfläche** – wirkt funktional, aber nicht besonders modern/minimalistisch.
+    
+- **Weniger Community als bei großen Projekten** (z. B. Rhythmbox oder VLC).
+    
+- **Kein eigener mobiler Client** – Synchronisation nur über Dateiübertragung.
+    
+
+---
+
+## 💻 Installation
+
+### Unter Ubuntu/Debian
+
+```bash
+sudo apt install strawberry
+```
+
+Falls nicht im Standard-Repo (bei älteren Versionen):
+
+```bash
+sudo add-apt-repository ppa:jonaski/strawberry
+sudo apt update
+sudo apt install strawberry
+```
+
+### Unter Fedora
+
+```bash
+sudo dnf install strawberry
+```
+
+### Unter Arch Linux / Manjaro
+
+```bash
+sudo pacman -S strawberry
+```
+
+### Alternative: Flatpak (universell)
+
+```bash
+flatpak install flathub org.strawberrymusicplayer.strawberry
+```
+
+---
+
+## 🔧 Einrichtung
+
+1. **Musikordner hinzufügen**: Beim ersten Start fragt Strawberry nach Verzeichnissen, in denen Musik liegt.
+    
+2. **Bibliothek scannen**: Die Dateien werden eingelesen und nach Tags sortiert.
+    
+3. **Audioausgabe konfigurieren**: In den Einstellungen (z. B. ALSA, PulseAudio, PipeWire auswählen).
+    
+4. **Metadaten-Services aktivieren**: Verknüpfung mit MusicBrainz, Last.fm oder Libre.fm, wenn gewünscht.
+    
+5. **Wiedergabelisten und Cover laden**: Automatisches Suchen und Speichern aktivieren.
+    
+
+---
+
+## 📌 Was man beachten sollte
+
+- Strawberry ist für **Sammler und Audiophile** gedacht – wenn man hauptsächlich Spotify oder YouTube nutzt, ist es weniger passend.
+    
+- Gute Organisation der Musikordner und Tags erleichtert die Verwaltung erheblich.
+    
+- Bei **Hi-Res-Audio**: Prüfen, ob das Audiosystem (ALSA/PipeWire) korrekt konfiguriert ist.
+    
+- Für große Bibliotheken (>100.000 Tracks) sollte man auf genügend RAM und eine SSD achten, sonst wird die Suche langsam.
+    
+
+---
+
+👉 Soll ich dir eine Schritt-für-Schritt-Anleitung schreiben, wie du Strawberry nach der Installation optimal für eine große Musiksammlung einrichtest (inkl. Cover, Tags, Audio-Einstellungen)?
@@ -0,0 +1,119 @@
+Perfekt – dann ist eine Subsonic-kompatible Library genau das, was du suchst 👍
+
+Für [[Python]] gibt es z. B. [`py-sonic`](https://github.com/crustymonkey/py-sonic).  
+Die ist zwar nicht mehr super aktiv gepflegt, funktioniert aber mit [[IT-Know-How/Linux/Navidrome]] problemlos, weil Navidrome die [[IT-Know-How/Linux/Subsonic-API]] spricht.
+
+---
+
+## Installation
+
+```bash
+pip install py-sonic
+```
+
+---
+
+## Grund-Setup
+
+```python
+from pysonic.connection import Connection
+
+# Verbindung aufbauen
+conn = Connection(
+    host="http://localhost:4533",
+    username="meinuser",
+    password="meinpass",
+    api_version="1.16.1",
+    client_name="pyclient"
+)
+```
+
+---
+
+## Anwendungsfälle
+
+### 1. Playlist erstellen oder öffnen
+
+```python
+# Neue Playlist
+playlist = conn.create_playlist("Importierte M3U Playlist")
+
+# Alle Playlists abfragen
+all_playlists = conn.get_playlists()
+```
+
+### 2. Tracks suchen (z. B. per Filename, Titel, Artist)
+
+```python
+search = conn.search2(query="Songtitel", songCount=5)
+for song in search['song']:
+    print(song['id'], song['title'], song['artist'])
+```
+
+### 3. Track zur Playlist hinzufügen
+
+```python
+conn.update_playlist(
+    playlist_id=playlist['id'],
+    song_id=["12345", "67890"]  # mehrere IDs möglich
+)
+```
+
+### 4. Stern vergeben
+
+```python
+conn.star("12345")   # Song-ID
+```
+
+### 5. Bookmark setzen
+
+```python
+conn.create_bookmark("12345", position=60000, comment="Kapitel 1")
+```
+
+---
+
+## Workflow: M3U importieren
+
+Du kannst einfach durch deine `.m3u`-Datei iterieren, für jede Zeile versuchen, den Track im Navidrome zu finden, und dann Aktionen ausführen:
+
+```python
+def import_m3u_to_navidrome(m3u_path, playlist_name):
+    # Playlist anlegen
+    playlist = conn.create_playlist(playlist_name)
+    playlist_id = playlist['id']
+
+    with open(m3u_path, encoding="utf-8") as f:
+        for line in f:
+            if line.startswith("#") or not line.strip():
+                continue
+            filename = line.strip().split("/")[-1]  # nur Dateiname
+            
+            # Suche im Server
+            search = conn.search2(query=filename, songCount=1)
+            if 'song' in search and search['song']:
+                song = search['song'][0]
+                song_id = song['id']
+                
+                # Playlist hinzufügen
+                conn.update_playlist(playlist_id=playlist_id, song_id=[song_id])
+                
+                # Stern setzen
+                conn.star(song_id)
+                
+                # Bookmark bei 0 (Startpunkt)
+                conn.create_bookmark(song_id, position=0, comment="Importiert aus M3U")
+                
+                print(f"→ {filename} gefunden und verarbeitet.")
+            else:
+                print(f"⚠ {filename} nicht gefunden.")
+```
+
+---
+
+👉 Damit hättest du ziemlich genau deinen beschriebenen Workflow:  
+M3U → Tracks auflösen → Playlist + Sterne + Bookmarks automatisch setzen.
+
+---
+
+Soll ich dir ein **vollständiges Script** bauen, das direkt eine `.m3u` einliest, die passende Playlist erstellt und alle drei Aktionen (Playlist-Eintrag, Stern, Bookmark) in einem Durchlauf macht?
@@ -0,0 +1,230 @@
+# Timeshift Kommandozeilen-Nutzung
+
+## Überblick
+Timeshift ist ein Backup-Tool für Linux-Systeme, das System-Snapshots erstellt. Es kann sowohl über eine grafische Oberfläche als auch über die Kommandozeile verwendet werden.
+
+## Installation
+```bash
+# Ubuntu/Debian
+sudo apt update && sudo apt install timeshift
+
+# Arch Linux
+sudo pacman -S timeshift
+
+# Fedora/CentOS
+sudo dnf install timeshift
+```
+
+## Grundlegende Konfiguration
+
+### Initialisierung
+```bash
+# Timeshift einrichten (wählt automatisch RSYNC oder BTRFS)
+sudo timeshift --check
+
+# Konfiguration anzeigen
+sudo timeshift --list-config
+```
+
+### Backup-Typ festlegen
+```bash
+# RSYNC-Modus (Standard für ext4)
+sudo timeshift --rsync
+
+# BTRFS-Modus (für BTRFS-Dateisysteme)
+sudo timeshift --btrfs
+```
+
+## Snapshots erstellen
+
+### Manuellen Snapshot erstellen
+```bash
+# Einfacher Snapshot
+sudo timeshift --create
+
+# Snapshot mit Kommentar
+sudo timeshift --create --comments "Vor System-Update"
+
+# Snapshot mit spezifischem Namen
+sudo timeshift --create --comments "Pre-Kernel-Update-$(date +%Y%m%d)"
+```
+
+### Automatische Snapshots konfigurieren
+```bash
+# Tägliche Snapshots aktivieren
+sudo timeshift --snapshot-device /dev/sda1 --schedule-daily
+
+# Wöchentliche Snapshots
+sudo timeshift --schedule-weekly
+
+# Monatliche Snapshots
+sudo timeshift --schedule-monthly
+```
+
+## Snapshots verwalten
+
+### Snapshots auflisten
+```bash
+# Alle verfügbaren Snapshots anzeigen
+sudo timeshift --list
+
+# Detaillierte Liste
+sudo timeshift --list --verbose
+```
+
+### Snapshot-Informationen anzeigen
+```bash
+# Informationen zu einem spezifischen Snapshot
+sudo timeshift --list | grep "2024-01-15"
+```
+
+## System wiederherstellen
+
+### Komplette Systemwiederherstellung
+```bash
+# Neuesten Snapshot wiederherstellen
+sudo timeshift --restore
+
+# Spezifischen Snapshot wiederherstellen
+sudo timeshift --restore --snapshot "2024-01-15_18-30-45"
+
+# Wiederherstellung mit Bestätigung
+sudo timeshift --restore --snapshot "2024-01-15_18-30-45" --skip-grub
+```
+
+### Einzelne Dateien wiederherstellen
+```bash
+# Snapshot mounten (nur-lesen)
+sudo timeshift --restore --snapshot "2024-01-15_18-30-45" --clone
+
+# Dann Dateien manuell kopieren
+cp /timeshift/snapshots/2024-01-15_18-30-45/localhost/path/to/file /original/path/
+```
+
+## TTY-Sitzung (Notfall-Wiederherstellung)
+
+### Zugang zur TTY
+```bash
+# Wechsel zu TTY (Strg+Alt+F1 bis F6)
+# Oder über SSH wenn verfügbar
+```
+
+### Wiederherstellung in TTY
+```bash
+# 1. Als root anmelden
+sudo su -
+
+# 2. Snapshots auflisten
+timeshift --list
+
+# 3. System wiederherstellen
+timeshift --restore --snapshot "SNAPSHOT_NAME"
+
+# 4. System neustarten
+reboot
+```
+
+### Notfall-Boot von Live-USB
+```bash
+# 1. Live-USB booten
+# 2. Festplatte mounten
+sudo mount /dev/sda1 /mnt
+
+# 3. Timeshift auf Live-System installieren
+sudo apt update && sudo apt install timeshift
+
+# 4. Wiederherstellung auf gemountete Partition
+sudo timeshift --restore --target-device /dev/sda1
+```
+
+## Nützliche Optionen
+
+### Backup-Ausschlüsse konfigurieren
+```bash
+# Bestimmte Verzeichnisse ausschließen
+sudo timeshift --exclude /home/user/Downloads
+sudo timeshift --exclude /tmp
+sudo timeshift --exclude /var/cache
+```
+
+### Aufbewahrungsrichtlinien
+```bash
+# Maximale Anzahl Snapshots begrenzen
+sudo timeshift --max-snapshots 5
+
+# Alte Snapshots automatisch löschen
+sudo timeshift --delete-old
+```
+
+### Snapshot löschen
+```bash
+# Spezifischen Snapshot löschen
+sudo timeshift --delete --snapshot "2024-01-15_18-30-45"
+
+# Alle bis auf die letzten 3 löschen
+sudo timeshift --delete-old --max-snapshots 3
+```
+
+## Automatisierung mit Cron
+
+### Tägliche Backups einrichten
+```bash
+# Crontab bearbeiten
+sudo crontab -e
+
+# Tägliches Backup um 2:00 Uhr
+0 2 * * * /usr/bin/timeshift --create --comments "Daily-Auto-$(date +\%Y\%m\%d)" && /usr/bin/timeshift --delete-old --max-snapshots 7
+```
+
+## Monitoring und Logs
+
+### Status überprüfen
+```bash
+# Timeshift-Status
+sudo timeshift --check
+
+# Logs anzeigen
+sudo journalctl -u timeshift
+tail -f /var/log/timeshift.log
+```
+
+### Speicherplatz überwachen
+```bash
+# Snapshot-Größen anzeigen
+du -sh /timeshift/snapshots/*
+
+# Verfügbaren Speicher prüfen
+df -h /timeshift
+```
+
+## Troubleshooting
+
+### Häufige Probleme
+```bash
+# Berechtigungen reparieren
+sudo timeshift --check
+
+# Cache leeren
+sudo rm -rf /tmp/timeshift*
+
+# Snapshot-Index reparieren
+sudo timeshift --delete-old --scripted
+```
+
+### Recovery bei korrupten Snapshots
+```bash
+# Snapshot-Konsistenz prüfen
+sudo timeshift --list --check-snapshots
+
+# Defekte Snapshots entfernen
+sudo timeshift --delete --snapshot "CORRUPT_SNAPSHOT"
+```
+
+---
+
+**Wichtige Hinweise:**
+- Immer mit `sudo` ausführen
+- Vor wichtigen Systemänderungen Snapshots erstellen
+- Regelmäßig alte Snapshots löschen (Speicherplatz)
+- Bei BTRFS-Systemen BTRFS-Modus verwenden
+- Boot-Snapshots für kritische Updates erstellen
@@ -0,0 +1,22 @@
+Nutze ==`udisksctl`==
+### Installation
+Arch Linux
+```bash
+sudo pacman -S udisks2
+```
+### Geräte anzeigen
+```bash
+lsblsk
+```
+Wenn man möchte mit Option `-f`
+USB Stick müsste dann z.B. `sda1` oder `sdb1` sein.
+### Mount
+```bash
+udisksctl mount -b /dev/sdb1
+```
+Ausgabe zeigt an, wo gemountet wurde
+### Unmount
+```bash
+udisksctl unmount -b /dev/sdb1
+```
+
@@ -0,0 +1,65 @@
+# `fmt` – Textabsätze umbrechen
+
+`fmt` formatiert einfachen Text neu, indem es Zeilen innerhalb eines Absatzes zusammenführt und passend zur gewünschten Breite wieder umbrechen lässt. Es gehört bei GNU/Linux üblicherweise zu **GNU coreutils**.
+
+`fmt` ist für Fließtext gedacht, nicht für Programmcode oder Dokumente mit komplexer Formatierung.
+
+## Grundlegende Verwendung
+
+```bash
+fmt notizen.txt              # Ausgabe auf stdout, Standardbreite: 75 Zeichen
+fmt -w 80 notizen.txt        # auf höchstens 80 Zeichen umbrechen
+fmt -w 72                   # Text aus stdin formatieren
+```
+
+Datei bearbeiten und das Ergebnis in eine neue Datei schreiben:
+
+```bash
+fmt -w 80 notizen.txt > notizen-neu.txt
+```
+
+> Nicht direkt mit `fmt notizen.txt > notizen.txt` überschreiben: Die Shell leert die Zieldatei bereits, bevor `fmt` sie einliest.
+
+## Nützliche Optionen
+
+| Option | Bedeutung |
+|---|---|
+| `-w 80` | Maximale Zeilenbreite festlegen (Standard: 75) |
+| `-s` | Nur zu lange Zeilen umbrechen, kurze Zeilen nicht mit Nachbarzeilen zusammenführen |
+| `-u` | Einheitliche Abstände zwischen Wörtern und Sätzen erzeugen |
+| `-c` | Einrückung der ersten beiden Zeilen eines Absatzes als „crown margin“ behandeln |
+
+Beispiel für eine Mail oder einen Text, dessen vorhandene Zeilenumbrüche weitgehend erhalten bleiben sollen:
+
+```bash
+fmt -s -w 72 mail.txt
+```
+
+## Wie `fmt` Absätze erkennt
+
+- Ein Absatz besteht grundsätzlich aus zusammenhängenden Textzeilen.
+- Leerzeilen trennen Absätze und bleiben erhalten.
+- `fmt` verbindet kurze Zeilen innerhalb eines Absatzes und verteilt den Text neu.
+- Lange Wörter werden normalerweise nicht automatisch getrennt.
+
+## Typische Anwendungsfälle
+
+- Lange oder uneinheitlich umbrochene Textdateien lesbar machen.
+- Text aus einer Pipe auf eine feste Breite bringen:
+
+  ```bash
+  cat entwurf.txt | fmt -w 72
+  ```
+
+- Einen Absatz für ein Terminal, eine E-Mail oder einen Plain-Text-Editor umbrechen.
+
+## Grenzen und Stolperfallen
+
+- `fmt` versteht keine Markdown-Struktur: Listen, Tabellen, Überschriften und Codeblöcke können beim Umbruch beschädigt werden.
+- Für Quellcode ist es ungeeignet; dafür den passenden Formatter der jeweiligen Sprache verwenden.
+- Die Eingabedatei wird nicht verändert. `fmt` schreibt das Ergebnis standardmäßig auf die Standardausgabe.
+
+## Siehe auch
+
+- [[IT-Know-How/Linux/BASH Basics/find|find]] – Dateien suchen
+- [[IT-Know-How/Linux/Linux|Linux]]
@@ -0,0 +1,59 @@
+# `locate` – Dateien schnell anhand des Namens finden
+
+`locate` sucht Dateipfade in einer vorberechneten Datenbank. Dadurch ist die Suche meist sehr schnell – anders als `find` muss `locate` dafür nicht bei jeder Suche das Dateisystem durchlaufen.
+
+Auf aktuellen Linux-Systemen wird häufig **plocate** verwendet; andere Distributionen können eine andere `locate`-Implementierung bereitstellen. Verfügbare Optionen und der Aktualisierungsdienst können sich deshalb leicht unterscheiden.
+
+## Grundlegende Verwendung
+
+```bash
+locate ssh_config             # Pfade finden, deren Name zum Muster passt
+locate -i readme.md           # Groß-/Kleinschreibung ignorieren
+locate -b bashrc              # nur Dateinamen statt des gesamten Pfads durchsuchen
+```
+
+Anführungszeichen sind sinnvoll, wenn ein Suchmuster Leerzeichen oder Shell-Sonderzeichen enthält:
+
+```bash
+locate 'project notes'
+locate '*.service'
+```
+
+Viele Implementierungen behandeln ein Muster ohne Platzhalter wie eine Teilzeichenfolge. Details zum Musterformat stehen in `man locate`.
+
+## Suchdatenbank aktualisieren
+
+`locate` findet nur Einträge, die in seiner Datenbank stehen. Diese wird üblicherweise automatisch regelmäßig aktualisiert. Nach dem Erstellen oder Verschieben einer Datei kann die Datenbank daher zunächst veraltet sein.
+
+Manuell aktualisieren (Befehl und Berechtigungen hängen von der Installation ab):
+
+```bash
+sudo updatedb
+```
+
+Danach die Suche erneut ausführen. Auf manchen Systemen heißt das Aktualisierungswerkzeug anders oder wird über einen systemd-Timer verwaltet.
+
+## Wann `locate` sinnvoll ist
+
+- Wenn schnell ein wahrscheinlich vorhandener Pfad gesucht werden soll.
+- Wenn der genaue Ordner unbekannt ist, der Dateiname aber ungefähr bekannt ist.
+- Für eine erste Orientierung, bevor eine gezieltere Suche gestartet wird.
+
+## Grenzen und Stolperfallen
+
+- `locate` durchsucht **Dateinamen und Pfade**, nicht den Inhalt der Dateien.
+- Neue, verschobene oder gelöschte Dateien sind eventuell noch nicht in der Datenbank berücksichtigt.
+- Es eignet sich nicht gut für Bedingungen wie Dateigröße, Änderungsdatum oder Dateityp innerhalb eines bestimmten Verzeichnisses.
+- Ein gefundener Pfad garantiert nicht, dass du die Datei lesen oder öffnen darfst.
+- Die Zugänglichkeit der Datenbank und ausgeschlossene Verzeichnisse hängen von der jeweiligen Konfiguration ab.
+
+Für eine aktuelle Suche mit Filtern ist `find` besser geeignet, zum Beispiel:
+
+```bash
+find ~/Downloads -type f -iname '*bericht*.pdf'
+```
+
+## Siehe auch
+
+- [[IT-Know-How/Linux/BASH Basics/find|find]] – aktuelle Suche mit Filtern
+- [[IT-Know-How/Linux/Linux|Linux]]
@@ -0,0 +1,63 @@
+# GNU Stow – Dateien mit Symlinks verwalten
+
+**GNU Stow** verwaltet Verzeichnisbäume, indem es symbolische Links (Symlinks) zu deren Dateien und Unterverzeichnissen anlegt oder entfernt. Ein häufiger Anwendungsfall ist die zentrale Verwaltung von **Dotfiles** und Konfigurationsdateien.
+
+Stow führt dabei keine Installationsskripte aus und erzeugt keine Konfigurationsdateien aus Vorlagen: Seine Aufgabe ist die Verwaltung der Symlinks.
+
+## Grundidee: Paketstruktur spiegelt das Ziel
+
+Jede Unterstruktur unterhalb des Stow-Verzeichnisses ist ein „Paket“. Die Verzeichnisse und Dateien darin entsprechen den Pfaden, die im Zielverzeichnis entstehen sollen.
+
+```text
+~/dotfiles/
+├── zsh/
+│   ├── .zshrc
+│   └── .config/
+│       └── zsh/
+│           └── aliases
+└── git/
+    └── .gitconfig
+```
+
+Beim Stowen von `zsh` mit `~` als Ziel werden zum Beispiel `~/.zshrc` und `~/.config/zsh/aliases` verlinkt.
+
+## Pakete verknüpfen und entfernen
+
+Mit explizitem Stow- und Zielverzeichnis sind die Befehle unabhängig vom aktuellen Arbeitsverzeichnis verständlich:
+
+```bash
+# Erst gefahrlos prüfen, was Stow tun würde
+stow --simulate --verbose --dir="$HOME/dotfiles" --target="$HOME" zsh
+
+# Symlinks anlegen
+stow --dir="$HOME/dotfiles" --target="$HOME" zsh
+
+# Symlinks dieses Pakets wieder entfernen
+stow --delete --dir="$HOME/dotfiles" --target="$HOME" zsh
+
+# Paket entfernen und anschließend erneut verknüpfen
+stow --restow --dir="$HOME/dotfiles" --target="$HOME" zsh
+```
+
+Die Kurzformen für häufige Optionen sind `-n` (simulieren), `-v` (Ausgabe), `-d` (Stow-Verzeichnis), `-t` (Zielverzeichnis), `-D` (entfernen) und `-R` (erneut anwenden).
+
+## Typischer Dotfiles-Workflow
+
+1. Konfigurationen in einem versionierten Verzeichnis wie `~/dotfiles` organisieren.
+2. Pro Gruppe oder Programm ein Paketverzeichnis anlegen, zum Beispiel `zsh`, `git` oder `hypr`.
+3. Die Paketstruktur so aufbauen, dass sie die gewünschten Pfade relativ zum Home-Verzeichnis abbildet.
+4. Mit `stow -n -v ...` zunächst prüfen, welche Links entstehen würden.
+5. Das Paket mit Stow verknüpfen und die Links bei Bedarf mit `stow -D ...` wieder entfernen.
+
+## Konflikte und wichtige Hinweise
+
+- Stow überschreibt vorhandene, nicht von Stow verwaltete Dateien nicht einfach. Bei Konflikten bricht es ab und meldet das Problem.
+- Vorhandene Konfigurationen erst sichern oder bewusst in das Paket übernehmen, bevor Stow sie verwalten soll.
+- Die Option `--adopt` kann vorhandene Dateien aus dem Ziel in das Paket verschieben. Sie kann Dateien verändern; nur nach Prüfung und mit Backup verwenden.
+- Symlinks können auf dasselbe Dateisystem oder über verschiedene Datenträger hinweg zeigen, solange Ziel und Link erreichbar sind.
+- Stow ist kein Paketmanager und installiert keine Programme. Für hostabhängige Logik, Templates oder zusätzliche Aktionen sind Skripte oder andere Dotfile-Manager nötig.
+
+## Siehe auch
+
+- [[IT-Know-How/Linux/Hyprland/Stow mit Logik|Stow mit Logik]] – GNU Stow mit Skripten kombinieren
+- [[IT-Know-How/Linux/Linux|Linux]]